vendor/gonum.org/v1/gonum/blas/testblas/dtpmv.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 Dtpmver interface {
  11         Dtpmv(ul blas.Uplo, tA blas.Transpose, d blas.Diag, n int, ap []float64, x []float64, incX int)
  12 }
  13
  14 func DtpmvTest(t *testing.T, blasser Dtpmver) {
  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: 3,
  26                         a: [][]float64{
  27                                 {5, 6, 7},
  28                                 {0, 9, 10},
  29                                 {0, 0, 13},
  30                         },
  31                         x:   []float64{3, 4, 5},
  32                         d:   blas.NonUnit,
  33                         ul:  blas.Upper,
  34                         tA:  blas.NoTrans,
  35                         ans: []float64{74, 86, 65},
  36                 },
  37                 {
  38                         n: 3,
  39                         a: [][]float64{
  40                                 {5, 6, 7},
  41                                 {0, 9, 10},
  42                                 {0, 0, 13},
  43                         },
  44                         x:   []float64{3, 4, 5},
  45                         d:   blas.Unit,
  46                         ul:  blas.Upper,
  47                         tA:  blas.NoTrans,
  48                         ans: []float64{62, 54, 5},
  49                 },
  50                 {
  51                         n: 3,
  52                         a: [][]float64{
  53                                 {5, 0, 0},
  54                                 {6, 9, 0},
  55                                 {7, 10, 13},
  56                         },
  57                         x:   []float64{3, 4, 5},
  58                         d:   blas.NonUnit,
  59                         ul:  blas.Lower,
  60                         tA:  blas.NoTrans,
  61                         ans: []float64{15, 54, 126},
  62                 },
  63                 {
  64                         n: 3,
  65                         a: [][]float64{
  66                                 {1, 0, 0},
  67                                 {6, 1, 0},
  68                                 {7, 10, 1},
  69                         },
  70                         x:   []float64{3, 4, 5},
  71                         d:   blas.Unit,
  72                         ul:  blas.Lower,
  73                         tA:  blas.NoTrans,
  74                         ans: []float64{3, 22, 66},
  75                 },
  76                 {
  77                         n: 3,
  78                         a: [][]float64{
  79                                 {5, 6, 7},
  80                                 {0, 9, 10},
  81                                 {0, 0, 13},
  82                         },
  83                         x:   []float64{3, 4, 5},
  84                         d:   blas.NonUnit,
  85                         ul:  blas.Upper,
  86                         tA:  blas.Trans,
  87                         ans: []float64{15, 54, 126},
  88                 },
  89                 {
  90                         n: 3,
  91                         a: [][]float64{
  92                                 {1, 6, 7},
  93                                 {0, 1, 10},
  94                                 {0, 0, 1},
  95                         },
  96                         x:   []float64{3, 4, 5},
  97                         d:   blas.Unit,
  98                         ul:  blas.Upper,
  99                         tA:  blas.Trans,
 100                         ans: []float64{3, 22, 66},
 101                 },
 102                 {
 103                         n: 3,
 104                         a: [][]float64{
 105                                 {5, 0, 0},
 106                                 {6, 9, 0},
 107                                 {7, 10, 13},
 108                         },
 109                         x:   []float64{3, 4, 5},
 110                         d:   blas.NonUnit,
 111                         ul:  blas.Lower,
 112                         tA:  blas.Trans,
 113                         ans: []float64{74, 86, 65},
 114                 },
 115         } {
 116                 incTest := func(incX, extra int) {
 117                         aFlat := flattenTriangular(test.a, test.ul)
 118                         x := makeIncremented(test.x, incX, extra)
 119                         blasser.Dtpmv(test.ul, test.tA, test.d, test.n, aFlat, x, incX)
 120                         ans := makeIncremented(test.ans, incX, extra)
 121                         if !floats.EqualApprox(x, ans, 1e-14) {
 122                                 t.Errorf("Case %v, idx %v: Want %v, got %v.", i, incX, ans, x)
 123                         }
 124                 }
 125                 incTest(1, 0)
 126                 incTest(-3, 3)
 127                 incTest(4, 3)
 128         }
 129 }