zfuncversion.go

Documentation: sort

		 1  // Code generated from sort.go using genzfunc.go; DO NOT EDIT.
		 2  
		 3  // Copyright 2016 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.
		 6  
		 7  package sort
		 8  
		 9  // Auto-generated variant of sort.go:insertionSort
		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-- {
		13  			data.Swap(j, j-1)
		14  		}
		15  	}
		16  }
		17  
		18  // Auto-generated variant of sort.go:siftDown
		19  func siftDown_func(data lessSwap, lo, hi, first int) {
		20  	root := lo
		21  	for {
		22  		child := 2*root + 1
		23  		if child >= hi {
		24  			break
		25  		}
		26  		if child+1 < hi && data.Less(first+child, first+child+1) {
		27  			child++
		28  		}
		29  		if !data.Less(first+root, first+child) {
		30  			return
		31  		}
		32  		data.Swap(first+root, first+child)
		33  		root = child
		34  	}
		35  }
		36  
		37  // Auto-generated variant of sort.go:heapSort
		38  func heapSort_func(data lessSwap, a, b int) {
		39  	first := a
		40  	lo := 0
		41  	hi := b - a
		42  	for i := (hi - 1) / 2; i >= 0; i-- {
		43  		siftDown_func(data, i, hi, first)
		44  	}
		45  	for i := hi - 1; i >= 0; i-- {
		46  		data.Swap(first, first+i)
		47  		siftDown_func(data, lo, i, first)
		48  	}
		49  }
		50  
		51  // Auto-generated variant of sort.go:medianOfThree
		52  func medianOfThree_func(data lessSwap, m1, m0, m2 int) {
		53  	if data.Less(m1, m0) {
		54  		data.Swap(m1, m0)
		55  	}
		56  	if data.Less(m2, m1) {
		57  		data.Swap(m2, m1)
		58  		if data.Less(m1, m0) {
		59  			data.Swap(m1, m0)
		60  		}
		61  	}
		62  }
		63  
		64  // Auto-generated variant of sort.go:swapRange
		65  func swapRange_func(data lessSwap, a, b, n int) {
		66  	for i := 0; i < n; i++ {
		67  		data.Swap(a+i, b+i)
		68  	}
		69  }
		70  
		71  // Auto-generated variant of sort.go:doPivot
		72  func doPivot_func(data lessSwap, lo, hi int) (midlo, midhi int) {
		73  	m := int(uint(lo+hi) >> 1)
		74  	if hi-lo > 40 {
		75  		s := (hi - lo) / 8
		76  		medianOfThree_func(data, lo, lo+s, lo+2*s)
		77  		medianOfThree_func(data, m, m-s, m+s)
		78  		medianOfThree_func(data, hi-1, hi-1-s, hi-1-2*s)
		79  	}
		80  	medianOfThree_func(data, lo, m, hi-1)
		81  	pivot := lo
		82  	a, c := lo+1, hi-1
		83  	for ; a < c && data.Less(a, pivot); a++ {
		84  	}
		85  	b := a
		86  	for {
		87  		for ; b < c && !data.Less(pivot, b); b++ {
		88  		}
		89  		for ; b < c && data.Less(pivot, c-1); c-- {
		90  		}
		91  		if b >= c {
		92  			break
		93  		}
		94  		data.Swap(b, c-1)
		95  		b++
		96  		c--
		97  	}
		98  	protect := hi-c < 5
		99  	if !protect && hi-c < (hi-lo)/4 {
	 100  		dups := 0
	 101  		if !data.Less(pivot, hi-1) {
	 102  			data.Swap(c, hi-1)
	 103  			c++
	 104  			dups++
	 105  		}
	 106  		if !data.Less(b-1, pivot) {
	 107  			b--
	 108  			dups++
	 109  		}
	 110  		if !data.Less(m, pivot) {
	 111  			data.Swap(m, b-1)
	 112  			b--
	 113  			dups++
	 114  		}
	 115  		protect = dups > 1
	 116  	}
	 117  	if protect {
	 118  		for {
	 119  			for ; a < b && !data.Less(b-1, pivot); b-- {
	 120  			}
	 121  			for ; a < b && data.Less(a, pivot); a++ {
	 122  			}
	 123  			if a >= b {
	 124  				break
	 125  			}
	 126  			data.Swap(a, b-1)
	 127  			a++
	 128  			b--
	 129  		}
	 130  	}
	 131  	data.Swap(pivot, b-1)
	 132  	return b - 1, c
	 133  }
	 134  
	 135  // Auto-generated variant of sort.go:quickSort
	 136  func quickSort_func(data lessSwap, a, b, maxDepth int) {
	 137  	for b-a > 12 {
	 138  		if maxDepth == 0 {
	 139  			heapSort_func(data, a, b)
	 140  			return
	 141  		}
	 142  		maxDepth--
	 143  		mlo, mhi := doPivot_func(data, a, b)
	 144  		if mlo-a < b-mhi {
	 145  			quickSort_func(data, a, mlo, maxDepth)
	 146  			a = mhi
	 147  		} else {
	 148  			quickSort_func(data, mhi, b, maxDepth)
	 149  			b = mlo
	 150  		}
	 151  	}
	 152  	if b-a > 1 {
	 153  		for i := a + 6; i < b; i++ {
	 154  			if data.Less(i, i-6) {
	 155  				data.Swap(i, i-6)
	 156  			}
	 157  		}
	 158  		insertionSort_func(data, a, b)
	 159  	}
	 160  }
	 161  
	 162  // Auto-generated variant of sort.go:stable
	 163  func stable_func(data lessSwap, n int) {
	 164  	blockSize := 20
	 165  	a, b := 0, blockSize
	 166  	for b <= n {
	 167  		insertionSort_func(data, a, b)
	 168  		a = b
	 169  		b += blockSize
	 170  	}
	 171  	insertionSort_func(data, a, n)
	 172  	for blockSize < n {
	 173  		a, b = 0, 2*blockSize
	 174  		for b <= n {
	 175  			symMerge_func(data, a, a+blockSize, b)
	 176  			a = b
	 177  			b += 2 * blockSize
	 178  		}
	 179  		if m := a + blockSize; m < n {
	 180  			symMerge_func(data, a, m, n)
	 181  		}
	 182  		blockSize *= 2
	 183  	}
	 184  }
	 185  
	 186  // Auto-generated variant of sort.go:symMerge
	 187  func symMerge_func(data lessSwap, a, m, b int) {
	 188  	if m-a == 1 {
	 189  		i := m
	 190  		j := b
	 191  		for i < j {
	 192  			h := int(uint(i+j) >> 1)
	 193  			if data.Less(h, a) {
	 194  				i = h + 1
	 195  			} else {
	 196  				j = h
	 197  			}
	 198  		}
	 199  		for k := a; k < i-1; k++ {
	 200  			data.Swap(k, k+1)
	 201  		}
	 202  		return
	 203  	}
	 204  	if b-m == 1 {
	 205  		i := a
	 206  		j := m
	 207  		for i < j {
	 208  			h := int(uint(i+j) >> 1)
	 209  			if !data.Less(m, h) {
	 210  				i = h + 1
	 211  			} else {
	 212  				j = h
	 213  			}
	 214  		}
	 215  		for k := m; k > i; k-- {
	 216  			data.Swap(k, k-1)
	 217  		}
	 218  		return
	 219  	}
	 220  	mid := int(uint(a+b) >> 1)
	 221  	n := mid + m
	 222  	var start, r int
	 223  	if m > mid {
	 224  		start = n - b
	 225  		r = mid
	 226  	} else {
	 227  		start = a
	 228  		r = m
	 229  	}
	 230  	p := n - 1
	 231  	for start < r {
	 232  		c := int(uint(start+r) >> 1)
	 233  		if !data.Less(p-c, c) {
	 234  			start = c + 1
	 235  		} else {
	 236  			r = c
	 237  		}
	 238  	}
	 239  	end := n - start
	 240  	if start < m && m < end {
	 241  		rotate_func(data, start, m, end)
	 242  	}
	 243  	if a < start && start < mid {
	 244  		symMerge_func(data, a, start, mid)
	 245  	}
	 246  	if mid < end && end < b {
	 247  		symMerge_func(data, mid, end, b)
	 248  	}
	 249  }
	 250  
	 251  // Auto-generated variant of sort.go:rotate
	 252  func rotate_func(data lessSwap, a, m, b int) {
	 253  	i := m - a
	 254  	j := b - m
	 255  	for i != j {
	 256  		if i > j {
	 257  			swapRange_func(data, m-i, m, j)
	 258  			i -= j
	 259  		} else {
	 260  			swapRange_func(data, m-i, m+j-i, i)
	 261  			j -= i
	 262  		}
	 263  	}
	 264  	swapRange_func(data, m-i, m, i)
	 265  }
	 266
View as plain text