ó
    pñ:i(  ã                   óf   • S SK rS SKJr  SSKJrJrJr  SS/r/ SQr	S r
S	 r " S
 S5      rSS jrg)é    N)Úarray_namespaceé   )Ú_output_lenÚ_applyÚ	mode_enumÚupfirdnr   )	ÚconstantÚwrapÚedgeÚsmoothÚ	symmetricÚreflectÚantisymmetricÚantireflectÚlinec                 óþ   • [        U 5      [        U 5      * U-  -   n[        R                  " X R                  5      nXS[        U 5      & UR	                  SU5      R
                  SS2SSS24   R                  5       nU$ )a˜  Store coefficients in a transposed, flipped arrangement.

For example, suppose upRate is 3, and the
input number of coefficients is 10, represented as h[0], ..., h[9].

Then the internal buffer will look like this::

   h[9], h[6], h[3], h[0],   // flipped phase 0 coefs
   0,    h[7], h[4], h[1],   // flipped phase 1 coefs (zero-padded)
   0,    h[8], h[5], h[2],   // flipped phase 2 coefs (zero-padded)

Néÿÿÿÿ)ÚlenÚnpÚzerosÚdtypeÚreshapeÚTÚravel)ÚhÚupÚh_padlenÚh_fulls       ÚX/srv/projetos/modelo_ml_acdoc/venv/lib/python3.13/site-packages/scipy/signal/_upfirdn.pyÚ_pad_hr    /   sl   € ô �1‹vœ#˜a›&˜ 2™Ñ&€HÜ�XŠX�h§¡Ó(€FØˆ7ŒC�‹F€OØ�^‰^˜B Ó#×%Ñ%¢a©¨2¨ gÑ.×4Ñ4Ó6€FØ€Mó    c                 ó<   • U R                  5       n [        U 5      nU$ )N)Úlowerr   )ÚmodeÚenums     r   Ú_check_moder&   C   s   € Ø�:‰:‹<€DÜ�T‹?€DØ€Kr!   c                   ó(   • \ rS rSrSrS rSS jrSrg)Ú_UpFIRDnéI   zHelper for resampling.c                 ód  • [         R                  " U5      nUR                  S:w  d  UR                  S:X  a  [	        S5      e[         R
                  " UR                  U[         R                  5      U l        [         R                  " XR                  5      n[        U5      U l
        [        U5      U l        U R                  S:  d  U R                  S:  a  [	        S5      e[        XR                  5      U l        [         R                  " U R                  5      U l        [        U5      U l        g )Nr   r   z"h must be 1-D with non-zero lengthzBoth up and down must be >= 1)r   ÚasarrayÚndimÚsizeÚ
ValueErrorÚresult_typer   Úfloat32Ú_output_typeÚintÚ_upÚ_downr    Ú_h_trans_flipÚascontiguousarrayr   Ú_h_len_orig)Úselfr   Úx_dtyper   Údowns        r   Ú__init__Ú_UpFIRDn.__init__L   sÎ   € Ü�JŠJ�q‹MˆØ�6‰6�Q‹;˜!Ÿ&™& A›+ÜÐAÓBÐBÜŸNšN¨1¯7©7°G¼R¿Z¹ZÓHˆÔÜ�JŠJ�q×+Ñ+Ó,ˆÜ�r“7ˆŒÜ˜“YˆŒ
Ø�8‰8�a‹<˜4Ÿ:™:¨›>ÜÐ<Ó=Ð=ä# A§x¡xÓ0ˆÔÜ×1Ò1°$×2DÑ2DÓEˆÔÜ˜q›6ˆÕr!   c           
      óä  • [        U R                  UR                  U   U R                  U R                  5      n[
        R                  " UR                  [
        R                  S9nXVU'   [
        R                  " X`R                  SS9nX!R                  -  n[        U5      n[        [
        R                  " XR                  5      U R                  UU R                  U R                  X#U5        U$ )z@Apply the prepared filter to the specified axis of N-D signal x.)r   ÚC)r   Úorder)r   r7   Úshaper3   r4   r   r+   Úint64r   r1   r,   r&   r   r5   )r8   ÚxÚaxisr$   ÚcvalÚ
output_lenÚoutput_shapeÚouts           r   Úapply_filterÚ_UpFIRDn.apply_filter[   s´   € ä  ×!1Ñ!1°1·7±7¸4±=Ø!%§¡¨4¯:©:ó7ˆ
ô —z’z !§'¡'´·±Ñ:ˆØ'�TÑÜ�hŠh�|×+<Ñ+<ÀCÑHˆØ—f‘f‰}ˆÜ˜4Ó ˆÜŒr�zŠz˜!×.Ñ.Ó/Ø×!Ñ! 3Ø�x‰x˜Ÿ™ T°ô	7ð ˆ
r!   )r4   r7   r5   r1   r3   N)r   r	   r   )Ú__name__Ú
__module__Ú__qualname__Ú__firstlineno__Ú__doc__r;   rH   Ú__static_attributes__© r!   r   r(   r(   I   s   † Ù ò"÷r!   r(   c                 ó²   • [        X5      n[        R                  " U5      n[        XR                  X#5      nUR                  UR                  XXV5      5      $ )aG  Upsample, FIR filter, and downsample.

Parameters
----------
h : array_like
    1-D FIR (finite-impulse response) filter coefficients.
x : array_like
    Input signal array.
up : int, optional
    Upsampling rate. Default is 1.
down : int, optional
    Downsampling rate. Default is 1.
axis : int, optional
    The axis of the input data array along which to apply the
    linear filter. The filter is applied to each subarray along
    this axis. Default is -1.
mode : str, optional
    The signal extension mode to use. The set
    ``{"constant", "symmetric", "reflect", "edge", "wrap"}`` correspond to
    modes provided by `numpy.pad`. ``"smooth"`` implements a smooth
    extension by extending based on the slope of the last 2 points at each
    end of the array. ``"antireflect"`` and ``"antisymmetric"`` are
    anti-symmetric versions of ``"reflect"`` and ``"symmetric"``. The mode
    `"line"` extends the signal based on a linear trend defined by the
    first and last points along the ``axis``.

    .. versionadded:: 1.4.0
cval : float, optional
    The constant value to use when ``mode == "constant"``.

    .. versionadded:: 1.4.0

Returns
-------
y : ndarray
    The output signal array. Dimensions will be the same as `x` except
    for along `axis`, which will change size according to the `h`,
    `up`,  and `down` parameters.

Notes
-----
The algorithm is an implementation of the block diagram shown on page 129
of the Vaidyanathan text [1]_ (Figure 4.3-8d).

The direct approach of upsampling by factor of P with zero insertion,
FIR filtering of length ``N``, and downsampling by factor of Q is
O(N*Q) per output sample. The polyphase implementation used here is
O(N/P).

.. versionadded:: 0.18

References
----------
.. [1] P. P. Vaidyanathan, Multirate Systems and Filter Banks,
       Prentice Hall, 1993.

Examples
--------
Simple operations:

>>> import numpy as np
>>> from scipy.signal import upfirdn
>>> upfirdn([1, 1, 1], [1, 1, 1])   # FIR filter
array([ 1.,  2.,  3.,  2.,  1.])
>>> upfirdn([1], [1, 2, 3], 3)  # upsampling with zeros insertion
array([ 1.,  0.,  0.,  2.,  0.,  0.,  3.])
>>> upfirdn([1, 1, 1], [1, 2, 3], 3)  # upsampling with sample-and-hold
array([ 1.,  1.,  1.,  2.,  2.,  2.,  3.,  3.,  3.])
>>> upfirdn([.5, 1, .5], [1, 1, 1], 2)  # linear interpolation
array([ 0.5,  1. ,  1. ,  1. ,  1. ,  1. ,  0.5])
>>> upfirdn([1], np.arange(10), 1, 3)  # decimation by 3
array([ 0.,  3.,  6.,  9.])
>>> upfirdn([.5, 1, .5], np.arange(10), 2, 3)  # linear interp, rate 2/3
array([ 0. ,  1. ,  2.5,  4. ,  5.5,  7. ,  8.5])

Apply a single filter to multiple signals:

>>> x = np.reshape(np.arange(8), (4, 2))
>>> x
array([[0, 1],
       [2, 3],
       [4, 5],
       [6, 7]])

Apply along the last dimension of ``x``:

>>> h = [1, 1]
>>> upfirdn(h, x, 2)
array([[ 0.,  0.,  1.,  1.],
       [ 2.,  2.,  3.,  3.],
       [ 4.,  4.,  5.,  5.],
       [ 6.,  6.,  7.,  7.]])

Apply along the 0th dimension of ``x``:

>>> upfirdn(h, x, 2, axis=0)
array([[ 0.,  1.],
       [ 0.,  1.],
       [ 2.,  3.],
       [ 2.,  3.],
       [ 4.,  5.],
       [ 4.,  5.],
       [ 6.,  7.],
       [ 6.,  7.]])
)r   r   r+   r(   r   rH   )	r   rB   r   r:   rC   r$   rD   ÚxpÚufds	            r   r   r   l   sH   € ôT 
˜Ó	€Bä
�
Š
�1‹€AÜ
�1—g‘g˜rÓ
(€Cà�:‰:�c×&Ñ& q°Ó;Ó<Ð<r!   )r   r   r   r	   r   )Únumpyr   Úscipy._lib._array_apir   Ú_upfirdn_applyr   r   r   Ú__all__Ú_upfirdn_modesr    r&   r(   r   rP   r!   r   Ú<module>rY      s@   ðóD å 1ß :Ñ :à�mÐ
$€ò€òò(÷ ñ  õFo=r!   