
    xf S                        d dl mZmZmZmZmZmZmZmZm	Z	m
Z
mZ d dlmZmZmZmZmZmZmZmZmZ d dl ZddlmZmZ d dlmZ d dlmZ d dlmZ g d	Z d d
Z!i Z"d Z#dZ$ ejJ                  e$      d        Z&d Z'dZ( ejJ                  e(      d        Z)d Z*dZ+ ejJ                  e+      d        Z,d Z-d Z.d Z/d Z0d Z1d Z2d Z3d!dZ4d!dZ5d"dZ6d"dZ7y)#    )logical_andasarraypi
zeros_like	piecewisearrayarctan2tanzerosarangefloor)	sqrtexpgreaterlesscosaddsin
less_equalgreater_equalN   )	cspline2dsepfir2d)comb)float_factorial)BSpline)	spline_filterbsplinegauss_splinecubic	quadratic	cspline1d	qspline1dcspline1d_evalqspline1d_evalc                    | j                   j                  }t        g dd      dz  }|dv rp| j                  d      } t	        | j
                  |      }t	        | j                  |      }t        |||      }t        |||      }|d|z  z   j                  |      }|S |dv r,t	        | |      }t        |||      }|j                  |      }|S t        d      )	a3  Smoothing spline (cubic) filtering of a rank-2 array.

    Filter an input data set, `Iin`, using a (cubic) smoothing spline of
    fall-off `lmbda`.

    Parameters
    ----------
    Iin : array_like
        input data set
    lmbda : float, optional
        spline smooghing fall-off value, default is `5.0`.

    Returns
    -------
    res : ndarray
        filterd input data

    Examples
    --------
    We can filter an multi dimentional signal (ex: 2D image) using cubic
    B-spline filter:

    >>> import numpy as np
    >>> from scipy.signal import spline_filter
    >>> import matplotlib.pyplot as plt
    >>> orig_img = np.eye(20)  # create an image
    >>> orig_img[10, :] = 1.0
    >>> sp_filter = spline_filter(orig_img, lmbda=0.1)
    >>> f, ax = plt.subplots(1, 2, sharex=True)
    >>> for ind, data in enumerate([[orig_img, "original image"],
    ...                             [sp_filter, "spline filter"]]):
    ...     ax[ind].imshow(data[0], cmap='gray_r')
    ...     ax[ind].set_title(data[1])
    >>> plt.tight_layout()
    >>> plt.show()

    )      ?g      @r'   f      @)FDr*   y              ?)r(   dzInvalid data type for Iin)	dtypecharr   astyper   realimagr   	TypeError)	Iinlmbdaintypehcolckrckioutroutiouts	            8/usr/lib/python3/dist-packages/scipy/signal/_bsplines.pyr   r      s    L YY^^F#&,Djjo%(%(T4(T4(b4i''/ J 
:	U#sD$'jj  J 344    c           	         	
 	 t             S # t        $ r Y nw xY wd } dz  dz   } dz  rd}nd} |dd|      g}|	t        d|dz
        D ]#  }|j                   |d		dz
               	dz
  	% |j                   |dd dz    dz               t	               
	
 fd}t        |      D cg c]
  } ||       nc c}w }}||ft          <   ||fS )	a  Returns the function defined over the left-side pieces for a bspline of
    a given order.

    The 0th piece is the first one less than 0. The last piece is a function
    identical to 0 (returned as the constant 0). (There are order//2 + 2 total
    pieces).

    Also returns the condition functions that when evaluated return boolean
    arrays for use with `numpy.piecewise`.
    c                 <    | dk(  rfdS | dk(  rfdS fdS )Nr   c                 D    t        t        |       t        |             S N)r   r   r   xval1val2s    r<   <lambda>z>_bspline_piecefunctions.<locals>.condfuncgen.<locals>.<lambda>_   s     [At)<)6q$)?A r=      c                     t        |       S rA   )r   )rC   rE   s    r<   rF   z>_bspline_piecefunctions.<locals>.condfuncgen.<locals>.<lambda>b   s    Z40 r=   c                 D    t        t        |       t        |             S rA   )r   r   r   rB   s    r<   rF   z>_bspline_piecefunctions.<locals>.condfuncgen.<locals>.<lambda>d   s    [a)6q$)?A r=    )numrD   rE   s    ``r<   condfuncgenz,_bspline_piecefunctions.<locals>.condfuncgen]   s/    !8A AAX00A Ar=   rG   g            r   r          @c                    dz  | z
  dk  ryt        dz         D cg c]+  }dd|dz  z  z
  t        t        dz   |d            z  z  - c}t        dz         D cg c]  } |z
  
 c}fd}|S c c}w c c}w )NrG   r   r   )exactc                 Z    d}t        dz         D ]  }||   | |   z   z  z  z  } |S )N        r   )range)rC   reskMkcoeffsordershiftss      r<   thefuncz>_bspline_piecefunctions.<locals>.piecefuncgen.<locals>.thefunc   sD    C26] <vayAq	Me#;;;<Jr=   )rS   floatr   )	rK   rU   rZ   rV   rW   rY   boundfvalrX   s	      @@@r<   piecefuncgenz-_bspline_piecefunctions.<locals>.piecefuncgen{   s    aZ#F a=* qAE{?eDAQ,G&HH4O *&+BFm45&1*4	
 *4s   0B &B)_splinefunc_cacheKeyErrorrS   appendr   )rX   rL   last
startbound	condfuncsrK   r^   rU   funclistr\   r]   s   `        @@r<   _bspline_piecefunctionsrf   M   s    '' A A:>Dqy

Q:./IEQq! Quqy9:	 [A|c'9:; 5!D */t5AQ55H5 ()4eYs    	3Ca5  `scipy.signal.bspline` is deprecated in SciPy 1.11 and will be
removed in SciPy 1.13.

The exact equivalent (for a float array `x`) is

>>> from scipy.interpolate import BSpline
>>> knots = np.arange(-(n+1)/2, (n+3)/2)
>>> out = BSpline.basis_element(knots)(x)
>>> out[(x < knots[0]) | (x > knots[-1])] = 0.0
)messagec                     t        t        | t                     }t        |      \  }}|D cg c]
  } ||       }}t	        |||      S c c}w )aw  B-spline basis function of order n.

    Parameters
    ----------
    x : array_like
        a knot vector
    n : int
        The order of the spline. Must be non-negative, i.e., n >= 0

    Returns
    -------
    res : ndarray
        B-spline basis function values

    See Also
    --------
    cubic : A cubic B-spline.
    quadratic : A quadratic B-spline.

    Notes
    -----
    Uses numpy.piecewise and automatic function-generator.

    Examples
    --------
    We can calculate B-Spline basis function of several orders:

    >>> import numpy as np
    >>> from scipy.signal import bspline, cubic, quadratic
    >>> bspline(0.0, 1)
    1

    >>> knots = [-1.0, 0.0, -1.0]
    >>> bspline(knots, 2)
    array([0.125, 0.75, 0.125])

    >>> np.array_equal(bspline(knots, 2), quadratic(knots))
    True

    >>> np.array_equal(bspline(knots, 3), cubic(knots))
    True

    r-   )absr   r[   rf   r   )rC   naxre   rd   funccondlists          r<   r   r      sS    Z gau%
&	&B1!4Hi%./TR/H/R8,, 0s   Ac                     t        |       } |dz   dz  }dt        dt        z  |z        z  t        | dz   dz  |z        z  S )a  Gaussian approximation to B-spline basis function of order n.

    Parameters
    ----------
    x : array_like
        a knot vector
    n : int
        The order of the spline. Must be non-negative, i.e., n >= 0

    Returns
    -------
    res : ndarray
        B-spline basis function values approximated by a zero-mean Gaussian
        function.

    Notes
    -----
    The B-spline basis function can be approximated well by a zero-mean
    Gaussian function with standard-deviation equal to :math:`\sigma=(n+1)/12`
    for large `n` :

    .. math::  \frac{1}{\sqrt {2\pi\sigma^2}}exp(-\frac{x^2}{2\sigma})

    References
    ----------
    .. [1] Bouma H., Vilanova A., Bescos J.O., ter Haar Romeny B.M., Gerritsen
       F.A. (2007) Fast and Accurate Gaussian Derivatives Based on B-Splines. In:
       Sgallari F., Murli A., Paragios N. (eds) Scale Space and Variational
       Methods in Computer Vision. SSVM 2007. Lecture Notes in Computer
       Science, vol 4485. Springer, Berlin, Heidelberg
    .. [2] http://folk.uio.no/inf3330/scripting/doc/python/SciPy/tutorial/old/node24.html

    Examples
    --------
    We can calculate B-Spline basis functions approximated by a gaussian
    distribution:

    >>> import numpy as np
    >>> from scipy.signal import gauss_spline, bspline
    >>> knots = np.array([-1.0, 0.0, -1.0])
    >>> gauss_spline(knots, 3)
    array([0.15418033, 0.6909883, 0.15418033])  # may vary

    >>> bspline(knots, 3)
    array([0.16666667, 0.66666667, 0.16666667])  # may vary

    r   g      (@rG   )r   r   r   r   )rC   rk   signsqs      r<   r   r      sL    ` 	
A!et^FtAFVO$$sAF7Q;+?'@@@r=   a  `scipy.signal.cubic` is deprecated in SciPy 1.11 and will be
removed in SciPy 1.13.

The exact equivalent (for a float array `x`) is

>>> from scipy.interpolate import BSpline
>>> out = BSpline.basis_element([-2, -1, 0, 1, 2])(x)
>>> out[(x < -2 | (x > 2)] = 0.0
c                     t        t        | t                    }t        |      }t	        |d      }|j                         r||   }dd|dz  z  d|z
  z  z
  ||<   | t	        |d      z  }|j                         r||   }dd|z
  dz  z  ||<   |S )a-  A cubic B-spline.

    This is a special case of `bspline`, and equivalent to ``bspline(x, 3)``.

    Parameters
    ----------
    x : array_like
        a knot vector

    Returns
    -------
    res : ndarray
        Cubic B-spline basis function values

    See Also
    --------
    bspline : B-spline basis function of order n
    quadratic : A quadratic B-spline.

    Examples
    --------
    We can calculate B-Spline basis function of several orders:

    >>> import numpy as np
    >>> from scipy.signal import bspline, cubic, quadratic
    >>> bspline(0.0, 1)
    1

    >>> knots = [-1.0, 0.0, -1.0]
    >>> bspline(knots, 2)
    array([0.125, 0.75, 0.125])

    >>> np.array_equal(bspline(knots, 2), quadratic(knots))
    True

    >>> np.array_equal(bspline(knots, 3), cubic(knots))
    True

    ri   r   gUUUUUU?      ?rG   gUUUUUU?   rj   r   r[   r   r   anyrC   rl   rT   cond1ax1cond2ax2s          r<   r    r      s    R 
WQe$	%B
R.CQKEyy{iw1QW==E
FT"a[ Eyy{iCA~-E
Jr=   c                     t        | t              } t        j                  g dd      } ||       }d|| dk  | dkD  z  <   |S )Nri   )r   r   rG   Fextrapolater   r|   rG   )r   r[   r   basis_elementrC   br;   s      r<   _cubicr   F  sF    A/UCA
A$CCRAEJr=   a  `scipy.signal.quadratic` is deprecated in SciPy 1.11 and
will be removed in SciPy 1.13.

The exact equivalent (for a float array `x`) is

>>> from scipy.interpolate import BSpline
>>> out = BSpline.basis_element([-1.5, -0.5, 0.5, 1.5])(x)
>>> out[(x < -1.5 | (x > 1.5)] = 0.0
c                    t        t        | t                    }t        |      }t	        |d      }|j                         r||   }d|dz  z
  ||<   | t	        |d      z  }|j                         r||   }|dz
  dz  dz  ||<   |S )a-  A quadratic B-spline.

    This is a special case of `bspline`, and equivalent to ``bspline(x, 2)``.

    Parameters
    ----------
    x : array_like
        a knot vector

    Returns
    -------
    res : ndarray
        Quadratic B-spline basis function values

    See Also
    --------
    bspline : B-spline basis function of order n
    cubic : A cubic B-spline.

    Examples
    --------
    We can calculate B-Spline basis function of several orders:

    >>> import numpy as np
    >>> from scipy.signal import bspline, cubic, quadratic
    >>> bspline(0.0, 1)
    1

    >>> knots = [-1.0, 0.0, -1.0]
    >>> bspline(knots, 2)
    array([0.125, 0.75, 0.125])

    >>> np.array_equal(bspline(knots, 2), quadratic(knots))
    True

    >>> np.array_equal(bspline(knots, 3), cubic(knots))
    True

    ri   rr   g      ?rG         ?rN   rt   rv   s          r<   r!   r!   Y  s    R 
WQe$	%B
R.CSMEyy{iC1H_E
FT"c]"Eyy{iCiA%+E
Jr=   c                     t        t        | t                    } t        j                  g dd      } ||       }d|| dk  | dkD  z  <   |S )Nri   )      rM   rr   r   Fr~   r   r   r   )rj   r   r[   r   r   r   s      r<   
_quadraticr     sK    GAU#$A4%HA
A$C"#CTa#gJr=   c           
         dd| z  z
  d| z  t        dd| z  z         z  z   }t        t        d| z  dz
        t        |            }d| z  dz
  t        |      z
  d| z  z  }|t        d| z  d| z  t        dd| z  z         z  z   |z        z  }||fS )Nr   `      rs      0   )r   r	   )lamxiomegrhos       r<   _coeff_smoothr     s    	
R#XS4C#I#66	6B4c	A&R1D8a<$r("rCx
0C
b3hcDS3Y,?!??2EF
FC9r=   c                 h    |t        |      z  || z  z  t        || dz   z        z  t        | d      z  S )Nr   r}   )r   r   )rU   csr   omegas       r<   _hcr     s;    UOsax(3uA+??ArN r=   c                    ||z  d||z  z   z  d||z  z
  z  dd|z  |z  t        d|z        z  z
  |dz  z   z  }d||z  z
  d||z  z   z  t        |      z  }t        |       }|||z  z  t        ||z        |t        ||z        z  z   z  S )Nr   rG      )r   r
   rj   r   )rU   r   r   r   c0gammaaks          r<   _hsr     s    
r'Qs]
#q39}
5q3w}s1u9~--q8:Bs]q39}-E
:E	QBr	>S_us52:/FFGGr=   c           	      Z   t        |      \  }}dd|z  t        |      z  z
  ||z  z   }t        |       }t        |f| j                  j
                        }t        |      }t        d|||      | d   z  t        j                  t        |dz   |||      | z        z   |d<   t        d|||      | d   z  t        d|||      | d   z  z   t        j                  t        |dz   |||      | z        z   |d<   t        d|      D ]7  }|| |   z  d|z  t        |      z  ||dz
     z  z   ||z  ||dz
     z  z
  ||<   9 t        |f| j                  j
                        }	t        j                  t        ||||      t        |dz   |||      z   | d d d   z        |	|dz
  <   t        j                  t        |dz
  |||      t        |dz   |||      z   | d d d   z        |	|dz
  <   t        |dz
  dd      D ]7  }|||   z  d|z  t        |      z  |	|dz      z  z   ||z  |	|dz      z  z
  |	|<   9 |	S )Nr   rG   r   r}   rs   )r   r   lenr   r-   r.   r   r   r   reducerS   r   )
signallambr   r   r   KyprU   rk   ys
             r<   _cubic_smooth_coeffr     s   t$JC	
QWs5z!	!C#I	-BFA	tV\\&&	'Bq	ABU#fQi/ZZAE2sE2V;<=BqE BU#fQi/BU#fQi/0ZZAE2sE2V;<=BqE 1a[ (fQi!c'CJ"6AE"BBsRAY&'1( 	qdFLL%%&Azz3q"c51q1ub#u569?"F GAa!eHzz3q1ub#u5q1ub#u569?"F GAa!eH 1q5"b! &RU
QWs5z1Aa!eH<<c	Aa!eH$%!& Hr=   c                    dt        d      z   }t        |       }t        |f| j                  j                        }|t        |      z  }| d   |t        j                  || z        z  z   |d<   t        d|      D ]  }| |   |||dz
     z  z   ||<    t        |f| j                        }||dz
  z  ||dz
     z  ||dz
  <   t        |dz
  dd      D ]  }|||dz      ||   z
  z  ||<    |dz  S )Nr|   rs   r   r   rG   r}   r)   	r   r   r   r-   r.   r   r   r   rS   r   zir   ypluspowersrU   outputs          r<   _cubic_coeffr     s   	d1gBFA1$))*E6!9_Fay2

6F? ;;;E!H1a[ 1!9rE!a%L00a1A4&F"q&ME!a%L0F1q5M1q5"b! 4&Q-%(23q	4C<r=   c                    ddt        d      z  z   }t        |       }t        |f| j                  j                        }|t        |      z  }| d   |t        j                  || z        z  z   |d<   t        d|      D ]  }| |   |||dz
     z  z   ||<    t        |f| j                  j                        }||dz
  z  ||dz
     z  ||dz
  <   t        |dz
  dd      D ]  }|||dz      ||   z
  z  ||<    |dz  S )NrG   rN   r   r   r}   g       @r   r   s          r<   _quadratic_coeffr     s   	a$s)m	BFA1$))*E6!9_Fay2

6F? ;;;E!H1a[ 1!9rE!a%L00a1A4**+F"q&ME!a%L0F1q5M1q5"b! 4&Q-%(23q	4C<r=   c                 :    |dk7  rt        | |      S t        |       S )a  
    Compute cubic spline coefficients for rank-1 array.

    Find the cubic spline coefficients for a 1-D signal assuming
    mirror-symmetric boundary conditions. To obtain the signal back from the
    spline representation mirror-symmetric-convolve these coefficients with a
    length 3 FIR window [1.0, 4.0, 1.0]/ 6.0 .

    Parameters
    ----------
    signal : ndarray
        A rank-1 array representing samples of a signal.
    lamb : float, optional
        Smoothing coefficient, default is 0.0.

    Returns
    -------
    c : ndarray
        Cubic spline coefficients.

    See Also
    --------
    cspline1d_eval : Evaluate a cubic spline at the new set of points.

    Examples
    --------
    We can filter a signal to reduce and smooth out high-frequency noise with
    a cubic spline:

    >>> import numpy as np
    >>> import matplotlib.pyplot as plt
    >>> from scipy.signal import cspline1d, cspline1d_eval
    >>> rng = np.random.default_rng()
    >>> sig = np.repeat([0., 1., 0.], 100)
    >>> sig += rng.standard_normal(len(sig))*0.05  # add noise
    >>> time = np.linspace(0, len(sig))
    >>> filtered = cspline1d_eval(cspline1d(sig), time)
    >>> plt.plot(sig, label="signal")
    >>> plt.plot(time, filtered, label="filtered")
    >>> plt.legend()
    >>> plt.show()

    rR   )r   r   r   r   s     r<   r"   r"     s$    X s{"6400F##r=   c                 8    |dk7  rt        d      t        |       S )aF  Compute quadratic spline coefficients for rank-1 array.

    Parameters
    ----------
    signal : ndarray
        A rank-1 array representing samples of a signal.
    lamb : float, optional
        Smoothing coefficient (must be zero for now).

    Returns
    -------
    c : ndarray
        Quadratic spline coefficients.

    See Also
    --------
    qspline1d_eval : Evaluate a quadratic spline at the new set of points.

    Notes
    -----
    Find the quadratic spline coefficients for a 1-D signal assuming
    mirror-symmetric boundary conditions. To obtain the signal back from the
    spline representation mirror-symmetric-convolve these coefficients with a
    length 3 FIR window [1.0, 6.0, 1.0]/ 8.0 .

    Examples
    --------
    We can filter a signal to reduce and smooth out high-frequency noise with
    a quadratic spline:

    >>> import numpy as np
    >>> import matplotlib.pyplot as plt
    >>> from scipy.signal import qspline1d, qspline1d_eval
    >>> rng = np.random.default_rng()
    >>> sig = np.repeat([0., 1., 0.], 100)
    >>> sig += rng.standard_normal(len(sig))*0.05  # add noise
    >>> time = np.linspace(0, len(sig))
    >>> filtered = qspline1d_eval(qspline1d(sig), time)
    >>> plt.plot(sig, label="signal")
    >>> plt.plot(time, filtered, label="filtered")
    >>> plt.legend()
    >>> plt.show()

    rR   z.Smoothing quadratic splines not supported yet.)
ValueErrorr   r   s     r<   r#   r#     s#    Z s{IJJ''r=   c                 P   t        |      |z
  t        |      z  }t        || j                        }|j                  dk(  r|S t        |       }|dk  }||dz
  kD  }||z   }t        | ||          ||<   t        | d|dz
  z  ||   z
        ||<   ||   }|j                  dk(  r|S t        || j                        }	t        |dz
        j                  t              dz   }
t        d      D ]3  }|
|z   }|j                  d|dz
        }|	| |   t        ||z
        z  z  }	5 |	||<   |S )a  Evaluate a cubic spline at the new set of points.

    `dx` is the old sample-spacing while `x0` was the old origin. In
    other-words the old-sample points (knot-points) for which the `cj`
    represent spline coefficients were at equally-spaced points of:

      oldx = x0 + j*dx  j=0...N-1, with N=len(cj)

    Edges are handled using mirror-symmetric boundary conditions.

    Parameters
    ----------
    cj : ndarray
        cublic spline coefficients
    newx : ndarray
        New set of points.
    dx : float, optional
        Old sample-spacing, the default value is 1.0.
    x0 : int, optional
        Old origin, the default value is 0.

    Returns
    -------
    res : ndarray
        Evaluated a cubic spline points.

    See Also
    --------
    cspline1d : Compute cubic spline coefficients for rank-1 array.

    Examples
    --------
    We can filter a signal to reduce and smooth out high-frequency noise with
    a cubic spline:

    >>> import numpy as np
    >>> import matplotlib.pyplot as plt
    >>> from scipy.signal import cspline1d, cspline1d_eval
    >>> rng = np.random.default_rng()
    >>> sig = np.repeat([0., 1., 0.], 100)
    >>> sig += rng.standard_normal(len(sig))*0.05  # add noise
    >>> time = np.linspace(0, len(sig))
    >>> filtered = cspline1d_eval(cspline1d(sig), time)
    >>> plt.plot(sig, label="signal")
    >>> plt.plot(time, filtered, label="filtered")
    >>> plt.legend()
    >>> plt.show()

    ri   r   r   rG   r   )r   r[   r   r-   sizer   r$   r   r/   intrS   clipr   cjnewxdxx0rT   Nrw   ry   cond3resultjlowerithisjindjs                 r<   r$   r$   N  s@   d DMB%)+D
T
*C
xx1}
BA1HEAENEemET%[L1CJAQK$u+$=>CJ;DyyA~
BHH-F4!8_##C(1,F1X 2
zz!QU#"T(VD5L1112 CJJr=   c                    t        |      |z
  |z  }t        |      }|j                  dk(  r|S t        |       }|dk  }||dz
  kD  }||z   }t	        | ||          ||<   t	        | d|dz
  z  ||   z
        ||<   ||   }|j                  dk(  r|S t        |      }	t        |dz
        j                  t              dz   }
t        d      D ]3  }|
|z   }|j                  d|dz
        }|	| |   t        ||z
        z  z  }	5 |	||<   |S )a  Evaluate a quadratic spline at the new set of points.

    Parameters
    ----------
    cj : ndarray
        Quadratic spline coefficients
    newx : ndarray
        New set of points.
    dx : float, optional
        Old sample-spacing, the default value is 1.0.
    x0 : int, optional
        Old origin, the default value is 0.

    Returns
    -------
    res : ndarray
        Evaluated a quadratic spline points.

    See Also
    --------
    qspline1d : Compute quadratic spline coefficients for rank-1 array.

    Notes
    -----
    `dx` is the old sample-spacing while `x0` was the old origin. In
    other-words the old-sample points (knot-points) for which the `cj`
    represent spline coefficients were at equally-spaced points of::

      oldx = x0 + j*dx  j=0...N-1, with N=len(cj)

    Edges are handled using mirror-symmetric boundary conditions.

    Examples
    --------
    We can filter a signal to reduce and smooth out high-frequency noise with
    a quadratic spline:

    >>> import numpy as np
    >>> import matplotlib.pyplot as plt
    >>> from scipy.signal import qspline1d, qspline1d_eval
    >>> rng = np.random.default_rng()
    >>> sig = np.repeat([0., 1., 0.], 100)
    >>> sig += rng.standard_normal(len(sig))*0.05  # add noise
    >>> time = np.linspace(0, len(sig))
    >>> filtered = qspline1d_eval(qspline1d(sig), time)
    >>> plt.plot(sig, label="signal")
    >>> plt.plot(time, filtered, label="filtered")
    >>> plt.legend()
    >>> plt.show()

    r   r   rG   r   rs   )r   r   r   r   r%   r   r/   r   rS   r   r   r   s                 r<   r%   r%     s1   h DMB"$D
T
C
xx1}
BA1HEAENEemET%[L1CJAQK$u+$=>CJ;DyyA~
F4#:%%c*Q.F1X 6
zz!QU#"T(Zu5556 CJJr=   )g      @)rR   )r'   r   )8numpyr   r   r   r   r   r   r	   r
   r   r   r   numpy.core.umathr   r   r   r   r   r   r   r   r   np_spliner   r   scipy.specialr   scipy._lib._utilr   scipy.interpolater   __all__r   r_   rf   msg_bspline	deprecater   r   	msg_cubicr    r   msg_quadraticr!   r   r   r   r   r   r   r   r"   r#   r$   r%   rJ   r=   r<   <module>r      s  I I I I9 9 9  )  , %I5p  AH	 k"0- #0-d2Aj	 i 2 !2j m$2 %2j
H>/$d0(fGTIr=   