1 // Copyright ©2015 The Gonum Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style
3 // license that can be found in the LICENSE file.
11 "golang.org/x/exp/rand"
13 "gonum.org/v1/gonum/blas/blas64"
16 func TestNewVecDense(t *testing.T) {
17 for i, test := range []struct {
24 data: []float64{4, 5, 6},
27 Data: []float64{4, 5, 6},
38 Data: []float64{0, 0, 0},
45 v := NewVecDense(test.n, test.data)
46 rows, cols := v.Dims()
48 t.Errorf("unexpected number of rows for test %d: got: %d want: %d", i, rows, test.n)
51 t.Errorf("unexpected number of cols for test %d: got: %d want: 1", i, cols)
53 if !reflect.DeepEqual(v, test.vector) {
54 t.Errorf("unexpected data slice for test %d: got: %v want: %v", i, v, test.vector)
59 func TestCap(t *testing.T) {
60 for i, test := range []struct {
64 {vector: NewVecDense(3, nil), want: 3},
68 Data: make([]float64, 7, 10),
78 Data: make([]float64, 10),
88 Data: make([]float64, 11),
98 Data: make([]float64, 12),
108 Data: make([]float64, 13),
116 got := test.vector.Cap()
117 if got != test.want {
118 t.Errorf("unexpected capacty for test %d: got: %d want: %d", i, got, test.want)
123 func TestVecDenseAtSet(t *testing.T) {
124 for i, test := range []struct {
130 Data: []float64{0, 1, 2},
139 Data: []float64{0, 10, 10, 1, 10, 10, 2},
149 for _, row := range []int{-1, n} {
150 panicked, message := panics(func() { v.At(row, 0) })
151 if !panicked || message != ErrRowAccess.Error() {
152 t.Errorf("expected panic for invalid row access for test %d n=%d r=%d", i, n, row)
155 for _, col := range []int{-1, 1} {
156 panicked, message := panics(func() { v.At(0, col) })
157 if !panicked || message != ErrColAccess.Error() {
158 t.Errorf("expected panic for invalid column access for test %d n=%d c=%d", i, n, col)
162 for _, row := range []int{0, 1, n - 1} {
163 if e := v.At(row, 0); e != float64(row) {
164 t.Errorf("unexpected value for At(%d, 0) for test %d : got: %v want: %v", row, i, e, float64(row))
168 for _, row := range []int{-1, n} {
169 panicked, message := panics(func() { v.SetVec(row, 100) })
170 if !panicked || message != ErrVectorAccess.Error() {
171 t.Errorf("expected panic for invalid row access for test %d n=%d r=%d", i, n, row)
175 for inc, row := range []int{0, 2} {
176 v.SetVec(row, 100+float64(inc))
177 if e := v.At(row, 0); e != 100+float64(inc) {
178 t.Errorf("unexpected value for At(%d, 0) after SetVec(%[1]d, %v) for test %d: got: %v want: %[2]v", row, 100+float64(inc), i, e)
184 func TestVecDenseMul(t *testing.T) {
185 method := func(receiver, a, b Matrix) {
186 type mulVecer interface {
187 MulVec(a Matrix, b Vector)
189 rd := receiver.(mulVecer)
190 rd.MulVec(a, b.(Vector))
192 denseComparison := func(receiver, a, b *Dense) {
195 legalSizeMulVec := func(ar, ac, br, bc int) bool {
204 testTwoInput(t, "MulVec", &VecDense{}, method, denseComparison, legalTypesMatrixVector, legalSizeMulVec, 1e-14)
207 func TestVecDenseScale(t *testing.T) {
208 for i, test := range []struct {
214 a: NewVecDense(3, []float64{0, 1, 2}),
216 want: NewVecDense(3, []float64{0, 0, 0}),
219 a: NewVecDense(3, []float64{0, 1, 2}),
221 want: NewVecDense(3, []float64{0, 1, 2}),
224 a: NewVecDense(3, []float64{0, 1, 2}),
226 want: NewVecDense(3, []float64{0, -2, -4}),
229 a: NewDense(3, 1, []float64{0, 1, 2}).ColView(0),
231 want: NewVecDense(3, []float64{0, 0, 0}),
234 a: NewDense(3, 1, []float64{0, 1, 2}).ColView(0),
236 want: NewVecDense(3, []float64{0, 1, 2}),
239 a: NewDense(3, 1, []float64{0, 1, 2}).ColView(0),
241 want: NewVecDense(3, []float64{0, -2, -4}),
244 a: NewDense(3, 3, []float64{
250 want: NewVecDense(3, []float64{-2, -8, -14}),
254 v.ScaleVec(test.alpha, test.a.(*VecDense))
255 if !reflect.DeepEqual(v.RawVector(), test.want.RawVector()) {
256 t.Errorf("test %d: unexpected result for v = alpha * a: got: %v want: %v", i, v.RawVector(), test.want.RawVector())
259 v.CopyVec(test.a.(*VecDense))
260 v.ScaleVec(test.alpha, &v)
261 if !reflect.DeepEqual(v.RawVector(), test.want.RawVector()) {
262 t.Errorf("test %d: unexpected result for v = alpha * v: got: %v want: %v", i, v.RawVector(), test.want.RawVector())
266 for _, alpha := range []float64{0, 1, -1, 2.3, -2.3} {
267 method := func(receiver, a Matrix) {
268 type scaleVecer interface {
269 ScaleVec(float64, Vector)
271 v := receiver.(scaleVecer)
272 v.ScaleVec(alpha, a.(Vector))
274 denseComparison := func(receiver, a *Dense) {
275 receiver.Scale(alpha, a)
277 testOneInput(t, "ScaleVec", &VecDense{}, method, denseComparison, legalTypeVector, isAnyColumnVector, 0)
281 func TestVecDenseAddScaled(t *testing.T) {
282 for _, alpha := range []float64{0, 1, -1, 2.3, -2.3} {
283 method := func(receiver, a, b Matrix) {
284 type addScaledVecer interface {
285 AddScaledVec(Vector, float64, Vector)
287 v := receiver.(addScaledVecer)
288 v.AddScaledVec(a.(Vector), alpha, b.(Vector))
290 denseComparison := func(receiver, a, b *Dense) {
295 testTwoInput(t, "AddScaledVec", &VecDense{}, method, denseComparison, legalTypesVectorVector, legalSizeSameVec, 1e-14)
299 func TestVecDenseAdd(t *testing.T) {
300 for i, test := range []struct {
305 a: NewVecDense(3, []float64{0, 1, 2}),
306 b: NewVecDense(3, []float64{0, 2, 3}),
307 want: NewVecDense(3, []float64{0, 3, 5}),
310 a: NewVecDense(3, []float64{0, 1, 2}),
311 b: NewDense(3, 1, []float64{0, 2, 3}).ColView(0),
312 want: NewVecDense(3, []float64{0, 3, 5}),
315 a: NewDense(3, 1, []float64{0, 1, 2}).ColView(0),
316 b: NewDense(3, 1, []float64{0, 2, 3}).ColView(0),
317 want: NewVecDense(3, []float64{0, 3, 5}),
321 v.AddVec(test.a.(*VecDense), test.b.(*VecDense))
322 if !reflect.DeepEqual(v.RawVector(), test.want.RawVector()) {
323 t.Errorf("unexpected result for test %d: got: %v want: %v", i, v.RawVector(), test.want.RawVector())
328 func TestVecDenseSub(t *testing.T) {
329 for i, test := range []struct {
334 a: NewVecDense(3, []float64{0, 1, 2}),
335 b: NewVecDense(3, []float64{0, 0.5, 1}),
336 want: NewVecDense(3, []float64{0, 0.5, 1}),
339 a: NewVecDense(3, []float64{0, 1, 2}),
340 b: NewDense(3, 1, []float64{0, 0.5, 1}).ColView(0),
341 want: NewVecDense(3, []float64{0, 0.5, 1}),
344 a: NewDense(3, 1, []float64{0, 1, 2}).ColView(0),
345 b: NewDense(3, 1, []float64{0, 0.5, 1}).ColView(0),
346 want: NewVecDense(3, []float64{0, 0.5, 1}),
350 v.SubVec(test.a.(*VecDense), test.b.(*VecDense))
351 if !reflect.DeepEqual(v.RawVector(), test.want.RawVector()) {
352 t.Errorf("unexpected result for test %d: got: %v want: %v", i, v.RawVector(), test.want.RawVector())
357 func TestVecDenseMulElem(t *testing.T) {
358 for i, test := range []struct {
363 a: NewVecDense(3, []float64{0, 1, 2}),
364 b: NewVecDense(3, []float64{0, 2, 3}),
365 want: NewVecDense(3, []float64{0, 2, 6}),
368 a: NewVecDense(3, []float64{0, 1, 2}),
369 b: NewDense(3, 1, []float64{0, 2, 3}).ColView(0),
370 want: NewVecDense(3, []float64{0, 2, 6}),
373 a: NewDense(3, 1, []float64{0, 1, 2}).ColView(0),
374 b: NewDense(3, 1, []float64{0, 2, 3}).ColView(0),
375 want: NewVecDense(3, []float64{0, 2, 6}),
379 v.MulElemVec(test.a.(*VecDense), test.b.(*VecDense))
380 if !reflect.DeepEqual(v.RawVector(), test.want.RawVector()) {
381 t.Errorf("unexpected result for test %d: got: %v want: %v", i, v.RawVector(), test.want.RawVector())
386 func TestVecDenseDivElem(t *testing.T) {
387 for i, test := range []struct {
392 a: NewVecDense(3, []float64{0.5, 1, 2}),
393 b: NewVecDense(3, []float64{0.5, 0.5, 1}),
394 want: NewVecDense(3, []float64{1, 2, 2}),
397 a: NewVecDense(3, []float64{0.5, 1, 2}),
398 b: NewDense(3, 1, []float64{0.5, 0.5, 1}).ColView(0),
399 want: NewVecDense(3, []float64{1, 2, 2}),
402 a: NewDense(3, 1, []float64{0.5, 1, 2}).ColView(0),
403 b: NewDense(3, 1, []float64{0.5, 0.5, 1}).ColView(0),
404 want: NewVecDense(3, []float64{1, 2, 2}),
408 v.DivElemVec(test.a.(*VecDense), test.b.(*VecDense))
409 if !reflect.DeepEqual(v.RawVector(), test.want.RawVector()) {
410 t.Errorf("unexpected result for test %d: got: %v want: %v", i, v.RawVector(), test.want.RawVector())
415 func BenchmarkAddScaledVec10Inc1(b *testing.B) { addScaledVecBench(b, 10, 1) }
416 func BenchmarkAddScaledVec100Inc1(b *testing.B) { addScaledVecBench(b, 100, 1) }
417 func BenchmarkAddScaledVec1000Inc1(b *testing.B) { addScaledVecBench(b, 1000, 1) }
418 func BenchmarkAddScaledVec10000Inc1(b *testing.B) { addScaledVecBench(b, 10000, 1) }
419 func BenchmarkAddScaledVec100000Inc1(b *testing.B) { addScaledVecBench(b, 100000, 1) }
420 func BenchmarkAddScaledVec10Inc2(b *testing.B) { addScaledVecBench(b, 10, 2) }
421 func BenchmarkAddScaledVec100Inc2(b *testing.B) { addScaledVecBench(b, 100, 2) }
422 func BenchmarkAddScaledVec1000Inc2(b *testing.B) { addScaledVecBench(b, 1000, 2) }
423 func BenchmarkAddScaledVec10000Inc2(b *testing.B) { addScaledVecBench(b, 10000, 2) }
424 func BenchmarkAddScaledVec100000Inc2(b *testing.B) { addScaledVecBench(b, 100000, 2) }
425 func BenchmarkAddScaledVec10Inc20(b *testing.B) { addScaledVecBench(b, 10, 20) }
426 func BenchmarkAddScaledVec100Inc20(b *testing.B) { addScaledVecBench(b, 100, 20) }
427 func BenchmarkAddScaledVec1000Inc20(b *testing.B) { addScaledVecBench(b, 1000, 20) }
428 func BenchmarkAddScaledVec10000Inc20(b *testing.B) { addScaledVecBench(b, 10000, 20) }
429 func BenchmarkAddScaledVec100000Inc20(b *testing.B) { addScaledVecBench(b, 100000, 20) }
430 func addScaledVecBench(b *testing.B, size, inc int) {
431 x := randVecDense(size, inc, 1, rand.NormFloat64)
432 y := randVecDense(size, inc, 1, rand.NormFloat64)
435 for i := 0; i < b.N; i++ {
436 v.AddScaledVec(y, 2, x)
440 func BenchmarkScaleVec10Inc1(b *testing.B) { scaleVecBench(b, 10, 1) }
441 func BenchmarkScaleVec100Inc1(b *testing.B) { scaleVecBench(b, 100, 1) }
442 func BenchmarkScaleVec1000Inc1(b *testing.B) { scaleVecBench(b, 1000, 1) }
443 func BenchmarkScaleVec10000Inc1(b *testing.B) { scaleVecBench(b, 10000, 1) }
444 func BenchmarkScaleVec100000Inc1(b *testing.B) { scaleVecBench(b, 100000, 1) }
445 func BenchmarkScaleVec10Inc2(b *testing.B) { scaleVecBench(b, 10, 2) }
446 func BenchmarkScaleVec100Inc2(b *testing.B) { scaleVecBench(b, 100, 2) }
447 func BenchmarkScaleVec1000Inc2(b *testing.B) { scaleVecBench(b, 1000, 2) }
448 func BenchmarkScaleVec10000Inc2(b *testing.B) { scaleVecBench(b, 10000, 2) }
449 func BenchmarkScaleVec100000Inc2(b *testing.B) { scaleVecBench(b, 100000, 2) }
450 func BenchmarkScaleVec10Inc20(b *testing.B) { scaleVecBench(b, 10, 20) }
451 func BenchmarkScaleVec100Inc20(b *testing.B) { scaleVecBench(b, 100, 20) }
452 func BenchmarkScaleVec1000Inc20(b *testing.B) { scaleVecBench(b, 1000, 20) }
453 func BenchmarkScaleVec10000Inc20(b *testing.B) { scaleVecBench(b, 10000, 20) }
454 func BenchmarkScaleVec100000Inc20(b *testing.B) { scaleVecBench(b, 100000, 20) }
455 func scaleVecBench(b *testing.B, size, inc int) {
456 x := randVecDense(size, inc, 1, rand.NormFloat64)
459 for i := 0; i < b.N; i++ {
464 func BenchmarkAddVec10Inc1(b *testing.B) { addVecBench(b, 10, 1) }
465 func BenchmarkAddVec100Inc1(b *testing.B) { addVecBench(b, 100, 1) }
466 func BenchmarkAddVec1000Inc1(b *testing.B) { addVecBench(b, 1000, 1) }
467 func BenchmarkAddVec10000Inc1(b *testing.B) { addVecBench(b, 10000, 1) }
468 func BenchmarkAddVec100000Inc1(b *testing.B) { addVecBench(b, 100000, 1) }
469 func BenchmarkAddVec10Inc2(b *testing.B) { addVecBench(b, 10, 2) }
470 func BenchmarkAddVec100Inc2(b *testing.B) { addVecBench(b, 100, 2) }
471 func BenchmarkAddVec1000Inc2(b *testing.B) { addVecBench(b, 1000, 2) }
472 func BenchmarkAddVec10000Inc2(b *testing.B) { addVecBench(b, 10000, 2) }
473 func BenchmarkAddVec100000Inc2(b *testing.B) { addVecBench(b, 100000, 2) }
474 func BenchmarkAddVec10Inc20(b *testing.B) { addVecBench(b, 10, 20) }
475 func BenchmarkAddVec100Inc20(b *testing.B) { addVecBench(b, 100, 20) }
476 func BenchmarkAddVec1000Inc20(b *testing.B) { addVecBench(b, 1000, 20) }
477 func BenchmarkAddVec10000Inc20(b *testing.B) { addVecBench(b, 10000, 20) }
478 func BenchmarkAddVec100000Inc20(b *testing.B) { addVecBench(b, 100000, 20) }
479 func addVecBench(b *testing.B, size, inc int) {
480 x := randVecDense(size, inc, 1, rand.NormFloat64)
481 y := randVecDense(size, inc, 1, rand.NormFloat64)
484 for i := 0; i < b.N; i++ {
489 func BenchmarkSubVec10Inc1(b *testing.B) { subVecBench(b, 10, 1) }
490 func BenchmarkSubVec100Inc1(b *testing.B) { subVecBench(b, 100, 1) }
491 func BenchmarkSubVec1000Inc1(b *testing.B) { subVecBench(b, 1000, 1) }
492 func BenchmarkSubVec10000Inc1(b *testing.B) { subVecBench(b, 10000, 1) }
493 func BenchmarkSubVec100000Inc1(b *testing.B) { subVecBench(b, 100000, 1) }
494 func BenchmarkSubVec10Inc2(b *testing.B) { subVecBench(b, 10, 2) }
495 func BenchmarkSubVec100Inc2(b *testing.B) { subVecBench(b, 100, 2) }
496 func BenchmarkSubVec1000Inc2(b *testing.B) { subVecBench(b, 1000, 2) }
497 func BenchmarkSubVec10000Inc2(b *testing.B) { subVecBench(b, 10000, 2) }
498 func BenchmarkSubVec100000Inc2(b *testing.B) { subVecBench(b, 100000, 2) }
499 func BenchmarkSubVec10Inc20(b *testing.B) { subVecBench(b, 10, 20) }
500 func BenchmarkSubVec100Inc20(b *testing.B) { subVecBench(b, 100, 20) }
501 func BenchmarkSubVec1000Inc20(b *testing.B) { subVecBench(b, 1000, 20) }
502 func BenchmarkSubVec10000Inc20(b *testing.B) { subVecBench(b, 10000, 20) }
503 func BenchmarkSubVec100000Inc20(b *testing.B) { subVecBench(b, 100000, 20) }
504 func subVecBench(b *testing.B, size, inc int) {
505 x := randVecDense(size, inc, 1, rand.NormFloat64)
506 y := randVecDense(size, inc, 1, rand.NormFloat64)
509 for i := 0; i < b.N; i++ {
514 func randVecDense(size, inc int, rho float64, rnd func() float64) *VecDense {
516 panic("bad vector size")
518 data := make([]float64, size*inc)
519 for i := range data {
520 if rand.Float64() < rho {