vendor/gonum.org/v1/gonum/blas/testblas/dsbmv.go

   1 package testblas
   2
   3 import (
   4         "testing"
   5
   6         "gonum.org/v1/gonum/blas"
   7 )
   8
   9 type Dsbmver interface {
  10         Dsbmv(ul blas.Uplo, n, k int, alpha float64, a []float64, lda int, x []float64, incX int, beta float64, y []float64, incY int)
  11 }
  12
  13 func DsbmvTest(t *testing.T, blasser Dsbmver) {
  14         for i, test := range []struct {
  15                 ul    blas.Uplo
  16                 n     int
  17                 k     int
  18                 alpha float64
  19                 beta  float64
  20                 a     [][]float64
  21                 x     []float64
  22                 y     []float64
  23
  24                 ans []float64
  25         }{
  26                 {
  27                         ul:    blas.Upper,
  28                         n:     4,
  29                         k:     2,
  30                         alpha: 2,
  31                         beta:  3,
  32                         a: [][]float64{
  33                                 {7, 8, 2, 0},
  34                                 {0, 8, 2, -3},
  35                                 {0, 0, 3, 6},
  36                                 {0, 0, 0, 9},
  37                         },
  38                         x:   []float64{1, 2, 3, 4},
  39                         y:   []float64{-1, -2, -3, -4},
  40                         ans: []float64{55, 30, 69, 84},
  41                 },
  42                 {
  43                         ul:    blas.Lower,
  44                         n:     4,
  45                         k:     2,
  46                         alpha: 2,
  47                         beta:  3,
  48                         a: [][]float64{
  49                                 {7, 0, 0, 0},
  50                                 {8, 8, 0, 0},
  51                                 {2, 2, 3, 0},
  52                                 {0, -3, 6, 9},
  53                         },
  54                         x:   []float64{1, 2, 3, 4},
  55                         y:   []float64{-1, -2, -3, -4},
  56                         ans: []float64{55, 30, 69, 84},
  57                 },
  58         } {
  59                 extra := 0
  60                 var aFlat []float64
  61                 if test.ul == blas.Upper {
  62                         aFlat = flattenBanded(test.a, test.k, 0)
  63                 } else {
  64                         aFlat = flattenBanded(test.a, 0, test.k)
  65                 }
  66                 incTest := func(incX, incY, extra int) {
  67                         xnew := makeIncremented(test.x, incX, extra)
  68                         ynew := makeIncremented(test.y, incY, extra)
  69                         ans := makeIncremented(test.ans, incY, extra)
  70                         blasser.Dsbmv(test.ul, test.n, test.k, test.alpha, aFlat, test.k+1, xnew, incX, test.beta, ynew, incY)
  71                         if !dSliceTolEqual(ans, ynew) {
  72                                 t.Errorf("Case %v: Want %v, got %v", i, ans, ynew)
  73                         }
  74                 }
  75                 incTest(1, 1, extra)
  76                 incTest(1, 3, extra)
  77                 incTest(1, -3, extra)
  78                 incTest(2, 3, extra)
  79                 incTest(2, -3, extra)
  80                 incTest(3, 2, extra)
  81                 incTest(-3, 2, extra)
  82         }
  83 }