`Vg+udZddlmZddlmZmZddlmZmZm Z ddl Z ddl m Z mZddlmZmZmZmZddlmZdd lmZdd lmZmZmZdd lmZmZmZerdd l m!Z!d)d Z"d*dZ#d+d,dZ$gdZ%gdZ&d-dZ'd.dZ( d/ d0dZ) d1 d2dZ*d3dZ+ d4 d5dZ, d6dZ-d7dZ.d8dZ/d9dZ0 d:dZ1 d; ddZ3d?dZ4e4 d@ dAd Z5e4 d@ dAd!Z6e4d@dBd"Z7e4d@dCd#Z8e5e6d$Z9dDdEd%Z:dFd&Z;dGd'Z XXnE:N>"G G8 $E 88CIIT *D   #C + axHh 3#,,4%,H H D {{} S  Kr c|dvryt|tr|j}|dk(rd}n|dk(rd}ddg}d}|r|jdd}||vrt d |d ||S) N)Nasfreqffillpadbfillbackfillzpad (ffill) or backfill (bfill)nearestz(pad (ffill), backfill (bfill) or nearestzInvalid fill method. Expecting z. Got )r)strlowerappendr)method allow_nearest valid_methods expectings rclean_fill_methodrBks !!&# W F w FJ'M1IY'>  ]":9+VF8TUU Mr )lineartimeindexvalues)r:zeroslinear quadraticcubic barycentrickroghspline polynomialfrom_derivativespiecewise_polynomialpchipakima cubicsplinec |jd}|dvr | tdttz}||vrtd|d|d|dvr|jst|d|S) Norder)rMrNz7You must specify the order of the spline or polynomial.zmethod must be one of z. Got 'z ' instead.)rLrPrQz4 interpolation requires that the index be monotonic.)getr NP_METHODS SP_METHODSis_monotonic_increasing)r>rEkwargsrUvalids rclean_interp_methodr\s JJw E ))emRSS  #E U1%xzRSS ;;,,(NO  Mr c |dvsJt|dk(ryt|}|jdk(r|jd}|dk(r|ddj }n*|dk(r%t|dz |ddd j z }|}|sy|S) a Retrieves the index of the first valid value. Parameters ---------- values : ndarray or ExtensionArray how : {'first', 'last'} Use this parameter to change between the first or last valid index. Returns ------- int or None )firstlastrNaxisr^r_)rrndimr,argmax)rFhowis_valididxpos chk_notnas rfind_valid_indexrks # ## # 6{aV }H {{a<#8#8#:: I  Mr c  t|} | | tdt|| |||y|Jtd||||||||d| y#t$rd} YFwxYw)z Wrapper to dispatch to either interpolate_2d or _interpolate_2d_with_fill. Notes ----- Alters 'data' in-place. Nz&Cannot pass both fill_value and method)r>rclimit limit_area)datarErcr>rmlimit_directionrn fill_value)rBrinterpolate_2d_interpolate_2d_with_fill) ror>rcrErmrprnrqcoercedowncastrZms rinterpolate_array_2drxs( f % }  !EF F !  *    ! +!!   ;  s A AAc   t|fit|jrt|jddk(r"t |js t ddgd} j | vrt d| dd *d d g} j | vrt d | ddtjd t| d fd } tj| ||y )z Column-wise application of _interpolate_1d. Notes ----- Alters 'data' in-place. The signature does differ from _interpolate_1d because it only includes what is needed for Block.interpolate. F)compatrDzStime-weighted interpolation only works on Series or DataFrames with a DatetimeIndexrF)forwardbackwardbothz*Invalid limit_direction: expecting one of z, got 'z'.Ninsideoutsidez%Invalid limit_area: expecting one of z, got .)nobsrmc .td|ddy)NF)indicesyvaluesr>rmrprnrq bounds_errorrr)_interpolate_1d)rrqrrZrmrnrpr>s rfuncz'_interpolate_2d_with_fill..funcAs4  +!!  r )r np.ndarrayreturnNone) r\rr"rrrr<r validate_limit_index_to_interp_indicesr$apply_along_axis) rorErcr>rmrprnrqrZvalid_limit_directionsvalid_limit_areasrrs `````` @rrtrts0,00Z4' 5A  "5;;/   <%++-O44 8%&go->b B  %y1%%' . .78I7J&,a!   d% 8E&uf5G   *dD) r cF|j}t|jr|jd}|dk(r|}t t j |}|St j|}|dvr2|jt jk(rtj|}|S)zE Convert Index to ndarray of indices to pass to NumPy/SciPy. i8rC)rFrE) _valuesrr"viewrr$r*asarrayobject_r maybe_convert_objects)rEr>xarrindss rrrZs ==D4::&yy BJJ% K zz$ ( (zzRZZ'006 Kr c  Vt|} | } | jsy| jrytt j | } t |d} | d} tt| }t |d}| t|}ttd|zt| }|dk(r|tt| |dz}n5|dk(r|tt| d|z}ntt| ||}|d k(r |||zz}n|d k(r | |z |z }||z}t|}|tvrBt j|| }t j|| || ||| ||| <nt|| || || f||||d | || <tj||<y) a Logic for the 1-d interpolation. The input indices and yvalues will each be 1-d arrays of the same length. Bounds_error is currently hardcoded to False since non-scipy ones don't take it as an argument. Notes ----- Fills 'yvalues' in-place. Nr^rgrr_rar{r|r~r)r>rqrrU)rr,allsetr$ flatnonzerorkranger _interp_limitsortedrWargsortinterp_interpolate_scipy_wrappernan)rrr>rmrprnrqrrUrZinvalidr[all_nansfirst_valid_index start_nanslast_valid_indexend_nans preserve_nansmid_nansindexers rrrps07mG HE 99; yy{2>>'*+H(g> U,-.J'V<w<5--s5z:;H)#"Swq)I%JJ J & 3}Wa'G#HH M'5%@A Xh.. y j(83! =)M **WU^,99 G genW5wu~g7N 6 EN EN G   !%     VVGM r c d|d}td|ddlm} tj|}| j | j ttd} t|ddr,|jjd |jd }}|d k(r| j| d <n|d k(r t| d <n|d k(r t| d <gd } || vr'|dk(r|}| j|||||} | |} | S|dk(r>t|s|dkrt!d|| j"||fd|i|} | |} | S|j$j&s|j)}|j$j&s|j)}|j$j&s|j)}| |}||||fi|} | S)z Passed off to scipy.interpolate.interp1d. method is scipy's kind. Returns an array interpolated at new_x. Add any new methods to the list in _clean_interp_method. z interpolation requires SciPy.scipy)extrar interpolate)rKrLrOrP _is_all_datesFrrQrRrS)r:rGrHrIrJrNrN)kindrqrrMz;order needs to be specified and greater than 0; got order: k)rrrr$rbarycentric_interpolatekrogh_interpolate_from_derivativesgetattrrastypepchip_interpolate_akima_interpolate_cubicspline_interpolateinterp1drrUnivariateSplineflags writeablecopy)r1ynew_xr>rqrrUrZrr alt_methodsinterp1d_methodsterpnew_ys rrrsh4 5Ewe4! JJu E#::..- 1 Kq/5)99##D)5<<+=5 *<< G 7 1 G = %= M"!! \ !F## qv*<$ U ( L' 8  ;5A:MeWU ,{++AqDEDVDU  Lww  Aww  A{{$$JJLEV$q!U-f- Lr cddlm}|jj}|||j dd||}||S)a Convenience function for interpolate.BPoly.from_derivatives. 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] order: None or int or array-like of ints. Default: None. Specifies the degree of local polynomials. If not None, some derivatives are ignored. der : int or list How many derivatives to extract; None for all potentially nonzero derivatives (that is a number equal to the number of points), or a list of derivatives to extract. This number includes the function value as 0th derivative. extrapolate : bool, optional Whether to extrapolate to ouf-of-bounds points based on first and last intervals, or to return NaNs. Default: True. See Also -------- scipy.interpolate.BPoly.from_derivatives Returns ------- y : scalar or array-like The result, of length R or length M or M by R. rrrdra)orders extrapolate)rrBPolyrOreshape) xiyir1rUderrrr>rws rrrs?D"   / /Fr2::b!$U LA Q4Kr cJddlm}|j|||}|||S)a[ Convenience function for akima interpolation. xi and yi are arrays of values used to approximate some function f, with ``yi = f(xi)``. See `Akima1DInterpolator` for details. Parameters ---------- xi : array-like A sorted list of x-coordinates, of length N. yi : array-like A 1-D array of real values. `yi`'s length along the interpolation axis must be equal to the length of `xi`. If N-D array, use axis parameter to select correct axis. x : scalar or array-like Of length M. der : int, optional How many derivatives to extract; None for all potentially nonzero derivatives (that is a number equal to the number of points), or a list of derivatives to extract. This number includes the function value as 0th derivative. axis : int, optional Axis in the yi array corresponding to the x-coordinate values. See Also -------- scipy.interpolate.Akima1DInterpolator Returns ------- y : scalar or array-like The result, of length R or length M or M by R, rrrb)nu)rrAkima1DInterpolator)rrr1rrcrPs rrrEs+H"''BT':A Q3<r cJddlm}|j|||||}||S)aq Convenience function for cubic spline data interpolator. See `scipy.interpolate.CubicSpline` for details. Parameters ---------- xi : array-like, shape (n,) 1-d array containing values of the independent variable. Values must be real, finite and in strictly increasing order. yi : array-like Array containing values of the dependent variable. It can have arbitrary number of dimensions, but the length along ``axis`` (see below) must match the length of ``x``. Values must be finite. x : scalar or array-like, shape (m,) axis : int, optional Axis along which `y` is assumed to be varying. Meaning that for ``x[i]`` the corresponding values are ``np.take(y, i, axis=axis)``. Default is 0. bc_type : string or 2-tuple, optional Boundary condition type. Two additional equations, given by the boundary conditions, are required to determine all coefficients of polynomials on each segment [2]_. If `bc_type` is a string, then the specified condition will be applied at both ends of a spline. Available conditions are: * 'not-a-knot' (default): The first and second segment at a curve end are the same polynomial. It is a good default when there is no information on boundary conditions. * 'periodic': The interpolated functions is assumed to be periodic of period ``x[-1] - x[0]``. The first and last value of `y` must be identical: ``y[0] == y[-1]``. This boundary condition will result in ``y'[0] == y'[-1]`` and ``y''[0] == y''[-1]``. * 'clamped': The first derivative at curves ends are zero. Assuming a 1D `y`, ``bc_type=((1, 0.0), (1, 0.0))`` is the same condition. * 'natural': The second derivative at curve ends are zero. Assuming a 1D `y`, ``bc_type=((2, 0.0), (2, 0.0))`` is the same condition. If `bc_type` is a 2-tuple, the first and the second value will be applied at the curve start and end respectively. The tuple values can be one of the previously mentioned strings (except 'periodic') or a tuple `(order, deriv_values)` allowing to specify arbitrary derivatives at curve ends: * `order`: the derivative order, 1 or 2. * `deriv_value`: array-like containing derivative values, shape must be the same as `y`, excluding ``axis`` dimension. For example, if `y` is 1D, then `deriv_value` must be a scalar. If `y` is 3D with the shape (n0, n1, n2) and axis=2, then `deriv_value` must be 2D and have the shape (n0, n1). extrapolate : {bool, 'periodic', None}, optional If bool, determines whether to extrapolate to out-of-bounds points based on first and last intervals, or to return NaNs. If 'periodic', periodic extrapolation is used. If None (default), ``extrapolate`` is set to 'periodic' for ``bc_type='periodic'`` and to True otherwise. See Also -------- scipy.interpolate.CubicHermiteSpline Returns ------- y : scalar or array-like The result, of shape (m,) References ---------- .. [1] `Cubic Spline Interpolation `_ on Wikiversity. .. [2] Carl de Boor, "A Practical Guide to Splines", Springer-Verlag, 1978. rr)rcbc_typer)rr CubicSpline)rrr1rcrrrrs rrrps3L" BT7   A Q4Kr ct|}|jslt|d}|d}t|d}| t|}t ||||dk(r d|||d zn|d k(r dx|d|||d zdt j ||<y) a Apply interpolation and limit_area logic to values along a to-be-specified axis. Parameters ---------- values: np.ndarray Input array. method: str Interpolation method. Could be "bfill" or "pad" limit: int, optional Index limit on interpolation. limit_area: str Limit area for interpolation. Can be "inside" or "outside" Notes ----- Modifies values in-place. r^rNrr_)r>rmr~Frar)rrrkrrsr$r)rFr>rmrnrr^r_s r_interpolate_with_limit_arears,6lG ;;= W5 =EF3 <v;D   !(-GED1H % 9 $49 9GFUOgdQhj1&&w r cb|)tjtt|||||y|dk(rdnd}|jdk(r7|dk7r t d|j td|jz}t|}||}|d k(rt|| yt|| y) a Perform an actual interpolation of values, values will be make 2-d if needed fills inplace, returns the result. Parameters ---------- values: np.ndarray Input array. method: str, default "pad" Interpolation method. Could be "bfill" or "pad" axis: 0 or 1 Interpolation axis limit: int, optional Index limit on interpolation. limit_area: str, optional Limit area for interpolation. Can be "inside" or "outside" Notes ----- Modifies values in-place. N)r>rmrnrc|SNrrr1s rz interpolate_2d.."sr c|jSr)Trs rrz interpolate_2d.."s r raz0cannot interpolate on a ndim == 1 with axis != 0rar7rm) r$rrrreAssertionErrorrtupler'rB_pad_2d _backfill_2d)rFr>rcrmrntransftvaluess rrsrss8  ,%    % ( "aikmF{{a 19 !ST TdV\\&9 :; v &FVnGu%  WE* r c^| t|}|jtj}|Sr)rrr$uint8)rFrs r _fillna_prepr6s)  |F| 99RXX D Kr cLtdfd }tt|S)z> Wrapper to handle datetime64 and timedelta64 dtypes. ct|jrG| t|}|jd||\}}|j|j|fS|||S)Nr)rmr)rr"rr)rFrmrresultrs rnew_funcz&_datetimelike_compat..new_funcGs_ v|| ,|F| D 1TJLFD;;v||,d2 2F%d33r NN)rrr )rrs` r_datetimelike_compatrBs*  4[ 4 4 8 r cRt||}tj|||||fSNr)rr pad_inplacerFrmrs r_pad_1drVs,  %D fd%0 4<r cRt||}tj|||||fSr)rr backfill_inplacers r _backfill_1dras,  %D 64u5 4<r ct||}tj|jrt j |||||fS ||fSr)rr$rr'r pad_2d_inplacers rrrlsK  %D vvfll VT7 4< 4<r ct||}tj|jrt j |||||fS ||fSr)rr$rr'r backfill_2d_inplacers rrrxsK  %D vvfll !!&$e< 4< 4<r r7r9cTt|}|dk(r t|Sttd|S)Nrar)rB _fill_methodsrr)r>res r get_fill_funcrs. v &F qyV$$ 5f ==r ct|dS)NT)r?)rB)r>s rclean_reindex_fill_methodrs V4 88r cRt|t}t}fd}|0|dk(r"ttj|d}n |||}|J|dk(r|St ||ddd|}tdz tj |z }|dk(r|S||zS)ak Get indexers of values that won't be filled because they exceed the limits. Parameters ---------- invalid : np.ndarray[bool] fw_limit : int or None forward limit to index bw_limit : int or None backward limit to index Returns ------- set of indexers Notes ----- This is equivalent to the more readable, but slower .. code-block:: python def _interp_limit(invalid, fw_limit, bw_limit): for x in np.where(invalid)[0]: if invalid[max(0, x - fw_limit):x + bw_limit + 1].all(): yield x c t|}t||dzjd}tt j |d|ztt j |d|dzj dk(dz}|S)Nrar)min_rolling_windowrrr$wherecumsum)rrmwindowedidxNs rinnerz_interp_limit..innersE1 "7EAI6::1="((8$Q'%/03 HHw{++335: ;A >4   r Nrrdra)rrr$rlistr)rfw_limitbw_limitf_idxb_idxr  b_idx_invr s @rrrs> G A EE EE q=)!,-E'8,E q=LU74R4=(; [ [True, True], [True, False], [False, True], [True, False], ] Nrdra)r'strides)r'rr$r stride_tricks as_strided)awindowr'rs rrrsj GGCRLAGGBK&014f= =Eii199R=**G 66   * *1E7 * KKr )rnpt.NDArray[np.bool_]rint)r-r rr)F)r> str | Noner?r()r>r;rErrr;)rgr;r int | None) r7rNNr{NNFN)rorr>r;rcrrEz Index | Nonermrrpr;rnrrq Any | Nonerur(rvrrr)rCNr{NN)rorrErrcrr>r;rmrrpr;rnrrqrrr)rErr>r;rr)rCNr{NNFN)rrrrr>rrmrrpr;rnrrqrrr(rUr)NFN)NrF)rr)rz not-a-knotN) rFrr>r;rmrrnrrr)r7rNN) rFrr>r;rcr rmrrnrrrr)rnpt.NDArray[np.bool_] | Nonerr)rr rr r)rFrrmrrrrz(tuple[np.ndarray, npt.NDArray[np.bool_]])rFrrr)rrr)rer)rr)rr)rrrrrr)>__doc__ __future__r functoolsrrtypingrrrnumpyr$ pandas._libsr r pandas._typingr r r rpandas.compat._optionalrpandas.core.dtypes.castrpandas.core.dtypes.commonrrrpandas.core.dtypes.missingrrrpandasrrr3rBrWrXr\rkrxrtrrrrrrrrsrrrrrrrrrrrrrr rr,s#  ?4   +\03  $&"N$!!3 3 3  3   3  3  3 3 3  3 3  3 t$!!P P P  P   P  P  P P P  P f2"$!!a a a  a   a  a  a a a  a JEICL(V(VL^- - #- ,6- DN-  - d! D D D  D   D  D  D P26 .  ()-   '. )-   '.  \: >9>BLr