`iw : d Z ddlZddlZddlZddlZddlmZ ddlmZ ddlm Z ddl
m Z g dZ d Z
d#d
Zd$d Z ej d
dd Zd%dZ d&dZd Z ej d
dd Zd Z d'dZ e j e j j d(d Z e j e j j d(d Z e j e j j d(d Z e j e j j d(d Z d%d Z d Z e j e j j d)d Z e j e j j! d)d Z! e j e j j" d)d! Z" e j e j j# d)d" Z#dS )*u Real-to-real transforms
cuFFT does not implement real-to-real FFTs. This module implements forward
and inverse DCT-II and DCT-III transforms using FFTs.
A length N DCT can be computed using a length N FFT and some additional
multiplications and reordering of entries.
The approach taken here is based on the work in [1]_, [2]_ and is discussed in
the freely-available online resources [3]_, [4]_.
The implementation here follows that approach with only minor modification to
match the normalization conventions in SciPy.
The modifications to turn a type II or III DCT to a DST were implemented as
described in [5]_.
.. [1] J. Makhoul, "A fast cosine transform in one and two dimensions," in
IEEE Transactions on Acoustics, Speech, and Signal Processing, vol. 28,
no. 1, pp. 27-34, February 1980.
.. [2] M.J. Narasimha and A.M. Peterson, “On the computation of the discrete
cosine transform,” IEEE Trans. Commun., vol. 26, no. 6, pp. 934–936, 1978.
.. [3] http://fourier.eng.hmc.edu/e161/lectures/dct/node2.html
.. [4] https://dsp.stackexchange.com/questions/2807/fast-cosine-transform-via-fft
.. [5] X. Shao, S. G. Johnson. Type-II/III DCT/DST algorithms with reduced
number of arithmetic operations, Signal Processing, Volume 88, Issue 6,
pp. 1553-1564, 2008.
N)_core) _cook_shape)_fft) AxisError)dctdctndstdstnidctidctnidstidstnc | j j dv r
t j }n$t j | j t j }| |d S )NbuiF)copy)dtypekindcupyfloat64
promote_typesfloat32astype)x float_dtypes s/home/jaya/work/projects/VOICE-AGENT/VIET/agent-env/lib/python3.11/site-packages/cupyx/scipy/fft/_realtransforms.py_promote_dtyper / sF w|u l ($,?? 88Ke8 , ,, c |dk rdS |dk rdnd}d| |z z }|dk rd|z }n-|dk rdt j | z }nt d |S ) a] Normalization factors for DCT/DST I-IV.
Parameters
----------
n : int
Data size.
inorm : {'none', 'sqrt', 'full'}
When `inorm` is 'none', the scaling factor is 1.0 (unnormalized). When
`inorm` is 1, scaling by ``1/sqrt(d)`` as needed for an orthogonal
transform is used. When `inorm` is 2, normalization by ``1/d`` is
applied. The value of ``d`` depends on both `n` and the `dct_type`.
dct_type : {1, 2, 3, 4}
Which type of DCT or DST is being normalized?.
Returns
-------
fct : float
The normalization factor.
none r r fullsqrtz)expected inorm = "none", "sqrt" or "full")mathr$
ValueError)ninormdct_typedeltadfcts r _get_dct_norm_factorr- 8 su (
qa--BBQE QYA !e & $)A,, DEEE Jr Fc t d g| j z }t ddd ||< t | }t d g| j z }|dz r$t ddd ||< t | }n#t ddd ||< t | }|r&t j | | | | f| } n$t j | | | | f| } | S );Reorder entries to allow computation of DCT/DST-II via FFT.Nr r )axis)slicendimtupler concatenate)r r' r1 r sl_evensl_odds r _reshuffle_dct2r8 Y s T{{maf$G!T1%%GDMGnnGDkk]QV
#F1u Rr**t v T4,,t v
A aj1V9* 5D A A A aj!F) 44 @ @ @ Hr z R xr, int32 N, R norm_factorzC yzS
C j(0., -1.);
y = (R)2.0 * norm_factor * exp(j * (R)(i * M_PI / (2 * N)));) in_params
out_params operationc ||}t j |f| j }t |j ||| | j dk r|S dg| j z }|||< t
| }| | S )z@Twiddle & scaling factors for computation of DCT/DST-II via FFT.Nr r! )r emptyr _mult_factor_dct2realr3 r4 reshape)r r' r1 norm_factor
n_truncatetmp tmp_shapes r _exp_factor_dct2rF u s
*j]!'
2
2
2Cch;444v{{
af I IdOi I ;;y ! !!r r" Tc P || j k s || j k rt d |dk r
|| j z
}||dk rt d| d t | |f|fd } | j | }t | | j | || } |dk rd }n|d
k r|rd nd }n|rd nd }t
||d
}t j | ||d } t | ||| } | | z } t j | } |dk r\t d g| j z }
t d |
|< | t |
xx t j d
dz z cc< |rAt d g| j z } t ddd | |< | t | } | S )a Forward DCT/DST-II (or inverse DCT/DST-III) along a single axis
Parameters
----------
x : cupy.ndarray
The data to transform.
n : int
The size of the transform. If None, ``x.shape[axis]`` is used.
axis : int
Axis along which the transform is applied.
forward : bool
Set true to indicate that this is a forward DCT-II as opposed to an
inverse DCT-III (The difference between the two is only in the
normalization factor).
norm : {None, 'ortho', 'forward', 'backward'}
The normalization convention to use.
dst : bool
If True, a discrete sine transform is computed rather than the discrete
cosine transform.
overwrite_x : bool
Indicates that it is okay to overwrite x. In practice, the current
implementation never performs the transform in-place.
Returns
-------
y: cupy.ndarray
The transformed array.
axis out of ranger Nr! invalid number of data points ( ) specifiedR2Rorthor$ forwardr# r r r( r) Tr' r1 overwrite_x ?r" )r3 r r& r shaper8 r- r fftrF r r@ r2 r4 r% r$ ) r r' r1 rM normr rP r( rB rD sl0slrevs r _dct_or_dst_type2rW s > qvg~~ +,,, axx }Q >"AgJ Dkk]QV
#FD!$$F4L
6]]F"fqj"--GDM
&uW~~&&& eGnn%& Hr zV
C j(0., 1.);
y = (R)(2 * N * norm_factor) * exp(j * (R)(i * M_PI / (2 * N)));c t j |f| }t |j ||| | j dk r|S dg| j z }|||< t | }| | S )zATwiddle & scaling factors for computation of DCT/DST-III via FFT.r= r! )r r> _mult_factor_dct3r@ r3 r4 rA )r r' r1 r rB rD rE s r _exp_factor_dct3r` ss
*aT
'
'
'Cch;444v{{
af IIdOi I ;;y ! !!r c || j k s || j k rt d |dk r
|| j z
}||dk rt d| d t | |f|fd } | j | }|dk rd t j d
z }d }n3|d k r d }|rd
nd}n$|dk s| d }|rdnd
}nt d| d t ||d } t j | t j
}
t d g| j z } t d | |< |rt d g| j z } t ddd | |< | t | } |dk rt j | j
t j }
| j
|
k r| |
} n|s| } | t | xx t j d
z cc< d }t# | |||
| }| |z } | t | xx |z cc< t% j | ||d } t j | } t+ | ||| S )a Forward DCT/DST-III (or inverse DCT/DST-II) along a single axis.
Parameters
----------
x : cupy.ndarray
The data to transform.
n : int
The size of the transform. If None, ``x.shape[axis]`` is used.
axis : int
Axis along which the transform is applied.
forward : bool
Set true to indicate that this is a forward DCT-II as opposed to an
inverse DCT-III (The difference between the two is only in the
normalization factor).
norm : {None, 'ortho', 'forward', 'backward'}
The normalization convention to use.
dst : bool
If True, a discrete sine transform is computed rather than the discrete
cosine transform.
overwrite_x : bool
Indicates that it is okay to overwrite x. In practice, the current
implementation never performs the transform in-place.
Returns
-------
y: cupy.ndarray
The transformed array.
rH r Nr! rI rJ rK rL rQ r r$ rM r# r backwardzInvalid norm value "z-", should be "backward", "ortho" or "forward" rN r" TrO )r3 r r& r rR r% r$ r- r r complex64r2 r4 r r r r r` r ifftr@ r] )r r' r1 rT rM r rP sl0_scaler( rB r rU rV r rD s r _dct_or_dst_type3rg s @ qvg~~ +,,, axx }Q 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.
Returns
-------
y : cupy.ndarray of real
The transformed input array.
See Also
--------
:func:`scipy.fft.dct`
Notes
-----
For a single dimension array ``x``, ``dct(x, norm='ortho')`` is equal
to MATLAB ``dct(x)``.
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.
CuPy currently only supports DCT types 2 and 3. 'The' DCT generally
refers to DCT type 2, and 'the' Inverse DCT generally refers to DCT
type 3 [1]_. See the :func:`scipy.fft.dct` documentation for a full
description of each type.
References
----------
.. [1] Wikipedia, "Discrete cosine transform",
https://en.wikipedia.org/wiki/Discrete_cosine_transform
c ?r TFr' r1 rT rM r rc r! .Only DCT-II and DCT-III have been implemented.invalid DCT type)
r r r r@ imagr rW rg NotImplementedErrorr& r typer' r1 rT rP outs r r r U s t w|s!&$4{;;BQVT1dD+FFFF
qA qyy
D$E
D$E
! <
+,,,r c
d | j j dk r:t | j ||||| }|dt | j ||||| z z }|S t | } |dk rt
| |||dd S |dk rt | |||dd S |dv rt d t d )
a Return the Discrete Sine Transform of an array, x.
Parameters
----------
x : cupy.ndarray
The input array.
type : {1, 2, 3, 4}, optional
Type of the DST (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 dst 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.
Returns
-------
dst : cupy.ndarray of real
The transformed input array.
See Also
--------
:func:`scipy.fft.dst`
Notes
-----
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 below).
For ``norm="backward"``, there is no scaling on the `dst` and the `idst` is
scaled by ``1/N`` where ``N`` is the "logical" size of the DST.
See the :func:`scipy.fft.dst` documentation for a full description of each
type. CuPy currently only supports DST types 2 and 3.
ri rj r Trk rc rl .Only DST-II and DST-III have been implemented.invalid DST type)
r r r r@ rp r rW rg rq r& rr s r r r s Z w|s!&$4{;;BQVT1dD+FFFF
qA qyy
D$D
D$D
! <
+,,,r c
` | j j dk r:t | j ||||| }|dt | j ||||| z z }|S t | } |dk rt
| |||d S |dk rt | |||d S |dv rt d t d )
a Return the Inverse Discrete Cosine Transform of an array, x.
Parameters
----------
x : cupy.ndarray
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 idct 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.
Returns
-------
idct : cupy.ndarray of real
The transformed input array.
See Also
--------
:func:`scipy.fft.idct`
Notes
-----
For a single dimension array `x`, ``idct(x, norm='ortho')`` is equal to
MATLAB ``idct(x)``.
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 IDCT matrix (see `dct` for the full
definitions).
'The' IDCT is the IDCT-II, which is the same as the normalized DCT-III
[1]_. See the :func:`scipy.fft.dct` documentation for a full description of
each type. CuPy currently only supports DCT types 2 and 3.
References
----------
.. [1] Wikipedia, "Discrete sine transform",
https://en.wikipedia.org/wiki/Discrete_sine_transform
ri rj r F)r' r1 rT rM rc rl rn ro )
r r r r@ rp r rg rW rq r& rr s r r r s f w|s164D$ <<BafdAtT;GGGG
qA qyy aduMMMM
aduMMMM
! <
+,,,r c
d | j j dk r:t | j ||||| }|dt | j ||||| z z }|S t | } |dk rt
| |||dd S |dk rt | |||dd S |dv rt d t d
) a> Return the Inverse Discrete Sine Transform of an array, x.
Parameters
----------
x : cupy.ndarray
The input array.
type : {1, 2, 3, 4}, optional
Type of the DST (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 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_x : bool, optional
If True, the contents of `x` can be destroyed; the default is False.
Returns
-------
idst : cupy.ndarray of real
The transformed input array.
See Also
--------
:func:`scipy.fft.idst`
Notes
-----
For full details of the DST types and normalization modes, as well as
references, see :func:`scipy.fft.dst`.
ri rj r FTrk rc rl rv rw )
r r r
r@ rp r rg rW rq r& rr s r r
r
5 s H w|s164D$ <<BafdAtT;GGGG
qA qyy
D%T
D%T
! <
+,,,r c t | t j r| f} d | D } n)# t $ r }|pd}t | d |d}~ww xY w| S )z-Convert ``x`` to an iterable sequence of int.c 6 g | ]}t j | S )operatorindex).0as r
z$_iterable_of_int..y s" * * *1X^A
* * *r valuez) must be a scalar or iterable of integersN)
isinstancenumbersNumber TypeErrorr& )r namees r _iterable_of_intr s s !W^$$
D * * * * * w > > >
Hs ,
AA
Ac B |du }|du }|st |d } fd|D }t fd|D rt d t t | t | k rt d |st |d }t | }|r"t | |k rt d |rD| j k rt d t
j t | z
j } fd
t || D }n9|r)t j }t
j }n fd |D }t d |D rt d
| d ||fS )z3Handles shape and axes arguments for nd transforms.Naxesc 4 g | ]}|d k r
|j z n|S )r r3 r r r s r r z+_init_nd_shape_and_axes.. s+ 999qa!eeAF
999r c 3 : K | ]}|j k p|d k V dS )r Nr r s r z*_init_nd_shape_and_axes.. s2 22qAF{#a!e222222r z$axes exceeds dimensionality of inputzall axes must be uniquerR zBwhen given, axes and shape arguments have to be of the same lengthz)shape requires more axes than are presentc @ g | ]\ }}|d k r
j | n|S )r" rR )r sr r s r r z+_init_nd_shape_and_axes.. s/ KKK$!QqBwwAKKKr c * g | ]}j | S r| r r s r r z+_init_nd_shape_and_axes.. s ******r c 3 " K | ]
}|d k V dS )r! Nr| )r r s r r z*_init_nd_shape_and_axes.. s&
Q1q5
r rI rJ )
r anyr& lensetr3 rangeziplistrR )r rR r noshapenoaxesnshapes ` r _init_nd_shape_and_axesr s tmG
T\F 8 f--9999D999 2222T222 2 2 E CDD D s4yy>>SYY & & 677 7 + 00U CII'' 1
6 !LMMM#e**,af55DKKKK#eT:J:JKKK +QW
QV}}****T***
%
@e @ @ @
$;r c
` | j j dk r:t | j ||||| }|dt | j ||||| z z }|S t | || \ }}t
| } t | dk r| S t || D ]\ }} t | ||| || } | S )a Compute a multidimensional Discrete Cosine Transform.
Parameters
----------
x : cupy.ndarray
The input array.
type : {1, 2, 3, 4}, optional
Type of the DCT (see Notes). Default type is 2.
s : int or array_like of ints or None, optional
The shape of the result. If both `s` and `axes` (see below) are None,
`s` is ``x.shape``; if `s` is None but `axes` is not None, then `s` is
``numpy.take(x.shape, axes, axis=0)``.
If ``s[i] > x.shape[i]``, the ith dimension is padded with zeros.
If ``s[i] < x.shape[i]``, the ith dimension is truncated to length
``s[i]``.
If any element of `s` is -1, the size of the corresponding dimension of
`x` is used.
axes : int or array_like of ints or None, optional
Axes over which the DCT is computed. If not given, the last ``len(s)``
axes are used, or all axes if `s` is also not specified.
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.
Returns
-------
y : cupy.ndarray of real
The transformed input array.
See Also
--------
:func:`scipy.fft.dctn`
Notes
-----
For full details of the DCT types and normalization modes, as well as
references, see `dct`.
ri rj r rs r' r1 rT rP )
r r r r@ rp r r r r r
r rs r r rT rP rt rR r' r1 s
r r r R w|s164D$ <<BafdAtT;GGGG
)!Q55KE4qA
4yyA~~ud##
4
DADt
Hr c
` | j j dk r:t | j ||||| }|dt | j ||||| z z }|S t | || \ }}t
| } t | dk r| S t || D ]\ }} t | ||| || } | S )a Compute a multidimensional Discrete Cosine Transform.
Parameters
----------
x : cupy.ndarray
The input array.
type : {1, 2, 3, 4}, optional
Type of the DCT (see Notes). Default type is 2.
s : int or array_like of ints or None, optional
The shape of the result. If both `s` and `axes` (see below) are None,
`s` is ``x.shape``; if `s` is None but `axes` is not None, then `s` is
``numpy.take(x.shape, axes, axis=0)``.
If ``s[i] > x.shape[i]``, the ith dimension is padded with zeros.
If ``s[i] < x.shape[i]``, the ith dimension is truncated to length
``s[i]``.
If any element of `s` is -1, the size of the corresponding dimension of
`x` is used.
axes : int or array_like of ints or None, optional
Axes over which the IDCT is computed. If not given, the last ``len(s)``
axes are used, or all axes if `s` is also not specified.
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.
Returns
-------
y : cupy.ndarray of real
The transformed input array.
See Also
--------
:func:`scipy.fft.idctn`
Notes
-----
For full details of the IDCT types and normalization modes, as well as
references, see :func:`scipy.fft.idct`.
ri rj r r )
r r r r@ rp r r r r r r s
r r r R w|sAFD!T4==BqvtQdKHHHH
)!Q55KE4qA
4yyA~~ud##
4
DADt
Hr c
` | j j dk r:t | j ||||| }|dt | j ||||| z z }|S t | || \ }}t
| } t | dk r| S t || D ]\ }} t | ||| || } | S )a Compute a multidimensional Discrete Sine Transform.
Parameters
----------
x : cupy.ndarray
The input array.
type : {1, 2, 3, 4}, optional
Type of the DST (see Notes). Default type is 2.
s : int or array_like of ints or None, optional
The shape of the result. If both `s` and `axes` (see below) are None,
`s` is ``x.shape``; if `s` is None but `axes` is not None, then `s` is
``numpy.take(x.shape, axes, axis=0)``.
If ``s[i] > x.shape[i]``, the ith dimension is padded with zeros.
If ``s[i] < x.shape[i]``, the ith dimension is truncated to length
``s[i]``.
If any element of `s` is -1, the size of the corresponding dimension of
`x` is used.
axes : int or array_like of ints or None, optional
Axes over which the DST is computed. If not given, the last ``len(s)``
axes are used, or all axes if `s` is also not specified.
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.
Returns
-------
y : cupy.ndarray of real
The transformed input array.
See Also
--------
:func:`scipy.fft.dstn`
Notes
-----
For full details of the DST types and normalization modes, as well as
references, see :func:`scipy.fft.dst`.
ri rj r r )
r r r
r@ rp r r r r r r s
r r
r
% r r c
` | j j dk r:t | j ||||| }|dt | j ||||| z z }|S t | || \ }}t
| } t | dk r| S t || D ]\ }} t | ||| || } | S )a Compute a multidimensional Discrete Sine Transform.
Parameters
----------
x : cupy.ndarray
The input array.
type : {1, 2, 3, 4}, optional
Type of the DST (see Notes). Default type is 2.
s : int or array_like of ints or None, optional
The shape of the result. If both `s` and `axes` (see below) are None,
`s` is ``x.shape``; if `s` is None but `axes` is not None, then `s` is
``numpy.take(x.shape, axes, axis=0)``.
If ``s[i] > x.shape[i]``, the ith dimension is padded with zeros.
If ``s[i] < x.shape[i]``, the ith dimension is truncated to length
``s[i]``.
If any element of `s` is -1, the size of the corresponding dimension of
`x` is used.
axes : int or array_like of ints or None, optional
Axes over which the IDST is computed. If not given, the last ``len(s)``
axes are used, or all axes if `s` is also not specified.
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.
Returns
-------
y : cupy.ndarray of real
The transformed input array.
See Also
--------
:func:`scipy.fft.idstn`
Notes
-----
For full details of the IDST types and normalization modes, as well as
references, see :func:`scipy.fft.idst`.
ri rj r r )
r r r r@ rp r r r r r
r s
r r r a r r )r )F)N)Nr" TNFF)Nr" NTFF)r Nr" NF)r NNNF)$__doc__r% r r} r r
cupy.fft._fftr cupyx.scipy.fftr cupy.exceptionsr __all__r r- r8 ElementwiseKernelr? rF rW r] r_ r` rg _implements
_scipy_fftr r r r
r r r r r
r r| r r r s\ B % % % % % % % % % % % %
J
J
J- - - B
& ,E+,D " " " " IND
D
D
D
N
6 ,E+,H
"
"
" INV, V, V, V,r $/%&&N- N- N- '&N-b $/%&&A- A- A- '&A-H $/&''E- E- E- ('E-P $/&'':- :- :- (':-z
' ' 'T $/&''8
8
8
('8
v $/'((8
8
8
)(8
v $/&''8
8
8
('8
v $/'((8
8
8
)(8
8
8
r