B
    î&]\»  ã               @   sF   d dl ZddlmZmZ ddgZdd„ ZG dd	„ d	eƒZddd„Z	dS )é    Né   )Ú_output_lenÚ_applyÚupfirdnr   c             C   s\   t | ƒt | ƒ |  }t || 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ÚdtypeZreshapeÚTZravel)ÚhÚupZh_padlenZh_full© r   ú4lib/python3.7/site-packages/scipy/signal/_upfirdn.pyÚ_pad_h)   s
    $r   c               @   s   e Zd Zdd„ Zddd„ZdS )Ú_UpFIRDnc             C   s˜   t  |¡}|jdks|jdkr&tdƒ‚t  |j|t j¡| _t  || j¡}t	|ƒ| _
t	|ƒ| _| j
dk sp| jdk rxtdƒ‚t|| j
ƒ| _t  | j¡| _dS )zHelper for resamplingr   r   z!h must be 1D with non-zero lengthzBoth up and down must be >= 1N)r   ÚasarrayÚndimÚsizeÚ
ValueErrorZresult_typer
   Zfloat32Ú_output_typeÚintÚ_upÚ_downr   Ú_h_trans_flipZascontiguousarray)Úselfr   Zx_dtyper   Údownr   r   r   Ú__init__>   s    


z_UpFIRDn.__init__r   c             C   st   t t| jƒ|j| | j| jƒ}t |j¡}|||< tj|| j	dd}||j
 }tt || j	¡| j|| j| j|ƒ |S )z@Apply the prepared filter to the specified axis of a nD signal xÚC)r
   Úorder)r   r   r   Úshaper   r   r   r   r	   r   r   r   )r   ÚxÚaxisZ
output_lenZoutput_shapeÚoutr   r   r   Úapply_filterM   s    
z_UpFIRDn.apply_filterN)r   )Ú__name__Ú
__module__Ú__qualname__r   r$   r   r   r   r   r   =   s   r   r   c             C   s&   t  |¡}t| |j||ƒ}| ||¡S )a©
  Upsample, FIR filter, and downsample

    Parameters
    ----------
    h : array_like
        1-dimensional 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.

    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).

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

    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

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

    >>> 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.,  0.,  0.])
    >>> 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,  0. ])
    >>> 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,  0. ])

    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$   )r   r!   r   r   r"   Zufdr   r   r   r   [   s    Y
)r   r   r   )
Znumpyr   Z_upfirdn_applyr   r   Ú__all__r   Úobjectr   r   r   r   r   r   Ú<module>"   s
   