< prev index next >

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

Print this page
rev 55237 : javadoc changes

@@ -828,10 +828,11 @@
      * return this.intoByteBuffer(ByteBuffer.wrap(a), i, m);
      * }</pre>
      *
      * @param a the byte array
      * @param i the offset into the array
+     * @param m the mask controlling lane selection
      * @throws IndexOutOfBoundsException if the offset is {@code < 0},
      * or {@code > a.length},
      * for any vector lane index {@code N} where the mask at lane {@code N}
      * is set
      * {@code i >= a.length - (N * this.elementSize() / Byte.SIZE)}

@@ -899,18 +900,23 @@
     public abstract void intoByteBuffer(ByteBuffer b, int i, Mask<E> m);
 
 
     /**
      * A {@code Shape} governs the total size, in bits, of a
-     * {@link Vector}, {@link Mask}, or {@code Shuffle}.  The shape in
+     * {@link Vector}, {@link Mask}, or {@link Shuffle}.  The shape in
      * combination with the element type together govern the number of lanes.
      */
     public enum Shape {
+        /** Shape of length 64 bits */
         S_64_BIT(64),
+        /** Shape of length 128 bits */
         S_128_BIT(128),
+        /** Shape of length 256 bits */
         S_256_BIT(256),
+        /** Shape of length 512 bits */
         S_512_BIT(512),
+        /** Shape of maximum length supported on the platform */
         S_Max_BIT(Unsafe.getUnsafe().getMaxVectorSize(byte.class) * 8);
 
         final int bitSize;
 
         Shape(int bitSize) {

@@ -964,12 +970,11 @@
         }
     }
 
 
     /**
-     * A factory for creating {@link Vector}, {@link Mask} and {@link Shuffle}
-     * values of the same element type and shape.
+     * Class representing vectors of same element type, {@code E} and {@link Vector.Shape Shape}.
      *
      * @param <E> the boxed element type of this species
      */
     public static abstract class Species<E> {
         Species() {}

@@ -1190,10 +1195,11 @@
      *     ar[i] = scalar_binary_op(a.isSet(i), b.isSet(i));
      * }
      * Mask<E> r = a.species().maskFromArray(ar, 0);
      * }</pre>
      *
+     * </ul>
      * @param <E> the boxed element type of this mask
      */
     public static abstract class Mask<E> {
         Mask() {}
 

@@ -1217,11 +1223,11 @@
          * For each mask lane, where {@code N} is the lane index, if the
          * mask lane at index {@code N} is set, then the mask lane at index
          * {@code N} of the resulting mask is set, otherwise that mask lane is
          * not set.
          *
-         * @param s the species of the desired mask
+         * @param species the species of the desired mask
          * @param <F> the boxed element type of the species
          * @return a mask converted by shape and element type
          * @throws IllegalArgumentException if this mask length and the species
          * length differ
          */
< prev index next >