
    tKg                     X    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y)    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        |        |j	                  d|      j
                  dddddf   j                         }|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       Y/home/alanp/www/video.onchill/myenv/lib/python3.12/site-packages/scipy/signal/_upfirdn.py_pad_hr   .   sp     1v#a&2&HXXh(FF7CFO^^B#%%a2g.446FM    c                 <    | j                         } 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y)_UpFIRDnzHelper for resampling.c                 X   t        j                  |      }|j                  dk7  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        |      | _        y )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    JJqM66Q;!&&A+ABBNN177GRZZHJJq$++,r7Y
88a<4::><==#Atxx011$2D2DEq6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     !1!11774=!%4::7
 zz!'':'Thh|4+<+<CHaff}4 rzz!T../!!3xxT4	7 
r    N)r   r   r   )__name__
__module____qualname____doc__r9   rE    r    r   r'   r'   H   s     "r    r'   c                     t        j                  |      }t        | |j                  ||      }|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   s=    T 	

1A
1aggr4
(CAtT4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1r    