vendor/gonum.org/v1/gonum/mat/vector_test.go

   1 // Copyright ©2015 The Gonum Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style
   3 // license that can be found in the LICENSE file.
   4
   5 package mat
   6
   7 import (
   8         "reflect"
   9         "testing"
  10
  11         "golang.org/x/exp/rand"
  12
  13         "gonum.org/v1/gonum/blas/blas64"
  14 )
  15
  16 func TestNewVecDense(t *testing.T) {
  17         for i, test := range []struct {
  18                 n      int
  19                 data   []float64
  20                 vector *VecDense
  21         }{
  22                 {
  23                         n:    3,
  24                         data: []float64{4, 5, 6},
  25                         vector: &VecDense{
  26                                 mat: blas64.Vector{
  27                                         Data: []float64{4, 5, 6},
  28                                         Inc:  1,
  29                                 },
  30                                 n: 3,
  31                         },
  32                 },
  33                 {
  34                         n:    3,
  35                         data: nil,
  36                         vector: &VecDense{
  37                                 mat: blas64.Vector{
  38                                         Data: []float64{0, 0, 0},
  39                                         Inc:  1,
  40                                 },
  41                                 n: 3,
  42                         },
  43                 },
  44         } {
  45                 v := NewVecDense(test.n, test.data)
  46                 rows, cols := v.Dims()
  47                 if rows != test.n {
  48                         t.Errorf("unexpected number of rows for test %d: got: %d want: %d", i, rows, test.n)
  49                 }
  50                 if cols != 1 {
  51                         t.Errorf("unexpected number of cols for test %d: got: %d want: 1", i, cols)
  52                 }
  53                 if !reflect.DeepEqual(v, test.vector) {
  54                         t.Errorf("unexpected data slice for test %d: got: %v want: %v", i, v, test.vector)
  55                 }
  56         }
  57 }
  58
  59 func TestCap(t *testing.T) {
  60         for i, test := range []struct {
  61                 vector *VecDense
  62                 want   int
  63         }{
  64                 {vector: NewVecDense(3, nil), want: 3},
  65                 {
  66                         vector: &VecDense{
  67                                 mat: blas64.Vector{
  68                                         Data: make([]float64, 7, 10),
  69                                         Inc:  3,
  70                                 },
  71                                 n: 3,
  72                         },
  73                         want: 4,
  74                 },
  75                 {
  76                         vector: &VecDense{
  77                                 mat: blas64.Vector{
  78                                         Data: make([]float64, 10),
  79                                         Inc:  3,
  80                                 },
  81                                 n: 4,
  82                         },
  83                         want: 4,
  84                 },
  85                 {
  86                         vector: &VecDense{
  87                                 mat: blas64.Vector{
  88                                         Data: make([]float64, 11),
  89                                         Inc:  3,
  90                                 },
  91                                 n: 4,
  92                         },
  93                         want: 4,
  94                 },
  95                 {
  96                         vector: &VecDense{
  97                                 mat: blas64.Vector{
  98                                         Data: make([]float64, 12),
  99                                         Inc:  3,
 100                                 },
 101                                 n: 4,
 102                         },
 103                         want: 4,
 104                 },
 105                 {
 106                         vector: &VecDense{
 107                                 mat: blas64.Vector{
 108                                         Data: make([]float64, 13),
 109                                         Inc:  3,
 110                                 },
 111                                 n: 4,
 112                         },
 113                         want: 5,
 114                 },
 115         } {
 116                 got := test.vector.Cap()
 117                 if got != test.want {
 118                         t.Errorf("unexpected capacty for test %d: got: %d want: %d", i, got, test.want)
 119                 }
 120         }
 121 }
 122
 123 func TestVecDenseAtSet(t *testing.T) {
 124         for i, test := range []struct {
 125                 vector *VecDense
 126         }{
 127                 {
 128                         vector: &VecDense{
 129                                 mat: blas64.Vector{
 130                                         Data: []float64{0, 1, 2},
 131                                         Inc:  1,
 132                                 },
 133                                 n: 3,
 134                         },
 135                 },
 136                 {
 137                         vector: &VecDense{
 138                                 mat: blas64.Vector{
 139                                         Data: []float64{0, 10, 10, 1, 10, 10, 2},
 140                                         Inc:  3,
 141                                 },
 142                                 n: 3,
 143                         },
 144                 },
 145         } {
 146                 v := test.vector
 147                 n := test.vector.n
 148
 149                 for _, row := range []int{-1, n} {
 150                         panicked, message := panics(func() { v.At(row, 0) })
 151                         if !panicked || message != ErrRowAccess.Error() {
 152                                 t.Errorf("expected panic for invalid row access for test %d n=%d r=%d", i, n, row)
 153                         }
 154                 }
 155                 for _, col := range []int{-1, 1} {
 156                         panicked, message := panics(func() { v.At(0, col) })
 157                         if !panicked || message != ErrColAccess.Error() {
 158                                 t.Errorf("expected panic for invalid column access for test %d n=%d c=%d", i, n, col)
 159                         }
 160                 }
 161
 162                 for _, row := range []int{0, 1, n - 1} {
 163                         if e := v.At(row, 0); e != float64(row) {
 164                                 t.Errorf("unexpected value for At(%d, 0) for test %d : got: %v want: %v", row, i, e, float64(row))
 165                         }
 166                 }
 167
 168                 for _, row := range []int{-1, n} {
 169                         panicked, message := panics(func() { v.SetVec(row, 100) })
 170                         if !panicked || message != ErrVectorAccess.Error() {
 171                                 t.Errorf("expected panic for invalid row access for test %d n=%d r=%d", i, n, row)
 172                         }
 173                 }
 174
 175                 for inc, row := range []int{0, 2} {
 176                         v.SetVec(row, 100+float64(inc))
 177                         if e := v.At(row, 0); e != 100+float64(inc) {
 178                                 t.Errorf("unexpected value for At(%d, 0) after SetVec(%[1]d, %v) for test %d: got: %v want: %[2]v", row, 100+float64(inc), i, e)
 179                         }
 180                 }
 181         }
 182 }
 183
 184 func TestVecDenseMul(t *testing.T) {
 185         method := func(receiver, a, b Matrix) {
 186                 type mulVecer interface {
 187                         MulVec(a Matrix, b Vector)
 188                 }
 189                 rd := receiver.(mulVecer)
 190                 rd.MulVec(a, b.(Vector))
 191         }
 192         denseComparison := func(receiver, a, b *Dense) {
 193                 receiver.Mul(a, b)
 194         }
 195         legalSizeMulVec := func(ar, ac, br, bc int) bool {
 196                 var legal bool
 197                 if bc != 1 {
 198                         legal = false
 199                 } else {
 200                         legal = ac == br
 201                 }
 202                 return legal
 203         }
 204         testTwoInput(t, "MulVec", &VecDense{}, method, denseComparison, legalTypesMatrixVector, legalSizeMulVec, 1e-14)
 205 }
 206
 207 func TestVecDenseScale(t *testing.T) {
 208         for i, test := range []struct {
 209                 a     Vector
 210                 alpha float64
 211                 want  *VecDense
 212         }{
 213                 {
 214                         a:     NewVecDense(3, []float64{0, 1, 2}),
 215                         alpha: 0,
 216                         want:  NewVecDense(3, []float64{0, 0, 0}),
 217                 },
 218                 {
 219                         a:     NewVecDense(3, []float64{0, 1, 2}),
 220                         alpha: 1,
 221                         want:  NewVecDense(3, []float64{0, 1, 2}),
 222                 },
 223                 {
 224                         a:     NewVecDense(3, []float64{0, 1, 2}),
 225                         alpha: -2,
 226                         want:  NewVecDense(3, []float64{0, -2, -4}),
 227                 },
 228                 {
 229                         a:     NewDense(3, 1, []float64{0, 1, 2}).ColView(0),
 230                         alpha: 0,
 231                         want:  NewVecDense(3, []float64{0, 0, 0}),
 232                 },
 233                 {
 234                         a:     NewDense(3, 1, []float64{0, 1, 2}).ColView(0),
 235                         alpha: 1,
 236                         want:  NewVecDense(3, []float64{0, 1, 2}),
 237                 },
 238                 {
 239                         a:     NewDense(3, 1, []float64{0, 1, 2}).ColView(0),
 240                         alpha: -2,
 241                         want:  NewVecDense(3, []float64{0, -2, -4}),
 242                 },
 243                 {
 244                         a: NewDense(3, 3, []float64{
 245                                 0, 1, 2,
 246                                 3, 4, 5,
 247                                 6, 7, 8,
 248                         }).ColView(1),
 249                         alpha: -2,
 250                         want:  NewVecDense(3, []float64{-2, -8, -14}),
 251                 },
 252         } {
 253                 var v VecDense
 254                 v.ScaleVec(test.alpha, test.a.(*VecDense))
 255                 if !reflect.DeepEqual(v.RawVector(), test.want.RawVector()) {
 256                         t.Errorf("test %d: unexpected result for v = alpha * a: got: %v want: %v", i, v.RawVector(), test.want.RawVector())
 257                 }
 258
 259                 v.CopyVec(test.a.(*VecDense))
 260                 v.ScaleVec(test.alpha, &v)
 261                 if !reflect.DeepEqual(v.RawVector(), test.want.RawVector()) {
 262                         t.Errorf("test %d: unexpected result for v = alpha * v: got: %v want: %v", i, v.RawVector(), test.want.RawVector())
 263                 }
 264         }
 265
 266         for _, alpha := range []float64{0, 1, -1, 2.3, -2.3} {
 267                 method := func(receiver, a Matrix) {
 268                         type scaleVecer interface {
 269                                 ScaleVec(float64, Vector)
 270                         }
 271                         v := receiver.(scaleVecer)
 272                         v.ScaleVec(alpha, a.(Vector))
 273                 }
 274                 denseComparison := func(receiver, a *Dense) {
 275                         receiver.Scale(alpha, a)
 276                 }
 277                 testOneInput(t, "ScaleVec", &VecDense{}, method, denseComparison, legalTypeVector, isAnyColumnVector, 0)
 278         }
 279 }
 280
 281 func TestVecDenseAddScaled(t *testing.T) {
 282         for _, alpha := range []float64{0, 1, -1, 2.3, -2.3} {
 283                 method := func(receiver, a, b Matrix) {
 284                         type addScaledVecer interface {
 285                                 AddScaledVec(Vector, float64, Vector)
 286                         }
 287                         v := receiver.(addScaledVecer)
 288                         v.AddScaledVec(a.(Vector), alpha, b.(Vector))
 289                 }
 290                 denseComparison := func(receiver, a, b *Dense) {
 291                         var sb Dense
 292                         sb.Scale(alpha, b)
 293                         receiver.Add(a, &sb)
 294                 }
 295                 testTwoInput(t, "AddScaledVec", &VecDense{}, method, denseComparison, legalTypesVectorVector, legalSizeSameVec, 1e-14)
 296         }
 297 }
 298
 299 func TestVecDenseAdd(t *testing.T) {
 300         for i, test := range []struct {
 301                 a, b Vector
 302                 want *VecDense
 303         }{
 304                 {
 305                         a:    NewVecDense(3, []float64{0, 1, 2}),
 306                         b:    NewVecDense(3, []float64{0, 2, 3}),
 307                         want: NewVecDense(3, []float64{0, 3, 5}),
 308                 },
 309                 {
 310                         a:    NewVecDense(3, []float64{0, 1, 2}),
 311                         b:    NewDense(3, 1, []float64{0, 2, 3}).ColView(0),
 312                         want: NewVecDense(3, []float64{0, 3, 5}),
 313                 },
 314                 {
 315                         a:    NewDense(3, 1, []float64{0, 1, 2}).ColView(0),
 316                         b:    NewDense(3, 1, []float64{0, 2, 3}).ColView(0),
 317                         want: NewVecDense(3, []float64{0, 3, 5}),
 318                 },
 319         } {
 320                 var v VecDense
 321                 v.AddVec(test.a.(*VecDense), test.b.(*VecDense))
 322                 if !reflect.DeepEqual(v.RawVector(), test.want.RawVector()) {
 323                         t.Errorf("unexpected result for test %d: got: %v want: %v", i, v.RawVector(), test.want.RawVector())
 324                 }
 325         }
 326 }
 327
 328 func TestVecDenseSub(t *testing.T) {
 329         for i, test := range []struct {
 330                 a, b Vector
 331                 want *VecDense
 332         }{
 333                 {
 334                         a:    NewVecDense(3, []float64{0, 1, 2}),
 335                         b:    NewVecDense(3, []float64{0, 0.5, 1}),
 336                         want: NewVecDense(3, []float64{0, 0.5, 1}),
 337                 },
 338                 {
 339                         a:    NewVecDense(3, []float64{0, 1, 2}),
 340                         b:    NewDense(3, 1, []float64{0, 0.5, 1}).ColView(0),
 341                         want: NewVecDense(3, []float64{0, 0.5, 1}),
 342                 },
 343                 {
 344                         a:    NewDense(3, 1, []float64{0, 1, 2}).ColView(0),
 345                         b:    NewDense(3, 1, []float64{0, 0.5, 1}).ColView(0),
 346                         want: NewVecDense(3, []float64{0, 0.5, 1}),
 347                 },
 348         } {
 349                 var v VecDense
 350                 v.SubVec(test.a.(*VecDense), test.b.(*VecDense))
 351                 if !reflect.DeepEqual(v.RawVector(), test.want.RawVector()) {
 352                         t.Errorf("unexpected result for test %d: got: %v want: %v", i, v.RawVector(), test.want.RawVector())
 353                 }
 354         }
 355 }
 356
 357 func TestVecDenseMulElem(t *testing.T) {
 358         for i, test := range []struct {
 359                 a, b Vector
 360                 want *VecDense
 361         }{
 362                 {
 363                         a:    NewVecDense(3, []float64{0, 1, 2}),
 364                         b:    NewVecDense(3, []float64{0, 2, 3}),
 365                         want: NewVecDense(3, []float64{0, 2, 6}),
 366                 },
 367                 {
 368                         a:    NewVecDense(3, []float64{0, 1, 2}),
 369                         b:    NewDense(3, 1, []float64{0, 2, 3}).ColView(0),
 370                         want: NewVecDense(3, []float64{0, 2, 6}),
 371                 },
 372                 {
 373                         a:    NewDense(3, 1, []float64{0, 1, 2}).ColView(0),
 374                         b:    NewDense(3, 1, []float64{0, 2, 3}).ColView(0),
 375                         want: NewVecDense(3, []float64{0, 2, 6}),
 376                 },
 377         } {
 378                 var v VecDense
 379                 v.MulElemVec(test.a.(*VecDense), test.b.(*VecDense))
 380                 if !reflect.DeepEqual(v.RawVector(), test.want.RawVector()) {
 381                         t.Errorf("unexpected result for test %d: got: %v want: %v", i, v.RawVector(), test.want.RawVector())
 382                 }
 383         }
 384 }
 385
 386 func TestVecDenseDivElem(t *testing.T) {
 387         for i, test := range []struct {
 388                 a, b Vector
 389                 want *VecDense
 390         }{
 391                 {
 392                         a:    NewVecDense(3, []float64{0.5, 1, 2}),
 393                         b:    NewVecDense(3, []float64{0.5, 0.5, 1}),
 394                         want: NewVecDense(3, []float64{1, 2, 2}),
 395                 },
 396                 {
 397                         a:    NewVecDense(3, []float64{0.5, 1, 2}),
 398                         b:    NewDense(3, 1, []float64{0.5, 0.5, 1}).ColView(0),
 399                         want: NewVecDense(3, []float64{1, 2, 2}),
 400                 },
 401                 {
 402                         a:    NewDense(3, 1, []float64{0.5, 1, 2}).ColView(0),
 403                         b:    NewDense(3, 1, []float64{0.5, 0.5, 1}).ColView(0),
 404                         want: NewVecDense(3, []float64{1, 2, 2}),
 405                 },
 406         } {
 407                 var v VecDense
 408                 v.DivElemVec(test.a.(*VecDense), test.b.(*VecDense))
 409                 if !reflect.DeepEqual(v.RawVector(), test.want.RawVector()) {
 410                         t.Errorf("unexpected result for test %d: got: %v want: %v", i, v.RawVector(), test.want.RawVector())
 411                 }
 412         }
 413 }
 414
 415 func BenchmarkAddScaledVec10Inc1(b *testing.B)      { addScaledVecBench(b, 10, 1) }
 416 func BenchmarkAddScaledVec100Inc1(b *testing.B)     { addScaledVecBench(b, 100, 1) }
 417 func BenchmarkAddScaledVec1000Inc1(b *testing.B)    { addScaledVecBench(b, 1000, 1) }
 418 func BenchmarkAddScaledVec10000Inc1(b *testing.B)   { addScaledVecBench(b, 10000, 1) }
 419 func BenchmarkAddScaledVec100000Inc1(b *testing.B)  { addScaledVecBench(b, 100000, 1) }
 420 func BenchmarkAddScaledVec10Inc2(b *testing.B)      { addScaledVecBench(b, 10, 2) }
 421 func BenchmarkAddScaledVec100Inc2(b *testing.B)     { addScaledVecBench(b, 100, 2) }
 422 func BenchmarkAddScaledVec1000Inc2(b *testing.B)    { addScaledVecBench(b, 1000, 2) }
 423 func BenchmarkAddScaledVec10000Inc2(b *testing.B)   { addScaledVecBench(b, 10000, 2) }
 424 func BenchmarkAddScaledVec100000Inc2(b *testing.B)  { addScaledVecBench(b, 100000, 2) }
 425 func BenchmarkAddScaledVec10Inc20(b *testing.B)     { addScaledVecBench(b, 10, 20) }
 426 func BenchmarkAddScaledVec100Inc20(b *testing.B)    { addScaledVecBench(b, 100, 20) }
 427 func BenchmarkAddScaledVec1000Inc20(b *testing.B)   { addScaledVecBench(b, 1000, 20) }
 428 func BenchmarkAddScaledVec10000Inc20(b *testing.B)  { addScaledVecBench(b, 10000, 20) }
 429 func BenchmarkAddScaledVec100000Inc20(b *testing.B) { addScaledVecBench(b, 100000, 20) }
 430 func addScaledVecBench(b *testing.B, size, inc int) {
 431         x := randVecDense(size, inc, 1, rand.NormFloat64)
 432         y := randVecDense(size, inc, 1, rand.NormFloat64)
 433         b.ResetTimer()
 434         var v VecDense
 435         for i := 0; i < b.N; i++ {
 436                 v.AddScaledVec(y, 2, x)
 437         }
 438 }
 439
 440 func BenchmarkScaleVec10Inc1(b *testing.B)      { scaleVecBench(b, 10, 1) }
 441 func BenchmarkScaleVec100Inc1(b *testing.B)     { scaleVecBench(b, 100, 1) }
 442 func BenchmarkScaleVec1000Inc1(b *testing.B)    { scaleVecBench(b, 1000, 1) }
 443 func BenchmarkScaleVec10000Inc1(b *testing.B)   { scaleVecBench(b, 10000, 1) }
 444 func BenchmarkScaleVec100000Inc1(b *testing.B)  { scaleVecBench(b, 100000, 1) }
 445 func BenchmarkScaleVec10Inc2(b *testing.B)      { scaleVecBench(b, 10, 2) }
 446 func BenchmarkScaleVec100Inc2(b *testing.B)     { scaleVecBench(b, 100, 2) }
 447 func BenchmarkScaleVec1000Inc2(b *testing.B)    { scaleVecBench(b, 1000, 2) }
 448 func BenchmarkScaleVec10000Inc2(b *testing.B)   { scaleVecBench(b, 10000, 2) }
 449 func BenchmarkScaleVec100000Inc2(b *testing.B)  { scaleVecBench(b, 100000, 2) }
 450 func BenchmarkScaleVec10Inc20(b *testing.B)     { scaleVecBench(b, 10, 20) }
 451 func BenchmarkScaleVec100Inc20(b *testing.B)    { scaleVecBench(b, 100, 20) }
 452 func BenchmarkScaleVec1000Inc20(b *testing.B)   { scaleVecBench(b, 1000, 20) }
 453 func BenchmarkScaleVec10000Inc20(b *testing.B)  { scaleVecBench(b, 10000, 20) }
 454 func BenchmarkScaleVec100000Inc20(b *testing.B) { scaleVecBench(b, 100000, 20) }
 455 func scaleVecBench(b *testing.B, size, inc int) {
 456         x := randVecDense(size, inc, 1, rand.NormFloat64)
 457         b.ResetTimer()
 458         var v VecDense
 459         for i := 0; i < b.N; i++ {
 460                 v.ScaleVec(2, x)
 461         }
 462 }
 463
 464 func BenchmarkAddVec10Inc1(b *testing.B)      { addVecBench(b, 10, 1) }
 465 func BenchmarkAddVec100Inc1(b *testing.B)     { addVecBench(b, 100, 1) }
 466 func BenchmarkAddVec1000Inc1(b *testing.B)    { addVecBench(b, 1000, 1) }
 467 func BenchmarkAddVec10000Inc1(b *testing.B)   { addVecBench(b, 10000, 1) }
 468 func BenchmarkAddVec100000Inc1(b *testing.B)  { addVecBench(b, 100000, 1) }
 469 func BenchmarkAddVec10Inc2(b *testing.B)      { addVecBench(b, 10, 2) }
 470 func BenchmarkAddVec100Inc2(b *testing.B)     { addVecBench(b, 100, 2) }
 471 func BenchmarkAddVec1000Inc2(b *testing.B)    { addVecBench(b, 1000, 2) }
 472 func BenchmarkAddVec10000Inc2(b *testing.B)   { addVecBench(b, 10000, 2) }
 473 func BenchmarkAddVec100000Inc2(b *testing.B)  { addVecBench(b, 100000, 2) }
 474 func BenchmarkAddVec10Inc20(b *testing.B)     { addVecBench(b, 10, 20) }
 475 func BenchmarkAddVec100Inc20(b *testing.B)    { addVecBench(b, 100, 20) }
 476 func BenchmarkAddVec1000Inc20(b *testing.B)   { addVecBench(b, 1000, 20) }
 477 func BenchmarkAddVec10000Inc20(b *testing.B)  { addVecBench(b, 10000, 20) }
 478 func BenchmarkAddVec100000Inc20(b *testing.B) { addVecBench(b, 100000, 20) }
 479 func addVecBench(b *testing.B, size, inc int) {
 480         x := randVecDense(size, inc, 1, rand.NormFloat64)
 481         y := randVecDense(size, inc, 1, rand.NormFloat64)
 482         b.ResetTimer()
 483         var v VecDense
 484         for i := 0; i < b.N; i++ {
 485                 v.AddVec(x, y)
 486         }
 487 }
 488
 489 func BenchmarkSubVec10Inc1(b *testing.B)      { subVecBench(b, 10, 1) }
 490 func BenchmarkSubVec100Inc1(b *testing.B)     { subVecBench(b, 100, 1) }
 491 func BenchmarkSubVec1000Inc1(b *testing.B)    { subVecBench(b, 1000, 1) }
 492 func BenchmarkSubVec10000Inc1(b *testing.B)   { subVecBench(b, 10000, 1) }
 493 func BenchmarkSubVec100000Inc1(b *testing.B)  { subVecBench(b, 100000, 1) }
 494 func BenchmarkSubVec10Inc2(b *testing.B)      { subVecBench(b, 10, 2) }
 495 func BenchmarkSubVec100Inc2(b *testing.B)     { subVecBench(b, 100, 2) }
 496 func BenchmarkSubVec1000Inc2(b *testing.B)    { subVecBench(b, 1000, 2) }
 497 func BenchmarkSubVec10000Inc2(b *testing.B)   { subVecBench(b, 10000, 2) }
 498 func BenchmarkSubVec100000Inc2(b *testing.B)  { subVecBench(b, 100000, 2) }
 499 func BenchmarkSubVec10Inc20(b *testing.B)     { subVecBench(b, 10, 20) }
 500 func BenchmarkSubVec100Inc20(b *testing.B)    { subVecBench(b, 100, 20) }
 501 func BenchmarkSubVec1000Inc20(b *testing.B)   { subVecBench(b, 1000, 20) }
 502 func BenchmarkSubVec10000Inc20(b *testing.B)  { subVecBench(b, 10000, 20) }
 503 func BenchmarkSubVec100000Inc20(b *testing.B) { subVecBench(b, 100000, 20) }
 504 func subVecBench(b *testing.B, size, inc int) {
 505         x := randVecDense(size, inc, 1, rand.NormFloat64)
 506         y := randVecDense(size, inc, 1, rand.NormFloat64)
 507         b.ResetTimer()
 508         var v VecDense
 509         for i := 0; i < b.N; i++ {
 510                 v.SubVec(x, y)
 511         }
 512 }
 513
 514 func randVecDense(size, inc int, rho float64, rnd func() float64) *VecDense {
 515         if size <= 0 {
 516                 panic("bad vector size")
 517         }
 518         data := make([]float64, size*inc)
 519         for i := range data {
 520                 if rand.Float64() < rho {
 521                         data[i] = rnd()
 522                 }
 523         }
 524         return &VecDense{
 525                 mat: blas64.Vector{
 526                         Inc:  inc,
 527                         Data: data,
 528                 },
 529                 n: size,
 530         }
 531 }