
    J/Ph߂                         d Z ddlZddlmZ  ej        dd          ZdZdZdZ ej        d	d
          Z	 ej        dd          Z
d Zd Zd ZdS )z
Timsort implementation.  Mostly adapted from CPython's listobject.c.

For more information, see listsort.txt in CPython's source tree.
    N)typesTimsortImplementation)compile	count_run
binarysortgallop_leftgallop_right
merge_initmerge_append	merge_popmerge_compute_minrunmerge_lomerge_himerge_atmerge_force_collapsemerge_collapserun_timsortrun_timsort_with_valuesU         
MergeState)
min_gallopkeysvaluespendingnMergeRun)startsizec                 Z  	
  |           t           j         d          | d             
| fd            | fd            | d             | d             | 
fd            | fd            | d	             | 
fd
            | fd            | fd            | fd            	| d             | 
fd            | 
fd            d| 	
fd            | 	
f	d            | 	fd            | fd            | fd            | 
fd            | fd            | fd            }| fd            }t          | 	||          S )Nr   c                 
    || uS N )r   r   s     R/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/numba/misc/timsort.py
has_valuesz%make_timsort_impl.<locals>.has_values?   s    T!!    c                     t          t          |           dz  dz   t                    } | |          }|}t                    gt          z  }t           t                    |||          S )z?
        Initialize a MergeState for a non-keyed sort.
              minlenMERGESTATE_TEMP_SIZEr   MAX_MERGE_PENDINGr   
MIN_GALLOP)r   	temp_size	temp_keystemp_valuesr   intpmake_temp_areazeros        r%   r
   z%make_timsort_impl.<locals>.merge_initC   sr    
 D		Q*,@AA	"N433	D$''(+<<$$z**I{GTRRRr'   c                     t          t          |           dz  dz   t                    } | |          } ||          }t                    gt          z  }t           t                    |||          S )z;
        Initialize a MergeState for a keyed sort.
        r)   r*   r+   )	r   r   r1   r2   r3   r   r4   r5   r6   s	         r%   merge_init_with_valuesz1make_timsort_impl.<locals>.merge_init_with_valuesN   s~    
 D		Q*,@AA	"N433	$nVY77D$''(+<<$$z**I{GTRRRr'   c                     | j         }|t          k     sJ || j        |<   t          | j        | j        | j        | j        |dz             S )z2
        Append a run on the merge stack.
        r*   )r   r/   r   r   r   r   r   )msrunr   s      r%   r   z'make_timsort_impl.<locals>.merge_appendY   sJ    
 D$$$$$
1"-")RZQOOOr'   c                 `    t          | j        | j        | j        | j        | j        dz
            S )z7
        Pop the top run from the merge stack.
        r*   )r   r   r   r   r   r   )r:   s    r%   r   z$make_timsort_impl.<locals>.merge_popc   s)    
 "-")RZPQRRRr'   c                    t          | j                  }||k    r| S ||k     r|dz  }||k      | j        |          } | j        | j                  r | j        |          }n|}t          | j        ||| j        | j                  S )zJ
        Ensure enough temp memory for 'need' items is available.
        r*   )r-   r   r   r   r   r   r   )r:   needallocedr2   r3   r&   r5   s        r%   merge_getmemz'make_timsort_impl.<locals>.merge_getmemj   s    
 bg,,7??InnlG nn #N27G44	:bgry)) 	$(.G<<KK#K"-KRTRRRr'   c                 d    t           |          | j        | j        | j        | j                  S )z5
        Modify the MergeState's min_gallop.
        )r   r   r   r   r   )r:   
new_gallopr4   s     r%   merge_adjust_gallopz.make_timsort_impl.<locals>.merge_adjust_gallop~   s-    
 $$z**BGRY
BDQQQr'   c                     | |k     S )z
        Trivial comparison function between two keys.  This is factored out to
        make it clear where comparisons occur.
        r$   )abs     r%   LTzmake_timsort_impl.<locals>.LT   s     1ur'   c                    ||k    r||k    sJ  | |          }||k    r|dz  }||k     r| |         }|}|}||k     r+|||z
  dz	  z   }	 || |	                   r|	}n|	dz   }||k     +t          ||d          D ]}	| |	dz
           | |	<   || |<   |r/||         }
t          ||d          D ]}	||	dz
           ||	<   |
||<   |dz  }||k     dS dS )a  
        binarysort is the best method for sorting small arrays: it does
        few compares, but can do data movement quadratic in the number of
        elements.
        [lo, hi) is a contiguous slice of a list, and is sorted via
        binary insertion.  This sort is stable.
        On entry, must have lo <= start <= hi, and that [lo, start) is already
        sorted (pass start == lo if you don't know!).
        r*   Nrange)r   r   lohir   _has_valuespivotlrp	pivot_valrG   r&   s              r%   r   z%make_timsort_impl.<locals>.binarysort   sI    U{{u{{{{ jv..;;QJEbjjKE AA
 a%%!a%A&2eT!W%% AA!A a%% 5!R(( & &q1u+QDG &"5M	ua,, . .A &q1uF1II%q	QJEA bjjjjjjr'   c                 d   ||k     sJ |dz   |k    rdS  | |dz            | |                   rAt          |dz   |          D ]&} | |         | |dz
                     s	||z
  dfc S '||z
  dfS t          |dz   |          D ]&} | |         | |dz
                     r	||z
  dfc S '||z
  dfS )a  
        Return the length of the run beginning at lo, in the slice [lo, hi).
        lo < hi is required on entry.  "A run" is the longest ascending sequence, with

            lo[0] <= lo[1] <= lo[2] <= ...

        or the longest descending sequence, with

            lo[0] > lo[1] > lo[2] > ...

        A tuple (length, descending) is returned, where boolean *descending*
        is set to 0 in the former case, or to 1 in the latter.
        For its intended use in a stable mergesort, the strictness of the defn of
        "descending" is needed so that the caller can safely reverse a descending
        sequence without violating stability (strict > ensures there are no equal
        elements to get out of order).
        r*   )r*   Fr)   TFrJ   )r   rL   rM   krG   s       r%   r   z$make_timsort_impl.<locals>.count_run   s   & Bwwww6R<<82d26lDH%% 	"262&& ( (r$q'4A;// (r64<'''(7D=  262&& ) )2d1gtAE{++ )r65=((()7E>!r'   c                 :   ||k    sJ ||k    r||k     sJ ||z
  }d}d} 
||         |           rM||z
  }||k     r/ 
|||z            |           r|}|dz  dz   }|dk    r|}nn||k     /||k    r|}||z  }||z  }nN||z
  dz   }||k     r. 
|||z
           |           rn|}|dz  dz   }|dk    r|}||k     .||k    r|}||z
  ||z
  }}|dz
  |k    r||k     r||k    sJ |dz  }||k     r+|||z
  dz	  z   }	 
||	         |           r|	dz   }n|	}||k     +|S )a  
        Locate the proper position of key in a sorted vector; if the vector contains
        an element equal to key, return the position immediately to the left of
        the leftmost equal element.  [gallop_right() does the same except returns
        the position to the right of the rightmost equal element (if any).]

        "a" is a sorted vector with stop elements, starting at a[start].
        stop must be > start.

        "hint" is an index at which to begin the search, start <= hint < stop.
        The closer hint is to the final result, the faster this runs.

        The return value is the int k in start..stop such that

            a[k-1] < key <= a[k]

        pretending that a[start-1] is minus infinity and a[stop] is plus infinity.
        IOW, key belongs at index k; or, IOW, the first k elements of a should
        precede key, and the last stop-start-k should follow key.

        See listsort.txt for info on the method.
        r   r*   r$   keyrE   r   stophintr   lastofsofsmaxofsmrG   s             r%   r   z&make_timsort_impl.<locals>.gallop_left   s   0 e||||u}}5L 2ags $	6 D[F,,2as
mS)) !G!8q.Caxx$  ,, V||tOG4KCC E\A%F,,2as
mS)) % "G!8q.Caxx$ ,, V||#:tg~SGqyG####++++ 	1mmC'Ma/0Ar!A$}} a%  mm 
r'   c                 :   ||k    sJ ||k    r||k     sJ ||z
  }d}d} 
| ||                   rP||z
  dz   }||k     r/ 
| |||z
                     r|}|dz  dz   }|dk    r|}nn||k     /||k    r|}||z
  ||z
  }}nK||z
  }||k     r. 
| |||z                      rn|}|dz  dz   }|dk    r|}||k     .||k    r|}||z  }||z  }|dz
  |k    r||k     r||k    sJ |dz  }||k     r+|||z
  dz	  z   }	 
| ||	                   r|	}n|	dz   }||k     +|S )a  
        Exactly like gallop_left(), except that if key already exists in a[start:stop],
        finds the position immediately to the right of the rightmost equal value.

        The return value is the int k in start..stop such that

            a[k-1] <= key < a[k]

        The code duplication is massive, but this is enough different given that
        we're sticking to "<" comparisons that it's much harder to follow if
        written as one routine with yet another "left or right?" flag.
        r   r*   r$   rW   s             r%   r	   z'make_timsort_impl.<locals>.gallop_right;  s    e||||u}}5L 2c1T7 $	 E\A%F,,2c1TCZ=)) !G!8q.Caxx$  ,, V||#:tg~SGG D[F,,2c1TCZ=)) % "G!8q.Caxx$ ,, V||tOG4KCqyG####++++ 	1mmC'Ma/0Ar#qt}}   a% mm 
r'   c                 R    d}| dk    sJ | dk    r|| dz  z  }| dz  } | dk    | |z   S )a  
        Compute a good value for the minimum run length; natural runs shorter
        than this are boosted artificially via binary insertion.

        If n < 64, return n (it's too small to bother with fancy stuff).
        Else if n is an exact power of 2, return 32.
        Else return an int k, 32 <= k <= 64, such that n/k is close to, but
        strictly less than, an exact power of 2.

        See listsort.txt for more info.
        r   @   r*   r$   )r   rQ   s     r%   r   z/make_timsort_impl.<locals>.merge_compute_minrun  sK     Avvvv2ggQJA!GA 2gg 1ur'   c                     |dk    sJ |dk    sJ t          |          D ]}|||z            | ||z   <    ||          r#t          |          D ]}|||z            |||z   <   dS dS )z#
        Upwards memcpy().
        r   NrJ   		dest_keysdest_values
dest_startsrc_keys
src_values	src_startnitemsir&   s	           r%   sortslice_copyz)make_timsort_impl.<locals>.sortslice_copy       A~~~~Qv 	@ 	@A(0Q(?Ij1n%%:h
++ 	H6]] H H.8Q.GJN++	H 	HH Hr'   c                     |dk    sJ |dk    sJ t          |          D ]}|||z
           | ||z
  <    ||          r#t          |          D ]}|||z
           |||z
  <   dS dS )z%
        Downwards memcpy().
        r   NrJ   rc   s	           r%   sortslice_copy_downz.make_timsort_impl.<locals>.sortslice_copy_down  rm   r'   r*   c           	      <   |dk    r|dk    r||k    sJ |||z   k    sJ  | |          }  | j         | j        d||||           | j         }| j        }|}	|}
|}d} ||          }| j        }|dk    r|dk    rd}d}	  |	|         ||                   r=|	|         ||<   |r|
|         ||<   |dz  }|dz  }|dz  }|dk    rnL|dz  }d}||k    rn>n<||         ||<   |r||         ||<   |dz  }|dz  }|dz  }|dk    rn|dz  }d}||k    rnrD|dk    r=|dk    r6|dz  }|t          k    s|t          k    r||dk    z  } |	|         ||||z   |          }||z  }|}|dk    r' |||||||           ||z  }||z  }||z  }|dk    rn|	|         ||<   |r|
|         ||<   |dz  }|dz  }|dz  }|dk    rn ||         |	|||z   |          }||z  }|}|dk    r' ||||	|
||           ||z  }||z  }||z  }|dk    rnF||         ||<   |r||         ||<   |dz  }|dz  }|dz  }|dk    rn|t          k    	|t          k    |dz  }|dk    r|dk    |dk    r |||||||           n|dk    sJ ||k    sJ  | |          S )a@  
        Merge the na elements starting at ssa with the nb elements starting at
        ssb = ssa + na in a stable way, in-place.  na and nb must be > 0,
        and should have na <= nb. See listsort.txt for more info.

        An updated MergeState is returned (with possibly a different min_gallop
        or larger temp arrays).

        NOTE: compared to CPython's timsort, the requirement that
            "Must also have that keys[ssa + na - 1] belongs at the end of the merge"

        is removed. This makes the code a bit simpler and easier to reason about.
        r   Tr*   r   r   r   r0   )r:   r   r   ssanassbnba_keysa_valuesb_keysb_valuesdestrN   r   acountbcountrU   	DO_GALLOPrG   r   r	   r&   rC   r@   rl   s                    r%   r   z#make_timsort_impl.<locals>.merge_lo  sD    Avv"q&&R2XXXXcBh\"b!!rw	1VS	 	 	 9 j22]
 1ffa FF2fSk6#;// !'DJ" 5'/}tAID1HC!GBQwwaKFF++ , "(DJ" 5'/}tAID1HC!GBQwwaKFF++9D  A R!VVQa

**f
.B.B *q.0J %VC[&#sRxMMAHAF1uu&tVT'-x'(* * * 	qa77!!'DJ" 5'/}tAID1HC!GBQww $F3KcBhLLAHAF1uu 'tVT'-x'(* * * 	qa77!!'DJ" 5'/}tAID1HC!GBQwww 
**f
.B.B| a
S 1ffaX 77N4!8S    77773;;;; #"2z222r'   c           	        	 |dk    r|dk    r||k    sJ |||z   k    sJ  | |          }  | j         | j        d||||           |}|}| j         }	| j        }
||z   dz
  }|dz
  }||z   dz
  } |	|
          }| j        }|dk    r|dk    rd}d}	  |	|         ||                   r=||         ||<   |r||         ||<   |dz  }|dz  }|dz  }|dk    rnL|dz  }d}||k    rn>n<|	|         ||<   |r|
|         ||<   |dz  }|dz  }|dz  }|dk    rn|dz  }d}||k    rnrV|dk    rO|dk    rH|dz  }|t          k    s|t          k    r'||dk    z  } |	|         |||z
  dz   |dz   |          }|dz   |z
  }|}|dk    r' |||||||           ||z  }||z  }||z  }|dk    rn|	|         ||<   |r|
|         ||<   |dz  }|dz  }|dz  }|dk    rn ||         |	||z
  dz   |dz   |          }|dz   |z
  }|}|dk    r' ||||	|
||           ||z  }||z  }||z  }|dk    rnF||         ||<   |r||         ||<   |dz  }|dz  }|dz  }|dk    rn|t          k    |t          k    '|dz  }|dk    r|dk    |dk    r ||||z
  dz   |	|
||z
  dz   |           n|dk    sJ ||k    sJ  | |          S )aA  
        Merge the na elements starting at ssa with the nb elements starting at
        ssb = ssa + na in a stable way, in-place.  na and nb must be > 0,
        and should have na >= nb.  See listsort.txt for more info.

        An updated MergeState is returned (with possibly a different min_gallop
        or larger temp arrays).

        NOTE: compared to CPython's timsort, the requirement that
            "Must also have that keys[ssa + na - 1] belongs at the end of the merge"

        is removed. This makes the code a bit simpler and easier to reason about.
        r   r*   rq   )r:   r   r   rr   rs   rt   ru   rv   rw   rx   ry   rz   rN   r   r{   r|   rU   r}   rG   r   r	   r&   rC   r@   rl   ro   s                    r%   r   z#make_timsort_impl.<locals>.merge_hiY  s    Avv"q&&R2XXXXcBh\"b!!rw	1VS	 	 	 9 Rx!|1fBhl j22]
1ffa FF2fSk6#;// !'DJ" 5'/}tAID1HC!GBQwwaKFF++ , "(DJ" 5'/}tAID1HC!GBQwwaKFF++;F  A R!VVQa

**f
.B.B *q.0J %VC[&#(Q,aQTUUAa!AF1uu ,+D&$,2Hc,-/ / / 	qa77!!'DJ" 5'/}tAID1HC!GBQww $F3KrAsQwPSTTAa!AF1uu++D&$,2Hc,-/ / / 	qa77!!'DJ" 5'/}tAID1HC!GBQwww 
**f
.B.B| a
U 1ffaZ 77N4Q!8S2X\    77773;;;; #"2z222r'   c           	      \   | j         }|dk    sJ |dk    sJ ||dz
  k    s||dz
  k    sJ | j        |         \  }}| j        |dz            \  }}|dk    r|dk    sJ ||z   |k    sJ t          |||z             | j        |<   ||dz
  k    r| j        |dz            | j        |dz   <    |           }  ||         ||||z   |          }	||	|z
  z  }|	}|dk    r| S  
|||z   dz
           ||||z   ||z   dz
            }	|	|z
  }||k    r | ||||||          S  | ||||||          S )zl
        Merge the two runs at stack indices i and i+1.

        An updated MergeState is returned.
        r)   r      r*   )r   r   r   )r:   r   r   rk   r   rr   rs   rt   ru   rU   r   r	   r   r   r   s             r%   r   z#make_timsort_impl.<locals>.merge_at  s    DAvvvvAvvvvAEzzQ!a%ZZZZ*Q-R*QU#RAvv"q&&&&Rx3
 !b2g..
1A:: "
1q5 1BJq1uYr]] LcD#sRx==
a#g77I KS2X\*D#sRxrANNW 888Bfc2sB???8Bfc2sB???r'   c                    | j         dk    r| j        }| j         dz
  }|dk    r0||dz
           j        ||         j        ||dz            j        z   k    s6|dk    rf||dz
           j        ||dz
           j        ||         j        z   k    r6||dz
           j        ||dz            j        k     r|dz  } | |||          } n/||         j        ||dz            j        k     r | |||          } nn| j         dk    | S )a(  
        Examine the stack of runs waiting to be merged, merging adjacent runs
        until the stack invariants are re-established:

        1. len[-3] > len[-2] + len[-1]
        2. len[-2] > len[-1]

        An updated MergeState is returned.

        See listsort.txt for more info.
        r*   r)   r   r   r   r    r:   r   r   r   r   r   s        r%   r   z)make_timsort_impl.<locals>.merge_collapse'  s    dQhhjGqAQ71Q3<,
'!A#,BS0SSSQ71Q3<,!0AGAJO0SSS1q5>&Q)<<<FAXb$2271q5>#666Xb$22 dQhh 	r'   c                     | j         dk    rW| j        }| j         dz
  }|dk    r'||dz
           j        ||dz            j        k     r|dz  } | |||          } | j         dk    W| S )z
        Regardless of invariants, merge all runs on the stack until only one
        remains.  This is used at the end of the mergesort.

        An updated MergeState is returned.
        r*   r)   r   r   r   s        r%   r   z/make_timsort_impl.<locals>.merge_force_collapseC  s~     dQhhjGqA1uu1q5>&Q)<<<FA"dFA..B dQhh 	r'   c                     |}|dz
  }||k     r'| |         | |         c| |<   | |<   |dz  }|dz  }||k     ' | |          r6|}|dz
  }||k     r+||         ||         c||<   ||<   |dz  }|dz  }||k     'dS dS dS )z,
        Reverse a slice, in-place.
        r*   Nr$   )r   r   r   rY   rk   jr&   s         r%   reverse_slicez(make_timsort_impl.<locals>.reverse_sliceV  s    
 1H!ee#AwQDGT!WFAFA !ee :dF## 	AqAa%%'-ay&)$q	6!9QQ a%%%%	 	 %r'   c                    t          |          }|dk     rdS  |          }}|dk    r 
||||z             \  }}|r |||||z              ||k     r't          ||          } 	|||||z   ||z              |} | t          ||                    }  | ||          } ||z  }||z  }|dk     | ||          } | j        dk    sJ | j        d         dt          |          fk    sJ dS )z2
        Run timsort with the mergestate.
        r)   Nr   r*   )r-   r,   r   r   r   )r:   r   r   
nremainingminrunrL   r   descforcer   r   r   r   r   r   r   r6   s            r%   run_timsort_with_mergestatez6make_timsort_impl.<locals>.run_timsort_with_mergestatej  sM   
 YY
>>F &%j111nnib"z/::GAt 8dFBQ7776zzFJ//
4R%Za@@@b(2q//22BD&11B!GB!OJ 1nn$ "!"dF33tqyyyyz!}CII......r'   c                 8    | }  |           | |           dS )z2
        Run timsort over the given keys.
        Nr$   )r   r   r
   r   s     r%   r   z&make_timsort_impl.<locals>.run_timsort  s/    
 ##JJt$4$4dFCCCCCr'   c                 6      | |          | |           dS )z=
        Run timsort over the given keys and values.
        Nr$   )r   r   r8   r   s     r%   r   z2make_timsort_impl.<locals>.run_timsort_with_values  s9    
 	$#$:$:4$H$H$(&	2 	2 	2 	2 	2r'   )r   r4   r   )wrapr5   r   r   r}   rG   r   r   r   r	   r&   r4   rC   r   r   r   r   r   r@   r   r
   r8   r   r   r   r   rl   ro   r6   s    `  @@@@@@@@@@@@@@@@@@@@@@@@@r%   make_timsort_implr   9   s   T.))N:D477D	" " 
T" 
S S S S S S 
TS 
S S S S S S 
TS 
P P 
TP 
S S 
TS 
S S S S S 
TS& 
R R R R 
TR 
  
T 
. . . . . 
T.b 
!" !" !" !" 
T!"H 
R R R R 
TRj 
H H H H 
THV 
  
T( 
H H H H 
TH 
H H H H 
TH  I	W3 W3 W3 W3 W3 W3 W3 W3 W3 W3 W3 
TW3t 
Z3 Z3 Z3 Z3 Z3 Z3 Z3 Z3 Z3 Z3 Z3 Z3 
TZ3z 
,@ ,@ ,@ ,@ ,@ ,@ ,@ ,@ 
T,@^ 
    
T6 
    
T$ 
    
T& 
!/ !/ !/ !/ !/ !/ !/ !/ !/ !/ !/ 
T!/H 
D D D D D 
TD 
2 2 2 2 2 
T2 !:{LL)h(n,. . .r'   c                      t          d g| R  S )Nc                     | S r#   r$   )fs    r%   <lambda>z!make_py_timsort.<locals>.<lambda>  s     r'   )r   )argss    r%   make_py_timsortr     s    kk2T2222r'   c                  0    ddl m t          fdg| R  S )Nr   )jitc                 .      d          |           S )NT)nopythonr$   )r   r   s    r%   r   z"make_jit_timsort.<locals>.<lambda>  s    (:T(:(:(:1(=(= r'   )numbar   r   )r   r   s    @r%   make_jit_timsortr     s@    ==== %#% % % %r'   )__doc__collections
numba.corer   
namedtupler   r/   r0   r.   r   r   r   r   r   r$   r'   r%   <module>r      s               /.	  *   
   $[#BD D
 ";!*.?@@m. m. m.`3 3 3% % % % %r'   