o X۷i,w@sdZddlmZddlZddlZddlZddlZddlmZddlm Z ddl m Z ddl m Z gdZd d Zd6d d Zd7ddZejddddZd8ddZ d9ddZddZejddddZddZ d:d d!Ze e jjd;d"d#Ze e jjd;d$d%Ze e jjd;d&d'Ze e jjd;d(d)Zd8d*d+Z d,d-Z!e e jj"dr@sl0slrevrrr_dct_or_dst_type2s<       rRc Cst|}|dd}tdg|j}tddd||<t|}tdg|j}td|||<|t|||<tdg|j}tddd||<t|}td|dd||<|ra|t| ||<|S|t|||<|S)r,rrNrr )r empty_liker/r0r1) yr%r.r rn_halfr3sl_halfr4rrr_reshuffle_dct3s"  rWzV C j(0., 1.); y = (R)(2 * N * norm_factor) * exp(j * (R)(i * M_PI / (2 * N)));cCsTtj|f|d}t|j||||jdkr|Sdg|j}|||<t|}||S)zATwiddle & scaling factors for computation of DCT/DST-III via FFT.r9r)rr:_mult_factor_dct3r<r0r1r=)rr%r.rr>r@rArrr_exp_factor_dct3s   rYcCs||j ks ||jkrtd|dkr||j7}|dur(|dkr(td|dt||f|fd}|j|}|dkrDd td }d }n&|d krQd }|rNd nd}n|dksY|durbd }|r_dnd }ntd|dt||dd} t |tj } t dg|j} t d| |<|rt dg|j} t ddd| |<|t | }|dkrt |j tj} |j | kr|| }n|s|}|t | td 9<d }t|||| | }||}|t | |9<tj|||dd}t|}t||||S)aForward 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. rCrNrrDrErFrGrLrr"rHr!rbackwardzInvalid norm value "z-", should be "backward", "ortho" or "forward"rIr TrJ)r0rr$rrMr#r"r+rr complex64r/r1rrrrrYrifftr<rW)rr%r.rOrHr rK sl0_scaler&r>rrPrQrr@rrr_dct_or_dst_type3sT         r_c C|jjdkr t|j|||||}|dt|j|||||}|St|}|dkr2t||||dddS|dkr@t||||dddS|dvrHtd t d ) aReturn the 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. Currently CuPy only supports types 2 and 3. 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. 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?rTFr%r.rOrHr r[r.Only DCT-II and DCT-III have been implemented.invalid DCT type) rrrr<imagrrRr_NotImplementedErrorr$rtyper%r.rOrKoutrrrrWs$ :  rc Cs|jjdkr t|j|||||}|dt|j|||||}|St|}|dkr2t||||dddS|dkr@t||||dddS|dvrHtdt d ) aReturn 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. rarbrTrcr[rd.Only DST-II and DST-III have been implemented.invalid DST type) rrr r<rhrrRr_rir$rjrrrr s$ -  r c Cs|jjdkr t|j|||||}|dt|j|||||}|St|}|dkr1t||||ddS|dkr>t||||ddS|dvrFtdt d ) aReturn 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 rarbrF)r%r.rOrHr[rdrfrg) rrr r<rhrr_rRrir$rjrrrr s 3r c Cr`) 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`. rarbrFTrcr[rdrmrn) rrr r<rhrr_rRrir$rjrrrr 7s$ $  r c CsXt|tjr |f}z dd|D}W|Sty+}z |pd}t|d|d}~ww)z-Convert ``x`` to an iterable sequence of int.cSsg|]}t|qSr)operatorindex.0arrr {z$_iterable_of_int..valuez) must be a scalar or iterable of integersN) isinstancenumbersNumber TypeErrorr$)rnameerrr_iterable_of_intus r}cs4|du}|du}|s5t|d}fdd|D}tfdd|Dr'tdtt|t|kr5td|sot|d }t|}|rLt||krLtd |rb|jkrWtd tjt|j}fd dt||D}n|r|tj }tj}n fd d|D}tdd|Drtd|d||fS)z3Handles shape and axes arguments for nd transforms.Naxescs"g|] }|dkr |jn|qS)rr0rqrrrrts"z+_init_nd_shape_and_axes..c3s"|] }|jkp |dkVqdS)rNrrqrrr s z*_init_nd_shape_and_axes..z$axes exceeds dimensionality of inputzall axes must be uniquerMzBwhen given, axes and shape arguments have to be of the same lengthz)shape requires more axes than are presentcs&g|]\}}|dkrj|n|qS)r rM)rrsrsrrrrts&csg|]}j|qSrrrqrrrrtrucss|]}|dkVqdS)rNr)rrrrrrrsrDrE) r}anyr$lensetr0rangeziplistrM)rrMr~noshapenoaxesnshaperrr_init_nd_shape_and_axess<      rc C|jjdkr t|j|||||}|dt|j|||||}|St|||\}}t|}t|dkr4|St||D]\}} t |||| ||d}q9|S)aCompute 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`. rarbrrkr%r.rOrK) rrrr<rhrrrrr rrkrr~rOrKrlrMr%r.rrrr )  rc Cr)aCompute 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`. rarbrr) rrr r<rhrrrrr rrrrr rr c Cr)aCompute 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`. rarbrr) rrr r<rhrrrrr rrrrr 'rr c Cr)aCompute 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`. rarbrr) rrrr<rhrrrrr rrrrrcrr)r)F)N)Nr TNFF)Nr NTFF)rNr NF)rNNNF)&__doc__ __future__rr#rxrorr cupy.fft._fftrcupyx.scipy.fftrcupy.exceptionsr__all__rr+r5ElementwiseKernelr;rBrRrWrXrYr_ _implements _scipy_fftrr r r r}rrr r rrrrrsb      !  G  Y  Q  D  H  = *  ;  ;  ;