1 /* 2 * Copyright (c) 2017, 2019, 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.DoubleBuffer; 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 jdk.internal.vm.annotation.Stable; 38 39 import static jdk.incubator.vector.VectorIntrinsics.*; 40 import static jdk.incubator.vector.VectorOperators.*; 41 42 // -- This file was mechanically generated: Do not edit! -- // 43 44 @SuppressWarnings("cast") // warning: redundant cast 45 final class Double64Vector extends DoubleVector { 46 static final DoubleSpecies VSPECIES = 47 (DoubleSpecies) DoubleVector.SPECIES_64; 48 49 static final VectorShape VSHAPE = 50 VSPECIES.vectorShape(); 51 52 static final Class<Double64Vector> VCLASS = Double64Vector.class; 53 54 static final int VSIZE = VSPECIES.vectorBitSize(); 55 56 static final int VLENGTH = VSPECIES.laneCount(); 57 58 static final Class<Double> ETYPE = double.class; 59 60 // The JVM expects to find the state here. 61 private final double[] vec; // Don't access directly, use getElements() instead. 62 63 Double64Vector(double[] v) { 64 vec = v; 65 } 66 67 // For compatibility as Double64Vector::new, 68 // stored into species.vectorFactory. 69 Double64Vector(Object v) { 70 this((double[]) v); 71 } 72 73 static final Double64Vector ZERO = new Double64Vector(new double[VLENGTH]); 74 static final Double64Vector IOTA = new Double64Vector(VSPECIES.iotaArray()); 75 76 static { 77 // Warm up a few species caches. 78 // If we do this too much we will 79 // get NPEs from bootstrap circularity. 80 VSPECIES.dummyVector(); 81 VSPECIES.withLanes(LaneType.BYTE); 82 } 83 84 // Specialized extractors 85 86 @ForceInline 87 final @Override 88 public DoubleSpecies vspecies() { 89 // ISSUE: This should probably be a @Stable 90 // field inside AbstractVector, rather than 91 // a megamorphic method. 92 return VSPECIES; 93 } 94 95 @ForceInline 96 @Override 97 public final Class<Double> elementType() { return double.class; } 98 99 @ForceInline 100 @Override 101 public final int elementSize() { return Double.SIZE; } 102 103 @ForceInline 104 @Override 105 public final VectorShape shape() { return VSHAPE; } 106 107 @ForceInline 108 @Override 109 public final int length() { return VLENGTH; } 110 111 @ForceInline 112 @Override 113 public final int bitSize() { return VSIZE; } 114 115 @ForceInline 116 @Override 117 public final int byteSize() { return VSIZE / Byte.SIZE; } 118 119 /*package-private*/ 120 @ForceInline 121 final @Override 122 double[] getElements() { 123 return VectorIntrinsics.maybeRebox(this).vec; 124 } 125 126 // Virtualized constructors 127 128 @Override 129 @ForceInline 130 public final Double64Vector broadcast(double e) { 131 return (Double64Vector) super.broadcastTemplate(e); // specialize 132 } 133 134 @Override 135 @ForceInline 136 public final Double64Vector broadcast(long e) { 137 return (Double64Vector) super.broadcastTemplate(e); // specialize 138 } 139 140 @Override 141 @ForceInline 142 Double64Mask maskFromArray(boolean[] bits) { 143 return new Double64Mask(bits); 144 } 145 146 @Override 147 @ForceInline 148 Double64Shuffle iotaShuffle() { return Double64Shuffle.IOTA; } 149 150 @ForceInline 151 Double64Shuffle iotaShuffle(int start) { 152 return (Double64Shuffle)VectorIntrinsics.shuffleIota(ETYPE, Double64Shuffle.class, VSPECIES, VLENGTH, start, (val, l) -> new Double64Shuffle(i -> (VectorIntrinsics.wrapToRange(i + val, l)))); 153 } 154 155 @Override 156 @ForceInline 157 Double64Shuffle shuffleFromBytes(byte[] reorder) { return new Double64Shuffle(reorder); } 158 159 @Override 160 @ForceInline 161 Double64Shuffle shuffleFromArray(int[] indexes, int i) { return new Double64Shuffle(indexes, i); } 162 163 @Override 164 @ForceInline 165 Double64Shuffle shuffleFromOp(IntUnaryOperator fn) { return new Double64Shuffle(fn); } 166 167 // Make a vector of the same species but the given elements: 168 @ForceInline 169 final @Override 170 Double64Vector vectorFactory(double[] vec) { 171 return new Double64Vector(vec); 172 } 173 174 @ForceInline 175 final @Override 176 Byte64Vector asByteVectorRaw() { 177 return (Byte64Vector) super.asByteVectorRawTemplate(); // specialize 178 } 179 180 @ForceInline 181 final @Override 182 AbstractVector<?> asVectorRaw(LaneType laneType) { 183 return super.asVectorRawTemplate(laneType); // specialize 184 } 185 186 // Unary operator 187 188 final @Override 189 Double64Vector uOp(FUnOp f) { 190 return (Double64Vector) super.uOpTemplate(f); // specialize 191 } 192 193 @ForceInline 194 final @Override 195 Double64Vector uOp(VectorMask<Double> m, FUnOp f) { 196 return (Double64Vector) 197 super.uOpTemplate((Double64Mask)m, f); // specialize 198 } 199 200 // Binary operator 201 202 @ForceInline 203 final @Override 204 Double64Vector bOp(Vector<Double> v, FBinOp f) { 205 return (Double64Vector) super.bOpTemplate((Double64Vector)v, f); // specialize 206 } 207 208 @ForceInline 209 final @Override 210 Double64Vector bOp(Vector<Double> v, 211 VectorMask<Double> m, FBinOp f) { 212 return (Double64Vector) 213 super.bOpTemplate((Double64Vector)v, (Double64Mask)m, 214 f); // specialize 215 } 216 217 // Ternary operator 218 219 @ForceInline 220 final @Override 221 Double64Vector tOp(Vector<Double> v1, Vector<Double> v2, FTriOp f) { 222 return (Double64Vector) 223 super.tOpTemplate((Double64Vector)v1, (Double64Vector)v2, 224 f); // specialize 225 } 226 227 @ForceInline 228 final @Override 229 Double64Vector tOp(Vector<Double> v1, Vector<Double> v2, 230 VectorMask<Double> m, FTriOp f) { 231 return (Double64Vector) 232 super.tOpTemplate((Double64Vector)v1, (Double64Vector)v2, 233 (Double64Mask)m, f); // specialize 234 } 235 236 @ForceInline 237 final @Override 238 double rOp(double v, FBinOp f) { 239 return super.rOpTemplate(v, f); // specialize 240 } 241 242 @Override 243 @ForceInline 244 public final <F> 245 Vector<F> convertShape(VectorOperators.Conversion<Double,F> conv, 246 VectorSpecies<F> rsp, int part) { 247 return super.convertShapeTemplate(conv, rsp, part); // specialize 248 } 249 250 @Override 251 @ForceInline 252 public final <F> 253 Vector<F> reinterpretShape(VectorSpecies<F> toSpecies, int part) { 254 return super.reinterpretShapeTemplate(toSpecies, part); // specialize 255 } 256 257 // Specialized algebraic operations: 258 259 // The following definition forces a specialized version of this 260 // crucial method into the v-table of this class. A call to add() 261 // will inline to a call to lanewise(ADD,), at which point the JIT 262 // intrinsic will have the opcode of ADD, plus all the metadata 263 // for this particular class, enabling it to generate precise 264 // code. 265 // 266 // There is probably no benefit to the JIT to specialize the 267 // masked or broadcast versions of the lanewise method. 268 269 @Override 270 @ForceInline 271 public Double64Vector lanewise(Unary op) { 272 return (Double64Vector) super.lanewiseTemplate(op); // specialize 273 } 274 275 @Override 276 @ForceInline 277 public Double64Vector lanewise(Binary op, Vector<Double> v) { 278 return (Double64Vector) super.lanewiseTemplate(op, v); // specialize 279 } 280 281 282 /*package-private*/ 283 @Override 284 @ForceInline 285 public final 286 Double64Vector 287 lanewise(VectorOperators.Ternary op, Vector<Double> v1, Vector<Double> v2) { 288 return (Double64Vector) super.lanewiseTemplate(op, v1, v2); // specialize 289 } 290 291 @Override 292 @ForceInline 293 public final 294 Double64Vector addIndex(int scale) { 295 return (Double64Vector) super.addIndexTemplate(scale); // specialize 296 } 297 298 // Type specific horizontal reductions 299 300 @Override 301 @ForceInline 302 public final double reduceLanes(VectorOperators.Associative op) { 303 return super.reduceLanesTemplate(op); // specialized 304 } 305 306 @Override 307 @ForceInline 308 public final double reduceLanes(VectorOperators.Associative op, 309 VectorMask<Double> m) { 310 return super.reduceLanesTemplate(op, m); // specialized 311 } 312 313 @Override 314 @ForceInline 315 public final long reduceLanesToLong(VectorOperators.Associative op) { 316 return (long) super.reduceLanesTemplate(op); // specialized 317 } 318 319 @Override 320 @ForceInline 321 public final long reduceLanesToLong(VectorOperators.Associative op, 322 VectorMask<Double> m) { 323 return (long) super.reduceLanesTemplate(op, m); // specialized 324 } 325 326 @Override 327 @ForceInline 328 public VectorShuffle<Double> toShuffle() { 329 double[] a = toArray(); 330 int[] sa = new int[a.length]; 331 for (int i = 0; i < a.length; i++) { 332 sa[i] = (int) a[i]; 333 } 334 return VectorShuffle.fromArray(VSPECIES, sa, 0); 335 } 336 337 // Specialized unary testing 338 339 @Override 340 @ForceInline 341 public final Double64Mask test(Test op) { 342 return super.testTemplate(Double64Mask.class, op); // specialize 343 } 344 345 // Specialized comparisons 346 347 @Override 348 @ForceInline 349 public final Double64Mask compare(Comparison op, Vector<Double> v) { 350 return super.compareTemplate(Double64Mask.class, op, v); // specialize 351 } 352 353 @Override 354 @ForceInline 355 public final Double64Mask compare(Comparison op, double s) { 356 return super.compareTemplate(Double64Mask.class, op, s); // specialize 357 } 358 359 @Override 360 @ForceInline 361 public final Double64Mask compare(Comparison op, long s) { 362 return super.compareTemplate(Double64Mask.class, op, s); // specialize 363 } 364 365 @Override 366 @ForceInline 367 public Double64Vector blend(Vector<Double> v, VectorMask<Double> m) { 368 return (Double64Vector) 369 super.blendTemplate(Double64Mask.class, 370 (Double64Vector) v, 371 (Double64Mask) m); // specialize 372 } 373 374 @Override 375 @ForceInline 376 public Double64Vector slice(int origin, Vector<Double> v) { 377 return (Double64Vector) super.sliceTemplate(origin, v); // specialize 378 } 379 380 @Override 381 @ForceInline 382 public Double64Vector slice(int origin) { 383 if ((origin < 0) || (origin >= VLENGTH)) { 384 throw new ArrayIndexOutOfBoundsException("Index " + origin + " out of bounds for vector length " + VLENGTH); 385 } else { 386 Double64Shuffle Iota = (Double64Shuffle)VectorShuffle.iota(VSPECIES, 0, 1, true); 387 VectorMask<Double> BlendMask = Iota.toVector().compare(VectorOperators.LT, (broadcast((double)(VLENGTH-origin)))); 388 Iota = (Double64Shuffle)VectorShuffle.iota(VSPECIES, origin, 1, true); 389 return ZERO.blend(this.rearrange(Iota), BlendMask); 390 } 391 } 392 393 @Override 394 @ForceInline 395 public Double64Vector unslice(int origin, Vector<Double> w, int part) { 396 return (Double64Vector) super.unsliceTemplate(origin, w, part); // specialize 397 } 398 399 @Override 400 @ForceInline 401 public Double64Vector unslice(int origin, Vector<Double> w, int part, VectorMask<Double> m) { 402 return (Double64Vector) 403 super.unsliceTemplate(Double64Mask.class, 404 origin, w, part, 405 (Double64Mask) m); // specialize 406 } 407 408 @Override 409 @ForceInline 410 public Double64Vector unslice(int origin) { 411 if ((origin < 0) || (origin >= VLENGTH)) { 412 throw new ArrayIndexOutOfBoundsException("Index " + origin + " out of bounds for vector length " + VLENGTH); 413 } else { 414 Double64Shuffle Iota = (Double64Shuffle)VectorShuffle.iota(VSPECIES, 0, 1, true); 415 VectorMask<Double> BlendMask = Iota.toVector().compare(VectorOperators.GE, (broadcast((double)(origin)))); 416 Iota = (Double64Shuffle)VectorShuffle.iota(VSPECIES, -origin, 1, true); 417 return ZERO.blend(this.rearrange(Iota), BlendMask); 418 } 419 } 420 421 @Override 422 @ForceInline 423 public Double64Vector rearrange(VectorShuffle<Double> s) { 424 return (Double64Vector) 425 super.rearrangeTemplate(Double64Shuffle.class, 426 (Double64Shuffle) s); // specialize 427 } 428 429 @Override 430 @ForceInline 431 public Double64Vector rearrange(VectorShuffle<Double> shuffle, 432 VectorMask<Double> m) { 433 return (Double64Vector) 434 super.rearrangeTemplate(Double64Shuffle.class, 435 (Double64Shuffle) shuffle, 436 (Double64Mask) m); // specialize 437 } 438 439 @Override 440 @ForceInline 441 public Double64Vector rearrange(VectorShuffle<Double> s, 442 Vector<Double> v) { 443 return (Double64Vector) 444 super.rearrangeTemplate(Double64Shuffle.class, 445 (Double64Shuffle) s, 446 (Double64Vector) v); // specialize 447 } 448 449 @Override 450 @ForceInline 451 public Double64Vector selectFrom(Vector<Double> v) { 452 return (Double64Vector) 453 super.selectFromTemplate((Double64Vector) v); // specialize 454 } 455 456 @Override 457 @ForceInline 458 public Double64Vector selectFrom(Vector<Double> v, 459 VectorMask<Double> m) { 460 return (Double64Vector) 461 super.selectFromTemplate((Double64Vector) v, 462 (Double64Mask) m); // specialize 463 } 464 465 466 @Override 467 public double lane(int i) { 468 if (i < 0 || i >= VLENGTH) { 469 throw new IllegalArgumentException("Index " + i + " must be zero or positive, and less than " + VLENGTH); 470 } 471 long bits = (long) VectorIntrinsics.extract( 472 VCLASS, ETYPE, VLENGTH, 473 this, i, 474 (vec, ix) -> { 475 double[] vecarr = vec.getElements(); 476 return (long)Double.doubleToLongBits(vecarr[ix]); 477 }); 478 return Double.longBitsToDouble(bits); 479 } 480 481 @Override 482 public Double64Vector withLane(int i, double e) { 483 if (i < 0 || i >= VLENGTH) { 484 throw new IllegalArgumentException("Index " + i + " must be zero or positive, and less than " + VLENGTH); 485 } 486 return VectorIntrinsics.insert( 487 VCLASS, ETYPE, VLENGTH, 488 this, i, (long)Double.doubleToLongBits(e), 489 (v, ix, bits) -> { 490 double[] res = v.getElements().clone(); 491 res[ix] = Double.longBitsToDouble((long)bits); 492 return v.vectorFactory(res); 493 }); 494 } 495 496 // Mask 497 498 static final class Double64Mask extends AbstractMask<Double> { 499 500 private final boolean[] bits; // Don't access directly, use getBits() instead. 501 502 public Double64Mask(boolean[] bits) { 503 this(bits, 0); 504 } 505 506 public Double64Mask(boolean[] bits, int offset) { 507 boolean[] a = new boolean[vspecies().laneCount()]; 508 for (int i = 0; i < a.length; i++) { 509 a[i] = bits[offset + i]; 510 } 511 this.bits = a; 512 } 513 514 public Double64Mask(boolean val) { 515 boolean[] bits = new boolean[vspecies().laneCount()]; 516 Arrays.fill(bits, val); 517 this.bits = bits; 518 } 519 520 @ForceInline 521 final @Override 522 public DoubleSpecies vspecies() { 523 // ISSUE: This should probably be a @Stable 524 // field inside AbstractMask, rather than 525 // a megamorphic method. 526 return VSPECIES; 527 } 528 529 boolean[] getBits() { 530 return VectorIntrinsics.maybeRebox(this).bits; 531 } 532 533 @Override 534 Double64Mask uOp(MUnOp f) { 535 boolean[] res = new boolean[vspecies().laneCount()]; 536 boolean[] bits = getBits(); 537 for (int i = 0; i < res.length; i++) { 538 res[i] = f.apply(i, bits[i]); 539 } 540 return new Double64Mask(res); 541 } 542 543 @Override 544 Double64Mask bOp(VectorMask<Double> m, MBinOp f) { 545 boolean[] res = new boolean[vspecies().laneCount()]; 546 boolean[] bits = getBits(); 547 boolean[] mbits = ((Double64Mask)m).getBits(); 548 for (int i = 0; i < res.length; i++) { 549 res[i] = f.apply(i, bits[i], mbits[i]); 550 } 551 return new Double64Mask(res); 552 } 553 554 @ForceInline 555 @Override 556 public final 557 Double64Vector toVector() { 558 return (Double64Vector) super.toVectorTemplate(); // specialize 559 } 560 561 @Override 562 @ForceInline 563 public <E> VectorMask<E> cast(VectorSpecies<E> s) { 564 AbstractSpecies<E> species = (AbstractSpecies<E>) s; 565 if (length() != species.laneCount()) 566 throw new IllegalArgumentException("VectorMask length and species length differ"); 567 boolean[] maskArray = toArray(); 568 // enum-switches don't optimize properly JDK-8161245 569 switch (species.laneType.switchKey) { 570 case LaneType.SK_BYTE: 571 return new Byte64Vector.Byte64Mask(maskArray).check(species); 572 case LaneType.SK_SHORT: 573 return new Short64Vector.Short64Mask(maskArray).check(species); 574 case LaneType.SK_INT: 575 return new Int64Vector.Int64Mask(maskArray).check(species); 576 case LaneType.SK_LONG: 577 return new Long64Vector.Long64Mask(maskArray).check(species); 578 case LaneType.SK_FLOAT: 579 return new Float64Vector.Float64Mask(maskArray).check(species); 580 case LaneType.SK_DOUBLE: 581 return new Double64Vector.Double64Mask(maskArray).check(species); 582 } 583 584 // Should not reach here. 585 throw new AssertionError(species); 586 } 587 588 // Unary operations 589 590 @Override 591 @ForceInline 592 public Double64Mask not() { 593 return (Double64Mask) VectorIntrinsics.unaryOp( 594 VECTOR_OP_NOT, Double64Mask.class, long.class, VLENGTH, 595 this, 596 (m1) -> m1.uOp((i, a) -> !a)); 597 } 598 599 // Binary operations 600 601 @Override 602 @ForceInline 603 public Double64Mask and(VectorMask<Double> mask) { 604 Objects.requireNonNull(mask); 605 Double64Mask m = (Double64Mask)mask; 606 return VectorIntrinsics.binaryOp(VECTOR_OP_AND, Double64Mask.class, long.class, VLENGTH, 607 this, m, 608 (m1, m2) -> m1.bOp(m2, (i, a, b) -> a & b)); 609 } 610 611 @Override 612 @ForceInline 613 public Double64Mask or(VectorMask<Double> mask) { 614 Objects.requireNonNull(mask); 615 Double64Mask m = (Double64Mask)mask; 616 return VectorIntrinsics.binaryOp(VECTOR_OP_OR, Double64Mask.class, long.class, VLENGTH, 617 this, m, 618 (m1, m2) -> m1.bOp(m2, (i, a, b) -> a | b)); 619 } 620 621 // Reductions 622 623 @Override 624 @ForceInline 625 public boolean anyTrue() { 626 return VectorIntrinsics.test(BT_ne, Double64Mask.class, long.class, VLENGTH, 627 this, this, 628 (m, __) -> anyTrueHelper(((Double64Mask)m).getBits())); 629 } 630 631 @Override 632 @ForceInline 633 public boolean allTrue() { 634 return VectorIntrinsics.test(BT_overflow, Double64Mask.class, long.class, VLENGTH, 635 this, vspecies().maskAll(true), 636 (m, __) -> allTrueHelper(((Double64Mask)m).getBits())); 637 } 638 639 /*package-private*/ 640 static Double64Mask maskAll(boolean bit) { 641 return bit ? TRUE_MASK : FALSE_MASK; 642 } 643 static final Double64Mask TRUE_MASK = new Double64Mask(true); 644 static final Double64Mask FALSE_MASK = new Double64Mask(false); 645 } 646 647 // Shuffle 648 649 static final class Double64Shuffle extends AbstractShuffle<Double> { 650 Double64Shuffle(byte[] reorder) { 651 super(reorder); 652 } 653 654 public Double64Shuffle(int[] reorder) { 655 super(reorder); 656 } 657 658 public Double64Shuffle(int[] reorder, int i) { 659 super(reorder, i); 660 } 661 662 public Double64Shuffle(IntUnaryOperator fn) { 663 super(fn); 664 } 665 666 @Override 667 public DoubleSpecies vspecies() { 668 return VSPECIES; 669 } 670 671 static { 672 // There must be enough bits in the shuffle lanes to encode 673 // VLENGTH valid indexes and VLENGTH exceptional ones. 674 assert(VLENGTH < Byte.MAX_VALUE); 675 assert(Byte.MIN_VALUE <= -VLENGTH); 676 } 677 static final Double64Shuffle IOTA = new Double64Shuffle(IDENTITY); 678 679 @Override 680 @ForceInline 681 public Double64Vector toVector() { 682 return VectorIntrinsics.shuffleToVector(VCLASS, ETYPE, Double64Shuffle.class, this, VLENGTH, 683 (s) -> ((Double64Vector)(((AbstractShuffle<Double>)(s)).toVectorTemplate()))); 684 } 685 686 @Override 687 @ForceInline 688 public <F> VectorShuffle<F> cast(VectorSpecies<F> s) { 689 AbstractSpecies<F> species = (AbstractSpecies<F>) s; 690 if (length() != species.laneCount()) 691 throw new IllegalArgumentException("VectorShuffle length and species length differ"); 692 int[] shuffleArray = toArray(); 693 // enum-switches don't optimize properly JDK-8161245 694 switch (species.laneType.switchKey) { 695 case LaneType.SK_BYTE: 696 return new Byte64Vector.Byte64Shuffle(shuffleArray).check(species); 697 case LaneType.SK_SHORT: 698 return new Short64Vector.Short64Shuffle(shuffleArray).check(species); 699 case LaneType.SK_INT: 700 return new Int64Vector.Int64Shuffle(shuffleArray).check(species); 701 case LaneType.SK_LONG: 702 return new Long64Vector.Long64Shuffle(shuffleArray).check(species); 703 case LaneType.SK_FLOAT: 704 return new Float64Vector.Float64Shuffle(shuffleArray).check(species); 705 case LaneType.SK_DOUBLE: 706 return new Double64Vector.Double64Shuffle(shuffleArray).check(species); 707 } 708 709 // Should not reach here. 710 throw new AssertionError(species); 711 } 712 713 @Override 714 public Double64Shuffle rearrange(VectorShuffle<Double> shuffle) { 715 Double64Shuffle s = (Double64Shuffle) shuffle; 716 byte[] r = new byte[reorder.length]; 717 for (int i = 0; i < reorder.length; i++) { 718 int ssi = s.reorder[i]; 719 r[i] = this.reorder[ssi]; // throws on exceptional index 720 } 721 return new Double64Shuffle(r); 722 } 723 } 724 725 // ================================================ 726 727 // Specialized low-level memory operations. 728 729 @ForceInline 730 @Override 731 final 732 DoubleVector fromArray0(double[] a, int offset) { 733 return super.fromArray0Template(a, offset); // specialize 734 } 735 736 @ForceInline 737 @Override 738 final 739 DoubleVector fromByteArray0(byte[] a, int offset) { 740 return super.fromByteArray0Template(a, offset); // specialize 741 } 742 743 @ForceInline 744 @Override 745 final 746 DoubleVector fromByteBuffer0(ByteBuffer bb, int offset) { 747 return super.fromByteBuffer0Template(bb, offset); // specialize 748 } 749 750 @ForceInline 751 @Override 752 final 753 void intoArray0(double[] a, int offset) { 754 super.intoArray0Template(a, offset); // specialize 755 } 756 757 @ForceInline 758 @Override 759 final 760 void intoByteArray0(byte[] a, int offset) { 761 super.intoByteArray0Template(a, offset); // specialize 762 } 763 764 // End of specialized low-level memory operations. 765 766 // ================================================ 767 768 }