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