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

   1 package testblas
   2
   3 import (
   4         "testing"
   5
   6         "gonum.org/v1/gonum/blas"
   7         "gonum.org/v1/gonum/floats"
   8 )
   9
  10 type Dtrmver interface {
  11         Dtrmv(ul blas.Uplo, tA blas.Transpose, d blas.Diag, n int, a []float64, lda int, x []float64, incX int)
  12 }
  13
  14 func DtrmvTest(t *testing.T, blasser Dtrmver) {
  15         for i, test := range []struct {
  16                 n   int
  17                 a   [][]float64
  18                 x   []float64
  19                 d   blas.Diag
  20                 ul  blas.Uplo
  21                 tA  blas.Transpose
  22                 ans []float64
  23         }{
  24                 {
  25                         n:   1,
  26                         a:   [][]float64{{5}},
  27                         x:   []float64{2},
  28                         d:   blas.NonUnit,
  29                         ul:  blas.Upper,
  30                         tA:  blas.NoTrans,
  31                         ans: []float64{10},
  32                 },
  33                 {
  34                         n:   1,
  35                         a:   [][]float64{{5}},
  36                         x:   []float64{2},
  37                         d:   blas.Unit,
  38                         ul:  blas.Upper,
  39                         tA:  blas.NoTrans,
  40                         ans: []float64{2},
  41                 },
  42                 {
  43                         n: 3,
  44                         a: [][]float64{
  45                                 {5, 6, 7},
  46                                 {0, 9, 10},
  47                                 {0, 0, 13},
  48                         },
  49                         x:   []float64{3, 4, 5},
  50                         d:   blas.NonUnit,
  51                         ul:  blas.Upper,
  52                         tA:  blas.NoTrans,
  53                         ans: []float64{74, 86, 65},
  54                 },
  55                 {
  56                         n: 3,
  57                         a: [][]float64{
  58                                 {5, 6, 7},
  59                                 {0, 9, 10},
  60                                 {0, 0, 13},
  61                         },
  62                         x:   []float64{3, 4, 5},
  63                         d:   blas.Unit,
  64                         ul:  blas.Upper,
  65                         tA:  blas.NoTrans,
  66                         ans: []float64{62, 54, 5},
  67                 },
  68                 {
  69                         n: 3,
  70                         a: [][]float64{
  71                                 {5, 0, 0},
  72                                 {6, 9, 0},
  73                                 {7, 10, 13},
  74                         },
  75                         x:   []float64{3, 4, 5},
  76                         d:   blas.NonUnit,
  77                         ul:  blas.Lower,
  78                         tA:  blas.NoTrans,
  79                         ans: []float64{15, 54, 126},
  80                 },
  81                 {
  82                         n: 3,
  83                         a: [][]float64{
  84                                 {1, 0, 0},
  85                                 {6, 1, 0},
  86                                 {7, 10, 1},
  87                         },
  88                         x:   []float64{3, 4, 5},
  89                         d:   blas.Unit,
  90                         ul:  blas.Lower,
  91                         tA:  blas.NoTrans,
  92                         ans: []float64{3, 22, 66},
  93                 },
  94                 {
  95                         n: 3,
  96                         a: [][]float64{
  97                                 {5, 6, 7},
  98                                 {0, 9, 10},
  99                                 {0, 0, 13},
 100                         },
 101                         x:   []float64{3, 4, 5},
 102                         d:   blas.NonUnit,
 103                         ul:  blas.Upper,
 104                         tA:  blas.Trans,
 105                         ans: []float64{15, 54, 126},
 106                 },
 107                 {
 108                         n: 3,
 109                         a: [][]float64{
 110                                 {1, 6, 7},
 111                                 {0, 1, 10},
 112                                 {0, 0, 1},
 113                         },
 114                         x:   []float64{3, 4, 5},
 115                         d:   blas.Unit,
 116                         ul:  blas.Upper,
 117                         tA:  blas.Trans,
 118                         ans: []float64{3, 22, 66},
 119                 },
 120                 {
 121                         n: 3,
 122                         a: [][]float64{
 123                                 {5, 0, 0},
 124                                 {6, 9, 0},
 125                                 {7, 10, 13},
 126                         },
 127                         x:   []float64{3, 4, 5},
 128                         d:   blas.NonUnit,
 129                         ul:  blas.Lower,
 130                         tA:  blas.Trans,
 131                         ans: []float64{74, 86, 65},
 132                 },
 133         } {
 134                 incTest := func(incX, extra int) {
 135                         aFlat := flatten(test.a)
 136                         x := makeIncremented(test.x, incX, extra)
 137                         blasser.Dtrmv(test.ul, test.tA, test.d, test.n, aFlat, test.n, x, incX)
 138                         ans := makeIncremented(test.ans, incX, extra)
 139                         if !floats.EqualApprox(x, ans, 1e-14) {
 140                                 t.Errorf("Case %v, idx %v: Want %v, got %v.", i, incX, ans, x)
 141                         }
 142                 }
 143                 incTest(1, 3)
 144                 incTest(-3, 3)
 145                 incTest(4, 3)
 146         }
 147 }