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