+++ /dev/null
-// Copyright ©2013 The Gonum 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 mat
-
-import (
- "fmt"
- "math"
- "reflect"
- "testing"
-
- "gonum.org/v1/gonum/blas"
- "gonum.org/v1/gonum/blas/blas64"
- "gonum.org/v1/gonum/floats"
-)
-
-func panics(fn func()) (panicked bool, message string) {
- defer func() {
- r := recover()
- panicked = r != nil
- message = fmt.Sprint(r)
- }()
- fn()
- return
-}
-
-func flatten(f [][]float64) (r, c int, d []float64) {
- r = len(f)
- if r == 0 {
- panic("bad test: no row")
- }
- c = len(f[0])
- d = make([]float64, 0, r*c)
- for _, row := range f {
- if len(row) != c {
- panic("bad test: ragged input")
- }
- d = append(d, row...)
- }
- return r, c, d
-}
-
-func unflatten(r, c int, d []float64) [][]float64 {
- m := make([][]float64, r)
- for i := 0; i < r; i++ {
- m[i] = d[i*c : (i+1)*c]
- }
- return m
-}
-
-// eye returns a new identity matrix of size n×n.
-func eye(n int) *Dense {
- d := make([]float64, n*n)
- for i := 0; i < n*n; i += n + 1 {
- d[i] = 1
- }
- return NewDense(n, n, d)
-}
-
-func TestCol(t *testing.T) {
- for id, af := range [][][]float64{
- {
- {1, 2, 3},
- {4, 5, 6},
- {7, 8, 9},
- },
- {
- {1, 2, 3},
- {4, 5, 6},
- {7, 8, 9},
- {10, 11, 12},
- },
- {
- {1, 2, 3, 4},
- {5, 6, 7, 8},
- {9, 10, 11, 12},
- },
- } {
- a := NewDense(flatten(af))
- col := make([]float64, a.mat.Rows)
- for j := range af[0] {
- for i := range col {
- col[i] = float64(i*a.mat.Cols + j + 1)
- }
-
- if got := Col(nil, j, a); !reflect.DeepEqual(got, col) {
- t.Errorf("test %d: unexpected values returned for dense col %d: got: %v want: %v",
- id, j, got, col)
- }
-
- got := make([]float64, a.mat.Rows)
- if Col(got, j, a); !reflect.DeepEqual(got, col) {
- t.Errorf("test %d: unexpected values filled for dense col %d: got: %v want: %v",
- id, j, got, col)
- }
- }
- }
-
- denseComparison := func(a *Dense) interface{} {
- r, c := a.Dims()
- ans := make([][]float64, c)
- for j := range ans {
- ans[j] = make([]float64, r)
- for i := range ans[j] {
- ans[j][i] = a.At(i, j)
- }
- }
- return ans
- }
-
- f := func(a Matrix) interface{} {
- _, c := a.Dims()
- ans := make([][]float64, c)
- for j := range ans {
- ans[j] = Col(nil, j, a)
- }
- return ans
- }
- testOneInputFunc(t, "Col", f, denseComparison, sameAnswerF64SliceOfSlice, isAnyType, isAnySize)
-
- f = func(a Matrix) interface{} {
- r, c := a.Dims()
- ans := make([][]float64, c)
- for j := range ans {
- ans[j] = make([]float64, r)
- Col(ans[j], j, a)
- }
- return ans
- }
- testOneInputFunc(t, "Col", f, denseComparison, sameAnswerF64SliceOfSlice, isAnyType, isAnySize)
-}
-
-func TestRow(t *testing.T) {
- for id, af := range [][][]float64{
- {
- {1, 2, 3},
- {4, 5, 6},
- {7, 8, 9},
- },
- {
- {1, 2, 3},
- {4, 5, 6},
- {7, 8, 9},
- {10, 11, 12},
- },
- {
- {1, 2, 3, 4},
- {5, 6, 7, 8},
- {9, 10, 11, 12},
- },
- } {
- a := NewDense(flatten(af))
- for i, row := range af {
- if got := Row(nil, i, a); !reflect.DeepEqual(got, row) {
- t.Errorf("test %d: unexpected values returned for dense row %d: got: %v want: %v",
- id, i, got, row)
- }
-
- got := make([]float64, len(row))
- if Row(got, i, a); !reflect.DeepEqual(got, row) {
- t.Errorf("test %d: unexpected values filled for dense row %d: got: %v want: %v",
- id, i, got, row)
- }
- }
- }
-
- denseComparison := func(a *Dense) interface{} {
- r, c := a.Dims()
- ans := make([][]float64, r)
- for i := range ans {
- ans[i] = make([]float64, c)
- for j := range ans[i] {
- ans[i][j] = a.At(i, j)
- }
- }
- return ans
- }
-
- f := func(a Matrix) interface{} {
- r, _ := a.Dims()
- ans := make([][]float64, r)
- for i := range ans {
- ans[i] = Row(nil, i, a)
- }
- return ans
- }
- testOneInputFunc(t, "Row", f, denseComparison, sameAnswerF64SliceOfSlice, isAnyType, isAnySize)
-
- f = func(a Matrix) interface{} {
- r, c := a.Dims()
- ans := make([][]float64, r)
- for i := range ans {
- ans[i] = make([]float64, c)
- Row(ans[i], i, a)
- }
- return ans
- }
- testOneInputFunc(t, "Row", f, denseComparison, sameAnswerF64SliceOfSlice, isAnyType, isAnySize)
-}
-
-func TestCond(t *testing.T) {
- for i, test := range []struct {
- a *Dense
- condOne float64
- condTwo float64
- condInf float64
- }{
- {
- a: NewDense(3, 3, []float64{
- 8, 1, 6,
- 3, 5, 7,
- 4, 9, 2,
- }),
- condOne: 16.0 / 3.0,
- condTwo: 4.330127018922192,
- condInf: 16.0 / 3.0,
- },
- {
- a: NewDense(4, 4, []float64{
- 2, 9, 3, 2,
- 10, 9, 9, 3,
- 1, 1, 5, 2,
- 8, 4, 10, 2,
- }),
- condOne: 1 / 0.024740155174938,
- condTwo: 34.521576567075087,
- condInf: 1 / 0.012034465570035,
- },
- {
- a: NewDense(3, 3, []float64{
- 5, 6, 7,
- 8, -2, 1,
- 7, 7, 7}),
- condOne: 30.769230769230749,
- condTwo: 21.662689498448440,
- condInf: 31.153846153846136,
- },
- } {
- orig := DenseCopyOf(test.a)
- condOne := Cond(test.a, 1)
- if !floats.EqualWithinAbsOrRel(test.condOne, condOne, 1e-13, 1e-13) {
- t.Errorf("Case %d: one norm mismatch. Want %v, got %v", i, test.condOne, condOne)
- }
- if !Equal(test.a, orig) {
- t.Errorf("Case %d: unexpected mutation of input matrix for one norm. Want %v, got %v", i, orig, test.a)
- }
- condTwo := Cond(test.a, 2)
- if !floats.EqualWithinAbsOrRel(test.condTwo, condTwo, 1e-13, 1e-13) {
- t.Errorf("Case %d: two norm mismatch. Want %v, got %v", i, test.condTwo, condTwo)
- }
- if !Equal(test.a, orig) {
- t.Errorf("Case %d: unexpected mutation of input matrix for two norm. Want %v, got %v", i, orig, test.a)
- }
- condInf := Cond(test.a, math.Inf(1))
- if !floats.EqualWithinAbsOrRel(test.condInf, condInf, 1e-13, 1e-13) {
- t.Errorf("Case %d: inf norm mismatch. Want %v, got %v", i, test.condInf, condInf)
- }
- if !Equal(test.a, orig) {
- t.Errorf("Case %d: unexpected mutation of input matrix for inf norm. Want %v, got %v", i, orig, test.a)
- }
- }
-
- for _, test := range []struct {
- name string
- norm float64
- }{
- {
- name: "CondOne",
- norm: 1,
- },
- {
- name: "CondTwo",
- norm: 2,
- },
- {
- name: "CondInf",
- norm: math.Inf(1),
- },
- } {
- f := func(a Matrix) interface{} {
- return Cond(a, test.norm)
- }
- denseComparison := func(a *Dense) interface{} {
- return Cond(a, test.norm)
- }
- testOneInputFunc(t, test.name, f, denseComparison, sameAnswerFloatApproxTol(1e-12), isAnyType, isAnySize)
- }
-}
-
-func TestDet(t *testing.T) {
- for c, test := range []struct {
- a *Dense
- ans float64
- }{
- {
- a: NewDense(2, 2, []float64{1, 0, 0, 1}),
- ans: 1,
- },
- {
- a: NewDense(2, 2, []float64{1, 0, 0, -1}),
- ans: -1,
- },
- {
- a: NewDense(3, 3, []float64{
- 1, 2, 0,
- 0, 1, 2,
- 0, 2, 1,
- }),
- ans: -3,
- },
- {
- a: NewDense(3, 3, []float64{
- 1, 2, 3,
- 5, 7, 9,
- 6, 9, 12,
- }),
- ans: 0,
- },
- } {
- a := DenseCopyOf(test.a)
- det := Det(a)
- if !Equal(a, test.a) {
- t.Errorf("Input matrix changed during Det. Case %d.", c)
- }
- if !floats.EqualWithinAbsOrRel(det, test.ans, 1e-14, 1e-14) {
- t.Errorf("Det mismatch case %d. Got %v, want %v", c, det, test.ans)
- }
- }
- // Perform the normal list test to ensure it works for all types.
- f := func(a Matrix) interface{} {
- return Det(a)
- }
- denseComparison := func(a *Dense) interface{} {
- return Det(a)
- }
- testOneInputFunc(t, "Det", f, denseComparison, sameAnswerFloatApproxTol(1e-12), isAnyType, isSquare)
-
- // Check that it gives approximately the same answer as Cholesky
- // Ensure the input matrices are wider than tall so they are full rank
- isWide := func(ar, ac int) bool {
- return ar <= ac
- }
- f = func(a Matrix) interface{} {
- ar, ac := a.Dims()
- if !isWide(ar, ac) {
- panic(ErrShape)
- }
- var tmp Dense
- tmp.Mul(a, a.T())
- return Det(&tmp)
- }
- denseComparison = func(a *Dense) interface{} {
- ar, ac := a.Dims()
- if !isWide(ar, ac) {
- panic(ErrShape)
- }
- var tmp SymDense
- tmp.SymOuterK(1, a)
- var chol Cholesky
- ok := chol.Factorize(&tmp)
- if !ok {
- panic("bad chol test")
- }
- return chol.Det()
- }
- testOneInputFunc(t, "DetVsChol", f, denseComparison, sameAnswerFloatApproxTol(1e-10), isAnyType, isWide)
-}
-
-type basicVector struct {
- m []float64
-}
-
-func (v *basicVector) AtVec(i int) float64 {
- if i < 0 || i >= v.Len() {
- panic(ErrRowAccess)
- }
- return v.m[i]
-}
-
-func (v *basicVector) At(r, c int) float64 {
- if c != 0 {
- panic(ErrColAccess)
- }
- return v.AtVec(r)
-}
-
-func (v *basicVector) Dims() (r, c int) {
- return v.Len(), 1
-}
-
-func (v *basicVector) T() Matrix {
- return Transpose{v}
-}
-
-func (v *basicVector) Len() int {
- return len(v.m)
-}
-
-func TestDot(t *testing.T) {
- f := func(a, b Matrix) interface{} {
- return Dot(a.(Vector), b.(Vector))
- }
- denseComparison := func(a, b *Dense) interface{} {
- ra, ca := a.Dims()
- rb, cb := b.Dims()
- if ra != rb || ca != cb {
- panic(ErrShape)
- }
- var sum float64
- for i := 0; i < ra; i++ {
- for j := 0; j < ca; j++ {
- sum += a.At(i, j) * b.At(i, j)
- }
- }
- return sum
- }
- testTwoInputFunc(t, "Dot", f, denseComparison, sameAnswerFloatApproxTol(1e-12), legalTypesVectorVector, legalSizeSameVec)
-}
-
-func TestEqual(t *testing.T) {
- f := func(a, b Matrix) interface{} {
- return Equal(a, b)
- }
- denseComparison := func(a, b *Dense) interface{} {
- return Equal(a, b)
- }
- testTwoInputFunc(t, "Equal", f, denseComparison, sameAnswerBool, legalTypesAll, isAnySize2)
-}
-
-func TestMax(t *testing.T) {
- // A direct test of Max with *Dense arguments is in TestNewDense.
- f := func(a Matrix) interface{} {
- return Max(a)
- }
- denseComparison := func(a *Dense) interface{} {
- return Max(a)
- }
- testOneInputFunc(t, "Max", f, denseComparison, sameAnswerFloat, isAnyType, isAnySize)
-}
-
-func TestMin(t *testing.T) {
- // A direct test of Min with *Dense arguments is in TestNewDense.
- f := func(a Matrix) interface{} {
- return Min(a)
- }
- denseComparison := func(a *Dense) interface{} {
- return Min(a)
- }
- testOneInputFunc(t, "Min", f, denseComparison, sameAnswerFloat, isAnyType, isAnySize)
-}
-
-func TestNorm(t *testing.T) {
- for i, test := range []struct {
- a [][]float64
- ord float64
- norm float64
- }{
- {
- a: [][]float64{{1, 2, 3}, {4, 5, 6}, {7, 8, 9}, {10, 11, 12}},
- ord: 1,
- norm: 30,
- },
- {
- a: [][]float64{{1, 2, 3}, {4, 5, 6}, {7, 8, 9}, {10, 11, 12}},
- ord: 2,
- norm: 25.495097567963924,
- },
- {
- a: [][]float64{{1, 2, 3}, {4, 5, 6}, {7, 8, 9}, {10, 11, 12}},
- ord: math.Inf(1),
- norm: 33,
- },
- {
- a: [][]float64{{1, -2, -2}, {-4, 5, 6}},
- ord: 1,
- norm: 8,
- },
- {
- a: [][]float64{{1, -2, -2}, {-4, 5, 6}},
- ord: math.Inf(1),
- norm: 15,
- },
- } {
- a := NewDense(flatten(test.a))
- if math.Abs(Norm(a, test.ord)-test.norm) > 1e-14 {
- t.Errorf("Mismatch test %d: %v norm = %f", i, test.a, test.norm)
- }
- }
-
- for _, test := range []struct {
- name string
- norm float64
- }{
- {"NormOne", 1},
- {"NormTwo", 2},
- {"NormInf", math.Inf(1)},
- } {
- f := func(a Matrix) interface{} {
- return Norm(a, test.norm)
- }
- denseComparison := func(a *Dense) interface{} {
- return Norm(a, test.norm)
- }
- testOneInputFunc(t, test.name, f, denseComparison, sameAnswerFloatApproxTol(1e-12), isAnyType, isAnySize)
- }
-}
-
-func TestNormZero(t *testing.T) {
- for _, a := range []Matrix{
- &Dense{},
- &SymDense{},
- &SymDense{mat: blas64.Symmetric{Uplo: blas.Upper}},
- &TriDense{},
- &TriDense{mat: blas64.Triangular{Uplo: blas.Upper, Diag: blas.NonUnit}},
- &VecDense{},
- } {
- for _, norm := range []float64{1, 2, math.Inf(1)} {
- panicked, message := panics(func() { Norm(a, norm) })
- if !panicked {
- t.Errorf("expected panic for Norm(&%T{}, %v)", a, norm)
- }
- if message != ErrShape.Error() {
- t.Errorf("unexpected panic string for Norm(&%T{}, %v): got:%s want:%s",
- a, norm, message, ErrShape.Error())
- }
- }
- }
-}
-
-func TestSum(t *testing.T) {
- f := func(a Matrix) interface{} {
- return Sum(a)
- }
- denseComparison := func(a *Dense) interface{} {
- return Sum(a)
- }
- testOneInputFunc(t, "Sum", f, denseComparison, sameAnswerFloatApproxTol(1e-12), isAnyType, isAnySize)
-}
-
-func TestTrace(t *testing.T) {
- for _, test := range []struct {
- a *Dense
- trace float64
- }{
- {
- a: NewDense(3, 3, []float64{1, 2, 3, 4, 5, 6, 7, 8, 9}),
- trace: 15,
- },
- } {
- trace := Trace(test.a)
- if trace != test.trace {
- t.Errorf("Trace mismatch. Want %v, got %v", test.trace, trace)
- }
- }
- f := func(a Matrix) interface{} {
- return Trace(a)
- }
- denseComparison := func(a *Dense) interface{} {
- return Trace(a)
- }
- testOneInputFunc(t, "Trace", f, denseComparison, sameAnswerFloat, isAnyType, isSquare)
-}
-
-func TestDoer(t *testing.T) {
- type MatrixDoer interface {
- Matrix
- NonZeroDoer
- RowNonZeroDoer
- ColNonZeroDoer
- }
- ones := func(n int) []float64 {
- data := make([]float64, n)
- for i := range data {
- data[i] = 1
- }
- return data
- }
- for i, m := range []MatrixDoer{
- NewTriDense(3, Lower, ones(3*3)),
- NewTriDense(3, Upper, ones(3*3)),
- NewBandDense(6, 6, 1, 1, ones(3*6)),
- NewBandDense(6, 10, 1, 1, ones(3*6)),
- NewBandDense(10, 6, 1, 1, ones(7*3)),
- NewSymBandDense(3, 0, ones(3)),
- NewSymBandDense(3, 1, ones(3*(1+1))),
- NewSymBandDense(6, 1, ones(6*(1+1))),
- NewSymBandDense(6, 2, ones(6*(2+1))),
- } {
- r, c := m.Dims()
-
- want := Sum(m)
-
- // got and fn sum the accessed elements in
- // the Doer that is being operated on.
- // fn also tests that the accessed elements
- // are within the writable areas of the
- // matrix to check that only valid elements
- // are operated on.
- var got float64
- fn := func(i, j int, v float64) {
- got += v
- switch m := m.(type) {
- case MutableTriangular:
- m.SetTri(i, j, v)
- case MutableBanded:
- m.SetBand(i, j, v)
- case MutableSymBanded:
- m.SetSymBand(i, j, v)
- default:
- panic("bad test: need mutable type")
- }
- }
-
- panicked, message := panics(func() { m.DoNonZero(fn) })
- if panicked {
- t.Errorf("unexpected panic for Doer test %d: %q", i, message)
- continue
- }
- if got != want {
- t.Errorf("unexpected Doer sum: got:%f want:%f", got, want)
- }
-
- // Reset got for testing with DoRowNonZero.
- got = 0
- panicked, message = panics(func() {
- for i := 0; i < r; i++ {
- m.DoRowNonZero(i, fn)
- }
- })
- if panicked {
- t.Errorf("unexpected panic for RowDoer test %d: %q", i, message)
- continue
- }
- if got != want {
- t.Errorf("unexpected RowDoer sum: got:%f want:%f", got, want)
- }
-
- // Reset got for testing with DoColNonZero.
- got = 0
- panicked, message = panics(func() {
- for j := 0; j < c; j++ {
- m.DoColNonZero(j, fn)
- }
- })
- if panicked {
- t.Errorf("unexpected panic for ColDoer test %d: %q", i, message)
- continue
- }
- if got != want {
- t.Errorf("unexpected ColDoer sum: got:%f want:%f", got, want)
- }
- }
-}
OSDN Git Service
