1 /* 2 * Copyright (c) 2017, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. Oracle designates this 8 * particular file as subject to the "Classpath" exception as provided 9 * by Oracle in the LICENSE file that accompanied this code. 10 * 11 * This code is distributed in the hope that it will be useful, but WITHOUT 12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14 * version 2 for more details (a copy is included in the LICENSE file that 15 * accompanied this code). 16 * 17 * You should have received a copy of the GNU General Public License version 18 * 2 along with this work; if not, write to the Free Software Foundation, 19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 20 * 21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 22 * or visit www.oracle.com if you need additional information or have 23 * questions. 24 */ 25 package jdk.incubator.vector; 26 27 import java.nio.ByteBuffer; 28 import java.util.Arrays; 29 import java.util.Objects; 30 import jdk.internal.vm.annotation.ForceInline; 31 import static jdk.incubator.vector.VectorIntrinsics.*; 32 33 @SuppressWarnings("cast") 34 final class Long128Vector extends LongVector<Shapes.S128Bit> { 35 static final Long128Species SPECIES = new Long128Species(); 36 37 static final Long128Vector ZERO = new Long128Vector(); 38 39 static final int LENGTH = SPECIES.length(); 40 41 private final long[] vec; // Don't access directly, use getElements() instead. 42 43 private long[] getElements() { 44 return VectorIntrinsics.maybeRebox(this).vec; 45 } 46 47 Long128Vector() { 48 vec = new long[SPECIES.length()]; 49 } 50 51 Long128Vector(long[] v) { 52 vec = v; 53 } 54 55 @Override 56 public int length() { return LENGTH; } 57 58 // Unary operator 59 60 @Override 61 Long128Vector uOp(FUnOp f) { 62 long[] vec = getElements(); 63 long[] res = new long[length()]; 64 for (int i = 0; i < length(); i++) { 65 res[i] = f.apply(i, vec[i]); 66 } 67 return new Long128Vector(res); 68 } 69 70 @Override 71 Long128Vector uOp(Mask<Long, Shapes.S128Bit> o, FUnOp f) { 72 long[] vec = getElements(); 73 long[] res = new long[length()]; 74 boolean[] mbits = ((Long128Mask)o).getBits(); 75 for (int i = 0; i < length(); i++) { 76 res[i] = mbits[i] ? f.apply(i, vec[i]) : vec[i]; 77 } 78 return new Long128Vector(res); 79 } 80 81 // Binary operator 82 83 @Override 84 Long128Vector bOp(Vector<Long, Shapes.S128Bit> o, FBinOp f) { 85 long[] res = new long[length()]; 86 long[] vec1 = this.getElements(); 87 long[] vec2 = ((Long128Vector)o).getElements(); 88 for (int i = 0; i < length(); i++) { 89 res[i] = f.apply(i, vec1[i], vec2[i]); 90 } 91 return new Long128Vector(res); 92 } 93 94 @Override 95 Long128Vector bOp(Vector<Long, Shapes.S128Bit> o1, Mask<Long, Shapes.S128Bit> o2, FBinOp f) { 96 long[] res = new long[length()]; 97 long[] vec1 = this.getElements(); 98 long[] vec2 = ((Long128Vector)o1).getElements(); 99 boolean[] mbits = ((Long128Mask)o2).getBits(); 100 for (int i = 0; i < length(); i++) { 101 res[i] = mbits[i] ? f.apply(i, vec1[i], vec2[i]) : vec1[i]; 102 } 103 return new Long128Vector(res); 104 } 105 106 // Trinary operator 107 108 @Override 109 Long128Vector tOp(Vector<Long, Shapes.S128Bit> o1, Vector<Long, Shapes.S128Bit> o2, FTriOp f) { 110 long[] res = new long[length()]; 111 long[] vec1 = this.getElements(); 112 long[] vec2 = ((Long128Vector)o1).getElements(); 113 long[] vec3 = ((Long128Vector)o2).getElements(); 114 for (int i = 0; i < length(); i++) { 115 res[i] = f.apply(i, vec1[i], vec2[i], vec3[i]); 116 } 117 return new Long128Vector(res); 118 } 119 120 @Override 121 Long128Vector tOp(Vector<Long, Shapes.S128Bit> o1, Vector<Long, Shapes.S128Bit> o2, Mask<Long, Shapes.S128Bit> o3, FTriOp f) { 122 long[] res = new long[length()]; 123 long[] vec1 = getElements(); 124 long[] vec2 = ((Long128Vector)o1).getElements(); 125 long[] vec3 = ((Long128Vector)o2).getElements(); 126 boolean[] mbits = ((Long128Mask)o3).getBits(); 127 for (int i = 0; i < length(); i++) { 128 res[i] = mbits[i] ? f.apply(i, vec1[i], vec2[i], vec3[i]) : vec1[i]; 129 } 130 return new Long128Vector(res); 131 } 132 133 @Override 134 long rOp(long v, FBinOp f) { 135 long[] vec = getElements(); 136 for (int i = 0; i < length(); i++) { 137 v = f.apply(i, v, vec[i]); 138 } 139 return v; 140 } 141 142 // Binary operations with scalars 143 144 @Override 145 @ForceInline 146 public LongVector<Shapes.S128Bit> add(long o) { 147 return add(SPECIES.broadcast(o)); 148 } 149 150 @Override 151 @ForceInline 152 public LongVector<Shapes.S128Bit> add(long o, Mask<Long,Shapes.S128Bit> m) { 153 return add(SPECIES.broadcast(o), m); 154 } 155 156 @Override 157 @ForceInline 158 public LongVector<Shapes.S128Bit> addSaturate(long o) { 159 return addSaturate(SPECIES.broadcast(o)); 160 } 161 162 @Override 163 @ForceInline 164 public LongVector<Shapes.S128Bit> addSaturate(long o, Mask<Long,Shapes.S128Bit> m) { 165 return addSaturate(SPECIES.broadcast(o), m); 166 } 167 168 @Override 169 @ForceInline 170 public LongVector<Shapes.S128Bit> sub(long o) { 171 return sub(SPECIES.broadcast(o)); 172 } 173 174 @Override 175 @ForceInline 176 public LongVector<Shapes.S128Bit> sub(long o, Mask<Long,Shapes.S128Bit> m) { 177 return sub(SPECIES.broadcast(o), m); 178 } 179 180 @Override 181 @ForceInline 182 public LongVector<Shapes.S128Bit> subSaturate(long o) { 183 return subSaturate(SPECIES.broadcast(o)); 184 } 185 186 @Override 187 @ForceInline 188 public LongVector<Shapes.S128Bit> subSaturate(long o, Mask<Long,Shapes.S128Bit> m) { 189 return subSaturate(SPECIES.broadcast(o), m); 190 } 191 192 @Override 193 @ForceInline 194 public LongVector<Shapes.S128Bit> mul(long o) { 195 return mul(SPECIES.broadcast(o)); 196 } 197 198 @Override 199 @ForceInline 200 public LongVector<Shapes.S128Bit> mul(long o, Mask<Long,Shapes.S128Bit> m) { 201 return mul(SPECIES.broadcast(o), m); 202 } 203 204 @Override 205 @ForceInline 206 public LongVector<Shapes.S128Bit> min(long o) { 207 return min(SPECIES.broadcast(o)); 208 } 209 210 @Override 211 @ForceInline 212 public LongVector<Shapes.S128Bit> max(long o) { 213 return max(SPECIES.broadcast(o)); 214 } 215 216 @Override 217 @ForceInline 218 public Mask<Long, Shapes.S128Bit> equal(long o) { 219 return equal(SPECIES.broadcast(o)); 220 } 221 222 @Override 223 @ForceInline 224 public Mask<Long, Shapes.S128Bit> notEqual(long o) { 225 return notEqual(SPECIES.broadcast(o)); 226 } 227 228 @Override 229 @ForceInline 230 public Mask<Long, Shapes.S128Bit> lessThan(long o) { 231 return lessThan(SPECIES.broadcast(o)); 232 } 233 234 @Override 235 @ForceInline 236 public Mask<Long, Shapes.S128Bit> lessThanEq(long o) { 237 return lessThanEq(SPECIES.broadcast(o)); 238 } 239 240 @Override 241 @ForceInline 242 public Mask<Long, Shapes.S128Bit> greaterThan(long o) { 243 return greaterThan(SPECIES.broadcast(o)); 244 } 245 246 @Override 247 @ForceInline 248 public Mask<Long, Shapes.S128Bit> greaterThanEq(long o) { 249 return greaterThanEq(SPECIES.broadcast(o)); 250 } 251 252 @Override 253 @ForceInline 254 public LongVector<Shapes.S128Bit> blend(long o, Mask<Long,Shapes.S128Bit> m) { 255 return blend(SPECIES.broadcast(o), m); 256 } 257 258 259 @Override 260 @ForceInline 261 public LongVector<Shapes.S128Bit> and(long o) { 262 return and(SPECIES.broadcast(o)); 263 } 264 265 @Override 266 @ForceInline 267 public LongVector<Shapes.S128Bit> and(long o, Mask<Long,Shapes.S128Bit> m) { 268 return and(SPECIES.broadcast(o), m); 269 } 270 271 @Override 272 @ForceInline 273 public LongVector<Shapes.S128Bit> or(long o) { 274 return or(SPECIES.broadcast(o)); 275 } 276 277 @Override 278 @ForceInline 279 public LongVector<Shapes.S128Bit> or(long o, Mask<Long,Shapes.S128Bit> m) { 280 return or(SPECIES.broadcast(o), m); 281 } 282 283 @Override 284 @ForceInline 285 public LongVector<Shapes.S128Bit> xor(long o) { 286 return xor(SPECIES.broadcast(o)); 287 } 288 289 @Override 290 @ForceInline 291 public LongVector<Shapes.S128Bit> xor(long o, Mask<Long,Shapes.S128Bit> m) { 292 return xor(SPECIES.broadcast(o), m); 293 } 294 295 296 // Unary operations 297 298 @Override 299 @ForceInline 300 public Long128Vector abs() { 301 return (Long128Vector) VectorIntrinsics.unaryOp( 302 VECTOR_OP_ABS, Long128Vector.class, long.class, LENGTH, 303 this, 304 v1 -> ((Long128Vector)v1).uOp((i, a) -> (long) Math.abs(a))); 305 } 306 307 308 309 @Override 310 @ForceInline 311 public Long128Vector not() { 312 return (Long128Vector) VectorIntrinsics.unaryOp( 313 VECTOR_OP_NOT, Long128Vector.class, long.class, LENGTH, 314 this, 315 v1 -> ((Long128Vector)v1).uOp((i, a) -> (long) ~a)); 316 } 317 // Binary operations 318 319 @Override 320 @ForceInline 321 public Long128Vector add(Vector<Long,Shapes.S128Bit> o) { 322 Objects.requireNonNull(o); 323 Long128Vector v = (Long128Vector)o; 324 return (Long128Vector) VectorIntrinsics.binaryOp( 325 VECTOR_OP_ADD, Long128Vector.class, long.class, LENGTH, 326 this, v, 327 (v1, v2) -> ((Long128Vector)v1).bOp(v2, (i, a, b) -> (long)(a + b))); 328 } 329 330 @Override 331 @ForceInline 332 public Long128Vector sub(Vector<Long,Shapes.S128Bit> o) { 333 Objects.requireNonNull(o); 334 Long128Vector v = (Long128Vector)o; 335 return (Long128Vector) VectorIntrinsics.binaryOp( 336 VECTOR_OP_SUB, Long128Vector.class, long.class, LENGTH, 337 this, v, 338 (v1, v2) -> ((Long128Vector)v1).bOp(v2, (i, a, b) -> (long)(a - b))); 339 } 340 341 @Override 342 @ForceInline 343 public Long128Vector mul(Vector<Long,Shapes.S128Bit> o) { 344 Objects.requireNonNull(o); 345 Long128Vector v = (Long128Vector)o; 346 return (Long128Vector) VectorIntrinsics.binaryOp( 347 VECTOR_OP_MUL, Long128Vector.class, long.class, LENGTH, 348 this, v, 349 (v1, v2) -> ((Long128Vector)v1).bOp(v2, (i, a, b) -> (long)(a * b))); 350 } 351 352 @Override 353 @ForceInline 354 public Long128Vector min(Vector<Long,Shapes.S128Bit> o) { 355 Objects.requireNonNull(o); 356 Long128Vector v = (Long128Vector)o; 357 return (Long128Vector) VectorIntrinsics.binaryOp( 358 VECTOR_OP_MIN, Long128Vector.class, long.class, LENGTH, 359 this, v, 360 (v1, v2) -> ((Long128Vector)v1).bOp(v2, (i, a, b) -> (long) ((a < b) ? a : b))); 361 } 362 363 @Override 364 @ForceInline 365 public Long128Vector max(Vector<Long,Shapes.S128Bit> o) { 366 Objects.requireNonNull(o); 367 Long128Vector v = (Long128Vector)o; 368 return (Long128Vector) VectorIntrinsics.binaryOp( 369 VECTOR_OP_MAX, Long128Vector.class, long.class, LENGTH, 370 this, v, 371 (v1, v2) -> ((Long128Vector)v1).bOp(v2, (i, a, b) -> (long) ((a > b) ? a : b))); 372 } 373 374 375 376 @Override 377 @ForceInline 378 public Long128Vector and(Vector<Long,Shapes.S128Bit> o) { 379 Objects.requireNonNull(o); 380 Long128Vector v = (Long128Vector)o; 381 return (Long128Vector) VectorIntrinsics.binaryOp( 382 VECTOR_OP_AND, Long128Vector.class, long.class, LENGTH, 383 this, v, 384 (v1, v2) -> ((Long128Vector)v1).bOp(v2, (i, a, b) -> (long)(a & b))); 385 } 386 387 @Override 388 @ForceInline 389 public Long128Vector or(Vector<Long,Shapes.S128Bit> o) { 390 Objects.requireNonNull(o); 391 Long128Vector v = (Long128Vector)o; 392 return (Long128Vector) VectorIntrinsics.binaryOp( 393 VECTOR_OP_OR, Long128Vector.class, long.class, LENGTH, 394 this, v, 395 (v1, v2) -> ((Long128Vector)v1).bOp(v2, (i, a, b) -> (long)(a | b))); 396 } 397 398 @Override 399 @ForceInline 400 public Long128Vector xor(Vector<Long,Shapes.S128Bit> o) { 401 Objects.requireNonNull(o); 402 Long128Vector v = (Long128Vector)o; 403 return (Long128Vector) VectorIntrinsics.binaryOp( 404 VECTOR_OP_XOR, Long128Vector.class, long.class, LENGTH, 405 this, v, 406 (v1, v2) -> ((Long128Vector)v1).bOp(v2, (i, a, b) -> (long)(a ^ b))); 407 } 408 409 @Override 410 @ForceInline 411 public Long128Vector and(Vector<Long,Shapes.S128Bit> v, Mask<Long, Shapes.S128Bit> m) { 412 return blend(and(v), m); 413 } 414 415 @Override 416 @ForceInline 417 public Long128Vector or(Vector<Long,Shapes.S128Bit> v, Mask<Long, Shapes.S128Bit> m) { 418 return blend(or(v), m); 419 } 420 421 @Override 422 @ForceInline 423 public Long128Vector xor(Vector<Long,Shapes.S128Bit> v, Mask<Long, Shapes.S128Bit> m) { 424 return blend(xor(v), m); 425 } 426 427 @Override 428 @ForceInline 429 public Long128Vector shiftL(int s) { 430 return (Long128Vector) VectorIntrinsics.broadcastInt( 431 VECTOR_OP_LSHIFT, Long128Vector.class, long.class, LENGTH, 432 this, s, 433 (v, i) -> v.uOp((__, a) -> (long) (a << i))); 434 } 435 436 @Override 437 @ForceInline 438 public Long128Vector shiftR(int s) { 439 return (Long128Vector) VectorIntrinsics.broadcastInt( 440 VECTOR_OP_URSHIFT, Long128Vector.class, long.class, LENGTH, 441 this, s, 442 (v, i) -> v.uOp((__, a) -> (long) (a >>> i))); 443 } 444 445 @Override 446 @ForceInline 447 public Long128Vector aShiftR(int s) { 448 return (Long128Vector) VectorIntrinsics.broadcastInt( 449 VECTOR_OP_RSHIFT, Long128Vector.class, long.class, LENGTH, 450 this, s, 451 (v, i) -> v.uOp((__, a) -> (long) (a >> i))); 452 } 453 454 @Override 455 @ForceInline 456 public Long128Vector shiftL(Vector<Long,Shapes.S128Bit> s) { 457 Long128Vector v = (Long128Vector)s; 458 return (Long128Vector) VectorIntrinsics.binaryOp( 459 VECTOR_OP_LSHIFT, Long128Vector.class, long.class, LENGTH, 460 this, v, 461 (v1, v2) -> ((Long128Vector)v1).bOp(v2,(i,a, b) -> (long) (a << b))); 462 } 463 464 @Override 465 @ForceInline 466 public Long128Vector shiftR(Vector<Long,Shapes.S128Bit> s) { 467 Long128Vector v = (Long128Vector)s; 468 return (Long128Vector) VectorIntrinsics.binaryOp( 469 VECTOR_OP_URSHIFT, Long128Vector.class, long.class, LENGTH, 470 this, v, 471 (v1, v2) -> ((Long128Vector)v1).bOp(v2,(i,a, b) -> (long) (a >>> b))); 472 } 473 474 @Override 475 @ForceInline 476 public Long128Vector ashiftR(Vector<Long,Shapes.S128Bit> s) { 477 Long128Vector v = (Long128Vector)s; 478 return (Long128Vector) VectorIntrinsics.binaryOp( 479 VECTOR_OP_RSHIFT, Long128Vector.class, long.class, LENGTH, 480 this, v, 481 (v1, v2) -> ((Long128Vector)v1).bOp(v2,(i,a, b) -> (long) (a >> b))); 482 } 483 // Ternary operations 484 485 486 // Type specific horizontal reductions 487 488 @Override 489 @ForceInline 490 public long addAll() { 491 return (long) VectorIntrinsics.reductionCoerced( 492 VECTOR_OP_ADD, Long128Vector.class, long.class, LENGTH, 493 this, 494 v -> (long) v.rOp((long) 0, (i, a, b) -> (long) (a + b))); 495 } 496 497 @Override 498 @ForceInline 499 public long andAll() { 500 return (long) VectorIntrinsics.reductionCoerced( 501 VECTOR_OP_AND, Long128Vector.class, long.class, LENGTH, 502 this, 503 v -> (long) v.rOp((long) -1, (i, a, b) -> (long) (a & b))); 504 } 505 506 @Override 507 @ForceInline 508 public long mulAll() { 509 return (long) VectorIntrinsics.reductionCoerced( 510 VECTOR_OP_MUL, Long128Vector.class, long.class, LENGTH, 511 this, 512 v -> (long) v.rOp((long) 1, (i, a, b) -> (long) (a * b))); 513 } 514 515 @Override 516 @ForceInline 517 public long orAll() { 518 return (long) VectorIntrinsics.reductionCoerced( 519 VECTOR_OP_OR, Long128Vector.class, long.class, LENGTH, 520 this, 521 v -> (long) v.rOp((long) 0, (i, a, b) -> (long) (a | b))); 522 } 523 524 @Override 525 @ForceInline 526 public long xorAll() { 527 return (long) VectorIntrinsics.reductionCoerced( 528 VECTOR_OP_XOR, Long128Vector.class, long.class, LENGTH, 529 this, 530 v -> (long) v.rOp((long) 0, (i, a, b) -> (long) (a ^ b))); 531 } 532 533 @Override 534 @ForceInline 535 public long subAll() { 536 return (long) VectorIntrinsics.reductionCoerced( 537 VECTOR_OP_SUB, Long128Vector.class, long.class, LENGTH, 538 this, 539 v -> (long) v.rOp((long) 0, (i, a, b) -> (long) (a - b))); 540 } 541 542 // Memory operations 543 544 @Override 545 @ForceInline 546 public void intoArray(long[] a, int ix) { 547 Objects.requireNonNull(a); 548 ix = VectorIntrinsics.checkIndex(ix, a.length, LENGTH); 549 VectorIntrinsics.store(Long128Vector.class, long.class, LENGTH, 550 a, ix, this, 551 (arr, idx, v) -> v.forEach((i, a_) -> ((long[])arr)[idx + i] = a_)); 552 } 553 554 @Override 555 @ForceInline 556 public void intoArray(long[] a, int ax, Mask<Long, Shapes.S128Bit> m) { 557 // TODO: use better default impl: forEach(m, (i, a_) -> a[ax + i] = a_); 558 Long128Vector oldVal = SPECIES.fromArray(a, ax); 559 Long128Vector newVal = oldVal.blend(this, m); 560 newVal.intoArray(a, ax); 561 } 562 563 // 564 565 @Override 566 public String toString() { 567 return Arrays.toString(getElements()); 568 } 569 570 @Override 571 public boolean equals(Object o) { 572 if (this == o) return true; 573 if (o == null || this.getClass() != o.getClass()) return false; 574 575 Long128Vector that = (Long128Vector) o; 576 return Arrays.equals(this.getElements(), that.getElements()); 577 } 578 579 @Override 580 public int hashCode() { 581 return Arrays.hashCode(vec); 582 } 583 584 // Binary test 585 586 @Override 587 Long128Mask bTest(Vector<Long, Shapes.S128Bit> o, FBinTest f) { 588 long[] vec1 = getElements(); 589 long[] vec2 = ((Long128Vector)o).getElements(); 590 boolean[] bits = new boolean[length()]; 591 for (int i = 0; i < length(); i++){ 592 bits[i] = f.apply(i, vec1[i], vec2[i]); 593 } 594 return new Long128Mask(bits); 595 } 596 597 // Comparisons 598 599 @Override 600 @ForceInline 601 public Long128Mask equal(Vector<Long, Shapes.S128Bit> o) { 602 Objects.requireNonNull(o); 603 Long128Vector v = (Long128Vector)o; 604 605 return (Long128Mask) VectorIntrinsics.compare( 606 BT_eq, Long128Vector.class, Long128Mask.class, long.class, LENGTH, 607 this, v, 608 (v1, v2) -> v1.bTest(v2, (i, a, b) -> a == b)); 609 } 610 611 @Override 612 @ForceInline 613 public Long128Mask notEqual(Vector<Long, Shapes.S128Bit> o) { 614 Objects.requireNonNull(o); 615 Long128Vector v = (Long128Vector)o; 616 617 return (Long128Mask) VectorIntrinsics.compare( 618 BT_ne, Long128Vector.class, Long128Mask.class, long.class, LENGTH, 619 this, v, 620 (v1, v2) -> v1.bTest(v2, (i, a, b) -> a != b)); 621 } 622 623 @Override 624 @ForceInline 625 public Long128Mask lessThan(Vector<Long, Shapes.S128Bit> o) { 626 Objects.requireNonNull(o); 627 Long128Vector v = (Long128Vector)o; 628 629 return (Long128Mask) VectorIntrinsics.compare( 630 BT_lt, Long128Vector.class, Long128Mask.class, long.class, LENGTH, 631 this, v, 632 (v1, v2) -> v1.bTest(v2, (i, a, b) -> a < b)); 633 } 634 635 @Override 636 @ForceInline 637 public Long128Mask lessThanEq(Vector<Long, Shapes.S128Bit> o) { 638 Objects.requireNonNull(o); 639 Long128Vector v = (Long128Vector)o; 640 641 return (Long128Mask) VectorIntrinsics.compare( 642 BT_le, Long128Vector.class, Long128Mask.class, long.class, LENGTH, 643 this, v, 644 (v1, v2) -> v1.bTest(v2, (i, a, b) -> a <= b)); 645 } 646 647 @Override 648 @ForceInline 649 public Long128Mask greaterThan(Vector<Long, Shapes.S128Bit> o) { 650 Objects.requireNonNull(o); 651 Long128Vector v = (Long128Vector)o; 652 653 return (Long128Mask) VectorIntrinsics.compare( 654 BT_gt, Long128Vector.class, Long128Mask.class, long.class, LENGTH, 655 this, v, 656 (v1, v2) -> v1.bTest(v2, (i, a, b) -> a > b)); 657 } 658 659 @Override 660 @ForceInline 661 public Long128Mask greaterThanEq(Vector<Long, Shapes.S128Bit> o) { 662 Objects.requireNonNull(o); 663 Long128Vector v = (Long128Vector)o; 664 665 return (Long128Mask) VectorIntrinsics.compare( 666 BT_ge, Long128Vector.class, Long128Mask.class, long.class, LENGTH, 667 this, v, 668 (v1, v2) -> v1.bTest(v2, (i, a, b) -> a >= b)); 669 } 670 671 // Foreach 672 673 @Override 674 void forEach(FUnCon f) { 675 long[] vec = getElements(); 676 for (int i = 0; i < length(); i++) { 677 f.apply(i, vec[i]); 678 } 679 } 680 681 @Override 682 void forEach(Mask<Long, Shapes.S128Bit> o, FUnCon f) { 683 boolean[] mbits = ((Long128Mask)o).getBits(); 684 forEach((i, a) -> { 685 if (mbits[i]) { f.apply(i, a); } 686 }); 687 } 688 689 690 Double128Vector toFP() { 691 long[] vec = getElements(); 692 double[] res = new double[this.species().length()]; 693 for(int i = 0; i < this.species().length(); i++){ 694 res[i] = Double.longBitsToDouble(vec[i]); 695 } 696 return new Double128Vector(res); 697 } 698 699 @Override 700 public Long128Vector rotateEL(int j) { 701 long[] vec = getElements(); 702 long[] res = new long[length()]; 703 for (int i = 0; i < length(); i++){ 704 res[(j + i) % length()] = vec[i]; 705 } 706 return new Long128Vector(res); 707 } 708 709 @Override 710 public Long128Vector rotateER(int j) { 711 long[] vec = getElements(); 712 long[] res = new long[length()]; 713 for (int i = 0; i < length(); i++){ 714 int z = i - j; 715 if(j < 0) { 716 res[length() + z] = vec[i]; 717 } else { 718 res[z] = vec[i]; 719 } 720 } 721 return new Long128Vector(res); 722 } 723 724 @Override 725 public Long128Vector shiftEL(int j) { 726 long[] vec = getElements(); 727 long[] res = new long[length()]; 728 for (int i = 0; i < length() - j; i++) { 729 res[i] = vec[i + j]; 730 } 731 return new Long128Vector(res); 732 } 733 734 @Override 735 public Long128Vector shiftER(int j) { 736 long[] vec = getElements(); 737 long[] res = new long[length()]; 738 for (int i = 0; i < length() - j; i++){ 739 res[i + j] = vec[i]; 740 } 741 return new Long128Vector(res); 742 } 743 744 @Override 745 public Long128Vector shuffle(Vector<Long, Shapes.S128Bit> o, Shuffle<Long, Shapes.S128Bit> s) { 746 Long128Vector v = (Long128Vector) o; 747 return uOp((i, a) -> { 748 long[] vec = this.getElements(); 749 int e = s.getElement(i); 750 if(e >= 0 && e < length()) { 751 //from this 752 return vec[e]; 753 } else if(e < length() * 2) { 754 //from o 755 return v.getElements()[e - length()]; 756 } else { 757 throw new ArrayIndexOutOfBoundsException("Bad reordering for shuffle"); 758 } 759 }); 760 } 761 762 @Override 763 public Long128Vector swizzle(Shuffle<Long, Shapes.S128Bit> s) { 764 return uOp((i, a) -> { 765 long[] vec = this.getElements(); 766 int e = s.getElement(i); 767 if(e >= 0 && e < length()) { 768 return vec[e]; 769 } else { 770 throw new ArrayIndexOutOfBoundsException("Bad reordering for shuffle"); 771 } 772 }); 773 } 774 775 @Override 776 @ForceInline 777 public Long128Vector blend(Vector<Long, Shapes.S128Bit> o1, Mask<Long, Shapes.S128Bit> o2) { 778 Objects.requireNonNull(o1); 779 Objects.requireNonNull(o2); 780 Long128Vector v = (Long128Vector)o1; 781 Long128Mask m = (Long128Mask)o2; 782 783 return (Long128Vector) VectorIntrinsics.blend( 784 Long128Vector.class, Long128Mask.class, long.class, LENGTH, 785 this, v, m, 786 (v1, v2, m_) -> v1.bOp(v2, (i, a, b) -> m_.getElement(i) ? b : a)); 787 } 788 789 // Accessors 790 791 @Override 792 public long get(int i) { 793 long[] vec = getElements(); 794 return vec[i]; 795 } 796 797 @Override 798 public Long128Vector with(int i, long e) { 799 long[] res = vec.clone(); 800 res[i] = e; 801 return new Long128Vector(res); 802 } 803 804 // Mask 805 806 static final class Long128Mask extends AbstractMask<Long, Shapes.S128Bit> { 807 static final Long128Mask TRUE_MASK = new Long128Mask(true); 808 static final Long128Mask FALSE_MASK = new Long128Mask(false); 809 810 // FIXME: was temporarily put here to simplify rematerialization support in the JVM 811 private final boolean[] bits; // Don't access directly, use getBits() instead. 812 813 public Long128Mask(boolean[] bits) { 814 this(bits, 0); 815 } 816 817 public Long128Mask(boolean[] bits, int i) { 818 this.bits = Arrays.copyOfRange(bits, i, i + species().length()); 819 } 820 821 public Long128Mask(boolean val) { 822 boolean[] bits = new boolean[species().length()]; 823 Arrays.fill(bits, val); 824 this.bits = bits; 825 } 826 827 boolean[] getBits() { 828 return VectorIntrinsics.maybeRebox(this).bits; 829 } 830 831 @Override 832 Long128Mask uOp(MUnOp f) { 833 boolean[] res = new boolean[species().length()]; 834 boolean[] bits = getBits(); 835 for (int i = 0; i < species().length(); i++) { 836 res[i] = f.apply(i, bits[i]); 837 } 838 return new Long128Mask(res); 839 } 840 841 @Override 842 Long128Mask bOp(Mask<Long, Shapes.S128Bit> o, MBinOp f) { 843 boolean[] res = new boolean[species().length()]; 844 boolean[] bits = getBits(); 845 boolean[] mbits = ((Long128Mask)o).getBits(); 846 for (int i = 0; i < species().length(); i++) { 847 res[i] = f.apply(i, bits[i], mbits[i]); 848 } 849 return new Long128Mask(res); 850 } 851 852 @Override 853 public Long128Species species() { 854 return SPECIES; 855 } 856 857 @Override 858 public Long128Vector toVector() { 859 long[] res = new long[species().length()]; 860 boolean[] bits = getBits(); 861 for (int i = 0; i < species().length(); i++) { 862 res[i] = (long) (bits[i] ? -1 : 0); 863 } 864 return new Long128Vector(res); 865 } 866 867 @Override 868 @ForceInline 869 @SuppressWarnings("unchecked") 870 public <Z> Mask<Z, Shapes.S128Bit> rebracket(Species<Z, Shapes.S128Bit> species) { 871 Objects.requireNonNull(species); 872 // TODO: check proper element type 873 return VectorIntrinsics.reinterpret( 874 Long128Mask.class, long.class, LENGTH, 875 species.elementType(), species.length(), this, 876 (m, t) -> m.reshape(species) 877 ); 878 } 879 880 // Unary operations 881 882 //Mask<E, S> not(); 883 884 // Binary operations 885 886 @Override 887 @ForceInline 888 public Long128Mask and(Mask<Long,Shapes.S128Bit> o) { 889 Objects.requireNonNull(o); 890 Long128Mask m = (Long128Mask)o; 891 return VectorIntrinsics.binaryOp(VECTOR_OP_AND, Long128Mask.class, long.class, LENGTH, 892 this, m, 893 (m1, m2) -> m1.bOp(m2, (i, a, b) -> a & b)); 894 } 895 896 @Override 897 @ForceInline 898 public Long128Mask or(Mask<Long,Shapes.S128Bit> o) { 899 Objects.requireNonNull(o); 900 Long128Mask m = (Long128Mask)o; 901 return VectorIntrinsics.binaryOp(VECTOR_OP_OR, Long128Mask.class, long.class, LENGTH, 902 this, m, 903 (m1, m2) -> m1.bOp(m2, (i, a, b) -> a | b)); 904 } 905 906 // Reductions 907 908 @Override 909 @ForceInline 910 public boolean anyTrue() { 911 return VectorIntrinsics.test(COND_notZero, Long128Mask.class, long.class, LENGTH, 912 this, this, 913 (m1, m2) -> super.anyTrue()); 914 } 915 916 @Override 917 @ForceInline 918 public boolean allTrue() { 919 return VectorIntrinsics.test(COND_carrySet, Long128Mask.class, long.class, LENGTH, 920 this, species().maskAllTrue(), 921 (m1, m2) -> super.allTrue()); 922 } 923 } 924 925 // Shuffle 926 927 static final class Long128Shuffle extends AbstractShuffle<Long, Shapes.S128Bit> { 928 static final IntVector.IntSpecies<Shapes.S128Bit> INT_SPECIES = IntVector.speciesInstance(Shapes.S_128_BIT); 929 930 public Long128Shuffle(int[] reorder) { 931 super(reorder); 932 } 933 934 public Long128Shuffle(int[] reorder, int i) { 935 super(reorder, i); 936 } 937 938 @Override 939 public Long128Species species() { 940 return SPECIES; 941 } 942 943 @Override 944 public IntVector.IntSpecies<Shapes.S128Bit> intSpecies() { 945 return INT_SPECIES; 946 } 947 } 948 949 // Species 950 951 @Override 952 public Long128Species species() { 953 return SPECIES; 954 } 955 956 static final class Long128Species extends LongSpecies<Shapes.S128Bit> { 957 static final int BIT_SIZE = Shapes.S_128_BIT.bitSize(); 958 959 static final int LENGTH = BIT_SIZE / Long.SIZE; 960 961 @Override 962 public String toString() { 963 StringBuilder sb = new StringBuilder("Shape["); 964 sb.append(bitSize()).append(" bits, "); 965 sb.append(length()).append(" ").append(long.class.getSimpleName()).append("s x "); 966 sb.append(elementSize()).append(" bits"); 967 sb.append("]"); 968 return sb.toString(); 969 } 970 971 @Override 972 @ForceInline 973 public int bitSize() { 974 return BIT_SIZE; 975 } 976 977 @Override 978 @ForceInline 979 public int length() { 980 return LENGTH; 981 } 982 983 @Override 984 @ForceInline 985 public Class<Long> elementType() { 986 return long.class; 987 } 988 989 @Override 990 @ForceInline 991 public int elementSize() { 992 return Long.SIZE; 993 } 994 995 @Override 996 @ForceInline 997 public Shapes.S128Bit shape() { 998 return Shapes.S_128_BIT; 999 } 1000 1001 @Override 1002 Long128Vector op(FOp f) { 1003 long[] res = new long[length()]; 1004 for (int i = 0; i < length(); i++) { 1005 res[i] = f.apply(i); 1006 } 1007 return new Long128Vector(res); 1008 } 1009 1010 @Override 1011 Long128Vector op(Mask<Long, Shapes.S128Bit> o, FOp f) { 1012 long[] res = new long[length()]; 1013 boolean[] mbits = ((Long128Mask)o).getBits(); 1014 for (int i = 0; i < length(); i++) { 1015 if (mbits[i]) { 1016 res[i] = f.apply(i); 1017 } 1018 } 1019 return new Long128Vector(res); 1020 } 1021 1022 // Factories 1023 1024 @Override 1025 public Long128Mask maskFromValues(boolean... bits) { 1026 return new Long128Mask(bits); 1027 } 1028 1029 @Override 1030 public Long128Mask maskFromArray(boolean[] bits, int i) { 1031 return new Long128Mask(bits, i); 1032 } 1033 1034 @Override 1035 public Long128Shuffle shuffleFromValues(int... ixs) { 1036 return new Long128Shuffle(ixs); 1037 } 1038 1039 @Override 1040 public Long128Shuffle shuffleFromArray(int[] ixs, int i) { 1041 return new Long128Shuffle(ixs, i); 1042 } 1043 1044 @Override 1045 public Long128Shuffle shuffleFromVector(Vector<Integer, Shapes.S128Bit> v) { 1046 int[] a = ((IntVector<Shapes.S128Bit>) v).toArray(); 1047 return new Long128Shuffle(a, 0); 1048 } 1049 1050 @Override 1051 @ForceInline 1052 public Long128Vector zero() { 1053 return VectorIntrinsics.broadcastCoerced(Long128Vector.class, long.class, LENGTH, 1054 0, 1055 (z -> ZERO)); 1056 } 1057 1058 @Override 1059 @ForceInline 1060 public Long128Vector broadcast(long e) { 1061 return VectorIntrinsics.broadcastCoerced( 1062 Long128Vector.class, long.class, LENGTH, 1063 e, 1064 ((long bits) -> SPECIES.op(i -> (long)bits))); 1065 } 1066 1067 @Override 1068 @ForceInline 1069 public Long128Mask maskAllTrue() { 1070 return VectorIntrinsics.broadcastCoerced(Long128Mask.class, long.class, LENGTH, 1071 (long)-1, 1072 (z -> Long128Mask.TRUE_MASK)); 1073 } 1074 1075 @Override 1076 @ForceInline 1077 public Long128Mask maskAllFalse() { 1078 return VectorIntrinsics.broadcastCoerced(Long128Mask.class, long.class, LENGTH, 1079 0, 1080 (z -> Long128Mask.FALSE_MASK)); 1081 } 1082 1083 @Override 1084 @ForceInline 1085 public Long128Vector fromArray(long[] a, int ix) { 1086 Objects.requireNonNull(a); 1087 ix = VectorIntrinsics.checkIndex(ix, a.length, LENGTH); 1088 return (Long128Vector) VectorIntrinsics.load(Long128Vector.class, long.class, LENGTH, 1089 a, ix, 1090 (arr, idx) -> super.fromArray((long[]) arr, idx)); 1091 } 1092 1093 @Override 1094 @ForceInline 1095 public Long128Vector fromArray(long[] a, int ax, Mask<Long, Shapes.S128Bit> m) { 1096 return zero().blend(fromArray(a, ax), m); // TODO: use better default impl: op(m, i -> a[ax + i]); 1097 } 1098 1099 @ForceInline 1100 @SuppressWarnings("unchecked") 1101 private <S extends Shape> Long128Vector castFromByte(ByteVector<S> o) { 1102 if (o.bitSize() == 64) { 1103 Byte64Vector so = (Byte64Vector)o; 1104 return VectorIntrinsics.cast( 1105 Byte64Vector.class, byte.class, so.length(), 1106 long.class, LENGTH, so, 1107 (v, t) -> (Long128Vector)super.cast(v) 1108 ); 1109 } else if (o.bitSize() == 128) { 1110 Byte128Vector so = (Byte128Vector)o; 1111 return VectorIntrinsics.cast( 1112 Byte128Vector.class, byte.class, so.length(), 1113 long.class, LENGTH, so, 1114 (v, t) -> (Long128Vector)super.cast(v) 1115 ); 1116 } else if (o.bitSize() == 256) { 1117 Byte256Vector so = (Byte256Vector)o; 1118 return VectorIntrinsics.cast( 1119 Byte256Vector.class, byte.class, so.length(), 1120 long.class, LENGTH, so, 1121 (v, t) -> (Long128Vector)super.cast(v) 1122 ); 1123 } else if (o.bitSize() == 512) { 1124 Byte512Vector so = (Byte512Vector)o; 1125 return VectorIntrinsics.cast( 1126 Byte512Vector.class, byte.class, so.length(), 1127 long.class, LENGTH, so, 1128 (v, t) -> (Long128Vector)super.cast(v) 1129 ); 1130 } else { 1131 throw new InternalError("Unimplemented size"); 1132 } 1133 } 1134 1135 @ForceInline 1136 @SuppressWarnings("unchecked") 1137 private <S extends Shape> Long128Vector castFromShort(ShortVector<S> o) { 1138 if (o.bitSize() == 64) { 1139 Short64Vector so = (Short64Vector)o; 1140 return VectorIntrinsics.cast( 1141 Short64Vector.class, short.class, so.length(), 1142 long.class, LENGTH, so, 1143 (v, t) -> (Long128Vector)super.cast(v) 1144 ); 1145 } else if (o.bitSize() == 128) { 1146 Short128Vector so = (Short128Vector)o; 1147 return VectorIntrinsics.cast( 1148 Short128Vector.class, short.class, so.length(), 1149 long.class, LENGTH, so, 1150 (v, t) -> (Long128Vector)super.cast(v) 1151 ); 1152 } else if (o.bitSize() == 256) { 1153 Short256Vector so = (Short256Vector)o; 1154 return VectorIntrinsics.cast( 1155 Short256Vector.class, short.class, so.length(), 1156 long.class, LENGTH, so, 1157 (v, t) -> (Long128Vector)super.cast(v) 1158 ); 1159 } else if (o.bitSize() == 512) { 1160 Short512Vector so = (Short512Vector)o; 1161 return VectorIntrinsics.cast( 1162 Short512Vector.class, short.class, so.length(), 1163 long.class, LENGTH, so, 1164 (v, t) -> (Long128Vector)super.cast(v) 1165 ); 1166 } else { 1167 throw new InternalError("Unimplemented size"); 1168 } 1169 } 1170 1171 @ForceInline 1172 @SuppressWarnings("unchecked") 1173 private <S extends Shape> Long128Vector castFromInt(IntVector<S> o) { 1174 if (o.bitSize() == 64) { 1175 Int64Vector so = (Int64Vector)o; 1176 return VectorIntrinsics.cast( 1177 Int64Vector.class, int.class, so.length(), 1178 long.class, LENGTH, so, 1179 (v, t) -> (Long128Vector)super.cast(v) 1180 ); 1181 } else if (o.bitSize() == 128) { 1182 Int128Vector so = (Int128Vector)o; 1183 return VectorIntrinsics.cast( 1184 Int128Vector.class, int.class, so.length(), 1185 long.class, LENGTH, so, 1186 (v, t) -> (Long128Vector)super.cast(v) 1187 ); 1188 } else if (o.bitSize() == 256) { 1189 Int256Vector so = (Int256Vector)o; 1190 return VectorIntrinsics.cast( 1191 Int256Vector.class, int.class, so.length(), 1192 long.class, LENGTH, so, 1193 (v, t) -> (Long128Vector)super.cast(v) 1194 ); 1195 } else if (o.bitSize() == 512) { 1196 Int512Vector so = (Int512Vector)o; 1197 return VectorIntrinsics.cast( 1198 Int512Vector.class, int.class, so.length(), 1199 long.class, LENGTH, so, 1200 (v, t) -> (Long128Vector)super.cast(v) 1201 ); 1202 } else { 1203 throw new InternalError("Unimplemented size"); 1204 } 1205 } 1206 1207 @ForceInline 1208 @SuppressWarnings("unchecked") 1209 private <S extends Shape> Long128Vector castFromLong(LongVector<S> o) { 1210 if (o.bitSize() == 64) { 1211 Long64Vector so = (Long64Vector)o; 1212 return VectorIntrinsics.cast( 1213 Long64Vector.class, long.class, so.length(), 1214 long.class, LENGTH, so, 1215 (v, t) -> (Long128Vector)super.cast(v) 1216 ); 1217 } else if (o.bitSize() == 128) { 1218 Long128Vector so = (Long128Vector)o; 1219 return VectorIntrinsics.cast( 1220 Long128Vector.class, long.class, so.length(), 1221 long.class, LENGTH, so, 1222 (v, t) -> (Long128Vector)super.cast(v) 1223 ); 1224 } else if (o.bitSize() == 256) { 1225 Long256Vector so = (Long256Vector)o; 1226 return VectorIntrinsics.cast( 1227 Long256Vector.class, long.class, so.length(), 1228 long.class, LENGTH, so, 1229 (v, t) -> (Long128Vector)super.cast(v) 1230 ); 1231 } else if (o.bitSize() == 512) { 1232 Long512Vector so = (Long512Vector)o; 1233 return VectorIntrinsics.cast( 1234 Long512Vector.class, long.class, so.length(), 1235 long.class, LENGTH, so, 1236 (v, t) -> (Long128Vector)super.cast(v) 1237 ); 1238 } else { 1239 throw new InternalError("Unimplemented size"); 1240 } 1241 } 1242 1243 @ForceInline 1244 @SuppressWarnings("unchecked") 1245 private <S extends Shape> Long128Vector castFromFloat(FloatVector<S> o) { 1246 if (o.bitSize() == 64) { 1247 Float64Vector so = (Float64Vector)o; 1248 return VectorIntrinsics.cast( 1249 Float64Vector.class, float.class, so.length(), 1250 long.class, LENGTH, so, 1251 (v, t) -> (Long128Vector)super.cast(v) 1252 ); 1253 } else if (o.bitSize() == 128) { 1254 Float128Vector so = (Float128Vector)o; 1255 return VectorIntrinsics.cast( 1256 Float128Vector.class, float.class, so.length(), 1257 long.class, LENGTH, so, 1258 (v, t) -> (Long128Vector)super.cast(v) 1259 ); 1260 } else if (o.bitSize() == 256) { 1261 Float256Vector so = (Float256Vector)o; 1262 return VectorIntrinsics.cast( 1263 Float256Vector.class, float.class, so.length(), 1264 long.class, LENGTH, so, 1265 (v, t) -> (Long128Vector)super.cast(v) 1266 ); 1267 } else if (o.bitSize() == 512) { 1268 Float512Vector so = (Float512Vector)o; 1269 return VectorIntrinsics.cast( 1270 Float512Vector.class, float.class, so.length(), 1271 long.class, LENGTH, so, 1272 (v, t) -> (Long128Vector)super.cast(v) 1273 ); 1274 } else { 1275 throw new InternalError("Unimplemented size"); 1276 } 1277 } 1278 1279 @ForceInline 1280 @SuppressWarnings("unchecked") 1281 private <S extends Shape> Long128Vector castFromDouble(DoubleVector<S> o) { 1282 if (o.bitSize() == 64) { 1283 Double64Vector so = (Double64Vector)o; 1284 return VectorIntrinsics.cast( 1285 Double64Vector.class, double.class, so.length(), 1286 long.class, LENGTH, so, 1287 (v, t) -> (Long128Vector)super.cast(v) 1288 ); 1289 } else if (o.bitSize() == 128) { 1290 Double128Vector so = (Double128Vector)o; 1291 return VectorIntrinsics.cast( 1292 Double128Vector.class, double.class, so.length(), 1293 long.class, LENGTH, so, 1294 (v, t) -> (Long128Vector)super.cast(v) 1295 ); 1296 } else if (o.bitSize() == 256) { 1297 Double256Vector so = (Double256Vector)o; 1298 return VectorIntrinsics.cast( 1299 Double256Vector.class, double.class, so.length(), 1300 long.class, LENGTH, so, 1301 (v, t) -> (Long128Vector)super.cast(v) 1302 ); 1303 } else if (o.bitSize() == 512) { 1304 Double512Vector so = (Double512Vector)o; 1305 return VectorIntrinsics.cast( 1306 Double512Vector.class, double.class, so.length(), 1307 long.class, LENGTH, so, 1308 (v, t) -> (Long128Vector)super.cast(v) 1309 ); 1310 } else { 1311 throw new InternalError("Unimplemented size"); 1312 } 1313 } 1314 1315 @Override 1316 @ForceInline 1317 @SuppressWarnings("unchecked") 1318 public <E, S extends Shape> Long128Vector cast(Vector<E, S> o) { 1319 Objects.requireNonNull(o); 1320 if (o.elementType() == byte.class) { 1321 ByteVector<S> so = (ByteVector<S>)o; 1322 return castFromByte(so); 1323 } else if (o.elementType() == short.class) { 1324 ShortVector<S> so = (ShortVector<S>)o; 1325 return castFromShort(so); 1326 } else if (o.elementType() == int.class) { 1327 IntVector<S> so = (IntVector<S>)o; 1328 return castFromInt(so); 1329 } else if (o.elementType() == long.class) { 1330 LongVector<S> so = (LongVector<S>)o; 1331 return castFromLong(so); 1332 } else if (o.elementType() == float.class) { 1333 FloatVector<S> so = (FloatVector<S>)o; 1334 return castFromFloat(so); 1335 } else if (o.elementType() == double.class) { 1336 DoubleVector<S> so = (DoubleVector<S>)o; 1337 return castFromDouble(so); 1338 } else { 1339 throw new InternalError("Unimplemented type"); 1340 } 1341 } 1342 1343 @Override 1344 @ForceInline 1345 @SuppressWarnings("unchecked") 1346 public <F> Long128Vector rebracket(Vector<F, Shapes.S128Bit> o) { 1347 Objects.requireNonNull(o); 1348 if (o.elementType() == byte.class) { 1349 Byte128Vector so = (Byte128Vector)o; 1350 return VectorIntrinsics.reinterpret( 1351 Byte128Vector.class, byte.class, so.length(), 1352 long.class, LENGTH, so, 1353 (v, t) -> (Long128Vector)reshape(v) 1354 ); 1355 } else if (o.elementType() == short.class) { 1356 Short128Vector so = (Short128Vector)o; 1357 return VectorIntrinsics.reinterpret( 1358 Short128Vector.class, short.class, so.length(), 1359 long.class, LENGTH, so, 1360 (v, t) -> (Long128Vector)reshape(v) 1361 ); 1362 } else if (o.elementType() == int.class) { 1363 Int128Vector so = (Int128Vector)o; 1364 return VectorIntrinsics.reinterpret( 1365 Int128Vector.class, int.class, so.length(), 1366 long.class, LENGTH, so, 1367 (v, t) -> (Long128Vector)reshape(v) 1368 ); 1369 } else if (o.elementType() == long.class) { 1370 Long128Vector so = (Long128Vector)o; 1371 return VectorIntrinsics.reinterpret( 1372 Long128Vector.class, long.class, so.length(), 1373 long.class, LENGTH, so, 1374 (v, t) -> (Long128Vector)reshape(v) 1375 ); 1376 } else if (o.elementType() == float.class) { 1377 Float128Vector so = (Float128Vector)o; 1378 return VectorIntrinsics.reinterpret( 1379 Float128Vector.class, float.class, so.length(), 1380 long.class, LENGTH, so, 1381 (v, t) -> (Long128Vector)reshape(v) 1382 ); 1383 } else if (o.elementType() == double.class) { 1384 Double128Vector so = (Double128Vector)o; 1385 return VectorIntrinsics.reinterpret( 1386 Double128Vector.class, double.class, so.length(), 1387 long.class, LENGTH, so, 1388 (v, t) -> (Long128Vector)reshape(v) 1389 ); 1390 } else { 1391 throw new InternalError("Unimplemented type"); 1392 } 1393 } 1394 1395 @Override 1396 @ForceInline 1397 @SuppressWarnings("unchecked") 1398 public <T extends Shape> Long128Vector resize(Vector<Long, T> o) { 1399 Objects.requireNonNull(o); 1400 if (o.bitSize() == 64) { 1401 Long64Vector so = (Long64Vector)o; 1402 return VectorIntrinsics.reinterpret( 1403 Long64Vector.class, long.class, so.length(), 1404 long.class, LENGTH, so, 1405 (v, t) -> (Long128Vector)reshape(v) 1406 ); 1407 } else if (o.bitSize() == 128) { 1408 Long128Vector so = (Long128Vector)o; 1409 return VectorIntrinsics.reinterpret( 1410 Long128Vector.class, long.class, so.length(), 1411 long.class, LENGTH, so, 1412 (v, t) -> (Long128Vector)reshape(v) 1413 ); 1414 } else if (o.bitSize() == 256) { 1415 Long256Vector so = (Long256Vector)o; 1416 return VectorIntrinsics.reinterpret( 1417 Long256Vector.class, long.class, so.length(), 1418 long.class, LENGTH, so, 1419 (v, t) -> (Long128Vector)reshape(v) 1420 ); 1421 } else if (o.bitSize() == 512) { 1422 Long512Vector so = (Long512Vector)o; 1423 return VectorIntrinsics.reinterpret( 1424 Long512Vector.class, long.class, so.length(), 1425 long.class, LENGTH, so, 1426 (v, t) -> (Long128Vector)reshape(v) 1427 ); 1428 } else { 1429 throw new InternalError("Unimplemented size"); 1430 } 1431 } 1432 } 1433 }