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.
final 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.
final 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.
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.
final 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.
final 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.
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.
final 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.
final 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.
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.
final 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.
final 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.
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.
final 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.
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.
final 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.
final 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.
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.
abstract VectorMask<E>	VectorMask.compress()	Compresses set lanes from this mask.
final VectorMask<Byte>	ByteVector.eq(byte e)	Tests if this vector is equal to an input scalar.
final VectorMask<Byte>	ByteVector.eq(Vector<Byte> v)	Tests if this vector is equal to another input vector.
final VectorMask<Double>	DoubleVector.eq(double e)	Tests if this vector is equal to an input scalar.
final VectorMask<Double>	DoubleVector.eq(Vector<Double> v)	Tests if this vector is equal to another input vector.
final VectorMask<Float>	FloatVector.eq(float e)	Tests if this vector is equal to an input scalar.
final VectorMask<Float>	FloatVector.eq(Vector<Float> v)	Tests if this vector is equal to another input vector.
final VectorMask<Integer>	IntVector.eq(int e)	Tests if this vector is equal to an input scalar.
final VectorMask<Integer>	IntVector.eq(Vector<Integer> v)	Tests if this vector is equal to another input vector.
final VectorMask<Long>	LongVector.eq(long e)	Tests if this vector is equal to an input scalar.
final VectorMask<Long>	LongVector.eq(Vector<Long> v)	Tests if this vector is equal to another input vector.
final VectorMask<Short>	ShortVector.eq(short e)	Tests if this vector is equal to an input scalar.
final 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.eq(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].
abstract VectorMask<E>	VectorMask.indexInRange(long offset, long 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.
VectorMask<E>	VectorSpecies.indexInRange(long offset, long 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.
final VectorMask<Byte>	ByteVector.lt(byte e)	Tests if this vector is less than an input scalar.
final VectorMask<Byte>	ByteVector.lt(Vector<Byte> v)	Tests if this vector is less than another input vector.
final VectorMask<Double>	DoubleVector.lt(double e)	Tests if this vector is less than an input scalar.
final VectorMask<Double>	DoubleVector.lt(Vector<Double> v)	Tests if this vector is less than another input vector.
final VectorMask<Float>	FloatVector.lt(float e)	Tests if this vector is less than an input scalar.
final VectorMask<Float>	FloatVector.lt(Vector<Float> v)	Tests if this vector is less than another input vector.
final VectorMask<Integer>	IntVector.lt(int e)	Tests if this vector is less than an input scalar.
final VectorMask<Integer>	IntVector.lt(Vector<Integer> v)	Tests if this vector is less than another input vector.
final VectorMask<Long>	LongVector.lt(long e)	Tests if this vector is less than an input scalar.
final VectorMask<Long>	LongVector.lt(Vector<Long> v)	Tests if this vector is less than another input vector.
final VectorMask<Short>	ShortVector.lt(short e)	Tests if this vector is less than an input scalar.
final 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.
abstract 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.
abstract 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.
abstract 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.
abstract 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.
abstract 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.
abstract 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.
abstract VectorMask<E>	VectorMask.xor(VectorMask<E> m)	Determines logical symmetric difference (as a^b) of this mask and a second input mask.

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
final 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.
final 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.
final 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.
final 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.
final 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.
final 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.
final 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.
final 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.
final 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.
final 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.
final 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.
final 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).
final ByteVector	ByteVector.blend(byte e, VectorMask<Byte> m)	Replaces selected lanes of this vector with a scalar value under the control of a mask.
final 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.
final DoubleVector	DoubleVector.blend(double e, VectorMask<Double> m)	Replaces selected lanes of this vector with a scalar value under the control of a mask.
final 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.
final FloatVector	FloatVector.blend(float e, VectorMask<Float> m)	Replaces selected lanes of this vector with a scalar value under the control of a mask.
final 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.
final IntVector	IntVector.blend(int e, VectorMask<Integer> m)	Replaces selected lanes of this vector with a scalar value under the control of a mask.
final 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.
final 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.
final ShortVector	ShortVector.blend(long e, VectorMask<Short> m)	Replaces selected lanes of this vector with a scalar value under the control of a mask.
final 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.
final 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.
final 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.
final 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.
final 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.
final 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.
final 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.
final 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.
final 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.
final 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.
final 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.
final 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<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.
abstract ByteVector	ByteVector.compress(VectorMask<Byte> m)	Compresses the lane elements of this vector selecting lanes under the control of a specific mask.
abstract DoubleVector	DoubleVector.compress(VectorMask<Double> m)	Compresses the lane elements of this vector selecting lanes under the control of a specific mask.
abstract FloatVector	FloatVector.compress(VectorMask<Float> m)	Compresses the lane elements of this vector selecting lanes under the control of a specific mask.
abstract IntVector	IntVector.compress(VectorMask<Integer> m)	Compresses the lane elements of this vector selecting lanes under the control of a specific mask.
abstract LongVector	LongVector.compress(VectorMask<Long> m)	Compresses the lane elements of this vector selecting lanes under the control of a specific mask.
abstract ShortVector	ShortVector.compress(VectorMask<Short> m)	Compresses the lane elements of this vector selecting lanes under the control of a specific mask.
abstract Vector<E>	Vector.compress(VectorMask<E> m)	Compresses the lane elements of this vector selecting lanes under the control of a specific mask.
final 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.
final ByteVector	ByteVector.div(Vector<Byte> v, VectorMask<Byte> m)	Divides this vector by a second input vector under the control of a mask.
final 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.
final DoubleVector	DoubleVector.div(Vector<Double> v, VectorMask<Double> m)	Divides this vector by a second input vector under the control of a mask.
final 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.
final FloatVector	FloatVector.div(Vector<Float> v, VectorMask<Float> m)	Divides this vector by a second input vector under the control of a mask.
final 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.
final IntVector	IntVector.div(Vector<Integer> v, VectorMask<Integer> m)	Divides this vector by a second input vector under the control of a mask.
final 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.
final LongVector	LongVector.div(Vector<Long> v, VectorMask<Long> m)	Divides this vector by a second input vector under the control of a mask.
final 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.
final 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.eq(VectorMask<E> m)	Determines logical equivalence of this mask to a second input mask (as boolean a==b or a^~b).
abstract ByteVector	ByteVector.expand(VectorMask<Byte> m)	Expands the lane elements of this vector under the control of a specific mask.
abstract DoubleVector	DoubleVector.expand(VectorMask<Double> m)	Expands the lane elements of this vector under the control of a specific mask.
abstract FloatVector	FloatVector.expand(VectorMask<Float> m)	Expands the lane elements of this vector under the control of a specific mask.
abstract IntVector	IntVector.expand(VectorMask<Integer> m)	Expands the lane elements of this vector under the control of a specific mask.
abstract LongVector	LongVector.expand(VectorMask<Long> m)	Expands the lane elements of this vector under the control of a specific mask.
abstract ShortVector	ShortVector.expand(VectorMask<Short> m)	Expands the lane elements of this vector under the control of a specific mask.
abstract Vector<E>	Vector.expand(VectorMask<E> m)	Expands the lane elements of this vector under the control of a specific mask.
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.fromBooleanArray(VectorSpecies<Byte> species, boolean[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Byte> m)	Gathers a new vector composed of elements from an array of type boolean[], 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.fromBooleanArray(VectorSpecies<Byte> species, boolean[] a, int offset, VectorMask<Byte> m)	Loads a vector from an array of type boolean[] starting at an offset and using a mask.
static ShortVector	ShortVector.fromCharArray(VectorSpecies<Short> species, char[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Short> m)	Gathers a new vector composed of elements from an array of type char[], 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.fromCharArray(VectorSpecies<Short> species, char[] a, int offset, VectorMask<Short> m)	Loads a vector from an array of type char[] starting at an offset and using a mask.
static ByteVector	ByteVector.fromMemorySegment(VectorSpecies<Byte> species, MemorySegment ms, long offset, ByteOrder bo, VectorMask<Byte> m)	Loads a vector from a memory segment starting at an offset into the memory segment and using a mask.
static DoubleVector	DoubleVector.fromMemorySegment(VectorSpecies<Double> species, MemorySegment ms, long offset, ByteOrder bo, VectorMask<Double> m)	Loads a vector from a memory segment starting at an offset into the memory segment and using a mask.
static FloatVector	FloatVector.fromMemorySegment(VectorSpecies<Float> species, MemorySegment ms, long offset, ByteOrder bo, VectorMask<Float> m)	Loads a vector from a memory segment starting at an offset into the memory segment and using a mask.
static IntVector	IntVector.fromMemorySegment(VectorSpecies<Integer> species, MemorySegment ms, long offset, ByteOrder bo, VectorMask<Integer> m)	Loads a vector from a memory segment starting at an offset into the memory segment and using a mask.
static LongVector	LongVector.fromMemorySegment(VectorSpecies<Long> species, MemorySegment ms, long offset, ByteOrder bo, VectorMask<Long> m)	Loads a vector from a memory segment starting at an offset into the memory segment and using a mask.
static ShortVector	ShortVector.fromMemorySegment(VectorSpecies<Short> species, MemorySegment ms, long offset, ByteOrder bo, VectorMask<Short> m)	Loads a vector from a memory segment starting at an offset into the memory segment and using a mask.
final 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.
final void	ByteVector.intoArray(byte[] a, int offset, VectorMask<Byte> m)	Stores this vector into an array of type byte[] starting at offset and using a mask.
final 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.
final void	DoubleVector.intoArray(double[] a, int offset, VectorMask<Double> m)	Stores this vector into an array of type double[] starting at offset and using a mask.
final 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.
final void	FloatVector.intoArray(float[] a, int offset, VectorMask<Float> m)	Stores this vector into an array of type float[] starting at offset and using a mask.
final 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.
final void	IntVector.intoArray(int[] a, int offset, VectorMask<Integer> m)	Stores this vector into an array of type int[] starting at offset and using a mask.
final 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.
final void	LongVector.intoArray(long[] a, int offset, VectorMask<Long> m)	Stores this vector into an array of type long[] starting at offset and using a mask.
final 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.
final void	ShortVector.intoArray(short[] a, int offset, VectorMask<Short> m)	Stores this vector into an array of type short[] starting at offset and using a mask.
final void	ByteVector.intoBooleanArray(boolean[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Byte> m)	Scatters this vector into an array of type boolean[], 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.
final void	ByteVector.intoBooleanArray(boolean[] a, int offset, VectorMask<Byte> m)	Stores this vector into an array of type boolean[] starting at offset and using a mask.
final void	ShortVector.intoCharArray(char[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Short> m)	Scatters this vector into an array of type char[], 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.
final void	ShortVector.intoCharArray(char[] a, int offset, VectorMask<Short> m)	Stores this vector into an array of type char[] starting at offset and using a mask.
final void	ByteVector.intoMemorySegment(MemorySegment ms, long offset, ByteOrder bo, VectorMask<Byte> m)	Stores this vector into a memory segment starting at an offset using explicit byte order and a mask.
final void	DoubleVector.intoMemorySegment(MemorySegment ms, long offset, ByteOrder bo, VectorMask<Double> m)	Stores this vector into a memory segment starting at an offset using explicit byte order and a mask.
final void	FloatVector.intoMemorySegment(MemorySegment ms, long offset, ByteOrder bo, VectorMask<Float> m)	Stores this vector into a memory segment starting at an offset using explicit byte order and a mask.
final void	IntVector.intoMemorySegment(MemorySegment ms, long offset, ByteOrder bo, VectorMask<Integer> m)	Stores this vector into a memory segment starting at an offset using explicit byte order and a mask.
final void	LongVector.intoMemorySegment(MemorySegment ms, long offset, ByteOrder bo, VectorMask<Long> m)	Stores this vector into a memory segment starting at an offset using explicit byte order and a mask.
final void	ShortVector.intoMemorySegment(MemorySegment ms, long offset, ByteOrder bo, VectorMask<Short> m)	Stores this vector into a memory segment starting at an offset using explicit byte order and a mask.
abstract void	Vector.intoMemorySegment(MemorySegment ms, long offset, ByteOrder bo, VectorMask<E> m)	Stores this vector into a memory segment starting at an offset using explicit byte order and a mask.
final 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.
final 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.
abstract 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.
final 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.
final 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.
final 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.
abstract 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.
abstract 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.
final 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.
final 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.
abstract 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.
final 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.
final 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.
final 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.
abstract 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.
abstract 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.
final 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.
final 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.
abstract 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.
final 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.
final 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.
final 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.
abstract 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.
abstract 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.
final 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.
final 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.
abstract 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.
final 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.
final 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.
final 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.
abstract 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.
abstract 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.
final 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.
abstract 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.
final 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.
final 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.
final 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.
abstract 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.
abstract 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.
final 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.
final 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.
abstract 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.
final 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.
final 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.
final 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.
abstract 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.
abstract 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.
final 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.
final ByteVector	ByteVector.mul(Vector<Byte> v, VectorMask<Byte> m)	Multiplies this vector by a second input vector under the control of a mask.
final 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.
final DoubleVector	DoubleVector.mul(Vector<Double> v, VectorMask<Double> m)	Multiplies this vector by a second input vector under the control of a mask.
final 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.
final FloatVector	FloatVector.mul(Vector<Float> v, VectorMask<Float> m)	Multiplies this vector by a second input vector under the control of a mask.
final 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.
final IntVector	IntVector.mul(Vector<Integer> v, VectorMask<Integer> m)	Multiplies this vector by a second input vector under the control of a mask.
final 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.
final LongVector	LongVector.mul(Vector<Long> v, VectorMask<Long> m)	Multiplies this vector by a second input vector under the control of a mask.
final 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.
final 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.
final 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.
final 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.
final 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.
final 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.
final 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.
final 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.
final ByteVector	ByteVector.sub(byte e, VectorMask<Byte> m)	Subtracts an input scalar from this vector under the control of a mask.
final ByteVector	ByteVector.sub(Vector<Byte> v, VectorMask<Byte> m)	Subtracts a second input vector from this vector under the control of a mask.
final DoubleVector	DoubleVector.sub(double e, VectorMask<Double> m)	Subtracts an input scalar from this vector under the control of a mask.
final DoubleVector	DoubleVector.sub(Vector<Double> v, VectorMask<Double> m)	Subtracts a second input vector from this vector under the control of a mask.
final FloatVector	FloatVector.sub(float e, VectorMask<Float> m)	Subtracts an input scalar from this vector under the control of a mask.
final FloatVector	FloatVector.sub(Vector<Float> v, VectorMask<Float> m)	Subtracts a second input vector from this vector under the control of a mask.
final IntVector	IntVector.sub(int e, VectorMask<Integer> m)	Subtracts an input scalar from this vector under the control of a mask.
final IntVector	IntVector.sub(Vector<Integer> v, VectorMask<Integer> m)	Subtracts a second input vector from this vector under the control of a mask.
final LongVector	LongVector.sub(long e, VectorMask<Long> m)	Subtracts an input scalar from this vector under the control of a mask.
final LongVector	LongVector.sub(Vector<Long> v, VectorMask<Long> m)	Subtracts a second input vector from this vector under the control of a mask.
final ShortVector	ShortVector.sub(short e, VectorMask<Short> m)	Subtracts an input scalar from this vector under the control of a mask.
final 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.
abstract 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, VectorMask<Double> m)	Test selected lanes of this vector, according to the given operation.
abstract 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, VectorMask<Integer> m)	Test selected lanes of this vector, according to the given operation.
abstract 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, 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.
abstract VectorMask<E>	VectorMask.xor(VectorMask<E> m)	Determines logical symmetric difference (as a^b) of this mask and a second input mask.