ByteVector |
ByteVector.add(Vector<Byte> v) |
Adds this vector to a second input vector.
|
ByteVector |
ByteVector.add(Vector<Byte> v,
VectorMask<Byte> m) |
Adds this vector to a second input vector, selecting lanes
under the control of a mask.
|
DoubleVector |
DoubleVector.add(Vector<Double> v) |
Adds this vector to a second input vector.
|
DoubleVector |
DoubleVector.add(Vector<Double> v,
VectorMask<Double> m) |
Adds this vector to a second input vector, selecting lanes
under the control of a mask.
|
FloatVector |
FloatVector.add(Vector<Float> v) |
Adds this vector to a second input vector.
|
FloatVector |
FloatVector.add(Vector<Float> v,
VectorMask<Float> m) |
Adds this vector to a second input vector, selecting lanes
under the control of a mask.
|
IntVector |
IntVector.add(Vector<Integer> v) |
Adds this vector to a second input vector.
|
IntVector |
IntVector.add(Vector<Integer> v,
VectorMask<Integer> m) |
Adds this vector to a second input vector, selecting lanes
under the control of a mask.
|
LongVector |
LongVector.add(Vector<Long> v) |
Adds this vector to a second input vector.
|
LongVector |
LongVector.add(Vector<Long> v,
VectorMask<Long> m) |
Adds this vector to a second input vector, selecting lanes
under the control of a mask.
|
ShortVector |
ShortVector.add(Vector<Short> v) |
Adds this vector to a second input vector.
|
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) |
Adds this vector to a second input vector.
|
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.
|
ByteVector |
ByteVector.and(Vector<Byte> v) |
Computes the bitwise logical conjunction (& )
of this vector and a second input vector.
|
IntVector |
IntVector.and(Vector<Integer> v) |
Computes the bitwise logical conjunction (& )
of this vector and a second input vector.
|
LongVector |
LongVector.and(Vector<Long> v) |
Computes the bitwise logical conjunction (& )
of this vector and a second input vector.
|
ShortVector |
ShortVector.and(Vector<Short> v) |
Computes the bitwise logical conjunction (& )
of this vector and a second input vector.
|
ByteVector |
ByteVector.bitwiseBlend(byte bits,
Vector<Byte> mask) |
Blends together the bits of a vector and a scalar under
the control of another vector, which supplies mask bits.
|
ByteVector |
ByteVector.bitwiseBlend(Vector<Byte> bits,
byte mask) |
Blends together the bits of two vectors under
the control of a scalar, which supplies mask bits.
|
ByteVector |
ByteVector.bitwiseBlend(Vector<Byte> bits,
Vector<Byte> mask) |
Blends together the bits of two vectors under
the control of a third, which supplies mask bits.
|
IntVector |
IntVector.bitwiseBlend(int bits,
Vector<Integer> mask) |
Blends together the bits of a vector and a scalar under
the control of another vector, which supplies mask bits.
|
IntVector |
IntVector.bitwiseBlend(Vector<Integer> bits,
int mask) |
Blends together the bits of two vectors under
the control of a scalar, which supplies mask bits.
|
IntVector |
IntVector.bitwiseBlend(Vector<Integer> bits,
Vector<Integer> mask) |
Blends together the bits of two vectors under
the control of a third, which supplies mask bits.
|
LongVector |
LongVector.bitwiseBlend(long bits,
Vector<Long> mask) |
Blends together the bits of a vector and a scalar under
the control of another vector, which supplies mask bits.
|
LongVector |
LongVector.bitwiseBlend(Vector<Long> bits,
long mask) |
Blends together the bits of two vectors under
the control of a scalar, which supplies mask bits.
|
LongVector |
LongVector.bitwiseBlend(Vector<Long> bits,
Vector<Long> mask) |
Blends together the bits of two vectors under
the control of a third, which supplies mask bits.
|
ShortVector |
ShortVector.bitwiseBlend(short bits,
Vector<Short> mask) |
Blends together the bits of a vector and a scalar under
the control of another vector, which supplies mask bits.
|
ShortVector |
ShortVector.bitwiseBlend(Vector<Short> bits,
short mask) |
Blends together the bits of two vectors under
the control of a scalar, which supplies mask bits.
|
ShortVector |
ShortVector.bitwiseBlend(Vector<Short> bits,
Vector<Short> mask) |
Blends together the bits of two vectors under
the control of a third, which supplies mask bits.
|
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.
|
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.
|
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.
|
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.
|
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.
|
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(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.
|
abstract VectorMask<Byte> |
ByteVector.compare(VectorOperators.Comparison op,
Vector<Byte> v) |
Tests this vector by comparing it with another input vector,
according to the given comparison operation.
|
VectorMask<Byte> |
ByteVector.compare(VectorOperators.Comparison op,
Vector<Byte> v,
VectorMask<Byte> m) |
Tests this vector by comparing it with another input vector,
according to the given comparison operation,
in lanes selected by a mask.
|
abstract VectorMask<Double> |
DoubleVector.compare(VectorOperators.Comparison op,
Vector<Double> v) |
Tests this vector by comparing it with another input vector,
according to the given comparison operation.
|
VectorMask<Double> |
DoubleVector.compare(VectorOperators.Comparison op,
Vector<Double> v,
VectorMask<Double> m) |
Tests this vector by comparing it with another input vector,
according to the given comparison operation,
in lanes selected by a mask.
|
abstract VectorMask<Float> |
FloatVector.compare(VectorOperators.Comparison op,
Vector<Float> v) |
Tests this vector by comparing it with another input vector,
according to the given comparison operation.
|
VectorMask<Float> |
FloatVector.compare(VectorOperators.Comparison op,
Vector<Float> v,
VectorMask<Float> m) |
Tests this vector by comparing it with another input vector,
according to the given comparison operation,
in lanes selected by a mask.
|
abstract VectorMask<Integer> |
IntVector.compare(VectorOperators.Comparison op,
Vector<Integer> v) |
Tests this vector by comparing it with another input vector,
according to the given comparison operation.
|
VectorMask<Integer> |
IntVector.compare(VectorOperators.Comparison op,
Vector<Integer> v,
VectorMask<Integer> m) |
Tests this vector by comparing it with another input vector,
according to the given comparison operation,
in lanes selected by a mask.
|
abstract VectorMask<Long> |
LongVector.compare(VectorOperators.Comparison op,
Vector<Long> v) |
Tests this vector by comparing it with another input vector,
according to the given comparison operation.
|
VectorMask<Long> |
LongVector.compare(VectorOperators.Comparison op,
Vector<Long> v,
VectorMask<Long> m) |
Tests this vector by comparing it with another input vector,
according to the given comparison operation,
in lanes selected by a mask.
|
abstract VectorMask<Short> |
ShortVector.compare(VectorOperators.Comparison op,
Vector<Short> v) |
Tests this vector by comparing it with another input vector,
according to the given comparison operation.
|
VectorMask<Short> |
ShortVector.compare(VectorOperators.Comparison op,
Vector<Short> v,
VectorMask<Short> m) |
Tests this vector by comparing it with another input vector,
according to the given comparison operation,
in lanes selected by a mask.
|
abstract VectorMask<E> |
Vector.compare(VectorOperators.Comparison op,
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.
|
ByteVector |
ByteVector.div(Vector<Byte> v) |
Divides this vector by a second input vector.
|
ByteVector |
ByteVector.div(Vector<Byte> v,
VectorMask<Byte> m) |
Divides this vector by a second input vector
under the control of a mask.
|
DoubleVector |
DoubleVector.div(Vector<Double> v) |
Divides this vector by a second input vector.
|
DoubleVector |
DoubleVector.div(Vector<Double> v,
VectorMask<Double> m) |
Divides this vector by a second input vector
under the control of a mask.
|
FloatVector |
FloatVector.div(Vector<Float> v) |
Divides this vector by a second input vector.
|
FloatVector |
FloatVector.div(Vector<Float> v,
VectorMask<Float> m) |
Divides this vector by a second input vector
under the control of a mask.
|
IntVector |
IntVector.div(Vector<Integer> v) |
Divides this vector by a second input vector.
|
IntVector |
IntVector.div(Vector<Integer> v,
VectorMask<Integer> m) |
Divides this vector by a second input vector
under the control of a mask.
|
LongVector |
LongVector.div(Vector<Long> v) |
Divides this vector by a second input vector.
|
LongVector |
LongVector.div(Vector<Long> v,
VectorMask<Long> m) |
Divides this vector by a second input vector
under the control of a mask.
|
ShortVector |
ShortVector.div(Vector<Short> v) |
Divides this vector by a second input vector.
|
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) |
Divides this vector by a second input vector.
|
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.
|
VectorMask<Byte> |
ByteVector.eq(Vector<Byte> v) |
Tests if this vector is equal to another input vector.
|
VectorMask<Double> |
DoubleVector.eq(Vector<Double> v) |
Tests if this vector is equal to another input vector.
|
VectorMask<Float> |
FloatVector.eq(Vector<Float> v) |
Tests if this vector is equal to another input vector.
|
VectorMask<Integer> |
IntVector.eq(Vector<Integer> v) |
Tests if this vector is equal to another input vector.
|
VectorMask<Long> |
LongVector.eq(Vector<Long> v) |
Tests if this vector is equal to another input vector.
|
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.
|
DoubleVector |
DoubleVector.fma(Vector<Double> b,
Vector<Double> c) |
Multiplies this vector by a second input vector, and sums
the result with a third.
|
FloatVector |
FloatVector.fma(Vector<Float> b,
Vector<Float> c) |
Multiplies this vector by a second input vector, and sums
the result with a third.
|
abstract ByteVector |
ByteVector.lanewise(VectorOperators.Binary op,
Vector<Byte> v) |
Combines the corresponding lane values of this vector
with those of a second input vector.
|
ByteVector |
ByteVector.lanewise(VectorOperators.Binary op,
Vector<Byte> v,
VectorMask<Byte> m) |
Combines the corresponding lane values of this vector
with those of a second input vector,
with selection of lane elements controlled by a mask.
|
ByteVector |
ByteVector.lanewise(VectorOperators.Ternary op,
byte e1,
Vector<Byte> v2) |
Combines the lane values of this vector
with the values of another vector and a broadcast scalar.
|
ByteVector |
ByteVector.lanewise(VectorOperators.Ternary op,
byte e1,
Vector<Byte> v2,
VectorMask<Byte> m) |
Combines the lane values of this vector
with the values of another vector and a broadcast scalar,
with selection of lane elements controlled by a mask.
|
ByteVector |
ByteVector.lanewise(VectorOperators.Ternary op,
Vector<Byte> v1,
byte e2) |
Combines the lane values of this vector
with the values of another vector and a broadcast scalar.
|
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) |
Combines the corresponding lane values of this vector
with the lanes of a second and a third input vector.
|
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 DoubleVector |
DoubleVector.lanewise(VectorOperators.Binary op,
Vector<Double> v) |
Combines the corresponding lane values of this vector
with those of a second input vector.
|
DoubleVector |
DoubleVector.lanewise(VectorOperators.Binary op,
Vector<Double> v,
VectorMask<Double> m) |
Combines the corresponding lane values of this vector
with those of a second input vector,
with selection of lane elements controlled by a mask.
|
DoubleVector |
DoubleVector.lanewise(VectorOperators.Ternary op,
double e1,
Vector<Double> v2) |
Combines the lane values of this vector
with the values of another vector and a broadcast scalar.
|
DoubleVector |
DoubleVector.lanewise(VectorOperators.Ternary op,
double e1,
Vector<Double> v2,
VectorMask<Double> m) |
Combines the lane values of this vector
with the values of another vector and a broadcast scalar,
with selection of lane elements controlled by a mask.
|
DoubleVector |
DoubleVector.lanewise(VectorOperators.Ternary op,
Vector<Double> v1,
double e2) |
Combines the lane values of this vector
with the values of another vector and a broadcast scalar.
|
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) |
Combines the corresponding lane values of this vector
with the lanes of a second and a third input vector.
|
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 FloatVector |
FloatVector.lanewise(VectorOperators.Binary op,
Vector<Float> v) |
Combines the corresponding lane values of this vector
with those of a second input vector.
|
FloatVector |
FloatVector.lanewise(VectorOperators.Binary op,
Vector<Float> v,
VectorMask<Float> m) |
Combines the corresponding lane values of this vector
with those of a second input vector,
with selection of lane elements controlled by a mask.
|
FloatVector |
FloatVector.lanewise(VectorOperators.Ternary op,
float e1,
Vector<Float> v2) |
Combines the lane values of this vector
with the values of another vector and a broadcast scalar.
|
FloatVector |
FloatVector.lanewise(VectorOperators.Ternary op,
float e1,
Vector<Float> v2,
VectorMask<Float> m) |
Combines the lane values of this vector
with the values of another vector and a broadcast scalar,
with selection of lane elements controlled by a mask.
|
FloatVector |
FloatVector.lanewise(VectorOperators.Ternary op,
Vector<Float> v1,
float e2) |
Combines the lane values of this vector
with the values of another vector and a broadcast scalar.
|
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) |
Combines the corresponding lane values of this vector
with the lanes of a second and a third input vector.
|
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 IntVector |
IntVector.lanewise(VectorOperators.Binary op,
Vector<Integer> v) |
Combines the corresponding lane values of this vector
with those of a second input vector.
|
IntVector |
IntVector.lanewise(VectorOperators.Binary op,
Vector<Integer> v,
VectorMask<Integer> m) |
Combines the corresponding lane values of this vector
with those of a second input vector,
with selection of lane elements controlled by a mask.
|
IntVector |
IntVector.lanewise(VectorOperators.Ternary op,
int e1,
Vector<Integer> v2) |
Combines the lane values of this vector
with the values of another vector and a broadcast scalar.
|
IntVector |
IntVector.lanewise(VectorOperators.Ternary op,
int e1,
Vector<Integer> v2,
VectorMask<Integer> m) |
Combines the lane values of this vector
with the values of another vector and a broadcast scalar,
with selection of lane elements controlled by a mask.
|
IntVector |
IntVector.lanewise(VectorOperators.Ternary op,
Vector<Integer> v1,
int e2) |
Combines the lane values of this vector
with the values of another vector and a broadcast scalar.
|
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) |
Combines the corresponding lane values of this vector
with the lanes of a second and a third input vector.
|
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 LongVector |
LongVector.lanewise(VectorOperators.Binary op,
Vector<Long> v) |
Combines the corresponding lane values of this vector
with those of a second input vector.
|
LongVector |
LongVector.lanewise(VectorOperators.Binary op,
Vector<Long> v,
VectorMask<Long> m) |
Combines the corresponding lane values of this vector
with those of a second input vector,
with selection of lane elements controlled by a mask.
|
LongVector |
LongVector.lanewise(VectorOperators.Ternary op,
long e1,
Vector<Long> v2) |
Combines the lane values of this vector
with the values of another vector and a broadcast scalar.
|
LongVector |
LongVector.lanewise(VectorOperators.Ternary op,
long e1,
Vector<Long> v2,
VectorMask<Long> m) |
Combines the lane values of this vector
with the values of another vector and a broadcast scalar,
with selection of lane elements controlled by a mask.
|
LongVector |
LongVector.lanewise(VectorOperators.Ternary op,
Vector<Long> v1,
long e2) |
Combines the lane values of this vector
with the values of another vector and a broadcast scalar.
|
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) |
Combines the corresponding lane values of this vector
with the lanes of a second and a third input vector.
|
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 ShortVector |
ShortVector.lanewise(VectorOperators.Binary op,
Vector<Short> v) |
Combines the corresponding lane values of this vector
with those of a second input vector.
|
ShortVector |
ShortVector.lanewise(VectorOperators.Binary op,
Vector<Short> v,
VectorMask<Short> m) |
Combines the corresponding lane values of this vector
with those of a second input vector,
with selection of lane elements controlled by a mask.
|
ShortVector |
ShortVector.lanewise(VectorOperators.Ternary op,
short e1,
Vector<Short> v2) |
Combines the lane values of this vector
with the values of another vector and a broadcast scalar.
|
ShortVector |
ShortVector.lanewise(VectorOperators.Ternary op,
short e1,
Vector<Short> v2,
VectorMask<Short> m) |
Combines the lane values of this vector
with the values of another vector and a broadcast scalar,
with selection of lane elements controlled by a mask.
|
ShortVector |
ShortVector.lanewise(VectorOperators.Ternary op,
Vector<Short> v1,
short e2) |
Combines the lane values of this vector
with the values of another vector and a broadcast scalar.
|
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) |
Combines the corresponding lane values of this vector
with the lanes of a second and a third input vector.
|
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 Vector<E> |
Vector.lanewise(VectorOperators.Binary op,
Vector<E> v) |
Combines the corresponding lane values of this vector
with those of a second input vector.
|
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) |
Combines the corresponding lane values of this vector
with the lanes of a second and a third input vector.
|
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.
|
VectorMask<Byte> |
ByteVector.lt(Vector<Byte> v) |
Tests if this vector is less than another input vector.
|
VectorMask<Double> |
DoubleVector.lt(Vector<Double> v) |
Tests if this vector is less than another input vector.
|
VectorMask<Float> |
FloatVector.lt(Vector<Float> v) |
Tests if this vector is less than another input vector.
|
VectorMask<Integer> |
IntVector.lt(Vector<Integer> v) |
Tests if this vector is less than another input vector.
|
VectorMask<Long> |
LongVector.lt(Vector<Long> v) |
Tests if this vector is less than another input vector.
|
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.
|
ByteVector |
ByteVector.max(Vector<Byte> v) |
Computes the larger of this vector and a second input vector.
|
DoubleVector |
DoubleVector.max(Vector<Double> v) |
Computes the larger of this vector and a second input vector.
|
FloatVector |
FloatVector.max(Vector<Float> v) |
Computes the larger of this vector and a second input vector.
|
IntVector |
IntVector.max(Vector<Integer> v) |
Computes the larger of this vector and a second input vector.
|
LongVector |
LongVector.max(Vector<Long> v) |
Computes the larger of this vector and a second input vector.
|
ShortVector |
ShortVector.max(Vector<Short> v) |
Computes the larger of this vector and a second input vector.
|
abstract Vector<E> |
Vector.max(Vector<E> v) |
Computes the larger of this vector and a second input vector.
|
ByteVector |
ByteVector.min(Vector<Byte> v) |
Computes the smaller of this vector and a second input vector.
|
DoubleVector |
DoubleVector.min(Vector<Double> v) |
Computes the smaller of this vector and a second input vector.
|
FloatVector |
FloatVector.min(Vector<Float> v) |
Computes the smaller of this vector and a second input vector.
|
IntVector |
IntVector.min(Vector<Integer> v) |
Computes the smaller of this vector and a second input vector.
|
LongVector |
LongVector.min(Vector<Long> v) |
Computes the smaller of this vector and a second input vector.
|
ShortVector |
ShortVector.min(Vector<Short> v) |
Computes the smaller of this vector and a second input vector.
|
abstract Vector<E> |
Vector.min(Vector<E> v) |
Computes the smaller of this vector and a second input vector.
|
ByteVector |
ByteVector.mul(Vector<Byte> v) |
Multiplies this vector by a second input vector.
|
ByteVector |
ByteVector.mul(Vector<Byte> v,
VectorMask<Byte> m) |
Multiplies this vector by a second input vector
under the control of a mask.
|
DoubleVector |
DoubleVector.mul(Vector<Double> v) |
Multiplies this vector by a second input vector.
|
DoubleVector |
DoubleVector.mul(Vector<Double> v,
VectorMask<Double> m) |
Multiplies this vector by a second input vector
under the control of a mask.
|
FloatVector |
FloatVector.mul(Vector<Float> v) |
Multiplies this vector by a second input vector.
|
FloatVector |
FloatVector.mul(Vector<Float> v,
VectorMask<Float> m) |
Multiplies this vector by a second input vector
under the control of a mask.
|
IntVector |
IntVector.mul(Vector<Integer> v) |
Multiplies this vector by a second input vector.
|
IntVector |
IntVector.mul(Vector<Integer> v,
VectorMask<Integer> m) |
Multiplies this vector by a second input vector
under the control of a mask.
|
LongVector |
LongVector.mul(Vector<Long> v) |
Multiplies this vector by a second input vector.
|
LongVector |
LongVector.mul(Vector<Long> v,
VectorMask<Long> m) |
Multiplies this vector by a second input vector
under the control of a mask.
|
ShortVector |
ShortVector.mul(Vector<Short> v) |
Multiplies this vector by a second input vector.
|
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) |
Multiplies this vector by a second input vector.
|
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.
|
ByteVector |
ByteVector.or(Vector<Byte> v) |
Computes the bitwise logical disjunction (| )
of this vector and a second input vector.
|
IntVector |
IntVector.or(Vector<Integer> v) |
Computes the bitwise logical disjunction (| )
of this vector and a second input vector.
|
LongVector |
LongVector.or(Vector<Long> v) |
Computes the bitwise logical disjunction (| )
of this vector and a second input vector.
|
ShortVector |
ShortVector.or(Vector<Short> v) |
Computes the bitwise logical disjunction (| )
of this vector and a second input vector.
|
DoubleVector |
DoubleVector.pow(Vector<Double> b) |
Raises this vector to the power of a second input vector.
|
FloatVector |
FloatVector.pow(Vector<Float> b) |
Raises this vector to the power of a second input vector.
|
abstract ByteVector |
ByteVector.rearrange(VectorShuffle<Byte> s,
Vector<Byte> v) |
Rearranges the lane elements of two vectors, selecting lanes
under the control of a specific shuffle, using both normal and
exceptional indexes in the shuffle to steer data.
|
abstract DoubleVector |
DoubleVector.rearrange(VectorShuffle<Double> s,
Vector<Double> v) |
Rearranges the lane elements of two vectors, selecting lanes
under the control of a specific shuffle, using both normal and
exceptional indexes in the shuffle to steer data.
|
abstract FloatVector |
FloatVector.rearrange(VectorShuffle<Float> s,
Vector<Float> v) |
Rearranges the lane elements of two vectors, selecting lanes
under the control of a specific shuffle, using both normal and
exceptional indexes in the shuffle to steer data.
|
abstract IntVector |
IntVector.rearrange(VectorShuffle<Integer> s,
Vector<Integer> v) |
Rearranges the lane elements of two vectors, selecting lanes
under the control of a specific shuffle, using both normal and
exceptional indexes in the shuffle to steer data.
|
abstract LongVector |
LongVector.rearrange(VectorShuffle<Long> s,
Vector<Long> v) |
Rearranges the lane elements of two vectors, selecting lanes
under the control of a specific shuffle, using both normal and
exceptional indexes in the shuffle to steer data.
|
abstract ShortVector |
ShortVector.rearrange(VectorShuffle<Short> s,
Vector<Short> v) |
Rearranges the lane elements of two vectors, selecting lanes
under the control of a specific shuffle, using both normal and
exceptional indexes in the shuffle to steer data.
|
abstract Vector<E> |
Vector.rearrange(VectorShuffle<E> s,
Vector<E> v) |
Rearranges the lane elements of two vectors, selecting lanes
under the control of a specific shuffle, using both normal and
exceptional indexes in the shuffle to steer data.
|
abstract ByteVector |
ByteVector.selectFrom(Vector<Byte> v) |
Using index values stored in the lanes of this vector,
assemble values stored in second vector v .
|
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> v) |
Using index values stored in the lanes of this vector,
assemble values stored in second vector v .
|
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> v) |
Using index values stored in the lanes of this vector,
assemble values stored in second vector v .
|
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> v) |
Using index values stored in the lanes of this vector,
assemble values stored in second vector v .
|
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> v) |
Using index values stored in the lanes of this vector,
assemble values stored in second vector v .
|
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> v) |
Using index values stored in the lanes of this vector,
assemble values stored in second vector v .
|
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) |
Using index values stored in the lanes of this vector,
assemble values stored in second vector v .
|
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.
|
abstract ByteVector |
ByteVector.slice(int origin,
Vector<Byte> v1) |
Slices a segment of adjacent lanes, starting at a given
origin lane in the current vector, and continuing (as
needed) into an immediately following vector.
|
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.
|
abstract DoubleVector |
DoubleVector.slice(int origin,
Vector<Double> v1) |
Slices a segment of adjacent lanes, starting at a given
origin lane in the current vector, and continuing (as
needed) into an immediately following vector.
|
DoubleVector |
DoubleVector.slice(int origin,
Vector<Double> w,
VectorMask<Double> m) |
Slices a segment of adjacent lanes
under the control of a mask,
starting at a given
origin lane in the current vector, and continuing (as
needed) into an immediately following vector.
|
abstract FloatVector |
FloatVector.slice(int origin,
Vector<Float> v1) |
Slices a segment of adjacent lanes, starting at a given
origin lane in the current vector, and continuing (as
needed) into an immediately following vector.
|
FloatVector |
FloatVector.slice(int origin,
Vector<Float> w,
VectorMask<Float> m) |
Slices a segment of adjacent lanes
under the control of a mask,
starting at a given
origin lane in the current vector, and continuing (as
needed) into an immediately following vector.
|
abstract IntVector |
IntVector.slice(int origin,
Vector<Integer> v1) |
Slices a segment of adjacent lanes, starting at a given
origin lane in the current vector, and continuing (as
needed) into an immediately following vector.
|
IntVector |
IntVector.slice(int origin,
Vector<Integer> w,
VectorMask<Integer> m) |
Slices a segment of adjacent lanes
under the control of a mask,
starting at a given
origin lane in the current vector, and continuing (as
needed) into an immediately following vector.
|
abstract LongVector |
LongVector.slice(int origin,
Vector<Long> v1) |
Slices a segment of adjacent lanes, starting at a given
origin lane in the current vector, and continuing (as
needed) into an immediately following vector.
|
LongVector |
LongVector.slice(int origin,
Vector<Long> w,
VectorMask<Long> m) |
Slices a segment of adjacent lanes
under the control of a mask,
starting at a given
origin lane in the current vector, and continuing (as
needed) into an immediately following vector.
|
abstract ShortVector |
ShortVector.slice(int origin,
Vector<Short> v1) |
Slices a segment of adjacent lanes, starting at a given
origin lane in the current vector, and continuing (as
needed) into an immediately following vector.
|
ShortVector |
ShortVector.slice(int origin,
Vector<Short> w,
VectorMask<Short> m) |
Slices a segment of adjacent lanes
under the control of a mask,
starting at a given
origin lane in the current vector, and continuing (as
needed) into an immediately following vector.
|
abstract Vector<E> |
Vector.slice(int origin,
Vector<E> v1) |
Slices a segment of adjacent lanes, starting at a given
origin lane in the current vector, and continuing (as
needed) into an immediately following vector.
|
abstract Vector<E> |
Vector.slice(int origin,
Vector<E> v1,
VectorMask<E> m) |
Slices a segment of adjacent lanes
under the control of a mask,
starting at a given
origin lane in the current vector, and continuing (as
needed) into an immediately following vector.
|
ByteVector |
ByteVector.sub(Vector<Byte> v) |
Subtracts a second input vector from this vector.
|
ByteVector |
ByteVector.sub(Vector<Byte> v,
VectorMask<Byte> m) |
Subtracts a second input vector from this vector
under the control of a mask.
|
DoubleVector |
DoubleVector.sub(Vector<Double> v) |
Subtracts a second input vector from this vector.
|
DoubleVector |
DoubleVector.sub(Vector<Double> v,
VectorMask<Double> m) |
Subtracts a second input vector from this vector
under the control of a mask.
|
FloatVector |
FloatVector.sub(Vector<Float> v) |
Subtracts a second input vector from this vector.
|
FloatVector |
FloatVector.sub(Vector<Float> v,
VectorMask<Float> m) |
Subtracts a second input vector from this vector
under the control of a mask.
|
IntVector |
IntVector.sub(Vector<Integer> v) |
Subtracts a second input vector from this vector.
|
IntVector |
IntVector.sub(Vector<Integer> v,
VectorMask<Integer> m) |
Subtracts a second input vector from this vector
under the control of a mask.
|
LongVector |
LongVector.sub(Vector<Long> v) |
Subtracts a second input vector from this vector.
|
LongVector |
LongVector.sub(Vector<Long> v,
VectorMask<Long> m) |
Subtracts a second input vector from this vector
under the control of a mask.
|
ShortVector |
ShortVector.sub(Vector<Short> v) |
Subtracts a second input vector from this vector.
|
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) |
Subtracts a second input vector from this vector.
|
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 ByteVector |
ByteVector.unslice(int origin,
Vector<Byte> w,
int part) |
Reverses a slice(), inserting
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 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) |
Reverses a slice(), inserting
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) |
Reverses a slice(), inserting
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) |
Reverses a slice(), inserting
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) |
Reverses a slice(), inserting
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) |
Reverses a slice(), inserting
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) |
Reverses a slice(), inserting
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.
|