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

   1 package testblas
   2
   3 import (
   4         "testing"
   5
   6         "gonum.org/v1/gonum/blas"
   7 )
   8
   9 type Dtbsver interface {
  10         Dtbsv(ul blas.Uplo, tA blas.Transpose, d blas.Diag, n, k int, a []float64, lda int, x []float64, incX int)
  11         Dtrsv(ul blas.Uplo, tA blas.Transpose, d blas.Diag, n int, a []float64, lda int, x []float64, incX int)
  12 }
  13
  14 func DtbsvTest(t *testing.T, blasser Dtbsver) {
  15         for i, test := range []struct {
  16                 ul   blas.Uplo
  17                 tA   blas.Transpose
  18                 d    blas.Diag
  19                 n, k int
  20                 a    [][]float64
  21                 x    []float64
  22                 incX int
  23                 ans  []float64
  24         }{
  25                 {
  26                         ul: blas.Upper,
  27                         tA: blas.NoTrans,
  28                         d:  blas.NonUnit,
  29                         n:  5,
  30                         k:  1,
  31                         a: [][]float64{
  32                                 {1, 3, 0, 0, 0},
  33                                 {0, 6, 7, 0, 0},
  34                                 {0, 0, 2, 1, 0},
  35                                 {0, 0, 0, 12, 3},
  36                                 {0, 0, 0, 0, -1},
  37                         },
  38                         x:    []float64{1, 2, 3, 4, 5},
  39                         incX: 1,
  40                         ans:  []float64{2.479166666666667, -0.493055555555556, 0.708333333333333, 1.583333333333333, -5.000000000000000},
  41                 },
  42                 {
  43                         ul: blas.Upper,
  44                         tA: blas.NoTrans,
  45                         d:  blas.NonUnit,
  46                         n:  5,
  47                         k:  2,
  48                         a: [][]float64{
  49                                 {1, 3, 5, 0, 0},
  50                                 {0, 6, 7, 5, 0},
  51                                 {0, 0, 2, 1, 5},
  52                                 {0, 0, 0, 12, 3},
  53                                 {0, 0, 0, 0, -1},
  54                         },
  55                         x:    []float64{1, 2, 3, 4, 5},
  56                         incX: 1,
  57                         ans:  []float64{-15.854166666666664, -16.395833333333336, 13.208333333333334, 1.583333333333333, -5.000000000000000},
  58                 },
  59                 {
  60                         ul: blas.Upper,
  61                         tA: blas.NoTrans,
  62                         d:  blas.NonUnit,
  63                         n:  5,
  64                         k:  1,
  65                         a: [][]float64{
  66                                 {1, 3, 0, 0, 0},
  67                                 {0, 6, 7, 0, 0},
  68                                 {0, 0, 2, 1, 0},
  69                                 {0, 0, 0, 12, 3},
  70                                 {0, 0, 0, 0, -1},
  71                         },
  72                         x:    []float64{1, -101, 2, -201, 3, -301, 4, -401, 5, -501, -601, -701},
  73                         incX: 2,
  74                         ans:  []float64{2.479166666666667, -101, -0.493055555555556, -201, 0.708333333333333, -301, 1.583333333333333, -401, -5.000000000000000, -501, -601, -701},
  75                 },
  76                 {
  77                         ul: blas.Upper,
  78                         tA: blas.NoTrans,
  79                         d:  blas.NonUnit,
  80                         n:  5,
  81                         k:  2,
  82                         a: [][]float64{
  83                                 {1, 3, 5, 0, 0},
  84                                 {0, 6, 7, 5, 0},
  85                                 {0, 0, 2, 1, 5},
  86                                 {0, 0, 0, 12, 3},
  87                                 {0, 0, 0, 0, -1},
  88                         },
  89                         x:    []float64{1, -101, 2, -201, 3, -301, 4, -401, 5, -501, -601, -701},
  90                         incX: 2,
  91                         ans:  []float64{-15.854166666666664, -101, -16.395833333333336, -201, 13.208333333333334, -301, 1.583333333333333, -401, -5.000000000000000, -501, -601, -701},
  92                 },
  93                 {
  94                         ul: blas.Lower,
  95                         tA: blas.NoTrans,
  96                         d:  blas.NonUnit,
  97                         n:  5,
  98                         k:  2,
  99                         a: [][]float64{
 100                                 {1, 0, 0, 0, 0},
 101                                 {3, 6, 0, 0, 0},
 102                                 {5, 7, 2, 0, 0},
 103                                 {0, 5, 1, 12, 0},
 104                                 {0, 0, 5, 3, -1},
 105                         },
 106                         x:    []float64{1, 2, 3, 4, 5},
 107                         incX: 1,
 108                         ans:  []float64{1, -0.166666666666667, -0.416666666666667, 0.437500000000000, -5.770833333333334},
 109                 },
 110                 {
 111                         ul: blas.Lower,
 112                         tA: blas.NoTrans,
 113                         d:  blas.NonUnit,
 114                         n:  5,
 115                         k:  2,
 116                         a: [][]float64{
 117                                 {1, 0, 0, 0, 0},
 118                                 {3, 6, 0, 0, 0},
 119                                 {5, 7, 2, 0, 0},
 120                                 {0, 5, 1, 12, 0},
 121                                 {0, 0, 5, 3, -1},
 122                         },
 123                         x:    []float64{1, -101, 2, -201, 3, -301, 4, -401, 5, -501, -601, -701},
 124                         incX: 2,
 125                         ans:  []float64{1, -101, -0.166666666666667, -201, -0.416666666666667, -301, 0.437500000000000, -401, -5.770833333333334, -501, -601, -701},
 126                 },
 127                 {
 128                         ul: blas.Upper,
 129                         tA: blas.Trans,
 130                         d:  blas.NonUnit,
 131                         n:  5,
 132                         k:  2,
 133                         a: [][]float64{
 134                                 {1, 3, 5, 0, 0},
 135                                 {0, 6, 7, 5, 0},
 136                                 {0, 0, 2, 1, 5},
 137                                 {0, 0, 0, 12, 3},
 138                                 {0, 0, 0, 0, -1},
 139                         },
 140                         x:    []float64{1, 2, 3, 4, 5},
 141                         incX: 1,
 142                         ans:  []float64{1, -0.166666666666667, -0.416666666666667, 0.437500000000000, -5.770833333333334},
 143                 },
 144                 {
 145                         ul: blas.Upper,
 146                         tA: blas.Trans,
 147                         d:  blas.NonUnit,
 148                         n:  5,
 149                         k:  2,
 150                         a: [][]float64{
 151                                 {1, 3, 5, 0, 0},
 152                                 {0, 6, 7, 5, 0},
 153                                 {0, 0, 2, 1, 5},
 154                                 {0, 0, 0, 12, 3},
 155                                 {0, 0, 0, 0, -1},
 156                         },
 157                         x:    []float64{1, -101, 2, -201, 3, -301, 4, -401, 5, -501, -601, -701},
 158                         incX: 2,
 159                         ans:  []float64{1, -101, -0.166666666666667, -201, -0.416666666666667, -301, 0.437500000000000, -401, -5.770833333333334, -501, -601, -701},
 160                 },
 161                 {
 162                         ul: blas.Lower,
 163                         tA: blas.Trans,
 164                         d:  blas.NonUnit,
 165                         n:  5,
 166                         k:  2,
 167                         a: [][]float64{
 168                                 {1, 0, 0, 0, 0},
 169                                 {3, 6, 0, 0, 0},
 170                                 {5, 7, 2, 0, 0},
 171                                 {0, 5, 1, 12, 0},
 172                                 {0, 0, 5, 3, -1},
 173                         },
 174                         x:    []float64{1, 2, 3, 4, 5},
 175                         incX: 1,
 176                         ans:  []float64{-15.854166666666664, -16.395833333333336, 13.208333333333334, 1.583333333333333, -5.000000000000000},
 177                 },
 178                 {
 179                         ul: blas.Lower,
 180                         tA: blas.Trans,
 181                         d:  blas.NonUnit,
 182                         n:  5,
 183                         k:  2,
 184                         a: [][]float64{
 185                                 {1, 0, 0, 0, 0},
 186                                 {3, 6, 0, 0, 0},
 187                                 {5, 7, 2, 0, 0},
 188                                 {0, 5, 1, 12, 0},
 189                                 {0, 0, 5, 3, -1},
 190                         },
 191                         x:    []float64{1, -101, 2, -201, 3, -301, 4, -401, 5, -501, -601, -701},
 192                         incX: 2,
 193                         ans:  []float64{-15.854166666666664, -101, -16.395833333333336, -201, 13.208333333333334, -301, 1.583333333333333, -401, -5.000000000000000, -501, -601, -701},
 194                 },
 195         } {
 196                 var aFlat []float64
 197                 if test.ul == blas.Upper {
 198                         aFlat = flattenBanded(test.a, test.k, 0)
 199                 } else {
 200                         aFlat = flattenBanded(test.a, 0, test.k)
 201                 }
 202                 xCopy := sliceCopy(test.x)
 203                 // TODO: Have tests where the banded matrix is constructed explicitly
 204                 // to allow testing for lda =! k+1
 205                 blasser.Dtbsv(test.ul, test.tA, test.d, test.n, test.k, aFlat, test.k+1, xCopy, test.incX)
 206                 if !dSliceTolEqual(test.ans, xCopy) {
 207                         t.Errorf("Case %v: Want %v, got %v", i, test.ans, xCopy)
 208                 }
 209         }
 210
 211         /*
 212                 // TODO: Uncomment when Dtrsv is fixed
 213                 // Compare with dense for larger matrices
 214                 for _, ul := range [...]blas.Uplo{blas.Upper, blas.Lower} {
 215                         for _, tA := range [...]blas.Transpose{blas.NoTrans, blas.Trans} {
 216                                 for _, n := range [...]int{7, 8, 11} {
 217                                         for _, d := range [...]blas.Diag{blas.NonUnit, blas.Unit} {
 218                                                 for _, k := range [...]int{0, 1, 3} {
 219                                                         for _, incX := range [...]int{1, 3} {
 220                                                                 a := make([][]float64, n)
 221                                                                 for i := range a {
 222                                                                         a[i] = make([]float64, n)
 223                                                                         for j := range a[i] {
 224                                                                                 a[i][j] = rand.Float64()
 225                                                                         }
 226                                                                 }
 227                                                                 x := make([]float64, n)
 228                                                                 for i := range x {
 229                                                                         x[i] = rand.Float64()
 230                                                                 }
 231                                                                 extra := 3
 232                                                                 xinc := makeIncremented(x, incX, extra)
 233                                                                 bandX := sliceCopy(xinc)
 234                                                                 var aFlatBand []float64
 235                                                                 if ul == blas.Upper {
 236                                                                         aFlatBand = flattenBanded(a, k, 0)
 237                                                                 } else {
 238                                                                         aFlatBand = flattenBanded(a, 0, k)
 239                                                                 }
 240                                                                 blasser.Dtbsv(ul, tA, d, n, k, aFlatBand, k+1, bandX, incX)
 241
 242                                                                 aFlatDense := flatten(a)
 243                                                                 denseX := sliceCopy(xinc)
 244                                                                 blasser.Dtrsv(ul, tA, d, n, aFlatDense, n, denseX, incX)
 245                                                                 if !dSliceTolEqual(denseX, bandX) {
 246                                                                         t.Errorf("Case %v: dense banded mismatch")
 247                                                                 }
 248                                                         }
 249                                                 }
 250                                         }
 251                                 }
 252                         }
 253                 }
 254         */
 255 }