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.FloatBuffer; 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 Float512Vector extends FloatVector { 46 static final FloatSpecies VSPECIES = 47 (FloatSpecies) FloatVector.SPECIES_512; 48 49 static final VectorShape VSHAPE = 50 VSPECIES.vectorShape(); 51 52 static final Class<Float512Vector> VCLASS = Float512Vector.class; 53 54 static final int VSIZE = VSPECIES.vectorBitSize(); 55 56 static final int VLENGTH = VSPECIES.laneCount(); 57 58 static final Class<Float> ETYPE = float.class; 59 60 // The JVM expects to find the state here. 61 private final float[] vec; // Don't access directly, use vec() instead. 62 63 Float512Vector(float[] v) { 64 vec = v; 65 } 66 67 // For compatibility as Float512Vector::new, 68 // stored into species.vectorFactory. 69 Float512Vector(Object v) { 70 this((float[]) v); 71 } 72 73 static final Float512Vector ZERO = new Float512Vector(new float[VLENGTH]); 74 static final Float512Vector IOTA = new Float512Vector(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 FloatSpecies 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<Float> elementType() { return float.class; } 98 99 @ForceInline 100 @Override 101 public final int elementSize() { return Float.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 float[] vec() { 123 return VectorIntrinsics.maybeRebox(this).vec; 124 } 125 126 // Virtualized constructors 127 128 @Override 129 @ForceInline 130 public final Float512Vector broadcast(float e) { 131 return (Float512Vector) super.broadcastTemplate(e); // specialize 132 } 133 134 @Override 135 @ForceInline 136 public final Float512Vector broadcast(long e) { 137 return (Float512Vector) super.broadcastTemplate(e); // specialize 138 } 139 140 @Override 141 @ForceInline 142 Float512Mask maskFromArray(boolean[] bits) { 143 return new Float512Mask(bits); 144 } 145 146 @Override 147 @ForceInline 148 Float512Shuffle iotaShuffle() { return Float512Shuffle.IOTA; } 149 150 @ForceInline 151 Float512Shuffle iotaShuffle(int start) { 152 return (Float512Shuffle)VectorIntrinsics.shuffleIota(ETYPE, Float512Shuffle.class, VSPECIES, VLENGTH, start, (val, l) -> new Float512Shuffle(i -> (VectorIntrinsics.wrapToRange(i + val, l)))); 153 } 154 155 @Override 156 @ForceInline 157 Float512Shuffle shuffleFromBytes(byte[] reorder) { return new Float512Shuffle(reorder); } 158 159 @Override 160 @ForceInline 161 Float512Shuffle shuffleFromArray(int[] indexes, int i) { return new Float512Shuffle(indexes, i); } 162 163 @Override 164 @ForceInline 165 Float512Shuffle shuffleFromOp(IntUnaryOperator fn) { return new Float512Shuffle(fn); } 166 167 // Make a vector of the same species but the given elements: 168 @ForceInline 169 final @Override 170 Float512Vector vectorFactory(float[] vec) { 171 return new Float512Vector(vec); 172 } 173 174 @ForceInline 175 final @Override 176 Byte512Vector asByteVectorRaw() { 177 return (Byte512Vector) 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 Float512Vector uOp(FUnOp f) { 190 return (Float512Vector) super.uOpTemplate(f); // specialize 191 } 192 193 @ForceInline 194 final @Override 195 Float512Vector uOp(VectorMask<Float> m, FUnOp f) { 196 return (Float512Vector) 197 super.uOpTemplate((Float512Mask)m, f); // specialize 198 } 199 200 // Binary operator 201 202 @ForceInline 203 final @Override 204 Float512Vector bOp(Vector<Float> v, FBinOp f) { 205 return (Float512Vector) super.bOpTemplate((Float512Vector)v, f); // specialize 206 } 207 208 @ForceInline 209 final @Override 210 Float512Vector bOp(Vector<Float> v, 211 VectorMask<Float> m, FBinOp f) { 212 return (Float512Vector) 213 super.bOpTemplate((Float512Vector)v, (Float512Mask)m, 214 f); // specialize 215 } 216 217 // Ternary operator 218 219 @ForceInline 220 final @Override 221 Float512Vector tOp(Vector<Float> v1, Vector<Float> v2, FTriOp f) { 222 return (Float512Vector) 223 super.tOpTemplate((Float512Vector)v1, (Float512Vector)v2, 224 f); // specialize 225 } 226 227 @ForceInline 228 final @Override 229 Float512Vector tOp(Vector<Float> v1, Vector<Float> v2, 230 VectorMask<Float> m, FTriOp f) { 231 return (Float512Vector) 232 super.tOpTemplate((Float512Vector)v1, (Float512Vector)v2, 233 (Float512Mask)m, f); // specialize 234 } 235 236 @ForceInline 237 final @Override 238 float rOp(float 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<Float,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 Float512Vector lanewise(Unary op) { 272 return (Float512Vector) super.lanewiseTemplate(op); // specialize 273 } 274 275 @Override 276 @ForceInline 277 public Float512Vector lanewise(Binary op, Vector<Float> v) { 278 return (Float512Vector) super.lanewiseTemplate(op, v); // specialize 279 } 280 281 282 /*package-private*/ 283 @Override 284 @ForceInline 285 public final 286 Float512Vector 287 lanewise(VectorOperators.Ternary op, Vector<Float> v1, Vector<Float> v2) { 288 return (Float512Vector) super.lanewiseTemplate(op, v1, v2); // specialize 289 } 290 291 @Override 292 @ForceInline 293 public final 294 Float512Vector addIndex(int scale) { 295 return (Float512Vector) super.addIndexTemplate(scale); // specialize 296 } 297 298 // Type specific horizontal reductions 299 300 @Override 301 @ForceInline 302 public final float reduceLanes(VectorOperators.Associative op) { 303 return super.reduceLanesTemplate(op); // specialized 304 } 305 306 @Override 307 @ForceInline 308 public final float reduceLanes(VectorOperators.Associative op, 309 VectorMask<Float> 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<Float> m) { 323 return (long) super.reduceLanesTemplate(op, m); // specialized 324 } 325 326 @Override 327 @ForceInline 328 public VectorShuffle<Float> toShuffle() { 329 float[] 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 Float512Mask test(Test op) { 342 return super.testTemplate(Float512Mask.class, op); // specialize 343 } 344 345 // Specialized comparisons 346 347 @Override 348 @ForceInline 349 public final Float512Mask compare(Comparison op, Vector<Float> v) { 350 return super.compareTemplate(Float512Mask.class, op, v); // specialize 351 } 352 353 @Override 354 @ForceInline 355 public final Float512Mask compare(Comparison op, float s) { 356 return super.compareTemplate(Float512Mask.class, op, s); // specialize 357 } 358 359 @Override 360 @ForceInline 361 public final Float512Mask compare(Comparison op, long s) { 362 return super.compareTemplate(Float512Mask.class, op, s); // specialize 363 } 364 365 @Override 366 @ForceInline 367 public Float512Vector blend(Vector<Float> v, VectorMask<Float> m) { 368 return (Float512Vector) 369 super.blendTemplate(Float512Mask.class, 370 (Float512Vector) v, 371 (Float512Mask) m); // specialize 372 } 373 374 @Override 375 @ForceInline 376 public Float512Vector slice(int origin, Vector<Float> v) { 377 return (Float512Vector) super.sliceTemplate(origin, v); // specialize 378 } 379 380 @Override 381 @ForceInline 382 public Float512Vector 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 Float512Shuffle Iota = (Float512Shuffle)VectorShuffle.iota(VSPECIES, 0, 1, true); 387 VectorMask<Float> BlendMask = Iota.toVector().compare(VectorOperators.LT, (broadcast((float)(VLENGTH-origin)))); 388 Iota = (Float512Shuffle)VectorShuffle.iota(VSPECIES, origin, 1, true); 389 return ZERO.blend(this.rearrange(Iota), BlendMask); 390 } 391 } 392 393 @Override 394 @ForceInline 395 public Float512Vector unslice(int origin, Vector<Float> w, int part) { 396 return (Float512Vector) super.unsliceTemplate(origin, w, part); // specialize 397 } 398 399 @Override 400 @ForceInline 401 public Float512Vector unslice(int origin, Vector<Float> w, int part, VectorMask<Float> m) { 402 return (Float512Vector) 403 super.unsliceTemplate(Float512Mask.class, 404 origin, w, part, 405 (Float512Mask) m); // specialize 406 } 407 408 @Override 409 @ForceInline 410 public Float512Vector 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 Float512Shuffle Iota = (Float512Shuffle)VectorShuffle.iota(VSPECIES, 0, 1, true); 415 VectorMask<Float> BlendMask = Iota.toVector().compare(VectorOperators.GE, (broadcast((float)(origin)))); 416 Iota = (Float512Shuffle)VectorShuffle.iota(VSPECIES, -origin, 1, true); 417 return ZERO.blend(this.rearrange(Iota), BlendMask); 418 } 419 } 420 421 @Override 422 @ForceInline 423 public Float512Vector rearrange(VectorShuffle<Float> s) { 424 return (Float512Vector) 425 super.rearrangeTemplate(Float512Shuffle.class, 426 (Float512Shuffle) s); // specialize 427 } 428 429 @Override 430 @ForceInline 431 public Float512Vector rearrange(VectorShuffle<Float> shuffle, 432 VectorMask<Float> m) { 433 return (Float512Vector) 434 super.rearrangeTemplate(Float512Shuffle.class, 435 (Float512Shuffle) shuffle, 436 (Float512Mask) m); // specialize 437 } 438 439 @Override 440 @ForceInline 441 public Float512Vector rearrange(VectorShuffle<Float> s, 442 Vector<Float> v) { 443 return (Float512Vector) 444 super.rearrangeTemplate(Float512Shuffle.class, 445 (Float512Shuffle) s, 446 (Float512Vector) v); // specialize 447 } 448 449 @Override 450 @ForceInline 451 public Float512Vector selectFrom(Vector<Float> v) { 452 return (Float512Vector) 453 super.selectFromTemplate((Float512Vector) v); // specialize 454 } 455 456 @Override 457 @ForceInline 458 public Float512Vector selectFrom(Vector<Float> v, 459 VectorMask<Float> m) { 460 return (Float512Vector) 461 super.selectFromTemplate((Float512Vector) v, 462 (Float512Mask) m); // specialize 463 } 464 465 466 @Override 467 public float 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 int bits = (int) VectorIntrinsics.extract( 472 VCLASS, ETYPE, VLENGTH, 473 this, i, 474 (vec, ix) -> { 475 float[] vecarr = vec.vec(); 476 return (long)Float.floatToIntBits(vecarr[ix]); 477 }); 478 return Float.intBitsToFloat(bits); 479 } 480 481 @Override 482 public Float512Vector withLane(int i, float 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)Float.floatToIntBits(e), 489 (v, ix, bits) -> { 490 float[] res = v.vec().clone(); 491 res[ix] = Float.intBitsToFloat((int)bits); 492 return v.vectorFactory(res); 493 }); 494 } 495 496 // Mask 497 498 static final class Float512Mask extends AbstractMask<Float> { 499 500 private final boolean[] bits; // Don't access directly, use getBits() instead. 501 502 public Float512Mask(boolean[] bits) { 503 this(bits, 0); 504 } 505 506 public Float512Mask(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 Float512Mask(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 FloatSpecies 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 Float512Mask 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 Float512Mask(res); 541 } 542 543 @Override 544 Float512Mask bOp(VectorMask<Float> m, MBinOp f) { 545 boolean[] res = new boolean[vspecies().laneCount()]; 546 boolean[] bits = getBits(); 547 boolean[] mbits = ((Float512Mask)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 Float512Mask(res); 552 } 553 554 @ForceInline 555 @Override 556 public final 557 Float512Vector toVector() { 558 return (Float512Vector) 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 Byte512Vector.Byte512Mask(maskArray).check(species); 572 case LaneType.SK_SHORT: 573 return new Short512Vector.Short512Mask(maskArray).check(species); 574 case LaneType.SK_INT: 575 return new Int512Vector.Int512Mask(maskArray).check(species); 576 case LaneType.SK_LONG: 577 return new Long512Vector.Long512Mask(maskArray).check(species); 578 case LaneType.SK_FLOAT: 579 return new Float512Vector.Float512Mask(maskArray).check(species); 580 case LaneType.SK_DOUBLE: 581 return new Double512Vector.Double512Mask(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 Float512Mask not() { 593 return (Float512Mask) VectorIntrinsics.unaryOp( 594 VECTOR_OP_NOT, Float512Mask.class, int.class, VLENGTH, 595 this, 596 (m1) -> m1.uOp((i, a) -> !a)); 597 } 598 599 // Binary operations 600 601 @Override 602 @ForceInline 603 public Float512Mask and(VectorMask<Float> mask) { 604 Objects.requireNonNull(mask); 605 Float512Mask m = (Float512Mask)mask; 606 return VectorIntrinsics.binaryOp(VECTOR_OP_AND, Float512Mask.class, int.class, VLENGTH, 607 this, m, 608 (m1, m2) -> m1.bOp(m2, (i, a, b) -> a & b)); 609 } 610 611 @Override 612 @ForceInline 613 public Float512Mask or(VectorMask<Float> mask) { 614 Objects.requireNonNull(mask); 615 Float512Mask m = (Float512Mask)mask; 616 return VectorIntrinsics.binaryOp(VECTOR_OP_OR, Float512Mask.class, int.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, Float512Mask.class, int.class, VLENGTH, 627 this, this, 628 (m, __) -> anyTrueHelper(((Float512Mask)m).getBits())); 629 } 630 631 @Override 632 @ForceInline 633 public boolean allTrue() { 634 return VectorIntrinsics.test(BT_overflow, Float512Mask.class, int.class, VLENGTH, 635 this, vspecies().maskAll(true), 636 (m, __) -> allTrueHelper(((Float512Mask)m).getBits())); 637 } 638 639 /*package-private*/ 640 static Float512Mask maskAll(boolean bit) { 641 return bit ? TRUE_MASK : FALSE_MASK; 642 } 643 static final Float512Mask TRUE_MASK = new Float512Mask(true); 644 static final Float512Mask FALSE_MASK = new Float512Mask(false); 645 } 646 647 // Shuffle 648 649 static final class Float512Shuffle extends AbstractShuffle<Float> { 650 Float512Shuffle(byte[] reorder) { 651 super(reorder); 652 } 653 654 public Float512Shuffle(int[] reorder) { 655 super(reorder); 656 } 657 658 public Float512Shuffle(int[] reorder, int i) { 659 super(reorder, i); 660 } 661 662 public Float512Shuffle(IntUnaryOperator fn) { 663 super(fn); 664 } 665 666 @Override 667 public FloatSpecies 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 Float512Shuffle IOTA = new Float512Shuffle(IDENTITY); 678 679 @Override 680 @ForceInline 681 public Float512Vector toVector() { 682 return VectorIntrinsics.shuffleToVector(VCLASS, ETYPE, Float512Shuffle.class, this, VLENGTH, 683 (s) -> ((Float512Vector)(((AbstractShuffle<Float>)(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 Byte512Vector.Byte512Shuffle(shuffleArray).check(species); 697 case LaneType.SK_SHORT: 698 return new Short512Vector.Short512Shuffle(shuffleArray).check(species); 699 case LaneType.SK_INT: 700 return new Int512Vector.Int512Shuffle(shuffleArray).check(species); 701 case LaneType.SK_LONG: 702 return new Long512Vector.Long512Shuffle(shuffleArray).check(species); 703 case LaneType.SK_FLOAT: 704 return new Float512Vector.Float512Shuffle(shuffleArray).check(species); 705 case LaneType.SK_DOUBLE: 706 return new Double512Vector.Double512Shuffle(shuffleArray).check(species); 707 } 708 709 // Should not reach here. 710 throw new AssertionError(species); 711 } 712 713 @Override 714 public Float512Shuffle rearrange(VectorShuffle<Float> shuffle) { 715 Float512Shuffle s = (Float512Shuffle) 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 Float512Shuffle(r); 722 } 723 } 724 725 // ================================================ 726 727 // Specialized low-level memory operations. 728 729 @ForceInline 730 @Override 731 final 732 FloatVector fromArray0(float[] a, int offset) { 733 return super.fromArray0Template(a, offset); // specialize 734 } 735 736 @ForceInline 737 @Override 738 final 739 FloatVector fromByteArray0(byte[] a, int offset) { 740 return super.fromByteArray0Template(a, offset); // specialize 741 } 742 743 @ForceInline 744 @Override 745 final 746 FloatVector fromByteBuffer0(ByteBuffer bb, int offset) { 747 return super.fromByteBuffer0Template(bb, offset); // specialize 748 } 749 750 @ForceInline 751 @Override 752 final 753 void intoArray0(float[] 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 }