github.com/jxskiss/gopkg@v0.17.3/easy/sort_gen.go

// Code generated by go generate at 2021-05-13T13:03:38+08:00; DO NOT EDIT.

package easy

//go:generate go run sort_template.go

import "sort"

// Int8sAsc attaches the methods of sort.Interface to []int8, sorting in ascending order.
type Int8sAsc []int8

func (x Int8sAsc) Len() int           { return len(x) }
func (x Int8sAsc) Less(i, j int) bool { return x[i] < x[j] }
func (x Int8sAsc) Swap(i, j int)      { x[i], x[j] = x[j], x[i] }

// Sort is a convenience method which calls sort.Sort(x).
func (x Int8sAsc) Sort() { sort.Sort(x) }

// Int8sDesc attaches the methods of sort.Interface to []int8, sorting in descending order.
type Int8sDesc []int8

func (x Int8sDesc) Len() int           { return len(x) }
func (x Int8sDesc) Less(i, j int) bool { return x[i] > x[j] }
func (x Int8sDesc) Swap(i, j int)      { x[i], x[j] = x[j], x[i] }

// Sort is a convenience method which calls sort.Sort(x).
func (x Int8sDesc) Sort() { sort.Sort(x) }

// SortInt8sAsc is a convenience method which calls sort.Sort(Int8sAsc(x)).
func SortInt8sAsc(x []int8) { sort.Sort(Int8sAsc(x)) }

// SortInt8sDesc is a convenience method which calls sort.Sort(Int8sDesc(x)).
func SortInt8sDesc(x []int8) { sort.Sort(Int8sDesc(x)) }

// Int8sAreSortedAsc is a convenience method which calls sort.IsSorted(Int8sAsc(x)).
func Int8sAreSortedAsc(x []int8) bool { return sort.IsSorted(Int8sAsc(x)) }

// Int8sAreSortedDesc is a convenience method which calls sort.IsSorted(Int8sDesc(x)).
func Int8sAreSortedDesc(x []int8) bool { return sort.IsSorted(Int8sDesc(x)) }

// InSortedInt8s tells whether elem is in a sorted int8 slice.
// The given slice must be sorted in either ascending order or
// descending, else it may give incorrect result.
func InSortedInt8s(slice []int8, elem int8) bool {
	length := len(slice)
	if length == 0 {
		return false
	}
	if length == 1 || slice[0] == slice[length-1] {
		return slice[0] == elem
	}

	var less func(i int) bool
	if slice[0] <= slice[length-1] {
		// ascending order
		less = func(i int) bool { return slice[i] >= elem }
	} else {
		// descending order
		less = func(i int) bool { return slice[i] <= elem }
	}
	i := sort.Search(length, less)
	return i < len(slice) && slice[i] == elem
}

// Uint8sAsc attaches the methods of sort.Interface to []uint8, sorting in ascending order.
type Uint8sAsc []uint8

func (x Uint8sAsc) Len() int           { return len(x) }
func (x Uint8sAsc) Less(i, j int) bool { return x[i] < x[j] }
func (x Uint8sAsc) Swap(i, j int)      { x[i], x[j] = x[j], x[i] }

// Sort is a convenience method which calls sort.Sort(x).
func (x Uint8sAsc) Sort() { sort.Sort(x) }

// Uint8sDesc attaches the methods of sort.Interface to []uint8, sorting in descending order.
type Uint8sDesc []uint8

func (x Uint8sDesc) Len() int           { return len(x) }
func (x Uint8sDesc) Less(i, j int) bool { return x[i] > x[j] }
func (x Uint8sDesc) Swap(i, j int)      { x[i], x[j] = x[j], x[i] }

// Sort is a convenience method which calls sort.Sort(x).
func (x Uint8sDesc) Sort() { sort.Sort(x) }

// SortUint8sAsc is a convenience method which calls sort.Sort(Uint8sAsc(x)).
func SortUint8sAsc(x []uint8) { sort.Sort(Uint8sAsc(x)) }

// SortUint8sDesc is a convenience method which calls sort.Sort(Uint8sDesc(x)).
func SortUint8sDesc(x []uint8) { sort.Sort(Uint8sDesc(x)) }

// Uint8sAreSortedAsc is a convenience method which calls sort.IsSorted(Uint8sAsc(x)).
func Uint8sAreSortedAsc(x []uint8) bool { return sort.IsSorted(Uint8sAsc(x)) }

// Uint8sAreSortedDesc is a convenience method which calls sort.IsSorted(Uint8sDesc(x)).
func Uint8sAreSortedDesc(x []uint8) bool { return sort.IsSorted(Uint8sDesc(x)) }

// InSortedUint8s tells whether elem is in a sorted uint8 slice.
// The given slice must be sorted in either ascending order or
// descending, else it may give incorrect result.
func InSortedUint8s(slice []uint8, elem uint8) bool {
	length := len(slice)
	if length == 0 {
		return false
	}
	if length == 1 || slice[0] == slice[length-1] {
		return slice[0] == elem
	}

	var less func(i int) bool
	if slice[0] <= slice[length-1] {
		// ascending order
		less = func(i int) bool { return slice[i] >= elem }
	} else {
		// descending order
		less = func(i int) bool { return slice[i] <= elem }
	}
	i := sort.Search(length, less)
	return i < len(slice) && slice[i] == elem
}

// Int16sAsc attaches the methods of sort.Interface to []int16, sorting in ascending order.
type Int16sAsc []int16

func (x Int16sAsc) Len() int           { return len(x) }
func (x Int16sAsc) Less(i, j int) bool { return x[i] < x[j] }
func (x Int16sAsc) Swap(i, j int)      { x[i], x[j] = x[j], x[i] }

// Sort is a convenience method which calls sort.Sort(x).
func (x Int16sAsc) Sort() { sort.Sort(x) }

// Int16sDesc attaches the methods of sort.Interface to []int16, sorting in descending order.
type Int16sDesc []int16

func (x Int16sDesc) Len() int           { return len(x) }
func (x Int16sDesc) Less(i, j int) bool { return x[i] > x[j] }
func (x Int16sDesc) Swap(i, j int)      { x[i], x[j] = x[j], x[i] }

// Sort is a convenience method which calls sort.Sort(x).
func (x Int16sDesc) Sort() { sort.Sort(x) }

// SortInt16sAsc is a convenience method which calls sort.Sort(Int16sAsc(x)).
func SortInt16sAsc(x []int16) { sort.Sort(Int16sAsc(x)) }

// SortInt16sDesc is a convenience method which calls sort.Sort(Int16sDesc(x)).
func SortInt16sDesc(x []int16) { sort.Sort(Int16sDesc(x)) }

// Int16sAreSortedAsc is a convenience method which calls sort.IsSorted(Int16sAsc(x)).
func Int16sAreSortedAsc(x []int16) bool { return sort.IsSorted(Int16sAsc(x)) }

// Int16sAreSortedDesc is a convenience method which calls sort.IsSorted(Int16sDesc(x)).
func Int16sAreSortedDesc(x []int16) bool { return sort.IsSorted(Int16sDesc(x)) }

// InSortedInt16s tells whether elem is in a sorted int16 slice.
// The given slice must be sorted in either ascending order or
// descending, else it may give incorrect result.
func InSortedInt16s(slice []int16, elem int16) bool {
	length := len(slice)
	if length == 0 {
		return false
	}
	if length == 1 || slice[0] == slice[length-1] {
		return slice[0] == elem
	}

	var less func(i int) bool
	if slice[0] <= slice[length-1] {
		// ascending order
		less = func(i int) bool { return slice[i] >= elem }
	} else {
		// descending order
		less = func(i int) bool { return slice[i] <= elem }
	}
	i := sort.Search(length, less)
	return i < len(slice) && slice[i] == elem
}

// Uint16sAsc attaches the methods of sort.Interface to []uint16, sorting in ascending order.
type Uint16sAsc []uint16

func (x Uint16sAsc) Len() int           { return len(x) }
func (x Uint16sAsc) Less(i, j int) bool { return x[i] < x[j] }
func (x Uint16sAsc) Swap(i, j int)      { x[i], x[j] = x[j], x[i] }

// Sort is a convenience method which calls sort.Sort(x).
func (x Uint16sAsc) Sort() { sort.Sort(x) }

// Uint16sDesc attaches the methods of sort.Interface to []uint16, sorting in descending order.
type Uint16sDesc []uint16

func (x Uint16sDesc) Len() int           { return len(x) }
func (x Uint16sDesc) Less(i, j int) bool { return x[i] > x[j] }
func (x Uint16sDesc) Swap(i, j int)      { x[i], x[j] = x[j], x[i] }

// Sort is a convenience method which calls sort.Sort(x).
func (x Uint16sDesc) Sort() { sort.Sort(x) }

// SortUint16sAsc is a convenience method which calls sort.Sort(Uint16sAsc(x)).
func SortUint16sAsc(x []uint16) { sort.Sort(Uint16sAsc(x)) }

// SortUint16sDesc is a convenience method which calls sort.Sort(Uint16sDesc(x)).
func SortUint16sDesc(x []uint16) { sort.Sort(Uint16sDesc(x)) }

// Uint16sAreSortedAsc is a convenience method which calls sort.IsSorted(Uint16sAsc(x)).
func Uint16sAreSortedAsc(x []uint16) bool { return sort.IsSorted(Uint16sAsc(x)) }

// Uint16sAreSortedDesc is a convenience method which calls sort.IsSorted(Uint16sDesc(x)).
func Uint16sAreSortedDesc(x []uint16) bool { return sort.IsSorted(Uint16sDesc(x)) }

// InSortedUint16s tells whether elem is in a sorted uint16 slice.
// The given slice must be sorted in either ascending order or
// descending, else it may give incorrect result.
func InSortedUint16s(slice []uint16, elem uint16) bool {
	length := len(slice)
	if length == 0 {
		return false
	}
	if length == 1 || slice[0] == slice[length-1] {
		return slice[0] == elem
	}

	var less func(i int) bool
	if slice[0] <= slice[length-1] {
		// ascending order
		less = func(i int) bool { return slice[i] >= elem }
	} else {
		// descending order
		less = func(i int) bool { return slice[i] <= elem }
	}
	i := sort.Search(length, less)
	return i < len(slice) && slice[i] == elem
}

// Int32sAsc attaches the methods of sort.Interface to []int32, sorting in ascending order.
type Int32sAsc []int32

func (x Int32sAsc) Len() int           { return len(x) }
func (x Int32sAsc) Less(i, j int) bool { return x[i] < x[j] }
func (x Int32sAsc) Swap(i, j int)      { x[i], x[j] = x[j], x[i] }

// Sort is a convenience method which calls sort.Sort(x).
func (x Int32sAsc) Sort() { sort.Sort(x) }

// Int32sDesc attaches the methods of sort.Interface to []int32, sorting in descending order.
type Int32sDesc []int32

func (x Int32sDesc) Len() int           { return len(x) }
func (x Int32sDesc) Less(i, j int) bool { return x[i] > x[j] }
func (x Int32sDesc) Swap(i, j int)      { x[i], x[j] = x[j], x[i] }

// Sort is a convenience method which calls sort.Sort(x).
func (x Int32sDesc) Sort() { sort.Sort(x) }

// SortInt32sAsc is a convenience method which calls sort.Sort(Int32sAsc(x)).
func SortInt32sAsc(x []int32) { sort.Sort(Int32sAsc(x)) }

// SortInt32sDesc is a convenience method which calls sort.Sort(Int32sDesc(x)).
func SortInt32sDesc(x []int32) { sort.Sort(Int32sDesc(x)) }

// Int32sAreSortedAsc is a convenience method which calls sort.IsSorted(Int32sAsc(x)).
func Int32sAreSortedAsc(x []int32) bool { return sort.IsSorted(Int32sAsc(x)) }

// Int32sAreSortedDesc is a convenience method which calls sort.IsSorted(Int32sDesc(x)).
func Int32sAreSortedDesc(x []int32) bool { return sort.IsSorted(Int32sDesc(x)) }

// InSortedInt32s tells whether elem is in a sorted int32 slice.
// The given slice must be sorted in either ascending order or
// descending, else it may give incorrect result.
func InSortedInt32s(slice []int32, elem int32) bool {
	length := len(slice)
	if length == 0 {
		return false
	}
	if length == 1 || slice[0] == slice[length-1] {
		return slice[0] == elem
	}

	var less func(i int) bool
	if slice[0] <= slice[length-1] {
		// ascending order
		less = func(i int) bool { return slice[i] >= elem }
	} else {
		// descending order
		less = func(i int) bool { return slice[i] <= elem }
	}
	i := sort.Search(length, less)
	return i < len(slice) && slice[i] == elem
}

// Uint32sAsc attaches the methods of sort.Interface to []uint32, sorting in ascending order.
type Uint32sAsc []uint32

func (x Uint32sAsc) Len() int           { return len(x) }
func (x Uint32sAsc) Less(i, j int) bool { return x[i] < x[j] }
func (x Uint32sAsc) Swap(i, j int)      { x[i], x[j] = x[j], x[i] }

// Sort is a convenience method which calls sort.Sort(x).
func (x Uint32sAsc) Sort() { sort.Sort(x) }

// Uint32sDesc attaches the methods of sort.Interface to []uint32, sorting in descending order.
type Uint32sDesc []uint32

func (x Uint32sDesc) Len() int           { return len(x) }
func (x Uint32sDesc) Less(i, j int) bool { return x[i] > x[j] }
func (x Uint32sDesc) Swap(i, j int)      { x[i], x[j] = x[j], x[i] }

// Sort is a convenience method which calls sort.Sort(x).
func (x Uint32sDesc) Sort() { sort.Sort(x) }

// SortUint32sAsc is a convenience method which calls sort.Sort(Uint32sAsc(x)).
func SortUint32sAsc(x []uint32) { sort.Sort(Uint32sAsc(x)) }

// SortUint32sDesc is a convenience method which calls sort.Sort(Uint32sDesc(x)).
func SortUint32sDesc(x []uint32) { sort.Sort(Uint32sDesc(x)) }

// Uint32sAreSortedAsc is a convenience method which calls sort.IsSorted(Uint32sAsc(x)).
func Uint32sAreSortedAsc(x []uint32) bool { return sort.IsSorted(Uint32sAsc(x)) }

// Uint32sAreSortedDesc is a convenience method which calls sort.IsSorted(Uint32sDesc(x)).
func Uint32sAreSortedDesc(x []uint32) bool { return sort.IsSorted(Uint32sDesc(x)) }

// InSortedUint32s tells whether elem is in a sorted uint32 slice.
// The given slice must be sorted in either ascending order or
// descending, else it may give incorrect result.
func InSortedUint32s(slice []uint32, elem uint32) bool {
	length := len(slice)
	if length == 0 {
		return false
	}
	if length == 1 || slice[0] == slice[length-1] {
		return slice[0] == elem
	}

	var less func(i int) bool
	if slice[0] <= slice[length-1] {
		// ascending order
		less = func(i int) bool { return slice[i] >= elem }
	} else {
		// descending order
		less = func(i int) bool { return slice[i] <= elem }
	}
	i := sort.Search(length, less)
	return i < len(slice) && slice[i] == elem
}

// IntsAsc attaches the methods of sort.Interface to []int, sorting in ascending order.
type IntsAsc []int

func (x IntsAsc) Len() int           { return len(x) }
func (x IntsAsc) Less(i, j int) bool { return x[i] < x[j] }
func (x IntsAsc) Swap(i, j int)      { x[i], x[j] = x[j], x[i] }

// Sort is a convenience method which calls sort.Sort(x).
func (x IntsAsc) Sort() { sort.Sort(x) }

// IntsDesc attaches the methods of sort.Interface to []int, sorting in descending order.
type IntsDesc []int

func (x IntsDesc) Len() int           { return len(x) }
func (x IntsDesc) Less(i, j int) bool { return x[i] > x[j] }
func (x IntsDesc) Swap(i, j int)      { x[i], x[j] = x[j], x[i] }

// Sort is a convenience method which calls sort.Sort(x).
func (x IntsDesc) Sort() { sort.Sort(x) }

// SortIntsAsc is a convenience method which calls sort.Sort(IntsAsc(x)).
func SortIntsAsc(x []int) { sort.Sort(IntsAsc(x)) }

// SortIntsDesc is a convenience method which calls sort.Sort(IntsDesc(x)).
func SortIntsDesc(x []int) { sort.Sort(IntsDesc(x)) }

// IntsAreSortedAsc is a convenience method which calls sort.IsSorted(IntsAsc(x)).
func IntsAreSortedAsc(x []int) bool { return sort.IsSorted(IntsAsc(x)) }

// IntsAreSortedDesc is a convenience method which calls sort.IsSorted(IntsDesc(x)).
func IntsAreSortedDesc(x []int) bool { return sort.IsSorted(IntsDesc(x)) }

// InSortedInts tells whether elem is in a sorted int slice.
// The given slice must be sorted in either ascending order or
// descending, else it may give incorrect result.
func InSortedInts(slice []int, elem int) bool {
	length := len(slice)
	if length == 0 {
		return false
	}
	if length == 1 || slice[0] == slice[length-1] {
		return slice[0] == elem
	}

	var less func(i int) bool
	if slice[0] <= slice[length-1] {
		// ascending order
		less = func(i int) bool { return slice[i] >= elem }
	} else {
		// descending order
		less = func(i int) bool { return slice[i] <= elem }
	}
	i := sort.Search(length, less)
	return i < len(slice) && slice[i] == elem
}

// UintsAsc attaches the methods of sort.Interface to []uint, sorting in ascending order.
type UintsAsc []uint

func (x UintsAsc) Len() int           { return len(x) }
func (x UintsAsc) Less(i, j int) bool { return x[i] < x[j] }
func (x UintsAsc) Swap(i, j int)      { x[i], x[j] = x[j], x[i] }

// Sort is a convenience method which calls sort.Sort(x).
func (x UintsAsc) Sort() { sort.Sort(x) }

// UintsDesc attaches the methods of sort.Interface to []uint, sorting in descending order.
type UintsDesc []uint

func (x UintsDesc) Len() int           { return len(x) }
func (x UintsDesc) Less(i, j int) bool { return x[i] > x[j] }
func (x UintsDesc) Swap(i, j int)      { x[i], x[j] = x[j], x[i] }

// Sort is a convenience method which calls sort.Sort(x).
func (x UintsDesc) Sort() { sort.Sort(x) }

// SortUintsAsc is a convenience method which calls sort.Sort(UintsAsc(x)).
func SortUintsAsc(x []uint) { sort.Sort(UintsAsc(x)) }

// SortUintsDesc is a convenience method which calls sort.Sort(UintsDesc(x)).
func SortUintsDesc(x []uint) { sort.Sort(UintsDesc(x)) }

// UintsAreSortedAsc is a convenience method which calls sort.IsSorted(UintsAsc(x)).
func UintsAreSortedAsc(x []uint) bool { return sort.IsSorted(UintsAsc(x)) }

// UintsAreSortedDesc is a convenience method which calls sort.IsSorted(UintsDesc(x)).
func UintsAreSortedDesc(x []uint) bool { return sort.IsSorted(UintsDesc(x)) }

// InSortedUints tells whether elem is in a sorted uint slice.
// The given slice must be sorted in either ascending order or
// descending, else it may give incorrect result.
func InSortedUints(slice []uint, elem uint) bool {
	length := len(slice)
	if length == 0 {
		return false
	}
	if length == 1 || slice[0] == slice[length-1] {
		return slice[0] == elem
	}

	var less func(i int) bool
	if slice[0] <= slice[length-1] {
		// ascending order
		less = func(i int) bool { return slice[i] >= elem }
	} else {
		// descending order
		less = func(i int) bool { return slice[i] <= elem }
	}
	i := sort.Search(length, less)
	return i < len(slice) && slice[i] == elem
}

// UintptrsAsc attaches the methods of sort.Interface to []uintptr, sorting in ascending order.
type UintptrsAsc []uintptr

func (x UintptrsAsc) Len() int           { return len(x) }
func (x UintptrsAsc) Less(i, j int) bool { return x[i] < x[j] }
func (x UintptrsAsc) Swap(i, j int)      { x[i], x[j] = x[j], x[i] }

// Sort is a convenience method which calls sort.Sort(x).
func (x UintptrsAsc) Sort() { sort.Sort(x) }

// UintptrsDesc attaches the methods of sort.Interface to []uintptr, sorting in descending order.
type UintptrsDesc []uintptr

func (x UintptrsDesc) Len() int           { return len(x) }
func (x UintptrsDesc) Less(i, j int) bool { return x[i] > x[j] }
func (x UintptrsDesc) Swap(i, j int)      { x[i], x[j] = x[j], x[i] }

// Sort is a convenience method which calls sort.Sort(x).
func (x UintptrsDesc) Sort() { sort.Sort(x) }

// SortUintptrsAsc is a convenience method which calls sort.Sort(UintptrsAsc(x)).
func SortUintptrsAsc(x []uintptr) { sort.Sort(UintptrsAsc(x)) }

// SortUintptrsDesc is a convenience method which calls sort.Sort(UintptrsDesc(x)).
func SortUintptrsDesc(x []uintptr) { sort.Sort(UintptrsDesc(x)) }

// UintptrsAreSortedAsc is a convenience method which calls sort.IsSorted(UintptrsAsc(x)).
func UintptrsAreSortedAsc(x []uintptr) bool { return sort.IsSorted(UintptrsAsc(x)) }

// UintptrsAreSortedDesc is a convenience method which calls sort.IsSorted(UintptrsDesc(x)).
func UintptrsAreSortedDesc(x []uintptr) bool { return sort.IsSorted(UintptrsDesc(x)) }

// InSortedUintptrs tells whether elem is in a sorted uintptr slice.
// The given slice must be sorted in either ascending order or
// descending, else it may give incorrect result.
func InSortedUintptrs(slice []uintptr, elem uintptr) bool {
	length := len(slice)
	if length == 0 {
		return false
	}
	if length == 1 || slice[0] == slice[length-1] {
		return slice[0] == elem
	}

	var less func(i int) bool
	if slice[0] <= slice[length-1] {
		// ascending order
		less = func(i int) bool { return slice[i] >= elem }
	} else {
		// descending order
		less = func(i int) bool { return slice[i] <= elem }
	}
	i := sort.Search(length, less)
	return i < len(slice) && slice[i] == elem
}

// Int64sAsc attaches the methods of sort.Interface to []int64, sorting in ascending order.
type Int64sAsc []int64

func (x Int64sAsc) Len() int           { return len(x) }
func (x Int64sAsc) Less(i, j int) bool { return x[i] < x[j] }
func (x Int64sAsc) Swap(i, j int)      { x[i], x[j] = x[j], x[i] }

// Sort is a convenience method which calls sort.Sort(x).
func (x Int64sAsc) Sort() { sort.Sort(x) }

// Int64sDesc attaches the methods of sort.Interface to []int64, sorting in descending order.
type Int64sDesc []int64

func (x Int64sDesc) Len() int           { return len(x) }
func (x Int64sDesc) Less(i, j int) bool { return x[i] > x[j] }
func (x Int64sDesc) Swap(i, j int)      { x[i], x[j] = x[j], x[i] }

// Sort is a convenience method which calls sort.Sort(x).
func (x Int64sDesc) Sort() { sort.Sort(x) }

// SortInt64sAsc is a convenience method which calls sort.Sort(Int64sAsc(x)).
func SortInt64sAsc(x []int64) { sort.Sort(Int64sAsc(x)) }

// SortInt64sDesc is a convenience method which calls sort.Sort(Int64sDesc(x)).
func SortInt64sDesc(x []int64) { sort.Sort(Int64sDesc(x)) }

// Int64sAreSortedAsc is a convenience method which calls sort.IsSorted(Int64sAsc(x)).
func Int64sAreSortedAsc(x []int64) bool { return sort.IsSorted(Int64sAsc(x)) }

// Int64sAreSortedDesc is a convenience method which calls sort.IsSorted(Int64sDesc(x)).
func Int64sAreSortedDesc(x []int64) bool { return sort.IsSorted(Int64sDesc(x)) }

// InSortedInt64s tells whether elem is in a sorted int64 slice.
// The given slice must be sorted in either ascending order or
// descending, else it may give incorrect result.
func InSortedInt64s(slice []int64, elem int64) bool {
	length := len(slice)
	if length == 0 {
		return false
	}
	if length == 1 || slice[0] == slice[length-1] {
		return slice[0] == elem
	}

	var less func(i int) bool
	if slice[0] <= slice[length-1] {
		// ascending order
		less = func(i int) bool { return slice[i] >= elem }
	} else {
		// descending order
		less = func(i int) bool { return slice[i] <= elem }
	}
	i := sort.Search(length, less)
	return i < len(slice) && slice[i] == elem
}

// Uint64sAsc attaches the methods of sort.Interface to []uint64, sorting in ascending order.
type Uint64sAsc []uint64

func (x Uint64sAsc) Len() int           { return len(x) }
func (x Uint64sAsc) Less(i, j int) bool { return x[i] < x[j] }
func (x Uint64sAsc) Swap(i, j int)      { x[i], x[j] = x[j], x[i] }

// Sort is a convenience method which calls sort.Sort(x).
func (x Uint64sAsc) Sort() { sort.Sort(x) }

// Uint64sDesc attaches the methods of sort.Interface to []uint64, sorting in descending order.
type Uint64sDesc []uint64

func (x Uint64sDesc) Len() int           { return len(x) }
func (x Uint64sDesc) Less(i, j int) bool { return x[i] > x[j] }
func (x Uint64sDesc) Swap(i, j int)      { x[i], x[j] = x[j], x[i] }

// Sort is a convenience method which calls sort.Sort(x).
func (x Uint64sDesc) Sort() { sort.Sort(x) }

// SortUint64sAsc is a convenience method which calls sort.Sort(Uint64sAsc(x)).
func SortUint64sAsc(x []uint64) { sort.Sort(Uint64sAsc(x)) }

// SortUint64sDesc is a convenience method which calls sort.Sort(Uint64sDesc(x)).
func SortUint64sDesc(x []uint64) { sort.Sort(Uint64sDesc(x)) }

// Uint64sAreSortedAsc is a convenience method which calls sort.IsSorted(Uint64sAsc(x)).
func Uint64sAreSortedAsc(x []uint64) bool { return sort.IsSorted(Uint64sAsc(x)) }

// Uint64sAreSortedDesc is a convenience method which calls sort.IsSorted(Uint64sDesc(x)).
func Uint64sAreSortedDesc(x []uint64) bool { return sort.IsSorted(Uint64sDesc(x)) }

// InSortedUint64s tells whether elem is in a sorted uint64 slice.
// The given slice must be sorted in either ascending order or
// descending, else it may give incorrect result.
func InSortedUint64s(slice []uint64, elem uint64) bool {
	length := len(slice)
	if length == 0 {
		return false
	}
	if length == 1 || slice[0] == slice[length-1] {
		return slice[0] == elem
	}

	var less func(i int) bool
	if slice[0] <= slice[length-1] {
		// ascending order
		less = func(i int) bool { return slice[i] >= elem }
	} else {
		// descending order
		less = func(i int) bool { return slice[i] <= elem }
	}
	i := sort.Search(length, less)
	return i < len(slice) && slice[i] == elem
}

// Float32sAsc attaches the methods of sort.Interface to []float32, sorting in ascending order.
type Float32sAsc []float32

func (x Float32sAsc) Len() int           { return len(x) }
func (x Float32sAsc) Less(i, j int) bool { return x[i] < x[j] }
func (x Float32sAsc) Swap(i, j int)      { x[i], x[j] = x[j], x[i] }

// Sort is a convenience method which calls sort.Sort(x).
func (x Float32sAsc) Sort() { sort.Sort(x) }

// Float32sDesc attaches the methods of sort.Interface to []float32, sorting in descending order.
type Float32sDesc []float32

func (x Float32sDesc) Len() int           { return len(x) }
func (x Float32sDesc) Less(i, j int) bool { return x[i] > x[j] }
func (x Float32sDesc) Swap(i, j int)      { x[i], x[j] = x[j], x[i] }

// Sort is a convenience method which calls sort.Sort(x).
func (x Float32sDesc) Sort() { sort.Sort(x) }

// SortFloat32sAsc is a convenience method which calls sort.Sort(Float32sAsc(x)).
func SortFloat32sAsc(x []float32) { sort.Sort(Float32sAsc(x)) }

// SortFloat32sDesc is a convenience method which calls sort.Sort(Float32sDesc(x)).
func SortFloat32sDesc(x []float32) { sort.Sort(Float32sDesc(x)) }

// Float32sAreSortedAsc is a convenience method which calls sort.IsSorted(Float32sAsc(x)).
func Float32sAreSortedAsc(x []float32) bool { return sort.IsSorted(Float32sAsc(x)) }

// Float32sAreSortedDesc is a convenience method which calls sort.IsSorted(Float32sDesc(x)).
func Float32sAreSortedDesc(x []float32) bool { return sort.IsSorted(Float32sDesc(x)) }

// InSortedFloat32s tells whether elem is in a sorted float32 slice.
// The given slice must be sorted in either ascending order or
// descending, else it may give incorrect result.
func InSortedFloat32s(slice []float32, elem float32) bool {
	length := len(slice)
	if length == 0 {
		return false
	}
	if length == 1 || slice[0] == slice[length-1] {
		return slice[0] == elem
	}

	var less func(i int) bool
	if slice[0] <= slice[length-1] {
		// ascending order
		less = func(i int) bool { return slice[i] >= elem }
	} else {
		// descending order
		less = func(i int) bool { return slice[i] <= elem }
	}
	i := sort.Search(length, less)
	return i < len(slice) && slice[i] == elem
}

// Float64sAsc attaches the methods of sort.Interface to []float64, sorting in ascending order.
type Float64sAsc []float64

func (x Float64sAsc) Len() int           { return len(x) }
func (x Float64sAsc) Less(i, j int) bool { return x[i] < x[j] }
func (x Float64sAsc) Swap(i, j int)      { x[i], x[j] = x[j], x[i] }

// Sort is a convenience method which calls sort.Sort(x).
func (x Float64sAsc) Sort() { sort.Sort(x) }

// Float64sDesc attaches the methods of sort.Interface to []float64, sorting in descending order.
type Float64sDesc []float64

func (x Float64sDesc) Len() int           { return len(x) }
func (x Float64sDesc) Less(i, j int) bool { return x[i] > x[j] }
func (x Float64sDesc) Swap(i, j int)      { x[i], x[j] = x[j], x[i] }

// Sort is a convenience method which calls sort.Sort(x).
func (x Float64sDesc) Sort() { sort.Sort(x) }

// SortFloat64sAsc is a convenience method which calls sort.Sort(Float64sAsc(x)).
func SortFloat64sAsc(x []float64) { sort.Sort(Float64sAsc(x)) }

// SortFloat64sDesc is a convenience method which calls sort.Sort(Float64sDesc(x)).
func SortFloat64sDesc(x []float64) { sort.Sort(Float64sDesc(x)) }

// Float64sAreSortedAsc is a convenience method which calls sort.IsSorted(Float64sAsc(x)).
func Float64sAreSortedAsc(x []float64) bool { return sort.IsSorted(Float64sAsc(x)) }

// Float64sAreSortedDesc is a convenience method which calls sort.IsSorted(Float64sDesc(x)).
func Float64sAreSortedDesc(x []float64) bool { return sort.IsSorted(Float64sDesc(x)) }

// InSortedFloat64s tells whether elem is in a sorted float64 slice.
// The given slice must be sorted in either ascending order or
// descending, else it may give incorrect result.
func InSortedFloat64s(slice []float64, elem float64) bool {
	length := len(slice)
	if length == 0 {
		return false
	}
	if length == 1 || slice[0] == slice[length-1] {
		return slice[0] == elem
	}

	var less func(i int) bool
	if slice[0] <= slice[length-1] {
		// ascending order
		less = func(i int) bool { return slice[i] >= elem }
	} else {
		// descending order
		less = func(i int) bool { return slice[i] <= elem }
	}
	i := sort.Search(length, less)
	return i < len(slice) && slice[i] == elem
}

// StringsAsc attaches the methods of sort.Interface to []string, sorting in ascending order.
type StringsAsc []string

func (x StringsAsc) Len() int           { return len(x) }
func (x StringsAsc) Less(i, j int) bool { return x[i] < x[j] }
func (x StringsAsc) Swap(i, j int)      { x[i], x[j] = x[j], x[i] }

// Sort is a convenience method which calls sort.Sort(x).
func (x StringsAsc) Sort() { sort.Sort(x) }

// StringsDesc attaches the methods of sort.Interface to []string, sorting in descending order.
type StringsDesc []string

func (x StringsDesc) Len() int           { return len(x) }
func (x StringsDesc) Less(i, j int) bool { return x[i] > x[j] }
func (x StringsDesc) Swap(i, j int)      { x[i], x[j] = x[j], x[i] }

// Sort is a convenience method which calls sort.Sort(x).
func (x StringsDesc) Sort() { sort.Sort(x) }

// SortStringsAsc is a convenience method which calls sort.Sort(StringsAsc(x)).
func SortStringsAsc(x []string) { sort.Sort(StringsAsc(x)) }

// SortStringsDesc is a convenience method which calls sort.Sort(StringsDesc(x)).
func SortStringsDesc(x []string) { sort.Sort(StringsDesc(x)) }

// StringsAreSortedAsc is a convenience method which calls sort.IsSorted(StringsAsc(x)).
func StringsAreSortedAsc(x []string) bool { return sort.IsSorted(StringsAsc(x)) }

// StringsAreSortedDesc is a convenience method which calls sort.IsSorted(StringsDesc(x)).
func StringsAreSortedDesc(x []string) bool { return sort.IsSorted(StringsDesc(x)) }

// InSortedStrings tells whether elem is in a sorted string slice.
// The given slice must be sorted in either ascending order or
// descending, else it may give incorrect result.
func InSortedStrings(slice []string, elem string) bool {
	length := len(slice)
	if length == 0 {
		return false
	}
	if length == 1 || slice[0] == slice[length-1] {
		return slice[0] == elem
	}

	var less func(i int) bool
	if slice[0] <= slice[length-1] {
		// ascending order
		less = func(i int) bool { return slice[i] >= elem }
	} else {
		// descending order
		less = func(i int) bool { return slice[i] <= elem }
	}
	i := sort.Search(length, less)
	return i < len(slice) && slice[i] == elem
}