+ xȇi Rt^RIHt^RIHtHt^RIHtHtH t H t ^RI t ^RI Ht^RIHtHtHt^RIHtHtHtHtHt^RIHt^R IHtHt^R IHt^R I H!t!H"t"H#t#H$t$H%t%H&t&^R I'H(t(H)t)H*t*H+t+H,t,H-t-H.t.H/t/H0t0H1t1^R I2H3t3H4t4^RI5H6t6^RI7H8t8^RI9H:t:^RI;HuH?t@^RIAHBtB^RICHDtDHEtEHFtF^RIGHHtHHItI^RIJHKtKHLtL^RIMHNtN^RIOHPtPHQtQ]'d^RIRHStS^RITHUtUHVtVHWtWHXtXRtYRtZRt[]L!RR.]rBrLs& rN_get_prev_labelrRvs E7DK 0E%)Y/00   E ud##z%'I'Ir~~a... % qy   ||EBFF7++?U OPPrPc&VP!R/VB#)zj This is called upon unpickling, rather than the default which doesn't have arguments and breaks __new__. ) from_arrays)clsds&&rN_new_IntervalIndexrXs ?? Q rP set_closed to_tuplesT)wrapis_non_overlapping_monotonicclosed)cachepandasca]tRt^t$RtRtR]R&R]R&R]R&R]R&R]R &R]R &R ]R &R ]R &Rt]t RVRRllt ] RWRRll4t ] RWRRll4t ] RWRRll4t]RRl4tRRltRRlt]RRl4tRt]R R!l4tRXR"R#llt]R$R%l4t]R&R'l4t]R(R)l4tR*R+ltR,tRYR-R.lltR/R0ltRZR1R2lltR3R4lt R5R6lt!R7R8lt"]R9R:l4t#R;t$R<V3R=llt%]R>R?l4t&R@RAlt'RBRClt(]RDREl4t)]RFRGl4t*]RHRIl4t+]RJRKl4t,RXRLRMllt-RNROlt.RPRQlt/RRRSlt0RTt1RUt2V;t3#)[ IntervalIndexa Immutable index of intervals that are closed on the same side. Parameters ---------- data : array-like (1-dimensional) Array-like (ndarray, :class:`DateTimeArray`, :class:`TimeDeltaArray`) containing Interval objects from which to build the IntervalIndex. closed : {'left', 'right', 'both', 'neither'}, default 'right' Whether the intervals are closed on the left-side, right-side, both or neither. dtype : dtype or None, default None If None, dtype will be inferred. copy : bool, default None Whether to copy input data, only relevant for array, Series, and Index inputs (for other input, e.g. a list, a new array is created anyway). Defaults to True for array input and False for Index/Series. Set to False to avoid copying array input at your own risk (if you know the input data won't be modified elsewhere). Set to True to force copying Series/Index input up front. name : object, optional Name to be stored in the index. verify_integrity : bool, default True Verify that the IntervalIndex is valid. Attributes ---------- left right closed mid length is_empty is_non_overlapping_monotonic is_overlapping values Methods ------- from_arrays from_tuples from_breaks contains overlaps set_closed to_tuples See Also -------- Index : The base pandas Index type. Interval : A bounded slice-like interval; the elements of an IntervalIndex. interval_range : Function to create a fixed frequency IntervalIndex. cut : Bin values into discrete Intervals. qcut : Bin values into equal-sized Intervals based on rank or sample quantiles. Notes ----- See the `user guide `__ for more. Examples -------- A new ``IntervalIndex`` is typically constructed using :func:`interval_range`: >>> pd.interval_range(start=0, end=5) IntervalIndex([(0, 1], (1, 2], (2, 3], (3, 4], (4, 5]], dtype='interval[int64, right]') It may also be constructed using one of the constructor methods: :meth:`IntervalIndex.from_arrays`, :meth:`IntervalIndex.from_breaks`, and :meth:`IntervalIndex.from_tuples`. See further examples in the doc strings of ``interval_range`` and the mentioned constructor methods. intervalindexr;r]boolr\ closed_left closed_right open_left open_rightr,_data_valuesFc 0V^8dQhRRRRRRRRR R R R /#) r]IntervalClosedType | Noner? Dtype | Nonecopyz bool | NonenameHashable | Noneverify_integrityrcreturnrrT)formats"rN __annotate__IntervalIndex.__annotate__sH,,*, ,  ,  ,, ,rPc  \WQV4pVPWV4wr\RVP4;_uu_4\ VVVVVR7pRRR4VP XV4# +'giL";i)r,)r]rnr?rqN)r0_maybe_copy_array_inputr__name__r, _simple_new)rVdatar]r?rnrorqarrays&&&&&&& rN__new__IntervalIndex.__new__sq"$c200UC   = =!!1 E>ud++> =s A** A: c ,V^8dQhRRRRRRRRR R /#) rkr]rlrorprnrcr?rmrrrarT)rss"rNrtrus>-1-1*-1 -1  -1  -1 -1rPc  \RVP4;_uu_4\P!WWER7pRRR4VP XVR7# +'giL#;i)a| Construct an IntervalIndex from an array of splits. Parameters ---------- breaks : array-like (1-dimensional) Left and right bounds for each interval. closed : {'left', 'right', 'both', 'neither'}, default 'right' Whether the intervals are closed on the left-side, right-side, both or neither. name : str, optional Name of the resulting IntervalIndex. copy : bool, default False Copy the data. dtype : dtype or None, default None If None, dtype will be inferred. Returns ------- IntervalIndex See Also -------- interval_range : Function to create a fixed frequency IntervalIndex. IntervalIndex.from_arrays : Construct from a left and right array. IntervalIndex.from_tuples : Construct from a sequence of tuples. Examples -------- >>> pd.IntervalIndex.from_breaks([0, 1, 2, 3]) IntervalIndex([(0, 1], (1, 2], (2, 3]], dtype='interval[int64, right]') r,r]rnr?Nro)rrxr, from_breaksry)rVbreaksr]rornr?r{s&&&&&& rNrIntervalIndex.from_breakssNT = =!--DE>u400 > = A A# c ,V^8dQhRRRRRRRRR R /# rkr]r;rorprnrcr?rmrrrarT)rss"rNrtruJsEA1A1# A1  A1  A1A1 A1rPc  \RVP4;_uu_4\P!WW5VR7pRRR4VP XVR7# +'giL#;i)a Construct from two arrays defining the left and right bounds. Parameters ---------- left : array-like (1-dimensional) Left bounds for each interval. right : array-like (1-dimensional) Right bounds for each interval. closed : {'left', 'right', 'both', 'neither'}, default 'right' Whether the intervals are closed on the left-side, right-side, both or neither. name : str, optional Name of the resulting IntervalIndex. copy : bool, default False Copy the data. dtype : dtype, optional If None, dtype will be inferred. Returns ------- IntervalIndex Raises ------ ValueError When a value is missing in only one of `left` or `right`. When a value in `left` is greater than the corresponding value in `right`. See Also -------- interval_range : Function to create a fixed frequency IntervalIndex. IntervalIndex.from_breaks : Construct an IntervalIndex from an array of splits. IntervalIndex.from_tuples : Construct an IntervalIndex from an array-like of tuples. Notes ----- Each element of `left` must be less than or equal to the `right` element at the same position. If an element is missing, it must be missing in both `left` and `right`. A TypeError is raised when using an unsupported type for `left` or `right`. At the moment, 'category', 'object', and 'string' subtypes are not supported. Examples -------- >>> pd.IntervalIndex.from_arrays([0, 1, 2], [1, 2, 3]) IntervalIndex([(0, 1], (1, 2], (2, 3]], dtype='interval[int64, right]') r,)rnr?Nr)rrxr,rUry)rVleftrightr]rornr?r{s&&&&&&& rNrUIntervalIndex.from_arraysIsP| = =!--VeE>u400 > =s A A$ c ,V^8dQhRRRRRRRRR R /#rrT)rss"rNrtrus>-/-/#-/ -/  -/  -/ -/rPc  \RVP4;_uu_4\P!WWER7pRRR4VP XVR7# +'giL#;i)a Construct an IntervalIndex from an array-like of tuples. Parameters ---------- data : array-like (1-dimensional) Array of tuples. closed : {'left', 'right', 'both', 'neither'}, default 'right' Whether the intervals are closed on the left-side, right-side, both or neither. name : str, optional Name of the resulting IntervalIndex. copy : bool, default False By-default copy the data, this is compat only and ignored. dtype : dtype or None, default None If None, dtype will be inferred. Returns ------- IntervalIndex See Also -------- interval_range : Function to create a fixed frequency IntervalIndex. IntervalIndex.from_arrays : Construct an IntervalIndex from a left and right array. IntervalIndex.from_breaks : Construct an IntervalIndex from an array of splits. Examples -------- >>> pd.IntervalIndex.from_tuples([(0, 1), (1, 2)]) IntervalIndex([(0, 1], (1, 2]], dtype='interval[int64, right]') r,rNr)rrxr, from_tuplesry)rVrzr]rornr?arrs&&&&&& rNrIntervalIndex.from_tuplessIX = =++DdXC>s..> =rcV^8dQhRR/#)rkrrr rT)rss"rNrtrus===rPc VPVP4p\V4pVPVP4p\V4p\ WVP R7#)r])_maybe_convert_i8rrrr r])selfrrs& rN_engineIntervalIndex._enginesQ%%dii0,T2&&tzz2-e4D <>> idx = pd.Index([1, 2, 3]) >>> idx.memory_usage() 24 )r)r memory_usager)rrs&&rNrIntervalIndex.memory_usages5Byy%%4%04::3J3JPT3J3UUUrPcV^8dQhRR/#rkrrrcrT)rss"rNrtru!s222rPc .VRRR1,P#)zh Return True if the IntervalIndex is monotonic decreasing (only equal or decreasing values), else False N)is_monotonic_increasingrs&rNis_monotonic_decreasing%IntervalIndex.is_monotonic_decreasing s DbDz111rPcV^8dQhRR/#rrT)rss"rNrtru)s4rPc VPpVPpVP4P4^8dR#VP'gVP'dR#\ 4p\ P!VPRR74^,pVF-pW,W%,3pWc9dR#VPV4K/ R#)zH Return True if the IntervalIndex contains unique elements, else False. FT)keep) rrisnasum is_uniquesetrGwhere duplicatedadd)rrr seen_pairs check_idxidxpairs& rNrIntervalIndex.is_unique(s yy  99;?? q  >>>U___U HHT__%_89!< CIuz*D! NN4  rPcV^8dQhRR/#rrT)rss"rNrtruAs/+/+/+rPc .VPP#)ap Return True if the IntervalIndex has overlapping intervals, else False. Two intervals overlap if they share a common point, including closed endpoints. Intervals that only have an open endpoint in common do not overlap. Returns ------- bool Boolean indicating if the IntervalIndex has overlapping intervals. See Also -------- Interval.overlaps : Check whether two Interval objects overlap. IntervalIndex.overlaps : Check an IntervalIndex elementwise for overlaps. Examples -------- >>> index = pd.IntervalIndex.from_tuples([(0, 2), (1, 3), (4, 5)]) >>> index IntervalIndex([(0, 2], (1, 3], (4, 5]], dtype='interval[int64, right]') >>> index.is_overlapping True Intervals that share closed endpoints overlap: >>> index = pd.interval_range(0, 3, closed="both") >>> index IntervalIndex([[0, 1], [1, 2], [2, 3]], dtype='interval[int64, both]') >>> index.is_overlapping True Intervals that only have an open endpoint in common do not overlap: >>> index = pd.interval_range(0, 3, closed="left") >>> index IntervalIndex([[0, 1), [1, 2), [2, 3)], dtype='interval[int64, left]') >>> index.is_overlapping False )ris_overlappingrs&rNrIntervalIndex.is_overlapping@s`||***rPcV^8dQhRR/#rrT)rss"rNrtrurs))4)rPc \VRR4p\V\4'g\V\4'dVP VP 4#\ \\\3p\W4#)a Check if a given key needs i8 conversion. Conversion is necessary for Timestamp, Timedelta, DatetimeIndex, and TimedeltaIndex keys. An Interval-like requires conversion if its endpoints are one of the aforementioned types. Assumes that any list-like data has already been cast to an Index. Parameters ---------- key : scalar or Index-like The key that should be checked for i8 conversion Returns ------- bool r?N) rCrEr'r _needs_i8_conversionrrrr1r6)rr key_dtypei8_typess&& rNr"IntervalIndex._needs_i8_conversionrsY$C$/ i / /:c83L3L,,SXX6 6y-H#((rPc \V4'd\V4p\V4pVPV4'gV#\ V4p\ VRR4p\ V\4'g\ V\4'diVPVP4pVPVP4pV'd\M\PpV!WEVPR7#V'd\V4wr7\ V\ 4'dVP"pM\ V\$4'dVP&pM\ V\(P*\(P,34'dVP/R4pMPVP0\3VP4RR7rsVP6'dVP9VP:(4pVP0P<pW8wd\?RV RV 24hV#) a Maybe convert a given key to its equivalent i8 value(s). Used as a preprocessing step prior to IntervalTree queries (self._engine), which expects numeric data. Parameters ---------- key : scalar or list-like The key that should maybe be converted to i8. Returns ------- scalar or list-like The original key if no conversion occurred, int if converted scalar, Index with an int64 dtype if converted list-like. r?Nri8Frnz)Cannot index an IntervalIndex of subtype z with values of dtype ) r r/rrr#rCrEr'r rrrrarUr]rrordinalr_valuerG datetime64rHviewr?r.asi8rr_isnansubtype ValueError) rrscalarrrr constructorkey_i8rs && rNrIntervalIndex._maybe_convert_i8s"   s#C/4C((--J3C$/ i / /:c83L3L))#((3D**3995E&,(-2K2KKt4;;? ?  7 < I#v&&FI..FR]]BNN$CDDT*!$ 5+Fv{{{ szzk2 **$$  ;G9E##,+/   rPcV^8dQhRR/#)rksidezLiteral['left', 'right']rT)rss"rNrtrus<<3K>> i1, i2 = pd.Interval(0, 1), pd.Interval(1, 2) >>> index = pd.IntervalIndex([i1, i2]) >>> index.get_loc(1) 0 You can also supply a point inside an interval. >>> index.get_loc(1.5) 1 If a label is in several intervals, you get the locations of all the relevant intervals. >>> i3 = pd.Interval(0, 2) >>> overlapping_index = pd.IntervalIndex([i1, i2, i3]) >>> overlapping_index.get_loc(0.5) array([ True, False, True]) Only exact matches will be returned if an interval is provided. >>> index.get_loc(pd.Interval(0, 1)) 0 Nu1)_check_indexing_errorrEr r]rrrr(r?rrdrrrerKrrargmaxr maybe_booleans_to_slicerrstopstartlenstep)rrmaskop_leftop_righterrmatchesrs&& rNrIntervalIndex.get_locsbf ""3' c8 $ ${{cjj(sm#II)djjCII.EFD "3 3 399;D!,,,b"G!...rBH -tyy#.#zz1JJ ((* a<3-  a<+DKKM: :))$))D/: c5 ! !chh&6 3t9chh7C  -sm, -s/*G G, G''G,c ,V^8dQhRRRRRRRRR R /#) rktargetr.methodz str | Nonelimitz int | None tolerancez Any | Nonerrnpt.NDArray[np.intp]rT)rss"rNrtru8s<,,,, ,  ,  ,rPc \V\4'ddVPP'd/VPP'dVP V4pMVP V4^,pM\VP4'gS\VP4'g8VPV4pVPPVP4pMVP V4^,#\V4#))rErarrr_get_indexer_unique_sides_get_indexer_pointwiser"r?r$rr get_indexervaluesr)rrrrrindexers&&&&& rN _get_indexerIntervalIndex._get_indexer8s fm , , yy"""tzz';';';88@55f=a@!&,,//?6<<3P3P++F3Fll..v}}=G..v6q9 9"7++rPc V^8dQhRRRR/#rkrr.rrz1tuple[npt.NDArray[np.intp], npt.NDArray[np.intp]]rT)rss"rNrtruUs$PJPJPJ :PJrPc \V4pVPV4'g,VPV4'gVPVRRR7#\ V\ 4'dvVP P'dIVPP'd-VPV4pVR8HP4^,pMVPV4#\VP4'gVPV4'gVPV4#VPV4pVPP!VP"4wr#\%V4\%V43#)a) Compute indexer and mask for new index given the current index. The indexer should be then used as an input to ndarray.take to align the current data to the new index. Parameters ---------- target : IntervalIndex or list of Intervals An iterable containing the values to be used for computing indexer. Returns ------- indexer : np.ndarray[np.intp] Integers from 0 to n - 1 indicating that the index at these positions matches the corresponding target values. Missing values in the target are marked by -1. missing : np.ndarray[np.intp] An indexer into the target of the values not found. These correspond to the -1 in the indexer array. See Also -------- Index.get_indexer : Computes indexer and mask for new index given the current index. Index.get_indexer_for : Returns an indexer even when non-unique. Examples -------- >>> index = pd.Index(["c", "b", "a", "b", "b"]) >>> index.get_indexer_non_unique(["b", "b"]) (array([1, 3, 4, 1, 3, 4]), array([], dtype=int64)) In the example below there are no matched values. >>> index = pd.Index(["c", "b", "a", "b", "b"]) >>> index.get_indexer_non_unique(["q", "r", "t"]) (array([-1, -1, -1]), array([0, 1, 2])) For this reason, the returned ``indexer`` contains only integers equal to -1. It demonstrates that there's no match between the index and the ``target`` values at these positions. The mask [0, 1, 2] in the return value shows that the first, second, and third elements are missing. Notice that the return value is a tuple contains two items. In the example below the first item is an array of locations in ``index``. The second item is a mask shows that the first and third elements are missing. >>> index = pd.Index(["c", "b", "a", "b", "b"]) >>> index.get_indexer_non_unique(["f", "b", "s"]) (array([-1, 1, 3, 4, -1]), array([0, 2])) NFr)r)r/_should_compare_should_partial_index_get_indexer_non_comparablerErarrrr nonzeror r"r?rrget_indexer_non_uniquerr)rrrmissings&& rNr$IntervalIndex.get_indexer_non_uniqueUs!nf%##F++D4N4Nv4V4V33FD3O O  . .yy"""tzz';';';88@"b=113A6226:: V\\ * *$2L2LV2T2T..v6 6 ++F3F#||BB6==Q G"7+-@-IIIrPc V^8dQhRRRR/#)rkrrarrr rT)rss"rNrtrus   BV rPc VPPVP4pVPPVP4p\P!W#8HVR4pV#)zJ _get_indexer specialized to the case where both of our sides are unique. r)rrrrGr)rr left_indexer right_indexerrs&& rNr 'IntervalIndex._get_indexer_unique_sidessNyy,,V[[9  ..v||< ((<8,KrPc V^8dQhRRRR/#rrT)rss"rNrtrus JJJ :JrPc ..r2\V4FwrEVPV4p\V\4'd:\P !VP VPVPRR7pMS\P!V4'd\P!V^R7pM\P!V4^,pVPV4K \P !V4p\#V4\#V43# \d,TPT4\P!R.4pLv\d,TPT4\P!R.4pLi;i)zF pointwise implementation for get_indexer and get_indexer_non_unique. intpr?)ndminr) enumeraterrErrGarangerrrr rr{rrappendr concatenater)rrrrirlocss&& rNr $IntervalIndex._get_indexer_pointwises r'FA &||C(dE**99TZZDIIVTD^^D))88D2D88D>!,D NN4 )(,..)"7+-@-III &q!xx~$ &q!xx~  &s0AD 5D D *D  3E3>E3)E32E3cV^8dQhRR/#rrT)rss"rNrtrusFF$FrPc fVP'*;'dVPP^8#)rk)rr _na_countrs&rN_index_as_uniqueIntervalIndex._index_as_uniques(&&&EE4<<+A+AA+EErPzKcannot handle overlapping indices; use IntervalIndex.get_indexer_non_uniquec V^8dQhRRRR/#)rkrrkindzLiteral['loc', 'getitem']rT)rss"rNrtrus 9 9% 97P 9rPc <VPeIVP^8Xg8RpVR8Xd \V4hVR8Xd\V4'g \V4h\SV`W4#)NzClabel-based slicing with step!=1 is not supported for IntervalIndexlocgetitem)rrr-super_convert_slice_indexer)rrr4msg __class__s&&& rNr9$IntervalIndex._convert_slice_indexers] CHHMXCu} o%y 055$S/)w-c88rPcV^8dQhRR/#rrT)rss"rNrtrus///rPc HVPPPR9#)r@)r?rr4rs&rN_should_fallback_to_positional,IntervalIndex._should_fallback_to_positionals zz!!&&$..rPcV^8dQhRR/#)rkrrrT)rss"rNrtrusHH3HrPc 6\W4PW4#N)rC_maybe_cast_slice_bound)rrMrs&&&rNrD%IntervalIndex._maybe_cast_slice_boundst"::5GGrPc V^8dQhRRRR/#)rkr?r:rrrcrT)rss"rNrtrus33(3t3rPc \V\4'gR#\VPV.4p\ V4'*#F)rEr'rr?r")rr?common_subtypes&& rN_is_comparable_dtype"IntervalIndex._is_comparable_dtypes3%//)4::u*=>">222rPcV^8dQhRR/#rkrrr.rT)rss"rNrtrus"2"2e"2rPc D\VPPRR7#)au Return left bounds of the intervals in the IntervalIndex. The left bounds of each interval in the IntervalIndex are returned as an Index. The datatype of the left bounds is the same as the datatype of the endpoints of the intervals. Returns ------- Index An Index containing the left bounds of the intervals. See Also -------- IntervalIndex.right : Return the right bounds of the intervals in the IntervalIndex. IntervalIndex.mid : Return the mid-point of the intervals in the IntervalIndex. IntervalIndex.length : Return the length of the intervals in the IntervalIndex. Examples -------- >>> iv_idx = pd.IntervalIndex.from_arrays([1, 2, 3], [4, 5, 6], closed="right") >>> iv_idx.left Index([1, 2, 3], dtype='int64') >>> iv_idx = pd.IntervalIndex.from_tuples( ... [(1, 4), (2, 5), (3, 6)], closed="left" ... ) >>> iv_idx.left Index([1, 2, 3], dtype='int64') Fr)r.rhrrs&rNrIntervalIndex.leftsFTZZ__511rPcV^8dQhRR/#rMrT)rss"rNrtru"s"3"3u"3rPc D\VPPRR7#)ay Return right bounds of the intervals in the IntervalIndex. The right bounds of each interval in the IntervalIndex are returned as an Index. The datatype of the right bounds is the same as the datatype of the endpoints of the intervals. Returns ------- Index An Index containing the right bounds of the intervals. See Also -------- IntervalIndex.left : Return the left bounds of the intervals in the IntervalIndex. IntervalIndex.mid : Return the mid-point of the intervals in the IntervalIndex. IntervalIndex.length : Return the length of the intervals in the IntervalIndex. Examples -------- >>> iv_idx = pd.IntervalIndex.from_arrays([1, 2, 3], [4, 5, 6], closed="right") >>> iv_idx.right Index([4, 5, 6], dtype='int64') >>> iv_idx = pd.IntervalIndex.from_tuples( ... [(1, 4), (2, 5), (3, 6)], closed="left" ... ) >>> iv_idx.right Index([4, 5, 6], dtype='int64') Fr)r.rhrrs&rNrIntervalIndex.right!sFTZZ%%E22rPcV^8dQhRR/#rMrT)rss"rNrtruGs&1&1U&1rPc D\VPPRR7#)au Return the midpoint of each interval in the IntervalIndex as an Index. Each midpoint is calculated as the average of the left and right bounds of each interval. The midpoints are returned as a pandas Index object. Returns ------- pandas.Index An Index containing the midpoints of each interval. See Also -------- IntervalIndex.left : Return the left bounds of the intervals in the IntervalIndex. IntervalIndex.right : Return the right bounds of the intervals in the IntervalIndex. IntervalIndex.length : Return the length of the intervals in the IntervalIndex. Notes ----- The midpoint is the average of the interval bounds, potentially resulting in a floating-point number even if bounds are integers. The returned Index will have a dtype that accurately holds the midpoints. This computation is the same regardless of whether intervals are open or closed. Examples -------- >>> iv_idx = pd.IntervalIndex.from_arrays([1, 2, 3], [4, 5, 6]) >>> iv_idx.mid Index([2.5, 3.5, 4.5], dtype='float64') >>> iv_idx = pd.IntervalIndex.from_tuples([(1, 4), (2, 5), (3, 6)]) >>> iv_idx.mid Index([2.5, 3.5, 4.5], dtype='float64') Fr)r.rhmidrs&rNrUIntervalIndex.midFsNTZZ^^%00rPcV^8dQhRR/#rMrT)rss"rNrtrups444rPc D\VPPRR7#)a Calculate the length of each interval in the IntervalIndex. This method returns a new Index containing the lengths of each interval in the IntervalIndex. The length of an interval is defined as the difference between its end and its start. Returns ------- Index An Index containing the lengths of each interval. See Also -------- Interval.length : Return the length of the Interval. Examples -------- >>> intervals = pd.IntervalIndex.from_arrays( ... [1, 2, 3], [4, 5, 6], closed="right" ... ) >>> intervals.length Index([3, 3, 3], dtype='int64') >>> intervals = pd.IntervalIndex.from_tuples([(1, 5), (6, 10), (11, 15)]) >>> intervals.length Index([4, 4, 4], dtype='int64') Fr)r.rhlengthrs&rNrYIntervalIndex.lengthos<TZZ&&U33rPcV^8dQhRR/#)rksortrcrT)rss"rNrtrusrPc VPP'd/VPP'dVPV4pM~VPP'dRVPP'd6VP 4P 4^8:dVPV4pMVP V4pV'dVP4pV#)z< intersection specialized to the case with matching dtypes. )rrr_intersection_uniquerr_intersection_non_unique sort_values)rotherr\takens&&& rN _intersectionIntervalIndex._intersections 99   4::#7#7#7--e4E ZZ ! ! !ekk&;&;&; @QUV@V..t4E11%8E %%'E rPc V^8dQhRRRR/#rkrararrrT)rss"rNrtrus""-"M"rPc 6VPPVP4pVPPVP4pW#8HVR8g,pVPVP 4^,4p\ V4pVPV4#)z Used when the IntervalIndex does not have any common endpoint, no matter left or right. Return the intersection with another IntervalIndex. Parameters ---------- other : IntervalIndex Returns ------- IntervalIndex r)rrrtakerr*)rralindexerrindexermatchrs&& rNr^"IntervalIndex._intersection_uniquesv99((4::))%++6%(b.9--  23/yy!!rPc V^8dQhRRRR/#rfrT)rss"rNrtrusm rPc \P!\V4\R7pVP'dRVP'd@\P !\V44VP 4,^,pRW#&\\VPVPRR74p\\VPVPRR74FwrVWd9gK RW%&K W,#)z Used when the IntervalIndex does have some common endpoints, on either sides. Return the intersection with another IntervalIndex. Parameters ---------- other : IntervalIndex Returns ------- IntervalIndex r%T)strict) rGzerosrrcrr(rrziprrr')rrar first_nan_loc other_tupsr+tups&& rNr_&IntervalIndex._intersection_non_uniques xxD . << RRrPracV^8dQhRR/#rrT)rss"rNrtrts  D rPcn\\V4\V\4\V\4VRJ.4#)zB Helper for interval_range to check if start/end are valid types. N)anyr!rErr)endpoints&rN_is_valid_endpointrs:  h  x + x +     rPcV^8dQhRR/#rrT)rss"rNrtrts   rPcRpRp\V4;'d\V4;'gWV!V4;'dV!V4;'g7V!V4;'dV!V4;'g\P!W4#)zC Helper for interval_range to check type compat of start/end/freq. c.\V\\34#rC)rErr xs&rN%_is_type_compatible..ZIz+BCrPc.\V\\34#rC)rErr rs&rNrrrrP)r!comany_none)ab is_ts_compat is_td_compats&& rN_is_type_compatiblersyDLCL 1 & &)A,   O / / Q   O / / Q   <<  rPc$V^8dQhRRRRRR/#)rkrorpr]r;rrrarT)rss"rNrtrts/ww  w  wwrPc *\V4p\V4pVeTMTpVf3\P!W V4'd\V4'd^MRp\P!WW#4^8wd \ R4h\ V4'g\ RV 24h\ V4'g\ RV 24h\V4pVe\V4'g \V4p\\W4\W4\W4.4'g \R4hVe V^, p\V4'EdV\P!R4p\P!WV4'EdB\V\P \P"34'dY\V\P \P"34'd)VPVP8XdVPpM\V\$\P"34'gM\V\$\P"34'g'\V\$\P"34'd\P!R 4p\P&!WVR ,,V4p \)W4p MpVf!\+W, V,4^,pM5VfW^, V,, pMVfW^, V,,p\P,!WV4p \;QJd1R \P.!WV44F 'dK R M& R M"!R \P.!WV444'd \)W4p M1\V\04'd\3WW#R7p M \5WW#R7p \6P9V VV\;V PVR7R7# \ dp\ RT 24ThRp?ii;i)a Return a fixed frequency IntervalIndex. Parameters ---------- start : numeric or datetime-like, default None Left bound for generating intervals. end : numeric or datetime-like, default None Right bound for generating intervals. periods : int, default None Number of periods to generate. freq : numeric, str, Timedelta, datetime.timedelta, or DateOffset, default None The length of each interval. Must be consistent with the type of start and end, e.g. 2 for numeric, or '5H' for datetime-like. Default is 1 for numeric and 'D' for datetime-like. name : str, default None Name of the resulting IntervalIndex. closed : {'left', 'right', 'both', 'neither'}, default 'right' Whether the intervals are closed on the left-side, right-side, both or neither. Returns ------- IntervalIndex Object with a fixed frequency. See Also -------- IntervalIndex : An Index of intervals that are all closed on the same side. Notes ----- Of the four parameters ``start``, ``end``, ``periods``, and ``freq``, exactly three must be specified. If ``freq`` is omitted, the resulting ``IntervalIndex`` will have ``periods`` linearly spaced elements between ``start`` and ``end``, inclusively. To learn more about datetime-like frequency strings, please see :ref:`this link`. Examples -------- Numeric ``start`` and ``end`` is supported. >>> pd.interval_range(start=0, end=5) IntervalIndex([(0, 1], (1, 2], (2, 3], (3, 4], (4, 5]], dtype='interval[int64, right]') Additionally, datetime-like input is also supported. >>> pd.interval_range( ... start=pd.Timestamp("2017-01-01"), end=pd.Timestamp("2017-01-04") ... ) IntervalIndex([(2017-01-01 00:00:00, 2017-01-02 00:00:00], (2017-01-02 00:00:00, 2017-01-03 00:00:00], (2017-01-03 00:00:00, 2017-01-04 00:00:00]], dtype='interval[datetime64[us], right]') The ``freq`` parameter specifies the frequency between the left and right. endpoints of the individual intervals within the ``IntervalIndex``. For numeric ``start`` and ``end``, the frequency must also be numeric. >>> pd.interval_range(start=0, periods=4, freq=1.5) IntervalIndex([(0.0, 1.5], (1.5, 3.0], (3.0, 4.5], (4.5, 6.0]], dtype='interval[float64, right]') Similarly, for datetime-like ``start`` and ``end``, the frequency must be convertible to a DateOffset. >>> pd.interval_range(start=pd.Timestamp("2017-01-01"), periods=3, freq="MS") IntervalIndex([(2017-01-01 00:00:00, 2017-02-01 00:00:00], (2017-02-01 00:00:00, 2017-03-01 00:00:00], (2017-03-01 00:00:00, 2017-04-01 00:00:00]], dtype='interval[datetime64[us], right]') Specify ``start``, ``end``, and ``periods``; the frequency is generated automatically (linearly spaced). >>> pd.interval_range(start=0, end=6, periods=4) IntervalIndex([(0.0, 1.5], (1.5, 3.0], (3.0, 4.5], (4.5, 6.0]], dtype='interval[float64, right]') The ``closed`` parameter specifies which endpoints of the individual intervals within the ``IntervalIndex`` are closed. >>> pd.interval_range(end=5, periods=4, closed="both") IntervalIndex([[1, 2], [2, 3], [3, 4], [4, 5]], dtype='interval[int64, both]') NDzVOf the four parameters: start, end, periods, and freq, exactly three must be specifiedz,start must be numeric or datetime-like, got z*end must be numeric or datetime-like, got z7freq must be numeric or convertible to DateOffset, got z+start, end, freq need to be type compatibleint64float64g?c38"TFp\V4xK R#5irC)r).0rs& rN !interval_range..sE&Dz!}}&DsFT)rendperiodsfreq)rr])ror]r?)rrrr!count_not_nonerrr+rallrrKrGr? all_not_nonerEintegerfloatingfloatr(rrlinspacenot_nonerr2r7rarr') rrrrror]rrr?rs &&&&&& rNinterval_rangers+D #5 )E  %C)usH | WS99h''qS %g49 4  e $ $GwOPP c " "EcUKLLw'G  $ T?D   +  ,  *   EFF1 ((7+   E - -52::r{{";<<sRZZ$=>>KK399, 55"++"677cE2;;#788dUBKK$899+YYuTCZ&8$?F+F:Fs{t34q8{d22{d22[[W5F 3Ecll5t&DE333Ecll5t&DE E E+F:F Hi ( (%'M uwR  $ $ FLL@ % u I$P  s O33 P>P  P) __array__overlapscontainsrdrerfrgis_empty)NNNNNr)`r __future__roperatorrrtypingrrrrnumpyrG pandas._libsr pandas._libs.intervalr r r pandas._libs.tslibsr rrrr pandas.errorsrpandas.util._decoratorsrrpandas.util._exceptionsrpandas.core.dtypes.castrrrrrrpandas.core.dtypes.commonrrrrr r!r"r#r$r%pandas.core.dtypes.dtypesr&r'pandas.core.dtypes.missingr(pandas.core.algorithmsr*pandas.core.arrays.datetimeliker+pandas.core.arrays.intervalr,pandas.core.commoncorecommonrpandas.core.indexersr-pandas.core.indexes.baser.r/r0pandas.core.indexes.datetimesr1r2pandas.core.indexes.extensionr3r4pandas.core.indexes.multir5pandas.core.indexes.timedeltasr6r7collections.abcr8pandas._typingr9r:r;r<rOrRrXrarrrrTrPrNrsT" ,6   =)<! : 1 (Q"Q"  k*ME  .9=PTU HFRNFRV F FRV"   HwwrP