# Uses of Class
jdk.incubator.vector.VectorMask

Packages that use VectorMask
Package | Description
--- | ---
jdk.incubator.vector | Incubating Feature. Will be removed in a future release.

- ## Uses of VectorMask in jdk.incubator.vector

  Methods in jdk.incubator.vector that return VectorMask
  Modifier and Type | Method | Description
  --- | --- | ---
  `abstract VectorMask<E>` | VectorMask.`and​(VectorMask<E> m)` | Computes the logical intersection (as `a&b`) between this mask and a second input mask.
  `abstract VectorMask<E>` | VectorMask.`andNot​(VectorMask<E> m)` | Logically subtracts a second input mask from this mask (as `a&~b`).
  `abstract <F> VectorMask<F>` | VectorMask.`cast​(VectorSpecies<F> species)` | Converts this mask to a mask of the given species of element type `F`.
  `abstract <F> VectorMask<F>` | VectorMask.`check​(Class<F> elementType)` | Checks that this mask applies to vectors with the given element type, and returns this mask unchanged.
  `abstract <F> VectorMask<F>` | VectorMask.`check​(VectorSpecies<F> species)` | Checks that this mask has the given species, and returns this mask unchanged.
  `abstract VectorMask<Byte>` | ByteVector.`compare​(VectorOperators.Comparison op, byte e)` | Tests this vector by comparing it with an input scalar, according to the given comparison operation.
  `VectorMask<Byte>` | ByteVector.`compare​(VectorOperators.Comparison op, byte e, VectorMask<Byte> m)` | Tests this vector by comparing it with an input scalar, according to the given comparison operation, in lanes selected by a mask.
  `abstract VectorMask<Byte>` | ByteVector.`compare​(VectorOperators.Comparison op, long e)` | Tests this vector by comparing it with an input scalar, according to the given comparison operation.
  `VectorMask<Byte>` | ByteVector.`compare​(VectorOperators.Comparison op, long e, VectorMask<Byte> m)` | Tests this vector by comparing it with an input scalar, according to the given comparison operation, in lanes selected by a mask.
  `abstract VectorMask<Byte>` | ByteVector.`compare​(VectorOperators.Comparison op, Vector<Byte> v)` | Tests this vector by comparing it with another input vector, according to the given comparison operation.
  `VectorMask<Byte>` | ByteVector.`compare​(VectorOperators.Comparison op, Vector<Byte> v, VectorMask<Byte> m)` | Tests this vector by comparing it with another input vector, according to the given comparison operation, in lanes selected by a mask.
  `abstract VectorMask<Double>` | DoubleVector.`compare​(VectorOperators.Comparison op, double e)` | Tests this vector by comparing it with an input scalar, according to the given comparison operation.
  `VectorMask<Double>` | DoubleVector.`compare​(VectorOperators.Comparison op, double e, VectorMask<Double> m)` | Tests this vector by comparing it with an input scalar, according to the given comparison operation, in lanes selected by a mask.
  `abstract VectorMask<Double>` | DoubleVector.`compare​(VectorOperators.Comparison op, long e)` | Tests this vector by comparing it with an input scalar, according to the given comparison operation.
  `VectorMask<Double>` | DoubleVector.`compare​(VectorOperators.Comparison op, long e, VectorMask<Double> m)` | Tests this vector by comparing it with an input scalar, according to the given comparison operation, in lanes selected by a mask.
  `abstract VectorMask<Double>` | DoubleVector.`compare​(VectorOperators.Comparison op, Vector<Double> v)` | Tests this vector by comparing it with another input vector, according to the given comparison operation.
  `VectorMask<Double>` | DoubleVector.`compare​(VectorOperators.Comparison op, Vector<Double> v, VectorMask<Double> m)` | Tests this vector by comparing it with another input vector, according to the given comparison operation, in lanes selected by a mask.
  `abstract VectorMask<Float>` | FloatVector.`compare​(VectorOperators.Comparison op, float e)` | Tests this vector by comparing it with an input scalar, according to the given comparison operation.
  `VectorMask<Float>` | FloatVector.`compare​(VectorOperators.Comparison op, float e, VectorMask<Float> m)` | Tests this vector by comparing it with an input scalar, according to the given comparison operation, in lanes selected by a mask.
  `abstract VectorMask<Float>` | FloatVector.`compare​(VectorOperators.Comparison op, long e)` | Tests this vector by comparing it with an input scalar, according to the given comparison operation.
  `VectorMask<Float>` | FloatVector.`compare​(VectorOperators.Comparison op, long e, VectorMask<Float> m)` | Tests this vector by comparing it with an input scalar, according to the given comparison operation, in lanes selected by a mask.
  `abstract VectorMask<Float>` | FloatVector.`compare​(VectorOperators.Comparison op, Vector<Float> v)` | Tests this vector by comparing it with another input vector, according to the given comparison operation.
  `VectorMask<Float>` | FloatVector.`compare​(VectorOperators.Comparison op, Vector<Float> v, VectorMask<Float> m)` | Tests this vector by comparing it with another input vector, according to the given comparison operation, in lanes selected by a mask.
  `abstract VectorMask<Integer>` | IntVector.`compare​(VectorOperators.Comparison op, int e)` | Tests this vector by comparing it with an input scalar, according to the given comparison operation.
  `VectorMask<Integer>` | IntVector.`compare​(VectorOperators.Comparison op, int e, VectorMask<Integer> m)` | Tests this vector by comparing it with an input scalar, according to the given comparison operation, in lanes selected by a mask.
  `abstract VectorMask<Integer>` | IntVector.`compare​(VectorOperators.Comparison op, long e)` | Tests this vector by comparing it with an input scalar, according to the given comparison operation.
  `VectorMask<Integer>` | IntVector.`compare​(VectorOperators.Comparison op, long e, VectorMask<Integer> m)` | Tests this vector by comparing it with an input scalar, according to the given comparison operation, in lanes selected by a mask.
  `abstract VectorMask<Integer>` | IntVector.`compare​(VectorOperators.Comparison op, Vector<Integer> v)` | Tests this vector by comparing it with another input vector, according to the given comparison operation.
  `VectorMask<Integer>` | IntVector.`compare​(VectorOperators.Comparison op, Vector<Integer> v, VectorMask<Integer> m)` | Tests this vector by comparing it with another input vector, according to the given comparison operation, in lanes selected by a mask.
  `abstract VectorMask<Long>` | LongVector.`compare​(VectorOperators.Comparison op, long e)` | Tests this vector by comparing it with an input scalar, according to the given comparison operation.
  `VectorMask<Long>` | LongVector.`compare​(VectorOperators.Comparison op, long e, VectorMask<Long> m)` | Tests this vector by comparing it with an input scalar, according to the given comparison operation, in lanes selected by a mask.
  `abstract VectorMask<Long>` | LongVector.`compare​(VectorOperators.Comparison op, Vector<Long> v)` | Tests this vector by comparing it with another input vector, according to the given comparison operation.
  `VectorMask<Long>` | LongVector.`compare​(VectorOperators.Comparison op, Vector<Long> v, VectorMask<Long> m)` | Tests this vector by comparing it with another input vector, according to the given comparison operation, in lanes selected by a mask.
  `abstract VectorMask<Short>` | ShortVector.`compare​(VectorOperators.Comparison op, long e)` | Tests this vector by comparing it with an input scalar, according to the given comparison operation.
  `VectorMask<Short>` | ShortVector.`compare​(VectorOperators.Comparison op, long e, VectorMask<Short> m)` | Tests this vector by comparing it with an input scalar, according to the given comparison operation, in lanes selected by a mask.
  `abstract VectorMask<Short>` | ShortVector.`compare​(VectorOperators.Comparison op, short e)` | Tests this vector by comparing it with an input scalar, according to the given comparison operation.
  `VectorMask<Short>` | ShortVector.`compare​(VectorOperators.Comparison op, short e, VectorMask<Short> m)` | Tests this vector by comparing it with an input scalar, according to the given comparison operation, in lanes selected by a mask.
  `abstract VectorMask<Short>` | ShortVector.`compare​(VectorOperators.Comparison op, Vector<Short> v)` | Tests this vector by comparing it with another input vector, according to the given comparison operation.
  `VectorMask<Short>` | ShortVector.`compare​(VectorOperators.Comparison op, Vector<Short> v, VectorMask<Short> m)` | Tests this vector by comparing it with another input vector, according to the given comparison operation, in lanes selected by a mask.
  `abstract VectorMask<E>` | Vector.`compare​(VectorOperators.Comparison op, long e)` | Tests this vector by comparing it with an input scalar, according to the given comparison operation.
  `abstract VectorMask<E>` | Vector.`compare​(VectorOperators.Comparison op, long e, VectorMask<E> m)` | Tests this vector by comparing it with an input scalar, according to the given comparison operation, in lanes selected by a mask.
  `abstract VectorMask<E>` | Vector.`compare​(VectorOperators.Comparison op, Vector<E> v)` | Tests this vector by comparing it with another input vector, according to the given comparison operation.
  `abstract VectorMask<E>` | Vector.`compare​(VectorOperators.Comparison op, Vector<E> v, VectorMask<E> m)` | Tests this vector by comparing it with another input vector, according to the given comparison operation, in lanes selected by a mask.
  `VectorMask<Byte>` | ByteVector.`eq​(byte e)` | Tests if this vector is equal to an input scalar.
  `VectorMask<Byte>` | ByteVector.`eq​(Vector<Byte> v)` | Tests if this vector is equal to another input vector.
  `VectorMask<Double>` | DoubleVector.`eq​(double e)` | Tests if this vector is equal to an input scalar.
  `VectorMask<Double>` | DoubleVector.`eq​(Vector<Double> v)` | Tests if this vector is equal to another input vector.
  `VectorMask<Float>` | FloatVector.`eq​(float e)` | Tests if this vector is equal to an input scalar.
  `VectorMask<Float>` | FloatVector.`eq​(Vector<Float> v)` | Tests if this vector is equal to another input vector.
  `VectorMask<Integer>` | IntVector.`eq​(int e)` | Tests if this vector is equal to an input scalar.
  `VectorMask<Integer>` | IntVector.`eq​(Vector<Integer> v)` | Tests if this vector is equal to another input vector.
  `VectorMask<Long>` | LongVector.`eq​(long e)` | Tests if this vector is equal to an input scalar.
  `VectorMask<Long>` | LongVector.`eq​(Vector<Long> v)` | Tests if this vector is equal to another input vector.
  `VectorMask<Short>` | ShortVector.`eq​(short e)` | Tests if this vector is equal to an input scalar.
  `VectorMask<Short>` | ShortVector.`eq​(Vector<Short> v)` | Tests if this vector is equal to another input vector.
  `abstract VectorMask<E>` | Vector.`eq​(Vector<E> v)` | Tests if this vector is equal to another input vector.
  `abstract VectorMask<E>` | VectorMask.`equal​(VectorMask<E> m)` | Determines logical equivalence of this mask to a second input mask (as boolean `a==b` or `a^~b`).
  `static <E> VectorMask<E>` | VectorMask.`fromArray​(VectorSpecies<E> species, boolean[] bits, int offset)` | Loads a mask from a `boolean` array starting at an offset.
  `static <E> VectorMask<E>` | VectorMask.`fromLong​(VectorSpecies<E> species, long bits)` | Returns a mask where each lane is set or unset according to the bits in the given bitmask, starting with the least significant bit, and continuing up to the sign bit.
  `static <E> VectorMask<E>` | VectorMask.`fromValues​(VectorSpecies<E> species, boolean... bits)` | Returns a mask where each lane is set or unset according to given `boolean` values.
  `abstract VectorMask<E>` | VectorMask.`indexInRange​(int offset, int limit)` | Removes lanes numbered `N` from this mask where the adjusted index `N+offset`, is not in the range `[0..limit-1]`.
  `VectorMask<E>` | VectorSpecies.`indexInRange​(int offset, int limit)` | Returns a mask of this species where only the lanes at index N such that the adjusted index `N+offset` is in the range `[0..limit-1]` are set.
  `abstract VectorMask<E>` | VectorShuffle.`laneIsValid()` | Find all lanes containing valid indexes (non-negative values) and return a mask where exactly those lanes are set.
  `VectorMask<E>` | VectorSpecies.`loadMask​(boolean[] bits, int offset)` | Returns a mask of this species where lane elements are initialized from the given array at the given offset.
  `VectorMask<Byte>` | ByteVector.`lt​(byte e)` | Tests if this vector is less than an input scalar.
  `VectorMask<Byte>` | ByteVector.`lt​(Vector<Byte> v)` | Tests if this vector is less than another input vector.
  `VectorMask<Double>` | DoubleVector.`lt​(double e)` | Tests if this vector is less than an input scalar.
  `VectorMask<Double>` | DoubleVector.`lt​(Vector<Double> v)` | Tests if this vector is less than another input vector.
  `VectorMask<Float>` | FloatVector.`lt​(float e)` | Tests if this vector is less than an input scalar.
  `VectorMask<Float>` | FloatVector.`lt​(Vector<Float> v)` | Tests if this vector is less than another input vector.
  `VectorMask<Integer>` | IntVector.`lt​(int e)` | Tests if this vector is less than an input scalar.
  `VectorMask<Integer>` | IntVector.`lt​(Vector<Integer> v)` | Tests if this vector is less than another input vector.
  `VectorMask<Long>` | LongVector.`lt​(long e)` | Tests if this vector is less than an input scalar.
  `VectorMask<Long>` | LongVector.`lt​(Vector<Long> v)` | Tests if this vector is less than another input vector.
  `VectorMask<Short>` | ShortVector.`lt​(short e)` | Tests if this vector is less than an input scalar.
  `VectorMask<Short>` | ShortVector.`lt​(Vector<Short> v)` | Tests if this vector is less than another input vector.
  `abstract VectorMask<E>` | Vector.`lt​(Vector<E> v)` | Tests if this vector is less than another input vector.
  `abstract VectorMask<E>` | Vector.`maskAll​(boolean bit)` | Returns a mask of same species as this vector, where each lane is set or unset according to given single boolean, which is broadcast to all lanes.
  `VectorMask<E>` | VectorSpecies.`maskAll​(boolean bit)` | Returns a mask of this species, where each lane is set or unset according to given single boolean, which is broadcast to all lanes.
  `abstract VectorMask<E>` | VectorMask.`not()` | Logically negates this mask.
  `abstract VectorMask<E>` | VectorMask.`or​(VectorMask<E> m)` | Computes the logical union (as `a|b`) of this mask and a second input mask.
  `abstract VectorMask<Byte>` | ByteVector.`test​(VectorOperators.Test op)` | Tests the lanes of this vector according to the given operation.
  `VectorMask<Byte>` | ByteVector.`test​(VectorOperators.Test op, VectorMask<Byte> m)` | Test selected lanes of this vector, according to the given operation.
  `abstract VectorMask<Double>` | DoubleVector.`test​(VectorOperators.Test op)` | Tests the lanes of this vector according to the given operation.
  `VectorMask<Double>` | DoubleVector.`test​(VectorOperators.Test op, VectorMask<Double> m)` | Test selected lanes of this vector, according to the given operation.
  `abstract VectorMask<Float>` | FloatVector.`test​(VectorOperators.Test op)` | Tests the lanes of this vector according to the given operation.
  `VectorMask<Float>` | FloatVector.`test​(VectorOperators.Test op, VectorMask<Float> m)` | Test selected lanes of this vector, according to the given operation.
  `abstract VectorMask<Integer>` | IntVector.`test​(VectorOperators.Test op)` | Tests the lanes of this vector according to the given operation.
  `VectorMask<Integer>` | IntVector.`test​(VectorOperators.Test op, VectorMask<Integer> m)` | Test selected lanes of this vector, according to the given operation.
  `abstract VectorMask<Long>` | LongVector.`test​(VectorOperators.Test op)` | Tests the lanes of this vector according to the given operation.
  `VectorMask<Long>` | LongVector.`test​(VectorOperators.Test op, VectorMask<Long> m)` | Test selected lanes of this vector, according to the given operation.
  `abstract VectorMask<Short>` | ShortVector.`test​(VectorOperators.Test op)` | Tests the lanes of this vector according to the given operation.
  `VectorMask<Short>` | ShortVector.`test​(VectorOperators.Test op, VectorMask<Short> m)` | Test selected lanes of this vector, according to the given operation.
  `abstract VectorMask<E>` | Vector.`test​(VectorOperators.Test op)` | Tests the lanes of this vector according to the given operation.
  `abstract VectorMask<E>` | Vector.`test​(VectorOperators.Test op, VectorMask<E> m)` | Test selected lanes of this vector, according to the given operation.

  Methods in jdk.incubator.vector that return types with arguments of type VectorMask
  Modifier and Type | Method | Description
  --- | --- | ---
  `Class<? extends VectorMask<E>>` | VectorSpecies.`maskType()` | Returns the vector mask type for this species.

  Methods in jdk.incubator.vector with parameters of type VectorMask
  Modifier and Type | Method | Description
  --- | --- | ---
  `ByteVector` | ByteVector.`add​(byte e, VectorMask<Byte> m)` | Adds this vector to the broadcast of an input scalar, selecting lane elements controlled by a mask.
  `ByteVector` | ByteVector.`add​(Vector<Byte> v, VectorMask<Byte> m)` | Adds this vector to a second input vector, selecting lanes under the control of a mask.
  `DoubleVector` | DoubleVector.`add​(double e, VectorMask<Double> m)` | Adds this vector to the broadcast of an input scalar, selecting lane elements controlled by a mask.
  `DoubleVector` | DoubleVector.`add​(Vector<Double> v, VectorMask<Double> m)` | Adds this vector to a second input vector, selecting lanes under the control of a mask.
  `FloatVector` | FloatVector.`add​(float e, VectorMask<Float> m)` | Adds this vector to the broadcast of an input scalar, selecting lane elements controlled by a mask.
  `FloatVector` | FloatVector.`add​(Vector<Float> v, VectorMask<Float> m)` | Adds this vector to a second input vector, selecting lanes under the control of a mask.
  `IntVector` | IntVector.`add​(int e, VectorMask<Integer> m)` | Adds this vector to the broadcast of an input scalar, selecting lane elements controlled by a mask.
  `IntVector` | IntVector.`add​(Vector<Integer> v, VectorMask<Integer> m)` | Adds this vector to a second input vector, selecting lanes under the control of a mask.
  `LongVector` | LongVector.`add​(long e, VectorMask<Long> m)` | Adds this vector to the broadcast of an input scalar, selecting lane elements controlled by a mask.
  `LongVector` | LongVector.`add​(Vector<Long> v, VectorMask<Long> m)` | Adds this vector to a second input vector, selecting lanes under the control of a mask.
  `ShortVector` | ShortVector.`add​(short e, VectorMask<Short> m)` | Adds this vector to the broadcast of an input scalar, selecting lane elements controlled by a mask.
  `ShortVector` | ShortVector.`add​(Vector<Short> v, VectorMask<Short> m)` | Adds this vector to a second input vector, selecting lanes under the control of a mask.
  `abstract Vector<E>` | Vector.`add​(Vector<E> v, VectorMask<E> m)` | Adds this vector to a second input vector, selecting lanes under the control of a mask.
  `abstract VectorMask<E>` | VectorMask.`and​(VectorMask<E> m)` | Computes the logical intersection (as `a&b`) between this mask and a second input mask.
  `abstract VectorMask<E>` | VectorMask.`andNot​(VectorMask<E> m)` | Logically subtracts a second input mask from this mask (as `a&~b`).
  `ByteVector` | ByteVector.`blend​(byte e, VectorMask<Byte> m)` | Replaces selected lanes of this vector with a scalar value under the control of a mask.
  `ByteVector` | ByteVector.`blend​(long e, VectorMask<Byte> m)` | Replaces selected lanes of this vector with a scalar value under the control of a mask.
  `abstract ByteVector` | ByteVector.`blend​(Vector<Byte> v, VectorMask<Byte> m)` | Replaces selected lanes of this vector with corresponding lanes from a second input vector under the control of a mask.
  `DoubleVector` | DoubleVector.`blend​(double e, VectorMask<Double> m)` | Replaces selected lanes of this vector with a scalar value under the control of a mask.
  `DoubleVector` | DoubleVector.`blend​(long e, VectorMask<Double> m)` | Replaces selected lanes of this vector with a scalar value under the control of a mask.
  `abstract DoubleVector` | DoubleVector.`blend​(Vector<Double> v, VectorMask<Double> m)` | Replaces selected lanes of this vector with corresponding lanes from a second input vector under the control of a mask.
  `FloatVector` | FloatVector.`blend​(float e, VectorMask<Float> m)` | Replaces selected lanes of this vector with a scalar value under the control of a mask.
  `FloatVector` | FloatVector.`blend​(long e, VectorMask<Float> m)` | Replaces selected lanes of this vector with a scalar value under the control of a mask.
  `abstract FloatVector` | FloatVector.`blend​(Vector<Float> v, VectorMask<Float> m)` | Replaces selected lanes of this vector with corresponding lanes from a second input vector under the control of a mask.
  `IntVector` | IntVector.`blend​(int e, VectorMask<Integer> m)` | Replaces selected lanes of this vector with a scalar value under the control of a mask.
  `IntVector` | IntVector.`blend​(long e, VectorMask<Integer> m)` | Replaces selected lanes of this vector with a scalar value under the control of a mask.
  `abstract IntVector` | IntVector.`blend​(Vector<Integer> v, VectorMask<Integer> m)` | Replaces selected lanes of this vector with corresponding lanes from a second input vector under the control of a mask.
  `LongVector` | LongVector.`blend​(long e, VectorMask<Long> m)` | Replaces selected lanes of this vector with a scalar value under the control of a mask.
  `abstract LongVector` | LongVector.`blend​(Vector<Long> v, VectorMask<Long> m)` | Replaces selected lanes of this vector with corresponding lanes from a second input vector under the control of a mask.
  `ShortVector` | ShortVector.`blend​(long e, VectorMask<Short> m)` | Replaces selected lanes of this vector with a scalar value under the control of a mask.
  `ShortVector` | ShortVector.`blend​(short e, VectorMask<Short> m)` | Replaces selected lanes of this vector with a scalar value under the control of a mask.
  `abstract ShortVector` | ShortVector.`blend​(Vector<Short> v, VectorMask<Short> m)` | Replaces selected lanes of this vector with corresponding lanes from a second input vector under the control of a mask.
  `abstract Vector<E>` | Vector.`blend​(long e, VectorMask<E> m)` | Replaces selected lanes of this vector with a scalar value under the control of a mask.
  `abstract Vector<E>` | Vector.`blend​(Vector<E> v, VectorMask<E> m)` | Replaces selected lanes of this vector with corresponding lanes from a second input vector under the control of a mask.
  `VectorMask<Byte>` | ByteVector.`compare​(VectorOperators.Comparison op, byte e, VectorMask<Byte> m)` | Tests this vector by comparing it with an input scalar, according to the given comparison operation, in lanes selected by a mask.
  `VectorMask<Byte>` | ByteVector.`compare​(VectorOperators.Comparison op, long e, VectorMask<Byte> m)` | Tests this vector by comparing it with an input scalar, according to the given comparison operation, in lanes selected by a mask.
  `VectorMask<Byte>` | ByteVector.`compare​(VectorOperators.Comparison op, Vector<Byte> v, VectorMask<Byte> m)` | Tests this vector by comparing it with another input vector, according to the given comparison operation, in lanes selected by a mask.
  `VectorMask<Double>` | DoubleVector.`compare​(VectorOperators.Comparison op, double e, VectorMask<Double> m)` | Tests this vector by comparing it with an input scalar, according to the given comparison operation, in lanes selected by a mask.
  `VectorMask<Double>` | DoubleVector.`compare​(VectorOperators.Comparison op, long e, VectorMask<Double> m)` | Tests this vector by comparing it with an input scalar, according to the given comparison operation, in lanes selected by a mask.
  `VectorMask<Double>` | DoubleVector.`compare​(VectorOperators.Comparison op, Vector<Double> v, VectorMask<Double> m)` | Tests this vector by comparing it with another input vector, according to the given comparison operation, in lanes selected by a mask.
  `VectorMask<Float>` | FloatVector.`compare​(VectorOperators.Comparison op, float e, VectorMask<Float> m)` | Tests this vector by comparing it with an input scalar, according to the given comparison operation, in lanes selected by a mask.
  `VectorMask<Float>` | FloatVector.`compare​(VectorOperators.Comparison op, long e, VectorMask<Float> m)` | Tests this vector by comparing it with an input scalar, according to the given comparison operation, in lanes selected by a mask.
  `VectorMask<Float>` | FloatVector.`compare​(VectorOperators.Comparison op, Vector<Float> v, VectorMask<Float> m)` | Tests this vector by comparing it with another input vector, according to the given comparison operation, in lanes selected by a mask.
  `VectorMask<Integer>` | IntVector.`compare​(VectorOperators.Comparison op, int e, VectorMask<Integer> m)` | Tests this vector by comparing it with an input scalar, according to the given comparison operation, in lanes selected by a mask.
  `VectorMask<Integer>` | IntVector.`compare​(VectorOperators.Comparison op, long e, VectorMask<Integer> m)` | Tests this vector by comparing it with an input scalar, according to the given comparison operation, in lanes selected by a mask.
  `VectorMask<Integer>` | IntVector.`compare​(VectorOperators.Comparison op, Vector<Integer> v, VectorMask<Integer> m)` | Tests this vector by comparing it with another input vector, according to the given comparison operation, in lanes selected by a mask.
  `VectorMask<Long>` | LongVector.`compare​(VectorOperators.Comparison op, long e, VectorMask<Long> m)` | Tests this vector by comparing it with an input scalar, according to the given comparison operation, in lanes selected by a mask.
  `VectorMask<Long>` | LongVector.`compare​(VectorOperators.Comparison op, Vector<Long> v, VectorMask<Long> m)` | Tests this vector by comparing it with another input vector, according to the given comparison operation, in lanes selected by a mask.
  `VectorMask<Short>` | ShortVector.`compare​(VectorOperators.Comparison op, long e, VectorMask<Short> m)` | Tests this vector by comparing it with an input scalar, according to the given comparison operation, in lanes selected by a mask.
  `VectorMask<Short>` | ShortVector.`compare​(VectorOperators.Comparison op, short e, VectorMask<Short> m)` | Tests this vector by comparing it with an input scalar, according to the given comparison operation, in lanes selected by a mask.
  `VectorMask<Short>` | ShortVector.`compare​(VectorOperators.Comparison op, Vector<Short> v, VectorMask<Short> m)` | Tests this vector by comparing it with another input vector, according to the given comparison operation, in lanes selected by a mask.
  `abstract VectorMask<E>` | Vector.`compare​(VectorOperators.Comparison op, long e, VectorMask<E> m)` | Tests this vector by comparing it with an input scalar, according to the given comparison operation, in lanes selected by a mask.
  `abstract VectorMask<E>` | Vector.`compare​(VectorOperators.Comparison op, Vector<E> v, VectorMask<E> m)` | Tests this vector by comparing it with another input vector, according to the given comparison operation, in lanes selected by a mask.
  `ByteVector` | ByteVector.`div​(byte e, VectorMask<Byte> m)` | Divides this vector by the broadcast of an input scalar, selecting lane elements controlled by a mask.
  `ByteVector` | ByteVector.`div​(Vector<Byte> v, VectorMask<Byte> m)` | Divides this vector by a second input vector under the control of a mask.
  `DoubleVector` | DoubleVector.`div​(double e, VectorMask<Double> m)` | Divides this vector by the broadcast of an input scalar, selecting lane elements controlled by a mask.
  `DoubleVector` | DoubleVector.`div​(Vector<Double> v, VectorMask<Double> m)` | Divides this vector by a second input vector under the control of a mask.
  `FloatVector` | FloatVector.`div​(float e, VectorMask<Float> m)` | Divides this vector by the broadcast of an input scalar, selecting lane elements controlled by a mask.
  `FloatVector` | FloatVector.`div​(Vector<Float> v, VectorMask<Float> m)` | Divides this vector by a second input vector under the control of a mask.
  `IntVector` | IntVector.`div​(int e, VectorMask<Integer> m)` | Divides this vector by the broadcast of an input scalar, selecting lane elements controlled by a mask.
  `IntVector` | IntVector.`div​(Vector<Integer> v, VectorMask<Integer> m)` | Divides this vector by a second input vector under the control of a mask.
  `LongVector` | LongVector.`div​(long e, VectorMask<Long> m)` | Divides this vector by the broadcast of an input scalar, selecting lane elements controlled by a mask.
  `LongVector` | LongVector.`div​(Vector<Long> v, VectorMask<Long> m)` | Divides this vector by a second input vector under the control of a mask.
  `ShortVector` | ShortVector.`div​(short e, VectorMask<Short> m)` | Divides this vector by the broadcast of an input scalar, selecting lane elements controlled by a mask.
  `ShortVector` | ShortVector.`div​(Vector<Short> v, VectorMask<Short> m)` | Divides this vector by a second input vector under the control of a mask.
  `abstract Vector<E>` | Vector.`div​(Vector<E> v, VectorMask<E> m)` | Divides this vector by a second input vector under the control of a mask.
  `abstract VectorMask<E>` | VectorMask.`equal​(VectorMask<E> m)` | Determines logical equivalence of this mask to a second input mask (as boolean `a==b` or `a^~b`).
  `static ByteVector` | ByteVector.`fromArray​(VectorSpecies<Byte> species, byte[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Byte> m)` | Gathers a new vector composed of elements from an array of type `byte[]`, under the control of a mask, and using indexes obtained by adding a fixed `offset` to a series of secondary offsets from an index map.
  `static ByteVector` | ByteVector.`fromArray​(VectorSpecies<Byte> species, byte[] a, int offset, VectorMask<Byte> m)` | Loads a vector from an array of type `byte[]` starting at an offset and using a mask.
  `static DoubleVector` | DoubleVector.`fromArray​(VectorSpecies<Double> species, double[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Double> m)` | Gathers a new vector composed of elements from an array of type `double[]`, under the control of a mask, and using indexes obtained by adding a fixed `offset` to a series of secondary offsets from an index map.
  `static DoubleVector` | DoubleVector.`fromArray​(VectorSpecies<Double> species, double[] a, int offset, VectorMask<Double> m)` | Loads a vector from an array of type `double[]` starting at an offset and using a mask.
  `static FloatVector` | FloatVector.`fromArray​(VectorSpecies<Float> species, float[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Float> m)` | Gathers a new vector composed of elements from an array of type `float[]`, under the control of a mask, and using indexes obtained by adding a fixed `offset` to a series of secondary offsets from an index map.
  `static FloatVector` | FloatVector.`fromArray​(VectorSpecies<Float> species, float[] a, int offset, VectorMask<Float> m)` | Loads a vector from an array of type `float[]` starting at an offset and using a mask.
  `static IntVector` | IntVector.`fromArray​(VectorSpecies<Integer> species, int[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Integer> m)` | Gathers a new vector composed of elements from an array of type `int[]`, under the control of a mask, and using indexes obtained by adding a fixed `offset` to a series of secondary offsets from an index map.
  `static IntVector` | IntVector.`fromArray​(VectorSpecies<Integer> species, int[] a, int offset, VectorMask<Integer> m)` | Loads a vector from an array of type `int[]` starting at an offset and using a mask.
  `static LongVector` | LongVector.`fromArray​(VectorSpecies<Long> species, long[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Long> m)` | Gathers a new vector composed of elements from an array of type `long[]`, under the control of a mask, and using indexes obtained by adding a fixed `offset` to a series of secondary offsets from an index map.
  `static LongVector` | LongVector.`fromArray​(VectorSpecies<Long> species, long[] a, int offset, VectorMask<Long> m)` | Loads a vector from an array of type `long[]` starting at an offset and using a mask.
  `static ShortVector` | ShortVector.`fromArray​(VectorSpecies<Short> species, short[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Short> m)` | Gathers a new vector composed of elements from an array of type `short[]`, under the control of a mask, and using indexes obtained by adding a fixed `offset` to a series of secondary offsets from an index map.
  `static ShortVector` | ShortVector.`fromArray​(VectorSpecies<Short> species, short[] a, int offset, VectorMask<Short> m)` | Loads a vector from an array of type `short[]` starting at an offset and using a mask.
  `static ByteVector` | ByteVector.`fromByteArray​(VectorSpecies<Byte> species, byte[] a, int offset, ByteOrder bo, VectorMask<Byte> m)` | Loads a vector from a byte array starting at an offset and using a mask.
  `static ByteVector` | ByteVector.`fromByteArray​(VectorSpecies<Byte> species, byte[] a, int offset, VectorMask<Byte> m)` | Loads a vector from a byte array starting at an offset and using a mask.
  `static DoubleVector` | DoubleVector.`fromByteArray​(VectorSpecies<Double> species, byte[] a, int offset, ByteOrder bo, VectorMask<Double> m)` | Loads a vector from a byte array starting at an offset and using a mask.
  `static DoubleVector` | DoubleVector.`fromByteArray​(VectorSpecies<Double> species, byte[] a, int offset, VectorMask<Double> m)` | Loads a vector from a byte array starting at an offset and using a mask.
  `static FloatVector` | FloatVector.`fromByteArray​(VectorSpecies<Float> species, byte[] a, int offset, ByteOrder bo, VectorMask<Float> m)` | Loads a vector from a byte array starting at an offset and using a mask.
  `static FloatVector` | FloatVector.`fromByteArray​(VectorSpecies<Float> species, byte[] a, int offset, VectorMask<Float> m)` | Loads a vector from a byte array starting at an offset and using a mask.
  `static IntVector` | IntVector.`fromByteArray​(VectorSpecies<Integer> species, byte[] a, int offset, ByteOrder bo, VectorMask<Integer> m)` | Loads a vector from a byte array starting at an offset and using a mask.
  `static IntVector` | IntVector.`fromByteArray​(VectorSpecies<Integer> species, byte[] a, int offset, VectorMask<Integer> m)` | Loads a vector from a byte array starting at an offset and using a mask.
  `static LongVector` | LongVector.`fromByteArray​(VectorSpecies<Long> species, byte[] a, int offset, ByteOrder bo, VectorMask<Long> m)` | Loads a vector from a byte array starting at an offset and using a mask.
  `static LongVector` | LongVector.`fromByteArray​(VectorSpecies<Long> species, byte[] a, int offset, VectorMask<Long> m)` | Loads a vector from a byte array starting at an offset and using a mask.
  `static ShortVector` | ShortVector.`fromByteArray​(VectorSpecies<Short> species, byte[] a, int offset, ByteOrder bo, VectorMask<Short> m)` | Loads a vector from a byte array starting at an offset and using a mask.
  `static ShortVector` | ShortVector.`fromByteArray​(VectorSpecies<Short> species, byte[] a, int offset, VectorMask<Short> m)` | Loads a vector from a byte array starting at an offset and using a mask.
  `static ByteVector` | ByteVector.`fromByteBuffer​(VectorSpecies<Byte> species, ByteBuffer bb, int offset, ByteOrder bo, VectorMask<Byte> m)` | Loads a vector from a byte buffer starting at an offset into the byte buffer and using a mask.
  `static DoubleVector` | DoubleVector.`fromByteBuffer​(VectorSpecies<Double> species, ByteBuffer bb, int offset, ByteOrder bo, VectorMask<Double> m)` | Loads a vector from a byte buffer starting at an offset into the byte buffer and using a mask.
  `static FloatVector` | FloatVector.`fromByteBuffer​(VectorSpecies<Float> species, ByteBuffer bb, int offset, ByteOrder bo, VectorMask<Float> m)` | Loads a vector from a byte buffer starting at an offset into the byte buffer and using a mask.
  `static IntVector` | IntVector.`fromByteBuffer​(VectorSpecies<Integer> species, ByteBuffer bb, int offset, ByteOrder bo, VectorMask<Integer> m)` | Loads a vector from a byte buffer starting at an offset into the byte buffer and using a mask.
  `static LongVector` | LongVector.`fromByteBuffer​(VectorSpecies<Long> species, ByteBuffer bb, int offset, ByteOrder bo, VectorMask<Long> m)` | Loads a vector from a byte buffer starting at an offset into the byte buffer and using a mask.
  `static ShortVector` | ShortVector.`fromByteBuffer​(VectorSpecies<Short> species, ByteBuffer bb, int offset, ByteOrder bo, VectorMask<Short> m)` | Loads a vector from a byte buffer starting at an offset into the byte buffer and using a mask.
  `void` | ByteVector.`intoArray​(byte[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Byte> m)` | Scatters this vector into an array of type `byte[]`, under the control of a mask, and using indexes obtained by adding a fixed `offset` to a series of secondary offsets from an index map.
  `void` | ByteVector.`intoArray​(byte[] a, int offset, VectorMask<Byte> m)` | Stores this vector into an array of `byte` starting at offset and using a mask.
  `void` | DoubleVector.`intoArray​(double[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Double> m)` | Scatters this vector into an array of type `double[]`, under the control of a mask, and using indexes obtained by adding a fixed `offset` to a series of secondary offsets from an index map.
  `void` | DoubleVector.`intoArray​(double[] a, int offset, VectorMask<Double> m)` | Stores this vector into an array of `double` starting at offset and using a mask.
  `void` | FloatVector.`intoArray​(float[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Float> m)` | Scatters this vector into an array of type `float[]`, under the control of a mask, and using indexes obtained by adding a fixed `offset` to a series of secondary offsets from an index map.
  `void` | FloatVector.`intoArray​(float[] a, int offset, VectorMask<Float> m)` | Stores this vector into an array of `float` starting at offset and using a mask.
  `void` | IntVector.`intoArray​(int[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Integer> m)` | Scatters this vector into an array of type `int[]`, under the control of a mask, and using indexes obtained by adding a fixed `offset` to a series of secondary offsets from an index map.
  `void` | IntVector.`intoArray​(int[] a, int offset, VectorMask<Integer> m)` | Stores this vector into an array of `int` starting at offset and using a mask.
  `void` | LongVector.`intoArray​(long[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Long> m)` | Scatters this vector into an array of type `long[]`, under the control of a mask, and using indexes obtained by adding a fixed `offset` to a series of secondary offsets from an index map.
  `void` | LongVector.`intoArray​(long[] a, int offset, VectorMask<Long> m)` | Stores this vector into an array of `long` starting at offset and using a mask.
  `void` | ShortVector.`intoArray​(short[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Short> m)` | Scatters this vector into an array of type `short[]`, under the control of a mask, and using indexes obtained by adding a fixed `offset` to a series of secondary offsets from an index map.
  `void` | ShortVector.`intoArray​(short[] a, int offset, VectorMask<Short> m)` | Stores this vector into an array of `short` starting at offset and using a mask.
  `void` | ByteVector.`intoByteArray​(byte[] a, int offset, ByteOrder bo, VectorMask<Byte> m)` | Stores this vector into a byte array starting at an offset using explicit byte order and a mask.
  `void` | ByteVector.`intoByteArray​(byte[] a, int offset, VectorMask<Byte> m)` | Stores this vector into a byte array starting at an offset using a mask.
  `void` | DoubleVector.`intoByteArray​(byte[] a, int offset, ByteOrder bo, VectorMask<Double> m)` | Stores this vector into a byte array starting at an offset using explicit byte order and a mask.
  `void` | DoubleVector.`intoByteArray​(byte[] a, int offset, VectorMask<Double> m)` | Stores this vector into a byte array starting at an offset using a mask.
  `void` | FloatVector.`intoByteArray​(byte[] a, int offset, ByteOrder bo, VectorMask<Float> m)` | Stores this vector into a byte array starting at an offset using explicit byte order and a mask.
  `void` | FloatVector.`intoByteArray​(byte[] a, int offset, VectorMask<Float> m)` | Stores this vector into a byte array starting at an offset using a mask.
  `void` | IntVector.`intoByteArray​(byte[] a, int offset, ByteOrder bo, VectorMask<Integer> m)` | Stores this vector into a byte array starting at an offset using explicit byte order and a mask.
  `void` | IntVector.`intoByteArray​(byte[] a, int offset, VectorMask<Integer> m)` | Stores this vector into a byte array starting at an offset using a mask.
  `void` | LongVector.`intoByteArray​(byte[] a, int offset, ByteOrder bo, VectorMask<Long> m)` | Stores this vector into a byte array starting at an offset using explicit byte order and a mask.
  `void` | LongVector.`intoByteArray​(byte[] a, int offset, VectorMask<Long> m)` | Stores this vector into a byte array starting at an offset using a mask.
  `void` | ShortVector.`intoByteArray​(byte[] a, int offset, ByteOrder bo, VectorMask<Short> m)` | Stores this vector into a byte array starting at an offset using explicit byte order and a mask.
  `void` | ShortVector.`intoByteArray​(byte[] a, int offset, VectorMask<Short> m)` | Stores this vector into a byte array starting at an offset using a mask.
  `abstract void` | Vector.`intoByteArray​(byte[] a, int offset, ByteOrder bo, VectorMask<E> m)` | Stores this vector into a byte array starting at an offset using explicit byte order and a mask.
  `abstract void` | Vector.`intoByteArray​(byte[] a, int offset, VectorMask<E> m)` | Stores this vector into a byte array starting at an offset using a mask.
  `void` | ByteVector.`intoByteBuffer​(ByteBuffer bb, int offset, ByteOrder bo, VectorMask<Byte> m)` | Stores this vector into a byte buffer starting at an offset using explicit byte order and a mask.
  `void` | DoubleVector.`intoByteBuffer​(ByteBuffer bb, int offset, ByteOrder bo, VectorMask<Double> m)` | Stores this vector into a byte buffer starting at an offset using explicit byte order and a mask.
  `void` | FloatVector.`intoByteBuffer​(ByteBuffer bb, int offset, ByteOrder bo, VectorMask<Float> m)` | Stores this vector into a byte buffer starting at an offset using explicit byte order and a mask.
  `void` | IntVector.`intoByteBuffer​(ByteBuffer bb, int offset, ByteOrder bo, VectorMask<Integer> m)` | Stores this vector into a byte buffer starting at an offset using explicit byte order and a mask.
  `void` | LongVector.`intoByteBuffer​(ByteBuffer bb, int offset, ByteOrder bo, VectorMask<Long> m)` | Stores this vector into a byte buffer starting at an offset using explicit byte order and a mask.
  `void` | ShortVector.`intoByteBuffer​(ByteBuffer bb, int offset, ByteOrder bo, VectorMask<Short> m)` | Stores this vector into a byte buffer starting at an offset using explicit byte order and a mask.
  `abstract void` | Vector.`intoByteBuffer​(ByteBuffer bb, int offset, ByteOrder bo, VectorMask<E> m)` | Stores this vector into a byte buffer starting at an offset using explicit byte order and a mask.
  `ByteVector` | ByteVector.`lanewise​(VectorOperators.Binary op, byte e, VectorMask<Byte> m)` | Combines the lane values of this vector with the value of a broadcast scalar, with selection of lane elements controlled by a mask.
  `ByteVector` | ByteVector.`lanewise​(VectorOperators.Binary op, long e, VectorMask<Byte> m)` | Combines the corresponding lane values of this vector with those of a second input vector, with selection of lane elements controlled by a mask.
  `ByteVector` | ByteVector.`lanewise​(VectorOperators.Binary op, Vector<Byte> v, VectorMask<Byte> m)` | Combines the corresponding lane values of this vector with those of a second input vector, with selection of lane elements controlled by a mask.
  `ByteVector` | ByteVector.`lanewise​(VectorOperators.Ternary op, byte e1, byte e2, VectorMask<Byte> m)` | Combines the lane values of this vector with the values of two broadcast scalars, with selection of lane elements controlled by a mask.
  `ByteVector` | ByteVector.`lanewise​(VectorOperators.Ternary op, byte e1, Vector<Byte> v2, VectorMask<Byte> m)` | Combines the lane values of this vector with the values of another vector and a broadcast scalar, with selection of lane elements controlled by a mask.
  `ByteVector` | ByteVector.`lanewise​(VectorOperators.Ternary op, Vector<Byte> v1, byte e2, VectorMask<Byte> m)` | Combines the lane values of this vector with the values of another vector and a broadcast scalar, with selection of lane elements controlled by a mask.
  `ByteVector` | ByteVector.`lanewise​(VectorOperators.Ternary op, Vector<Byte> v1, Vector<Byte> v2, VectorMask<Byte> m)` | Combines the corresponding lane values of this vector with the lanes of a second and a third input vector, with selection of lane elements controlled by a mask.
  `ByteVector` | ByteVector.`lanewise​(VectorOperators.Unary op, VectorMask<Byte> m)` | Operates on the lane values of this vector, with selection of lane elements controlled by a mask.
  `DoubleVector` | DoubleVector.`lanewise​(VectorOperators.Binary op, double e, VectorMask<Double> m)` | Combines the lane values of this vector with the value of a broadcast scalar, with selection of lane elements controlled by a mask.
  `DoubleVector` | DoubleVector.`lanewise​(VectorOperators.Binary op, long e, VectorMask<Double> m)` | Combines the corresponding lane values of this vector with those of a second input vector, with selection of lane elements controlled by a mask.
  `DoubleVector` | DoubleVector.`lanewise​(VectorOperators.Binary op, Vector<Double> v, VectorMask<Double> m)` | Combines the corresponding lane values of this vector with those of a second input vector, with selection of lane elements controlled by a mask.
  `DoubleVector` | DoubleVector.`lanewise​(VectorOperators.Ternary op, double e1, double e2, VectorMask<Double> m)` | Combines the lane values of this vector with the values of two broadcast scalars, with selection of lane elements controlled by a mask.
  `DoubleVector` | DoubleVector.`lanewise​(VectorOperators.Ternary op, double e1, Vector<Double> v2, VectorMask<Double> m)` | Combines the lane values of this vector with the values of another vector and a broadcast scalar, with selection of lane elements controlled by a mask.
  `DoubleVector` | DoubleVector.`lanewise​(VectorOperators.Ternary op, Vector<Double> v1, double e2, VectorMask<Double> m)` | Combines the lane values of this vector with the values of another vector and a broadcast scalar, with selection of lane elements controlled by a mask.
  `DoubleVector` | DoubleVector.`lanewise​(VectorOperators.Ternary op, Vector<Double> v1, Vector<Double> v2, VectorMask<Double> m)` | Combines the corresponding lane values of this vector with the lanes of a second and a third input vector, with selection of lane elements controlled by a mask.
  `DoubleVector` | DoubleVector.`lanewise​(VectorOperators.Unary op, VectorMask<Double> m)` | Operates on the lane values of this vector, with selection of lane elements controlled by a mask.
  `FloatVector` | FloatVector.`lanewise​(VectorOperators.Binary op, float e, VectorMask<Float> m)` | Combines the lane values of this vector with the value of a broadcast scalar, with selection of lane elements controlled by a mask.
  `FloatVector` | FloatVector.`lanewise​(VectorOperators.Binary op, long e, VectorMask<Float> m)` | Combines the corresponding lane values of this vector with those of a second input vector, with selection of lane elements controlled by a mask.
  `FloatVector` | FloatVector.`lanewise​(VectorOperators.Binary op, Vector<Float> v, VectorMask<Float> m)` | Combines the corresponding lane values of this vector with those of a second input vector, with selection of lane elements controlled by a mask.
  `FloatVector` | FloatVector.`lanewise​(VectorOperators.Ternary op, float e1, float e2, VectorMask<Float> m)` | Combines the lane values of this vector with the values of two broadcast scalars, with selection of lane elements controlled by a mask.
  `FloatVector` | FloatVector.`lanewise​(VectorOperators.Ternary op, float e1, Vector<Float> v2, VectorMask<Float> m)` | Combines the lane values of this vector with the values of another vector and a broadcast scalar, with selection of lane elements controlled by a mask.
  `FloatVector` | FloatVector.`lanewise​(VectorOperators.Ternary op, Vector<Float> v1, float e2, VectorMask<Float> m)` | Combines the lane values of this vector with the values of another vector and a broadcast scalar, with selection of lane elements controlled by a mask.
  `FloatVector` | FloatVector.`lanewise​(VectorOperators.Ternary op, Vector<Float> v1, Vector<Float> v2, VectorMask<Float> m)` | Combines the corresponding lane values of this vector with the lanes of a second and a third input vector, with selection of lane elements controlled by a mask.
  `FloatVector` | FloatVector.`lanewise​(VectorOperators.Unary op, VectorMask<Float> m)` | Operates on the lane values of this vector, with selection of lane elements controlled by a mask.
  `IntVector` | IntVector.`lanewise​(VectorOperators.Binary op, int e, VectorMask<Integer> m)` | Combines the lane values of this vector with the value of a broadcast scalar, with selection of lane elements controlled by a mask.
  `IntVector` | IntVector.`lanewise​(VectorOperators.Binary op, long e, VectorMask<Integer> m)` | Combines the corresponding lane values of this vector with those of a second input vector, with selection of lane elements controlled by a mask.
  `IntVector` | IntVector.`lanewise​(VectorOperators.Binary op, Vector<Integer> v, VectorMask<Integer> m)` | Combines the corresponding lane values of this vector with those of a second input vector, with selection of lane elements controlled by a mask.
  `IntVector` | IntVector.`lanewise​(VectorOperators.Ternary op, int e1, int e2, VectorMask<Integer> m)` | Combines the lane values of this vector with the values of two broadcast scalars, with selection of lane elements controlled by a mask.
  `IntVector` | IntVector.`lanewise​(VectorOperators.Ternary op, int e1, Vector<Integer> v2, VectorMask<Integer> m)` | Combines the lane values of this vector with the values of another vector and a broadcast scalar, with selection of lane elements controlled by a mask.
  `IntVector` | IntVector.`lanewise​(VectorOperators.Ternary op, Vector<Integer> v1, int e2, VectorMask<Integer> m)` | Combines the lane values of this vector with the values of another vector and a broadcast scalar, with selection of lane elements controlled by a mask.
  `IntVector` | IntVector.`lanewise​(VectorOperators.Ternary op, Vector<Integer> v1, Vector<Integer> v2, VectorMask<Integer> m)` | Combines the corresponding lane values of this vector with the lanes of a second and a third input vector, with selection of lane elements controlled by a mask.
  `IntVector` | IntVector.`lanewise​(VectorOperators.Unary op, VectorMask<Integer> m)` | Operates on the lane values of this vector, with selection of lane elements controlled by a mask.
  `LongVector` | LongVector.`lanewise​(VectorOperators.Binary op, long e, VectorMask<Long> m)` | Combines the lane values of this vector with the value of a broadcast scalar, with selection of lane elements controlled by a mask.
  `LongVector` | LongVector.`lanewise​(VectorOperators.Binary op, Vector<Long> v, VectorMask<Long> m)` | Combines the corresponding lane values of this vector with those of a second input vector, with selection of lane elements controlled by a mask.
  `LongVector` | LongVector.`lanewise​(VectorOperators.Ternary op, long e1, long e2, VectorMask<Long> m)` | Combines the lane values of this vector with the values of two broadcast scalars, with selection of lane elements controlled by a mask.
  `LongVector` | LongVector.`lanewise​(VectorOperators.Ternary op, long e1, Vector<Long> v2, VectorMask<Long> m)` | Combines the lane values of this vector with the values of another vector and a broadcast scalar, with selection of lane elements controlled by a mask.
  `LongVector` | LongVector.`lanewise​(VectorOperators.Ternary op, Vector<Long> v1, long e2, VectorMask<Long> m)` | Combines the lane values of this vector with the values of another vector and a broadcast scalar, with selection of lane elements controlled by a mask.
  `LongVector` | LongVector.`lanewise​(VectorOperators.Ternary op, Vector<Long> v1, Vector<Long> v2, VectorMask<Long> m)` | Combines the corresponding lane values of this vector with the lanes of a second and a third input vector, with selection of lane elements controlled by a mask.
  `LongVector` | LongVector.`lanewise​(VectorOperators.Unary op, VectorMask<Long> m)` | Operates on the lane values of this vector, with selection of lane elements controlled by a mask.
  `ShortVector` | ShortVector.`lanewise​(VectorOperators.Binary op, long e, VectorMask<Short> m)` | Combines the corresponding lane values of this vector with those of a second input vector, with selection of lane elements controlled by a mask.
  `ShortVector` | ShortVector.`lanewise​(VectorOperators.Binary op, short e, VectorMask<Short> m)` | Combines the lane values of this vector with the value of a broadcast scalar, with selection of lane elements controlled by a mask.
  `ShortVector` | ShortVector.`lanewise​(VectorOperators.Binary op, Vector<Short> v, VectorMask<Short> m)` | Combines the corresponding lane values of this vector with those of a second input vector, with selection of lane elements controlled by a mask.
  `ShortVector` | ShortVector.`lanewise​(VectorOperators.Ternary op, short e1, short e2, VectorMask<Short> m)` | Combines the lane values of this vector with the values of two broadcast scalars, with selection of lane elements controlled by a mask.
  `ShortVector` | ShortVector.`lanewise​(VectorOperators.Ternary op, short e1, Vector<Short> v2, VectorMask<Short> m)` | Combines the lane values of this vector with the values of another vector and a broadcast scalar, with selection of lane elements controlled by a mask.
  `ShortVector` | ShortVector.`lanewise​(VectorOperators.Ternary op, Vector<Short> v1, short e2, VectorMask<Short> m)` | Combines the lane values of this vector with the values of another vector and a broadcast scalar, with selection of lane elements controlled by a mask.
  `ShortVector` | ShortVector.`lanewise​(VectorOperators.Ternary op, Vector<Short> v1, Vector<Short> v2, VectorMask<Short> m)` | Combines the corresponding lane values of this vector with the lanes of a second and a third input vector, with selection of lane elements controlled by a mask.
  `ShortVector` | ShortVector.`lanewise​(VectorOperators.Unary op, VectorMask<Short> m)` | Operates on the lane values of this vector, with selection of lane elements controlled by a mask.
  `abstract Vector<E>` | Vector.`lanewise​(VectorOperators.Binary op, long e, VectorMask<E> m)` | Combines the corresponding lane values of this vector with those of a second input vector, with selection of lane elements controlled by a mask.
  `abstract Vector<E>` | Vector.`lanewise​(VectorOperators.Binary op, Vector<E> v, VectorMask<E> m)` | Combines the corresponding lane values of this vector with those of a second input vector, with selection of lane elements controlled by a mask.
  `abstract Vector<E>` | Vector.`lanewise​(VectorOperators.Ternary op, Vector<E> v1, Vector<E> v2, VectorMask<E> m)` | Combines the corresponding lane values of this vector with the lanes of a second and a third input vector, with selection of lane elements controlled by a mask.
  `abstract Vector<E>` | Vector.`lanewise​(VectorOperators.Unary op, VectorMask<E> m)` | Operates on the lane values of this vector, with selection of lane elements controlled by a mask.
  `ByteVector` | ByteVector.`mul​(byte e, VectorMask<Byte> m)` | Multiplies this vector by the broadcast of an input scalar, selecting lane elements controlled by a mask.
  `ByteVector` | ByteVector.`mul​(Vector<Byte> v, VectorMask<Byte> m)` | Multiplies this vector by a second input vector under the control of a mask.
  `DoubleVector` | DoubleVector.`mul​(double e, VectorMask<Double> m)` | Multiplies this vector by the broadcast of an input scalar, selecting lane elements controlled by a mask.
  `DoubleVector` | DoubleVector.`mul​(Vector<Double> v, VectorMask<Double> m)` | Multiplies this vector by a second input vector under the control of a mask.
  `FloatVector` | FloatVector.`mul​(float e, VectorMask<Float> m)` | Multiplies this vector by the broadcast of an input scalar, selecting lane elements controlled by a mask.
  `FloatVector` | FloatVector.`mul​(Vector<Float> v, VectorMask<Float> m)` | Multiplies this vector by a second input vector under the control of a mask.
  `IntVector` | IntVector.`mul​(int e, VectorMask<Integer> m)` | Multiplies this vector by the broadcast of an input scalar, selecting lane elements controlled by a mask.
  `IntVector` | IntVector.`mul​(Vector<Integer> v, VectorMask<Integer> m)` | Multiplies this vector by a second input vector under the control of a mask.
  `LongVector` | LongVector.`mul​(long e, VectorMask<Long> m)` | Multiplies this vector by the broadcast of an input scalar, selecting lane elements controlled by a mask.
  `LongVector` | LongVector.`mul​(Vector<Long> v, VectorMask<Long> m)` | Multiplies this vector by a second input vector under the control of a mask.
  `ShortVector` | ShortVector.`mul​(short e, VectorMask<Short> m)` | Multiplies this vector by the broadcast of an input scalar, selecting lane elements controlled by a mask.
  `ShortVector` | ShortVector.`mul​(Vector<Short> v, VectorMask<Short> m)` | Multiplies this vector by a second input vector under the control of a mask.
  `abstract Vector<E>` | Vector.`mul​(Vector<E> v, VectorMask<E> m)` | Multiplies this vector by a second input vector under the control of a mask.
  `abstract VectorMask<E>` | VectorMask.`or​(VectorMask<E> m)` | Computes the logical union (as `a|b`) of this mask and a second input mask.
  `abstract ByteVector` | ByteVector.`rearrange​(VectorShuffle<Byte> s, VectorMask<Byte> m)` | Rearranges the lane elements of this vector, selecting lanes under the control of a specific shuffle and a mask.
  `abstract DoubleVector` | DoubleVector.`rearrange​(VectorShuffle<Double> s, VectorMask<Double> m)` | Rearranges the lane elements of this vector, selecting lanes under the control of a specific shuffle and a mask.
  `abstract FloatVector` | FloatVector.`rearrange​(VectorShuffle<Float> s, VectorMask<Float> m)` | Rearranges the lane elements of this vector, selecting lanes under the control of a specific shuffle and a mask.
  `abstract IntVector` | IntVector.`rearrange​(VectorShuffle<Integer> s, VectorMask<Integer> m)` | Rearranges the lane elements of this vector, selecting lanes under the control of a specific shuffle and a mask.
  `abstract LongVector` | LongVector.`rearrange​(VectorShuffle<Long> s, VectorMask<Long> m)` | Rearranges the lane elements of this vector, selecting lanes under the control of a specific shuffle and a mask.
  `abstract ShortVector` | ShortVector.`rearrange​(VectorShuffle<Short> s, VectorMask<Short> m)` | Rearranges the lane elements of this vector, selecting lanes under the control of a specific shuffle and a mask.
  `abstract Vector<E>` | Vector.`rearrange​(VectorShuffle<E> s, VectorMask<E> m)` | Rearranges the lane elements of this vector, selecting lanes under the control of a specific shuffle and a mask.
  `abstract byte` | ByteVector.`reduceLanes​(VectorOperators.Associative op, VectorMask<Byte> m)` | Returns a value accumulated from selected lanes of this vector, controlled by a mask.
  `abstract double` | DoubleVector.`reduceLanes​(VectorOperators.Associative op, VectorMask<Double> m)` | Returns a value accumulated from selected lanes of this vector, controlled by a mask.
  `abstract float` | FloatVector.`reduceLanes​(VectorOperators.Associative op, VectorMask<Float> m)` | Returns a value accumulated from selected lanes of this vector, controlled by a mask.
  `abstract int` | IntVector.`reduceLanes​(VectorOperators.Associative op, VectorMask<Integer> m)` | Returns a value accumulated from selected lanes of this vector, controlled by a mask.
  `abstract long` | LongVector.`reduceLanes​(VectorOperators.Associative op, VectorMask<Long> m)` | Returns a value accumulated from selected lanes of this vector, controlled by a mask.
  `abstract short` | ShortVector.`reduceLanes​(VectorOperators.Associative op, VectorMask<Short> m)` | Returns a value accumulated from selected lanes of this vector, controlled by a mask.
  `abstract long` | Vector.`reduceLanesToLong​(VectorOperators.Associative op, VectorMask<E> m)` | Returns a value accumulated from selected lanes of this vector, controlled by a mask.
  `abstract ByteVector` | ByteVector.`selectFrom​(Vector<Byte> s, VectorMask<Byte> m)` | Using index values stored in the lanes of this vector, assemble values stored in second vector, under the control of a mask.
  `abstract DoubleVector` | DoubleVector.`selectFrom​(Vector<Double> s, VectorMask<Double> m)` | Using index values stored in the lanes of this vector, assemble values stored in second vector, under the control of a mask.
  `abstract FloatVector` | FloatVector.`selectFrom​(Vector<Float> s, VectorMask<Float> m)` | Using index values stored in the lanes of this vector, assemble values stored in second vector, under the control of a mask.
  `abstract IntVector` | IntVector.`selectFrom​(Vector<Integer> s, VectorMask<Integer> m)` | Using index values stored in the lanes of this vector, assemble values stored in second vector, under the control of a mask.
  `abstract LongVector` | LongVector.`selectFrom​(Vector<Long> s, VectorMask<Long> m)` | Using index values stored in the lanes of this vector, assemble values stored in second vector, under the control of a mask.
  `abstract ShortVector` | ShortVector.`selectFrom​(Vector<Short> s, VectorMask<Short> m)` | Using index values stored in the lanes of this vector, assemble values stored in second vector, under the control of a mask.
  `abstract Vector<E>` | Vector.`selectFrom​(Vector<E> v, VectorMask<E> m)` | Using index values stored in the lanes of this vector, assemble values stored in second vector, under the control of a mask.
  `ByteVector` | ByteVector.`slice​(int origin, Vector<Byte> w, VectorMask<Byte> m)` | Slices a segment of adjacent lanes under the control of a mask, starting at a given `origin` lane in the current vector, and continuing (as needed) into an immediately following vector.
  `DoubleVector` | DoubleVector.`slice​(int origin, Vector<Double> w, VectorMask<Double> m)` | Slices a segment of adjacent lanes under the control of a mask, starting at a given `origin` lane in the current vector, and continuing (as needed) into an immediately following vector.
  `FloatVector` | FloatVector.`slice​(int origin, Vector<Float> w, VectorMask<Float> m)` | Slices a segment of adjacent lanes under the control of a mask, starting at a given `origin` lane in the current vector, and continuing (as needed) into an immediately following vector.
  `IntVector` | IntVector.`slice​(int origin, Vector<Integer> w, VectorMask<Integer> m)` | Slices a segment of adjacent lanes under the control of a mask, starting at a given `origin` lane in the current vector, and continuing (as needed) into an immediately following vector.
  `LongVector` | LongVector.`slice​(int origin, Vector<Long> w, VectorMask<Long> m)` | Slices a segment of adjacent lanes under the control of a mask, starting at a given `origin` lane in the current vector, and continuing (as needed) into an immediately following vector.
  `ShortVector` | ShortVector.`slice​(int origin, Vector<Short> w, VectorMask<Short> m)` | Slices a segment of adjacent lanes under the control of a mask, starting at a given `origin` lane in the current vector, and continuing (as needed) into an immediately following vector.
  `abstract Vector<E>` | Vector.`slice​(int origin, Vector<E> v1, VectorMask<E> m)` | Slices a segment of adjacent lanes under the control of a mask, starting at a given `origin` lane in the current vector, and continuing (as needed) into an immediately following vector.
  `ByteVector` | ByteVector.`sub​(byte e, VectorMask<Byte> m)` | Subtracts an input scalar from this vector under the control of a mask.
  `ByteVector` | ByteVector.`sub​(Vector<Byte> v, VectorMask<Byte> m)` | Subtracts a second input vector from this vector under the control of a mask.
  `DoubleVector` | DoubleVector.`sub​(double e, VectorMask<Double> m)` | Subtracts an input scalar from this vector under the control of a mask.
  `DoubleVector` | DoubleVector.`sub​(Vector<Double> v, VectorMask<Double> m)` | Subtracts a second input vector from this vector under the control of a mask.
  `FloatVector` | FloatVector.`sub​(float e, VectorMask<Float> m)` | Subtracts an input scalar from this vector under the control of a mask.
  `FloatVector` | FloatVector.`sub​(Vector<Float> v, VectorMask<Float> m)` | Subtracts a second input vector from this vector under the control of a mask.
  `IntVector` | IntVector.`sub​(int e, VectorMask<Integer> m)` | Subtracts an input scalar from this vector under the control of a mask.
  `IntVector` | IntVector.`sub​(Vector<Integer> v, VectorMask<Integer> m)` | Subtracts a second input vector from this vector under the control of a mask.
  `LongVector` | LongVector.`sub​(long e, VectorMask<Long> m)` | Subtracts an input scalar from this vector under the control of a mask.
  `LongVector` | LongVector.`sub​(Vector<Long> v, VectorMask<Long> m)` | Subtracts a second input vector from this vector under the control of a mask.
  `ShortVector` | ShortVector.`sub​(short e, VectorMask<Short> m)` | Subtracts an input scalar from this vector under the control of a mask.
  `ShortVector` | ShortVector.`sub​(Vector<Short> v, VectorMask<Short> m)` | Subtracts a second input vector from this vector under the control of a mask.
  `abstract Vector<E>` | Vector.`sub​(Vector<E> v, VectorMask<E> m)` | Subtracts a second input vector from this vector under the control of a mask.
  `VectorMask<Byte>` | ByteVector.`test​(VectorOperators.Test op, VectorMask<Byte> m)` | Test selected lanes of this vector, according to the given operation.
  `VectorMask<Double>` | DoubleVector.`test​(VectorOperators.Test op, VectorMask<Double> m)` | Test selected lanes of this vector, according to the given operation.
  `VectorMask<Float>` | FloatVector.`test​(VectorOperators.Test op, VectorMask<Float> m)` | Test selected lanes of this vector, according to the given operation.
  `VectorMask<Integer>` | IntVector.`test​(VectorOperators.Test op, VectorMask<Integer> m)` | Test selected lanes of this vector, according to the given operation.
  `VectorMask<Long>` | LongVector.`test​(VectorOperators.Test op, VectorMask<Long> m)` | Test selected lanes of this vector, according to the given operation.
  `VectorMask<Short>` | ShortVector.`test​(VectorOperators.Test op, VectorMask<Short> m)` | Test selected lanes of this vector, according to the given operation.
  `abstract VectorMask<E>` | Vector.`test​(VectorOperators.Test op, VectorMask<E> m)` | Test selected lanes of this vector, according to the given operation.
  `abstract ByteVector` | ByteVector.`unslice​(int origin, Vector<Byte> w, int part, VectorMask<Byte> m)` | Reverses a slice(), inserting (under the control of a mask) the current vector as a slice within another "background" input vector, which is regarded as one or the other input to a hypothetical subsequent `slice()` operation.
  `abstract DoubleVector` | DoubleVector.`unslice​(int origin, Vector<Double> w, int part, VectorMask<Double> m)` | Reverses a slice(), inserting (under the control of a mask) the current vector as a slice within another "background" input vector, which is regarded as one or the other input to a hypothetical subsequent `slice()` operation.
  `abstract FloatVector` | FloatVector.`unslice​(int origin, Vector<Float> w, int part, VectorMask<Float> m)` | Reverses a slice(), inserting (under the control of a mask) the current vector as a slice within another "background" input vector, which is regarded as one or the other input to a hypothetical subsequent `slice()` operation.
  `abstract IntVector` | IntVector.`unslice​(int origin, Vector<Integer> w, int part, VectorMask<Integer> m)` | Reverses a slice(), inserting (under the control of a mask) the current vector as a slice within another "background" input vector, which is regarded as one or the other input to a hypothetical subsequent `slice()` operation.
  `abstract LongVector` | LongVector.`unslice​(int origin, Vector<Long> w, int part, VectorMask<Long> m)` | Reverses a slice(), inserting (under the control of a mask) the current vector as a slice within another "background" input vector, which is regarded as one or the other input to a hypothetical subsequent `slice()` operation.
  `abstract ShortVector` | ShortVector.`unslice​(int origin, Vector<Short> w, int part, VectorMask<Short> m)` | Reverses a slice(), inserting (under the control of a mask) the current vector as a slice within another "background" input vector, which is regarded as one or the other input to a hypothetical subsequent `slice()` operation.
  `abstract Vector<E>` | Vector.`unslice​(int origin, Vector<E> w, int part, VectorMask<E> m)` | Reverses a slice(), inserting (under the control of a mask) the current vector as a slice within another "background" input vector, which is regarded as one or the other input to a hypothetical subsequent `slice()` operation.