447 public static final DoubleVector single(Species<Double> s, double e) {
448 return zero(s).with(0, e);
449 }
450
451 /**
452 * Returns a vector where each lane element is set to a randomly
453 * generated primitive value.
454 *
455 * The semantics are equivalent to calling
456 * {@link ThreadLocalRandom#nextDouble()}
457 *
458 * @param s species of the desired vector
459 * @return a vector where each lane elements is set to a randomly
460 * generated primitive value
461 */
462 public static DoubleVector random(Species<Double> s) {
463 ThreadLocalRandom r = ThreadLocalRandom.current();
464 return ((DoubleSpecies)s).op(i -> r.nextDouble());
465 }
466
467 /**
468 * Returns a mask where each lane is set or unset according to given
469 * {@code boolean} values
470 * <p>
471 * For each mask lane, where {@code N} is the mask lane index,
472 * if the given {@code boolean} value at index {@code N} is {@code true}
473 * then the mask lane at index {@code N} is set, otherwise it is unset.
474 *
475 * @param species mask species
476 * @param bits the given {@code boolean} values
477 * @return a mask where each lane is set or unset according to the given {@code boolean} value
478 * @throws IndexOutOfBoundsException if {@code bits.length < species.length()}
479 */
480 @ForceInline
481 public static Mask<Double> maskFromValues(Species<Double> species, boolean... bits) {
482 if (species.boxType() == DoubleMaxVector.class)
483 return new DoubleMaxVector.DoubleMaxMask(bits);
484 switch (species.bitSize()) {
485 case 64: return new Double64Vector.Double64Mask(bits);
486 case 128: return new Double128Vector.Double128Mask(bits);
487 case 256: return new Double256Vector.Double256Mask(bits);
488 case 512: return new Double512Vector.Double512Mask(bits);
489 default: throw new IllegalArgumentException(Integer.toString(species.bitSize()));
490 }
491 }
492
493 // @@@ This is a bad implementation -- makes lambdas capturing -- fix this
494 static Mask<Double> trueMask(Species<Double> species) {
495 if (species.boxType() == DoubleMaxVector.class)
496 return DoubleMaxVector.DoubleMaxMask.TRUE_MASK;
497 switch (species.bitSize()) {
498 case 64: return Double64Vector.Double64Mask.TRUE_MASK;
499 case 128: return Double128Vector.Double128Mask.TRUE_MASK;
500 case 256: return Double256Vector.Double256Mask.TRUE_MASK;
501 case 512: return Double512Vector.Double512Mask.TRUE_MASK;
502 default: throw new IllegalArgumentException(Integer.toString(species.bitSize()));
503 }
504 }
505
506 static Mask<Double> falseMask(Species<Double> species) {
507 if (species.boxType() == DoubleMaxVector.class)
508 return DoubleMaxVector.DoubleMaxMask.FALSE_MASK;
509 switch (species.bitSize()) {
510 case 64: return Double64Vector.Double64Mask.FALSE_MASK;
511 case 128: return Double128Vector.Double128Mask.FALSE_MASK;
512 case 256: return Double256Vector.Double256Mask.FALSE_MASK;
513 case 512: return Double512Vector.Double512Mask.FALSE_MASK;
514 default: throw new IllegalArgumentException(Integer.toString(species.bitSize()));
515 }
516 }
517
518 /**
519 * Loads a mask from a {@code boolean} array starting at an offset.
520 * <p>
521 * For each mask lane, where {@code N} is the mask lane index,
522 * if the array element at index {@code ix + N} is {@code true} then the
523 * mask lane at index {@code N} is set, otherwise it is unset.
524 *
525 * @param species mask species
526 * @param bits the {@code boolean} array
527 * @param ix the offset into the array
528 * @return the mask loaded from a {@code boolean} array
529 * @throws IndexOutOfBoundsException if {@code ix < 0}, or
530 * {@code ix > bits.length - species.length()}
531 */
532 @ForceInline
533 @SuppressWarnings("unchecked")
534 public static Mask<Double> maskFromArray(Species<Double> species, boolean[] bits, int ix) {
535 Objects.requireNonNull(bits);
536 ix = VectorIntrinsics.checkIndex(ix, bits.length, species.length());
537 return VectorIntrinsics.load((Class<Mask<Double>>) species.maskType(), long.class, species.length(),
538 bits, (((long) ix) << ARRAY_SHIFT) + Unsafe.ARRAY_BOOLEAN_BASE_OFFSET,
539 bits, ix, species,
540 (c, idx, s) -> (Mask<Double>) ((DoubleSpecies)s).opm(n -> c[idx + n]));
541 }
542
543 /**
544 * Returns a mask where all lanes are set.
545 *
546 * @param species mask species
547 * @return a mask where all lanes are set
548 */
549 @ForceInline
550 @SuppressWarnings("unchecked")
551 public static Mask<Double> maskAllTrue(Species<Double> species) {
552 return VectorIntrinsics.broadcastCoerced((Class<Mask<Double>>) species.maskType(), long.class, species.length(),
553 (long)-1, species,
554 ((z, s) -> trueMask(s)));
555 }
556
557 /**
558 * Returns a mask where all lanes are unset.
559 *
560 * @param species mask species
561 * @return a mask where all lanes are unset
562 */
563 @ForceInline
564 @SuppressWarnings("unchecked")
565 public static Mask<Double> maskAllFalse(Species<Double> species) {
566 return VectorIntrinsics.broadcastCoerced((Class<Mask<Double>>) species.maskType(), long.class, species.length(),
567 0, species,
568 ((z, s) -> falseMask(s)));
569 }
570
571 /**
572 * Returns a shuffle of mapped indexes where each lane element is
573 * the result of applying a mapping function to the corresponding lane
574 * index.
575 * <p>
576 * Care should be taken to ensure Shuffle values produced from this
577 * method are consumed as constants to ensure optimal generation of
578 * code. For example, values held in static final fields or values
579 * held in loop constant local variables.
580 * <p>
581 * This method behaves as if a shuffle is created from an array of
582 * mapped indexes as follows:
583 * <pre>{@code
584 * int[] a = new int[species.length()];
585 * for (int i = 0; i < a.length; i++) {
586 * a[i] = f.applyAsInt(i);
587 * }
588 * return this.shuffleFromValues(a);
589 * }</pre>
590 *
591 * @param species shuffle species
592 * @param f the lane index mapping function
593 * @return a shuffle of mapped indexes
594 */
595 @ForceInline
596 public static Shuffle<Double> shuffle(Species<Double> species, IntUnaryOperator f) {
597 if (species.boxType() == DoubleMaxVector.class)
598 return new DoubleMaxVector.DoubleMaxShuffle(f);
599 switch (species.bitSize()) {
600 case 64: return new Double64Vector.Double64Shuffle(f);
601 case 128: return new Double128Vector.Double128Shuffle(f);
602 case 256: return new Double256Vector.Double256Shuffle(f);
603 case 512: return new Double512Vector.Double512Shuffle(f);
604 default: throw new IllegalArgumentException(Integer.toString(species.bitSize()));
605 }
606 }
607
608 /**
609 * Returns a shuffle where each lane element is the value of its
610 * corresponding lane index.
611 * <p>
612 * This method behaves as if a shuffle is created from an identity
613 * index mapping function as follows:
614 * <pre>{@code
615 * return this.shuffle(i -> i);
616 * }</pre>
617 *
618 * @param species shuffle species
619 * @return a shuffle of lane indexes
620 */
621 @ForceInline
622 public static Shuffle<Double> shuffleIota(Species<Double> species) {
623 if (species.boxType() == DoubleMaxVector.class)
624 return new DoubleMaxVector.DoubleMaxShuffle(AbstractShuffle.IDENTITY);
625 switch (species.bitSize()) {
626 case 64: return new Double64Vector.Double64Shuffle(AbstractShuffle.IDENTITY);
627 case 128: return new Double128Vector.Double128Shuffle(AbstractShuffle.IDENTITY);
628 case 256: return new Double256Vector.Double256Shuffle(AbstractShuffle.IDENTITY);
629 case 512: return new Double512Vector.Double512Shuffle(AbstractShuffle.IDENTITY);
630 default: throw new IllegalArgumentException(Integer.toString(species.bitSize()));
631 }
632 }
633
634 /**
635 * Returns a shuffle where each lane element is set to a given
636 * {@code int} value logically AND'ed by the species length minus one.
637 * <p>
638 * For each shuffle lane, where {@code N} is the shuffle lane index, the
639 * the {@code int} value at index {@code N} logically AND'ed by
640 * {@code species.length() - 1} is placed into the resulting shuffle at
641 * lane index {@code N}.
642 *
643 * @param species shuffle species
644 * @param ixs the given {@code int} values
645 * @return a shuffle where each lane element is set to a given
646 * {@code int} value
647 * @throws IndexOutOfBoundsException if the number of int values is
648 * {@code < species.length()}
649 */
650 @ForceInline
651 public static Shuffle<Double> shuffleFromValues(Species<Double> species, int... ixs) {
652 if (species.boxType() == DoubleMaxVector.class)
653 return new DoubleMaxVector.DoubleMaxShuffle(ixs);
654 switch (species.bitSize()) {
655 case 64: return new Double64Vector.Double64Shuffle(ixs);
656 case 128: return new Double128Vector.Double128Shuffle(ixs);
657 case 256: return new Double256Vector.Double256Shuffle(ixs);
658 case 512: return new Double512Vector.Double512Shuffle(ixs);
659 default: throw new IllegalArgumentException(Integer.toString(species.bitSize()));
660 }
661 }
662
663 /**
664 * Loads a shuffle from an {@code int} array starting at an offset.
665 * <p>
666 * For each shuffle lane, where {@code N} is the shuffle lane index, the
667 * array element at index {@code i + N} logically AND'ed by
668 * {@code species.length() - 1} is placed into the resulting shuffle at lane
669 * index {@code N}.
670 *
671 * @param species shuffle species
672 * @param ixs the {@code int} array
673 * @param i the offset into the array
674 * @return a shuffle loaded from the {@code int} array
675 * @throws IndexOutOfBoundsException if {@code i < 0}, or
676 * {@code i > a.length - species.length()}
677 */
678 @ForceInline
679 public static Shuffle<Double> shuffleFromArray(Species<Double> species, int[] ixs, int i) {
680 if (species.boxType() == DoubleMaxVector.class)
681 return new DoubleMaxVector.DoubleMaxShuffle(ixs, i);
682 switch (species.bitSize()) {
683 case 64: return new Double64Vector.Double64Shuffle(ixs, i);
684 case 128: return new Double128Vector.Double128Shuffle(ixs, i);
685 case 256: return new Double256Vector.Double256Shuffle(ixs, i);
686 case 512: return new Double512Vector.Double512Shuffle(ixs, i);
687 default: throw new IllegalArgumentException(Integer.toString(species.bitSize()));
688 }
689 }
690
691 // Ops
692
693 @Override
694 public abstract DoubleVector add(Vector<Double> v);
695
696 /**
697 * Adds this vector to the broadcast of an input scalar.
698 * <p>
699 * This is a vector binary operation where the primitive addition operation
700 * ({@code +}) is applied to lane elements.
701 *
702 * @param s the input scalar
703 * @return the result of adding this vector to the broadcast of an input
704 * scalar
705 */
706 public abstract DoubleVector add(double s);
707
708 @Override
709 public abstract DoubleVector add(Vector<Double> v, Mask<Double> m);
710
2085 * @param a the array
2086 * @param i the offset into the array, may be negative if relative
2087 * indexes in the index map compensate to produce a value within the
2088 * array bounds
2089 * @param m the mask
2090 * @param indexMap the index map
2091 * @param j the offset into the index map
2092 * @throws IndexOutOfBoundsException if {@code j < 0}, or
2093 * {@code j > indexMap.length - this.length()},
2094 * or for any vector lane index {@code N} where the mask at lane
2095 * {@code N} is set the result of {@code i + indexMap[j + N]} is
2096 * {@code < 0} or {@code >= a.length}
2097 */
2098 public abstract void intoArray(double[] a, int i, Mask<Double> m, int[] indexMap, int j);
2099 // Species
2100
2101 @Override
2102 public abstract Species<Double> species();
2103
2104 /**
2105 * Class representing {@link DoubleVector}'s of the same {@link Vector.Shape Shape}.
2106 */
2107 static final class DoubleSpecies extends Vector.AbstractSpecies<Double> {
2108 final Function<double[], DoubleVector> vectorFactory;
2109 final Function<boolean[], Vector.Mask<Double>> maskFactory;
2110
2111 private DoubleSpecies(Vector.Shape shape,
2112 Class<?> boxType,
2113 Class<?> maskType,
2114 Function<double[], DoubleVector> vectorFactory,
2115 Function<boolean[], Vector.Mask<Double>> maskFactory) {
2116 super(shape, double.class, Double.SIZE, boxType, maskType);
2117 this.vectorFactory = vectorFactory;
2118 this.maskFactory = maskFactory;
2119 }
2120
2121 interface FOp {
2122 double apply(int i);
2123 }
2124
2125 interface FOpm {
2126 boolean apply(int i);
2127 }
2128
2129 DoubleVector op(FOp f) {
2130 double[] res = new double[length()];
2131 for (int i = 0; i < length(); i++) {
2132 res[i] = f.apply(i);
2133 }
2134 return vectorFactory.apply(res);
2135 }
2136
2137 DoubleVector op(Vector.Mask<Double> o, FOp f) {
2138 double[] res = new double[length()];
2139 boolean[] mbits = ((AbstractMask<Double>)o).getBits();
2140 for (int i = 0; i < length(); i++) {
2141 if (mbits[i]) {
2142 res[i] = f.apply(i);
2143 }
2144 }
2145 return vectorFactory.apply(res);
2146 }
2147
2148 Vector.Mask<Double> opm(IntVector.IntSpecies.FOpm f) {
2149 boolean[] res = new boolean[length()];
2150 for (int i = 0; i < length(); i++) {
2151 res[i] = (boolean)f.apply(i);
2152 }
2153 return maskFactory.apply(res);
2154 }
2155 }
2156
2157 /**
2158 * Finds the preferred species for an element type of {@code double}.
2159 * <p>
2160 * A preferred species is a species chosen by the platform that has a
2161 * shape of maximal bit size. A preferred species for different element
2162 * types will have the same shape, and therefore vectors, masks, and
2163 * shuffles created from such species will be shape compatible.
2164 *
2165 * @return the preferred species for an element type of {@code double}
2166 */
2167 private static DoubleSpecies preferredSpecies() {
2168 return (DoubleSpecies) Species.ofPreferred(double.class);
2169 }
2170
2171 /**
2172 * Finds a species for an element type of {@code double} and shape.
2173 *
2174 * @param s the shape
2175 * @return a species for an element type of {@code double} and shape
2176 * @throws IllegalArgumentException if no such species exists for the shape
2177 */
2178 static DoubleSpecies species(Vector.Shape s) {
2179 Objects.requireNonNull(s);
2180 switch (s) {
2181 case S_64_BIT: return (DoubleSpecies) SPECIES_64;
2182 case S_128_BIT: return (DoubleSpecies) SPECIES_128;
2183 case S_256_BIT: return (DoubleSpecies) SPECIES_256;
2184 case S_512_BIT: return (DoubleSpecies) SPECIES_512;
2185 case S_Max_BIT: return (DoubleSpecies) SPECIES_MAX;
2186 default: throw new IllegalArgumentException("Bad shape: " + s);
2187 }
2188 }
2189
2190 /** Species representing {@link DoubleVector}s of {@link Vector.Shape#S_64_BIT Shape.S_64_BIT}. */
2191 public static final Species<Double> SPECIES_64 = new DoubleSpecies(Shape.S_64_BIT, Double64Vector.class, Double64Vector.Double64Mask.class,
2192 Double64Vector::new, Double64Vector.Double64Mask::new);
2193
2194 /** Species representing {@link DoubleVector}s of {@link Vector.Shape#S_128_BIT Shape.S_128_BIT}. */
2195 public static final Species<Double> SPECIES_128 = new DoubleSpecies(Shape.S_128_BIT, Double128Vector.class, Double128Vector.Double128Mask.class,
2196 Double128Vector::new, Double128Vector.Double128Mask::new);
2197
2198 /** Species representing {@link DoubleVector}s of {@link Vector.Shape#S_256_BIT Shape.S_256_BIT}. */
2199 public static final Species<Double> SPECIES_256 = new DoubleSpecies(Shape.S_256_BIT, Double256Vector.class, Double256Vector.Double256Mask.class,
2200 Double256Vector::new, Double256Vector.Double256Mask::new);
2201
2202 /** Species representing {@link DoubleVector}s of {@link Vector.Shape#S_512_BIT Shape.S_512_BIT}. */
2203 public static final Species<Double> SPECIES_512 = new DoubleSpecies(Shape.S_512_BIT, Double512Vector.class, Double512Vector.Double512Mask.class,
2204 Double512Vector::new, Double512Vector.Double512Mask::new);
2205
2206 /** Species representing {@link DoubleVector}s of {@link Vector.Shape#S_Max_BIT Shape.S_Max_BIT}. */
2207 public static final Species<Double> SPECIES_MAX = new DoubleSpecies(Shape.S_Max_BIT, DoubleMaxVector.class, DoubleMaxVector.DoubleMaxMask.class,
2208 DoubleMaxVector::new, DoubleMaxVector.DoubleMaxMask::new);
2209
2210 /**
2211 * Preferred species for {@link DoubleVector}s.
2212 * A preferred species is a species of maximal bit size for the platform.
2213 */
2214 public static final Species<Double> SPECIES_PREFERRED = (Species<Double>) preferredSpecies();
2215 }
|
447 public static final DoubleVector single(Species<Double> s, double e) {
448 return zero(s).with(0, e);
449 }
450
451 /**
452 * Returns a vector where each lane element is set to a randomly
453 * generated primitive value.
454 *
455 * The semantics are equivalent to calling
456 * {@link ThreadLocalRandom#nextDouble()}
457 *
458 * @param s species of the desired vector
459 * @return a vector where each lane elements is set to a randomly
460 * generated primitive value
461 */
462 public static DoubleVector random(Species<Double> s) {
463 ThreadLocalRandom r = ThreadLocalRandom.current();
464 return ((DoubleSpecies)s).op(i -> r.nextDouble());
465 }
466
467 // Ops
468
469 @Override
470 public abstract DoubleVector add(Vector<Double> v);
471
472 /**
473 * Adds this vector to the broadcast of an input scalar.
474 * <p>
475 * This is a vector binary operation where the primitive addition operation
476 * ({@code +}) is applied to lane elements.
477 *
478 * @param s the input scalar
479 * @return the result of adding this vector to the broadcast of an input
480 * scalar
481 */
482 public abstract DoubleVector add(double s);
483
484 @Override
485 public abstract DoubleVector add(Vector<Double> v, Mask<Double> m);
486
1861 * @param a the array
1862 * @param i the offset into the array, may be negative if relative
1863 * indexes in the index map compensate to produce a value within the
1864 * array bounds
1865 * @param m the mask
1866 * @param indexMap the index map
1867 * @param j the offset into the index map
1868 * @throws IndexOutOfBoundsException if {@code j < 0}, or
1869 * {@code j > indexMap.length - this.length()},
1870 * or for any vector lane index {@code N} where the mask at lane
1871 * {@code N} is set the result of {@code i + indexMap[j + N]} is
1872 * {@code < 0} or {@code >= a.length}
1873 */
1874 public abstract void intoArray(double[] a, int i, Mask<Double> m, int[] indexMap, int j);
1875 // Species
1876
1877 @Override
1878 public abstract Species<Double> species();
1879
1880 /**
1881 * Class representing {@link DoubleVector}'s of the same {@link Shape Shape}.
1882 */
1883 static final class DoubleSpecies extends AbstractSpecies<Double> {
1884 final Function<double[], DoubleVector> vectorFactory;
1885
1886 private DoubleSpecies(Shape shape,
1887 Class<?> boxType,
1888 Class<?> maskType,
1889 Function<double[], DoubleVector> vectorFactory,
1890 Function<boolean[], Mask<Double>> maskFactory,
1891 Function<IntUnaryOperator, Shuffle<Double>> shuffleFromArrayFactory,
1892 fShuffleFromArray<Double> shuffleFromOpFactory) {
1893 super(shape, double.class, Double.SIZE, boxType, maskType, maskFactory,
1894 shuffleFromArrayFactory, shuffleFromOpFactory);
1895 this.vectorFactory = vectorFactory;
1896 }
1897
1898 interface FOp {
1899 double apply(int i);
1900 }
1901
1902 interface FOpm {
1903 boolean apply(int i);
1904 }
1905
1906 DoubleVector op(FOp f) {
1907 double[] res = new double[length()];
1908 for (int i = 0; i < length(); i++) {
1909 res[i] = f.apply(i);
1910 }
1911 return vectorFactory.apply(res);
1912 }
1913
1914 DoubleVector op(Mask<Double> o, FOp f) {
1915 double[] res = new double[length()];
1916 boolean[] mbits = ((AbstractMask<Double>)o).getBits();
1917 for (int i = 0; i < length(); i++) {
1918 if (mbits[i]) {
1919 res[i] = f.apply(i);
1920 }
1921 }
1922 return vectorFactory.apply(res);
1923 }
1924 }
1925
1926 /**
1927 * Finds the preferred species for an element type of {@code double}.
1928 * <p>
1929 * A preferred species is a species chosen by the platform that has a
1930 * shape of maximal bit size. A preferred species for different element
1931 * types will have the same shape, and therefore vectors, masks, and
1932 * shuffles created from such species will be shape compatible.
1933 *
1934 * @return the preferred species for an element type of {@code double}
1935 */
1936 private static DoubleSpecies preferredSpecies() {
1937 return (DoubleSpecies) Species.ofPreferred(double.class);
1938 }
1939
1940 /**
1941 * Finds a species for an element type of {@code double} and shape.
1942 *
1943 * @param s the shape
1944 * @return a species for an element type of {@code double} and shape
1945 * @throws IllegalArgumentException if no such species exists for the shape
1946 */
1947 static DoubleSpecies species(Shape s) {
1948 Objects.requireNonNull(s);
1949 switch (s) {
1950 case S_64_BIT: return (DoubleSpecies) SPECIES_64;
1951 case S_128_BIT: return (DoubleSpecies) SPECIES_128;
1952 case S_256_BIT: return (DoubleSpecies) SPECIES_256;
1953 case S_512_BIT: return (DoubleSpecies) SPECIES_512;
1954 case S_Max_BIT: return (DoubleSpecies) SPECIES_MAX;
1955 default: throw new IllegalArgumentException("Bad shape: " + s);
1956 }
1957 }
1958
1959 /** Species representing {@link DoubleVector}s of {@link Shape#S_64_BIT Shape.S_64_BIT}. */
1960 public static final Species<Double> SPECIES_64 = new DoubleSpecies(Shape.S_64_BIT, Double64Vector.class, Double64Vector.Double64Mask.class,
1961 Double64Vector::new, Double64Vector.Double64Mask::new,
1962 Double64Vector.Double64Shuffle::new, Double64Vector.Double64Shuffle::new);
1963
1964 /** Species representing {@link DoubleVector}s of {@link Shape#S_128_BIT Shape.S_128_BIT}. */
1965 public static final Species<Double> SPECIES_128 = new DoubleSpecies(Shape.S_128_BIT, Double128Vector.class, Double128Vector.Double128Mask.class,
1966 Double128Vector::new, Double128Vector.Double128Mask::new,
1967 Double128Vector.Double128Shuffle::new, Double128Vector.Double128Shuffle::new);
1968
1969 /** Species representing {@link DoubleVector}s of {@link Shape#S_256_BIT Shape.S_256_BIT}. */
1970 public static final Species<Double> SPECIES_256 = new DoubleSpecies(Shape.S_256_BIT, Double256Vector.class, Double256Vector.Double256Mask.class,
1971 Double256Vector::new, Double256Vector.Double256Mask::new,
1972 Double256Vector.Double256Shuffle::new, Double256Vector.Double256Shuffle::new);
1973
1974 /** Species representing {@link DoubleVector}s of {@link Shape#S_512_BIT Shape.S_512_BIT}. */
1975 public static final Species<Double> SPECIES_512 = new DoubleSpecies(Shape.S_512_BIT, Double512Vector.class, Double512Vector.Double512Mask.class,
1976 Double512Vector::new, Double512Vector.Double512Mask::new,
1977 Double512Vector.Double512Shuffle::new, Double512Vector.Double512Shuffle::new);
1978
1979 /** Species representing {@link DoubleVector}s of {@link Shape#S_Max_BIT Shape.S_Max_BIT}. */
1980 public static final Species<Double> SPECIES_MAX = new DoubleSpecies(Shape.S_Max_BIT, DoubleMaxVector.class, DoubleMaxVector.DoubleMaxMask.class,
1981 DoubleMaxVector::new, DoubleMaxVector.DoubleMaxMask::new,
1982 DoubleMaxVector.DoubleMaxShuffle::new, DoubleMaxVector.DoubleMaxShuffle::new);
1983
1984 /**
1985 * Preferred species for {@link DoubleVector}s.
1986 * A preferred species is a species of maximal bit size for the platform.
1987 */
1988 public static final Species<Double> SPECIES_PREFERRED = (Species<Double>) preferredSpecies();
1989 }
|