o i+u@s0dZddlmZddlmZmZddlmZmZm Z ddl Z ddl m Z mZddlmZmZmZmZddlmZdd lmZdd lmZmZmZdd lmZmZmZerZdd l m!Z!drddZ"dsddZ#dtduddZ$gdZ%gd Z&dvd$d%Z'dwd(d)Z( *    +    dxdyd8d9Z) :  +  dzd{d;d<Z*d|d=d>Z+ :  +    d}d~dCdDZ, ddEdFZ-ddGdHZ.ddIdJZ/ddLdMZ0ddOdPZ1 *   dddRdSZ2 dddUdVZ3ddYdZZ4e4  ddd\d]Z5e4  ddd^d_Z6e4ddd`daZ7e4dddbdcZ8e5e6ddZ9dddgdhZ:ddidjZ;ddldmZt|d|ddd }||}|sFdS|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)rFr\is_valididxpos chk_notnarrrfind_valid_indexs     rjr9forwarddata np.ndarrayrc Index | Nonelimitlimit_direction limit_area fill_value Any | NonecoercedowncastNonec Kszt|} Wn tyd} Ynw| dur)|durtdt|| |||ddS|dus/Jtd||||||||d| dS)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)r4rcrorq)rlrErcr4rorprqrrr)rBrinterpolate_2d_interpolate_2d_with_fill) rlr4rcrErorprqrrrtrurYmrrrinterpolate_array_2ds<     rzrCc  st|fit|jrt|jdddkr%t|js#tddgd} | vr.func)rrmr"rv) r[rr#rrrr>rvalidate_limit_index_to_interp_indicesr%apply_along_axis) rlrErcr4rorprqrrrYvalid_limit_directionsvalid_limit_areasrrrrrxsB   rxcCsb|j}t|jr |d}|dkr|}ttj|}|St|}|dvr/|jtjkr/t |}|S)zE Convert Index to ndarray of indices to pass to NumPy/SciPy. i8rC)rFrE) _valuesrr#viewrr%r+asarrayobject_r maybe_convert_objects)rEr4xarrindsrrrrZs      rrrrrTc Kst|} | } | s dS| rdStt| } t|dd} | dur&d} tt| }t|dd}|dur:t|}ttd|t| }|dkrT|tt | |dB}n|dkrc|tt | d|B}ntt | ||}|d krv|||BO}n|d kr| ||}||O}t |}|t vrt || }t || || ||| ||| <nt|| || || f||||d | || <tj||<dS) 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^r\rr_rarkr|r~r)r4rrrrT)rr-allsetr% flatnonzerorjranger _interp_limitsortedrVargsortinterp_interpolate_scipy_wrappernan)rrr4rorprqrrrrTrYinvalidrZall_nansfirst_valid_index start_nanslast_valid_indexend_nans preserve_nansmid_nansindexerrrrrpsZ       rcKsn|d}td|dddlm} t|}| j| jttd} t|ddr1|j d | d }}|d kr;| j | d <n|d krDt | d <n|d krLt | d <gd } || vrj|dkrZ|}| j|||||d} | |} | S|dkrt|sv|dkr}td|| j||fd|i|} | |} | S|jjs|}|jjs|}|jjs|}| |}||||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)kindrrrrMz;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_xr4rrrrTrYrr alt_methodsinterp1d_methodsterpnew_yrrrrsV         rc Cs4ddlm}|jj}|||dd||d}||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) xiyir1rTderrrr4ryrrrrs "rcCs(ddlm}|j|||d}|||dS)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)rrr1rrcrPrrrrEs $ r not-a-knotcCs(ddlm}|j|||||d}||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)rrr1rcrrrrrrrrps F rrFcCst|}|sMt|dd}|durd}t|dd}|dur"t|}t|||d|dkr6d|||d <n|d krHd|d|<||d d<tj||<dS) 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_)r4ror~Frar)rrrjrrwr%r)rFr4rorqrr^r_rrr_interpolate_with_limit_areas&   rr cCs|durttt|||d||dS|dkrddndd}|jdkr6|dkr,td|td |j}t |}||}|d krJt ||d dSt ||d dS) 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)r4rorqrcSs|SNrr1rrr"sz interpolate_2d..cSs|jSr)Trrrrr"sraz0cannot interpolate on a ndim == 1 with axis != 0rar9ro) r%rrrreAssertionErrorrtupler(rB_pad_2d _backfill_2d)rFr4rcrorqtransftvaluesrrrrws0    rwnpt.NDArray[np.bool_] | NonecCs |durt|}|tj}|Sr)rrr%uint8)rFrrrr _fillna_prep6s rrr cs tdfdd }tt|S)z> Wrapper to handle datetime64 and timedelta64 dtypes. NcsPt|jr!|dur t|}|d||d\}}||j|fS|||dS)Nr)ror)rr#rr)rFrorresultrrrnew_funcGs z&_datetimelike_compat..new_funcNN)rrr )rrrrr_datetimelike_compatBs r(tuple[np.ndarray, npt.NDArray[np.bool_]]cC"t||}tj|||d||fSNr)rr pad_inplacerFrorrrr_pad_1dV rcCrr)rrbackfill_inplacerrrr _backfill_1darrcC8t||}t|jrtj|||d||fS ||fSr)rr%rr(rpad_2d_inplacerrrrrl  rcCrr)rr%rr(rbackfill_2d_inplacerrrrrxrrr9r;rarecCs&t|}|dkr t|Sttd|S)Nrar)rB _fill_methodsrr)r4rerrr get_fill_funcsrcCs t|ddS)NT)r6)rB)r4rrrclean_reindex_fill_methods rrcst|t}t}fdd}|dur'|dkr"tt|d}n|||}|durN|dkr1|St||ddd|}tdt|}|dkrN|S||@S)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 cs`t|}t||dd}tt|d|tt|d|ddkdB}|S)Nrar)min_rolling_windowrrr%wherecumsum)rrowindowedidxNrrinners "z_interp_limit..innerNrrdra)rrr%rlistr)rfw_limitbw_limitf_idxb_idxr b_idx_invrrrrs   rawindowcCsJ|jdd|jd|d|f}|j|jdf}tjjj|||dS)z [True, True, False, True, False], 2 -> [ [True, True], [True, False], [False, True], [True, False], ] Nrdra)r(strides)r(rr%r stride_tricks as_strided)rrr(rrrrrs$ r)rrrr)r!r r"r)F)r4r5r6r))r4r=rErr"r=)r\r=r"r]) r9rNNrkNNFN)rlrmr4r=rcrrErnror]rpr=rqr5rrrsrtr)rur5r"rv)rCNrkNN)rlrmrErrcrr4r=ror]rpr=rqr5rrrsr"rv)rErr4r=r"rm)rCNrkNNFN)rrmrrmr4r5ror]rpr=rqr5rrrsrr)rTr])NFN)NrF)rr)rrN) rFrmr4r=ror]rqr5r"rv)r9rNN) rFrmr4r=rcr ror]rqr5r"rvr)rrr"r)rr r"r r)rFrmror]rrr"r)rFrmrr)rrr)rer)r"r5)rr)rrrrr"r)>__doc__ __future__r functoolsrrtypingrrrnumpyr% pandas._libsrr pandas._typingr r r r pandas.compat._optionalrpandas.core.dtypes.castrpandas.core.dtypes.commonrrrpandas.core.dtypes.missingrrrpandasrr r3rBrVrWr[rjrzrxrrrrrrrrwrrrrrrrrrrrrrrrs       .  ' : S e F + + O2 H       A