Uses of Class
jdk.incubator.vector.VectorMask
Packages that use VectorMask
-
Uses of VectorMask in jdk.incubator.vector
Methods in jdk.incubator.vector that return VectorMaskModifier and TypeMethodDescriptionabstract VectorMask<E>VectorMask.and(VectorMask<E> m) Computes the logical intersection (asa&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 (asa&~b).abstract <F> VectorMask<F>VectorMask.cast(VectorSpecies<F> species) Converts this mask to a mask of the given species of element typeF.abstract <F> VectorMask<F>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.final VectorMask<Byte>ByteVector.compare(VectorOperators.Comparison op, Vector<Byte> v, VectorMask<Byte> m) Tests this vector by comparing it with another input vector, according to the given comparison operation, in lanes selected by a mask.abstract VectorMask<Double>DoubleVector.compare(VectorOperators.Comparison op, double e) Tests this vector by comparing it with an input scalar, according to the given comparison operation.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.final VectorMask<Double>DoubleVector.compare(VectorOperators.Comparison op, Vector<Double> v, VectorMask<Double> m) Tests this vector by comparing it with another input vector, according to the given comparison operation, in lanes selected by a mask.abstract VectorMask<Float>FloatVector.compare(VectorOperators.Comparison op, float e) Tests this vector by comparing it with an input scalar, according to the given comparison operation.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.final VectorMask<Float>FloatVector.compare(VectorOperators.Comparison op, Vector<Float> v, VectorMask<Float> m) Tests this vector by comparing it with another input vector, according to the given comparison operation, in lanes selected by a mask.abstract VectorMask<Integer>IntVector.compare(VectorOperators.Comparison op, int e) Tests this vector by comparing it with an input scalar, according to the given comparison operation.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.final VectorMask<Integer>IntVector.compare(VectorOperators.Comparison op, Vector<Integer> v, VectorMask<Integer> m) Tests this vector by comparing it with another input vector, according to the given comparison operation, in lanes selected by a mask.abstract VectorMask<Long>LongVector.compare(VectorOperators.Comparison op, long e) Tests this vector by comparing it with an input scalar, according to the given comparison operation.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.final VectorMask<Long>LongVector.compare(VectorOperators.Comparison op, Vector<Long> v, VectorMask<Long> m) Tests this vector by comparing it with another input vector, according to the given comparison operation, in lanes selected by a mask.abstract VectorMask<Short>ShortVector.compare(VectorOperators.Comparison op, long e) Tests this vector by comparing it with an input scalar, according to the given comparison operation.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.final VectorMask<Short>ShortVector.compare(VectorOperators.Comparison op, Vector<Short> v, VectorMask<Short> m) Tests this vector by comparing it with another input vector, according to the given comparison operation, in lanes selected by a mask.abstract VectorMask<E>Vector.compare(VectorOperators.Comparison op, long e) Tests this vector by comparing it with an input scalar, according to the given comparison operation.abstract VectorMask<E>Vector.compare(VectorOperators.Comparison op, long e, VectorMask<E> m) Tests this vector by comparing it with an input scalar, according to the given comparison operation, in lanes selected by a mask.abstract VectorMask<E>Vector.compare(VectorOperators.Comparison op, Vector<E> v) Tests this vector by comparing it with another input vector, according to the given comparison operation.abstract VectorMask<E>Vector.compare(VectorOperators.Comparison op, Vector<E> v, VectorMask<E> m) Tests this vector by comparing it with another input vector, according to the given comparison operation, in lanes selected by a mask.final VectorMask<Byte>ByteVector.eq(byte e) Tests if this vector is equal to an input scalar.final VectorMask<Byte>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>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>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>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>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>Tests if this vector is equal to another input vector.abstract VectorMask<E>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 booleana==bora^~b).static <E> VectorMask<E>VectorMask.fromArray(VectorSpecies<E> species, boolean[] bits, int offset) Loads a mask from abooleanarray 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 givenbooleanvalues.abstract VectorMask<E>VectorMask.indexInRange(int offset, int limit) Removes lanes numberedNfrom this mask where the adjusted indexN+offset, is not in the range[0..limit-1].VectorSpecies.indexInRange(int offset, int limit) Returns a mask of this species where only the lanes at index N such that the adjusted indexN+offsetis 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.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>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>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>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>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>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>Tests if this vector is less than another input vector.abstract VectorMask<E>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.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 (asa|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.final 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.final 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.final 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.final 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.final 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.final VectorMask<Short>ShortVector.test(VectorOperators.Test op, VectorMask<Short> m) Test selected lanes of this vector, according to the given operation.abstract VectorMask<E>Vector.test(VectorOperators.Test op) Tests the lanes of this vector according to the given operation.abstract VectorMask<E>Vector.test(VectorOperators.Test op, VectorMask<E> m) Test selected lanes of this vector, according to the given operation.Methods in jdk.incubator.vector that return types with arguments of type VectorMaskModifier and TypeMethodDescriptionClass<? extends VectorMask<E>>VectorSpecies.maskType()Returns the vector mask type for this species.Methods in jdk.incubator.vector with parameters of type VectorMaskModifier and TypeMethodDescriptionfinal ByteVectorByteVector.add(byte e, VectorMask<Byte> m) Adds this vector to the broadcast of an input scalar, selecting lane elements controlled by a mask.final ByteVectorByteVector.add(Vector<Byte> v, VectorMask<Byte> m) Adds this vector to a second input vector, selecting lanes under the control of a mask.final DoubleVectorDoubleVector.add(double e, VectorMask<Double> m) Adds this vector to the broadcast of an input scalar, selecting lane elements controlled by a mask.final DoubleVectorDoubleVector.add(Vector<Double> v, VectorMask<Double> m) Adds this vector to a second input vector, selecting lanes under the control of a mask.final FloatVectorFloatVector.add(float e, VectorMask<Float> m) Adds this vector to the broadcast of an input scalar, selecting lane elements controlled by a mask.final FloatVectorFloatVector.add(Vector<Float> v, VectorMask<Float> m) Adds this vector to a second input vector, selecting lanes under the control of a mask.final IntVectorIntVector.add(int e, VectorMask<Integer> m) Adds this vector to the broadcast of an input scalar, selecting lane elements controlled by a mask.final IntVectorIntVector.add(Vector<Integer> v, VectorMask<Integer> m) Adds this vector to a second input vector, selecting lanes under the control of a mask.final LongVectorLongVector.add(long e, VectorMask<Long> m) Adds this vector to the broadcast of an input scalar, selecting lane elements controlled by a mask.final LongVectorLongVector.add(Vector<Long> v, VectorMask<Long> m) Adds this vector to a second input vector, selecting lanes under the control of a mask.final ShortVectorShortVector.add(short e, VectorMask<Short> m) Adds this vector to the broadcast of an input scalar, selecting lane elements controlled by a mask.final ShortVectorShortVector.add(Vector<Short> v, VectorMask<Short> m) Adds this vector to a second input vector, selecting lanes under the control of a mask.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 (asa&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 (asa&~b).final ByteVectorByteVector.blend(byte e, VectorMask<Byte> m) Replaces selected lanes of this vector with a scalar value under the control of a mask.final ByteVectorByteVector.blend(long e, VectorMask<Byte> m) Replaces selected lanes of this vector with a scalar value under the control of a mask.abstract ByteVectorByteVector.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 DoubleVectorDoubleVector.blend(double e, VectorMask<Double> m) Replaces selected lanes of this vector with a scalar value under the control of a mask.final DoubleVectorDoubleVector.blend(long e, VectorMask<Double> m) Replaces selected lanes of this vector with a scalar value under the control of a mask.abstract DoubleVectorDoubleVector.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 FloatVectorFloatVector.blend(float e, VectorMask<Float> m) Replaces selected lanes of this vector with a scalar value under the control of a mask.final FloatVectorFloatVector.blend(long e, VectorMask<Float> m) Replaces selected lanes of this vector with a scalar value under the control of a mask.abstract FloatVectorFloatVector.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 IntVectorIntVector.blend(int e, VectorMask<Integer> m) Replaces selected lanes of this vector with a scalar value under the control of a mask.final IntVectorIntVector.blend(long e, VectorMask<Integer> m) Replaces selected lanes of this vector with a scalar value under the control of a mask.abstract IntVectorIntVector.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 LongVectorLongVector.blend(long e, VectorMask<Long> m) Replaces selected lanes of this vector with a scalar value under the control of a mask.abstract LongVectorLongVector.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 ShortVectorShortVector.blend(long e, VectorMask<Short> m) Replaces selected lanes of this vector with a scalar value under the control of a mask.final ShortVectorShortVector.blend(short e, VectorMask<Short> m) Replaces selected lanes of this vector with a scalar value under the control of a mask.abstract ShortVectorShortVector.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.Vector.blend(long e, VectorMask<E> m) Replaces selected lanes of this vector with a scalar value under the control of a mask.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<Byte>ByteVector.compare(VectorOperators.Comparison op, Vector<Byte> v, VectorMask<Byte> m) Tests this vector by comparing it with another input vector, according to the given comparison operation, in lanes selected by a mask.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<Double>DoubleVector.compare(VectorOperators.Comparison op, Vector<Double> v, VectorMask<Double> m) Tests this vector by comparing it with another input vector, according to the given comparison operation, in lanes selected by a mask.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<Float>FloatVector.compare(VectorOperators.Comparison op, Vector<Float> v, VectorMask<Float> m) Tests this vector by comparing it with another input vector, according to the given comparison operation, in lanes selected by a mask.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<Integer>IntVector.compare(VectorOperators.Comparison op, Vector<Integer> v, VectorMask<Integer> m) Tests this vector by comparing it with another input vector, according to the given comparison operation, in lanes selected by a mask.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<Long>LongVector.compare(VectorOperators.Comparison op, Vector<Long> v, VectorMask<Long> m) Tests this vector by comparing it with another input vector, according to the given comparison operation, in lanes selected by a mask.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.final VectorMask<Short>ShortVector.compare(VectorOperators.Comparison op, Vector<Short> v, VectorMask<Short> m) Tests this vector by comparing it with another input vector, according to the given comparison operation, in lanes selected by a mask.abstract VectorMask<E>Vector.compare(VectorOperators.Comparison op, long e, VectorMask<E> m) Tests this vector by comparing it with an input scalar, according to the given comparison operation, in lanes selected by a mask.abstract VectorMask<E>Vector.compare(VectorOperators.Comparison op, Vector<E> v, VectorMask<E> m) Tests this vector by comparing it with another input vector, according to the given comparison operation, in lanes selected by a mask.final ByteVectorByteVector.div(byte e, VectorMask<Byte> m) Divides this vector by the broadcast of an input scalar, selecting lane elements controlled by a mask.final ByteVectorByteVector.div(Vector<Byte> v, VectorMask<Byte> m) Divides this vector by a second input vector under the control of a mask.final DoubleVectorDoubleVector.div(double e, VectorMask<Double> m) Divides this vector by the broadcast of an input scalar, selecting lane elements controlled by a mask.final DoubleVectorDoubleVector.div(Vector<Double> v, VectorMask<Double> m) Divides this vector by a second input vector under the control of a mask.final FloatVectorFloatVector.div(float e, VectorMask<Float> m) Divides this vector by the broadcast of an input scalar, selecting lane elements controlled by a mask.final FloatVectorFloatVector.div(Vector<Float> v, VectorMask<Float> m) Divides this vector by a second input vector under the control of a mask.final IntVectorIntVector.div(int e, VectorMask<Integer> m) Divides this vector by the broadcast of an input scalar, selecting lane elements controlled by a mask.final IntVectorIntVector.div(Vector<Integer> v, VectorMask<Integer> m) Divides this vector by a second input vector under the control of a mask.final LongVectorLongVector.div(long e, VectorMask<Long> m) Divides this vector by the broadcast of an input scalar, selecting lane elements controlled by a mask.final LongVectorLongVector.div(Vector<Long> v, VectorMask<Long> m) Divides this vector by a second input vector under the control of a mask.final ShortVectorShortVector.div(short e, VectorMask<Short> m) Divides this vector by the broadcast of an input scalar, selecting lane elements controlled by a mask.final ShortVectorShortVector.div(Vector<Short> v, VectorMask<Short> m) Divides this vector by a second input vector under the control of a mask.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 booleana==bora^~b).static ByteVectorByteVector.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 typebyte[], under the control of a mask, and using indexes obtained by adding a fixedoffsetto a series of secondary offsets from an index map.static ByteVectorByteVector.fromArray(VectorSpecies<Byte> species, byte[] a, int offset, VectorMask<Byte> m) Loads a vector from an array of typebyte[]starting at an offset and using a mask.static DoubleVectorDoubleVector.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 typedouble[], under the control of a mask, and using indexes obtained by adding a fixedoffsetto a series of secondary offsets from an index map.static DoubleVectorDoubleVector.fromArray(VectorSpecies<Double> species, double[] a, int offset, VectorMask<Double> m) Loads a vector from an array of typedouble[]starting at an offset and using a mask.static FloatVectorFloatVector.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 typefloat[], under the control of a mask, and using indexes obtained by adding a fixedoffsetto a series of secondary offsets from an index map.static FloatVectorFloatVector.fromArray(VectorSpecies<Float> species, float[] a, int offset, VectorMask<Float> m) Loads a vector from an array of typefloat[]starting at an offset and using a mask.static IntVectorIntVector.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 typeint[], under the control of a mask, and using indexes obtained by adding a fixedoffsetto a series of secondary offsets from an index map.static IntVectorIntVector.fromArray(VectorSpecies<Integer> species, int[] a, int offset, VectorMask<Integer> m) Loads a vector from an array of typeint[]starting at an offset and using a mask.static LongVectorLongVector.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 typelong[], under the control of a mask, and using indexes obtained by adding a fixedoffsetto a series of secondary offsets from an index map.static LongVectorLongVector.fromArray(VectorSpecies<Long> species, long[] a, int offset, VectorMask<Long> m) Loads a vector from an array of typelong[]starting at an offset and using a mask.static ShortVectorShortVector.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 typeshort[], under the control of a mask, and using indexes obtained by adding a fixedoffsetto a series of secondary offsets from an index map.static ShortVectorShortVector.fromArray(VectorSpecies<Short> species, short[] a, int offset, VectorMask<Short> m) Loads a vector from an array of typeshort[]starting at an offset and using a mask.static ByteVectorByteVector.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 typeboolean[], under the control of a mask, and using indexes obtained by adding a fixedoffsetto a series of secondary offsets from an index map.static ByteVectorByteVector.fromBooleanArray(VectorSpecies<Byte> species, boolean[] a, int offset, VectorMask<Byte> m) Loads a vector from an array of typeboolean[]starting at an offset and using a mask.static ByteVectorByteVector.fromByteArray(VectorSpecies<Byte> species, byte[] a, int offset, ByteOrder bo, VectorMask<Byte> m) Loads a vector from a byte array starting at an offset and using a mask.static DoubleVectorDoubleVector.fromByteArray(VectorSpecies<Double> species, byte[] a, int offset, ByteOrder bo, VectorMask<Double> m) Loads a vector from a byte array starting at an offset and using a mask.static FloatVectorFloatVector.fromByteArray(VectorSpecies<Float> species, byte[] a, int offset, ByteOrder bo, VectorMask<Float> m) Loads a vector from a byte array starting at an offset and using a mask.static IntVectorIntVector.fromByteArray(VectorSpecies<Integer> species, byte[] a, int offset, ByteOrder bo, VectorMask<Integer> m) Loads a vector from a byte array starting at an offset and using a mask.static LongVectorLongVector.fromByteArray(VectorSpecies<Long> species, byte[] a, int offset, ByteOrder bo, VectorMask<Long> m) Loads a vector from a byte array starting at an offset and using a mask.static ShortVectorShortVector.fromByteArray(VectorSpecies<Short> species, byte[] a, int offset, ByteOrder bo, VectorMask<Short> m) Loads a vector from a byte array starting at an offset and using a mask.static ByteVectorByteVector.fromByteBuffer(VectorSpecies<Byte> species, ByteBuffer bb, int offset, ByteOrder bo, VectorMask<Byte> m) Loads a vector from a byte buffer starting at an offset into the byte buffer and using a mask.static DoubleVectorDoubleVector.fromByteBuffer(VectorSpecies<Double> species, ByteBuffer bb, int offset, ByteOrder bo, VectorMask<Double> m) Loads a vector from a byte buffer starting at an offset into the byte buffer and using a mask.static FloatVectorFloatVector.fromByteBuffer(VectorSpecies<Float> species, ByteBuffer bb, int offset, ByteOrder bo, VectorMask<Float> m) Loads a vector from a byte buffer starting at an offset into the byte buffer and using a mask.static IntVectorIntVector.fromByteBuffer(VectorSpecies<Integer> species, ByteBuffer bb, int offset, ByteOrder bo, VectorMask<Integer> m) Loads a vector from a byte buffer starting at an offset into the byte buffer and using a mask.static LongVectorLongVector.fromByteBuffer(VectorSpecies<Long> species, ByteBuffer bb, int offset, ByteOrder bo, VectorMask<Long> m) Loads a vector from a byte buffer starting at an offset into the byte buffer and using a mask.static ShortVectorShortVector.fromByteBuffer(VectorSpecies<Short> species, ByteBuffer bb, int offset, ByteOrder bo, VectorMask<Short> m) Loads a vector from a byte buffer starting at an offset into the byte buffer and using a mask.static ShortVectorShortVector.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 typechar[], under the control of a mask, and using indexes obtained by adding a fixedoffsetto a series of secondary offsets from an index map.static ShortVectorShortVector.fromCharArray(VectorSpecies<Short> species, char[] a, int offset, VectorMask<Short> m) Loads a vector from an array of typechar[]starting at an offset and using a mask.final voidByteVector.intoArray(byte[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Byte> m) Scatters this vector into an array of typebyte[], under the control of a mask, and using indexes obtained by adding a fixedoffsetto a series of secondary offsets from an index map.final voidByteVector.intoArray(byte[] a, int offset, VectorMask<Byte> m) Stores this vector into an array of typebyte[]starting at offset and using a mask.final voidDoubleVector.intoArray(double[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Double> m) Scatters this vector into an array of typedouble[], under the control of a mask, and using indexes obtained by adding a fixedoffsetto a series of secondary offsets from an index map.final voidDoubleVector.intoArray(double[] a, int offset, VectorMask<Double> m) Stores this vector into an array of typedouble[]starting at offset and using a mask.final voidFloatVector.intoArray(float[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Float> m) Scatters this vector into an array of typefloat[], under the control of a mask, and using indexes obtained by adding a fixedoffsetto a series of secondary offsets from an index map.final voidFloatVector.intoArray(float[] a, int offset, VectorMask<Float> m) Stores this vector into an array of typefloat[]starting at offset and using a mask.final voidIntVector.intoArray(int[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Integer> m) Scatters this vector into an array of typeint[], under the control of a mask, and using indexes obtained by adding a fixedoffsetto a series of secondary offsets from an index map.final voidIntVector.intoArray(int[] a, int offset, VectorMask<Integer> m) Stores this vector into an array of typeint[]starting at offset and using a mask.final voidLongVector.intoArray(long[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Long> m) Scatters this vector into an array of typelong[], under the control of a mask, and using indexes obtained by adding a fixedoffsetto a series of secondary offsets from an index map.final voidLongVector.intoArray(long[] a, int offset, VectorMask<Long> m) Stores this vector into an array of typelong[]starting at offset and using a mask.final voidShortVector.intoArray(short[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Short> m) Scatters this vector into an array of typeshort[], under the control of a mask, and using indexes obtained by adding a fixedoffsetto a series of secondary offsets from an index map.final voidShortVector.intoArray(short[] a, int offset, VectorMask<Short> m) Stores this vector into an array of typeshort[]starting at offset and using a mask.final voidByteVector.intoBooleanArray(boolean[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Byte> m) Scatters this vector into an array of typeboolean[], under the control of a mask, and using indexes obtained by adding a fixedoffsetto a series of secondary offsets from an index map.final voidByteVector.intoBooleanArray(boolean[] a, int offset, VectorMask<Byte> m) Stores this vector into an array of typeboolean[]starting at offset and using a mask.final voidByteVector.intoByteArray(byte[] a, int offset, ByteOrder bo, VectorMask<Byte> m) Stores this vector into a byte array starting at an offset using explicit byte order and a mask.final voidDoubleVector.intoByteArray(byte[] a, int offset, ByteOrder bo, VectorMask<Double> m) Stores this vector into a byte array starting at an offset using explicit byte order and a mask.final voidFloatVector.intoByteArray(byte[] a, int offset, ByteOrder bo, VectorMask<Float> m) Stores this vector into a byte array starting at an offset using explicit byte order and a mask.final voidIntVector.intoByteArray(byte[] a, int offset, ByteOrder bo, VectorMask<Integer> m) Stores this vector into a byte array starting at an offset using explicit byte order and a mask.final voidLongVector.intoByteArray(byte[] a, int offset, ByteOrder bo, VectorMask<Long> m) Stores this vector into a byte array starting at an offset using explicit byte order and a mask.final voidShortVector.intoByteArray(byte[] a, int offset, ByteOrder bo, VectorMask<Short> m) Stores this vector into a byte array starting at an offset using explicit byte order and a mask.abstract voidVector.intoByteArray(byte[] a, int offset, ByteOrder bo, VectorMask<E> m) Stores this vector into a byte array starting at an offset using explicit byte order and a mask.final voidByteVector.intoByteBuffer(ByteBuffer bb, int offset, ByteOrder bo, VectorMask<Byte> m) Stores this vector into a byte buffer starting at an offset using explicit byte order and a mask.final voidDoubleVector.intoByteBuffer(ByteBuffer bb, int offset, ByteOrder bo, VectorMask<Double> m) Stores this vector into a byte buffer starting at an offset using explicit byte order and a mask.final voidFloatVector.intoByteBuffer(ByteBuffer bb, int offset, ByteOrder bo, VectorMask<Float> m) Stores this vector into a byte buffer starting at an offset using explicit byte order and a mask.final voidIntVector.intoByteBuffer(ByteBuffer bb, int offset, ByteOrder bo, VectorMask<Integer> m) Stores this vector into a byte buffer starting at an offset using explicit byte order and a mask.final voidLongVector.intoByteBuffer(ByteBuffer bb, int offset, ByteOrder bo, VectorMask<Long> m) Stores this vector into a byte buffer starting at an offset using explicit byte order and a mask.final voidShortVector.intoByteBuffer(ByteBuffer bb, int offset, ByteOrder bo, VectorMask<Short> m) Stores this vector into a byte buffer starting at an offset using explicit byte order and a mask.abstract voidVector.intoByteBuffer(ByteBuffer bb, int offset, ByteOrder bo, VectorMask<E> m) Stores this vector into a byte buffer starting at an offset using explicit byte order and a mask.final voidShortVector.intoCharArray(char[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Short> m) Scatters this vector into an array of typechar[], under the control of a mask, and using indexes obtained by adding a fixedoffsetto a series of secondary offsets from an index map.final voidShortVector.intoCharArray(char[] a, int offset, VectorMask<Short> m) Stores this vector into an array of typechar[]starting at offset and using a mask.final ByteVectorByteVector.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 ByteVectorByteVector.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.final ByteVectorByteVector.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 ByteVectorByteVector.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 ByteVectorByteVector.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 ByteVectorByteVector.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.final ByteVectorByteVector.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.final ByteVectorByteVector.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 DoubleVectorDoubleVector.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 DoubleVectorDoubleVector.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.final DoubleVectorDoubleVector.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 DoubleVectorDoubleVector.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 DoubleVectorDoubleVector.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 DoubleVectorDoubleVector.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.final DoubleVectorDoubleVector.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.final DoubleVectorDoubleVector.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 FloatVectorFloatVector.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 FloatVectorFloatVector.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.final FloatVectorFloatVector.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 FloatVectorFloatVector.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 FloatVectorFloatVector.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 FloatVectorFloatVector.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.final FloatVectorFloatVector.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.final FloatVectorFloatVector.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 IntVectorIntVector.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 IntVectorIntVector.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.final IntVectorIntVector.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 IntVectorIntVector.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 IntVectorIntVector.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 IntVectorIntVector.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.final IntVectorIntVector.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.final IntVectorIntVector.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 LongVectorLongVector.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.final LongVectorLongVector.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 LongVectorLongVector.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 LongVectorLongVector.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 LongVectorLongVector.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.final LongVectorLongVector.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.final LongVectorLongVector.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 ShortVectorShortVector.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 ShortVectorShortVector.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.final ShortVectorShortVector.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 ShortVectorShortVector.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 ShortVectorShortVector.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 ShortVectorShortVector.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.final ShortVectorShortVector.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.final ShortVectorShortVector.lanewise(VectorOperators.Unary op, VectorMask<Short> m) Operates on the lane values of this vector, with selection of lane elements controlled by a mask.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.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.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.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 ByteVectorByteVector.mul(byte e, VectorMask<Byte> m) Multiplies this vector by the broadcast of an input scalar, selecting lane elements controlled by a mask.final ByteVectorByteVector.mul(Vector<Byte> v, VectorMask<Byte> m) Multiplies this vector by a second input vector under the control of a mask.final DoubleVectorDoubleVector.mul(double e, VectorMask<Double> m) Multiplies this vector by the broadcast of an input scalar, selecting lane elements controlled by a mask.final DoubleVectorDoubleVector.mul(Vector<Double> v, VectorMask<Double> m) Multiplies this vector by a second input vector under the control of a mask.final FloatVectorFloatVector.mul(float e, VectorMask<Float> m) Multiplies this vector by the broadcast of an input scalar, selecting lane elements controlled by a mask.final FloatVectorFloatVector.mul(Vector<Float> v, VectorMask<Float> m) Multiplies this vector by a second input vector under the control of a mask.final IntVectorIntVector.mul(int e, VectorMask<Integer> m) Multiplies this vector by the broadcast of an input scalar, selecting lane elements controlled by a mask.final IntVectorIntVector.mul(Vector<Integer> v, VectorMask<Integer> m) Multiplies this vector by a second input vector under the control of a mask.final LongVectorLongVector.mul(long e, VectorMask<Long> m) Multiplies this vector by the broadcast of an input scalar, selecting lane elements controlled by a mask.final LongVectorLongVector.mul(Vector<Long> v, VectorMask<Long> m) Multiplies this vector by a second input vector under the control of a mask.final ShortVectorShortVector.mul(short e, VectorMask<Short> m) Multiplies this vector by the broadcast of an input scalar, selecting lane elements controlled by a mask.final ShortVectorShortVector.mul(Vector<Short> v, VectorMask<Short> m) Multiplies this vector by a second input vector under the control of a mask.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 (asa|b) of this mask and a second input mask.abstract ByteVectorByteVector.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 DoubleVectorDoubleVector.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 FloatVectorFloatVector.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 IntVectorIntVector.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 LongVectorLongVector.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 ShortVectorShortVector.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.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 byteByteVector.reduceLanes(VectorOperators.Associative op, VectorMask<Byte> m) Returns a value accumulated from selected lanes of this vector, controlled by a mask.abstract doubleDoubleVector.reduceLanes(VectorOperators.Associative op, VectorMask<Double> m) Returns a value accumulated from selected lanes of this vector, controlled by a mask.abstract floatFloatVector.reduceLanes(VectorOperators.Associative op, VectorMask<Float> m) Returns a value accumulated from selected lanes of this vector, controlled by a mask.abstract intIntVector.reduceLanes(VectorOperators.Associative op, VectorMask<Integer> m) Returns a value accumulated from selected lanes of this vector, controlled by a mask.abstract longLongVector.reduceLanes(VectorOperators.Associative op, VectorMask<Long> m) Returns a value accumulated from selected lanes of this vector, controlled by a mask.abstract shortShortVector.reduceLanes(VectorOperators.Associative op, VectorMask<Short> m) Returns a value accumulated from selected lanes of this vector, controlled by a mask.abstract longVector.reduceLanesToLong(VectorOperators.Associative op, VectorMask<E> m) Returns a value accumulated from selected lanes of this vector, controlled by a mask.abstract ByteVectorByteVector.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 DoubleVectorDoubleVector.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 FloatVectorFloatVector.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 IntVectorIntVector.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 LongVectorLongVector.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 ShortVectorShortVector.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.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 ByteVectorByteVector.slice(int origin, Vector<Byte> w, VectorMask<Byte> m) Slices a segment of adjacent lanes under the control of a mask, starting at a givenoriginlane in the current vector, and continuing (as needed) into an immediately following vector.final DoubleVectorDoubleVector.slice(int origin, Vector<Double> w, VectorMask<Double> m) Slices a segment of adjacent lanes under the control of a mask, starting at a givenoriginlane in the current vector, and continuing (as needed) into an immediately following vector.final FloatVectorFloatVector.slice(int origin, Vector<Float> w, VectorMask<Float> m) Slices a segment of adjacent lanes under the control of a mask, starting at a givenoriginlane in the current vector, and continuing (as needed) into an immediately following vector.final IntVectorIntVector.slice(int origin, Vector<Integer> w, VectorMask<Integer> m) Slices a segment of adjacent lanes under the control of a mask, starting at a givenoriginlane in the current vector, and continuing (as needed) into an immediately following vector.final LongVectorLongVector.slice(int origin, Vector<Long> w, VectorMask<Long> m) Slices a segment of adjacent lanes under the control of a mask, starting at a givenoriginlane in the current vector, and continuing (as needed) into an immediately following vector.final ShortVectorShortVector.slice(int origin, Vector<Short> w, VectorMask<Short> m) Slices a segment of adjacent lanes under the control of a mask, starting at a givenoriginlane in the current vector, and continuing (as needed) into an immediately following vector.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 givenoriginlane in the current vector, and continuing (as needed) into an immediately following vector.final ByteVectorByteVector.sub(byte e, VectorMask<Byte> m) Subtracts an input scalar from this vector under the control of a mask.final ByteVectorByteVector.sub(Vector<Byte> v, VectorMask<Byte> m) Subtracts a second input vector from this vector under the control of a mask.final DoubleVectorDoubleVector.sub(double e, VectorMask<Double> m) Subtracts an input scalar from this vector under the control of a mask.final DoubleVectorDoubleVector.sub(Vector<Double> v, VectorMask<Double> m) Subtracts a second input vector from this vector under the control of a mask.final FloatVectorFloatVector.sub(float e, VectorMask<Float> m) Subtracts an input scalar from this vector under the control of a mask.final FloatVectorFloatVector.sub(Vector<Float> v, VectorMask<Float> m) Subtracts a second input vector from this vector under the control of a mask.final IntVectorIntVector.sub(int e, VectorMask<Integer> m) Subtracts an input scalar from this vector under the control of a mask.final IntVectorIntVector.sub(Vector<Integer> v, VectorMask<Integer> m) Subtracts a second input vector from this vector under the control of a mask.final LongVectorLongVector.sub(long e, VectorMask<Long> m) Subtracts an input scalar from this vector under the control of a mask.final LongVectorLongVector.sub(Vector<Long> v, VectorMask<Long> m) Subtracts a second input vector from this vector under the control of a mask.final ShortVectorShortVector.sub(short e, VectorMask<Short> m) Subtracts an input scalar from this vector under the control of a mask.final ShortVectorShortVector.sub(Vector<Short> v, VectorMask<Short> m) Subtracts a second input vector from this vector under the control of a mask.Vector.sub(Vector<E> v, VectorMask<E> m) Subtracts a second input vector from this vector under the control of a mask.final VectorMask<Byte>ByteVector.test(VectorOperators.Test op, VectorMask<Byte> m) Test selected lanes of this vector, according to the given operation.final VectorMask<Double>DoubleVector.test(VectorOperators.Test op, VectorMask<Double> m) Test selected lanes of this vector, according to the given operation.final VectorMask<Float>FloatVector.test(VectorOperators.Test op, VectorMask<Float> m) Test selected lanes of this vector, according to the given operation.final VectorMask<Integer>IntVector.test(VectorOperators.Test op, VectorMask<Integer> m) Test selected lanes of this vector, according to the given operation.final VectorMask<Long>LongVector.test(VectorOperators.Test op, VectorMask<Long> m) Test selected lanes of this vector, according to the given operation.final 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 ByteVectorByteVector.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 subsequentslice()operation.abstract DoubleVectorDoubleVector.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 subsequentslice()operation.abstract FloatVectorFloatVector.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 subsequentslice()operation.abstract IntVectorIntVector.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 subsequentslice()operation.abstract LongVectorLongVector.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 subsequentslice()operation.abstract ShortVectorShortVector.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 subsequentslice()operation.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 subsequentslice()operation.