a d߂@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![/var/www/html/stable-diffusion-webui/venv/lib/python3.9/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}|tksJ||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_popcsjt|j}||kr|S||kr(|d>}q|j|}|j|jrP|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||ksJ||}||kr.|d7}||kr||}|}|}||kr||||d?} ||| rr| }qF| d}qFt||dD]} || d|| <q|||<|r||} t||dD]} || d|| <q| ||<|d7}q.dS)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#rs,   z%make_timsort_impl..binarysortcs||ks J|d|krdS||d||rxt|d|D]*}||||ds@||dfSq@||dfSt|d|D]*}||||dr||dfSq||dfSdS)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%TFNr=)rr?r@kr;r!r#rs   z$make_timsort_impl..count_runc st||ks J||kr||ks J||}d}d}|||r||}||kr||||r|}|d>d}|dkr|}qFqqF||kr|}||7}||7}nf||d}||kr||||rqq|}|d>d}|dkr|}q||kr|}||||}}|d|kr(||kr(||ks,J|d7}||krp|||d?} || |rh| d}n| }q4|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#rsJ     &  z&make_timsort_impl..gallop_leftc st||ks J||kr||ks J||}d}d}|||r||d}||kr||||r|}|d>d}|dkr|}qJqqJ||kr|}||||}}n`||}||kr||||rqq|}|d>d}|dkr|}q||kr|}||7}||7}|d|kr(||kr(||ks,J|d7}||krp|||d?} ||| rd| }n| d}q4|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;sJ    &  z'make_timsort_impl..gallop_rightcSs6d}|dksJ|dkr.||d@O}|dL}q||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_minruncsj|dks J|dksJt|D]}||||||<q ||rft|D]}||||||<qLdS)z# Upwards memcpy(). rNr=Z dest_keysZ dest_valuesZ dest_startZsrc_keysZ src_valuesZ src_startZnitemsir$r!r#sortslice_copys     z)make_timsort_impl..sortslice_copycsj|dks J|dksJt|D]}||||||<q ||rft|D]}||||||<qLdS)z% Downwards memcpy(). rNr=rMrOr!r#sortslice_copy_downs     z.make_timsort_impl..sortslice_copy_downr&csL|dkr|dkr||ksJ|||ks,J||}|j|jd|||||j}|j}|} |} |} d}||} |j} |dkr|dkrd}d}| |||r| ||| <| r| ||| <| d7} |d7}|d8}|dkrqd|d7}d}|| krbqdq|||| <| r$|||| <| d7} |d7}|d8}|dkrJqd|d7}d}|| krqdqrz|dkrz|dkrz| d7} |tks|tkr| | dk8} | ||||||}||8}|}|dkr||| ||||| |7} ||7}||8}|dkrq| ||| <| r&| ||| <| d7} |d7}|d8}|dkrLq||| ||||}||8}|}|dkr||| | | ||| |7} ||7}||8}|dkrq|||| <| r|||| <| d7} |d7}|d8}|dkrqq| d7} qz|dkr&||| ||||n|dks4J| |ksBJ|| 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. rr&rrrr,r5rrssanassbnbZa_keysZa_valuesZb_keysZb_valuesdestrArZacountZbcountrE) DO_GALLOPr;rrr$r8r7rPr!r#r s                      z#make_timsort_impl..merge_locs|dkr|dkr||ksJ|||ks,J||}|j|jd|||||}|}|j} |j} ||d} |d}||d}| | } |j} |dkr8|dkr8d}d}| |||r |||| <| r|||| <| d8} |d8}|d8}|dkrq~|d7}d}|| kr|q~q| ||| <| r>| ||| <| d8} |d8}|d8}|dkrdq~|d7}d}|| krq~qr|dkr|dkr| d7} |tks|tkr.| | dk8} | ||||d|d|}|d|}|}|dkr.||| ||||| |8} ||8}||8}|dkr.q.| ||| <| rL| ||| <| d8} |d8}|d8}|dkrrq.||| ||d|d|}|d|}|}|dkr||| | | ||| |8} ||8}||8}|dkrq.|||| <| r|||| <| d8} |d8}|d8}|dkrq.q| d7} q|dkrh||| |d| | ||d|n|dksvJ| |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&rRrS) rYr;rrr$r8r7rPrQr!r#rYs                             z#make_timsort_impl..merge_hic sX|j}|dksJ|dksJ||dks:||dks:J|j|\}}|j|d\}}|dkrj|dksnJ|||ks~Jt||||j|<||dkr|j|d|j|d<|}|||||||} || |8}| }|dkr|S|||d||||||d} | |}||kr@|||||||S|||||||SdS)zl Merge the two runs at stack indices i and i+1. An updated MergeState is returned. r%rr&N)rrr) r5rrrNrrTrUrVrWrE)rrrr r r!r#rs,    ( z#make_timsort_impl..merge_atcs|jdkr|j}|jd}|dkrH||dj||j||djksv|dkr||dj||dj||jkr||dj||djkr|d8}||||}q||j||djkrֈ||||}qqq|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_collapsecsZ|jdkrV|j}|jd}|dkrF||dj||djkrF|d8}||||}q|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}q ||r|}|d}||kr||||||<||<|d7}|d8}qVdS)z, Reverse a slice, in-place. r&Nr!)rrrrIrNjrOr!r# reverse_sliceVs  z(make_timsort_impl..reverse_slicec st|}|dkrdS|}}|dkr||||\}}|rR|||||||krt||}||||||||}|t||}|||}||7}||8}q |||}|jdksJ|jddt|fksJdS)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 rbr!r#rsz&make_timsort_impl..run_timsortcs||||dS)z= Run timsort over the given keys and values. Nr!r")r4rbr!r#rs z2make_timsort_impl..run_timsort_with_values)rr1r)wrapr2rrr!)rYr;rrrrr$r1r2r8r rrr rr7rr r4r r r_rbrPrQr3r#make_timsort_impl9s|      1$UK /$rdcGstddg|RS)NcSs|Sr r!fr!r!r#z!make_py_timsort..)rdargsr!r!r#make_py_timsortsrkcs$ddlmtfddg|RS)Nrjitcsdd|S)NT)Znopythonr!rerlr!r#rgrhz"make_jit_timsort..)Znumbarmrdrir!rlr#make_jit_timsorts rn)__doc__ collectionsZ numba.corer namedtuplerr+r,r*rrrdrkrnr!r!r!r#s,   v