# 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.