
    (ph@>                        S r / SQrSSKrSSKJrJrJrJrJrJ	r	J
r
Jr  SSKJr  SSKJr  \R                   " 5       rSS\4S jrS\4S	 jrS\4S
 jr\4S jr\4S jrS\4S jrS\4S jrS\4S jrS\4S jrS\4S jrg)z1
Differential and pseudo-differential operators.
)
difftilbertitilberthilbertihilbertcs_diffcc_diffsc_diffss_diffshift    N)piasarraysincossinhcoshtanhiscomplexobj   )convolve)_datacopiedc                    [        U[        R                  5      (       a$  [        US5      (       d  0 Ul        UR                  n[        U 5      nUS:X  a  U$ [        U5      (       a2  [        UR                  XU5      S[        UR                  XU5      -  -   $ Ub  S[        -  U-  nOSn[        U 5      nUR                  XaU45      nUcQ  [        U5      S:  a   U(       a  UR                  5         U(       a  M  X4S jn[        R                  " XhUSS	9nXsXaU4'   [!        X@5      n	[        R                  " XGUS-  U	S
9$ )a  
Return kth derivative (or integral) of a periodic sequence x.

If x_j and y_j are Fourier coefficients of periodic functions x
and y, respectively, then::

  y_j = pow(sqrt(-1)*j*2*pi/period, order) * x_j
  y_0 = 0 if order is not 0.

Parameters
----------
x : array_like
    Input array.
order : int, optional
    The order of differentiation. Default order is 1. If order is
    negative, then integration is carried out under the assumption
    that ``x_0 == 0``.
period : float, optional
    The assumed period of the sequence. Default is ``2*pi``.

Notes
-----
If ``sum(x, axis=0) = 0`` then ``diff(diff(x, k), -k) == x`` (within
numerical accuracy).

For odd order and even ``len(x)``, the Nyquist mode is taken zero.


diff_cacher                 ?         ?   c                 .    U (       a  [        X -  U5      $ gNr   )pow)kordercs      N/var/www/html/venv/lib/python3.13/site-packages/scipy/fftpack/_pseudo_diffs.pykerneldiff.<locals>.kernelI   s    13u~%    r   dzero_nyquistswap_real_imagoverwrite_x)
isinstance	threadinglocalhasattrr   r   r   r   realimagr   lengetpopitemr   init_convolution_kernelr   )
xr"   period_cachetmpr#   nomegar%   r-   s
             r$   r   r      s8   : &)//**v|,, "F""
!*Cz
CCHHeV4RHHeV9- 6- - 	-bDKAAJJ{#E}v;  & ! 	 00E>?A#{c%KSeai)46 6r'   c                 f   [        U[        R                  5      (       a$  [        US5      (       d  0 Ul        UR                  n[        U 5      n[        U5      (       a2  [        UR                  XU5      S[        UR                  XU5      -  -   $ Ub  US-  [        -  U-  n[        U 5      nUR                  XQ45      nUcO  [        U5      S:  a   U(       a  UR                  5         U(       a  M  U4S jn[        R                  " XWSS9nXcXQ4'   [!        X@5      n[        R                  " XFSUS9$ )	a'  
Return h-Tilbert transform of a periodic sequence x.

If x_j and y_j are Fourier coefficients of periodic functions x
and y, respectively, then::

    y_j = sqrt(-1)*coth(j*h*2*pi/period) * x_j
    y_0 = 0

Parameters
----------
x : array_like
    The input array to transform.
h : float
    Defines the parameter of the Tilbert transform.
period : float, optional
    The assumed period of the sequence. Default period is ``2*pi``.

Returns
-------
tilbert : ndarray
    The result of the transform.

Notes
-----
If ``sum(x, axis=0) == 0`` and ``n = len(x)`` is odd, then
``tilbert(itilbert(x)) == x``.

If ``2 * pi * h / period`` is approximately 10 or larger, then
numerically ``tilbert == hilbert``
(theoretically oo-Tilbert == Hilbert).

For even ``len(x)``, the Nyquist mode of ``x`` is taken zero.

tilbert_cacher   r   r   c                 2    U (       a  S[        X-  5      -  $ g)Nr   r   r   r!   hs     r$   r%   tilbert.<locals>.kernel   s    49}$r'   r   r)   r+   )r.   r/   r0   r1   r?   r   r   r   r2   r3   r   r4   r5   r6   r   r7   r   	r8   rC   r9   r:   r;   r<   r=   r%   r-   s	            r$   r   r   U   s   H &)//**v//#%F %%
!*CCsxxF3GCHHa889 	9 EBJAAJJvE}v;  &  	 00a@uc%KSaKPPr'   c                 f   [        U[        R                  5      (       a$  [        US5      (       d  0 Ul        UR                  n[        U 5      n[        U5      (       a2  [        UR                  XU5      S[        UR                  XU5      -  -   $ Ub  US-  [        -  U-  n[        U 5      nUR                  XQ45      nUcO  [        U5      S:  a   U(       a  UR                  5         U(       a  M  U4S jn[        R                  " XWSS9nXcXQ4'   [!        X@5      n[        R                  " XFSUS9$ )	z
Return inverse h-Tilbert transform of a periodic sequence x.

If ``x_j`` and ``y_j`` are Fourier coefficients of periodic functions x
and y, respectively, then::

  y_j = -sqrt(-1)*tanh(j*h*2*pi/period) * x_j
  y_0 = 0

For more details, see `tilbert`.

itilbert_cacher   r   r   c                 .    U (       a  [        X-  5      * $ gr   rA   rB   s     r$   r%   itilbert.<locals>.kernel   s    QS	z!r'   r   rE   r+   )r.   r/   r0   r1   rH   r   r   r   r2   r3   r   r4   r5   r6   r   r7   r   rF   s	            r$   r   r      s    &)//**v/00$&F!&&
!*CC!V4(388Q778 	8aCF6MAAJJuE}v;  &  	 00A>uc%KSaKPPr'   c                 4   [        U[        R                  5      (       a$  [        US5      (       d  0 Ul        UR                  n[        U 5      n[        U5      (       a0  [        UR                  U5      S[        UR                  U5      -  -   $ [        U 5      nUR                  U5      nUcK  [        U5      S:  a   U(       a  UR                  5         U(       a  M  S n[        R                  " X5SS9nXAU'   [        X 5      n[        R                  " X$SUS9$ )a  
Return Hilbert transform of a periodic sequence x.

If x_j and y_j are Fourier coefficients of periodic functions x
and y, respectively, then::

  y_j = sqrt(-1)*sign(j) * x_j
  y_0 = 0

Parameters
----------
x : array_like
    The input array, should be periodic.
_cache : dict, optional
    Dictionary that contains the kernel used to do a convolution with.

Returns
-------
y : ndarray
    The transformed input.

See Also
--------
scipy.signal.hilbert : Compute the analytic signal, using the Hilbert
                       transform.

Notes
-----
If ``sum(x, axis=0) == 0`` then ``hilbert(ihilbert(x)) == x``.

For even len(x), the Nyquist mode of x is taken zero.

The sign of the returned transform does not have a factor -1 that is more
often than not found in the definition of the Hilbert transform. Note also
that `scipy.signal.hilbert` does have an extra -1 factor compared to this
function.

hilbert_cacher   r   c                      U S:  a  gU S:  a  gg)Nr   r   g      g         )r!   s    r$   r%   hilbert.<locals>.kernel   s    1uQr'   r   rE   r+   )r.   r/   r0   r1   rL   r   r   r   r2   r3   r4   r5   r6   r   r7   r   )r8   r:   r;   r<   r=   r%   r-   s          r$   r   r      s    N &)//**v//#%F %%
!*CCsxx(2&0I+IIIAAJJqME}v;  &	 00A>q	c%KSaKPPr'   c                     [        U[        R                  5      (       a$  [        US5      (       d  0 Ul        UR                  n[        X5      * $ )z
Return inverse Hilbert transform of a periodic sequence x.

If ``x_j`` and ``y_j`` are Fourier coefficients of periodic functions x
and y, respectively, then::

  y_j = -sqrt(-1)*sign(j) * x_j
  y_0 = 0

ihilbert_cache)r.   r/   r0   r1   rQ   r   )r8   r:   s     r$   r   r     sD     &)//**v/00$&F!&&Ar'   c           	         [        U[        R                  5      (       a$  [        US5      (       d  0 Ul        UR                  n[        U 5      n[        U5      (       a2  [        UR                  XX45      S[        UR                  XX45      -  -   $ Ub  US-  [        -  U-  nUS-  [        -  U-  n[        U 5      nUR                  XaU45      nUcP  [        U5      S:  a   U(       a  UR                  5         U(       a  M  X4S jn[        R                  " XhSS9nXtXaU4'   [!        XP5      n	[        R                  " XWSU	S9$ )	a  
Return (a,b)-cosh/sinh pseudo-derivative of a periodic sequence.

If ``x_j`` and ``y_j`` are Fourier coefficients of periodic functions x
and y, respectively, then::

  y_j = -sqrt(-1)*cosh(j*a*2*pi/period)/sinh(j*b*2*pi/period) * x_j
  y_0 = 0

Parameters
----------
x : array_like
    The array to take the pseudo-derivative from.
a, b : float
    Defines the parameters of the cosh/sinh pseudo-differential
    operator.
period : float, optional
    The period of the sequence. Default period is ``2*pi``.

Returns
-------
cs_diff : ndarray
    Pseudo-derivative of periodic sequence `x`.

Notes
-----
For even len(`x`), the Nyquist mode of `x` is taken as zero.

cs_diff_cacher   r   r   c                 J    U (       a  [        X-  5      * [        X -  5      -  $ gr   )r   r   r!   abs      r$   r%   cs_diff.<locals>.kernelH  s!    QS	z$qs)++r'   r   rE   r+   )r.   r/   r0   r1   rS   r   r   r   r2   r3   r   r4   r5   r6   r   r7   r   
r8   rV   rW   r9   r:   r;   r<   r=   r%   r-   s
             r$   r   r     s(   < &)//**v//#%F %%
!*CCsxxv6'#((A&99: 	:aCF6MaCF6MAAJJAwE}v;  &  	 00A>Awc%KSaKPPr'   c           	         [        U[        R                  5      (       a$  [        US5      (       d  0 Ul        UR                  n[        U 5      n[        U5      (       a2  [        UR                  XX45      S[        UR                  XX45      -  -   $ Ub  US-  [        -  U-  nUS-  [        -  U-  n[        U 5      nUR                  XaU45      nUcP  [        U5      S:  a   U(       a  UR                  5         U(       a  M  X4S jn[        R                  " XhSS9nXtXaU4'   [!        XP5      n	[        R                  " XWSU	S9$ )	a<  
Return (a,b)-sinh/cosh pseudo-derivative of a periodic sequence x.

If x_j and y_j are Fourier coefficients of periodic functions x
and y, respectively, then::

  y_j = sqrt(-1)*sinh(j*a*2*pi/period)/cosh(j*b*2*pi/period) * x_j
  y_0 = 0

Parameters
----------
x : array_like
    Input array.
a,b : float
    Defines the parameters of the sinh/cosh pseudo-differential
    operator.
period : float, optional
    The period of the sequence x. Default is 2*pi.

Notes
-----
``sc_diff(cs_diff(x,a,b),b,a) == x``
For even ``len(x)``, the Nyquist mode of x is taken as zero.

sc_diff_cacher   r   r   c                 H    U (       a  [        X-  5      [        X -  5      -  $ gr   )r   r   rU   s      r$   r%   sc_diff.<locals>.kernel  s    ACyac**r'   r   rE   r+   )r.   r/   r0   r1   r[   r   r   r	   r2   r3   r   r4   r5   r6   r   r7   r   rY   s
             r$   r	   r	   R  s(   4 &)//**v//#%F %%
!*CCsxxv6GCHHaF;;< 	<aCF6MaCF6MAAJJAwE}v;  &  	 00A>Awc%KSaKPPr'   c           	         [        U[        R                  5      (       a$  [        US5      (       d  0 Ul        UR                  n[        U 5      n[        U5      (       a2  [        UR                  XX45      S[        UR                  XX45      -  -   $ Ub  US-  [        -  U-  nUS-  [        -  U-  n[        U 5      nUR                  XaU45      nUcQ  [        U5      S:  a   U(       a  UR                  5         U(       a  M  X4S jn[        R                  " Xh5      nXtXaU4'   [!        XP5      n	[        R                  " XWU	S9$ )a  
Return (a,b)-sinh/sinh pseudo-derivative of a periodic sequence x.

If x_j and y_j are Fourier coefficients of periodic functions x
and y, respectively, then::

  y_j = sinh(j*a*2*pi/period)/sinh(j*b*2*pi/period) * x_j
  y_0 = a/b * x_0

Parameters
----------
x : array_like
    The array to take the pseudo-derivative from.
a,b
    Defines the parameters of the sinh/sinh pseudo-differential
    operator.
period : float, optional
    The period of the sequence x. Default is ``2*pi``.

Notes
-----
``ss_diff(ss_diff(x,a,b),b,a) == x``

ss_diff_cacher   r   r   c                 b    U (       a  [        X-  5      [        X -  5      -  $ [        U5      U-  $ N)r   floatrU   s      r$   r%   ss_diff.<locals>.kernel  s*    ACyac**8A:r'   r-   )r.   r/   r0   r1   r_   r   r   r
   r2   r3   r   r4   r5   r6   r   r7   r   rY   s
             r$   r
   r
     s$   2 &)//**v//#%F %%
!*CCsxxv6'#((A&99: 	:aCF6MaCF6MAAJJAwE}v;  &  	 00:Awc%KS;??r'   c           	         [        U[        R                  5      (       a$  [        US5      (       d  0 Ul        UR                  n[        U 5      n[        U5      (       a2  [        UR                  XX45      S[        UR                  XX45      -  -   $ Ub  US-  [        -  U-  nUS-  [        -  U-  n[        U 5      nUR                  XaU45      nUcQ  [        U5      S:  a   U(       a  UR                  5         U(       a  M  X4S jn[        R                  " Xh5      nXtXaU4'   [!        XP5      n	[        R                  " XWU	S9$ )ab  
Return (a,b)-cosh/cosh pseudo-derivative of a periodic sequence.

If x_j and y_j are Fourier coefficients of periodic functions x
and y, respectively, then::

  y_j = cosh(j*a*2*pi/period)/cosh(j*b*2*pi/period) * x_j

Parameters
----------
x : array_like
    The array to take the pseudo-derivative from.
a,b : float
    Defines the parameters of the sinh/sinh pseudo-differential
    operator.
period : float, optional
    The period of the sequence x. Default is ``2*pi``.

Returns
-------
cc_diff : ndarray
    Pseudo-derivative of periodic sequence `x`.

Notes
-----
``cc_diff(cc_diff(x,a,b),b,a) == x``

cc_diff_cacher   r   r   c                 8    [        X-  5      [        X -  5      -  $ ra   )r   rU   s      r$   r%   cc_diff.<locals>.kernel  s    9T!#Y&&r'   rd   )r.   r/   r0   r1   rf   r   r   r   r2   r3   r   r4   r5   r6   r   r7   r   rY   s
             r$   r   r     s"   : &)//**v//#%F %%
!*CCsxxv6GCHHaF;;< 	<aCF6MaCF6MAAJJAwE}v;  &  	'00:Awc%KS;??r'   c                    [        U[        R                  5      (       a$  [        US5      (       d  0 Ul        UR                  n[        U 5      n[        U5      (       a2  [        UR                  XU5      S[        UR                  XU5      -  -   $ Ub  US-  [        -  U-  n[        U 5      nUR                  XQ45      nUco  [        U5      S:  a   U(       a  UR                  5         U(       a  M  U4S jnU4S jn[        R                  " XWSSS9n	[        R                  " XXS	SS9n
X4X5U4'   OUu  p[!        X@5      n[        R"                  " XIU
US
9$ )a  
Shift periodic sequence x by a: y(u) = x(u+a).

If x_j and y_j are Fourier coefficients of periodic functions x
and y, respectively, then::

      y_j = exp(j*a*2*pi/period*sqrt(-1)) * x_f

Parameters
----------
x : array_like
    The array to take the pseudo-derivative from.
a : float
    Defines the parameters of the sinh/sinh pseudo-differential
period : float, optional
    The period of the sequences x and y. Default period is ``2*pi``.
shift_cacher   r   r   c                     [        X-  5      $ ra   )r   r!   rV   s     r$   kernel_realshift.<locals>.kernel_real      qs8Or'   c                     [        X-  5      $ ra   )r   rl   s     r$   kernel_imagshift.<locals>.kernel_imag  ro   r'   r   r(   r   rd   )r.   r/   r0   r1   rj   r   r   r   r2   r3   r   r4   r5   r6   r   r7   r   
convolve_z)r8   rV   r9   r:   r;   r<   r=   rm   rq   
omega_real
omega_imagr-   s               r$   r   r     sO   $ &)//**v}--!#F##
!*CCSXXq&1BHHa:) 5) ) 	)aCF6MAAJJuE}v;  &  	  	55aaCDF
55aaCDF
"-!u %
c%Ksj+68 8r'   )__doc____all__r/   numpyr   r   r   r   r   r   r   r    r   scipy.fft._pocketfft.helperr   r0   r:   r   r   r   r   r   r   r	   r
   r   r   rN   r'   r$   <module>r{      s   

  G G G  3 
	 $v <6~ f BQJ V &QR  ?QD  $ ! 8Qv ! 4Qn ! 3@l ! 5@p F 28r'   