mirror of
https://github.com/gonum/gonum.git
synced 2025-11-01 02:52:49 +08:00
1404 lines
38 KiB
Go
1404 lines
38 KiB
Go
// Copyright 2013 The Gonum Authors. All rights reserved.
|
|
// Use of this code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file
|
|
|
|
package floats
|
|
|
|
import (
|
|
"math"
|
|
"math/rand"
|
|
"strconv"
|
|
"testing"
|
|
)
|
|
|
|
const (
|
|
EqTolerance = 1E-14
|
|
Small = 10
|
|
Medium = 1000
|
|
Large = 100000
|
|
Huge = 10000000
|
|
)
|
|
|
|
func AreSlicesEqual(t *testing.T, truth, comp []float64, str string) {
|
|
if !EqualApprox(comp, truth, EqTolerance) {
|
|
t.Errorf(str+". Expected %v, returned %v", truth, comp)
|
|
}
|
|
}
|
|
|
|
func Panics(fun func()) (b bool) {
|
|
defer func() {
|
|
err := recover()
|
|
if err != nil {
|
|
b = true
|
|
}
|
|
}()
|
|
fun()
|
|
return
|
|
}
|
|
|
|
func TestAdd(t *testing.T) {
|
|
a := []float64{1, 2, 3}
|
|
b := []float64{4, 5, 6}
|
|
c := []float64{7, 8, 9}
|
|
truth := []float64{12, 15, 18}
|
|
n := make([]float64, len(a))
|
|
|
|
Add(n, a)
|
|
Add(n, b)
|
|
Add(n, c)
|
|
AreSlicesEqual(t, truth, n, "Wrong addition of slices new receiver")
|
|
Add(a, b)
|
|
Add(a, c)
|
|
AreSlicesEqual(t, truth, n, "Wrong addition of slices for no new receiver")
|
|
|
|
// Test that it panics
|
|
if !Panics(func() { Add(make([]float64, 2), make([]float64, 3)) }) {
|
|
t.Errorf("Did not panic with length mismatch")
|
|
}
|
|
}
|
|
|
|
func TestAddTo(t *testing.T) {
|
|
a := []float64{1, 2, 3}
|
|
b := []float64{4, 5, 6}
|
|
truth := []float64{5, 7, 9}
|
|
n1 := make([]float64, len(a))
|
|
|
|
n2 := AddTo(n1, a, b)
|
|
AreSlicesEqual(t, truth, n1, "Bad addition from mutator")
|
|
AreSlicesEqual(t, truth, n2, "Bad addition from returned slice")
|
|
|
|
// Test that it panics
|
|
if !Panics(func() { AddTo(make([]float64, 2), make([]float64, 3), make([]float64, 3)) }) {
|
|
t.Errorf("Did not panic with length mismatch")
|
|
}
|
|
if !Panics(func() { AddTo(make([]float64, 3), make([]float64, 3), make([]float64, 2)) }) {
|
|
t.Errorf("Did not panic with length mismatch")
|
|
}
|
|
|
|
}
|
|
|
|
func TestAddConst(t *testing.T) {
|
|
s := []float64{3, 4, 1, 7, 5}
|
|
c := 6.0
|
|
truth := []float64{9, 10, 7, 13, 11}
|
|
AddConst(c, s)
|
|
AreSlicesEqual(t, truth, s, "Wrong addition of constant")
|
|
}
|
|
|
|
func TestAddScaled(t *testing.T) {
|
|
s := []float64{3, 4, 1, 7, 5}
|
|
alpha := 6.0
|
|
dst := []float64{1, 2, 3, 4, 5}
|
|
ans := []float64{19, 26, 9, 46, 35}
|
|
AddScaled(dst, alpha, s)
|
|
if !EqualApprox(dst, ans, EqTolerance) {
|
|
t.Errorf("Adding scaled did not match")
|
|
}
|
|
short := []float64{1}
|
|
if !Panics(func() { AddScaled(dst, alpha, short) }) {
|
|
t.Errorf("Doesn't panic if s is smaller than dst")
|
|
}
|
|
if !Panics(func() { AddScaled(short, alpha, s) }) {
|
|
t.Errorf("Doesn't panic if dst is smaller than s")
|
|
}
|
|
}
|
|
|
|
func TestAddScaledTo(t *testing.T) {
|
|
s := []float64{3, 4, 1, 7, 5}
|
|
alpha := 6.0
|
|
y := []float64{1, 2, 3, 4, 5}
|
|
dst1 := make([]float64, 5)
|
|
ans := []float64{19, 26, 9, 46, 35}
|
|
dst2 := AddScaledTo(dst1, y, alpha, s)
|
|
if !EqualApprox(dst1, ans, EqTolerance) {
|
|
t.Errorf("AddScaledTo did not match for mutator")
|
|
}
|
|
if !EqualApprox(dst2, ans, EqTolerance) {
|
|
t.Errorf("AddScaledTo did not match for returned slice")
|
|
}
|
|
AddScaledTo(dst1, y, alpha, s)
|
|
if !EqualApprox(dst1, ans, EqTolerance) {
|
|
t.Errorf("Reusing dst did not match")
|
|
}
|
|
short := []float64{1}
|
|
if !Panics(func() { AddScaledTo(dst1, y, alpha, short) }) {
|
|
t.Errorf("Doesn't panic if s is smaller than dst")
|
|
}
|
|
if !Panics(func() { AddScaledTo(short, y, alpha, s) }) {
|
|
t.Errorf("Doesn't panic if dst is smaller than s")
|
|
}
|
|
if !Panics(func() { AddScaledTo(dst1, short, alpha, s) }) {
|
|
t.Errorf("Doesn't panic if y is smaller than dst")
|
|
}
|
|
}
|
|
|
|
func TestArgsort(t *testing.T) {
|
|
s := []float64{3, 4, 1, 7, 5}
|
|
inds := make([]int, len(s))
|
|
|
|
Argsort(s, inds)
|
|
|
|
sortedS := []float64{1, 3, 4, 5, 7}
|
|
trueInds := []int{2, 0, 1, 4, 3}
|
|
|
|
if !Equal(s, sortedS) {
|
|
t.Error("elements not sorted correctly")
|
|
}
|
|
for i := range trueInds {
|
|
if trueInds[i] != inds[i] {
|
|
t.Error("inds not correct")
|
|
}
|
|
}
|
|
|
|
inds = []int{1, 2}
|
|
if !Panics(func() { Argsort(s, inds) }) {
|
|
t.Error("does not panic if lengths do not match")
|
|
}
|
|
}
|
|
|
|
func TestCount(t *testing.T) {
|
|
s := []float64{3, 4, 1, 7, 5}
|
|
f := func(v float64) bool { return v > 3.5 }
|
|
truth := 3
|
|
n := Count(f, s)
|
|
if n != truth {
|
|
t.Errorf("Wrong number of elements counted")
|
|
}
|
|
}
|
|
|
|
func TestCumProd(t *testing.T) {
|
|
s := []float64{3, 4, 1, 7, 5}
|
|
receiver := make([]float64, len(s))
|
|
result := CumProd(receiver, s)
|
|
truth := []float64{3, 12, 12, 84, 420}
|
|
AreSlicesEqual(t, truth, receiver, "Wrong cumprod mutated with new receiver")
|
|
AreSlicesEqual(t, truth, result, "Wrong cumprod result with new receiver")
|
|
CumProd(receiver, s)
|
|
AreSlicesEqual(t, truth, receiver, "Wrong cumprod returned with reused receiver")
|
|
|
|
// Test that it panics
|
|
if !Panics(func() { CumProd(make([]float64, 2), make([]float64, 3)) }) {
|
|
t.Errorf("Did not panic with length mismatch")
|
|
}
|
|
|
|
// Test empty CumProd
|
|
emptyReceiver := make([]float64, 0)
|
|
truth = []float64{}
|
|
CumProd(emptyReceiver, emptyReceiver)
|
|
AreSlicesEqual(t, truth, emptyReceiver, "Wrong cumprod returned with empty receiver")
|
|
|
|
}
|
|
|
|
func TestCumSum(t *testing.T) {
|
|
s := []float64{3, 4, 1, 7, 5}
|
|
receiver := make([]float64, len(s))
|
|
result := CumSum(receiver, s)
|
|
truth := []float64{3, 7, 8, 15, 20}
|
|
AreSlicesEqual(t, truth, receiver, "Wrong cumsum mutated with new receiver")
|
|
AreSlicesEqual(t, truth, result, "Wrong cumsum returned with new receiver")
|
|
CumSum(receiver, s)
|
|
AreSlicesEqual(t, truth, receiver, "Wrong cumsum returned with reused receiver")
|
|
|
|
// Test that it panics
|
|
if !Panics(func() { CumSum(make([]float64, 2), make([]float64, 3)) }) {
|
|
t.Errorf("Did not panic with length mismatch")
|
|
}
|
|
|
|
// Test empty CumSum
|
|
emptyReceiver := make([]float64, 0)
|
|
truth = []float64{}
|
|
CumSum(emptyReceiver, emptyReceiver)
|
|
AreSlicesEqual(t, truth, emptyReceiver, "Wrong cumsum returned with empty receiver")
|
|
|
|
}
|
|
|
|
func TestDistance(t *testing.T) {
|
|
norms := []float64{1, 2, 4, math.Inf(1)}
|
|
slices := []struct {
|
|
s []float64
|
|
t []float64
|
|
}{
|
|
{
|
|
nil,
|
|
nil,
|
|
},
|
|
{
|
|
[]float64{8, 9, 10, -12},
|
|
[]float64{8, 9, 10, -12},
|
|
},
|
|
{
|
|
[]float64{1, 2, 3, -4, -5, 8},
|
|
[]float64{-9.2, -6.8, 9, -3, -2, 1},
|
|
},
|
|
}
|
|
|
|
for j, test := range slices {
|
|
tmp := make([]float64, len(test.s))
|
|
for i, L := range norms {
|
|
dist := Distance(test.s, test.t, L)
|
|
copy(tmp, test.s)
|
|
Sub(tmp, test.t)
|
|
norm := Norm(tmp, L)
|
|
if dist != norm { // Use equality because they should be identical
|
|
t.Errorf("Distance does not match norm for case %v, %v. Expected %v, Found %v.", i, j, norm, dist)
|
|
}
|
|
}
|
|
}
|
|
|
|
if !Panics(func() { Distance([]float64{}, norms, 1) }) {
|
|
t.Errorf("Did not panic with unequal lengths")
|
|
}
|
|
|
|
}
|
|
|
|
func TestDiv(t *testing.T) {
|
|
s1 := []float64{5, 12, 27}
|
|
s2 := []float64{1, 2, 3}
|
|
ans := []float64{5, 6, 9}
|
|
Div(s1, s2)
|
|
if !EqualApprox(s1, ans, EqTolerance) {
|
|
t.Errorf("Mul doesn't give correct answer")
|
|
}
|
|
s1short := []float64{1}
|
|
if !Panics(func() { Div(s1short, s2) }) {
|
|
t.Errorf("Did not panic with unequal lengths")
|
|
}
|
|
s2short := []float64{1}
|
|
if !Panics(func() { Div(s1, s2short) }) {
|
|
t.Errorf("Did not panic with unequal lengths")
|
|
}
|
|
}
|
|
|
|
func TestDivTo(t *testing.T) {
|
|
s1 := []float64{5, 12, 27}
|
|
s1orig := []float64{5, 12, 27}
|
|
s2 := []float64{1, 2, 3}
|
|
s2orig := []float64{1, 2, 3}
|
|
dst1 := make([]float64, 3)
|
|
ans := []float64{5, 6, 9}
|
|
dst2 := DivTo(dst1, s1, s2)
|
|
if !EqualApprox(dst1, ans, EqTolerance) {
|
|
t.Errorf("DivTo doesn't give correct answer in mutated slice")
|
|
}
|
|
if !EqualApprox(dst2, ans, EqTolerance) {
|
|
t.Errorf("DivTo doesn't give correct answer in returned slice")
|
|
}
|
|
if !EqualApprox(s1, s1orig, EqTolerance) {
|
|
t.Errorf("S1 changes during multo")
|
|
}
|
|
if !EqualApprox(s2, s2orig, EqTolerance) {
|
|
t.Errorf("s2 changes during multo")
|
|
}
|
|
DivTo(dst1, s1, s2)
|
|
if !EqualApprox(dst1, ans, EqTolerance) {
|
|
t.Errorf("DivTo doesn't give correct answer reusing dst")
|
|
}
|
|
dstShort := []float64{1}
|
|
if !Panics(func() { DivTo(dstShort, s1, s2) }) {
|
|
t.Errorf("Did not panic with s1 wrong length")
|
|
}
|
|
s1short := []float64{1}
|
|
if !Panics(func() { DivTo(dst1, s1short, s2) }) {
|
|
t.Errorf("Did not panic with s1 wrong length")
|
|
}
|
|
s2short := []float64{1}
|
|
if !Panics(func() { DivTo(dst1, s1, s2short) }) {
|
|
t.Errorf("Did not panic with s2 wrong length")
|
|
}
|
|
}
|
|
|
|
func TestDot(t *testing.T) {
|
|
s1 := []float64{1, 2, 3, 4}
|
|
s2 := []float64{-3, 4, 5, -6}
|
|
truth := -4.0
|
|
ans := Dot(s1, s2)
|
|
if ans != truth {
|
|
t.Errorf("Dot product computed incorrectly")
|
|
}
|
|
|
|
// Test that it panics
|
|
if !Panics(func() { Dot(make([]float64, 2), make([]float64, 3)) }) {
|
|
t.Errorf("Did not panic with length mismatch")
|
|
}
|
|
}
|
|
|
|
func TestEquals(t *testing.T) {
|
|
s1 := []float64{1, 2, 3, 4}
|
|
s2 := []float64{1, 2, 3, 4}
|
|
if !Equal(s1, s2) {
|
|
t.Errorf("Equal slices returned as unequal")
|
|
}
|
|
s2 = []float64{1, 2, 3, 4 + 1e-14}
|
|
if Equal(s1, s2) {
|
|
t.Errorf("Unequal slices returned as equal")
|
|
}
|
|
if Equal(s1, []float64{}) {
|
|
t.Errorf("Unequal slice lengths returned as equal")
|
|
}
|
|
}
|
|
|
|
func TestEqualApprox(t *testing.T) {
|
|
s1 := []float64{1, 2, 3, 4}
|
|
s2 := []float64{1, 2, 3, 4 + 1e-10}
|
|
if EqualApprox(s1, s2, 1e-13) {
|
|
t.Errorf("Unequal slices returned as equal for absolute")
|
|
}
|
|
if !EqualApprox(s1, s2, 1e-5) {
|
|
t.Errorf("Equal slices returned as unequal for absolute")
|
|
}
|
|
s1 = []float64{1, 2, 3, 1000}
|
|
s2 = []float64{1, 2, 3, 1000 * (1 + 1e-7)}
|
|
if EqualApprox(s1, s2, 1e-8) {
|
|
t.Errorf("Unequal slices returned as equal for relative")
|
|
}
|
|
if !EqualApprox(s1, s2, 1e-5) {
|
|
t.Errorf("Equal slices returned as unequal for relative")
|
|
}
|
|
if EqualApprox(s1, []float64{}, 1e-5) {
|
|
t.Errorf("Unequal slice lengths returned as equal")
|
|
}
|
|
}
|
|
|
|
func TestEqualFunc(t *testing.T) {
|
|
s1 := []float64{1, 2, 3, 4}
|
|
s2 := []float64{1, 2, 3, 4}
|
|
eq := func(x, y float64) bool { return x == y }
|
|
if !EqualFunc(s1, s2, eq) {
|
|
t.Errorf("Equal slices returned as unequal")
|
|
}
|
|
s2 = []float64{1, 2, 3, 4 + 1e-14}
|
|
if EqualFunc(s1, s2, eq) {
|
|
t.Errorf("Unequal slices returned as equal")
|
|
}
|
|
if EqualFunc(s1, []float64{}, eq) {
|
|
t.Errorf("Unequal slice lengths returned as equal")
|
|
}
|
|
}
|
|
|
|
func TestEqualsRelative(t *testing.T) {
|
|
var equalityTests = []struct {
|
|
a, b float64
|
|
tol float64
|
|
equal bool
|
|
}{
|
|
{1000000, 1000001, 0, true},
|
|
{1000001, 1000000, 0, true},
|
|
{10000, 10001, 0, false},
|
|
{10001, 10000, 0, false},
|
|
{-1000000, -1000001, 0, true},
|
|
{-1000001, -1000000, 0, true},
|
|
{-10000, -10001, 0, false},
|
|
{-10001, -10000, 0, false},
|
|
{1.0000001, 1.0000002, 0, true},
|
|
{1.0000002, 1.0000001, 0, true},
|
|
{1.0002, 1.0001, 0, false},
|
|
{1.0001, 1.0002, 0, false},
|
|
{-1.000001, -1.000002, 0, true},
|
|
{-1.000002, -1.000001, 0, true},
|
|
{-1.0001, -1.0002, 0, false},
|
|
{-1.0002, -1.0001, 0, false},
|
|
{0.000000001000001, 0.000000001000002, 0, true},
|
|
{0.000000001000002, 0.000000001000001, 0, true},
|
|
{0.000000000001002, 0.000000000001001, 0, false},
|
|
{0.000000000001001, 0.000000000001002, 0, false},
|
|
{-0.000000001000001, -0.000000001000002, 0, true},
|
|
{-0.000000001000002, -0.000000001000001, 0, true},
|
|
{-0.000000000001002, -0.000000000001001, 0, false},
|
|
{-0.000000000001001, -0.000000000001002, 0, false},
|
|
{0, 0, 0, true},
|
|
{0, -0, 0, true},
|
|
{-0, -0, 0, true},
|
|
{0.00000001, 0, 0, false},
|
|
{0, 0.00000001, 0, false},
|
|
{-0.00000001, 0, 0, false},
|
|
{0, -0.00000001, 0, false},
|
|
{0, 1e-310, 0.01, true},
|
|
{1e-310, 0, 0.01, true},
|
|
{1e-310, 0, 0.000001, false},
|
|
{0, 1e-310, 0.000001, false},
|
|
{0, -1e-310, 0.1, true},
|
|
{-1e-310, 0, 0.1, true},
|
|
{-1e-310, 0, 0.00000001, false},
|
|
{0, -1e-310, 0.00000001, false},
|
|
{math.Inf(1), math.Inf(1), 0, true},
|
|
{math.Inf(-1), math.Inf(-1), 0, true},
|
|
{math.Inf(-1), math.Inf(1), 0, false},
|
|
{math.Inf(1), math.MaxFloat64, 0, false},
|
|
{math.Inf(-1), -math.MaxFloat64, 0, false},
|
|
{math.NaN(), math.NaN(), 0, false},
|
|
{math.NaN(), 0, 0, false},
|
|
{-0, math.NaN(), 0, false},
|
|
{math.NaN(), -0, 0, false},
|
|
{0, math.NaN(), 0, false},
|
|
{math.NaN(), math.Inf(1), 0, false},
|
|
{math.Inf(1), math.NaN(), 0, false},
|
|
{math.NaN(), math.Inf(-1), 0, false},
|
|
{math.Inf(-1), math.NaN(), 0, false},
|
|
{math.NaN(), math.MaxFloat64, 0, false},
|
|
{math.MaxFloat64, math.NaN(), 0, false},
|
|
{math.NaN(), -math.MaxFloat64, 0, false},
|
|
{-math.MaxFloat64, math.NaN(), 0, false},
|
|
{math.NaN(), math.SmallestNonzeroFloat64, 0, false},
|
|
{math.SmallestNonzeroFloat64, math.NaN(), 0, false},
|
|
{math.NaN(), -math.SmallestNonzeroFloat64, 0, false},
|
|
{-math.SmallestNonzeroFloat64, math.NaN(), 0, false},
|
|
{1.000000001, -1.0, 0, false},
|
|
{-1.0, 1.000000001, 0, false},
|
|
{-1.000000001, 1.0, 0, false},
|
|
{1.0, -1.000000001, 0, false},
|
|
{10 * math.SmallestNonzeroFloat64, 10 * -math.SmallestNonzeroFloat64, 0, true},
|
|
{1e11 * math.SmallestNonzeroFloat64, 1e11 * -math.SmallestNonzeroFloat64, 0, false},
|
|
{math.SmallestNonzeroFloat64, -math.SmallestNonzeroFloat64, 0, true},
|
|
{-math.SmallestNonzeroFloat64, math.SmallestNonzeroFloat64, 0, true},
|
|
{math.SmallestNonzeroFloat64, 0, 0, true},
|
|
{0, math.SmallestNonzeroFloat64, 0, true},
|
|
{-math.SmallestNonzeroFloat64, 0, 0, true},
|
|
{0, -math.SmallestNonzeroFloat64, 0, true},
|
|
{0.000000001, -math.SmallestNonzeroFloat64, 0, false},
|
|
{0.000000001, math.SmallestNonzeroFloat64, 0, false},
|
|
{math.SmallestNonzeroFloat64, 0.000000001, 0, false},
|
|
{-math.SmallestNonzeroFloat64, 0.000000001, 0, false},
|
|
}
|
|
for _, ts := range equalityTests {
|
|
if ts.tol == 0 {
|
|
ts.tol = 1e-5
|
|
}
|
|
if equal := EqualWithinRel(ts.a, ts.b, ts.tol); equal != ts.equal {
|
|
t.Errorf("Relative equality of %g and %g with tolerance %g returned: %v. Expected: %v",
|
|
ts.a, ts.b, ts.tol, equal, ts.equal)
|
|
}
|
|
}
|
|
}
|
|
|
|
func nextAfterN(x, y float64, n int) float64 {
|
|
for i := 0; i < n; i++ {
|
|
x = math.Nextafter(x, y)
|
|
}
|
|
return x
|
|
}
|
|
|
|
func TestEqualsULP(t *testing.T) {
|
|
if f := 67329.242; !EqualWithinULP(f, nextAfterN(f, math.Inf(1), 10), 10) {
|
|
t.Errorf("Equal values returned as unequal")
|
|
}
|
|
if f := 67329.242; EqualWithinULP(f, nextAfterN(f, math.Inf(1), 5), 1) {
|
|
t.Errorf("Unequal values returned as equal")
|
|
}
|
|
if f := 67329.242; EqualWithinULP(nextAfterN(f, math.Inf(1), 5), f, 1) {
|
|
t.Errorf("Unequal values returned as equal")
|
|
}
|
|
if f := nextAfterN(0, math.Inf(1), 2); !EqualWithinULP(f, nextAfterN(f, math.Inf(-1), 5), 10) {
|
|
t.Errorf("Equal values returned as unequal")
|
|
}
|
|
if !EqualWithinULP(67329.242, 67329.242, 10) {
|
|
t.Errorf("Equal float64s not returned as equal")
|
|
}
|
|
if EqualWithinULP(1, math.NaN(), 10) {
|
|
t.Errorf("NaN returned as equal")
|
|
}
|
|
|
|
}
|
|
|
|
func TestEqualLengths(t *testing.T) {
|
|
s1 := []float64{1, 2, 3, 4}
|
|
s2 := []float64{1, 2, 3, 4}
|
|
s3 := []float64{1, 2, 3}
|
|
if !EqualLengths(s1, s2) {
|
|
t.Errorf("Equal lengths returned as unequal")
|
|
}
|
|
if EqualLengths(s1, s3) {
|
|
t.Errorf("Unequal lengths returned as equal")
|
|
}
|
|
if !EqualLengths(s1) {
|
|
t.Errorf("Single slice returned as unequal")
|
|
}
|
|
if !EqualLengths() {
|
|
t.Errorf("No slices returned as unequal")
|
|
}
|
|
}
|
|
|
|
func eqIntSlice(one, two []int) string {
|
|
if len(one) != len(two) {
|
|
return "Length mismatch"
|
|
}
|
|
for i, val := range one {
|
|
if val != two[i] {
|
|
return "Index " + strconv.Itoa(i) + " mismatch"
|
|
}
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func TestFind(t *testing.T) {
|
|
s := []float64{3, 4, 1, 7, 5}
|
|
f := func(v float64) bool { return v > 3.5 }
|
|
allTrueInds := []int{1, 3, 4}
|
|
|
|
// Test finding first two elements
|
|
inds, err := Find(nil, f, s, 2)
|
|
if err != nil {
|
|
t.Errorf("Find first two: Improper error return")
|
|
}
|
|
trueInds := allTrueInds[:2]
|
|
str := eqIntSlice(inds, trueInds)
|
|
if str != "" {
|
|
t.Errorf("Find first two: " + str)
|
|
}
|
|
|
|
// Test finding no elements with non nil slice
|
|
inds = []int{1, 2, 3, 4, 5, 6}
|
|
inds, err = Find(inds, f, s, 0)
|
|
if err != nil {
|
|
t.Errorf("Find no elements: Improper error return")
|
|
}
|
|
str = eqIntSlice(inds, []int{})
|
|
if str != "" {
|
|
t.Errorf("Find no non-nil: " + str)
|
|
}
|
|
|
|
// Test finding first two elements with non nil slice
|
|
inds = []int{1, 2, 3, 4, 5, 6}
|
|
inds, err = Find(inds, f, s, 2)
|
|
if err != nil {
|
|
t.Errorf("Find first two non-nil: Improper error return")
|
|
}
|
|
str = eqIntSlice(inds, trueInds)
|
|
if str != "" {
|
|
t.Errorf("Find first two non-nil: " + str)
|
|
}
|
|
|
|
// Test finding too many elements
|
|
inds, err = Find(inds, f, s, 4)
|
|
if err == nil {
|
|
t.Errorf("Request too many: No error returned")
|
|
}
|
|
str = eqIntSlice(inds, allTrueInds)
|
|
if str != "" {
|
|
t.Errorf("Request too many: Does not match all of the inds: " + str)
|
|
}
|
|
|
|
// Test finding all elements
|
|
inds, err = Find(nil, f, s, -1)
|
|
if err != nil {
|
|
t.Errorf("Find all: Improper error returned")
|
|
}
|
|
str = eqIntSlice(inds, allTrueInds)
|
|
if str != "" {
|
|
t.Errorf("Find all: Does not match all of the inds: " + str)
|
|
}
|
|
}
|
|
|
|
func TestHasNaN(t *testing.T) {
|
|
for i, test := range []struct {
|
|
s []float64
|
|
ans bool
|
|
}{
|
|
{},
|
|
{
|
|
s: []float64{1, 2, 3, 4},
|
|
},
|
|
{
|
|
s: []float64{1, math.NaN(), 3, 4},
|
|
ans: true,
|
|
},
|
|
{
|
|
s: []float64{1, 2, 3, math.NaN()},
|
|
ans: true,
|
|
},
|
|
} {
|
|
b := HasNaN(test.s)
|
|
if b != test.ans {
|
|
t.Errorf("HasNaN mismatch case %d. Expected %v, Found %v", i, test.ans, b)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestLogSpan(t *testing.T) {
|
|
receiver1 := make([]float64, 6)
|
|
truth := []float64{0.001, 0.01, 0.1, 1, 10, 100}
|
|
receiver2 := LogSpan(receiver1, 0.001, 100)
|
|
tst := make([]float64, 6)
|
|
for i := range truth {
|
|
tst[i] = receiver1[i] / truth[i]
|
|
}
|
|
comp := make([]float64, 6)
|
|
for i := range comp {
|
|
comp[i] = 1
|
|
}
|
|
AreSlicesEqual(t, comp, tst, "Improper logspace from mutator")
|
|
|
|
for i := range truth {
|
|
tst[i] = receiver2[i] / truth[i]
|
|
}
|
|
AreSlicesEqual(t, comp, tst, "Improper logspace from returned slice")
|
|
|
|
if !Panics(func() { LogSpan(nil, 1, 5) }) {
|
|
t.Errorf("Span accepts nil argument")
|
|
}
|
|
if !Panics(func() { LogSpan(make([]float64, 1), 1, 5) }) {
|
|
t.Errorf("Span accepts argument of len = 1")
|
|
}
|
|
}
|
|
|
|
func TestLogSumExp(t *testing.T) {
|
|
s := []float64{1, 2, 3, 4, 5}
|
|
val := LogSumExp(s)
|
|
// http://www.wolframalpha.com/input/?i=log%28exp%281%29+%2B+exp%282%29+%2B+exp%283%29+%2B+exp%284%29+%2B+exp%285%29%29
|
|
truth := 5.4519143959375933331957225109748087179338972737576824
|
|
if math.Abs(val-truth) > EqTolerance {
|
|
t.Errorf("Wrong logsumexp for many values")
|
|
}
|
|
s = []float64{1, 2}
|
|
// http://www.wolframalpha.com/input/?i=log%28exp%281%29+%2B+exp%282%29%29
|
|
truth = 2.3132616875182228340489954949678556419152800856703483
|
|
val = LogSumExp(s)
|
|
if math.Abs(val-truth) > EqTolerance {
|
|
t.Errorf("Wrong logsumexp for two values. %v expected, %v found", truth, val)
|
|
}
|
|
// This case would normally underflow
|
|
s = []float64{-1001, -1002, -1003, -1004, -1005}
|
|
// http://www.wolframalpha.com/input/?i=log%28exp%28-1001%29%2Bexp%28-1002%29%2Bexp%28-1003%29%2Bexp%28-1004%29%2Bexp%28-1005%29%29
|
|
truth = -1000.54808560406240666680427748902519128206610272624
|
|
val = LogSumExp(s)
|
|
if math.Abs(val-truth) > EqTolerance {
|
|
t.Errorf("Doesn't match for underflow case. %v expected, %v found", truth, val)
|
|
}
|
|
// positive infinite case
|
|
s = []float64{1, 2, 3, 4, 5, math.Inf(1)}
|
|
val = LogSumExp(s)
|
|
truth = math.Inf(1)
|
|
if val != truth {
|
|
t.Errorf("Doesn't match for pos Infinity case. %v expected, %v found", truth, val)
|
|
}
|
|
// negative infinite case
|
|
s = []float64{1, 2, 3, 4, 5, math.Inf(-1)}
|
|
val = LogSumExp(s)
|
|
truth = 5.4519143959375933331957225109748087179338972737576824 // same as first case
|
|
if math.Abs(val-truth) > EqTolerance {
|
|
t.Errorf("Wrong logsumexp for values with negative infinity")
|
|
}
|
|
|
|
}
|
|
|
|
func TestMaxAndIdx(t *testing.T) {
|
|
s := []float64{3, 4, 1, 7, 5}
|
|
ind := MaxIdx(s)
|
|
val := Max(s)
|
|
if val != 7 {
|
|
t.Errorf("Wrong value returned")
|
|
}
|
|
if ind != 3 {
|
|
t.Errorf("Wrong index returned")
|
|
}
|
|
}
|
|
|
|
func TestMinAndIdx(t *testing.T) {
|
|
s := []float64{3, 4, 1, 7, 5}
|
|
ind := MinIdx(s)
|
|
val := Min(s)
|
|
if val != 1 {
|
|
t.Errorf("Wrong value returned")
|
|
}
|
|
if ind != 2 {
|
|
t.Errorf("Wrong index returned")
|
|
}
|
|
}
|
|
|
|
func TestMul(t *testing.T) {
|
|
s1 := []float64{1, 2, 3}
|
|
s2 := []float64{1, 2, 3}
|
|
ans := []float64{1, 4, 9}
|
|
Mul(s1, s2)
|
|
if !EqualApprox(s1, ans, EqTolerance) {
|
|
t.Errorf("Mul doesn't give correct answer")
|
|
}
|
|
s1short := []float64{1}
|
|
if !Panics(func() { Mul(s1short, s2) }) {
|
|
t.Errorf("Did not panic with unequal lengths")
|
|
}
|
|
s2short := []float64{1}
|
|
if !Panics(func() { Mul(s1, s2short) }) {
|
|
t.Errorf("Did not panic with unequal lengths")
|
|
}
|
|
}
|
|
|
|
func TestMulTo(t *testing.T) {
|
|
s1 := []float64{1, 2, 3}
|
|
s1orig := []float64{1, 2, 3}
|
|
s2 := []float64{1, 2, 3}
|
|
s2orig := []float64{1, 2, 3}
|
|
dst1 := make([]float64, 3)
|
|
ans := []float64{1, 4, 9}
|
|
dst2 := MulTo(dst1, s1, s2)
|
|
if !EqualApprox(dst1, ans, EqTolerance) {
|
|
t.Errorf("MulTo doesn't give correct answer in mutated slice")
|
|
}
|
|
if !EqualApprox(dst2, ans, EqTolerance) {
|
|
t.Errorf("MulTo doesn't give correct answer in returned slice")
|
|
}
|
|
if !EqualApprox(s1, s1orig, EqTolerance) {
|
|
t.Errorf("S1 changes during multo")
|
|
}
|
|
if !EqualApprox(s2, s2orig, EqTolerance) {
|
|
t.Errorf("s2 changes during multo")
|
|
}
|
|
MulTo(dst1, s1, s2)
|
|
if !EqualApprox(dst1, ans, EqTolerance) {
|
|
t.Errorf("MulTo doesn't give correct answer reusing dst")
|
|
}
|
|
dstShort := []float64{1}
|
|
if !Panics(func() { MulTo(dstShort, s1, s2) }) {
|
|
t.Errorf("Did not panic with s1 wrong length")
|
|
}
|
|
s1short := []float64{1}
|
|
if !Panics(func() { MulTo(dst1, s1short, s2) }) {
|
|
t.Errorf("Did not panic with s1 wrong length")
|
|
}
|
|
s2short := []float64{1}
|
|
if !Panics(func() { MulTo(dst1, s1, s2short) }) {
|
|
t.Errorf("Did not panic with s2 wrong length")
|
|
}
|
|
}
|
|
|
|
func TestNearest(t *testing.T) {
|
|
s := []float64{6.2, 3, 5, 6.2, 8}
|
|
ind := Nearest(s, 2.0)
|
|
if ind != 1 {
|
|
t.Errorf("Wrong index returned when value is less than all of elements")
|
|
}
|
|
ind = Nearest(s, 9.0)
|
|
if ind != 4 {
|
|
t.Errorf("Wrong index returned when value is greater than all of elements")
|
|
}
|
|
ind = Nearest(s, 3.1)
|
|
if ind != 1 {
|
|
t.Errorf("Wrong index returned when value is greater than closest element")
|
|
}
|
|
ind = Nearest(s, 3.1)
|
|
if ind != 1 {
|
|
t.Errorf("Wrong index returned when value is greater than closest element")
|
|
}
|
|
ind = Nearest(s, 2.9)
|
|
if ind != 1 {
|
|
t.Errorf("Wrong index returned when value is less than closest element")
|
|
}
|
|
ind = Nearest(s, 3)
|
|
if ind != 1 {
|
|
t.Errorf("Wrong index returned when value is equal to element")
|
|
}
|
|
ind = Nearest(s, 6.2)
|
|
if ind != 0 {
|
|
t.Errorf("Wrong index returned when value is equal to several elements")
|
|
}
|
|
ind = Nearest(s, 4)
|
|
if ind != 1 {
|
|
t.Errorf("Wrong index returned when value is exactly between two closest elements")
|
|
}
|
|
}
|
|
|
|
func TestNearestWithinSpan(t *testing.T) {
|
|
if !Panics(func() { NearestWithinSpan(10, 8, 2, 4.5) }) {
|
|
t.Errorf("Did not panic when upper bound is lower than greater bound")
|
|
}
|
|
for i, test := range []struct {
|
|
length int
|
|
lower float64
|
|
upper float64
|
|
value float64
|
|
idx int
|
|
}{
|
|
{
|
|
length: 13,
|
|
lower: 7,
|
|
upper: 8.2,
|
|
value: 6,
|
|
idx: -1,
|
|
},
|
|
{
|
|
length: 13,
|
|
lower: 7,
|
|
upper: 8.2,
|
|
value: 10,
|
|
idx: -1,
|
|
},
|
|
{
|
|
length: 13,
|
|
lower: 7,
|
|
upper: 8.2,
|
|
value: 7.19,
|
|
idx: 2,
|
|
},
|
|
{
|
|
length: 13,
|
|
lower: 7,
|
|
upper: 8.2,
|
|
value: 7.21,
|
|
idx: 2,
|
|
},
|
|
{
|
|
length: 13,
|
|
lower: 7,
|
|
upper: 8.2,
|
|
value: 7.2,
|
|
idx: 2,
|
|
},
|
|
{
|
|
length: 13,
|
|
lower: 7,
|
|
upper: 8.2,
|
|
value: 7.151,
|
|
idx: 2,
|
|
},
|
|
{
|
|
length: 13,
|
|
lower: 7,
|
|
upper: 8.2,
|
|
value: 7.249,
|
|
idx: 2,
|
|
},
|
|
} {
|
|
if idx := NearestWithinSpan(test.length, test.lower, test.upper, test.value); test.idx != idx {
|
|
t.Errorf("Case %v mismatch: Want: %v, Got: %v", i, test.idx, idx)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestNorm(t *testing.T) {
|
|
s := []float64{-1, -3.4, 5, -6}
|
|
val := Norm(s, math.Inf(1))
|
|
truth := 6.0
|
|
if math.Abs(val-truth) > EqTolerance {
|
|
t.Errorf("Doesn't match for inf norm. %v expected, %v found", truth, val)
|
|
}
|
|
// http://www.wolframalpha.com/input/?i=%28%28-1%29%5E2+%2B++%28-3.4%29%5E2+%2B+5%5E2%2B++6%5E2%29%5E%281%2F2%29
|
|
val = Norm(s, 2)
|
|
truth = 8.5767126569566267590651614132751986658027271236078592
|
|
if math.Abs(val-truth) > EqTolerance {
|
|
t.Errorf("Doesn't match for inf norm. %v expected, %v found", truth, val)
|
|
}
|
|
// http://www.wolframalpha.com/input/?i=%28%28%7C-1%7C%29%5E3+%2B++%28%7C-3.4%7C%29%5E3+%2B+%7C5%7C%5E3%2B++%7C6%7C%5E3%29%5E%281%2F3%29
|
|
val = Norm(s, 3)
|
|
truth = 7.2514321388020228478109121239004816430071237369356233
|
|
if math.Abs(val-truth) > EqTolerance {
|
|
t.Errorf("Doesn't match for inf norm. %v expected, %v found", truth, val)
|
|
}
|
|
|
|
//http://www.wolframalpha.com/input/?i=%7C-1%7C+%2B+%7C-3.4%7C+%2B+%7C5%7C%2B++%7C6%7C
|
|
val = Norm(s, 1)
|
|
truth = 15.4
|
|
if math.Abs(val-truth) > EqTolerance {
|
|
t.Errorf("Doesn't match for inf norm. %v expected, %v found", truth, val)
|
|
}
|
|
}
|
|
|
|
func TestProd(t *testing.T) {
|
|
s := []float64{}
|
|
val := Prod(s)
|
|
if val != 1 {
|
|
t.Errorf("Val not returned as default when slice length is zero")
|
|
}
|
|
s = []float64{3, 4, 1, 7, 5}
|
|
val = Prod(s)
|
|
if val != 420 {
|
|
t.Errorf("Wrong prod returned. Expected %v returned %v", 420, val)
|
|
}
|
|
}
|
|
|
|
func TestReverse(t *testing.T) {
|
|
for _, s := range [][]float64{
|
|
{0},
|
|
{1, 0},
|
|
{2, 1, 0},
|
|
{3, 2, 1, 0},
|
|
{9, 8, 7, 6, 5, 4, 3, 2, 1, 0},
|
|
} {
|
|
Reverse(s)
|
|
for i, v := range s {
|
|
if v != float64(i) {
|
|
t.Errorf("unexpected values for element %d: got:%v want:%v", i, v, i)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestRound(t *testing.T) {
|
|
for _, test := range []struct {
|
|
x float64
|
|
prec int
|
|
want float64
|
|
}{
|
|
{x: 0, prec: 1, want: 0},
|
|
{x: math.Inf(1), prec: 1, want: math.Inf(1)},
|
|
{x: math.NaN(), prec: 1, want: math.NaN()},
|
|
{x: func() float64 { var f float64; return -f }(), prec: 1, want: 0},
|
|
{x: math.MaxFloat64 / 2, prec: 1, want: math.MaxFloat64 / 2},
|
|
{x: 1 << 64, prec: 1, want: 1 << 64},
|
|
{x: 454.4445, prec: 3, want: 454.445},
|
|
{x: 454.44445, prec: 4, want: 454.4445},
|
|
{x: 0.42499, prec: 4, want: 0.425},
|
|
{x: 0.42599, prec: 4, want: 0.426},
|
|
{x: 0.424999999999993, prec: 2, want: 0.42},
|
|
{x: 0.425, prec: 2, want: 0.43},
|
|
{x: 0.425000000000001, prec: 2, want: 0.43},
|
|
{x: 123.4244999999999, prec: 3, want: 123.424},
|
|
{x: 123.4245, prec: 3, want: 123.425},
|
|
{x: 123.4245000000001, prec: 3, want: 123.425},
|
|
|
|
{x: 454.45, prec: 0, want: 454},
|
|
{x: 454.45, prec: 1, want: 454.5},
|
|
{x: 454.45, prec: 2, want: 454.45},
|
|
{x: 454.45, prec: 3, want: 454.45},
|
|
{x: 454.445, prec: 0, want: 454},
|
|
{x: 454.445, prec: 1, want: 454.4},
|
|
{x: 454.445, prec: 2, want: 454.45},
|
|
{x: 454.445, prec: 3, want: 454.445},
|
|
{x: 454.445, prec: 4, want: 454.445},
|
|
{x: 454.55, prec: 0, want: 455},
|
|
{x: 454.55, prec: 1, want: 454.6},
|
|
{x: 454.55, prec: 2, want: 454.55},
|
|
{x: 454.55, prec: 3, want: 454.55},
|
|
{x: 454.455, prec: 0, want: 454},
|
|
{x: 454.455, prec: 1, want: 454.5},
|
|
{x: 454.455, prec: 2, want: 454.46},
|
|
{x: 454.455, prec: 3, want: 454.455},
|
|
{x: 454.455, prec: 4, want: 454.455},
|
|
|
|
// Negative precision.
|
|
{x: 454.45, prec: -1, want: 450},
|
|
{x: 454.45, prec: -2, want: 500},
|
|
{x: 500, prec: -3, want: 1000},
|
|
{x: 500, prec: -4, want: 0},
|
|
{x: 1500, prec: -3, want: 2000},
|
|
{x: 1500, prec: -4, want: 0},
|
|
} {
|
|
for _, sign := range []float64{1, -1} {
|
|
got := Round(sign*test.x, test.prec)
|
|
want := sign * test.want
|
|
if want == 0 {
|
|
want = 0
|
|
}
|
|
if (got != want || math.Signbit(got) != math.Signbit(want)) && !(math.IsNaN(got) && math.IsNaN(want)) {
|
|
t.Errorf("unexpected result for Round(%g, %d): got: %g, want: %g", sign*test.x, test.prec, got, want)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestRoundEven(t *testing.T) {
|
|
for _, test := range []struct {
|
|
x float64
|
|
prec int
|
|
want float64
|
|
}{
|
|
{x: 0, prec: 1, want: 0},
|
|
{x: math.Inf(1), prec: 1, want: math.Inf(1)},
|
|
{x: math.NaN(), prec: 1, want: math.NaN()},
|
|
{x: func() float64 { var f float64; return -f }(), prec: 1, want: 0},
|
|
{x: math.MaxFloat64 / 2, prec: 1, want: math.MaxFloat64 / 2},
|
|
{x: 1 << 64, prec: 1, want: 1 << 64},
|
|
{x: 454.4445, prec: 3, want: 454.444},
|
|
{x: 454.44445, prec: 4, want: 454.4444},
|
|
{x: 0.42499, prec: 4, want: 0.425},
|
|
{x: 0.42599, prec: 4, want: 0.426},
|
|
{x: 0.424999999999993, prec: 2, want: 0.42},
|
|
{x: 0.425, prec: 2, want: 0.42},
|
|
{x: 0.425000000000001, prec: 2, want: 0.43},
|
|
{x: 123.4244999999999, prec: 3, want: 123.424},
|
|
{x: 123.4245, prec: 3, want: 123.424},
|
|
{x: 123.4245000000001, prec: 3, want: 123.425},
|
|
|
|
{x: 454.45, prec: 0, want: 454},
|
|
{x: 454.45, prec: 1, want: 454.4},
|
|
{x: 454.45, prec: 2, want: 454.45},
|
|
{x: 454.45, prec: 3, want: 454.45},
|
|
{x: 454.445, prec: 0, want: 454},
|
|
{x: 454.445, prec: 1, want: 454.4},
|
|
{x: 454.445, prec: 2, want: 454.44},
|
|
{x: 454.445, prec: 3, want: 454.445},
|
|
{x: 454.445, prec: 4, want: 454.445},
|
|
{x: 454.55, prec: 0, want: 455},
|
|
{x: 454.55, prec: 1, want: 454.6},
|
|
{x: 454.55, prec: 2, want: 454.55},
|
|
{x: 454.55, prec: 3, want: 454.55},
|
|
{x: 454.455, prec: 0, want: 454},
|
|
{x: 454.455, prec: 1, want: 454.5},
|
|
{x: 454.455, prec: 2, want: 454.46},
|
|
{x: 454.455, prec: 3, want: 454.455},
|
|
{x: 454.455, prec: 4, want: 454.455},
|
|
|
|
// Negative precision.
|
|
{x: 454.45, prec: -1, want: 450},
|
|
{x: 454.45, prec: -2, want: 500},
|
|
{x: 500, prec: -3, want: 0},
|
|
{x: 500, prec: -4, want: 0},
|
|
{x: 1500, prec: -3, want: 2000},
|
|
{x: 1500, prec: -4, want: 0},
|
|
} {
|
|
for _, sign := range []float64{1, -1} {
|
|
got := RoundEven(sign*test.x, test.prec)
|
|
want := sign * test.want
|
|
if want == 0 {
|
|
want = 0
|
|
}
|
|
if (got != want || math.Signbit(got) != math.Signbit(want)) && !(math.IsNaN(got) && math.IsNaN(want)) {
|
|
t.Errorf("unexpected result for RoundEven(%g, %d): got: %g, want: %g", sign*test.x, test.prec, got, want)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestSame(t *testing.T) {
|
|
s1 := []float64{1, 2, 3, 4}
|
|
s2 := []float64{1, 2, 3, 4}
|
|
if !Same(s1, s2) {
|
|
t.Errorf("Equal slices returned as unequal")
|
|
}
|
|
s2 = []float64{1, 2, 3, 4 + 1e-14}
|
|
if Same(s1, s2) {
|
|
t.Errorf("Unequal slices returned as equal")
|
|
}
|
|
if Same(s1, []float64{}) {
|
|
t.Errorf("Unequal slice lengths returned as equal")
|
|
}
|
|
s1 = []float64{1, 2, math.NaN(), 4}
|
|
s2 = []float64{1, 2, math.NaN(), 4}
|
|
if !Same(s1, s2) {
|
|
t.Errorf("Slices with matching NaN values returned as unequal")
|
|
}
|
|
s1 = []float64{1, 2, math.NaN(), 4}
|
|
s2 = []float64{1, math.NaN(), 3, 4}
|
|
if !Same(s1, s2) {
|
|
t.Errorf("Slices with unmatching NaN values returned as equal")
|
|
}
|
|
}
|
|
|
|
func TestScale(t *testing.T) {
|
|
s := []float64{3, 4, 1, 7, 5}
|
|
c := 5.0
|
|
truth := []float64{15, 20, 5, 35, 25}
|
|
Scale(c, s)
|
|
AreSlicesEqual(t, truth, s, "Bad scaling")
|
|
}
|
|
|
|
func TestSpan(t *testing.T) {
|
|
receiver1 := make([]float64, 5)
|
|
truth := []float64{1, 2, 3, 4, 5}
|
|
receiver2 := Span(receiver1, 1, 5)
|
|
AreSlicesEqual(t, truth, receiver1, "Improper linspace from mutator")
|
|
AreSlicesEqual(t, truth, receiver2, "Improper linspace from returned slice")
|
|
receiver1 = make([]float64, 6)
|
|
truth = []float64{0, 0.2, 0.4, 0.6, 0.8, 1.0}
|
|
Span(receiver1, 0, 1)
|
|
AreSlicesEqual(t, truth, receiver1, "Improper linspace")
|
|
if !Panics(func() { Span(nil, 1, 5) }) {
|
|
t.Errorf("Span accepts nil argument")
|
|
}
|
|
if !Panics(func() { Span(make([]float64, 1), 1, 5) }) {
|
|
t.Errorf("Span accepts argument of len = 1")
|
|
}
|
|
}
|
|
|
|
func TestSub(t *testing.T) {
|
|
s := []float64{3, 4, 1, 7, 5}
|
|
v := []float64{1, 2, 3, 4, 5}
|
|
truth := []float64{2, 2, -2, 3, 0}
|
|
Sub(s, v)
|
|
AreSlicesEqual(t, truth, s, "Bad subtract")
|
|
// Test that it panics
|
|
if !Panics(func() { Sub(make([]float64, 2), make([]float64, 3)) }) {
|
|
t.Errorf("Did not panic with length mismatch")
|
|
}
|
|
}
|
|
|
|
func TestSubTo(t *testing.T) {
|
|
s := []float64{3, 4, 1, 7, 5}
|
|
v := []float64{1, 2, 3, 4, 5}
|
|
truth := []float64{2, 2, -2, 3, 0}
|
|
dst1 := make([]float64, len(s))
|
|
dst2 := SubTo(dst1, s, v)
|
|
AreSlicesEqual(t, truth, dst1, "Bad subtract from mutator")
|
|
AreSlicesEqual(t, truth, dst2, "Bad subtract from returned slice")
|
|
// Test that all mismatch combinations panic
|
|
if !Panics(func() { SubTo(make([]float64, 2), make([]float64, 3), make([]float64, 3)) }) {
|
|
t.Errorf("Did not panic with dst different length")
|
|
}
|
|
if !Panics(func() { SubTo(make([]float64, 3), make([]float64, 2), make([]float64, 3)) }) {
|
|
t.Errorf("Did not panic with subtractor different length")
|
|
}
|
|
if !Panics(func() { SubTo(make([]float64, 3), make([]float64, 3), make([]float64, 2)) }) {
|
|
t.Errorf("Did not panic with subtractee different length")
|
|
}
|
|
}
|
|
|
|
func TestSum(t *testing.T) {
|
|
s := []float64{}
|
|
val := Sum(s)
|
|
if val != 0 {
|
|
t.Errorf("Val not returned as default when slice length is zero")
|
|
}
|
|
s = []float64{3, 4, 1, 7, 5}
|
|
val = Sum(s)
|
|
if val != 20 {
|
|
t.Errorf("Wrong sum returned")
|
|
}
|
|
}
|
|
|
|
func TestWithin(t *testing.T) {
|
|
for i, test := range []struct {
|
|
s []float64
|
|
v float64
|
|
idx int
|
|
panics bool
|
|
}{
|
|
{
|
|
s: []float64{1, 2, 5, 9},
|
|
v: 1,
|
|
idx: 0,
|
|
},
|
|
{
|
|
s: []float64{1, 2, 5, 9},
|
|
v: 9,
|
|
idx: -1,
|
|
},
|
|
{
|
|
s: []float64{1, 2, 5, 9},
|
|
v: 1.5,
|
|
idx: 0,
|
|
},
|
|
{
|
|
s: []float64{1, 2, 5, 9},
|
|
v: 2,
|
|
idx: 1,
|
|
},
|
|
{
|
|
s: []float64{1, 2, 5, 9},
|
|
v: 2.5,
|
|
idx: 1,
|
|
},
|
|
{
|
|
s: []float64{1, 2, 5, 9},
|
|
v: -3,
|
|
idx: -1,
|
|
},
|
|
{
|
|
s: []float64{1, 2, 5, 9},
|
|
v: 15,
|
|
idx: -1,
|
|
},
|
|
{
|
|
s: []float64{1, 2, 5, 9},
|
|
v: math.NaN(),
|
|
idx: -1,
|
|
},
|
|
{
|
|
s: []float64{5, 2, 6},
|
|
panics: true,
|
|
},
|
|
{
|
|
panics: true,
|
|
},
|
|
{
|
|
s: []float64{1},
|
|
panics: true,
|
|
},
|
|
} {
|
|
var idx int
|
|
panics := Panics(func() { idx = Within(test.s, test.v) })
|
|
if panics {
|
|
if !test.panics {
|
|
t.Errorf("Case %v: bad panic", i)
|
|
}
|
|
continue
|
|
}
|
|
if test.panics {
|
|
if !panics {
|
|
t.Errorf("Case %v: did not panic when it should", i)
|
|
}
|
|
continue
|
|
}
|
|
if idx != test.idx {
|
|
t.Errorf("Case %v: Idx mismatch. Want: %v, got: %v", i, test.idx, idx)
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
func randomSlice(l int) []float64 {
|
|
s := make([]float64, l)
|
|
for i := range s {
|
|
s[i] = rand.Float64()
|
|
}
|
|
return s
|
|
}
|
|
|
|
func benchmarkMin(b *testing.B, size int) {
|
|
s := randomSlice(size)
|
|
b.ResetTimer()
|
|
for i := 0; i < b.N; i++ {
|
|
Min(s)
|
|
}
|
|
}
|
|
func BenchmarkMinSmall(b *testing.B) { benchmarkMin(b, Small) }
|
|
func BenchmarkMinMed(b *testing.B) { benchmarkMin(b, Medium) }
|
|
func BenchmarkMinLarge(b *testing.B) { benchmarkMin(b, Large) }
|
|
func BenchmarkMinHuge(b *testing.B) { benchmarkMin(b, Huge) }
|
|
|
|
func benchmarkAdd(b *testing.B, size int) {
|
|
s1 := randomSlice(size)
|
|
s2 := randomSlice(size)
|
|
b.ResetTimer()
|
|
for i := 0; i < b.N; i++ {
|
|
Add(s1, s2)
|
|
}
|
|
}
|
|
func BenchmarkAddSmall(b *testing.B) { benchmarkAdd(b, Small) }
|
|
func BenchmarkAddMed(b *testing.B) { benchmarkAdd(b, Medium) }
|
|
func BenchmarkAddLarge(b *testing.B) { benchmarkAdd(b, Large) }
|
|
func BenchmarkAddHuge(b *testing.B) { benchmarkAdd(b, Huge) }
|
|
|
|
func benchmarkAddTo(b *testing.B, size int) {
|
|
s1 := randomSlice(size)
|
|
s2 := randomSlice(size)
|
|
dst := randomSlice(size)
|
|
b.ResetTimer()
|
|
for i := 0; i < b.N; i++ {
|
|
AddTo(dst, s1, s2)
|
|
}
|
|
}
|
|
func BenchmarkAddToSmall(b *testing.B) { benchmarkAddTo(b, Small) }
|
|
func BenchmarkAddToMed(b *testing.B) { benchmarkAddTo(b, Medium) }
|
|
func BenchmarkAddToLarge(b *testing.B) { benchmarkAddTo(b, Large) }
|
|
func BenchmarkAddToHuge(b *testing.B) { benchmarkAddTo(b, Huge) }
|
|
|
|
func benchmarkCumProd(b *testing.B, size int) {
|
|
s := randomSlice(size)
|
|
dst := randomSlice(size)
|
|
b.ResetTimer()
|
|
for i := 0; i < b.N; i++ {
|
|
CumProd(dst, s)
|
|
}
|
|
}
|
|
func BenchmarkCumProdSmall(b *testing.B) { benchmarkCumProd(b, Small) }
|
|
func BenchmarkCumProdMed(b *testing.B) { benchmarkCumProd(b, Medium) }
|
|
func BenchmarkCumProdLarge(b *testing.B) { benchmarkCumProd(b, Large) }
|
|
func BenchmarkCumProdHuge(b *testing.B) { benchmarkCumProd(b, Huge) }
|
|
|
|
func benchmarkCumSum(b *testing.B, size int) {
|
|
s := randomSlice(size)
|
|
dst := randomSlice(size)
|
|
b.ResetTimer()
|
|
for i := 0; i < b.N; i++ {
|
|
CumSum(dst, s)
|
|
}
|
|
}
|
|
func BenchmarkCumSumSmall(b *testing.B) { benchmarkCumSum(b, Small) }
|
|
func BenchmarkCumSumMed(b *testing.B) { benchmarkCumSum(b, Medium) }
|
|
func BenchmarkCumSumLarge(b *testing.B) { benchmarkCumSum(b, Large) }
|
|
func BenchmarkCumSumHuge(b *testing.B) { benchmarkCumSum(b, Huge) }
|
|
|
|
func benchmarkDiv(b *testing.B, size int) {
|
|
s := randomSlice(size)
|
|
dst := randomSlice(size)
|
|
b.ResetTimer()
|
|
for i := 0; i < b.N; i++ {
|
|
Div(dst, s)
|
|
}
|
|
}
|
|
func BenchmarkDivSmall(b *testing.B) { benchmarkDiv(b, Small) }
|
|
func BenchmarkDivMed(b *testing.B) { benchmarkDiv(b, Medium) }
|
|
func BenchmarkDivLarge(b *testing.B) { benchmarkDiv(b, Large) }
|
|
func BenchmarkDivHuge(b *testing.B) { benchmarkDiv(b, Huge) }
|
|
|
|
func benchmarkDivTo(b *testing.B, size int) {
|
|
s1 := randomSlice(size)
|
|
s2 := randomSlice(size)
|
|
dst := randomSlice(size)
|
|
b.ResetTimer()
|
|
for i := 0; i < b.N; i++ {
|
|
DivTo(dst, s1, s2)
|
|
}
|
|
}
|
|
func BenchmarkDivToSmall(b *testing.B) { benchmarkDivTo(b, Small) }
|
|
func BenchmarkDivToMed(b *testing.B) { benchmarkDivTo(b, Medium) }
|
|
func BenchmarkDivToLarge(b *testing.B) { benchmarkDivTo(b, Large) }
|
|
func BenchmarkDivToHuge(b *testing.B) { benchmarkDivTo(b, Huge) }
|
|
|
|
func benchmarkSub(b *testing.B, size int) {
|
|
s1 := randomSlice(size)
|
|
s2 := randomSlice(size)
|
|
b.ResetTimer()
|
|
for i := 0; i < b.N; i++ {
|
|
Sub(s1, s2)
|
|
}
|
|
}
|
|
func BenchmarkSubSmall(b *testing.B) { benchmarkSub(b, Small) }
|
|
func BenchmarkSubMed(b *testing.B) { benchmarkSub(b, Medium) }
|
|
func BenchmarkSubLarge(b *testing.B) { benchmarkSub(b, Large) }
|
|
func BenchmarkSubHuge(b *testing.B) { benchmarkSub(b, Huge) }
|
|
|
|
func benchmarkSubTo(b *testing.B, size int) {
|
|
s1 := randomSlice(size)
|
|
s2 := randomSlice(size)
|
|
dst := randomSlice(size)
|
|
b.ResetTimer()
|
|
for i := 0; i < b.N; i++ {
|
|
SubTo(dst, s1, s2)
|
|
}
|
|
}
|
|
func BenchmarkSubToSmall(b *testing.B) { benchmarkSubTo(b, Small) }
|
|
func BenchmarkSubToMed(b *testing.B) { benchmarkSubTo(b, Medium) }
|
|
func BenchmarkSubToLarge(b *testing.B) { benchmarkSubTo(b, Large) }
|
|
func BenchmarkSubToHuge(b *testing.B) { benchmarkSubTo(b, Huge) }
|
|
|
|
func benchmarkLogSumExp(b *testing.B, size int) {
|
|
s := randomSlice(size)
|
|
b.ResetTimer()
|
|
for i := 0; i < b.N; i++ {
|
|
LogSumExp(s)
|
|
}
|
|
}
|
|
func BenchmarkLogSumExpSmall(b *testing.B) { benchmarkLogSumExp(b, Small) }
|
|
func BenchmarkLogSumExpMed(b *testing.B) { benchmarkLogSumExp(b, Medium) }
|
|
func BenchmarkLogSumExpLarge(b *testing.B) { benchmarkLogSumExp(b, Large) }
|
|
func BenchmarkLogSumExpHuge(b *testing.B) { benchmarkLogSumExp(b, Huge) }
|
|
|
|
func benchmarkDot(b *testing.B, size int) {
|
|
s1 := randomSlice(size)
|
|
s2 := randomSlice(size)
|
|
b.ResetTimer()
|
|
for i := 0; i < b.N; i++ {
|
|
Dot(s1, s2)
|
|
}
|
|
}
|
|
func BenchmarkDotSmall(b *testing.B) { benchmarkDot(b, Small) }
|
|
func BenchmarkDotMed(b *testing.B) { benchmarkDot(b, Medium) }
|
|
func BenchmarkDotLarge(b *testing.B) { benchmarkDot(b, Large) }
|
|
func BenchmarkDotHuge(b *testing.B) { benchmarkDot(b, Huge) }
|
|
|
|
func benchmarkAddScaledTo(b *testing.B, size int) {
|
|
dst := randomSlice(size)
|
|
y := randomSlice(size)
|
|
s := randomSlice(size)
|
|
b.ResetTimer()
|
|
for i := 0; i < b.N; i++ {
|
|
AddScaledTo(dst, y, 2.3, s)
|
|
}
|
|
}
|
|
func BenchmarkAddScaledToSmall(b *testing.B) { benchmarkAddScaledTo(b, Small) }
|
|
func BenchmarkAddScaledToMedium(b *testing.B) { benchmarkAddScaledTo(b, Medium) }
|
|
func BenchmarkAddScaledToLarge(b *testing.B) { benchmarkAddScaledTo(b, Large) }
|
|
func BenchmarkAddScaledToHuge(b *testing.B) { benchmarkAddScaledTo(b, Huge) }
|
|
|
|
func benchmarkScale(b *testing.B, size int) {
|
|
dst := randomSlice(size)
|
|
b.ResetTimer()
|
|
for i := 0; i < b.N; i += 2 {
|
|
Scale(2.0, dst)
|
|
Scale(0.5, dst)
|
|
}
|
|
}
|
|
func BenchmarkScaleSmall(b *testing.B) { benchmarkScale(b, Small) }
|
|
func BenchmarkScaleMedium(b *testing.B) { benchmarkScale(b, Medium) }
|
|
func BenchmarkScaleLarge(b *testing.B) { benchmarkScale(b, Large) }
|
|
func BenchmarkScaleHuge(b *testing.B) { benchmarkScale(b, Huge) }
|