1 // Code generated by gen_sort_variants.go; DO NOT EDIT.
3 // Copyright 2022 The Go Authors. All rights reserved.
4 // Use of this source code is governed by a BSD-style
5 // license that can be found in the LICENSE file.
9 // insertionSort_func sorts data[a:b] using insertion sort.
10 func insertionSort_func(data lessSwap, a, b int) {
11 for i := a + 1; i < b; i++ {
12 for j := i; j > a && data.Less(j, j-1); j-- {
18 // siftDown_func implements the heap property on data[lo:hi].
19 // first is an offset into the array where the root of the heap lies.
20 func siftDown_func(data lessSwap, lo, hi, first int) {
27 if child+1 < hi && data.Less(first+child, first+child+1) {
30 if !data.Less(first+root, first+child) {
33 data.Swap(first+root, first+child)
38 func heapSort_func(data lessSwap, a, b int) {
43 // Build heap with greatest element at top.
44 for i := (hi - 1) / 2; i >= 0; i-- {
45 siftDown_func(data, i, hi, first)
48 // Pop elements, largest first, into end of data.
49 for i := hi - 1; i >= 0; i-- {
50 data.Swap(first, first+i)
51 siftDown_func(data, lo, i, first)
55 // pdqsort_func sorts data[a:b].
56 // The algorithm based on pattern-defeating quicksort(pdqsort), but without the optimizations from BlockQuicksort.
57 // pdqsort paper: https://arxiv.org/pdf/2106.05123.pdf
58 // C++ implementation: https://github.com/orlp/pdqsort
59 // Rust implementation: https://docs.rs/pdqsort/latest/pdqsort/
60 // limit is the number of allowed bad (very unbalanced) pivots before falling back to heapsort.
61 func pdqsort_func(data lessSwap, a, b, limit int) {
62 const maxInsertion = 12
65 wasBalanced = true // whether the last partitioning was reasonably balanced
66 wasPartitioned = true // whether the slice was already partitioned
72 if length <= maxInsertion {
73 insertionSort_func(data, a, b)
77 // Fall back to heapsort if too many bad choices were made.
79 heapSort_func(data, a, b)
83 // If the last partitioning was imbalanced, we need to breaking patterns.
85 breakPatterns_func(data, a, b)
89 pivot, hint := choosePivot_func(data, a, b)
90 if hint == decreasingHint {
91 reverseRange_func(data, a, b)
92 // The chosen pivot was pivot-a elements after the start of the array.
93 // After reversing it is pivot-a elements before the end of the array.
94 // The idea came from Rust's implementation.
95 pivot = (b - 1) - (pivot - a)
99 // The slice is likely already sorted.
100 if wasBalanced && wasPartitioned && hint == increasingHint {
101 if partialInsertionSort_func(data, a, b) {
106 // Probably the slice contains many duplicate elements, partition the slice into
107 // elements equal to and elements greater than the pivot.
108 if a > 0 && !data.Less(a-1, pivot) {
109 mid := partitionEqual_func(data, a, b, pivot)
114 mid, alreadyPartitioned := partition_func(data, a, b, pivot)
115 wasPartitioned = alreadyPartitioned
117 leftLen, rightLen := mid-a, b-mid
118 balanceThreshold := length / 8
119 if leftLen < rightLen {
120 wasBalanced = leftLen >= balanceThreshold
121 pdqsort_func(data, a, mid, limit)
124 wasBalanced = rightLen >= balanceThreshold
125 pdqsort_func(data, mid+1, b, limit)
131 // partition_func does one quicksort partition.
132 // Let p = data[pivot]
133 // Moves elements in data[a:b] around, so that data[i]<p and data[j]>=p for i<newpivot and j>newpivot.
134 // On return, data[newpivot] = p
135 func partition_func(data lessSwap, a, b, pivot int) (newpivot int, alreadyPartitioned bool) {
137 i, j := a+1, b-1 // i and j are inclusive of the elements remaining to be partitioned
139 for i <= j && data.Less(i, a) {
142 for i <= j && !data.Less(j, a) {
154 for i <= j && data.Less(i, a) {
157 for i <= j && !data.Less(j, a) {
171 // partitionEqual_func partitions data[a:b] into elements equal to data[pivot] followed by elements greater than data[pivot].
172 // It assumed that data[a:b] does not contain elements smaller than the data[pivot].
173 func partitionEqual_func(data lessSwap, a, b, pivot int) (newpivot int) {
175 i, j := a+1, b-1 // i and j are inclusive of the elements remaining to be partitioned
178 for i <= j && !data.Less(a, i) {
181 for i <= j && data.Less(a, j) {
194 // partialInsertionSort_func partially sorts a slice, returns true if the slice is sorted at the end.
195 func partialInsertionSort_func(data lessSwap, a, b int) bool {
197 maxSteps = 5 // maximum number of adjacent out-of-order pairs that will get shifted
198 shortestShifting = 50 // don't shift any elements on short arrays
201 for j := 0; j < maxSteps; j++ {
202 for i < b && !data.Less(i, i-1) {
210 if b-a < shortestShifting {
216 // Shift the smaller one to the left.
218 for j := i - 1; j >= 1; j-- {
219 if !data.Less(j, j-1) {
225 // Shift the greater one to the right.
227 for j := i + 1; j < b; j++ {
228 if !data.Less(j, j-1) {
238 // breakPatterns_func scatters some elements around in an attempt to break some patterns
239 // that might cause imbalanced partitions in quicksort.
240 func breakPatterns_func(data lessSwap, a, b int) {
243 random := xorshift(length)
244 modulus := nextPowerOfTwo(length)
246 for idx := a + (length/4)*2 - 1; idx <= a+(length/4)*2+1; idx++ {
247 other := int(uint(random.Next()) & (modulus - 1))
251 data.Swap(idx, a+other)
256 // choosePivot_func chooses a pivot in data[a:b].
258 // [0,8): chooses a static pivot.
259 // [8,shortestNinther): uses the simple median-of-three method.
260 // [shortestNinther,∞): uses the Tukey ninther method.
261 func choosePivot_func(data lessSwap, a, b int) (pivot int, hint sortedHint) {
277 if l >= shortestNinther {
278 // Tukey ninther method, the idea came from Rust's implementation.
279 i = medianAdjacent_func(data, i, &swaps)
280 j = medianAdjacent_func(data, j, &swaps)
281 k = medianAdjacent_func(data, k, &swaps)
283 // Find the median among i, j, k and stores it into j.
284 j = median_func(data, i, j, k, &swaps)
289 return j, increasingHint
291 return j, decreasingHint
293 return j, unknownHint
297 // order2_func returns x,y where data[x] <= data[y], where x,y=a,b or x,y=b,a.
298 func order2_func(data lessSwap, a, b int, swaps *int) (int, int) {
306 // median_func returns x where data[x] is the median of data[a],data[b],data[c], where x is a, b, or c.
307 func median_func(data lessSwap, a, b, c int, swaps *int) int {
308 a, b = order2_func(data, a, b, swaps)
309 b, c = order2_func(data, b, c, swaps)
310 a, b = order2_func(data, a, b, swaps)
314 // medianAdjacent_func finds the median of data[a - 1], data[a], data[a + 1] and stores the index into a.
315 func medianAdjacent_func(data lessSwap, a int, swaps *int) int {
316 return median_func(data, a-1, a, a+1, swaps)
319 func reverseRange_func(data lessSwap, a, b int) {
329 func swapRange_func(data lessSwap, a, b, n int) {
330 for i := 0; i < n; i++ {
335 func stable_func(data lessSwap, n int) {
336 blockSize := 20 // must be > 0
339 insertionSort_func(data, a, b)
343 insertionSort_func(data, a, n)
346 a, b = 0, 2*blockSize
348 symMerge_func(data, a, a+blockSize, b)
352 if m := a + blockSize; m < n {
353 symMerge_func(data, a, m, n)
359 // symMerge_func merges the two sorted subsequences data[a:m] and data[m:b] using
360 // the SymMerge algorithm from Pok-Son Kim and Arne Kutzner, "Stable Minimum
361 // Storage Merging by Symmetric Comparisons", in Susanne Albers and Tomasz
362 // Radzik, editors, Algorithms - ESA 2004, volume 3221 of Lecture Notes in
363 // Computer Science, pages 714-723. Springer, 2004.
365 // Let M = m-a and N = b-n. Wolog M < N.
366 // The recursion depth is bound by ceil(log(N+M)).
367 // The algorithm needs O(M*log(N/M + 1)) calls to data.Less.
368 // The algorithm needs O((M+N)*log(M)) calls to data.Swap.
370 // The paper gives O((M+N)*log(M)) as the number of assignments assuming a
371 // rotation algorithm which uses O(M+N+gcd(M+N)) assignments. The argumentation
372 // in the paper carries through for Swap operations, especially as the block
373 // swapping rotate uses only O(M+N) Swaps.
375 // symMerge assumes non-degenerate arguments: a < m && m < b.
376 // Having the caller check this condition eliminates many leaf recursion calls,
377 // which improves performance.
378 func symMerge_func(data lessSwap, a, m, b int) {
379 // Avoid unnecessary recursions of symMerge
380 // by direct insertion of data[a] into data[m:b]
381 // if data[a:m] only contains one element.
383 // Use binary search to find the lowest index i
384 // such that data[i] >= data[a] for m <= i < b.
385 // Exit the search loop with i == b in case no such index exists.
389 h := int(uint(i+j) >> 1)
396 // Swap values until data[a] reaches the position before i.
397 for k := a; k < i-1; k++ {
403 // Avoid unnecessary recursions of symMerge
404 // by direct insertion of data[m] into data[a:m]
405 // if data[m:b] only contains one element.
407 // Use binary search to find the lowest index i
408 // such that data[i] > data[m] for a <= i < m.
409 // Exit the search loop with i == m in case no such index exists.
413 h := int(uint(i+j) >> 1)
414 if !data.Less(m, h) {
420 // Swap values until data[m] reaches the position i.
421 for k := m; k > i; k-- {
427 mid := int(uint(a+b) >> 1)
440 c := int(uint(start+r) >> 1)
441 if !data.Less(p-c, c) {
449 if start < m && m < end {
450 rotate_func(data, start, m, end)
452 if a < start && start < mid {
453 symMerge_func(data, a, start, mid)
455 if mid < end && end < b {
456 symMerge_func(data, mid, end, b)
460 // rotate_func rotates two consecutive blocks u = data[a:m] and v = data[m:b] in data:
461 // Data of the form 'x u v y' is changed to 'x v u y'.
462 // rotate performs at most b-a many calls to data.Swap,
463 // and it assumes non-degenerate arguments: a < m && m < b.
464 func rotate_func(data lessSwap, a, m, b int) {
470 swapRange_func(data, m-i, m, j)
473 swapRange_func(data, m-i, m+j-i, i)
478 swapRange_func(data, m-i, m, i)