vendor/gonum.org/v1/gonum/mat/io_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         "bytes"
   9         "encoding"
  10         "io"
  11         "io/ioutil"
  12         "math"
  13         "testing"
  14
  15         "gonum.org/v1/gonum/blas/blas64"
  16 )
  17
  18 var (
  19         _ encoding.BinaryMarshaler   = (*Dense)(nil)
  20         _ encoding.BinaryUnmarshaler = (*Dense)(nil)
  21         _ encoding.BinaryMarshaler   = (*VecDense)(nil)
  22         _ encoding.BinaryUnmarshaler = (*VecDense)(nil)
  23 )
  24
  25 var denseData = []struct {
  26         raw  []byte
  27         want *Dense
  28         eq   func(got, want Matrix) bool
  29 }{
  30         {
  31                 raw:  []byte("\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"),
  32                 want: NewDense(0, 0, []float64{}),
  33                 eq:   Equal,
  34         },
  35         {
  36                 raw:  []byte("\x02\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf0?\x00\x00\x00\x00\x00\x00\x00@\x00\x00\x00\x00\x00\x00\b@\x00\x00\x00\x00\x00\x00\x10@"),
  37                 want: NewDense(2, 2, []float64{1, 2, 3, 4}),
  38                 eq:   Equal,
  39         },
  40         {
  41                 raw:  []byte("\x02\x00\x00\x00\x00\x00\x00\x00\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf0?\x00\x00\x00\x00\x00\x00\x00@\x00\x00\x00\x00\x00\x00\b@\x00\x00\x00\x00\x00\x00\x10@\x00\x00\x00\x00\x00\x00\x14@\x00\x00\x00\x00\x00\x00\x18@"),
  42                 want: NewDense(2, 3, []float64{1, 2, 3, 4, 5, 6}),
  43                 eq:   Equal,
  44         },
  45         {
  46                 raw:  []byte("\x03\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf0?\x00\x00\x00\x00\x00\x00\x00@\x00\x00\x00\x00\x00\x00\b@\x00\x00\x00\x00\x00\x00\x10@\x00\x00\x00\x00\x00\x00\x14@\x00\x00\x00\x00\x00\x00\x18@"),
  47                 want: NewDense(3, 2, []float64{1, 2, 3, 4, 5, 6}),
  48                 eq:   Equal,
  49         },
  50         {
  51                 raw:  []byte("\x03\x00\x00\x00\x00\x00\x00\x00\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf0?\x00\x00\x00\x00\x00\x00\x00@\x00\x00\x00\x00\x00\x00\b@\x00\x00\x00\x00\x00\x00\x10@\x00\x00\x00\x00\x00\x00\x14@\x00\x00\x00\x00\x00\x00\x18@\x00\x00\x00\x00\x00\x00\x1c@\x00\x00\x00\x00\x00\x00 @\x00\x00\x00\x00\x00\x00\"@"),
  52                 want: NewDense(3, 3, []float64{1, 2, 3, 4, 5, 6, 7, 8, 9}),
  53                 eq:   Equal,
  54         },
  55         {
  56                 raw:  []byte("\x02\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf0?\x00\x00\x00\x00\x00\x00\x00@\x00\x00\x00\x00\x00\x00\x10@\x00\x00\x00\x00\x00\x00\x14@"),
  57                 want: NewDense(3, 3, []float64{1, 2, 3, 4, 5, 6, 7, 8, 9}).Slice(0, 2, 0, 2).(*Dense),
  58                 eq:   Equal,
  59         },
  60         {
  61                 raw:  []byte("\x02\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14@\x00\x00\x00\x00\x00\x00\x18@\x00\x00\x00\x00\x00\x00 @\x00\x00\x00\x00\x00\x00\"@"),
  62                 want: NewDense(3, 3, []float64{1, 2, 3, 4, 5, 6, 7, 8, 9}).Slice(1, 3, 1, 3).(*Dense),
  63                 eq:   Equal,
  64         },
  65         {
  66                 raw:  []byte("\x03\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00@\x00\x00\x00\x00\x00\x00\b@\x00\x00\x00\x00\x00\x00\x14@\x00\x00\x00\x00\x00\x00\x18@\x00\x00\x00\x00\x00\x00 @\x00\x00\x00\x00\x00\x00\"@"),
  67                 want: NewDense(3, 3, []float64{1, 2, 3, 4, 5, 6, 7, 8, 9}).Slice(0, 3, 1, 3).(*Dense),
  68                 eq:   Equal,
  69         },
  70         {
  71                 raw:  []byte("\x01\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf0\xff\x00\x00\x00\x00\x00\x00\xf0\u007f\x01\x00\x00\x00\x00\x00\xf8\u007f"),
  72                 want: NewDense(1, 4, []float64{0, math.Inf(-1), math.Inf(+1), math.NaN()}),
  73                 eq: func(got, want Matrix) bool {
  74                         for _, v := range []bool{
  75                                 got.At(0, 0) == 0,
  76                                 math.IsInf(got.At(0, 1), -1),
  77                                 math.IsInf(got.At(0, 2), +1),
  78                                 math.IsNaN(got.At(0, 3)),
  79                         } {
  80                                 if !v {
  81                                         return false
  82                                 }
  83                         }
  84                         return true
  85                 },
  86         },
  87 }
  88
  89 func TestDenseMarshal(t *testing.T) {
  90         for i, test := range denseData {
  91                 buf, err := test.want.MarshalBinary()
  92                 if err != nil {
  93                         t.Errorf("error encoding test-%d: %v\n", i, err)
  94                         continue
  95                 }
  96
  97                 nrows, ncols := test.want.Dims()
  98                 sz := nrows*ncols*sizeFloat64 + 2*sizeInt64
  99                 if len(buf) != sz {
 100                         t.Errorf("encoded size test-%d: want=%d got=%d\n", i, sz, len(buf))
 101                 }
 102
 103                 if !bytes.Equal(buf, test.raw) {
 104                         t.Errorf("error encoding test-%d: bytes mismatch.\n got=%q\nwant=%q\n",
 105                                 i,
 106                                 string(buf),
 107                                 string(test.raw),
 108                         )
 109                         continue
 110                 }
 111         }
 112 }
 113
 114 func TestDenseMarshalTo(t *testing.T) {
 115         for i, test := range denseData {
 116                 buf := new(bytes.Buffer)
 117                 n, err := test.want.MarshalBinaryTo(buf)
 118                 if err != nil {
 119                         t.Errorf("error encoding test-%d: %v\n", i, err)
 120                         continue
 121                 }
 122
 123                 nrows, ncols := test.want.Dims()
 124                 sz := nrows*ncols*sizeFloat64 + 2*sizeInt64
 125                 if n != sz {
 126                         t.Errorf("encoded size test-%d: want=%d got=%d\n", i, sz, n)
 127                 }
 128
 129                 if !bytes.Equal(buf.Bytes(), test.raw) {
 130                         t.Errorf("error encoding test-%d: bytes mismatch.\n got=%q\nwant=%q\n",
 131                                 i,
 132                                 string(buf.Bytes()),
 133                                 string(test.raw),
 134                         )
 135                         continue
 136                 }
 137         }
 138 }
 139
 140 func TestDenseUnmarshal(t *testing.T) {
 141         for i, test := range denseData {
 142                 var v Dense
 143                 err := v.UnmarshalBinary(test.raw)
 144                 if err != nil {
 145                         t.Errorf("error decoding test-%d: %v\n", i, err)
 146                         continue
 147                 }
 148                 if !test.eq(&v, test.want) {
 149                         t.Errorf("error decoding test-%d: values differ.\n got=%v\nwant=%v\n",
 150                                 i,
 151                                 &v,
 152                                 test.want,
 153                         )
 154                 }
 155         }
 156 }
 157
 158 func TestDenseUnmarshalFrom(t *testing.T) {
 159         for i, test := range denseData {
 160                 var v Dense
 161                 buf := bytes.NewReader(test.raw)
 162                 n, err := v.UnmarshalBinaryFrom(buf)
 163                 if err != nil {
 164                         t.Errorf("error decoding test-%d: %v\n", i, err)
 165                         continue
 166                 }
 167                 if n != len(test.raw) {
 168                         t.Errorf("error decoding test-%d: lengths differ.\n got=%d\nwant=%d\n",
 169                                 i, n, len(test.raw),
 170                         )
 171                 }
 172                 if !test.eq(&v, test.want) {
 173                         t.Errorf("error decoding test-%d: values differ.\n got=%v\nwant=%v\n",
 174                                 i,
 175                                 &v,
 176                                 test.want,
 177                         )
 178                 }
 179         }
 180 }
 181
 182 func TestDenseUnmarshalFromError(t *testing.T) {
 183         test := denseData[1]
 184         for i, tt := range []struct {
 185                 beg int
 186                 end int
 187         }{
 188                 {
 189                         beg: 0,
 190                         end: len(test.raw) - 1,
 191                 },
 192                 {
 193                         beg: 0,
 194                         end: len(test.raw) - sizeFloat64,
 195                 },
 196                 {
 197                         beg: 0,
 198                         end: 0,
 199                 },
 200                 {
 201                         beg: 0,
 202                         end: 1,
 203                 },
 204                 {
 205                         beg: 0,
 206                         end: sizeInt64,
 207                 },
 208                 {
 209                         beg: 0,
 210                         end: sizeInt64 - 1,
 211                 },
 212                 {
 213                         beg: 0,
 214                         end: sizeInt64 + 1,
 215                 },
 216                 {
 217                         beg: 0,
 218                         end: 2*sizeInt64 - 1,
 219                 },
 220                 {
 221                         beg: 0,
 222                         end: 2 * sizeInt64,
 223                 },
 224                 {
 225                         beg: 0,
 226                         end: 2*sizeInt64 + 1,
 227                 },
 228                 {
 229                         beg: 0,
 230                         end: 2*sizeInt64 + sizeFloat64 - 1,
 231                 },
 232                 {
 233                         beg: 0,
 234                         end: 2*sizeInt64 + sizeFloat64,
 235                 },
 236                 {
 237                         beg: 0,
 238                         end: 2*sizeInt64 + sizeFloat64 + 1,
 239                 },
 240         } {
 241                 buf := bytes.NewReader(test.raw[tt.beg:tt.end])
 242                 var m Dense
 243                 _, err := m.UnmarshalBinaryFrom(buf)
 244                 if err != io.ErrUnexpectedEOF {
 245                         t.Errorf("test #%d: error decoding. got=%v. want=%v\n", i, err, io.ErrUnexpectedEOF)
 246                 }
 247         }
 248 }
 249
 250 func TestDenseIORoundTrip(t *testing.T) {
 251         for i, test := range denseData {
 252                 buf, err := test.want.MarshalBinary()
 253                 if err != nil {
 254                         t.Errorf("error encoding test #%d: %v\n", i, err)
 255                 }
 256
 257                 var got Dense
 258                 err = got.UnmarshalBinary(buf)
 259                 if err != nil {
 260                         t.Errorf("error decoding test #%d: %v\n", i, err)
 261                 }
 262
 263                 if !test.eq(&got, test.want) {
 264                         t.Errorf("r/w test #%d failed\n got=%#v\nwant=%#v\n", i, &got, test.want)
 265                 }
 266
 267                 wbuf := new(bytes.Buffer)
 268                 _, err = test.want.MarshalBinaryTo(wbuf)
 269                 if err != nil {
 270                         t.Errorf("error encoding test #%d: %v\n", i, err)
 271                 }
 272
 273                 if !bytes.Equal(buf, wbuf.Bytes()) {
 274                         t.Errorf("r/w test #%d encoding via MarshalBinary and MarshalBinaryTo differ:\nwith-stream: %q\n  no-stream: %q\n",
 275                                 i, wbuf.Bytes(), buf,
 276                         )
 277                 }
 278
 279                 var wgot Dense
 280                 _, err = wgot.UnmarshalBinaryFrom(wbuf)
 281                 if err != nil {
 282                         t.Errorf("error decoding test #%d: %v\n", i, err)
 283                 }
 284
 285                 if !test.eq(&wgot, test.want) {
 286                         t.Errorf("r/w test #%d failed\n got=%#v\nwant=%#v\n", i, &wgot, test.want)
 287                 }
 288         }
 289 }
 290
 291 var vectorData = []struct {
 292         raw  []byte
 293         want *VecDense
 294         eq   func(got, want Matrix) bool
 295 }{
 296         {
 297                 raw:  []byte("\x00\x00\x00\x00\x00\x00\x00\x00"),
 298                 want: NewVecDense(0, []float64{}),
 299                 eq:   Equal,
 300         },
 301         {
 302                 raw:  []byte("\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf0?\x00\x00\x00\x00\x00\x00\x00@\x00\x00\x00\x00\x00\x00\b@\x00\x00\x00\x00\x00\x00\x10@"),
 303                 want: NewVecDense(4, []float64{1, 2, 3, 4}),
 304                 eq:   Equal,
 305         },
 306         {
 307                 raw:  []byte("\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf0?\x00\x00\x00\x00\x00\x00\x00@\x00\x00\x00\x00\x00\x00\b@\x00\x00\x00\x00\x00\x00\x10@\x00\x00\x00\x00\x00\x00\x14@\x00\x00\x00\x00\x00\x00\x18@"),
 308                 want: NewVecDense(6, []float64{1, 2, 3, 4, 5, 6}),
 309                 eq:   Equal,
 310         },
 311         {
 312                 raw:  []byte("\t\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf0?\x00\x00\x00\x00\x00\x00\x00@\x00\x00\x00\x00\x00\x00\b@\x00\x00\x00\x00\x00\x00\x10@\x00\x00\x00\x00\x00\x00\x14@\x00\x00\x00\x00\x00\x00\x18@\x00\x00\x00\x00\x00\x00\x1c@\x00\x00\x00\x00\x00\x00 @\x00\x00\x00\x00\x00\x00\"@"),
 313                 want: NewVecDense(9, []float64{1, 2, 3, 4, 5, 6, 7, 8, 9}),
 314                 eq:   Equal,
 315         },
 316         {
 317                 raw:  []byte("\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf0?\x00\x00\x00\x00\x00\x00\x00@\x00\x00\x00\x00\x00\x00\b@"),
 318                 want: NewVecDense(9, []float64{1, 2, 3, 4, 5, 6, 7, 8, 9}).SliceVec(0, 3).(*VecDense),
 319                 eq:   Equal,
 320         },
 321         {
 322                 raw:  []byte("\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00@\x00\x00\x00\x00\x00\x00\b@\x00\x00\x00\x00\x00\x00\x10@"),
 323                 want: NewVecDense(9, []float64{1, 2, 3, 4, 5, 6, 7, 8, 9}).SliceVec(1, 4).(*VecDense),
 324                 eq:   Equal,
 325         },
 326         {
 327                 raw:  []byte("\b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf0?\x00\x00\x00\x00\x00\x00\x00@\x00\x00\x00\x00\x00\x00\b@\x00\x00\x00\x00\x00\x00\x10@\x00\x00\x00\x00\x00\x00\x14@\x00\x00\x00\x00\x00\x00\x18@\x00\x00\x00\x00\x00\x00\x1c@\x00\x00\x00\x00\x00\x00 @"),
 328                 want: NewVecDense(9, []float64{1, 2, 3, 4, 5, 6, 7, 8, 9}).SliceVec(0, 8).(*VecDense),
 329                 eq:   Equal,
 330         },
 331         {
 332                 raw: []byte("\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\b@\x00\x00\x00\x00\x00\x00\x18@"),
 333                 want: &VecDense{
 334                         mat: blas64.Vector{
 335                                 Data: []float64{0, 1, 2, 3, 4, 5, 6},
 336                                 Inc:  3,
 337                         },
 338                         n: 3,
 339                 },
 340                 eq: Equal,
 341         },
 342         {
 343                 raw:  []byte("\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf0\xff\x00\x00\x00\x00\x00\x00\xf0\u007f\x01\x00\x00\x00\x00\x00\xf8\u007f"),
 344                 want: NewVecDense(4, []float64{0, math.Inf(-1), math.Inf(+1), math.NaN()}),
 345                 eq: func(got, want Matrix) bool {
 346                         for _, v := range []bool{
 347                                 got.At(0, 0) == 0,
 348                                 math.IsInf(got.At(1, 0), -1),
 349                                 math.IsInf(got.At(2, 0), +1),
 350                                 math.IsNaN(got.At(3, 0)),
 351                         } {
 352                                 if !v {
 353                                         return false
 354                                 }
 355                         }
 356                         return true
 357                 },
 358         },
 359 }
 360
 361 func TestVecDenseMarshal(t *testing.T) {
 362         for i, test := range vectorData {
 363                 buf, err := test.want.MarshalBinary()
 364                 if err != nil {
 365                         t.Errorf("error encoding test-%d: %v\n", i, err)
 366                         continue
 367                 }
 368
 369                 nrows, ncols := test.want.Dims()
 370                 sz := nrows*ncols*sizeFloat64 + sizeInt64
 371                 if len(buf) != sz {
 372                         t.Errorf("encoded size test-%d: want=%d got=%d\n", i, sz, len(buf))
 373                 }
 374
 375                 if !bytes.Equal(buf, test.raw) {
 376                         t.Errorf("error encoding test-%d: bytes mismatch.\n got=%q\nwant=%q\n",
 377                                 i,
 378                                 string(buf),
 379                                 string(test.raw),
 380                         )
 381                         continue
 382                 }
 383         }
 384 }
 385
 386 func TestVecDenseMarshalTo(t *testing.T) {
 387         for i, test := range vectorData {
 388                 buf := new(bytes.Buffer)
 389                 n, err := test.want.MarshalBinaryTo(buf)
 390                 if err != nil {
 391                         t.Errorf("error encoding test-%d: %v\n", i, err)
 392                         continue
 393                 }
 394
 395                 nrows, ncols := test.want.Dims()
 396                 sz := nrows*ncols*sizeFloat64 + sizeInt64
 397                 if n != sz {
 398                         t.Errorf("encoded size test-%d: want=%d got=%d\n", i, sz, n)
 399                 }
 400
 401                 if !bytes.Equal(buf.Bytes(), test.raw) {
 402                         t.Errorf("error encoding test-%d: bytes mismatch.\n got=%q\nwant=%q\n",
 403                                 i,
 404                                 string(buf.Bytes()),
 405                                 string(test.raw),
 406                         )
 407                         continue
 408                 }
 409         }
 410 }
 411
 412 func TestVecDenseUnmarshal(t *testing.T) {
 413         for i, test := range vectorData {
 414                 var v VecDense
 415                 err := v.UnmarshalBinary(test.raw)
 416                 if err != nil {
 417                         t.Errorf("error decoding test-%d: %v\n", i, err)
 418                         continue
 419                 }
 420                 if !test.eq(&v, test.want) {
 421                         t.Errorf("error decoding test-%d: values differ.\n got=%v\nwant=%v\n",
 422                                 i,
 423                                 &v,
 424                                 test.want,
 425                         )
 426                 }
 427         }
 428 }
 429
 430 func TestVecDenseUnmarshalFrom(t *testing.T) {
 431         for i, test := range vectorData {
 432                 var v VecDense
 433                 buf := bytes.NewReader(test.raw)
 434                 n, err := v.UnmarshalBinaryFrom(buf)
 435                 if err != nil {
 436                         t.Errorf("error decoding test-%d: %v\n", i, err)
 437                         continue
 438                 }
 439                 if n != len(test.raw) {
 440                         t.Errorf("error decoding test-%d: lengths differ.\n got=%d\nwant=%d\n",
 441                                 i,
 442                                 n,
 443                                 len(test.raw),
 444                         )
 445                 }
 446                 if !test.eq(&v, test.want) {
 447                         t.Errorf("error decoding test-%d: values differ.\n got=%v\nwant=%v\n",
 448                                 i,
 449                                 &v,
 450                                 test.want,
 451                         )
 452                 }
 453         }
 454 }
 455
 456 func TestVecDenseUnmarshalFromError(t *testing.T) {
 457         test := vectorData[1]
 458         for i, tt := range []struct {
 459                 beg int
 460                 end int
 461         }{
 462                 {
 463                         beg: 0,
 464                         end: len(test.raw) - 1,
 465                 },
 466                 {
 467                         beg: 0,
 468                         end: len(test.raw) - sizeFloat64,
 469                 },
 470                 {
 471                         beg: 0,
 472                         end: 0,
 473                 },
 474                 {
 475                         beg: 0,
 476                         end: 1,
 477                 },
 478                 {
 479                         beg: 0,
 480                         end: sizeInt64,
 481                 },
 482                 {
 483                         beg: 0,
 484                         end: sizeInt64 - 1,
 485                 },
 486                 {
 487                         beg: 0,
 488                         end: sizeInt64 + 1,
 489                 },
 490                 {
 491                         beg: 0,
 492                         end: sizeInt64 + sizeFloat64 - 1,
 493                 },
 494                 {
 495                         beg: 0,
 496                         end: sizeInt64 + sizeFloat64,
 497                 },
 498                 {
 499                         beg: 0,
 500                         end: sizeInt64 + sizeFloat64 + 1,
 501                 },
 502         } {
 503                 buf := bytes.NewReader(test.raw[tt.beg:tt.end])
 504                 var v VecDense
 505                 _, err := v.UnmarshalBinaryFrom(buf)
 506                 if err != io.ErrUnexpectedEOF {
 507                         t.Errorf("test #%d: error decoding. got=%v. want=%v\n", i, err, io.ErrUnexpectedEOF)
 508                 }
 509         }
 510 }
 511
 512 func TestVecDenseIORoundTrip(t *testing.T) {
 513         for i, test := range vectorData {
 514                 buf, err := test.want.MarshalBinary()
 515                 if err != nil {
 516                         t.Errorf("error encoding test #%d: %v\n", i, err)
 517                 }
 518
 519                 var got VecDense
 520                 err = got.UnmarshalBinary(buf)
 521                 if err != nil {
 522                         t.Errorf("error decoding test #%d: %v\n", i, err)
 523                 }
 524                 if !test.eq(&got, test.want) {
 525                         t.Errorf("r/w test #%d failed\n got=%#v\nwant=%#v\n", i, &got, test.want)
 526                 }
 527
 528                 wbuf := new(bytes.Buffer)
 529                 _, err = test.want.MarshalBinaryTo(wbuf)
 530                 if err != nil {
 531                         t.Errorf("error encoding test #%d: %v\n", i, err)
 532                 }
 533
 534                 if !bytes.Equal(buf, wbuf.Bytes()) {
 535                         t.Errorf("test #%d encoding via MarshalBinary and MarshalBinaryTo differ:\nwith-stream: %q\n  no-stream: %q\n",
 536                                 i, wbuf.Bytes(), buf,
 537                         )
 538                 }
 539
 540                 var wgot VecDense
 541                 _, err = wgot.UnmarshalBinaryFrom(wbuf)
 542                 if err != nil {
 543                         t.Errorf("error decoding test #%d: %v\n", i, err)
 544                 }
 545
 546                 if !test.eq(&wgot, test.want) {
 547                         t.Errorf("r/w test #%d failed\n got=%#v\nwant=%#v\n", i, &wgot, test.want)
 548                 }
 549         }
 550 }
 551
 552 func BenchmarkMarshalDense10(b *testing.B)    { marshalBinaryBenchDense(b, 10) }
 553 func BenchmarkMarshalDense100(b *testing.B)   { marshalBinaryBenchDense(b, 100) }
 554 func BenchmarkMarshalDense1000(b *testing.B)  { marshalBinaryBenchDense(b, 1000) }
 555 func BenchmarkMarshalDense10000(b *testing.B) { marshalBinaryBenchDense(b, 10000) }
 556
 557 func marshalBinaryBenchDense(b *testing.B, size int) {
 558         data := make([]float64, size)
 559         for i := range data {
 560                 data[i] = float64(i)
 561         }
 562         m := NewDense(1, size, data)
 563         b.ResetTimer()
 564
 565         for n := 0; n < b.N; n++ {
 566                 m.MarshalBinary()
 567         }
 568 }
 569
 570 func BenchmarkUnmarshalDense10(b *testing.B)    { unmarshalBinaryBenchDense(b, 10) }
 571 func BenchmarkUnmarshalDense100(b *testing.B)   { unmarshalBinaryBenchDense(b, 100) }
 572 func BenchmarkUnmarshalDense1000(b *testing.B)  { unmarshalBinaryBenchDense(b, 1000) }
 573 func BenchmarkUnmarshalDense10000(b *testing.B) { unmarshalBinaryBenchDense(b, 10000) }
 574
 575 func unmarshalBinaryBenchDense(b *testing.B, size int) {
 576         data := make([]float64, size)
 577         for i := range data {
 578                 data[i] = float64(i)
 579         }
 580         buf, err := NewDense(1, size, data).MarshalBinary()
 581         if err != nil {
 582                 b.Fatalf("error creating binary buffer (size=%d): %v\n", size, err)
 583         }
 584         b.ResetTimer()
 585
 586         for n := 0; n < b.N; n++ {
 587                 var m Dense
 588                 m.UnmarshalBinary(buf)
 589         }
 590 }
 591
 592 func BenchmarkMarshalToDense10(b *testing.B)    { marshalBinaryToBenchDense(b, 10) }
 593 func BenchmarkMarshalToDense100(b *testing.B)   { marshalBinaryToBenchDense(b, 100) }
 594 func BenchmarkMarshalToDense1000(b *testing.B)  { marshalBinaryToBenchDense(b, 1000) }
 595 func BenchmarkMarshalToDense10000(b *testing.B) { marshalBinaryToBenchDense(b, 10000) }
 596
 597 func marshalBinaryToBenchDense(b *testing.B, size int) {
 598         data := make([]float64, size)
 599         for i := range data {
 600                 data[i] = float64(i)
 601         }
 602         m := NewDense(1, size, data)
 603         w := ioutil.Discard
 604         b.ResetTimer()
 605
 606         for n := 0; n < b.N; n++ {
 607                 m.MarshalBinaryTo(w)
 608         }
 609 }
 610
 611 type readerTest struct {
 612         buf []byte
 613         pos int
 614 }
 615
 616 func (r *readerTest) Read(data []byte) (int, error) {
 617         n := copy(data, r.buf[r.pos:r.pos+len(data)])
 618         r.pos += n
 619         return n, nil
 620 }
 621
 622 func (r *readerTest) reset() {
 623         r.pos = 0
 624 }
 625
 626 func BenchmarkUnmarshalFromDense10(b *testing.B)    { unmarshalBinaryFromBenchDense(b, 10) }
 627 func BenchmarkUnmarshalFromDense100(b *testing.B)   { unmarshalBinaryFromBenchDense(b, 100) }
 628 func BenchmarkUnmarshalFromDense1000(b *testing.B)  { unmarshalBinaryFromBenchDense(b, 1000) }
 629 func BenchmarkUnmarshalFromDense10000(b *testing.B) { unmarshalBinaryFromBenchDense(b, 10000) }
 630
 631 func unmarshalBinaryFromBenchDense(b *testing.B, size int) {
 632         data := make([]float64, size)
 633         for i := range data {
 634                 data[i] = float64(i)
 635         }
 636         buf, err := NewDense(1, size, data).MarshalBinary()
 637         if err != nil {
 638                 b.Fatalf("error creating binary buffer (size=%d): %v\n", size, err)
 639         }
 640         r := &readerTest{buf: buf}
 641         b.ResetTimer()
 642
 643         for n := 0; n < b.N; n++ {
 644                 var m Dense
 645                 m.UnmarshalBinaryFrom(r)
 646                 r.reset()
 647         }
 648 }
 649
 650 func BenchmarkMarshalVecDense10(b *testing.B)    { marshalBinaryBenchVecDense(b, 10) }
 651 func BenchmarkMarshalVecDense100(b *testing.B)   { marshalBinaryBenchVecDense(b, 100) }
 652 func BenchmarkMarshalVecDense1000(b *testing.B)  { marshalBinaryBenchVecDense(b, 1000) }
 653 func BenchmarkMarshalVecDense10000(b *testing.B) { marshalBinaryBenchVecDense(b, 10000) }
 654
 655 func marshalBinaryBenchVecDense(b *testing.B, size int) {
 656         data := make([]float64, size)
 657         for i := range data {
 658                 data[i] = float64(i)
 659         }
 660         vec := NewVecDense(size, data)
 661         b.ResetTimer()
 662
 663         for n := 0; n < b.N; n++ {
 664                 vec.MarshalBinary()
 665         }
 666 }
 667
 668 func BenchmarkUnmarshalVecDense10(b *testing.B)    { unmarshalBinaryBenchVecDense(b, 10) }
 669 func BenchmarkUnmarshalVecDense100(b *testing.B)   { unmarshalBinaryBenchVecDense(b, 100) }
 670 func BenchmarkUnmarshalVecDense1000(b *testing.B)  { unmarshalBinaryBenchVecDense(b, 1000) }
 671 func BenchmarkUnmarshalVecDense10000(b *testing.B) { unmarshalBinaryBenchVecDense(b, 10000) }
 672
 673 func unmarshalBinaryBenchVecDense(b *testing.B, size int) {
 674         data := make([]float64, size)
 675         for i := range data {
 676                 data[i] = float64(i)
 677         }
 678         buf, err := NewVecDense(size, data).MarshalBinary()
 679         if err != nil {
 680                 b.Fatalf("error creating binary buffer (size=%d): %v\n", size, err)
 681         }
 682         b.ResetTimer()
 683
 684         for n := 0; n < b.N; n++ {
 685                 var vec VecDense
 686                 vec.UnmarshalBinary(buf)
 687         }
 688 }
 689
 690 func BenchmarkMarshalToVecDense10(b *testing.B)    { marshalBinaryToBenchVecDense(b, 10) }
 691 func BenchmarkMarshalToVecDense100(b *testing.B)   { marshalBinaryToBenchVecDense(b, 100) }
 692 func BenchmarkMarshalToVecDense1000(b *testing.B)  { marshalBinaryToBenchVecDense(b, 1000) }
 693 func BenchmarkMarshalToVecDense10000(b *testing.B) { marshalBinaryToBenchVecDense(b, 10000) }
 694
 695 func marshalBinaryToBenchVecDense(b *testing.B, size int) {
 696         data := make([]float64, size)
 697         for i := range data {
 698                 data[i] = float64(i)
 699         }
 700         vec := NewVecDense(size, data)
 701         w := ioutil.Discard
 702         b.ResetTimer()
 703
 704         for n := 0; n < b.N; n++ {
 705                 vec.MarshalBinaryTo(w)
 706         }
 707 }
 708
 709 func BenchmarkUnmarshalFromVecDense10(b *testing.B)    { unmarshalBinaryFromBenchVecDense(b, 10) }
 710 func BenchmarkUnmarshalFromVecDense100(b *testing.B)   { unmarshalBinaryFromBenchVecDense(b, 100) }
 711 func BenchmarkUnmarshalFromVecDense1000(b *testing.B)  { unmarshalBinaryFromBenchVecDense(b, 1000) }
 712 func BenchmarkUnmarshalFromVecDense10000(b *testing.B) { unmarshalBinaryFromBenchVecDense(b, 10000) }
 713
 714 func unmarshalBinaryFromBenchVecDense(b *testing.B, size int) {
 715         data := make([]float64, size)
 716         for i := range data {
 717                 data[i] = float64(i)
 718         }
 719         buf, err := NewVecDense(size, data).MarshalBinary()
 720         if err != nil {
 721                 b.Fatalf("error creating binary buffer (size=%d): %v\n", size, err)
 722         }
 723         r := &readerTest{buf: buf}
 724         b.ResetTimer()
 725
 726         for n := 0; n < b.N; n++ {
 727                 var vec VecDense
 728                 vec.UnmarshalBinaryFrom(r)
 729                 r.reset()
 730         }
 731 }