< prev index next >

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

Print this page




 447     public static final LongVector single(Species<Long> s, long 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#nextLong()}
 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 LongVector random(Species<Long> s) {
 463         ThreadLocalRandom r = ThreadLocalRandom.current();
 464         return ((LongSpecies)s).op(i -> r.nextLong());
 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<Long> maskFromValues(Species<Long> species, boolean... bits) {
 482         if (species.boxType() == LongMaxVector.class)
 483             return new LongMaxVector.LongMaxMask(bits);
 484         switch (species.bitSize()) {
 485             case 64: return new Long64Vector.Long64Mask(bits);
 486             case 128: return new Long128Vector.Long128Mask(bits);
 487             case 256: return new Long256Vector.Long256Mask(bits);
 488             case 512: return new Long512Vector.Long512Mask(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<Long> trueMask(Species<Long> species) {
 495         if (species.boxType() == LongMaxVector.class)
 496             return LongMaxVector.LongMaxMask.TRUE_MASK;
 497         switch (species.bitSize()) {
 498             case 64: return Long64Vector.Long64Mask.TRUE_MASK;
 499             case 128: return Long128Vector.Long128Mask.TRUE_MASK;
 500             case 256: return Long256Vector.Long256Mask.TRUE_MASK;
 501             case 512: return Long512Vector.Long512Mask.TRUE_MASK;
 502             default: throw new IllegalArgumentException(Integer.toString(species.bitSize()));
 503         }
 504     }
 505 
 506     static Mask<Long> falseMask(Species<Long> species) {
 507         if (species.boxType() == LongMaxVector.class)
 508             return LongMaxVector.LongMaxMask.FALSE_MASK;
 509         switch (species.bitSize()) {
 510             case 64: return Long64Vector.Long64Mask.FALSE_MASK;
 511             case 128: return Long128Vector.Long128Mask.FALSE_MASK;
 512             case 256: return Long256Vector.Long256Mask.FALSE_MASK;
 513             case 512: return Long512Vector.Long512Mask.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<Long> maskFromArray(Species<Long> species, boolean[] bits, int ix) {
 535         Objects.requireNonNull(bits);
 536         ix = VectorIntrinsics.checkIndex(ix, bits.length, species.length());
 537         return VectorIntrinsics.load((Class<Mask<Long>>) 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<Long>) ((LongSpecies)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<Long> maskAllTrue(Species<Long> species) {
 552         return VectorIntrinsics.broadcastCoerced((Class<Mask<Long>>) 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<Long> maskAllFalse(Species<Long> species) {
 566         return VectorIntrinsics.broadcastCoerced((Class<Mask<Long>>) 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<Long> shuffle(Species<Long> species, IntUnaryOperator f) {
 597         if (species.boxType() == LongMaxVector.class)
 598             return new LongMaxVector.LongMaxShuffle(f);
 599         switch (species.bitSize()) {
 600             case 64: return new Long64Vector.Long64Shuffle(f);
 601             case 128: return new Long128Vector.Long128Shuffle(f);
 602             case 256: return new Long256Vector.Long256Shuffle(f);
 603             case 512: return new Long512Vector.Long512Shuffle(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<Long> shuffleIota(Species<Long> species) {
 623         if (species.boxType() == LongMaxVector.class)
 624             return new LongMaxVector.LongMaxShuffle(AbstractShuffle.IDENTITY);
 625         switch (species.bitSize()) {
 626             case 64: return new Long64Vector.Long64Shuffle(AbstractShuffle.IDENTITY);
 627             case 128: return new Long128Vector.Long128Shuffle(AbstractShuffle.IDENTITY);
 628             case 256: return new Long256Vector.Long256Shuffle(AbstractShuffle.IDENTITY);
 629             case 512: return new Long512Vector.Long512Shuffle(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<Long> shuffleFromValues(Species<Long> species, int... ixs) {
 652         if (species.boxType() == LongMaxVector.class)
 653             return new LongMaxVector.LongMaxShuffle(ixs);
 654         switch (species.bitSize()) {
 655             case 64: return new Long64Vector.Long64Shuffle(ixs);
 656             case 128: return new Long128Vector.Long128Shuffle(ixs);
 657             case 256: return new Long256Vector.Long256Shuffle(ixs);
 658             case 512: return new Long512Vector.Long512Shuffle(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<Long> shuffleFromArray(Species<Long> species, int[] ixs, int i) {
 680         if (species.boxType() == LongMaxVector.class)
 681             return new LongMaxVector.LongMaxShuffle(ixs, i);
 682         switch (species.bitSize()) {
 683             case 64: return new Long64Vector.Long64Shuffle(ixs, i);
 684             case 128: return new Long128Vector.Long128Shuffle(ixs, i);
 685             case 256: return new Long256Vector.Long256Shuffle(ixs, i);
 686             case 512: return new Long512Vector.Long512Shuffle(ixs, i);
 687             default: throw new IllegalArgumentException(Integer.toString(species.bitSize()));
 688         }
 689     }
 690 
 691     // Ops
 692 
 693     @Override
 694     public abstract LongVector add(Vector<Long> 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 LongVector add(long s);
 707 
 708     @Override
 709     public abstract LongVector add(Vector<Long> v, Mask<Long> m);
 710 


1685      * @param a the array
1686      * @param i the offset into the array, may be negative if relative
1687      * indexes in the index map compensate to produce a value within the
1688      * array bounds
1689      * @param m the mask
1690      * @param indexMap the index map
1691      * @param j the offset into the index map
1692      * @throws IndexOutOfBoundsException if {@code j < 0}, or
1693      * {@code j > indexMap.length - this.length()},
1694      * or for any vector lane index {@code N} where the mask at lane
1695      * {@code N} is set the result of {@code i + indexMap[j + N]} is
1696      * {@code < 0} or {@code >= a.length}
1697      */
1698     public abstract void intoArray(long[] a, int i, Mask<Long> m, int[] indexMap, int j);
1699     // Species
1700 
1701     @Override
1702     public abstract Species<Long> species();
1703 
1704     /**
1705      * Class representing {@link LongVector}'s of the same {@link Vector.Shape Shape}.
1706      */
1707     static final class LongSpecies extends Vector.AbstractSpecies<Long> {
1708         final Function<long[], LongVector> vectorFactory;
1709         final Function<boolean[], Vector.Mask<Long>> maskFactory;
1710 
1711         private LongSpecies(Vector.Shape shape,
1712                           Class<?> boxType,
1713                           Class<?> maskType,
1714                           Function<long[], LongVector> vectorFactory,
1715                           Function<boolean[], Vector.Mask<Long>> maskFactory) {
1716             super(shape, long.class, Long.SIZE, boxType, maskType);



1717             this.vectorFactory = vectorFactory;
1718             this.maskFactory = maskFactory;
1719         }
1720 
1721         interface FOp {
1722             long apply(int i);
1723         }
1724 
1725         interface FOpm {
1726             boolean apply(int i);
1727         }
1728 
1729         LongVector op(FOp f) {
1730             long[] res = new long[length()];
1731             for (int i = 0; i < length(); i++) {
1732                 res[i] = f.apply(i);
1733             }
1734             return vectorFactory.apply(res);
1735         }
1736 
1737         LongVector op(Vector.Mask<Long> o, FOp f) {
1738             long[] res = new long[length()];
1739             boolean[] mbits = ((AbstractMask<Long>)o).getBits();
1740             for (int i = 0; i < length(); i++) {
1741                 if (mbits[i]) {
1742                     res[i] = f.apply(i);
1743                 }
1744             }
1745             return vectorFactory.apply(res);
1746         }
1747 
1748         Vector.Mask<Long> opm(IntVector.IntSpecies.FOpm f) {
1749             boolean[] res = new boolean[length()];
1750             for (int i = 0; i < length(); i++) {
1751                 res[i] = (boolean)f.apply(i);
1752             }
1753             return maskFactory.apply(res);
1754         }
1755     }
1756 
1757     /**
1758      * Finds the preferred species for an element type of {@code long}.
1759      * <p>
1760      * A preferred species is a species chosen by the platform that has a
1761      * shape of maximal bit size.  A preferred species for different element
1762      * types will have the same shape, and therefore vectors, masks, and
1763      * shuffles created from such species will be shape compatible.
1764      *
1765      * @return the preferred species for an element type of {@code long}
1766      */
1767     private static LongSpecies preferredSpecies() {
1768         return (LongSpecies) Species.ofPreferred(long.class);
1769     }
1770 
1771     /**
1772      * Finds a species for an element type of {@code long} and shape.
1773      *
1774      * @param s the shape
1775      * @return a species for an element type of {@code long} and shape
1776      * @throws IllegalArgumentException if no such species exists for the shape
1777      */
1778     static LongSpecies species(Vector.Shape s) {
1779         Objects.requireNonNull(s);
1780         switch (s) {
1781             case S_64_BIT: return (LongSpecies) SPECIES_64;
1782             case S_128_BIT: return (LongSpecies) SPECIES_128;
1783             case S_256_BIT: return (LongSpecies) SPECIES_256;
1784             case S_512_BIT: return (LongSpecies) SPECIES_512;
1785             case S_Max_BIT: return (LongSpecies) SPECIES_MAX;
1786             default: throw new IllegalArgumentException("Bad shape: " + s);
1787         }
1788     }
1789 
1790     /** Species representing {@link LongVector}s of {@link Vector.Shape#S_64_BIT Shape.S_64_BIT}. */
1791     public static final Species<Long> SPECIES_64 = new LongSpecies(Shape.S_64_BIT, Long64Vector.class, Long64Vector.Long64Mask.class,
1792                                                                      Long64Vector::new, Long64Vector.Long64Mask::new);

1793 
1794     /** Species representing {@link LongVector}s of {@link Vector.Shape#S_128_BIT Shape.S_128_BIT}. */
1795     public static final Species<Long> SPECIES_128 = new LongSpecies(Shape.S_128_BIT, Long128Vector.class, Long128Vector.Long128Mask.class,
1796                                                                       Long128Vector::new, Long128Vector.Long128Mask::new);

1797 
1798     /** Species representing {@link LongVector}s of {@link Vector.Shape#S_256_BIT Shape.S_256_BIT}. */
1799     public static final Species<Long> SPECIES_256 = new LongSpecies(Shape.S_256_BIT, Long256Vector.class, Long256Vector.Long256Mask.class,
1800                                                                       Long256Vector::new, Long256Vector.Long256Mask::new);

1801 
1802     /** Species representing {@link LongVector}s of {@link Vector.Shape#S_512_BIT Shape.S_512_BIT}. */
1803     public static final Species<Long> SPECIES_512 = new LongSpecies(Shape.S_512_BIT, Long512Vector.class, Long512Vector.Long512Mask.class,
1804                                                                       Long512Vector::new, Long512Vector.Long512Mask::new);

1805 
1806     /** Species representing {@link LongVector}s of {@link Vector.Shape#S_Max_BIT Shape.S_Max_BIT}. */
1807     public static final Species<Long> SPECIES_MAX = new LongSpecies(Shape.S_Max_BIT, LongMaxVector.class, LongMaxVector.LongMaxMask.class,
1808                                                                       LongMaxVector::new, LongMaxVector.LongMaxMask::new);

1809 
1810     /**
1811      * Preferred species for {@link LongVector}s.
1812      * A preferred species is a species of maximal bit size for the platform.
1813      */
1814     public static final Species<Long> SPECIES_PREFERRED = (Species<Long>) preferredSpecies();
1815 }


 447     public static final LongVector single(Species<Long> s, long 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#nextLong()}
 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 LongVector random(Species<Long> s) {
 463         ThreadLocalRandom r = ThreadLocalRandom.current();
 464         return ((LongSpecies)s).op(i -> r.nextLong());
 465     }
 466 
































































































































































































































 467     // Ops
 468 
 469     @Override
 470     public abstract LongVector add(Vector<Long> 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 LongVector add(long s);
 483 
 484     @Override
 485     public abstract LongVector add(Vector<Long> v, Mask<Long> m);
 486 


1461      * @param a the array
1462      * @param i the offset into the array, may be negative if relative
1463      * indexes in the index map compensate to produce a value within the
1464      * array bounds
1465      * @param m the mask
1466      * @param indexMap the index map
1467      * @param j the offset into the index map
1468      * @throws IndexOutOfBoundsException if {@code j < 0}, or
1469      * {@code j > indexMap.length - this.length()},
1470      * or for any vector lane index {@code N} where the mask at lane
1471      * {@code N} is set the result of {@code i + indexMap[j + N]} is
1472      * {@code < 0} or {@code >= a.length}
1473      */
1474     public abstract void intoArray(long[] a, int i, Mask<Long> m, int[] indexMap, int j);
1475     // Species
1476 
1477     @Override
1478     public abstract Species<Long> species();
1479 
1480     /**
1481      * Class representing {@link LongVector}'s of the same {@link Shape Shape}.
1482      */
1483     static final class LongSpecies extends AbstractSpecies<Long> {
1484         final Function<long[], LongVector> vectorFactory;

1485 
1486         private LongSpecies(Shape shape,
1487                           Class<?> boxType,
1488                           Class<?> maskType,
1489                           Function<long[], LongVector> vectorFactory,
1490                           Function<boolean[], Mask<Long>> maskFactory,
1491                           Function<IntUnaryOperator, Shuffle<Long>> shuffleFromArrayFactory,
1492                           fShuffleFromArray<Long> shuffleFromOpFactory) {
1493             super(shape, long.class, Long.SIZE, boxType, maskType, maskFactory,
1494                   shuffleFromArrayFactory, shuffleFromOpFactory);
1495             this.vectorFactory = vectorFactory;

1496         }
1497 
1498         interface FOp {
1499             long apply(int i);
1500         }
1501 
1502         interface FOpm {
1503             boolean apply(int i);
1504         }
1505 
1506         LongVector op(FOp f) {
1507             long[] res = new long[length()];
1508             for (int i = 0; i < length(); i++) {
1509                 res[i] = f.apply(i);
1510             }
1511             return vectorFactory.apply(res);
1512         }
1513 
1514         LongVector op(Mask<Long> o, FOp f) {
1515             long[] res = new long[length()];
1516             boolean[] mbits = ((AbstractMask<Long>)o).getBits();
1517             for (int i = 0; i < length(); i++) {
1518                 if (mbits[i]) {
1519                     res[i] = f.apply(i);
1520                 }
1521             }
1522             return vectorFactory.apply(res);
1523         }








1524     }
1525 
1526     /**
1527      * Finds the preferred species for an element type of {@code long}.
1528      * <p>
1529      * A preferred species is a species chosen by the platform that has a
1530      * shape of maximal bit size.  A preferred species for different element
1531      * types will have the same shape, and therefore vectors, masks, and
1532      * shuffles created from such species will be shape compatible.
1533      *
1534      * @return the preferred species for an element type of {@code long}
1535      */
1536     private static LongSpecies preferredSpecies() {
1537         return (LongSpecies) Species.ofPreferred(long.class);
1538     }
1539 
1540     /**
1541      * Finds a species for an element type of {@code long} and shape.
1542      *
1543      * @param s the shape
1544      * @return a species for an element type of {@code long} and shape
1545      * @throws IllegalArgumentException if no such species exists for the shape
1546      */
1547     static LongSpecies species(Shape s) {
1548         Objects.requireNonNull(s);
1549         switch (s) {
1550             case S_64_BIT: return (LongSpecies) SPECIES_64;
1551             case S_128_BIT: return (LongSpecies) SPECIES_128;
1552             case S_256_BIT: return (LongSpecies) SPECIES_256;
1553             case S_512_BIT: return (LongSpecies) SPECIES_512;
1554             case S_Max_BIT: return (LongSpecies) SPECIES_MAX;
1555             default: throw new IllegalArgumentException("Bad shape: " + s);
1556         }
1557     }
1558 
1559     /** Species representing {@link LongVector}s of {@link Shape#S_64_BIT Shape.S_64_BIT}. */
1560     public static final Species<Long> SPECIES_64 = new LongSpecies(Shape.S_64_BIT, Long64Vector.class, Long64Vector.Long64Mask.class,
1561                                                                      Long64Vector::new, Long64Vector.Long64Mask::new,
1562                                                                      Long64Vector.Long64Shuffle::new, Long64Vector.Long64Shuffle::new);
1563 
1564     /** Species representing {@link LongVector}s of {@link Shape#S_128_BIT Shape.S_128_BIT}. */
1565     public static final Species<Long> SPECIES_128 = new LongSpecies(Shape.S_128_BIT, Long128Vector.class, Long128Vector.Long128Mask.class,
1566                                                                       Long128Vector::new, Long128Vector.Long128Mask::new,
1567                                                                       Long128Vector.Long128Shuffle::new, Long128Vector.Long128Shuffle::new);
1568 
1569     /** Species representing {@link LongVector}s of {@link Shape#S_256_BIT Shape.S_256_BIT}. */
1570     public static final Species<Long> SPECIES_256 = new LongSpecies(Shape.S_256_BIT, Long256Vector.class, Long256Vector.Long256Mask.class,
1571                                                                       Long256Vector::new, Long256Vector.Long256Mask::new,
1572                                                                       Long256Vector.Long256Shuffle::new, Long256Vector.Long256Shuffle::new);
1573 
1574     /** Species representing {@link LongVector}s of {@link Shape#S_512_BIT Shape.S_512_BIT}. */
1575     public static final Species<Long> SPECIES_512 = new LongSpecies(Shape.S_512_BIT, Long512Vector.class, Long512Vector.Long512Mask.class,
1576                                                                       Long512Vector::new, Long512Vector.Long512Mask::new,
1577                                                                       Long512Vector.Long512Shuffle::new, Long512Vector.Long512Shuffle::new);
1578 
1579     /** Species representing {@link LongVector}s of {@link Shape#S_Max_BIT Shape.S_Max_BIT}. */
1580     public static final Species<Long> SPECIES_MAX = new LongSpecies(Shape.S_Max_BIT, LongMaxVector.class, LongMaxVector.LongMaxMask.class,
1581                                                                       LongMaxVector::new, LongMaxVector.LongMaxMask::new,
1582                                                                       LongMaxVector.LongMaxShuffle::new, LongMaxVector.LongMaxShuffle::new);
1583 
1584     /**
1585      * Preferred species for {@link LongVector}s.
1586      * A preferred species is a species of maximal bit size for the platform.
1587      */
1588     public static final Species<Long> SPECIES_PREFERRED = (Species<Long>) preferredSpecies();
1589 }
< prev index next >