U +if@s*dZddlmZddlZddlmZddlmZmZm Z m Z m Z m Z m Z ddlmZddlZddlmZmZmZmZddlmZmZmZmZmZmZmZdd l m!Z!dd l"m#Z#dd l$m%Z%m&Z&m'Z'dd l(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:dd l;mZ>m?Z?ddl@mAZAmBZBmCZCmDZDmEZEmFZFmGZGddlHmIZImJZJddlKmLZLddlMmNZOmPZPmQZQddlRmSZSerddlmTZTmUZUddlVmWZWmXZXmYZYmZZZddl[m\Z\m]Z]m^Z^dddddZ_ddddddd Z`dd!d"d#Zaejbejcejdejeejfejgejhejiejjejkejlejmejnejod$Zpdd%d&d'Zqdddd(d)Zrdd%d*d+Zsdd,dd-d.Ztd/d0ZueuZvddd1d2d3d4Zwddd6d7d8d9d:d;d<Zxe!ed=ed>ed?d@ddBd7d7dCdDdEdFZyddBdBdBdBdHdIdJdKZzdBdLdMdNZ{dddPd1dQdRdSZ|dddBddTdUdVZ}ddd6d,d,dBdBdYdZd[d\Z~ddd]d]dd^d_d`ZGdadbdbZGdcddddeZGdedfdfeZddgd6dBdhdidjZdddldmdndodpdqdrZdsdtdudvdwdxhZdd6d6dydzd{Zdd6dBdBd|d}d~dZdd!ddZdddddZddddddZdS)zl Generic data algorithms. This module is experimental at the moment and not intended for public consumption ) annotationsN)dedent) TYPE_CHECKINGHashableLiteralSequenceUnioncastfinal)warn)algos hashtableiNaTlib) AnyArrayLike ArrayLikeDtypeObj IndexLabelScalar TakeIndexernpt)doc)find_stack_level)'construct_1d_object_array_from_listlikeinfer_dtype_from_arraysanitize_to_nanoseconds)ensure_float64 ensure_objectensure_platform_int is_array_like is_bool_dtypeis_categorical_dtypeis_complex_dtypeis_datetime64_dtypeis_extension_array_dtypeis_float_dtype is_integeris_integer_dtype is_list_likeis_numeric_dtypeis_object_dtype is_scalaris_timedelta64_dtypeneeds_i8_conversion) concat_compat)ExtensionDtype PandasDtype)ABCDatetimeArrayABCExtensionArrayABCIndex ABCMultiIndex ABCRangeIndex ABCSeriesABCTimedeltaArray)isnana_value_for_dtype)take_nd)arrayensure_wrapped_if_datetimelike extract_array)validate_indices) NumpySorterNumpyValueArrayLike) Categorical DataFrameIndexSeries) DatetimeArrayExtensionArrayTimedeltaArrayrz np.ndarray)valuesreturnc CsLt|tst|dd}t|jr.tt|St|jrt|tj rTt| dSzt|j dddWSt t fk rt|YSXnt|jrt|St|jr|jjdkrt|St|St|jr|St|jrt|tj rt|}| d}ttj |}|St|jr6td|}|j}|Stj|td }t|S) a routine to ensure that our data is of the correct input dtype for lower-level routines This will coerce: - ints -> int64 - uint -> uint64 - bool -> uint8 - datetimelike -> i8 - datetime64tz -> i8 (in local tz) - categorical -> codes Parameters ---------- values : np.ndarray or ExtensionArray Returns ------- np.ndarray T extract_numpyuint8Fcopy) i8rAdtype) isinstancer4r=r*rTrnpasarrayr ndarrayviewastype TypeError ValueErrorr'r%itemsizerr"r-rr r!codesobject)rHZnpvaluesr`I/home/mars/bis/venv/lib/python3.8/site-packages/pandas/core/algorithms.py _ensure_datass>                rbrr)rHrToriginalrIcCst|tr|j|kr|St|tjsT|}t||rD|j|krD|S|j||d}nlt|r|j|dd}t|tr|jt dd}n<|dk rt |rtd}nt |rtd}|j|dd}|S)z reverse of _ensure_data Parameters ---------- values : np.ndarray or ExtensionArray dtype : np.dtype or ExtensionDtype original : AnyArrayLike Returns ------- ExtensionArray or np.ndarray rSFrMNzdatetime64[ns]timedelta64[ns]) rUr2rTrVZconstruct_array_typeZ_from_sequencer rZr3r_r#r,)rHrTrcclsr`r`ra_reconstruct_datas$    rf)rIcCsHt|sDtj|dd}|dkr:t|tr0t|}t|}n t|}|S)z5 ensure that we are arraylike if not already FZskipna)mixedstring mixed-integer) rr infer_dtyperUtuplelistrrVrW)rHinferredr`r`ra_ensure_arraylikes   ro)Z complex128Z complex64float64float32Zuint64Zuint32Zuint16rLint64int32int16int8rir_)rHcCs t|}t|}t|}||fS)z Parameters ---------- values : np.ndarray Returns ------- htable : HashTable subclass values : ndarray )rb_check_object_for_strings _hashtablesrHndtypehtabler`r`ra_get_hashtable_algos r{cCs2t|}|jjdkr.|jjd}|j|dd}|S)N)iuf8FrM)rbrTkindrZ)rHrTr`r`ra_get_values_for_rank!s   rcCs(t|}t|}t|td}||fS)Nr_)rrvrwgetrxr`r`ra_get_data_algo+srstrcCs*|jj}|dkr&tj|dddkr&d}|S)z Check if we can use string hashtable instead of object hashtable. Parameters ---------- values : ndarray Returns ------- str r_Frg)riri)rTnamerrk)rHryr`r`rarv4s rvcCsRt|}t|jr|S|}t|\}}|t|}||}t||j|}|S)a Return unique values based on a hash table. Uniques are returned in order of appearance. This does NOT sort. Significantly faster than numpy.unique for long enough sequences. Includes NA values. Parameters ---------- values : 1d array-like Returns ------- numpy.ndarray or ExtensionArray The return can be: * Index : when the input is an Index * Categorical : when the input is a Categorical dtype * ndarray : when the input is a Series/ndarray Return numpy.ndarray or ExtensionArray. See Also -------- Index.unique : Return unique values from an Index. Series.unique : Return unique values of Series object. Examples -------- >>> pd.unique(pd.Series([2, 1, 3, 3])) array([2, 1, 3]) >>> pd.unique(pd.Series([2] + [1] * 5)) array([2, 1]) >>> pd.unique(pd.Series([pd.Timestamp("20160101"), pd.Timestamp("20160101")])) array(['2016-01-01T00:00:00.000000000'], dtype='datetime64[ns]') >>> pd.unique( ... pd.Series( ... [ ... pd.Timestamp("20160101", tz="US/Eastern"), ... pd.Timestamp("20160101", tz="US/Eastern"), ... ] ... ) ... ) ['2016-01-01 00:00:00-05:00'] Length: 1, dtype: datetime64[ns, US/Eastern] >>> pd.unique( ... pd.Index( ... [ ... pd.Timestamp("20160101", tz="US/Eastern"), ... pd.Timestamp("20160101", tz="US/Eastern"), ... ] ... ) ... ) DatetimeIndex(['2016-01-01 00:00:00-05:00'], dtype='datetime64[ns, US/Eastern]', freq=None) >>> pd.unique(list("baabc")) array(['b', 'a', 'c'], dtype=object) An unordered Categorical will return categories in the order of appearance. >>> pd.unique(pd.Series(pd.Categorical(list("baabc")))) ['b', 'a', 'c'] Categories (3, object): ['a', 'b', 'c'] >>> pd.unique(pd.Series(pd.Categorical(list("baabc"), categories=list("abc")))) ['b', 'a', 'c'] Categories (3, object): ['a', 'b', 'c'] An ordered Categorical preserves the category ordering. >>> pd.unique( ... pd.Series( ... pd.Categorical(list("baabc"), categories=list("abc"), ordered=True) ... ) ... ) ['b', 'a', 'c'] Categories (3, object): ['a' < 'b' < 'c'] An array of tuples >>> pd.unique([("a", "b"), ("b", "a"), ("a", "c"), ("b", "a")]) array([('a', 'b'), ('b', 'a'), ('a', 'c')], dtype=object) )ror$rTuniquer{lenrf)rHrcrztableuniquesr`r`rarPs^    rznpt.NDArray[np.bool_])compsrHrIcCst|stdt|jdt|s.fFrM)"r(r[type__name__rUr3r6r2rVrXrormr4r;r=isinr-rTpd_arrayr*ZzerosshapeboolrZr_r/rWrr8anyrZfind_common_typerzZismember)rrHr~commonr`r`rarsD       & rintz int | Noneznp.ndarray | Nonez'tuple[npt.NDArray[np.intp], np.ndarray])rH na_sentinel size_hintmaskrIc CsBt|\}}||pt|}|j||||d\}}t|}||fS)a[ Factorize a numpy array to codes and uniques. This doesn't do any coercion of types or unboxing before factorization. Parameters ---------- values : ndarray na_sentinel : int, default -1 size_hint : int, optional Passed through to the hashtable's 'get_labels' method na_value : object, optional A value in `values` to consider missing. Note: only use this parameter when you know that you don't have any values pandas would consider missing in the array (NaN for float data, iNaT for datetimes, etc.). mask : ndarray[bool], optional If not None, the mask is used as indicator for missing values (True = missing, False = valid) instead of `na_value` or condition "val != val". Returns ------- codes : ndarray[np.intp] uniques : ndarray )rna_valuer)rr factorizer) rHrrrr hash_klassrrr^r`r`rafactorize_array s!  rz values : sequence A 1-D sequence. Sequences that aren't pandas objects are coerced to ndarrays before factorization. zt sort : bool, default False Sort `uniques` and shuffle `codes` to maintain the relationship. zG size_hint : int, optional Hint to the hashtable sizer. )rHsortrFrz%tuple[np.ndarray, np.ndarray | Index])rrrrIc Cst|tr|j|dSt|}|}t|ts8t|dd}d}|dkrLd}d}t|ttfr|jdk r|j|d\}}t|t r|j |dd}nt|t rdd l m }||}||fSt|jtjs|j|d \}}|j} n8|j} t|}|jjd krt} nd} t|||| d \}}|r` for more examples. Examples -------- These examples all show factorize as a top-level method like ``pd.factorize(values)``. The results are identical for methods like :meth:`Series.factorize`. >>> codes, uniques = pd.factorize(['b', 'b', 'a', 'c', 'b']) >>> codes array([0, 0, 1, 2, 0]...) >>> uniques array(['b', 'a', 'c'], dtype=object) With ``sort=True``, the `uniques` will be sorted, and `codes` will be shuffled so that the relationship is the maintained. >>> codes, uniques = pd.factorize(['b', 'b', 'a', 'c', 'b'], sort=True) >>> codes array([1, 1, 0, 2, 1]...) >>> uniques array(['a', 'b', 'c'], dtype=object) Missing values are indicated in `codes` with `na_sentinel` (``-1`` by default). Note that missing values are never included in `uniques`. >>> codes, uniques = pd.factorize(['b', None, 'a', 'c', 'b']) >>> codes array([ 0, -1, 1, 2, 0]...) >>> uniques array(['b', 'a', 'c'], dtype=object) Thus far, we've only factorized lists (which are internally coerced to NumPy arrays). When factorizing pandas objects, the type of `uniques` will differ. For Categoricals, a `Categorical` is returned. >>> cat = pd.Categorical(['a', 'a', 'c'], categories=['a', 'b', 'c']) >>> codes, uniques = pd.factorize(cat) >>> codes array([0, 0, 1]...) >>> uniques ['a', 'c'] Categories (3, object): ['a', 'b', 'c'] Notice that ``'b'`` is in ``uniques.categories``, despite not being present in ``cat.values``. For all other pandas objects, an Index of the appropriate type is returned. >>> cat = pd.Series(['a', 'a', 'c']) >>> codes, uniques = pd.factorize(cat) >>> codes array([0, 0, 1]...) >>> uniques Index(['a', 'c'], dtype='object') If NaN is in the values, and we want to include NaN in the uniques of the values, it can be achieved by setting ``na_sentinel=None``. >>> values = np.array([1, 2, 1, np.nan]) >>> codes, uniques = pd.factorize(values) # default: na_sentinel=-1 >>> codes array([ 0, 1, 0, -1]) >>> uniques array([1., 2.]) >>> codes, uniques = pd.factorize(values, na_sentinel=None) >>> codes array([0, 1, 0, 2]) >>> uniques array([ 1., 2., nan]) )rTrJNrF)rr)rC)r)mM)rrr)r assume_uniqueverify)compatz$Union[DatetimeArray, TimedeltaArray]rS) rUr5rror4r=r1r7freqr3Z _shallow_copyr6pandasrCrTrVrbrrrr safe_sortrr9appendwhererfrXr _datarZ _simple_new) rHrrrrcdropnar^rrCrTrZ code_is_nar`r`rar8s|               rTrD)r ascending normalizerrIc CsBddlm}t|dd}|dk rddlm}||}z|||dd} Wn,tk rr} ztd| W5d} ~ XYnX| j|d } | | j} | j d | _| } |r| j dk r| j dd} tt| g} nDt|r||j j|d } || _| j } nt||\} } || | |d } |r,| j|d } |r>| | } | S) aK Compute a histogram of the counts of non-null values. Parameters ---------- values : ndarray (1-d) sort : bool, default True Sort by values ascending : bool, default False Sort in ascending order normalize: bool, default False If True then compute a relative histogram bins : integer, optional Rather than count values, group them into half-open bins, convenience for pd.cut, only works with numeric data dropna : bool, default True Don't include counts of NaN Returns ------- Series r)rDrN)cutT)Zinclude_lowestz+bins argument only works with numeric data.rintervalindexrr)Zpandas.core.seriesrDgetattrZpandas.core.reshape.tilerr[ value_countsrZnotnarZZ sort_index_valuesallilocrVr;rr$rvalue_counts_arraylike sort_valuessum)rHrrrZbinsrrDrriierrresultcountskeysr`r`rar#s6      rrcCsbt|}|}t|}t||\}}t|jrL|rL|tk}||||}}t||j|}||fS)z Parameters ---------- values : arraylike dropna : bool Returns ------- uniques : np.ndarray or ExtensionArray counts : np.ndarray )rorbrzZ value_countr-rTrrf)rHrrcrrZmskZres_keysr`r`rarss  rfirstz!Literal[('first', 'last', False)])rHkeeprIcCst|}tj||dS)a Return boolean ndarray denoting duplicate values. Parameters ---------- values : nd.array, ExtensionArray or Series Array over which to check for duplicate values. keep : {'first', 'last', False}, default 'first' - ``first`` : Mark duplicates as ``True`` except for the first occurrence. - ``last`` : Mark duplicates as ``True`` except for the last occurrence. - False : Mark all duplicates as ``True``. Returns ------- duplicated : ndarray[bool] r)rbrz duplicated)rHrr`r`rarsr)rHrrIc Cst|}|}t|jr*t|}|j|dSt|}tj||d}zt |}Wn0t k r~}zt d|W5d}~XYnXt ||j|}|S)a Returns the mode(s) of an array. Parameters ---------- values : array-like Array over which to check for duplicate values. dropna : bool, default True Don't consider counts of NaN/NaT. Returns ------- np.ndarray or ExtensionArray rzUnable to sort modes: N) ror-rTr<_moderbrzmoderVrr[r rf)rHrrcZnpresultrrr`r`rars   raveragerznpt.NDArray[np.float64])rHaxismethod na_optionrpctrIc Csdt|j}t|}|jdkr4tj||||||d}n,|jdkrXtj|||||||d}ntd|S)a Rank the values along a given axis. Parameters ---------- values : np.ndarray or ExtensionArray Array whose values will be ranked. The number of dimensions in this array must not exceed 2. axis : int, default 0 Axis over which to perform rankings. method : {'average', 'min', 'max', 'first', 'dense'}, default 'average' The method by which tiebreaks are broken during the ranking. na_option : {'keep', 'top'}, default 'keep' The method by which NaNs are placed in the ranking. - ``keep``: rank each NaN value with a NaN ranking - ``top``: replace each NaN with either +/- inf so that they there are ranked at the top ascending : bool, default True Whether or not the elements should be ranked in ascending order. pct : bool, default False Whether or not to the display the returned rankings in integer form (e.g. 1, 2, 3) or in percentile form (e.g. 0.333..., 0.666..., 1). r)is_datetimelike ties_methodrrrrO)rrrrrrz&Array with ndim > 2 are not supported.)r-rTrndimr Zrank_1dZrank_2dr[)rHrrrrrrZranksr`r`raranks.    rznpt.NDArray[np.bool_] | None)arrarr_maskb_maskrIc Cs:t||j}|dk r&t||j}nd}|dk rJ|dk rJt||B}nB|dk r^t|}n.|dk rrt|}ntj|jtd}|dtj}t }|dk} |dk} | s|||k|@ } n`| s|||k|@ } nB||| || k|| @ p"||| || k|| @ } | r2t d||S)a Perform array addition that checks for underflow and overflow. Performs the addition of an int64 array and an int64 integer (or array) but checks that they do not result in overflow first. For elements that are indicated to be NaN, whether or not there is overflow for that element is automatically ignored. Parameters ---------- arr : array addend. b : array or scalar addend. arr_mask : np.ndarray[bool] or None, default None array indicating which elements to exclude from checking b_mask : np.ndarray[bool] or None, default None array or scalar indicating which element(s) to exclude from checking Returns ------- sum : An array for elements x + b for each element x in arr if b is a scalar or an array for elements x + y for each element pair (x, y) in (arr, b). Raises ------ OverflowError if any x + y exceeds the maximum or minimum int64 value. NrSTrzOverflow in int64 addition) rVZ broadcast_torZ logical_notemptyrfillri8maxrr OverflowError) rbrrb2Zb2_maskZnot_nanrZi8minZmask1Zmask2Zto_raiser`r`rachecked_add_with_arrs4#   "rc@s\eZdZdddddZddddd Zed d Zed d ZeedddddZ dS)SelectNrrnrcCs(||_||_||_|jdkr$tddS)N)rlastrz,keep must be either "first", "last" or "all")objrrr\)selfrrrr`r`ra__init__ds  zSelectN.__init__zDataFrame | SeriesrrIcCstdSr)NotImplementedError)rrr`r`racomputelszSelectN.computecCs |dS)Nnlargestrrr`r`raroszSelectN.nlargestcCs |dS)N nsmallestrrr`r`rarsszSelectN.nsmallestrr)rTrIcCst|rt| pt|S)zg Helper function to determine if dtype is valid for nsmallest/nlargest methods )r)r"r-rSr`r`rais_valid_dtype_n_methodwszSelectN.is_valid_dtype_n_methodN) r __module__ __qualname__rrr rr staticmethodrr`r`r`rarcs  rc@s eZdZdZdddddZdS) SelectNSeriesz Implement n largest/smallest for Series Parameters ---------- obj : Series n : int keep : {'first', 'last'}, default 'first' Returns ------- nordered : Series rrDrcCsddlm}|j}|jj}||s8td|d||dkrJ|jgS|j}|j|j }t |jrddl m }|j }t||rt||j|j |jd} t|| |j|jd|} | |jS|t|jkr|dk} |jj| d |S|j} t|j}|d kr:| }t| r&|d 8}nt| r:d | }|jd krT|ddd }|} t|j}t|}t||}t|jdd|d }t !||k\}|||j"dd}|jdkr|d|}| }|jd kr|d |}||j#||gj#d|S)Nr)concatzCannot use method 'z ' with dtype )BaseMaskedArrayrrrrrrrrC)order mergesort)rr)$Zpandas.core.reshape.concatrrrrTrr[rdroprr$pandas.core.arraysrrrUrrrrrrZrrheadrbrHr'r minr Z kth_smallestrNrVZnonzeroargsortr)rrrrrTZdroppedZ nan_indexrrZserrrZ new_dtypeZnbaseZfindexZnarrZkth_valnsZindsr`r`rarsT                     zSelectNSeries.computeN)rrr__doc__rr`r`r`rarsrcs<eZdZdZdddddfdd Zddd d d ZZS) SelectNFramez Implement n largest/smallest for DataFrame Parameters ---------- obj : DataFrame n : int keep : {'first', 'last'}, default 'first' columns : list or str Returns ------- nordered : DataFrame rBrrr)rrrcolumnscsHt|||t|r"t|tr(|g}ttt|}t|}||_ dSr) superrr(rUrlr rrrmr)rrrrr __class__r`rars zSelectNFrame.__init__rc s~ddlm}|j}|j}|j}|D]<}||j}||s"tdt|d|dtdq"fdd}|j } |j d d } }|} |g} t |D]\} }| |}t |d | k}t || |r|jnd d }|st || kr|| |j } q>|||j dk}||}||}|| |j } | j|j } |t | } q|| }| | |_ t |d krf|Sdk}|j||ddS)Nr) Int64IndexzColumn z has dtype z, cannot use method z with this dtypecs dkr||S||SdS)z{ Helper function to concat `current_indexer` and `other_indexer` depending on `method` rN)r)Zcurrent_indexerZ other_indexerrr`ra get_indexers z)SelectNFrame.compute..get_indexerT)rrrrrrr)rr)Zpandas.core.apirrrrrTrr[reprrZ reset_index enumeraterrrloctaker)rrrrframercolumnrTrZoriginal_indexZ cur_frameZcur_nindexerr|ZseriesZis_last_columnrHZ border_valueZ unsafe_valuesZ safe_valuesrr`rrarsJ           zSelectNFrame.compute)rrrrrr __classcell__r`r`rrars rr)indicesr allow_fillcCs\t|st|}tj|tjd}|rJt||j|t|||d|d}n|j||d}|S)a Take elements from an array. Parameters ---------- arr : array-like or scalar value Non array-likes (sequences/scalars without a dtype) are coerced to an ndarray. indices : sequence of int or one-dimensional np.ndarray of int Indices to be taken. axis : int, default 0 The axis over which to select values. allow_fill : bool, default False How to handle negative values in `indices`. * False: negative values in `indices` indicate positional indices from the right (the default). This is similar to :func:`numpy.take`. * True: negative values in `indices` indicate missing values. These values are set to `fill_value`. Any other negative values raise a ``ValueError``. fill_value : any, optional Fill value to use for NA-indices when `allow_fill` is True. This may be ``None``, in which case the default NA value for the type (``self.dtype.na_value``) is used. For multi-dimensional `arr`, each *element* is filled with `fill_value`. Returns ------- ndarray or ExtensionArray Same type as the input. Raises ------ IndexError When `indices` is out of bounds for the array. ValueError When the indexer contains negative values other than ``-1`` and `allow_fill` is True. Notes ----- When `allow_fill` is False, `indices` may be whatever dimensionality is accepted by NumPy for `arr`. When `allow_fill` is True, `indices` should be 1-D. See Also -------- numpy.take : Take elements from an array along an axis. Examples -------- >>> from pandas.api.extensions import take With the default ``allow_fill=False``, negative numbers indicate positional indices from the right. >>> take(np.array([10, 20, 30]), [0, 0, -1]) array([10, 10, 30]) Setting ``allow_fill=True`` will place `fill_value` in those positions. >>> take(np.array([10, 20, 30]), [0, 0, -1], allow_fill=True) array([10., 10., nan]) >>> take(np.array([10, 20, 30]), [0, 0, -1], allow_fill=True, ... fill_value=-10) array([ 10, 10, -10]) rST)rr fill_value)r)rrVrWZintpr>rr:r )rrrrrrr`r`rar HsP r leftz$NumpyValueArrayLike | ExtensionArrayzLiteral[('left', 'right')]r?znpt.NDArray[np.intp] | np.intp)rvaluesidesorterrIcCs|dk rt|}t|tjrt|jrt|s6t|rt|jj}t |rXt |gnt |}||j k r||j k r|j}n|j}t |rtt||}qttt||d}nt|}|j|||dS)a Find indices where elements should be inserted to maintain order. .. versionadded:: 0.25.0 Find the indices into a sorted array `arr` (a) such that, if the corresponding elements in `value` were inserted before the indices, the order of `arr` would be preserved. Assuming that `arr` is sorted: ====== ================================ `side` returned index `i` satisfies ====== ================================ left ``arr[i-1] < value <= self[i]`` right ``arr[i-1] <= value < self[i]`` ====== ================================ Parameters ---------- arr: np.ndarray, ExtensionArray, Series Input array. If `sorter` is None, then it must be sorted in ascending order, otherwise `sorter` must be an array of indices that sort it. value : array-like or scalar Values to insert into `arr`. side : {'left', 'right'}, optional If 'left', the index of the first suitable location found is given. If 'right', return the last such index. If there is no suitable index, return either 0 or N (where N is the length of `self`). sorter : 1-D array-like, optional Optional array of integer indices that sort array a into ascending order. They are typically the result of argsort. Returns ------- array of ints or int If value is array-like, array of insertion points. If value is scalar, a single integer. See Also -------- numpy.searchsorted : Similar method from NumPy. NrS)rr)rrUrVrXr'rTr&iinforr+r;rrmaxr rrrr< searchsorted)rrrrrZ value_arrrTr`r`rars(2  rrprqrrrsrtru)rrcCs`t|}tj}|j}t|}|r(tj}ntj}t|t rF| }|j}t|tjst |d|j dr|dkrt dt|j d|||||Stdttdt|}|j}d}t|jrtj}|d}t}d }n2|rtj}n&t|r|jjd kr tj}ntj}|j}|d kr.|d d }t|}tj|j |d } t!dgd} |dkrjt!d|nt!|d| |<|| t"| <|jjt#krt$j%|| |||dnt!dgd} |dkrt!|dnt!d|| |<t"| } t!dgd} |dkrt!d| n t!| d| |<t"| }||| ||| | <|rB| d} |d kr\| dddf} | S)aQ difference of n between self, analogous to s-s.shift(n) Parameters ---------- arr : ndarray or ExtensionArray n : int number of periods axis : {0, 1} axis to shift on stacklevel : int, default 3 The stacklevel for the lost dtype warning. Returns ------- shifted __rz cannot diff z on axis=zwdtype lost in 'diff()'. In the future this will raise a TypeError. Convert to a suitable dtype prior to calling 'diff'.) stacklevelFrRT)rurtrrrSNrO)Z datetimelikerd)&rrVnanrTr operatorxorsubrUr0Zto_numpyhasattrrr\rshiftr FutureWarningrrWr-rrrYrZobject_r'rrqrprZreshaperrslicerl _diff_specialr Zdiff_2d)rrrnarTZis_boolopZ is_timedeltaZ orig_ndimZout_arrZ na_indexerZ _res_indexerZ res_indexerZ _lag_indexerZ lag_indexerr`r`radiff sp         " "&  r&z*np.ndarray | tuple[np.ndarray, np.ndarray])rrrrIcCst|stdt|tjtfs:t|\}}tj||d}d}t|sbt j |dddkrbt |}nRz| }| |}Wn:tk r|jrt|dtrt|}nt |}YnX|dkr|St|stdtt|}|stt|t|kstd |dkr8t|\} }| t|} | |t| |}|d kr| } t| |d d } |rz|t| k|t|kB} nd} ndtjt|tjd}||tt||j |d d } ||k} |r| |t| kB|t|kB} | dk rt| | ||t| fS)a Sort ``values`` and reorder corresponding ``codes``. ``values`` should be unique if ``codes`` is not None. Safe for use with mixed types (int, str), orders ints before strs. Parameters ---------- values : list-like Sequence; must be unique if ``codes`` is not None. codes : list_like, optional Indices to ``values``. All out of bound indices are treated as "not found" and will be masked with ``na_sentinel``. na_sentinel : int, default -1 Value in ``codes`` to mark "not found". Ignored when ``codes`` is None. assume_unique : bool, default False When True, ``values`` are assumed to be unique, which can speed up the calculation. Ignored when ``codes`` is None. verify : bool, default True Check if codes are out of bound for the values and put out of bound codes equal to na_sentinel. If ``verify=False``, it is assumed there are no out of bound codes. Ignored when ``codes`` is None. .. versionadded:: 0.25.0 Returns ------- ordered : ndarray Sorted ``values`` new_codes : ndarray Reordered ``codes``; returned when ``codes`` is not None. Raises ------ TypeError * If ``values`` is not list-like or if ``codes`` is neither None nor list-like * If ``values`` cannot be sorted ValueError * If ``codes`` is not None and ``values`` contain duplicates. zFOnly list-like objects are allowed to be passed to safe_sort as valuesrSNFrgrjrzMOnly list-like objects or None are allowed to be passed to safe_sort as codesz,values should be unique if codes is not Nonerrwrap)r)r(r[rUrVrXr2rrWr$rrk _sort_mixedrr sizerl _sort_tuplesrrrr\rZ map_locationslookupr:rint_putZarangeZputmask)rHr^rrrrT_rZorderedrtZorder2Z new_codesrZreverse_indexerr`r`rarsb1         rcCsNtjdd|Dtd}t||}t||}t|tj|tdgS)z3order ints before strings in 1d arrays, safe in py3cSsg|]}t|tqSr`)rUr).0xr`r`ra sz_sort_mixed..rS)rVr;rrZ concatenaterWr_)rHZstr_posnumsstrsr`r`rar)sr)cCs:ddlm}ddlm}||d\}}||dd}||S)a Convert array of tuples (1d) to array or array (2d). We need to keep the columns separately as they contain different types and nans (can't use `np.sort` as it may fail when str and nan are mixed in a column as types cannot be compared). r) to_arrays)lexsort_indexerNT)Zorders)Z"pandas.core.internals.constructionr6Zpandas.core.sortingr7)rHr6r7Zarraysr/r r`r`rar+ s    r+)lvalsrvalsrIcCsg}t|dd}t|dd}|j|dd\}}tt||g}t|}t|D],\}}||gtt|j||j|7}qN| |S)a Extracts the union from lvals and rvals with respect to duplicates and nans in both arrays. Parameters ---------- lvals: np.ndarray or ExtensionArray left values which is ordered in front. rvals: np.ndarray or ExtensionArray right values ordered after lvals. Returns ------- np.ndarray or ExtensionArray Containing the unsorted union of both arrays. Notes ----- Caller is responsible for ensuring lvals.dtype == rvals.dtype. Frrr') ralignrr.r<rrratr )r8r9r Zl_countZr_countZ unique_arrayr|rr`r`raunion_with_duplicatess  &r<)rNNN)FrN)TFFNT)r)T)rrrTF)NN)rFN)rN)r)NrFT)r __future__rrtextwraprtypingrrrrrr r warningsr numpyrVZ pandas._libsr r rzrrZpandas._typingrrrrrrrZpandas.util._decoratorsrZpandas.util._exceptionsrZpandas.core.dtypes.castrrrZpandas.core.dtypes.commonrrrrr r!r"r#r$r%r&r'r(r)r*r+r,r-Zpandas.core.dtypes.concatr.Zpandas.core.dtypes.dtypesr/r0Zpandas.core.dtypes.genericr1r2r3r4r5r6r7Zpandas.core.dtypes.missingr8r9Zpandas.core.array_algos.taker:Zpandas.core.constructionr;rr<r=Zpandas.core.indexersr>r?r@rrArBrCrDrrErFrGrbrfroZComplex128HashTableZComplex64HashTableZFloat64HashTableZFloat32HashTableZUInt64HashTableZUInt32HashTableZUInt16HashTableZUInt8HashTableZInt64HashTableZInt32HashTableZInt16HashTableZ Int8HashTableZStringHashTableZPyObjectHashTablerwr{rrrvrZunique1drrrrrrrrrrrrr rr#r&rr)r+r<r`r`r`ras  $ $  P $    N,  mN,XP'=[ UsiZv