vendor/gonum.org/v1/gonum/blas/testblas/dsyr2k.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 Dsyr2ker interface {
  11         Dsyr2k(ul blas.Uplo, tA blas.Transpose, n, k int, alpha float64, a []float64, lda int, b []float64, ldb int, beta float64, c []float64, ldc int)
  12 }
  13
  14 func Dsyr2kTest(t *testing.T, blasser Dsyr2ker) {
  15         for i, test := range []struct {
  16                 ul    blas.Uplo
  17                 tA    blas.Transpose
  18                 n     int
  19                 k     int
  20                 alpha float64
  21                 a     [][]float64
  22                 b     [][]float64
  23                 c     [][]float64
  24                 beta  float64
  25                 ans   [][]float64
  26         }{
  27                 {
  28                         ul:    blas.Upper,
  29                         tA:    blas.NoTrans,
  30                         n:     3,
  31                         k:     2,
  32                         alpha: 0,
  33                         a: [][]float64{
  34                                 {1, 2},
  35                                 {3, 4},
  36                                 {5, 6},
  37                         },
  38                         b: [][]float64{
  39                                 {7, 8},
  40                                 {9, 10},
  41                                 {11, 12},
  42                         },
  43                         c: [][]float64{
  44                                 {1, 2, 3},
  45                                 {0, 5, 6},
  46                                 {0, 0, 9},
  47                         },
  48                         beta: 2,
  49                         ans: [][]float64{
  50                                 {2, 4, 6},
  51                                 {0, 10, 12},
  52                                 {0, 0, 18},
  53                         },
  54                 },
  55                 {
  56                         ul:    blas.Lower,
  57                         tA:    blas.NoTrans,
  58                         n:     3,
  59                         k:     2,
  60                         alpha: 0,
  61                         a: [][]float64{
  62                                 {1, 2},
  63                                 {3, 4},
  64                                 {5, 6},
  65                         },
  66                         b: [][]float64{
  67                                 {7, 8},
  68                                 {9, 10},
  69                                 {11, 12},
  70                         },
  71                         c: [][]float64{
  72                                 {1, 0, 0},
  73                                 {2, 3, 0},
  74                                 {4, 5, 6},
  75                         },
  76                         beta: 2,
  77                         ans: [][]float64{
  78                                 {2, 0, 0},
  79                                 {4, 6, 0},
  80                                 {8, 10, 12},
  81                         },
  82                 },
  83                 {
  84                         ul:    blas.Upper,
  85                         tA:    blas.NoTrans,
  86                         n:     3,
  87                         k:     2,
  88                         alpha: 3,
  89                         a: [][]float64{
  90                                 {1, 2},
  91                                 {3, 4},
  92                                 {5, 6},
  93                         },
  94                         b: [][]float64{
  95                                 {7, 8},
  96                                 {9, 10},
  97                                 {11, 12},
  98                         },
  99                         c: [][]float64{
 100                                 {1, 2, 3},
 101                                 {0, 4, 5},
 102                                 {0, 0, 6},
 103                         },
 104                         beta: 2,
 105                         ans: [][]float64{
 106                                 {140, 250, 360},
 107                                 {0, 410, 568},
 108                                 {0, 0, 774},
 109                         },
 110                 },
 111                 {
 112                         ul:    blas.Lower,
 113                         tA:    blas.NoTrans,
 114                         n:     3,
 115                         k:     2,
 116                         alpha: 3,
 117                         a: [][]float64{
 118                                 {1, 2},
 119                                 {3, 4},
 120                                 {5, 6},
 121                         },
 122                         b: [][]float64{
 123                                 {7, 8},
 124                                 {9, 10},
 125                                 {11, 12},
 126                         },
 127                         c: [][]float64{
 128                                 {1, 0, 0},
 129                                 {2, 4, 0},
 130                                 {3, 5, 6},
 131                         },
 132                         beta: 2,
 133                         ans: [][]float64{
 134                                 {140, 0, 0},
 135                                 {250, 410, 0},
 136                                 {360, 568, 774},
 137                         },
 138                 },
 139                 {
 140                         ul:    blas.Upper,
 141                         tA:    blas.Trans,
 142                         n:     3,
 143                         k:     2,
 144                         alpha: 3,
 145                         a: [][]float64{
 146                                 {1, 3, 5},
 147                                 {2, 4, 6},
 148                         },
 149                         b: [][]float64{
 150                                 {7, 9, 11},
 151                                 {8, 10, 12},
 152                         },
 153                         c: [][]float64{
 154                                 {1, 2, 3},
 155                                 {0, 4, 5},
 156                                 {0, 0, 6},
 157                         },
 158                         beta: 2,
 159                         ans: [][]float64{
 160                                 {140, 250, 360},
 161                                 {0, 410, 568},
 162                                 {0, 0, 774},
 163                         },
 164                 },
 165                 {
 166                         ul:    blas.Lower,
 167                         tA:    blas.Trans,
 168                         n:     3,
 169                         k:     2,
 170                         alpha: 3,
 171                         a: [][]float64{
 172                                 {1, 3, 5},
 173                                 {2, 4, 6},
 174                         },
 175                         b: [][]float64{
 176                                 {7, 9, 11},
 177                                 {8, 10, 12},
 178                         },
 179                         c: [][]float64{
 180                                 {1, 0, 0},
 181                                 {2, 4, 0},
 182                                 {3, 5, 6},
 183                         },
 184                         beta: 2,
 185                         ans: [][]float64{
 186                                 {140, 0, 0},
 187                                 {250, 410, 0},
 188                                 {360, 568, 774},
 189                         },
 190                 },
 191         } {
 192                 aFlat := flatten(test.a)
 193                 bFlat := flatten(test.b)
 194                 cFlat := flatten(test.c)
 195                 ansFlat := flatten(test.ans)
 196                 blasser.Dsyr2k(test.ul, test.tA, test.n, test.k, test.alpha, aFlat, len(test.a[0]), bFlat, len(test.b[0]), test.beta, cFlat, len(test.c[0]))
 197                 if !floats.EqualApprox(ansFlat, cFlat, 1e-14) {
 198                         t.Errorf("Case %v. Want %v, got %v.", i, ansFlat, cFlat)
 199                 }
 200         }
 201 }