a BCCfX@s:gdZddlmZddlZddlZddlmZmZmZm Z m Z m Z m Z m Z mZddlmZddlmZddlmZddlmZdd lmZdd lmZdd lmZdd lmZdd lmZmZddZ dZ!GdddZ"ddZ#ddZ$GdddeZ%GdddZ&Gddde&Z'Gddde&Z(Gdd d Z)dS)!)interp1dinterp2dlagrangePPolyBPolyNdPPoly)prodN) array transpose searchsorted atleast_1d atleast_2dravelpoly1dasarrayintp)copy_if_needed)comb) _fitpack_py)dfitpack)_Interpolator1D)_ppoly)_ndim_coords_from_arrays)make_interp_splineBSplinecCsxt|}td}t|D]Z}t||}t|D]8}||kr>q0||||}|td|| g|9}q0||7}q|S)ag Return a Lagrange interpolating polynomial. Given two 1-D arrays `x` and `w,` returns the Lagrange interpolating polynomial through the points ``(x, w)``. Warning: This implementation is numerically unstable. Do not expect to be able to use more than about 20 points even if they are chosen optimally. Parameters ---------- x : array_like `x` represents the x-coordinates of a set of datapoints. w : array_like `w` represents the y-coordinates of a set of datapoints, i.e., f(`x`). Returns ------- lagrange : `numpy.poly1d` instance The Lagrange interpolating polynomial. Examples -------- Interpolate :math:`f(x) = x^3` by 3 points. >>> import numpy as np >>> from scipy.interpolate import lagrange >>> x = np.array([0, 1, 2]) >>> y = x**3 >>> poly = lagrange(x, y) Since there are only 3 points, Lagrange polynomial has degree 2. Explicitly, it is given by .. math:: \begin{aligned} L(x) &= 1\times \frac{x (x - 2)}{-1} + 8\times \frac{x (x-1)}{2} \\ &= x (-2 + 3x) \end{aligned} >>> from numpy.polynomial.polynomial import Polynomial >>> Polynomial(poly.coef[::-1]).coef array([ 0., -2., 3.]) >>> import matplotlib.pyplot as plt >>> x_new = np.arange(0, 2.1, 0.1) >>> plt.scatter(x, y, label='data') >>> plt.plot(x_new, Polynomial(poly.coef[::-1])(x_new), label='Polynomial') >>> plt.plot(x_new, 3*x_new**2 - 2*x_new + 0*x_new, ... label=r"$3 x^2 - 2 x$", linestyle='-.') >>> plt.legend() >>> plt.show() g?)lenrrange)xwMpjptkZfacr&Z/var/www/html/django/DPS/env/lib/python3.9/site-packages/scipy/interpolate/_interpolate.pyrs9    ra`interp2d` is deprecated in SciPy 1.10 and will be removed in SciPy 1.14.0. For legacy code, nearly bug-for-bug compatible replacements are `RectBivariateSpline` on regular grids, and `bisplrep`/`bisplev` for scattered 2D data. In new code, for regular grids use `RegularGridInterpolator` instead. For scattered data, prefer `LinearNDInterpolator` or `CloughTocher2DInterpolator`. For more details see `https://scipy.github.io/devdocs/notebooks/interp_transition_guide.html` c@s$eZdZdZd ddZd d d ZdS) rav interp2d(x, y, z, kind='linear', copy=True, bounds_error=False, fill_value=None) .. deprecated:: 1.10.0 `interp2d` is deprecated in SciPy 1.10 and will be removed in SciPy 1.14.0. For legacy code, nearly bug-for-bug compatible replacements are `RectBivariateSpline` on regular grids, and `bisplrep`/`bisplev` for scattered 2D data. In new code, for regular grids use `RegularGridInterpolator` instead. For scattered data, prefer `LinearNDInterpolator` or `CloughTocher2DInterpolator`. For more details see `https://scipy.github.io/devdocs/notebooks/interp_transition_guide.html `_ Interpolate over a 2-D grid. `x`, `y` and `z` are arrays of values used to approximate some function f: ``z = f(x, y)`` which returns a scalar value `z`. This class returns a function whose call method uses spline interpolation to find the value of new points. If `x` and `y` represent a regular grid, consider using `RectBivariateSpline`. If `z` is a vector value, consider using `interpn`. Note that calling `interp2d` with NaNs present in input values, or with decreasing values in `x` an `y` results in undefined behaviour. Methods ------- __call__ Parameters ---------- x, y : array_like Arrays defining the data point coordinates. The data point coordinates need to be sorted by increasing order. If the points lie on a regular grid, `x` can specify the column coordinates and `y` the row coordinates, for example:: >>> x = [0,1,2]; y = [0,3]; z = [[1,2,3], [4,5,6]] Otherwise, `x` and `y` must specify the full coordinates for each point, for example:: >>> x = [0,1,2,0,1,2]; y = [0,0,0,3,3,3]; z = [1,4,2,5,3,6] If `x` and `y` are multidimensional, they are flattened before use. z : array_like The values of the function to interpolate at the data points. If `z` is a multidimensional array, it is flattened before use assuming Fortran-ordering (order='F'). The length of a flattened `z` array is either len(`x`)*len(`y`) if `x` and `y` specify the column and row coordinates or ``len(z) == len(x) == len(y)`` if `x` and `y` specify coordinates for each point. kind : {'linear', 'cubic', 'quintic'}, optional The kind of spline interpolation to use. Default is 'linear'. copy : bool, optional If True, the class makes internal copies of x, y and z. If False, references may be used. The default is to copy. bounds_error : bool, optional If True, when interpolated values are requested outside of the domain of the input data (x,y), a ValueError is raised. If False, then `fill_value` is used. fill_value : number, optional If provided, the value to use for points outside of the interpolation domain. If omitted (None), values outside the domain are extrapolated via nearest-neighbor extrapolation. See Also -------- RectBivariateSpline : Much faster 2-D interpolation if your input data is on a grid bisplrep, bisplev : Spline interpolation based on FITPACK BivariateSpline : a more recent wrapper of the FITPACK routines interp1d : 1-D version of this function RegularGridInterpolator : interpolation on a regular or rectilinear grid in arbitrary dimensions. interpn : Multidimensional interpolation on regular grids (wraps `RegularGridInterpolator` and `RectBivariateSpline`). Notes ----- The minimum number of data points required along the interpolation axis is ``(k+1)**2``, with k=1 for linear, k=3 for cubic and k=5 for quintic interpolation. The interpolator is constructed by `bisplrep`, with a smoothing factor of 0. If more control over smoothing is needed, `bisplrep` should be used directly. The coordinates of the data points to interpolate `xnew` and `ynew` have to be sorted by ascending order. `interp2d` is legacy and is not recommended for use in new code. New code should use `RegularGridInterpolator` instead. Examples -------- Construct a 2-D grid and interpolate on it: >>> import numpy as np >>> from scipy import interpolate >>> x = np.arange(-5.01, 5.01, 0.25) >>> y = np.arange(-5.01, 5.01, 0.25) >>> xx, yy = np.meshgrid(x, y) >>> z = np.sin(xx**2+yy**2) >>> f = interpolate.interp2d(x, y, z, kind='cubic') Now use the obtained interpolation function and plot the result: >>> import matplotlib.pyplot as plt >>> xnew = np.arange(-5.01, 5.01, 1e-2) >>> ynew = np.arange(-5.01, 5.01, 1e-2) >>> znew = f(xnew, ynew) >>> plt.plot(x, z[0, :], 'ro-', xnew, znew[0, :], 'b-') >>> plt.show() linearTFNc stjttddt|}t|}t|}|jt|t|k}|r|jdkrj|j t|t|fkrjt dt |dd|ddkst |} || }|dd| f}t |dd|ddkst |} || }|| ddf}t|j}n(z$interp2d.__init__..)#warningswarndep_mesgDeprecationWarningrrsizerndimshape ValueErrornpallargsortTKeyErrorreprjoinmaprZbisplreptckrZ regrid_smth bounds_error fill_valueryzZaminZamaxx_minx_maxy_miny_max)selfrrMrNkindr5rKrLZrectangular_gridr#Zinterpolation_typesr1r2enxZtxnytycfpZierr&r4r'__init__sh      2$zinterp2d.__init__rc CsXtjttddt|}t|}|jdks4|jdkr= 0, < kx Order of partial derivatives in x. dy : int >= 0, < ky Order of partial derivatives in y. assume_sorted : bool, optional If False, values of `x` and `y` can be in any order and they are sorted first. If True, `x` and `y` have to be arrays of monotonically increasing values. Returns ------- z : 2-D array with shape (len(y), len(x)) The interpolated values. r)r*rz!x and y should both be 1-D arrays mergesortrTNz"Values out of range; x must be in z, y in r)r:r;r<r=r r?rArBsortrKrLrOrPrQrRanyrZbisplevrJr r rr ) rSrrMdxZdy assume_sortedZout_of_bounds_xZout_of_bounds_yZany_out_of_bounds_xZany_out_of_bounds_yrNr&r&r'__call__-s<    zinterp2d.__call__)r(TFN)rrF)__name__ __module__ __qualname____doc__r[rbr&r&r&r'ros  ;rcCs|j}t|t|krt|ddd|dddD]\}}|dkr4||kr4qq4|jdkrx|j|krxt||j|}|St|d|d|dS)z7Helper to check that arr_from broadcasts up to shape_toNr,rz0 argument must be able to broadcast up to shape z but had shape ) r@rzipr>rBZonesdtyperrA)Zarr_fromZshape_tonameZ shape_fromtfr&r&r'_check_broadcast_up_toms&rlcCst|to|dkS)z?Helper to check if fill_value == "extrapolate" without warnings extrapolate) isinstancestr)rLr&r&r'_do_extrapolate}s rpc@seZdZdZddddejdfddZed d Zej d d Zd d Z ddZ ddZ ddZ ddZddZddZddZddZdS)ra Interpolate a 1-D function. .. legacy:: class For a guide to the intended replacements for `interp1d` see :ref:`tutorial-interpolate_1Dsection`. `x` and `y` are arrays of values used to approximate some function f: ``y = f(x)``. This class returns a function whose call method uses interpolation to find the value of new points. Parameters ---------- x : (npoints, ) array_like A 1-D array of real values. y : (..., npoints, ...) array_like A 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 correct axis. Unlike other interpolators, the default interpolation axis is the last axis of `y`. kind : str or int, optional Specifies the kind of interpolation as a string or as an integer specifying the order of the spline interpolator to use. The string has to be one of 'linear', 'nearest', 'nearest-up', 'zero', 'slinear', 'quadratic', 'cubic', 'previous', or 'next'. 'zero', 'slinear', 'quadratic' and 'cubic' refer to a spline interpolation of zeroth, first, second or third order; 'previous' and 'next' simply return the previous or next value of the point; 'nearest-up' and 'nearest' differ when interpolating half-integers (e.g. 0.5, 1.5) in that 'nearest-up' rounds up and 'nearest' rounds down. Default is 'linear'. axis : int, optional Axis in the ``y`` array corresponding to the x-coordinate values. Unlike other interpolators, defaults to ``axis=-1``. copy : bool, optional If ``True``, the class makes internal copies of x and y. If ``False``, references to ``x`` and ``y`` are used if possible. The default is to copy. bounds_error : bool, optional If True, a ValueError is raised any time interpolation is attempted on a value outside of the range of x (where extrapolation is necessary). If False, out of bounds values are assigned `fill_value`. By default, an error is raised unless ``fill_value="extrapolate"``. fill_value : array-like or (array-like, array_like) or "extrapolate", optional - if a ndarray (or float), this value will be used to fill in for requested points outside of the data range. If not provided, then the default is NaN. The array-like must broadcast properly to the dimensions of the non-interpolation axes. - If a two-element tuple, then the first element is used as a fill value for ``x_new < x[0]`` and the second element is used for ``x_new > x[-1]``. Anything that is not a 2-element tuple (e.g., list or ndarray, regardless of shape) is taken to be a single array-like argument meant to be used for both bounds as ``below, above = fill_value, fill_value``. Using a two-element tuple or ndarray requires ``bounds_error=False``. .. versionadded:: 0.17.0 - If "extrapolate", then points outside the data range will be extrapolated. .. versionadded:: 0.17.0 assume_sorted : bool, optional If False, values of `x` can be in any order and they are sorted first. If True, `x` has to be an array of monotonically increasing values. Attributes ---------- fill_value Methods ------- __call__ See Also -------- splrep, splev Spline interpolation/smoothing based on FITPACK. UnivariateSpline : An object-oriented wrapper of the FITPACK routines. interp2d : 2-D interpolation Notes ----- Calling `interp1d` with NaNs present in input values results in undefined behaviour. Input values `x` and `y` must be convertible to `float` values like `int` or `float`. If the values in `x` are not unique, the resulting behavior is undefined and specific to the choice of `kind`, i.e., changing `kind` will change the behavior for duplicates. Examples -------- >>> import numpy as np >>> import matplotlib.pyplot as plt >>> from scipy import interpolate >>> x = np.arange(0, 10) >>> y = np.exp(-x/3.0) >>> f = interpolate.interp1d(x, y) >>> xnew = np.arange(0, 9, 0.1) >>> ynew = f(xnew) # use interpolation function returned by `interp1d` >>> plt.plot(x, y, 'o', xnew, ynew, '-') >>> plt.show() r(r,TNFc Cstj||||d||_||_|s(t|_|dvrHddddd|} d}n(t|tr\|} d}n|dvrptd |t||jd }t||jd }|st j |d d } || }t j || |d}|j dkrt d |j dkrt dt|jjt js|t j}||j |_||_||j|_||_~~||_|dvrd} |dkr|d|_|jd|_|jdd|jdd|_|jj|_q|dkrd|_|jd|_|jdd|jdd|_|jj|_q|dkr"d|_d|_t |jt j! |_"|jj#|_t$|r|%t j&t |jd|f}n|dkr~d|_d|_t |jt j!|_"|jj#|_t$|r|%t |jd|t j&f}nnt t jt tf} |jj| vo|jj| v} | o|jj dk} | ot$| } | r|jj'|_n |jj(|_n| d} d}|j|j}}| dkrt )|j}|*rp|j|}|j+dkrHt dt ,t -|jt .|jt/|j}d}t )|j*rt 0|j}d}t1||| dd|_2|r|jj3|_n |jj4|_t/|j| krt d| ||_5dS)z- Initialize a 1-D linear interpolation class.axis)zeroZslinearZ quadraticr/rrr)r-Zspline)r(nearest nearest-uppreviousnextz8%s is unsupported: Use fitpack routines for other types.r4r\r]z,the x array must have exactly one dimension.z-the y array must have at least one dimension.rtleftg@Nr,rurightrvrwFz`x` array is all-nanT)r%Z check_finitez,x and y arrays must have at least %d entries)6rr[rKr5rrnintNotImplementedErrorr rBrDZtaker?rA issubclassrhtypeZinexactastypefloat64rrrMZ _reshape_yi_yr_kind_sidex_bds __class__ _call_nearest_call_ind nextafterinf_x_shift_call_previousnextrp0_check_and_update_bounds_error_for_extrapolationnan_call_linear_np _call_linearisnanr_r>ZlinspaceZnanminZnanmaxrZ ones_liker_spline_call_nan_spline _call_splinerL)rSrrMrTrrr5rKrLraorderindminvalZ np_dtypesZcondZ rewrite_nanxxyymasksxr&r&r'r[s                           zinterp1d.__init__cCs|jS)zThe fill value.)_fill_value_origrSr&r&r'rLszinterp1d.fill_valuecCst|r|d|_n|jjd|j|jj|jdd}t|dkrPd}t|trt|dkrt |dt |dg}d}t dD]}t |||||||<qnt |}t ||dgd}|\|_ |_d|_|jdurd|_||_dS) NTrrrr))zfill_value (below)zfill_value (above)rLF)rpr _extrapolaterMr@rrrrntuplerBrrrl_fill_value_below_fill_value_aboverKr)rSrLZbroadcast_shapeZ below_abovenamesiir&r&r'rLs8        cCs|jrtdd|_dS)Nz.Cannot extrapolate and raise at the same time.F)rKrArr&r&r'rsz9interp1d._check_and_update_bounds_error_for_extrapolationcCst||j|jSN)rBZinterprrMrSx_newr&r&r'rszinterp1d._call_linear_npc Cst|j|}|dt|jdt}|d}|}|j|}|j|}|j|}|j|}||||dddf} | ||dddf|} | S)Nr)r rcliprr~rzr) rSr x_new_indiceslohiZx_loZx_hiZy_loZy_hiZslopey_newr&r&r'rs     zinterp1d._call_linearcCs<t|j||jd}|dt|jdt}|j|}|S)z5 Find nearest neighbor interpolated y_new = f(x_new).Zsiderr) r rrrrrr~rrrSrrrr&r&r'rs zinterp1d._call_nearestcCsNt|j||jd}|d|jt|j|jt}|j ||jd}|S)z6Use previous/next neighbor of x_new, y_new = f(x_new).rr) r rrrrrrr~rrrr&r&r'rs zinterp1d._call_previousnextcCs ||Sr)rrr&r&r'rszinterp1d._call_splinecCs||}tj|d<|S)N.)rrBr)rSroutr&r&r'rs  zinterp1d._call_nan_splinecCsLt|}|||}|jsH||\}}t|dkrH|j||<|j||<|SNr)rrr _check_boundsrrr)rSrr below_bounds above_boundsr&r&r' _evaluates    zinterp1d._evaluatecCs||jdk}||jdk}|jrT|rT|t|}td|d|jdd|jr|r|t|}td|d|jdd||fS)aCheck the inputs for being in the bounds of the interpolated data. Parameters ---------- x_new : array Returns ------- out_of_bounds : bool array The mask on x_new of values that are out of the bounds. rr,z A value (z=) in x_new is below the interpolation range's minimum value (z).z=) in x_new is above the interpolation range's maximum value ()rrKr_rBZargmaxrA)rSrrrZbelow_bounds_valueZabove_bounds_valuer&r&r'rs    zinterp1d._check_bounds)rcrdrerfrBrr[propertyrLsetterrrrrrrrrrr&r&r&r'rs&l   rc@sNeZdZdZdZdddZddZedd d Zd d Z d dZ dddZ dS) _PPolyBasez%Base class for piecewise polynomials.)rYrrmrrNrcCst||_tj|tjd|_|dur,d}n|dkrr@diffrC _get_dtyperh)rSrYrrmrrr`rhr&r&r'r[+s<      z_PPolyBase.__init__cCs0t|tjs t|jjtjr&tjStjSdSrrB issubdtypecomplexfloatingrYrh complex128rrSrhr&r&r'rXs z_PPolyBase._get_dtypecCs2t|}||_||_||_|dur(d}||_|S)aH Construct the piecewise polynomial without making checks. Takes the same parameters as the constructor. Input arguments ``c`` and ``x`` must be arrays of the correct shape and type. The ``c`` array can only be of dtypes float and complex, and ``x`` array must have dtype float. NT)object__new__rYrrrrm)clsrYrrmrrrSr&r&r'construct_fast_s z_PPolyBase.construct_fastcCs0|jjjs|j|_|jjjs,|j|_dS)zr c and x may be modified by the user. The Cython code expects that they are C contiguous. N)rflags c_contiguousr5rYrr&r&r'_ensure_c_contiguousrs   z_PPolyBase._ensure_c_contiguouscCst|}t|}|jdkr&td|jdkr8td|jd|jdkrftd|jd|jd|jdd |jjdd ks|j|jjkrtd |j|jj|jdkrd St|}t |dkst |dkstd |j d |j dkrR|d |dkstd |d|j d kr.d}n"|d |j dkrHd}ntdnV|d |dksltd |d|j d krd}n"|d |j dkrd}ntd| |j }t |jd|jjd}tj||jjd|jdf|jjdd |d}|dkrn|j|||jjdd d |jjdf<||||jdd |jjdd f<tj|j |f|_ nh|dkr||||jjdd d |jdf<|j|||jdd |jdd f<tj||j f|_ ||_d S)a# Add additional breakpoints and coefficients to the polynomial. Parameters ---------- c : ndarray, size (k, m, ...) Additional coefficients for polynomials in intervals. Note that the first additional interval will be formed using one of the ``self.x`` end points. x : ndarray, size (m,) Additional breakpoints. Must be sorted in the same order as ``self.x`` and either to the right or to the left of the current breakpoints. r)zinvalid dimensions for crzinvalid dimensions for xrz Shapes of x z and c z are incompatibleNz-Shapes of c {} and self.c {} are incompatiblez`x` is not sorted.r,z,`x` is in the different order than `self.x`.appendprependz9`x` is neither on the left or on the right from `self.x`.r)rBrr?rAr@rYformatr>rrCrrrhmaxzerosZr_)rSrYrr`actionrhZk2c2r&r&r'extend|s\    ,     , *& &&z_PPolyBase.extendcCs&|dur|j}t|}|j|j}}tj|tjd}|dkrr|jd||jd|jd|jd}d}tj t |t |j jddf|j j d}|||||||||j jdd}|jdkr"tt|j}||||j|d||||jd}||}|S)aX Evaluate the piecewise polynomial or its derivative. Parameters ---------- x : array_like Points to evaluate the interpolant at. nu : int, optional Order of derivative to evaluate. Must be non-negative. 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), use `self.extrapolate`. Returns ------- y : array_like Interpolated values. Shape is determined by replacing the interpolation axis in the original array with the shape of x. Notes ----- Derivatives are evaluated piecewise for each polynomial segment, even if the polynomial is not differentiable at the breakpoints. The polynomial intervals are considered half-open, ``[a, b)``, except for the last interval which is closed ``[a, b]``. Nrrrr,Fr))rmrBrr@r?rrrremptyrrrYrhrrreshaperrlistrr )rSrnurmx_shapeZx_ndimrlr&r&r'rbs" ,* 0 z_PPolyBase.__call__)Nr)Nr)rN) rcrdrerf __slots__r[r classmethodrrrrbr&r&r&r'r's -  Nrc@sfeZdZdZddZdddZdddZdd d ZdddZdddZ e dddZ e dddZ d S)raL Piecewise polynomial in terms of coefficients and breakpoints The polynomial between ``x[i]`` and ``x[i + 1]`` is written in the local power basis:: S = sum(c[m, i] * (xp - x[i])**(k-m) for m in range(k+1)) where ``k`` is the degree of the polynomial. Parameters ---------- c : ndarray, shape (k, m, ...) Polynomial coefficients, order `k` and `m` intervals. x : ndarray, shape (m+1,) Polynomial breakpoints. Must be sorted in either increasing or decreasing order. extrapolate : bool or 'periodic', 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. Default is True. axis : int, optional Interpolation axis. Default is zero. Attributes ---------- x : ndarray Breakpoints. c : ndarray Coefficients of the polynomials. They are reshaped to a 3-D array with the last dimension representing the trailing dimensions of the original coefficient array. axis : int Interpolation axis. Methods ------- __call__ derivative antiderivative integrate solve roots extend from_spline from_bernstein_basis construct_fast See also -------- BPoly : piecewise polynomials in the Bernstein basis Notes ----- High-order polynomials in the power basis can be numerically unstable. Precision problems can start to appear for orders larger than 20-30. cCs:t|j|jjd|jjdd|j||t||dSNrrr,)revaluaterYrr@rrrSrrrmrr&r&r'r<s"zPPoly._evaluatercCs|dkr|| S|dkr(|j}n|jd| ddf}|jddkrptjd|jdd|jd}tt |jddd|}||t dfd|j d9}| ||j |j|jS)a Construct a new piecewise polynomial representing the derivative. Parameters ---------- nu : int, optional Order of derivative to evaluate. Default is 1, i.e., compute the first derivative. If negative, the antiderivative is returned. Returns ------- pp : PPoly Piecewise polynomial of order k2 = k - n representing the derivative of this polynomial. Notes ----- Derivatives are evaluated piecewise for each polynomial segment, even if the polynomial is not differentiable at the breakpoints. The polynomial intervals are considered half-open, ``[a, b)``, except for the last interval which is closed ``[a, b]``. rNrrrr,r)antiderivativerYr5r@rBrrhspecpocharangeslicer?rrrmrr)rSrrfactorr&r&r' derivative@s   zPPoly.derivativecCs|dkr|| Stj|jjd||jjdf|jjdd|jjd}|j|d| <tt|jjddd|}|d| |t dfd|j d<| t ||jd|jdd|j|d|jdkrd }n|j}|||j||jS) a= Construct a new piecewise polynomial representing the antiderivative. Antiderivative is also the indefinite integral of the function, and derivative is its inverse operation. Parameters ---------- nu : int, optional Order of antiderivative to evaluate. Default is 1, i.e., compute the first integral. If negative, the derivative is returned. Returns ------- pp : PPoly Piecewise polynomial of order k2 = k + n representing the antiderivative of this polynomial. Notes ----- The antiderivative returned by this function is continuous and continuously differentiable to order n-1, up to floating point rounding error. If antiderivative is computed and ``self.extrapolate='periodic'``, it will be set to False for the returned instance. This is done because the antiderivative is no longer periodic and its correct evaluation outside of the initially given x interval is difficult. rrr)Nrr,rrF)rrBrrYr@rhrrrrr?rrfix_continuityrrrmrrr)rSrrYrrmr&r&r'rls  ..  zPPoly.antiderivativeNc Cs(|dur|j}d}||kr(||}}d}tjt|jjddf|jjd}||dkr|jd|jd}}||}||} t | |\} } | dkrt j |j |jjd|jjdd|j||d|d || 9}n | d||||}|| }t|} ||krLt j |j |jjd|jjdd|j||d| d || 7}nt j |j |jjd|jjdd|j||d| d || 7}t j |j |jjd|jjdd|j||| ||d| d || 7}n8t j |j |jjd|jjdd|j||t||d ||9}| |jjddS) a Compute a definite integral over a piecewise polynomial. Parameters ---------- a : float Lower integration bound b : float Upper integration bound 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), use `self.extrapolate`. Returns ------- ig : array_like Definite integral of the piecewise polynomial over [a, b] Nrr,r)rrrF)r)rmrBrrrYr@rhrrdivmodr integraterfillZ empty_liker) rSr7brmsignZ range_intxsxeperiodinterval n_periodsrxZ remainder_intr&r&r'rsZ $          zPPoly.integraterTcCs|dur|j}|t|jjtjr0tdt|}t |j |jj d|jj dd|j |t|t|}|jjdkr|dStjt|jj ddtd}t|D]\}}|||<q| |jj ddSdS)a Find real solutions of the equation ``pp(x) == y``. Parameters ---------- y : float, optional Right-hand side. Default is zero. discontinuity : bool, optional Whether to report sign changes across discontinuities at breakpoints as roots. extrapolate : {bool, 'periodic', None}, optional If bool, determines whether to return roots from the polynomial extrapolated based on first and last intervals, 'periodic' works the same as False. If None (default), use `self.extrapolate`. Returns ------- roots : ndarray Roots of the polynomial(s). If the PPoly object describes multiple polynomials, the return value is an object array whose each element is an ndarray containing the roots. Notes ----- This routine works only on real-valued polynomials. If the piecewise polynomial contains sections that are identically zero, the root list will contain the start point of the corresponding interval, followed by a ``nan`` value. If the polynomial is discontinuous across a breakpoint, and there is a sign change across the breakpoint, this is reported if the `discont` parameter is True. Examples -------- Finding roots of ``[x**2 - 1, (x - 1)**2]`` defined on intervals ``[-2, 1], [1, 2]``: >>> import numpy as np >>> from scipy.interpolate import PPoly >>> pp = PPoly(np.array([[1, -4, 3], [1, 0, 0]]).T, [-2, 1, 2]) >>> pp.solve() array([-1., 1.]) Nz0Root finding is only for real-valued polynomialsrrr,r)r)rmrrBrrYrhrrAfloatrZ real_rootsrr@rrr?rrr enumerate)rSrM discontinuityrmrr2rrootr&r&r'solves 1"   z PPoly.solvecCs|d||S)a[ Find real roots of the piecewise polynomial. Parameters ---------- discontinuity : bool, optional Whether to report sign changes across discontinuities at breakpoints as roots. extrapolate : {bool, 'periodic', None}, optional If bool, determines whether to return roots from the polynomial extrapolated based on first and last intervals, 'periodic' works the same as False. If None (default), use `self.extrapolate`. Returns ------- roots : ndarray Roots of the polynomial(s). If the PPoly object describes multiple polynomials, the return value is an object array whose each element is an ndarray containing the roots. See Also -------- PPoly.solve r)r)rSrrmr&r&r'roots=sz PPoly.rootsc Cst|tr&|j\}}}|dur0|j}n |\}}}tj|dt|df|jd}t|ddD]>}t j |dd||d}|t |d|||ddf<q\| |||S)a Construct a piecewise polynomial from a spline Parameters ---------- tck A spline, as returned by `splrep` or a BSpline object. extrapolate : bool or 'periodic', 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. Default is True. Examples -------- Construct an interpolating spline and convert it to a `PPoly` instance >>> import numpy as np >>> from scipy.interpolate import splrep, PPoly >>> x = np.linspace(0, 1, 11) >>> y = np.sin(2*np.pi*x) >>> tck = splrep(x, y, s=0) >>> p = PPoly.from_spline(tck) >>> isinstance(p, PPoly) True Note that this function only supports 1D splines out of the box. If the ``tck`` object represents a parametric spline (e.g. constructed by `splprep` or a `BSpline` with ``c.ndim > 1``), you will need to loop over the dimensions manually. >>> from scipy.interpolate import splprep, splev >>> t = np.linspace(0, 1, 11) >>> x = np.sin(2*np.pi*t) >>> y = np.cos(2*np.pi*t) >>> (t, c, k), u = splprep([x, y], s=0) Note that ``c`` is a list of two arrays of length 11. >>> unew = np.arange(0, 1.01, 0.01) >>> out = splev(unew, (t, c, k)) To convert this spline to the power basis, we convert each component of the list of b-spline coefficients, ``c``, into the corresponding cubic polynomial. >>> polys = [PPoly.from_spline((t, cj, k)) for cj in c] >>> polys[0].c.shape (4, 14) Note that the coefficients of the polynomials `polys` are in the power basis and their dimensions reflect just that: here 4 is the order (degree+1), and 14 is the number of intervals---which is nothing but the length of the knot array of the original `tck` minus one. Optionally, we can stack the components into a single `PPoly` along the third dimension: >>> cc = np.dstack([p.c for p in polys]) # has shape = (4, 14, 2) >>> poly = PPoly(cc, polys[0].x) >>> np.allclose(poly(unew).T, # note the transpose to match `splev` ... out, atol=1e-15) True Nrrr,)Zder)rnrrJrmrBrrrhrrZsplevrgammar) rrJrmrjrYr%ZcvalsmrMr&r&r' from_splineZsC    $zPPoly.from_splinec Cst|tstdt|t|j}|jjdd}d|jj d}t |j}t |dD]|}d|t |||j|}t ||dD]L} t ||| |d| } ||| || |t df|| 7<qq^|dur|j}|||j||jS)a Construct a piecewise polynomial in the power basis from a polynomial in Bernstein basis. Parameters ---------- bp : BPoly A Bernstein basis polynomial, as created by BPoly extrapolate : bool or 'periodic', 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. Default is True. zC.from_bernstein_basis only accepts BPoly instances. Got %s instead.rrrr)r,N)rnr TypeErrorr}rBrrrYr@r? zeros_likerrrrmrrr) rbprmr`r%restrYr7rr3valr&r&r'from_bernstein_basiss    2zPPoly.from_bernstein_basis)r)r)N)rTN)TN)N)N) rcrdrerfrrrrrrrrrr&r&r&r'rs; , 6 R I  Prc@s|eZdZdZddZdddZdddZdd d Zd d Ze jje_e dddZ e dddZ e ddZe ddZd S)ra Piecewise polynomial in terms of coefficients and breakpoints. The polynomial between ``x[i]`` and ``x[i + 1]`` is written in the Bernstein polynomial basis:: S = sum(c[a, i] * b(a, k; x) for a in range(k+1)), where ``k`` is the degree of the polynomial, and:: b(a, k; x) = binom(k, a) * t**a * (1 - t)**(k - a), with ``t = (x - x[i]) / (x[i+1] - x[i])`` and ``binom`` is the binomial coefficient. Parameters ---------- c : ndarray, shape (k, m, ...) Polynomial coefficients, order `k` and `m` intervals x : ndarray, shape (m+1,) Polynomial breakpoints. Must be sorted in either increasing or decreasing order. extrapolate : bool, 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. Default is True. axis : int, optional Interpolation axis. Default is zero. Attributes ---------- x : ndarray Breakpoints. c : ndarray Coefficients of the polynomials. They are reshaped to a 3-D array with the last dimension representing the trailing dimensions of the original coefficient array. axis : int Interpolation axis. Methods ------- __call__ extend derivative antiderivative integrate construct_fast from_power_basis from_derivatives See also -------- PPoly : piecewise polynomials in the power basis Notes ----- Properties of Bernstein polynomials are well documented in the literature, see for example [1]_ [2]_ [3]_. References ---------- .. [1] https://en.wikipedia.org/wiki/Bernstein_polynomial .. [2] Kenneth I. Joy, Bernstein polynomials, http://www.idav.ucdavis.edu/education/CAGDNotes/Bernstein-Polynomials.pdf .. [3] E. H. Doha, A. H. Bhrawy, and M. A. Saker, Boundary Value Problems, vol 2011, article ID 829546, :doi:`10.1155/2011/829543`. Examples -------- >>> from scipy.interpolate import BPoly >>> x = [0, 1] >>> c = [[1], [2], [3]] >>> bp = BPoly(c, x) This creates a 2nd order polynomial .. math:: B(x) = 1 \times b_{0, 2}(x) + 2 \times b_{1, 2}(x) + 3 \times b_{2, 2}(x) \\ = 1 \times (1-x)^2 + 2 \times 2 x (1 - x) + 3 \times x^2 cCs:t|j|jjd|jjdd|j||t||dSr)rZevaluate_bernsteinrYrr@rrrr&r&r'r'szBPoly._evaluatercCs|dkr|| S|dkr:|}t|D] }|}q(|S|dkrN|j}nTd|jjd}|jjdd}t|j dt df|}|tj|jdd|}|jddkrtj d|jdd|j d}| ||j |j|jS) a Construct a new piecewise polynomial representing the derivative. Parameters ---------- nu : int, optional Order of derivative to evaluate. Default is 1, i.e., compute the first derivative. If negative, the antiderivative is returned. Returns ------- bp : BPoly Piecewise polynomial of order k - nu representing the derivative of this polynomial. rrrr)Nrqrr)rrrrYr5r?r@rBrrrrrhrrmrr)rSrrr%rrr`r&r&r'r,s     zBPoly.derivativec Cs4|dkr|| S|dkr:|}t|D] }|}q(|S|j|j}}|jd}tj|df|jdd|jd}tj |dd||dddf<|dd|dd}||dt dfd|j d 9}|ddddftj ||ddfdddd7<|j d krd }n|j }|j ||||jdS) a Construct a new piecewise polynomial representing the antiderivative. Parameters ---------- nu : int, optional Order of antiderivative to evaluate. Default is 1, i.e., compute the first integral. If negative, the derivative is returned. Returns ------- bp : BPoly Piecewise polynomial of order k + nu representing the antiderivative of this polynomial. Notes ----- If antiderivative is computed and ``self.extrapolate='periodic'``, it will be set to False for the returned instance. This is done because the antiderivative is no longer periodic and its correct evaluation outside of the initially given x interval is difficult. rrNrrq.r,rr)rF)rrrrYrr@rBrrhZcumsumrr?rmrrr) rSrrr%rYrrdeltarmr&r&r'ras$    $": zBPoly.antiderivativeNc Cs|}|dur|j}|dkr$||_|dkr||kr>> from scipy.interpolate import BPoly >>> BPoly.from_derivatives([0, 1], [[1, 2], [3, 4]]) Creates a polynomial `f(x)` of degree 3, defined on `[0, 1]` such that `f(0) = 1, df/dx(0) = 2, f(1) = 3, df/dx(1) = 4` >>> BPoly.from_derivatives([0, 1, 2], [[0, 1], [0], [2]]) Creates a piecewise polynomial `f(x)`, such that `f(0) = f(1) = 0`, `f(2) = 2`, and `df/dx(0) = 1`. Based on the number of derivatives provided, the order of the local polynomials is 2 on `[0, 1]` and 1 on `[1, 2]`. Notice that no restriction is imposed on the derivatives at ``x = 1`` and ``x = 2``. Indeed, the explicit form of the polynomial is:: f(x) = | x * (1 - x), 0 <= x < 1 | 2 * (x - 1), 1 <= x <= 2 So that f'(1-0) = -1 and f'(1+0) = 2 z&xi and yi need to have the same lengthrNrz)x coordinates are not in increasing orderc3s*|]"}t|t|dVqdSrN)r)r6iyir&r'r8Nr9z)BPoly.from_derivatives..z0Using a 1-D array for y? Please .reshape(-1, 1).css|]}|dkVqdS)rNr&)r6or&r&r'r8[r9zOrders must be positive.r)zPPoint %g has %d derivatives, point %g has %d derivatives, but order %d requestedz0`order` input incompatible with length y1 or y2.)rBrrrAr_rrrrnrzintegerminr_construct_from_derivativesrrZswapaxes)rxirZordersrmrr%rUrYry1y2Zn1Zn2nZmesgrr&rr'from_derivativess\@ "    " zBPoly.from_derivativesc Cst|t|}}|jdd|jddkrFtd|j|j|j|j}}t|tjspt|tjrxtj}ntj }t |t |}}||} tj ||f|jdd|d} t d|D]h} || t | | | ||| | | <t d| D]0} | | d| | t| | | | 8<qqt d|D]} || t | | | d| ||| | | d<t d| D]@} | | dd| dt| | d| | | 8<q|q8| S)aLCompute the coefficients of a polynomial in the Bernstein basis given the values and derivatives at the edges. Return the coefficients of a polynomial in the Bernstein basis defined on ``[xa, xb]`` and having the values and derivatives at the endpoints `xa` and `xb` as specified by `ya` and `yb`. The polynomial constructed is of the minimal possible degree, i.e., if the lengths of `ya` and `yb` are `na` and `nb`, the degree of the polynomial is ``na + nb - 1``. Parameters ---------- xa : float Left-hand end point of the interval xb : float Right-hand end point of the interval ya : array_like Derivatives at `xa`. ``ya[0]`` is the value of the function, and ``ya[i]`` for ``i > 0`` is the value of the ``i``\ th derivative. yb : array_like Derivatives at `xb`. Returns ------- array coefficient array of a polynomial having specified derivatives Notes ----- This uses several facts from life of Bernstein basis functions. First of all, .. math:: b'_{a, n} = n (b_{a-1, n-1} - b_{a, n-1}) If B(x) is a linear combination of the form .. math:: B(x) = \sum_{a=0}^{n} c_a b_{a, n}, then :math: B'(x) = n \sum_{a=0}^{n-1} (c_{a+1} - c_{a}) b_{a, n-1}. Iterating the latter one, one finds for the q-th derivative .. math:: B^{q}(x) = n!/(n-q)! \sum_{a=0}^{n-q} Q_a b_{a, n-q}, with .. math:: Q_a = \sum_{j=0}^{q} (-)^{j+q} comb(q, j) c_{j+a} This way, only `a=0` contributes to :math: `B^{q}(x = xa)`, and `c_q` are found one by one by iterating `q = 0, ..., na`. At ``x = xb`` it's the same with ``a = n - q``. rNz*Shapes of ya {} and yb {} are incompatiblerrr,)rBrr@rArrhrrrrrrrrrr) ZxaxbZyaZybZdtaZdtbdtnanbrrYqr#r&r&r'r {s.7 "(06Bz!BPoly._construct_from_derivativesc Cs|dkr |S|jdd}tj|jd|f|jdd|jd}t|jdD]X}||t||}t|dD]4}||||t||t||||7<qtqR|S)a Raise a degree of a polynomial in the Bernstein basis. Given the coefficients of a polynomial degree `k`, return (the coefficients of) the equivalent polynomial of degree `k+d`. Parameters ---------- c : array_like coefficient array, 1-D d : integer Returns ------- array coefficient array, 1-D array of length `c.shape[0] + d` Notes ----- This uses the fact that a Bernstein polynomial `b_{a, k}` can be identically represented as a linear combination of polynomials of a higher degree `k+d`: .. math:: b_{a, k} = comb(k, a) \sum_{j=0}^{d} b_{a+j, k+d} \ comb(d, j) / comb(k+d, a+j) rrNr)r@rBrrhrr)rYdr%rr7rkr#r&r&r'rs*4zBPoly._raise_degree)r)r)N)N)NN)rcrdrerfrrrrrrrrr staticmethodr rr&r&r&r'rsV 5 8 @  " w Vrc@sveZdZdZdddZedddZddZd d Zdd d Z d dZ ddZ ddZ ddZ dddZdddZdS)raW Piecewise tensor product polynomial The value at point ``xp = (x', y', z', ...)`` is evaluated by first computing the interval indices `i` such that:: x[0][i[0]] <= x' < x[0][i[0]+1] x[1][i[1]] <= y' < x[1][i[1]+1] ... and then computing:: S = sum(c[k0-m0-1,...,kn-mn-1,i[0],...,i[n]] * (xp[0] - x[0][i[0]])**m0 * ... * (xp[n] - x[n][i[n]])**mn for m0 in range(k[0]+1) ... for mn in range(k[n]+1)) where ``k[j]`` is the degree of the polynomial in dimension j. This representation is the piecewise multivariate power basis. Parameters ---------- c : ndarray, shape (k0, ..., kn, m0, ..., mn, ...) Polynomial coefficients, with polynomial order `kj` and `mj+1` intervals for each dimension `j`. x : ndim-tuple of ndarrays, shapes (mj+1,) Polynomial breakpoints for each dimension. These must be sorted in increasing order. extrapolate : bool, optional Whether to extrapolate to out-of-bounds points based on first and last intervals, or to return NaNs. Default: True. Attributes ---------- x : tuple of ndarrays Breakpoints. c : ndarray Coefficients of the polynomials. Methods ------- __call__ derivative antiderivative integrate integrate_1d construct_fast See also -------- PPoly : piecewise polynomials in 1D Notes ----- High-order polynomials in the power basis can be numerically unstable. NcCstdd|D|_t||_|dur,d}t||_t|j}tdd|jDr\t dtdd|jDrxt d|j d|krt d td d|jDrt d td dt |j |d||jDrt d | |jj}tj|j|d|_dS)Ncss|]}tj|tjdVqdS)rN)rBrrr6vr&r&r'r8;r9z#NdPPoly.__init__..Tcss|]}|jdkVqdSr)r?rr&r&r'r8Br9z"x arrays must all be 1-dimensionalcss|]}|jdkVqdS)r)Nr>rr&r&r'r8Dr9z+x arrays must all contain at least 2 pointsr)z(c must have at least 2*len(x) dimensionscss0|](}t|dd|dddkVqdS)rNr,r)rBr_rr&r&r'r8Hr9z)x-coordinates are not in increasing ordercss |]\}}||jdkVqdSrr)r6r7rr&r&r'r8Jr9z/x and c do not agree on the number of intervalsr)rrrBrrYrrmrr_rAr?rgr@rrhr)rSrYrrmr?rhr&r&r'r[:s$   (zNdPPoly.__init__cCs,t|}||_||_|dur"d}||_|S)aJ Construct the piecewise polynomial without making checks. Takes the same parameters as the constructor. Input arguments ``c`` and ``x`` must be arrays of the correct shape and type. The ``c`` array can only be of dtypes float and complex, and ``x`` array must have dtype float. NT)rrrYrrm)rrYrrmrSr&r&r'rPs zNdPPoly.construct_fastcCs0t|tjs t|jjtjr&tjStjSdSrrrr&r&r'rcs zNdPPoly._get_dtypecCs2|jjjs|j|_t|jts.t|j|_dSr)rYrrr5rnrrrr&r&r'rjs   zNdPPoly._ensure_c_contiguousc Csl|dur|j}nt|}t|j}t|}|j}tj|d|jdtj d}|durjtj |ftj d}n0tj |tj d}|j dks|jd|krtdt|jjd|}t|jj|d|}t|jjd|d}tj|jjd|tj d} tj|jd|f|jjd} |t|j||||j| ||t|| | |dd|jjd|dS)a Evaluate the piecewise polynomial or its derivative Parameters ---------- x : array-like Points to evaluate the interpolant at. nu : tuple, optional Orders of derivatives to evaluate. Each must be non-negative. extrapolate : bool, optional Whether to extrapolate to out-of-bounds points based on first and last intervals, or to return NaNs. Returns ------- y : array-like Interpolated values. Shape is determined by replacing the interpolation axis in the original array with the shape of x. Notes ----- Derivatives are evaluated piecewise for each polynomial segment, even if the polynomial is not differentiable at the breakpoints. The polynomial intervals are considered half-open, ``[a, b)``, except for the last interval which is closed ``[a, b]``. Nr,rrrz&invalid number of derivative orders nur))rmrrrrr@rBrrrrZintcrr?rArrYr rrhrrZ evaluate_nd) rSrrrmr?rZdim1Zdim2Zdim3ksrr&r&r'rbps6 zNdPPoly.__call__cCs|dkr|| |St|j}||}|dkr4dStdg|}td| d||<|jt|}|j|dkrt|j}d||<tj ||j d}t t |j|dd|}dg|j}td||<||t|9}||_dS)zz Compute 1-D derivative along a selected dimension in-place May result to non-contiguous c array. rNrrr,)_antiderivative_inplacerrrrYrr@rrBrrhrrrr?)rSrrrr?slrZshprr&r&r'_derivative_inplaces$    zNdPPoly._derivative_inplacec Cs|dkr|| |St|j}||}tt|}|||d|d<||<|tt||jj}|j|}tj |j d|f|j dd|j d}||d| <t t|j ddd|}|d| |tdfd|jd<tt|j}||||d|d<|||<||}|}t||j d|j dd|j||d||}||}||_dS)zu Compute 1-D antiderivative along a selected dimension May result to non-contiguous c array. rrNrr,r)rrrrrrYr?r rBrr@rhrrrrr5rrr) rSrrrr?permrYrrZperm2r&r&r'rs0    ."   zNdPPoly._antiderivative_inplacecCsB||j|j|j}t|D]\}}|||q ||S)a$ Construct a new piecewise polynomial representing the derivative. Parameters ---------- nu : ndim-tuple of int Order of derivatives to evaluate for each dimension. If negative, the antiderivative is returned. Returns ------- pp : NdPPoly Piecewise polynomial of orders (k[0] - nu[0], ..., k[n] - nu[n]) representing the derivative of this polynomial. Notes ----- Derivatives are evaluated piecewise for each polynomial segment, even if the polynomial is not differentiable at the breakpoints. The polynomial intervals in each dimension are considered half-open, ``[a, b)``, except for the last interval which is closed ``[a, b]``. )rrYr5rrmrrrrSrr"rrrr&r&r'rs zNdPPoly.derivativecCsB||j|j|j}t|D]\}}|||q ||S)a Construct a new piecewise polynomial representing the antiderivative. Antiderivative is also the indefinite integral of the function, and derivative is its inverse operation. Parameters ---------- nu : ndim-tuple of int Order of derivatives to evaluate for each dimension. If negative, the derivative is returned. Returns ------- pp : PPoly Piecewise polynomial of order k2 = k + n representing the antiderivative of this polynomial. Notes ----- The antiderivative returned by this function is continuous and continuously differentiable to order n-1, up to floating point rounding error. )rrYr5rrmrrrr!r&r&r'r s zNdPPoly.antiderivativec Cs(|dur|j}nt|}t|j}t||}|j}tt|j}| d||||d=| d||||||d=| |}t j | |jd|jdd|j||d}|j|||d} |dkr| |jddS| |jdd}|jd||j|dd} |j || |dSdS)a Compute NdPPoly representation for one dimensional definite integral The result is a piecewise polynomial representing the integral: .. math:: p(y, z, ...) = \int_a^b dx\, p(x, y, z, ...) where the dimension integrated over is specified with the `axis` parameter. Parameters ---------- a, b : float Lower and upper bound for integration. axis : int Dimension over which to compute the 1-D integrals extrapolate : bool, optional Whether to extrapolate to out-of-bounds points based on first and last intervals, or to return NaNs. Returns ------- ig : NdPPoly or array-like Definite integral of the piecewise polynomial over [a, b]. If the polynomial was 1D, an array is returned, otherwise, an NdPPoly object. Nrrr,rmr))rmrrrrzrYrrr?insertr rrrr@r) rSr7rrrrmr?rYswapr"rrr&r&r' integrate_1d> s,     zNdPPoly.integrate_1dc Cst|j}|dur|j}nt|}t|dr8t||kr@td||j}t|D]\}\}}t t |j }| d||||||d=| |}tj||j||d} | j|||d} | |jdd}qV|S)aq Compute a definite integral over a piecewise polynomial. Parameters ---------- ranges : ndim-tuple of 2-tuples float Sequence of lower and upper bounds for each dimension, ``[(a[0], b[0]), ..., (a[ndim-1], b[ndim-1])]`` extrapolate : bool, optional Whether to extrapolate to out-of-bounds points based on first and last intervals, or to return NaNs. Returns ------- ig : array_like Definite integral of the piecewise polynomial over [a[0], b[0]] x ... x [a[ndim-1], b[ndim-1]] N__len__z&Range not a sequence of correct lengthrr"r))rrrmrhasattrrArrYrrrr?r#r rrrrr@) rSrangesrmr?rYrr7rr$r"rr&r&r'r{ s"  zNdPPoly.integrate)N)N)NN)N)N)rcrdrerfr[rrrrrbrrrrr%rr&r&r&r'rs>   A"(!" =r)*__all__mathrr:numpyrBr r r r r rrrrZ scipy.specialZspecialrZscipy._lib._utilrrrrZ_polyintrrZinterpndrZ _bsplinesrrrr<rrlrprrrrrr&r&r&r'sH ,        J'ZS/