github.com/wzzhu/tensor@v0.9.24/dense_maskcmp_methods_test.go (about) 1 // Code generated by genlib2. DO NOT EDIT. 2 3 package tensor 4 5 import ( 6 "fmt" 7 "testing" 8 9 "github.com/stretchr/testify/assert" 10 ) 11 12 /* MaskedEqual */ 13 14 func TestDense_MaskedEqual_I(t *testing.T) { 15 assert := assert.New(t) 16 T := New(Of(Int), WithShape(2, 3, 4, 5)) 17 assert.False(T.IsMasked()) 18 data := T.Ints() 19 for i := range data { 20 data[i] = int(i) 21 } 22 T.MaskedEqual(int(0)) 23 assert.True(T.IsMasked()) 24 T.MaskedEqual(int(1)) 25 assert.True(T.mask[0] && T.mask[1]) 26 T.MaskedNotEqual(int(2)) 27 assert.False(T.mask[2] && !(T.mask[0])) 28 29 T.ResetMask() 30 T.MaskedInside(int(1), int(22)) 31 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 32 33 T.ResetMask() 34 T.MaskedOutside(int(1), int(22)) 35 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 36 37 T.ResetMask() 38 for i := 0; i < 5; i++ { 39 T.MaskedEqual(int(i * 10)) 40 } 41 it := IteratorFromDense(T) 42 43 j := 0 44 for _, err := it.Next(); err == nil; _, err = it.Next() { 45 j++ 46 } 47 48 it.Reset() 49 assert.Equal(120, j) 50 j = 0 51 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 52 j++ 53 } 54 it.Reset() 55 assert.Equal(115, j) 56 j = 0 57 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 58 j++ 59 } 60 it.Reset() 61 assert.Equal(5, j) 62 } 63 func TestDense_MaskedEqual_I8(t *testing.T) { 64 assert := assert.New(t) 65 T := New(Of(Int8), WithShape(2, 3, 4, 5)) 66 assert.False(T.IsMasked()) 67 data := T.Int8s() 68 for i := range data { 69 data[i] = int8(i) 70 } 71 T.MaskedEqual(int8(0)) 72 assert.True(T.IsMasked()) 73 T.MaskedEqual(int8(1)) 74 assert.True(T.mask[0] && T.mask[1]) 75 T.MaskedNotEqual(int8(2)) 76 assert.False(T.mask[2] && !(T.mask[0])) 77 78 T.ResetMask() 79 T.MaskedInside(int8(1), int8(22)) 80 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 81 82 T.ResetMask() 83 T.MaskedOutside(int8(1), int8(22)) 84 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 85 86 T.ResetMask() 87 for i := 0; i < 5; i++ { 88 T.MaskedEqual(int8(i * 10)) 89 } 90 it := IteratorFromDense(T) 91 92 j := 0 93 for _, err := it.Next(); err == nil; _, err = it.Next() { 94 j++ 95 } 96 97 it.Reset() 98 assert.Equal(120, j) 99 j = 0 100 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 101 j++ 102 } 103 it.Reset() 104 assert.Equal(115, j) 105 j = 0 106 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 107 j++ 108 } 109 it.Reset() 110 assert.Equal(5, j) 111 } 112 func TestDense_MaskedEqual_I16(t *testing.T) { 113 assert := assert.New(t) 114 T := New(Of(Int16), WithShape(2, 3, 4, 5)) 115 assert.False(T.IsMasked()) 116 data := T.Int16s() 117 for i := range data { 118 data[i] = int16(i) 119 } 120 T.MaskedEqual(int16(0)) 121 assert.True(T.IsMasked()) 122 T.MaskedEqual(int16(1)) 123 assert.True(T.mask[0] && T.mask[1]) 124 T.MaskedNotEqual(int16(2)) 125 assert.False(T.mask[2] && !(T.mask[0])) 126 127 T.ResetMask() 128 T.MaskedInside(int16(1), int16(22)) 129 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 130 131 T.ResetMask() 132 T.MaskedOutside(int16(1), int16(22)) 133 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 134 135 T.ResetMask() 136 for i := 0; i < 5; i++ { 137 T.MaskedEqual(int16(i * 10)) 138 } 139 it := IteratorFromDense(T) 140 141 j := 0 142 for _, err := it.Next(); err == nil; _, err = it.Next() { 143 j++ 144 } 145 146 it.Reset() 147 assert.Equal(120, j) 148 j = 0 149 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 150 j++ 151 } 152 it.Reset() 153 assert.Equal(115, j) 154 j = 0 155 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 156 j++ 157 } 158 it.Reset() 159 assert.Equal(5, j) 160 } 161 func TestDense_MaskedEqual_I32(t *testing.T) { 162 assert := assert.New(t) 163 T := New(Of(Int32), WithShape(2, 3, 4, 5)) 164 assert.False(T.IsMasked()) 165 data := T.Int32s() 166 for i := range data { 167 data[i] = int32(i) 168 } 169 T.MaskedEqual(int32(0)) 170 assert.True(T.IsMasked()) 171 T.MaskedEqual(int32(1)) 172 assert.True(T.mask[0] && T.mask[1]) 173 T.MaskedNotEqual(int32(2)) 174 assert.False(T.mask[2] && !(T.mask[0])) 175 176 T.ResetMask() 177 T.MaskedInside(int32(1), int32(22)) 178 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 179 180 T.ResetMask() 181 T.MaskedOutside(int32(1), int32(22)) 182 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 183 184 T.ResetMask() 185 for i := 0; i < 5; i++ { 186 T.MaskedEqual(int32(i * 10)) 187 } 188 it := IteratorFromDense(T) 189 190 j := 0 191 for _, err := it.Next(); err == nil; _, err = it.Next() { 192 j++ 193 } 194 195 it.Reset() 196 assert.Equal(120, j) 197 j = 0 198 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 199 j++ 200 } 201 it.Reset() 202 assert.Equal(115, j) 203 j = 0 204 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 205 j++ 206 } 207 it.Reset() 208 assert.Equal(5, j) 209 } 210 func TestDense_MaskedEqual_I64(t *testing.T) { 211 assert := assert.New(t) 212 T := New(Of(Int64), WithShape(2, 3, 4, 5)) 213 assert.False(T.IsMasked()) 214 data := T.Int64s() 215 for i := range data { 216 data[i] = int64(i) 217 } 218 T.MaskedEqual(int64(0)) 219 assert.True(T.IsMasked()) 220 T.MaskedEqual(int64(1)) 221 assert.True(T.mask[0] && T.mask[1]) 222 T.MaskedNotEqual(int64(2)) 223 assert.False(T.mask[2] && !(T.mask[0])) 224 225 T.ResetMask() 226 T.MaskedInside(int64(1), int64(22)) 227 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 228 229 T.ResetMask() 230 T.MaskedOutside(int64(1), int64(22)) 231 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 232 233 T.ResetMask() 234 for i := 0; i < 5; i++ { 235 T.MaskedEqual(int64(i * 10)) 236 } 237 it := IteratorFromDense(T) 238 239 j := 0 240 for _, err := it.Next(); err == nil; _, err = it.Next() { 241 j++ 242 } 243 244 it.Reset() 245 assert.Equal(120, j) 246 j = 0 247 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 248 j++ 249 } 250 it.Reset() 251 assert.Equal(115, j) 252 j = 0 253 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 254 j++ 255 } 256 it.Reset() 257 assert.Equal(5, j) 258 } 259 func TestDense_MaskedEqual_U(t *testing.T) { 260 assert := assert.New(t) 261 T := New(Of(Uint), WithShape(2, 3, 4, 5)) 262 assert.False(T.IsMasked()) 263 data := T.Uints() 264 for i := range data { 265 data[i] = uint(i) 266 } 267 T.MaskedEqual(uint(0)) 268 assert.True(T.IsMasked()) 269 T.MaskedEqual(uint(1)) 270 assert.True(T.mask[0] && T.mask[1]) 271 T.MaskedNotEqual(uint(2)) 272 assert.False(T.mask[2] && !(T.mask[0])) 273 274 T.ResetMask() 275 T.MaskedInside(uint(1), uint(22)) 276 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 277 278 T.ResetMask() 279 T.MaskedOutside(uint(1), uint(22)) 280 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 281 282 T.ResetMask() 283 for i := 0; i < 5; i++ { 284 T.MaskedEqual(uint(i * 10)) 285 } 286 it := IteratorFromDense(T) 287 288 j := 0 289 for _, err := it.Next(); err == nil; _, err = it.Next() { 290 j++ 291 } 292 293 it.Reset() 294 assert.Equal(120, j) 295 j = 0 296 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 297 j++ 298 } 299 it.Reset() 300 assert.Equal(115, j) 301 j = 0 302 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 303 j++ 304 } 305 it.Reset() 306 assert.Equal(5, j) 307 } 308 func TestDense_MaskedEqual_U8(t *testing.T) { 309 assert := assert.New(t) 310 T := New(Of(Uint8), WithShape(2, 3, 4, 5)) 311 assert.False(T.IsMasked()) 312 data := T.Uint8s() 313 for i := range data { 314 data[i] = uint8(i) 315 } 316 T.MaskedEqual(uint8(0)) 317 assert.True(T.IsMasked()) 318 T.MaskedEqual(uint8(1)) 319 assert.True(T.mask[0] && T.mask[1]) 320 T.MaskedNotEqual(uint8(2)) 321 assert.False(T.mask[2] && !(T.mask[0])) 322 323 T.ResetMask() 324 T.MaskedInside(uint8(1), uint8(22)) 325 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 326 327 T.ResetMask() 328 T.MaskedOutside(uint8(1), uint8(22)) 329 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 330 331 T.ResetMask() 332 for i := 0; i < 5; i++ { 333 T.MaskedEqual(uint8(i * 10)) 334 } 335 it := IteratorFromDense(T) 336 337 j := 0 338 for _, err := it.Next(); err == nil; _, err = it.Next() { 339 j++ 340 } 341 342 it.Reset() 343 assert.Equal(120, j) 344 j = 0 345 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 346 j++ 347 } 348 it.Reset() 349 assert.Equal(115, j) 350 j = 0 351 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 352 j++ 353 } 354 it.Reset() 355 assert.Equal(5, j) 356 } 357 func TestDense_MaskedEqual_U16(t *testing.T) { 358 assert := assert.New(t) 359 T := New(Of(Uint16), WithShape(2, 3, 4, 5)) 360 assert.False(T.IsMasked()) 361 data := T.Uint16s() 362 for i := range data { 363 data[i] = uint16(i) 364 } 365 T.MaskedEqual(uint16(0)) 366 assert.True(T.IsMasked()) 367 T.MaskedEqual(uint16(1)) 368 assert.True(T.mask[0] && T.mask[1]) 369 T.MaskedNotEqual(uint16(2)) 370 assert.False(T.mask[2] && !(T.mask[0])) 371 372 T.ResetMask() 373 T.MaskedInside(uint16(1), uint16(22)) 374 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 375 376 T.ResetMask() 377 T.MaskedOutside(uint16(1), uint16(22)) 378 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 379 380 T.ResetMask() 381 for i := 0; i < 5; i++ { 382 T.MaskedEqual(uint16(i * 10)) 383 } 384 it := IteratorFromDense(T) 385 386 j := 0 387 for _, err := it.Next(); err == nil; _, err = it.Next() { 388 j++ 389 } 390 391 it.Reset() 392 assert.Equal(120, j) 393 j = 0 394 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 395 j++ 396 } 397 it.Reset() 398 assert.Equal(115, j) 399 j = 0 400 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 401 j++ 402 } 403 it.Reset() 404 assert.Equal(5, j) 405 } 406 func TestDense_MaskedEqual_U32(t *testing.T) { 407 assert := assert.New(t) 408 T := New(Of(Uint32), WithShape(2, 3, 4, 5)) 409 assert.False(T.IsMasked()) 410 data := T.Uint32s() 411 for i := range data { 412 data[i] = uint32(i) 413 } 414 T.MaskedEqual(uint32(0)) 415 assert.True(T.IsMasked()) 416 T.MaskedEqual(uint32(1)) 417 assert.True(T.mask[0] && T.mask[1]) 418 T.MaskedNotEqual(uint32(2)) 419 assert.False(T.mask[2] && !(T.mask[0])) 420 421 T.ResetMask() 422 T.MaskedInside(uint32(1), uint32(22)) 423 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 424 425 T.ResetMask() 426 T.MaskedOutside(uint32(1), uint32(22)) 427 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 428 429 T.ResetMask() 430 for i := 0; i < 5; i++ { 431 T.MaskedEqual(uint32(i * 10)) 432 } 433 it := IteratorFromDense(T) 434 435 j := 0 436 for _, err := it.Next(); err == nil; _, err = it.Next() { 437 j++ 438 } 439 440 it.Reset() 441 assert.Equal(120, j) 442 j = 0 443 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 444 j++ 445 } 446 it.Reset() 447 assert.Equal(115, j) 448 j = 0 449 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 450 j++ 451 } 452 it.Reset() 453 assert.Equal(5, j) 454 } 455 func TestDense_MaskedEqual_U64(t *testing.T) { 456 assert := assert.New(t) 457 T := New(Of(Uint64), WithShape(2, 3, 4, 5)) 458 assert.False(T.IsMasked()) 459 data := T.Uint64s() 460 for i := range data { 461 data[i] = uint64(i) 462 } 463 T.MaskedEqual(uint64(0)) 464 assert.True(T.IsMasked()) 465 T.MaskedEqual(uint64(1)) 466 assert.True(T.mask[0] && T.mask[1]) 467 T.MaskedNotEqual(uint64(2)) 468 assert.False(T.mask[2] && !(T.mask[0])) 469 470 T.ResetMask() 471 T.MaskedInside(uint64(1), uint64(22)) 472 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 473 474 T.ResetMask() 475 T.MaskedOutside(uint64(1), uint64(22)) 476 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 477 478 T.ResetMask() 479 for i := 0; i < 5; i++ { 480 T.MaskedEqual(uint64(i * 10)) 481 } 482 it := IteratorFromDense(T) 483 484 j := 0 485 for _, err := it.Next(); err == nil; _, err = it.Next() { 486 j++ 487 } 488 489 it.Reset() 490 assert.Equal(120, j) 491 j = 0 492 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 493 j++ 494 } 495 it.Reset() 496 assert.Equal(115, j) 497 j = 0 498 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 499 j++ 500 } 501 it.Reset() 502 assert.Equal(5, j) 503 } 504 func TestDense_MaskedEqual_F32(t *testing.T) { 505 assert := assert.New(t) 506 T := New(Of(Float32), WithShape(2, 3, 4, 5)) 507 assert.False(T.IsMasked()) 508 data := T.Float32s() 509 for i := range data { 510 data[i] = float32(i) 511 } 512 T.MaskedEqual(float32(0)) 513 assert.True(T.IsMasked()) 514 T.MaskedEqual(float32(1)) 515 assert.True(T.mask[0] && T.mask[1]) 516 T.MaskedNotEqual(float32(2)) 517 assert.False(T.mask[2] && !(T.mask[0])) 518 519 T.ResetMask() 520 T.MaskedInside(float32(1), float32(22)) 521 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 522 523 T.ResetMask() 524 T.MaskedOutside(float32(1), float32(22)) 525 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 526 527 T.ResetMask() 528 for i := 0; i < 5; i++ { 529 T.MaskedEqual(float32(i * 10)) 530 } 531 it := IteratorFromDense(T) 532 533 j := 0 534 for _, err := it.Next(); err == nil; _, err = it.Next() { 535 j++ 536 } 537 538 it.Reset() 539 assert.Equal(120, j) 540 j = 0 541 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 542 j++ 543 } 544 it.Reset() 545 assert.Equal(115, j) 546 j = 0 547 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 548 j++ 549 } 550 it.Reset() 551 assert.Equal(5, j) 552 } 553 func TestDense_MaskedEqual_F64(t *testing.T) { 554 assert := assert.New(t) 555 T := New(Of(Float64), WithShape(2, 3, 4, 5)) 556 assert.False(T.IsMasked()) 557 data := T.Float64s() 558 for i := range data { 559 data[i] = float64(i) 560 } 561 T.MaskedEqual(float64(0)) 562 assert.True(T.IsMasked()) 563 T.MaskedEqual(float64(1)) 564 assert.True(T.mask[0] && T.mask[1]) 565 T.MaskedNotEqual(float64(2)) 566 assert.False(T.mask[2] && !(T.mask[0])) 567 568 T.ResetMask() 569 T.MaskedInside(float64(1), float64(22)) 570 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 571 572 T.ResetMask() 573 T.MaskedOutside(float64(1), float64(22)) 574 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 575 576 T.ResetMask() 577 for i := 0; i < 5; i++ { 578 T.MaskedEqual(float64(i * 10)) 579 } 580 it := IteratorFromDense(T) 581 582 j := 0 583 for _, err := it.Next(); err == nil; _, err = it.Next() { 584 j++ 585 } 586 587 it.Reset() 588 assert.Equal(120, j) 589 j = 0 590 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 591 j++ 592 } 593 it.Reset() 594 assert.Equal(115, j) 595 j = 0 596 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 597 j++ 598 } 599 it.Reset() 600 assert.Equal(5, j) 601 } 602 func TestDense_MaskedEqual_Str(t *testing.T) { 603 assert := assert.New(t) 604 T := New(Of(String), WithShape(2, 3, 4, 5)) 605 assert.False(T.IsMasked()) 606 data := T.Strings() 607 for i := range data { 608 data[i] = fmt.Sprint(i) 609 } 610 T.MaskedEqual(fmt.Sprint(0)) 611 assert.True(T.IsMasked()) 612 T.MaskedEqual(fmt.Sprint(1)) 613 assert.True(T.mask[0] && T.mask[1]) 614 T.MaskedNotEqual(fmt.Sprint(2)) 615 assert.False(T.mask[2] && !(T.mask[0])) 616 617 T.ResetMask() 618 T.MaskedInside(fmt.Sprint(1), fmt.Sprint(22)) 619 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 620 621 T.ResetMask() 622 T.MaskedOutside(fmt.Sprint(1), fmt.Sprint(22)) 623 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 624 625 T.ResetMask() 626 for i := 0; i < 5; i++ { 627 T.MaskedEqual(fmt.Sprint(i * 10)) 628 } 629 it := IteratorFromDense(T) 630 631 j := 0 632 for _, err := it.Next(); err == nil; _, err = it.Next() { 633 j++ 634 } 635 636 it.Reset() 637 assert.Equal(120, j) 638 j = 0 639 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 640 j++ 641 } 642 it.Reset() 643 assert.Equal(115, j) 644 j = 0 645 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 646 j++ 647 } 648 it.Reset() 649 assert.Equal(5, j) 650 } 651 652 /* MaskedNotEqual */ 653 654 func TestDense_MaskedNotEqual_I(t *testing.T) { 655 assert := assert.New(t) 656 T := New(Of(Int), WithShape(2, 3, 4, 5)) 657 assert.False(T.IsMasked()) 658 data := T.Ints() 659 for i := range data { 660 data[i] = int(i) 661 } 662 T.MaskedEqual(int(0)) 663 assert.True(T.IsMasked()) 664 T.MaskedEqual(int(1)) 665 assert.True(T.mask[0] && T.mask[1]) 666 T.MaskedNotEqual(int(2)) 667 assert.False(T.mask[2] && !(T.mask[0])) 668 669 T.ResetMask() 670 T.MaskedInside(int(1), int(22)) 671 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 672 673 T.ResetMask() 674 T.MaskedOutside(int(1), int(22)) 675 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 676 677 T.ResetMask() 678 for i := 0; i < 5; i++ { 679 T.MaskedEqual(int(i * 10)) 680 } 681 it := IteratorFromDense(T) 682 683 j := 0 684 for _, err := it.Next(); err == nil; _, err = it.Next() { 685 j++ 686 } 687 688 it.Reset() 689 assert.Equal(120, j) 690 j = 0 691 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 692 j++ 693 } 694 it.Reset() 695 assert.Equal(115, j) 696 j = 0 697 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 698 j++ 699 } 700 it.Reset() 701 assert.Equal(5, j) 702 } 703 func TestDense_MaskedNotEqual_I8(t *testing.T) { 704 assert := assert.New(t) 705 T := New(Of(Int8), WithShape(2, 3, 4, 5)) 706 assert.False(T.IsMasked()) 707 data := T.Int8s() 708 for i := range data { 709 data[i] = int8(i) 710 } 711 T.MaskedEqual(int8(0)) 712 assert.True(T.IsMasked()) 713 T.MaskedEqual(int8(1)) 714 assert.True(T.mask[0] && T.mask[1]) 715 T.MaskedNotEqual(int8(2)) 716 assert.False(T.mask[2] && !(T.mask[0])) 717 718 T.ResetMask() 719 T.MaskedInside(int8(1), int8(22)) 720 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 721 722 T.ResetMask() 723 T.MaskedOutside(int8(1), int8(22)) 724 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 725 726 T.ResetMask() 727 for i := 0; i < 5; i++ { 728 T.MaskedEqual(int8(i * 10)) 729 } 730 it := IteratorFromDense(T) 731 732 j := 0 733 for _, err := it.Next(); err == nil; _, err = it.Next() { 734 j++ 735 } 736 737 it.Reset() 738 assert.Equal(120, j) 739 j = 0 740 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 741 j++ 742 } 743 it.Reset() 744 assert.Equal(115, j) 745 j = 0 746 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 747 j++ 748 } 749 it.Reset() 750 assert.Equal(5, j) 751 } 752 func TestDense_MaskedNotEqual_I16(t *testing.T) { 753 assert := assert.New(t) 754 T := New(Of(Int16), WithShape(2, 3, 4, 5)) 755 assert.False(T.IsMasked()) 756 data := T.Int16s() 757 for i := range data { 758 data[i] = int16(i) 759 } 760 T.MaskedEqual(int16(0)) 761 assert.True(T.IsMasked()) 762 T.MaskedEqual(int16(1)) 763 assert.True(T.mask[0] && T.mask[1]) 764 T.MaskedNotEqual(int16(2)) 765 assert.False(T.mask[2] && !(T.mask[0])) 766 767 T.ResetMask() 768 T.MaskedInside(int16(1), int16(22)) 769 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 770 771 T.ResetMask() 772 T.MaskedOutside(int16(1), int16(22)) 773 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 774 775 T.ResetMask() 776 for i := 0; i < 5; i++ { 777 T.MaskedEqual(int16(i * 10)) 778 } 779 it := IteratorFromDense(T) 780 781 j := 0 782 for _, err := it.Next(); err == nil; _, err = it.Next() { 783 j++ 784 } 785 786 it.Reset() 787 assert.Equal(120, j) 788 j = 0 789 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 790 j++ 791 } 792 it.Reset() 793 assert.Equal(115, j) 794 j = 0 795 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 796 j++ 797 } 798 it.Reset() 799 assert.Equal(5, j) 800 } 801 func TestDense_MaskedNotEqual_I32(t *testing.T) { 802 assert := assert.New(t) 803 T := New(Of(Int32), WithShape(2, 3, 4, 5)) 804 assert.False(T.IsMasked()) 805 data := T.Int32s() 806 for i := range data { 807 data[i] = int32(i) 808 } 809 T.MaskedEqual(int32(0)) 810 assert.True(T.IsMasked()) 811 T.MaskedEqual(int32(1)) 812 assert.True(T.mask[0] && T.mask[1]) 813 T.MaskedNotEqual(int32(2)) 814 assert.False(T.mask[2] && !(T.mask[0])) 815 816 T.ResetMask() 817 T.MaskedInside(int32(1), int32(22)) 818 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 819 820 T.ResetMask() 821 T.MaskedOutside(int32(1), int32(22)) 822 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 823 824 T.ResetMask() 825 for i := 0; i < 5; i++ { 826 T.MaskedEqual(int32(i * 10)) 827 } 828 it := IteratorFromDense(T) 829 830 j := 0 831 for _, err := it.Next(); err == nil; _, err = it.Next() { 832 j++ 833 } 834 835 it.Reset() 836 assert.Equal(120, j) 837 j = 0 838 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 839 j++ 840 } 841 it.Reset() 842 assert.Equal(115, j) 843 j = 0 844 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 845 j++ 846 } 847 it.Reset() 848 assert.Equal(5, j) 849 } 850 func TestDense_MaskedNotEqual_I64(t *testing.T) { 851 assert := assert.New(t) 852 T := New(Of(Int64), WithShape(2, 3, 4, 5)) 853 assert.False(T.IsMasked()) 854 data := T.Int64s() 855 for i := range data { 856 data[i] = int64(i) 857 } 858 T.MaskedEqual(int64(0)) 859 assert.True(T.IsMasked()) 860 T.MaskedEqual(int64(1)) 861 assert.True(T.mask[0] && T.mask[1]) 862 T.MaskedNotEqual(int64(2)) 863 assert.False(T.mask[2] && !(T.mask[0])) 864 865 T.ResetMask() 866 T.MaskedInside(int64(1), int64(22)) 867 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 868 869 T.ResetMask() 870 T.MaskedOutside(int64(1), int64(22)) 871 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 872 873 T.ResetMask() 874 for i := 0; i < 5; i++ { 875 T.MaskedEqual(int64(i * 10)) 876 } 877 it := IteratorFromDense(T) 878 879 j := 0 880 for _, err := it.Next(); err == nil; _, err = it.Next() { 881 j++ 882 } 883 884 it.Reset() 885 assert.Equal(120, j) 886 j = 0 887 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 888 j++ 889 } 890 it.Reset() 891 assert.Equal(115, j) 892 j = 0 893 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 894 j++ 895 } 896 it.Reset() 897 assert.Equal(5, j) 898 } 899 func TestDense_MaskedNotEqual_U(t *testing.T) { 900 assert := assert.New(t) 901 T := New(Of(Uint), WithShape(2, 3, 4, 5)) 902 assert.False(T.IsMasked()) 903 data := T.Uints() 904 for i := range data { 905 data[i] = uint(i) 906 } 907 T.MaskedEqual(uint(0)) 908 assert.True(T.IsMasked()) 909 T.MaskedEqual(uint(1)) 910 assert.True(T.mask[0] && T.mask[1]) 911 T.MaskedNotEqual(uint(2)) 912 assert.False(T.mask[2] && !(T.mask[0])) 913 914 T.ResetMask() 915 T.MaskedInside(uint(1), uint(22)) 916 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 917 918 T.ResetMask() 919 T.MaskedOutside(uint(1), uint(22)) 920 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 921 922 T.ResetMask() 923 for i := 0; i < 5; i++ { 924 T.MaskedEqual(uint(i * 10)) 925 } 926 it := IteratorFromDense(T) 927 928 j := 0 929 for _, err := it.Next(); err == nil; _, err = it.Next() { 930 j++ 931 } 932 933 it.Reset() 934 assert.Equal(120, j) 935 j = 0 936 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 937 j++ 938 } 939 it.Reset() 940 assert.Equal(115, j) 941 j = 0 942 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 943 j++ 944 } 945 it.Reset() 946 assert.Equal(5, j) 947 } 948 func TestDense_MaskedNotEqual_U8(t *testing.T) { 949 assert := assert.New(t) 950 T := New(Of(Uint8), WithShape(2, 3, 4, 5)) 951 assert.False(T.IsMasked()) 952 data := T.Uint8s() 953 for i := range data { 954 data[i] = uint8(i) 955 } 956 T.MaskedEqual(uint8(0)) 957 assert.True(T.IsMasked()) 958 T.MaskedEqual(uint8(1)) 959 assert.True(T.mask[0] && T.mask[1]) 960 T.MaskedNotEqual(uint8(2)) 961 assert.False(T.mask[2] && !(T.mask[0])) 962 963 T.ResetMask() 964 T.MaskedInside(uint8(1), uint8(22)) 965 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 966 967 T.ResetMask() 968 T.MaskedOutside(uint8(1), uint8(22)) 969 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 970 971 T.ResetMask() 972 for i := 0; i < 5; i++ { 973 T.MaskedEqual(uint8(i * 10)) 974 } 975 it := IteratorFromDense(T) 976 977 j := 0 978 for _, err := it.Next(); err == nil; _, err = it.Next() { 979 j++ 980 } 981 982 it.Reset() 983 assert.Equal(120, j) 984 j = 0 985 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 986 j++ 987 } 988 it.Reset() 989 assert.Equal(115, j) 990 j = 0 991 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 992 j++ 993 } 994 it.Reset() 995 assert.Equal(5, j) 996 } 997 func TestDense_MaskedNotEqual_U16(t *testing.T) { 998 assert := assert.New(t) 999 T := New(Of(Uint16), WithShape(2, 3, 4, 5)) 1000 assert.False(T.IsMasked()) 1001 data := T.Uint16s() 1002 for i := range data { 1003 data[i] = uint16(i) 1004 } 1005 T.MaskedEqual(uint16(0)) 1006 assert.True(T.IsMasked()) 1007 T.MaskedEqual(uint16(1)) 1008 assert.True(T.mask[0] && T.mask[1]) 1009 T.MaskedNotEqual(uint16(2)) 1010 assert.False(T.mask[2] && !(T.mask[0])) 1011 1012 T.ResetMask() 1013 T.MaskedInside(uint16(1), uint16(22)) 1014 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 1015 1016 T.ResetMask() 1017 T.MaskedOutside(uint16(1), uint16(22)) 1018 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 1019 1020 T.ResetMask() 1021 for i := 0; i < 5; i++ { 1022 T.MaskedEqual(uint16(i * 10)) 1023 } 1024 it := IteratorFromDense(T) 1025 1026 j := 0 1027 for _, err := it.Next(); err == nil; _, err = it.Next() { 1028 j++ 1029 } 1030 1031 it.Reset() 1032 assert.Equal(120, j) 1033 j = 0 1034 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 1035 j++ 1036 } 1037 it.Reset() 1038 assert.Equal(115, j) 1039 j = 0 1040 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 1041 j++ 1042 } 1043 it.Reset() 1044 assert.Equal(5, j) 1045 } 1046 func TestDense_MaskedNotEqual_U32(t *testing.T) { 1047 assert := assert.New(t) 1048 T := New(Of(Uint32), WithShape(2, 3, 4, 5)) 1049 assert.False(T.IsMasked()) 1050 data := T.Uint32s() 1051 for i := range data { 1052 data[i] = uint32(i) 1053 } 1054 T.MaskedEqual(uint32(0)) 1055 assert.True(T.IsMasked()) 1056 T.MaskedEqual(uint32(1)) 1057 assert.True(T.mask[0] && T.mask[1]) 1058 T.MaskedNotEqual(uint32(2)) 1059 assert.False(T.mask[2] && !(T.mask[0])) 1060 1061 T.ResetMask() 1062 T.MaskedInside(uint32(1), uint32(22)) 1063 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 1064 1065 T.ResetMask() 1066 T.MaskedOutside(uint32(1), uint32(22)) 1067 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 1068 1069 T.ResetMask() 1070 for i := 0; i < 5; i++ { 1071 T.MaskedEqual(uint32(i * 10)) 1072 } 1073 it := IteratorFromDense(T) 1074 1075 j := 0 1076 for _, err := it.Next(); err == nil; _, err = it.Next() { 1077 j++ 1078 } 1079 1080 it.Reset() 1081 assert.Equal(120, j) 1082 j = 0 1083 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 1084 j++ 1085 } 1086 it.Reset() 1087 assert.Equal(115, j) 1088 j = 0 1089 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 1090 j++ 1091 } 1092 it.Reset() 1093 assert.Equal(5, j) 1094 } 1095 func TestDense_MaskedNotEqual_U64(t *testing.T) { 1096 assert := assert.New(t) 1097 T := New(Of(Uint64), WithShape(2, 3, 4, 5)) 1098 assert.False(T.IsMasked()) 1099 data := T.Uint64s() 1100 for i := range data { 1101 data[i] = uint64(i) 1102 } 1103 T.MaskedEqual(uint64(0)) 1104 assert.True(T.IsMasked()) 1105 T.MaskedEqual(uint64(1)) 1106 assert.True(T.mask[0] && T.mask[1]) 1107 T.MaskedNotEqual(uint64(2)) 1108 assert.False(T.mask[2] && !(T.mask[0])) 1109 1110 T.ResetMask() 1111 T.MaskedInside(uint64(1), uint64(22)) 1112 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 1113 1114 T.ResetMask() 1115 T.MaskedOutside(uint64(1), uint64(22)) 1116 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 1117 1118 T.ResetMask() 1119 for i := 0; i < 5; i++ { 1120 T.MaskedEqual(uint64(i * 10)) 1121 } 1122 it := IteratorFromDense(T) 1123 1124 j := 0 1125 for _, err := it.Next(); err == nil; _, err = it.Next() { 1126 j++ 1127 } 1128 1129 it.Reset() 1130 assert.Equal(120, j) 1131 j = 0 1132 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 1133 j++ 1134 } 1135 it.Reset() 1136 assert.Equal(115, j) 1137 j = 0 1138 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 1139 j++ 1140 } 1141 it.Reset() 1142 assert.Equal(5, j) 1143 } 1144 func TestDense_MaskedNotEqual_F32(t *testing.T) { 1145 assert := assert.New(t) 1146 T := New(Of(Float32), WithShape(2, 3, 4, 5)) 1147 assert.False(T.IsMasked()) 1148 data := T.Float32s() 1149 for i := range data { 1150 data[i] = float32(i) 1151 } 1152 T.MaskedEqual(float32(0)) 1153 assert.True(T.IsMasked()) 1154 T.MaskedEqual(float32(1)) 1155 assert.True(T.mask[0] && T.mask[1]) 1156 T.MaskedNotEqual(float32(2)) 1157 assert.False(T.mask[2] && !(T.mask[0])) 1158 1159 T.ResetMask() 1160 T.MaskedInside(float32(1), float32(22)) 1161 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 1162 1163 T.ResetMask() 1164 T.MaskedOutside(float32(1), float32(22)) 1165 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 1166 1167 T.ResetMask() 1168 for i := 0; i < 5; i++ { 1169 T.MaskedEqual(float32(i * 10)) 1170 } 1171 it := IteratorFromDense(T) 1172 1173 j := 0 1174 for _, err := it.Next(); err == nil; _, err = it.Next() { 1175 j++ 1176 } 1177 1178 it.Reset() 1179 assert.Equal(120, j) 1180 j = 0 1181 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 1182 j++ 1183 } 1184 it.Reset() 1185 assert.Equal(115, j) 1186 j = 0 1187 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 1188 j++ 1189 } 1190 it.Reset() 1191 assert.Equal(5, j) 1192 } 1193 func TestDense_MaskedNotEqual_F64(t *testing.T) { 1194 assert := assert.New(t) 1195 T := New(Of(Float64), WithShape(2, 3, 4, 5)) 1196 assert.False(T.IsMasked()) 1197 data := T.Float64s() 1198 for i := range data { 1199 data[i] = float64(i) 1200 } 1201 T.MaskedEqual(float64(0)) 1202 assert.True(T.IsMasked()) 1203 T.MaskedEqual(float64(1)) 1204 assert.True(T.mask[0] && T.mask[1]) 1205 T.MaskedNotEqual(float64(2)) 1206 assert.False(T.mask[2] && !(T.mask[0])) 1207 1208 T.ResetMask() 1209 T.MaskedInside(float64(1), float64(22)) 1210 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 1211 1212 T.ResetMask() 1213 T.MaskedOutside(float64(1), float64(22)) 1214 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 1215 1216 T.ResetMask() 1217 for i := 0; i < 5; i++ { 1218 T.MaskedEqual(float64(i * 10)) 1219 } 1220 it := IteratorFromDense(T) 1221 1222 j := 0 1223 for _, err := it.Next(); err == nil; _, err = it.Next() { 1224 j++ 1225 } 1226 1227 it.Reset() 1228 assert.Equal(120, j) 1229 j = 0 1230 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 1231 j++ 1232 } 1233 it.Reset() 1234 assert.Equal(115, j) 1235 j = 0 1236 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 1237 j++ 1238 } 1239 it.Reset() 1240 assert.Equal(5, j) 1241 } 1242 func TestDense_MaskedNotEqual_Str(t *testing.T) { 1243 assert := assert.New(t) 1244 T := New(Of(String), WithShape(2, 3, 4, 5)) 1245 assert.False(T.IsMasked()) 1246 data := T.Strings() 1247 for i := range data { 1248 data[i] = fmt.Sprint(i) 1249 } 1250 T.MaskedEqual(fmt.Sprint(0)) 1251 assert.True(T.IsMasked()) 1252 T.MaskedEqual(fmt.Sprint(1)) 1253 assert.True(T.mask[0] && T.mask[1]) 1254 T.MaskedNotEqual(fmt.Sprint(2)) 1255 assert.False(T.mask[2] && !(T.mask[0])) 1256 1257 T.ResetMask() 1258 T.MaskedInside(fmt.Sprint(1), fmt.Sprint(22)) 1259 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 1260 1261 T.ResetMask() 1262 T.MaskedOutside(fmt.Sprint(1), fmt.Sprint(22)) 1263 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 1264 1265 T.ResetMask() 1266 for i := 0; i < 5; i++ { 1267 T.MaskedEqual(fmt.Sprint(i * 10)) 1268 } 1269 it := IteratorFromDense(T) 1270 1271 j := 0 1272 for _, err := it.Next(); err == nil; _, err = it.Next() { 1273 j++ 1274 } 1275 1276 it.Reset() 1277 assert.Equal(120, j) 1278 j = 0 1279 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 1280 j++ 1281 } 1282 it.Reset() 1283 assert.Equal(115, j) 1284 j = 0 1285 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 1286 j++ 1287 } 1288 it.Reset() 1289 assert.Equal(5, j) 1290 } 1291 1292 /* MaskedValues */ 1293 1294 func TestDense_MaskedValues_F32(t *testing.T) { 1295 assert := assert.New(t) 1296 T := New(Of(Float32), WithShape(2, 3, 4, 5)) 1297 assert.False(T.IsMasked()) 1298 data := T.Float32s() 1299 for i := range data { 1300 data[i] = float32(i) 1301 } 1302 T.MaskedEqual(float32(0)) 1303 assert.True(T.IsMasked()) 1304 T.MaskedEqual(float32(1)) 1305 assert.True(T.mask[0] && T.mask[1]) 1306 T.MaskedNotEqual(float32(2)) 1307 assert.False(T.mask[2] && !(T.mask[0])) 1308 1309 T.ResetMask() 1310 T.MaskedInside(float32(1), float32(22)) 1311 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 1312 1313 T.ResetMask() 1314 T.MaskedOutside(float32(1), float32(22)) 1315 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 1316 1317 T.ResetMask() 1318 for i := 0; i < 5; i++ { 1319 T.MaskedEqual(float32(i * 10)) 1320 } 1321 it := IteratorFromDense(T) 1322 1323 j := 0 1324 for _, err := it.Next(); err == nil; _, err = it.Next() { 1325 j++ 1326 } 1327 1328 it.Reset() 1329 assert.Equal(120, j) 1330 j = 0 1331 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 1332 j++ 1333 } 1334 it.Reset() 1335 assert.Equal(115, j) 1336 j = 0 1337 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 1338 j++ 1339 } 1340 it.Reset() 1341 assert.Equal(5, j) 1342 } 1343 func TestDense_MaskedValues_F64(t *testing.T) { 1344 assert := assert.New(t) 1345 T := New(Of(Float64), WithShape(2, 3, 4, 5)) 1346 assert.False(T.IsMasked()) 1347 data := T.Float64s() 1348 for i := range data { 1349 data[i] = float64(i) 1350 } 1351 T.MaskedEqual(float64(0)) 1352 assert.True(T.IsMasked()) 1353 T.MaskedEqual(float64(1)) 1354 assert.True(T.mask[0] && T.mask[1]) 1355 T.MaskedNotEqual(float64(2)) 1356 assert.False(T.mask[2] && !(T.mask[0])) 1357 1358 T.ResetMask() 1359 T.MaskedInside(float64(1), float64(22)) 1360 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 1361 1362 T.ResetMask() 1363 T.MaskedOutside(float64(1), float64(22)) 1364 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 1365 1366 T.ResetMask() 1367 for i := 0; i < 5; i++ { 1368 T.MaskedEqual(float64(i * 10)) 1369 } 1370 it := IteratorFromDense(T) 1371 1372 j := 0 1373 for _, err := it.Next(); err == nil; _, err = it.Next() { 1374 j++ 1375 } 1376 1377 it.Reset() 1378 assert.Equal(120, j) 1379 j = 0 1380 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 1381 j++ 1382 } 1383 it.Reset() 1384 assert.Equal(115, j) 1385 j = 0 1386 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 1387 j++ 1388 } 1389 it.Reset() 1390 assert.Equal(5, j) 1391 } 1392 1393 /* MaskedGreater */ 1394 1395 func TestDense_MaskedGreater_I(t *testing.T) { 1396 assert := assert.New(t) 1397 T := New(Of(Int), WithShape(2, 3, 4, 5)) 1398 assert.False(T.IsMasked()) 1399 data := T.Ints() 1400 for i := range data { 1401 data[i] = int(i) 1402 } 1403 T.MaskedEqual(int(0)) 1404 assert.True(T.IsMasked()) 1405 T.MaskedEqual(int(1)) 1406 assert.True(T.mask[0] && T.mask[1]) 1407 T.MaskedNotEqual(int(2)) 1408 assert.False(T.mask[2] && !(T.mask[0])) 1409 1410 T.ResetMask() 1411 T.MaskedInside(int(1), int(22)) 1412 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 1413 1414 T.ResetMask() 1415 T.MaskedOutside(int(1), int(22)) 1416 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 1417 1418 T.ResetMask() 1419 for i := 0; i < 5; i++ { 1420 T.MaskedEqual(int(i * 10)) 1421 } 1422 it := IteratorFromDense(T) 1423 1424 j := 0 1425 for _, err := it.Next(); err == nil; _, err = it.Next() { 1426 j++ 1427 } 1428 1429 it.Reset() 1430 assert.Equal(120, j) 1431 j = 0 1432 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 1433 j++ 1434 } 1435 it.Reset() 1436 assert.Equal(115, j) 1437 j = 0 1438 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 1439 j++ 1440 } 1441 it.Reset() 1442 assert.Equal(5, j) 1443 } 1444 func TestDense_MaskedGreater_I8(t *testing.T) { 1445 assert := assert.New(t) 1446 T := New(Of(Int8), WithShape(2, 3, 4, 5)) 1447 assert.False(T.IsMasked()) 1448 data := T.Int8s() 1449 for i := range data { 1450 data[i] = int8(i) 1451 } 1452 T.MaskedEqual(int8(0)) 1453 assert.True(T.IsMasked()) 1454 T.MaskedEqual(int8(1)) 1455 assert.True(T.mask[0] && T.mask[1]) 1456 T.MaskedNotEqual(int8(2)) 1457 assert.False(T.mask[2] && !(T.mask[0])) 1458 1459 T.ResetMask() 1460 T.MaskedInside(int8(1), int8(22)) 1461 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 1462 1463 T.ResetMask() 1464 T.MaskedOutside(int8(1), int8(22)) 1465 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 1466 1467 T.ResetMask() 1468 for i := 0; i < 5; i++ { 1469 T.MaskedEqual(int8(i * 10)) 1470 } 1471 it := IteratorFromDense(T) 1472 1473 j := 0 1474 for _, err := it.Next(); err == nil; _, err = it.Next() { 1475 j++ 1476 } 1477 1478 it.Reset() 1479 assert.Equal(120, j) 1480 j = 0 1481 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 1482 j++ 1483 } 1484 it.Reset() 1485 assert.Equal(115, j) 1486 j = 0 1487 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 1488 j++ 1489 } 1490 it.Reset() 1491 assert.Equal(5, j) 1492 } 1493 func TestDense_MaskedGreater_I16(t *testing.T) { 1494 assert := assert.New(t) 1495 T := New(Of(Int16), WithShape(2, 3, 4, 5)) 1496 assert.False(T.IsMasked()) 1497 data := T.Int16s() 1498 for i := range data { 1499 data[i] = int16(i) 1500 } 1501 T.MaskedEqual(int16(0)) 1502 assert.True(T.IsMasked()) 1503 T.MaskedEqual(int16(1)) 1504 assert.True(T.mask[0] && T.mask[1]) 1505 T.MaskedNotEqual(int16(2)) 1506 assert.False(T.mask[2] && !(T.mask[0])) 1507 1508 T.ResetMask() 1509 T.MaskedInside(int16(1), int16(22)) 1510 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 1511 1512 T.ResetMask() 1513 T.MaskedOutside(int16(1), int16(22)) 1514 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 1515 1516 T.ResetMask() 1517 for i := 0; i < 5; i++ { 1518 T.MaskedEqual(int16(i * 10)) 1519 } 1520 it := IteratorFromDense(T) 1521 1522 j := 0 1523 for _, err := it.Next(); err == nil; _, err = it.Next() { 1524 j++ 1525 } 1526 1527 it.Reset() 1528 assert.Equal(120, j) 1529 j = 0 1530 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 1531 j++ 1532 } 1533 it.Reset() 1534 assert.Equal(115, j) 1535 j = 0 1536 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 1537 j++ 1538 } 1539 it.Reset() 1540 assert.Equal(5, j) 1541 } 1542 func TestDense_MaskedGreater_I32(t *testing.T) { 1543 assert := assert.New(t) 1544 T := New(Of(Int32), WithShape(2, 3, 4, 5)) 1545 assert.False(T.IsMasked()) 1546 data := T.Int32s() 1547 for i := range data { 1548 data[i] = int32(i) 1549 } 1550 T.MaskedEqual(int32(0)) 1551 assert.True(T.IsMasked()) 1552 T.MaskedEqual(int32(1)) 1553 assert.True(T.mask[0] && T.mask[1]) 1554 T.MaskedNotEqual(int32(2)) 1555 assert.False(T.mask[2] && !(T.mask[0])) 1556 1557 T.ResetMask() 1558 T.MaskedInside(int32(1), int32(22)) 1559 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 1560 1561 T.ResetMask() 1562 T.MaskedOutside(int32(1), int32(22)) 1563 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 1564 1565 T.ResetMask() 1566 for i := 0; i < 5; i++ { 1567 T.MaskedEqual(int32(i * 10)) 1568 } 1569 it := IteratorFromDense(T) 1570 1571 j := 0 1572 for _, err := it.Next(); err == nil; _, err = it.Next() { 1573 j++ 1574 } 1575 1576 it.Reset() 1577 assert.Equal(120, j) 1578 j = 0 1579 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 1580 j++ 1581 } 1582 it.Reset() 1583 assert.Equal(115, j) 1584 j = 0 1585 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 1586 j++ 1587 } 1588 it.Reset() 1589 assert.Equal(5, j) 1590 } 1591 func TestDense_MaskedGreater_I64(t *testing.T) { 1592 assert := assert.New(t) 1593 T := New(Of(Int64), WithShape(2, 3, 4, 5)) 1594 assert.False(T.IsMasked()) 1595 data := T.Int64s() 1596 for i := range data { 1597 data[i] = int64(i) 1598 } 1599 T.MaskedEqual(int64(0)) 1600 assert.True(T.IsMasked()) 1601 T.MaskedEqual(int64(1)) 1602 assert.True(T.mask[0] && T.mask[1]) 1603 T.MaskedNotEqual(int64(2)) 1604 assert.False(T.mask[2] && !(T.mask[0])) 1605 1606 T.ResetMask() 1607 T.MaskedInside(int64(1), int64(22)) 1608 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 1609 1610 T.ResetMask() 1611 T.MaskedOutside(int64(1), int64(22)) 1612 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 1613 1614 T.ResetMask() 1615 for i := 0; i < 5; i++ { 1616 T.MaskedEqual(int64(i * 10)) 1617 } 1618 it := IteratorFromDense(T) 1619 1620 j := 0 1621 for _, err := it.Next(); err == nil; _, err = it.Next() { 1622 j++ 1623 } 1624 1625 it.Reset() 1626 assert.Equal(120, j) 1627 j = 0 1628 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 1629 j++ 1630 } 1631 it.Reset() 1632 assert.Equal(115, j) 1633 j = 0 1634 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 1635 j++ 1636 } 1637 it.Reset() 1638 assert.Equal(5, j) 1639 } 1640 func TestDense_MaskedGreater_U(t *testing.T) { 1641 assert := assert.New(t) 1642 T := New(Of(Uint), WithShape(2, 3, 4, 5)) 1643 assert.False(T.IsMasked()) 1644 data := T.Uints() 1645 for i := range data { 1646 data[i] = uint(i) 1647 } 1648 T.MaskedEqual(uint(0)) 1649 assert.True(T.IsMasked()) 1650 T.MaskedEqual(uint(1)) 1651 assert.True(T.mask[0] && T.mask[1]) 1652 T.MaskedNotEqual(uint(2)) 1653 assert.False(T.mask[2] && !(T.mask[0])) 1654 1655 T.ResetMask() 1656 T.MaskedInside(uint(1), uint(22)) 1657 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 1658 1659 T.ResetMask() 1660 T.MaskedOutside(uint(1), uint(22)) 1661 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 1662 1663 T.ResetMask() 1664 for i := 0; i < 5; i++ { 1665 T.MaskedEqual(uint(i * 10)) 1666 } 1667 it := IteratorFromDense(T) 1668 1669 j := 0 1670 for _, err := it.Next(); err == nil; _, err = it.Next() { 1671 j++ 1672 } 1673 1674 it.Reset() 1675 assert.Equal(120, j) 1676 j = 0 1677 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 1678 j++ 1679 } 1680 it.Reset() 1681 assert.Equal(115, j) 1682 j = 0 1683 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 1684 j++ 1685 } 1686 it.Reset() 1687 assert.Equal(5, j) 1688 } 1689 func TestDense_MaskedGreater_U8(t *testing.T) { 1690 assert := assert.New(t) 1691 T := New(Of(Uint8), WithShape(2, 3, 4, 5)) 1692 assert.False(T.IsMasked()) 1693 data := T.Uint8s() 1694 for i := range data { 1695 data[i] = uint8(i) 1696 } 1697 T.MaskedEqual(uint8(0)) 1698 assert.True(T.IsMasked()) 1699 T.MaskedEqual(uint8(1)) 1700 assert.True(T.mask[0] && T.mask[1]) 1701 T.MaskedNotEqual(uint8(2)) 1702 assert.False(T.mask[2] && !(T.mask[0])) 1703 1704 T.ResetMask() 1705 T.MaskedInside(uint8(1), uint8(22)) 1706 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 1707 1708 T.ResetMask() 1709 T.MaskedOutside(uint8(1), uint8(22)) 1710 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 1711 1712 T.ResetMask() 1713 for i := 0; i < 5; i++ { 1714 T.MaskedEqual(uint8(i * 10)) 1715 } 1716 it := IteratorFromDense(T) 1717 1718 j := 0 1719 for _, err := it.Next(); err == nil; _, err = it.Next() { 1720 j++ 1721 } 1722 1723 it.Reset() 1724 assert.Equal(120, j) 1725 j = 0 1726 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 1727 j++ 1728 } 1729 it.Reset() 1730 assert.Equal(115, j) 1731 j = 0 1732 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 1733 j++ 1734 } 1735 it.Reset() 1736 assert.Equal(5, j) 1737 } 1738 func TestDense_MaskedGreater_U16(t *testing.T) { 1739 assert := assert.New(t) 1740 T := New(Of(Uint16), WithShape(2, 3, 4, 5)) 1741 assert.False(T.IsMasked()) 1742 data := T.Uint16s() 1743 for i := range data { 1744 data[i] = uint16(i) 1745 } 1746 T.MaskedEqual(uint16(0)) 1747 assert.True(T.IsMasked()) 1748 T.MaskedEqual(uint16(1)) 1749 assert.True(T.mask[0] && T.mask[1]) 1750 T.MaskedNotEqual(uint16(2)) 1751 assert.False(T.mask[2] && !(T.mask[0])) 1752 1753 T.ResetMask() 1754 T.MaskedInside(uint16(1), uint16(22)) 1755 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 1756 1757 T.ResetMask() 1758 T.MaskedOutside(uint16(1), uint16(22)) 1759 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 1760 1761 T.ResetMask() 1762 for i := 0; i < 5; i++ { 1763 T.MaskedEqual(uint16(i * 10)) 1764 } 1765 it := IteratorFromDense(T) 1766 1767 j := 0 1768 for _, err := it.Next(); err == nil; _, err = it.Next() { 1769 j++ 1770 } 1771 1772 it.Reset() 1773 assert.Equal(120, j) 1774 j = 0 1775 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 1776 j++ 1777 } 1778 it.Reset() 1779 assert.Equal(115, j) 1780 j = 0 1781 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 1782 j++ 1783 } 1784 it.Reset() 1785 assert.Equal(5, j) 1786 } 1787 func TestDense_MaskedGreater_U32(t *testing.T) { 1788 assert := assert.New(t) 1789 T := New(Of(Uint32), WithShape(2, 3, 4, 5)) 1790 assert.False(T.IsMasked()) 1791 data := T.Uint32s() 1792 for i := range data { 1793 data[i] = uint32(i) 1794 } 1795 T.MaskedEqual(uint32(0)) 1796 assert.True(T.IsMasked()) 1797 T.MaskedEqual(uint32(1)) 1798 assert.True(T.mask[0] && T.mask[1]) 1799 T.MaskedNotEqual(uint32(2)) 1800 assert.False(T.mask[2] && !(T.mask[0])) 1801 1802 T.ResetMask() 1803 T.MaskedInside(uint32(1), uint32(22)) 1804 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 1805 1806 T.ResetMask() 1807 T.MaskedOutside(uint32(1), uint32(22)) 1808 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 1809 1810 T.ResetMask() 1811 for i := 0; i < 5; i++ { 1812 T.MaskedEqual(uint32(i * 10)) 1813 } 1814 it := IteratorFromDense(T) 1815 1816 j := 0 1817 for _, err := it.Next(); err == nil; _, err = it.Next() { 1818 j++ 1819 } 1820 1821 it.Reset() 1822 assert.Equal(120, j) 1823 j = 0 1824 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 1825 j++ 1826 } 1827 it.Reset() 1828 assert.Equal(115, j) 1829 j = 0 1830 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 1831 j++ 1832 } 1833 it.Reset() 1834 assert.Equal(5, j) 1835 } 1836 func TestDense_MaskedGreater_U64(t *testing.T) { 1837 assert := assert.New(t) 1838 T := New(Of(Uint64), WithShape(2, 3, 4, 5)) 1839 assert.False(T.IsMasked()) 1840 data := T.Uint64s() 1841 for i := range data { 1842 data[i] = uint64(i) 1843 } 1844 T.MaskedEqual(uint64(0)) 1845 assert.True(T.IsMasked()) 1846 T.MaskedEqual(uint64(1)) 1847 assert.True(T.mask[0] && T.mask[1]) 1848 T.MaskedNotEqual(uint64(2)) 1849 assert.False(T.mask[2] && !(T.mask[0])) 1850 1851 T.ResetMask() 1852 T.MaskedInside(uint64(1), uint64(22)) 1853 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 1854 1855 T.ResetMask() 1856 T.MaskedOutside(uint64(1), uint64(22)) 1857 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 1858 1859 T.ResetMask() 1860 for i := 0; i < 5; i++ { 1861 T.MaskedEqual(uint64(i * 10)) 1862 } 1863 it := IteratorFromDense(T) 1864 1865 j := 0 1866 for _, err := it.Next(); err == nil; _, err = it.Next() { 1867 j++ 1868 } 1869 1870 it.Reset() 1871 assert.Equal(120, j) 1872 j = 0 1873 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 1874 j++ 1875 } 1876 it.Reset() 1877 assert.Equal(115, j) 1878 j = 0 1879 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 1880 j++ 1881 } 1882 it.Reset() 1883 assert.Equal(5, j) 1884 } 1885 func TestDense_MaskedGreater_F32(t *testing.T) { 1886 assert := assert.New(t) 1887 T := New(Of(Float32), WithShape(2, 3, 4, 5)) 1888 assert.False(T.IsMasked()) 1889 data := T.Float32s() 1890 for i := range data { 1891 data[i] = float32(i) 1892 } 1893 T.MaskedEqual(float32(0)) 1894 assert.True(T.IsMasked()) 1895 T.MaskedEqual(float32(1)) 1896 assert.True(T.mask[0] && T.mask[1]) 1897 T.MaskedNotEqual(float32(2)) 1898 assert.False(T.mask[2] && !(T.mask[0])) 1899 1900 T.ResetMask() 1901 T.MaskedInside(float32(1), float32(22)) 1902 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 1903 1904 T.ResetMask() 1905 T.MaskedOutside(float32(1), float32(22)) 1906 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 1907 1908 T.ResetMask() 1909 for i := 0; i < 5; i++ { 1910 T.MaskedEqual(float32(i * 10)) 1911 } 1912 it := IteratorFromDense(T) 1913 1914 j := 0 1915 for _, err := it.Next(); err == nil; _, err = it.Next() { 1916 j++ 1917 } 1918 1919 it.Reset() 1920 assert.Equal(120, j) 1921 j = 0 1922 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 1923 j++ 1924 } 1925 it.Reset() 1926 assert.Equal(115, j) 1927 j = 0 1928 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 1929 j++ 1930 } 1931 it.Reset() 1932 assert.Equal(5, j) 1933 } 1934 func TestDense_MaskedGreater_F64(t *testing.T) { 1935 assert := assert.New(t) 1936 T := New(Of(Float64), WithShape(2, 3, 4, 5)) 1937 assert.False(T.IsMasked()) 1938 data := T.Float64s() 1939 for i := range data { 1940 data[i] = float64(i) 1941 } 1942 T.MaskedEqual(float64(0)) 1943 assert.True(T.IsMasked()) 1944 T.MaskedEqual(float64(1)) 1945 assert.True(T.mask[0] && T.mask[1]) 1946 T.MaskedNotEqual(float64(2)) 1947 assert.False(T.mask[2] && !(T.mask[0])) 1948 1949 T.ResetMask() 1950 T.MaskedInside(float64(1), float64(22)) 1951 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 1952 1953 T.ResetMask() 1954 T.MaskedOutside(float64(1), float64(22)) 1955 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 1956 1957 T.ResetMask() 1958 for i := 0; i < 5; i++ { 1959 T.MaskedEqual(float64(i * 10)) 1960 } 1961 it := IteratorFromDense(T) 1962 1963 j := 0 1964 for _, err := it.Next(); err == nil; _, err = it.Next() { 1965 j++ 1966 } 1967 1968 it.Reset() 1969 assert.Equal(120, j) 1970 j = 0 1971 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 1972 j++ 1973 } 1974 it.Reset() 1975 assert.Equal(115, j) 1976 j = 0 1977 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 1978 j++ 1979 } 1980 it.Reset() 1981 assert.Equal(5, j) 1982 } 1983 func TestDense_MaskedGreater_Str(t *testing.T) { 1984 assert := assert.New(t) 1985 T := New(Of(String), WithShape(2, 3, 4, 5)) 1986 assert.False(T.IsMasked()) 1987 data := T.Strings() 1988 for i := range data { 1989 data[i] = fmt.Sprint(i) 1990 } 1991 T.MaskedEqual(fmt.Sprint(0)) 1992 assert.True(T.IsMasked()) 1993 T.MaskedEqual(fmt.Sprint(1)) 1994 assert.True(T.mask[0] && T.mask[1]) 1995 T.MaskedNotEqual(fmt.Sprint(2)) 1996 assert.False(T.mask[2] && !(T.mask[0])) 1997 1998 T.ResetMask() 1999 T.MaskedInside(fmt.Sprint(1), fmt.Sprint(22)) 2000 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 2001 2002 T.ResetMask() 2003 T.MaskedOutside(fmt.Sprint(1), fmt.Sprint(22)) 2004 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 2005 2006 T.ResetMask() 2007 for i := 0; i < 5; i++ { 2008 T.MaskedEqual(fmt.Sprint(i * 10)) 2009 } 2010 it := IteratorFromDense(T) 2011 2012 j := 0 2013 for _, err := it.Next(); err == nil; _, err = it.Next() { 2014 j++ 2015 } 2016 2017 it.Reset() 2018 assert.Equal(120, j) 2019 j = 0 2020 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 2021 j++ 2022 } 2023 it.Reset() 2024 assert.Equal(115, j) 2025 j = 0 2026 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 2027 j++ 2028 } 2029 it.Reset() 2030 assert.Equal(5, j) 2031 } 2032 2033 /* MaskedGreaterEqual */ 2034 2035 func TestDense_MaskedGreaterEqual_I(t *testing.T) { 2036 assert := assert.New(t) 2037 T := New(Of(Int), WithShape(2, 3, 4, 5)) 2038 assert.False(T.IsMasked()) 2039 data := T.Ints() 2040 for i := range data { 2041 data[i] = int(i) 2042 } 2043 T.MaskedEqual(int(0)) 2044 assert.True(T.IsMasked()) 2045 T.MaskedEqual(int(1)) 2046 assert.True(T.mask[0] && T.mask[1]) 2047 T.MaskedNotEqual(int(2)) 2048 assert.False(T.mask[2] && !(T.mask[0])) 2049 2050 T.ResetMask() 2051 T.MaskedInside(int(1), int(22)) 2052 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 2053 2054 T.ResetMask() 2055 T.MaskedOutside(int(1), int(22)) 2056 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 2057 2058 T.ResetMask() 2059 for i := 0; i < 5; i++ { 2060 T.MaskedEqual(int(i * 10)) 2061 } 2062 it := IteratorFromDense(T) 2063 2064 j := 0 2065 for _, err := it.Next(); err == nil; _, err = it.Next() { 2066 j++ 2067 } 2068 2069 it.Reset() 2070 assert.Equal(120, j) 2071 j = 0 2072 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 2073 j++ 2074 } 2075 it.Reset() 2076 assert.Equal(115, j) 2077 j = 0 2078 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 2079 j++ 2080 } 2081 it.Reset() 2082 assert.Equal(5, j) 2083 } 2084 func TestDense_MaskedGreaterEqual_I8(t *testing.T) { 2085 assert := assert.New(t) 2086 T := New(Of(Int8), WithShape(2, 3, 4, 5)) 2087 assert.False(T.IsMasked()) 2088 data := T.Int8s() 2089 for i := range data { 2090 data[i] = int8(i) 2091 } 2092 T.MaskedEqual(int8(0)) 2093 assert.True(T.IsMasked()) 2094 T.MaskedEqual(int8(1)) 2095 assert.True(T.mask[0] && T.mask[1]) 2096 T.MaskedNotEqual(int8(2)) 2097 assert.False(T.mask[2] && !(T.mask[0])) 2098 2099 T.ResetMask() 2100 T.MaskedInside(int8(1), int8(22)) 2101 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 2102 2103 T.ResetMask() 2104 T.MaskedOutside(int8(1), int8(22)) 2105 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 2106 2107 T.ResetMask() 2108 for i := 0; i < 5; i++ { 2109 T.MaskedEqual(int8(i * 10)) 2110 } 2111 it := IteratorFromDense(T) 2112 2113 j := 0 2114 for _, err := it.Next(); err == nil; _, err = it.Next() { 2115 j++ 2116 } 2117 2118 it.Reset() 2119 assert.Equal(120, j) 2120 j = 0 2121 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 2122 j++ 2123 } 2124 it.Reset() 2125 assert.Equal(115, j) 2126 j = 0 2127 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 2128 j++ 2129 } 2130 it.Reset() 2131 assert.Equal(5, j) 2132 } 2133 func TestDense_MaskedGreaterEqual_I16(t *testing.T) { 2134 assert := assert.New(t) 2135 T := New(Of(Int16), WithShape(2, 3, 4, 5)) 2136 assert.False(T.IsMasked()) 2137 data := T.Int16s() 2138 for i := range data { 2139 data[i] = int16(i) 2140 } 2141 T.MaskedEqual(int16(0)) 2142 assert.True(T.IsMasked()) 2143 T.MaskedEqual(int16(1)) 2144 assert.True(T.mask[0] && T.mask[1]) 2145 T.MaskedNotEqual(int16(2)) 2146 assert.False(T.mask[2] && !(T.mask[0])) 2147 2148 T.ResetMask() 2149 T.MaskedInside(int16(1), int16(22)) 2150 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 2151 2152 T.ResetMask() 2153 T.MaskedOutside(int16(1), int16(22)) 2154 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 2155 2156 T.ResetMask() 2157 for i := 0; i < 5; i++ { 2158 T.MaskedEqual(int16(i * 10)) 2159 } 2160 it := IteratorFromDense(T) 2161 2162 j := 0 2163 for _, err := it.Next(); err == nil; _, err = it.Next() { 2164 j++ 2165 } 2166 2167 it.Reset() 2168 assert.Equal(120, j) 2169 j = 0 2170 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 2171 j++ 2172 } 2173 it.Reset() 2174 assert.Equal(115, j) 2175 j = 0 2176 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 2177 j++ 2178 } 2179 it.Reset() 2180 assert.Equal(5, j) 2181 } 2182 func TestDense_MaskedGreaterEqual_I32(t *testing.T) { 2183 assert := assert.New(t) 2184 T := New(Of(Int32), WithShape(2, 3, 4, 5)) 2185 assert.False(T.IsMasked()) 2186 data := T.Int32s() 2187 for i := range data { 2188 data[i] = int32(i) 2189 } 2190 T.MaskedEqual(int32(0)) 2191 assert.True(T.IsMasked()) 2192 T.MaskedEqual(int32(1)) 2193 assert.True(T.mask[0] && T.mask[1]) 2194 T.MaskedNotEqual(int32(2)) 2195 assert.False(T.mask[2] && !(T.mask[0])) 2196 2197 T.ResetMask() 2198 T.MaskedInside(int32(1), int32(22)) 2199 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 2200 2201 T.ResetMask() 2202 T.MaskedOutside(int32(1), int32(22)) 2203 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 2204 2205 T.ResetMask() 2206 for i := 0; i < 5; i++ { 2207 T.MaskedEqual(int32(i * 10)) 2208 } 2209 it := IteratorFromDense(T) 2210 2211 j := 0 2212 for _, err := it.Next(); err == nil; _, err = it.Next() { 2213 j++ 2214 } 2215 2216 it.Reset() 2217 assert.Equal(120, j) 2218 j = 0 2219 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 2220 j++ 2221 } 2222 it.Reset() 2223 assert.Equal(115, j) 2224 j = 0 2225 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 2226 j++ 2227 } 2228 it.Reset() 2229 assert.Equal(5, j) 2230 } 2231 func TestDense_MaskedGreaterEqual_I64(t *testing.T) { 2232 assert := assert.New(t) 2233 T := New(Of(Int64), WithShape(2, 3, 4, 5)) 2234 assert.False(T.IsMasked()) 2235 data := T.Int64s() 2236 for i := range data { 2237 data[i] = int64(i) 2238 } 2239 T.MaskedEqual(int64(0)) 2240 assert.True(T.IsMasked()) 2241 T.MaskedEqual(int64(1)) 2242 assert.True(T.mask[0] && T.mask[1]) 2243 T.MaskedNotEqual(int64(2)) 2244 assert.False(T.mask[2] && !(T.mask[0])) 2245 2246 T.ResetMask() 2247 T.MaskedInside(int64(1), int64(22)) 2248 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 2249 2250 T.ResetMask() 2251 T.MaskedOutside(int64(1), int64(22)) 2252 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 2253 2254 T.ResetMask() 2255 for i := 0; i < 5; i++ { 2256 T.MaskedEqual(int64(i * 10)) 2257 } 2258 it := IteratorFromDense(T) 2259 2260 j := 0 2261 for _, err := it.Next(); err == nil; _, err = it.Next() { 2262 j++ 2263 } 2264 2265 it.Reset() 2266 assert.Equal(120, j) 2267 j = 0 2268 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 2269 j++ 2270 } 2271 it.Reset() 2272 assert.Equal(115, j) 2273 j = 0 2274 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 2275 j++ 2276 } 2277 it.Reset() 2278 assert.Equal(5, j) 2279 } 2280 func TestDense_MaskedGreaterEqual_U(t *testing.T) { 2281 assert := assert.New(t) 2282 T := New(Of(Uint), WithShape(2, 3, 4, 5)) 2283 assert.False(T.IsMasked()) 2284 data := T.Uints() 2285 for i := range data { 2286 data[i] = uint(i) 2287 } 2288 T.MaskedEqual(uint(0)) 2289 assert.True(T.IsMasked()) 2290 T.MaskedEqual(uint(1)) 2291 assert.True(T.mask[0] && T.mask[1]) 2292 T.MaskedNotEqual(uint(2)) 2293 assert.False(T.mask[2] && !(T.mask[0])) 2294 2295 T.ResetMask() 2296 T.MaskedInside(uint(1), uint(22)) 2297 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 2298 2299 T.ResetMask() 2300 T.MaskedOutside(uint(1), uint(22)) 2301 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 2302 2303 T.ResetMask() 2304 for i := 0; i < 5; i++ { 2305 T.MaskedEqual(uint(i * 10)) 2306 } 2307 it := IteratorFromDense(T) 2308 2309 j := 0 2310 for _, err := it.Next(); err == nil; _, err = it.Next() { 2311 j++ 2312 } 2313 2314 it.Reset() 2315 assert.Equal(120, j) 2316 j = 0 2317 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 2318 j++ 2319 } 2320 it.Reset() 2321 assert.Equal(115, j) 2322 j = 0 2323 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 2324 j++ 2325 } 2326 it.Reset() 2327 assert.Equal(5, j) 2328 } 2329 func TestDense_MaskedGreaterEqual_U8(t *testing.T) { 2330 assert := assert.New(t) 2331 T := New(Of(Uint8), WithShape(2, 3, 4, 5)) 2332 assert.False(T.IsMasked()) 2333 data := T.Uint8s() 2334 for i := range data { 2335 data[i] = uint8(i) 2336 } 2337 T.MaskedEqual(uint8(0)) 2338 assert.True(T.IsMasked()) 2339 T.MaskedEqual(uint8(1)) 2340 assert.True(T.mask[0] && T.mask[1]) 2341 T.MaskedNotEqual(uint8(2)) 2342 assert.False(T.mask[2] && !(T.mask[0])) 2343 2344 T.ResetMask() 2345 T.MaskedInside(uint8(1), uint8(22)) 2346 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 2347 2348 T.ResetMask() 2349 T.MaskedOutside(uint8(1), uint8(22)) 2350 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 2351 2352 T.ResetMask() 2353 for i := 0; i < 5; i++ { 2354 T.MaskedEqual(uint8(i * 10)) 2355 } 2356 it := IteratorFromDense(T) 2357 2358 j := 0 2359 for _, err := it.Next(); err == nil; _, err = it.Next() { 2360 j++ 2361 } 2362 2363 it.Reset() 2364 assert.Equal(120, j) 2365 j = 0 2366 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 2367 j++ 2368 } 2369 it.Reset() 2370 assert.Equal(115, j) 2371 j = 0 2372 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 2373 j++ 2374 } 2375 it.Reset() 2376 assert.Equal(5, j) 2377 } 2378 func TestDense_MaskedGreaterEqual_U16(t *testing.T) { 2379 assert := assert.New(t) 2380 T := New(Of(Uint16), WithShape(2, 3, 4, 5)) 2381 assert.False(T.IsMasked()) 2382 data := T.Uint16s() 2383 for i := range data { 2384 data[i] = uint16(i) 2385 } 2386 T.MaskedEqual(uint16(0)) 2387 assert.True(T.IsMasked()) 2388 T.MaskedEqual(uint16(1)) 2389 assert.True(T.mask[0] && T.mask[1]) 2390 T.MaskedNotEqual(uint16(2)) 2391 assert.False(T.mask[2] && !(T.mask[0])) 2392 2393 T.ResetMask() 2394 T.MaskedInside(uint16(1), uint16(22)) 2395 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 2396 2397 T.ResetMask() 2398 T.MaskedOutside(uint16(1), uint16(22)) 2399 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 2400 2401 T.ResetMask() 2402 for i := 0; i < 5; i++ { 2403 T.MaskedEqual(uint16(i * 10)) 2404 } 2405 it := IteratorFromDense(T) 2406 2407 j := 0 2408 for _, err := it.Next(); err == nil; _, err = it.Next() { 2409 j++ 2410 } 2411 2412 it.Reset() 2413 assert.Equal(120, j) 2414 j = 0 2415 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 2416 j++ 2417 } 2418 it.Reset() 2419 assert.Equal(115, j) 2420 j = 0 2421 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 2422 j++ 2423 } 2424 it.Reset() 2425 assert.Equal(5, j) 2426 } 2427 func TestDense_MaskedGreaterEqual_U32(t *testing.T) { 2428 assert := assert.New(t) 2429 T := New(Of(Uint32), WithShape(2, 3, 4, 5)) 2430 assert.False(T.IsMasked()) 2431 data := T.Uint32s() 2432 for i := range data { 2433 data[i] = uint32(i) 2434 } 2435 T.MaskedEqual(uint32(0)) 2436 assert.True(T.IsMasked()) 2437 T.MaskedEqual(uint32(1)) 2438 assert.True(T.mask[0] && T.mask[1]) 2439 T.MaskedNotEqual(uint32(2)) 2440 assert.False(T.mask[2] && !(T.mask[0])) 2441 2442 T.ResetMask() 2443 T.MaskedInside(uint32(1), uint32(22)) 2444 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 2445 2446 T.ResetMask() 2447 T.MaskedOutside(uint32(1), uint32(22)) 2448 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 2449 2450 T.ResetMask() 2451 for i := 0; i < 5; i++ { 2452 T.MaskedEqual(uint32(i * 10)) 2453 } 2454 it := IteratorFromDense(T) 2455 2456 j := 0 2457 for _, err := it.Next(); err == nil; _, err = it.Next() { 2458 j++ 2459 } 2460 2461 it.Reset() 2462 assert.Equal(120, j) 2463 j = 0 2464 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 2465 j++ 2466 } 2467 it.Reset() 2468 assert.Equal(115, j) 2469 j = 0 2470 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 2471 j++ 2472 } 2473 it.Reset() 2474 assert.Equal(5, j) 2475 } 2476 func TestDense_MaskedGreaterEqual_U64(t *testing.T) { 2477 assert := assert.New(t) 2478 T := New(Of(Uint64), WithShape(2, 3, 4, 5)) 2479 assert.False(T.IsMasked()) 2480 data := T.Uint64s() 2481 for i := range data { 2482 data[i] = uint64(i) 2483 } 2484 T.MaskedEqual(uint64(0)) 2485 assert.True(T.IsMasked()) 2486 T.MaskedEqual(uint64(1)) 2487 assert.True(T.mask[0] && T.mask[1]) 2488 T.MaskedNotEqual(uint64(2)) 2489 assert.False(T.mask[2] && !(T.mask[0])) 2490 2491 T.ResetMask() 2492 T.MaskedInside(uint64(1), uint64(22)) 2493 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 2494 2495 T.ResetMask() 2496 T.MaskedOutside(uint64(1), uint64(22)) 2497 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 2498 2499 T.ResetMask() 2500 for i := 0; i < 5; i++ { 2501 T.MaskedEqual(uint64(i * 10)) 2502 } 2503 it := IteratorFromDense(T) 2504 2505 j := 0 2506 for _, err := it.Next(); err == nil; _, err = it.Next() { 2507 j++ 2508 } 2509 2510 it.Reset() 2511 assert.Equal(120, j) 2512 j = 0 2513 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 2514 j++ 2515 } 2516 it.Reset() 2517 assert.Equal(115, j) 2518 j = 0 2519 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 2520 j++ 2521 } 2522 it.Reset() 2523 assert.Equal(5, j) 2524 } 2525 func TestDense_MaskedGreaterEqual_F32(t *testing.T) { 2526 assert := assert.New(t) 2527 T := New(Of(Float32), WithShape(2, 3, 4, 5)) 2528 assert.False(T.IsMasked()) 2529 data := T.Float32s() 2530 for i := range data { 2531 data[i] = float32(i) 2532 } 2533 T.MaskedEqual(float32(0)) 2534 assert.True(T.IsMasked()) 2535 T.MaskedEqual(float32(1)) 2536 assert.True(T.mask[0] && T.mask[1]) 2537 T.MaskedNotEqual(float32(2)) 2538 assert.False(T.mask[2] && !(T.mask[0])) 2539 2540 T.ResetMask() 2541 T.MaskedInside(float32(1), float32(22)) 2542 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 2543 2544 T.ResetMask() 2545 T.MaskedOutside(float32(1), float32(22)) 2546 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 2547 2548 T.ResetMask() 2549 for i := 0; i < 5; i++ { 2550 T.MaskedEqual(float32(i * 10)) 2551 } 2552 it := IteratorFromDense(T) 2553 2554 j := 0 2555 for _, err := it.Next(); err == nil; _, err = it.Next() { 2556 j++ 2557 } 2558 2559 it.Reset() 2560 assert.Equal(120, j) 2561 j = 0 2562 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 2563 j++ 2564 } 2565 it.Reset() 2566 assert.Equal(115, j) 2567 j = 0 2568 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 2569 j++ 2570 } 2571 it.Reset() 2572 assert.Equal(5, j) 2573 } 2574 func TestDense_MaskedGreaterEqual_F64(t *testing.T) { 2575 assert := assert.New(t) 2576 T := New(Of(Float64), WithShape(2, 3, 4, 5)) 2577 assert.False(T.IsMasked()) 2578 data := T.Float64s() 2579 for i := range data { 2580 data[i] = float64(i) 2581 } 2582 T.MaskedEqual(float64(0)) 2583 assert.True(T.IsMasked()) 2584 T.MaskedEqual(float64(1)) 2585 assert.True(T.mask[0] && T.mask[1]) 2586 T.MaskedNotEqual(float64(2)) 2587 assert.False(T.mask[2] && !(T.mask[0])) 2588 2589 T.ResetMask() 2590 T.MaskedInside(float64(1), float64(22)) 2591 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 2592 2593 T.ResetMask() 2594 T.MaskedOutside(float64(1), float64(22)) 2595 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 2596 2597 T.ResetMask() 2598 for i := 0; i < 5; i++ { 2599 T.MaskedEqual(float64(i * 10)) 2600 } 2601 it := IteratorFromDense(T) 2602 2603 j := 0 2604 for _, err := it.Next(); err == nil; _, err = it.Next() { 2605 j++ 2606 } 2607 2608 it.Reset() 2609 assert.Equal(120, j) 2610 j = 0 2611 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 2612 j++ 2613 } 2614 it.Reset() 2615 assert.Equal(115, j) 2616 j = 0 2617 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 2618 j++ 2619 } 2620 it.Reset() 2621 assert.Equal(5, j) 2622 } 2623 func TestDense_MaskedGreaterEqual_Str(t *testing.T) { 2624 assert := assert.New(t) 2625 T := New(Of(String), WithShape(2, 3, 4, 5)) 2626 assert.False(T.IsMasked()) 2627 data := T.Strings() 2628 for i := range data { 2629 data[i] = fmt.Sprint(i) 2630 } 2631 T.MaskedEqual(fmt.Sprint(0)) 2632 assert.True(T.IsMasked()) 2633 T.MaskedEqual(fmt.Sprint(1)) 2634 assert.True(T.mask[0] && T.mask[1]) 2635 T.MaskedNotEqual(fmt.Sprint(2)) 2636 assert.False(T.mask[2] && !(T.mask[0])) 2637 2638 T.ResetMask() 2639 T.MaskedInside(fmt.Sprint(1), fmt.Sprint(22)) 2640 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 2641 2642 T.ResetMask() 2643 T.MaskedOutside(fmt.Sprint(1), fmt.Sprint(22)) 2644 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 2645 2646 T.ResetMask() 2647 for i := 0; i < 5; i++ { 2648 T.MaskedEqual(fmt.Sprint(i * 10)) 2649 } 2650 it := IteratorFromDense(T) 2651 2652 j := 0 2653 for _, err := it.Next(); err == nil; _, err = it.Next() { 2654 j++ 2655 } 2656 2657 it.Reset() 2658 assert.Equal(120, j) 2659 j = 0 2660 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 2661 j++ 2662 } 2663 it.Reset() 2664 assert.Equal(115, j) 2665 j = 0 2666 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 2667 j++ 2668 } 2669 it.Reset() 2670 assert.Equal(5, j) 2671 } 2672 2673 /* MaskedLess */ 2674 2675 func TestDense_MaskedLess_I(t *testing.T) { 2676 assert := assert.New(t) 2677 T := New(Of(Int), WithShape(2, 3, 4, 5)) 2678 assert.False(T.IsMasked()) 2679 data := T.Ints() 2680 for i := range data { 2681 data[i] = int(i) 2682 } 2683 T.MaskedEqual(int(0)) 2684 assert.True(T.IsMasked()) 2685 T.MaskedEqual(int(1)) 2686 assert.True(T.mask[0] && T.mask[1]) 2687 T.MaskedNotEqual(int(2)) 2688 assert.False(T.mask[2] && !(T.mask[0])) 2689 2690 T.ResetMask() 2691 T.MaskedInside(int(1), int(22)) 2692 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 2693 2694 T.ResetMask() 2695 T.MaskedOutside(int(1), int(22)) 2696 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 2697 2698 T.ResetMask() 2699 for i := 0; i < 5; i++ { 2700 T.MaskedEqual(int(i * 10)) 2701 } 2702 it := IteratorFromDense(T) 2703 2704 j := 0 2705 for _, err := it.Next(); err == nil; _, err = it.Next() { 2706 j++ 2707 } 2708 2709 it.Reset() 2710 assert.Equal(120, j) 2711 j = 0 2712 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 2713 j++ 2714 } 2715 it.Reset() 2716 assert.Equal(115, j) 2717 j = 0 2718 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 2719 j++ 2720 } 2721 it.Reset() 2722 assert.Equal(5, j) 2723 } 2724 func TestDense_MaskedLess_I8(t *testing.T) { 2725 assert := assert.New(t) 2726 T := New(Of(Int8), WithShape(2, 3, 4, 5)) 2727 assert.False(T.IsMasked()) 2728 data := T.Int8s() 2729 for i := range data { 2730 data[i] = int8(i) 2731 } 2732 T.MaskedEqual(int8(0)) 2733 assert.True(T.IsMasked()) 2734 T.MaskedEqual(int8(1)) 2735 assert.True(T.mask[0] && T.mask[1]) 2736 T.MaskedNotEqual(int8(2)) 2737 assert.False(T.mask[2] && !(T.mask[0])) 2738 2739 T.ResetMask() 2740 T.MaskedInside(int8(1), int8(22)) 2741 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 2742 2743 T.ResetMask() 2744 T.MaskedOutside(int8(1), int8(22)) 2745 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 2746 2747 T.ResetMask() 2748 for i := 0; i < 5; i++ { 2749 T.MaskedEqual(int8(i * 10)) 2750 } 2751 it := IteratorFromDense(T) 2752 2753 j := 0 2754 for _, err := it.Next(); err == nil; _, err = it.Next() { 2755 j++ 2756 } 2757 2758 it.Reset() 2759 assert.Equal(120, j) 2760 j = 0 2761 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 2762 j++ 2763 } 2764 it.Reset() 2765 assert.Equal(115, j) 2766 j = 0 2767 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 2768 j++ 2769 } 2770 it.Reset() 2771 assert.Equal(5, j) 2772 } 2773 func TestDense_MaskedLess_I16(t *testing.T) { 2774 assert := assert.New(t) 2775 T := New(Of(Int16), WithShape(2, 3, 4, 5)) 2776 assert.False(T.IsMasked()) 2777 data := T.Int16s() 2778 for i := range data { 2779 data[i] = int16(i) 2780 } 2781 T.MaskedEqual(int16(0)) 2782 assert.True(T.IsMasked()) 2783 T.MaskedEqual(int16(1)) 2784 assert.True(T.mask[0] && T.mask[1]) 2785 T.MaskedNotEqual(int16(2)) 2786 assert.False(T.mask[2] && !(T.mask[0])) 2787 2788 T.ResetMask() 2789 T.MaskedInside(int16(1), int16(22)) 2790 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 2791 2792 T.ResetMask() 2793 T.MaskedOutside(int16(1), int16(22)) 2794 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 2795 2796 T.ResetMask() 2797 for i := 0; i < 5; i++ { 2798 T.MaskedEqual(int16(i * 10)) 2799 } 2800 it := IteratorFromDense(T) 2801 2802 j := 0 2803 for _, err := it.Next(); err == nil; _, err = it.Next() { 2804 j++ 2805 } 2806 2807 it.Reset() 2808 assert.Equal(120, j) 2809 j = 0 2810 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 2811 j++ 2812 } 2813 it.Reset() 2814 assert.Equal(115, j) 2815 j = 0 2816 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 2817 j++ 2818 } 2819 it.Reset() 2820 assert.Equal(5, j) 2821 } 2822 func TestDense_MaskedLess_I32(t *testing.T) { 2823 assert := assert.New(t) 2824 T := New(Of(Int32), WithShape(2, 3, 4, 5)) 2825 assert.False(T.IsMasked()) 2826 data := T.Int32s() 2827 for i := range data { 2828 data[i] = int32(i) 2829 } 2830 T.MaskedEqual(int32(0)) 2831 assert.True(T.IsMasked()) 2832 T.MaskedEqual(int32(1)) 2833 assert.True(T.mask[0] && T.mask[1]) 2834 T.MaskedNotEqual(int32(2)) 2835 assert.False(T.mask[2] && !(T.mask[0])) 2836 2837 T.ResetMask() 2838 T.MaskedInside(int32(1), int32(22)) 2839 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 2840 2841 T.ResetMask() 2842 T.MaskedOutside(int32(1), int32(22)) 2843 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 2844 2845 T.ResetMask() 2846 for i := 0; i < 5; i++ { 2847 T.MaskedEqual(int32(i * 10)) 2848 } 2849 it := IteratorFromDense(T) 2850 2851 j := 0 2852 for _, err := it.Next(); err == nil; _, err = it.Next() { 2853 j++ 2854 } 2855 2856 it.Reset() 2857 assert.Equal(120, j) 2858 j = 0 2859 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 2860 j++ 2861 } 2862 it.Reset() 2863 assert.Equal(115, j) 2864 j = 0 2865 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 2866 j++ 2867 } 2868 it.Reset() 2869 assert.Equal(5, j) 2870 } 2871 func TestDense_MaskedLess_I64(t *testing.T) { 2872 assert := assert.New(t) 2873 T := New(Of(Int64), WithShape(2, 3, 4, 5)) 2874 assert.False(T.IsMasked()) 2875 data := T.Int64s() 2876 for i := range data { 2877 data[i] = int64(i) 2878 } 2879 T.MaskedEqual(int64(0)) 2880 assert.True(T.IsMasked()) 2881 T.MaskedEqual(int64(1)) 2882 assert.True(T.mask[0] && T.mask[1]) 2883 T.MaskedNotEqual(int64(2)) 2884 assert.False(T.mask[2] && !(T.mask[0])) 2885 2886 T.ResetMask() 2887 T.MaskedInside(int64(1), int64(22)) 2888 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 2889 2890 T.ResetMask() 2891 T.MaskedOutside(int64(1), int64(22)) 2892 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 2893 2894 T.ResetMask() 2895 for i := 0; i < 5; i++ { 2896 T.MaskedEqual(int64(i * 10)) 2897 } 2898 it := IteratorFromDense(T) 2899 2900 j := 0 2901 for _, err := it.Next(); err == nil; _, err = it.Next() { 2902 j++ 2903 } 2904 2905 it.Reset() 2906 assert.Equal(120, j) 2907 j = 0 2908 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 2909 j++ 2910 } 2911 it.Reset() 2912 assert.Equal(115, j) 2913 j = 0 2914 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 2915 j++ 2916 } 2917 it.Reset() 2918 assert.Equal(5, j) 2919 } 2920 func TestDense_MaskedLess_U(t *testing.T) { 2921 assert := assert.New(t) 2922 T := New(Of(Uint), WithShape(2, 3, 4, 5)) 2923 assert.False(T.IsMasked()) 2924 data := T.Uints() 2925 for i := range data { 2926 data[i] = uint(i) 2927 } 2928 T.MaskedEqual(uint(0)) 2929 assert.True(T.IsMasked()) 2930 T.MaskedEqual(uint(1)) 2931 assert.True(T.mask[0] && T.mask[1]) 2932 T.MaskedNotEqual(uint(2)) 2933 assert.False(T.mask[2] && !(T.mask[0])) 2934 2935 T.ResetMask() 2936 T.MaskedInside(uint(1), uint(22)) 2937 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 2938 2939 T.ResetMask() 2940 T.MaskedOutside(uint(1), uint(22)) 2941 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 2942 2943 T.ResetMask() 2944 for i := 0; i < 5; i++ { 2945 T.MaskedEqual(uint(i * 10)) 2946 } 2947 it := IteratorFromDense(T) 2948 2949 j := 0 2950 for _, err := it.Next(); err == nil; _, err = it.Next() { 2951 j++ 2952 } 2953 2954 it.Reset() 2955 assert.Equal(120, j) 2956 j = 0 2957 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 2958 j++ 2959 } 2960 it.Reset() 2961 assert.Equal(115, j) 2962 j = 0 2963 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 2964 j++ 2965 } 2966 it.Reset() 2967 assert.Equal(5, j) 2968 } 2969 func TestDense_MaskedLess_U8(t *testing.T) { 2970 assert := assert.New(t) 2971 T := New(Of(Uint8), WithShape(2, 3, 4, 5)) 2972 assert.False(T.IsMasked()) 2973 data := T.Uint8s() 2974 for i := range data { 2975 data[i] = uint8(i) 2976 } 2977 T.MaskedEqual(uint8(0)) 2978 assert.True(T.IsMasked()) 2979 T.MaskedEqual(uint8(1)) 2980 assert.True(T.mask[0] && T.mask[1]) 2981 T.MaskedNotEqual(uint8(2)) 2982 assert.False(T.mask[2] && !(T.mask[0])) 2983 2984 T.ResetMask() 2985 T.MaskedInside(uint8(1), uint8(22)) 2986 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 2987 2988 T.ResetMask() 2989 T.MaskedOutside(uint8(1), uint8(22)) 2990 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 2991 2992 T.ResetMask() 2993 for i := 0; i < 5; i++ { 2994 T.MaskedEqual(uint8(i * 10)) 2995 } 2996 it := IteratorFromDense(T) 2997 2998 j := 0 2999 for _, err := it.Next(); err == nil; _, err = it.Next() { 3000 j++ 3001 } 3002 3003 it.Reset() 3004 assert.Equal(120, j) 3005 j = 0 3006 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 3007 j++ 3008 } 3009 it.Reset() 3010 assert.Equal(115, j) 3011 j = 0 3012 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 3013 j++ 3014 } 3015 it.Reset() 3016 assert.Equal(5, j) 3017 } 3018 func TestDense_MaskedLess_U16(t *testing.T) { 3019 assert := assert.New(t) 3020 T := New(Of(Uint16), WithShape(2, 3, 4, 5)) 3021 assert.False(T.IsMasked()) 3022 data := T.Uint16s() 3023 for i := range data { 3024 data[i] = uint16(i) 3025 } 3026 T.MaskedEqual(uint16(0)) 3027 assert.True(T.IsMasked()) 3028 T.MaskedEqual(uint16(1)) 3029 assert.True(T.mask[0] && T.mask[1]) 3030 T.MaskedNotEqual(uint16(2)) 3031 assert.False(T.mask[2] && !(T.mask[0])) 3032 3033 T.ResetMask() 3034 T.MaskedInside(uint16(1), uint16(22)) 3035 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 3036 3037 T.ResetMask() 3038 T.MaskedOutside(uint16(1), uint16(22)) 3039 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 3040 3041 T.ResetMask() 3042 for i := 0; i < 5; i++ { 3043 T.MaskedEqual(uint16(i * 10)) 3044 } 3045 it := IteratorFromDense(T) 3046 3047 j := 0 3048 for _, err := it.Next(); err == nil; _, err = it.Next() { 3049 j++ 3050 } 3051 3052 it.Reset() 3053 assert.Equal(120, j) 3054 j = 0 3055 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 3056 j++ 3057 } 3058 it.Reset() 3059 assert.Equal(115, j) 3060 j = 0 3061 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 3062 j++ 3063 } 3064 it.Reset() 3065 assert.Equal(5, j) 3066 } 3067 func TestDense_MaskedLess_U32(t *testing.T) { 3068 assert := assert.New(t) 3069 T := New(Of(Uint32), WithShape(2, 3, 4, 5)) 3070 assert.False(T.IsMasked()) 3071 data := T.Uint32s() 3072 for i := range data { 3073 data[i] = uint32(i) 3074 } 3075 T.MaskedEqual(uint32(0)) 3076 assert.True(T.IsMasked()) 3077 T.MaskedEqual(uint32(1)) 3078 assert.True(T.mask[0] && T.mask[1]) 3079 T.MaskedNotEqual(uint32(2)) 3080 assert.False(T.mask[2] && !(T.mask[0])) 3081 3082 T.ResetMask() 3083 T.MaskedInside(uint32(1), uint32(22)) 3084 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 3085 3086 T.ResetMask() 3087 T.MaskedOutside(uint32(1), uint32(22)) 3088 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 3089 3090 T.ResetMask() 3091 for i := 0; i < 5; i++ { 3092 T.MaskedEqual(uint32(i * 10)) 3093 } 3094 it := IteratorFromDense(T) 3095 3096 j := 0 3097 for _, err := it.Next(); err == nil; _, err = it.Next() { 3098 j++ 3099 } 3100 3101 it.Reset() 3102 assert.Equal(120, j) 3103 j = 0 3104 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 3105 j++ 3106 } 3107 it.Reset() 3108 assert.Equal(115, j) 3109 j = 0 3110 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 3111 j++ 3112 } 3113 it.Reset() 3114 assert.Equal(5, j) 3115 } 3116 func TestDense_MaskedLess_U64(t *testing.T) { 3117 assert := assert.New(t) 3118 T := New(Of(Uint64), WithShape(2, 3, 4, 5)) 3119 assert.False(T.IsMasked()) 3120 data := T.Uint64s() 3121 for i := range data { 3122 data[i] = uint64(i) 3123 } 3124 T.MaskedEqual(uint64(0)) 3125 assert.True(T.IsMasked()) 3126 T.MaskedEqual(uint64(1)) 3127 assert.True(T.mask[0] && T.mask[1]) 3128 T.MaskedNotEqual(uint64(2)) 3129 assert.False(T.mask[2] && !(T.mask[0])) 3130 3131 T.ResetMask() 3132 T.MaskedInside(uint64(1), uint64(22)) 3133 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 3134 3135 T.ResetMask() 3136 T.MaskedOutside(uint64(1), uint64(22)) 3137 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 3138 3139 T.ResetMask() 3140 for i := 0; i < 5; i++ { 3141 T.MaskedEqual(uint64(i * 10)) 3142 } 3143 it := IteratorFromDense(T) 3144 3145 j := 0 3146 for _, err := it.Next(); err == nil; _, err = it.Next() { 3147 j++ 3148 } 3149 3150 it.Reset() 3151 assert.Equal(120, j) 3152 j = 0 3153 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 3154 j++ 3155 } 3156 it.Reset() 3157 assert.Equal(115, j) 3158 j = 0 3159 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 3160 j++ 3161 } 3162 it.Reset() 3163 assert.Equal(5, j) 3164 } 3165 func TestDense_MaskedLess_F32(t *testing.T) { 3166 assert := assert.New(t) 3167 T := New(Of(Float32), WithShape(2, 3, 4, 5)) 3168 assert.False(T.IsMasked()) 3169 data := T.Float32s() 3170 for i := range data { 3171 data[i] = float32(i) 3172 } 3173 T.MaskedEqual(float32(0)) 3174 assert.True(T.IsMasked()) 3175 T.MaskedEqual(float32(1)) 3176 assert.True(T.mask[0] && T.mask[1]) 3177 T.MaskedNotEqual(float32(2)) 3178 assert.False(T.mask[2] && !(T.mask[0])) 3179 3180 T.ResetMask() 3181 T.MaskedInside(float32(1), float32(22)) 3182 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 3183 3184 T.ResetMask() 3185 T.MaskedOutside(float32(1), float32(22)) 3186 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 3187 3188 T.ResetMask() 3189 for i := 0; i < 5; i++ { 3190 T.MaskedEqual(float32(i * 10)) 3191 } 3192 it := IteratorFromDense(T) 3193 3194 j := 0 3195 for _, err := it.Next(); err == nil; _, err = it.Next() { 3196 j++ 3197 } 3198 3199 it.Reset() 3200 assert.Equal(120, j) 3201 j = 0 3202 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 3203 j++ 3204 } 3205 it.Reset() 3206 assert.Equal(115, j) 3207 j = 0 3208 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 3209 j++ 3210 } 3211 it.Reset() 3212 assert.Equal(5, j) 3213 } 3214 func TestDense_MaskedLess_F64(t *testing.T) { 3215 assert := assert.New(t) 3216 T := New(Of(Float64), WithShape(2, 3, 4, 5)) 3217 assert.False(T.IsMasked()) 3218 data := T.Float64s() 3219 for i := range data { 3220 data[i] = float64(i) 3221 } 3222 T.MaskedEqual(float64(0)) 3223 assert.True(T.IsMasked()) 3224 T.MaskedEqual(float64(1)) 3225 assert.True(T.mask[0] && T.mask[1]) 3226 T.MaskedNotEqual(float64(2)) 3227 assert.False(T.mask[2] && !(T.mask[0])) 3228 3229 T.ResetMask() 3230 T.MaskedInside(float64(1), float64(22)) 3231 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 3232 3233 T.ResetMask() 3234 T.MaskedOutside(float64(1), float64(22)) 3235 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 3236 3237 T.ResetMask() 3238 for i := 0; i < 5; i++ { 3239 T.MaskedEqual(float64(i * 10)) 3240 } 3241 it := IteratorFromDense(T) 3242 3243 j := 0 3244 for _, err := it.Next(); err == nil; _, err = it.Next() { 3245 j++ 3246 } 3247 3248 it.Reset() 3249 assert.Equal(120, j) 3250 j = 0 3251 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 3252 j++ 3253 } 3254 it.Reset() 3255 assert.Equal(115, j) 3256 j = 0 3257 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 3258 j++ 3259 } 3260 it.Reset() 3261 assert.Equal(5, j) 3262 } 3263 func TestDense_MaskedLess_Str(t *testing.T) { 3264 assert := assert.New(t) 3265 T := New(Of(String), WithShape(2, 3, 4, 5)) 3266 assert.False(T.IsMasked()) 3267 data := T.Strings() 3268 for i := range data { 3269 data[i] = fmt.Sprint(i) 3270 } 3271 T.MaskedEqual(fmt.Sprint(0)) 3272 assert.True(T.IsMasked()) 3273 T.MaskedEqual(fmt.Sprint(1)) 3274 assert.True(T.mask[0] && T.mask[1]) 3275 T.MaskedNotEqual(fmt.Sprint(2)) 3276 assert.False(T.mask[2] && !(T.mask[0])) 3277 3278 T.ResetMask() 3279 T.MaskedInside(fmt.Sprint(1), fmt.Sprint(22)) 3280 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 3281 3282 T.ResetMask() 3283 T.MaskedOutside(fmt.Sprint(1), fmt.Sprint(22)) 3284 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 3285 3286 T.ResetMask() 3287 for i := 0; i < 5; i++ { 3288 T.MaskedEqual(fmt.Sprint(i * 10)) 3289 } 3290 it := IteratorFromDense(T) 3291 3292 j := 0 3293 for _, err := it.Next(); err == nil; _, err = it.Next() { 3294 j++ 3295 } 3296 3297 it.Reset() 3298 assert.Equal(120, j) 3299 j = 0 3300 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 3301 j++ 3302 } 3303 it.Reset() 3304 assert.Equal(115, j) 3305 j = 0 3306 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 3307 j++ 3308 } 3309 it.Reset() 3310 assert.Equal(5, j) 3311 } 3312 3313 /* MaskedLessEqual */ 3314 3315 func TestDense_MaskedLessEqual_I(t *testing.T) { 3316 assert := assert.New(t) 3317 T := New(Of(Int), WithShape(2, 3, 4, 5)) 3318 assert.False(T.IsMasked()) 3319 data := T.Ints() 3320 for i := range data { 3321 data[i] = int(i) 3322 } 3323 T.MaskedEqual(int(0)) 3324 assert.True(T.IsMasked()) 3325 T.MaskedEqual(int(1)) 3326 assert.True(T.mask[0] && T.mask[1]) 3327 T.MaskedNotEqual(int(2)) 3328 assert.False(T.mask[2] && !(T.mask[0])) 3329 3330 T.ResetMask() 3331 T.MaskedInside(int(1), int(22)) 3332 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 3333 3334 T.ResetMask() 3335 T.MaskedOutside(int(1), int(22)) 3336 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 3337 3338 T.ResetMask() 3339 for i := 0; i < 5; i++ { 3340 T.MaskedEqual(int(i * 10)) 3341 } 3342 it := IteratorFromDense(T) 3343 3344 j := 0 3345 for _, err := it.Next(); err == nil; _, err = it.Next() { 3346 j++ 3347 } 3348 3349 it.Reset() 3350 assert.Equal(120, j) 3351 j = 0 3352 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 3353 j++ 3354 } 3355 it.Reset() 3356 assert.Equal(115, j) 3357 j = 0 3358 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 3359 j++ 3360 } 3361 it.Reset() 3362 assert.Equal(5, j) 3363 } 3364 func TestDense_MaskedLessEqual_I8(t *testing.T) { 3365 assert := assert.New(t) 3366 T := New(Of(Int8), WithShape(2, 3, 4, 5)) 3367 assert.False(T.IsMasked()) 3368 data := T.Int8s() 3369 for i := range data { 3370 data[i] = int8(i) 3371 } 3372 T.MaskedEqual(int8(0)) 3373 assert.True(T.IsMasked()) 3374 T.MaskedEqual(int8(1)) 3375 assert.True(T.mask[0] && T.mask[1]) 3376 T.MaskedNotEqual(int8(2)) 3377 assert.False(T.mask[2] && !(T.mask[0])) 3378 3379 T.ResetMask() 3380 T.MaskedInside(int8(1), int8(22)) 3381 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 3382 3383 T.ResetMask() 3384 T.MaskedOutside(int8(1), int8(22)) 3385 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 3386 3387 T.ResetMask() 3388 for i := 0; i < 5; i++ { 3389 T.MaskedEqual(int8(i * 10)) 3390 } 3391 it := IteratorFromDense(T) 3392 3393 j := 0 3394 for _, err := it.Next(); err == nil; _, err = it.Next() { 3395 j++ 3396 } 3397 3398 it.Reset() 3399 assert.Equal(120, j) 3400 j = 0 3401 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 3402 j++ 3403 } 3404 it.Reset() 3405 assert.Equal(115, j) 3406 j = 0 3407 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 3408 j++ 3409 } 3410 it.Reset() 3411 assert.Equal(5, j) 3412 } 3413 func TestDense_MaskedLessEqual_I16(t *testing.T) { 3414 assert := assert.New(t) 3415 T := New(Of(Int16), WithShape(2, 3, 4, 5)) 3416 assert.False(T.IsMasked()) 3417 data := T.Int16s() 3418 for i := range data { 3419 data[i] = int16(i) 3420 } 3421 T.MaskedEqual(int16(0)) 3422 assert.True(T.IsMasked()) 3423 T.MaskedEqual(int16(1)) 3424 assert.True(T.mask[0] && T.mask[1]) 3425 T.MaskedNotEqual(int16(2)) 3426 assert.False(T.mask[2] && !(T.mask[0])) 3427 3428 T.ResetMask() 3429 T.MaskedInside(int16(1), int16(22)) 3430 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 3431 3432 T.ResetMask() 3433 T.MaskedOutside(int16(1), int16(22)) 3434 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 3435 3436 T.ResetMask() 3437 for i := 0; i < 5; i++ { 3438 T.MaskedEqual(int16(i * 10)) 3439 } 3440 it := IteratorFromDense(T) 3441 3442 j := 0 3443 for _, err := it.Next(); err == nil; _, err = it.Next() { 3444 j++ 3445 } 3446 3447 it.Reset() 3448 assert.Equal(120, j) 3449 j = 0 3450 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 3451 j++ 3452 } 3453 it.Reset() 3454 assert.Equal(115, j) 3455 j = 0 3456 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 3457 j++ 3458 } 3459 it.Reset() 3460 assert.Equal(5, j) 3461 } 3462 func TestDense_MaskedLessEqual_I32(t *testing.T) { 3463 assert := assert.New(t) 3464 T := New(Of(Int32), WithShape(2, 3, 4, 5)) 3465 assert.False(T.IsMasked()) 3466 data := T.Int32s() 3467 for i := range data { 3468 data[i] = int32(i) 3469 } 3470 T.MaskedEqual(int32(0)) 3471 assert.True(T.IsMasked()) 3472 T.MaskedEqual(int32(1)) 3473 assert.True(T.mask[0] && T.mask[1]) 3474 T.MaskedNotEqual(int32(2)) 3475 assert.False(T.mask[2] && !(T.mask[0])) 3476 3477 T.ResetMask() 3478 T.MaskedInside(int32(1), int32(22)) 3479 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 3480 3481 T.ResetMask() 3482 T.MaskedOutside(int32(1), int32(22)) 3483 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 3484 3485 T.ResetMask() 3486 for i := 0; i < 5; i++ { 3487 T.MaskedEqual(int32(i * 10)) 3488 } 3489 it := IteratorFromDense(T) 3490 3491 j := 0 3492 for _, err := it.Next(); err == nil; _, err = it.Next() { 3493 j++ 3494 } 3495 3496 it.Reset() 3497 assert.Equal(120, j) 3498 j = 0 3499 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 3500 j++ 3501 } 3502 it.Reset() 3503 assert.Equal(115, j) 3504 j = 0 3505 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 3506 j++ 3507 } 3508 it.Reset() 3509 assert.Equal(5, j) 3510 } 3511 func TestDense_MaskedLessEqual_I64(t *testing.T) { 3512 assert := assert.New(t) 3513 T := New(Of(Int64), WithShape(2, 3, 4, 5)) 3514 assert.False(T.IsMasked()) 3515 data := T.Int64s() 3516 for i := range data { 3517 data[i] = int64(i) 3518 } 3519 T.MaskedEqual(int64(0)) 3520 assert.True(T.IsMasked()) 3521 T.MaskedEqual(int64(1)) 3522 assert.True(T.mask[0] && T.mask[1]) 3523 T.MaskedNotEqual(int64(2)) 3524 assert.False(T.mask[2] && !(T.mask[0])) 3525 3526 T.ResetMask() 3527 T.MaskedInside(int64(1), int64(22)) 3528 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 3529 3530 T.ResetMask() 3531 T.MaskedOutside(int64(1), int64(22)) 3532 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 3533 3534 T.ResetMask() 3535 for i := 0; i < 5; i++ { 3536 T.MaskedEqual(int64(i * 10)) 3537 } 3538 it := IteratorFromDense(T) 3539 3540 j := 0 3541 for _, err := it.Next(); err == nil; _, err = it.Next() { 3542 j++ 3543 } 3544 3545 it.Reset() 3546 assert.Equal(120, j) 3547 j = 0 3548 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 3549 j++ 3550 } 3551 it.Reset() 3552 assert.Equal(115, j) 3553 j = 0 3554 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 3555 j++ 3556 } 3557 it.Reset() 3558 assert.Equal(5, j) 3559 } 3560 func TestDense_MaskedLessEqual_U(t *testing.T) { 3561 assert := assert.New(t) 3562 T := New(Of(Uint), WithShape(2, 3, 4, 5)) 3563 assert.False(T.IsMasked()) 3564 data := T.Uints() 3565 for i := range data { 3566 data[i] = uint(i) 3567 } 3568 T.MaskedEqual(uint(0)) 3569 assert.True(T.IsMasked()) 3570 T.MaskedEqual(uint(1)) 3571 assert.True(T.mask[0] && T.mask[1]) 3572 T.MaskedNotEqual(uint(2)) 3573 assert.False(T.mask[2] && !(T.mask[0])) 3574 3575 T.ResetMask() 3576 T.MaskedInside(uint(1), uint(22)) 3577 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 3578 3579 T.ResetMask() 3580 T.MaskedOutside(uint(1), uint(22)) 3581 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 3582 3583 T.ResetMask() 3584 for i := 0; i < 5; i++ { 3585 T.MaskedEqual(uint(i * 10)) 3586 } 3587 it := IteratorFromDense(T) 3588 3589 j := 0 3590 for _, err := it.Next(); err == nil; _, err = it.Next() { 3591 j++ 3592 } 3593 3594 it.Reset() 3595 assert.Equal(120, j) 3596 j = 0 3597 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 3598 j++ 3599 } 3600 it.Reset() 3601 assert.Equal(115, j) 3602 j = 0 3603 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 3604 j++ 3605 } 3606 it.Reset() 3607 assert.Equal(5, j) 3608 } 3609 func TestDense_MaskedLessEqual_U8(t *testing.T) { 3610 assert := assert.New(t) 3611 T := New(Of(Uint8), WithShape(2, 3, 4, 5)) 3612 assert.False(T.IsMasked()) 3613 data := T.Uint8s() 3614 for i := range data { 3615 data[i] = uint8(i) 3616 } 3617 T.MaskedEqual(uint8(0)) 3618 assert.True(T.IsMasked()) 3619 T.MaskedEqual(uint8(1)) 3620 assert.True(T.mask[0] && T.mask[1]) 3621 T.MaskedNotEqual(uint8(2)) 3622 assert.False(T.mask[2] && !(T.mask[0])) 3623 3624 T.ResetMask() 3625 T.MaskedInside(uint8(1), uint8(22)) 3626 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 3627 3628 T.ResetMask() 3629 T.MaskedOutside(uint8(1), uint8(22)) 3630 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 3631 3632 T.ResetMask() 3633 for i := 0; i < 5; i++ { 3634 T.MaskedEqual(uint8(i * 10)) 3635 } 3636 it := IteratorFromDense(T) 3637 3638 j := 0 3639 for _, err := it.Next(); err == nil; _, err = it.Next() { 3640 j++ 3641 } 3642 3643 it.Reset() 3644 assert.Equal(120, j) 3645 j = 0 3646 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 3647 j++ 3648 } 3649 it.Reset() 3650 assert.Equal(115, j) 3651 j = 0 3652 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 3653 j++ 3654 } 3655 it.Reset() 3656 assert.Equal(5, j) 3657 } 3658 func TestDense_MaskedLessEqual_U16(t *testing.T) { 3659 assert := assert.New(t) 3660 T := New(Of(Uint16), WithShape(2, 3, 4, 5)) 3661 assert.False(T.IsMasked()) 3662 data := T.Uint16s() 3663 for i := range data { 3664 data[i] = uint16(i) 3665 } 3666 T.MaskedEqual(uint16(0)) 3667 assert.True(T.IsMasked()) 3668 T.MaskedEqual(uint16(1)) 3669 assert.True(T.mask[0] && T.mask[1]) 3670 T.MaskedNotEqual(uint16(2)) 3671 assert.False(T.mask[2] && !(T.mask[0])) 3672 3673 T.ResetMask() 3674 T.MaskedInside(uint16(1), uint16(22)) 3675 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 3676 3677 T.ResetMask() 3678 T.MaskedOutside(uint16(1), uint16(22)) 3679 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 3680 3681 T.ResetMask() 3682 for i := 0; i < 5; i++ { 3683 T.MaskedEqual(uint16(i * 10)) 3684 } 3685 it := IteratorFromDense(T) 3686 3687 j := 0 3688 for _, err := it.Next(); err == nil; _, err = it.Next() { 3689 j++ 3690 } 3691 3692 it.Reset() 3693 assert.Equal(120, j) 3694 j = 0 3695 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 3696 j++ 3697 } 3698 it.Reset() 3699 assert.Equal(115, j) 3700 j = 0 3701 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 3702 j++ 3703 } 3704 it.Reset() 3705 assert.Equal(5, j) 3706 } 3707 func TestDense_MaskedLessEqual_U32(t *testing.T) { 3708 assert := assert.New(t) 3709 T := New(Of(Uint32), WithShape(2, 3, 4, 5)) 3710 assert.False(T.IsMasked()) 3711 data := T.Uint32s() 3712 for i := range data { 3713 data[i] = uint32(i) 3714 } 3715 T.MaskedEqual(uint32(0)) 3716 assert.True(T.IsMasked()) 3717 T.MaskedEqual(uint32(1)) 3718 assert.True(T.mask[0] && T.mask[1]) 3719 T.MaskedNotEqual(uint32(2)) 3720 assert.False(T.mask[2] && !(T.mask[0])) 3721 3722 T.ResetMask() 3723 T.MaskedInside(uint32(1), uint32(22)) 3724 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 3725 3726 T.ResetMask() 3727 T.MaskedOutside(uint32(1), uint32(22)) 3728 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 3729 3730 T.ResetMask() 3731 for i := 0; i < 5; i++ { 3732 T.MaskedEqual(uint32(i * 10)) 3733 } 3734 it := IteratorFromDense(T) 3735 3736 j := 0 3737 for _, err := it.Next(); err == nil; _, err = it.Next() { 3738 j++ 3739 } 3740 3741 it.Reset() 3742 assert.Equal(120, j) 3743 j = 0 3744 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 3745 j++ 3746 } 3747 it.Reset() 3748 assert.Equal(115, j) 3749 j = 0 3750 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 3751 j++ 3752 } 3753 it.Reset() 3754 assert.Equal(5, j) 3755 } 3756 func TestDense_MaskedLessEqual_U64(t *testing.T) { 3757 assert := assert.New(t) 3758 T := New(Of(Uint64), WithShape(2, 3, 4, 5)) 3759 assert.False(T.IsMasked()) 3760 data := T.Uint64s() 3761 for i := range data { 3762 data[i] = uint64(i) 3763 } 3764 T.MaskedEqual(uint64(0)) 3765 assert.True(T.IsMasked()) 3766 T.MaskedEqual(uint64(1)) 3767 assert.True(T.mask[0] && T.mask[1]) 3768 T.MaskedNotEqual(uint64(2)) 3769 assert.False(T.mask[2] && !(T.mask[0])) 3770 3771 T.ResetMask() 3772 T.MaskedInside(uint64(1), uint64(22)) 3773 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 3774 3775 T.ResetMask() 3776 T.MaskedOutside(uint64(1), uint64(22)) 3777 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 3778 3779 T.ResetMask() 3780 for i := 0; i < 5; i++ { 3781 T.MaskedEqual(uint64(i * 10)) 3782 } 3783 it := IteratorFromDense(T) 3784 3785 j := 0 3786 for _, err := it.Next(); err == nil; _, err = it.Next() { 3787 j++ 3788 } 3789 3790 it.Reset() 3791 assert.Equal(120, j) 3792 j = 0 3793 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 3794 j++ 3795 } 3796 it.Reset() 3797 assert.Equal(115, j) 3798 j = 0 3799 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 3800 j++ 3801 } 3802 it.Reset() 3803 assert.Equal(5, j) 3804 } 3805 func TestDense_MaskedLessEqual_F32(t *testing.T) { 3806 assert := assert.New(t) 3807 T := New(Of(Float32), WithShape(2, 3, 4, 5)) 3808 assert.False(T.IsMasked()) 3809 data := T.Float32s() 3810 for i := range data { 3811 data[i] = float32(i) 3812 } 3813 T.MaskedEqual(float32(0)) 3814 assert.True(T.IsMasked()) 3815 T.MaskedEqual(float32(1)) 3816 assert.True(T.mask[0] && T.mask[1]) 3817 T.MaskedNotEqual(float32(2)) 3818 assert.False(T.mask[2] && !(T.mask[0])) 3819 3820 T.ResetMask() 3821 T.MaskedInside(float32(1), float32(22)) 3822 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 3823 3824 T.ResetMask() 3825 T.MaskedOutside(float32(1), float32(22)) 3826 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 3827 3828 T.ResetMask() 3829 for i := 0; i < 5; i++ { 3830 T.MaskedEqual(float32(i * 10)) 3831 } 3832 it := IteratorFromDense(T) 3833 3834 j := 0 3835 for _, err := it.Next(); err == nil; _, err = it.Next() { 3836 j++ 3837 } 3838 3839 it.Reset() 3840 assert.Equal(120, j) 3841 j = 0 3842 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 3843 j++ 3844 } 3845 it.Reset() 3846 assert.Equal(115, j) 3847 j = 0 3848 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 3849 j++ 3850 } 3851 it.Reset() 3852 assert.Equal(5, j) 3853 } 3854 func TestDense_MaskedLessEqual_F64(t *testing.T) { 3855 assert := assert.New(t) 3856 T := New(Of(Float64), WithShape(2, 3, 4, 5)) 3857 assert.False(T.IsMasked()) 3858 data := T.Float64s() 3859 for i := range data { 3860 data[i] = float64(i) 3861 } 3862 T.MaskedEqual(float64(0)) 3863 assert.True(T.IsMasked()) 3864 T.MaskedEqual(float64(1)) 3865 assert.True(T.mask[0] && T.mask[1]) 3866 T.MaskedNotEqual(float64(2)) 3867 assert.False(T.mask[2] && !(T.mask[0])) 3868 3869 T.ResetMask() 3870 T.MaskedInside(float64(1), float64(22)) 3871 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 3872 3873 T.ResetMask() 3874 T.MaskedOutside(float64(1), float64(22)) 3875 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 3876 3877 T.ResetMask() 3878 for i := 0; i < 5; i++ { 3879 T.MaskedEqual(float64(i * 10)) 3880 } 3881 it := IteratorFromDense(T) 3882 3883 j := 0 3884 for _, err := it.Next(); err == nil; _, err = it.Next() { 3885 j++ 3886 } 3887 3888 it.Reset() 3889 assert.Equal(120, j) 3890 j = 0 3891 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 3892 j++ 3893 } 3894 it.Reset() 3895 assert.Equal(115, j) 3896 j = 0 3897 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 3898 j++ 3899 } 3900 it.Reset() 3901 assert.Equal(5, j) 3902 } 3903 func TestDense_MaskedLessEqual_Str(t *testing.T) { 3904 assert := assert.New(t) 3905 T := New(Of(String), WithShape(2, 3, 4, 5)) 3906 assert.False(T.IsMasked()) 3907 data := T.Strings() 3908 for i := range data { 3909 data[i] = fmt.Sprint(i) 3910 } 3911 T.MaskedEqual(fmt.Sprint(0)) 3912 assert.True(T.IsMasked()) 3913 T.MaskedEqual(fmt.Sprint(1)) 3914 assert.True(T.mask[0] && T.mask[1]) 3915 T.MaskedNotEqual(fmt.Sprint(2)) 3916 assert.False(T.mask[2] && !(T.mask[0])) 3917 3918 T.ResetMask() 3919 T.MaskedInside(fmt.Sprint(1), fmt.Sprint(22)) 3920 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 3921 3922 T.ResetMask() 3923 T.MaskedOutside(fmt.Sprint(1), fmt.Sprint(22)) 3924 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 3925 3926 T.ResetMask() 3927 for i := 0; i < 5; i++ { 3928 T.MaskedEqual(fmt.Sprint(i * 10)) 3929 } 3930 it := IteratorFromDense(T) 3931 3932 j := 0 3933 for _, err := it.Next(); err == nil; _, err = it.Next() { 3934 j++ 3935 } 3936 3937 it.Reset() 3938 assert.Equal(120, j) 3939 j = 0 3940 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 3941 j++ 3942 } 3943 it.Reset() 3944 assert.Equal(115, j) 3945 j = 0 3946 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 3947 j++ 3948 } 3949 it.Reset() 3950 assert.Equal(5, j) 3951 } 3952 3953 /* MaskedInside */ 3954 3955 func TestDense_MaskedInside_I(t *testing.T) { 3956 assert := assert.New(t) 3957 T := New(Of(Int), WithShape(2, 3, 4, 5)) 3958 assert.False(T.IsMasked()) 3959 data := T.Ints() 3960 for i := range data { 3961 data[i] = int(i) 3962 } 3963 T.MaskedEqual(int(0)) 3964 assert.True(T.IsMasked()) 3965 T.MaskedEqual(int(1)) 3966 assert.True(T.mask[0] && T.mask[1]) 3967 T.MaskedNotEqual(int(2)) 3968 assert.False(T.mask[2] && !(T.mask[0])) 3969 3970 T.ResetMask() 3971 T.MaskedInside(int(1), int(22)) 3972 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 3973 3974 T.ResetMask() 3975 T.MaskedOutside(int(1), int(22)) 3976 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 3977 3978 T.ResetMask() 3979 for i := 0; i < 5; i++ { 3980 T.MaskedEqual(int(i * 10)) 3981 } 3982 it := IteratorFromDense(T) 3983 3984 j := 0 3985 for _, err := it.Next(); err == nil; _, err = it.Next() { 3986 j++ 3987 } 3988 3989 it.Reset() 3990 assert.Equal(120, j) 3991 j = 0 3992 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 3993 j++ 3994 } 3995 it.Reset() 3996 assert.Equal(115, j) 3997 j = 0 3998 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 3999 j++ 4000 } 4001 it.Reset() 4002 assert.Equal(5, j) 4003 } 4004 func TestDense_MaskedInside_I8(t *testing.T) { 4005 assert := assert.New(t) 4006 T := New(Of(Int8), WithShape(2, 3, 4, 5)) 4007 assert.False(T.IsMasked()) 4008 data := T.Int8s() 4009 for i := range data { 4010 data[i] = int8(i) 4011 } 4012 T.MaskedEqual(int8(0)) 4013 assert.True(T.IsMasked()) 4014 T.MaskedEqual(int8(1)) 4015 assert.True(T.mask[0] && T.mask[1]) 4016 T.MaskedNotEqual(int8(2)) 4017 assert.False(T.mask[2] && !(T.mask[0])) 4018 4019 T.ResetMask() 4020 T.MaskedInside(int8(1), int8(22)) 4021 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 4022 4023 T.ResetMask() 4024 T.MaskedOutside(int8(1), int8(22)) 4025 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 4026 4027 T.ResetMask() 4028 for i := 0; i < 5; i++ { 4029 T.MaskedEqual(int8(i * 10)) 4030 } 4031 it := IteratorFromDense(T) 4032 4033 j := 0 4034 for _, err := it.Next(); err == nil; _, err = it.Next() { 4035 j++ 4036 } 4037 4038 it.Reset() 4039 assert.Equal(120, j) 4040 j = 0 4041 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 4042 j++ 4043 } 4044 it.Reset() 4045 assert.Equal(115, j) 4046 j = 0 4047 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 4048 j++ 4049 } 4050 it.Reset() 4051 assert.Equal(5, j) 4052 } 4053 func TestDense_MaskedInside_I16(t *testing.T) { 4054 assert := assert.New(t) 4055 T := New(Of(Int16), WithShape(2, 3, 4, 5)) 4056 assert.False(T.IsMasked()) 4057 data := T.Int16s() 4058 for i := range data { 4059 data[i] = int16(i) 4060 } 4061 T.MaskedEqual(int16(0)) 4062 assert.True(T.IsMasked()) 4063 T.MaskedEqual(int16(1)) 4064 assert.True(T.mask[0] && T.mask[1]) 4065 T.MaskedNotEqual(int16(2)) 4066 assert.False(T.mask[2] && !(T.mask[0])) 4067 4068 T.ResetMask() 4069 T.MaskedInside(int16(1), int16(22)) 4070 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 4071 4072 T.ResetMask() 4073 T.MaskedOutside(int16(1), int16(22)) 4074 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 4075 4076 T.ResetMask() 4077 for i := 0; i < 5; i++ { 4078 T.MaskedEqual(int16(i * 10)) 4079 } 4080 it := IteratorFromDense(T) 4081 4082 j := 0 4083 for _, err := it.Next(); err == nil; _, err = it.Next() { 4084 j++ 4085 } 4086 4087 it.Reset() 4088 assert.Equal(120, j) 4089 j = 0 4090 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 4091 j++ 4092 } 4093 it.Reset() 4094 assert.Equal(115, j) 4095 j = 0 4096 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 4097 j++ 4098 } 4099 it.Reset() 4100 assert.Equal(5, j) 4101 } 4102 func TestDense_MaskedInside_I32(t *testing.T) { 4103 assert := assert.New(t) 4104 T := New(Of(Int32), WithShape(2, 3, 4, 5)) 4105 assert.False(T.IsMasked()) 4106 data := T.Int32s() 4107 for i := range data { 4108 data[i] = int32(i) 4109 } 4110 T.MaskedEqual(int32(0)) 4111 assert.True(T.IsMasked()) 4112 T.MaskedEqual(int32(1)) 4113 assert.True(T.mask[0] && T.mask[1]) 4114 T.MaskedNotEqual(int32(2)) 4115 assert.False(T.mask[2] && !(T.mask[0])) 4116 4117 T.ResetMask() 4118 T.MaskedInside(int32(1), int32(22)) 4119 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 4120 4121 T.ResetMask() 4122 T.MaskedOutside(int32(1), int32(22)) 4123 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 4124 4125 T.ResetMask() 4126 for i := 0; i < 5; i++ { 4127 T.MaskedEqual(int32(i * 10)) 4128 } 4129 it := IteratorFromDense(T) 4130 4131 j := 0 4132 for _, err := it.Next(); err == nil; _, err = it.Next() { 4133 j++ 4134 } 4135 4136 it.Reset() 4137 assert.Equal(120, j) 4138 j = 0 4139 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 4140 j++ 4141 } 4142 it.Reset() 4143 assert.Equal(115, j) 4144 j = 0 4145 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 4146 j++ 4147 } 4148 it.Reset() 4149 assert.Equal(5, j) 4150 } 4151 func TestDense_MaskedInside_I64(t *testing.T) { 4152 assert := assert.New(t) 4153 T := New(Of(Int64), WithShape(2, 3, 4, 5)) 4154 assert.False(T.IsMasked()) 4155 data := T.Int64s() 4156 for i := range data { 4157 data[i] = int64(i) 4158 } 4159 T.MaskedEqual(int64(0)) 4160 assert.True(T.IsMasked()) 4161 T.MaskedEqual(int64(1)) 4162 assert.True(T.mask[0] && T.mask[1]) 4163 T.MaskedNotEqual(int64(2)) 4164 assert.False(T.mask[2] && !(T.mask[0])) 4165 4166 T.ResetMask() 4167 T.MaskedInside(int64(1), int64(22)) 4168 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 4169 4170 T.ResetMask() 4171 T.MaskedOutside(int64(1), int64(22)) 4172 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 4173 4174 T.ResetMask() 4175 for i := 0; i < 5; i++ { 4176 T.MaskedEqual(int64(i * 10)) 4177 } 4178 it := IteratorFromDense(T) 4179 4180 j := 0 4181 for _, err := it.Next(); err == nil; _, err = it.Next() { 4182 j++ 4183 } 4184 4185 it.Reset() 4186 assert.Equal(120, j) 4187 j = 0 4188 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 4189 j++ 4190 } 4191 it.Reset() 4192 assert.Equal(115, j) 4193 j = 0 4194 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 4195 j++ 4196 } 4197 it.Reset() 4198 assert.Equal(5, j) 4199 } 4200 func TestDense_MaskedInside_U(t *testing.T) { 4201 assert := assert.New(t) 4202 T := New(Of(Uint), WithShape(2, 3, 4, 5)) 4203 assert.False(T.IsMasked()) 4204 data := T.Uints() 4205 for i := range data { 4206 data[i] = uint(i) 4207 } 4208 T.MaskedEqual(uint(0)) 4209 assert.True(T.IsMasked()) 4210 T.MaskedEqual(uint(1)) 4211 assert.True(T.mask[0] && T.mask[1]) 4212 T.MaskedNotEqual(uint(2)) 4213 assert.False(T.mask[2] && !(T.mask[0])) 4214 4215 T.ResetMask() 4216 T.MaskedInside(uint(1), uint(22)) 4217 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 4218 4219 T.ResetMask() 4220 T.MaskedOutside(uint(1), uint(22)) 4221 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 4222 4223 T.ResetMask() 4224 for i := 0; i < 5; i++ { 4225 T.MaskedEqual(uint(i * 10)) 4226 } 4227 it := IteratorFromDense(T) 4228 4229 j := 0 4230 for _, err := it.Next(); err == nil; _, err = it.Next() { 4231 j++ 4232 } 4233 4234 it.Reset() 4235 assert.Equal(120, j) 4236 j = 0 4237 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 4238 j++ 4239 } 4240 it.Reset() 4241 assert.Equal(115, j) 4242 j = 0 4243 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 4244 j++ 4245 } 4246 it.Reset() 4247 assert.Equal(5, j) 4248 } 4249 func TestDense_MaskedInside_U8(t *testing.T) { 4250 assert := assert.New(t) 4251 T := New(Of(Uint8), WithShape(2, 3, 4, 5)) 4252 assert.False(T.IsMasked()) 4253 data := T.Uint8s() 4254 for i := range data { 4255 data[i] = uint8(i) 4256 } 4257 T.MaskedEqual(uint8(0)) 4258 assert.True(T.IsMasked()) 4259 T.MaskedEqual(uint8(1)) 4260 assert.True(T.mask[0] && T.mask[1]) 4261 T.MaskedNotEqual(uint8(2)) 4262 assert.False(T.mask[2] && !(T.mask[0])) 4263 4264 T.ResetMask() 4265 T.MaskedInside(uint8(1), uint8(22)) 4266 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 4267 4268 T.ResetMask() 4269 T.MaskedOutside(uint8(1), uint8(22)) 4270 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 4271 4272 T.ResetMask() 4273 for i := 0; i < 5; i++ { 4274 T.MaskedEqual(uint8(i * 10)) 4275 } 4276 it := IteratorFromDense(T) 4277 4278 j := 0 4279 for _, err := it.Next(); err == nil; _, err = it.Next() { 4280 j++ 4281 } 4282 4283 it.Reset() 4284 assert.Equal(120, j) 4285 j = 0 4286 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 4287 j++ 4288 } 4289 it.Reset() 4290 assert.Equal(115, j) 4291 j = 0 4292 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 4293 j++ 4294 } 4295 it.Reset() 4296 assert.Equal(5, j) 4297 } 4298 func TestDense_MaskedInside_U16(t *testing.T) { 4299 assert := assert.New(t) 4300 T := New(Of(Uint16), WithShape(2, 3, 4, 5)) 4301 assert.False(T.IsMasked()) 4302 data := T.Uint16s() 4303 for i := range data { 4304 data[i] = uint16(i) 4305 } 4306 T.MaskedEqual(uint16(0)) 4307 assert.True(T.IsMasked()) 4308 T.MaskedEqual(uint16(1)) 4309 assert.True(T.mask[0] && T.mask[1]) 4310 T.MaskedNotEqual(uint16(2)) 4311 assert.False(T.mask[2] && !(T.mask[0])) 4312 4313 T.ResetMask() 4314 T.MaskedInside(uint16(1), uint16(22)) 4315 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 4316 4317 T.ResetMask() 4318 T.MaskedOutside(uint16(1), uint16(22)) 4319 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 4320 4321 T.ResetMask() 4322 for i := 0; i < 5; i++ { 4323 T.MaskedEqual(uint16(i * 10)) 4324 } 4325 it := IteratorFromDense(T) 4326 4327 j := 0 4328 for _, err := it.Next(); err == nil; _, err = it.Next() { 4329 j++ 4330 } 4331 4332 it.Reset() 4333 assert.Equal(120, j) 4334 j = 0 4335 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 4336 j++ 4337 } 4338 it.Reset() 4339 assert.Equal(115, j) 4340 j = 0 4341 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 4342 j++ 4343 } 4344 it.Reset() 4345 assert.Equal(5, j) 4346 } 4347 func TestDense_MaskedInside_U32(t *testing.T) { 4348 assert := assert.New(t) 4349 T := New(Of(Uint32), WithShape(2, 3, 4, 5)) 4350 assert.False(T.IsMasked()) 4351 data := T.Uint32s() 4352 for i := range data { 4353 data[i] = uint32(i) 4354 } 4355 T.MaskedEqual(uint32(0)) 4356 assert.True(T.IsMasked()) 4357 T.MaskedEqual(uint32(1)) 4358 assert.True(T.mask[0] && T.mask[1]) 4359 T.MaskedNotEqual(uint32(2)) 4360 assert.False(T.mask[2] && !(T.mask[0])) 4361 4362 T.ResetMask() 4363 T.MaskedInside(uint32(1), uint32(22)) 4364 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 4365 4366 T.ResetMask() 4367 T.MaskedOutside(uint32(1), uint32(22)) 4368 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 4369 4370 T.ResetMask() 4371 for i := 0; i < 5; i++ { 4372 T.MaskedEqual(uint32(i * 10)) 4373 } 4374 it := IteratorFromDense(T) 4375 4376 j := 0 4377 for _, err := it.Next(); err == nil; _, err = it.Next() { 4378 j++ 4379 } 4380 4381 it.Reset() 4382 assert.Equal(120, j) 4383 j = 0 4384 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 4385 j++ 4386 } 4387 it.Reset() 4388 assert.Equal(115, j) 4389 j = 0 4390 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 4391 j++ 4392 } 4393 it.Reset() 4394 assert.Equal(5, j) 4395 } 4396 func TestDense_MaskedInside_U64(t *testing.T) { 4397 assert := assert.New(t) 4398 T := New(Of(Uint64), WithShape(2, 3, 4, 5)) 4399 assert.False(T.IsMasked()) 4400 data := T.Uint64s() 4401 for i := range data { 4402 data[i] = uint64(i) 4403 } 4404 T.MaskedEqual(uint64(0)) 4405 assert.True(T.IsMasked()) 4406 T.MaskedEqual(uint64(1)) 4407 assert.True(T.mask[0] && T.mask[1]) 4408 T.MaskedNotEqual(uint64(2)) 4409 assert.False(T.mask[2] && !(T.mask[0])) 4410 4411 T.ResetMask() 4412 T.MaskedInside(uint64(1), uint64(22)) 4413 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 4414 4415 T.ResetMask() 4416 T.MaskedOutside(uint64(1), uint64(22)) 4417 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 4418 4419 T.ResetMask() 4420 for i := 0; i < 5; i++ { 4421 T.MaskedEqual(uint64(i * 10)) 4422 } 4423 it := IteratorFromDense(T) 4424 4425 j := 0 4426 for _, err := it.Next(); err == nil; _, err = it.Next() { 4427 j++ 4428 } 4429 4430 it.Reset() 4431 assert.Equal(120, j) 4432 j = 0 4433 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 4434 j++ 4435 } 4436 it.Reset() 4437 assert.Equal(115, j) 4438 j = 0 4439 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 4440 j++ 4441 } 4442 it.Reset() 4443 assert.Equal(5, j) 4444 } 4445 func TestDense_MaskedInside_F32(t *testing.T) { 4446 assert := assert.New(t) 4447 T := New(Of(Float32), WithShape(2, 3, 4, 5)) 4448 assert.False(T.IsMasked()) 4449 data := T.Float32s() 4450 for i := range data { 4451 data[i] = float32(i) 4452 } 4453 T.MaskedEqual(float32(0)) 4454 assert.True(T.IsMasked()) 4455 T.MaskedEqual(float32(1)) 4456 assert.True(T.mask[0] && T.mask[1]) 4457 T.MaskedNotEqual(float32(2)) 4458 assert.False(T.mask[2] && !(T.mask[0])) 4459 4460 T.ResetMask() 4461 T.MaskedInside(float32(1), float32(22)) 4462 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 4463 4464 T.ResetMask() 4465 T.MaskedOutside(float32(1), float32(22)) 4466 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 4467 4468 T.ResetMask() 4469 for i := 0; i < 5; i++ { 4470 T.MaskedEqual(float32(i * 10)) 4471 } 4472 it := IteratorFromDense(T) 4473 4474 j := 0 4475 for _, err := it.Next(); err == nil; _, err = it.Next() { 4476 j++ 4477 } 4478 4479 it.Reset() 4480 assert.Equal(120, j) 4481 j = 0 4482 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 4483 j++ 4484 } 4485 it.Reset() 4486 assert.Equal(115, j) 4487 j = 0 4488 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 4489 j++ 4490 } 4491 it.Reset() 4492 assert.Equal(5, j) 4493 } 4494 func TestDense_MaskedInside_F64(t *testing.T) { 4495 assert := assert.New(t) 4496 T := New(Of(Float64), WithShape(2, 3, 4, 5)) 4497 assert.False(T.IsMasked()) 4498 data := T.Float64s() 4499 for i := range data { 4500 data[i] = float64(i) 4501 } 4502 T.MaskedEqual(float64(0)) 4503 assert.True(T.IsMasked()) 4504 T.MaskedEqual(float64(1)) 4505 assert.True(T.mask[0] && T.mask[1]) 4506 T.MaskedNotEqual(float64(2)) 4507 assert.False(T.mask[2] && !(T.mask[0])) 4508 4509 T.ResetMask() 4510 T.MaskedInside(float64(1), float64(22)) 4511 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 4512 4513 T.ResetMask() 4514 T.MaskedOutside(float64(1), float64(22)) 4515 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 4516 4517 T.ResetMask() 4518 for i := 0; i < 5; i++ { 4519 T.MaskedEqual(float64(i * 10)) 4520 } 4521 it := IteratorFromDense(T) 4522 4523 j := 0 4524 for _, err := it.Next(); err == nil; _, err = it.Next() { 4525 j++ 4526 } 4527 4528 it.Reset() 4529 assert.Equal(120, j) 4530 j = 0 4531 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 4532 j++ 4533 } 4534 it.Reset() 4535 assert.Equal(115, j) 4536 j = 0 4537 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 4538 j++ 4539 } 4540 it.Reset() 4541 assert.Equal(5, j) 4542 } 4543 func TestDense_MaskedInside_Str(t *testing.T) { 4544 assert := assert.New(t) 4545 T := New(Of(String), WithShape(2, 3, 4, 5)) 4546 assert.False(T.IsMasked()) 4547 data := T.Strings() 4548 for i := range data { 4549 data[i] = fmt.Sprint(i) 4550 } 4551 T.MaskedEqual(fmt.Sprint(0)) 4552 assert.True(T.IsMasked()) 4553 T.MaskedEqual(fmt.Sprint(1)) 4554 assert.True(T.mask[0] && T.mask[1]) 4555 T.MaskedNotEqual(fmt.Sprint(2)) 4556 assert.False(T.mask[2] && !(T.mask[0])) 4557 4558 T.ResetMask() 4559 T.MaskedInside(fmt.Sprint(1), fmt.Sprint(22)) 4560 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 4561 4562 T.ResetMask() 4563 T.MaskedOutside(fmt.Sprint(1), fmt.Sprint(22)) 4564 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 4565 4566 T.ResetMask() 4567 for i := 0; i < 5; i++ { 4568 T.MaskedEqual(fmt.Sprint(i * 10)) 4569 } 4570 it := IteratorFromDense(T) 4571 4572 j := 0 4573 for _, err := it.Next(); err == nil; _, err = it.Next() { 4574 j++ 4575 } 4576 4577 it.Reset() 4578 assert.Equal(120, j) 4579 j = 0 4580 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 4581 j++ 4582 } 4583 it.Reset() 4584 assert.Equal(115, j) 4585 j = 0 4586 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 4587 j++ 4588 } 4589 it.Reset() 4590 assert.Equal(5, j) 4591 } 4592 4593 /* MaskedOutside */ 4594 4595 func TestDense_MaskedOutside_I(t *testing.T) { 4596 assert := assert.New(t) 4597 T := New(Of(Int), WithShape(2, 3, 4, 5)) 4598 assert.False(T.IsMasked()) 4599 data := T.Ints() 4600 for i := range data { 4601 data[i] = int(i) 4602 } 4603 T.MaskedEqual(int(0)) 4604 assert.True(T.IsMasked()) 4605 T.MaskedEqual(int(1)) 4606 assert.True(T.mask[0] && T.mask[1]) 4607 T.MaskedNotEqual(int(2)) 4608 assert.False(T.mask[2] && !(T.mask[0])) 4609 4610 T.ResetMask() 4611 T.MaskedInside(int(1), int(22)) 4612 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 4613 4614 T.ResetMask() 4615 T.MaskedOutside(int(1), int(22)) 4616 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 4617 4618 T.ResetMask() 4619 for i := 0; i < 5; i++ { 4620 T.MaskedEqual(int(i * 10)) 4621 } 4622 it := IteratorFromDense(T) 4623 4624 j := 0 4625 for _, err := it.Next(); err == nil; _, err = it.Next() { 4626 j++ 4627 } 4628 4629 it.Reset() 4630 assert.Equal(120, j) 4631 j = 0 4632 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 4633 j++ 4634 } 4635 it.Reset() 4636 assert.Equal(115, j) 4637 j = 0 4638 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 4639 j++ 4640 } 4641 it.Reset() 4642 assert.Equal(5, j) 4643 } 4644 func TestDense_MaskedOutside_I8(t *testing.T) { 4645 assert := assert.New(t) 4646 T := New(Of(Int8), WithShape(2, 3, 4, 5)) 4647 assert.False(T.IsMasked()) 4648 data := T.Int8s() 4649 for i := range data { 4650 data[i] = int8(i) 4651 } 4652 T.MaskedEqual(int8(0)) 4653 assert.True(T.IsMasked()) 4654 T.MaskedEqual(int8(1)) 4655 assert.True(T.mask[0] && T.mask[1]) 4656 T.MaskedNotEqual(int8(2)) 4657 assert.False(T.mask[2] && !(T.mask[0])) 4658 4659 T.ResetMask() 4660 T.MaskedInside(int8(1), int8(22)) 4661 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 4662 4663 T.ResetMask() 4664 T.MaskedOutside(int8(1), int8(22)) 4665 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 4666 4667 T.ResetMask() 4668 for i := 0; i < 5; i++ { 4669 T.MaskedEqual(int8(i * 10)) 4670 } 4671 it := IteratorFromDense(T) 4672 4673 j := 0 4674 for _, err := it.Next(); err == nil; _, err = it.Next() { 4675 j++ 4676 } 4677 4678 it.Reset() 4679 assert.Equal(120, j) 4680 j = 0 4681 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 4682 j++ 4683 } 4684 it.Reset() 4685 assert.Equal(115, j) 4686 j = 0 4687 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 4688 j++ 4689 } 4690 it.Reset() 4691 assert.Equal(5, j) 4692 } 4693 func TestDense_MaskedOutside_I16(t *testing.T) { 4694 assert := assert.New(t) 4695 T := New(Of(Int16), WithShape(2, 3, 4, 5)) 4696 assert.False(T.IsMasked()) 4697 data := T.Int16s() 4698 for i := range data { 4699 data[i] = int16(i) 4700 } 4701 T.MaskedEqual(int16(0)) 4702 assert.True(T.IsMasked()) 4703 T.MaskedEqual(int16(1)) 4704 assert.True(T.mask[0] && T.mask[1]) 4705 T.MaskedNotEqual(int16(2)) 4706 assert.False(T.mask[2] && !(T.mask[0])) 4707 4708 T.ResetMask() 4709 T.MaskedInside(int16(1), int16(22)) 4710 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 4711 4712 T.ResetMask() 4713 T.MaskedOutside(int16(1), int16(22)) 4714 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 4715 4716 T.ResetMask() 4717 for i := 0; i < 5; i++ { 4718 T.MaskedEqual(int16(i * 10)) 4719 } 4720 it := IteratorFromDense(T) 4721 4722 j := 0 4723 for _, err := it.Next(); err == nil; _, err = it.Next() { 4724 j++ 4725 } 4726 4727 it.Reset() 4728 assert.Equal(120, j) 4729 j = 0 4730 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 4731 j++ 4732 } 4733 it.Reset() 4734 assert.Equal(115, j) 4735 j = 0 4736 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 4737 j++ 4738 } 4739 it.Reset() 4740 assert.Equal(5, j) 4741 } 4742 func TestDense_MaskedOutside_I32(t *testing.T) { 4743 assert := assert.New(t) 4744 T := New(Of(Int32), WithShape(2, 3, 4, 5)) 4745 assert.False(T.IsMasked()) 4746 data := T.Int32s() 4747 for i := range data { 4748 data[i] = int32(i) 4749 } 4750 T.MaskedEqual(int32(0)) 4751 assert.True(T.IsMasked()) 4752 T.MaskedEqual(int32(1)) 4753 assert.True(T.mask[0] && T.mask[1]) 4754 T.MaskedNotEqual(int32(2)) 4755 assert.False(T.mask[2] && !(T.mask[0])) 4756 4757 T.ResetMask() 4758 T.MaskedInside(int32(1), int32(22)) 4759 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 4760 4761 T.ResetMask() 4762 T.MaskedOutside(int32(1), int32(22)) 4763 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 4764 4765 T.ResetMask() 4766 for i := 0; i < 5; i++ { 4767 T.MaskedEqual(int32(i * 10)) 4768 } 4769 it := IteratorFromDense(T) 4770 4771 j := 0 4772 for _, err := it.Next(); err == nil; _, err = it.Next() { 4773 j++ 4774 } 4775 4776 it.Reset() 4777 assert.Equal(120, j) 4778 j = 0 4779 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 4780 j++ 4781 } 4782 it.Reset() 4783 assert.Equal(115, j) 4784 j = 0 4785 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 4786 j++ 4787 } 4788 it.Reset() 4789 assert.Equal(5, j) 4790 } 4791 func TestDense_MaskedOutside_I64(t *testing.T) { 4792 assert := assert.New(t) 4793 T := New(Of(Int64), WithShape(2, 3, 4, 5)) 4794 assert.False(T.IsMasked()) 4795 data := T.Int64s() 4796 for i := range data { 4797 data[i] = int64(i) 4798 } 4799 T.MaskedEqual(int64(0)) 4800 assert.True(T.IsMasked()) 4801 T.MaskedEqual(int64(1)) 4802 assert.True(T.mask[0] && T.mask[1]) 4803 T.MaskedNotEqual(int64(2)) 4804 assert.False(T.mask[2] && !(T.mask[0])) 4805 4806 T.ResetMask() 4807 T.MaskedInside(int64(1), int64(22)) 4808 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 4809 4810 T.ResetMask() 4811 T.MaskedOutside(int64(1), int64(22)) 4812 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 4813 4814 T.ResetMask() 4815 for i := 0; i < 5; i++ { 4816 T.MaskedEqual(int64(i * 10)) 4817 } 4818 it := IteratorFromDense(T) 4819 4820 j := 0 4821 for _, err := it.Next(); err == nil; _, err = it.Next() { 4822 j++ 4823 } 4824 4825 it.Reset() 4826 assert.Equal(120, j) 4827 j = 0 4828 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 4829 j++ 4830 } 4831 it.Reset() 4832 assert.Equal(115, j) 4833 j = 0 4834 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 4835 j++ 4836 } 4837 it.Reset() 4838 assert.Equal(5, j) 4839 } 4840 func TestDense_MaskedOutside_U(t *testing.T) { 4841 assert := assert.New(t) 4842 T := New(Of(Uint), WithShape(2, 3, 4, 5)) 4843 assert.False(T.IsMasked()) 4844 data := T.Uints() 4845 for i := range data { 4846 data[i] = uint(i) 4847 } 4848 T.MaskedEqual(uint(0)) 4849 assert.True(T.IsMasked()) 4850 T.MaskedEqual(uint(1)) 4851 assert.True(T.mask[0] && T.mask[1]) 4852 T.MaskedNotEqual(uint(2)) 4853 assert.False(T.mask[2] && !(T.mask[0])) 4854 4855 T.ResetMask() 4856 T.MaskedInside(uint(1), uint(22)) 4857 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 4858 4859 T.ResetMask() 4860 T.MaskedOutside(uint(1), uint(22)) 4861 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 4862 4863 T.ResetMask() 4864 for i := 0; i < 5; i++ { 4865 T.MaskedEqual(uint(i * 10)) 4866 } 4867 it := IteratorFromDense(T) 4868 4869 j := 0 4870 for _, err := it.Next(); err == nil; _, err = it.Next() { 4871 j++ 4872 } 4873 4874 it.Reset() 4875 assert.Equal(120, j) 4876 j = 0 4877 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 4878 j++ 4879 } 4880 it.Reset() 4881 assert.Equal(115, j) 4882 j = 0 4883 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 4884 j++ 4885 } 4886 it.Reset() 4887 assert.Equal(5, j) 4888 } 4889 func TestDense_MaskedOutside_U8(t *testing.T) { 4890 assert := assert.New(t) 4891 T := New(Of(Uint8), WithShape(2, 3, 4, 5)) 4892 assert.False(T.IsMasked()) 4893 data := T.Uint8s() 4894 for i := range data { 4895 data[i] = uint8(i) 4896 } 4897 T.MaskedEqual(uint8(0)) 4898 assert.True(T.IsMasked()) 4899 T.MaskedEqual(uint8(1)) 4900 assert.True(T.mask[0] && T.mask[1]) 4901 T.MaskedNotEqual(uint8(2)) 4902 assert.False(T.mask[2] && !(T.mask[0])) 4903 4904 T.ResetMask() 4905 T.MaskedInside(uint8(1), uint8(22)) 4906 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 4907 4908 T.ResetMask() 4909 T.MaskedOutside(uint8(1), uint8(22)) 4910 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 4911 4912 T.ResetMask() 4913 for i := 0; i < 5; i++ { 4914 T.MaskedEqual(uint8(i * 10)) 4915 } 4916 it := IteratorFromDense(T) 4917 4918 j := 0 4919 for _, err := it.Next(); err == nil; _, err = it.Next() { 4920 j++ 4921 } 4922 4923 it.Reset() 4924 assert.Equal(120, j) 4925 j = 0 4926 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 4927 j++ 4928 } 4929 it.Reset() 4930 assert.Equal(115, j) 4931 j = 0 4932 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 4933 j++ 4934 } 4935 it.Reset() 4936 assert.Equal(5, j) 4937 } 4938 func TestDense_MaskedOutside_U16(t *testing.T) { 4939 assert := assert.New(t) 4940 T := New(Of(Uint16), WithShape(2, 3, 4, 5)) 4941 assert.False(T.IsMasked()) 4942 data := T.Uint16s() 4943 for i := range data { 4944 data[i] = uint16(i) 4945 } 4946 T.MaskedEqual(uint16(0)) 4947 assert.True(T.IsMasked()) 4948 T.MaskedEqual(uint16(1)) 4949 assert.True(T.mask[0] && T.mask[1]) 4950 T.MaskedNotEqual(uint16(2)) 4951 assert.False(T.mask[2] && !(T.mask[0])) 4952 4953 T.ResetMask() 4954 T.MaskedInside(uint16(1), uint16(22)) 4955 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 4956 4957 T.ResetMask() 4958 T.MaskedOutside(uint16(1), uint16(22)) 4959 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 4960 4961 T.ResetMask() 4962 for i := 0; i < 5; i++ { 4963 T.MaskedEqual(uint16(i * 10)) 4964 } 4965 it := IteratorFromDense(T) 4966 4967 j := 0 4968 for _, err := it.Next(); err == nil; _, err = it.Next() { 4969 j++ 4970 } 4971 4972 it.Reset() 4973 assert.Equal(120, j) 4974 j = 0 4975 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 4976 j++ 4977 } 4978 it.Reset() 4979 assert.Equal(115, j) 4980 j = 0 4981 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 4982 j++ 4983 } 4984 it.Reset() 4985 assert.Equal(5, j) 4986 } 4987 func TestDense_MaskedOutside_U32(t *testing.T) { 4988 assert := assert.New(t) 4989 T := New(Of(Uint32), WithShape(2, 3, 4, 5)) 4990 assert.False(T.IsMasked()) 4991 data := T.Uint32s() 4992 for i := range data { 4993 data[i] = uint32(i) 4994 } 4995 T.MaskedEqual(uint32(0)) 4996 assert.True(T.IsMasked()) 4997 T.MaskedEqual(uint32(1)) 4998 assert.True(T.mask[0] && T.mask[1]) 4999 T.MaskedNotEqual(uint32(2)) 5000 assert.False(T.mask[2] && !(T.mask[0])) 5001 5002 T.ResetMask() 5003 T.MaskedInside(uint32(1), uint32(22)) 5004 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 5005 5006 T.ResetMask() 5007 T.MaskedOutside(uint32(1), uint32(22)) 5008 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 5009 5010 T.ResetMask() 5011 for i := 0; i < 5; i++ { 5012 T.MaskedEqual(uint32(i * 10)) 5013 } 5014 it := IteratorFromDense(T) 5015 5016 j := 0 5017 for _, err := it.Next(); err == nil; _, err = it.Next() { 5018 j++ 5019 } 5020 5021 it.Reset() 5022 assert.Equal(120, j) 5023 j = 0 5024 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 5025 j++ 5026 } 5027 it.Reset() 5028 assert.Equal(115, j) 5029 j = 0 5030 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 5031 j++ 5032 } 5033 it.Reset() 5034 assert.Equal(5, j) 5035 } 5036 func TestDense_MaskedOutside_U64(t *testing.T) { 5037 assert := assert.New(t) 5038 T := New(Of(Uint64), WithShape(2, 3, 4, 5)) 5039 assert.False(T.IsMasked()) 5040 data := T.Uint64s() 5041 for i := range data { 5042 data[i] = uint64(i) 5043 } 5044 T.MaskedEqual(uint64(0)) 5045 assert.True(T.IsMasked()) 5046 T.MaskedEqual(uint64(1)) 5047 assert.True(T.mask[0] && T.mask[1]) 5048 T.MaskedNotEqual(uint64(2)) 5049 assert.False(T.mask[2] && !(T.mask[0])) 5050 5051 T.ResetMask() 5052 T.MaskedInside(uint64(1), uint64(22)) 5053 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 5054 5055 T.ResetMask() 5056 T.MaskedOutside(uint64(1), uint64(22)) 5057 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 5058 5059 T.ResetMask() 5060 for i := 0; i < 5; i++ { 5061 T.MaskedEqual(uint64(i * 10)) 5062 } 5063 it := IteratorFromDense(T) 5064 5065 j := 0 5066 for _, err := it.Next(); err == nil; _, err = it.Next() { 5067 j++ 5068 } 5069 5070 it.Reset() 5071 assert.Equal(120, j) 5072 j = 0 5073 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 5074 j++ 5075 } 5076 it.Reset() 5077 assert.Equal(115, j) 5078 j = 0 5079 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 5080 j++ 5081 } 5082 it.Reset() 5083 assert.Equal(5, j) 5084 } 5085 func TestDense_MaskedOutside_F32(t *testing.T) { 5086 assert := assert.New(t) 5087 T := New(Of(Float32), WithShape(2, 3, 4, 5)) 5088 assert.False(T.IsMasked()) 5089 data := T.Float32s() 5090 for i := range data { 5091 data[i] = float32(i) 5092 } 5093 T.MaskedEqual(float32(0)) 5094 assert.True(T.IsMasked()) 5095 T.MaskedEqual(float32(1)) 5096 assert.True(T.mask[0] && T.mask[1]) 5097 T.MaskedNotEqual(float32(2)) 5098 assert.False(T.mask[2] && !(T.mask[0])) 5099 5100 T.ResetMask() 5101 T.MaskedInside(float32(1), float32(22)) 5102 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 5103 5104 T.ResetMask() 5105 T.MaskedOutside(float32(1), float32(22)) 5106 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 5107 5108 T.ResetMask() 5109 for i := 0; i < 5; i++ { 5110 T.MaskedEqual(float32(i * 10)) 5111 } 5112 it := IteratorFromDense(T) 5113 5114 j := 0 5115 for _, err := it.Next(); err == nil; _, err = it.Next() { 5116 j++ 5117 } 5118 5119 it.Reset() 5120 assert.Equal(120, j) 5121 j = 0 5122 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 5123 j++ 5124 } 5125 it.Reset() 5126 assert.Equal(115, j) 5127 j = 0 5128 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 5129 j++ 5130 } 5131 it.Reset() 5132 assert.Equal(5, j) 5133 } 5134 func TestDense_MaskedOutside_F64(t *testing.T) { 5135 assert := assert.New(t) 5136 T := New(Of(Float64), WithShape(2, 3, 4, 5)) 5137 assert.False(T.IsMasked()) 5138 data := T.Float64s() 5139 for i := range data { 5140 data[i] = float64(i) 5141 } 5142 T.MaskedEqual(float64(0)) 5143 assert.True(T.IsMasked()) 5144 T.MaskedEqual(float64(1)) 5145 assert.True(T.mask[0] && T.mask[1]) 5146 T.MaskedNotEqual(float64(2)) 5147 assert.False(T.mask[2] && !(T.mask[0])) 5148 5149 T.ResetMask() 5150 T.MaskedInside(float64(1), float64(22)) 5151 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 5152 5153 T.ResetMask() 5154 T.MaskedOutside(float64(1), float64(22)) 5155 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 5156 5157 T.ResetMask() 5158 for i := 0; i < 5; i++ { 5159 T.MaskedEqual(float64(i * 10)) 5160 } 5161 it := IteratorFromDense(T) 5162 5163 j := 0 5164 for _, err := it.Next(); err == nil; _, err = it.Next() { 5165 j++ 5166 } 5167 5168 it.Reset() 5169 assert.Equal(120, j) 5170 j = 0 5171 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 5172 j++ 5173 } 5174 it.Reset() 5175 assert.Equal(115, j) 5176 j = 0 5177 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 5178 j++ 5179 } 5180 it.Reset() 5181 assert.Equal(5, j) 5182 } 5183 func TestDense_MaskedOutside_Str(t *testing.T) { 5184 assert := assert.New(t) 5185 T := New(Of(String), WithShape(2, 3, 4, 5)) 5186 assert.False(T.IsMasked()) 5187 data := T.Strings() 5188 for i := range data { 5189 data[i] = fmt.Sprint(i) 5190 } 5191 T.MaskedEqual(fmt.Sprint(0)) 5192 assert.True(T.IsMasked()) 5193 T.MaskedEqual(fmt.Sprint(1)) 5194 assert.True(T.mask[0] && T.mask[1]) 5195 T.MaskedNotEqual(fmt.Sprint(2)) 5196 assert.False(T.mask[2] && !(T.mask[0])) 5197 5198 T.ResetMask() 5199 T.MaskedInside(fmt.Sprint(1), fmt.Sprint(22)) 5200 assert.True(!T.mask[0] && !T.mask[23] && T.mask[1] && T.mask[22]) 5201 5202 T.ResetMask() 5203 T.MaskedOutside(fmt.Sprint(1), fmt.Sprint(22)) 5204 assert.True(T.mask[0] && T.mask[23] && !T.mask[1] && !T.mask[22]) 5205 5206 T.ResetMask() 5207 for i := 0; i < 5; i++ { 5208 T.MaskedEqual(fmt.Sprint(i * 10)) 5209 } 5210 it := IteratorFromDense(T) 5211 5212 j := 0 5213 for _, err := it.Next(); err == nil; _, err = it.Next() { 5214 j++ 5215 } 5216 5217 it.Reset() 5218 assert.Equal(120, j) 5219 j = 0 5220 for _, _, err := it.NextValid(); err == nil; _, _, err = it.NextValid() { 5221 j++ 5222 } 5223 it.Reset() 5224 assert.Equal(115, j) 5225 j = 0 5226 for _, _, err := it.NextInvalid(); err == nil; _, _, err = it.NextInvalid() { 5227 j++ 5228 } 5229 it.Reset() 5230 assert.Equal(5, j) 5231 }