← Back
Editing: _savitzky_golay.cpython-311.pyc
� d�ci4 � �h � d dl Zd dlmZ d dlmZ d dlmZ ddlm Z dd �Z d � Z d � Z d � Z dd�ZdS )� N)�lstsq)�float_factorial)� convolve1d� )� axis_slice� �?�convc �Z � || k rt d� � �t | d� � \ }}|�|dk r|dz }n|}d|cxk r| k sn t d� � �|dvrt d� � �||k rt j | � � }|S t j | | |z t � � � } |d k r | ddd � } t j |d z � � � 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.)r �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 �>/usr/lib/python3/dist-packages/scipy/signal/_savitzky_golay.py� savgol_coeffsr% sq � �x �M�!�!��E�F�F�F��-��+�+�L�G�S� �{� �!�8�8��C�-�C�C��C� �� $� $� $� $�}� $� $� $� $�� *� +� +� +� �/�!�!��8�9�9�9� �y�����-�(�(��� � � �3�$� ��+�5�9�9�9�A� �f�}�}� �d�d��d�G�� �I�i�!�m� $� $� ,� ,�R�� 3� 3�E� �U� �A� ���Q� � � �A� �u�%�%��%� �8�A�e�H� �A�q�k�k�O�F�A�q�!� �M� c �z � |dk r| }n�t | � � }||k r t j | dd�df � � }n}| d| � � � � }t |� � D ]N}t j ||z dz ||z dz d� � }||� ||z fd| j dz z z � � z }�O|}|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$ �_polyderr4 � s� � � �A�v�v���� ��F�F�� ��6�6��]�1�R�a�R��W�:�.�.�F�F��3�Q�B�3���� � �B��1�X�X� B� B���i��A��� �1�q�5�1�9�b�9�9���c�k�k�1�q�5�(�T�Q�V�a�Z�-@�"@�A�A�A����F� �Mr& c �� � t | |||�� � } |dk s || j k r| } d} n| � |d� � } d} | � | j d d� � } t j t j d||z � � | |� � } |dk rt | |� � } t j ||z ||z � � }t j | |� dd� � � � ||z z }t | j � � }|| |d c|d< ||< |j ||z g|dd� �R � }| r|� d|� � }t | |||�� � }||d< dS ) 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 r4 �polyval�list)r � window_start� window_stop� interp_start� interp_stopr8 r r r r" �x_edge�xx_edge�swapped� poly_coeffs�i�values�shp�y_edges r$ � _fit_edgerJ � s� � � �� �K�d� K� K� K�F� �q�y�y�D�Q�V�G�O�O�������/�/�$��*�*�����o�o�g�m�A� .��3�3�G� �*�R�Y�q�+� �*D� E� E� $�i�1� 1�K� �q�y�y� �{�E�2�2� � � �,� �-�{�\�/I�J�J�A� �Z� �Q�Y�Y�r�1�%5�%5� 6� 6�%�5�.� I�F� �q�w�-�-�C��D� �3�q�6��C��F�C��I� �V�^�K�,� 6� A��Q�R�R�� A� A� A�F�� *�� � ��D�)�)�� �� �K�d� K� K� K�F��F�3�K�K�Kr& c � � |dz }t | d|d||||||� � | j | }t | ||z |||z ||||||� � dS )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)rJ r: ) r r r r r r8 r" r r0 s r$ �_fit_edges_polyfitrL � sz � � �q� �G� �a��M�1�g�t����q�*� *� *� ��� �A� �a��]�"�A�q�7�{�A�t����q�*� *� *� *� *r& r �interp� c �� � |dvrt d� � �t j | � � } | j t j k r4| j t j k r | � t j � � } t ||||�� � }|dk rI|| j | k rt d� � �t | ||d�� � } t | |||||| � � nt | ||||�� � } | 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�nearestrM �wrapz@mode must be 'mirror', 'constant', 'nearest' 'wrap' or 'interp'.)r r rM zOIf mode is 'interp', window_length must be less than or equal to the size of x.rQ )r8 �mode)r8 rT �cval) r r �asarrayr �float64�float32�astyper% r: r rL ) r r r r r r8 rT rU r r" s r$ � savgol_filterrZ � s � �L �F�F�F�� /� 0� 0� 0� � �1� � �A��w�"�*� � ���B�J�!6�!6� �H�H�R�Z� � �� �=�)�5�� N� N� N�F� �x��� �1�7�4�=� (� (� � ?� @� @� @� �q�&�t�*� =� =� =���1�m�Y��u�d�A�N�N�N�N� �q�&�t�$�T� B� B� B�� �Hr& )r r Nr )r r r rM rN )�numpyr � scipy.linalgr �scipy._lib._utilr � scipy.ndimager � _arraytoolsr r% r4 rJ rL rZ � r& r$ �<module>ra s� �� � � � � � � � � � � ,� ,� ,� ,� ,� ,� $� $� $� $� $� $� #� #� #� #� #� #� EI� �H� H� H� H�V� � �0)� )� )�X *� *� *� ?B�/2� � � � � � r&
Save File
Cancel