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