
    _Mh                     `    d dl ZddlmZmZmZ ddgZg dZd Zd Z	 G d	 d
          Z
ddZdS )    N   )_output_len_apply	mode_enumupfirdnr   )	constantwrapedgesmooth	symmetricreflectantisymmetricantireflectlinec                    t          |           t          |            |z  z   }t          j        || j                  }| |dt          |           <   |                    d|          j        dddddf                                         }|S )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       U/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/scipy/signal/_upfirdn.py_pad_hr   .   s     1vv#a&&2&HXh((FF7CFF7O^^B##%aaa2g.4466FM    c                 L    |                                  } t          |           }|S )N)lowerr   )modeenums     r   _check_moder%   B   s    ::<<DT??DKr    c                        e Zd ZdZd ZddZdS )	_UpFIRDnzHelper for resampling.c                 2   t          j        |          }|j        dk    s|j        dk    rt	          d          t          j        |j        |t           j                  | _        t          j        || j                  }t          |          | _
        t          |          | _        | j
        dk     s| j        dk     rt	          d          t          || j
                  | _        t          j        | j                  | _        t          |          | _        d S )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__z_UpFIRDn.__init__K   s    JqMM6Q;;!&A++ABBBN17GRZHHJq$+,,r77YY
8a<<4:>><===#Atx001$2DEEq66r    r   r   r   c           
         t          | j        |j        |         | j        | j                  }t          j        |j        t
          j                  }|||<   t          j        || j	        d          }||j
        z  }t          |          }t          t          j        || j	                  | j        || j        | j        |||           |S )z@Apply the prepared filter to the specified axis of N-D signal x.)r   C)r   order)r   r5   shaper1   r2   r   r)   int64r   r/   r*   r%   r   r3   )r6   xaxisr#   cval
output_lenoutput_shapeouts           r   apply_filterz_UpFIRDn.apply_filterZ   s     !1174=!%4:7 7
 z!':::'Th|4+<CHHHaf}4  rz!T.//!3xT4	7 	7 	7 
r    N)r   r   r   )__name__
__module____qualname____doc__r9   rE    r    r   r'   r'   H   s=          " " "     r    r'   r   r   c                     t          j        |          }t          | |j        ||          }|                    ||||          S )a  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   rE   )r   r?   r   r8   r@   r#   rA   ufds           r   r   r   k   sA    T 	
1A
1agr4
(
(CAtT4000r    )r   r   r   r   r   )numpyr   _upfirdn_applyr   r   r   __all___upfirdn_modesr   r%   r'   r   rJ   r    r   <module>rQ      s   D     : : : : : : : : : :m
$    (                 Fm1 m1 m1 m1 m1 m1r    