ByteVector |
ByteVector.abs() |
Returns the absolute value of this vector.
|
ByteVector |
ByteVector.add(byte e) |
Adds this vector to the broadcast of an input scalar.
|
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) |
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.
|
abstract ByteVector |
ByteVector.addIndex(int scale) |
Adds the lanes of this vector to their corresponding
lane numbers, scaled by a given constant.
|
ByteVector |
ByteVector.and(byte e) |
Computes the bitwise logical conjunction (& )
of this vector and a scalar.
|
ByteVector |
ByteVector.and(Vector<Byte> v) |
Computes the bitwise logical conjunction (& )
of this vector and a second input vector.
|
ByteVector |
ByteVector.bitwiseBlend(byte bits,
byte mask) |
Blends together the bits of a vector and a scalar under
the control of another scalar, which supplies mask bits.
|
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 scalar 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.
|
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.
|
abstract ByteVector |
ByteVector.broadcast(byte e) |
Returns a vector of the same species as this one
where all lane elements are set to
the primitive value e .
|
abstract ByteVector |
ByteVector.broadcast(long e) |
Returns a vector of the same species as this one
where all lane elements are set to
the primitive value e .
|
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 .
|
ByteVector |
ByteVector.div(byte e) |
Divides this vector by the broadcast of an input scalar.
|
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) |
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.
|
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 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 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 ByteVector |
ByteVector.fromValues(VectorSpecies<Byte> species,
byte... es) |
Returns a vector where each lane element is set to given
primitive values.
|
ByteVector |
ByteVector.lanewise(VectorOperators.Binary op,
byte e) |
Combines the lane values of this vector
with the value of a broadcast scalar.
|
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) |
Combines the lane values of this vector
with the value of a broadcast scalar.
|
ByteVector |
ByteVector.lanewise(VectorOperators.Binary op,
long e,
VectorMask<Byte> m) |
Combines the corresponding lane values of this vector
with those of a second input vector,
with selection of lane elements controlled by a mask.
|
abstract ByteVector |
ByteVector.lanewise(VectorOperators.Binary op,
Vector<Byte> v) |
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,
byte e2) |
Combines the lane values of this vector
with the values of two broadcast scalars.
|
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) |
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 ByteVector |
ByteVector.lanewise(VectorOperators.Unary op) |
Operates on the lane values of this vector.
|
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.
|
ByteVector |
ByteVector.max(byte e) |
Computes the larger of this vector and the broadcast of an input scalar.
|
ByteVector |
ByteVector.max(Vector<Byte> v) |
Computes the larger of this vector and a second input vector.
|
ByteVector |
ByteVector.min(byte e) |
Computes the smaller of this vector and the broadcast of an input scalar.
|
ByteVector |
ByteVector.min(Vector<Byte> v) |
Computes the smaller of this vector and a second input vector.
|
ByteVector |
ByteVector.mul(byte e) |
Multiplies this vector by the broadcast of an input scalar.
|
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) |
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.
|
ByteVector |
ByteVector.neg() |
Negates this vector.
|
ByteVector |
ByteVector.not() |
Computes the bitwise logical complement (~ )
of this vector.
|
ByteVector |
ByteVector.or(byte e) |
Computes the bitwise logical disjunction (| )
of this vector and a scalar.
|
ByteVector |
ByteVector.or(Vector<Byte> v) |
Computes the bitwise logical disjunction (| )
of this vector and a second input vector.
|
static ByteVector |
ByteVector.random(VectorSpecies<Byte> species) |
Returns a vector where each lane element is set to a randomly
generated primitive value.
|
abstract ByteVector |
ByteVector.rearrange(VectorShuffle<Byte> m) |
Rearranges the lane elements of this vector, selecting lanes
under the control of a specific shuffle.
|
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 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.
|
ByteVector |
ByteVector.reinterpretAsBytes() |
Views this vector as a vector of the same shape
and contents but a lane type of byte ,
where the bytes are extracted from the lanes
according to little-endian order.
|
ByteVector |
DoubleVector.reinterpretAsBytes() |
Views this vector as a vector of the same shape
and contents but a lane type of byte ,
where the bytes are extracted from the lanes
according to little-endian order.
|
ByteVector |
FloatVector.reinterpretAsBytes() |
Views this vector as a vector of the same shape
and contents but a lane type of byte ,
where the bytes are extracted from the lanes
according to little-endian order.
|
ByteVector |
IntVector.reinterpretAsBytes() |
Views this vector as a vector of the same shape
and contents but a lane type of byte ,
where the bytes are extracted from the lanes
according to little-endian order.
|
ByteVector |
LongVector.reinterpretAsBytes() |
Views this vector as a vector of the same shape
and contents but a lane type of byte ,
where the bytes are extracted from the lanes
according to little-endian order.
|
ByteVector |
ShortVector.reinterpretAsBytes() |
Views this vector as a vector of the same shape
and contents but a lane type of byte ,
where the bytes are extracted from the lanes
according to little-endian order.
|
abstract ByteVector |
Vector.reinterpretAsBytes() |
Views this vector as a vector of the same shape
and contents but a lane type of byte ,
where the bytes are extracted from the lanes
according to little-endian order.
|
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.
|
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.
|
abstract ByteVector |
ByteVector.slice(int origin) |
Slices a segment of adjacent lanes, starting at a given
origin lane in the current vector.
|
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.
|
ByteVector |
ByteVector.sub(byte e) |
Subtracts an input scalar from this 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) |
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.
|
abstract ByteVector |
ByteVector.unslice(int origin) |
Reverses a slice(), inserting
the current vector as a slice within a "background" input
of zero lane values.
|
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.
|
ByteVector |
ByteVector.viewAsIntegralLanes() |
Views this vector as a vector of the same shape, length, and
contents, but a lane type that is not a floating-point type.
|
abstract ByteVector |
ByteVector.withLane(int i,
byte e) |
Replaces the lane element of this vector at lane index i with
value e .
|
static ByteVector |
ByteVector.zero(VectorSpecies<Byte> species) |
|