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