blob: 5061e80ccb9b49909776214b1edc866b9bfda4ce [file] [log] [blame]
 // 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 cmplxs import ( "fmt" "math" "math/cmplx" "strconv" "testing" "golang.org/x/exp/rand" "gonum.org/v1/gonum/cmplxs/cscalar" "gonum.org/v1/gonum/floats" ) const ( EqTolerance = 1e-14 Small = 10 Medium = 1000 Large = 100000 Huge = 10000000 ) func areSlicesEqual(t *testing.T, truth, comp []complex128, str string) { if !EqualApprox(comp, truth, EqTolerance) { t.Errorf(str+". Expected %v, returned %v", truth, comp) } } func areSlicesSame(t *testing.T, truth, comp []complex128, str string) { ok := len(truth) == len(comp) if ok { for i, a := range truth { if !cscalar.EqualWithinAbsOrRel(a, comp[i], EqTolerance, EqTolerance) && !cscalar.Same(a, comp[i]) { ok = false break } } } if !ok { 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 := []complex128{1 + 1i, 2 + 2i, 3 + 3i} b := []complex128{4 + 4i, 5 + 5i, 6 + 6i} c := []complex128{7 + 7i, 8 + 8i, 9 + 9i} truth := []complex128{12 + 12i, 15 + 15i, 18 + 18i} n := make([]complex128, 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([]complex128, 2), make([]complex128, 3)) }) { t.Errorf("Did not panic with length mismatch") } } func TestAddTo(t *testing.T) { a := []complex128{1 + 1i, 2 + 2i, 3 + 3i} b := []complex128{4 + 4i, 5 + 5i, 6 + 6i} truth := []complex128{5 + 5i, 7 + 7i, 9 + 9i} n1 := make([]complex128, 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([]complex128, 2), make([]complex128, 3), make([]complex128, 3)) }) { t.Errorf("Did not panic with length mismatch") } if !Panics(func() { AddTo(make([]complex128, 3), make([]complex128, 3), make([]complex128, 2)) }) { t.Errorf("Did not panic with length mismatch") } } func TestAddConst(t *testing.T) { s := []complex128{3 + 1i, 4 + 2i, 1 + 3i, 7 + 4i, 5 + 5i} c := 6 + 1i truth := []complex128{9 + 2i, 10 + 3i, 7 + 4i, 13 + 5i, 11 + 6i} AddConst(c, s) areSlicesEqual(t, truth, s, "Wrong addition of constant") } func TestAddScaled(t *testing.T) { s := []complex128{3, 4, 1, 7, 5} alpha := 6 + 1i dst := []complex128{1, 2, 3, 4, 5} ans := []complex128{19 + 3i, 26 + 4i, 9 + 1i, 46 + 7i, 35 + 5i} AddScaled(dst, alpha, s) if !EqualApprox(dst, ans, EqTolerance) { t.Errorf("Adding scaled did not match. Expected %v, returned %v", ans, dst) } short := []complex128{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 := []complex128{3, 4, 1, 7, 5} alpha := 6 + 1i y := []complex128{1, 2, 3, 4, 5} dst1 := make([]complex128, 5) ans := []complex128{19 + 3i, 26 + 4i, 9 + 1i, 46 + 7i, 35 + 5i} 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 := []complex128{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 TestCount(t *testing.T) { s := []complex128{3, 4, 1, 7, 5} f := func(v complex128) bool { return cmplx.Abs(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 := []complex128{3 + 1i, 4 + 2i, 1 + 3i, 7 + 4i, 5 + 5i} receiver := make([]complex128, len(s)) result := CumProd(receiver, s) truth := []complex128{3 + 1i, 10 + 10i, -20 + 40i, -300 + 200i, -2500 - 500i} 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([]complex128, 2), make([]complex128, 3)) }) { t.Errorf("Did not panic with length mismatch") } // Test empty CumProd emptyReceiver := make([]complex128, 0) truth = []complex128{} CumProd(emptyReceiver, emptyReceiver) areSlicesEqual(t, truth, emptyReceiver, "Wrong cumprod returned with empty receiver") } func TestComplex(t *testing.T) { for i, test := range []struct { dst []complex128 real, imag []float64 want []complex128 panics bool }{ {}, { dst: make([]complex128, 4), real: []float64{1, 2, 3, 4}, imag: []float64{1, 2, 3, 4}, want: []complex128{1 + 1i, 2 + 2i, 3 + 3i, 4 + 4i}, }, { dst: make([]complex128, 3), real: []float64{1, 2, 3, 4}, imag: []float64{1, 2, 3, 4}, panics: true, }, { dst: make([]complex128, 4), real: []float64{1, 2, 3}, imag: []float64{1, 2, 3, 4}, panics: true, }, { dst: make([]complex128, 4), real: []float64{1, 2, 3, 4}, imag: []float64{1, 2, 3}, panics: true, }, { dst: make([]complex128, 4), real: []float64{1, 2, 3, 4}, imag: []float64{1, 2, 3, math.NaN()}, want: []complex128{1 + 1i, 2 + 2i, 3 + 3i, cmplx.NaN()}, }, } { var got []complex128 panicked := Panics(func() { got = Complex(test.dst, test.real, test.imag) }) if panicked != test.panics { if panicked { t.Errorf("unexpected panic for test %d", i) } else { t.Errorf("expected panic for test %d", i) } } if panicked || test.panics { continue } if !Same(got, test.dst) { t.Errorf("mismatch between dst and return test %d: got:%v want:%v", i, got, test.dst) } if !Same(got, test.want) { t.Errorf("unexpected result for test %d: got:%v want:%v", i, got, test.want) } } } func TestCumSum(t *testing.T) { s := []complex128{3 + 1i, 4 + 2i, 1 + 3i, 7 + 4i, 5 + 5i} receiver := make([]complex128, len(s)) result := CumSum(receiver, s) truth := []complex128{3 + 1i, 7 + 3i, 8 + 6i, 15 + 10i, 20 + 15i} 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([]complex128, 2), make([]complex128, 3)) }) { t.Errorf("Did not panic with length mismatch") } // Test empty CumSum emptyReceiver := make([]complex128, 0) truth = []complex128{} 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 []complex128 t []complex128 }{ { nil, nil, }, { []complex128{8 + 1i, 9 + 2i, 10 + 3i, -12 + 4i}, []complex128{8 + 1i, 9 + 2i, 10 + 3i, -12 + 4i}, }, { []complex128{1 + 1i, 2 + 2i, 3 + 3i, -4 + 4i, -5 + 5i, 8 + 6i}, []complex128{-9.2 - 1i, -6.8 - 2i, 9 - 3i, -3 - 4i, -2 - 5i, 1 - 6i}, }, } for j, test := range slices { tmp := make([]complex128, 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([]complex128{}, []complex128{1}, 1) }) { t.Errorf("Did not panic with unequal lengths") } } func TestDiv(t *testing.T) { s1 := []complex128{5 - 5i, 12 + 2i, 27 - 3i} s2 := []complex128{1 - 1i, 2 + 2i, 3 - 1i} ans := []complex128{5 + 0i, 3.5 - 2.5i, 8.4 + 1.8i} Div(s1, s2) if !EqualApprox(s1, ans, EqTolerance) { t.Errorf("Div doesn't give correct answer. Expected %v, Found %v.", ans, s1) } s1short := []complex128{1} if !Panics(func() { Div(s1short, s2) }) { t.Errorf("Did not panic with unequal lengths") } s2short := []complex128{1} if !Panics(func() { Div(s1, s2short) }) { t.Errorf("Did not panic with unequal lengths") } } func TestDivTo(t *testing.T) { s1 := []complex128{5 - 5i, 12 + 2i, 27 - 3i} s1orig := []complex128{5 - 5i, 12 + 2i, 27 - 3i} s2 := []complex128{1 - 1i, 2 + 2i, 3 - 1i} s2orig := []complex128{1 - 1i, 2 + 2i, 3 - 1i} dst1 := make([]complex128, 3) ans := []complex128{5 + 0i, 3.5 - 2.5i, 8.4 + 1.8i} 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 := []complex128{1} if !Panics(func() { DivTo(dstShort, s1, s2) }) { t.Errorf("Did not panic with s1 wrong length") } s1short := []complex128{1} if !Panics(func() { DivTo(dst1, s1short, s2) }) { t.Errorf("Did not panic with s1 wrong length") } s2short := []complex128{1} if !Panics(func() { DivTo(dst1, s1, s2short) }) { t.Errorf("Did not panic with s2 wrong length") } } func TestDot(t *testing.T) { s1 := []complex128{1 + 1i, 2 + 2i, 3 + 3i, 4 + 4i} s2 := []complex128{-3 + 4i, 4 + 3i, 5 + 2i, -6 + 1i} truth := 16 + 24i ans := Dot(s1, s2) if ans != truth { t.Errorf("Dot product computed incorrectly. Expected %v, Found %v.", truth, ans) } // Test that it panics if !Panics(func() { Dot(make([]complex128, 2), make([]complex128, 3)) }) { t.Errorf("Did not panic with length mismatch") } } func TestEquals(t *testing.T) { s1 := []complex128{1 + 1i, 2 + 4i, 3 + 8i, 4 + 16i} s2 := []complex128{1 + 1i, 2 + 4i, 3 + 8i, 4 + 16i} if !Equal(s1, s2) { t.Errorf("Equal slices returned as unequal") } s2 = []complex128{1 + 1i, 2 + 4i, 3 + 8i, 4 + 16i + 1e-14} if Equal(s1, s2) { t.Errorf("Unequal slices returned as equal") } if Equal(s1, []complex128{}) { t.Errorf("Unequal slice lengths returned as equal") } } func TestEqualApprox(t *testing.T) { s1 := []complex128{1 + 1i, 2 + 4i, 3 + 8i, 4 + 16i} s2 := []complex128{1 + 1i, 2 + 4i, 3 + 8i, 4 + 16i + 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 = []complex128{1 + 1i, 2 + 4i, 3 + 8i, 1000 + 1000i} s2 = []complex128{1 + 1i, 2 + 4i, 3 + 8i, (1000 + 1000i) * (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, []complex128{}, 1e-5) { t.Errorf("Unequal slice lengths returned as equal") } } func TestEqualFunc(t *testing.T) { s1 := []complex128{1 + 1i, 2 + 4i, 3 + 8i, 4 + 16i} s2 := []complex128{1 + 1i, 2 + 4i, 3 + 8i, 4 + 16i} eq := func(x, y complex128) bool { return x == y } if !EqualFunc(s1, s2, eq) { t.Errorf("Equal slices returned as unequal") } s2 = []complex128{1 + 1i, 2 + 4i, 3 + 8i, 4 + 16i + 1e-14} if EqualFunc(s1, s2, eq) { t.Errorf("Unequal slices returned as equal") } if EqualFunc(s1, []complex128{}, eq) { t.Errorf("Unequal slice lengths returned as equal") } } func TestEqualLengths(t *testing.T) { s1 := []complex128{1 + 1i, 2 + 2i, 3 + 3i, 4 + 4i} s2 := []complex128{1 + 1i, 2 + 2i, 3 + 3i, 4 + 4i} s3 := []complex128{1 + 1i, 2 + 2i, 3 + 3i} 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 := []complex128{3 + 1i, 4 - 1i, 1 + 2i, 7 + 10i, 5 - 100i} f := func(v complex128) bool { return cmplx.Abs(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 []complex128 ans bool }{ {}, { s: []complex128{1 + 1i, 2 + 2i, 3 + 3i, 4 + 4i}, }, { s: []complex128{1 + 1i, cmplx.NaN(), 3 + 3i, 4 + 4i}, ans: true, }, { s: []complex128{1 + 1i, 2 + 2i, 3 + 3i, cmplx.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 TestImag(t *testing.T) { for i, test := range []struct { dst []float64 src []complex128 want []float64 panics bool }{ {}, { dst: make([]float64, 4), src: []complex128{1 + 1i, 2 + 2i, 3 + 3i, 4 + 4i}, want: []float64{1, 2, 3, 4}, }, { dst: make([]float64, 3), src: []complex128{1 + 1i, 2 + 2i, 3 + 3i, 4 + 4i}, panics: true, }, { dst: make([]float64, 4), src: []complex128{1 + 1i, 2 + 2i, 3 + 3i, cmplx.NaN()}, want: []float64{1, 2, 3, math.NaN()}, }, } { var got []float64 panicked := Panics(func() { got = Imag(test.dst, test.src) }) if panicked != test.panics { if panicked { t.Errorf("unexpected panic for test %d", i) } else { t.Errorf("expected panic for test %d", i) } } if panicked || test.panics { continue } if !floats.Same(got, test.dst) { t.Errorf("mismatch between dst and return test %d: got:%v want:%v", i, got, test.dst) } if !floats.Same(got, test.want) { t.Errorf("unexpected result for test %d: got:%v want:%v", i, got, test.want) } } } func TestLogSpan(t *testing.T) { // FIXME(kortschak) receiver1 := make([]complex128, 6) truth := []complex128{0.001, 0.01, 0.1, 1, 10, 100} receiver2 := LogSpan(receiver1, 0.001, 100) tst := make([]complex128, 6) for i := range truth { tst[i] = receiver1[i] / truth[i] } comp := make([]complex128, 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([]complex128, 1), 1, 5) }) { t.Errorf("Span accepts argument of len = 1") } } func TestMaxAbsAndIdx(t *testing.T) { for _, test := range []struct { in []complex128 wantIdx int wantVal complex128 desc string }{ { in: []complex128{3 + 1i, 4 + 1i, 1 + 1i, 7 + 1i, 5 + 1i}, wantIdx: 3, wantVal: 7 + 1i, desc: "with only finite entries", }, { in: []complex128{cmplx.NaN(), 4 + 1i, 1 + 1i, 7 + 1i, 5 + 1i}, wantIdx: 3, wantVal: 7 + 1i, desc: "with leading NaN", }, { in: []complex128{cmplx.NaN(), cmplx.NaN(), cmplx.NaN()}, wantIdx: 0, wantVal: cmplx.NaN(), desc: "when only NaN elements exist", }, { in: []complex128{cmplx.NaN(), cmplx.Inf()}, wantIdx: 1, wantVal: cmplx.Inf(), desc: "leading NaN followed by Inf", }, } { ind := MaxAbsIdx(test.in) if ind != test.wantIdx { t.Errorf("Wrong index "+test.desc+": got:%d want:%d", ind, test.wantIdx) } val := MaxAbs(test.in) if !cscalar.Same(val, test.wantVal) { t.Errorf("Wrong value "+test.desc+": got:%f want:%f", val, test.wantVal) } } } func TestMinAbsAndIdx(t *testing.T) { for _, test := range []struct { in []complex128 wantIdx int wantVal complex128 desc string }{ { in: []complex128{3 + 1i, 4 + 1i, 1 + 1i, 7 + 1i, 5 + 1i}, wantIdx: 2, wantVal: 1 + 1i, desc: "with only finite entries", }, { in: []complex128{cmplx.NaN(), 4 + 1i, 1 + 1i, 7 + 1i, 5 + 1i}, wantIdx: 2, wantVal: 1 + 1i, desc: "with leading NaN", }, { in: []complex128{cmplx.NaN(), cmplx.NaN(), cmplx.NaN()}, wantIdx: 0, wantVal: cmplx.NaN(), desc: "when only NaN elements exist", }, { in: []complex128{cmplx.NaN(), cmplx.Inf()}, wantIdx: 1, wantVal: cmplx.Inf(), desc: "leading NaN followed by Inf", }, } { ind := MinAbsIdx(test.in) if ind != test.wantIdx { t.Errorf("Wrong index "+test.desc+": got:%d want:%d", ind, test.wantIdx) } val := MinAbs(test.in) if !cscalar.Same(val, test.wantVal) { t.Errorf("Wrong value "+test.desc+": got:%f want:%f", val, test.wantVal) } } } func TestMul(t *testing.T) { s1 := []complex128{1 + 1i, 2 + 2i, 3 + 3i} s2 := []complex128{1 + 1i, 2 + 2i, 3 + 3i} ans := []complex128{0 + 2i, 0 + 8i, 0 + 18i} Mul(s1, s2) if !EqualApprox(s1, ans, EqTolerance) { t.Errorf("Mul doesn't give correct answer. Expected %v, Found %v", ans, s1) } s1short := []complex128{1} if !Panics(func() { Mul(s1short, s2) }) { t.Errorf("Did not panic with unequal lengths") } s2short := []complex128{1} if !Panics(func() { Mul(s1, s2short) }) { t.Errorf("Did not panic with unequal lengths") } } func TestMulTo(t *testing.T) { s1 := []complex128{1 + 1i, 2 + 2i, 3 + 3i} s1orig := []complex128{1 + 1i, 2 + 2i, 3 + 3i} s2 := []complex128{1 + 1i, 2 + 2i, 3 + 3i} s2orig := []complex128{1 + 1i, 2 + 2i, 3 + 3i} dst1 := make([]complex128, 3) ans := []complex128{0 + 2i, 0 + 8i, 0 + 18i} 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 := []complex128{1} if !Panics(func() { MulTo(dstShort, s1, s2) }) { t.Errorf("Did not panic with s1 wrong length") } s1short := []complex128{1} if !Panics(func() { MulTo(dst1, s1short, s2) }) { t.Errorf("Did not panic with s1 wrong length") } s2short := []complex128{1} if !Panics(func() { MulTo(dst1, s1, s2short) }) { t.Errorf("Did not panic with s2 wrong length") } } // Complexify func TestNearestIdx(t *testing.T) { for _, test := range []struct { in []complex128 query complex128 want int desc string }{ { in: []complex128{6.2, 3, 5, 6.2, 8}, query: 2, want: 1, desc: "Wrong index returned when value is less than all of elements", }, { in: []complex128{6.2, 3, 5, 6.2, 8}, query: 9, want: 4, desc: "Wrong index returned when value is greater than all of elements", }, { in: []complex128{6.2, 3, 5, 6.2, 8}, query: 3.1, want: 1, desc: "Wrong index returned when value is greater than closest element", }, { in: []complex128{6.2, 3, 5, 6.2, 8}, query: 2.9, want: 1, desc: "Wrong index returned when value is less than closest element", }, { in: []complex128{6.2, 3, 5, 6.2, 8}, query: 3, want: 1, desc: "Wrong index returned when value is equal to element", }, { in: []complex128{6.2, 3, 5, 6.2, 8}, query: 6.2, want: 0, desc: "Wrong index returned when value is equal to several elements", }, { in: []complex128{6.2, 3, 5, 6.2, 8}, query: 4, want: 1, desc: "Wrong index returned when value is exactly between two closest elements", }, { in: []complex128{cmplx.NaN(), 3, 2, -1}, query: 2, want: 2, desc: "Wrong index returned when initial element is NaN", }, { in: []complex128{0, cmplx.NaN(), -1, 2}, query: cmplx.NaN(), want: 0, desc: "Wrong index returned when query is NaN and a NaN element exists", }, { in: []complex128{0, cmplx.NaN(), -1, 2}, query: cmplx.Inf(), want: 3, desc: "Wrong index returned when query is Inf and no Inf element exists", }, { in: []complex128{cmplx.NaN(), cmplx.NaN(), cmplx.NaN()}, query: 1, want: 0, desc: "Wrong index returned when query is a number and only NaN elements exist", }, { in: []complex128{cmplx.NaN(), cmplx.Inf()}, query: 1, want: 1, desc: "Wrong index returned when query is a number and single NaN precedes Inf", }, } { ind := NearestIdx(test.in, test.query) if ind != test.want { t.Errorf(test.desc+": got:%d want:%d", ind, test.want) } } } func TestNorm(t *testing.T) { s := []complex128{-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 := []complex128{} val := Prod(s) if val != 1 { t.Errorf("Val not returned as default when slice length is zero") } s = []complex128{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 [][]complex128{ {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 != complex(float64(i), 0) { t.Errorf("unexpected values for element %d: got:%v want:%v", i, v, i) } } } } func TestReal(t *testing.T) { for i, test := range []struct { dst []float64 src []complex128 want []float64 panics bool }{ {}, { dst: make([]float64, 4), src: []complex128{1 + 1i, 2 + 2i, 3 + 3i, 4 + 4i}, want: []float64{1, 2, 3, 4}, }, { dst: make([]float64, 3), src: []complex128{1 + 1i, 2 + 2i, 3 + 3i, 4 + 4i}, panics: true, }, { dst: make([]float64, 4), src: []complex128{1 + 1i, 2 + 2i, 3 + 3i, cmplx.NaN()}, want: []float64{1, 2, 3, math.NaN()}, }, } { var got []float64 panicked := Panics(func() { got = Real(test.dst, test.src) }) if panicked != test.panics { if panicked { t.Errorf("unexpected panic for test %d", i) } else { t.Errorf("expected panic for test %d", i) } } if panicked || test.panics { continue } if !floats.Same(got, test.dst) { t.Errorf("mismatch between dst and return test %d: got:%v want:%v", i, got, test.dst) } if !floats.Same(got, test.want) { t.Errorf("unexpected result for test %d: got:%v want:%v", i, got, test.want) } } } func TestSame(t *testing.T) { s1 := []complex128{1 + 1i, 2 + 2i, 3 + 3i, 4 + 4i} s2 := []complex128{1 + 1i, 2 + 2i, 3 + 3i, 4 + 4i} if !Same(s1, s2) { t.Errorf("Equal slices returned as unequal") } s2 = []complex128{1 + 1i, 2 + 2i, 3 + 3i, 4 + 4i + 1e-14} if Same(s1, s2) { t.Errorf("Unequal slices returned as equal") } if Same(s1, []complex128{}) { t.Errorf("Unequal slice lengths returned as equal") } s1 = []complex128{1 + 1i, 2 + 2i, cmplx.NaN(), 4 + 4i} s2 = []complex128{1 + 1i, 2 + 2i, cmplx.NaN(), 4 + 4i} if !Same(s1, s2) { t.Errorf("Slices with matching NaN values returned as unequal") } s1 = []complex128{1 + 1i, 2 + 2i, cmplx.NaN(), 4 + 4i} s2 = []complex128{1 + 1i, cmplx.NaN(), 3 + 3i, 4 + 4i} if Same(s1, s2) { t.Errorf("Slices with unmatching NaN values returned as equal") } } func TestScale(t *testing.T) { s := []complex128{3, 4, 1, 7, 5} c := 5 + 5i truth := []complex128{15 + 15i, 20 + 20i, 5 + 5i, 35 + 35i, 25 + 25i} Scale(c, s) areSlicesEqual(t, truth, s, "Bad scaling") } func TestScaleTo(t *testing.T) { s := []complex128{3, 4, 1, 7, 5} sCopy := make([]complex128, len(s)) copy(sCopy, s) c := 5 + 5i truth := []complex128{15 + 15i, 20 + 20i, 5 + 5i, 35 + 35i, 25 + 25i} dst := make([]complex128, len(s)) ScaleTo(dst, c, s) if !Same(dst, truth) { t.Errorf("Scale to does not match. Got %v, want %v", dst, truth) } if !Same(s, sCopy) { t.Errorf("Source modified during call. Got %v, want %v", s, sCopy) } } func TestSpan(t *testing.T) { receiver1 := make([]complex128, 5) truth := []complex128{1 + 1i, 2 + 2i, 3 + 3i, 4 + 4i, 5 + 5i} receiver2 := Span(receiver1, 1+1i, 5+5i) areSlicesEqual(t, truth, receiver1, "Improper linspace from mutator") areSlicesEqual(t, truth, receiver2, "Improper linspace from returned slice") receiver1 = make([]complex128, 6) truth = []complex128{0, 0.2 + 0.4i, 0.4 + 0.8i, 0.6 + 1.2i, 0.8 + 1.6i, 1 + 2i} Span(receiver1, 0, 1+2i) areSlicesEqual(t, truth, receiver1, "Improper linspace") if !Panics(func() { Span(nil, 1, 5) }) { t.Errorf("Span accepts nil argument") } if !Panics(func() { Span(make([]complex128, 1), 1, 5) }) { t.Errorf("Span accepts argument of len = 1") } for _, test := range []struct { n int l, u complex128 want []complex128 }{ { n: 5, l: cmplx.Inf(), u: cmplx.Inf(), want: []complex128{cmplx.Inf(), cmplx.Inf(), cmplx.Inf(), cmplx.Inf(), cmplx.Inf()}, }, { n: 5, l: cmplx.Inf(), u: cmplx.NaN(), want: []complex128{cmplx.Inf(), cmplx.NaN(), cmplx.NaN(), cmplx.NaN(), cmplx.NaN()}, }, { n: 5, l: cmplx.NaN(), u: cmplx.Inf(), want: []complex128{cmplx.NaN(), cmplx.NaN(), cmplx.NaN(), cmplx.NaN(), cmplx.Inf()}, }, { n: 5, l: 42, u: cmplx.Inf(), want: []complex128{42, cmplx.Inf(), cmplx.Inf(), cmplx.Inf(), cmplx.Inf()}, }, { n: 5, l: 42, u: cmplx.NaN(), want: []complex128{42, cmplx.NaN(), cmplx.NaN(), cmplx.NaN(), cmplx.NaN()}, }, { n: 5, l: cmplx.Inf(), u: 42, want: []complex128{cmplx.Inf(), cmplx.Inf(), cmplx.Inf(), cmplx.Inf(), 42}, }, { n: 5, l: cmplx.NaN(), u: 42, want: []complex128{cmplx.NaN(), cmplx.NaN(), cmplx.NaN(), cmplx.NaN(), 42}, }, } { got := Span(make([]complex128, test.n), test.l, test.u) areSlicesSame(t, test.want, got, fmt.Sprintf("Unexpected slice of length %d for %f to %f", test.n, test.l, test.u)) } } func TestSub(t *testing.T) { s := []complex128{3 + 2i, 4 + 3i, 1 + 7i, 7 + 1i, 5 - 1i} v := []complex128{1 + 1i, 2 + 4i, 3, 4, 5 - 1i} truth := []complex128{2 + 1i, 2 - 1i, -2 + 7i, 3 + 1i, 0} Sub(s, v) areSlicesEqual(t, truth, s, "Bad subtract") // Test that it panics if !Panics(func() { Sub(make([]complex128, 2), make([]complex128, 3)) }) { t.Errorf("Did not panic with length mismatch") } } func TestSubTo(t *testing.T) { s := []complex128{3 + 2i, 4 + 3i, 1 + 7i, 7 + 1i, 5 - 1i} v := []complex128{1 + 1i, 2 + 4i, 3, 4, 5 - 1i} truth := []complex128{2 + 1i, 2 - 1i, -2 + 7i, 3 + 1i, 0} dst1 := make([]complex128, 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([]complex128, 2), make([]complex128, 3), make([]complex128, 3)) }) { t.Errorf("Did not panic with dst different length") } if !Panics(func() { SubTo(make([]complex128, 3), make([]complex128, 2), make([]complex128, 3)) }) { t.Errorf("Did not panic with subtractor different length") } if !Panics(func() { SubTo(make([]complex128, 3), make([]complex128, 3), make([]complex128, 2)) }) { t.Errorf("Did not panic with subtractee different length") } } func TestSum(t *testing.T) { s := []complex128{} val := Sum(s) if val != 0 { t.Errorf("Val not returned as default when slice length is zero") } s = []complex128{3 + 1i, 4 + 2i, 1 + 3i, 7 + 4i, 5 + 5i} val = Sum(s) if val != 20+15i { t.Errorf("Wrong sum returned") } } func randomSlice(l int, src rand.Source) []complex128 { rnd := rand.New(src) s := make([]complex128, l) for i := range s { s[i] = complex(rnd.Float64(), rnd.Float64()) } return s } func benchmarkAdd(b *testing.B, size int) { src := rand.NewSource(1) s1 := randomSlice(size, src) s2 := randomSlice(size, src) 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) { src := rand.NewSource(1) s1 := randomSlice(size, src) s2 := randomSlice(size, src) dst := randomSlice(size, src) 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) { src := rand.NewSource(1) s := randomSlice(size, src) dst := randomSlice(size, src) 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) { src := rand.NewSource(1) s := randomSlice(size, src) dst := randomSlice(size, src) 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) { src := rand.NewSource(1) s := randomSlice(size, src) dst := randomSlice(size, src) 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) { src := rand.NewSource(1) s1 := randomSlice(size, src) s2 := randomSlice(size, src) dst := randomSlice(size, src) 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) { src := rand.NewSource(1) s1 := randomSlice(size, src) s2 := randomSlice(size, src) 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) { src := rand.NewSource(1) s1 := randomSlice(size, src) s2 := randomSlice(size, src) dst := randomSlice(size, src) 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 benchmarkDot(b *testing.B, size int) { src := rand.NewSource(1) s1 := randomSlice(size, src) s2 := randomSlice(size, src) 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) { src := rand.NewSource(1) dst := randomSlice(size, src) y := randomSlice(size, src) s := randomSlice(size, src) 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) { src := rand.NewSource(1) dst := randomSlice(size, src) 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) } func benchmarkNorm2(b *testing.B, size int) { src := rand.NewSource(1) s := randomSlice(size, src) b.ResetTimer() for i := 0; i < b.N; i++ { Norm(s, 2) } } func BenchmarkNorm2Small(b *testing.B) { benchmarkNorm2(b, Small) } func BenchmarkNorm2Medium(b *testing.B) { benchmarkNorm2(b, Medium) } func BenchmarkNorm2Large(b *testing.B) { benchmarkNorm2(b, Large) } func BenchmarkNorm2Huge(b *testing.B) { benchmarkNorm2(b, Huge) }