 java.lang.Object

 jdk.incubator.vector.Vector<Byte>

 jdk.incubator.vector.ByteVector


Field Summary
Fields Modifier and Type Field Description static Species<Byte>
SPECIES_128
Species representingByteVector
s ofShape.S_128_BIT
.static Species<Byte>
SPECIES_256
Species representingByteVector
s ofShape.S_256_BIT
.static Species<Byte>
SPECIES_512
Species representingByteVector
s ofShape.S_512_BIT
.static Species<Byte>
SPECIES_64
Species representingByteVector
s ofShape.S_64_BIT
.static Species<Byte>
SPECIES_MAX
Species representingByteVector
s ofShape.S_Max_BIT
.static Species<Byte>
SPECIES_PREFERRED
Preferred species forByteVector
s.

Method Summary
Modifier and Type Method Description abstract ByteVector
add(byte s)
Adds this vector to the broadcast of an input scalar.abstract ByteVector
add(byte s, Mask<Byte> m)
Adds this vector to broadcast of an input scalar, selecting lane elements controlled by a mask.abstract byte
addAll()
Adds all lane elements of this vector.abstract byte
addAll(Mask<Byte> m)
Adds all lane elements of this vector, selecting lane elements controlled by a mask.abstract ByteVector
and(byte s)
Bitwise ANDs this vector with the broadcast of an input scalar.abstract ByteVector
and(byte s, Mask<Byte> m)
Bitwise ANDs this vector with the broadcast of an input scalar, selecting lane elements controlled by a mask.abstract ByteVector
and(Vector<Byte> v)
Bitwise ANDs this vector with an input vector.abstract ByteVector
and(Vector<Byte> v, Mask<Byte> m)
Bitwise ANDs this vector with an input vector, selecting lane elements controlled by a mask.abstract byte
andAll()
Logically ANDs all lane elements of this vector.abstract byte
andAll(Mask<Byte> m)
Logically ANDs all lane elements of this vector, selecting lane elements controlled by a mask.abstract ByteVector
aShiftR(int s)
Arithmetically right shifts (or signed right shifts) this vector by the broadcast of an input scalar.abstract ByteVector
aShiftR(int s, Mask<Byte> m)
Arithmetically right shifts (or signed right shifts) this vector by the broadcast of an input scalar, selecting lane elements controlled by a mask.abstract ByteVector
blend(byte s, Mask<Byte> m)
Blends the lane elements of this vector with those of the broadcast of an input scalar, selecting lanes controlled by a mask.static ByteVector
broadcast(Species<Byte> s, byte e)
Returns a vector where all lane elements are set to the primitive valuee
.abstract Mask<Byte>
equal(byte s)
Tests if this vector is equal to the broadcast of an input scalar.static ByteVector
fromArray(Species<Byte> species, byte[] a, int i)
Loads a vector from an array starting at offset.static ByteVector
fromArray(Species<Byte> species, byte[] a, int i, int[] indexMap, int j)
Loads a vector from an array using indexes obtained from an index map.static ByteVector
fromArray(Species<Byte> species, byte[] a, int i, Mask<Byte> m)
Loads a vector from an array starting at offset and using a mask.static ByteVector
fromArray(Species<Byte> species, byte[] a, int i, Mask<Byte> m, int[] indexMap, int j)
Loads a vector from an array using indexes obtained from an index map and using a mask.static ByteVector
fromByteArray(Species<Byte> species, byte[] a, int ix)
Loads a vector from a byte array starting at an offset.static ByteVector
fromByteArray(Species<Byte> species, byte[] a, int ix, Mask<Byte> m)
Loads a vector from a byte array starting at an offset and using a mask.static ByteVector
fromByteBuffer(Species<Byte> species, ByteBuffer bb, int ix)
Loads a vector from abyte buffer
starting at an offset into the byte buffer.static ByteVector
fromByteBuffer(Species<Byte> species, ByteBuffer bb, int ix, Mask<Byte> m)
Loads a vector from abyte buffer
starting at an offset into the byte buffer and using a mask.abstract byte
get(int i)
Gets the lane element at lane indexi
abstract Mask<Byte>
greaterThan(byte s)
Tests if this vector is greater than the broadcast of an input scalar.abstract Mask<Byte>
greaterThanEq(byte s)
Tests if this vector is greater than or equal to the broadcast of an input scalar.abstract void
intoArray(byte[] a, int i)
Stores this vector into an array starting at offset.void
intoArray(byte[] a, int i, int[] indexMap, int j)
Stores this vector into an array using indexes obtained from an index map.abstract void
intoArray(byte[] a, int i, Mask<Byte> m)
Stores this vector into an array starting at offset and using a mask.void
intoArray(byte[] a, int i, Mask<Byte> m, int[] indexMap, int j)
Stores this vector into an array using indexes obtained from an index map and using a mask.abstract Mask<Byte>
lessThan(byte s)
Tests if this vector is less than the broadcast of an input scalar.abstract Mask<Byte>
lessThanEq(byte s)
Tests if this vector is less or equal to the broadcast of an input scalar.abstract ByteVector
max(byte s)
Returns the maximum of this vector and the broadcast of an input scalar.abstract byte
maxAll()
Returns the maximum lane element of this vector.abstract byte
maxAll(Mask<Byte> m)
Returns the maximum lane element of this vector, selecting lane elements controlled by a mask.abstract ByteVector
min(byte s)
Returns the minimum of this vector and the broadcast of an input scalar.abstract byte
minAll()
Returns the minimum lane element of this vector.abstract byte
minAll(Mask<Byte> m)
Returns the minimum lane element of this vector, selecting lane elements controlled by a mask.abstract ByteVector
mul(byte s)
Multiplies this vector with the broadcast of an input scalar.abstract ByteVector
mul(byte s, Mask<Byte> m)
Multiplies this vector with the broadcast of an input scalar, selecting lane elements controlled by a mask.abstract byte
mulAll()
Multiplies all lane elements of this vector.abstract byte
mulAll(Mask<Byte> m)
Multiplies all lane elements of this vector, selecting lane elements controlled by a mask.abstract ByteVector
not()
Bitwise NOTs this vector.abstract ByteVector
not(Mask<Byte> m)
Bitwise NOTs this vector, selecting lane elements controlled by a mask.abstract Mask<Byte>
notEqual(byte s)
Tests if this vector is not equal to the broadcast of an input scalar.abstract ByteVector
or(byte s)
Bitwise ORs this vector with the broadcast of an input scalar.abstract ByteVector
or(byte s, Mask<Byte> m)
Bitwise ORs this vector with the broadcast of an input scalar, selecting lane elements controlled by a mask.abstract ByteVector
or(Vector<Byte> v)
Bitwise ORs this vector with an input vector.abstract ByteVector
or(Vector<Byte> v, Mask<Byte> m)
Bitwise ORs this vector with an input vector, selecting lane elements controlled by a mask.abstract byte
orAll()
Logically ORs all lane elements of this vector.abstract byte
orAll(Mask<Byte> m)
Logically ORs all lane elements of this vector, selecting lane elements controlled by a mask.static ByteVector
random(Species<Byte> s)
Returns a vector where each lane element is set to a randomly generated primitive value.static ByteVector
scalars(Species<Byte> s, byte... es)
Returns a vector where each lane element is set to a given primitive value.abstract ByteVector
shiftL(int s)
Logically left shifts this vector by the broadcast of an input scalar.abstract ByteVector
shiftL(int s, Mask<Byte> m)
Logically left shifts this vector by the broadcast of an input scalar, selecting lane elements controlled by a mask.abstract ByteVector
shiftR(int s)
Logically right shifts (or unsigned right shifts) this vector by the broadcast of an input scalar.abstract ByteVector
shiftR(int s, Mask<Byte> m)
Logically right shifts (or unsigned right shifts) this vector by the broadcast of an input scalar, selecting lane elements controlled by a mask.static ByteVector
single(Species<Byte> s, byte e)
Returns a vector where the first lane element is set to the primtive valuee
, all other lane elements are set to the default value.abstract ByteVector
sub(byte s)
Subtracts the broadcast of an input scalar from this vector.abstract ByteVector
sub(byte s, Mask<Byte> m)
Subtracts the broadcast of an input scalar from this vector, selecting lane elements controlled by a mask.byte[]
toArray()
Returns an array containing the lane elements of this vector.abstract ByteVector
with(int i, byte e)
Replaces the lane element of this vector at lane indexi
with valuee
.abstract ByteVector
xor(byte s)
Bitwise XORs this vector with the broadcast of an input scalar.abstract ByteVector
xor(byte s, Mask<Byte> m)
Bitwise XORs this vector with the broadcast of an input scalar, selecting lane elements controlled by a mask.abstract ByteVector
xor(Vector<Byte> v)
Bitwise XORs this vector with an input vector.abstract ByteVector
xor(Vector<Byte> v, Mask<Byte> m)
Bitwise XORs this vector with an input vector, selecting lane elements controlled by a mask.abstract byte
xorAll()
Logically XORs all lane elements of this vector.abstract byte
xorAll(Mask<Byte> m)
Logically XORs all lane elements of this vector, selecting lane elements controlled by a mask.static ByteVector
zero(Species<Byte> species)
Returns a vector where all lane elements are set to the default primitive value.
Methods declared in class jdk.incubator.vector.Vector
abs, abs, add, add, bitSize, bitSizeForVectorLength, blend, cast, elementSize, elementType, equal, greaterThan, greaterThanEq, intoByteArray, intoByteArray, intoByteBuffer, intoByteBuffer, length, lessThan, lessThanEq, max, max, min, min, mul, mul, neg, neg, notEqual, rearrange, rearrange, reinterpret, reshape, rotateEL, rotateER, shape, shiftEL, shiftER, species, sub, sub, toShuffle




Field Detail

SPECIES_64
public static final Species<Byte> SPECIES_64
Species representingByteVector
s ofShape.S_64_BIT
.

SPECIES_128
public static final Species<Byte> SPECIES_128
Species representingByteVector
s ofShape.S_128_BIT
.

SPECIES_256
public static final Species<Byte> SPECIES_256
Species representingByteVector
s ofShape.S_256_BIT
.

SPECIES_512
public static final Species<Byte> SPECIES_512
Species representingByteVector
s ofShape.S_512_BIT
.

SPECIES_MAX
public static final Species<Byte> SPECIES_MAX
Species representingByteVector
s ofShape.S_Max_BIT
.

SPECIES_PREFERRED
public static final Species<Byte> SPECIES_PREFERRED
Preferred species forByteVector
s. A preferred species is a species of maximal bit size for the platform.


Method Detail

zero
public static ByteVector zero(Species<Byte> species)
Returns a vector where all lane elements are set to the default primitive value. Parameters:
species
 species of desired vector Returns:
 a zero vector of given species

fromByteArray
public static ByteVector fromByteArray(Species<Byte> species, byte[] a, int ix)
Loads a vector from a byte array starting at an offset.Bytes are composed into primitive lane elements according to the native byte order of the underlying platform
This method behaves as if it returns the result of calling the byte buffer, offset, and mask accepting
method
as follows:return this.fromByteBuffer(ByteBuffer.wrap(a), i, this.maskAllTrue());
 Parameters:
species
 species of desired vectora
 the byte arrayix
 the offset into the array Returns:
 a vector loaded from a byte array
 Throws:
IndexOutOfBoundsException
 ifi < 0
ori > a.length  (this.length() * this.elementSize() / Byte.SIZE)

fromByteArray
public static ByteVector fromByteArray(Species<Byte> species, byte[] a, int ix, Mask<Byte> m)
Loads a vector from a byte array starting at an offset and using a mask.Bytes are composed into primitive lane elements according to the native byte order of the underlying platform.
This method behaves as if it returns the result of calling the byte buffer, offset, and mask accepting
method
as follows:return this.fromByteBuffer(ByteBuffer.wrap(a), i, m);
 Parameters:
species
 species of desired vectora
 the byte arrayix
 the offset into the arraym
 the mask Returns:
 a vector loaded from a byte array
 Throws:
IndexOutOfBoundsException
 ifi < 0
ori > a.length  (this.length() * this.elementSize() / Byte.SIZE)
IndexOutOfBoundsException
 if the offset is< 0
, or> a.length
, for any vector lane indexN
where the mask at laneN
is seti >= a.length  (N * this.elementSize() / Byte.SIZE)

fromArray
public static ByteVector fromArray(Species<Byte> species, byte[] a, int i)
Loads a vector from an array starting at offset.For each vector lane, where
N
is the vector lane index, the array element at indexi + N
is placed into the resulting vector at lane indexN
. Parameters:
species
 species of desired vectora
 the arrayi
 the offset into the array Returns:
 the vector loaded from an array
 Throws:
IndexOutOfBoundsException
 ifi < 0
, ori > a.length  this.length()

fromArray
public static ByteVector fromArray(Species<Byte> species, byte[] a, int i, Mask<Byte> m)
Loads a vector from an array starting at offset and using a mask.For each vector lane, where
N
is the vector lane index, if the mask lane at indexN
is set then the array element at indexi + N
is placed into the resulting vector at lane indexN
, otherwise the default element value is placed into the resulting vector at lane indexN
. Parameters:
species
 species of desired vectora
 the arrayi
 the offset into the arraym
 the mask Returns:
 the vector loaded from an array
 Throws:
IndexOutOfBoundsException
 ifi < 0
, or for any vector lane indexN
where the mask at laneN
is seti > a.length  N

fromArray
public static ByteVector fromArray(Species<Byte> species, byte[] a, int i, int[] indexMap, int j)
Loads a vector from an array using indexes obtained from an index map.For each vector lane, where
N
is the vector lane index, the array element at indexi + indexMap[j + N]
is placed into the resulting vector at lane indexN
. Parameters:
species
 species of desired vectora
 the arrayi
 the offset into the array, may be negative if relative indexes in the index map compensate to produce a value within the array boundsindexMap
 the index mapj
 the offset into the index map Returns:
 the vector loaded from an array
 Throws:
IndexOutOfBoundsException
 ifj < 0
, orj > indexMap.length  this.length()
, or for any vector lane indexN
the result ofi + indexMap[j + N]
is< 0
or>= a.length

fromArray
public static ByteVector fromArray(Species<Byte> species, byte[] a, int i, Mask<Byte> m, int[] indexMap, int j)
Loads a vector from an array using indexes obtained from an index map and using a mask.For each vector lane, where
N
is the vector lane index, if the mask lane at indexN
is set then the array element at indexi + indexMap[j + N]
is placed into the resulting vector at lane indexN
. Parameters:
species
 species of desired vectora
 the arrayi
 the offset into the array, may be negative if relative indexes in the index map compensate to produce a value within the array boundsm
 the maskindexMap
 the index mapj
 the offset into the index map Returns:
 the vector loaded from an array
 Throws:
IndexOutOfBoundsException
 ifj < 0
, orj > indexMap.length  this.length()
, or for any vector lane indexN
where the mask at laneN
is set the result ofi + indexMap[j + N]
is< 0
or>= a.length

fromByteBuffer
public static ByteVector fromByteBuffer(Species<Byte> species, ByteBuffer bb, int ix)
Loads a vector from abyte buffer
starting at an offset into the byte buffer.Bytes are composed into primitive lane elements according to the native byte order of the underlying platform.
This method behaves as if it returns the result of calling the byte buffer, offset, and mask accepting
#fromByteBuffer(Species
method} as follows:, ByteBuffer, int, Mask) return this.fromByteBuffer(b, i, this.maskAllTrue())
 Parameters:
species
 species of desired vectorbb
 the byte bufferix
 the offset into the byte buffer Returns:
 a vector loaded from a byte buffer
 Throws:
IndexOutOfBoundsException
 if the offset is< 0
, or> b.limit()
, or if there are fewer thanthis.length() * this.elementSize() / Byte.SIZE
bytes remaining in the byte buffer from the given offset

fromByteBuffer
public static ByteVector fromByteBuffer(Species<Byte> species, ByteBuffer bb, int ix, Mask<Byte> m)
Loads a vector from abyte buffer
starting at an offset into the byte buffer and using a mask.This method behaves as if the byte buffer is viewed as a primitive
buffer
for the primitive element type, according to the native byte order of the underlying platform, and the returned vector is loaded with a mask from a primitive array obtained from the primitive buffer. The following pseudocode expresses the behaviour, where is the primitive buffer type,e
is the primitive element type, andESpecies<S>
is the primitive species fore
:EBuffer eb = b.duplicate(). order(ByteOrder.nativeOrder()).position(i). asEBuffer(); e[] es = new e[this.length()]; for (int n = 0; n < t.length; n++) { if (m.isSet(n)) es[n] = eb.get(n); } Vector<E> r = ((ESpecies<S>)this).fromArray(es, 0, m);
 Parameters:
species
 species of desired vectorbb
 the byte bufferix
 the offset into the byte bufferm
 the mask Returns:
 a vector loaded from a byte buffer
 Throws:
IndexOutOfBoundsException
 if the offset is< 0
, or> b.limit()
, for any vector lane indexN
where the mask at laneN
is seti >= b.limit()  (N * this.elementSize() / Byte.SIZE)

broadcast
public static ByteVector broadcast(Species<Byte> s, byte e)
Returns a vector where all lane elements are set to the primitive valuee
. Parameters:
s
 species of the desired vectore
 the value Returns:
 a vector of vector where all lane elements are set to
the primitive value
e

scalars
public static ByteVector scalars(Species<Byte> s, byte... es)
Returns a vector where each lane element is set to a given primitive value.For each vector lane, where
N
is the vector lane index, the the primitive value at indexN
is placed into the resulting vector at lane indexN
. Parameters:
s
 species of the desired vectores
 the given primitive values Returns:
 a vector where each lane element is set to a given primitive value
 Throws:
IndexOutOfBoundsException
 ifes.length < this.length()

single
public static final ByteVector single(Species<Byte> s, byte e)
Returns a vector where the first lane element is set to the primtive valuee
, all other lane elements are set to the default value. Parameters:
s
 species of the desired vectore
 the value Returns:
 a vector where the first lane element is set to the primitive
value
e

random
public static ByteVector random(Species<Byte> s)
Returns a vector where each lane element is set to a randomly generated primitive value. The semantics are equivalent to calling (byte)ThreadLocalRandom.nextInt()
 Parameters:
s
 species of the desired vector Returns:
 a vector where each lane elements is set to a randomly generated primitive value

add
public abstract ByteVector add(byte s)
Adds this vector to the broadcast of an input scalar.This is a vector binary operation where the primitive addition operation (
+
) is applied to lane elements. Parameters:
s
 the input scalar Returns:
 the result of adding this vector to the broadcast of an input scalar

add
public abstract ByteVector add(byte s, Mask<Byte> m)
Adds this vector to broadcast of an input scalar, selecting lane elements controlled by a mask.This is a vector binary operation where the primitive addition operation (
+
) is applied to lane elements. Parameters:
s
 the input scalarm
 the mask controlling lane selection Returns:
 the result of adding this vector to the broadcast of an input scalar

sub
public abstract ByteVector sub(byte s)
Subtracts the broadcast of an input scalar from this vector.This is a vector binary operation where the primitive subtraction operation (

) is applied to lane elements. Parameters:
s
 the input scalar Returns:
 the result of subtracting the broadcast of an input scalar from this vector

sub
public abstract ByteVector sub(byte s, Mask<Byte> m)
Subtracts the broadcast of an input scalar from this vector, selecting lane elements controlled by a mask.This is a vector binary operation where the primitive subtraction operation (

) is applied to lane elements. Parameters:
s
 the input scalarm
 the mask controlling lane selection Returns:
 the result of subtracting the broadcast of an input scalar from this vector

mul
public abstract ByteVector mul(byte s)
Multiplies this vector with the broadcast of an input scalar.This is a vector binary operation where the primitive multiplication operation (
*
) is applied to lane elements. Parameters:
s
 the input scalar Returns:
 the result of multiplying this vector with the broadcast of an input scalar

mul
public abstract ByteVector mul(byte s, Mask<Byte> m)
Multiplies this vector with the broadcast of an input scalar, selecting lane elements controlled by a mask.This is a vector binary operation where the primitive multiplication operation (
*
) is applied to lane elements. Parameters:
s
 the input scalarm
 the mask controlling lane selection Returns:
 the result of multiplying this vector with the broadcast of an input scalar

min
public abstract ByteVector min(byte s)
Returns the minimum of this vector and the broadcast of an input scalar.This is a vector binary operation where the operation
(a, b) > Math.min(a, b)
is applied to lane elements. Parameters:
s
 the input scalar Returns:
 the minimum of this vector and the broadcast of an input scalar

max
public abstract ByteVector max(byte s)
Returns the maximum of this vector and the broadcast of an input scalar.This is a vector binary operation where the operation
(a, b) > Math.max(a, b)
is applied to lane elements. Parameters:
s
 the input scalar Returns:
 the maximum of this vector and the broadcast of an input scalar

equal
public abstract Mask<Byte> equal(byte s)
Tests if this vector is equal to the broadcast of an input scalar.This is a vector binary test operation where the primitive equals operation (
==
) is applied to lane elements. Parameters:
s
 the input scalar Returns:
 the result mask of testing if this vector is equal to the broadcast of an input scalar

notEqual
public abstract Mask<Byte> notEqual(byte s)
Tests if this vector is not equal to the broadcast of an input scalar.This is a vector binary test operation where the primitive not equals operation (
!=
) is applied to lane elements. Parameters:
s
 the input scalar Returns:
 the result mask of testing if this vector is not equal to the broadcast of an input scalar

lessThan
public abstract Mask<Byte> lessThan(byte s)
Tests if this vector is less than the broadcast of an input scalar.This is a vector binary test operation where the primitive less than operation (
<
) is applied to lane elements. Parameters:
s
 the input scalar Returns:
 the mask result of testing if this vector is less than the broadcast of an input scalar

lessThanEq
public abstract Mask<Byte> lessThanEq(byte s)
Tests if this vector is less or equal to the broadcast of an input scalar.This is a vector binary test operation where the primitive less than or equal to operation (
<=
) is applied to lane elements. Parameters:
s
 the input scalar Returns:
 the mask result of testing if this vector is less than or equal to the broadcast of an input scalar

greaterThan
public abstract Mask<Byte> greaterThan(byte s)
Tests if this vector is greater than the broadcast of an input scalar.This is a vector binary test operation where the primitive greater than operation (
>
) is applied to lane elements. Parameters:
s
 the input scalar Returns:
 the mask result of testing if this vector is greater than the broadcast of an input scalar

greaterThanEq
public abstract Mask<Byte> greaterThanEq(byte s)
Tests if this vector is greater than or equal to the broadcast of an input scalar.This is a vector binary test operation where the primitive greater than or equal to operation (
>=
) is applied to lane elements. Parameters:
s
 the input scalar Returns:
 the mask result of testing if this vector is greater than or equal to the broadcast of an input scalar

blend
public abstract ByteVector blend(byte s, Mask<Byte> m)
Blends the lane elements of this vector with those of the broadcast of an input scalar, selecting lanes controlled by a mask.For each lane of the mask, at lane index
N
, if the mask lane is set then the lane element atN
from the input vector is selected and placed into the resulting vector atN
, otherwise the the lane element atN
from this input vector is selected and placed into the resulting vector atN
. Parameters:
s
 the input scalarm
 the mask controlling lane selection Returns:
 the result of blending the lane elements of this vector with those of the broadcast of an input scalar

and
public abstract ByteVector and(Vector<Byte> v)
Bitwise ANDs this vector with an input vector.This is a vector binary operation where the primitive bitwise AND operation (
&
) is applied to lane elements. Parameters:
v
 the input vector Returns:
 the bitwise AND of this vector with the input vector

and
public abstract ByteVector and(byte s)
Bitwise ANDs this vector with the broadcast of an input scalar.This is a vector binary operation where the primitive bitwise AND operation (
&
) is applied to lane elements. Parameters:
s
 the input scalar Returns:
 the bitwise AND of this vector with the broadcast of an input scalar

and
public abstract ByteVector and(Vector<Byte> v, Mask<Byte> m)
Bitwise ANDs this vector with an input vector, selecting lane elements controlled by a mask.This is a vector binary operation where the primitive bitwise AND operation (
&
) is applied to lane elements. Parameters:
v
 the input vectorm
 the mask controlling lane selection Returns:
 the bitwise AND of this vector with the input vector

and
public abstract ByteVector and(byte s, Mask<Byte> m)
Bitwise ANDs this vector with the broadcast of an input scalar, selecting lane elements controlled by a mask.This is a vector binary operation where the primitive bitwise AND operation (
&
) is applied to lane elements. Parameters:
s
 the input scalarm
 the mask controlling lane selection Returns:
 the bitwise AND of this vector with the broadcast of an input scalar

or
public abstract ByteVector or(Vector<Byte> v)
Bitwise ORs this vector with an input vector.This is a vector binary operation where the primitive bitwise OR operation (

) is applied to lane elements. Parameters:
v
 the input vector Returns:
 the bitwise OR of this vector with the input vector

or
public abstract ByteVector or(byte s)
Bitwise ORs this vector with the broadcast of an input scalar.This is a vector binary operation where the primitive bitwise OR operation (

) is applied to lane elements. Parameters:
s
 the input scalar Returns:
 the bitwise OR of this vector with the broadcast of an input scalar

or
public abstract ByteVector or(Vector<Byte> v, Mask<Byte> m)
Bitwise ORs this vector with an input vector, selecting lane elements controlled by a mask.This is a vector binary operation where the primitive bitwise OR operation (

) is applied to lane elements. Parameters:
v
 the input vectorm
 the mask controlling lane selection Returns:
 the bitwise OR of this vector with the input vector

or
public abstract ByteVector or(byte s, Mask<Byte> m)
Bitwise ORs this vector with the broadcast of an input scalar, selecting lane elements controlled by a mask.This is a vector binary operation where the primitive bitwise OR operation (

) is applied to lane elements. Parameters:
s
 the input scalarm
 the mask controlling lane selection Returns:
 the bitwise OR of this vector with the broadcast of an input scalar

xor
public abstract ByteVector xor(Vector<Byte> v)
Bitwise XORs this vector with an input vector.This is a vector binary operation where the primitive bitwise XOR operation (
^
) is applied to lane elements. Parameters:
v
 the input vector Returns:
 the bitwise XOR of this vector with the input vector

xor
public abstract ByteVector xor(byte s)
Bitwise XORs this vector with the broadcast of an input scalar.This is a vector binary operation where the primitive bitwise XOR operation (
^
) is applied to lane elements. Parameters:
s
 the input scalar Returns:
 the bitwise XOR of this vector with the broadcast of an input scalar

xor
public abstract ByteVector xor(Vector<Byte> v, Mask<Byte> m)
Bitwise XORs this vector with an input vector, selecting lane elements controlled by a mask.This is a vector binary operation where the primitive bitwise XOR operation (
^
) is applied to lane elements. Parameters:
v
 the input vectorm
 the mask controlling lane selection Returns:
 the bitwise XOR of this vector with the input vector

xor
public abstract ByteVector xor(byte s, Mask<Byte> m)
Bitwise XORs this vector with the broadcast of an input scalar, selecting lane elements controlled by a mask.This is a vector binary operation where the primitive bitwise XOR operation (
^
) is applied to lane elements. Parameters:
s
 the input scalarm
 the mask controlling lane selection Returns:
 the bitwise XOR of this vector with the broadcast of an input scalar

not
public abstract ByteVector not()
Bitwise NOTs this vector.This is a vector unary operation where the primitive bitwise NOT operation (
~
) is applied to lane elements. Returns:
 the bitwise NOT of this vector

not
public abstract ByteVector not(Mask<Byte> m)
Bitwise NOTs this vector, selecting lane elements controlled by a mask.This is a vector unary operation where the primitive bitwise NOT operation (
~
) is applied to lane elements. Parameters:
m
 the mask controlling lane selection Returns:
 the bitwise NOT of this vector

shiftL
public abstract ByteVector shiftL(int s)
Logically left shifts this vector by the broadcast of an input scalar.This is a vector binary operation where the primitive logical left shift operation (
<<
) is applied to lane elements to left shift the element by shift value as specified by the input scalar. Only the 3 lowestorder bits of shift value are used. It is as if the shift value were subjected to a bitwise logical AND operator (&
) with the mask value 0x7. The shift distance actually used is therefore always in the range 0 to 7, inclusive. Parameters:
s
 the input scalar; the number of the bits to left shift Returns:
 the result of logically left shifting left this vector by the broadcast of an input scalar

shiftL
public abstract ByteVector shiftL(int s, Mask<Byte> m)
Logically left shifts this vector by the broadcast of an input scalar, selecting lane elements controlled by a mask.This is a vector binary operation where the primitive logical left shift operation (
<<
) is applied to lane elements to left shift the element by shift value as specified by the input scalar. Only the 3 lowestorder bits of shift value are used. It is as if the shift value were subjected to a bitwise logical AND operator (&
) with the mask value 0x7. The shift distance actually used is therefore always in the range 0 to 7, inclusive. Parameters:
s
 the input scalar; the number of the bits to left shiftm
 the mask controlling lane selection Returns:
 the result of logically left shifting left this vector by the broadcast of an input scalar

shiftR
public abstract ByteVector shiftR(int s)
Logically right shifts (or unsigned right shifts) this vector by the broadcast of an input scalar.This is a vector binary operation where the primitive logical right shift operation (
>>>
) is applied to lane elements to logically right shift the element by shift value as specified by the input scalar. Only the 3 lowestorder bits of shift value are used. It is as if the shift value were subjected to a bitwise logical AND operator (&
) with the mask value 0x7. The shift distance actually used is therefore always in the range 0 to 7, inclusive. Parameters:
s
 the input scalar; the number of the bits to right shift Returns:
 the result of logically right shifting this vector by the broadcast of an input scalar

shiftR
public abstract ByteVector shiftR(int s, Mask<Byte> m)
Logically right shifts (or unsigned right shifts) this vector by the broadcast of an input scalar, selecting lane elements controlled by a mask.This is a vector binary operation where the primitive logical right shift operation (
>>>
) is applied to lane elements to logically right shift the element by shift value as specified by the input scalar. Only the 3 lowestorder bits of shift value are used. It is as if the shift value were subjected to a bitwise logical AND operator (&
) with the mask value 0x7. The shift distance actually used is therefore always in the range 0 to 7, inclusive. Parameters:
s
 the input scalar; the number of the bits to right shiftm
 the mask controlling lane selection Returns:
 the result of logically right shifting this vector by the broadcast of an input scalar

aShiftR
public abstract ByteVector aShiftR(int s)
Arithmetically right shifts (or signed right shifts) this vector by the broadcast of an input scalar.This is a vector binary operation where the primitive arithmetic right shift operation (
>>
) is applied to lane elements to arithmetically right shift the element by shift value as specified by the input scalar. Only the 3 lowestorder bits of shift value are used. It is as if the shift value were subjected to a bitwise logical AND operator (&
) with the mask value 0x7. The shift distance actually used is therefore always in the range 0 to 7, inclusive. Parameters:
s
 the input scalar; the number of the bits to right shift Returns:
 the result of arithmetically right shifting this vector by the broadcast of an input scalar

aShiftR
public abstract ByteVector aShiftR(int s, Mask<Byte> m)
Arithmetically right shifts (or signed right shifts) this vector by the broadcast of an input scalar, selecting lane elements controlled by a mask.This is a vector binary operation where the primitive arithmetic right shift operation (
>>
) is applied to lane elements to arithmetically right shift the element by shift value as specified by the input scalar. Only the 3 lowestorder bits of shift value are used. It is as if the shift value were subjected to a bitwise logical AND operator (&
) with the mask value 0x7. The shift distance actually used is therefore always in the range 0 to 7, inclusive. Parameters:
s
 the input scalar; the number of the bits to right shiftm
 the mask controlling lane selection Returns:
 the result of arithmetically right shifting this vector by the broadcast of an input scalar

addAll
public abstract byte addAll()
Adds all lane elements of this vector.This is an associative vector reduction operation where the addition operation (
+
) is applied to lane elements, and the identity value is0
. Returns:
 the addition of all the lane elements of this vector

addAll
public abstract byte addAll(Mask<Byte> m)
Adds all lane elements of this vector, selecting lane elements controlled by a mask.This is an associative vector reduction operation where the addition operation (
+
) is applied to lane elements, and the identity value is0
. Parameters:
m
 the mask controlling lane selection Returns:
 the addition of the selected lane elements of this vector

mulAll
public abstract byte mulAll()
Multiplies all lane elements of this vector.This is an associative vector reduction operation where the multiplication operation (
*
) is applied to lane elements, and the identity value is1
. Returns:
 the multiplication of all the lane elements of this vector

mulAll
public abstract byte mulAll(Mask<Byte> m)
Multiplies all lane elements of this vector, selecting lane elements controlled by a mask.This is an associative vector reduction operation where the multiplication operation (
*
) is applied to lane elements, and the identity value is1
. Parameters:
m
 the mask controlling lane selection Returns:
 the multiplication of all the lane elements of this vector

minAll
public abstract byte minAll()
Returns the minimum lane element of this vector.This is an associative vector reduction operation where the operation
(a, b) > Math.min(a, b)
is applied to lane elements, and the identity value isByte.MAX_VALUE
. Returns:
 the minimum lane element of this vector

minAll
public abstract byte minAll(Mask<Byte> m)
Returns the minimum lane element of this vector, selecting lane elements controlled by a mask.This is an associative vector reduction operation where the operation
(a, b) > Math.min(a, b)
is applied to lane elements, and the identity value isByte.MAX_VALUE
. Parameters:
m
 the mask controlling lane selection Returns:
 the minimum lane element of this vector

maxAll
public abstract byte maxAll()
Returns the maximum lane element of this vector.This is an associative vector reduction operation where the operation
(a, b) > Math.max(a, b)
is applied to lane elements, and the identity value isByte.MIN_VALUE
. Returns:
 the maximum lane element of this vector

maxAll
public abstract byte maxAll(Mask<Byte> m)
Returns the maximum lane element of this vector, selecting lane elements controlled by a mask.This is an associative vector reduction operation where the operation
(a, b) > Math.max(a, b)
is applied to lane elements, and the identity value isByte.MIN_VALUE
. Parameters:
m
 the mask controlling lane selection Returns:
 the maximum lane element of this vector

orAll
public abstract byte orAll()
Logically ORs all lane elements of this vector.This is an associative vector reduction operation where the logical OR operation (

) is applied to lane elements, and the identity value is0
. Returns:
 the logical OR all the lane elements of this vector

orAll
public abstract byte orAll(Mask<Byte> m)
Logically ORs all lane elements of this vector, selecting lane elements controlled by a mask.This is an associative vector reduction operation where the logical OR operation (

) is applied to lane elements, and the identity value is0
. Parameters:
m
 the mask controlling lane selection Returns:
 the logical OR all the lane elements of this vector

andAll
public abstract byte andAll()
Logically ANDs all lane elements of this vector.This is an associative vector reduction operation where the logical AND operation (

) is applied to lane elements, and the identity value is1
. Returns:
 the logical AND all the lane elements of this vector

andAll
public abstract byte andAll(Mask<Byte> m)
Logically ANDs all lane elements of this vector, selecting lane elements controlled by a mask.This is an associative vector reduction operation where the logical AND operation (

) is applied to lane elements, and the identity value is1
. Parameters:
m
 the mask controlling lane selection Returns:
 the logical AND all the lane elements of this vector

xorAll
public abstract byte xorAll()
Logically XORs all lane elements of this vector.This is an associative vector reduction operation where the logical XOR operation (
^
) is applied to lane elements, and the identity value is0
. Returns:
 the logical XOR all the lane elements of this vector

xorAll
public abstract byte xorAll(Mask<Byte> m)
Logically XORs all lane elements of this vector, selecting lane elements controlled by a mask.This is an associative vector reduction operation where the logical XOR operation (
^
) is applied to lane elements, and the identity value is0
. Parameters:
m
 the mask controlling lane selection Returns:
 the logical XOR all the lane elements of this vector

get
public abstract byte get(int i)
Gets the lane element at lane indexi
 Parameters:
i
 the lane index Returns:
 the lane element at lane index
i
 Throws:
IllegalArgumentException
 if the index is is out of range (< 0  >= length()
)

with
public abstract ByteVector with(int i, byte e)
Replaces the lane element of this vector at lane indexi
with valuee
.This is a crosslane operation and behaves as if it returns the result of blending this vector with an input vector that is the result of broadcasting
e
and a mask that has only one lane set at lane indexi
. Parameters:
i
 the lane index of the lane element to be replacede
 the value to be placed Returns:
 the result of replacing the lane element of this vector at lane
index
i
with valuee
.  Throws:
IllegalArgumentException
 if the index is is out of range (< 0  >= length()
)

toArray
public final byte[] toArray()
Returns an array containing the lane elements of this vector.This method behaves as if it
intoArray(byte[], int)
stores} this vector into an allocated array and returns the array as follows:byte[] a = new byte[this.length()]; this.intoArray(a, 0); return a;
 Returns:
 an array containing the the lane elements of this vector

intoArray
public abstract void intoArray(byte[] a, int i)
Stores this vector into an array starting at offset.For each vector lane, where
N
is the vector lane index, the lane element at indexN
is stored into the array at indexi + N
. Parameters:
a
 the arrayi
 the offset into the array Throws:
IndexOutOfBoundsException
 ifi < 0
, ori > a.length  this.length()

intoArray
public abstract void intoArray(byte[] a, int i, Mask<Byte> m)
Stores this vector into an array starting at offset and using a mask.For each vector lane, where
N
is the vector lane index, if the mask lane at indexN
is set then the lane element at indexN
is stored into the array indexi + N
. Parameters:
a
 the arrayi
 the offset into the arraym
 the mask Throws:
IndexOutOfBoundsException
 ifi < 0
, or for any vector lane indexN
where the mask at laneN
is seti >= a.length  N

intoArray
public void intoArray(byte[] a, int i, int[] indexMap, int j)
Stores this vector into an array using indexes obtained from an index map.For each vector lane, where
N
is the vector lane index, the lane element at indexN
is stored into the array at indexi + indexMap[j + N]
. Parameters:
a
 the arrayi
 the offset into the array, may be negative if relative indexes in the index map compensate to produce a value within the array boundsindexMap
 the index mapj
 the offset into the index map Throws:
IndexOutOfBoundsException
 ifj < 0
, orj > indexMap.length  this.length()
, or for any vector lane indexN
the result ofi + indexMap[j + N]
is< 0
or>= a.length

intoArray
public void intoArray(byte[] a, int i, Mask<Byte> m, int[] indexMap, int j)
Stores this vector into an array using indexes obtained from an index map and using a mask.For each vector lane, where
N
is the vector lane index, if the mask lane at indexN
is set then the lane element at indexN
is stored into the array at indexi + indexMap[j + N]
. Parameters:
a
 the arrayi
 the offset into the array, may be negative if relative indexes in the index map compensate to produce a value within the array boundsm
 the maskindexMap
 the index mapj
 the offset into the index map Throws:
IndexOutOfBoundsException
 ifj < 0
, orj > indexMap.length  this.length()
, or for any vector lane indexN
where the mask at laneN
is set the result ofi + indexMap[j + N]
is< 0
or>= a.length

