< prev index next >

src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Double128Vector.java

Print this page
rev 54658 : refactored mask and shuffle creation methods, moved classes to top-level


  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 static jdk.incubator.vector.VectorIntrinsics.*;
  38 
  39 @SuppressWarnings("cast")
  40 final class Double128Vector extends DoubleVector {
  41     private static final Species<Double> SPECIES = DoubleVector.SPECIES_128;
  42 
  43     static final Double128Vector ZERO = new Double128Vector();
  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 double[] vec; // Don't access directly, use getElements() instead.
  56 
  57     private double[] getElements() {
  58         return VectorIntrinsics.maybeRebox(this).vec;
  59     }
  60 
  61     Double128Vector() {
  62         vec = new double[SPECIES.length()];
  63     }
  64 
  65     Double128Vector(double[] v) {
  66         vec = v;
  67     }
  68 
  69     @Override
  70     public int length() { return LENGTH; }
  71 
  72     // Unary operator
  73 
  74     @Override
  75     Double128Vector uOp(FUnOp f) {
  76         double[] vec = getElements();
  77         double[] res = new double[length()];
  78         for (int i = 0; i < length(); i++) {
  79             res[i] = f.apply(i, vec[i]);
  80         }
  81         return new Double128Vector(res);
  82     }
  83 
  84     @Override
  85     Double128Vector uOp(Mask<Double> o, FUnOp f) {
  86         double[] vec = getElements();
  87         double[] res = new double[length()];
  88         boolean[] mbits = ((Double128Mask)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 Double128Vector(res);
  93     }
  94 
  95     // Binary operator
  96 
  97     @Override
  98     Double128Vector bOp(Vector<Double> o, FBinOp f) {
  99         double[] res = new double[length()];
 100         double[] vec1 = this.getElements();
 101         double[] vec2 = ((Double128Vector)o).getElements();
 102         for (int i = 0; i < length(); i++) {
 103             res[i] = f.apply(i, vec1[i], vec2[i]);
 104         }
 105         return new Double128Vector(res);
 106     }
 107 
 108     @Override
 109     Double128Vector bOp(Vector<Double> o1, Mask<Double> o2, FBinOp f) {
 110         double[] res = new double[length()];
 111         double[] vec1 = this.getElements();
 112         double[] vec2 = ((Double128Vector)o1).getElements();
 113         boolean[] mbits = ((Double128Mask)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 Double128Vector(res);
 118     }
 119 
 120     // Trinary operator
 121 
 122     @Override
 123     Double128Vector tOp(Vector<Double> o1, Vector<Double> o2, FTriOp f) {
 124         double[] res = new double[length()];
 125         double[] vec1 = this.getElements();
 126         double[] vec2 = ((Double128Vector)o1).getElements();
 127         double[] vec3 = ((Double128Vector)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 Double128Vector(res);
 132     }
 133 
 134     @Override
 135     Double128Vector tOp(Vector<Double> o1, Vector<Double> o2, Mask<Double> o3, FTriOp f) {
 136         double[] res = new double[length()];
 137         double[] vec1 = getElements();
 138         double[] vec2 = ((Double128Vector)o1).getElements();
 139         double[] vec3 = ((Double128Vector)o2).getElements();
 140         boolean[] mbits = ((Double128Mask)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 Double128Vector(res);
 145     }
 146 
 147     @Override
 148     double rOp(double v, FBinOp f) {
 149         double[] 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             Double128Vector.class,
 165             double.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(double.class)) {
 227             return (Vector<F>) reshape((Species<Double>)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                 Double128Vector.class,
 244                 double.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                 Double128Vector.class,
 253                 double.class, LENGTH,
 254                 Short128Vector.class,
 255                 short.class, Short128Vector.LENGTH,
 256                 this, s,
 257                 (species, vector) -> vector.defaultReinterpret(species)


 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                 Double128Vector.class,
 289                 double.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 DoubleVector reshape(Species<Double> s) {
 303         Objects.requireNonNull(s);
 304         if (s.bitSize() == 64 && (s.boxType() == Double64Vector.class)) {
 305             return VectorIntrinsics.reinterpret(
 306                 Double128Vector.class,
 307                 double.class, LENGTH,
 308                 Double64Vector.class,
 309                 double.class, Double64Vector.LENGTH,
 310                 this, s,
 311                 (species, vector) -> (DoubleVector) vector.defaultReinterpret(species)
 312             );
 313         } else if (s.bitSize() == 128 && (s.boxType() == Double128Vector.class)) {
 314             return VectorIntrinsics.reinterpret(
 315                 Double128Vector.class,
 316                 double.class, LENGTH,
 317                 Double128Vector.class,
 318                 double.class, Double128Vector.LENGTH,
 319                 this, s,
 320                 (species, vector) -> (DoubleVector) vector.defaultReinterpret(species)
 321             );
 322         } else if (s.bitSize() == 256 && (s.boxType() == Double256Vector.class)) {


 345                 DoubleMaxVector.class,
 346                 double.class, DoubleMaxVector.LENGTH,
 347                 this, s,
 348                 (species, vector) -> (DoubleVector) 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 DoubleVector add(double o) {
 360         return add((Double128Vector)DoubleVector.broadcast(SPECIES, o));
 361     }
 362 
 363     @Override
 364     @ForceInline
 365     public DoubleVector add(double o, Mask<Double> m) {
 366         return add((Double128Vector)DoubleVector.broadcast(SPECIES, o), m);
 367     }
 368 
 369     @Override
 370     @ForceInline
 371     public DoubleVector sub(double o) {
 372         return sub((Double128Vector)DoubleVector.broadcast(SPECIES, o));
 373     }
 374 
 375     @Override
 376     @ForceInline
 377     public DoubleVector sub(double o, Mask<Double> m) {
 378         return sub((Double128Vector)DoubleVector.broadcast(SPECIES, o), m);
 379     }
 380 
 381     @Override
 382     @ForceInline
 383     public DoubleVector mul(double o) {
 384         return mul((Double128Vector)DoubleVector.broadcast(SPECIES, o));
 385     }
 386 
 387     @Override
 388     @ForceInline
 389     public DoubleVector mul(double o, Mask<Double> m) {
 390         return mul((Double128Vector)DoubleVector.broadcast(SPECIES, o), m);
 391     }
 392 
 393     @Override
 394     @ForceInline
 395     public DoubleVector min(double o) {
 396         return min((Double128Vector)DoubleVector.broadcast(SPECIES, o));
 397     }
 398 
 399     @Override
 400     @ForceInline
 401     public DoubleVector max(double o) {
 402         return max((Double128Vector)DoubleVector.broadcast(SPECIES, o));
 403     }
 404 
 405     @Override
 406     @ForceInline
 407     public Mask<Double> equal(double o) {
 408         return equal((Double128Vector)DoubleVector.broadcast(SPECIES, o));
 409     }
 410 
 411     @Override
 412     @ForceInline
 413     public Mask<Double> notEqual(double o) {
 414         return notEqual((Double128Vector)DoubleVector.broadcast(SPECIES, o));
 415     }
 416 
 417     @Override
 418     @ForceInline
 419     public Mask<Double> lessThan(double o) {
 420         return lessThan((Double128Vector)DoubleVector.broadcast(SPECIES, o));
 421     }
 422 
 423     @Override
 424     @ForceInline
 425     public Mask<Double> lessThanEq(double o) {
 426         return lessThanEq((Double128Vector)DoubleVector.broadcast(SPECIES, o));
 427     }
 428 
 429     @Override
 430     @ForceInline
 431     public Mask<Double> greaterThan(double o) {
 432         return greaterThan((Double128Vector)DoubleVector.broadcast(SPECIES, o));
 433     }
 434 
 435     @Override
 436     @ForceInline
 437     public Mask<Double> greaterThanEq(double o) {
 438         return greaterThanEq((Double128Vector)DoubleVector.broadcast(SPECIES, o));
 439     }
 440 
 441     @Override
 442     @ForceInline
 443     public DoubleVector blend(double o, Mask<Double> m) {
 444         return blend((Double128Vector)DoubleVector.broadcast(SPECIES, o), m);
 445     }
 446 
 447     @Override
 448     @ForceInline
 449     public DoubleVector div(double o) {
 450         return div((Double128Vector)DoubleVector.broadcast(SPECIES, o));
 451     }
 452 
 453     @Override
 454     @ForceInline
 455     public DoubleVector div(double o, Mask<Double> m) {
 456         return div((Double128Vector)DoubleVector.broadcast(SPECIES, o), m);
 457     }
 458 
 459     @Override
 460     @ForceInline
 461     public Double128Vector div(Vector<Double> v, Mask<Double> m) {
 462         return blend(div(v), m);
 463     }
 464 
 465     @Override
 466     @ForceInline
 467     public DoubleVector atan2(double o) {
 468         return atan2((Double128Vector)DoubleVector.broadcast(SPECIES, o));
 469     }
 470 
 471     @Override
 472     @ForceInline
 473     public DoubleVector atan2(double o, Mask<Double> m) {
 474         return atan2((Double128Vector)DoubleVector.broadcast(SPECIES, o), m);
 475     }
 476 
 477     @Override
 478     @ForceInline
 479     public DoubleVector pow(double o) {
 480         return pow((Double128Vector)DoubleVector.broadcast(SPECIES, o));
 481     }
 482 
 483     @Override
 484     @ForceInline
 485     public DoubleVector pow(double o, Mask<Double> m) {
 486         return pow((Double128Vector)DoubleVector.broadcast(SPECIES, o), m);
 487     }
 488 
 489     @Override
 490     @ForceInline
 491     public DoubleVector fma(double o1, double o2) {
 492         return fma((Double128Vector)DoubleVector.broadcast(SPECIES, o1), (Double128Vector)DoubleVector.broadcast(SPECIES, o2));
 493     }
 494 
 495     @Override
 496     @ForceInline
 497     public DoubleVector fma(double o1, double o2, Mask<Double> m) {
 498         return fma((Double128Vector)DoubleVector.broadcast(SPECIES, o1), (Double128Vector)DoubleVector.broadcast(SPECIES, o2), m);
 499     }
 500 
 501     @Override
 502     @ForceInline
 503     public DoubleVector hypot(double o) {
 504         return hypot((Double128Vector)DoubleVector.broadcast(SPECIES, o));
 505     }
 506 
 507     @Override
 508     @ForceInline
 509     public DoubleVector hypot(double o, Mask<Double> m) {
 510         return hypot((Double128Vector)DoubleVector.broadcast(SPECIES, o), m);
 511     }
 512 
 513 
 514     // Unary operations
 515 
 516     @ForceInline
 517     @Override
 518     public Double128Vector neg(Mask<Double> m) {
 519         return blend(neg(), m);
 520     }
 521 
 522     @Override
 523     @ForceInline
 524     public Double128Vector abs() {
 525         return VectorIntrinsics.unaryOp(
 526             VECTOR_OP_ABS, Double128Vector.class, double.class, LENGTH,
 527             this,
 528             v1 -> v1.uOp((i, a) -> (double) Math.abs(a)));
 529     }
 530 
 531     @ForceInline
 532     @Override
 533     public Double128Vector abs(Mask<Double> m) {
 534         return blend(abs(), m);
 535     }
 536 
 537     @Override
 538     @ForceInline
 539     public Double128Vector neg() {
 540         return VectorIntrinsics.unaryOp(
 541             VECTOR_OP_NEG, Double128Vector.class, double.class, LENGTH,
 542             this,
 543             v1 -> v1.uOp((i, a) -> (double) -a));
 544     }
 545 
 546     @Override
 547     @ForceInline
 548     public Double128Vector div(Vector<Double> o) {
 549         Objects.requireNonNull(o);
 550         Double128Vector v = (Double128Vector)o;
 551         return VectorIntrinsics.binaryOp(
 552             VECTOR_OP_DIV, Double128Vector.class, double.class, LENGTH,
 553             this, v,


 730             this, v,
 731             (v1, v2) -> ((Double128Vector)v1).bOp(v2, (i, a, b) -> (double)(Math.atan2(a,b))));
 732     }
 733 
 734 
 735     // Binary operations
 736 
 737     @Override
 738     @ForceInline
 739     public Double128Vector add(Vector<Double> o) {
 740         Objects.requireNonNull(o);
 741         Double128Vector v = (Double128Vector)o;
 742         return VectorIntrinsics.binaryOp(
 743             VECTOR_OP_ADD, Double128Vector.class, double.class, LENGTH,
 744             this, v,
 745             (v1, v2) -> v1.bOp(v2, (i, a, b) -> (double)(a + b)));
 746     }
 747 
 748     @Override
 749     @ForceInline
 750     public Double128Vector add(Vector<Double> v, Mask<Double> m) {
 751         return blend(add(v), m);
 752     }
 753 
 754     @Override
 755     @ForceInline
 756     public Double128Vector sub(Vector<Double> o) {
 757         Objects.requireNonNull(o);
 758         Double128Vector v = (Double128Vector)o;
 759         return VectorIntrinsics.binaryOp(
 760             VECTOR_OP_SUB, Double128Vector.class, double.class, LENGTH,
 761             this, v,
 762             (v1, v2) -> v1.bOp(v2, (i, a, b) -> (double)(a - b)));
 763     }
 764 
 765     @Override
 766     @ForceInline
 767     public Double128Vector sub(Vector<Double> v, Mask<Double> m) {
 768         return blend(sub(v), m);
 769     }
 770 
 771     @Override
 772     @ForceInline
 773     public Double128Vector mul(Vector<Double> o) {
 774         Objects.requireNonNull(o);
 775         Double128Vector v = (Double128Vector)o;
 776         return VectorIntrinsics.binaryOp(
 777             VECTOR_OP_MUL, Double128Vector.class, double.class, LENGTH,
 778             this, v,
 779             (v1, v2) -> v1.bOp(v2, (i, a, b) -> (double)(a * b)));
 780     }
 781 
 782     @Override
 783     @ForceInline
 784     public Double128Vector mul(Vector<Double> v, Mask<Double> m) {
 785         return blend(mul(v), m);
 786     }
 787 
 788     @Override
 789     @ForceInline
 790     public Double128Vector min(Vector<Double> o) {
 791         Objects.requireNonNull(o);
 792         Double128Vector v = (Double128Vector)o;
 793         return (Double128Vector) VectorIntrinsics.binaryOp(
 794             VECTOR_OP_MIN, Double128Vector.class, double.class, LENGTH,
 795             this, v,
 796             (v1, v2) -> v1.bOp(v2, (i, a, b) -> (double) Math.min(a, b)));
 797     }
 798 
 799     @Override
 800     @ForceInline
 801     public Double128Vector min(Vector<Double> v, Mask<Double> m) {
 802         return blend(min(v), m);
 803     }
 804 
 805     @Override
 806     @ForceInline
 807     public Double128Vector max(Vector<Double> o) {
 808         Objects.requireNonNull(o);
 809         Double128Vector v = (Double128Vector)o;
 810         return VectorIntrinsics.binaryOp(
 811             VECTOR_OP_MAX, Double128Vector.class, double.class, LENGTH,
 812             this, v,
 813             (v1, v2) -> v1.bOp(v2, (i, a, b) -> (double) Math.max(a, b)));
 814         }
 815 
 816     @Override
 817     @ForceInline
 818     public Double128Vector max(Vector<Double> v, Mask<Double> m) {
 819         return blend(max(v), m);
 820     }
 821 
 822 
 823     // Ternary operations
 824 
 825     @Override
 826     @ForceInline
 827     public Double128Vector fma(Vector<Double> o1, Vector<Double> o2) {
 828         Objects.requireNonNull(o1);
 829         Objects.requireNonNull(o2);
 830         Double128Vector v1 = (Double128Vector)o1;
 831         Double128Vector v2 = (Double128Vector)o2;
 832         return VectorIntrinsics.ternaryOp(
 833             VECTOR_OP_FMA, Double128Vector.class, double.class, LENGTH,
 834             this, v1, v2,
 835             (w1, w2, w3) -> w1.tOp(w2, w3, (i, a, b, c) -> Math.fma(a, b, c)));
 836     }
 837 
 838     // Type specific horizontal reductions


 875                                 });
 876         return Double.longBitsToDouble(bits);
 877     }
 878 
 879     @Override
 880     @ForceInline
 881     public double maxAll() {
 882         long bits = (long) VectorIntrinsics.reductionCoerced(
 883                                 VECTOR_OP_MAX, Double128Vector.class, double.class, LENGTH,
 884                                 this,
 885                                 v -> {
 886                                     double r = v.rOp(Double.NEGATIVE_INFINITY, (i, a, b) -> (double) Math.max(a, b));
 887                                     return (long)Double.doubleToLongBits(r);
 888                                 });
 889         return Double.longBitsToDouble(bits);
 890     }
 891 
 892 
 893     @Override
 894     @ForceInline
 895     public double addAll(Mask<Double> m) {
 896         return blend((Double128Vector)DoubleVector.broadcast(SPECIES, (double) 0), m).addAll();
 897     }
 898 
 899 
 900     @Override
 901     @ForceInline
 902     public double mulAll(Mask<Double> m) {
 903         return blend((Double128Vector)DoubleVector.broadcast(SPECIES, (double) 1), m).mulAll();
 904     }
 905 
 906     @Override
 907     @ForceInline
 908     public double minAll(Mask<Double> m) {
 909         return blend((Double128Vector)DoubleVector.broadcast(SPECIES, Double.MAX_VALUE), m).minAll();
 910     }
 911 
 912     @Override
 913     @ForceInline
 914     public double maxAll(Mask<Double> m) {
 915         return blend((Double128Vector)DoubleVector.broadcast(SPECIES, Double.MIN_VALUE), m).maxAll();
 916     }
 917 
 918     @Override
 919     @ForceInline
 920     public Shuffle<Double> toShuffle() {
 921         double[] a = toArray();
 922         int[] sa = new int[a.length];
 923         for (int i = 0; i < a.length; i++) {
 924             sa[i] = (int) a[i];
 925         }
 926         return DoubleVector.shuffleFromArray(SPECIES, sa, 0);
 927     }
 928 
 929     // Memory operations
 930 
 931     private static final int ARRAY_SHIFT         = 31 - Integer.numberOfLeadingZeros(Unsafe.ARRAY_DOUBLE_INDEX_SCALE);
 932     private static final int BOOLEAN_ARRAY_SHIFT = 31 - Integer.numberOfLeadingZeros(Unsafe.ARRAY_BOOLEAN_INDEX_SCALE);
 933 
 934     @Override
 935     @ForceInline
 936     public void intoArray(double[] a, int ix) {
 937         Objects.requireNonNull(a);
 938         ix = VectorIntrinsics.checkIndex(ix, a.length, LENGTH);
 939         VectorIntrinsics.store(Double128Vector.class, double.class, LENGTH,
 940                                a, (((long) ix) << ARRAY_SHIFT) + Unsafe.ARRAY_DOUBLE_BASE_OFFSET,
 941                                this,
 942                                a, ix,
 943                                (arr, idx, v) -> v.forEach((i, e) -> arr[idx + i] = e));
 944     }
 945 
 946     @Override
 947     @ForceInline
 948     public final void intoArray(double[] a, int ax, Mask<Double> m) {
 949         DoubleVector oldVal = DoubleVector.fromArray(SPECIES, a, ax);
 950         DoubleVector newVal = oldVal.blend(this, m);
 951         newVal.intoArray(a, ax);
 952     }
 953     @Override
 954     @ForceInline
 955     public void intoArray(double[] a, int ix, int[] b, int iy) {
 956         Objects.requireNonNull(a);
 957         Objects.requireNonNull(b);
 958 
 959         // Index vector: vix[0:n] = i -> ix + indexMap[iy + i]
 960         IntVector vix = IntVector.fromArray(INDEX_SPECIES, b, iy).add(ix);
 961 
 962         vix = VectorIntrinsics.checkIndex(vix, a.length);
 963 
 964         VectorIntrinsics.storeWithMap(Double128Vector.class, double.class, LENGTH, Int64Vector.class,
 965                                a, Unsafe.ARRAY_DOUBLE_BASE_OFFSET, vix,
 966                                this,
 967                                a, ix, b, iy,
 968                                (arr, idx, v, indexMap, idy) -> v.forEach((i, e) -> arr[idx+indexMap[idy+i]] = e));
 969     }
 970 
 971      @Override
 972      @ForceInline
 973      public final void intoArray(double[] a, int ax, Mask<Double> m, int[] b, int iy) {
 974          // @@@ This can result in out of bounds errors for unset mask lanes
 975          DoubleVector oldVal = DoubleVector.fromArray(SPECIES, a, ax, b, iy);
 976          DoubleVector newVal = oldVal.blend(this, m);
 977          newVal.intoArray(a, ax, b, iy);
 978      }
 979 
 980     @Override
 981     @ForceInline
 982     public void intoByteArray(byte[] a, int ix) {
 983         Objects.requireNonNull(a);
 984         ix = VectorIntrinsics.checkIndex(ix, a.length, bitSize() / Byte.SIZE);
 985         VectorIntrinsics.store(Double128Vector.class, double.class, LENGTH,
 986                                a, ((long) ix) + Unsafe.ARRAY_BYTE_BASE_OFFSET,
 987                                this,
 988                                a, ix,
 989                                (c, idx, v) -> {
 990                                    ByteBuffer bbc = ByteBuffer.wrap(c, idx, c.length - idx).order(ByteOrder.nativeOrder());
 991                                    DoubleBuffer tb = bbc.asDoubleBuffer();
 992                                    v.forEach((i, e) -> tb.put(e));
 993                                });
 994     }
 995 
 996     @Override
 997     @ForceInline
 998     public final void intoByteArray(byte[] a, int ix, Mask<Double> m) {
 999         Double128Vector oldVal = (Double128Vector) DoubleVector.fromByteArray(SPECIES, a, ix);
1000         Double128Vector newVal = oldVal.blend(this, m);
1001         newVal.intoByteArray(a, ix);
1002     }
1003 
1004     @Override
1005     @ForceInline
1006     public void intoByteBuffer(ByteBuffer bb, int ix) {
1007         if (bb.order() != ByteOrder.nativeOrder()) {
1008             throw new IllegalArgumentException();
1009         }
1010         if (bb.isReadOnly()) {
1011             throw new ReadOnlyBufferException();
1012         }
1013         ix = VectorIntrinsics.checkIndex(ix, bb.limit(), bitSize() / Byte.SIZE);
1014         VectorIntrinsics.store(Double128Vector.class, double.class, LENGTH,
1015                                U.getReference(bb, BYTE_BUFFER_HB), ix + U.getLong(bb, BUFFER_ADDRESS),
1016                                this,
1017                                bb, ix,
1018                                (c, idx, v) -> {
1019                                    ByteBuffer bbc = c.duplicate().position(idx).order(ByteOrder.nativeOrder());
1020                                    DoubleBuffer tb = bbc.asDoubleBuffer();
1021                                    v.forEach((i, e) -> tb.put(e));
1022                                });
1023     }
1024 
1025     @Override
1026     @ForceInline
1027     public void intoByteBuffer(ByteBuffer bb, int ix, Mask<Double> m) {
1028         Double128Vector oldVal = (Double128Vector) DoubleVector.fromByteBuffer(SPECIES, bb, ix);
1029         Double128Vector newVal = oldVal.blend(this, m);
1030         newVal.intoByteBuffer(bb, ix);
1031     }
1032 
1033     //
1034 
1035     @Override
1036     public String toString() {
1037         return Arrays.toString(getElements());
1038     }
1039 
1040     @Override
1041     public boolean equals(Object o) {
1042         if (this == o) return true;
1043         if (o == null || this.getClass() != o.getClass()) return false;
1044 
1045         Double128Vector that = (Double128Vector) o;
1046         return this.equal(that).allTrue();
1047     }


1132         Objects.requireNonNull(o);
1133         Double128Vector v = (Double128Vector)o;
1134 
1135         return VectorIntrinsics.compare(
1136             BT_ge, Double128Vector.class, Double128Mask.class, double.class, LENGTH,
1137             this, v,
1138             (v1, v2) -> v1.bTest(v2, (i, a, b) -> a >= b));
1139     }
1140 
1141     // Foreach
1142 
1143     @Override
1144     void forEach(FUnCon f) {
1145         double[] vec = getElements();
1146         for (int i = 0; i < length(); i++) {
1147             f.apply(i, vec[i]);
1148         }
1149     }
1150 
1151     @Override
1152     void forEach(Mask<Double> o, FUnCon f) {
1153         boolean[] mbits = ((Double128Mask)o).getBits();
1154         forEach((i, a) -> {
1155             if (mbits[i]) { f.apply(i, a); }
1156         });
1157     }
1158 
1159     Long128Vector toBits() {
1160         double[] vec = getElements();
1161         long[] res = new long[this.species().length()];
1162         for(int i = 0; i < this.species().length(); i++){
1163             res[i] = Double.doubleToLongBits(vec[i]);
1164         }
1165         return new Long128Vector(res);
1166     }
1167 
1168 
1169     @Override
1170     public Double128Vector rotateEL(int j) {
1171         double[] vec = getElements();
1172         double[] res = new double[length()];


1197         double[] res = new double[length()];
1198         for (int i = 0; i < length() - j; i++) {
1199             res[i] = vec[i + j];
1200         }
1201         return new Double128Vector(res);
1202     }
1203 
1204     @Override
1205     public Double128Vector shiftER(int j) {
1206         double[] vec = getElements();
1207         double[] res = new double[length()];
1208         for (int i = 0; i < length() - j; i++){
1209             res[i + j] = vec[i];
1210         }
1211         return new Double128Vector(res);
1212     }
1213 
1214     @Override
1215     @ForceInline
1216     public Double128Vector rearrange(Vector<Double> v,
1217                                   Shuffle<Double> s, Mask<Double> m) {
1218         return this.rearrange(s).blend(v.rearrange(s), m);
1219     }
1220 
1221     @Override
1222     @ForceInline
1223     public Double128Vector rearrange(Shuffle<Double> o1) {
1224         Objects.requireNonNull(o1);
1225         Double128Shuffle s =  (Double128Shuffle)o1;
1226 
1227         return VectorIntrinsics.rearrangeOp(
1228             Double128Vector.class, Double128Shuffle.class, double.class, LENGTH,
1229             this, s,
1230             (v1, s_) -> v1.uOp((i, a) -> {
1231                 int ei = s_.getElement(i);
1232                 return v1.get(ei);
1233             }));
1234     }
1235 
1236     @Override
1237     @ForceInline
1238     public Double128Vector blend(Vector<Double> o1, Mask<Double> o2) {
1239         Objects.requireNonNull(o1);
1240         Objects.requireNonNull(o2);
1241         Double128Vector v = (Double128Vector)o1;
1242         Double128Mask   m = (Double128Mask)o2;
1243 
1244         return VectorIntrinsics.blend(
1245             Double128Vector.class, Double128Mask.class, double.class, LENGTH,
1246             this, v, m,
1247             (v1, v2, m_) -> v1.bOp(v2, (i, a, b) -> m_.getElement(i) ? b : a));
1248     }
1249 
1250     // Accessors
1251 
1252     @Override
1253     public double get(int i) {
1254         if (i < 0 || i >= LENGTH) {
1255             throw new IllegalArgumentException("Index " + i + " must be zero or positive, and less than " + LENGTH);
1256         }
1257         long bits = (long) VectorIntrinsics.extract(
1258                                 Double128Vector.class, double.class, LENGTH,


1303             boolean[] bits = new boolean[species().length()];
1304             Arrays.fill(bits, val);
1305             this.bits = bits;
1306         }
1307 
1308         boolean[] getBits() {
1309             return VectorIntrinsics.maybeRebox(this).bits;
1310         }
1311 
1312         @Override
1313         Double128Mask uOp(MUnOp f) {
1314             boolean[] res = new boolean[species().length()];
1315             boolean[] bits = getBits();
1316             for (int i = 0; i < species().length(); i++) {
1317                 res[i] = f.apply(i, bits[i]);
1318             }
1319             return new Double128Mask(res);
1320         }
1321 
1322         @Override
1323         Double128Mask bOp(Mask<Double> o, MBinOp f) {
1324             boolean[] res = new boolean[species().length()];
1325             boolean[] bits = getBits();
1326             boolean[] mbits = ((Double128Mask)o).getBits();
1327             for (int i = 0; i < species().length(); i++) {
1328                 res[i] = f.apply(i, bits[i], mbits[i]);
1329             }
1330             return new Double128Mask(res);
1331         }
1332 
1333         @Override
1334         public Species<Double> species() {
1335             return SPECIES;
1336         }
1337 
1338         @Override
1339         public Double128Vector toVector() {
1340             double[] res = new double[species().length()];
1341             boolean[] bits = getBits();
1342             for (int i = 0; i < species().length(); i++) {
1343                 // -1 will result in the most significant bit being set in
1344                 // addition to some or all other bits
1345                 res[i] = (double) (bits[i] ? -1 : 0);
1346             }
1347             return new Double128Vector(res);
1348         }
1349 
1350         @Override
1351         @ForceInline
1352         @SuppressWarnings("unchecked")
1353         public <E> Mask<E> cast(Species<E> species) {
1354             if (length() != species.length())
1355                 throw new IllegalArgumentException("Mask length and species length differ");
1356             Class<?> stype = species.elementType();
1357             boolean [] maskArray = toArray();
1358             if (stype == byte.class) {
1359                 return (Mask <E>) new Byte128Vector.Byte128Mask(maskArray);
1360             } else if (stype == short.class) {
1361                 return (Mask <E>) new Short128Vector.Short128Mask(maskArray);
1362             } else if (stype == int.class) {
1363                 return (Mask <E>) new Int128Vector.Int128Mask(maskArray);
1364             } else if (stype == long.class) {
1365                 return (Mask <E>) new Long128Vector.Long128Mask(maskArray);
1366             } else if (stype == float.class) {
1367                 return (Mask <E>) new Float128Vector.Float128Mask(maskArray);
1368             } else if (stype == double.class) {
1369                 return (Mask <E>) new Double128Vector.Double128Mask(maskArray);
1370             } else {
1371                 throw new UnsupportedOperationException("Bad lane type for casting.");
1372             }
1373         }
1374 
1375         // Unary operations
1376 
1377         @Override
1378         @ForceInline
1379         public Double128Mask not() {
1380             return (Double128Mask) VectorIntrinsics.unaryOp(
1381                                              VECTOR_OP_NOT, Double128Mask.class, long.class, LENGTH,
1382                                              this,
1383                                              (m1) -> m1.uOp((i, a) -> !a));
1384         }
1385 
1386         // Binary operations
1387 
1388         @Override
1389         @ForceInline
1390         public Double128Mask and(Mask<Double> o) {
1391             Objects.requireNonNull(o);
1392             Double128Mask m = (Double128Mask)o;
1393             return VectorIntrinsics.binaryOp(VECTOR_OP_AND, Double128Mask.class, long.class, LENGTH,
1394                                              this, m,
1395                                              (m1, m2) -> m1.bOp(m2, (i, a, b) -> a & b));
1396         }
1397 
1398         @Override
1399         @ForceInline
1400         public Double128Mask or(Mask<Double> o) {
1401             Objects.requireNonNull(o);
1402             Double128Mask m = (Double128Mask)o;
1403             return VectorIntrinsics.binaryOp(VECTOR_OP_OR, Double128Mask.class, long.class, LENGTH,
1404                                              this, m,
1405                                              (m1, m2) -> m1.bOp(m2, (i, a, b) -> a | b));
1406         }
1407 
1408         // Reductions
1409 
1410         @Override
1411         @ForceInline
1412         public boolean anyTrue() {
1413             return VectorIntrinsics.test(BT_ne, Double128Mask.class, long.class, LENGTH,
1414                                          this, this,
1415                                          (m, __) -> anyTrueHelper(((Double128Mask)m).getBits()));
1416         }
1417 
1418         @Override
1419         @ForceInline
1420         public boolean allTrue() {
1421             return VectorIntrinsics.test(BT_overflow, Double128Mask.class, long.class, LENGTH,
1422                                          this, DoubleVector.maskAllTrue(species()),
1423                                          (m, __) -> allTrueHelper(((Double128Mask)m).getBits()));
1424         }
1425     }
1426 
1427     // Shuffle
1428 
1429     static final class Double128Shuffle extends AbstractShuffle<Double> {
1430         Double128Shuffle(byte[] reorder) {
1431             super(reorder);
1432         }
1433 
1434         public Double128Shuffle(int[] reorder) {
1435             super(reorder);
1436         }
1437 
1438         public Double128Shuffle(int[] reorder, int i) {
1439             super(reorder, i);
1440         }
1441 
1442         public Double128Shuffle(IntUnaryOperator f) {
1443             super(f);
1444         }
1445 
1446         @Override
1447         public Species<Double> species() {
1448             return SPECIES;
1449         }
1450 
1451         @Override
1452         public DoubleVector toVector() {
1453             double[] va = new double[SPECIES.length()];
1454             for (int i = 0; i < va.length; i++) {
1455               va[i] = (double) getElement(i);
1456             }
1457             return DoubleVector.fromArray(SPECIES, va, 0);
1458         }
1459 
1460         @Override
1461         @ForceInline
1462         @SuppressWarnings("unchecked")
1463         public <F> Shuffle<F> cast(Species<F> species) {
1464             if (length() != species.length())
1465                 throw new IllegalArgumentException("Shuffle length and species length differ");
1466             Class<?> stype = species.elementType();
1467             int [] shuffleArray = toArray();
1468             if (stype == byte.class) {
1469                 return (Shuffle<F>) new Byte128Vector.Byte128Shuffle(shuffleArray);
1470             } else if (stype == short.class) {
1471                 return (Shuffle<F>) new Short128Vector.Short128Shuffle(shuffleArray);
1472             } else if (stype == int.class) {
1473                 return (Shuffle<F>) new Int128Vector.Int128Shuffle(shuffleArray);
1474             } else if (stype == long.class) {
1475                 return (Shuffle<F>) new Long128Vector.Long128Shuffle(shuffleArray);
1476             } else if (stype == float.class) {
1477                 return (Shuffle<F>) new Float128Vector.Float128Shuffle(shuffleArray);
1478             } else if (stype == double.class) {
1479                 return (Shuffle<F>) new Double128Vector.Double128Shuffle(shuffleArray);
1480             } else {
1481                 throw new UnsupportedOperationException("Bad lane type for casting.");
1482             }
1483         }
1484 
1485         @Override
1486         public Double128Shuffle rearrange(Vector.Shuffle<Double> o) {
1487             Double128Shuffle s = (Double128Shuffle) o;
1488             byte[] r = new byte[reorder.length];
1489             for (int i = 0; i < reorder.length; i++) {
1490                 r[i] = reorder[s.reorder[i]];
1491             }
1492             return new Double128Shuffle(r);
1493         }
1494     }
1495 
1496     // Species
1497 
1498     @Override
1499     public Species<Double> species() {
1500         return SPECIES;
1501     }
1502 }


  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 static jdk.incubator.vector.VectorIntrinsics.*;
  38 
  39 @SuppressWarnings("cast")
  40 final class Double128Vector extends DoubleVector {
  41     private static final VectorSpecies<Double> SPECIES = DoubleVector.SPECIES_128;
  42 
  43     static final Double128Vector ZERO = new Double128Vector();
  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(VectorShape.forBitSize(bitSize));
  53     }
  54 
  55     private final double[] vec; // Don't access directly, use getElements() instead.
  56 
  57     private double[] getElements() {
  58         return VectorIntrinsics.maybeRebox(this).vec;
  59     }
  60 
  61     Double128Vector() {
  62         vec = new double[SPECIES.length()];
  63     }
  64 
  65     Double128Vector(double[] v) {
  66         vec = v;
  67     }
  68 
  69     @Override
  70     public int length() { return LENGTH; }
  71 
  72     // Unary operator
  73 
  74     @Override
  75     Double128Vector uOp(FUnOp f) {
  76         double[] vec = getElements();
  77         double[] res = new double[length()];
  78         for (int i = 0; i < length(); i++) {
  79             res[i] = f.apply(i, vec[i]);
  80         }
  81         return new Double128Vector(res);
  82     }
  83 
  84     @Override
  85     Double128Vector uOp(VectorMask<Double> o, FUnOp f) {
  86         double[] vec = getElements();
  87         double[] res = new double[length()];
  88         boolean[] mbits = ((Double128Mask)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 Double128Vector(res);
  93     }
  94 
  95     // Binary operator
  96 
  97     @Override
  98     Double128Vector bOp(Vector<Double> o, FBinOp f) {
  99         double[] res = new double[length()];
 100         double[] vec1 = this.getElements();
 101         double[] vec2 = ((Double128Vector)o).getElements();
 102         for (int i = 0; i < length(); i++) {
 103             res[i] = f.apply(i, vec1[i], vec2[i]);
 104         }
 105         return new Double128Vector(res);
 106     }
 107 
 108     @Override
 109     Double128Vector bOp(Vector<Double> o1, VectorMask<Double> o2, FBinOp f) {
 110         double[] res = new double[length()];
 111         double[] vec1 = this.getElements();
 112         double[] vec2 = ((Double128Vector)o1).getElements();
 113         boolean[] mbits = ((Double128Mask)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 Double128Vector(res);
 118     }
 119 
 120     // Trinary operator
 121 
 122     @Override
 123     Double128Vector tOp(Vector<Double> o1, Vector<Double> o2, FTriOp f) {
 124         double[] res = new double[length()];
 125         double[] vec1 = this.getElements();
 126         double[] vec2 = ((Double128Vector)o1).getElements();
 127         double[] vec3 = ((Double128Vector)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 Double128Vector(res);
 132     }
 133 
 134     @Override
 135     Double128Vector tOp(Vector<Double> o1, Vector<Double> o2, VectorMask<Double> o3, FTriOp f) {
 136         double[] res = new double[length()];
 137         double[] vec1 = getElements();
 138         double[] vec2 = ((Double128Vector)o1).getElements();
 139         double[] vec3 = ((Double128Vector)o2).getElements();
 140         boolean[] mbits = ((Double128Mask)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 Double128Vector(res);
 145     }
 146 
 147     @Override
 148     double rOp(double v, FBinOp f) {
 149         double[] 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(VectorSpecies<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             Double128Vector.class,
 165             double.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(VectorSpecies<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((VectorSpecies<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((VectorSpecies<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((VectorSpecies<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((VectorSpecies<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((VectorSpecies<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((VectorSpecies<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(VectorSpecies<F> s) {
 224         Objects.requireNonNull(s);
 225 
 226         if(s.elementType().equals(double.class)) {
 227             return (Vector<F>) reshape((VectorSpecies<Double>)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(VectorSpecies<F> s) {
 238         Objects.requireNonNull(s);
 239 
 240         Class<?> stype = s.elementType();
 241         if (stype == byte.class) {
 242             return VectorIntrinsics.reinterpret(
 243                 Double128Vector.class,
 244                 double.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                 Double128Vector.class,
 253                 double.class, LENGTH,
 254                 Short128Vector.class,
 255                 short.class, Short128Vector.LENGTH,
 256                 this, s,
 257                 (species, vector) -> vector.defaultReinterpret(species)


 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                 Double128Vector.class,
 289                 double.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 DoubleVector reshape(VectorSpecies<Double> s) {
 303         Objects.requireNonNull(s);
 304         if (s.bitSize() == 64 && (s.boxType() == Double64Vector.class)) {
 305             return VectorIntrinsics.reinterpret(
 306                 Double128Vector.class,
 307                 double.class, LENGTH,
 308                 Double64Vector.class,
 309                 double.class, Double64Vector.LENGTH,
 310                 this, s,
 311                 (species, vector) -> (DoubleVector) vector.defaultReinterpret(species)
 312             );
 313         } else if (s.bitSize() == 128 && (s.boxType() == Double128Vector.class)) {
 314             return VectorIntrinsics.reinterpret(
 315                 Double128Vector.class,
 316                 double.class, LENGTH,
 317                 Double128Vector.class,
 318                 double.class, Double128Vector.LENGTH,
 319                 this, s,
 320                 (species, vector) -> (DoubleVector) vector.defaultReinterpret(species)
 321             );
 322         } else if (s.bitSize() == 256 && (s.boxType() == Double256Vector.class)) {


 345                 DoubleMaxVector.class,
 346                 double.class, DoubleMaxVector.LENGTH,
 347                 this, s,
 348                 (species, vector) -> (DoubleVector) 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 DoubleVector add(double o) {
 360         return add((Double128Vector)DoubleVector.broadcast(SPECIES, o));
 361     }
 362 
 363     @Override
 364     @ForceInline
 365     public DoubleVector add(double o, VectorMask<Double> m) {
 366         return add((Double128Vector)DoubleVector.broadcast(SPECIES, o), m);
 367     }
 368 
 369     @Override
 370     @ForceInline
 371     public DoubleVector sub(double o) {
 372         return sub((Double128Vector)DoubleVector.broadcast(SPECIES, o));
 373     }
 374 
 375     @Override
 376     @ForceInline
 377     public DoubleVector sub(double o, VectorMask<Double> m) {
 378         return sub((Double128Vector)DoubleVector.broadcast(SPECIES, o), m);
 379     }
 380 
 381     @Override
 382     @ForceInline
 383     public DoubleVector mul(double o) {
 384         return mul((Double128Vector)DoubleVector.broadcast(SPECIES, o));
 385     }
 386 
 387     @Override
 388     @ForceInline
 389     public DoubleVector mul(double o, VectorMask<Double> m) {
 390         return mul((Double128Vector)DoubleVector.broadcast(SPECIES, o), m);
 391     }
 392 
 393     @Override
 394     @ForceInline
 395     public DoubleVector min(double o) {
 396         return min((Double128Vector)DoubleVector.broadcast(SPECIES, o));
 397     }
 398 
 399     @Override
 400     @ForceInline
 401     public DoubleVector max(double o) {
 402         return max((Double128Vector)DoubleVector.broadcast(SPECIES, o));
 403     }
 404 
 405     @Override
 406     @ForceInline
 407     public VectorMask<Double> equal(double o) {
 408         return equal((Double128Vector)DoubleVector.broadcast(SPECIES, o));
 409     }
 410 
 411     @Override
 412     @ForceInline
 413     public VectorMask<Double> notEqual(double o) {
 414         return notEqual((Double128Vector)DoubleVector.broadcast(SPECIES, o));
 415     }
 416 
 417     @Override
 418     @ForceInline
 419     public VectorMask<Double> lessThan(double o) {
 420         return lessThan((Double128Vector)DoubleVector.broadcast(SPECIES, o));
 421     }
 422 
 423     @Override
 424     @ForceInline
 425     public VectorMask<Double> lessThanEq(double o) {
 426         return lessThanEq((Double128Vector)DoubleVector.broadcast(SPECIES, o));
 427     }
 428 
 429     @Override
 430     @ForceInline
 431     public VectorMask<Double> greaterThan(double o) {
 432         return greaterThan((Double128Vector)DoubleVector.broadcast(SPECIES, o));
 433     }
 434 
 435     @Override
 436     @ForceInline
 437     public VectorMask<Double> greaterThanEq(double o) {
 438         return greaterThanEq((Double128Vector)DoubleVector.broadcast(SPECIES, o));
 439     }
 440 
 441     @Override
 442     @ForceInline
 443     public DoubleVector blend(double o, VectorMask<Double> m) {
 444         return blend((Double128Vector)DoubleVector.broadcast(SPECIES, o), m);
 445     }
 446 
 447     @Override
 448     @ForceInline
 449     public DoubleVector div(double o) {
 450         return div((Double128Vector)DoubleVector.broadcast(SPECIES, o));
 451     }
 452 
 453     @Override
 454     @ForceInline
 455     public DoubleVector div(double o, VectorMask<Double> m) {
 456         return div((Double128Vector)DoubleVector.broadcast(SPECIES, o), m);
 457     }
 458 
 459     @Override
 460     @ForceInline
 461     public Double128Vector div(Vector<Double> v, VectorMask<Double> m) {
 462         return blend(div(v), m);
 463     }
 464 
 465     @Override
 466     @ForceInline
 467     public DoubleVector atan2(double o) {
 468         return atan2((Double128Vector)DoubleVector.broadcast(SPECIES, o));
 469     }
 470 
 471     @Override
 472     @ForceInline
 473     public DoubleVector atan2(double o, VectorMask<Double> m) {
 474         return atan2((Double128Vector)DoubleVector.broadcast(SPECIES, o), m);
 475     }
 476 
 477     @Override
 478     @ForceInline
 479     public DoubleVector pow(double o) {
 480         return pow((Double128Vector)DoubleVector.broadcast(SPECIES, o));
 481     }
 482 
 483     @Override
 484     @ForceInline
 485     public DoubleVector pow(double o, VectorMask<Double> m) {
 486         return pow((Double128Vector)DoubleVector.broadcast(SPECIES, o), m);
 487     }
 488 
 489     @Override
 490     @ForceInline
 491     public DoubleVector fma(double o1, double o2) {
 492         return fma((Double128Vector)DoubleVector.broadcast(SPECIES, o1), (Double128Vector)DoubleVector.broadcast(SPECIES, o2));
 493     }
 494 
 495     @Override
 496     @ForceInline
 497     public DoubleVector fma(double o1, double o2, VectorMask<Double> m) {
 498         return fma((Double128Vector)DoubleVector.broadcast(SPECIES, o1), (Double128Vector)DoubleVector.broadcast(SPECIES, o2), m);
 499     }
 500 
 501     @Override
 502     @ForceInline
 503     public DoubleVector hypot(double o) {
 504         return hypot((Double128Vector)DoubleVector.broadcast(SPECIES, o));
 505     }
 506 
 507     @Override
 508     @ForceInline
 509     public DoubleVector hypot(double o, VectorMask<Double> m) {
 510         return hypot((Double128Vector)DoubleVector.broadcast(SPECIES, o), m);
 511     }
 512 
 513 
 514     // Unary operations
 515 
 516     @ForceInline
 517     @Override
 518     public Double128Vector neg(VectorMask<Double> m) {
 519         return blend(neg(), m);
 520     }
 521 
 522     @Override
 523     @ForceInline
 524     public Double128Vector abs() {
 525         return VectorIntrinsics.unaryOp(
 526             VECTOR_OP_ABS, Double128Vector.class, double.class, LENGTH,
 527             this,
 528             v1 -> v1.uOp((i, a) -> (double) Math.abs(a)));
 529     }
 530 
 531     @ForceInline
 532     @Override
 533     public Double128Vector abs(VectorMask<Double> m) {
 534         return blend(abs(), m);
 535     }
 536 
 537     @Override
 538     @ForceInline
 539     public Double128Vector neg() {
 540         return VectorIntrinsics.unaryOp(
 541             VECTOR_OP_NEG, Double128Vector.class, double.class, LENGTH,
 542             this,
 543             v1 -> v1.uOp((i, a) -> (double) -a));
 544     }
 545 
 546     @Override
 547     @ForceInline
 548     public Double128Vector div(Vector<Double> o) {
 549         Objects.requireNonNull(o);
 550         Double128Vector v = (Double128Vector)o;
 551         return VectorIntrinsics.binaryOp(
 552             VECTOR_OP_DIV, Double128Vector.class, double.class, LENGTH,
 553             this, v,


 730             this, v,
 731             (v1, v2) -> ((Double128Vector)v1).bOp(v2, (i, a, b) -> (double)(Math.atan2(a,b))));
 732     }
 733 
 734 
 735     // Binary operations
 736 
 737     @Override
 738     @ForceInline
 739     public Double128Vector add(Vector<Double> o) {
 740         Objects.requireNonNull(o);
 741         Double128Vector v = (Double128Vector)o;
 742         return VectorIntrinsics.binaryOp(
 743             VECTOR_OP_ADD, Double128Vector.class, double.class, LENGTH,
 744             this, v,
 745             (v1, v2) -> v1.bOp(v2, (i, a, b) -> (double)(a + b)));
 746     }
 747 
 748     @Override
 749     @ForceInline
 750     public Double128Vector add(Vector<Double> v, VectorMask<Double> m) {
 751         return blend(add(v), m);
 752     }
 753 
 754     @Override
 755     @ForceInline
 756     public Double128Vector sub(Vector<Double> o) {
 757         Objects.requireNonNull(o);
 758         Double128Vector v = (Double128Vector)o;
 759         return VectorIntrinsics.binaryOp(
 760             VECTOR_OP_SUB, Double128Vector.class, double.class, LENGTH,
 761             this, v,
 762             (v1, v2) -> v1.bOp(v2, (i, a, b) -> (double)(a - b)));
 763     }
 764 
 765     @Override
 766     @ForceInline
 767     public Double128Vector sub(Vector<Double> v, VectorMask<Double> m) {
 768         return blend(sub(v), m);
 769     }
 770 
 771     @Override
 772     @ForceInline
 773     public Double128Vector mul(Vector<Double> o) {
 774         Objects.requireNonNull(o);
 775         Double128Vector v = (Double128Vector)o;
 776         return VectorIntrinsics.binaryOp(
 777             VECTOR_OP_MUL, Double128Vector.class, double.class, LENGTH,
 778             this, v,
 779             (v1, v2) -> v1.bOp(v2, (i, a, b) -> (double)(a * b)));
 780     }
 781 
 782     @Override
 783     @ForceInline
 784     public Double128Vector mul(Vector<Double> v, VectorMask<Double> m) {
 785         return blend(mul(v), m);
 786     }
 787 
 788     @Override
 789     @ForceInline
 790     public Double128Vector min(Vector<Double> o) {
 791         Objects.requireNonNull(o);
 792         Double128Vector v = (Double128Vector)o;
 793         return (Double128Vector) VectorIntrinsics.binaryOp(
 794             VECTOR_OP_MIN, Double128Vector.class, double.class, LENGTH,
 795             this, v,
 796             (v1, v2) -> v1.bOp(v2, (i, a, b) -> (double) Math.min(a, b)));
 797     }
 798 
 799     @Override
 800     @ForceInline
 801     public Double128Vector min(Vector<Double> v, VectorMask<Double> m) {
 802         return blend(min(v), m);
 803     }
 804 
 805     @Override
 806     @ForceInline
 807     public Double128Vector max(Vector<Double> o) {
 808         Objects.requireNonNull(o);
 809         Double128Vector v = (Double128Vector)o;
 810         return VectorIntrinsics.binaryOp(
 811             VECTOR_OP_MAX, Double128Vector.class, double.class, LENGTH,
 812             this, v,
 813             (v1, v2) -> v1.bOp(v2, (i, a, b) -> (double) Math.max(a, b)));
 814         }
 815 
 816     @Override
 817     @ForceInline
 818     public Double128Vector max(Vector<Double> v, VectorMask<Double> m) {
 819         return blend(max(v), m);
 820     }
 821 
 822 
 823     // Ternary operations
 824 
 825     @Override
 826     @ForceInline
 827     public Double128Vector fma(Vector<Double> o1, Vector<Double> o2) {
 828         Objects.requireNonNull(o1);
 829         Objects.requireNonNull(o2);
 830         Double128Vector v1 = (Double128Vector)o1;
 831         Double128Vector v2 = (Double128Vector)o2;
 832         return VectorIntrinsics.ternaryOp(
 833             VECTOR_OP_FMA, Double128Vector.class, double.class, LENGTH,
 834             this, v1, v2,
 835             (w1, w2, w3) -> w1.tOp(w2, w3, (i, a, b, c) -> Math.fma(a, b, c)));
 836     }
 837 
 838     // Type specific horizontal reductions


 875                                 });
 876         return Double.longBitsToDouble(bits);
 877     }
 878 
 879     @Override
 880     @ForceInline
 881     public double maxAll() {
 882         long bits = (long) VectorIntrinsics.reductionCoerced(
 883                                 VECTOR_OP_MAX, Double128Vector.class, double.class, LENGTH,
 884                                 this,
 885                                 v -> {
 886                                     double r = v.rOp(Double.NEGATIVE_INFINITY, (i, a, b) -> (double) Math.max(a, b));
 887                                     return (long)Double.doubleToLongBits(r);
 888                                 });
 889         return Double.longBitsToDouble(bits);
 890     }
 891 
 892 
 893     @Override
 894     @ForceInline
 895     public double addAll(VectorMask<Double> m) {
 896         return blend((Double128Vector)DoubleVector.broadcast(SPECIES, (double) 0), m).addAll();
 897     }
 898 
 899 
 900     @Override
 901     @ForceInline
 902     public double mulAll(VectorMask<Double> m) {
 903         return blend((Double128Vector)DoubleVector.broadcast(SPECIES, (double) 1), m).mulAll();
 904     }
 905 
 906     @Override
 907     @ForceInline
 908     public double minAll(VectorMask<Double> m) {
 909         return blend((Double128Vector)DoubleVector.broadcast(SPECIES, Double.MAX_VALUE), m).minAll();
 910     }
 911 
 912     @Override
 913     @ForceInline
 914     public double maxAll(VectorMask<Double> m) {
 915         return blend((Double128Vector)DoubleVector.broadcast(SPECIES, Double.MIN_VALUE), m).maxAll();
 916     }
 917 
 918     @Override
 919     @ForceInline
 920     public VectorShuffle<Double> toShuffle() {
 921         double[] a = toArray();
 922         int[] sa = new int[a.length];
 923         for (int i = 0; i < a.length; i++) {
 924             sa[i] = (int) a[i];
 925         }
 926         return VectorShuffle.fromArray(SPECIES, sa, 0);
 927     }
 928 
 929     // Memory operations
 930 
 931     private static final int ARRAY_SHIFT         = 31 - Integer.numberOfLeadingZeros(Unsafe.ARRAY_DOUBLE_INDEX_SCALE);
 932     private static final int BOOLEAN_ARRAY_SHIFT = 31 - Integer.numberOfLeadingZeros(Unsafe.ARRAY_BOOLEAN_INDEX_SCALE);
 933 
 934     @Override
 935     @ForceInline
 936     public void intoArray(double[] a, int ix) {
 937         Objects.requireNonNull(a);
 938         ix = VectorIntrinsics.checkIndex(ix, a.length, LENGTH);
 939         VectorIntrinsics.store(Double128Vector.class, double.class, LENGTH,
 940                                a, (((long) ix) << ARRAY_SHIFT) + Unsafe.ARRAY_DOUBLE_BASE_OFFSET,
 941                                this,
 942                                a, ix,
 943                                (arr, idx, v) -> v.forEach((i, e) -> arr[idx + i] = e));
 944     }
 945 
 946     @Override
 947     @ForceInline
 948     public final void intoArray(double[] a, int ax, VectorMask<Double> m) {
 949         DoubleVector oldVal = DoubleVector.fromArray(SPECIES, a, ax);
 950         DoubleVector newVal = oldVal.blend(this, m);
 951         newVal.intoArray(a, ax);
 952     }
 953     @Override
 954     @ForceInline
 955     public void intoArray(double[] a, int ix, int[] b, int iy) {
 956         Objects.requireNonNull(a);
 957         Objects.requireNonNull(b);
 958 
 959         // Index vector: vix[0:n] = i -> ix + indexMap[iy + i]
 960         IntVector vix = IntVector.fromArray(INDEX_SPECIES, b, iy).add(ix);
 961 
 962         vix = VectorIntrinsics.checkIndex(vix, a.length);
 963 
 964         VectorIntrinsics.storeWithMap(Double128Vector.class, double.class, LENGTH, Int64Vector.class,
 965                                a, Unsafe.ARRAY_DOUBLE_BASE_OFFSET, vix,
 966                                this,
 967                                a, ix, b, iy,
 968                                (arr, idx, v, indexMap, idy) -> v.forEach((i, e) -> arr[idx+indexMap[idy+i]] = e));
 969     }
 970 
 971      @Override
 972      @ForceInline
 973      public final void intoArray(double[] a, int ax, VectorMask<Double> m, int[] b, int iy) {
 974          // @@@ This can result in out of bounds errors for unset mask lanes
 975          DoubleVector oldVal = DoubleVector.fromArray(SPECIES, a, ax, b, iy);
 976          DoubleVector newVal = oldVal.blend(this, m);
 977          newVal.intoArray(a, ax, b, iy);
 978      }
 979 
 980     @Override
 981     @ForceInline
 982     public void intoByteArray(byte[] a, int ix) {
 983         Objects.requireNonNull(a);
 984         ix = VectorIntrinsics.checkIndex(ix, a.length, bitSize() / Byte.SIZE);
 985         VectorIntrinsics.store(Double128Vector.class, double.class, LENGTH,
 986                                a, ((long) ix) + Unsafe.ARRAY_BYTE_BASE_OFFSET,
 987                                this,
 988                                a, ix,
 989                                (c, idx, v) -> {
 990                                    ByteBuffer bbc = ByteBuffer.wrap(c, idx, c.length - idx).order(ByteOrder.nativeOrder());
 991                                    DoubleBuffer tb = bbc.asDoubleBuffer();
 992                                    v.forEach((i, e) -> tb.put(e));
 993                                });
 994     }
 995 
 996     @Override
 997     @ForceInline
 998     public final void intoByteArray(byte[] a, int ix, VectorMask<Double> m) {
 999         Double128Vector oldVal = (Double128Vector) DoubleVector.fromByteArray(SPECIES, a, ix);
1000         Double128Vector newVal = oldVal.blend(this, m);
1001         newVal.intoByteArray(a, ix);
1002     }
1003 
1004     @Override
1005     @ForceInline
1006     public void intoByteBuffer(ByteBuffer bb, int ix) {
1007         if (bb.order() != ByteOrder.nativeOrder()) {
1008             throw new IllegalArgumentException();
1009         }
1010         if (bb.isReadOnly()) {
1011             throw new ReadOnlyBufferException();
1012         }
1013         ix = VectorIntrinsics.checkIndex(ix, bb.limit(), bitSize() / Byte.SIZE);
1014         VectorIntrinsics.store(Double128Vector.class, double.class, LENGTH,
1015                                U.getReference(bb, BYTE_BUFFER_HB), ix + U.getLong(bb, BUFFER_ADDRESS),
1016                                this,
1017                                bb, ix,
1018                                (c, idx, v) -> {
1019                                    ByteBuffer bbc = c.duplicate().position(idx).order(ByteOrder.nativeOrder());
1020                                    DoubleBuffer tb = bbc.asDoubleBuffer();
1021                                    v.forEach((i, e) -> tb.put(e));
1022                                });
1023     }
1024 
1025     @Override
1026     @ForceInline
1027     public void intoByteBuffer(ByteBuffer bb, int ix, VectorMask<Double> m) {
1028         Double128Vector oldVal = (Double128Vector) DoubleVector.fromByteBuffer(SPECIES, bb, ix);
1029         Double128Vector newVal = oldVal.blend(this, m);
1030         newVal.intoByteBuffer(bb, ix);
1031     }
1032 
1033     //
1034 
1035     @Override
1036     public String toString() {
1037         return Arrays.toString(getElements());
1038     }
1039 
1040     @Override
1041     public boolean equals(Object o) {
1042         if (this == o) return true;
1043         if (o == null || this.getClass() != o.getClass()) return false;
1044 
1045         Double128Vector that = (Double128Vector) o;
1046         return this.equal(that).allTrue();
1047     }


1132         Objects.requireNonNull(o);
1133         Double128Vector v = (Double128Vector)o;
1134 
1135         return VectorIntrinsics.compare(
1136             BT_ge, Double128Vector.class, Double128Mask.class, double.class, LENGTH,
1137             this, v,
1138             (v1, v2) -> v1.bTest(v2, (i, a, b) -> a >= b));
1139     }
1140 
1141     // Foreach
1142 
1143     @Override
1144     void forEach(FUnCon f) {
1145         double[] vec = getElements();
1146         for (int i = 0; i < length(); i++) {
1147             f.apply(i, vec[i]);
1148         }
1149     }
1150 
1151     @Override
1152     void forEach(VectorMask<Double> o, FUnCon f) {
1153         boolean[] mbits = ((Double128Mask)o).getBits();
1154         forEach((i, a) -> {
1155             if (mbits[i]) { f.apply(i, a); }
1156         });
1157     }
1158 
1159     Long128Vector toBits() {
1160         double[] vec = getElements();
1161         long[] res = new long[this.species().length()];
1162         for(int i = 0; i < this.species().length(); i++){
1163             res[i] = Double.doubleToLongBits(vec[i]);
1164         }
1165         return new Long128Vector(res);
1166     }
1167 
1168 
1169     @Override
1170     public Double128Vector rotateEL(int j) {
1171         double[] vec = getElements();
1172         double[] res = new double[length()];


1197         double[] res = new double[length()];
1198         for (int i = 0; i < length() - j; i++) {
1199             res[i] = vec[i + j];
1200         }
1201         return new Double128Vector(res);
1202     }
1203 
1204     @Override
1205     public Double128Vector shiftER(int j) {
1206         double[] vec = getElements();
1207         double[] res = new double[length()];
1208         for (int i = 0; i < length() - j; i++){
1209             res[i + j] = vec[i];
1210         }
1211         return new Double128Vector(res);
1212     }
1213 
1214     @Override
1215     @ForceInline
1216     public Double128Vector rearrange(Vector<Double> v,
1217                                   VectorShuffle<Double> s, VectorMask<Double> m) {
1218         return this.rearrange(s).blend(v.rearrange(s), m);
1219     }
1220 
1221     @Override
1222     @ForceInline
1223     public Double128Vector rearrange(VectorShuffle<Double> o1) {
1224         Objects.requireNonNull(o1);
1225         Double128Shuffle s =  (Double128Shuffle)o1;
1226 
1227         return VectorIntrinsics.rearrangeOp(
1228             Double128Vector.class, Double128Shuffle.class, double.class, LENGTH,
1229             this, s,
1230             (v1, s_) -> v1.uOp((i, a) -> {
1231                 int ei = s_.getElement(i);
1232                 return v1.get(ei);
1233             }));
1234     }
1235 
1236     @Override
1237     @ForceInline
1238     public Double128Vector blend(Vector<Double> o1, VectorMask<Double> o2) {
1239         Objects.requireNonNull(o1);
1240         Objects.requireNonNull(o2);
1241         Double128Vector v = (Double128Vector)o1;
1242         Double128Mask   m = (Double128Mask)o2;
1243 
1244         return VectorIntrinsics.blend(
1245             Double128Vector.class, Double128Mask.class, double.class, LENGTH,
1246             this, v, m,
1247             (v1, v2, m_) -> v1.bOp(v2, (i, a, b) -> m_.getElement(i) ? b : a));
1248     }
1249 
1250     // Accessors
1251 
1252     @Override
1253     public double get(int i) {
1254         if (i < 0 || i >= LENGTH) {
1255             throw new IllegalArgumentException("Index " + i + " must be zero or positive, and less than " + LENGTH);
1256         }
1257         long bits = (long) VectorIntrinsics.extract(
1258                                 Double128Vector.class, double.class, LENGTH,


1303             boolean[] bits = new boolean[species().length()];
1304             Arrays.fill(bits, val);
1305             this.bits = bits;
1306         }
1307 
1308         boolean[] getBits() {
1309             return VectorIntrinsics.maybeRebox(this).bits;
1310         }
1311 
1312         @Override
1313         Double128Mask uOp(MUnOp f) {
1314             boolean[] res = new boolean[species().length()];
1315             boolean[] bits = getBits();
1316             for (int i = 0; i < species().length(); i++) {
1317                 res[i] = f.apply(i, bits[i]);
1318             }
1319             return new Double128Mask(res);
1320         }
1321 
1322         @Override
1323         Double128Mask bOp(VectorMask<Double> o, MBinOp f) {
1324             boolean[] res = new boolean[species().length()];
1325             boolean[] bits = getBits();
1326             boolean[] mbits = ((Double128Mask)o).getBits();
1327             for (int i = 0; i < species().length(); i++) {
1328                 res[i] = f.apply(i, bits[i], mbits[i]);
1329             }
1330             return new Double128Mask(res);
1331         }
1332 
1333         @Override
1334         public VectorSpecies<Double> species() {
1335             return SPECIES;
1336         }
1337 
1338         @Override
1339         public Double128Vector toVector() {
1340             double[] res = new double[species().length()];
1341             boolean[] bits = getBits();
1342             for (int i = 0; i < species().length(); i++) {
1343                 // -1 will result in the most significant bit being set in
1344                 // addition to some or all other bits
1345                 res[i] = (double) (bits[i] ? -1 : 0);
1346             }
1347             return new Double128Vector(res);
1348         }
1349 
1350         @Override
1351         @ForceInline
1352         @SuppressWarnings("unchecked")
1353         public <E> VectorMask<E> cast(VectorSpecies<E> species) {
1354             if (length() != species.length())
1355                 throw new IllegalArgumentException("VectorMask length and species length differ");
1356             Class<?> stype = species.elementType();
1357             boolean [] maskArray = toArray();
1358             if (stype == byte.class) {
1359                 return (VectorMask <E>) new Byte128Vector.Byte128Mask(maskArray);
1360             } else if (stype == short.class) {
1361                 return (VectorMask <E>) new Short128Vector.Short128Mask(maskArray);
1362             } else if (stype == int.class) {
1363                 return (VectorMask <E>) new Int128Vector.Int128Mask(maskArray);
1364             } else if (stype == long.class) {
1365                 return (VectorMask <E>) new Long128Vector.Long128Mask(maskArray);
1366             } else if (stype == float.class) {
1367                 return (VectorMask <E>) new Float128Vector.Float128Mask(maskArray);
1368             } else if (stype == double.class) {
1369                 return (VectorMask <E>) new Double128Vector.Double128Mask(maskArray);
1370             } else {
1371                 throw new UnsupportedOperationException("Bad lane type for casting.");
1372             }
1373         }
1374 
1375         // Unary operations
1376 
1377         @Override
1378         @ForceInline
1379         public Double128Mask not() {
1380             return (Double128Mask) VectorIntrinsics.unaryOp(
1381                                              VECTOR_OP_NOT, Double128Mask.class, long.class, LENGTH,
1382                                              this,
1383                                              (m1) -> m1.uOp((i, a) -> !a));
1384         }
1385 
1386         // Binary operations
1387 
1388         @Override
1389         @ForceInline
1390         public Double128Mask and(VectorMask<Double> o) {
1391             Objects.requireNonNull(o);
1392             Double128Mask m = (Double128Mask)o;
1393             return VectorIntrinsics.binaryOp(VECTOR_OP_AND, Double128Mask.class, long.class, LENGTH,
1394                                              this, m,
1395                                              (m1, m2) -> m1.bOp(m2, (i, a, b) -> a & b));
1396         }
1397 
1398         @Override
1399         @ForceInline
1400         public Double128Mask or(VectorMask<Double> o) {
1401             Objects.requireNonNull(o);
1402             Double128Mask m = (Double128Mask)o;
1403             return VectorIntrinsics.binaryOp(VECTOR_OP_OR, Double128Mask.class, long.class, LENGTH,
1404                                              this, m,
1405                                              (m1, m2) -> m1.bOp(m2, (i, a, b) -> a | b));
1406         }
1407 
1408         // Reductions
1409 
1410         @Override
1411         @ForceInline
1412         public boolean anyTrue() {
1413             return VectorIntrinsics.test(BT_ne, Double128Mask.class, long.class, LENGTH,
1414                                          this, this,
1415                                          (m, __) -> anyTrueHelper(((Double128Mask)m).getBits()));
1416         }
1417 
1418         @Override
1419         @ForceInline
1420         public boolean allTrue() {
1421             return VectorIntrinsics.test(BT_overflow, Double128Mask.class, long.class, LENGTH,
1422                                          this, VectorMask.maskAllTrue(species()),
1423                                          (m, __) -> allTrueHelper(((Double128Mask)m).getBits()));
1424         }
1425     }
1426 
1427     // Shuffle
1428 
1429     static final class Double128Shuffle extends AbstractShuffle<Double> {
1430         Double128Shuffle(byte[] reorder) {
1431             super(reorder);
1432         }
1433 
1434         public Double128Shuffle(int[] reorder) {
1435             super(reorder);
1436         }
1437 
1438         public Double128Shuffle(int[] reorder, int i) {
1439             super(reorder, i);
1440         }
1441 
1442         public Double128Shuffle(IntUnaryOperator f) {
1443             super(f);
1444         }
1445 
1446         @Override
1447         public VectorSpecies<Double> species() {
1448             return SPECIES;
1449         }
1450 
1451         @Override
1452         public DoubleVector toVector() {
1453             double[] va = new double[SPECIES.length()];
1454             for (int i = 0; i < va.length; i++) {
1455               va[i] = (double) getElement(i);
1456             }
1457             return DoubleVector.fromArray(SPECIES, va, 0);
1458         }
1459 
1460         @Override
1461         @ForceInline
1462         @SuppressWarnings("unchecked")
1463         public <F> VectorShuffle<F> cast(VectorSpecies<F> species) {
1464             if (length() != species.length())
1465                 throw new IllegalArgumentException("Shuffle length and species length differ");
1466             Class<?> stype = species.elementType();
1467             int [] shuffleArray = toArray();
1468             if (stype == byte.class) {
1469                 return (VectorShuffle<F>) new Byte128Vector.Byte128Shuffle(shuffleArray);
1470             } else if (stype == short.class) {
1471                 return (VectorShuffle<F>) new Short128Vector.Short128Shuffle(shuffleArray);
1472             } else if (stype == int.class) {
1473                 return (VectorShuffle<F>) new Int128Vector.Int128Shuffle(shuffleArray);
1474             } else if (stype == long.class) {
1475                 return (VectorShuffle<F>) new Long128Vector.Long128Shuffle(shuffleArray);
1476             } else if (stype == float.class) {
1477                 return (VectorShuffle<F>) new Float128Vector.Float128Shuffle(shuffleArray);
1478             } else if (stype == double.class) {
1479                 return (VectorShuffle<F>) new Double128Vector.Double128Shuffle(shuffleArray);
1480             } else {
1481                 throw new UnsupportedOperationException("Bad lane type for casting.");
1482             }
1483         }
1484 
1485         @Override
1486         public Double128Shuffle rearrange(VectorShuffle<Double> o) {
1487             Double128Shuffle s = (Double128Shuffle) o;
1488             byte[] r = new byte[reorder.length];
1489             for (int i = 0; i < reorder.length; i++) {
1490                 r[i] = reorder[s.reorder[i]];
1491             }
1492             return new Double128Shuffle(r);
1493         }
1494     }
1495 
1496     // VectorSpecies
1497 
1498     @Override
1499     public VectorSpecies<Double> species() {
1500         return SPECIES;
1501     }
1502 }
< prev index next >