
    5[gi4                     f    d dl Zd dlmZ d dlmZ d dlmZ ddlm	Z	 	 	 ddZ
d Zd	 Zd
 Z	 	 ddZy)    N)lstsq)float_factorial)
convolve1d   )
axis_slicec                 *   || k\  rt        d      t        | d      \  }}||dk(  r|dz
  }n|}d|cxk  r| k  st        d       t        d      |dvrt        d      ||kD  rt        j                  |       }|S t        j                  | | |z
  t
        	      }	|d
k(  r|	ddd   }	t        j                  |dz         j                  dd      }
|	|
z  }t        j                  |dz         }t        |      ||z  z  ||<   t        ||      \  }}}}|S )a	  Compute the coefficients for a 1-D Savitzky-Golay FIR filter.

    Parameters
    ----------
    window_length : int
        The length of the filter window (i.e., the number of coefficients).
    polyorder : int
        The order of the polynomial used to fit the samples.
        `polyorder` must be less than `window_length`.
    deriv : int, optional
        The order of the derivative to compute. This must be a
        nonnegative integer. The default is 0, which means to filter
        the data without differentiating.
    delta : float, optional
        The spacing of the samples to which the filter will be applied.
        This is only used if deriv > 0.
    pos : int or None, optional
        If pos is not None, it specifies evaluation position within the
        window. The default is the middle of the window.
    use : str, optional
        Either 'conv' or 'dot'. This argument chooses the order of the
        coefficients. The default is 'conv', which means that the
        coefficients are ordered to be used in a convolution. With
        use='dot', the order is reversed, so the filter is applied by
        dotting the coefficients with the data set.

    Returns
    -------
    coeffs : 1-D ndarray
        The filter coefficients.

    See Also
    --------
    savgol_filter

    Notes
    -----
    .. versionadded:: 0.14.0

    References
    ----------
    A. Savitzky, M. J. E. Golay, Smoothing and Differentiation of Data by
    Simplified Least Squares Procedures. Analytical Chemistry, 1964, 36 (8),
    pp 1627-1639.
    Jianwen Luo, Kui Ying, and Jing Bai. 2005. Savitzky-Golay smoothing and
    differentiation filter for even number data. Signal Process.
    85, 7 (July 2005), 1429-1434.

    Examples
    --------
    >>> import numpy as np
    >>> from scipy.signal import savgol_coeffs
    >>> savgol_coeffs(5, 2)
    array([-0.08571429,  0.34285714,  0.48571429,  0.34285714, -0.08571429])
    >>> savgol_coeffs(5, 2, deriv=1)
    array([ 2.00000000e-01,  1.00000000e-01,  2.07548111e-16, -1.00000000e-01,
           -2.00000000e-01])

    Note that use='dot' simply reverses the coefficients.

    >>> savgol_coeffs(5, 2, pos=3)
    array([ 0.25714286,  0.37142857,  0.34285714,  0.17142857, -0.14285714])
    >>> savgol_coeffs(5, 2, pos=3, use='dot')
    array([-0.14285714,  0.17142857,  0.34285714,  0.37142857,  0.25714286])
    >>> savgol_coeffs(4, 2, pos=3, deriv=1, use='dot')
    array([0.45,  -0.85,  -0.65,  1.05])

    `x` contains data from the parabola x = t**2, sampled at
    t = -1, 0, 1, 2, 3.  `c` holds the coefficients that will compute the
    derivative at the last position.  When dotted with `x` the result should
    be 6.

    >>> x = np.array([1, 0, 1, 4, 9])
    >>> c = savgol_coeffs(5, 2, pos=4, deriv=1, use='dot')
    >>> c.dot(x)
    6.0
    z*polyorder must be less than window_length.   Nr   g      ?z4pos must be nonnegative and less than window_length.)convdotz`use` must be 'conv' or 'dot')dtyper
   r   )	
ValueErrordivmodnpzerosarangefloatreshaper   r   )window_length	polyorderderivdeltaposusehalflenremcoeffsxorderAy_s                 W/var/www/html/bid-api/venv/lib/python3.12/site-packages/scipy/signal/_savitzky_golay.pysavgol_coeffsr$      sH   x M!EFF-+LGS
{!8C-CC$}$ * + 	+ % * + 	+ /!899y-( 			3$+59A
f}ddGIIi!m$,,R3E	U
A 	QA u%%8AeH AqkOFAq!M    c                 \   |dk(  r| }|S t        |       }||k  rt        j                  | dddf         }|S | d|  j                         }t	        |      D ]P  }t        j
                  ||z
  dz
  ||z
  dz
  d      }||j                  ||z
  fd| j                  dz
  z  z         z  }R |}|S )aH  Differentiate polynomials represented with coefficients.

    p must be a 1-D or 2-D array.  In the 2-D case, each column gives
    the coefficients of a polynomial; the first row holds the coefficients
    associated with the highest power. m must be a nonnegative integer.
    (numpy.polyder doesn't handle the 2-D case.)
    r   Nr   .r   )r   )lenr   
zeros_likecopyranger   r   ndim)pmresultndpkrngs          r#   _polyderr3      s     	Av M F6]]1RaRW:.F M 3QBB1XiiA	1q519b9ckk1q5(TQVVaZ-@"@AA  FMr%   c
                    t        | |||      }
|dk(  s|| j                   k(  r|
}d}n|
j                  |d      }d}|j                  |j                  d   d      }t        j                  t        j                  d||z
        ||      }|dkD  rt        ||      }t        j                  ||z
  ||z
        }t        j                  ||j                  dd            ||z  z  }t        |	j                        }||   |d   c|d<   ||<    |j                  ||z
  g|dd  }|r|j                  d|      }t        |	|||      }||d<   y)	aE  
    Given an N-d array `x` and the specification of a slice of `x` from
    `window_start` to `window_stop` along `axis`, create an interpolating
    polynomial of each 1-D slice, and evaluate that polynomial in the slice
    from `interp_start` to `interp_stop`. Put the result into the
    corresponding slice of `y`.
    )startstopaxisr   FTr   r   N.)r   r+   swapaxesr   shaper   polyfitr   r3   polyvallist)r   window_startwindow_stopinterp_startinterp_stopr7   r   r   r   r!   x_edgexx_edgeswappedpoly_coeffsivaluesshpy_edges                     r#   	_fit_edgerI      sR    KdKFqyDQVVGO//$*oogmmA.3G **RYYq+*DE$i1K qy{E2 			,-{\/IJAZZQYYr1%56%5.IF qww-CD	3q6CFCIV^^K,6AQRAFD)KdKFF3Kr%   c                     |dz  }t        | d|d||||||
       | j                  |   }t        | ||z
  |||z
  ||||||
       y)z
    Use polynomial interpolation of x at the low and high ends of the axis
    to fill in the halflen values in y.

    This function just calls _fit_edge twice, once for each end of the axis.
    r	   r   N)rI   r9   )	r   r   r   r   r   r7   r!   r   r/   s	            r#   _fit_edges_polyfitrK      s^     q GaM1gtq*	Aa]"Aq7{Atq*r%   c           	         |dvrt        d      t        j                  |       } | j                  t        j                  k7  r<| j                  t        j
                  k7  r| j                  t        j                        } t        ||||      }|dk(  r?|| j                  |   kD  rt        d      t        | ||d      }	t        | ||||||	       |	S t        | ||||      }	|	S )	a   Apply a Savitzky-Golay filter to an array.

    This is a 1-D filter. If `x`  has dimension greater than 1, `axis`
    determines the axis along which the filter is applied.

    Parameters
    ----------
    x : array_like
        The data to be filtered. If `x` is not a single or double precision
        floating point array, it will be converted to type ``numpy.float64``
        before filtering.
    window_length : int
        The length of the filter window (i.e., the number of coefficients).
        If `mode` is 'interp', `window_length` must be less than or equal
        to the size of `x`.
    polyorder : int
        The order of the polynomial used to fit the samples.
        `polyorder` must be less than `window_length`.
    deriv : int, optional
        The order of the derivative to compute. This must be a
        nonnegative integer. The default is 0, which means to filter
        the data without differentiating.
    delta : float, optional
        The spacing of the samples to which the filter will be applied.
        This is only used if deriv > 0. Default is 1.0.
    axis : int, optional
        The axis of the array `x` along which the filter is to be applied.
        Default is -1.
    mode : str, optional
        Must be 'mirror', 'constant', 'nearest', 'wrap' or 'interp'. This
        determines the type of extension to use for the padded signal to
        which the filter is applied.  When `mode` is 'constant', the padding
        value is given by `cval`.  See the Notes for more details on 'mirror',
        'constant', 'wrap', and 'nearest'.
        When the 'interp' mode is selected (the default), no extension
        is used.  Instead, a degree `polyorder` polynomial is fit to the
        last `window_length` values of the edges, and this polynomial is
        used to evaluate the last `window_length // 2` output values.
    cval : scalar, optional
        Value to fill past the edges of the input if `mode` is 'constant'.
        Default is 0.0.

    Returns
    -------
    y : ndarray, same shape as `x`
        The filtered data.

    See Also
    --------
    savgol_coeffs

    Notes
    -----
    Details on the `mode` options:

        'mirror':
            Repeats the values at the edges in reverse order. The value
            closest to the edge is not included.
        'nearest':
            The extension contains the nearest input value.
        'constant':
            The extension contains the value given by the `cval` argument.
        'wrap':
            The extension contains the values from the other end of the array.

    For example, if the input is [1, 2, 3, 4, 5, 6, 7, 8], and
    `window_length` is 7, the following shows the extended data for
    the various `mode` options (assuming `cval` is 0)::

        mode       |   Ext   |         Input          |   Ext
        -----------+---------+------------------------+---------
        'mirror'   | 4  3  2 | 1  2  3  4  5  6  7  8 | 7  6  5
        'nearest'  | 1  1  1 | 1  2  3  4  5  6  7  8 | 8  8  8
        'constant' | 0  0  0 | 1  2  3  4  5  6  7  8 | 0  0  0
        'wrap'     | 6  7  8 | 1  2  3  4  5  6  7  8 | 1  2  3

    .. versionadded:: 0.14.0

    Examples
    --------
    >>> import numpy as np
    >>> from scipy.signal import savgol_filter
    >>> np.set_printoptions(precision=2)  # For compact display.
    >>> x = np.array([2, 2, 5, 2, 1, 0, 1, 4, 9])

    Filter with a window length of 5 and a degree 2 polynomial.  Use
    the defaults for all other parameters.

    >>> savgol_filter(x, 5, 2)
    array([1.66, 3.17, 3.54, 2.86, 0.66, 0.17, 1.  , 4.  , 9.  ])

    Note that the last five values in x are samples of a parabola, so
    when mode='interp' (the default) is used with polyorder=2, the last
    three values are unchanged. Compare that to, for example,
    `mode='nearest'`:

    >>> savgol_filter(x, 5, 2, mode='nearest')
    array([1.74, 3.03, 3.54, 2.86, 0.66, 0.17, 1.  , 4.6 , 7.97])

    )mirrorconstantnearestinterpwrapz@mode must be 'mirror', 'constant', 'nearest' 'wrap' or 'interp'.)r   r   rP   zOIf mode is 'interp', window_length must be less than or equal to the size of x.rN   )r7   mode)r7   rR   cval)r   r   asarrayr   float64float32astyper$   r9   r   rK   )
r   r   r   r   r   r7   rR   rS   r   r!   s
             r#   savgol_filterrX      s    L FF / 0 	0 	

1Aww"**BJJ!6HHRZZ =)5NFx1774=( ? @ @ q&t*=1mYudAN
 H q&t$TBHr%   )r         ?Nr
   )r   rY   r   rP   g        )numpyr   scipy.linalgr   scipy._lib._utilr   scipy.ndimager   _arraytoolsr   r$   r3   rI   rK   rX    r%   r#   <module>r`      sD      , $ # EIHV0)X* ?B/2r%   