- java.lang.Object
-
- jdk.incubator.vector.Vector<Integer>
-
- jdk.incubator.vector.IntVector
-
-
Field Summary
Fields Modifier and Type Field Description static Species<Integer>
SPECIES_128
Species representingIntVector
s ofShape.S_128_BIT
.static Species<Integer>
SPECIES_256
Species representingIntVector
s ofShape.S_256_BIT
.static Species<Integer>
SPECIES_512
Species representingIntVector
s ofShape.S_512_BIT
.static Species<Integer>
SPECIES_64
Species representingIntVector
s ofShape.S_64_BIT
.static Species<Integer>
SPECIES_MAX
Species representingIntVector
s ofShape.S_Max_BIT
.static Species<Integer>
SPECIES_PREFERRED
Preferred species forIntVector
s.
-
Method Summary
Modifier and Type Method Description abstract IntVector
add(int s)
Adds this vector to the broadcast of an input scalar.abstract IntVector
add(int s, Mask<Integer> m)
Adds this vector to broadcast of an input scalar, selecting lane elements controlled by a mask.abstract int
addAll()
Adds all lane elements of this vector.abstract int
addAll(Mask<Integer> m)
Adds all lane elements of this vector, selecting lane elements controlled by a mask.abstract IntVector
and(int s)
Bitwise ANDs this vector with the broadcast of an input scalar.abstract IntVector
and(int s, Mask<Integer> m)
Bitwise ANDs this vector with the broadcast of an input scalar, selecting lane elements controlled by a mask.abstract IntVector
and(Vector<Integer> v)
Bitwise ANDs this vector with an input vector.abstract IntVector
and(Vector<Integer> v, Mask<Integer> m)
Bitwise ANDs this vector with an input vector, selecting lane elements controlled by a mask.abstract int
andAll()
Logically ANDs all lane elements of this vector.abstract int
andAll(Mask<Integer> m)
Logically ANDs all lane elements of this vector, selecting lane elements controlled by a mask.abstract IntVector
aShiftR(int s)
Arithmetically right shifts (or signed right shifts) this vector by the broadcast of an input scalar.abstract IntVector
aShiftR(int s, Mask<Integer> 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 IntVector
aShiftR(Vector<Integer> v)
Arithmetically right shifts (or signed right shifts) this vector by an input vector.IntVector
aShiftR(Vector<Integer> v, Mask<Integer> m)
Arithmetically right shifts (or signed right shifts) this vector by an input vector, selecting lane elements controlled by a mask.abstract IntVector
blend(int s, Mask<Integer> m)
Blends the lane elements of this vector with those of the broadcast of an input scalar, selecting lanes controlled by a mask.static IntVector
broadcast(Species<Integer> s, int e)
Returns a vector where all lane elements are set to the primitive valuee
.abstract Mask<Integer>
equal(int s)
Tests if this vector is equal to the broadcast of an input scalar.static IntVector
fromArray(Species<Integer> species, int[] a, int i)
Loads a vector from an array starting at offset.static IntVector
fromArray(Species<Integer> species, int[] a, int i, int[] indexMap, int j)
Loads a vector from an array using indexes obtained from an index map.static IntVector
fromArray(Species<Integer> species, int[] a, int i, Mask<Integer> m)
Loads a vector from an array starting at offset and using a mask.static IntVector
fromArray(Species<Integer> species, int[] a, int i, Mask<Integer> m, int[] indexMap, int j)
Loads a vector from an array using indexes obtained from an index map and using a mask.static IntVector
fromByteArray(Species<Integer> species, byte[] a, int ix)
Loads a vector from a byte array starting at an offset.static IntVector
fromByteArray(Species<Integer> species, byte[] a, int ix, Mask<Integer> m)
Loads a vector from a byte array starting at an offset and using a mask.static IntVector
fromByteBuffer(Species<Integer> species, ByteBuffer bb, int ix)
Loads a vector from abyte buffer
starting at an offset into the byte buffer.static IntVector
fromByteBuffer(Species<Integer> species, ByteBuffer bb, int ix, Mask<Integer> m)
Loads a vector from abyte buffer
starting at an offset into the byte buffer and using a mask.abstract int
get(int i)
Gets the lane element at lane indexi
abstract Mask<Integer>
greaterThan(int s)
Tests if this vector is greater than the broadcast of an input scalar.abstract Mask<Integer>
greaterThanEq(int s)
Tests if this vector is greater than or equal to the broadcast of an input scalar.abstract void
intoArray(int[] a, int i)
Stores this vector into an array starting at offset.abstract void
intoArray(int[] a, int i, int[] indexMap, int j)
Stores this vector into an array using indexes obtained from an index map.abstract void
intoArray(int[] a, int i, Mask<Integer> m)
Stores this vector into an array starting at offset and using a mask.abstract void
intoArray(int[] a, int i, Mask<Integer> m, int[] indexMap, int j)
Stores this vector into an array using indexes obtained from an index map and using a mask.abstract Mask<Integer>
lessThan(int s)
Tests if this vector is less than the broadcast of an input scalar.abstract Mask<Integer>
lessThanEq(int s)
Tests if this vector is less or equal to the broadcast of an input scalar.abstract IntVector
max(int s)
Returns the maximum of this vector and the broadcast of an input scalar.abstract int
maxAll()
Returns the maximum lane element of this vector.abstract int
maxAll(Mask<Integer> m)
Returns the maximum lane element of this vector, selecting lane elements controlled by a mask.abstract IntVector
min(int s)
Returns the minimum of this vector and the broadcast of an input scalar.abstract int
minAll()
Returns the minimum lane element of this vector.abstract int
minAll(Mask<Integer> m)
Returns the minimum lane element of this vector, selecting lane elements controlled by a mask.abstract IntVector
mul(int s)
Multiplies this vector with the broadcast of an input scalar.abstract IntVector
mul(int s, Mask<Integer> m)
Multiplies this vector with the broadcast of an input scalar, selecting lane elements controlled by a mask.abstract int
mulAll()
Multiplies all lane elements of this vector.abstract int
mulAll(Mask<Integer> m)
Multiplies all lane elements of this vector, selecting lane elements controlled by a mask.abstract IntVector
not()
Bitwise NOTs this vector.abstract IntVector
not(Mask<Integer> m)
Bitwise NOTs this vector, selecting lane elements controlled by a mask.abstract Mask<Integer>
notEqual(int s)
Tests if this vector is not equal to the broadcast of an input scalar.abstract IntVector
or(int s)
Bitwise ORs this vector with the broadcast of an input scalar.abstract IntVector
or(int s, Mask<Integer> m)
Bitwise ORs this vector with the broadcast of an input scalar, selecting lane elements controlled by a mask.abstract IntVector
or(Vector<Integer> v)
Bitwise ORs this vector with an input vector.abstract IntVector
or(Vector<Integer> v, Mask<Integer> m)
Bitwise ORs this vector with an input vector, selecting lane elements controlled by a mask.abstract int
orAll()
Logically ORs all lane elements of this vector.abstract int
orAll(Mask<Integer> m)
Logically ORs all lane elements of this vector, selecting lane elements controlled by a mask.static IntVector
random(Species<Integer> s)
Returns a vector where each lane element is set to a randomly generated primitive value.IntVector
rotateL(int s)
Rotates left this vector by the broadcast of an input scalar.IntVector
rotateL(int s, Mask<Integer> m)
Rotates left this vector by the broadcast of an input scalar, selecting lane elements controlled by a mask.IntVector
rotateR(int s)
Rotates right this vector by the broadcast of an input scalar.IntVector
rotateR(int s, Mask<Integer> m)
Rotates right this vector by the broadcast of an input scalar, selecting lane elements controlled by a mask.static IntVector
scalars(Species<Integer> s, int... es)
Returns a vector where each lane element is set to a given primitive value.abstract IntVector
shiftL(int s)
Logically left shifts this vector by the broadcast of an input scalar.abstract IntVector
shiftL(int s, Mask<Integer> m)
Logically left shifts this vector by the broadcast of an input scalar, selecting lane elements controlled by a mask.abstract IntVector
shiftL(Vector<Integer> v)
Logically left shifts this vector by an input vector.IntVector
shiftL(Vector<Integer> v, Mask<Integer> m)
Logically left shifts this vector by an input vector, selecting lane elements controlled by a mask.abstract IntVector
shiftR(int s)
Logically right shifts (or unsigned right shifts) this vector by the broadcast of an input scalar.abstract IntVector
shiftR(int s, Mask<Integer> m)
Logically right shifts (or unsigned right shifts) this vector by the broadcast of an input scalar, selecting lane elements controlled by a mask.abstract IntVector
shiftR(Vector<Integer> v)
Logically right shifts (or unsigned right shifts) this vector by an input vector.IntVector
shiftR(Vector<Integer> v, Mask<Integer> m)
Logically right shifts (or unsigned right shifts) this vector by an input vector, selecting lane elements controlled by a mask.static IntVector
single(Species<Integer> s, int 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 IntVector
sub(int s)
Subtracts the broadcast of an input scalar from this vector.abstract IntVector
sub(int s, Mask<Integer> m)
Subtracts the broadcast of an input scalar from this vector, selecting lane elements controlled by a mask.int[]
toArray()
Returns an array containing the lane elements of this vector.abstract IntVector
with(int i, int e)
Replaces the lane element of this vector at lane indexi
with valuee
.abstract IntVector
xor(int s)
Bitwise XORs this vector with the broadcast of an input scalar.abstract IntVector
xor(int s, Mask<Integer> m)
Bitwise XORs this vector with the broadcast of an input scalar, selecting lane elements controlled by a mask.abstract IntVector
xor(Vector<Integer> v)
Bitwise XORs this vector with an input vector.abstract IntVector
xor(Vector<Integer> v, Mask<Integer> m)
Bitwise XORs this vector with an input vector, selecting lane elements controlled by a mask.abstract int
xorAll()
Logically XORs all lane elements of this vector.abstract int
xorAll(Mask<Integer> m)
Logically XORs all lane elements of this vector, selecting lane elements controlled by a mask.static IntVector
zero(Species<Integer> 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<Integer> SPECIES_64
Species representingIntVector
s ofShape.S_64_BIT
.
-
SPECIES_128
public static final Species<Integer> SPECIES_128
Species representingIntVector
s ofShape.S_128_BIT
.
-
SPECIES_256
public static final Species<Integer> SPECIES_256
Species representingIntVector
s ofShape.S_256_BIT
.
-
SPECIES_512
public static final Species<Integer> SPECIES_512
Species representingIntVector
s ofShape.S_512_BIT
.
-
SPECIES_MAX
public static final Species<Integer> SPECIES_MAX
Species representingIntVector
s ofShape.S_Max_BIT
.
-
-
Method Detail
-
zero
public static IntVector zero(Species<Integer> 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 IntVector fromByteArray(Species<Integer> 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 IntVector fromByteArray(Species<Integer> species, byte[] a, int ix, Mask<Integer> 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 IntVector fromArray(Species<Integer> species, int[] 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 IntVector fromArray(Species<Integer> species, int[] a, int i, Mask<Integer> 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 IntVector fromArray(Species<Integer> species, int[] 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 IntVector fromArray(Species<Integer> species, int[] a, int i, Mask<Integer> 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 IntVector fromByteBuffer(Species<Integer> 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 IntVector fromByteBuffer(Species<Integer> species, ByteBuffer bb, int ix, Mask<Integer> 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 IntVector broadcast(Species<Integer> s, int 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 IntVector scalars(Species<Integer> s, int... 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 IntVector single(Species<Integer> s, int 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 IntVector random(Species<Integer> s)
Returns a vector where each lane element is set to a randomly generated primitive value. The semantics are equivalent to callingThreadLocalRandom.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 IntVector add(int 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 IntVector add(int s, Mask<Integer> 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 IntVector sub(int 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 IntVector sub(int s, Mask<Integer> 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 IntVector mul(int 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 IntVector mul(int s, Mask<Integer> 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 IntVector min(int 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 IntVector max(int 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<Integer> equal(int 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<Integer> notEqual(int 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<Integer> lessThan(int 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<Integer> lessThanEq(int 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<Integer> greaterThan(int 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<Integer> greaterThanEq(int 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 IntVector blend(int s, Mask<Integer> 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 IntVector and(Vector<Integer> 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 IntVector and(int 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 IntVector and(Vector<Integer> v, Mask<Integer> 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 IntVector and(int s, Mask<Integer> 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 IntVector or(Vector<Integer> 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 IntVector or(int 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 IntVector or(Vector<Integer> v, Mask<Integer> 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 IntVector or(int s, Mask<Integer> 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 IntVector xor(Vector<Integer> 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 IntVector xor(int 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 IntVector xor(Vector<Integer> v, Mask<Integer> 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 IntVector xor(int s, Mask<Integer> 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 IntVector 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 IntVector not(Mask<Integer> 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 IntVector 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.- 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 IntVector shiftL(int s, Mask<Integer> 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.- 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 this vector by the broadcast of an input scalar
-
shiftL
public abstract IntVector shiftL(Vector<Integer> v)
Logically left shifts this vector by an input vector.This is a vector binary operation where the primitive logical left shift operation (
<<
) is applied to lane elements.- Parameters:
v
- the input vector- Returns:
- the result of logically left shifting this vector by the input vector
-
shiftL
public IntVector shiftL(Vector<Integer> v, Mask<Integer> m)
Logically left shifts this vector by an input vector, 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.- Parameters:
v
- the input vectorm
- the mask controlling lane selection- Returns:
- the result of logically left shifting this vector by the input vector
-
shiftR
public abstract IntVector 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.- 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 IntVector shiftR(int s, Mask<Integer> 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.- 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
-
shiftR
public abstract IntVector shiftR(Vector<Integer> v)
Logically right shifts (or unsigned right shifts) this vector by an input vector.This is a vector binary operation where the primitive logical right shift operation (
>>>
) is applied to lane elements.- Parameters:
v
- the input vector- Returns:
- the result of logically right shifting this vector by the input vector
-
shiftR
public IntVector shiftR(Vector<Integer> v, Mask<Integer> m)
Logically right shifts (or unsigned right shifts) this vector by an input vector, 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.- Parameters:
v
- the input vectorm
- the mask controlling lane selection- Returns:
- the result of logically right shifting this vector by the input vector
-
aShiftR
public abstract IntVector 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.- 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 IntVector aShiftR(int s, Mask<Integer> 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.- 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
-
aShiftR
public abstract IntVector aShiftR(Vector<Integer> v)
Arithmetically right shifts (or signed right shifts) this vector by an input vector.This is a vector binary operation where the primitive arithmetic right shift operation (
>>
) is applied to lane elements.- Parameters:
v
- the input vector- Returns:
- the result of arithmetically right shifting this vector by the input vector
-
aShiftR
public IntVector aShiftR(Vector<Integer> v, Mask<Integer> m)
Arithmetically right shifts (or signed right shifts) this vector by an input vector, 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.- Parameters:
v
- the input vectorm
- the mask controlling lane selection- Returns:
- the result of arithmetically right shifting this vector by the input vector
-
rotateL
public final IntVector rotateL(int s)
Rotates left this vector by the broadcast of an input scalar.This is a vector binary operation where the operation
Integer.rotateLeft(int, int)
is applied to lane elements and where lane elements of this vector apply to the first argument, and lane elements of the broadcast vector apply to the second argument (the rotation distance).- Parameters:
s
- the input scalar; the number of the bits to rotate left- Returns:
- the result of rotating left this vector by the broadcast of an input scalar
-
rotateL
public final IntVector rotateL(int s, Mask<Integer> m)
Rotates left this vector by the broadcast of an input scalar, selecting lane elements controlled by a mask.This is a vector binary operation where the operation
Integer.rotateLeft(int, int)
is applied to lane elements and where lane elements of this vector apply to the first argument, and lane elements of the broadcast vector apply to the second argument (the rotation distance).- Parameters:
s
- the input scalar; the number of the bits to rotate leftm
- the mask controlling lane selection- Returns:
- the result of rotating left this vector by the broadcast of an input scalar
-
rotateR
public final IntVector rotateR(int s)
Rotates right this vector by the broadcast of an input scalar.This is a vector binary operation where the operation
Integer.rotateRight(int, int)
is applied to lane elements and where lane elements of this vector apply to the first argument, and lane elements of the broadcast vector apply to the second argument (the rotation distance).- Parameters:
s
- the input scalar; the number of the bits to rotate right- Returns:
- the result of rotating right this vector by the broadcast of an input scalar
-
rotateR
public final IntVector rotateR(int s, Mask<Integer> m)
Rotates right this vector by the broadcast of an input scalar, selecting lane elements controlled by a mask.This is a vector binary operation where the operation
Integer.rotateRight(int, int)
is applied to lane elements and where lane elements of this vector apply to the first argument, and lane elements of the broadcast vector apply to the second argument (the rotation distance).- Parameters:
s
- the input scalar; the number of the bits to rotate rightm
- the mask controlling lane selection- Returns:
- the result of rotating right this vector by the broadcast of an input scalar
-
addAll
public abstract int 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 int addAll(Mask<Integer> 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 int 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 int mulAll(Mask<Integer> 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 int 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 isInteger.MAX_VALUE
.- Returns:
- the minimum lane element of this vector
-
minAll
public abstract int minAll(Mask<Integer> 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 isInteger.MAX_VALUE
.- Parameters:
m
- the mask controlling lane selection- Returns:
- the minimum lane element of this vector
-
maxAll
public abstract int 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 isInteger.MIN_VALUE
.- Returns:
- the maximum lane element of this vector
-
maxAll
public abstract int maxAll(Mask<Integer> 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 isInteger.MIN_VALUE
.- Parameters:
m
- the mask controlling lane selection- Returns:
- the maximum lane element of this vector
-
orAll
public abstract int 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 int orAll(Mask<Integer> 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 int 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 is-1
.- Returns:
- the logical AND all the lane elements of this vector
-
andAll
public abstract int andAll(Mask<Integer> 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 is-1
.- Parameters:
m
- the mask controlling lane selection- Returns:
- the logical AND all the lane elements of this vector
-
xorAll
public abstract int 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 int xorAll(Mask<Integer> 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 int 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 IntVector with(int i, int e)
Replaces the lane element of this vector at lane indexi
with valuee
.This is a cross-lane 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 int[] toArray()
Returns an array containing the lane elements of this vector.This method behaves as if it
intoArray(int[], int)
stores} this vector into an allocated array and returns the array as follows:int[] a = new int[this.length()]; this.intoArray(a, 0); return a;
- Returns:
- an array containing the the lane elements of this vector
-
intoArray
public abstract void intoArray(int[] 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(int[] a, int i, Mask<Integer> 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 abstract void intoArray(int[] 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 abstract void intoArray(int[] a, int i, Mask<Integer> 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
-
-