# dct#

ivy.dct(x, /, *, type=2, n=None, axis=-1, norm=None, out=None)[source]#

Compute the 1D Discrete Cosine Transformation of a given signal.

Parameters:
• x (`Union`[`Array`, `NativeArray`]) – The input signal.

• type (`Literal`[`1`, `2`, `3`, `4`], default: `2`) – The type of the dct. Must be 1, 2, 3 or 4.

• n (`Optional`[`int`], default: `None`) – The length of the transform. If n is less than the input signal length, then x is truncated, if n is larger then x is zero-padded.

• axis (`int`, default: `-1`) – The axis to compute the DCT along.

• norm (`Optional`[`Literal`[`'ortho'`]], default: `None`) – The type of normalization to be applied. Must be either None or “ortho”.

• out (`Optional`[`Union`[`Array`, `NativeArray`]], default: `None`) – optional output array, for writing the result to.

Return type:

`Union`[`Array`, `NativeArray`]

Returns:

• ret – Array containing the transformed input.

• Both the description and the type hints above assumes an array input for simplicity,

• but this function is nestable, and therefore also accepts `ivy.Container`

• instances in place of any of the arguments.

Examples

With `ivy.Array` input:

```>>> x = ivy.array([8, 16, 24, 32, 40, 48, 56, 64])
>>> y = ivy.dct(x, type=2, n=None, norm='ortho')
>>> print(y)
ivy.array([ 1.01823380e+02, -5.15385818e+01,  1.36371466e-06, -5.38763905e+00,
0.00000000e+00, -1.60722279e+00, -8.80319249e-08, -4.05617893e-01])
```
```>>> x = ivy.array([[[8, 16, 24, 32], [40, 48, 56, 64]],
...                [[1,  2,  3,  4], [ 5,  6,  7,  8]]])
>>> y = ivy.dct(x, type=1, n=None, axis=0, norm=None)
>>> print(y)
ivy.array([[[ 9., 18., 27., 36.],
[45., 54., 63., 72.]],
```
[[ 7., 14., 21., 28.],

[35., 42., 49., 56.]]])

```>>> x = ivy.array([[ 8.1, 16.2, 24.3, 32.4],
...                [40.5, 48.6, 56.7, 64.8]])
>>> y = ivy.zeros((2, 4), dtype=ivy.float32)
>>> ivy.dct(x, type=1, n=None, norm=None, out=y)
>>> print(y)
ivy.array([[ 1.21500000e+02, -3.24000015e+01,  1.90734863e-06,
-8.10000420e+00],
[ 3.15899994e+02, -3.24000053e+01,  3.81469727e-06,
-8.09999847e+00]])
```
```>>> x = ivy.array([8., 16., 24., 32., 40., 48., 56., 64.])
>>> ivy.dct(x, type=4, n=None, norm=None, out=x)
>>> print(x)
ivy.array([ 279.4135742 , -279.6779785 ,  128.3770599 , -114.8719864 ,
83.72109985,  -79.52869415,   69.79182434,  -68.72489166])
```

With one `ivy.Container` input:

```>>> x = ivy.Container(a=ivy.array([8, 16, 24, 32, 40, 48, 56, 64]),
...                   b=ivy.array([1,  2,  3,  4,  5,  6,  7,  8]))
>>> y = ivy.dct(x, type=3, n=None, norm='ortho')
>>> print(y)
{
a: ivy.array([79.49862671, -70.37691498, 30.00390816, -23.58938599,
13.92713165, -10.078475, 5.19664812, -1.95411837]),
b: ivy.array([9.93732834, -8.79711437, 3.75048852, -2.94867325, 1.74089146,
-1.25980937, 0.64958102, -0.2442648])
}
```

With multiple `ivy.Container` inputs:

```>>> x = ivy.Container(a=ivy.array([8, 16, 24, 32, 40, 48, 56, 64]),
...                   b=ivy.array([1,  2,  3,  4,  5,  6,  7,  8]))
>>> container_n = ivy.Container(a=9, b=4)
>>> container_type = ivy.Container(a=2, b=1)
>>> container_norm = ivy.Container(a="ortho", b=None)
>>> y = ivy.dct(x, type=container_type, n=container_n, norm=container_norm)
>>> print(y)
{
a: ivy.array([96., -28.1580677, -31.89422607, 22.86190414,
-26.00041008, 19.75149155, -16.97056389, 10.87819386,
-5.89381361]),
b: ivy.array([1.50000000e+01, -4.00000000e+00, -2.22044605e-16,
-1.00000000e+00])
}
```
Array.dct(self, /, *, type=2, n=None, axis=-1, norm=None, out=None)[source]#

ivy.Array instance method variant of ivy.dct. This method simply wraps the function, and so the docstring for ivy.dct also applies to this method with minimal changes.

Parameters:
• self (`Array`) – The input signal.

• type (`Literal`[`1`, `2`, `3`, `4`], default: `2`) – The type of the dct. Must be 1, 2, 3 or 4.

• n (`Optional`[`int`], default: `None`) – The length of the transform. If n is less than the input signal length, then x is truncated, if n is larger than x is zero-padded.

• norm (`Optional`[`Literal`[`'ortho'`]], default: `None`) – The type of normalization to be applied. Must be either None or “ortho”.

• out (`Optional`[`Array`], default: `None`) – optional output array, for writing the result to.

Return type:

`Array`

Returns:

ret – Array containing the transformed input.

Examples

```>>> x = ivy.array([8., 16., 24., 32., 40., 48., 56., 64.])
>>> x.dct(type=2, norm="ortho")
ivy.array([ 102.,  -51.5,   0.,  -5.39,   0.,  -1.61,   0., -0.406])
```
Container.dct(self, /, *, type=2, n=None, axis=-1, norm=None, out=None)[source]#

ivy.Container instance method variant of ivy.dct. This method simply wraps the function, and so the docstring for ivy.dct also applies to this method with minimal changes.

Parameters:
• self (`Container`) – Container with the input signals.

• type (`Union`[`Literal`[`1`, `2`, `3`, `4`], `Container`], default: `2`) – The type of the dct. Must be 1, 2, 3 or 4.

• n (`Optional`[`Union`[`int`, `Container`]], default: `None`) – The length of the transform. If n is less than the input signal length, then x is truncated, if n is larger then x is zero-padded.

• norm (`Optional`[`Union`[`Literal`[`'ortho'`], `Container`]], default: `None`) – The type of normalization to be applied. Must be either None or “ortho”.

• out (`Optional`[`Container`], default: `None`) – optional output container, for writing the result to.

Return type:

`Container`

Returns:

ret – The transformed input.

Examples

```>>> x = ivy.Container(a=ivy.array([8, 16, 24, 32, 40, 48, 56, 64]),
...                   b=ivy.array([1,  2,  3,  4,  5,  6,  7,  8]))
>>> x.dct(type=2, norm='ortho')
{
a: ivy.array([102., -51.5, 0., -5.39, 0., -1.61, 0.,
-0.406]),
b: ivy.array([12.7, -6.44, 0., -0.673, 0., -0.201, 0.,
-0.0507])
}
```