403WebShell

403Webshell
Server IP : 35.80.110.71 / Your IP : 216.73.216.221
Web Server : Apache/2.4.58 (Ubuntu)
System : Linux ip-172-31-21-44 6.17.0-1019-aws #19~24.04.1-Ubuntu SMP Tue Jun 23 18:53:06 UTC 2026 x86_64
User : ubuntu ( 1000)
PHP Version : 8.3.31
Disable Function : NONE
MySQL : OFF | cURL : ON | WGET : ON | Perl : ON | Python : OFF | Sudo : ON | Pkexec : OFF
Directory : /lib/python3/dist-packages/scipy/interpolate/__pycache__/
Upload File :
[ Back ]
Current File : /lib/python3/dist-packages/scipy/interpolate/__pycache__/_cubic.cpython-312.pyc
�

x�f�����dZddlZddlmZddlmZddlmZm	Z	gd�Z
dd�ZGd	�d
e�ZGd�de�Z
dd
�ZGd�de�ZGd�de�Zy)z;Interpolation algorithms using piecewise cubic polynomials.�N�)�PPoly)�	_isscalar)�solve_banded�solve)�CubicHermiteSpline�PchipInterpolator�pchip_interpolate�Akima1DInterpolator�CubicSplinec��ttj||f�\}}tj|jtj
�rt
d��|jt�}tj|jtj
�rt}nt}|��tj|�}|j|jk7rt
d��tj|jtj
�rt}|j|d��}|j|d��}||jz}|jdk7rt
d��|jddkrt
d	��|jd|j|k7rt
d
j|���tjtj|��st
d��tjtj|��st
d��|�3tjtj|��st
d
��tj|�}tj |dk�rt
d��tj"||d�}|�tj"||d�}|||||fS)a Prepare input for cubic spline interpolators.

    All data are converted to numpy arrays and checked for correctness.
    Axes equal to `axis` of arrays `y` and `dydx` are moved to be the 0th
    axis. The value of `axis` is converted to lie in
    [0, number of dimensions of `y`).
    z`x` must contain real values.z/The shapes of `y` and `dydx` must be identical.F��copyrz`x` must be 1-dimensional.r�z%`x` must contain at least 2 elements.zAThe length of `y` along `axis`={} doesn't match the length of `x`z$`x` must contain only finite values.z$`y` must contain only finite values.z'`dydx` must contain only finite values.z)`x` must be strictly increasing sequence.)�map�np�asarray�
issubdtype�dtype�complexfloating�
ValueError�astype�float�complex�shape�ndim�format�all�isfinite�diff�any�moveaxis)�x�y�axis�dydxr�dxs      �:/usr/lib/python3/dist-packages/scipy/interpolate/_cubic.py�
prepare_inputr)s���r�z�z�A�q�6�"�D�A�q�	�}�}�Q�W�W�b�0�0�1��8�9�9�	�����A�	�}�}�Q�W�W�b�0�0�1��������z�z�$����7�7�d�j�j� ��N�O�O�
�=�=����R�%7�%7�8��E��{�{�5�u�{�-��	����U��#�A��!�&�&�=�D��v�v��{��5�6�6��w�w�q�z�A�~��@�A�A��w�w�q�z�Q�W�W�T�]�"��3�39�6�$�<�A�	A��6�6�"�+�+�a�.�!��?�@�@�
�6�6�"�+�+�a�.�!��?�@�@������r�{�{�4�'8� 9��B�C�C�	�����B�	�v�v�b�A�g���D�E�E�
���A�t�Q��A����{�{�4��q�)���b�!�T�4���c�$��eZdZdZd�fd�	Z�xZS)ra�	Piecewise-cubic interpolator matching values and first derivatives.

    The result is represented as a `PPoly` instance.

    Parameters
    ----------
    x : array_like, shape (n,)
        1-D array containing values of the independent variable.
        Values must be real, finite and in strictly increasing order.
    y : array_like
        Array containing values of the dependent variable. It can have
        arbitrary number of dimensions, but the length along ``axis``
        (see below) must match the length of ``x``. Values must be finite.
    dydx : array_like
        Array containing derivatives of the dependent variable. It can have
        arbitrary number of dimensions, but the length along ``axis``
        (see below) must match the length of ``x``. Values must be finite.
    axis : int, optional
        Axis along which `y` is assumed to be varying. Meaning that for
        ``x[i]`` the corresponding values are ``np.take(y, i, axis=axis)``.
        Default is 0.
    extrapolate : {bool, 'periodic', None}, optional
        If bool, determines whether to extrapolate to out-of-bounds points
        based on first and last intervals, or to return NaNs. If 'periodic',
        periodic extrapolation is used. If None (default), it is set to True.

    Attributes
    ----------
    x : ndarray, shape (n,)
        Breakpoints. The same ``x`` which was passed to the constructor.
    c : ndarray, shape (4, n-1, ...)
        Coefficients of the polynomials on each segment. The trailing
        dimensions match the dimensions of `y`, excluding ``axis``.
        For example, if `y` is 1-D, then ``c[k, i]`` is a coefficient for
        ``(x-x[i])**(3-k)`` on the segment between ``x[i]`` and ``x[i+1]``.
    axis : int
        Interpolation axis. The same axis which was passed to the
        constructor.

    Methods
    -------
    __call__
    derivative
    antiderivative
    integrate
    roots

    See Also
    --------
    Akima1DInterpolator : Akima 1D interpolator.
    PchipInterpolator : PCHIP 1-D monotonic cubic interpolator.
    CubicSpline : Cubic spline data interpolator.
    PPoly : Piecewise polynomial in terms of coefficients and breakpoints

    Notes
    -----
    If you want to create a higher-order spline matching higher-order
    derivatives, use `BPoly.from_derivatives`.

    References
    ----------
    .. [1] `Cubic Hermite spline
            <https://en.wikipedia.org/wiki/Cubic_Hermite_spline>`_
            on Wikipedia.
    c���|�d}t||||�\}}}}}|j|jdgdg|jdz
zz�}t	j
|d��|z}|dd|ddzd|zz
|z}	t	jdt|�dz
f|jddz|	j��}
|	|z|
d<||ddz
|z|	z
|
d<|dd|
d<|dd|
d	<t�|�)|
||�
�||_y)NTrr�r%���r��r�)�extrapolate)r)�reshaperrrr �empty�lenr�super�__init__r%)�selfr#r$r&r%r2r'�dxr�slope�t�c�	__class__s           �r(r7zCubicHermiteSpline.__init__�s!������K�,�Q��4��>���2�q�$���j�j�"�(�(�1�+��!������
�);�;�<�������"�S�(��
�#�2�Y��a�b��
!�A��I�
-��4���H�H�a��Q��!��_�q�w�w�q�r�{�2�!�'�'�B���3�w��!����S�b�	�!�S�(�1�,��!���C�R�y��!����"�v��!��
����A�;��7���	r*�rN)�__name__�
__module__�__qualname__�__doc__r7�
__classcell__�r=s@r(rrFs���@�D�r*rc�D��eZdZdZd�fd�	Zed��Zed��Z�xZS)r	aK
PCHIP 1-D monotonic cubic interpolation.

    ``x`` and ``y`` are arrays of values used to approximate some function f,
    with ``y = f(x)``. The interpolant uses monotonic cubic splines
    to find the value of new points. (PCHIP stands for Piecewise Cubic
    Hermite Interpolating Polynomial).

    Parameters
    ----------
    x : ndarray, shape (npoints, )
        A 1-D array of monotonically increasing real values. ``x`` cannot
        include duplicate values (otherwise f is overspecified)
    y : ndarray, shape (..., npoints, ...)
        A N-D array of real values. ``y``'s length along the interpolation
        axis must be equal to the length of ``x``. Use the ``axis``
        parameter to select the interpolation axis.
    axis : int, optional
        Axis in the ``y`` array corresponding to the x-coordinate values. Defaults
        to ``axis=0``.
    extrapolate : bool, optional
        Whether to extrapolate to out-of-bounds points based on first
        and last intervals, or to return NaNs.

    Methods
    -------
    __call__
    derivative
    antiderivative
    roots

    See Also
    --------
    CubicHermiteSpline : Piecewise-cubic interpolator.
    Akima1DInterpolator : Akima 1D interpolator.
    CubicSpline : Cubic spline data interpolator.
    PPoly : Piecewise polynomial in terms of coefficients and breakpoints.

    Notes
    -----
    The interpolator preserves monotonicity in the interpolation data and does
    not overshoot if the data is not smooth.

    The first derivatives are guaranteed to be continuous, but the second
    derivatives may jump at :math:`x_k`.

    Determines the derivatives at the points :math:`x_k`, :math:`f'_k`,
    by using PCHIP algorithm [1]_.

    Let :math:`h_k = x_{k+1} - x_k`, and  :math:`d_k = (y_{k+1} - y_k) / h_k`
    are the slopes at internal points :math:`x_k`.
    If the signs of :math:`d_k` and :math:`d_{k-1}` are different or either of
    them equals zero, then :math:`f'_k = 0`. Otherwise, it is given by the
    weighted harmonic mean

    .. math::

        \frac{w_1 + w_2}{f'_k} = \frac{w_1}{d_{k-1}} + \frac{w_2}{d_k}

    where :math:`w_1 = 2 h_k + h_{k-1}` and :math:`w_2 = h_k + 2 h_{k-1}`.

    The end slopes are set using a one-sided scheme [2]_.


    References
    ----------
    .. [1] F. N. Fritsch and J. Butland,
           A method for constructing local
           monotone piecewise cubic interpolants,
           SIAM J. Sci. Comput., 5(2), 300-304 (1984).
           :doi:`10.1137/0905021`.
    .. [2] see, e.g., C. Moler, Numerical Computing with Matlab, 2004.
           :doi:`10.1137/1.9780898717952`

    c����t|||�\}}}}}|j|jdfd|jdz
zz�}|j	||�}t
�|�|||d|��||_y)Nr)rr�r%r2)r)r3rr�_find_derivativesr6r7r%)	r8r#r$r%r2�_�xp�dkr=s	        �r(r7zPchipInterpolator.__init__�sv���(��A�t�4���1�a��q�
�Y�Y�����
�}�t�Q�V�V�A�X��6�
7��
�
#�
#�B��
*��
����A�r��{��C���	r*c�j�d|z|z|z||zz
||zz}tj|�tj|�k7}tj|�tj|�k7tj|�dtj|�zkDz}||z}d||<d||z||<|S)Nrg@�)r�sign�abs)�h0�h1�m0�m1�d�mask�mask2�mmms        r(�
_edge_casezPchipInterpolator._edge_case�s�����d�R�i��^�b��e�
#��R��0���w�w�q�z�R�W�W�R�[�(������������+����q�	�B�r�v�v�b�z�M�0I�J���u��o����$���B�s�G���#���r*c�L�|j}|jdk(r|dd�df}|dd�df}|dd|ddz
}|dd|ddz
|z}|jddk(r0tj|�}||d<||d<|j	|�Stj
|�}|dd|ddk7|dddk(z|dddk(z}d|ddz|ddz}|ddd|ddzz}	tjdd��5||ddz|	|ddzz||	zz}
ddd�tj|�}d|dd|<d
|z|dd|<tj|d|d|d|d�|d<tj|d|d	|d|d	�|d<|j	|�S#1swY��xYw)
Nrr.rr�ignore)�divide�invalidrM��?���)	rrr�
zeros_liker3rN�errstater	rX)r#r$�y_shape�hk�mkrK�smk�	condition�w1�w2�whmeans           r(rHz#PchipInterpolator._find_derivatives�s���'�'���6�6�Q�;��!�T�'�
�A��!�T�'�
�A�
�q�r�U�Q�s��V�^�����e�a���f�n��
"���7�7�1�:��?����q�!�B��B�q�E��B�q�E��:�:�g�&�&��g�g�b�k�����W��C�R��(�R���V�q�[�9�R���W��\�J�	�
�r�!�"�v�X��3�B��
��
���V�a��3�B��i�
���[�[��(�
;�	:���C�R��j�2�b���f�9�,��b��9�F�	:��]�]�1�
��!��1�R����"�V�Y�J�%7�7��1�R��)���"�,�,�R��U�B�q�E�2�a�5�"�Q�%�H��1��"�-�-�b��f�b��f�b��f�b��f�M��2���z�z�'�"�"�	:�	:�s�.F�F#r>)	r?r@rArBr7�staticmethodrXrHrCrDs@r(r	r	�s7���I�V������.#��.#r*r	c���t|||��}|dk(r||�St|�r|j|�|�S|D�cgc]}|j|�|���c}Scc}w)a�
    Convenience function for pchip interpolation.

    xi and yi are arrays of values used to approximate some function f,
    with ``yi = f(xi)``. The interpolant uses monotonic cubic splines
    to find the value of new points x and the derivatives there.

    See `scipy.interpolate.PchipInterpolator` for details.

    Parameters
    ----------
    xi : array_like
        A sorted list of x-coordinates, of length N.
    yi : array_like
        A 1-D array of real values. `yi`'s length along the interpolation
        axis must be equal to the length of `xi`. If N-D array, use axis
        parameter to select correct axis.
    x : scalar or array_like
        Of length M.
    der : int or list, optional
        Derivatives to extract. The 0th derivative can be included to
        return the function value.
    axis : int, optional
        Axis in the yi array corresponding to the x-coordinate values.

    Returns
    -------
    y : scalar or array_like
        The result, of length R or length M or M by R.

    See Also
    --------
    PchipInterpolator : PCHIP 1-D monotonic cubic interpolator.

    Examples
    --------
    We can interpolate 2D observed data using pchip interpolation:

    >>> import numpy as np
    >>> import matplotlib.pyplot as plt
    >>> from scipy.interpolate import pchip_interpolate
    >>> x_observed = np.linspace(0.0, 10.0, 11)
    >>> y_observed = np.sin(x_observed)
    >>> x = np.linspace(min(x_observed), max(x_observed), num=100)
    >>> y = pchip_interpolate(x_observed, y_observed, x)
    >>> plt.plot(x_observed, y_observed, "o", label="observation")
    >>> plt.plot(x, y, label="pchip interpolation")
    >>> plt.legend()
    >>> plt.show()

    r-r)r	r�
derivative)�xi�yir#�derr%�P�nus       r(r
r
1se��h	�"�b�t�,�A�
�a�x���t��	�3�� �q�|�|�C� ��#�#�.1�2�� ����R� ��#�2�2��2s�A#c�P��eZdZdZd�fd�	Zdd�Zedd��Zedd��Z�xZ	S)	ra
    Akima interpolator

    Fit piecewise cubic polynomials, given vectors x and y. The interpolation
    method by Akima uses a continuously differentiable sub-spline built from
    piecewise cubic polynomials. The resultant curve passes through the given
    data points and will appear smooth and natural.

    Parameters
    ----------
    x : ndarray, shape (npoints, )
        1-D array of monotonically increasing real values.
    y : ndarray, shape (..., npoints, ...)
        N-D array of real values. The length of ``y`` along the interpolation axis
        must be equal to the length of ``x``. Use the ``axis`` parameter to
        select the interpolation axis.
    axis : int, optional
        Axis in the ``y`` array corresponding to the x-coordinate values. Defaults
        to ``axis=0``.

    Methods
    -------
    __call__
    derivative
    antiderivative
    roots

    See Also
    --------
    PchipInterpolator : PCHIP 1-D monotonic cubic interpolator.
    CubicSpline : Cubic spline data interpolator.
    PPoly : Piecewise polynomial in terms of coefficients and breakpoints

    Notes
    -----
    .. versionadded:: 0.14

    Use only for precise data, as the fitted curve passes through the given
    points exactly. This routine is useful for plotting a pleasingly smooth
    curve through a few given points for purposes of plotting.

    References
    ----------
    [1] A new method of interpolation and smooth curve fitting based
        on local procedures. Hiroshi Akima, J. ACM, October 1970, 17(4),
        589-602.

    c�J��t|||�\}}}}}tj|jdzf|jddz�}|td�fd|jdz
zz}tj|d��|z|ddd|dz|dz
|d<d|dz|dz
|d<d|d	z|d
z
|d<d|dz|d	z
|d<d|dd|dd	zz}tjtj|d���}|dd}	|dd}
|	|
z}tj|d
tj|tj��zkD�}|d|dd}}
|	|||
dzf|zz|
|||
dzf|zzz||z||<t�|�5|||dd��||_y)Nr1r�Nrr-rr^g@������r.��?g��&�.>)�initialFrG)r)rr4�sizer�slicerr rO�nonzero�max�infr6r7r%)r8r#r$r%r'rI�mr;�dm�f1�f2�f12�ind�x_ind�y_indr=s               �r(r7zAkima1DInterpolator.__init__�s����*�!�Q��5���2�q�$��
�H�H�a�f�f�q�j�^�a�g�g�a�b�k�1�2��
��t���(�a�f�f�q�j�"9�9�
:���'�'�!�!�$�r�)��!�B���A�a�D�y�1�Q�4���!���A�a�D�y�1�Q�4���!���Q�r�U�
�Q�r�U�"��"���Q�r�U�
�Q�r�U�"��"��
�!�A�B�%�!�C�R�&�.�!��
�V�V�B�G�G�A�A�&�
'��
���V��
���W���2�g���j�j��t�b�f�f�S�2�6�6�'�&B�B�B�C���1�v�s�1�2�w�u���S�'�A�u�q�y�l�U�2�3�3��S�'�A�u�q�y�l�U�2�3�3�4�7:�3�x�@��#��	����A�q�q�e��<���	r*c��td��)Nz9Extending a 1-D Akima interpolator is not yet implemented��NotImplementedError)r8r<r#�rights    r(�extendzAkima1DInterpolator.extend�s��!�#4�5�	5r*c��td���Nz:This method does not make sense for an Akima interpolator.r�)�cls�tckr2s   r(�from_splinezAkima1DInterpolator.from_spline����!�#;�<�	<r*c��td��r�r�)r��bpr2s   r(�from_bernstein_basisz(Akima1DInterpolator.from_bernstein_basis�r�r*)r)Trs)
r?r@rArBr7r��classmethodr�r�rCrDs@r(rros<���/�b!�F5��<��<��<��<r*rc�4��eZdZdZd�fd�	Zed��Z�xZS)ra�Cubic spline data interpolator.

    Interpolate data with a piecewise cubic polynomial which is twice
    continuously differentiable [1]_. The result is represented as a `PPoly`
    instance with breakpoints matching the given data.

    Parameters
    ----------
    x : array_like, shape (n,)
        1-D array containing values of the independent variable.
        Values must be real, finite and in strictly increasing order.
    y : array_like
        Array containing values of the dependent variable. It can have
        arbitrary number of dimensions, but the length along ``axis``
        (see below) must match the length of ``x``. Values must be finite.
    axis : int, optional
        Axis along which `y` is assumed to be varying. Meaning that for
        ``x[i]`` the corresponding values are ``np.take(y, i, axis=axis)``.
        Default is 0.
    bc_type : string or 2-tuple, optional
        Boundary condition type. Two additional equations, given by the
        boundary conditions, are required to determine all coefficients of
        polynomials on each segment [2]_.

        If `bc_type` is a string, then the specified condition will be applied
        at both ends of a spline. Available conditions are:

        * 'not-a-knot' (default): The first and second segment at a curve end
          are the same polynomial. It is a good default when there is no
          information on boundary conditions.
        * 'periodic': The interpolated functions is assumed to be periodic
          of period ``x[-1] - x[0]``. The first and last value of `y` must be
          identical: ``y[0] == y[-1]``. This boundary condition will result in
          ``y'[0] == y'[-1]`` and ``y''[0] == y''[-1]``.
        * 'clamped': The first derivative at curves ends are zero. Assuming
          a 1D `y`, ``bc_type=((1, 0.0), (1, 0.0))`` is the same condition.
        * 'natural': The second derivative at curve ends are zero. Assuming
          a 1D `y`, ``bc_type=((2, 0.0), (2, 0.0))`` is the same condition.

        If `bc_type` is a 2-tuple, the first and the second value will be
        applied at the curve start and end respectively. The tuple values can
        be one of the previously mentioned strings (except 'periodic') or a
        tuple `(order, deriv_values)` allowing to specify arbitrary
        derivatives at curve ends:

        * `order`: the derivative order, 1 or 2.
        * `deriv_value`: array_like containing derivative values, shape must
          be the same as `y`, excluding ``axis`` dimension. For example, if
          `y` is 1-D, then `deriv_value` must be a scalar. If `y` is 3-D with
          the shape (n0, n1, n2) and axis=2, then `deriv_value` must be 2-D
          and have the shape (n0, n1).
    extrapolate : {bool, 'periodic', None}, optional
        If bool, determines whether to extrapolate to out-of-bounds points
        based on first and last intervals, or to return NaNs. If 'periodic',
        periodic extrapolation is used. If None (default), ``extrapolate`` is
        set to 'periodic' for ``bc_type='periodic'`` and to True otherwise.

    Attributes
    ----------
    x : ndarray, shape (n,)
        Breakpoints. The same ``x`` which was passed to the constructor.
    c : ndarray, shape (4, n-1, ...)
        Coefficients of the polynomials on each segment. The trailing
        dimensions match the dimensions of `y`, excluding ``axis``.
        For example, if `y` is 1-d, then ``c[k, i]`` is a coefficient for
        ``(x-x[i])**(3-k)`` on the segment between ``x[i]`` and ``x[i+1]``.
    axis : int
        Interpolation axis. The same axis which was passed to the
        constructor.

    Methods
    -------
    __call__
    derivative
    antiderivative
    integrate
    roots

    See Also
    --------
    Akima1DInterpolator : Akima 1D interpolator.
    PchipInterpolator : PCHIP 1-D monotonic cubic interpolator.
    PPoly : Piecewise polynomial in terms of coefficients and breakpoints.

    Notes
    -----
    Parameters `bc_type` and ``extrapolate`` work independently, i.e. the
    former controls only construction of a spline, and the latter only
    evaluation.

    When a boundary condition is 'not-a-knot' and n = 2, it is replaced by
    a condition that the first derivative is equal to the linear interpolant
    slope. When both boundary conditions are 'not-a-knot' and n = 3, the
    solution is sought as a parabola passing through given points.

    When 'not-a-knot' boundary conditions is applied to both ends, the
    resulting spline will be the same as returned by `splrep` (with ``s=0``)
    and `InterpolatedUnivariateSpline`, but these two methods use a
    representation in B-spline basis.

    .. versionadded:: 0.18.0

    Examples
    --------
    In this example the cubic spline is used to interpolate a sampled sinusoid.
    You can see that the spline continuity property holds for the first and
    second derivatives and violates only for the third derivative.

    >>> import numpy as np
    >>> from scipy.interpolate import CubicSpline
    >>> import matplotlib.pyplot as plt
    >>> x = np.arange(10)
    >>> y = np.sin(x)
    >>> cs = CubicSpline(x, y)
    >>> xs = np.arange(-0.5, 9.6, 0.1)
    >>> fig, ax = plt.subplots(figsize=(6.5, 4))
    >>> ax.plot(x, y, 'o', label='data')
    >>> ax.plot(xs, np.sin(xs), label='true')
    >>> ax.plot(xs, cs(xs), label="S")
    >>> ax.plot(xs, cs(xs, 1), label="S'")
    >>> ax.plot(xs, cs(xs, 2), label="S''")
    >>> ax.plot(xs, cs(xs, 3), label="S'''")
    >>> ax.set_xlim(-0.5, 9.5)
    >>> ax.legend(loc='lower left', ncol=2)
    >>> plt.show()

    In the second example, the unit circle is interpolated with a spline. A
    periodic boundary condition is used. You can see that the first derivative
    values, ds/dx=0, ds/dy=1 at the periodic point (1, 0) are correctly
    computed. Note that a circle cannot be exactly represented by a cubic
    spline. To increase precision, more breakpoints would be required.

    >>> theta = 2 * np.pi * np.linspace(0, 1, 5)
    >>> y = np.c_[np.cos(theta), np.sin(theta)]
    >>> cs = CubicSpline(theta, y, bc_type='periodic')
    >>> print("ds/dx={:.1f} ds/dy={:.1f}".format(cs(0, 1)[0], cs(0, 1)[1]))
    ds/dx=0.0 ds/dy=1.0
    >>> xs = 2 * np.pi * np.linspace(0, 1, 100)
    >>> fig, ax = plt.subplots(figsize=(6.5, 4))
    >>> ax.plot(y[:, 0], y[:, 1], 'o', label='data')
    >>> ax.plot(np.cos(xs), np.sin(xs), label='true')
    >>> ax.plot(cs(xs)[:, 0], cs(xs)[:, 1], label='spline')
    >>> ax.axes.set_aspect('equal')
    >>> ax.legend(loc='center')
    >>> plt.show()

    The third example is the interpolation of a polynomial y = x**3 on the
    interval 0 <= x<= 1. A cubic spline can represent this function exactly.
    To achieve that we need to specify values and first derivatives at
    endpoints of the interval. Note that y' = 3 * x**2 and thus y'(0) = 0 and
    y'(1) = 3.

    >>> cs = CubicSpline([0, 1], [0, 1], bc_type=((1, 0), (1, 3)))
    >>> x = np.linspace(0, 1)
    >>> np.allclose(x**3, cs(x))
    True

    References
    ----------
    .. [1] `Cubic Spline Interpolation
            <https://en.wikiversity.org/wiki/Cubic_Spline_Interpolation>`_
            on Wikiversity.
    .. [2] Carl de Boor, "A Practical Guide to Splines", Springer-Verlag, 1978.
    c�\��t|||�\}}}}}t|�}|j|||jdd|�\}	}|�
|	ddk(rd}nd}|jdk(rtj|�}
�n|j|jdgdg|jdz
zz�}tj|d��|z}|dk(r"|	ddvr
d|df|	d<|	ddvr
d|df|	d<|dk(r�|	dd	k(r�|	dd	k(r�tjd
�}
tjd|jddz|j��}d|
d
<d|
d<|d|
d<d|d|dzz|
d<|d|
d<d|
d<d|
d<d|dz|d<d|d|dz|d|dzzz|d<d|dz|d<t|
|ddd��}
�n�|dk(rt|	ddk(rltj|f|jddz|j��}
||zj�d|zj�z}|
j|��nWtjd|f�}
tj|f|jddz|j��}d|dd|ddzz|
ddd�f<|dd|
ddd�f<|dd|
ddd�f<d|dd|ddz|dd|ddzzz|dd|	\}}|dk(�rP|
dd�dd�f}
d|d|dzz|
d<|d|
d<|dd}|d}|d}d|d|dzz}|d}|d}d|d|dz|d|dzzz|d<d|d|dz|d|dzzz|d<|
dd�dd�f}|dd}tj|�}||d<||d<t!d||ddd��}t!d||ddd��}|d||dzz
||dzz
|||dzz||dzzz}tj|f|jddz|j��}
|||zz|
dd||
d<|
d|
d<�ni|d	k(rN|d|
d<|d|dz
|
d<|d|dz
}|dd|zz|dz|dz|ddz|dzz|z|d<nY|ddk(rd|
d<d|
d<|d|d<n>|ddk(r6d|dz|
d<|d|
d<d|dz|ddzzd|d|dz
zz|d<|d	k(rN|d|
d<|d|dz
|
d<|d|dz
}|ddz|dzd|z|dz|dz|dzz|z|d<nY|ddk(rd|
d<d|
d<|d|d<n>|ddk(r6d|dz|
d<|d|
d<d|dz|ddzzd|d|dz
zz|d<t!d|
|ddd��}
t"�|�I|||
d|��||_y) Nrr�periodicTr-r��
not-a-knotr�r1r�)r1r1)r1r0�rr)rr)rr)rr�rr)rr)rrF)�overwrite_a�overwrite_b�check_finiter]r.r^rt)�overwrite_abr�r�g�)rr.)r.r^rvrG)r)r5�_validate_bcrrxrr_r3rr �zerosr4rr�sum�fillrr6r7r%)r8r#r$r%�bc_typer2r'rI�n�bc�sr9r:�A�br;�bc_start�bc_end�a_m1_0�a_m1_m2�a_m1_m1�a_m2_m1�a_0_m1�Ac�b1�b2�s1�s2�s_m1rTr=s                              �r(r7zCubicSpline.__init__{s����)�!�Q��5���2�q�$����F���!�!�'�1�a�g�g�a�b�k�4�@���A����!�u�
�"�(��"���6�6�Q�;��
�
�a� �A��*�*�b�h�h�q�k�]�a�S�A�F�F�Q�J�-?�?�@�C��G�G�A�A�&��,�E��A�v��a�5�6�6���a��M�B�q�E��a�5�6�6���a��M�B�q�E��A�v�"�Q�%�<�/�B�q�E�\�4I��H�H�V�$���H�H�T�A�G�G�A�B�K�/�q�w�w�?����$����$���Q�%��$���r�!�u�r�!�u�}�-��$���Q�%��$����$����$���5��8�|��!���C��F�U�1�X�-��A���q��0A�A�B��!���5��8�|��!���!�Q�D�d�',�.���a��B�q�E�Z�/��H�H�a�T�A�G�G�A�B�K�/�q�w�w�?���S�[�%�%�'�2��8�.�.�*:�:�����q�	��H�H�a��V�$���H�H�a�T�A�G�G�A�B�K�/�q�w�w�?���"�S�b�'�B�q�r�F�"2�3��!�Q�r�T�'�
��c�r�7��!�Q�R�%�����V��"�c�r�c�'�
��s�1�2�w��s���3�c�#�2�h��q�r��6J�J�K��!�B��#%� ��&��z�)��!�Q�r�T�'�
�A��2�b�6�B�q�E�>�2�A�d�G� ��f�A�d�G��#�2��A� ��V�F� ��f�G��2�b�6�B�r�F�?�3�G� ��f�G���U�F���A���r�� 2�S��W�u�Q�x�5G� G�H�A�a�D���R��5��9�!4�s�2�w��r��7J�!J�K�A�b�E��1�c�r�c�6��B��3�B��B����r�*�B�#�G�B�q�E�%�X�B�r�F�&�f�b�"�5�27�e�M�B�&�f�b�"�5�27�e�M�B��r�U�V�b��e�^�3�g��2��6F�F�$�v��1��~�5��"�R�&�8H�H�J�D����!��������!3�1�7�7�C�A��$��)�^�A�c�r�F� �A�b�E��a�D�A�b�E��<�/�"$�Q�%��$��"#�A�$��1��+��$���a�D�1�Q�4�K��!$�Q��!�A�#���Q�� 7�%��(� B� #�A���	�E�!�H� 4�!5�89� :��!��!�!���)�"#��$��"#��$��'��{��!��!�!���)�"#�b��e�)��$��"$�Q�%��$��#�h�q�k�1�B�q�E�1�H�<�q�A�a�D�1�Q�4�K�?P�P��!����-�#%�b�6��%��$%�b�E�A�b�E�M��&�	��b�E�A�b�E�M��"%�b�'�1�*�U�2�Y�"6�"#�A�#��B��-��R��!8��r��!B�#C�FG�"H��"�����a��#$��%��$%��&�	� &�q�	��"�����a��#$�r�"�v�:��%��$&�r�F��&�	� #�f�Q�i��"�R�&�!�)� ;�a�1�R�5�1�R�5�=�>Q� Q��"��$�V�Q���15�E�K�A�	����A�q�q�k��B���	r*c���t|t�rC|dk(r9tj|d|ddd��st	dj|���||f}n(t
|�dk7rt	d��d|vrt	d	��g}|D�]F}t|t�r}|d
k(r'|jdtj|�f��@|dk(r'|jdtj|�f��l|d
vr|j|���t	d|�d���	|\}}|dvrt	d��tj|�}|j|k7r%t	dj|j|���tj|jtj�r|jt d��}|j||f���I||fS#t$r}t	d�|�d}~wwxYw)a(Validate and prepare boundary conditions.

        Returns
        -------
        validated_bc : 2-tuple
            Boundary conditions for a curve start and end.
        y : ndarray
            y casted to complex dtype if one of the boundary conditions has
            complex dtype.
        r�rr.gV瞯�<)�rtol�atolzpThe first and last `y` point along axis {} must be identical (within machine precision) when bc_type='periodic'.rzF`bc_type` must contain 2 elements to specify start and end conditions.zf'periodic' `bc_type` is defined for both curve ends and cannot be used with other boundary conditions.�clampedr�naturalr�zbc_type=z is not allowed.zFA specified derivative value must be given in the form (order, value).Nr�z.The specified derivative order must be 1 or 2.z2`deriv_value` shape {} is not the expected one {}.Fr)�
isinstance�strr�allcloserrr5�appendr��	Exceptionrrrrrrr)	r�r$�expected_deriv_shaper%�validated_bcr��deriv_order�deriv_value�es	         r(r�zCubicSpline._validate_bcs���g�s�#��*�$��{�{�1�Q�4��2��U��G�$�.�.4�f�T�l�<�<�
��(�G��7�|�q� � �"E�F�F��W�$� �"8�9�9���� 	@�B��"�c�"���?� �'�'��B�H�H�5I�,J�(K�L��9�_� �'�'��B�H�H�5I�,J�(K�L��5�5� �'�'��+�$�x��t�3C�%D�E�E��/1�,�K���f�,�$�&2�3�3�!�j�j��5���$�$�(<�<�$�L���� 1� 1�3G�H�J�J��=�=��!2�!2�B�4F�4F�G�����u��5�A��#�#�[�+�$>�?�A 	@�D�Q����+!��$�<������s�G�	G(�G#�#G()rr�N)r?r@rArBr7rir�rCrDs@r(rr�s'���c�Ja�F�B��Br*rrsr�)rB�numpyr�r�_polyintr�scipy.linalgrr�__all__r)rr	r
rr�r*r(�<module>r�se��A����,�1��5 �pT��T�nQ#�*�Q#�h;3�|c<�,�c<�LL�$�Lr*
Youez - 2016 - github.com/yon3zu
LinuXploit