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

   1 package testblas
   2
   3 import (
   4         "testing"
   5
   6         "gonum.org/v1/gonum/blas"
   7 )
   8
   9 type Dgbmver interface {
  10         Dgbmv(tA blas.Transpose, m, n, kL, kU int, alpha float64, a []float64, lda int, x []float64, incX int, beta float64, y []float64, incY int)
  11 }
  12
  13 func DgbmvTest(t *testing.T, blasser Dgbmver) {
  14         for i, test := range []struct {
  15                 tA     blas.Transpose
  16                 m, n   int
  17                 kL, kU int
  18                 alpha  float64
  19                 a      [][]float64
  20                 lda    int
  21                 x      []float64
  22                 beta   float64
  23                 y      []float64
  24                 ans    []float64
  25         }{
  26                 {
  27                         tA:    blas.NoTrans,
  28                         m:     9,
  29                         n:     6,
  30                         lda:   4,
  31                         kL:    2,
  32                         kU:    1,
  33                         alpha: 3.0,
  34                         beta:  2.0,
  35                         a: [][]float64{
  36                                 {5, 3, 0, 0, 0, 0},
  37                                 {-1, 2, 9, 0, 0, 0},
  38                                 {4, 8, 3, 6, 0, 0},
  39                                 {0, -1, 8, 2, 1, 0},
  40                                 {0, 0, 9, 9, 9, 5},
  41                                 {0, 0, 0, 2, -3, 2},
  42                                 {0, 0, 0, 0, 1, 5},
  43                                 {0, 0, 0, 0, 0, 6},
  44                         },
  45                         x:   []float64{1, 2, 3, 4, 5, 6},
  46                         y:   []float64{-1, -2, -3, -4, -5, -6, -7, -8, -9},
  47                         ans: []float64{31, 86, 153, 97, 404, 3, 91, 92, -18},
  48                 },
  49                 {
  50                         tA:    blas.Trans,
  51                         m:     9,
  52                         n:     6,
  53                         lda:   4,
  54                         kL:    2,
  55                         kU:    1,
  56                         alpha: 3.0,
  57                         beta:  2.0,
  58                         a: [][]float64{
  59                                 {5, 3, 0, 0, 0, 0},
  60                                 {-1, 2, 9, 0, 0, 0},
  61                                 {4, 8, 3, 6, 0, 0},
  62                                 {0, -1, 8, 2, 1, 0},
  63                                 {0, 0, 9, 9, 9, 5},
  64                                 {0, 0, 0, 2, -3, 2},
  65                                 {0, 0, 0, 0, 1, 5},
  66                                 {0, 0, 0, 0, 0, 6},
  67                         },
  68                         x:   []float64{1, 2, 3, 4, 5, 6, 7, 8, 9},
  69                         y:   []float64{-1, -2, -3, -4, -5, -6},
  70                         ans: []float64{43, 77, 306, 241, 104, 348},
  71                 },
  72                 {
  73                         tA:    blas.NoTrans,
  74                         m:     6,
  75                         n:     3,
  76                         lda:   1,
  77                         kL:    0,
  78                         kU:    0,
  79                         alpha: 2.0,
  80                         beta:  1.0,
  81                         a: [][]float64{
  82                                 {1, 0, 0},
  83                                 {0, 1, 0},
  84                                 {0, 0, 1},
  85                         },
  86                         x:   []float64{1, 2, 3},
  87                         y:   []float64{-1, -2, -3, -4, -5, -6},
  88                         ans: []float64{1, 2, 3, -4, -5, -6},
  89                 },
  90                 {
  91                         tA:    blas.Trans,
  92                         m:     6,
  93                         n:     3,
  94                         lda:   1,
  95                         kL:    0,
  96                         kU:    0,
  97                         alpha: 2.0,
  98                         beta:  1.0,
  99                         a: [][]float64{
 100                                 {1, 0, 0},
 101                                 {0, 1, 0},
 102                                 {0, 0, 1},
 103                                 {0, 0, 0},
 104                                 {0, 0, 0},
 105                                 {0, 0, 0},
 106                         },
 107                         x:   []float64{1, 2, 3, 4, 5, 6},
 108                         y:   []float64{-1, -2, -3},
 109                         ans: []float64{1, 2, 3},
 110                 },
 111         } {
 112                 extra := 3
 113                 aFlat := flattenBanded(test.a, test.kU, test.kL)
 114                 incTest := func(incX, incY, extra int) {
 115                         xnew := makeIncremented(test.x, incX, extra)
 116                         ynew := makeIncremented(test.y, incY, extra)
 117                         ans := makeIncremented(test.ans, incY, extra)
 118                         blasser.Dgbmv(test.tA, test.m, test.n, test.kL, test.kU, test.alpha, aFlat, test.lda, xnew, incX, test.beta, ynew, incY)
 119                         if !dSliceTolEqual(ans, ynew) {
 120                                 t.Errorf("Case %v: Want %v, got %v", i, ans, ynew)
 121                         }
 122                 }
 123                 incTest(1, 1, extra)
 124                 incTest(1, 3, extra)
 125                 incTest(1, -3, extra)
 126                 incTest(2, 3, extra)
 127                 incTest(2, -3, extra)
 128                 incTest(3, 2, extra)
 129                 incTest(-3, 2, extra)
 130         }
 131 }