a BCCf@sXddlZddlmZmZmZddgZgdZddZd d Z Gd d d Z dddZ dS)N) _output_len_apply mode_enumupfirdnr) constantwrapedgeZsmoothZ symmetricZreflectZ antisymmetricZ antireflectlinecCs\t|t| |}t||j}||dt|<|d|jdddddf}|S)aStore 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)lennpzerosdtypeZreshapeTZravel)hupZh_padlenZh_fullrQ/var/www/html/django/DPS/env/lib/python3.9/site-packages/scipy/signal/_upfirdn.py_pad_h.s $rcCs|}t|}|S)N)lowerr)modeenumrrr _check_modeBsrc@s"eZdZdZddZd ddZd S) _UpFIRDnzHelper for resampling.cCst|}|jdks|jdkr&tdt|j|tj|_t||j}t ||_ t ||_ |j dksp|j dkrxtdt ||j |_ t|j |_ t||_dS)Nrrz"h must be 1-D with non-zero lengthzBoth up and down must be >= 1)r asarrayndimsize ValueErrorZ result_typerZfloat32 _output_typeint_up_downr _h_trans_flipZascontiguousarrayr _h_len_orig)selfrZx_dtyperdownrrr__init__Ks   z_UpFIRDn.__init__r rrc Cst|j|j||j|j}tj|jtjd}|||<tj||j dd}||j }t |}t t||j |j ||j|j||||S)z@Apply the prepared filter to the specified axis of N-D signal x.)rC)rorder)rr$shaper!r"r rZint64rrrrrr#)r%xaxisrcvalZ output_lenZ output_shapeoutrrr apply_filterZs z_UpFIRDn.apply_filterN)r rr)__name__ __module__ __qualname____doc__r'r/rrrrrHsrr rcCs*t|}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 rrrr/)rr+rr&r,rr-Zufdrrrrksj )rrr rr) numpyr Z_upfirdn_applyrrr__all__Z_upfirdn_modesrrrrrrrr"s#