
    MhW                       S SK Jr  S SKJrJr  S SKJr  S SKrS SKJ	r	  S SK
JrJrJrJrJrJr  S SKrS SKJrJr  S SKJr  S S	KJr  S S
KJr  S SKJrJ r J!r!  S SK"J#r#J$r$J%r%J&r&J'r'J(r(  S SK)J*r*  S SK+J,r,  S SK-J.s  J/r0  S SK1J2r2  S SK3J.s  J4s  J5r6  S SK3J7r7J8r8  S SK9J:r:  \(       a  S SK;J<r<J=r=J>r>J?r?J@r@  \A" S 5      rB\R                  " \R                  5      rE " S S\75      rFg)    )annotations)HashableIterator)	timedeltaN)	getsizeof)TYPE_CHECKINGAnyCallableLiteralcastoverload)indexlib)unique_deltas)
no_default)function)cache_readonlydeprecate_nonkeyword_argumentsdoc)ensure_platform_intensure_python_intis_float
is_integer	is_scalaris_signed_integer_dtype)ABCTimedeltaIndex)ops)extract_array)Indexmaybe_extract_name)unpack_zerodim_and_defer)AxisDtype
NaPositionSelfnptc                    ^  \ rS rSr% SrSr\S4rS\S'   S\S'   \	SNS	 j5       r
      SO       SPS
 jjr\SQSRS jj5       r\ SS     STS jj5       r\SUS j5       r\SVS j5       r\SWS j5       rSXS jrS rS rSYS jr\	SZS j5       r\	SZS j5       r\	SZS j5       r\SZS j5       rS[S\S jjr\	S]S j5       r\	S^S j5       r\S^S j5       r\S^S j5       rS_S jr \	S`S j5       r!\"" \#RH                  5      SZS j5       r$   Sa       SbU 4S  jjjr%\S^S! j5       r&ScS" jr'\"" \#RP                  5      SdS# j5       r(\"" \#RR                  5      \*4SeS$ jj5       r)SfS% jr+\"" \#RX                  5      SgShS& jj5       r,SiS' jr-SjSkS( jjr.SjSkS) jjr/SlS* jr0  Sm     SnS+ jjr1SoU 4S, jjr2\3S-S-S-S-S..         SpS/ jj5       r4\3S-S-S-S0.         SqS1 jj5       r4\3S-S-S-S-S..         SrS2 jj5       r4\5" S3S4/S5S69    Ss         SrU 4S7 jjj5       r4S[StU 4S8 jjjr6SuS9 jr7SvS: jr8SwS; jr9SxU 4S< jjr:SSU 4S= jjr; SQ SyU 4S> jjjr<SzU 4S? jjr=S{U 4S@ jjr>S|U 4SA jjr?SZSB jr@\	SZSC j5       rAU 4SD jrBS}SE jrC\D" SF5      U 4SG j5       rES^SH jrFS^SI jrGU 4SJ jrHU 4SK jrI   S~     SSL jjrJSMrKU =rL$ )
RangeIndexB   a  
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 (default: 0), range, or other RangeIndex instance
    If int and "stop" is not given, interpreted as "stop" instead.
stop : int (default: 0)
step : int (default: 1)
dtype : np.int64
    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                "    [         R                  $ N)libindexInt64Engineselfs    K/var/www/html/env/lib/python3.13/site-packages/pandas/core/indexes/range.py_engine_typeRangeIndex._engine_type   s    ###    c                   U R                  U5        [        XaU 5      n[        X5      (       a  UR                  US9$ [        U[        5      (       a  U R                  XS9$ [        R                  " XU5      (       a  [        S5      eUb  [        U5      OSnUc  SUp!O[        U5      nUb  [        U5      OSnUS:X  a  [        S5      e[	        XU5      nU R                  XvS9$ )Nnamez,RangeIndex(...) must be called with integersr      zStep must not be zero)_validate_dtyper    
isinstancecopyr+   _simple_newcomall_none	TypeErrorr   
ValueError)clsstartstopstepdtyper?   r;   rngs           r5   __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..r8   c                    [        U[        5      (       d$  [        U R                   S[	        U5       S35      eU R                  U5        U R                  XS9$ )a  
Create :class:`pandas.RangeIndex` from a ``range`` object.

Returns
-------
RangeIndex

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 passedr:   )r>   r+   rC   __name__reprr=   r@   )rE   datar;   rI   s       r5   
from_rangeRangeIndex.from_range   s]    " $&&<<. !t*[2  	E"t//r8   c                    [         R                  U 5      n[        U[        5      (       d   eXl        X#l        0 Ul        UR                  5         S Ul        U$ r0   )	objectrK   r>   r+   r,   _name_cache_reset_identity_references)rE   valuesr;   results       r5   r@   RangeIndex._simple_new   sO     $&%(((( !r8   c                d    Uc  g U R                   u  p#U" U5      (       d  [        SU SU 35      eg )Nz#Incorrect `dtype` passed: expected z, received )_dtype_validation_metadatarD   )rE   rI   validation_funcexpecteds       r5   r=   RangeIndex._validate_dtype   sE    =$'$B$B!u%%5hZ{5'R  &r8   c                    [         $ )z(return the class to use for construction)r   r3   s    r5   _constructorRangeIndex._constructor   s	     r8   c                    [         R                  " U R                  U R                  U R                  [         R
                  S9$ )zw
An int array that for performance reasons is created only when needed.

The constructed array is saved in ``_cache``.
rI   )nparangerF   rG   rH   int64r3   s    r5   _dataRangeIndex._data   s)     yyTYY		JJr8   c                l    U R                   nSUR                  4SUR                  4SUR                  4/$ )z,return a list of tuples of start, stop, steprF   rG   rH   )r,   rF   rG   rH   r4   rJ   s     r5   _get_data_as_itemsRangeIndex._get_data_as_items   s3    kk#))$vsxx&86388:LMMr8   c                    SU R                   0nUR                  [        U R                  5       5      5        [        R
                  [        U 5      U4S 4$ )Nr;   )rU   updatedictrm   ibase
_new_Indextype)r4   ds     r5   
__reduce__RangeIndex.__reduce__   sE    TZZ 	d--/01$t*a$66r8   c                    [        SU R                  5       5      nU R                  b1  UR                  S[        R
                  " U R                  5      45        U$ )z8
Return a list of tuples of the (attr, formatted_value)
zlist[tuple[str, str | int]]r;   )r   rm   rU   appendrr   default_pprint)r4   attrss     r5   _format_attrsRangeIndex._format_attrs  sI     2D4K4K4MN::!LL&%"6"6tzz"BCDr8   c               &   [        U R                  5      (       d  U$ [        U R                  S   5      n[        U R                  S   5      n[        [        U5      [        U5      5      nXR                   Vs/ s H	  ofSU 3 PM     sn-   $ s  snf )Nr   <)lenr,   strmax)r4   headerna_repfirst_val_strlast_val_str
max_lengthxs          r5   _format_with_headerRangeIndex._format_with_header  s{    4;;MDKKN+4;;r?+]+S->?
{{C{!a
|^,-{CCCCs   9Bc                .    U R                   R                  $ )z
The value of the `start` parameter (``0`` if this was not supplied).

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

>>> idx = pd.RangeIndex(2, -10, -3)
>>> idx.start
2
)r,   rF   r3   s    r5   rF   RangeIndex.start  s      {{   r8   c                .    U R                   R                  $ )z
The value of the `stop` parameter.

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

>>> idx = pd.RangeIndex(2, -10, -3)
>>> idx.stop
-10
)r,   rG   r3   s    r5   rG   RangeIndex.stop*  s     {{r8   c                .    U R                   R                  $ )a<  
The value of the `step` parameter (``1`` if this was not supplied).

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,   rH   r3   s    r5   rH   RangeIndex.step;  s    . {{r8   c                ^   ^ U R                   m[        T5      [        U4S jS 5       5      -   $ )z4
Return the number of bytes in the underlying data.
c              3  N   >#    U  H  n[        [        TU5      5      v   M     g 7fr0   )r   getattr).0	attr_namerJ   s     r5   	<genexpr>$RangeIndex.nbytes.<locals>.<genexpr>Z  s'      $
6	 gc9-..6s   "%)rF   rG   rH   )r,   r   sumrl   s    @r5   nbytesRangeIndex.nbytesT  s3    
 kk~ $
6$
 !
 
 	
r8   c                    U R                   $ )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   )r4   deeps     r5   memory_usageRangeIndex.memory_usage_  s    . {{r8   c                    [         $ r0   )_dtype_int64r3   s    r5   rI   RangeIndex.dtypex  s    r8   c                    g)z%return if the index has unique valuesT r3   s    r5   	is_uniqueRangeIndex.is_unique|  s     r8   c                ^    U R                   R                  S:  =(       d    [        U 5      S:*  $ Nr   r<   r,   rH   r   r3   s    r5   is_monotonic_increasing"RangeIndex.is_monotonic_increasing  $    {{!#5s4yA~5r8   c                ^    U R                   R                  S:  =(       d    [        U 5      S:*  $ r   r   r3   s    r5   is_monotonic_decreasing"RangeIndex.is_monotonic_decreasing  r   r8   c                l    [        U5         [        U5      nXR                  ;   $ ! [         a     gf = fNF)hashr   rC   r,   )r4   keys     r5   __contains__RangeIndex.__contains__  s;    S		#C(C kk!!  		s   & 
33c                    g)Nintegerr   r3   s    r5   inferred_typeRangeIndex.inferred_type  s    r8   c                n   [        U5      (       d%  [        U5      (       a<  UR                  5       (       a'  [        U5      n U R                  R	                  U5      $ [        U[        5      (       a  [        U5      eU R                  U5        [        U5      e! [
         a  n[        U5      UeS nAff = fr0   )
r   r   intr,   r   rD   KeyErrorr>   r   _check_indexing_error)r4   r   new_keyerrs       r5   get_locRangeIndex.get_loc  s    c??x}}1A1A#hG-{{((11 c8$$3-""3'sm  -sm,-s   B 
B4#B//B4c                  > [         R                  " X$U5      (       a  [        TU ]  XXCS9$ U R                  S:  a$  U R
                  U R                  U R                  pvnO5U R                  S S S2   nUR
                  UR                  UR                  pvn[        R                  " U5      n	X-
  n
X-  S:H  U
S:  -  X:  -  nSX) '   X   U-  X'   XpR                  :w  a  [        U 5      S-
  X   -
  X'   [        U
5      $ )N)method	tolerancelimitr   r   r<   )rA   any_not_nonesuper_get_indexerrH   rF   rG   r,   rf   asarrayr   r   )r4   targetr   r   r   rF   rG   rH   reversetarget_arraylocsvalid	__class__s               r5   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((r8   c                    g)z1
Should an integer key be treated as positional?
Fr   r3   s    r5   _should_fallback_to_positional)RangeIndex._should_fallback_to_positional  s    
 r8   c                ,    [        U R                  5      $ r0   )listr,   r3   s    r5   tolistRangeIndex.tolist  s    DKK  r8   c              #  8   #    U R                    S h  vN   g  N7fr0   r,   r3   s    r5   __iter__RangeIndex.__iter__  s     ;;s   c                r   U[         L a  U R                  OUnUR                  R                  S:X  a  [	        X[
        R                  S9$ [        U5      n[        U5      S:X  a<  US   S:w  a3  US   n[        US   US   U-   U5      n[        U 5      R                  XRS9$ U R                  R                  XS9$ )Nf)r;   rI   r<   r   r   r:   )r   rU   rI   kindr   rf   float64r   r   r+   rt   r@   rb   )r4   rY   r;   unique_diffsdiff	new_ranges         r5   _shallow_copyRangeIndex._shallow_copy  s    !Z/tzzT<<#"**== %V,|!l1o&:?DfQid):DAI:))))??$$000CCr8   c                    [        U 5      R                  U R                  U R                  S9nU R                  Ul        U$ )Nr:   )rt   r@   r,   rU   rV   )r4   rZ   s     r5   _viewRangeIndex._view  s3    d''$**'Er8   c                H    U R                  XS9S   nU R                  US9nU$ )N)r;   r   r   r:   )_validate_names_rename)r4   r;   r   	new_indexs       r5   r?   RangeIndex.copy  s0    ###9!<LLdL+	r8   c                    [        U 5      S-
  nUS:X  a  [        R                  $ US:X  a  U R                  S:  d  US:X  a  U R                  S:  a  U R                  $ U R                  U R                  U-  -   $ )Nr<   r   minr   r   )r   rf   nanrH   rF   )r4   methno_stepss      r5   _minmaxRangeIndex._minmax  sc    t9q=r>66Mem		A45=TYYQR]::zzDII000r8   c                |    [         R                  " U5        [         R                  " X45        U R                  S5      $ )z#The minimum value of the RangeIndexr   )nvvalidate_minmax_axisvalidate_minr   r4   axisskipnaargskwargss        r5   r   RangeIndex.min  +    
%
%||E""r8   c                |    [         R                  " U5        [         R                  " X45        U R                  S5      $ )z#The maximum value of the RangeIndexr   )r   r   validate_maxr   r   s        r5   r   RangeIndex.max  r   r8   c                   UR                  SS5      nUR                  SS5        [        R                  " X5        U R                  R                  S:  a-  [
        R                  " [        U 5      [
        R                  S9nO1[
        R                  " [        U 5      S-
  SS[
        R                  S9nU(       d  USSS2   nU$ )	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   re   r<   r   )	popr   validate_argsortr,   rH   rf   rg   r   intp)r4   r   r   r  rZ   s        r5   argsortRangeIndex.argsort  s     JJ{D1	

64 
D);;aYYs4y8FYYs4y1}b"BGGDFDbD\Fr8   c                    [         R                  " [        U 5      [         R                  S9nU nU(       a   U R                  S:  a  US S S2   nUS S S2   nX44$ )Nre   r   r   )rf   rg   r   r  rH   )r4   sortuse_na_sentinelcodesuniquess        r5   	factorizeRangeIndex.factorize  sP    
 		#d)2773DIIM$B$KEddmG~r8   c                ~   > [        U[        5      (       a  U R                  UR                  :H  $ [        TU ]  U5      $ )z<
Determines if two Index objects contain the same elements.
)r>   r(   r,   r   equals)r4   otherr   s     r5   r  RangeIndex.equals)  s4     eZ((;;%,,..w~e$$r8   .return_indexerr  na_positionr   c                   g r0   r   r4   r  r  r  r   s        r5   sort_valuesRangeIndex.sort_values2       	r8   )r  r  r   c                   g r0   r   r  s        r5   r  r  =  r  r8   c                   g r0   r   r  s        r5   r  r  H  r  r8   z3.0r4   r  )versionallowed_argsr;   c                @  > Ub  [         TU ]  UUUUS9$ U nSnU(       a  U R                  S:  a
  U S S S2   nSnOU R                  S:  a
  U S S S2   nSnU(       aB  U(       a  [        [	        U 5      S-
  SS5      nO[        [	        U 5      5      nU[        U5      4$ U$ )Nr  Fr   r   Tr<   )r   r  rH   r+   r   r(   )	r4   r  r  r  r   sorted_indexinverse_indexerrJ   r   s	           r5   r  r  S  s     ?7&-#'	 '    L#O99q=#'":L&*O99q=#'":L&*OCIM2r2CI&C00r8   c                ~  > [        U[        5      (       d  [        TU ]  XS9$ U R                  S:  a  U R
                  S S S2   OU R
                  nUR                  S:  a  UR
                  S S S2   OUR
                  n[        UR                  UR                  5      n[        UR                  UR                  5      nXe::  a  U R                  [        5      $ U R                  UR                  UR                  5      u  pxn	UR                  UR                  -
  U-  (       a  U R                  [        5      $ UR                  UR                  UR                  -
  UR                  -  U-  U-  -   n
UR                  UR                  -  U-  n[        XU5      nU R                  U5      nUR                  U5      n[        XR                  UR                  5      nU R                  U5      nU R                  S:  =(       a    UR                  S:  UR                  S:  La  US S S2   nUc  UR                  5       nU$ )Nr
  r   r   )r>   r(   r   _intersectionrH   r,   r   rF   r   rG   r@   _empty_range_extended_gcdr+   _min_fitting_elementr  )r4   r  r
  firstsecondint_lowint_highgcds_	tmp_startnew_stepr   r   	new_startr   s                  r5   r%  RangeIndex._intersection|  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)x8	$$Y/	 227;	)^^Y^^D	$$Y/	IIM,ejj1ninnq6HI!$B$I<!--/Ir8   c                    XR                   -
  * [        U R                  5      -  * nU R                   [        U R                  5      U-  -   $ )z?Returns the smallest element greater than or equal to the limit)rF   absrH   )r4   lower_limitr   s      r5   r(  RangeIndex._min_fitting_element  s=    "ZZ/0C		NBCzzC		NX555r8   c                p    Su  p4Su  pVX!pU(       a"  X-  n	XxX-  -
  pxX4X-  -
  p4XVX-  -
  pVU(       a  M"  XU4$ )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
)r   r<   )r<   r   r   )
r4   abr.  old_stold_trold_rquotients
             r5   r'  RangeIndex._extended_gcd  sY     5zH(,.1(,.1(,.1	 a
 U""r8   c                
   U(       d  gU R                   (       d  g[        U5      S:  a)  UR                  U R                   R                  -  (       a  gUR                  U R                   ;   =(       a    US   U R                   ;   $ )z)Check if other range is contained in selfTFr<   r   )r,   r   rH   rF   )r4   r  s     r5   _range_in_selfRangeIndex._range_in_self  s\     {{u:>ejj4;;+;+;;{{dkk)FeBi4;;.FFr8   c                  > [        U[        5      (       GaT  US;   d8  USL GaH  U R                  S:  Ga7  U R                  UR                  5      (       Ga  U R
                  U R                  pCU R
                  U R                  [        U 5      S-
  -  -   nUR
                  UR                  pvUR
                  UR                  [        U5      S-
  -  -   nU R                  S:  a  XT* UpTnUR                  S:  a  X* Upn[        U 5      S:X  a3  [        U5      S:X  a$  [        U R
                  UR
                  -
  5      =pGO#[        U 5      S:X  a  UnO[        U5      S:X  a  Un[        X65      n	[        XX5      n
Xt:X  a}  X6-
  U-  S:X  a%  X8-
  U::  a  Xe-
  U::  a  [        U 5      " XU-   U5      $ US-  S:X  aC  [        X6-
  5      US-  :X  a/  [        XX-
  5      US-  :X  a  [        U 5      " XUS-  -   US-  5      $ OqXt-  S:X  a1  Xc-
  U-  S:X  a%  Xd-   U:  a  X-
  U::  a  [        U 5      " XU-   U5      $ O8XG-  S:X  a0  X6-
  U-  S:X  a%  X7-   U:  a  XW-
  U::  a  [        U 5      " XU-   U5      $ [        TU ]1  XS9$ )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 a 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
NTFr   r<      r$  )r>   r(   rH   rC  r,   rF   r   r5  r   r   rt   r   _union)r4   r  r
  start_sstep_send_sstart_ostep_oend_ostart_rend_rr   s              r5   rH  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~//r8   c                  > U R                  U5        U R                  U5        U R                  U5      u  p[        U[        5      (       d  [
        T
U ]  XS9$ USLa'  U R                  S:  a  U S S S2   R                  U5      $ [        R                  " X5      nU R                  S:  a  U R                  S S S2   OU R                  nU R                  U5      nUR                  S:  a  US S S2   n[        U5      S:X  a  U R                  US9$ [        U5      [        U 5      :X  a  U S S R                  U5      $ [        U5      S:X  aR  US   U S   :X  a  U SS  $ US   U S   :X  a  U S S $ [        U 5      S:X  a  US   U S   :X  a  U S S S2   $ [
        T
U ]  XS9$ [        U5      S:X  a  US   US   :X  a  US   US   :X  a  U SS $ UR                  UR                  :X  a  US   UR                  :X  a2  [        US   UR                  -   UR                   UR                  5      nOUS   US   :X  a%  [        UR                  US   UR                  5      nOUR                  USS :X  a  [        U5      S-
  nUS S U2   nO[
        T
U ]  XS9$ [        U 5      S:  d   eUR                  UR                  S-  :X  aY  US   US   :X  a  US   US   US	   4;   a	  USS S2   nO@US   US   :X  a  US   US   US	   4;   a	  US S S2   nO[
        T
U ]  XS9$ [
        T
U ]  XS9$ [#        U 5      R%                  XtS9n	XPR                  La  U	S S S2   n	U	$ )
Nr$  Fr   r   r:   r<      rG  )_validate_sort_keyword_assert_can_do_setop_convert_can_do_setopr>   r(   r   _differencerH   r   get_op_result_namer,   intersectionr   renamerF   r+   rG   rt   r@   )r4   r  r
  result_nameres_namer)  overlapnew_rngrH   r   r   s             r5   rX  RangeIndex._difference  sr   ##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$ABxtBx'CRy TaGAJ$q'$9CaCy  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#ADqDkGQZ58+b	5QS9?U0U#CaCjG !7.u.@@ w*5*<<J**7*B	#!$B$Ir8   c                   > [        U[        5      (       a  Ub  [        TU ]  XU5      $ U R	                  U5      nUR	                  U 5      nUR                  U5      nUb  UR                  U5      nU$ r0   )r>   r(   r   symmetric_difference
differenceunionr[  )r4   r  r\  r
  leftrightrZ   r   s          r5   rb  RangeIndex.symmetric_differencem  sn     %,,0@7/DIIu%  &E""]];/Fr8   c                  > [        U5      (       aN  US[        U 5      * 4;   a  U SS  $ US[        U 5      S-
  4;   a  U S S $ [        U 5      S:X  a  US;   a  U S S S2   $ O[        R                  " U5      (       aj  [        R                  " [
        R                  " U[
        R                  S9[        U 5      5      n[        U[        5      (       a  X   nU R                  USS	9$ [        TU ]1  U5      $ )
Nr   r<   r   rS  )r<   rT  rG  re   Fr$  )r   r   r   is_list_likemaybe_indices_to_slicerf   r   r  r>   slicerc  r   delete)r4   locslcr  r   s       r5   rl  RangeIndex.delete  s     c??q3t9*o%ABxr3t9q=))CRy 4yA~#.CaCy c"",,RZZ277-KSQUYWC#u%% 	u599w~c""r8   c                  > [        U 5      (       Ga  [        U5      (       d  [        U5      (       Ga  U R                  nUS:X  ao  X S   U R                  -
  :X  aZ  [        UR                  UR                  -
  UR                  UR                  5      n[        U 5      R                  X@R                  S9$ U[        U 5      :X  ao  X S   U R                  -   :X  aZ  [        UR                  UR                  UR                  -   UR                  5      n[        U 5      R                  X@R                  S9$ [        U 5      S:X  as  X S   U R                  S-  -   :X  a[  [        U R                  S-  5      n[        U R                  U R                  U5      n[        U 5      R                  X@R                  S9$ [        TU ]5  X5      $ )Nr   r:   r   rG  )r   r   r   r,   rH   r+   rF   rG   rt   r@   rU   r   r   insert)r4   rm  itemrJ   r_  rH   r   s         r5   rq  RangeIndex.insert  sR   t99*T**htnn ++CaxDGdii$77		CHH 4chhIDz--gJJ-GGD	!d2h.B&B		388chh+>IDz--gJJ-GGTaDGdii!m,C$C499q=)

DIIt<Dz--gJJ-GGw~c((r8   c           	       > [        S U 5       5      (       d  [        TU ]	  X5      $ [        U5      S:X  a  US   $ [	        [
        [           U5      nS=n=pVU Vs/ s H  n[        U5      (       d  M  UPM     nnU GH_  nUR                  n	Uc+  U	R                  nUc  [        U	5      S:  a  U	R                  nOvUcs  U	R                  U:X  aT  [        R                  " U V
s/ s H  oR                  PM     sn
5      nU R                  U5      nUR                  U5      s  $ U	R                  U-
  nXYR                  :g  =(       a    [        U	5      S:  =(       d    USL=(       a    U	R                  U:g  nU(       aR  U R                  [        R                  " U V
s/ s H  oR                  PM     sn
5      5      nUR                  U5      s  $ Uc  GMW  U	S   U-   nGMb     U(       a/  Uc  US   R                  OUn[        XNU5      R                  U5      $ [        SS5      R                  U5      $ s  snf s  sn
f s  sn
f )aZ  
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 a 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   #    U  H  n[        U[        5      v   M     g 7fr0   )r>   r(   r   r   s     r5   r   %RangeIndex._concat.<locals>.<genexpr>  s     >g:a,,gs   r<   r   Nr   )allr   _concatr   r   r   r(   r,   rF   rH   rf   concatenater.   rb   r[  rG   )r4   indexesr;   rng_indexesrF   rH   next_objnon_empty_indexesrJ   r   rY   rZ   non_consecutiverG   r   s                  r5   ry  RangeIndex._concat  s    >g>>>7?711\Q1:4
+W5### -8DKS3s8SKD$C**C}		<CHqL88D99%^^,L1YY,LMF!..v6F!==..yy5(#xx/@CHqL T!8cii5&8  **NN{#C{!II{#CD }}T**B$7 %:  27$R(--EDe4077== !Q&&t,,O E -M $Ds   H34H3#H8
H=c                ,    [        U R                  5      $ )z%
return the length of the RangeIndex
)r   r,   r3   s    r5   __len__RangeIndex.__len__  s     4;;r8   c                    [        U 5      $ r0   )r   r3   s    r5   sizeRangeIndex.size  s    4yr8   c           	     T  > [        U[        5      (       a  U R                  U5      $ [        U5      (       a  [	        U5      n U R
                  U   $ [        U5      (       a  [        S5      e[        TU ])  U5      $ ! [         a   n[        SU S[        U 5       35      UeSnAff = f)z5
Conserve RangeIndex type for scalar and slice keys.
index ' is out of bounds for axis 0 with size Nzuonly integers, slices (`:`), ellipsis (`...`), numpy.newaxis (`None`) and integer or boolean arrays are valid indices)r>   rk  _getitem_slicer   r   r,   
IndexErrorr   r   r   __getitem__)r4   r   r   r   r   s       r5   r  RangeIndex.__getitem__  s     c5!!&&s++__#hG{{7++
 s^^+  w"3''   SE!HTTs   A= =
B'B""B'c                d    U R                   U   n[        U 5      R                  X R                  S9$ )z8
Fastpath for __getitem__ when we know we have a slice.
r:   )r,   rt   r@   rU   )r4   slobjress      r5   r  RangeIndex._getitem_slice  s.     kk% Dz%%c

%;;r8   __floordiv__c                  > [        U5      (       a  US:w  a  [        U 5      S:X  d&  U R                  U-  S:X  ap  U R                  U-  S:X  a]  U R                  U-  nU R                  U-  nU[        U 5      U-  -   n[	        X$U=(       d    S5      nU R                  XPR                  S9$ [        U 5      S:X  a7  U R                  U-  n[	        X"S-   S5      nU R                  XPR                  S9$ [        TU ]!  U5      $ )Nr   r<   r:   )	r   r   rF   rH   r+   r@   rU   r   r  )r4   r  rF   rH   rG   r   r   s         r5   r  RangeIndex.__floordiv__  s    e!4yA~e!3q!8TYY=NRS=S

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

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

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

'CCw#E**r8   c                     SU R                   ;  $ )Nr   r   r4   r   r   s      r5   rx  RangeIndex.all"  s    ##r8   c                ,    [        U R                  5      $ r0   )anyr,   r  s      r5   r  RangeIndex.any%  s    4;;r8   c                   > [        U[        5      (       a)  U R                  UR                  :X  a  [        TU ]  X5      $ [        TU ]  X5      $ r0   )r>   r(   r,   r   _cmp_method)r4   r  opr   s      r5   r  RangeIndex._cmp_method*  s?    eZ((T[[ELL-H7&t00w"5--r8   c           	       > [        U[        5      (       a  [        $ [        U[        [        R
                  45      (       a  [        TU ]  X5      $ [        R                  " [        USS5      S5      (       a  [        TU ]  X5      $ U[        R                  [        R                  [        R                  [        R                   [        R"                  [        R$                  [&        [        R(                  4;   a  [        TU ]  X5      $ SnU[        R*                  [        R,                  [        R.                  [        R0                  4;   a  Un[3        USSS9nU n U(       aN  [        R4                  " SS9   U" UR6                  U5      nSSS5        [9        W5      (       a  U(       d  [:        eO-U[        R<                  :X  a  UR6                  * OUR6                  n[        R4                  " SS9   U" UR>                  U5      nU" UR@                  U5      nSSS5        [        RB                  " X5      n	[E        U 5      " WWXiS9n
[G        S	 XxU4 5       5      (       d  U
RI                  S
5      n
U
$ ! , (       d  f       N= f! , (       d  f       Nr= f! [:        [J        [L        4 a    [        TU ]  X5      s $ f = f)za
Parameters
----------
other : Any
op : callable that accepts 2 params
    perform the binary op
rI   NmT)extract_numpyextract_rangeignore)rx  r:   c              3  8   #    U  H  n[        U5      v   M     g 7fr0   )r   rv  s     r5   r   +RangeIndex._arith_method.<locals>.<genexpr>q  s     E.Dz!}}.Ds   r   )'r>   r   NotImplementedr   rf   timedelta64r   _arith_methodr   is_np_dtyper   operatorpowr   rpowmodrmodfloordiv	rfloordivdivmodrdivmodmulrmultruedivrtruedivr   errstaterH   r   rD   rsubrF   rG   rY  rt   rx  astyperC   ZeroDivisionError)r4   r  r  rH   rf  re  rsteprstartrstopr]  rZ   r   s              r5   r  RangeIndex._arith_method0  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
 Eve.DEEEy1M3 /. +* I'89 	47(33	4sD   J 9I6A'J 4'JAJ 6
J J 
JJ $J?>J?c                   U(       a  [         R                  " SU5        [        U5      (       a  [        S5      e[	        U5      nU R                  X4U5        [        U5      S:X  a   [        R                  " / U R                  S9nOUR                  5       nU[        U 5      :  a  [        SU S[        U 5       35      eUR                  5       nU[        U 5      * :  a  [        SU S[        U 5       35      eUR                  U R                  SS9nUS:  a  U[        U 5      -  nU R                  S	:w  a  X`R                  -  nU R                  S:w  a  X`R                  -  nU R                   R#                  X`R$                  S
9$ )Nr   z!Expected indices to be array-liker   re   r  r  safe)castingr<   r:   )r   validate_taker   rC   r   _maybe_disallow_fillr   rf   arrayrI   r   r  r   r  rH   rF   rb   r@   r;   )	r4   indicesr   
allow_fill
fill_valuer   takenind_maxind_mins	            r5   takeRangeIndex.take|  s]    R(W?@@%g. 	!!*'Bw<1HHRtzz2EkkmG#d)# WI%LSQUYKX  kkmG#d)# WI%LSQUYKX  NN4::vN>E{T"yyA~"zzQ#   ,,U,CCr8   r   )returnztype[libindex.Int64Engine])NNNNFN)rI   Dtype | Noner?   boolr;   Hashable | Noner  r%   )NN)rP   r+   rI   r  r  r%   r0   )rY   r+   r;   r  r  r%   )rI   r  r  None)r  ztype[Index])r  r-   )r  zlist[tuple[str, int]])r   	list[str]r   r   r  r  )r  r   )F)r   r  r  r   )r  znp.dtype)r  r  )r   r	   r  r  )r  r   )NNN)r   r   r   z
str | Noner   z
int | Noner  npt.NDArray[np.intp])r  z	list[int])r  zIterator[int])r;   r   )r  r%   r   )r;   r  r   r  r  r%   )r   r   rF  )r   r  r  r   )r  r  )FT)r
  r  r  r  r  z'tuple[npt.NDArray[np.intp], RangeIndex])r  rT   r  r  )
r  zLiteral[False]r  r  r  r$   r   Callable | Noner  r%   )
r  zLiteral[True]r  r  r  r$   r   r  r  z$tuple[Self, np.ndarray | RangeIndex])
r  r  r  r  r  r$   r   r  r  z+Self | tuple[Self, np.ndarray | RangeIndex])FTlastN)r  r   r
  r  )r6  r   r  r   )r9  r   r:  r   r  ztuple[int, int, int])r  r+   r  r  )r  r   r
  zbool | None)r\  r  )r  r   )rm  r   r  r   )r{  zlist[Index]r;   r   r  r   )r  rk  r  r%   )r   TN)r   r"   r  r  r  r   )MrN   
__module____qualname____firstlineno____doc___typr   r]   __annotations__propertyr6   rK   classmethodrQ   r@   r=   r   rb   ri   rm   rv   r|   r   rF   rG   rH   r   r   rI   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r?   r   r   r   r  r  r  r   r  r   r%  r(  r'  rC  rH  rX  rb  rl  rq  ry  r  r  r  r  r!   r  rx  r  r  r  r  __static_attributes____classcell__)r   s   @r5   r(   r(   B   s   8t D"9;K!LM$ $ " $"/
 "/ "/ "/ 
"/H 0 06 48"1	     
 K KN
7D ! !"         0 
 
2     6 6 6 6"   	
 
 " )) ) 	) 
) )<  ! 	  			5? D D
 	_ 
1##8  $

 
 
1	
%  *-"%" ' 	
    
  
 "%" & 	
    
.    #"%"  	
    
5  $VH=
  %"(#! !  !   	! 
 !  
5! ! L, ,\6
#"	GI0VUp @D"1 $#,)*;-z   (.< n-+ .+$$ 
.H4^ 'D 'D 	'D 
'D 'Dr8   r(   )G
__future__r   collections.abcr   r   datetimer   r  sysr   typingr   r	   r
   r   r   r   numpyrf   pandas._libsr   r1   r   pandas._libs.algosr   pandas._libs.libr   pandas.compat.numpyr   r   pandas.util._decoratorsr   r   r   pandas.core.dtypes.commonr   r   r   r   r   r   pandas.core.dtypes.genericr   pandas.corer   pandas.core.commoncorecommonrA   pandas.core.constructionr   pandas.core.indexes.baser{  baserr   r   r    pandas.core.ops.commonr!   pandas._typingr"   r#   r$   r%   r&   r+   r&  rI   rh   r   r(   r   r8   r5   <module>r     s    "      - ' .   9      2 ( ( <  Qxxx!aD aDr8   