scipy.fft.

idst#

scipy.fft.idst(x, type=2, n=None, axis=-1, norm=None, overwrite_x=False, workers=None, orthogonalize=None)[source]#

Return the Inverse Discrete Sine Transform of an arbitrary type sequence.

Parameters:

xarray_like: The input array.
type{1, 2, 3, 4}, optional: Type of the DST (see Notes). Default type is 2.
nint, optional: Length of the transform. If n < x.shape[axis], x is truncated. If n > x.shape[axis], x is zero-padded. The default results in n = x.shape[axis].
axisint, optional: Axis along which the idst is computed; the default is over the last axis (i.e., axis=-1).
norm{“backward”, “ortho”, “forward”}, optional: Normalization mode (see Notes). Default is “backward”.
overwrite_xbool, optional: If True, the contents of x can be destroyed; the default is False.
workersint, optional: Maximum number of workers to use for parallel computation. If negative, the value wraps around from os.cpu_count(). See fft for more details.
orthogonalizebool, optional: Whether to use the orthogonalized IDST variant (see Notes). Defaults to True when norm="ortho" and False otherwise.

Added in version 1.8.0.

Returns:

idstndarray of real: The transformed input array.

See also

dst: Forward DST
irfft: Inverse FFT for real input

Notes

Warning

For type in {2, 3}, norm="ortho" breaks the direct correspondence with the inverse direct Fourier transform.

For norm="ortho" both the dst and idst are scaled by the same overall factor in both directions. By default, the transform is also orthogonalized which for types 2 and 3 means the transform definition is modified to give orthogonality of the DST matrix (see dst for the full definitions).

‘The’ IDST is the IDST-II, which is the same as the normalized DST-III.

The IDST is equivalent to a normal DST except for the normalization and type. DST type 1 and 4 are their own inverse and DSTs 2 and 3 are each other’s inverses. For an example that demonstrates the relation between the DST and ISDT, consult the DST and IDST section of the SciPy User Guide.

Array API Standard Support

idst has experimental support for Python Array API Standard compatible backends in addition to NumPy. Please consider testing these features by setting an environment variable SCIPY_ARRAY_API=1 and providing CuPy, PyTorch, JAX, or Dask arrays as array arguments. The following combinations of backend and device (or other capability) are supported.

Library	CPU	GPU
NumPy	✅	n/a
CuPy	n/a	⛔
PyTorch	✅	⛔
JAX	✅	⛔
Dask	⚠️ computes graph	n/a

See Support for the array API standard for more information.

Examples

The following example calculates the signal from a spectrum X where only the first bin has a non-zero value. The signal for all four DST types is plotted:

>>> import numpy as np
>>> import matplotlib.pyplot as plt
>>> from scipy.fft import idst
...
>>> N = 15
>>> X = np.array([0, N])  # the last `N-2` bin zero-valued bins are not needed
...
>>> _, ax = plt.subplots()
>>> ax.set(title=f"Inverse of one component DST ({N} samples)",
...        xlim=(0, N), xlabel="k", ylabel="x[k]")
>>> for t_ in range(1, 5):
...     x = idst(X, type=t_, n=N)  # parameter `n` pads `X` to length `N`.
...     ax.plot(x, '.-', alpha=0.5, label=f"Type {t_}")
>>> ax.grid(True)
>>> ax.legend()
>>> plt.show()

../../_images/scipy-fft-idst-1_00_00.png

The resulting signals are sines with their period and their phase determined by the used DST type. The following table shows those, with N being the number of signal samples and n is the index of the non-zero bin (here: N, n = 15, 1):

Type	period in samples	phase shift in samples
1	\(2 (N+1) / (n+1) = 16\)	\(-1\)
2	\(2 N / (n+1) = 15\)	\(-1/2\)
3	\(2 N / (n+1/2) = 20\)	\(-1\)
4	\(2 N / (n+1/2) = 20\)	\(-1/2\)