static ByteVector |
ByteVector.broadcast(VectorSpecies<Byte> species,
byte e) |
Returns a vector of the given species
where all lane elements are set to
the primitive value e .
|
static ByteVector |
ByteVector.broadcast(VectorSpecies<Byte> species,
long e) |
Returns a vector of the given species
where all lane elements are set to
the primitive value e .
|
static DoubleVector |
DoubleVector.broadcast(VectorSpecies<Double> species,
double e) |
Returns a vector of the given species
where all lane elements are set to
the primitive value e .
|
static DoubleVector |
DoubleVector.broadcast(VectorSpecies<Double> species,
long e) |
Returns a vector of the given species
where all lane elements are set to
the primitive value e .
|
static FloatVector |
FloatVector.broadcast(VectorSpecies<Float> species,
float e) |
Returns a vector of the given species
where all lane elements are set to
the primitive value e .
|
static FloatVector |
FloatVector.broadcast(VectorSpecies<Float> species,
long e) |
Returns a vector of the given species
where all lane elements are set to
the primitive value e .
|
static IntVector |
IntVector.broadcast(VectorSpecies<Integer> species,
int e) |
Returns a vector of the given species
where all lane elements are set to
the primitive value e .
|
static IntVector |
IntVector.broadcast(VectorSpecies<Integer> species,
long e) |
Returns a vector of the given species
where all lane elements are set to
the primitive value e .
|
static LongVector |
LongVector.broadcast(VectorSpecies<Long> species,
long e) |
Returns a vector of the given species
where all lane elements are set to
the primitive value e .
|
static ShortVector |
ShortVector.broadcast(VectorSpecies<Short> species,
long e) |
Returns a vector of the given species
where all lane elements are set to
the primitive value e .
|
static ShortVector |
ShortVector.broadcast(VectorSpecies<Short> species,
short e) |
Returns a vector of the given species
where all lane elements are set to
the primitive value e .
|
abstract <F> VectorMask<F> |
VectorMask.cast(VectorSpecies<F> species) |
Converts this mask to a mask of the given species of
element type F .
|
abstract <F> VectorShuffle<F> |
VectorShuffle.cast(VectorSpecies<F> species) |
Converts this shuffle to a shuffle of the given species of
element type F .
|
abstract <F> Vector<F> |
Vector.castShape(VectorSpecies<F> rsp,
int part) |
Convenience method for converting a vector from one lane type
to another, reshaping as needed when lane sizes change.
|
abstract <F> Vector<F> |
Vector.check(VectorSpecies<F> species) |
Checks that this vector has the given species,
and returns this vector unchanged.
|
abstract <F> VectorMask<F> |
VectorMask.check(VectorSpecies<F> species) |
Checks that this mask has the given species,
and returns this mask unchanged.
|
abstract <F> VectorShuffle<F> |
VectorShuffle.check(VectorSpecies<F> species) |
Checks that this shuffle has the given species,
and returns this shuffle unchanged.
|
abstract <F> Vector<F> |
Vector.convertShape(VectorOperators.Conversion<E,F> conv,
VectorSpecies<F> rsp,
int part) |
Converts this vector to a vector of the given species, shape and
element type, converting lane values from the current ETYPE
to a new lane type (called FTYPE here) according to the
indicated conversion.
|
static ByteVector |
ByteVector.fromArray(VectorSpecies<Byte> species,
byte[] a,
int offset) |
Loads a vector from an array of type byte[]
starting at an offset.
|
static ByteVector |
ByteVector.fromArray(VectorSpecies<Byte> species,
byte[] a,
int offset,
int[] indexMap,
int mapOffset) |
Gathers a new vector composed of elements from an array of type
byte[] ,
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,
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) |
Loads a vector from an array of type double[]
starting at an offset.
|
static DoubleVector |
DoubleVector.fromArray(VectorSpecies<Double> species,
double[] a,
int offset,
int[] indexMap,
int mapOffset) |
Gathers a new vector composed of elements from an array of type
double[] ,
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,
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) |
Loads a vector from an array of type float[]
starting at an offset.
|
static FloatVector |
FloatVector.fromArray(VectorSpecies<Float> species,
float[] a,
int offset,
int[] indexMap,
int mapOffset) |
Gathers a new vector composed of elements from an array of type
float[] ,
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,
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) |
Loads a vector from an array of type int[]
starting at an offset.
|
static IntVector |
IntVector.fromArray(VectorSpecies<Integer> species,
int[] a,
int offset,
int[] indexMap,
int mapOffset) |
Gathers a new vector composed of elements from an array of type
int[] ,
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,
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) |
Loads a vector from an array of type long[]
starting at an offset.
|
static LongVector |
LongVector.fromArray(VectorSpecies<Long> species,
long[] a,
int offset,
int[] indexMap,
int mapOffset) |
Gathers a new vector composed of elements from an array of type
long[] ,
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,
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) |
Loads a vector from an array of type short[]
starting at an offset.
|
static ShortVector |
ShortVector.fromArray(VectorSpecies<Short> species,
short[] a,
int offset,
int[] indexMap,
int mapOffset) |
Gathers a new vector composed of elements from an array of type
short[] ,
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,
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 <E> VectorMask<E> |
VectorMask.fromArray(VectorSpecies<E> species,
boolean[] bits,
int offset) |
Loads a mask from a boolean array starting at an offset.
|
static <E> VectorShuffle<E> |
VectorShuffle.fromArray(VectorSpecies<E> species,
int[] sourceIndexes,
int offset) |
Creates a shuffle for a given species from
an int array starting at an offset.
|
static ByteVector |
ByteVector.fromByteArray(VectorSpecies<Byte> species,
byte[] a,
int offset) |
Loads a vector from a byte array starting at an offset.
|
static ByteVector |
ByteVector.fromByteArray(VectorSpecies<Byte> species,
byte[] a,
int offset,
ByteOrder bo) |
Loads a vector from a byte array starting at an offset.
|
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) |
Loads a vector from a byte array starting at an offset.
|
static DoubleVector |
DoubleVector.fromByteArray(VectorSpecies<Double> species,
byte[] a,
int offset,
ByteOrder bo) |
Loads a vector from a byte array starting at an offset.
|
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) |
Loads a vector from a byte array starting at an offset.
|
static FloatVector |
FloatVector.fromByteArray(VectorSpecies<Float> species,
byte[] a,
int offset,
ByteOrder bo) |
Loads a vector from a byte array starting at an offset.
|
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) |
Loads a vector from a byte array starting at an offset.
|
static IntVector |
IntVector.fromByteArray(VectorSpecies<Integer> species,
byte[] a,
int offset,
ByteOrder bo) |
Loads a vector from a byte array starting at an offset.
|
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) |
Loads a vector from a byte array starting at an offset.
|
static LongVector |
LongVector.fromByteArray(VectorSpecies<Long> species,
byte[] a,
int offset,
ByteOrder bo) |
Loads a vector from a byte array starting at an offset.
|
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) |
Loads a vector from a byte array starting at an offset.
|
static ShortVector |
ShortVector.fromByteArray(VectorSpecies<Short> species,
byte[] a,
int offset,
ByteOrder bo) |
Loads a vector from a byte array starting at an offset.
|
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) |
Loads a vector from a byte buffer
starting at an offset into the byte buffer.
|
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) |
Loads a vector from a byte buffer
starting at an offset into the byte buffer.
|
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) |
Loads a vector from a byte buffer
starting at an offset into the byte buffer.
|
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) |
Loads a vector from a byte buffer
starting at an offset into the byte buffer.
|
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) |
Loads a vector from a byte buffer
starting at an offset into the byte buffer.
|
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) |
Loads a vector from a byte buffer
starting at an offset into the byte buffer.
|
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.
|
static <E> VectorMask<E> |
VectorMask.fromLong(VectorSpecies<E> species,
long bits) |
Returns a mask where each lane is set or unset according to
the bits in the given bitmask, starting with the least
significant bit, and continuing up to the sign bit.
|
static <E> VectorShuffle<E> |
VectorShuffle.fromOp(VectorSpecies<E> species,
IntUnaryOperator fn) |
Creates a shuffle for a given species from
the successive values of an operator applied to
the range [0..VLENGTH-1] .
|
static ByteVector |
ByteVector.fromValues(VectorSpecies<Byte> species,
byte... es) |
Returns a vector where each lane element is set to given
primitive values.
|
static DoubleVector |
DoubleVector.fromValues(VectorSpecies<Double> species,
double... es) |
Returns a vector where each lane element is set to given
primitive values.
|
static FloatVector |
FloatVector.fromValues(VectorSpecies<Float> species,
float... es) |
Returns a vector where each lane element is set to given
primitive values.
|
static IntVector |
IntVector.fromValues(VectorSpecies<Integer> species,
int... es) |
Returns a vector where each lane element is set to given
primitive values.
|
static LongVector |
LongVector.fromValues(VectorSpecies<Long> species,
long... es) |
Returns a vector where each lane element is set to given
primitive values.
|
static ShortVector |
ShortVector.fromValues(VectorSpecies<Short> species,
short... es) |
Returns a vector where each lane element is set to given
primitive values.
|
static <E> VectorMask<E> |
VectorMask.fromValues(VectorSpecies<E> species,
boolean... bits) |
Returns a mask where each lane is set or unset according to given
boolean values.
|
static <E> VectorShuffle<E> |
VectorShuffle.fromValues(VectorSpecies<E> species,
int... sourceIndexes) |
Creates a shuffle for a given species from
a series of source indexes.
|
static <E> VectorShuffle<E> |
VectorShuffle.iota(VectorSpecies<E> species,
int start,
int step,
boolean wrap) |
Creates a shuffle using source indexes set to sequential
values starting from start and stepping
by the given step .
|
static <E> VectorShuffle<E> |
VectorShuffle.makeUnzip(VectorSpecies<E> species,
int part) |
Creates a shuffle which will unzip the concatenation of two
vectors, alternatively storing input lanes into one or the
other output vector.
|
static <E> VectorShuffle<E> |
VectorShuffle.makeZip(VectorSpecies<E> species,
int part) |
Creates a shuffle which will zip together two vectors,
alternatively selecting lanes from one or the other.
|
int |
VectorSpecies.partLimit(VectorSpecies<?> outputSpecies,
boolean lanewise) |
|
static ByteVector |
ByteVector.random(VectorSpecies<Byte> species) |
Returns a vector where each lane element is set to a randomly
generated primitive value.
|
static DoubleVector |
DoubleVector.random(VectorSpecies<Double> species) |
Returns a vector where each lane element is set to a randomly
generated primitive value.
|
static FloatVector |
FloatVector.random(VectorSpecies<Float> species) |
Returns a vector where each lane element is set to a randomly
generated primitive value.
|
static IntVector |
IntVector.random(VectorSpecies<Integer> species) |
Returns a vector where each lane element is set to a randomly
generated primitive value.
|
static LongVector |
LongVector.random(VectorSpecies<Long> species) |
Returns a vector where each lane element is set to a randomly
generated primitive value.
|
static ShortVector |
ShortVector.random(VectorSpecies<Short> species) |
Returns a vector where each lane element is set to a randomly
generated primitive value.
|
abstract <F> Vector<F> |
Vector.reinterpretShape(VectorSpecies<F> species,
int part) |
Transforms this vector to a vector of the given species of
element type F , reinterpreting the bytes of this
vector without performing any value conversions.
|
static ByteVector |
ByteVector.single(VectorSpecies<Byte> species,
byte e) |
Returns a vector where the first lane element is set to the primtive
value e , all other lane elements are set to the default
value.
|
static DoubleVector |
DoubleVector.single(VectorSpecies<Double> species,
double e) |
Returns a vector where the first lane element is set to the primtive
value e , all other lane elements are set to the default
value.
|
static FloatVector |
FloatVector.single(VectorSpecies<Float> species,
float e) |
Returns a vector where the first lane element is set to the primtive
value e , all other lane elements are set to the default
value.
|
static IntVector |
IntVector.single(VectorSpecies<Integer> species,
int e) |
Returns a vector where the first lane element is set to the primtive
value e , all other lane elements are set to the default
value.
|
static LongVector |
LongVector.single(VectorSpecies<Long> species,
long e) |
Returns a vector where the first lane element is set to the primtive
value e , all other lane elements are set to the default
value.
|
static ShortVector |
ShortVector.single(VectorSpecies<Short> species,
short e) |
Returns a vector where the first lane element is set to the primtive
value e , all other lane elements are set to the default
value.
|
static ByteVector |
ByteVector.zero(VectorSpecies<Byte> species) |
|
static DoubleVector |
DoubleVector.zero(VectorSpecies<Double> species) |
|
static FloatVector |
FloatVector.zero(VectorSpecies<Float> species) |
|
static IntVector |
IntVector.zero(VectorSpecies<Integer> species) |
|
static LongVector |
LongVector.zero(VectorSpecies<Long> species) |
|
static ShortVector |
ShortVector.zero(VectorSpecies<Short> species) |
|