+
    xȇi                       ^ RI Ht ^ RIHtHtHt ^ RIHt ^ RIt^ RI	H
t
 ^ RIHtHtHtHtHtHt ^ RIt^ RIHtHt ^ RIHt ^ R	IHt ^ R
IHtHt ^ RI H!t! ^ RI"H#t#H$t$H%t%H&t&H't'H(t( ^ RI)H*t* ^ RI+H,t, ^ RI-H.u H/t0 ^ RI1H2t2 ^ RI3H4t4 ^ RI5H.u H6u H7t8 ^ RI5H9t9H:t: ^ RI;H<t< ]'       d   ^ RI=H>t>H?t?H@t@HAtAHBtBHCtC ^ RIDHEtE ]F! ^ 4      tG]P                  ! ]P                  4      tJR R ltK]! R4       ! R R]94      4       tLR# )    )annotations)CallableHashableIterator)	timedeltaN)	getsizeof)TYPE_CHECKINGAnyLiteralSelfcastoverload)indexlib)
no_default)function)cache_readonly
set_module)ExtensionDtype)ensure_platform_intensure_python_intis_float
is_integer	is_scalaris_signed_integer_dtype)ABCTimedeltaIndex)ops)extract_array)check_array_indexer)Indexmaybe_extract_name)unpack_zerodim_and_defer)AxisDtypeJoinHow
NaPositionNumpySorternptSeriesc               (    V ^8  d   QhRRRRRRRR/# )   startintsteplower_limitreturn )formats   "i/Users/max/.openclaw/workspace/postharvest/venv/lib/python3.14/site-packages/pandas/core/indexes/range.py__annotate__r5   G   s(     ( (s (# (C (C (    c                h    W ,
          ) \        V4      ,          ) pV \        V4      V,          ,           # )z?Returns the smallest element greater than or equal to the limit)abs)r-   r/   r0   no_stepss   &&& r4   min_fitting_elementr:   G   s-    &'3t945H3t9x'''r6   pandasc            	      |  a  ] tR t^Mt$ RtRt]R3tR]R&   R]R&   ]	R R	 l4       t
RR R llt]RR R ll4       t]RR R ll4       t]R R l4       t]R R l4       t]R R l4       tR R ltR tR tR R lt]	R R l4       t]	R  R! l4       t]	R" R# l4       t]R$ R% l4       tRR& R' llt]	R( R) l4       t]	R* R+ l4       t]R, R- l4       t]R. R/ l4       tR0 R1 lt ]	R2 R3 l4       t!R4 R5 lt"RR6 V 3R7 lllt#]R8 R9 l4       t$R: R; lt%R< R= lt&]'3R> R? llt(R@ RA lt)RB V 3RC llt*RRD RE llt+RF RG lt,RRI RJ llt-RRK RL llt.RRM V 3RN lllt/RRO RP llt0RRQ RR llt1RS RT lt2RRU RV llt3RW V 3RX llt4]5RYRZR[RZR\RZR]RZ/R^ R_ ll4       t6]5R[RZR\RZR]RZ/R` Ra ll4       t6]5RYRZR[RZR\RZR]RZ/Rb Rc ll4       t6RYRR[RHR\RdR]R
/Re V 3Rf lllt6RRg V 3Rh lllt7Ri Rj lt8Rk Rl lt9Rm V 3Rn llt:RV 3Ro llt;RRp V 3Rq lllt<Rr V 3Rs llt=RRt V 3Ru lllt>Rv V 3Rw llt?Rx V 3Ry llt@Rz V 3R{ lltAR| R} ltB]	R~ R l4       tCV 3R ltDR R ltE]F! R4      V 3R l4       tGR R ltHR R ltIRR V 3R llltJV 3R ltKV 3R ltLR V 3R lltMR R ltNR R ltOR R ltPRR R lltQRR V 3R llltRRR V 3R llltSRtTV ;tU# )
RangeIndexa  
Immutable Index implementing a monotonic integer range.

RangeIndex is a memory-saving special case of an Index limited to representing
monotonic ranges with a 64-bit dtype. Using RangeIndex may in some instances
improve computing speed.

This is the default index type used
by DataFrame and Series when no explicit index is provided by the user.

Parameters
----------
start : int, range, or other RangeIndex instance, default None
    If int and "stop" is not given, interpreted as "stop" instead.
stop : int, default None
    The end value of the range (exclusive).
step : int, default None
    The step size of the range.
dtype : np.int64, default None
    Unused, accepted for homogeneity with other index types.
copy : bool, default False
    Unused, accepted for homogeneity with other index types.
name : object, optional
    Name to be stored in the index.

Attributes
----------
start
stop
step

Methods
-------
from_range

See Also
--------
Index : The base pandas Index type.

Examples
--------
>>> list(pd.RangeIndex(5))
[0, 1, 2, 3, 4]

>>> list(pd.RangeIndex(-2, 4))
[-2, -1, 0, 1, 2, 3]

>>> list(pd.RangeIndex(0, 10, 2))
[0, 2, 4, 6, 8]

>>> list(pd.RangeIndex(2, -10, -3))
[2, -1, -4, -7]

>>> list(pd.RangeIndex(0))
[]

>>> list(pd.RangeIndex(1, 0))
[]

rangeindexzsigned integerrange_range
np.ndarray_valuesc                   V ^8  d   QhRR/# )r,   r1   ztype[libindex.Int64Engine]r2   )r3   s   "r4   r5   RangeIndex.__annotate__   s     $ $8 $r6   c                	"    \         P                  # N)libindexInt64Engineselfs   &r4   _engine_typeRangeIndex._engine_type   s    ###r6   NFc               (    V ^8  d   QhRRRRRRRR/# )	r,   dtypeDtype | NonecopyboolnameHashable | Noner1   r   r2   )r3   s   "r4   r5   rD      s4     "/ "/
 "/ "/ "/ 
"/r6   c                	   V P                  V4       \        WaV 4      p\        W4      '       d   VP                  VR 7      # \        V\        4      '       d   V P                  WR 7      # \        P                  ! WV4      '       d   \        R4      hVe   \        V4      M^ pVf   ^ Tr!M\        V4      pVe   \        V4      M^pV^ 8X  d   \        R4      h\	        WV4      pV P                  WvR 7      # )rR   z,RangeIndex(...) must be called with integerszStep must not be zero)_validate_dtyper!   
isinstancerP   r?   _simple_newcomall_none	TypeErrorr   
ValueError)clsr-   stopr/   rN   rP   rR   rngs   &&&&&&& r4   __new__RangeIndex.__new__   s     	E"!$s3 e!!::4:((u%%??5?44 <<T**JKK,1,=!%(1<U4$T*D*.*: &19455E&s..r6   c               $    V ^8  d   QhRRRRRR/# )r,   datar?   rN   rO   r1   r   r2   )r3   s   "r4   r5   rD      s!     +0 +0e +0| +0t +0r6   c                    \        V\        4      '       g   \        V P                   RV: R24      hV P	                  V4       V P                  WR7      # )a  
Create :class:`pandas.RangeIndex` from a ``range`` object.

This method provides a way to create a :class:`pandas.RangeIndex` directly
from a Python ``range`` object. The resulting :class:`RangeIndex` will have
the same start, stop, and step values as the input ``range`` object.
It is particularly useful for constructing indices in an efficient and
memory-friendly manner.

Parameters
----------
data : range
    The range object to be converted into a RangeIndex.
name : str, default None
    Name to be stored in the index.
dtype : Dtype or None
    Data type for the RangeIndex. If None, the default integer type will
    be used.

Returns
-------
RangeIndex

See Also
--------
RangeIndex : Immutable Index implementing a monotonic integer range.
Index : Immutable sequence used for indexing and alignment.

Examples
--------
>>> pd.RangeIndex.from_range(range(5))
RangeIndex(start=0, stop=5, step=1)

>>> pd.RangeIndex.from_range(range(2, -10, -3))
RangeIndex(start=2, stop=-10, step=-3)
z7(...) must be called with object coercible to a range, z was passedrU   )rW   r?   r[   __name__rV   rX   )r]   rc   rR   rN   s   &&&&r4   
from_rangeRangeIndex.from_range   sZ    L $&&<<. !.  	E"t//r6   c               $    V ^8  d   QhRRRRRR/# )r,   valuesr?   rR   rS   r1   r   r2   )r3   s   "r4   r5   rD      s$      "1	r6   c                	    \         P                  V 4      p\        V\        4      '       g   Q hWn        W#n        / Vn        VP                  4        R Vn        V# rF   )	objectr`   rW   r?   r@   _name_cache_reset_identity_references)r]   ri   rR   results   &&& r4   rX   RangeIndex._simple_new   sO     $&%(((( !r6   c                    V ^8  d   QhRRRR/# )r,   rN   rO   r1   Noner2   )r3   s   "r4   r5   rD      s      L T r6   c                	l    Vf   R # V P                   w  r#V! V4      '       g   \        RV RV 24      hR # )Nz#Incorrect `dtype` passed: expected z, received )_dtype_validation_metadatar\   )r]   rN   validation_funcexpecteds   &&  r4   rV   RangeIndex._validate_dtype   sE    =$'$B$B!u%%5hZ{5'R  &r6   c                   V ^8  d   QhRR/# )r,   r1   ztype[Index]r2   )r3   s   "r4   r5   rD     s      k r6   c                    \         # )z(return the class to use for construction)r    rI   s   &r4   _constructorRangeIndex._constructor
  s	     r6   c                   V ^8  d   QhRR/# )r,   r1   rA   r2   )r3   s   "r4   r5   rD     s     K Kz Kr6   c                    \         P                  ! V P                  V P                  V P                  \         P
                  R7      # )zw
An int array that for performance reasons is created only when needed.

The constructed array is saved in ``_cache``.
rN   )nparanger-   r^   r/   int64rI   s   &r4   _dataRangeIndex._data  s)     yyTYY		JJr6   c                   V ^8  d   QhRR/# )r,   r1   zlist[tuple[str, int]]r2   )r3   s   "r4   r5   rD     s     N N$9 Nr6   c                l    V P                   pRVP                  3RVP                  3RVP                  3.# )z,return a list of tuples of start, stop, stepr-   r^   r/   )r@   r-   r^   r/   rJ   r_   s   & r4   _get_data_as_itemsRangeIndex._get_data_as_items  s3    kk#))$vsxx&86388:LMMr6   c                	    R V P                   /pVP                  \        V P                  4       4      4       \        P
                  \        V 4      V3R3# )rR   N)rl   updatedictr   ibase
_new_Indextype)rJ   ds   & r4   
__reduce__RangeIndex.__reduce__  sE    TZZ 	d--/01$t*a$66r6   c                    \        RV P                  4       4      pV P                  e2   VP                  R\        P
                  ! V P                  4      34       V# )z8
Return a list of tuples of the (attr, formatted_value)
zlist[tuple[str, str | int]]rR   )r   r   rl   appendr   default_pprint)rJ   attrss   & r4   _format_attrsRangeIndex._format_attrs&  sI     2D4K4K4MN::!LL&%"6"6tzz"BCDr6   c               $    V ^8  d   QhRRRRRR/# )r,   headerz	list[str]na_repstrr1   r2   )r3   s   "r4   r5   rD   /  s&     D DY D D	 Dr6   c               	>   \        V P                  4      '       g   V# \        V P                  ^ ,          4      p\        V P                  R,          4      p\        \        V4      \        V4      4      pYP                   Uu. uF	  qfRV 2 NK  	  up,           # u upi )r   <)lenr@   r   max)rJ   r   r   first_val_strlast_val_str
max_lengthxs   &$$    r4   _format_with_headerRangeIndex._format_with_header/  s{    4;;MDKKN+4;;r?+]+S->?
{{C{!a
|^,-{CCCCs   Bc                   V ^8  d   QhRR/# r,   r1   r.   r2   )r3   s   "r4   r5   rD   <  s     ! !s !r6   c                .    V P                   P                  # )a1  
The value of the `start` parameter (``0`` if this was not supplied).

This property returns the starting value of the `RangeIndex`. If the `start`
value is not explicitly provided during the creation of the `RangeIndex`,
it defaults to 0.

See Also
--------
RangeIndex : Immutable index implementing a range-based index.
RangeIndex.stop : Returns the stop value of the `RangeIndex`.
RangeIndex.step : Returns the step value of the `RangeIndex`.

Examples
--------
>>> idx = pd.RangeIndex(5)
>>> idx.start
0

>>> idx = pd.RangeIndex(2, -10, -3)
>>> idx.start
2
)r@   r-   rI   s   &r4   r-   RangeIndex.start;  s    4 {{   r6   c                   V ^8  d   QhRR/# r   r2   )r3   s   "r4   r5   rD   X  s        c  r6   c                .    V P                   P                  # )a`  
The value of the `stop` parameter.

This property returns the `stop` value of the RangeIndex, which defines the
upper (or lower, in case of negative steps) bound of the index range. The
`stop` value is exclusive, meaning the RangeIndex includes values up to but
not including this value.

See Also
--------
RangeIndex : Immutable index representing a range of integers.
RangeIndex.start : The start value of the RangeIndex.
RangeIndex.step : The step size between elements in the RangeIndex.

Examples
--------
>>> idx = pd.RangeIndex(5)
>>> idx.stop
5

>>> idx = pd.RangeIndex(2, -10, -3)
>>> idx.stop
-10
)r@   r^   rI   s   &r4   r^   RangeIndex.stopW  s    4 {{r6   c                   V ^8  d   QhRR/# r   r2   )r3   s   "r4   r5   rD   t  s        c  r6   c                .    V P                   P                  # )a  
The value of the `step` parameter (``1`` if this was not supplied).

The ``step`` parameter determines the increment (or decrement in the case
of negative values) between consecutive elements in the ``RangeIndex``.

See Also
--------
RangeIndex : Immutable index implementing a range-based index.
RangeIndex.stop : Returns the stop value of the RangeIndex.
RangeIndex.start : Returns the start value of the RangeIndex.

Examples
--------
>>> idx = pd.RangeIndex(5)
>>> idx.step
1

>>> idx = pd.RangeIndex(2, -10, -3)
>>> idx.step
-3

Even if :class:`pandas.RangeIndex` is empty, ``step`` is still ``1`` if
not supplied.

>>> idx = pd.RangeIndex(1, 0)
>>> idx.step
1
)r@   r/   rI   s   &r4   r/   RangeIndex.steps  s    @ {{r6   c                   V ^8  d   QhRR/# r   r2   )r3   s   "r4   r5   rD     s     
 
 
r6   c                f   a V P                   o\        S4      \        V3R lR 4       4      ,           # )z4
Return the number of bytes in the underlying data.
c              3  N   <"   T F  p\        \        SV4      4      x  K  	  R # 5irF   )r   getattr).0	attr_namer_   s   & r4   	<genexpr>$RangeIndex.nbytes.<locals>.<genexpr>  s'      $
6	 gc9-..6s   "%)r-   r^   r/   )r@   r   sumr   s   &@r4   nbytesRangeIndex.nbytes  s3    
 kk~ $
6$
 !
 
 	
r6   c                    V ^8  d   QhRRRR/# )r,   deeprQ   r1   r.   r2   )r3   s   "r4   r5   rD     s       # r6   c                    V P                   # )a`  
Memory usage of my values

Parameters
----------
deep : bool
    Introspect the data deeply, interrogate
    `object` dtypes for system-level memory consumption

Returns
-------
bytes used

Notes
-----
Memory usage does not include memory consumed by elements that
are not components of the array if deep=False

See Also
--------
numpy.ndarray.nbytes
)r   )rJ   r   s   &&r4   memory_usageRangeIndex.memory_usage  s    . {{r6   c                   V ^8  d   QhRR/# )r,   r1   znp.dtyper2   )r3   s   "r4   r5   rD     s      x r6   c                	    \         # rF   )_dtype_int64rI   s   &r4   rN   RangeIndex.dtype  s    r6   c                   V ^8  d   QhRR/# r,   r1   rQ   r2   )r3   s   "r4   r5   rD     s      4 r6   c                    R# )z%return if the index has unique valuesTr2   rI   s   &r4   	is_uniqueRangeIndex.is_unique  s     r6   c                   V ^8  d   QhRR/# r   r2   )r3   s   "r4   r5   rD          6 6 6r6   c                	`    V P                   P                  ^ 8  ;'       g    \        V 4      ^8*  # r   r@   r/   r   rI   s   &r4   is_monotonic_increasing"RangeIndex.is_monotonic_increasing  '    {{!#55s4yA~5r6   c                   V ^8  d   QhRR/# r   r2   )r3   s   "r4   r5   rD     r   r6   c                	`    V P                   P                  ^ 8  ;'       g    \        V 4      ^8*  # r   r   rI   s   &r4   is_monotonic_decreasing"RangeIndex.is_monotonic_decreasing  r   r6   c                    V ^8  d   QhRRRR/# )r,   keyr
   r1   rQ   r2   )r3   s   "r4   r5   rD     s     " " " "r6   c                	|    \        V4        \        V4      pYP                  9   #   \        \        3 d     R # i ; iF)hashr   r[   OverflowErrorr@   )rJ   r   s   &&r4   __contains__RangeIndex.__contains__  s@    S		#C(C kk!! =) 		s   & ;;c                   V ^8  d   QhRR/# )r,   r1   r   r2   )r3   s   "r4   r5   rD     s      s r6   c                	    R # )integerr2   rI   s   &r4   inferred_typeRangeIndex.inferred_type  s    r6   c                   V ^8  d   QhRR/# r   r2   )r3   s   "r4   r5   rD     s     6 6c 6r6   c                x   \        V4      '       g(   \        V4      '       d>   VP                  4       '       d(   \        V4      p V P                  P	                  V4      # \        V\        4      '       d   \        V4      hV P                  V4       \        V4      h  \
         d   p\        T4      ThRp?ii ; i)aH  
Get integer location for requested label.

Parameters
----------
key : int or float
    Label to locate. Integer-like floats (e.g. 3.0) are accepted and
    treated as the corresponding integer. Non-integer floats and other
    non-integer labels are not valid and will raise KeyError or
    InvalidIndexError.

Returns
-------
int
    Integer location of the label within the RangeIndex.

Raises
------
KeyError
    If the label is not present in the RangeIndex or the label is a
    non-integer value.
InvalidIndexError
    If the label is of an invalid type for the RangeIndex.

See Also
--------
RangeIndex.get_slice_bound : Calculate slice bound that corresponds to
    given label.
RangeIndex.get_indexer : Computes indexer and mask for new index given
    the current index.
RangeIndex.get_non_unique : Returns indexer and masks for new index given
    the current index.
RangeIndex.get_indexer_for : Returns an indexer even when non-unique.

Examples
--------
>>> idx = pd.RangeIndex(5)
>>> idx.get_loc(3)
3

>>> idx = pd.RangeIndex(2, 10, 2)  # values [2, 4, 6, 8]
>>> idx.get_loc(6)
2
N)
r   r   r.   r@   r   r\   KeyErrorrW   r   _check_indexing_error)rJ   r   new_keyerrs   &&  r4   get_locRangeIndex.get_loc  s    Z c??x}}1A1A#hG-{{((11 c8$$3-""3'sm  -sm,-s   B B9(B44B9c               (    V ^8  d   QhRRRRRRRR/# )	r,   targetr    methodz
str | Nonelimitz
int | Noner1   npt.NDArray[np.intp]r2   )r3   s   "r4   r5   rD     s2     ) )) ) 	) 
)r6   c                	X  < \         P                  ! W$V4      '       d   \        SV `  WWCR 7      # V P                  ^ 8  d%   V P
                  V P                  V P                  rvpM9V P                  RRR1,          pVP
                  VP                  VP                  rvp\        P                  ! V4      p	W,
          p
W,          ^ 8H  V
^ 8  ,          W8  ,          pRW( &   W,          V,          W&   WpP                  8w  d"   \        V 4      ^,
          W,          ,
          W&   \        V
4      # ))r   	tolerancer   Nr   )rY   any_not_nonesuper_get_indexerr/   r-   r^   r@   r   asarrayr   r   )rJ   r   r   r   r   r-   r^   r/   reversetarget_arraylocsvalid	__class__s   &&&&&       r4   r   RangeIndex._get_indexer  s     Fu557' (   99q= $

DIItyyE kk$B$'G 'w||W\\Ezz&)#!dai0L4GHVkD(99d)a-$+5DK"4((r6   c                   V ^8  d   QhRR/# r   r2   )r3   s   "r4   r5   rD   0  s       r6   c                    R# )z1
Should an integer key be treated as positional?
Fr2   rI   s   &r4   _should_fallback_to_positional)RangeIndex._should_fallback_to_positional/  s    
 r6   c                   V ^8  d   QhRR/# )r,   r1   z	list[int]r2   )r3   s   "r4   r5   rD   8  s     ! !	 !r6   c                	,    \        V P                  4      # rF   )listr@   rI   s   &r4   tolistRangeIndex.tolist8  s    DKK  r6   c                   V ^8  d   QhRR/# )r,   r1   zIterator[int]r2   )r3   s   "r4   r5   rD   ;  s      - r6   c              #  :   "   V P                    Rj  xL
  R#  L5i)z
Return an iterator of the values.

Returns
-------
iterator
    An iterator yielding ints from the RangeIndex.

Examples
--------
>>> idx = pd.RangeIndex(3)
>>> for x in idx:
...     print(x)
0
1
2
Nr@   rI   s   &r4   __iter__RangeIndex.__iter__;  s     $ ;;s   c                   V ^8  d   QhRR/# )r,   rR   r   r2   )r3   s   "r4   r5   rD   O  s     @ @( @r6   c                t   V\         J d   V P                  MTpVP                  P                  R8X  d   \	        W\
        P                  RR7      # VP                  P                  R8X  d   VP                  ^8X  d   \        V4      ^8X  dL   V^ ,          p\        W3V P                  ,           V P                  4      p\        V 4      P                  WBR7      # \        P                  ! V4      p\        V\        4      '       d   \        V 4      P                  WRR7      # V P                   P                  WR7      # )a<  
Create a new RangeIndex with the same class as the caller, don't copy the
data, use the same object attributes with passed in attributes taking
precedence.

*this is an internal non-public method*

Parameters
----------
values : the values to create the new RangeIndex, optional
name : Label, defaults to self.name
fF)rR   rN   rP   irU   )r   rl   rN   kindr    r   float64ndimr   r?   r/   r   rX   r   maybe_sequence_to_rangerW   r{   )rJ   ri   rR   r-   	new_rangemaybe_ranges   &&&   r4   _shallow_copyRangeIndex._shallow_copyO  s     "Z/tzzT<<#"**5II<<#q(8 6{aq	!%):DIIF	Dz--i-CC77?K+u--Dz--k-EE  ,,V,??r6   c                   V ^8  d   QhRR/# r,   r1   r   r2   )r3   s   "r4   r5   rD   l  s      t r6   c                	    \        V 4      P                  V P                  V P                  R 7      pV P                  Vn        V# rU   )r   rX   r@   rl   rm   )rJ   rp   s   & r4   _viewRangeIndex._viewl  s3    d''$**'Er6   c                   V ^8  d   QhRR/# )r,   preserve_namesrQ   r2   )r3   s   "r4   r5   rD   q  s     M MD Mr6   c                	   < \        V\        V 4      4      '       gC   VP                  P                  R 8X  d(   V P	                  VP
                  VP                  R7      p\        SV `!  WV4      # )r  rU   )	rW   r   rN   r  r  rB   rR   r   _wrap_reindex_result)rJ   r   indexerr  r   s   &&&&r4   r   RangeIndex._wrap_reindex_resultq  sT    &$t*--&,,2C2Cs2J''V[['IFw+F^LLr6   c               $    V ^8  d   QhRRRRRR/# )r,   rR   rS   r   rQ   r1   r   r2   )r3   s   "r4   r5   rD   v  s!     & & &t & &r6   c                \    V P                  WR7      ^ ,          pV P                  VR7      pV# )a  
Make a copy of this object.

Name is set on the new object.

Parameters
----------
name : Label, optional
    Set name for new object.
deep : bool, default False
    If True attempts to make a deep copy of the RangeIndex.
        Else makes a shallow copy.

Returns
-------
RangeIndex
    RangeIndex refer to new object which is a copy of this object.

See Also
--------
RangeIndex.delete: Make new RangeIndex with passed location(-s) deleted.
RangeIndex.drop: Make new RangeIndex with passed list of labels deleted.

Notes
-----
In most cases, there should be no functional difference from using
``deep``, but if ``deep`` is passed it will attempt to deepcopy.

Examples
--------
>>> idx = pd.RangeIndex(3)
>>> new_idx = idx.copy()
>>> idx is new_idx
False
)rR   r   rU   )_validate_names_rename)rJ   rR   r   	new_indexs   &&& r4   rP   RangeIndex.copyv  s3    H ###9!<LLdL+	r6   c                    V ^8  d   QhRRRR/# )r,   methLiteral['min', 'max']r1   int | floatr2   )r3   s   "r4   r5   rD     s     1 11 1k 1r6   c                	   \        V 4      ^,
          pVR8X  d   \        P                  # VR8X  d   V P                  ^ 8  g   VR8X  d   V P                  ^ 8  d   V P                  # V P                  V P                  V,          ,           # )   minr   r   )r   r   nanr/   r-   )rJ   r*  r9   s   && r4   _minmaxRangeIndex._minmax  sc    t9q=r>66Mem		A45=TYYQR]::zzDII000r6   Tc                    V ^8  d   QhRRRR/# r,   skipnarQ   r1   r,  r2   )r3   s   "r4   r5   rD          # #T #k #r6   c                |    \         P                  ! V4       \         P                  ! W44       V P                  R4      # )z#The minimum value of the RangeIndexr/  )nvvalidate_minmax_axisvalidate_minr1  rJ   axisr5  argskwargss   &&&*,r4   r/  RangeIndex.min  +    
%
%||E""r6   c                    V ^8  d   QhRRRR/# r4  r2   )r3   s   "r4   r5   rD     r6  r6   c                |    \         P                  ! V4       \         P                  ! W44       V P                  R4      # )z#The maximum value of the RangeIndexr   )r8  r9  validate_maxr1  r;  s   &&&*,r4   r   RangeIndex.max  r@  r6   c               $    V ^8  d   QhRRRRRR/# )r,   r*  r+  r5  rQ   r1   r.   r2   )r3   s   "r4   r5   rD     s(     < <#< 	<
 
<r6   c                	^  < \         P                  ! V4       \        V 4      ^ 8X  d    \        \	        4       RV 24      ! VVR7      # VR8X  d&   V P
                  ^ 8  d   ^ # \        V 4      ^,
          # VR8X  d&   V P
                  ^ 8  d   \        V 4      ^,
          # ^ # \        RV: R24      h)r   argr<  r5  r/  r   zmeth=z must be max or min)r8  r9  r   r   r   r/   r\   )rJ   r*  r<  r5  r   s   &&&&r4   
_argminmaxRangeIndex._argminmax  s     	%t9>57c$L1  U]yy1}4y1}$U]yy1}4y1}$w&9:;;r6   c                    V ^8  d   QhRRRR/# r,   r5  rQ   r1   r.   r2   )r3   s   "r4   r5   rD          @ @ @ @r6   c                	T    \         P                  ! W44       V P                  R WR7      # )r/  rH  )r8  validate_argminrI  r;  s   &&&*,r4   argminRangeIndex.argmin  #    
4(u4??r6   c                    V ^8  d   QhRRRR/# rL  r2   )r3   s   "r4   r5   rD     rM  r6   c                	T    \         P                  ! W44       V P                  R WR7      # )r   rH  )r8  validate_argmaxrI  r;  s   &&&*,r4   argmaxRangeIndex.argmax  rR  r6   c                   V ^8  d   QhRR/# )r,   r1   r   r2   )r3   s   "r4   r5   rD     s     ; ;*> ;r6   c                   VP                  RR4      pVP                  RR4       \        P                  ! W4       RRRrepV P                  P                  ^ 8  d+   V'       d   \        V 4      pM?\        V 4      ^,
          RRrepM)V'       d   \        V 4      ^,
          RRrepM\        V 4      p\        P                  ! WEV\        P                  R7      # )z
Returns the indices that would sort the index and its
underlying data.

Returns
-------
np.ndarray[np.intp]

See Also
--------
numpy.ndarray.argsort
	ascendingTr  Nr   r   )	popr8  validate_argsortr@   r/   r   r   r   intp)rJ   r=  r>  rZ  r-   r^   r/   s   &*,    r4   argsortRangeIndex.argsort  s     JJ{D1	

64 
D) $T;;aD	$'IM2rTT #D	Ar2EIEyyd"''::r6   c               $    V ^8  d   QhRRRRRR/# )r,   sortrQ   use_na_sentinelr1   z'tuple[npt.NDArray[np.intp], RangeIndex]r2   )r3   s   "r4   r5   rD     s(        
1	r6   c                	*   V'       dY   V P                   ^ 8  dH   \        P                  ! \        V 4      ^,
          RR\        P                  R7      pV RRR1,          pW43# \        P                  ! \        V 4      \        P                  R7      pT pW43# )r   r   Nr   )r/   r   r   r   r]  )rJ   ra  rb  codesuniquess   &&&  r4   	factorizeRangeIndex.factorize  so    
 DIIMIIc$i!mR277CE4R4jG ~ IIc$irww7EG~r6   c                    V ^8  d   QhRRRR/# )r,   otherrk   r1   rQ   r2   )r3   s   "r4   r5   rD     s     % %F %t %r6   c                   < \        V\        4      '       d   V P                  VP                  8H  # \        SV `  V4      # )z<
Determines if two Index objects contain the same elements.
)rW   r=   r@   r   equals)rJ   ri  r   s   &&r4   rk  RangeIndex.equals  s4     eZ((;;%,,..w~e$$r6   return_indexer.rZ  na_positionr   c          
     ,    V ^8  d   QhRRRRRRRRR	R
/# )r,   rm  zLiteral[False]rZ  rQ   rn  r&   r   Callable | Noner1   r   r2   )r3   s   "r4   r5   rD   	  s>       ' 	
    
r6   c               	    R # rF   r2   rJ   rm  rZ  rn  r   s   &$$$$r4   sort_valuesRangeIndex.sort_values  s     r6   c          
     ,    V ^8  d   QhRRRRRRRRR	R
/# )r,   rm  zLiteral[True]rZ  rQ   rn  r&   r   rp  r1   z$tuple[Self, np.ndarray | RangeIndex]r2   )r3   s   "r4   r5   rD     s>     3 3 &3 	3
  3 3 
.3r6   c               	    R # rF   r2   rr  s   &$$$$r4   rs  rt    s     03r6   c          
     ,    V ^8  d   QhRRRRRRRRRR	/# 
r,   rm  rQ   rZ  rn  r&   r   rp  r1   z+Self | tuple[Self, np.ndarray | RangeIndex]r2   )r3   s   "r4   r5   rD     s>     : : : 	:
  : : 
5:r6   c               	    R # rF   r2   rr  s   &$$$$r4   rs  rt    s     7:r6   lastc          
     ,    V ^8  d   QhRRRRRRRRRR	/# rx  r2   )r3   s   "r4   r5   rD   &  s>     !  !  !  	! 
  !  !  
5! r6   c               	j  < Ve   \         SV `  VVVVR7      # T pRpV'       d!   V P                  ^ 8  d   V R R R1,          pRpMV P                  ^ 8  d   V R R R1,          pRpV'       dH   V'       d   \        \	        V 4      ^,
          RR4      pM\        \	        V 4      4      pV\        V4      3# V# )N)rm  rZ  rn  r   FTr   )r   rs  r/   r?   r   r=   )	rJ   rm  rZ  rn  r   sorted_indexinverse_indexerr_   r   s	   &$$$$   r4   rs  rt  &  s     ?7&-#'	 '    L#O99q=#'":L&*OQ#DbDz"&CIM2r2CI&C00r6   c                    V ^8  d   QhRRRR/# )r,   ri  r    ra  rQ   r2   )r3   s   "r4   r5   rD   L  s     &+ &+5 &+ &+r6   c                	\  < \        V\        4      '       g   \        SV `  WR 7      # V P                  ^ 8  d   V P
                  RRR1,          MV P
                  pVP                  ^ 8  d   VP
                  RRR1,          MVP
                  p\        VP                  VP                  4      p\        VP                  VP                  4      pWe8:  d   V P                  \        4      # V P                  VP                  VP                  4      w  rxp	VP                  VP                  ,
          V,          '       d   V P                  \        4      # VP                  VP                  VP                  ,
          VP                  ,          V,          V,          ,           p
VP                  VP                  ,          V,          p\        WV4      p\        WV4      pV P                  ^ 8  ;'       d    VP                  ^ 8  VP                  ^ 8  Jd   VRRR1,          pV P                  V4      # )ra  Nr   )rW   r=   r   _intersectionr/   r@   r   r-   r/  r^   rX   _empty_range_extended_gcdr:   r?   )rJ   ri  ra  firstsecondint_lowint_highgcds_	tmp_startnew_step	new_startr  r   s   &&&           r4   r  RangeIndex._intersectionL  s    %,,7((::%)YY]DbD!',zzA~dd#5<< ekk6<<0uzz6;;/##L11 &&uzz6;;?	 KK&,,&#--##L11 KK6<<%++#="Ks"RUV"VV	::+s2 (	WE	)x8	IIM,,ejj1ninnq6HI!$B$I	**r6   c               $    V ^8  d   QhRRRRRR/# )r,   ar.   br1   ztuple[int, int, int]r2   )r3   s   "r4   r5   rD   t  s"     # #s #s #/C #r6   c                    ^ ^rC^^ reY!rV'       d8   W,          p	YxW,          ,
          rxY4W,          ,
          r4YVW,          ,
          rVK?  WV3# )z
Extended Euclidean algorithms to solve Bezout's identity:
   a*x + b*y = gcd(x, y)
Finds one particular solution for x, y: s, t
Returns: gcd, s, t
r2   )
rJ   r  r  r  old_stold_trold_rquotients
   &&&       r4   r  RangeIndex._extended_gcdt  sP     a5a55zH(,.1(,.1(,.1U""r6   c                    V ^8  d   QhRRRR/# )r,   ri  r?   r1   rQ   r2   )r3   s   "r4   r5   rD     s     	G 	GE 	Gd 	Gr6   c                *   V'       g   R# V P                   '       g   R# \        V4      ^8  d0   VP                  V P                   P                  ,          '       d   R# VP                  V P                   9   ;'       d    VR,          V P                   9   # )z)Check if other range is contained in selfTFr   )r@   r   r/   r-   )rJ   ri  s   &&r4   _range_in_selfRangeIndex._range_in_self  sd     {{{u:>ejj4;;+;+;;;{{dkk)FFeBi4;;.FFr6   c                    V ^8  d   QhRRRR/# )r,   ri  r    ra  zbool | Noner2   )r3   s   "r4   r5   rD     s     I0 I0E I0 I0r6   c                ,  < \        V\        4      '       Ed   VR9   g<   VRJ Ed   V P                  ^ 8  Ed   V P                  VP                  4      '       Ed   V P
                  V P                  rCV P
                  V P                  \        V 4      ^,
          ,          ,           pVP
                  VP                  rvVP
                  VP                  \        V4      ^,
          ,          ,           pV P                  ^ 8  d   YT) TrTpVP                  ^ 8  d   Y) Trp\        V 4      ^8X  d9   \        V4      ^8X  d)   \        V P
                  VP
                  ,
          4      ;rGM%\        V 4      ^8X  d   TpM\        V4      ^8X  d   Tp\        W64      p	\        WX4      p
Wt8X  d   W6,
          V,          ^ 8X  d4   W8,
          V8:  d'   We,
          V8:  d   \        V 4      ! WV,           V4      # V^,          ^ 8X  db   \        W6,
          4      V^,          8X  dE   \        WX,
          4      V^,          8X  d(   \        V 4      ! WV^,          ,           V^,          4      # MWt,          ^ 8X  dI   Wc,
          V,          ^ 8X  d4   Wd,           V8  d'   W,
          V8:  d   \        V 4      ! WV,           V4      # MTWG,          ^ 8X  dH   W6,
          V,          ^ 8X  d4   W7,           V8  d'   WW,
          V8:  d   \        V 4      ! WV,           V4      # \        SV `1  WR7      # )a%  
Form the union of two Index objects and sorts if possible

Parameters
----------
other : Index or array-like

sort : bool or None, default None
    Whether to sort (monotonically increasing) the resulting index.
    ``sort=None|True`` returns a ``RangeIndex`` if possible or a sorted
    ``Index`` with an int64 dtype if not.
    ``sort=False`` can return a ``RangeIndex`` if self is monotonically
    increasing and other is fully contained in self. Otherwise, returns
    an unsorted ``Index`` with an int64 dtype.

Returns
-------
union : Index
Fr  NT)rW   r=   r/   r  r@   r-   r   r8   r/  r   r   r   _union)rJ   ri  ra  start_sstep_send_sstart_ostep_oend_ostart_rend_rr   s   &&&        r4   r  RangeIndex._union  s[   ( eZ((|#$))a-D4G4G4U4U #'**dii

TYY#d)a-%@@"'++uzzejjCJN&CC99q=-2GWUG::>-2GWUGt9>c%jAo&)$**u{{*B&CCFVY!^#FZ1_#Fg/E)# *f49$_7$_7#Dz'6>6JJ!q !23vzA /6A:=  $Dz'6A:3EvPQzRR_) *f49$-8"^u4#Dz'6>6JJ_) *f49$-8"^u4#Dz'6>6JJw~e~//r6   c                	(  < V P                  V4       V P                  V4       V P                  V4      w  r\        V\        4      '       g   \
        S
V `  WR 7      # VRJd-   V P                  ^ 8  d   V RRR1,          P                  V4      # \        P                  ! W4      pV P                  ^ 8  d   V P                  RRR1,          MV P                  pV P                  V4      pVP                  ^ 8  d   VRRR1,          p\        V4      ^ 8X  d   V P                  VR7      # \        V4      \        V 4      8X  d   V R,          P                  V4      # \        V4      ^8X  dw   V^ ,          V ^ ,          8X  d
   V R,          # V^ ,          V R,          8X  d   V RR # \        V 4      ^8X  d   V^ ,          V ^,          8X  d
   V R,          # \
        S
V `  WR 7      # \        V4      ^8X  d0   V^ ,          V^ ,          8X  d   VR,          VR,          8X  d   V ^R # VP                  VP                  8X  d   V^ ,          VP                  8X  d<   \        VR,          VP                  ,           VP                   VP                  4      pEMPVR,          VR,          8X  d+   \        VP                  V^ ,          VP                  4      pEMVP                  V^R 8X  d    \        V4      ^,
          pVRRV1,          pM\
        S
V `  WR 7      # \        V 4      ^8  g   Q hVP                  VP                  ^,          8X  d   V^ ,          V^ ,          8X  d)   VR,          VR,          VR	,          39   d   VR,          pM]V^ ,          V^,          8X  d)   VR,          VR,          VR	,          39   d   VR,          pM \
        S
V `  WR 7      # \
        S
V `  WR 7      # WPP                  Jd   VRRR1,          p\#        V 4      P%                  WtR7      p	V	# )
r  FNrU   :Nr   Nr.  NNNNr,   :r.  Nr,   r   )_validate_sort_keyword_assert_can_do_setop_convert_can_do_setoprW   r=   r   _differencer/   r   get_op_result_namer@   intersectionr   renamer-   r?   r^   r   rX   )rJ   ri  ra  result_nameres_namer  overlapnew_rngr/   r'  r   s   &&&       r4   r  RangeIndex._difference  s`   ##D)!!%(!77>%,,7&u&88uQ":))%00))$6%)YY]DbD!##E*<<!ddmGw<1;;H;--w<3t9$8??8,, w<1qzT!W$BxtBx'CRy TaGAJ$q'$9Cy  w*5*<<\Q71:q#9gbkUSUY>V":<<5::%qzU[[(ejj 8%**ejjQb	)WQZD52;.5zA~$- w*5*<<
 t9q= =||uzzA~-1:q)gbkeBir=S.S#DkGQZ58+b	5QS9?U0U#CjG !7.u.@@ w*5*<<#ddmGJ**7*B	r6   c                    V ^8  d   QhRRRR/# )r,   r  rS   r1   r    r2   )r3   s   "r4   r5   rD   2  s      "1	r6   c                	   < \        V\        4      '       d   Ve   \        SV `  WV4      # V P	                  V4      pVP	                  V 4      pVP                  V4      pVe   VP                  V4      pV# rF   )rW   r=   r   symmetric_difference
differenceunionr  )rJ   ri  r  ra  leftrightrp   r   s   &&&&   r4   r  RangeIndex.symmetric_difference2  sn     %,,0@7/DIIu%  &E""]];/Fr6   c               (    V ^8  d   QhRRRRRRRR/# )	r,   ri  r    howr%   ra  rQ   r1   Ftuple[Index, npt.NDArray[np.intp] | None, npt.NDArray[np.intp] | None]r2   )r3   s   "r4   r5   rD   @  s,     > >>!(>04>	O>r6   c                	   < \        V\        4      '       gC   VP                  P                  R 8X  d(   V P	                  VP
                  VP                  R7      p\        SV `!  WVR7      # )r  rU   )r  ra  )	rW   r=   rN   r  r  rB   rR   r   _join_empty)rJ   ri  r  ra  r   s   &&&&r4   r  RangeIndex._join_empty@  sU     %,,1A1AS1H&&u}}5::&FEw"5"==r6   c               $    V ^8  d   QhRRRRRR/# )r,   ri  r    r  r%   r1   r  r2   )r3   s   "r4   r5   rD   G  s$     !& !&!&!(!&	O!&r6   c                	  < \        V\        V 4      4      '       gU   V P                  VP                  VP                  R 7      p\        V\        V 4      4      '       g   \
        SV `  WR7      # TpV P                  V4      '       d   VR8X  d   TMT pVRR3# VR8X  d   T pRpVP                  V4      pMVR8X  d   TpV P                  V4      pRpMuVR8X  d5   V P                  V4      pV P                  V4      pVP                  V4      pM:VR8X  d4   V P                  V4      pV P                  V4      pVP                  V4      pXf   RM
\        V4      pXf   RM
\        V4      pXWg3# )rU   )r  r  Nr  innerouter)rW   r   r  rB   rR   r   _join_monotonicrk  get_indexerr  r  r   )	rJ   ri  r  maybe_ri	ret_index
join_indexlidxridxr   s	   &&&     r4   r  RangeIndex._join_monotonicG  s`    %d,,))%--ejj)IHhT
33w.u.>>E;;u!$TIdD((&=JD$$Z0DG^J##J/DDG^**51J##J/D$$Z0DG^E*J##J/D$$Z0D|t)<T)B|t)<T)B4%%r6   c                   V ^8  d   QhRR/# )r,   r1   r    r2   )r3   s   "r4   r5   rD   n  s     # #U #r6   c                	  < \        V4      '       d\   V^ \        V 4      ) 39   d
   V R,          # VR\        V 4      ^,
          39   d   V RR # \        V 4      ^8X  d   VR9   d
   V R,          # M\        P                  ! V4      '       dv   \        P                  ! \
        P                  ! V\
        P                  R7      \        V 4      4      p\        V\        4      '       d   W,          pV P                  VRR7      # \        SV `1  V4      # )	r   r  Nr  r   Fr  r   )r.  r  )r   r   r   is_list_likemaybe_indices_to_slicer   r   r]  rW   slicer  r   delete)rJ   locslcri  r   s   &&  r4   r  RangeIndex.deleten  s     c??q3t9*o%Bxr3t9q=))CRy 4yA~#.Cy c"",,RZZ277-KSQUYWC#u%% 	u599w~c""r6   c                    V ^8  d   QhRRRR/# )r,   r  r.   r1   r    r2   )r3   s   "r4   r5   rD     s     ) )# ) )r6   c                	  < \        V4      '       g   \        V4      '       Ed?   \        V 4      ^ 8X  de   V^ 8X  d^   \        V4      '       dM   \        W"V P                  ,           V P                  4      p\        V 4      P                  W0P                  R7      # \        V 4      '       Ed   V P                  pV^ 8X  d   W ^ ,          V P                  ,
          8X  db   \        VP                  VP                  ,
          VP                  VP                  4      p\        V 4      P                  W0P                  R7      # V\        V 4      8X  d   W R,          V P                  ,           8X  db   \        VP                  VP                  VP                  ,           VP                  4      p\        V 4      P                  W0P                  R7      # \        V 4      ^8X  d   W ^ ,          V P                  ^,          ,           8X  dc   \        V P                  ^,          4      p\        V P                  V P                  V4      p\        V 4      P                  W0P                  R7      # \        SV `5  W4      # )r   rU   r   )r   r   r   r?   r/   r   rX   rl   r@   r-   r^   r.   r   insert)rJ   r  itemr  r_   r/   r   s   &&&   r4   r  RangeIndex.insert  s   dx~~ 4yA~#(z$/?/?TYY&6		BDz--gJJ-GGTkk!8Q$))(; ;#CII$8#((CHHMG:11'

1KKCI%$r(TYY2F*F#CIIsxx#((/BCHHMG:11'

1KKY!^Q$))a-0G(Gtyy1}-D#DJJ		4@G:11'

1KKw~c((r6   c               $    V ^8  d   QhRRRRRR/# )r,   indexeszlist[Index]rR   r   r1   r    r2   )r3   s   "r4   r5   rD     s&     S3 S3{ S3( S3u S3r6   c                  < \         ;QJ d    R V 4       F  '       d   K   RM	  RM! R V 4       4      '       gH   \        SV `	  W4      pVP                  P                  R8X  d   V P                  VP                  4      # V# \        V4      ^8X  d
   V^ ,          # \        \        \        ,          V4      pR;p;rg. pRp	Rp
V FJ  p\        V4      '       g   K  VP                  V4       V	'       g   K1  V
e   V
P                  V4      p	KH  Tp
KL  	  V EF  pVP                  pVf.   VP                  pVf   \        V4      ^8  d   VP                  pMVf   VP                  V8X  d   V	'       d3   \         P"                  ! V^ ,          P                  \        V4      4      pM/\         P$                  ! V Uu. uF  qP                  NK  	  up4      pV P'                  VRR7      pVP)                  V4      u # VP                  V,
          pWlP                  8g  ;'       d    \        V4      ^8  ;'       g    VRJ;'       d    VP                  V8g  pV'       d   V	'       d3   \         P"                  ! V^ ,          P                  \        V4      4      pM/\         P$                  ! V Uu. uF  qP                  NK  	  up4      pV P'                  VRR7      pVP)                  V4      u # Vf   EK  VR,          V,           pEK  	  V'       dK   Vf   VR,          P*                  MTp\        V4      ^8X  d   V^ ,          P                  p\        VVWbR7      # \        \,        VR7      # u upi u upi )	a[  
Overriding parent method for the case of all RangeIndex instances.

When all members of "indexes" are of type RangeIndex: result will be
RangeIndex if possible, Index with an int64 dtype otherwise. E.g.:
indexes = [RangeIndex(3), RangeIndex(3, 6)] -> RangeIndex(6)
indexes = [RangeIndex(3), RangeIndex(4, 6)] -> Index([0,1,2,4,5], dtype='int64')
c              3  B   "   T F  p\        V\        4      x  K  	  R # 5irF   )rW   r=   r   r   s   & r4   r   %RangeIndex._concat.<locals>.<genexpr>  s     >g:a,,gs   FTr  NrP   rU   r   )allr   _concatrN   r  r  rB   r   r   r  r=   r   rk  r@   r-   r/   r   tileconcatenater{   r  r^   r  )rJ   r  rR   rp   rng_indexesr-   r/   next_non_empty_indexesall_same_indexprevobjr_   ri   r   non_consecutiver^   r   s   &&&              r4   r  RangeIndex._concat  s    s>g>sss>g>>>W_W3F||  C'))&..99M\Q1:4
+W5### "&C3xx!((-!>')-S)9"  %C**C}		<CHqL88D99%%!#-a088#>O:P" "$K0PKqK0P!Q!..vE.BF!==..yy5(#xx/@@CHqL  T!88cii5&8  !WW)!,44c:K6LF  ^^,L1YY,LMF**6*>}}T**B$I %L  27$R(--ED$%*(+00eT4;; ,T22A 1Q -Ms   8M)
)M.
c                   V ^8  d   QhRR/# r   r2   )r3   s   "r4   r5   rD     s          r6   c                ,    \        V P                  4      # )z%
return the length of the RangeIndex
)r   r@   rI   s   &r4   __len__RangeIndex.__len__  s     4;;r6   c                   V ^8  d   QhRR/# r   r2   )r3   s   "r4   r5   rD     s      c r6   c                	    \        V 4      # rF   )r   rI   s   &r4   sizeRangeIndex.size  s    4yr6   c           	     F  < \         P                  ! V4      pV\        J d   \        R4      p\	        V\        4      '       d   V P                  V4      # \        V4      '       d    \        V4      p V P                  V,          # \        V4      '       d   \        R4      h\        P                  ! V4      '       d   \	        \        VRR4      \        4      '       d   VP!                  \"        RR7      pM\$        P&                  ! V\"        R7      p\)        V P                  V4       \$        P*                  ! V4      p V P-                  V4      #   \         d!   p\        RT R\        T 4       24      ThRp?ii ; i  \.        \0        3 d    \2        ST `i  T4      u # i ; i)	z5
Conserve RangeIndex type for scalar and slice keys.
Nindex ' is out of bounds for axis 0 with size zuonly integers, slices (`:`), ellipsis (`...`), numpy.newaxis (`None`) and integer or boolean arrays are valid indicesrN   F)rN   na_valuer   )r   item_from_zerodimEllipsisr  rW   _getitem_slicer   r.   r@   
IndexErrorr   r   rY   is_bool_indexerr   r   to_numpyrQ   r   r   r   flatnonzerotaker[   r\   r   __getitem__)rJ   r   r   r   r   s   &&  r4   r  RangeIndex.__getitem__  s\    ##C((?+Cc5!!&&s++__#hG{{7++
 s^^+    %%'#w5~FFlll>jjD1S1..%C	,99S>!'   SE!HTT( :& 	,7&s++	,s*   1E >E= E:E55E:= F F c                    V ^8  d   QhRRRR/# )r,   slobjr  r1   r   r2   )r3   s   "r4   r5   rD      s     < <E <d <r6   c                r    V P                   V,          p\        V 4      P                  W P                  R7      # )z8
Fastpath for __getitem__ when we know we have a slice.
rU   )r@   r   rX   rl   )rJ   r  ress   && r4   r  RangeIndex._getitem_slice   s.     kk% Dz%%c

%;;r6   __floordiv__c                	\  < \        V4      '       Ed   V^ 8w  Ed   \        V 4      ^ 8X  g1   V P                  V,          ^ 8X  d   V P                  V,          ^ 8X  dr   V P                  V,          pV P                  V,          pV\        V 4      V,          ,           p\	        Y$T;'       g    ^4      pV P                  WPP                  R7      # \        V 4      ^8X  dC   V P                  V,          p\	        W"^,           ^4      pV P                  WPP                  R7      # \        SV `!  V4      # r   rU   )	r   r   r-   r/   r?   rX   rl   r   r  )rJ   ri  r-   r/   r^   r  r   s   &&    r4   r  RangeIndex.__floordiv__'  s    e!4yA~$**u"4"9dii%>OST>T

e+yyE)s4y4//!%tyyq9	''	

'CC4yA~

e+!%A6	''	

'CCw#E**r6   c                   V ^8  d   QhRR/# r   r2   )r3   s   "r4   r5   rD   :  s     $ $d $r6   c                	     ^ V P                   9  # r   r  rJ   r=  r>  s   &*,r4   r  RangeIndex.all:  s    ##r6   c                   V ^8  d   QhRR/# r   r2   )r3   s   "r4   r5   rD   =  s        d  r6   c                	,    \        V P                  4      # rF   )anyr@   r  s   &*,r4   r  RangeIndex.any=  s    4;;r6   c                    V ^8  d   QhRRRR/# )r,   decimalsr.   r1   Self | Indexr2   )r3   s   "r4   r5   rD   D  s      4  4c  4,  4r6   c                   < V^ 8  d   V P                  4       # V P                  ^
V) ,          ,          ^ 8X  d1   V P                  ^
V) ,          ,          ^ 8X  d   V P                  4       # \        SV `  VR7      # )ak  
Round each value in the Index to the given number of decimals.

Parameters
----------
decimals : int, optional
    Number of decimal places to round to. If decimals is negative,
    it specifies the number of positions to the left of the decimal point
    e.g. ``round(11.0, -1) == 10.0``.

Returns
-------
Index or RangeIndex
    A new Index with the rounded values.

Examples
--------
>>> import pandas as pd
>>> idx = pd.RangeIndex(10, 30, 10)
>>> idx.round(decimals=-1)
RangeIndex(start=10, stop=30, step=10)
>>> idx = pd.RangeIndex(10, 15, 1)
>>> idx.round(decimals=-1)
Index([10, 10, 10, 10, 10], dtype='int64')
)r  )rP   r-   r/   r   round)rJ   r  r   s   &&r4   r"  RangeIndex.roundD  sb    4 q=99;ZZ"xi-'1,R(]1Ja1O99;7=(=33r6   c                	   < \        V\        4      '       d+   V P                  VP                  8X  d   \        SV `  W4      # \        SV `  W4      # rF   )rW   r=   r@   r   _cmp_method)rJ   ri  opr   s   &&&r4   r%  RangeIndex._cmp_methodf  s?    eZ((T[[ELL-H7&t00w"5--r6   c           	     $  < \        V\        4      '       d   \        # \        V\        \        P
                  34      '       d   \        SV `  W4      # \        P                  ! \        VRR4      R4      '       d   \        SV `  W4      # V\        P                  \        P                  \        P                  \        P                   \        P"                  \        P$                  \&        \        P(                  39   d   \        SV `  W4      # RpV\        P*                  \        P,                  \        P.                  \        P0                  39   d   Tp\3        VRRR7      pT p V'       d\   \        P4                  ! RR7      ;_uu_ 4        V! VP6                  V4      pRRR4       \9        X4      '       d	   V'       g   \:        hM.V\        P<                  8X  d   VP6                  ) MVP6                  p\        P4                  ! RR7      ;_uu_ 4        V! VP>                  V4      pV! VP@                  V4      pRRR4       \        PB                  ! W4      p	\E        V 4      ! XXWiR7      p
\F        ;QJ d    R	 WxV3 4       F  '       d   K   R
M	  RM! R	 WxV3 4       4      '       g   V
PI                  R4      p
V
#   + '       g   i     EL(; i  + '       g   i     L; i  \:        \J        \L        3 d    \        ST `  Y4      u # i ; i)za
Parameters
----------
other : Any
op : callable that accepts 2 params
    perform the binary op
rN   NmT)extract_numpyextract_rangeignore)r  rU   c              3  8   "   T F  p\        V4      x  K  	  R # 5irF   )r   r  s   & r4   r   +RangeIndex._arith_method.<locals>.<genexpr>  s     E.Dz!}}.Ds   Fr  )'rW   r   NotImplementedr   r   timedelta64r   _arith_methodr   is_np_dtyper   operatorpowr   rpowmodrmodfloordiv	rfloordivdivmodrdivmodmulrmultruedivrtruedivr   errstater/   r   r\   rsubr-   r^   r  r   r  astyper[   ZeroDivisionError)rJ   ri  r&  r/   r  r  rsteprstartrstopr  rp   r   s   &&&        r4   r1  RangeIndex._arith_methodl  s:    e.//!!	2>>:;; 7(33__WUGT:C@@7(33LLHHLLHHMMKK	
 	
 7(33 $(,,(*:*:CLLIID e4tL 	4[[X.. E2E /
 "%(($$ 16
 ')CHHn
$))**DJJ.499e, + --d:H$ZuDF
 3Eve.DE333Eve.DEEEy1M3 /.. +* I'89 	47(33	4sV   &'K' K ! K' AK' 'K=AK' K' -K'  K		K' K$	K' '%LLc                   V ^8  d   QhRR/# )r,   r1   r   r2   )r3   s   "r4   r5   rD     s     % % %r6   c                	   < \        V 4      ^ 8X  g   V P                  4       ^ 8  d   V P                  4       # V P                  4       ^ 8:  d   V ) # \        SV `  4       # r   )r   r/  rP   r   r   __abs__)rJ   r   s   &r4   rJ  RangeIndex.__abs__  sG    t9>TXXZ1_99;XXZ1_5L7?$$r6   c                   V ^8  d   QhRR/# r  r2   )r3   s   "r4   r5   rD     s     5 5 5r6   c                	    \        V P                  ) V P                  ) V P                  ) 4      pV P	                  WP
                  R 7      # r  )r?   r-   r^   r/   rX   rR   r   s   & r4   __neg__RangeIndex.__neg__  s:    TZZK$))diiZ8))44r6   c                   V ^8  d   QhRR/# r  r2   )r3   s   "r4   r5   rD     s       r6   c                	"    V P                  4       # rF   r  rI   s   &r4   __pos__RangeIndex.__pos__  s    yy{r6   c                   V ^8  d   QhRR/# r  r2   )r3   s   "r4   r5   rD     s     5 5D 5r6   c                	    \        V 4      ^ 8X  d   V P                  4       # \        V P                  ( V P                  ( V P
                  ) 4      pV P                  WP                  R7      # r  )r   rP   r?   r-   r^   r/   rX   rR   r   s   & r4   
__invert__RangeIndex.__invert__  sQ    t9>99;TZZK$))diiZ8))44r6   c               $    V ^8  d   QhRRRRRR/# )r,   r<  r#   
allow_fillrQ   r1   r   r2   )r3   s   "r4   r5   rD     s*     &9 &9 &9 	&9 
&9r6   c                	.   V'       d   \         P                  ! RV4       \        V4      '       d   \        R 4      h\	        V4      pV P                  W4V4       \        V4      ^ 8X  d"   \        V 4      ! \        V P                  R7      # VP                  4       pV\        V 4      8  d   \        RV R\        V 4       24      hVP                  4       pV\        V 4      ) 8  d   \        RV R\        V 4       24      hVP                  V P                  RR7      pV^ 8  d   V\        V 4      ,          pV P                  ^8w  d   WP                  ,          pV P                   ^ 8w  d   WP                   ,          pV P#                  WP                  R7      # )z!Expected indices to be array-likerU   r   r  safe)castingr2   )r8  validate_taker   r[   r   _maybe_disallow_fillr   r   r  rR   r   r  r/  rB  rN   r/   r-   r  )	rJ   indicesr<  rY  
fill_valuer>  ind_maxind_mintakens	   &&&&&,   r4   r
  RangeIndex.take  sV    R(W?@@%g. 	!!*'Bw<1:l;;kkmG#d)# WI%LSQUYKX  kkmG#d)# WI%LSQUYKX  NN4::vN>E{T"yyA~"zzQ#!!%ii!88r6   c          
     ,    V ^8  d   QhRRRRRRRRRR/# )r,   	normalizerQ   ra  rZ  dropnar1   r*   r2   )r3   s   "r4   r5   rD     s<     : :: : 	: : 
:r6   c                	  < ^ RI Hp Ve   \        S	V `  VVVVVR7      # V'       d   RMRp\        P
                  ! \        V 4      \        P                  R7      pV'       d   V\        V 4      ,          pV! WP                  4       VR7      # )r   r)   )rf  ra  rZ  binsrg  
proportioncountr   )r   rR   )	r;   r*   r   value_countsr   onesr   r   rP   )
rJ   rf  ra  rZ  ri  rg  r*   rR   rc   r   s
   &&&&&&   r4   rl  RangeIndex.value_counts  s     	"7'## (    )|gIKIRXXJ
 #d)#Dd))+D99r6   c               $    V ^8  d   QhRRRRRR/# )r,   sidezLiteral['left', 'right']sorterzNumpySorter | Noner1   znpt.NDArray[np.intp] | np.intpr2   )r3   s   "r4   r5   rD     s*     !2 !2 '!2 #	!2
 
(!2r6   c                	n  < VR9  g   Ve   \         SV `  WVR7      # Rp\        V4      '       d   Rp\        P                  ! V.4      pM\        P
                  ! V4      pVP                  P                  R9  d   \         SV `  WVR7      # V P                  ^ 8  ;p'       d5   V P                  RRR	1,          pVP                  pVP                  p	VR8H  p
MV P                  pV P                  p	VR 8H  p
WX,
          \        V
4      ,
          V	,          ^,           pV'       d   \        V 4      V,
          p\        P                  ! \        P                  ! V\        V 4      4      ^ 4      pV'       d%   \        P                  ! VP!                  4       4      # VP#                  \        P                  RR7      # )
r  r  N)valuerp  rq  FTiur  >   r  r  r   )r   searchsortedr   r   arrayr   rN   r  r/   r@   r-   r.   r   maximumminimumr]  r  rB  )rJ   rs  rp  rq  
was_scalararray_valueflipr_   r-   r/   shiftrp   r   s   &&&&        r4   ru  RangeIndex.searchsorted  sY    ((F,>7'ev'NN
UJ((E7+K**U+K!!-7'ev'NNIIM"4"++dd#CIIE88DGOEJJE99DFNE%E
2t;a?Y'FBJJvs4y91=776;;=))}}RWW5}11r6   r2   )NNNNFN)NNrF   r   )NNN)NFr  )FT)r  r   )r   TN)FTFNT)r  N)Vre   
__module____qualname____firstlineno____doc___typr   ru   __annotations__propertyrK   r`   classmethodrf   rX   rV   r   r{   r   r   r   r   r   r-   r^   r/   r   r   rN   r   r   r   r   r   r   r   r   r  r	  r   r  r  r   rP   r1  r/  r   rI  rP  rV  r^  rf  rk  r   rs  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r"   r  r  r  r"  r%  r1  rJ  rN  rR  rV  r
  rl  ru  __static_attributes____classcell__)r   s   @r4   r=   r=   M   s   :x D"9;K!LM$ $"/H +0 +0`      
 K KN
7D ! !6    6    B 
 
2     6 6 6 6"  6p) )<  !( 6@ @:
M M
&P1##< <2@@;<% %  *- 	
 #&  #  3 	3
 #&3  #3 3 :  #: 	:
 #&:  #: :!   %!  	! 
 #)!   $!  ! L&+ &+P#"	GI0 I0VUn > >!& !&N# #,) )2S3 S3j   ",H< n-+ .+$$  4  4D.H4T% %55&9P: :4!2 !2 !2r6   r=   )M
__future__r   collections.abcr   r   r   datetimer   r3  sysr   typingr	   r
   r   r   r   r   numpyr   pandas._libsr   rG   r   pandas._libs.libr   pandas.compat.numpyr   r8  pandas.util._decoratorsr   r   pandas.core.dtypes.baser   pandas.core.dtypes.commonr   r   r   r   r   r   pandas.core.dtypes.genericr   pandas.corer   pandas.core.commoncorecommonrY   pandas.core.constructionr   pandas.core.indexersr   pandas.core.indexes.baser  baser   r    r!   pandas.core.ops.commonr"   pandas._typingr#   r$   r%   r&   r'   r(   r;   r*   r?   r  rN   r   r   r:   r=   r2   r6   r4   <module>r     s    " 
      ( .
 3  9      2 4 ( ( <  Qxxx!( Hb2 b2 b2r6   