ó ˽÷Xc @`s-dZddlmZmZmZddddddd d d d d ddg ZddlZddlZddlZddl Z ddl Z ddl m Z m Z mZmZmZmZmZmZmZmZddlZddljZddlmZddlmZmZmZddl m!Z!ddl m"Z"ddl m#Z#ddl$m%Z%ddl m&Z&ddl'm(Z(ddl)m*Z*ddl+m,Z,m-Z-d„Z.d„Z/de0fd„ƒYZ1d „Z2d!„Z3de%fd"„ƒYZ4d#e0fd$„ƒYZ5d e5fd%„ƒYZ6d e5fd&„ƒYZ7d e0fd'„ƒYZ8de0fd(„ƒYZ9d)e:e j;d*„Z<d e6fd+„ƒYZ=d,„Z>e?e?d-„Z@d.„ZAe jBd/d0ƒd1d2e?d3„ƒZCe jBd/d4ƒdd5„ƒZDe jBd/d6ƒd7„ƒZEe jBd/d8ƒd1d2e?d9„ƒZFdS(:s# Classes for interpolating values. i(tdivisiontprint_functiontabsolute_importtinterp1dtinterp2dtsplinetsplevaltsplmaketspltopptppformtlagrangetPPolytBPolytNdPPolytRegularGridInterpolatortinterpnN( tarrayt transposet searchsortedt atleast_1dt atleast_2dtdottraveltpoly1dtasarraytintp(tcomb(txranget integer_typest string_typesi(tfitpack(tdfitpack(t_fitpack(t_Interpolator1D(t_ppoly(tRectBivariateSpline(t_ndim_coords_from_arrays(tmake_interp_splinetBSplinecC`s)t|ƒdkrdStjtj|ƒS(sFProduct of a list of numbers; ~40x faster vs np.prod for Python tuplesii(tlent functoolstreducetoperatortmul(tx((s</tmp/pip-build-7oUkmx/scipy/scipy/interpolate/interpolate.pytprod$scC`s§t|ƒ}tdƒ}xˆt|ƒD]z}t||ƒ}xWt|ƒD]I}||kr`qHn||||}|td|| gƒ|9}qHW||7}q%W|S(s‹ 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. ggð?(R'RR(R,twtMtptjtpttktfac((s</tmp/pip-build-7oUkmx/scipy/scipy/interpolate/interpolate.pyR +s   #cB`s5eZdZdeedd„Zdded„ZRS(sà interp2d(x, y, z, kind='linear', copy=True, bounds_error=False, fill_value=nan) Interpolate over a 2-D grid. `x`, `y` and `z` are arrays of values used to approximate some function f: ``z = f(x, y)``. 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. Note that calling `interp2d` with NaNs present in input values results in undefined behaviour. Methods ------- __call__ Parameters ---------- x, y : array_like Arrays defining the data point coordinates. 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,2,3,4,5,6] If `x` and `y` are multi-dimensional, they are flattened before use. z : array_like The values of the function to interpolate at the data points. If `z` is a multi-dimensional array, it is flattened before use. 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. See Also -------- RectBivariateSpline : Much faster 2D 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 : one dimension version of this function 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. Examples -------- Construct a 2-D grid and interpolate on it: >>> 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() tlinearcC`s/t|ƒ}t|ƒ}t|ƒ}|jt|ƒt|ƒk}|r;|jdkr‹|jt|ƒt|ƒfkr‹tdƒ‚q‹ntj|d|d kƒsÚtj |ƒ} || }|dd…| f}ntj|d|d kƒs)tj |ƒ} || }|| dd…f}nt|j ƒ}nZt|ƒ}t|ƒt|ƒkrntdƒ‚nt|ƒt|ƒkr•tdƒ‚ny'idd6dd 6d d 6|} } Wnt k rÛtd ƒ‚nX|st j |||d | d| ddƒ|_n€tj|||ddddd | d| ddƒ\} } }}}}}| | || || | d|| d | | f|_||_||_g|||fD]}t|d|ƒ^q±\|_|_|_tj|ƒtj|ƒ|_|_tj|ƒtj|ƒ|_|_dS(NisdWhen on a regular grid with x.size = m and y.size = n, if z.ndim == 2, then z must have shape (n, m)iiÿÿÿÿs8x and y must have equal lengths for non rectangular grids3Invalid length for input z for non rectangular gridR5itcubicitquinticsUnsupported interpolation type.tkxtkytsgtcopy(RRtsizeR'tndimtshapet ValueErrortnptalltargsorttTtKeyErrorRtbisplrepttckRt regrid_smthtNonet bounds_errort fill_valueRR,tytztamintamaxtx_mintx_maxty_minty_max(tselfR,RKRLtkindR;RIRJtrectangular_gridR1R8R9tnxttxtnyttytctfptierta((s</tmp/pip-build-7oUkmx/scipy/scipy/interpolate/interpolate.pyt__init__µsT   !       -*)  @%ic C`sØt|ƒ}t|ƒ}|jdks6|jdkrEtdƒ‚n|sltj|ƒ}tj|ƒ}n|js„|jdk rÝ||jk||j kB}||j k||j kB}tj |ƒ}tj |ƒ} n|jr#|sò| r#td|j|j f|j |j ffƒ‚nt j|||j||ƒ} t| ƒ} t| ƒ} |jdk r¯|rŠ|j| dd…|f= 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 : 2D array with shape (len(y), len(x)) The interpolated values. is!x and y should both be 1-D arrayss-Values out of range; x must be in %r, y in %rNi(RR=R?R@tsortRIRJRHRORPRQRRtanyRtbisplevRFRRR'R( RSR,RKtdxtdyt assume_sortedtout_of_bounds_xtout_of_bounds_ytany_out_of_bounds_xtany_out_of_bounds_yRL((s</tmp/pip-build-7oUkmx/scipy/scipy/interpolate/interpolate.pyt__call__ìs6     N(t__name__t __module__t__doc__tTruetFalseRHR^Ri(((s</tmp/pip-build-7oUkmx/scipy/scipy/interpolate/interpolate.pyRSs`  6cC`sÛ|j}t|ƒt|ƒkr¾xšt|ddd…|ddd…ƒD](\}}|dkrK||krKPqKqKW|jdkr±|j|kr±tj||jƒ|}n|jƒSntd|||fƒ‚dS(s7Helper to check that arr_from broadcasts up to shape_toNiÿÿÿÿisE%s argument must be able to broadcast up to shape %s but had shape %s( R>R'tzipR<R@tonestdtypeRR?(tarr_fromtshape_totnamet shape_fromtttf((s</tmp/pip-build-7oUkmx/scipy/scipy/interpolate/interpolate.pyt_check_broadcast_up_to*s 6 cC`st|tƒo|dkS(s?Helper to check if fill_value == "extrapolate" without warningst extrapolate(t isinstanceR(RJ((s</tmp/pip-build-7oUkmx/scipy/scipy/interpolate/interpolate.pyt_do_extrapolate;scB`sŒeZdZdded ejed„Ze d„ƒZ e j d„ƒZ d„Z d„Z d„Zd „Zd „Zd „Zd „ZRS(s> Interpolate a 1-D function. `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. Note that calling `interp1d` with NaNs present in input values results in undefined behaviour. Parameters ---------- x : (N,) array_like A 1-D array of real values. y : (...,N,...) 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`. kind : str or int, optional Specifies the kind of interpolation as a string ('linear', 'nearest', 'zero', 'slinear', 'quadratic', 'cubic' where 'zero', 'slinear', 'quadratic' and 'cubic' refer to a spline interpolation of zeroth, first, second or third order) or as an integer specifying the order of the spline interpolator to use. Default is 'linear'. axis : int, optional Specifies the axis of `y` along which to interpolate. Interpolation defaults to the last axis of `y`. copy : bool, optional If True, the class makes internal copies of x and y. If False, references to `x` and `y` are used. 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``. .. 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. 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 Examples -------- >>> 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() R5iÿÿÿÿc C`sÇtj|||d|ƒ||_||_|dkrmidd6dd6dd6d d6d d6|} d }n=t|tƒr‹|} d }n|dkrªtd |ƒ‚nt|d|jƒ}t|d|jƒ}|stj |ƒ} || }tj || d|ƒ}n|j dkr,t dƒ‚n|j dkrJt dƒ‚nt |jjtjƒsw|jtjƒ}n||j |_||_|j|jƒ|_||_~~||_||_|dkr d } |dkr!|jd|_|jd|jd |_|jj|_q›|jjtjkoH|jjtjk} | o`|jj dk} | ost|ƒ } | rŽ|jj|_q›|jj |_nû| d} t!} |j|j}}| dkrVtj"|jƒj#ƒr tj$t%|jƒt&|jƒt'|jƒƒ}t(} ntj"|jƒj#ƒrVtj)|jƒ}t(} qVnt*||d| dt!ƒ|_+| rŒ|jj,|_n|jj-|_t'|jƒ| krÃt d| ƒ‚ndS(s, Initialize a 1D linear interpolation class.taxistzerotslineart quadraticR6itnearestiiiRR5s8%s is unsupported: Use fitpack routines for other types.R;s,the x array must have exactly one dimension.s-the y array must have at least one dimension.g@iÿÿÿÿR3t check_finites,x and y arrays must have at least %d entriesN(R}R~Rscubic(slinearR€(slinearR€(.R!R^RIR;RztinttNotImplementedErrorRR@RBttakeR=R?t issubclassRqttypetinexacttastypetfloat_R|RKt _reshape_yit_yR,t_kindRJtx_bdst __class__t _call_nearestt_callR{t_call_linear_npt _call_linearRntisnanR`tlinspacetmintmaxR'Rmt ones_likeR%t_splinet_call_nan_splinet _call_spline(RSR,RKRTR|R;RIRJRdtordertindtminvaltcondt rewrite_nantxxtyy((s</tmp/pip-build-7oUkmx/scipy/scipy/interpolate/interpolate.pyR^“s|              *  0   cC`s|jS(N(t_fill_value_orig(RS((s</tmp/pip-build-7oUkmx/scipy/scipy/interpolate/interpolate.pyRJúscC`slt|ƒr9|jr$tdƒ‚nt|_t|_n&|jj|j |jj|jd}t |ƒdkr|d}nt |t ƒrt |ƒdkrt j |dƒt j |dƒg}d }x]tdƒD]$}t|||||ƒ||R|R'RzttupleR@RtrangeRxt_fill_value_belowt_fill_value_aboveRHR¢(RSRJtbroadcast_shapet below_abovetnamestii((s</tmp/pip-build-7oUkmx/scipy/scipy/interpolate/interpolate.pyRJÿs0     !"  cC`stj||j|jƒS(N(R@tinterpR,RK(RStx_new((s</tmp/pip-build-7oUkmx/scipy/scipy/interpolate/interpolate.pyR‘!sc C`sÆt|j|ƒ}|jdt|jƒdƒjtƒ}|d}|}|j|}|j|}|j|}|j|}||||dd…df} | ||dd…df|} | S(Ni(RR,tclipR'RˆR‚R‹RH( RSR­t x_new_indicestlothitx_lotx_hity_loty_hitslopety_new((s</tmp/pip-build-7oUkmx/scipy/scipy/interpolate/interpolate.pyR’%s(     ""cC`sQt|j|ddƒ}|jdt|jƒdƒjtƒ}|j|}|S(s6 Find nearest neighbour interpolated y_new = f(x_new).tsidetleftii(RRR®R'R,RˆRR‹(RSR­R¯R·((s</tmp/pip-build-7oUkmx/scipy/scipy/interpolate/interpolate.pyRBs( cC`s |j|ƒS(N(R˜(RSR­((s</tmp/pip-build-7oUkmx/scipy/scipy/interpolate/interpolate.pyRšSscC`s |j|ƒ}tj|d<|S(N.(R˜R@tnan(RSR­tout((s</tmp/pip-build-7oUkmx/scipy/scipy/interpolate/interpolate.pyR™Vs cC`srt|ƒ}|j||ƒ}|jsn|j|ƒ\}}t|ƒdkrn|j||<|j||t dƒ‚n|jj dkr_t d ƒ‚n|jjddkr„t d ƒ‚n|jjd|jjdkr³t d ƒ‚ntj|jƒ}tj|dkƒpìtj|dkƒsþt d ƒ‚n|j|jjƒ}tj|jd|ƒ|_dS( NRqtperiodiciis%s must be between 0 and %ssx must be 1-dimensionalis!at least 2 breakpoints are neededs!c must have at least 2 dimensionss&polynomial must be at least of order 0s"number of coefficients != len(x)-1s.`x` must be strictly increasing or decreasing.(R@RRZtascontiguousarraytfloat64R,RHRmtboolRyR=R?R|trollaxisR<R>tdiffRAt _get_dtypeRq(RSRZR,RyR|RbRq((s</tmp/pip-build-7oUkmx/scipy/scipy/interpolate/interpolate.pyR^Žs8    &    *cC`sBtj|tjƒs0tj|jjtjƒr7tjStjSdS(N(R@t issubdtypetcomplexfloatingRZRqtcomplex_R‰(RSRq((s</tmp/pip-build-7oUkmx/scipy/scipy/interpolate/interpolate.pyRÉ·scC`sLtj|ƒ}||_||_||_|dkr?t}n||_|S(sA 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. N(tobjectt__new__RZR,R|RHRmRy(tclsRZR,RyR|RS((s</tmp/pip-build-7oUkmx/scipy/scipy/interpolate/interpolate.pytconstruct_fast¾s       cC`sL|jjjs$|jjƒ|_n|jjjsH|jjƒ|_ndS(sr c and x may be modified by the user. The Cython code expects that they are C contiguous. N(R,tflagst c_contiguousR;RZ(RS((s</tmp/pip-build-7oUkmx/scipy/scipy/interpolate/interpolate.pyt_ensure_c_contiguousÑsc C`sÍ|d k rtjdƒntj|ƒ}tj|ƒ}|jdkrXtdƒ‚n|jdkrvtdƒ‚n|jd|jdkrŸtdƒ‚n|jd|jjdksÑ|j|jjkràtdƒ‚n|j dkród Stj |ƒ}tj |dkƒp)tj |dkƒs;td ƒ‚n|j d |j dkrÇ|d |dksxtd ƒ‚n|d|j d kr˜d }q6|d |j dkr¸d}q6tdƒ‚no|d |dksêtd ƒ‚n|d|j d kr d }n,|d |j dkr*d}n tdƒ‚|j |jƒ}t|jd|jjdƒ}tj||jjd|jdf|jjdd|ƒ}|d kr6|j|||jjdd …d |jjd…f<||||jdd …|jjdd …fRZR<RÈRAR,RÉRqR–tzerostr_( RSRZR,trightRbtactionRqtk2tc2((s</tmp/pip-build-7oUkmx/scipy/scipy/interpolate/interpolate.pytextendÛsZ 2*      5  71 11cC`sx|dkr|j}ntj|ƒ}|j|j}}tj|jƒdtjƒ}|dkrŸ|j d||j d|j d|j d}t }ntj t |ƒt |jjdƒfd|jjƒ}|jƒ|j||||ƒ|j||jjdƒ}|jdkrttt|jƒƒ}||||j!|| |||j}|j|ƒ}n|S(sX 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]``. RqRÃiiÿÿÿÿiN(RHRyR@RR>R=RÄRR‰R,RntemptyR'R-RZRqRÓR¿treshapeR|tlistR¥R(RSR,tnuRytx_shapetx_ndimR»tl((s</tmp/pip-build-7oUkmx/scipy/scipy/interpolate/interpolate.pyRi.s"   2 7 +(RZR,s extrapolatesaxisN( RjRkRlt __slots__RHR^RÉt classmethodRÐRÓRÞRi(((s</tmp/pip-build-7oUkmx/scipy/scipy/interpolate/interpolate.pyRŠs)  ScB`s€eZdZd„Zdd„Zdd„Zd d„Zded d„Z ed d„Z e d d „ƒZ e d d „ƒZ RS( sV 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-dimensional 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. cC`sOtj|jj|jjd|jjddƒ|j||t|ƒ|ƒdS(Niiiÿÿÿÿ(R"tevaluateRZRàR>R,RÆ(RSR,RâRyR»((s</tmp/pip-build-7oUkmx/scipy/scipy/interpolate/interpolate.pyR¿Ÿs/icC`s|dkr|j| ƒS|dkr8|jjƒ}n&|jd| …dd…fjƒ}|jddkr—tjd|jdd|jƒ}ntjtj |jdddƒ|ƒ}||t dƒfd|j d9}|j ||j|j|jƒS(s 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]``. iNiRqiÿÿÿÿ(i(N(tantiderivativeRZR;R>R@RØRqtspectpochtarangetsliceRHR=RÐR,RyR|(RSRâRÝtfactor((s</tmp/pip-build-7oUkmx/scipy/scipy/interpolate/interpolate.pyt derivative£s  &&(&cC`sE|dkr|j| ƒStj|jjd||jjdf|jjdd|jjƒ}|j|| *tjtj|jjdddƒ|ƒ}|| c |t dƒfd|j d*|j ƒt j|j|jd|jddƒ|j|dƒ|jdkr t}n |j}|j||j||jƒS( s< 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. iiiRqiÿÿÿÿRÃN(N(RïR@RØRZR>RqRêRëRìRíRHR=RÓR"tfix_continuityRàR,RyRnRÐR|(RSRâRZRîRy((s</tmp/pip-build-7oUkmx/scipy/scipy/interpolate/interpolate.pyRéÏs 8+- &  c C`sä|dkr|j}nd}||kr@||}}d}ntjt|jjdƒfd|jjƒ}|jƒ|dkru|j d|j d}}||}||} t | |ƒ\} } | dkr)t j |jj |jjd|jjddƒ|j ||td|ƒ|| 9}n |jdƒ||||}|| }tj|ƒ} ||krÂt j |jj |jjd|jjddƒ|j ||td| ƒ|| 7}qÃt j |jj |jjd|jjddƒ|j ||td| ƒ|| 7}t j |jj |jjd|jjddƒ|j ||| ||td| ƒ|| 7}nNt j |jj |jjd|jjddƒ|j ||t|ƒd|ƒ||9}|j |jjdƒS( s˜ 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] iiÿÿÿÿiRqRÃiR»N(RHRyR@RßR-RZR>RqRÓR,tdivmodR"t integrateRàRntfillt empty_likeRÆ( RSR]tbRytsignt range_inttxstxetperiodtintervalt n_periodsR¹t remainder_int((s</tmp/pip-build-7oUkmx/scipy/scipy/interpolate/interpolate.pyRòsP     .     )    ) ) )% ) gcC`s)|dkr|j}n|jƒtj|jjtjƒrLtdƒ‚nt |ƒ}t j |jj |jj d|jj ddƒ|j|t|ƒt|ƒƒ}|jjdkrÂ|dStjt|jj dƒdtƒ}x$t|ƒD]\}}|||>> from scipy.interpolate import PPoly >>> pp = PPoly(np.array([[1, -4, 3], [1, 0, 0]]).T, [-2, 1, 2]) >>> pp.roots() array([-1., 1.]) s0Root finding is only for real-valued polynomialsiiiÿÿÿÿiRqN(RHRyRÓR@RÊRZRqRËR?tfloatR"t real_rootsRàR>R,RÆR=RßR-RÍt enumerate(RSRKt discontinuityRytrtr2R«troot((s</tmp/pip-build-7oUkmx/scipy/scipy/interpolate/interpolate.pytsolveWs0    /%cC`s|jd||ƒS(s_ Find real roots of the 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 i(R(RSRRy((s</tmp/pip-build-7oUkmx/scipy/scipy/interpolate/interpolate.pytrootsŸsc C`sît|tƒr<|j\}}}|dkrK|j}qKn|\}}}tj|dt|ƒdfd|jƒ}xat |ddƒD]M}t j |d |d|ƒ}|t j |dƒ|||dd…fRHR=t zeros_likeR¥RRíRyRÐR|( RÏtbpRyRbR3trestRZR]RîR:tval((s</tmp/pip-build-7oUkmx/scipy/scipy/interpolate/interpolate.pytfrom_bernstein_basisØs"9  N(RjRkRlR¿RïRéRHRòRmRRRçR R(((s</tmp/pip-build-7oUkmx/scipy/scipy/interpolate/interpolate.pyR ds:  , 6 RHcB`s›eZdZd„Zdd„Zdd„Zd d„Zd d„Ze jje_e d d„ƒZ e d d d„ƒZ e d „ƒZe d „ƒZRS( s_ 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-dimensional 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. Here's a non-exhaustive list: .. [1] http://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 cC`sOtj|jj|jjd|jjddƒ|j||t|ƒ|ƒdS(Niiiÿÿÿÿ(R"tevaluate_bernsteinRZRàR>R,RÆ(RSR,RâRyR»((s</tmp/pip-build-7oUkmx/scipy/scipy/interpolate/interpolate.pyR¿Ms)icC`s7|dkr|j| ƒS|dkrS|}x t|ƒD]}|jƒ}q9W|S|dkrq|jjƒ}nnd|jjd}|jjdd}tj |j ƒdt dƒf|}|tj |jddƒ|}|jddkrtj d|jdd|j ƒ}n|j||j |j|jƒS( sÎ 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. iiiR|RqN(N(i(RéR¥RïRZR;RHR=R>R@RÈR,RíRØRqRÐRyR|(RSRâRR3RÝRRb((s</tmp/pip-build-7oUkmx/scipy/scipy/interpolate/interpolate.pyRïRs     & &c C`sƒ|dkr|j| ƒS|dkrS|}x t|ƒD]}|jƒ}q9W|S|j|j}}|jd}tj|df|jdd|jƒ}tj |ddƒ||dd…df<|d|d }||dt dƒfd |j d9}|dd…dd…fctj ||dd…fddƒd 7<|j d kr^t}n |j }|j|||d|jƒS( s 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. iiRqR|N.iÿÿÿÿiRÃ(N(RïR¥RéRZR,R>R@RØRqtcumsumRHRíR=RyRnRÐR|( RSRâRR3RZR,RÝtdeltaRy((s</tmp/pip-build-7oUkmx/scipy/scipy/interpolate/interpolate.pyRé‡s$   *))E  c C`sm|jƒ}|dkr$|j}n|dkr<||_n|dkrU||kr]d}n||}}d}|jd|jd}}||}||} t| |ƒ\} } | ||ƒ||ƒ} ||||}|| }||kr| ||ƒ||ƒ7} n:| ||ƒ||ƒ||| ||ƒ||ƒ7} || S||ƒ||ƒSdS(st Compute a definite integral over a piecewise polynomial. Parameters ---------- a : float Lower integration bound b : float Upper integration bound extrapolate : {bool, 'periodic', None}, optional 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 ------- array_like Definite integral of the piecewise polynomial over [a, b] RÃiiÿÿÿÿiN(RéRHRyR,Rñ( RSR]RõRytibRöRøRùRúRûRüR¹tres((s</tmp/pip-build-7oUkmx/scipy/scipy/interpolate/interpolate.pyRò¿s,             :cC`syt|jjd|jdƒ}|j|j||jjdƒ|_|j|||jdƒ}tj||||ƒS(Ni(R–RZR>t _raise_degreeRÂRÞ(RSRZR,RÚR3((s</tmp/pip-build-7oUkmx/scipy/scipy/interpolate/interpolate.pyRÞÿs &c C`stj|jƒ}|jjdd}d|jjd}tj|jƒ}x–t|dƒD]„}|j|t |||ƒ|t dƒf|||}x@t|||dƒD]'} || c|t | ||ƒ7RHR=R R¥RRíRyRÐR|( RÏtppRyRbR3RRZR]RîR1((s</tmp/pip-build-7oUkmx/scipy/scipy/interpolate/interpolate.pytfrom_power_basiss;)  c`stj|ƒ}t|ƒtˆƒkr6tdƒ‚ntj|d|d dkƒrftdƒ‚nt|ƒd}y&t‡fd†t|ƒDƒƒ}Wntk r»tdƒ‚nX|d krØd g|}nbt |t tj fƒr|g|}nt|t|ƒƒ}td„|Dƒƒr:tdƒ‚ng}x£t|ƒD]•}ˆ|ˆ|d} } ||d kr˜t| ƒt| ƒ} } nà||d} t | d t| ƒƒ} t | | t| ƒƒ} t | | t| ƒƒ} | | | krEd ||t| ƒ||dt| ƒ||f}t|ƒ‚n| t| ƒkof| t| ƒksxtd ƒ‚nt j||||d| | | | ƒ}t|ƒ|krÕt j||t|ƒƒ}n|j|ƒqMWtj|ƒ}||jddƒ||ƒS( s0 Construct a piecewise polynomial in the Bernstein basis, compatible with the specified values and derivatives at breakpoints. Parameters ---------- xi : array_like sorted 1D array of x-coordinates yi : array_like or list of array_likes ``yi[i][j]`` is the ``j``-th derivative known at ``xi[i]`` orders : None or int or array_like of ints. Default: None. Specifies the degree of local polynomials. If not None, some derivatives are ignored. 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. Notes ----- If ``k`` derivatives are specified at a breakpoint ``x``, the constructed polynomial is exactly ``k`` times continuously differentiable at ``x``, unless the ``order`` is provided explicitly. In the latter case, the smoothness of the polynomial at the breakpoint is controlled by the ``order``. Deduces the number of derivatives to match at each end from ``order`` and the number of derivatives available. If possible it uses the same number of derivatives from each end; if the number is odd it tries to take the extra one from y2. In any case if not enough derivatives are available at one end or another it draws enough to make up the total from the other end. If the order is too high and not enough derivatives are available, an exception is raised. Examples -------- >>> 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 s&xi and yi need to have the same lengthiis)x coordinates are not in increasing orderc3`s1|]'}tˆ|ƒtˆ|dƒVqdS(iN(R'(t.0ti(tyi(s</tmp/pip-build-7oUkmx/scipy/scipy/interpolate/interpolate.pys pss/Using a 1D array for y? Please .reshape(-1, 1).cs`s|]}|dkVqdS(iN((Rto((s</tmp/pip-build-7oUkmx/scipy/scipy/interpolate/interpolate.pys {ssOrders must be positive.isPPoint %g has %d derivatives, point %g has %d derivatives, but order %d requesteds0`order` input incompatible with length y1 or y2.N(R@RR'R?R`R–R¥t TypeErrorRHRzRtintegerR•R t_construct_from_derivativesRRÔtswapaxes(RÏtxiRtordersRyR R3RZRty1ty2tn1tn2tntmesgRõ((Rs</tmp/pip-build-7oUkmx/scipy/scipy/interpolate/interpolate.pytfrom_derivatives%sN@!&  2$c C`s!tj|ƒtj|ƒ}}|jd|jdkrHtdƒ‚n|j|j}}tj|tjƒs…tj|tjƒr‘tj}n tj}t |ƒt |ƒ}}||} tj ||f|jdd|ƒ} xŒt d|ƒD]{} || t j | | | ƒ||| | | 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`. is'ya and yb have incompatible dimensions.Rqiiÿÿÿÿ(R@RR>R?RqRÊRËRÌR‰R'RßR¥RêRëR( txatxbtyatybtdtatdtbtdttnatnbR(RZtqR1((s</tmp/pip-build-7oUkmx/scipy/scipy/interpolate/interpolate.pyR ›s(7   '.5;Cc C`sÜ|dkr|S|jdd}tj|jd|f|jdd|jƒ}xƒt|jdƒD]n}||t||ƒ}xNt|dƒD]<}|||c|t||ƒt||||ƒ7R@RØRqR¥R(RZtdR3R»R]RwR1((s</tmp/pip-build-7oUkmx/scipy/scipy/interpolate/interpolate.pyRñs 1>N(RjRkRlR¿RïRéRHRòRÞRÂRçRR*t staticmethodR R(((s</tmp/pip-build-7oUkmx/scipy/scipy/interpolate/interpolate.pyR ùsR  5 8 @ uVcB`s‰eZdZd d„Zed d„ƒZd„Zd„Zd d d„Z d„Z d„Z d„Z d „Z d d „Zd d „ZRS( s 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__ construct_fast See also -------- PPoly : piecewise polynomials in 1D Notes ----- High-order polynomials in the power basis can be numerically unstable. cC`sktd„|Dƒƒ|_tj|ƒ|_|dkr@t}nt|ƒ|_t |jƒ}t d„|jDƒƒr†t dƒ‚nt d„|jDƒƒr®t dƒ‚n|j d|krÐt dƒ‚nt d„|jDƒƒrøt d ƒ‚nt d „t |j|d|!|jƒDƒƒr7t d ƒ‚n|j|jjƒ}tj|jd |ƒ|_dS( Ncs`s'|]}tj|dtjƒVqdS(RqN(R@RÄRÅ(Rtv((s</tmp/pip-build-7oUkmx/scipy/scipy/interpolate/interpolate.pys Vscs`s|]}|jdkVqdS(iN(R=(RR7((s</tmp/pip-build-7oUkmx/scipy/scipy/interpolate/interpolate.pys ]ss"x arrays must all be 1-dimensionalcs`s|]}|jdkVqdS(iN(R<(RR7((s</tmp/pip-build-7oUkmx/scipy/scipy/interpolate/interpolate.pys _ss+x arrays must all contain at least 2 pointsis(c must have at least 2*len(x) dimensionscs`s0|]&}tj|d|d dkƒVqdS(iiÿÿÿÿiN(R@R`(RR7((s</tmp/pip-build-7oUkmx/scipy/scipy/interpolate/interpolate.pys css)x-coordinates are not in increasing ordercs`s(|]\}}||jdkVqdS(iN(R<(RR]Rõ((s</tmp/pip-build-7oUkmx/scipy/scipy/interpolate/interpolate.pys ess/x and c do not agree on the number of intervalsRq(R¤R,R@RRZRHRmRÆRyR'R`R?R=RoR>RÉRqRÄ(RSRZR,RyR=Rq((s</tmp/pip-build-7oUkmx/scipy/scipy/interpolate/interpolate.pyR^Us$  0cC`sCtj|ƒ}||_||_|dkr6t}n||_|S(sB 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. N(RÍRÎRZR,RHRmRy(RÏRZR,RyRS((s</tmp/pip-build-7oUkmx/scipy/scipy/interpolate/interpolate.pyRÐks      cC`sBtj|tjƒs0tj|jjtjƒr7tjStjSdS(N(R@RÊRËRZRqRÌR‰(RSRq((s</tmp/pip-build-7oUkmx/scipy/scipy/interpolate/interpolate.pyRÉ~scC`sO|jjjs$|jjƒ|_nt|jtƒsKt|jƒ|_ndS(N(RZRÑRÒR;RzR,R¤(RS((s</tmp/pip-build-7oUkmx/scipy/scipy/interpolate/interpolate.pyRÓ…sc C`sä|dkr|j}n t|ƒ}t|jƒ}t|ƒ}|j}tj|j d|jdƒdtj ƒ}|dkrtj |fdtj ƒ}nItj |dtj ƒ}|jdks×|jd|krætdƒ‚nt|jj| ƒ}t|jj|d|!ƒ}t|jjd|ƒ}tj|jj| dtj ƒ} tj|jd|fd|jjƒ} |jƒtj|jj |||ƒ|j| ||t|ƒ| ƒ| j |d |jjd|ƒS(sÇ 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]``. iÿÿÿÿRqiis&invalid number of derivative orders nuiN(RHRyRÆR'R,R$R>R@RÄRàR‰RØtintcRR=R?R-RZRRßRqRÓR"t evaluate_nd( RSR,RâRyR=Rãtdim1tdim2tdim3tksR»((s</tmp/pip-build-7oUkmx/scipy/scipy/interpolate/interpolate.pyRi‹s4     + ""(  cC`s'|dkr|j| |ƒSt|jƒ}||}|dkrFdStdƒg|}td| dƒ||<|j|}|j|dkrÄt|jƒ}d||RáR@RØRqRêRëRìR=(RSRâR|R=tslRÝtshpRî((s</tmp/pip-build-7oUkmx/scipy/scipy/interpolate/interpolate.pyt_derivative_inplaceÌs$     (c C`sâ|dkr|j| |ƒSt|jƒ}||}tt|ƒƒ}|||d|d<||<|tt||jjƒƒ}|jj|ƒ}tj |j d|f|j dd|j ƒ}||| *t j tj|j dddƒ|ƒ}|| c |tdƒfd|jd*tt|jƒƒ}||||d|d<|||<|j|ƒ}|jƒ}tj|j|j d|j ddƒ|j||dƒ|j|ƒ}|j|ƒ}||_dS(st Compute 1D antiderivative along a selected dimension May result to non-contiguous c array. iiRqiÿÿÿÿN(N(RAR'R,RáR¥RZR=RR@RØR>RqRêRëRìRíRHR;R"RðRà( RSRâR|R=tpermRZRÝRîtperm2((s</tmp/pip-build-7oUkmx/scipy/scipy/interpolate/interpolate.pyR>îs,  %  (-% &cC`s_|j|jjƒ|j|jƒ}x*t|ƒD]\}}|j||ƒq1W|jƒ|S(s$ 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]``. (RÐRZR;R,RyRRARÓ(RSRâR0R|R(((s</tmp/pip-build-7oUkmx/scipy/scipy/interpolate/interpolate.pyRïs $ cC`s_|j|jjƒ|j|jƒ}x*t|ƒD]\}}|j||ƒq1W|jƒ|S(sú 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. (RÐRZR;R,RyRR>RÓ(RSRâR0R|R(((s</tmp/pip-build-7oUkmx/scipy/scipy/interpolate/interpolate.pyRé7s $ c C`sv|dkr|j}n t|ƒ}t|jƒ}t|ƒ|}|j}tt|j ƒƒ}|j d||ƒ||d=|j d|||ƒ|||d=|j |ƒ}t j |j|jd|jddƒ|j|d|ƒ}|j||d|ƒ} |dkr*| j|jdƒS| j|jdƒ}|j| |j|d} |j || d|ƒSdS(s¦ 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 1D 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 1-dimensional, an array is returned, otherwise, an NdPPoly object. iiiÿÿÿÿRyiN(RHRyRÆR'R,R‚RZRáR¥R=tinsertRR RÐRàR>Rò( RSR]RõR|RyR=RZtswapR0R»R,((s</tmp/pip-build-7oUkmx/scipy/scipy/interpolate/interpolate.pyt integrate_1dYs*     &   c C`s6t|jƒ}|dkr'|j}n t|ƒ}t|dƒ sUt|ƒ|krdtdƒ‚n|jƒ|j}x¸t |ƒD]ª\}\}}t t |j ƒƒ}|j d|||ƒ|||d=|j|ƒ}tj||j|d|ƒ} | j||d|ƒ} | j|jdƒ}q„W|S(sq 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]] t__len__s&Range not a sequence of correct lengthiRyiN(R'R,RHRyRÆthasattrR?RÓRZRRáR¥R=RDRR RÐRòRàR>( RStrangesRyR=RZR(R]RõRER0R»((s</tmp/pip-build-7oUkmx/scipy/scipy/interpolate/interpolate.pyRò–s"   "  N(RjRkRlRHR^RçRÐRÉRÓRiRAR>RïRéRFRò(((s</tmp/pip-build-7oUkmx/scipy/scipy/interpolate/interpolate.pyR s9   A " ( ! " =cB`sJeZdZdeejd„Zdd„Zd„Z d„Z d„Z RS(sj Interpolation on a regular grid in arbitrary dimensions The data must be defined on a regular grid; the grid spacing however may be uneven. Linear and nearest-neighbour interpolation are supported. After setting up the interpolator object, the interpolation method (*linear* or *nearest*) may be chosen at each evaluation. Parameters ---------- points : tuple of ndarray of float, with shapes (m1, ), ..., (mn, ) The points defining the regular grid in n dimensions. values : array_like, shape (m1, ..., mn, ...) The data on the regular grid in n dimensions. method : str, optional The method of interpolation to perform. Supported are "linear" and "nearest". This parameter will become the default for the object's ``__call__`` method. Default is "linear". bounds_error : bool, optional If True, when interpolated values are requested outside of the domain of the input data, 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 None, values outside the domain are extrapolated. Methods ------- __call__ Notes ----- Contrary to LinearNDInterpolator and NearestNDInterpolator, this class avoids expensive triangulation of the input data by taking advantage of the regular grid structure. .. versionadded:: 0.14 Examples -------- Evaluate a simple example function on the points of a 3D grid: >>> from scipy.interpolate import RegularGridInterpolator >>> def f(x, y, z): ... return 2 * x**3 + 3 * y**2 - z >>> x = np.linspace(1, 4, 11) >>> y = np.linspace(4, 7, 22) >>> z = np.linspace(7, 9, 33) >>> data = f(*np.meshgrid(x, y, z, indexing='ij', sparse=True)) ``data`` is now a 3D array with ``data[i,j,k] = f(x[i], y[j], z[k])``. Next, define an interpolating function from this data: >>> my_interpolating_function = RegularGridInterpolator((x, y, z), data) Evaluate the interpolating function at the two points ``(x,y,z) = (2.1, 6.2, 8.3)`` and ``(3.3, 5.2, 7.1)``: >>> pts = np.array([[2.1, 6.2, 8.3], [3.3, 5.2, 7.1]]) >>> my_interpolating_function(pts) array([ 125.80469388, 146.30069388]) which is indeed a close approximation to ``[f(2.1, 6.2, 8.3), f(3.3, 5.2, 7.1)]``. See also -------- NearestNDInterpolator : Nearest neighbour interpolation on unstructured data in N dimensions LinearNDInterpolator : Piecewise linear interpolant on unstructured data in N dimensions References ---------- .. [1] Python package *regulargrid* by Johannes Buchner, see https://pypi.python.org/pypi/regulargrid/ .. [2] Trilinear interpolation. (2013, January 17). In Wikipedia, The Free Encyclopedia. Retrieved 27 Feb 2013 01:28. http://en.wikipedia.org/w/index.php?title=Trilinear_interpolation&oldid=533448871 .. [3] Weiser, Alan, and Sergio E. Zarantonello. "A note on piecewise linear and multilinear table interpolation in many dimensions." MATH. COMPUT. 50.181 (1988): 189-196. http://www.ams.org/journals/mcom/1988-50-181/S0025-5718-1988-0917826-0/S0025-5718-1988-0917826-0.pdf R5c C`s+|dkrtd|ƒ‚n||_||_t|dƒsRtj|ƒ}nt|ƒ|jkr‰tdt|ƒ|jfƒ‚nt|dƒrÔt|dƒrÔtj|j tj ƒsÔ|j t ƒ}qÔn||_ |dk r8tj|ƒj }t|dƒr8tj||j dd ƒ r8td ƒ‚q8nx¸t|ƒD]ª\}}tjtj|ƒd kƒs‚td |ƒ‚ntj|ƒjd ks­td|ƒ‚n|j|t|ƒksEtdt|ƒ|j||fƒ‚qEqEWtg|D]}tj|ƒ^qýƒ|_||_dS(NR5R€sMethod '%s' is not definedR=s7There are %d point arrays, but values has %d dimensionsRqRˆtcastingt same_kindsDfill_value must be either 'None' or of a type compatible with valuesgs5The points in dimension %d must be strictly ascendingis0The points in dimension %d must be 1-dimensionals1There are %d points and %d values in dimension %d(slinearsnearest(R?tmethodRIRHR@RR'R=RÊRqR‡RˆRþRJRHtcan_castRRARÈR>R¤tgridtvalues( RStpointsRORLRIRJtfill_value_dtypeRR0((s</tmp/pip-build-7oUkmx/scipy/scipy/interpolate/interpolate.pyR^& s>        '+c C`sæ|d kr|jn|}|d kr:td|ƒ‚nt|jƒ}t|d|ƒ}|jdt|jƒkr—td|jd|fƒ‚n|j}|jd|dƒ}|jr;xyt |j ƒD]e\}}t j t j |j|d|kƒt j ||j|dkƒƒsÏtd |ƒ‚qÏqÏWn|j|j ƒ\}}} |dkrz|j||| ƒ} n$|dkrž|j||| ƒ} n|j rÇ|jd k rÇ|j| | RàRIRRCR@t logical_andRAt _find_indicest_evaluate_lineart_evaluate_nearestRJRO( RSR"RLR=txi_shapeRR0tindicestnorm_distancest out_of_boundstresult((s</tmp/pip-build-7oUkmx/scipy/scipy/interpolate/interpolate.pyRiO s8   ##      c C`sßtdƒfd|jjt|ƒ}tjg|D]}||dg^q4Œ}d}x|D]w}d} xFt|||ƒD]2\} }} | tj | |kd| | ƒ9} qW|tj |j|ƒ| |7}q`W|S(Niggð?(N( RíRHROR=R't itertoolstproductRoR@twhereR( RSRWRXRYtvsliceRtedgesROt edge_indicestweightteiR((s</tmp/pip-build-7oUkmx/scipy/scipy/interpolate/interpolate.pyRT€ s', "'&cC`sWg}xCt||ƒD]2\}}|jtj|dk||dƒƒqW|j|S(Ngà?i(RoRÔR@R]RO(RSRWRXRYtidx_resRR((s</tmp/pip-build-7oUkmx/scipy/scipy/interpolate/interpolate.pyRU s*cC`sg}g}tj|jddtƒ}xÎt||jƒD]º\}}tj||ƒd}d||dk<|jd|||jdk<|j|ƒ|j|||||d||ƒ|j s;|||dk7}|||dk7}q;q;W|||fS(NiRqiiiÿÿÿÿ( R@RØR>RÆRoRNRR<RÔRI(RSR"RWRXRYR,RNR((s</tmp/pip-build-7oUkmx/scipy/scipy/interpolate/interpolate.pyRS• s  N( RjRkRlRmR@RºR^RHRiRTRURS(((s</tmp/pip-build-7oUkmx/scipy/scipy/interpolate/interpolate.pyRÇs[( 1  R5c C`sq|dkrtd|ƒ‚nt|dƒs@tj|ƒ}n|j}|dkrp|dkrptdƒ‚n| rž|dkrž|dkržtdƒ‚nt|ƒ|krÏtd t|ƒ|fƒ‚nt|ƒ|krü|dkrütd ƒ‚nx¸t|ƒD]ª\}}tjtj |ƒd kƒsFtd |ƒ‚ntj|ƒjd ksqtd|ƒ‚n|j |t|ƒks tdt|ƒ|j ||fƒ‚q q Wt g|D]}tj|ƒ^qÁƒ} t |dt| ƒƒ}|j dt| ƒkr6td|j d t| ƒfƒ‚nxwt|j ƒD]f\}}|rFtjtj| |d|kƒtj|| |dkƒƒ rFtd|ƒ‚qFqFW|dkrçt||ddd|d|ƒ} | |ƒS|dkrt||ddd|d|ƒ} | |ƒS|dkrm|j } |jd|j dƒ}tj| dd|dd…dfk|dd…df| ddk| d d|dd…d fk|dd…d f| d dkfddƒ} tj|dd…dfƒ} t|d|d |ƒ} | j|| df|| d fƒ| | <|| tj| ƒ<| j| d ƒSdS(sï Multidimensional interpolation on regular grids. Parameters ---------- points : tuple of ndarray of float, with shapes (m1, ), ..., (mn, ) The points defining the regular grid in n dimensions. values : array_like, shape (m1, ..., mn, ...) The data on the regular grid in n dimensions. xi : ndarray of shape (..., ndim) The coordinates to sample the gridded data at method : str, optional The method of interpolation to perform. Supported are "linear" and "nearest", and "splinef2d". "splinef2d" is only supported for 2-dimensional data. bounds_error : bool, optional If True, when interpolated values are requested outside of the domain of the input data, 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 None, values outside the domain are extrapolated. Extrapolation is not supported by method "splinef2d". Returns ------- values_x : ndarray, shape xi.shape[:-1] + values.shape[ndim:] Interpolated values at input coordinates. Notes ----- .. versionadded:: 0.14 See also -------- NearestNDInterpolator : Nearest neighbour interpolation on unstructured data in N dimensions LinearNDInterpolator : Piecewise linear interpolant on unstructured data in N dimensions RegularGridInterpolator : Linear and nearest-neighbor Interpolation on a regular grid in arbitrary dimensions RectBivariateSpline : Bivariate spline approximation over a rectangular mesh R5R€t splinef2ds[interpn only understands the methods 'linear', 'nearest', and 'splinef2d'. You provided %s.R=isBThe method spline2fd can only be used for 2-dimensional input datas4The method spline2fd does not support extrapolation.s7There are %d point arrays, but values has %d dimensionssSThe method spline2fd can only be used for scalar data with one point per coordinategs5The points in dimension %d must be strictly ascendingis0The points in dimension %d must be 1-dimensionals1There are %d points and %d values in dimension %diÿÿÿÿscThe requested sample points xi have dimension %d, but this RegularGridInterpolator has dimension %dis8One of the requested xi is out of bounds in dimension %dRLRIRJNR|(slinearsnearestRd(R?RHR@RR=RHR'RRARÈR>R¤R$RCRRRRàRôR#tevt logical_not(RPROR"RLRIRJR=RR0RNR¬RVt idx_validRZ((s</tmp/pip-build-7oUkmx/scipy/scipy/interpolate/interpolate.pyRª sp9     '( &!        HH *cB`sAeZdZded„Zd„Zd„Zedd„ƒZRS(se Deprecated piecewise polynomial class. New code should use the `PPoly` class instead. gcC`s¥tjddtƒ|r+tj|ƒ}ntj|ƒ}tj|||ƒ|j|_ |j |_ |j j d|_ ||_|j d|_|j d|_dS(Ns)ppform is deprecated -- use PPoly insteadtcategoryiiÿÿÿÿ(RÖR×tDeprecationWarningR@R_RR R^RZtcoeffsR,tbreaksR>tKRóR]Rõ(RSRjRkRóR_((s</tmp/pip-build-7oUkmx/scipy/scipy/interpolate/interpolate.pyR^: s    cC`stj||dtƒS(Ni(R RiRn(RSR,((s</tmp/pip-build-7oUkmx/scipy/scipy/interpolate/interpolate.pyRiL scC`sAtj|||||ƒ|j|||jk||jk@<|S(N(R R¿RóR]Rõ(RSR,RâRyR»((s</tmp/pip-build-7oUkmx/scipy/scipy/interpolate/interpolate.pyR¿O s$c C`sµt|ƒd}tj|d|fdtƒ}xpt|ddƒD]\}tj|dƒ}tj|d ||||ƒ} | |} | |||dd…fR?RˆRHRxRyR( RnR}R›R~RtlhtrhR.R/Ro((s</tmp/pip-build-7oUkmx/scipy/scipy/interpolate/interpolate.pyt _find_user s    tmessagesFsplmake is deprecated in scipy 0.19.0, use make_interp_spline instead.it smoothestcC`sÇtj|ƒ}t|ƒ}|dkr6tdƒ‚n|dkrS||d |fS|dkrl|||fSytd|ƒ}Wn t‚nXtj||ƒ}||||||ƒ}|||fS(sŽ Return a representation of a spline given data-points at internal knots Parameters ---------- xk : array_like The input array of x values of rank 1 yk : array_like The input array of y values of rank N. `yk` can be an N-d array to represent more than one curve, through the same `xk` points. The first dimension is assumed to be the interpolating dimension and is the same length of `xk`. order : int, optional Order of the spline kind : str, optional Can be 'smoothest', 'not_a_knot', 'fixed', 'clamped', 'natural', 'periodic', 'symmetric', 'user', 'mixed' and it is ignored if order < 2 conds : optional Conds Returns ------- splmake : tuple Return a (`xk`, `cvals`, `k`) representation of a spline given data-points where the (internal) knots are at the data-points. isorder must not be negativeiÿÿÿÿis_find_%s(R@t asanyarrayR‚R?tevalRƒR Rv(RnR}R›RTR~tfuncRtcoefs((s</tmp/pip-build-7oUkmx/scipy/scipy/interpolate/interpolate.pyRž s      s;spleval is deprecated in scipy 0.19.0, use BSpline instead.c C`s'|\}}}tj|ƒ}tj|ƒ}|jd}tj|j|d|jƒ} xºtj|ŒD]©} tdƒf| } t|jj tj ƒrït j |||j | ||ƒ| | _ t j |||j| ||ƒ| | _qit j |||| ||ƒ| | 1) and/or `xnew` is N-d, then the result is `xnew.shape` + `cvals.shape[1:]` providing the interpolation of multiple curves. Notes ----- Internally, an additional `k`-1 knot points are added on either side of the spline. iRqN(R@R>RRßRqtndindexRíRHR…R†RËR Rmtrealtimag( txcktxnewtderivtxjR R3toldshapeR tshRtindexR?((s</tmp/pip-build-7oUkmx/scipy/scipy/interpolate/interpolate.pyRÑ s& ),' sEspltopp is deprecated in scipy 0.19.0, use PPoly.from_spline instead.cC`stj|||ƒS(s@Return a piece-wise polynomial object from a fixed-spline tuple.(R Rr(RnR R3((s</tmp/pip-build-7oUkmx/scipy/scipy/interpolate/interpolate.pyR ss@spline is deprecated in scipy 0.19.0, use Bspline class instead.c C`s(tt||d|d|d|ƒ|ƒS(s÷ Interpolate a curve at new points using a spline fit Parameters ---------- xk, yk : array_like The x and y values that define the curve. xnew : array_like The x values where spline should estimate the y values. order : int Default is 3. kind : string One of {'smoothest'} conds : Don't know Don't know Returns ------- spline : ndarray An array of y values; the spline evaluated at the positions `xnew`. R›RTR~(RR(RnR}R—R›RTR~((s</tmp/pip-build-7oUkmx/scipy/scipy/interpolate/interpolate.pyR s(GRlt __future__RRRt__all__R[RÖR(R*tnumpyR@RRRRRRRRRRt scipy.linalgRxt scipy.specialtspecialRêRtscipy._lib.sixRRRtRRR tpolyintR!R"tfitpack2R#tinterpndR$t _bsplinesR%R&R-R RÍRRxR{RRÂR R R RRmRºRR RuRHRˆRŒt deprecateRRRR(((s</tmp/pip-build-7oUkmx/scipy/scipy/interpolate/interpolate.pytsf      F   (×  ÿJÚÿ–ÿÿ#ÿ®ã‡2  14