| Server IP : 217.160.0.135 / Your IP : 216.73.217.85 Web Server : Apache System : Linux www 6.18.52-i1-ampere #1203 SMP Mon Sep 14 18:29:59 CEST 2026 aarch64 User : sws1074145052 ( 1074145052) PHP Version : 8.3.32 Disable Function : NONE MySQL : OFF | cURL : ON | WGET : ON | Perl : ON | Python : OFF | Sudo : OFF | Pkexec : OFF Directory : /lib/python3/dist-packages/scipy/interpolate/__pycache__/ |
Upload File : |
�
d�c�> � � � d Z g d�ZddlZddlmZmZmZmZmZm Z ddlZ
ddl m Z ddl m
Z
e
j j j Zdd d
d d �Zddddd
d
ddd�Z G d� d� � Z G d� de� � ZdZ G d� de� � Z G d� d� � Zdddd d d d d �Z G d!� d"e� � Z G d#� d$e� � Z G d%� d&e� � Z G d'� d(e� � Z G d)� d*e� � Z e� � � Z d+e d,< d-e d.< G d/� d0e� � Z! G d1� d2e!� � Z" G d3� d4e!� � Z#e� � � Z$d5e$d,< G d6� d7e!� � Z%dS )8z�
fitpack --- curve and surface fitting with splines
fitpack is based on a collection of Fortran routines DIERCKX
by P. Dierckx (see http://www.netlib.org/dierckx/) transformed
to double routines by Pearu Peterson.
)
�UnivariateSpline� InterpolatedUnivariateSpline�LSQUnivariateSpline�BivariateSpline�LSQBivariateSpline�SmoothBivariateSpline�LSQSphereBivariateSpline�SmoothSphereBivariateSpline�RectBivariateSpline�RectSphereBivariateSpline� N)�zeros� concatenate�ravel�diff�array�ones� )�
_fitpack_impl)�dfitpacka�
The required storage space exceeds the available storage space, as
specified by the parameter nest: nest too small. If nest is already
large (say nest > m/2), it may also indicate that s is too small.
The approximation returned is the weighted least-squares spline
according to the knots t[0],t[1],...,t[n-1]. (n=nest) the parameter fp
gives the corresponding weighted sum of squared residuals (fp>s).
a
A theoretically impossible result was found during the iteration
process for finding a smoothing spline with fp = s: s too small.
There is an approximation returned but the corresponding weighted sum
of squared residuals does not satisfy the condition abs(fp-s)/s < tol.a
The maximal number of iterations maxit (set to 20 by the program)
allowed for finding a smoothing spline with fp=s has been reached: s
too small.
There is an approximation returned but the corresponding weighted sum
of squared residuals does not satisfy the condition abs(fp-s)/s < tol.z�
Error on entry, no approximation returned. The following conditions
must hold:
xb<=x[0]<x[1]<...<x[m-1]<=xe, w[i]>0, i=0..m-1
if iopt=-1:
xb<t[k+1]<t[k+2]<...<t[n-k-2]<xe)r � � �
r r )r � extrapolater r
r �raiser �constc � � e Zd ZdZddgdz ddddfd�Zed� � � Zedd �� � Zd
� Z d � Z
dd �Z d
� Z dd�Z
d� Zd� Zd� Zd� Zd� Zd� Zdd�Zdd�ZdS ) r a
1-D smoothing spline fit to a given set of data points.
Fits a spline y = spl(x) of degree `k` to the provided `x`, `y` data. `s`
specifies the number of knots by specifying a smoothing condition.
Parameters
----------
x : (N,) array_like
1-D array of independent input data. Must be increasing;
must be strictly increasing if `s` is 0.
y : (N,) array_like
1-D array of dependent input data, of the same length as `x`.
w : (N,) array_like, optional
Weights for spline fitting. Must be positive. If `w` is None,
weights are all 1. Default is None.
bbox : (2,) array_like, optional
2-sequence specifying the boundary of the approximation interval. If
`bbox` is None, ``bbox=[x[0], x[-1]]``. Default is None.
k : int, optional
Degree of the smoothing spline. Must be 1 <= `k` <= 5.
``k = 3`` is a cubic spline. Default is 3.
s : float or None, optional
Positive smoothing factor used to choose the number of knots. Number
of knots will be increased until the smoothing condition is satisfied::
sum((w[i] * (y[i]-spl(x[i])))**2, axis=0) <= s
However, because of numerical issues, the actual condition is::
abs(sum((w[i] * (y[i]-spl(x[i])))**2, axis=0) - s) < 0.001 * s
If `s` is None, `s` will be set as `len(w)` for a smoothing spline
that uses all data points.
If 0, spline will interpolate through all data points. This is
equivalent to `InterpolatedUnivariateSpline`.
Default is None.
The user can use the `s` to control the tradeoff between closeness
and smoothness of fit. Larger `s` means more smoothing while smaller
values of `s` indicate less smoothing.
Recommended values of `s` depend on the weights, `w`. If the weights
represent the inverse of the standard-deviation of `y`, then a good
`s` value should be found in the range (m-sqrt(2*m),m+sqrt(2*m))
where m is the number of datapoints in `x`, `y`, and `w`. This means
``s = len(w)`` should be a good value if ``1/w[i]`` is an
estimate of the standard deviation of ``y[i]``.
ext : int or str, optional
Controls the extrapolation mode for elements
not in the interval defined by the knot sequence.
* if ext=0 or 'extrapolate', return the extrapolated value.
* if ext=1 or 'zeros', return 0
* if ext=2 or 'raise', raise a ValueError
* if ext=3 of 'const', return the boundary value.
Default is 0.
check_finite : bool, optional
Whether to check that the input arrays contain only finite numbers.
Disabling may give a performance gain, but may result in problems
(crashes, non-termination or non-sensical results) if the inputs
do contain infinities or NaNs.
Default is False.
See Also
--------
BivariateSpline :
a base class for bivariate splines.
SmoothBivariateSpline :
a smoothing bivariate spline through the given points
LSQBivariateSpline :
a bivariate spline using weighted least-squares fitting
RectSphereBivariateSpline :
a bivariate spline over a rectangular mesh on a sphere
SmoothSphereBivariateSpline :
a smoothing bivariate spline in spherical coordinates
LSQSphereBivariateSpline :
a bivariate spline in spherical coordinates using weighted
least-squares fitting
RectBivariateSpline :
a bivariate spline over a rectangular mesh
InterpolatedUnivariateSpline :
a interpolating univariate spline for a given set of data points.
bisplrep :
a function to find a bivariate B-spline representation of a surface
bisplev :
a function to evaluate a bivariate B-spline and its derivatives
splrep :
a function to find the B-spline representation of a 1-D curve
splev :
a function to evaluate a B-spline or its derivatives
sproot :
a function to find the roots of a cubic B-spline
splint :
a function to evaluate the definite integral of a B-spline between two
given points
spalde :
a function to evaluate all derivatives of a B-spline
Notes
-----
The number of data points must be larger than the spline degree `k`.
**NaN handling**: If the input arrays contain ``nan`` values, the result
is not useful, since the underlying spline fitting routines cannot deal
with ``nan``. A workaround is to use zero weights for not-a-number
data points:
>>> import numpy as np
>>> from scipy.interpolate import UnivariateSpline
>>> x, y = np.array([1, 2, 3, 4]), np.array([1, np.nan, 3, 4])
>>> w = np.isnan(y)
>>> y[w] = 0.
>>> spl = UnivariateSpline(x, y, w=~w)
Notice the need to replace a ``nan`` by a numerical value (precise value
does not matter as long as the corresponding weight is zero.)
Examples
--------
>>> import numpy as np
>>> import matplotlib.pyplot as plt
>>> from scipy.interpolate import UnivariateSpline
>>> rng = np.random.default_rng()
>>> x = np.linspace(-3, 3, 50)
>>> y = np.exp(-x**2) + 0.1 * rng.standard_normal(50)
>>> plt.plot(x, y, 'ro', ms=5)
Use the default value for the smoothing parameter:
>>> spl = UnivariateSpline(x, y)
>>> xs = np.linspace(-3, 3, 1000)
>>> plt.plot(xs, spl(xs), 'g', lw=3)
Manually change the amount of smoothing:
>>> spl.set_smoothing_factor(0.5)
>>> plt.plot(xs, spl(xs), 'b', lw=3)
>>> plt.show()
Nr r r Fc
� � | � ||||||||� � \ }}}}| _ t j |||||d |d |�� � } | d dk r| � | � � } | | _ | � � � d S )Nr r ��w�xb�xe�s���)�validate_input�extr �fpcurf0� _reset_nest�_data� _reset_class)
�self�x�yr �bbox�kr" r% � check_finite�datas
�=/usr/lib/python3/dist-packages/scipy/interpolate/_fitpack2.py�__init__zUnivariateSpline.__init__� s� � � #'�"5�"5�a��A�t�Q��3�6B�#D� #D� ��1�a��t�x� � ��1�a�1��a��#'��7�a�1� 1� 1�� ��8�q�=�=��#�#�D�)�)�D���
� �������� c �J � t j | � � t j |� � t j |� � }}} |�t j |� � }|r�|�&t j |� � � � � nd}t j | � � � � � r(t j |� � � � � r|st d� � �|�|dk r5t j t | � � dk � � st d� � �n4t j t | � � dk � � st d� � �| j |j k rt d� � �|�-| j |j cxk r |j k sn t d� � �|j d k rt d
� � �d |cxk rd k sn t d
� � �|�|dk st d� � � t | }n%# t $ r} t d|z � � | �d } ~ ww xY w| ||||fS )NTz,x and y array must not contain NaNs or infs.r � z x must be increasing if s > 0z&x must be strictly increasing if s = 0z!x and y should have a same lengthz%x, y, and w should have a same length)r zbbox shape should be (2,)r � zk should be 1 <= k <= 5�s should be s >= 0.0� Unknown extrapolation mode %s.)
�np�asarray�isfinite�all�
ValueErrorr �size�shape�
_extrap_modes�KeyError)
r+ r, r r- r. r" r% r/ �w_finite�es
r1 r$ z UnivariateSpline.validate_input� s: � ��Z��]�]�B�J�q�M�M�2�:�d�3C�3C�d�1�� �=��
�1�
�
�A� � 2�/0�}�r�{�1�~�~�)�)�+�+�+�$�H��K��N�N�&�&�(�(�
2�� �A���0B�0B�0D�0D�
2� �
2� � "1� 2� 2� 2� �9��A����6�$�q�'�'�S�.�)�)�
B� �!@�A�A�A�
B� �6�$�q�'�'�C�-�(�(�
K� �!I�J�J�J� �6�Q�V� � � � @�A�A� A�
�]�1�6�Q�V�#=�#=�#=�#=�q�v�#=�#=�#=�#=� � D�E�E� E�
�Z�4�
�
� � 8�9�9� 9��q�+�+�+�+�A�+�+�+�+� � 6�7�7� 7�
�]�1��8�8� � 3�4�4� 4� L� ��$�C�C��� L� L� L� � =�� C�D�D�!� K����� L���� �!�Q��c�!�!s �+
G9 �9
H�H�Hc � � | � | � � }|\ }}}||_ ddddd|dt |� � ||ddddf|_ ||_ |S )z(Construct a spline object from given tckN)�__new__�
_eval_args�lenr( r% )�cls�tckr% r* �t�cr. s r1 � _from_tckzUnivariateSpline._from_tck s` � � �{�{�3� � �����1�a� ����D�$��d�A�t�S��V�V�Q���t�T�4�1��
����� r3 c �� � | j }|d |d |d |d |d f\ }}}}}|d |� |d |� |f| _ |dk rd S |dk r | � t � � d S |dk r | � t � � d S |dk r| � t � � t
� |d |z � � }t j |� � d S )
N� � � r6 r# r ���r �ier=%s) r( rF �
_set_classr r �_curfit_messages�get�warnings�warn)r* r0 �nrJ rK r. �ier�messages r1 r) z UnivariateSpline._reset_class s� � ��z�� �q�'�4��7�D��G�T�!�W�d�2�h�F���1�a��C��B�Q�B�%��2�A�2���/��� �!�8�8�
�D�
�B�Y�Y� �O�O� 8� 9� 9� 9� 9� 9�
�B�Y�Y�
�O�O� /� 0� 0� 0� 0� 0� �a�x�x���� 3�4�4�4�&�*�*�3��C�0@�A�A�G� �M�'� "� "� "� "� "r3 c �\ � || _ | j t t t fv r || _ d S d S �N)�
_spline_class� __class__r r r )r* rH s r1 rS zUnivariateSpline._set_class, s9 � � ��� �>� .�0L� 1� 3� 3� 3� �D�N�N�N�
�Dr3 c �
��� �d }��&�d t �d � � }}||z dz �n|�k st d� � ���fd�dD � � \ }}}} �d d� ||||| �d fz }
t j |
� ��S )
Nr r6 r r z `nest` can only be increasedc �F �� g | ] }t j �| �� � �� S � )r9 �resize)�.0�jr0 �nests ��r1 �
<listcomp>z0UnivariateSpline._reset_nest.<locals>.<listcomp>= s5 �� � /� /� /�A�r�y��a��$� 7� 7� /� /� /r3 )rO rP � � rO �
)rG r= r �fpcurf1) r* r0 re rX r. �mrJ rK �fpint�nrdata�argss `` r1 r' z UnivariateSpline._reset_nest5 s� ��� � ��H�� �<���7�C��Q��L�L�q�A��Q�3�q�5�D�D���9�9� �!?�@�@�@� /� /� /� /� /� -� /� /� /���1�e�V� �B�Q�B�x�1�a��E�6�4��8�<�<��� ��&��� r3 c � � | j }|d dk rt j d� � dS |dd� |fz |dd� z }t j |� }|d dk r| � |� � }|| _ | � � � dS )z� Continue spline computation with the given smoothing
factor s and with the knots found at the last call.
This routine modifies the spline in place.
� r# z9smoothing factor unchanged forLSQ spline with fixed knotsNrN r )r( rV rW r rj r' r) )r* r" r0 rn s r1 �set_smoothing_factorz%UnivariateSpline.set_smoothing_factorD s� � � �z�� ��7�b�=�=� �M� 8�
9�
9�
9� �F��B�Q�B�x�1�$���a�b�b��)��� ��&�� ��8�q�=�=��#�#�D�)�)�D���
� �������r3 c � � t j |� � }|j dk rt g � � S |�| j }n4 t
| }n%# t $ r}t d|z � � |�d}~ww xY wt j || j
||�� � S )a�
Evaluate spline (or its nu-th derivative) at positions x.
Parameters
----------
x : array_like
A 1-D array of points at which to return the value of the smoothed
spline or its derivatives. Note: `x` can be unordered but the
evaluation is more efficient if `x` is (partially) ordered.
nu : int
The order of derivative of the spline to compute.
ext : int
Controls the value returned for elements of `x` not in the
interval defined by the knot sequence.
* if ext=0 or 'extrapolate', return the extrapolated value.
* if ext=1 or 'zeros', return 0
* if ext=2 or 'raise', raise a ValueError
* if ext=3 or 'const', return the boundary value.
The default value is 0, passed from the initialization of
UnivariateSpline.
r Nr8 )�derr% ) r9 r: r> r r% r@ rA r= r �splevrF )r* r+ �nur% rC s r1 �__call__zUnivariateSpline.__call__X s� � �2
�J�q�M�M�� �6�Q�;�;���9�9� � �;��(�C�C�
P�#�C�(�����
P�
P�
P� �!A�C�!G�H�H�a�O�����
P���� �"�1�d�o�2�3�G�G�G�Gs �
A �
A*�A%�%A*c �V � | j }|d |d }}|d |||z
� S )z� Return positions of interior knots of the spline.
Internally, the knot vector contains ``2*k`` additional boundary knots.
r6 rN rO �r( �r* r0 r. rX s r1 � get_knotszUnivariateSpline.get_knots~ s2 � �
�z���A�w��Q��1���A�w�q��1��u�~� r3 c �\ � | j }|d |d }}|d d||z
dz
� S )zReturn spline coefficients.r6 rN rP Nr rx ry s r1 �
get_coeffszUnivariateSpline.get_coeffs� s4 � ��z���A�w��Q��1���A�w�v��!��A��v�� r3 c � � | j d S )z�Return weighted sum of squared residuals of the spline approximation.
This is equivalent to::
sum((w[i] * (y[i]-spl(x[i])))**2, axis=0)
r rx �r* s r1 � get_residualz UnivariateSpline.get_residual� s � � �z�"�~� r3 c �8 � t j ||| j � � S )a� Return definite integral of the spline between two given points.
Parameters
----------
a : float
Lower limit of integration.
b : float
Upper limit of integration.
Returns
-------
integral : float
The value of the definite integral of the spline between limits.
Examples
--------
>>> import numpy as np
>>> from scipy.interpolate import UnivariateSpline
>>> x = np.linspace(0, 3, 11)
>>> y = x**2
>>> spl = UnivariateSpline(x, y)
>>> spl.integral(0, 3)
9.0
which agrees with :math:`\int x^2 dx = x^3 / 3` between the limits
of 0 and 3.
A caveat is that this routine assumes the spline to be zero outside of
the data limits:
>>> spl.integral(-1, 4)
9.0
>>> spl.integral(-1, 0)
0.0
)r �splintrF )r* �a�bs r1 �integralzUnivariateSpline.integral� s � �J �#�A�q�$�/�:�:�:r3 c �6 � t j || j � � S )aE Return all derivatives of the spline at the point x.
Parameters
----------
x : float
The point to evaluate the derivatives at.
Returns
-------
der : ndarray, shape(k+1,)
Derivatives of the orders 0 to k.
Examples
--------
>>> import numpy as np
>>> from scipy.interpolate import UnivariateSpline
>>> x = np.linspace(0, 3, 11)
>>> y = x**2
>>> spl = UnivariateSpline(x, y)
>>> spl.derivatives(1.5)
array([2.25, 3.0, 2.0, 0])
)r �spalderF )r* r+ s r1 � derivativesz UnivariateSpline.derivatives� s � �0 �#�A�t��7�7�7r3 c �x � | j d }|dk rt j | j � � S t d� � �)a0 Return the zeros of the spline.
Notes
-----
Restriction: only cubic splines are supported by FITPACK. For non-cubic
splines, use `PPoly.root` (see below for an example).
Examples
--------
For some data, this method may miss a root. This happens when one of
the spline knots (which FITPACK places automatically) happens to
coincide with the true root. A workaround is to convert to `PPoly`,
which uses a different root-finding algorithm.
For example,
>>> x = [1.96, 1.97, 1.98, 1.99, 2.00, 2.01, 2.02, 2.03, 2.04, 2.05]
>>> y = [-6.365470e-03, -4.790580e-03, -3.204320e-03, -1.607270e-03,
... 4.440892e-16, 1.616930e-03, 3.243000e-03, 4.877670e-03,
... 6.520430e-03, 8.170770e-03]
>>> from scipy.interpolate import UnivariateSpline
>>> spl = UnivariateSpline(x, y, s=0)
>>> spl.roots()
array([], dtype=float64)
Converting to a PPoly object does find the roots at `x=2`:
>>> from scipy.interpolate import splrep, PPoly
>>> tck = splrep(x, y, s=0)
>>> ppoly = PPoly.from_spline(tck)
>>> ppoly.roots(extrapolate=False)
array([2.])
See Also
--------
sproot
PPoly.roots
r6 r z/finding roots unsupported for non-cubic splines)r( r �sprootrF �NotImplementedError)r* r. s r1 �rootszUnivariateSpline.roots� sC � �R
�J�q�M�� ��6�6� �'���8�8� 8�!� #6� 7� 7� 7r3 r c � � t j | j |� � }| j dk rdn| j }t � ||�� � S )a�
Construct a new spline representing the derivative of this spline.
Parameters
----------
n : int, optional
Order of derivative to evaluate. Default: 1
Returns
-------
spline : UnivariateSpline
Spline of order k2=k-n representing the derivative of this
spline.
See Also
--------
splder, antiderivative
Notes
-----
.. versionadded:: 0.13.0
Examples
--------
This can be used for finding maxima of a curve:
>>> import numpy as np
>>> from scipy.interpolate import UnivariateSpline
>>> x = np.linspace(0, 10, 70)
>>> y = np.sin(x)
>>> spl = UnivariateSpline(x, y, k=4, s=0)
Now, differentiate the spline and find the zeros of the
derivative. (NB: `sproot` only works for order 3 splines, so we
fit an order 4 spline):
>>> spl.derivative().roots() / np.pi
array([ 0.50000001, 1.5 , 2.49999998])
This agrees well with roots :math:`\pi/2 + n\pi` of
:math:`\cos(x) = \sin'(x)`.
r r )r% )r �splderrF r% r rL )r* rX rI r% s r1 �
derivativezUnivariateSpline.derivative sG � �Z �"�4�?�A�6�6���8�q�=�=�a�a�d�h�� �)�)�#�3�)�7�7�7r3 c �v � t j | j |� � }t � || j � � S )a�
Construct a new spline representing the antiderivative of this spline.
Parameters
----------
n : int, optional
Order of antiderivative to evaluate. Default: 1
Returns
-------
spline : UnivariateSpline
Spline of order k2=k+n representing the antiderivative of this
spline.
Notes
-----
.. versionadded:: 0.13.0
See Also
--------
splantider, derivative
Examples
--------
>>> import numpy as np
>>> from scipy.interpolate import UnivariateSpline
>>> x = np.linspace(0, np.pi/2, 70)
>>> y = 1 / np.sqrt(1 - 0.8*np.sin(x)**2)
>>> spl = UnivariateSpline(x, y, s=0)
The derivative is the inverse operation of the antiderivative,
although some floating point error accumulates:
>>> spl(1.7), spl.antiderivative().derivative()(1.7)
(array(2.1565429877197317), array(2.1565429877201865))
Antiderivative can be used to evaluate definite integrals:
>>> ispl = spl.antiderivative()
>>> ispl(np.pi/2) - ispl(0)
2.2572053588768486
This is indeed an approximation to the complete elliptic integral
:math:`K(m) = \int_0^{\pi/2} [1 - m\sin^2 x]^{-1/2} dx`:
>>> from scipy.special import ellipk
>>> ellipk(0.8)
2.2572053268208538
)r �
splantiderrF r rL r% )r* rX rI s r1 �antiderivativez UnivariateSpline.antiderivative9 s1 � �h �&�t���:�:�� �)�)�#�t�x�8�8�8r3 )r r\ )r N)r )�__name__�
__module__� __qualname__�__doc__r2 � staticmethodr$ � classmethodrL r) rS r' rq rv rz r| r r� r� r� r� r� ra r3 r1 r r G sf � � � � � �L� L�\ $�4�&��(�a�4��U�
�
�
�
� � "� "� �\� "�D � � � � �[� �#� #� #�0� � �
�
�
�
� � � �($H� $H� $H� $H�L � � � � � � � � �%;� %;� %;�N8� 8� 8�4-7� -7� -7�^08� 08� 08� 08�d59� 59� 59� 59� 59� 59r3 r c �, � e Zd ZdZddgdz dddfd�ZdS )r a�
1-D interpolating spline for a given set of data points.
Fits a spline y = spl(x) of degree `k` to the provided `x`, `y` data.
Spline function passes through all provided points. Equivalent to
`UnivariateSpline` with `s` = 0.
Parameters
----------
x : (N,) array_like
Input dimension of data points -- must be strictly increasing
y : (N,) array_like
input dimension of data points
w : (N,) array_like, optional
Weights for spline fitting. Must be positive. If None (default),
weights are all 1.
bbox : (2,) array_like, optional
2-sequence specifying the boundary of the approximation interval. If
None (default), ``bbox=[x[0], x[-1]]``.
k : int, optional
Degree of the smoothing spline. Must be ``1 <= k <= 5``. Default is
``k = 3``, a cubic spline.
ext : int or str, optional
Controls the extrapolation mode for elements
not in the interval defined by the knot sequence.
* if ext=0 or 'extrapolate', return the extrapolated value.
* if ext=1 or 'zeros', return 0
* if ext=2 or 'raise', raise a ValueError
* if ext=3 of 'const', return the boundary value.
The default value is 0.
check_finite : bool, optional
Whether to check that the input arrays contain only finite numbers.
Disabling may give a performance gain, but may result in problems
(crashes, non-termination or non-sensical results) if the inputs
do contain infinities or NaNs.
Default is False.
See Also
--------
UnivariateSpline :
a smooth univariate spline to fit a given set of data points.
LSQUnivariateSpline :
a spline for which knots are user-selected
SmoothBivariateSpline :
a smoothing bivariate spline through the given points
LSQBivariateSpline :
a bivariate spline using weighted least-squares fitting
splrep :
a function to find the B-spline representation of a 1-D curve
splev :
a function to evaluate a B-spline or its derivatives
sproot :
a function to find the roots of a cubic B-spline
splint :
a function to evaluate the definite integral of a B-spline between two
given points
spalde :
a function to evaluate all derivatives of a B-spline
Notes
-----
The number of data points must be larger than the spline degree `k`.
Examples
--------
>>> import numpy as np
>>> import matplotlib.pyplot as plt
>>> from scipy.interpolate import InterpolatedUnivariateSpline
>>> rng = np.random.default_rng()
>>> x = np.linspace(-3, 3, 50)
>>> y = np.exp(-x**2) + 0.1 * rng.standard_normal(50)
>>> spl = InterpolatedUnivariateSpline(x, y)
>>> plt.plot(x, y, 'ro', ms=5)
>>> xs = np.linspace(-3, 3, 1000)
>>> plt.plot(xs, spl(xs), 'g', lw=3, alpha=0.7)
>>> plt.show()
Notice that the ``spl(x)`` interpolates `y`:
>>> spl.get_residual()
0.0
Nr r r Fc
�< � | � |||||d ||� � \ }}}}| _ t j t |� � dk � � st d� � �t
j |||||d |d d�� � | _ | � � � d S )Nr5 � x must be strictly increasingr r r )
r$ r% r9 r< r r= r r& r( r) )r* r+ r, r r- r. r% r/ s r1 r2 z%InterpolatedUnivariateSpline.__init__� s� � � #'�"5�"5�a��A�t�Q��,/� �#?� #?� ��1�a��t�x��v�d�1�g�g��m�$�$� >� � <�=�=� =� �%�a��A��t�A�w�)-�a��A�7� 7� 7��
� �������r3 �r� r� r� r� r2 ra r3 r1 r r q sI � � � � � �U� U�n $�4�&��(�a��U� � � � � � r3 r a� The input parameters have been rejected by fpchec. This means that at least one of the following conditions is violated:
1) k+1 <= n-k-1 <= m
2) t(1) <= t(2) <= ... <= t(k+1)
t(n-k) <= t(n-k+1) <= ... <= t(n)
3) t(k+1) < t(k+2) < ... < t(n-k)
4) t(k+1) <= x(i) <= t(n-k)
5) The conditions specified by Schoenberg and Whitney must hold
for at least one subset of data points, i.e., there must be a
subset of data points y(j) such that
t(j) < y(j) < t(j+k+1), j=1,2,...,n-k-1
c �, � e Zd ZdZddgdz dddfd�ZdS )r a�
1-D spline with explicit internal knots.
Fits a spline y = spl(x) of degree `k` to the provided `x`, `y` data. `t`
specifies the internal knots of the spline
Parameters
----------
x : (N,) array_like
Input dimension of data points -- must be increasing
y : (N,) array_like
Input dimension of data points
t : (M,) array_like
interior knots of the spline. Must be in ascending order and::
bbox[0] < t[0] < ... < t[-1] < bbox[-1]
w : (N,) array_like, optional
weights for spline fitting. Must be positive. If None (default),
weights are all 1.
bbox : (2,) array_like, optional
2-sequence specifying the boundary of the approximation interval. If
None (default), ``bbox = [x[0], x[-1]]``.
k : int, optional
Degree of the smoothing spline. Must be 1 <= `k` <= 5.
Default is `k` = 3, a cubic spline.
ext : int or str, optional
Controls the extrapolation mode for elements
not in the interval defined by the knot sequence.
* if ext=0 or 'extrapolate', return the extrapolated value.
* if ext=1 or 'zeros', return 0
* if ext=2 or 'raise', raise a ValueError
* if ext=3 of 'const', return the boundary value.
The default value is 0.
check_finite : bool, optional
Whether to check that the input arrays contain only finite numbers.
Disabling may give a performance gain, but may result in problems
(crashes, non-termination or non-sensical results) if the inputs
do contain infinities or NaNs.
Default is False.
Raises
------
ValueError
If the interior knots do not satisfy the Schoenberg-Whitney conditions
See Also
--------
UnivariateSpline :
a smooth univariate spline to fit a given set of data points.
InterpolatedUnivariateSpline :
a interpolating univariate spline for a given set of data points.
splrep :
a function to find the B-spline representation of a 1-D curve
splev :
a function to evaluate a B-spline or its derivatives
sproot :
a function to find the roots of a cubic B-spline
splint :
a function to evaluate the definite integral of a B-spline between two
given points
spalde :
a function to evaluate all derivatives of a B-spline
Notes
-----
The number of data points must be larger than the spline degree `k`.
Knots `t` must satisfy the Schoenberg-Whitney conditions,
i.e., there must be a subset of data points ``x[j]`` such that
``t[j] < x[j] < t[j+k+1]``, for ``j=0, 1,...,n-k-2``.
Examples
--------
>>> import numpy as np
>>> from scipy.interpolate import LSQUnivariateSpline, UnivariateSpline
>>> import matplotlib.pyplot as plt
>>> rng = np.random.default_rng()
>>> x = np.linspace(-3, 3, 50)
>>> y = np.exp(-x**2) + 0.1 * rng.standard_normal(50)
Fit a smoothing spline with a pre-defined internal knots:
>>> t = [-1, 0, 1]
>>> spl = LSQUnivariateSpline(x, y, t)
>>> xs = np.linspace(-3, 3, 1000)
>>> plt.plot(x, y, 'ro', ms=5)
>>> plt.plot(xs, spl(xs), 'g-', lw=3)
>>> plt.show()
Check the knot vector:
>>> spl.get_knots()
array([-3., -1., 0., 1., 3.])
Constructing lsq spline using the knots from another spline:
>>> x = np.arange(10)
>>> s = UnivariateSpline(x, x, s=0)
>>> s.get_knots()
array([ 0., 2., 3., 4., 5., 6., 7., 9.])
>>> knt = s.get_knots()
>>> s1 = LSQUnivariateSpline(x, x, knt[1:-1]) # Chop 1st and last knot
>>> s1.get_knots()
array([ 0., 2., 3., 4., 5., 6., 7., 9.])
Nr r r Fc
�� � | � |||||d ||� � \ }}}}| _ t j t |� � dk � � st d� � �|d } |d }
| �|d } |
�|d }
t
| g|dz z ||
g|dz z f� � }t |� � } t j ||dz | |z
� ||| |z
dz
� z
dk d�� � st d� � �t j |||� � dk st t � � �t j |||||| |
�� � } | d d � d d | d fz | _ | �
� � d S )
Nr5 zx must be increasingr r r# )�axisz;Interior knots t must satisfy Schoenberg-Whitney conditions)r r r! ���)r$ r% r9 r< r r= r rG r �fpchec�_fpchec_error_string�fpcurfm1r( r) )
r* r+ r, rJ r r- r. r% r/ r r! rX r0 s
r1 r2 z LSQUnivariateSpline.__init__W s� � � #'�"5�"5�a��A�t�Q��69�<�#I� #I� ��1�a��t�x��v�d�1�g�g��n�%�%� 5� � 3�4�4� 4� �!�W��
�!�W��
�:��1��B�
�:��2��B� �"��q��s��Q���a��c�
�3� 4� 4�� ��F�F���v�a��!��A�a�C��j��1�Q�q�S��U�7��+�a�/�a�8�8�8� >� � =� >� >�
>���q�!�Q�'�'�1�,�,� � 1�2�2� 2�� ��A�q�!�q�R�B�?�?�?���#�2�#�Y�$��d�2�h�!7�7��
� �������r3 r� ra r3 r1 r r � sI � � � � � �n� n�` #'�d�V�A�X���U� � � � � � r3 r c �H � e Zd ZdZed� � � Zd� Zd� Zd� Zd d�Z d � Z
d
S ) �_BivariateSplineBasea� Base class for Bivariate spline s(x,y) interpolation on the rectangle
[xb,xe] x [yb, ye] calculated from a given set of data points
(x,y,z).
See Also
--------
bisplrep :
a function to find a bivariate B-spline representation of a surface
bisplev :
a function to evaluate a bivariate B-spline and its derivatives
BivariateSpline :
a base class for bivariate splines.
SphereBivariateSpline :
a bivariate spline on a spherical grid
c � � | � | � � }t |� � dk rt d� � �|dd� |_ |dd� |_ |S )z3Construct a spline object from given tck and degreer6 z4tck should be a 5 element tuple of tx, ty, c, kx, kyNr )rE rG r= rI �degrees)rH rI r* s r1 rL z _BivariateSplineBase._from_tck� s^ � � �{�{�3� � �� �s�8�8�q�=�=� � .� /� /�
/��r��r�7����1�2�2�w�� �� r3 c � � | j S )z� Return weighted sum of squared residuals of the spline
approximation: sum ((w[i]*(z[i]-s(x[i],y[i])))**2,axis=0)
)�fpr~ s r1 r z!_BivariateSplineBase.get_residual� s � � �w�r3 c � � | j dd� S )a Return a tuple (tx,ty) where tx,ty contain knots positions
of the spline with respect to x-, y-variable, respectively.
The position of interior and additional knots are given as
t[k+1:-k-1] and t[:k+1]=b, t[-k-1:]=e, respectively.
Nr �rI r~ s r1 rz z _BivariateSplineBase.get_knots� s � � �x����|�r3 c � � | j d S )z Return spline coefficients.r r� r~ s r1 r| z _BivariateSplineBase.get_coeffs� s � ��x��{�r3 r Tc �P � t j |� � }t j |� � }| j dd� \ }}}| j \ } }
|�rD|j dk s |j dk r2t j |j |j f| j d j �� � S |j dk r9t j t j |� � dk � � st d� � �|j dk r9t j t j |� � dk � � st d� � �|s|r9t j |||| |
||||� � \ } } | dk st d | z � � ��nPt j |||| |
||� � \ } } | dk st d
| z � � ��n|j
|j
k rt j ||� � \ }}|j
}
|� � � }|� � � }|j dk s |j dk r&t j |
| j d j �� � S |s|r8t j |||| |
||||� � \ } } | dk st d | z � � �n5t j |||| |
||� � \ } } | dk st d | z � � �| � |
� � } | S )
a�
Evaluate the spline or its derivatives at given positions.
Parameters
----------
x, y : array_like
Input coordinates.
If `grid` is False, evaluate the spline at points ``(x[i],
y[i]), i=0, ..., len(x)-1``. Standard Numpy broadcasting
is obeyed.
If `grid` is True: evaluate spline at the grid points
defined by the coordinate arrays x, y. The arrays must be
sorted to increasing order.
Note that the axis ordering is inverted relative to
the output of meshgrid.
dx : int
Order of x-derivative
.. versionadded:: 0.14.0
dy : int
Order of y-derivative
.. versionadded:: 0.14.0
grid : bool
Whether to evaluate the results on a grid spanned by the
input arrays, or at points specified by the input arrays.
.. versionadded:: 0.14.0
Nr r r ��dtyper5 z1x must be strictly increasing when `grid` is Truez1y must be strictly increasing when `grid` is Truez!Error code returned by parder: %sz!Error code returned by bispev: %sz!Error code returned by pardeu: %sz!Error code returned by bispeu: %s)r9 r: rI r� r> r
r� r< r r= r �parder�bispevr? �broadcast_arraysr �pardeu�bispeu�reshape)r* r+ r, �dx�dy�grid�tx�tyrK �kx�ky�zrY r? s r1 rv z _BivariateSplineBase.__call__� s� � �D
�J�q�M�M�� �J�q�M�M���H�R�a�R�L� ��B��� ���B� � & !��v��{�{�a�f��k�k��x����� 0���� �8I�J�J�J�J���!� � �b�f�R�W�Q�Z�Z�3�->�&?�&?� � �!T�U�U�U���!� � �b�f�R�W�Q�Z�Z�3�->�&?�&?� � �!T�U�U�U��
P�R�
P�!� ��R��B��B��A�q�I�I���3��a�x�x�$�%H�3�%N�O�O�O� � "� ��R��B��A�q�A�A���3��a�x�x�$�%H�3�%N�O�O�O� � �w�!�'�!�!��*�1�a�0�0���1��G�E���� � �A���� � �A��v��{�{�a�f��k�k��x��T�X�a�[�->�?�?�?�?��
P�R�
P�!� ��R��B��B��A�q�I�I���3��a�x�x�$�%H�3�%N�O�O�O� � "� ��R��B��A�q�A�A���3��a�x�x�$�%H�3�%N�O�O�O�� � �%� � �A��r3 c �. � |dk r|dk r| S | j \ }}|dk r|dk st d� � �||k r||k st d� � �| j dd� \ }}}t j |||||||� � \ }} | dk rt d| z � � �t |� � }
t |� � } |||
|z
� } ||| |z
� }
||z
||z
}}|
|z
|z
dz
| |z
|z
dz
z }t � | |
|d|� ||f� � S )a\ Construct a new spline representing a partial derivative of this
spline.
Parameters
----------
dx, dy : int
Orders of the derivative in x and y respectively. They must be
non-negative integers and less than the respective degree of the
original spline (self) in that direction (``kx``, ``ky``).
Returns
-------
spline :
A new spline of degrees (``kx - dx``, ``ky - dy``) representing the
derivative of this spline.
Notes
-----
.. versionadded:: 1.9.0
r z,order of derivative must be positive or zeroz6order of derivative must be less than degree of splineNr z,Unexpected error code returned by pardtc: %dr )r� r= rI r �pardtcrG �_DerivedBivariateSplinerL )r* r� r� r� r� r� r� rK �newcrY �nx�ny�newtx�newty�newkx�newky�newclens r1 �partial_derivativez'_BivariateSplineBase.partial_derivative� ss � �. ��7�7�r�Q�w�w��K��\�F�B���!�G�G��a��� � ")� *� *� *���G�G��R��� � "5� 6� 6� 6� ���!�� �I�B��A� ���B��2�r�2�r�B�B�I�D�#��a�x�x� � "/�14�"5� 6� 6� 6��R���B��R���B��r�"�r�'�z�N�E��r�"�r�'�z�N�E� ��7�B��G�5�E��B�w��|�a�'�B��G�b�L�1�,<�=�G�*�4�4�e�U�6:�8�G�8�n�6;�U�6D� E� E�
Er3 N�r r T) r� r� r� r� r� rL r rz r| rv r� ra r3 r1 r� r� t s� � � � � � �� � �� � �[��� � � � � �� � �N� N� N� N�`/E� /E� /E� /E� /Er3 r� z�
The required storage space exceeds the available storage space: nxest
or nyest too small, or s too small.
The weighted least-squares spline corresponds to the current set of
knots.z�
A theoretically impossible result was found during the iteration
process for finding a smoothing spline with fp = s: s too small or
badly chosen eps.
Weighted sum of squared residuals does not satisfy abs(fp-s)/s < tol.z�
the maximal number of iterations maxit (set to 20 by the program)
allowed for finding a smoothing spline with fp=s has been reached:
s too small.
Weighted sum of squared residuals does not satisfy abs(fp-s)/s < tol.z�
No more knots can be added because the number of b-spline coefficients
(nx-kx-1)*(ny-ky-1) already exceeds the number of data points m:
either s or m too small.
The weighted least-squares spline corresponds to the current set of
knots.z�
No more knots can be added because the additional knot would (quasi)
coincide with an old one: s too small or too large a weight to an
inaccurate data point.
The weighted least-squares spline corresponds to the current set of
knots.z�
Error on entry, no approximation returned. The following conditions
must hold:
xb<=x[i]<=xe, yb<=y[i]<=ye, w[i]>0, i=0..m-1
If iopt==-1, then
xb<tx[kx+1]<tx[kx+2]<...<tx[nx-kx-2]<xe
yb<ty[ky+1]<ty[ky+2]<...<ty[ny-ky-2]<yea
The coefficients of the spline returned have been computed as the
minimal norm least-squares solution of a (numerically) rank deficient
system (deficiency=%i). If deficiency is large, the results may be
inaccurate. Deficiency may strongly depend on the value of eps.)r r r � r6 r r� c �6 � e Zd ZdZdd�Zd� Zed� � � ZdS )r a
Base class for bivariate splines.
This describes a spline ``s(x, y)`` of degrees ``kx`` and ``ky`` on
the rectangle ``[xb, xe] * [yb, ye]`` calculated from a given set
of data points ``(x, y, z)``.
This class is meant to be subclassed, not instantiated directly.
To construct these splines, call either `SmoothBivariateSpline` or
`LSQBivariateSpline` or `RectBivariateSpline`.
See Also
--------
UnivariateSpline :
a smooth univariate spline to fit a given set of data points.
SmoothBivariateSpline :
a smoothing bivariate spline through the given points
LSQBivariateSpline :
a bivariate spline using weighted least-squares fitting
RectSphereBivariateSpline :
a bivariate spline over a rectangular mesh on a sphere
SmoothSphereBivariateSpline :
a smoothing bivariate spline in spherical coordinates
LSQSphereBivariateSpline :
a bivariate spline in spherical coordinates using weighted
least-squares fitting
RectBivariateSpline :
a bivariate spline over a rectangular mesh.
bisplrep :
a function to find a bivariate B-spline representation of a surface
bisplev :
a function to evaluate a bivariate B-spline and its derivatives
r c �6 � | � ||||d�� � S )a�
Evaluate the spline at points
Returns the interpolated value at ``(xi[i], yi[i]),
i=0,...,len(xi)-1``.
Parameters
----------
xi, yi : array_like
Input coordinates. Standard Numpy broadcasting is obeyed.
dx : int, optional
Order of x-derivative
.. versionadded:: 0.14.0
dy : int, optional
Order of y-derivative
.. versionadded:: 0.14.0
F�r� r� r� �rv )r* �xi�yir� r� s r1 �evzBivariateSpline.evq s � �( �}�}�R���r��}�>�>�>r3 c �t � | j dd� \ }}}| j \ }} t j ||||| ||||� � S )a�
Evaluate the integral of the spline over area [xa,xb] x [ya,yb].
Parameters
----------
xa, xb : float
The end-points of the x integration interval.
ya, yb : float
The end-points of the y integration interval.
Returns
-------
integ : float
The value of the resulting integral.
Nr )rI r� r �dblint)
r* �xar �ya�ybr� r� rK r� r� s
r1 r� zBivariateSpline.integral� sD � �" �H�R�a�R�L� ��B��� ���B���r�2�q�"�b�"�b�"�b�A�A�Ar3 c � � t j | � � t j |� � t j |� � }}} | j |j cxk r |j k sn t d� � �|�Zt j |� � }| j |j k rt d� � �t j |dk � � st d� � �|� d|cxk rdk sn t d� � �| j |dz |dz z k st d� � �| |||fS ) Nz%x, y, and z should have a same lengthz(x, y, z, and w should have a same lengthr5 �w should be positive� �?� eps should be between (0, 1)r z;The length of x, y and z should be at least (kx+1) * (ky+1))r9 r: r> r= r< )r+ r, r� r r� r� �epss r1 �_validate_inputz BivariateSpline._validate_input� s � ��*�Q�-�-���A� � ��
�1�
�
�a�1���v���)�)�)�)�1�6�)�)�)�)� � D�E�E� E� �=��
�1�
�
�A��v��� � � �!K�L�L�L��V�A��H�%�%�
9� �!7�8�8�8� �O�c�C�o�o�o�o�#�o�o�o�o� � ;�<�<� <��v�"�q�&�R�!�V�,�,�,� � 0� 1� 1�
1��!�Q��z�r3 N�r r )r� r� r� r� r� r� r� r� ra r3 r1 r r N s` � � � � � � � �D?� ?� ?� ?�,B� B� B�* �� � �\�� � r3 r c �2 � e Zd ZdZdZed� � � Zd� ZdS )r� a� Bivariate spline constructed from the coefficients and knots of another
spline.
Notes
-----
The class is not meant to be instantiated directly from the data to be
interpolated or smoothed. As a result, its ``fp`` attribute and
``get_residual`` method are inherited but overriden; ``AttributeError`` is
raised when they are accessed.
The other inherited attributes can be used as usual.
z�is unavailable, because _DerivedBivariateSpline instance is not constructed from data that are to be interpolated or smoothed, but derived from the underlying knots and coefficients of another spline objectc �0 � t d| j z � � �)Nzattribute "fp" %s��AttributeError� _invalid_whyr~ s r1 r� z_DerivedBivariateSpline.fp� s � � � 2�T�5F� F�G�G�Gr3 c �0 � t d| j z � � �)Nzmethod "get_residual" %sr� r~ s r1 r z$_DerivedBivariateSpline.get_residual� s � � � 9�D�<M� M�N�N�Nr3 N)r� r� r� r� r� �propertyr� r ra r3 r1 r� r� � sW � � � � � � � � �L� �H� H� �X�H�O� O� O� O� Or3 r� c �. � e Zd ZdZddgdz ddddfd�ZdS )r aI
Smooth bivariate spline approximation.
Parameters
----------
x, y, z : array_like
1-D sequences of data points (order is not important).
w : array_like, optional
Positive 1-D sequence of weights, of same length as `x`, `y` and `z`.
bbox : array_like, optional
Sequence of length 4 specifying the boundary of the rectangular
approximation domain. By default,
``bbox=[min(x), max(x), min(y), max(y)]``.
kx, ky : ints, optional
Degrees of the bivariate spline. Default is 3.
s : float, optional
Positive smoothing factor defined for estimation condition:
``sum((w[i]*(z[i]-s(x[i], y[i])))**2, axis=0) <= s``
Default ``s=len(w)`` which should be a good value if ``1/w[i]`` is an
estimate of the standard deviation of ``z[i]``.
eps : float, optional
A threshold for determining the effective rank of an over-determined
linear system of equations. `eps` should have a value within the open
interval ``(0, 1)``, the default is 1e-16.
See Also
--------
BivariateSpline :
a base class for bivariate splines.
UnivariateSpline :
a smooth univariate spline to fit a given set of data points.
LSQBivariateSpline :
a bivariate spline using weighted least-squares fitting
RectSphereBivariateSpline :
a bivariate spline over a rectangular mesh on a sphere
SmoothSphereBivariateSpline :
a smoothing bivariate spline in spherical coordinates
LSQSphereBivariateSpline :
a bivariate spline in spherical coordinates using weighted
least-squares fitting
RectBivariateSpline :
a bivariate spline over a rectangular mesh
bisplrep :
a function to find a bivariate B-spline representation of a surface
bisplev :
a function to evaluate a bivariate B-spline and its derivatives
Notes
-----
The length of `x`, `y` and `z` should be at least ``(kx+1) * (ky+1)``.
If the input data is such that input dimensions have incommensurate
units and differ by many orders of magnitude, the interpolant may have
numerical artifacts. Consider rescaling the data before interpolating.
This routine constructs spline knot vectors automatically via the FITPACK
algorithm. The spline knots may be placed away from the data points. For
some data sets, this routine may fail to construct an interpolating spline,
even if one is requested via ``s=0`` parameter. In such situations, it is
recommended to use `bisplrep` / `bisplev` directly instead of this routine
and, if needed, increase the values of ``nxest`` and ``nyest`` parameters
of `bisplrep`.
For linear interpolation, prefer `LinearNDInterpolator`.
See ``https://gist.github.com/ev-br/8544371b40f414b7eaf3fe6217209bff``
for discussion.
Nr� r 缉ؗ�Ҝ<c
�x � | � ||||||| � � \ }}}}t |� � }|j dk st d� � �|�|dk st d� � �|\ }
} } }
t j |||||
| | |
|||| d��
�
\ }}}}}}}}|dk r*t j |||||
| | |
|||| |��
�
\ }}}}}}}}|dv rn2t � |d |z � � }t j |� � || _
|d |� |d |� |d ||z
dz
||z
dz
z � f| _ ||f| _ d S )
N�r� �bbox shape should be (4,)r5 r7 r )r" r� �lwrk2r �r r# rQ rR )
r� r r? r= r � surfit_smth�_surfit_messagesrU rV rW r� rI r� )r* r+ r, r� r r- r� r� r" r� r r! r� �yer� r� r� r� rK r� �wrk1rY rZ s r1 r2 z SmoothBivariateSpline.__init__ s� � � �)�)�!�Q��1�b�"�c�B�B�
��1�a���T�{�{���z�T�!�!� � 8�9�9� 9� �=��c��� � 3�4�4� 4� ���B��B�+3�+?��1�a��@B�B��@B�B��BC��FG� ,I� ,I� ,I�(��B��B��2�t�S�
��8�8�/7�/C�A�q�!�Q�DF��B�DF��B�FG�HK�JM� 0O� 0O� 0O� ,�B��B��A�r�4�� �+� � � �&�*�*�3��C�0@�A�A�G� �M�'� "� "� "�����c�r�c�7�B�s��s�G�Q�';��B��q��2�b�5��7�(;�';�%<�<����2�v�� � � r3 r� ra r3 r1 r r � sK � � � � � �C� C�J #'�d�V�a�Z�A�!�t�� � � � � � r3 r c �, � e Zd ZdZddgdz dddfd�ZdS )r a
Weighted least-squares bivariate spline approximation.
Parameters
----------
x, y, z : array_like
1-D sequences of data points (order is not important).
tx, ty : array_like
Strictly ordered 1-D sequences of knots coordinates.
w : array_like, optional
Positive 1-D array of weights, of the same length as `x`, `y` and `z`.
bbox : (4,) array_like, optional
Sequence of length 4 specifying the boundary of the rectangular
approximation domain. By default,
``bbox=[min(x,tx),max(x,tx), min(y,ty),max(y,ty)]``.
kx, ky : ints, optional
Degrees of the bivariate spline. Default is 3.
eps : float, optional
A threshold for determining the effective rank of an over-determined
linear system of equations. `eps` should have a value within the open
interval ``(0, 1)``, the default is 1e-16.
See Also
--------
BivariateSpline :
a base class for bivariate splines.
UnivariateSpline :
a smooth univariate spline to fit a given set of data points.
SmoothBivariateSpline :
a smoothing bivariate spline through the given points
RectSphereBivariateSpline :
a bivariate spline over a rectangular mesh on a sphere
SmoothSphereBivariateSpline :
a smoothing bivariate spline in spherical coordinates
LSQSphereBivariateSpline :
a bivariate spline in spherical coordinates using weighted
least-squares fitting
RectBivariateSpline :
a bivariate spline over a rectangular mesh.
bisplrep :
a function to find a bivariate B-spline representation of a surface
bisplev :
a function to evaluate a bivariate B-spline and its derivatives
Notes
-----
The length of `x`, `y` and `z` should be at least ``(kx+1) * (ky+1)``.
If the input data is such that input dimensions have incommensurate
units and differ by many orders of magnitude, the interpolant may have
numerical artifacts. Consider rescaling the data before interpolating.
Nr� r c � � | � |||||| |
� � \ }}}}t |� � }|j dk st d� � �d|z dz t |� � z } d| z dz t |� � z } t | | � � }
t
|
ft � � }t
|
ft � � }|||dz | |z
dz
�< ||| dz | | z
dz
�< |\ }}}}t j |||| || |||||||| |
d�� � \ }}}}}|dk r*t j |||| || |||||||| |
|�� � \ }}}}}|dv rnj|dk r2| |z
dz
| | z
dz
z |z }t � d � � |z }n t � |d
|z � � }t j
|� � || _ |d | � |d | � |f| _ || f| _ d S ) Nr� r� r r )r� r r� rQ r� rR )r� r r? r= rG �maxr
�floatr �
surfit_lsqr� rU rV rW r� rI r� )r* r+ r, r� r� r� r r- r� r� r� r� r� �nmax�tx1�ty1r r! r� r� rK r� rY �
deficiencyrZ s r1 r2 zLSQBivariateSpline.__init__j s< � � �)�)�!�Q��1�b�"�c�B�B�
��1�a���T�{�{���z�T�!�!� � 8�9�9� 9�
�r�T�!�V�C��G�G�^��
�r�T�!�V�C��G�G�^�� �2�r�{�{���T�G�U�#�#���T�G�U�#�#�� ��B�q�D��B��q��L�� ��B�q�D��B��q��L�� ���B��B� '� 2�1�a��B��R��34�b�"�b�"�35�r�3�a� I� I� I� ��S�!�R�� ��8�8�#+�#6�q�!�Q�79�3��C��79�2�r�2�79�2�s�#�$O� $O� $O� �C��a��S� �+� � � ��R�x�x� ��e�A�g��2��a�� 0�� 4�
�*�.�.�r�2�2�j�A���*�.�.�s�H��4D�E�E�� �M�'� "� "� "�����s��s�8�S��"��X�q�(����2�v�� � � r3 r� ra r3 r1 r r 3 sG � � � � � �4� 4�l +/�d�V�A�X�!���) � ) � ) � ) � ) � ) r3 r c �* � e Zd ZdZdgdz dddfd�ZdS )r
a/
Bivariate spline approximation over a rectangular mesh.
Can be used for both smoothing and interpolating data.
Parameters
----------
x,y : array_like
1-D arrays of coordinates in strictly ascending order.
Evaluated points outside the data range will be extrapolated.
z : array_like
2-D array of data with shape (x.size,y.size).
bbox : array_like, optional
Sequence of length 4 specifying the boundary of the rectangular
approximation domain, which means the start and end spline knots of
each dimension are set by these values. By default,
``bbox=[min(x), max(x), min(y), max(y)]``.
kx, ky : ints, optional
Degrees of the bivariate spline. Default is 3.
s : float, optional
Positive smoothing factor defined for estimation condition:
``sum((z[i]-f(x[i], y[i]))**2, axis=0) <= s`` where f is a spline
function. Default is ``s=0``, which is for interpolation.
See Also
--------
BivariateSpline :
a base class for bivariate splines.
UnivariateSpline :
a smooth univariate spline to fit a given set of data points.
SmoothBivariateSpline :
a smoothing bivariate spline through the given points
LSQBivariateSpline :
a bivariate spline using weighted least-squares fitting
RectSphereBivariateSpline :
a bivariate spline over a rectangular mesh on a sphere
SmoothSphereBivariateSpline :
a smoothing bivariate spline in spherical coordinates
LSQSphereBivariateSpline :
a bivariate spline in spherical coordinates using weighted
least-squares fitting
bisplrep :
a function to find a bivariate B-spline representation of a surface
bisplev :
a function to evaluate a bivariate B-spline and its derivatives
Notes
-----
If the input data is such that input dimensions have incommensurate
units and differ by many orders of magnitude, the interpolant may have
numerical artifacts. Consider rescaling the data before interpolating.
Nr� r r c � � t |� � t |� � t |� � }}}t j |� � }t j t |� � dk � � st d� � �t j t |� � dk � � st d� � �|j |j d k st d� � �|j |j d k st d� � �|j dk st d � � �|�|dk st d
� � �t |� � }|\ }} }
} t j ||||| |
| |||�
�
\ } }
}}}}}|d vr-t � |d |z � � }t |� � �|| _ |
d | � |d |� |d | |z
dz
||z
dz
z � f| _
||f| _ d S )
Nr5 r� z y must be strictly increasingr z7x dimension of z must have same number of elements as xr z7y dimension of z must have same number of elements as yr� r� r7 r� rR )r r9 r: r< r r= r> r? r � regrid_smthr� rU r� rI r� )r* r+ r, r� r- r� r� r" r r! r� r� r� r� r� r� rK r� rY �msgs r1 r2 z RectBivariateSpline.__init__� s� � ��1�X�X�u�Q�x�x��t���d�1�� �J�q�M�M���v�d�1�g�g��m�$�$� >� � <�=�=� =��v�d�1�g�g��m�$�$� >� � <�=�=� =��v�����#�#� � -� .� .�
.��v�����#�#� � -� .� .�
.��z�T�!�!� � 8�9�9� 9� �=��c��� � 3�4�4� 4� �!�H�H�� ���B��B�%-�%9�!�Q��2�r�2�:<�b�"�a�&I� &I�"��B��B��2�s� �k� !� !�"�&�&�s�H��,<�=�=�C� �S�/�/� !�����c�r�c�7�B�s��s�G�Q�'E��b��1���b��1��(E�'E�%F�F����2�v�� � � r3 r� ra r3 r1 r
r
� sD � � � � � �5� 5�n '+�V�a�Z�A�!�q� � � � � � r3 r
a�
ERROR. On entry, the input data are controlled on validity. The following
restrictions must be satisfied:
-1<=iopt<=1, m>=2, ntest>=8 ,npest >=8, 0<eps<1,
0<=teta(i)<=pi, 0<=phi(i)<=2*pi, w(i)>0, i=1,...,m
lwrk1 >= 185+52*v+10*u+14*u*v+8*(u-1)*v**2+8*m
kwrk >= m+(ntest-7)*(npest-7)
if iopt=-1: 8<=nt<=ntest , 9<=np<=npest
0<tt(5)<tt(6)<...<tt(nt-4)<pi
0<tp(5)<tp(6)<...<tp(np-4)<2*pi
if iopt>=0: s>=0
if one of these conditions is found to be violated,control
is immediately repassed to the calling program. in that
case there is no approximation returned.r a�
WARNING. The coefficients of the spline returned have been computed as the
minimal norm least-squares solution of a (numerically) rank
deficient system (deficiency=%i, rank=%i). Especially if the rank
deficiency, which is computed by 6+(nt-8)*(np-7)+ier, is large,
the results may be inaccurate. They could also seriously depend on
the value of eps.r� c �" � e Zd ZdZdd�Zdd�ZdS ) �SphereBivariateSplineau
Bivariate spline s(x,y) of degrees 3 on a sphere, calculated from a
given set of data points (theta,phi,r).
.. versionadded:: 0.11.0
See Also
--------
bisplrep :
a function to find a bivariate B-spline representation of a surface
bisplev :
a function to evaluate a bivariate B-spline and its derivatives
UnivariateSpline :
a smooth univariate spline to fit a given set of data points.
SmoothBivariateSpline :
a smoothing bivariate spline through the given points
LSQUnivariateSpline :
a univariate spline using weighted least-squares fitting
r Tc �: � t j |� � }t j |� � }|j dk rI|� � � dk s"|� � � t j k rt
d� � �t � | |||||�� � S )a�
Evaluate the spline or its derivatives at given positions.
Parameters
----------
theta, phi : array_like
Input coordinates.
If `grid` is False, evaluate the spline at points
``(theta[i], phi[i]), i=0, ..., len(x)-1``. Standard
Numpy broadcasting is obeyed.
If `grid` is True: evaluate spline at the grid points
defined by the coordinate arrays theta, phi. The arrays
must be sorted to increasing order.
dtheta : int, optional
Order of theta-derivative
.. versionadded:: 0.14.0
dphi : int
Order of phi-derivative
.. versionadded:: 0.14.0
grid : bool
Whether to evaluate the results on a grid spanned by the
input arrays, or at points specified by the input arrays.
.. versionadded:: 0.14.0
r r5 z requested theta out of bounds.r� ) r9 r: r> �minr� �pir= r� rv �r* �theta�phi�dtheta�dphir� s r1 rv z SphereBivariateSpline.__call__ s� � �> �
�5�!�!���j��o�o�� �:��>�>�u�y�y�{�{�R� /� /�5�9�9�;�;���3F�3F� � =�>�>� >�#�,�,�T�5�#�06�4�d� -� L� L� Lr3 c �6 � | � ||||d�� � S )a�
Evaluate the spline at points
Returns the interpolated value at ``(theta[i], phi[i]),
i=0,...,len(theta)-1``.
Parameters
----------
theta, phi : array_like
Input coordinates. Standard Numpy broadcasting is obeyed.
dtheta : int, optional
Order of theta-derivative
.. versionadded:: 0.14.0
dphi : int, optional
Order of phi-derivative
.. versionadded:: 0.14.0
F�r r r� r� )r* r r r r s r1 r� zSphereBivariateSpline.evC s � �( �}�}�U�C��T��}�N�N�Nr3 Nr� r� )r� r� r� r� rv r� ra r3 r1 r� r� sQ � � � � � �� �(&L� &L� &L� &L�PO� O� O� O� O� Or3 r� c �" � e Zd ZdZd d�Zd
d�ZdS ) r a�
Smooth bivariate spline approximation in spherical coordinates.
.. versionadded:: 0.11.0
Parameters
----------
theta, phi, r : array_like
1-D sequences of data points (order is not important). Coordinates
must be given in radians. Theta must lie within the interval
``[0, pi]``, and phi must lie within the interval ``[0, 2pi]``.
w : array_like, optional
Positive 1-D sequence of weights.
s : float, optional
Positive smoothing factor defined for estimation condition:
``sum((w(i)*(r(i) - s(theta(i), phi(i))))**2, axis=0) <= s``
Default ``s=len(w)`` which should be a good value if ``1/w[i]`` is an
estimate of the standard deviation of ``r[i]``.
eps : float, optional
A threshold for determining the effective rank of an over-determined
linear system of equations. `eps` should have a value within the open
interval ``(0, 1)``, the default is 1e-16.
See Also
--------
BivariateSpline :
a base class for bivariate splines.
UnivariateSpline :
a smooth univariate spline to fit a given set of data points.
SmoothBivariateSpline :
a smoothing bivariate spline through the given points
LSQBivariateSpline :
a bivariate spline using weighted least-squares fitting
RectSphereBivariateSpline :
a bivariate spline over a rectangular mesh on a sphere
LSQSphereBivariateSpline :
a bivariate spline in spherical coordinates using weighted
least-squares fitting
RectBivariateSpline :
a bivariate spline over a rectangular mesh.
bisplrep :
a function to find a bivariate B-spline representation of a surface
bisplev :
a function to evaluate a bivariate B-spline and its derivatives
Notes
-----
For more information, see the FITPACK_ site about this function.
.. _FITPACK: http://www.netlib.org/dierckx/sphere.f
Examples
--------
Suppose we have global data on a coarse grid (the input data does not
have to be on a grid):
>>> import numpy as np
>>> theta = np.linspace(0., np.pi, 7)
>>> phi = np.linspace(0., 2*np.pi, 9)
>>> data = np.empty((theta.shape[0], phi.shape[0]))
>>> data[:,0], data[0,:], data[-1,:] = 0., 0., 0.
>>> data[1:-1,1], data[1:-1,-1] = 1., 1.
>>> data[1,1:-1], data[-2,1:-1] = 1., 1.
>>> data[2:-2,2], data[2:-2,-2] = 2., 2.
>>> data[2,2:-2], data[-3,2:-2] = 2., 2.
>>> data[3,3:-2] = 3.
>>> data = np.roll(data, 4, 1)
We need to set up the interpolator object
>>> lats, lons = np.meshgrid(theta, phi)
>>> from scipy.interpolate import SmoothSphereBivariateSpline
>>> lut = SmoothSphereBivariateSpline(lats.ravel(), lons.ravel(),
... data.T.ravel(), s=3.5)
As a first test, we'll see what the algorithm returns when run on the
input coordinates
>>> data_orig = lut(theta, phi)
Finally we interpolate the data to a finer grid
>>> fine_lats = np.linspace(0., np.pi, 70)
>>> fine_lons = np.linspace(0., 2 * np.pi, 90)
>>> data_smth = lut(fine_lats, fine_lons)
>>> import matplotlib.pyplot as plt
>>> fig = plt.figure()
>>> ax1 = fig.add_subplot(131)
>>> ax1.imshow(data, interpolation='nearest')
>>> ax2 = fig.add_subplot(132)
>>> ax2.imshow(data_orig, interpolation='nearest')
>>> ax3 = fig.add_subplot(133)
>>> ax3.imshow(data_smth, interpolation='nearest')
>>> plt.show()
Nr5 r� c � � t j |� � t j |� � t j |� � }}}d|k � � � r"|t j k � � � st d� � �d|k � � � r%|dt j z k � � � st d� � �|�;t j |� � }|dk � � � st d� � �|dk st d� � �d|cxk rdk sn t d� � �t j |t � � r t t |� � � � |z }t j
||||||� � � \ }}} }
} } }
|
d
vr-t � |
d |
z � � }t |� � �| | _
|d |� |
d | � | d |d z
| d z
z � f| _ d
| _ d S )Nr5 � theta should be between [0, pi]� @� phi should be between [0, 2pi]r� �s should be positiver� r� )r r" r� r� rR r� �r r )r9 r: r< r r= � issubclass_r� r rG r �
spherfit_smth�_spherefit_messagesrU r� rI r� )r* r r �rr r" r� �nt_�tt_�np_�tp_rK r� rY rZ s r1 r2 z$SmoothSphereBivariateSpline.__init__� s � ��
�5�)�)�2�:�c�?�?�B�J�q�M�M�A�s�� �� �"�"�$�$� @�%�2�5�.�)=�)=�)?�)?� @� � >�?�?� ?���� � �"�"� ?��s�R�U�{�(:�'?�'?�'A�'A� ?� � =�>�>� >� �=��
�1�
�
�A���H�>�>�#�#�
9� �!7�8�8�8��C�x�x� � 3�4�4� 4��S�����3����� � ;�<�<� <�
�>�!�U� #� #� %��S��Z�Z� � �1�$�A�)1�)?��s�@A�Q�!�DG�*I� *I� *I�&��S�#�s�A�r�3� �k� !� !�)�-�-�c�8�s�3C�D�D�G� �W�%�%� %�����t��t�9�c�$�3�$�i��+A�S�1�W��q��,A�+A�)B�B��� �� � � r3 r Tc �@ � t j |� � }t j |� � }|j dk rL|� � � dk s%|� � � dt j z k rt
d� � �t � | |||||�� � S �Nr r5 r z requested phi out of bounds.r � r9 r: r> r r� r r= r� rv r s r1 rv z$SmoothSphereBivariateSpline.__call__� � � ��
�5�!�!���j��o�o�� �8�a�<�<�S�W�W�Y�Y��^�^�s�w�w�y�y�2���:�/E�/E� � ;�<�<� <�$�-�-�d�E�3�v�37�d� .� D� D� Dr3 )Nr5 r� r� �r� r� r� r� r2 rv ra r3 r1 r r Z sO � � � � � �a� a�F � � � �> D� D� D� D� D� Dr3 r c �" � e Zd ZdZdd�Zd d�ZdS )
r a�
Weighted least-squares bivariate spline approximation in spherical
coordinates.
Determines a smoothing bicubic spline according to a given
set of knots in the `theta` and `phi` directions.
.. versionadded:: 0.11.0
Parameters
----------
theta, phi, r : array_like
1-D sequences of data points (order is not important). Coordinates
must be given in radians. Theta must lie within the interval
``[0, pi]``, and phi must lie within the interval ``[0, 2pi]``.
tt, tp : array_like
Strictly ordered 1-D sequences of knots coordinates.
Coordinates must satisfy ``0 < tt[i] < pi``, ``0 < tp[i] < 2*pi``.
w : array_like, optional
Positive 1-D sequence of weights, of the same length as `theta`, `phi`
and `r`.
eps : float, optional
A threshold for determining the effective rank of an over-determined
linear system of equations. `eps` should have a value within the
open interval ``(0, 1)``, the default is 1e-16.
See Also
--------
BivariateSpline :
a base class for bivariate splines.
UnivariateSpline :
a smooth univariate spline to fit a given set of data points.
SmoothBivariateSpline :
a smoothing bivariate spline through the given points
LSQBivariateSpline :
a bivariate spline using weighted least-squares fitting
RectSphereBivariateSpline :
a bivariate spline over a rectangular mesh on a sphere
SmoothSphereBivariateSpline :
a smoothing bivariate spline in spherical coordinates
RectBivariateSpline :
a bivariate spline over a rectangular mesh.
bisplrep :
a function to find a bivariate B-spline representation of a surface
bisplev :
a function to evaluate a bivariate B-spline and its derivatives
Notes
-----
For more information, see the FITPACK_ site about this function.
.. _FITPACK: http://www.netlib.org/dierckx/sphere.f
Examples
--------
Suppose we have global data on a coarse grid (the input data does not
have to be on a grid):
>>> from scipy.interpolate import LSQSphereBivariateSpline
>>> import numpy as np
>>> import matplotlib.pyplot as plt
>>> theta = np.linspace(0, np.pi, num=7)
>>> phi = np.linspace(0, 2*np.pi, num=9)
>>> data = np.empty((theta.shape[0], phi.shape[0]))
>>> data[:,0], data[0,:], data[-1,:] = 0., 0., 0.
>>> data[1:-1,1], data[1:-1,-1] = 1., 1.
>>> data[1,1:-1], data[-2,1:-1] = 1., 1.
>>> data[2:-2,2], data[2:-2,-2] = 2., 2.
>>> data[2,2:-2], data[-3,2:-2] = 2., 2.
>>> data[3,3:-2] = 3.
>>> data = np.roll(data, 4, 1)
We need to set up the interpolator object. Here, we must also specify the
coordinates of the knots to use.
>>> lats, lons = np.meshgrid(theta, phi)
>>> knotst, knotsp = theta.copy(), phi.copy()
>>> knotst[0] += .0001
>>> knotst[-1] -= .0001
>>> knotsp[0] += .0001
>>> knotsp[-1] -= .0001
>>> lut = LSQSphereBivariateSpline(lats.ravel(), lons.ravel(),
... data.T.ravel(), knotst, knotsp)
As a first test, we'll see what the algorithm returns when run on the
input coordinates
>>> data_orig = lut(theta, phi)
Finally we interpolate the data to a finer grid
>>> fine_lats = np.linspace(0., np.pi, 70)
>>> fine_lons = np.linspace(0., 2*np.pi, 90)
>>> data_lsq = lut(fine_lats, fine_lons)
>>> fig = plt.figure()
>>> ax1 = fig.add_subplot(131)
>>> ax1.imshow(data, interpolation='nearest')
>>> ax2 = fig.add_subplot(132)
>>> ax2.imshow(data_orig, interpolation='nearest')
>>> ax3 = fig.add_subplot(133)
>>> ax3.imshow(data_lsq, interpolation='nearest')
>>> plt.show()
Nr� c �, � t j |� � t j |� � t j |� � }}}t j |� � t j |� � }}d|k � � � r"|t j k � � � st d� � �d|k � � � r%|dt j z k � � � st d� � �d|k � � � r"|t j k � � � st d� � �d|k � � � r%|dt j z k � � � st d� � �|�;t j |� � }|dk � � � st d� � �d|cxk rdk sn t d � � �t j |t � � r t t |� � � � |z }d
t |� � z d
t |� � z } }t |ft � � t | ft � � } }
||c|
d d �< | d d �< t j d
t j z c|
d d �< | d d �< t j ||||
| ||�� � \ }
} } }
}|dk r-t �
|d|z � � }t |� � �|
| _ |
| | f| _ d| _ d S )Nr5 r r r
z tt should be between (0, pi)z tp should be between (0, 2pi)r� r� r� rO r� ���r )r r� r rR r )r9 r: r< r r= r r� r rG r
r � spherfit_lsqr rU r� rI r� )r* r r r �tt�tpr r� r r r r rK r� rY rZ s r1 r2 z!LSQSphereBivariateSpline.__init__U s� � ��
�5�)�)�2�:�c�?�?�B�J�q�M�M�A�s����B� � ���B� � �B���� �"�"�$�$� @�%�2�5�.�)=�)=�)?�)?� @� � >�?�?� ?���� � �"�"� ?��q���w��';�';�'=�'=� ?� � =�>�>� >��r���� � � =�b�2�5�j�%5�%5�%7�%7� =� � ;�<�<� <��r���� � � >�b�1�R�U�7�l�%7�%7�%9�%9� >� � <�=�=� =� �=��
�1�
�
�A���H�>�>�#�#�
9� �!7�8�8�8��S�����3����� � ;�<�<� <�
�>�!�U� #� #� %��S��Z�Z� � �1�$�A��s�2�w�w�;��C��G�G� �S���#���'�'���v�u�)=�)=�S�� !�2� ��A�b�D� �3�q��t�9� �U�B���J���B�C�C��#�b�c�c�(� '� 4�U�C��C��78�c� C� C� C� ��S�!�R�� ��7�7�)�-�-�c�8�s�3C�D�D�G� �W�%�%� %������Q�;��� �� � � r3 r Tc �@ � t j |� � }t j |� � }|j dk rL|� � � dk s%|� � � dt j z k rt
d� � �t � | |||||�� � S r r r s r1 rv z!LSQSphereBivariateSpline.__call__y r r3 )Nr� r� r ra r3 r1 r r � sP � � � � � �i� i�V" � " � " � " �H D� D� D� D� D� Dr3 r a�
ERROR: on entry, the input data are controlled on validity
the following restrictions must be satisfied.
-1<=iopt(1)<=1, 0<=iopt(2)<=1, 0<=iopt(3)<=1,
-1<=ider(1)<=1, 0<=ider(2)<=1, ider(2)=0 if iopt(2)=0.
-1<=ider(3)<=1, 0<=ider(4)<=1, ider(4)=0 if iopt(3)=0.
mu >= mumin (see above), mv >= 4, nuest >=8, nvest >= 8,
kwrk>=5+mu+mv+nuest+nvest,
lwrk >= 12+nuest*(mv+nvest+3)+nvest*24+4*mu+8*mv+max(nuest,mv+nvest)
0< u(i-1)<u(i)< pi,i=2,..,mu,
-pi<=v(1)< pi, v(1)<v(i-1)<v(i)<v(1)+2*pi, i=3,...,mv
if iopt(1)=-1: 8<=nu<=min(nuest,mu+6+iopt(2)+iopt(3))
0<tu(5)<tu(6)<...<tu(nu-4)< pi
8<=nv<=min(nvest,mv+7)
v(1)<tv(5)<tv(6)<...<tv(nv-4)<v(1)+2*pi
the schoenberg-whitney conditions, i.e. there must be
subset of grid co-ordinates uu(p) and vv(q) such that
tu(p) < uu(p) < tu(p+4) ,p=1,...,nu-4
(iopt(2)=1 and iopt(3)=1 also count for a uu-value
tv(q) < vv(q) < tv(q+4) ,q=1,...,nv-4
(vv(q) is either a value v(j) or v(j)+2*pi)
if iopt(1)>=0: s>=0
if s=0: nuest>=mu+6+iopt(2)+iopt(3), nvest>=mv+7
if one of these conditions is found to be violated,control is
immediately repassed to the calling program. in that case there is no
approximation returned.c �& � e Zd ZdZ d d�Zd
d�ZdS ) r a}
Bivariate spline approximation over a rectangular mesh on a sphere.
Can be used for smoothing data.
.. versionadded:: 0.11.0
Parameters
----------
u : array_like
1-D array of colatitude coordinates in strictly ascending order.
Coordinates must be given in radians and lie within the open interval
``(0, pi)``.
v : array_like
1-D array of longitude coordinates in strictly ascending order.
Coordinates must be given in radians. First element (``v[0]``) must lie
within the interval ``[-pi, pi)``. Last element (``v[-1]``) must satisfy
``v[-1] <= v[0] + 2*pi``.
r : array_like
2-D array of data with shape ``(u.size, v.size)``.
s : float, optional
Positive smoothing factor defined for estimation condition
(``s=0`` is for interpolation).
pole_continuity : bool or (bool, bool), optional
Order of continuity at the poles ``u=0`` (``pole_continuity[0]``) and
``u=pi`` (``pole_continuity[1]``). The order of continuity at the pole
will be 1 or 0 when this is True or False, respectively.
Defaults to False.
pole_values : float or (float, float), optional
Data values at the poles ``u=0`` and ``u=pi``. Either the whole
parameter or each individual element can be None. Defaults to None.
pole_exact : bool or (bool, bool), optional
Data value exactness at the poles ``u=0`` and ``u=pi``. If True, the
value is considered to be the right function value, and it will be
fitted exactly. If False, the value will be considered to be a data
value just like the other data values. Defaults to False.
pole_flat : bool or (bool, bool), optional
For the poles at ``u=0`` and ``u=pi``, specify whether or not the
approximation has vanishing derivatives. Defaults to False.
See Also
--------
BivariateSpline :
a base class for bivariate splines.
UnivariateSpline :
a smooth univariate spline to fit a given set of data points.
SmoothBivariateSpline :
a smoothing bivariate spline through the given points
LSQBivariateSpline :
a bivariate spline using weighted least-squares fitting
SmoothSphereBivariateSpline :
a smoothing bivariate spline in spherical coordinates
LSQSphereBivariateSpline :
a bivariate spline in spherical coordinates using weighted
least-squares fitting
RectBivariateSpline :
a bivariate spline over a rectangular mesh.
bisplrep :
a function to find a bivariate B-spline representation of a surface
bisplev :
a function to evaluate a bivariate B-spline and its derivatives
Notes
-----
Currently, only the smoothing spline approximation (``iopt[0] = 0`` and
``iopt[0] = 1`` in the FITPACK routine) is supported. The exact
least-squares spline approximation is not implemented yet.
When actually performing the interpolation, the requested `v` values must
lie within the same length 2pi interval that the original `v` values were
chosen from.
For more information, see the FITPACK_ site about this function.
.. _FITPACK: http://www.netlib.org/dierckx/spgrid.f
Examples
--------
Suppose we have global data on a coarse grid
>>> import numpy as np
>>> lats = np.linspace(10, 170, 9) * np.pi / 180.
>>> lons = np.linspace(0, 350, 18) * np.pi / 180.
>>> data = np.dot(np.atleast_2d(90. - np.linspace(-80., 80., 18)).T,
... np.atleast_2d(180. - np.abs(np.linspace(0., 350., 9)))).T
We want to interpolate it to a global one-degree grid
>>> new_lats = np.linspace(1, 180, 180) * np.pi / 180
>>> new_lons = np.linspace(1, 360, 360) * np.pi / 180
>>> new_lats, new_lons = np.meshgrid(new_lats, new_lons)
We need to set up the interpolator object
>>> from scipy.interpolate import RectSphereBivariateSpline
>>> lut = RectSphereBivariateSpline(lats, lons, data)
Finally we interpolate the data. The `RectSphereBivariateSpline` object
only takes 1-D arrays as input, therefore we need to do some reshaping.
>>> data_interp = lut.ev(new_lats.ravel(),
... new_lons.ravel()).reshape((360, 180)).T
Looking at the original and the interpolated data, one can see that the
interpolant reproduces the original data very well:
>>> import matplotlib.pyplot as plt
>>> fig = plt.figure()
>>> ax1 = fig.add_subplot(211)
>>> ax1.imshow(data, interpolation='nearest')
>>> ax2 = fig.add_subplot(212)
>>> ax2.imshow(data_interp, interpolation='nearest')
>>> plt.show()
Choosing the optimal value of ``s`` can be a delicate task. Recommended
values for ``s`` depend on the accuracy of the data values. If the user
has an idea of the statistical errors on the data, she can also find a
proper estimate for ``s``. By assuming that, if she specifies the
right ``s``, the interpolator will use a spline ``f(u,v)`` which exactly
reproduces the function underlying the data, she can evaluate
``sum((r(i,j)-s(u(i),v(j)))**2)`` to find a good estimate for this ``s``.
For example, if she knows that the statistical errors on her
``r(i,j)``-values are not greater than 0.1, she may expect that a good
``s`` should have a value not larger than ``u.size * v.size * (0.1)**2``.
If nothing is known about the statistical error in ``r(i,j)``, ``s`` must
be determined by trial and error. The best is then to start with a very
large value of ``s`` (to determine the least-squares polynomial and the
corresponding upper bound ``fp0`` for ``s``) and then to progressively
decrease the value of ``s`` (say by a factor 10 in the beginning, i.e.
``s = fp0 / 10, fp0 / 100, ...`` and more carefully as the approximation
shows more detail) to obtain closer fits.
The interpolation results for different values of ``s`` give some insight
into this process:
>>> fig2 = plt.figure()
>>> s = [3e9, 2e9, 1e9, 1e8]
>>> for idx, sval in enumerate(s, 1):
... lut = RectSphereBivariateSpline(lats, lons, data, s=sval)
... data_interp = lut.ev(new_lats.ravel(),
... new_lons.ravel()).reshape((360, 180)).T
... ax = fig2.add_subplot(2, 2, idx)
... ax.imshow(data_interp, interpolation='nearest')
... ax.set_title(f"s = {sval:g}")
>>> plt.show()
r5 FNc
� � t j g d�t �� � } t j g d�t �� � }
|�d}n0t |t t j t j f� � r||f}t |t � � r||f}t |t � � r||f}t |t � � r||f}|\ } } || dd �< | �d|
d< n |d |
d< | �d|
d< n |d |
d< |\ |
d< |
d < t j |� � t j |� � }}t j |� � }d
|d k r|d t j
k st d � � �t j
|d cxk rt j
k sn t d � � �|d |d dt j
z z k st d
� � �t j t j
|� � d
k � � st d� � �t j t j
|� � d
k � � st d� � �|j |j d k st d� � �|j |j d k st d� � �|d du r|d du rt d� � �|d du r|d du rt d� � �|d
k st d� � �t j |� � }t! j | |
|� � � |� � � |� � � | | |� � \ }
}}}}}}|dvr-t& � |d|z � � }t |� � �|| _ |d |
� |d |� |d |
dz
|dz
z � f| _ d| _ |d | _ d S )N)r r r r� )r# r r# r )NNr r# r r r r5 zu should be between (0, pi)z v[0] should be between [-pi, pi)z#v[-1] should be v[0] + 2pi or less z u must be strictly increasingz v must be strictly increasingz7u dimension of r must have same number of elements as uz7v dimension of r must have same number of elements as vFTz1if pole_continuity is False, so must be pole_flatr r� rR r� r )r9 r � dfitpack_int�
isinstancer� �float32�float64�boolr r: r r= r< r r> r? r �regrid_smth_spher�copy�_spfit_messagesrU r� rI r� �v0)r* �u�vr r" �pole_continuity� pole_values�
pole_exact� pole_flat�iopt�ider�r0�r1ru �tu�nv�tvrK r� rY r� s r1 r2 z"RectSphereBivariateSpline.__init__8 s� � ��x� � � � �6�6�6���x����l�;�;�;�� � �&�K�K�
� �e�R�Z���%D�
E�
E� 5�&� �4�K� �o�t� ,� ,� A� .�� @�O� �j�$� '� '� 2�$�j�1�J� �i�� &� &� /�"�I�.�I� ���B�"��Q�R�R��
�:��D��G�G� ��m�D��G�
�:��D��G�G� ��m�D��G�$���Q���a���x��{�{�B�H�Q�K�K�1�� �J�q�M�M���a��d�
�
�q��u�r�u�}�}� � :�;�;� ;���v��1��%�%�%�%���%�%�%�%� � ?�@�@� @���u��!��q���w��&�&� � B�C�C� C��v�b�g�a�j�j�3�&�'�'� >� � <�=�=� =��v�b�g�a�j�j�3�&�'�'� >� � <�=�=� =��v�����#�#� � -� .� .�
.��v�����#�#� � -� .� .�
.� �1� �� &� &�9�Q�<�4�+?�+?� � )� *� *�
*� �1� �� &� &�9�Q�<�4�+?�+?� � )� *� *�
*� �C�x�x� � 3�4�4� 4� �H�Q�K�K��%-�%?��d�@A�����@A�����@A�����@B�B�� &K� &K�"��B��B��2�s� �k� !� !�!�%�%�c�8�s�+;�<�<�C� �S�/�/� !�����c�r�c�7�B�s��s�G�Q�'9��a��B�q�D�(9�'9�%:�:��� �� ��A�$����r3 r Tc � � t j |� � }t j |� � }t � | |||||�� � S )Nr )r9 r: r� rv r s r1 rv z"RectSphereBivariateSpline.__call__� sK � ��
�5�!�!���j��o�o��$�-�-�d�E�3�v�37�d� .� D� D� Dr3 )r5 FNFFr� r ra r3 r1 r r � s^ � � � � � �S� S�j JN�-2�K� K� K� K�ZD� D� D� D� D� Dr3 r )&r� �__all__rV �numpyr
r r r r r r9 � r r �types�intvarr� r& rT r@ r r r� r r� r� r r� r r r
r, r r� r r r- r ra r3 r1 �<module>rB s8 ��� �
!�
!�
!�� ���� >� >� >� >� >� >� >� >� >� >� >� >� >� >� >� >� � � � � � � � � � � � � � � � � �~�$�*� �
�J�
J� &�'� � �: �a�������#� #�
� g9� g9� g9� g9� g9� g9� g9� g9�Tc � c � c � c � c �#3� c � c � c �L � � I � I � I � I � I �*� I � I � I �\mE� mE� mE� mE� mE� mE� mE� mE�`
�
I�
I�
�
� -�C�E'� '� �T_� _� _� _� _�*� _� _� _�DO� O� O� O� O� 2� O� O� O�6e � e � e � e � e �O� e � e � e �P` � ` � ` � ` � ` � � ` � ` � ` �FU � U � U � U � U �/� U � U � U �p '�+�+�-�-� �
8� �B� � � �B� �QO� QO� QO� QO� QO� 0� QO� QO� QO�hLD� LD� LD� LD� LD�"7� LD� LD� LD�^YD� YD� YD� YD� YD� 4� YD� YD� YD�x #�'�'�)�)��"��� �8iD� iD� iD� iD� iD� 5� iD� iD� iD� iD� iDr3