Skip to main content
`Ctrl`+`K`
scipy.fft.

# dct

scipy.fft.dct(x, type=2, n=None, axis=-1, norm=None, overwrite_x=False, workers=None, orthogonalize=None)

  Return the Discrete Cosine Transform of arbitrary type sequence x.

  Parameters:
    x array_like

      The input array.

    type{1, 2, 3, 4}, optional

      Type of the DCT (see Notes). Default type is 2.

    n int, 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]`.

    axis int, optional

      Axis along which the dct 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_x bool, optional

      If True, the contents of x can be destroyed; the default is False.

    workers int, 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.

    orthogonalize bool, optional

      Whether to use the orthogonalized DCT variant (see Notes). Defaults to `True` when `norm="ortho"` and `False` otherwise.

      Added in version 1.8.0.

  Returns:
    y ndarray of real

      The transformed input array.

  See also

  `idct`

    Inverse DCT

  Notes

  For a single dimension array `x`, `dct(x, norm='ortho')` is equal to MATLAB `dct(x)`.

  Warning

  For `type in {1, 2, 3}`, `norm="ortho"` breaks the direct correspondence with the direct Fourier transform. To recover it you must specify `orthogonalize=False`.

  For `norm="ortho"` both the `dct` and `idct` are scaled by the same overall factor in both directions. By default, the transform is also orthogonalized which for types 1, 2 and 3 means the transform definition is modified to give orthogonality of the DCT matrix (see below).

  For `norm="backward"`, there is no scaling on `dct` and the `idct` is scaled by `1/N` where `N` is the “logical” size of the DCT. For `norm="forward"` the `1/N` normalization is applied to the forward `dct` instead and the `idct` is unnormalized.

  There are, theoretically, 8 types of the DCT, only the first 4 types are implemented in SciPy.’The’ DCT generally refers to DCT type 2, and ‘the’ Inverse DCT generally refers to DCT type 3.

  Type I

  There are several definitions of the DCT-I; we use the following (for `norm="backward"`)

  \[y_k = x_0 + (-1)^k x_{N-1} + 2 \sum_{n=1}^{N-2} x_n \cos\left( \frac{\pi k n}{N-1} \right)\]

  If `orthogonalize=True`, `x[0]` and `x[N-1]` are multiplied by a scaling factor of \(\sqrt{2}\), and `y[0]` and `y[N-1]` are divided by \(\sqrt{2}\). When combined with `norm="ortho"`, this makes the corresponding matrix of coefficients orthonormal (`O @ O.T = np.eye(N)`).

  Note

  The DCT-I is only supported for input size > 1.

  Type II

  There are several definitions of the DCT-II; we use the following (for `norm="backward"`)

  \[y_k = 2 \sum_{n=0}^{N-1} x_n \cos\left(\frac{\pi k(2n+1)}{2N} \right)\]

  If `orthogonalize=True`, `y[0]` is divided by \(\sqrt{2}\) which, when combined with `norm="ortho"`, makes the corresponding matrix of coefficients orthonormal (`O @ O.T = np.eye(N)`).

  Type III

  There are several definitions, we use the following (for `norm="backward"`)

  \[y_k = x_0 + 2 \sum_{n=1}^{N-1} x_n \cos\left(\frac{\pi(2k+1)n}{2N}\right)\]

  If `orthogonalize=True`, `x[0]` terms are multiplied by \(\sqrt{2}\) which, when combined with `norm="ortho"`, makes the corresponding matrix of coefficients orthonormal (`O @ O.T = np.eye(N)`).

  The (unnormalized) DCT-III is the inverse of the (unnormalized) DCT-II, up to a factor 2N. The orthonormalized DCT-III is exactly the inverse of the orthonormalized DCT-II.

  Type IV

  There are several definitions of the DCT-IV; we use the following (for `norm="backward"`)

  \[y_k = 2 \sum_{n=0}^{N-1} x_n \cos\left(\frac{\pi(2k+1)(2n+1)}{4N} \right)\]

  `orthogonalize` has no effect here, as the DCT-IV matrix is already orthogonal up to a scale factor of `2N`.

  Array API Standard Support

  `dct` 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.

  References

  [1]

  ‘A Fast Cosine Transform in One and Two Dimensions’, by J. Makhoul, IEEE Transactions on acoustics, speech and signal processing vol. 28(1), pp. 27-34, DOI:10.1109/TASSP.1980.1163351 (1980).

  [2]

  Wikipedia, “Discrete cosine transform”, https://en.wikipedia.org/wiki/Discrete_cosine_transform

  Examples

  The Type 1 DCT is equivalent to the FFT (though faster) for real, even-symmetrical inputs. The output is also real and even-symmetrical. Half of the FFT input is used to generate half of the FFT output:

      >>> from scipy.fft import fft, dct
      >>> import numpy as np
      >>> fft(np.array([4., 3., 5., 10., 5., 3.])).real
      array([ 30.,  -8.,   6.,  -2.,   6.,  -8.])
      >>> dct(np.array([4., 3., 5., 10.]), 1)
      array([ 30.,  -8.,   6.,  -2.])