2@jdZddlZddlmZejddZdZdZdZejd d Z ejd d Z d Z dZ dZ dS)z Timsort implementation. Mostly adapted from CPython's listobject.c. For more information, see listsort.txt in CPython's source tree. N)typesTimsortImplementation)compile count_run binarysort gallop_left gallop_right merge_init merge_append merge_popmerge_compute_minrunmerge_lomerge_himerge_atmerge_force_collapsemerge_collapse run_timsortrun_timsort_with_valuesU MergeState) min_gallopkeysvaluespendingnMergeRun)startsizecZ |tj  d|d | fd| fd|d |d| fd| fd |d | fd |fd |fd |fd  |d| fd| fdd| fd| f d| fd|fd|fd| fd| fd|fd}|fd}t|  ||S)Nrc ||uSN)rrs CC:\Projects\Historical\venv\Lib\site-packages\numba/misc/timsort.py has_valuesz%make_timsort_impl..has_values?s T!!ctt|dzdzt}||}|}tgtz}t t |||S)z? Initialize a MergeState for a non-keyed sort. minlenMERGESTATE_TEMP_SIZErMAX_MERGE_PENDINGr MIN_GALLOP)r temp_size temp_keys temp_valuesrintpmake_temp_areazeros r%r z%make_timsort_impl..merge_initCsr D Q*,@AA "N433  D$''(+<<$$z**I{GTRRRr'ctt|dzdzt}||}||}tgtz}t t |||S)z; Initialize a MergeState for a keyed sort. r)r*r+) rrr1r2r3rr4r5r6s r%merge_init_with_valuesz1make_timsort_impl..merge_init_with_valuesNs~ D Q*,@AA "N433 $nVY77 D$''(+<<$$z**I{GTRRRr'c|j}|tksJ||j|<t|j|j|j|j|dzS)z2 Append a run on the merge stack. r*)rr/rrrrr)msrunrs r%r z'make_timsort_impl..merge_appendYsJ D$$$$$ 1 "-")RZQOOOr'c`t|j|j|j|j|jdz S)z7 Pop the top run from the merge stack. r*)rrrrrr)r:s r%r z$make_timsort_impl..merge_popcs) "-")RZPQRRRr'ct|j}||kr|S||kr |dz}||k |j|}|j|jr|j|}n|}t|j|||j|jS)zJ Ensure enough temp memory for 'need' items is available. r*)r-rrrrrr)r:needallocedr2r3r&r5s r% merge_getmemz'make_timsort_impl..merge_getmemjs bg,, 7??InnlGnn#N27G44 :bgry ) ) $(.G<.merge_adjust_gallop~s- $$z**BGRY BDQQQr'c||kS)z Trivial comparison function between two keys. This is factored out to make it clear where comparisons occur. r$)abs r%LTzmake_timsort_impl..LTs 1u r'c||kr||ksJ ||}||kr|dz }||kr||}|}|}||kr+|||z dz z}  ||| r| }n| dz}||k+t||dD]} || dz || <|||<|r/||} t||dD]} || dz || <| ||<|dz }||kdSdS)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*Nrange) rrlohir _has_valuespivotlrp pivot_valrGr&s r%rz%make_timsort_impl..binarysortsJU{{u{{{* jv.. ;; QJEbjjKEAA a%%!a%A&2eT!W%%AA!A a%%5!R(( & &q1u+QDG &"5M ua,,..A &q1u F1II%q QJEAbjjjjjjr'cd||ksJ|dz|krdS||dz||rAt|dz|D]&}||||dz s ||z dfcS'||z dfSt|dz|D]&}||||dz r ||z dfcS'||z dfS)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)rrLrMkrGs r%rz$make_timsort_impl..count_runs&Bwwww 6R<<8 2d26lDH % % "262&& ( (r$q'4A;//(r64<'''(7D= 262&& ) )2d1gtAE{++)r65=((()7E> !r'c:||ksJ||kr||ksJ||z }d}d} |||rM||z }||kr/ |||z|r|}|dzdz}|dkr|}nn||k/||kr|}||z }||z }nN||z dz}||kr. |||z |rn|}|dzdz}|dkr|}||k.||kr|}||z ||z }}|dz |kr ||kr||ksJ|dz }||kr+|||z dz z}  || |r| dz}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. rr*r$ keyrErstophintrlastofsofsmaxofsmrGs r%rz&make_timsort_impl..gallop_lefts0e||||u}}, 5L 2ags  $ 6D[F,,2as mS))!G!8q.Caxx$,,V|| tOG 4KCCE\A%F,,2as mS))%"G!8q.Caxx$,,V||#:tg~SGqyG### #+++E 1 mmC'Ma/0Ar!A$}} a%mm r'c:||ksJ||kr||ksJ||z }d}d} |||rP||z dz}||kr/ ||||z r|}|dzdz}|dkr|}nn||k/||kr|}||z ||z }}nK||z }||kr. ||||zrn|}|dzdz}|dkr|}||k.||kr|}||z }||z }|dz |kr ||kr||ksJ|dz }||kr+|||z dz z}  ||| r| }n| dz}||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. rr*r$rWs r%r z'make_timsort_impl..gallop_right;se||||u}}, 5L 2c1T7  $ E\A%F,,2c1TCZ=))!G!8q.Caxx$,,V||#:tg~SGGD[F,,2c1TCZ=))%"G!8q.Caxx$,,V|| tOG 4KCqyG### #+++E 1 mmC'Ma/0Ar#qt}} a%mm r'cRd}|dksJ|dkr||dzz}|dz}|dk||zS)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$)rrQs r%r z/make_timsort_impl..merge_compute_minrunsK Avvvv2gg QJA !GA2gg1u r'c|dksJ|dksJt|D]}|||z|||z<||r#t|D]}|||z|||z<dSdS)z# Upwards memcpy(). rNrJ dest_keys dest_values dest_startsrc_keys src_values src_startnitemsir&s r%sortslice_copyz)make_timsort_impl..sortslice_copyA~~~~Qv @ @A(0Q(?Ij1n % % :h + + H6]] H H.8Q.G JN++ H H H Hr'c|dksJ|dksJt|D]}|||z |||z <||r#t|D]}|||z |||z <dSdS)z% Downwards memcpy(). rNrJrcs r%sortslice_copy_downz.make_timsort_impl..sortslice_copy_downrmr'r*c <|dkr |dkr||ksJ|||zksJ||}|j|jd|||||j}|j}|} |} |} d}||} |j} |dkr|dkrd}d} | |||r=| ||| <| r | ||| <| dz } |dz }|dz}|dkrnL|dz }d}|| krn>n<|||| <| r |||| <| dz } |dz }|dz}|dkrn|dz }d}|| krnrD|dkr=|dkr6| dz } |tks |tkr| | dkz} | |||||z|}||z}|}|dkr'||| ||||| |z } ||z }||z}|dkrn| ||| <| r | ||| <| dz } |dz }|dz}|dkrn||| |||z|}||z}|}|dkr'||| | | ||| |z } ||z }||z}|dkrnF|||| <| r |||| <| dz } |dz }|dz}|dkrn|tk |tk| dz } |dkr|dk|dkr||| ||||n|dksJ| |ksJ|| 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. rTr*rrrr0)r:rrssanassbnba_keysa_valuesb_keysb_valuesdestrNracountbcountrU DO_GALLOPrGrr r&rCr@rls r%rz#make_timsort_impl..merge_losEAvv"q&&R2XXX-cBh \"b ! !rw 1VS   9 j22 ] 1ffaFF 2fSk6#;//!'DJ"5'/}t AID1HC!GBQwwaKFF++,"(DJ"5'/}t AID1HC!GBQwwaKFF++9 DA R!VVQa  **f .B.B*q.0J% VC[&#sRxMMAHAF1uu&tVT'-x'(*** qa77!!'DJ"5'/}t AID1HC!GBQww$ F3KcBhLLAHAF1uu'tVT'-x'(*** qa77!!'DJ"5'/}t AID1HC!GBQwww **f .B.B|a S1ffaX 77 N4!8S    77773;;;;#"2z222r'c  |dkr |dkr||ksJ|||zksJ||}|j|jd|||||}|}|j} |j} ||zdz } |dz }||zdz }| | } |j} |dkr|dkrd}d} | |||r=|||| <| r |||| <| dz} |dz}|dz}|dkrnL|dz }d}|| krn>n<| ||| <| r | ||| <| dz} |dz}|dz}|dkrn|dz }d}|| krnrV|dkrO|dkrH| dz } |tks |tkr'| | dkz} | ||||z dz|dz|}|dz|z }|}|dkr'||| ||||| |z} ||z}||z}|dkrn| ||| <| r | ||| <| dz} |dz}|dz}|dkrn||| ||z dz|dz|}|dz|z }|}|dkr'||| | | ||| |z} ||z}||z}|dkrnF|||| <| r |||| <| dz} |dz}|dz}|dkrn|tk|tk'| dz } |dkr|dk|dkr||| |z dz| | ||z dz|n|dksJ| |ksJ|| 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. rr*rq)r:rrrrrsrtrurvrwrxryrzrNrr{r|rUr}rGrr r&rCr@rlros r%rz#make_timsort_impl..merge_hiYsAvv"q&&R2XXX-cBh \"b ! !rw 1VS   9Rx!|1fBhl j22 ] 1ffaFF 2fSk6#;//!'DJ"5'/}t AID1HC!GBQwwaKFF++,"(DJ"5'/}t AID1HC!GBQwwaKFF++; FA R!VVQa  **f .B.B*q.0J% VC[&#(Q,aQTUUAa! AF1uu,+D&$,2Hc,-/// qa77!!'DJ"5'/}t AID1HC!GBQww$ F3KrAsQwPSTTAa! AF1uu++D&$,2Hc,-/// qa77!!'DJ"5'/}t AID1HC!GBQwww **f .B.B|a U1ffaZ 77 N4Q!8S2X\    77773;;;;#"2z222r'c \|j}|dksJ|dksJ||dz ks ||dz ksJ|j|\}}|j|dz\}}|dkr|dksJ||z|ksJt|||z|j|<||dz kr|j|dz|j|dz<|} ||||||z|} || |z z}| }|dkr|S |||zdz ||||z||zdz } | |z }||kr |||||||S |||||||S)zl Merge the two runs at stack indices i and i+1. An updated MergeState is returned. r)rr*)rrr)r:rrrkrrrrsrtrurUrr rrr s r%rz#make_timsort_impl..merge_ats DAvvvvAvvvvAEzzQ!a%ZZZ'*Q-R*QU#RAvv"q&&& Rx3 !b2g.. 1 A:: " 1q5 1BJq1u  Yr]] LcD#sRx = = a#g  77I KS2X\*D#sRxrA N N W 888Bfc2sB?? ?8Bfc2sB?? ?r'c|jdkr|j}|jdz }|dkr0||dz j||j||dzjzks6|dkrf||dz j||dz j||jzkr6||dz j||dzjkr|dz}||||}n/||j||dzjkr||||}nn |jdk|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)rrrr r:rrrrrs r%rz)make_timsort_impl..merge_collapse'sdQhhjGqAQ71Q3<, '!A#,BS0SSSQ71Q3<,! 0AGAJO0SSS1q5>&Q)<<<FAXb$2271q5>#666Xb$22dQhh r'c|jdkrW|j}|jdz }|dkr'||dz j||dzjkr|dz}||||}|jdkW|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)rrrs r%rz/make_timsort_impl..merge_force_collapseCs~dQhhjGqA1uu1q5>&Q)<<<FA"dFA..BdQhh r'c|}|dz }||kr'||||c||<||<|dz }|dz}||k'||r6|}|dz }||kr+||||c||<||<|dz }|dz}||k'dSdSdS)z, Reverse a slice, in-place. r*Nr$)rrrrYrkjr&s r% reverse_slicez(make_timsort_impl..reverse_sliceVs  1H!ee#AwQ DGT!W FA FA!ee :dF # # AqAa%%'-ay&)$q 6!9QQa%%%%  %r'ct|}|dkrdS |}}|dkr ||||z\}}|r|||||z||kr't||} |||||z||z|} |t||} |||}||z }||z}|dk|||}|jdksJ|jddt|fksJdS)z2 Run timsort with the mergestate. r)Nrr*)r-r,rrr)r:rr nremainingminrunrLrdescforcerrr rr rrr6s r%run_timsort_with_mergestatez6make_timsort_impl..run_timsort_with_mergestatejsM YY >> F&%j11 1nnib"z/::GAt 8 dFBQ7776zzFJ// 4R%Za@@@b(2q//22BD&11B !GB !OJ1nn$" !"dF 3 3tqyyyyz!}CII......r'c8|}|||dS)z2 Run timsort over the given keys. Nr$)rrr rs r%rz&make_timsort_impl..run_timsorts/ ##JJt$4$4dFCCCCCr'c6||||dS)z= Run timsort over the given keys and values. Nr$)rrr8rs r%rz2make_timsort_impl..run_timsort_with_valuess9 $#$:$:4$H$H$(& 2 2 2 2 2r')rr4r)wrapr5rrr}rGrrrr r&r4rCr rrr rr@rr r8rr rrrlror6s ` @@@@@@@@@@@@@@@@@@@@@@@@@r%make_timsort_implr9sT.))N :D 477D "" T" SSSSSS TS SSSSSS TS PP TP SS TS  SSSSS TS& RRRR TR  T ..... T.b !"!"!"!" T!"H RRRR TRj HHHH THV  T(  H H H H T H  H H H H T H I W3W3W3W3W3W3W3W3W3W3W3 TW3t Z3Z3Z3Z3Z3Z3Z3Z3Z3Z3Z3Z3 TZ3z ,@,@,@,@,@,@,@,@ T,@^  T6  T$  T& !/!/!/!/!/!/!/!/!/!/!/ T!/H DDDDD TD 22222 T2 ! :{LL)h(n,  . ..r'ctdg|RS)Nc|Sr#r$)fs r%z!make_py_timsort..sr')r)argss r%make_py_timsortrs kk 2T 2 2 22r'c0ddlmtfdg|RS)Nr)jitc.d|S)NT)nopythonr$)rrs r%rz"make_jit_timsort..s(:T(:(:(:1(=(=r')numbarr)rrs @r%make_jit_timsortrs@ ==== %# % % %%r')__doc__ collections numba.corer namedtuplerr/r0r.rrrrrr$r'r%rs/ .   * $[ #BDD  "; !*.? @ @m .m .m .`333%%%%%r'