// compile

// Copyright 2020 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package p

type Float64Slice []float64

func (a Float64Slice) Search1(x float64) int {
	f := func(q int) bool { return a[q] >= x }
	i := 0
	if !f(3) {
		i = 5
	}
	return i

package sort

func intsImpl(x []int)         { Sort(IntSlice(x)) }
func float64sImpl(x []float64) { Sort(Float64Slice(x)) }
func stringsImpl(x []string)   { Sort(StringSlice(x)) }

func intsAreSortedImpl(x []int) bool         { return IsSorted(IntSlice(x)) }
func float64sAreSortedImpl(x []float64) bool { return IsSorted(Float64Slice(x)) }

// Sort is a convenience method: x.Sort() calls Sort(x).
func (x IntSlice) Sort() { Sort(x) }

// Float64Slice implements Interface for a []float64, sorting in increasing order,
// with not-a-number (NaN) values ordered before other values.
type Float64Slice []float64

func (x Float64Slice) Len() int { return len(x) }

// Less reports whether x[i] should be ordered before x[j], as required by the sort Interface.

}{
	{"SearchInts", SearchInts(data, 11), 8},
	{"SearchFloat64s", SearchFloat64s(fdata, 2.1), 4},
	{"SearchStrings", SearchStrings(sdata, ""), 0},
	{"IntSlice.Search", IntSlice(data).Search(0), 2},
	{"Float64Slice.Search", Float64Slice(fdata).Search(2.0), 3},
	{"StringSlice.Search", StringSlice(sdata).Search("x"), 3},
}

func TestSearchWrappers(t *testing.T) {
	for _, e := range wrappertests {
		if e.result != e.i {

func (p IntSlice) Search(x int) int { return SearchInts(p, x) }

// Search returns the result of applying [SearchFloat64s] to the receiver and x.
func (p Float64Slice) Search(x float64) int { return SearchFloat64s(p, x) }

// Search returns the result of applying [SearchStrings] to the receiver and x.

	data := float64s
	a := Float64Slice(data[0:])
	Sort(a)
	if !IsSorted(a) {
		t.Errorf("sorted %v", float64s)
		t.Errorf("   got %v", data)
	}
}

// Compare Sort with slices.Sort sorting a float64 slice containing NaNs.
func TestSortFloat64sCompareSlicesSort(t *testing.T) {
	slice1 := slices.Clone(float64s[:])
	slice2 := slices.Clone(float64s[:])

	Sort(Float64Slice(slice1))
	slices.Sort(slice2)

		{"Sort", Func, 21},
		{"SortFunc", Func, 21},
		{"SortStableFunc", Func, 21},
	},
	"sort": {
		{"(Float64Slice).Len", Method, 0},
		{"(Float64Slice).Less", Method, 0},
		{"(Float64Slice).Search", Method, 0},
		{"(Float64Slice).Sort", Method, 0},
		{"(Float64Slice).Swap", Method, 0},
		{"(IntSlice).Len", Method, 0},
		{"(IntSlice).Less", Method, 0},
		{"(IntSlice).Search", Method, 0},

pkg sort, func Strings([]string)
pkg sort, func StringsAreSorted([]string) bool
pkg sort, method (Float64Slice) Len() int
pkg sort, method (Float64Slice) Less(int, int) bool
pkg sort, method (Float64Slice) Search(float64) int
pkg sort, method (Float64Slice) Sort()
pkg sort, method (Float64Slice) Swap(int, int)
pkg sort, method (IntSlice) Len() int
pkg sort, method (IntSlice) Less(int, int) bool