o 1&i@sddZddlZddlmZeddZdZdZdZed d Z ed d Z d dZ ddZ ddZ 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)startsizecs|tjd|dd|fdd|fdd|dd  |d d |fd d |fdd |dd|fdd|fdd|fdd|fdd|dd |fdd|fddd | fd!d"| f d#d$|fd%d& | fd'd( | fd)d*|fd+d,| fd-d.|fd/d0}|fd1d2}t|    ||S)3NrcSs||uSNrrr!r!=C:\wamp64\www\opt\env\Lib\site-packages\numba/misc/timsort.py has_values?sz%make_timsort_impl..has_valuescsHtt|ddt}||}|}tgt}tt|||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_areazeror!r#r Cs  z%make_timsort_impl..merge_initcsNtt|ddt}||}||}tgt}tt|||S)z; Initialize a MergeState for a keyed sort. r%r&r')rrr-r.r/rr0r!r#merge_init_with_valuesNs   z1make_timsort_impl..merge_init_with_valuescSs8|j}|tks J||j|<t|j|j|j|j|dS)z2 Append a run on the merge stack. r&)rr+rrrrr)msrunrr!r!r#r Ys  z'make_timsort_impl..merge_appendcSst|j|j|j|j|jdS)z7 Pop the top run from the merge stack. r&)rrrrrr)r5r!r!r#r csz$make_timsort_impl..merge_popcspt|j}||kr |S||kr|d>}||ks|j|}|j|jr+|j|}n|}t|j|||j|jS)zJ Ensure enough temp memory for 'need' items is available. r&)r)rrrrrr)r5ZneedZallocedr.r/)r$r2r!r# merge_getmemjs  z'make_timsort_impl..merge_getmemcst||j|j|j|jS)z5 Modify the MergeState's min_gallop. )rrrrr)r5Z new_gallop)r1r!r#merge_adjust_gallop~sz.make_timsort_impl..merge_adjust_gallopcSs||kS)z Trivial comparison function between two keys. This is factored out to make it clear where comparisons occur. r!)abr!r!r#LTszmake_timsort_impl..LTc s||kr||ks J||}||kr|d7}||kr{||}|}|}||krA|||d?} ||| r9| }n| d}||ks't||dD] } || d|| <qG|||<|rq||} t||dD] } || d|| <qb| ||<|d7}||ksdSdS)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_valuesZpivotlrpZ pivot_val)r;r$r!r#rs0  z%make_timsort_impl..binarysortcs||ksJ|d|krdS||d||r 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%TFr=)rr?r@kr;r!r#rs    z$make_timsort_impl..count_runc sx||ksJ||kr||ksJ||}d}d}|||rS||}||krD||||r?|}|d>d}|dkr>|}nn||ks'||krJ|}||7}||7}n5||d}||kry||||rgn|}|d>d}|dkru|}||ks]||kr|}||||}}|d|kr||kr||ksJ|d7}||kr|||d?} || |r| d}n| }||ks|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! keyr9rstophintrZlastofsZofsZmaxofsmrFr!r#rsR          z&make_timsort_impl..gallop_leftc sx||ksJ||kr||ksJ||}d}d}|||rV||d}||krF||||rA|}|d>d}|dkr@|}nn||ks)||krL|}||||}}n2||}||krz||||rhn|}|d>d}|dkrv|}||ks^||kr|}||7}||7}|d|kr||kr||ksJ|d7}||kr|||d?} ||| r| }n| d}||ks|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!rGrFr!r#r;sR        z'make_timsort_impl..gallop_rightcSs<d}|dksJ|dkr||d@O}|dL}|dks ||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!)rrCr!r!r#r s  z/make_timsort_impl..merge_compute_minruncsn|dksJ|dks Jt|D] }||||||<q||r3t|D]}||||||<q&dSdS)z# Upwards memcpy(). rNr=Z dest_keysZ dest_valuesZ dest_startZsrc_keysZ src_valuesZ src_startZnitemsir$r!r#sortslice_copy     z)make_timsort_impl..sortslice_copycsn|dksJ|dks Jt|D] }||||||<q||r3t|D]}||||||<q&dSdS)z% Downwards memcpy(). rNr=rMrOr!r#sortslice_copy_downrQz.make_timsort_impl..sortslice_copy_downr&csR|dkr |dkr ||ksJ|||ksJ||}|j|jd|||||j}|j}|} |} |} d}||} |j} |dkr|dkrd}d} | |||r| ||| <| rc| ||| <| d7} |d7}|d8}|dkrtn7|d7}d}|| krn,n*|||| <| r|||| <| d7} |d7}|d8}|dkrn |d7}d}|| krnqLr}|dkr}|dkr}| d7} |tks|tkry| | dk8} | ||||||}||8}|}|dkr||| ||||| |7} ||7}||8}|dkrn}| ||| <| r | ||| <| d7} |d7}|d8}|dkrn\||| ||||}||8}|}|dkrP||| | | ||| |7} ||7}||8}|dkrPn)|||| <| r_|||| <| d7} |d7}|d8}|dkrqn|tks|tks| d7} |dkr|dksG|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&rrrr,r5rrssanassbnbZa_keysZa_valuesZb_keysZb_valuesdestrArZacountZbcountrE) DO_GALLOPr;rrr$r8r7rPr!r#r s       "         > l z#make_timsort_impl..merge_locs|dkr |dkr ||ksJ|||ksJ||}|j|jd|||||}|}|j} |j} ||d} |d}||d}| | } |j} |dkr|dkrd}d} | |||r|||| <| ro|||| <| d8} |d8}|d8}|dkrn7|d7}d}|| krn,n*| ||| <| r| ||| <| d8} |d8}|d8}|dkrn |d7}d}|| krnqXr|dkr|dkr| d7} |tks|tkr| | dk8} | ||||d|d|}|d|}|}|dkr||| ||||| |8} ||8}||8}|dkrn| ||| <| r| ||| <| d8} |d8}|d8}|dkr1nb||| ||d|d|}|d|}|}|dkrj||| | | ||| |8} ||8}||8}|dkrjn)|||| <| ry|||| <| d8} |d8}|d8}|dkrn|tks|tks| d7} |dkr|dksS|dkr||| |d| | ||d|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&rSrT) rZr;rrr$r8r7rPrRr!r#rYs         #               > m z#make_timsort_impl..merge_hic sR|j}|dks J|dksJ||dks||dksJ|j|\}}|j|d\}}|dkr5|dks7J|||ks?Jt||||j|<||dkr[|j|d|j|d<|}|||||||} || |8}| }|dkry|S|||d||||||d} | |}||kr|||||||S|||||||S)zl Merge the two runs at stack indices i and i+1. An updated MergeState is returned. r%rr&)rrr) r5rrrNrrUrVrWrXrE)rrrr r r!r#rs,    (z#make_timsort_impl..merge_atcs|jdkrq|j}|jd}|dkr$||dj||j||djks;|dkrU||dj||dj||jkrU||dj||djkrM|d8}||||}n||j||djkri||||}n |S|jdks|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%rrrrr5rrrrrr!r#r's  ..  z)make_timsort_impl..merge_collapsecsb|jdkr/|j}|jd}|dkr#||dj||djkr#|d8}||||}|jdks|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%rr\r]r^r!r#rCs   z/make_timsort_impl..merge_force_collapsecs|}|d}||kr#||||||<||<|d7}|d8}||ks ||rM|}|d}||krO||||||<||<|d7}|d8}||ks2dSdSdS)z, Reverse a slice, in-place. r&Nr!)rrrrIrNjrOr!r# reverse_sliceVs"  z(make_timsort_impl..reverse_slicec st|}|dkr dS|}}|dkrZ||||\}}|r)|||||||kr@t||}||||||||}|t||}|||}||7}||8}|dks|||}|jdksgJ|jddt|fkstJdS)z2 Run timsort with the mergestate. r%Nrr&)r)r(rrr) r5rrZ nremainingZminrunr?rdescforce)rrr rr rr`r3r!r#run_timsort_with_mergestatejs*   z6make_timsort_impl..run_timsort_with_mergestatecs|}|||dS)z2 Run timsort over the given keys. Nr!r")r rcr!r#rsz&make_timsort_impl..run_timsortcs||||dS)z= Run timsort over the given keys and values. Nr!r")r4rcr!r#rs z2make_timsort_impl..run_timsort_with_values)rr1r)wrapr2rrr!)rZr;rrrrr$r1r2r8r rrr rr7rr r4r r r`rcrPrRr3r#make_timsort_impl9s|     1$UK /$recGstddg|RS)NcSs|Sr r!fr!r!r#sz!make_py_timsort..)reargsr!r!r#make_py_timsortsrkcs$ddlmtfddg|RS)Nrjitcsdd|S)NT)Znopythonr!rfrlr!r#rhsz"make_jit_timsort..)Znumbarmrerir!rlr#make_jit_timsorts rn)__doc__ collectionsZ numba.corer namedtuplerr+r,r*rrrerkrnr!r!r!r#s.   v