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