- java.lang.Object
-
- jdk.incubator.vector.Vector<Short>
-
- jdk.incubator.vector.ShortVector
-
-
Field Summary
Fields Modifier and Type Field Description static VectorSpecies<Short>
SPECIES_128
Species representingShortVector
s ofVectorShape.S_128_BIT
.static VectorSpecies<Short>
SPECIES_256
Species representingShortVector
s ofVectorShape.S_256_BIT
.static VectorSpecies<Short>
SPECIES_512
Species representingShortVector
s ofVectorShape.S_512_BIT
.static VectorSpecies<Short>
SPECIES_64
Species representingShortVector
s ofVectorShape.S_64_BIT
.static VectorSpecies<Short>
SPECIES_MAX
Species representingShortVector
s ofVectorShape.S_Max_BIT
.static VectorSpecies<Short>
SPECIES_PREFERRED
Preferred species forShortVector
s.
-
Method Summary
Modifier and Type Method Description abstract ShortVector
add(short s)
Adds this vector to the broadcast of an input scalar.abstract ShortVector
add(short s, VectorMask<Short> m)
Adds this vector to broadcast of an input scalar, selecting lane elements controlled by a mask.abstract short
addLanes()
Adds all lane elements of this vector.abstract short
addLanes(VectorMask<Short> m)
Adds all lane elements of this vector, selecting lane elements controlled by a mask.abstract ShortVector
and(short s)
Bitwise ANDs this vector with the broadcast of an input scalar.abstract ShortVector
and(short s, VectorMask<Short> m)
Bitwise ANDs this vector with the broadcast of an input scalar, selecting lane elements controlled by a mask.abstract ShortVector
and(Vector<Short> v)
Bitwise ANDs this vector with an input vector.abstract ShortVector
and(Vector<Short> v, VectorMask<Short> m)
Bitwise ANDs this vector with an input vector, selecting lane elements controlled by a mask.abstract short
andLanes()
Logically ANDs all lane elements of this vector.abstract short
andLanes(VectorMask<Short> m)
Logically ANDs all lane elements of this vector, selecting lane elements controlled by a mask.abstract ShortVector
blend(short s, VectorMask<Short> m)
Blends the lane elements of this vector with those of the broadcast of an input scalar, selecting lanes controlled by a mask.static ShortVector
broadcast(VectorSpecies<Short> species, short e)
Returns a vector where all lane elements are set to the primitive valuee
.abstract VectorMask<Short>
equal(short s)
Tests if this vector is equal to the broadcast of an input scalar.static ShortVector
fromArray(VectorSpecies<Short> species, short[] a, int offset)
Loads a vector from an array starting at offset.static ShortVector
fromArray(VectorSpecies<Short> species, short[] a, int a_offset, int[] indexMap, int i_offset)
Loads a vector from an array using indexes obtained from an index map.static ShortVector
fromArray(VectorSpecies<Short> species, short[] a, int offset, VectorMask<Short> m)
Loads a vector from an array starting at offset and using a mask.static ShortVector
fromArray(VectorSpecies<Short> species, short[] a, int a_offset, VectorMask<Short> m, int[] indexMap, int i_offset)
Loads a vector from an array using indexes obtained from an index map and using a mask.static ShortVector
fromByteArray(VectorSpecies<Short> species, byte[] a, int offset)
Loads a vector from a byte array starting at an offset.static ShortVector
fromByteArray(VectorSpecies<Short> species, byte[] a, int offset, VectorMask<Short> m)
Loads a vector from a byte array starting at an offset and using a mask.static ShortVector
fromByteBuffer(VectorSpecies<Short> species, ByteBuffer bb, int offset)
Loads a vector from abyte buffer
starting at an offset into the byte buffer.static ShortVector
fromByteBuffer(VectorSpecies<Short> species, ByteBuffer bb, int offset, VectorMask<Short> m)
Loads a vector from abyte buffer
starting at an offset into the byte buffer and using a mask.abstract VectorMask<Short>
greaterThan(short s)
Tests if this vector is greater than the broadcast of an input scalar.abstract VectorMask<Short>
greaterThanEq(short s)
Tests if this vector is greater than or equal to the broadcast of an input scalar.abstract void
intoArray(short[] a, int offset)
Stores this vector into an array starting at offset.void
intoArray(short[] a, int a_offset, int[] indexMap, int i_offset)
Stores this vector into an array using indexes obtained from an index map.abstract void
intoArray(short[] a, int offset, VectorMask<Short> m)
Stores this vector into an array starting at offset and using a mask.void
intoArray(short[] a, int a_offset, VectorMask<Short> m, int[] indexMap, int i_offset)
Stores this vector into an array using indexes obtained from an index map and using a mask.abstract short
lane(int i)
Gets the lane element at lane indexi
abstract VectorMask<Short>
lessThan(short s)
Tests if this vector is less than the broadcast of an input scalar.abstract VectorMask<Short>
lessThanEq(short s)
Tests if this vector is less or equal to the broadcast of an input scalar.abstract ShortVector
max(short s)
Returns the maximum of this vector and the broadcast of an input scalar.abstract short
maxLanes()
Returns the maximum lane element of this vector.abstract short
maxLanes(VectorMask<Short> m)
Returns the maximum lane element of this vector, selecting lane elements controlled by a mask.abstract ShortVector
min(short s)
Returns the minimum of this vector and the broadcast of an input scalar.abstract short
minLanes()
Returns the minimum lane element of this vector.abstract short
minLanes(VectorMask<Short> m)
Returns the minimum lane element of this vector, selecting lane elements controlled by a mask.abstract ShortVector
mul(short s)
Multiplies this vector with the broadcast of an input scalar.abstract ShortVector
mul(short s, VectorMask<Short> m)
Multiplies this vector with the broadcast of an input scalar, selecting lane elements controlled by a mask.abstract short
mulLanes()
Multiplies all lane elements of this vector.abstract short
mulLanes(VectorMask<Short> m)
Multiplies all lane elements of this vector, selecting lane elements controlled by a mask.abstract ShortVector
not()
Bitwise NOTs this vector.abstract ShortVector
not(VectorMask<Short> m)
Bitwise NOTs this vector, selecting lane elements controlled by a mask.abstract VectorMask<Short>
notEqual(short s)
Tests if this vector is not equal to the broadcast of an input scalar.abstract ShortVector
or(short s)
Bitwise ORs this vector with the broadcast of an input scalar.abstract ShortVector
or(short s, VectorMask<Short> m)
Bitwise ORs this vector with the broadcast of an input scalar, selecting lane elements controlled by a mask.abstract ShortVector
or(Vector<Short> v)
Bitwise ORs this vector with an input vector.abstract ShortVector
or(Vector<Short> v, VectorMask<Short> m)
Bitwise ORs this vector with an input vector, selecting lane elements controlled by a mask.abstract short
orLanes()
Logically ORs all lane elements of this vector.abstract short
orLanes(VectorMask<Short> m)
Logically ORs all lane elements of this vector, selecting lane elements controlled by a mask.static ShortVector
random(VectorSpecies<Short> species)
Returns a vector where each lane element is set to a randomly generated primitive value.ShortVector
rotateLeft(int s)
Rotates left this vector by the broadcast of an input scalar.ShortVector
rotateLeft(int s, VectorMask<Short> m)
Rotates left this vector by the broadcast of an input scalar, selecting lane elements controlled by a mask.ShortVector
rotateRight(int s)
Rotates right this vector by the broadcast of an input scalar.ShortVector
rotateRight(int s, VectorMask<Short> m)
Rotates right this vector by the broadcast of an input scalar, selecting lane elements controlled by a mask.static ShortVector
scalars(VectorSpecies<Short> species, short... es)
Returns a vector where each lane element is set to given primitive values.abstract ShortVector
shiftArithmeticRight(int s)
Arithmetically right shifts (or signed right shifts) this vector by the broadcast of an input scalar.abstract ShortVector
shiftArithmeticRight(int s, VectorMask<Short> 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 ShortVector
shiftArithmeticRight(Vector<Short> v)
Arithmetically right shifts (or signed right shifts) this vector by an input vector.ShortVector
shiftArithmeticRight(Vector<Short> v, VectorMask<Short> m)
Arithmetically right shifts (or signed right shifts) this vector by an input vector, selecting lane elements controlled by a mask.abstract ShortVector
shiftLeft(int s)
Logically left shifts this vector by the broadcast of an input scalar.abstract ShortVector
shiftLeft(int s, VectorMask<Short> m)
Logically left shifts this vector by the broadcast of an input scalar, selecting lane elements controlled by a mask.abstract ShortVector
shiftLeft(Vector<Short> v)
Logically left shifts this vector by an input vector.ShortVector
shiftLeft(Vector<Short> v, VectorMask<Short> m)
Logically left shifts this vector by an input vector, selecting lane elements controlled by a mask.abstract ShortVector
shiftRight(int s)
Logically right shifts (or unsigned right shifts) this vector by the broadcast of an input scalar.abstract ShortVector
shiftRight(int s, VectorMask<Short> 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 ShortVector
shiftRight(Vector<Short> v)
Logically right shifts (or unsigned right shifts) this vector by an input vector.ShortVector
shiftRight(Vector<Short> v, VectorMask<Short> m)
Logically right shifts (or unsigned right shifts) this vector by an input vector, selecting lane elements controlled by a mask.static ShortVector
single(VectorSpecies<Short> species, short 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 ShortVector
sub(short s)
Subtracts the broadcast of an input scalar from this vector.abstract ShortVector
sub(short s, VectorMask<Short> m)
Subtracts the broadcast of an input scalar from this vector, selecting lane elements controlled by a mask.short[]
toArray()
Returns an array containing the lane elements of this vector.abstract ShortVector
with(int i, short e)
Replaces the lane element of this vector at lane indexi
with valuee
.abstract ShortVector
xor(short s)
Bitwise XORs this vector with the broadcast of an input scalar.abstract ShortVector
xor(short s, VectorMask<Short> m)
Bitwise XORs this vector with the broadcast of an input scalar, selecting lane elements controlled by a mask.abstract ShortVector
xor(Vector<Short> v)
Bitwise XORs this vector with an input vector.abstract ShortVector
xor(Vector<Short> v, VectorMask<Short> m)
Bitwise XORs this vector with an input vector, selecting lane elements controlled by a mask.abstract short
xorLanes()
Logically XORs all lane elements of this vector.abstract short
xorLanes(VectorMask<Short> m)
Logically XORs all lane elements of this vector, selecting lane elements controlled by a mask.static ShortVector
zero(VectorSpecies<Short> 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, maskAllFalse, maskAllTrue, maskFromArray, maskFromValues, max, max, min, min, mul, mul, neg, neg, notEqual, rearrange, rearrange, reinterpret, reshape, rotateLanesLeft, rotateLanesRight, shape, shiftLanesLeft, shiftLanesRight, shuffle, shuffleFromArray, shuffleFromValues, shuffleIota, shuffleIota, shuffleOffset, species, sub, sub, toShuffle
-
-
-
-
Field Detail
-
SPECIES_64
public static final VectorSpecies<Short> SPECIES_64
Species representingShortVector
s ofVectorShape.S_64_BIT
.
-
SPECIES_128
public static final VectorSpecies<Short> SPECIES_128
Species representingShortVector
s ofVectorShape.S_128_BIT
.
-
SPECIES_256
public static final VectorSpecies<Short> SPECIES_256
Species representingShortVector
s ofVectorShape.S_256_BIT
.
-
SPECIES_512
public static final VectorSpecies<Short> SPECIES_512
Species representingShortVector
s ofVectorShape.S_512_BIT
.
-
SPECIES_MAX
public static final VectorSpecies<Short> SPECIES_MAX
Species representingShortVector
s ofVectorShape.S_Max_BIT
.
-
SPECIES_PREFERRED
public static final VectorSpecies<Short> SPECIES_PREFERRED
Preferred species forShortVector
s. A preferred species is a species of maximal bit size for the platform.
-
-
Method Detail
-
zero
public static ShortVector zero(VectorSpecies<Short> 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 ShortVector fromByteArray(VectorSpecies<Short> species, byte[] a, int offset)
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 fromByteBuffer(species, ByteBuffer.wrap(a), offset, VectorMask.allTrue());
- Parameters:
species
- species of desired vectora
- the byte arrayoffset
- the offset into the array- Returns:
- a vector loaded from a byte array
- Throws:
IndexOutOfBoundsException
- ifi < 0
oroffset > a.length - (species.length() * species.elementSize() / Byte.SIZE)
-
fromByteArray
public static ShortVector fromByteArray(VectorSpecies<Short> species, byte[] a, int offset, VectorMask<Short> m)
Loads a vector from a byte array starting at an offset and using a mask.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 fromByteBuffer(species, ByteBuffer.wrap(a), offset, m);
- Parameters:
species
- species of desired vectora
- the byte arrayoffset
- the offset into the arraym
- the mask- Returns:
- a vector loaded from a byte array
- Throws:
IndexOutOfBoundsException
- ifoffset < 0
or for any vector lane indexN
where the mask at laneN
is setoffset >= a.length - (N * species.elementSize() / Byte.SIZE)
-
fromArray
public static ShortVector fromArray(VectorSpecies<Short> species, short[] a, int offset)
Loads a vector from an array starting at offset.For each vector lane, where
N
is the vector lane index, the array element at indexoffset + N
is placed into the resulting vector at lane indexN
.- Parameters:
species
- species of desired vectora
- the arrayoffset
- the offset into the array- Returns:
- the vector loaded from an array
- Throws:
IndexOutOfBoundsException
- ifoffset < 0
, oroffset > a.length - species.length()
-
fromArray
public static ShortVector fromArray(VectorSpecies<Short> species, short[] a, int offset, VectorMask<Short> 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 indexoffset + 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 arrayoffset
- the offset into the arraym
- the mask- Returns:
- the vector loaded from an array
- Throws:
IndexOutOfBoundsException
- ifoffset < 0
, or for any vector lane indexN
where the mask at laneN
is setoffset > a.length - N
-
fromArray
public static ShortVector fromArray(VectorSpecies<Short> species, short[] a, int a_offset, int[] indexMap, int i_offset)
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 indexa_offset + indexMap[i_offset + N]
is placed into the resulting vector at lane indexN
.- Parameters:
species
- species of desired vectora
- the arraya_offset
- 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 mapi_offset
- the offset into the index map- Returns:
- the vector loaded from an array
- Throws:
IndexOutOfBoundsException
- ifi_offset < 0
, ori_offset > indexMap.length - species.length()
, or for any vector lane indexN
the result ofa_offset + indexMap[i_offset + N]
is< 0
or>= a.length
-
fromArray
public static ShortVector fromArray(VectorSpecies<Short> species, short[] a, int a_offset, VectorMask<Short> m, int[] indexMap, int i_offset)
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 indexa_offset + indexMap[i_offset + N]
is placed into the resulting vector at lane indexN
.- Parameters:
species
- species of desired vectora
- the arraya_offset
- 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 mapi_offset
- the offset into the index map- Returns:
- the vector loaded from an array
- Throws:
IndexOutOfBoundsException
- ifi_offset < 0
, ori_offset > indexMap.length - species.length()
, or for any vector lane indexN
where the mask at laneN
is set the result ofa_offset + indexMap[i_offset + N]
is< 0
or>= a.length
-
fromByteBuffer
public static ShortVector fromByteBuffer(VectorSpecies<Short> species, ByteBuffer bb, int offset)
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(VectorSpecies, ByteBuffer, int, VectorMask)
method} as follows:return fromByteBuffer(b, offset, VectorMask.allTrue())
- Parameters:
species
- species of desired vectorbb
- the byte bufferoffset
- 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 thanspecies.length() * species.elementSize() / Byte.SIZE
bytes remaining in the byte buffer from the given offset
-
fromByteBuffer
public static ShortVector fromByteBuffer(VectorSpecies<Short> species, ByteBuffer bb, int offset, VectorMask<Short> 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, whereEBuffer
is the primitive buffer type,e
is the primitive element type, andESpecies
is the primitive species fore
:EBuffer eb = b.duplicate(). order(ByteOrder.nativeOrder()).position(offset). asEBuffer(); e[] es = new e[species.length()]; for (int n = 0; n < t.length; n++) { if (m.isSet(n)) es[n] = eb.get(n); } EVector r = EVector.fromArray(es, 0, m);
- Parameters:
species
- species of desired vectorbb
- the byte bufferoffset
- 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 setoffset >= b.limit() - (N * species.elementSize() / Byte.SIZE)
-
broadcast
public static ShortVector broadcast(VectorSpecies<Short> species, short e)
Returns a vector where all lane elements are set to the primitive valuee
.- Parameters:
species
- species of the desired vectore
- the value to be broadcasted- Returns:
- a vector of vector where all lane elements are set to
the primitive value
e
-
scalars
public static ShortVector scalars(VectorSpecies<Short> species, short... es)
Returns a vector where each lane element is set to given primitive values.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:
species
- species of the desired vectores
- the given primitive values- Returns:
- a vector where each lane element is set to given primitive values
- Throws:
IndexOutOfBoundsException
- ifes.length < species.length()
-
single
public static final ShortVector single(VectorSpecies<Short> species, short 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:
species
- 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 ShortVector random(VectorSpecies<Short> species)
Returns a vector where each lane element is set to a randomly generated primitive value. The semantics are equivalent to calling (short)ThreadLocalRandom.nextInt()
- Parameters:
species
- species of the desired vector- Returns:
- a vector where each lane elements is set to a randomly generated primitive value
-
add
public abstract ShortVector add(short s)
Adds this vector to the broadcast of an input scalar.This is a lane-wise binary operation which applies the primitive addition operation (
+
) to each lane.- Parameters:
s
- the input scalar- Returns:
- the result of adding this vector to the broadcast of an input scalar
-
add
public abstract ShortVector add(short s, VectorMask<Short> m)
Adds this vector to broadcast of an input scalar, selecting lane elements controlled by a mask.This is a lane-wise binary operation which applies the primitive addition operation (
+
) to each lane.- 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 ShortVector sub(short s)
Subtracts the broadcast of an input scalar from this vector.This is a lane-wise binary operation which applies the primitive subtraction operation (
-
) to each lane.- Parameters:
s
- the input scalar- Returns:
- the result of subtracting the broadcast of an input scalar from this vector
-
sub
public abstract ShortVector sub(short s, VectorMask<Short> m)
Subtracts the broadcast of an input scalar from this vector, selecting lane elements controlled by a mask.This is a lane-wise binary operation which applies the primitive subtraction operation (
-
) to each lane.- 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 ShortVector mul(short s)
Multiplies this vector with the broadcast of an input scalar.This is a lane-wise binary operation which applies the primitive multiplication operation (
*
) to each lane.- Parameters:
s
- the input scalar- Returns:
- the result of multiplying this vector with the broadcast of an input scalar
-
mul
public abstract ShortVector mul(short s, VectorMask<Short> m)
Multiplies this vector with the broadcast of an input scalar, selecting lane elements controlled by a mask.This is a lane-wise binary operation which applies the primitive multiplication operation (
*
) to each lane.- 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 ShortVector min(short s)
Returns the minimum of this vector and the broadcast of an input scalar.This is a lane-wise binary operation which applies the operation
(a, b) -> Math.min(a, b)
to each lane.- Parameters:
s
- the input scalar- Returns:
- the minimum of this vector and the broadcast of an input scalar
-
max
public abstract ShortVector max(short s)
Returns the maximum of this vector and the broadcast of an input scalar.This is a lane-wise binary operation which applies the operation
(a, b) -> Math.max(a, b)
to each lane.- Parameters:
s
- the input scalar- Returns:
- the maximum of this vector and the broadcast of an input scalar
-
equal
public abstract VectorMask<Short> equal(short s)
Tests if this vector is equal to the broadcast of an input scalar.This is a lane-wise binary test operation which applies the primitive equals operation (
==
) each lane.- 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 VectorMask<Short> notEqual(short s)
Tests if this vector is not equal to the broadcast of an input scalar.This is a lane-wise binary test operation which applies the primitive not equals operation (
!=
) to each lane.- 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 VectorMask<Short> lessThan(short s)
Tests if this vector is less than the broadcast of an input scalar.This is a lane-wise binary test operation which applies the primitive less than operation (
<
) to each lane.- 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 VectorMask<Short> lessThanEq(short s)
Tests if this vector is less or equal to the broadcast of an input scalar.This is a lane-wise binary test operation which applies the primitive less than or equal to operation (
<=
) to each lane.- 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 VectorMask<Short> greaterThan(short s)
Tests if this vector is greater than the broadcast of an input scalar.This is a lane-wise binary test operation which applies the primitive greater than operation (
>
) to each lane.- 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 VectorMask<Short> greaterThanEq(short s)
Tests if this vector is greater than or equal to the broadcast of an input scalar.This is a lane-wise binary test operation which applies the primitive greater than or equal to operation (
>=
) to each lane.- 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 ShortVector blend(short s, VectorMask<Short> 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 ShortVector and(Vector<Short> v)
Bitwise ANDs this vector with an input vector.This is a lane-wise binary operation which applies the primitive bitwise AND operation (
&
) to each lane.- Parameters:
v
- the input vector- Returns:
- the bitwise AND of this vector with the input vector
-
and
public abstract ShortVector and(short s)
Bitwise ANDs this vector with the broadcast of an input scalar.This is a lane-wise binary operation which applies the primitive bitwise AND operation (
&
) to each lane.- Parameters:
s
- the input scalar- Returns:
- the bitwise AND of this vector with the broadcast of an input scalar
-
and
public abstract ShortVector and(Vector<Short> v, VectorMask<Short> m)
Bitwise ANDs this vector with an input vector, selecting lane elements controlled by a mask.This is a lane-wise binary operation which applies the primitive bitwise AND operation (
&
) to each lane.- Parameters:
v
- the input vectorm
- the mask controlling lane selection- Returns:
- the bitwise AND of this vector with the input vector
-
and
public abstract ShortVector and(short s, VectorMask<Short> m)
Bitwise ANDs this vector with the broadcast of an input scalar, selecting lane elements controlled by a mask.This is a lane-wise binary operation which applies the primitive bitwise AND operation (
&
) to each lane.- 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 ShortVector or(Vector<Short> v)
Bitwise ORs this vector with an input vector.This is a lane-wise binary operation which applies the primitive bitwise OR operation (
|
) to each lane.- Parameters:
v
- the input vector- Returns:
- the bitwise OR of this vector with the input vector
-
or
public abstract ShortVector or(short s)
Bitwise ORs this vector with the broadcast of an input scalar.This is a lane-wise binary operation which applies the primitive bitwise OR operation (
|
) to each lane.- Parameters:
s
- the input scalar- Returns:
- the bitwise OR of this vector with the broadcast of an input scalar
-
or
public abstract ShortVector or(Vector<Short> v, VectorMask<Short> m)
Bitwise ORs this vector with an input vector, selecting lane elements controlled by a mask.This is a lane-wise binary operation which applies the primitive bitwise OR operation (
|
) to each lane.- Parameters:
v
- the input vectorm
- the mask controlling lane selection- Returns:
- the bitwise OR of this vector with the input vector
-
or
public abstract ShortVector or(short s, VectorMask<Short> m)
Bitwise ORs this vector with the broadcast of an input scalar, selecting lane elements controlled by a mask.This is a lane-wise binary operation which applies the primitive bitwise OR operation (
|
) to each lane.- 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 ShortVector xor(Vector<Short> v)
Bitwise XORs this vector with an input vector.This is a lane-wise binary operation which applies the primitive bitwise XOR operation (
^
) to each lane.- Parameters:
v
- the input vector- Returns:
- the bitwise XOR of this vector with the input vector
-
xor
public abstract ShortVector xor(short s)
Bitwise XORs this vector with the broadcast of an input scalar.This is a lane-wise binary operation which applies the primitive bitwise XOR operation (
^
) to each lane.- Parameters:
s
- the input scalar- Returns:
- the bitwise XOR of this vector with the broadcast of an input scalar
-
xor
public abstract ShortVector xor(Vector<Short> v, VectorMask<Short> m)
Bitwise XORs this vector with an input vector, selecting lane elements controlled by a mask.This is a lane-wise binary operation which applies the primitive bitwise XOR operation (
^
) to each lane.- Parameters:
v
- the input vectorm
- the mask controlling lane selection- Returns:
- the bitwise XOR of this vector with the input vector
-
xor
public abstract ShortVector xor(short s, VectorMask<Short> m)
Bitwise XORs this vector with the broadcast of an input scalar, selecting lane elements controlled by a mask.This is a lane-wise binary operation which applies the primitive bitwise XOR operation (
^
) to each lane.- 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 ShortVector not()
Bitwise NOTs this vector.This is a lane-wise unary operation which applies the primitive bitwise NOT operation (
~
) to each lane.- Returns:
- the bitwise NOT of this vector
-
not
public abstract ShortVector not(VectorMask<Short> m)
Bitwise NOTs this vector, selecting lane elements controlled by a mask.This is a lane-wise unary operation which applies the primitive bitwise NOT operation (
~
) to each lane.- Parameters:
m
- the mask controlling lane selection- Returns:
- the bitwise NOT of this vector
-
shiftLeft
public abstract ShortVector shiftLeft(int s)
Logically left shifts this vector by the broadcast of an input scalar.This is a lane-wise binary operation which applies the primitive logical left shift operation (
<<
) to each lane to left shift the element by shift value as specified by the input scalar. Only the 4 lowest-order 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 0xF. The shift distance actually used is therefore always in the range 0 to 15, inclusive.- Parameters:
s
- the input scalar; the number of the bits to left shift- Returns:
- the result of logically left shifting this vector by the broadcast of an input scalar
-
shiftLeft
public abstract ShortVector shiftLeft(int s, VectorMask<Short> m)
Logically left shifts this vector by the broadcast of an input scalar, selecting lane elements controlled by a mask.This is a lane-wise binary operation which applies the primitive logical left shift operation (
<<
) to each lane to left shift the element by shift value as specified by the input scalar. Only the 4 lowest-order 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 0xF. The shift distance actually used is therefore always in the range 0 to 15, 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 this vector by the broadcast of an input scalar
-
shiftLeft
public abstract ShortVector shiftLeft(Vector<Short> v)
Logically left shifts this vector by an input vector.This is a lane-wise binary operation which applies the primitive logical left shift operation (
<<
) to each lane. For each lane of this vector, the shift value is the corresponding lane of input vector. Only the 4 lowest-order 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 0xF. The shift distance actually used is therefore always in the range 0 to 15, inclusive.- Parameters:
v
- the input vector- Returns:
- the result of logically left shifting this vector by the input vector
-
shiftLeft
public ShortVector shiftLeft(Vector<Short> v, VectorMask<Short> m)
Logically left shifts this vector by an input vector, selecting lane elements controlled by a mask.This is a lane-wise binary operation which applies the primitive logical left shift operation (
<<
) to each lane. For each lane of this vector, the shift value is the corresponding lane of input vector. Only the 4 lowest-order 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 0xF. The shift distance actually used is therefore always in the range 0 to 15, inclusive.- Parameters:
v
- the input vectorm
- the mask controlling lane selection- Returns:
- the result of logically left shifting this vector by the input vector
-
shiftRight
public abstract ShortVector shiftRight(int s)
Logically right shifts (or unsigned right shifts) this vector by the broadcast of an input scalar.This is a lane-wise binary operation which applies the primitive logical right shift operation (
>>>
) to each lane to logically right shift the element by shift value as specified by the input scalar. Only the 4 lowest-order 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 0xF. The shift distance actually used is therefore always in the range 0 to 15, 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
-
shiftRight
public abstract ShortVector shiftRight(int s, VectorMask<Short> 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 lane-wise binary operation which applies the primitive logical right shift operation (
>>
) to each lane to logically right shift the element by shift value as specified by the input scalar. Only the 4 lowest-order 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 0xF. The shift distance actually used is therefore always in the range 0 to 15, 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
-
shiftRight
public abstract ShortVector shiftRight(Vector<Short> v)
Logically right shifts (or unsigned right shifts) this vector by an input vector.This is a lane-wise binary operation which applies the primitive logical right shift operation (
>>>
) to each lane. For each lane of this vector, the shift value is the corresponding lane of input vector. Only the 4 lowest-order 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 0xF. The shift distance actually used is therefore always in the range 0 to 15, inclusive.- Parameters:
v
- the input vector- Returns:
- the result of logically right shifting this vector by the input vector
-
shiftRight
public ShortVector shiftRight(Vector<Short> v, VectorMask<Short> m)
Logically right shifts (or unsigned right shifts) this vector by an input vector, selecting lane elements controlled by a mask.This is a lane-wise binary operation which applies the primitive logical right shift operation (
>>>
) to each lane. For each lane of this vector, the shift value is the corresponding lane of input vector. Only the 4 lowest-order 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 0xF. The shift distance actually used is therefore always in the range 0 to 15, inclusive.- Parameters:
v
- the input vectorm
- the mask controlling lane selection- Returns:
- the result of logically right shifting this vector by the input vector
-
shiftArithmeticRight
public abstract ShortVector shiftArithmeticRight(int s)
Arithmetically right shifts (or signed right shifts) this vector by the broadcast of an input scalar.This is a lane-wise binary operation which applies the primitive arithmetic right shift operation (
>>
) to each lane to arithmetically right shift the element by shift value as specified by the input scalar. Only the 4 lowest-order 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 0xF. The shift distance actually used is therefore always in the range 0 to 15, 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
-
shiftArithmeticRight
public abstract ShortVector shiftArithmeticRight(int s, VectorMask<Short> 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 lane-wise binary operation which applies the primitive arithmetic right shift operation (
>>
) to each lane to arithmetically right shift the element by shift value as specified by the input scalar. Only the 4 lowest-order 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 0xF. The shift distance actually used is therefore always in the range 0 to 15, 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
-
shiftArithmeticRight
public abstract ShortVector shiftArithmeticRight(Vector<Short> v)
Arithmetically right shifts (or signed right shifts) this vector by an input vector.This is a lane-wise binary operation which applies the primitive arithmetic right shift operation (
>>
) to each lane. For each lane of this vector, the shift value is the corresponding lane of input vector. Only the 4 lowest-order 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 0xF. The shift distance actually used is therefore always in the range 0 to 15, inclusive.- Parameters:
v
- the input vector- Returns:
- the result of arithmetically right shifting this vector by the input vector
-
shiftArithmeticRight
public ShortVector shiftArithmeticRight(Vector<Short> v, VectorMask<Short> m)
Arithmetically right shifts (or signed right shifts) this vector by an input vector, selecting lane elements controlled by a mask.This is a lane-wise binary operation which applies the primitive arithmetic right shift operation (
>>
) to each lane. For each lane of this vector, the shift value is the corresponding lane of input vector. Only the 4 lowest-order 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 0xF. The shift distance actually used is therefore always in the range 0 to 15, inclusive.- Parameters:
v
- the input vectorm
- the mask controlling lane selection- Returns:
- the result of arithmetically right shifting this vector by the input vector
-
rotateLeft
public final ShortVector rotateLeft(int s)
Rotates left this vector by the broadcast of an input scalar.This is a lane-wise binary operation which produces the result of rotating left the two's complement binary representation of each lane of first operand (this vector) by input scalar. Rotation by any multiple of 16 is a no-op, so only the 4 lowest-order bits of input value are used. It is as if the input value were subjected to a bitwise logical AND operator (
&
) with the mask value 0xF.- 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
-
rotateLeft
public final ShortVector rotateLeft(int s, VectorMask<Short> m)
Rotates left this vector by the broadcast of an input scalar, selecting lane elements controlled by a mask.This is a lane-wise binary operation which produces the result of rotating left the two's complement binary representation of each lane of first operand (this vector) by input scalar. Rotation by any multiple of 16 is a no-op, so only the 4 lowest-order bits of input value are used. It is as if the input value were subjected to a bitwise logical AND operator (
&
) with the mask value 0xF.- 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
-
rotateRight
public final ShortVector rotateRight(int s)
Rotates right this vector by the broadcast of an input scalar.This is a lane-wise binary operation which produces the result of rotating right the two's complement binary representation of each lane of first operand (this vector) by input scalar. Rotation by any multiple of 16 is a no-op, so only the 4 lowest-order bits of input value are used. It is as if the input value were subjected to a bitwise logical AND operator (
&
) with the mask value 0xF.- 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
-
rotateRight
public final ShortVector rotateRight(int s, VectorMask<Short> m)
Rotates right this vector by the broadcast of an input scalar, selecting lane elements controlled by a mask.This is a lane-wise binary operation which produces the result of rotating right the two's complement binary representation of each lane of first operand (this vector) by input scalar. Rotation by any multiple of 16 is a no-op, so only the 4 lowest-order bits of input value are used. It is as if the input value were subjected to a bitwise logical AND operator (
&
) with the mask value 0xF.- 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
-
addLanes
public abstract short addLanes()
Adds all lane elements of this vector.This is an associative cross-lane reduction operation which applies the addition operation (
+
) to lane elements, and the identity value is0
.- Returns:
- the addition of all the lane elements of this vector
-
addLanes
public abstract short addLanes(VectorMask<Short> m)
Adds all lane elements of this vector, selecting lane elements controlled by a mask.This is an associative cross-lane reduction operation which applies the addition operation (
+
) 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
-
mulLanes
public abstract short mulLanes()
Multiplies all lane elements of this vector.This is an associative cross-lane reduction operation which applies the multiplication operation (
*
) to lane elements, and the identity value is1
.- Returns:
- the multiplication of all the lane elements of this vector
-
mulLanes
public abstract short mulLanes(VectorMask<Short> m)
Multiplies all lane elements of this vector, selecting lane elements controlled by a mask.This is an associative cross-lane reduction operation which applies the multiplication operation (
*
) 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
-
minLanes
public abstract short minLanes()
Returns the minimum lane element of this vector.This is an associative cross-lane reduction operation which applies the operation
(a, b) -> Math.min(a, b)
to lane elements, and the identity value isShort.MAX_VALUE
.- Returns:
- the minimum lane element of this vector
-
minLanes
public abstract short minLanes(VectorMask<Short> m)
Returns the minimum lane element of this vector, selecting lane elements controlled by a mask.This is an associative cross-lane reduction operation which applies the operation
(a, b) -> Math.min(a, b)
to lane elements, and the identity value isShort.MAX_VALUE
.- Parameters:
m
- the mask controlling lane selection- Returns:
- the minimum lane element of this vector
-
maxLanes
public abstract short maxLanes()
Returns the maximum lane element of this vector.This is an associative cross-lane reduction operation which applies the operation
(a, b) -> Math.max(a, b)
to lane elements, and the identity value isShort.MIN_VALUE
.- Returns:
- the maximum lane element of this vector
-
maxLanes
public abstract short maxLanes(VectorMask<Short> m)
Returns the maximum lane element of this vector, selecting lane elements controlled by a mask.This is an associative cross-lane reduction operation which applies the operation
(a, b) -> Math.max(a, b)
to lane elements, and the identity value isShort.MIN_VALUE
.- Parameters:
m
- the mask controlling lane selection- Returns:
- the maximum lane element of this vector
-
orLanes
public abstract short orLanes()
Logically ORs all lane elements of this vector.This is an associative cross-lane reduction operation which applies the logical OR operation (
|
) to lane elements, and the identity value is0
.- Returns:
- the logical OR all the lane elements of this vector
-
orLanes
public abstract short orLanes(VectorMask<Short> m)
Logically ORs all lane elements of this vector, selecting lane elements controlled by a mask.This is an associative cross-lane reduction operation which applies the logical OR operation (
|
) 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
-
andLanes
public abstract short andLanes()
Logically ANDs all lane elements of this vector.This is an associative cross-lane reduction operation which applies the logical AND operation (
|
) to lane elements, and the identity value is-1
.- Returns:
- the logical AND all the lane elements of this vector
-
andLanes
public abstract short andLanes(VectorMask<Short> m)
Logically ANDs all lane elements of this vector, selecting lane elements controlled by a mask.This is an associative cross-lane reduction operation which applies the logical AND operation (
|
) 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
-
xorLanes
public abstract short xorLanes()
Logically XORs all lane elements of this vector.This is an associative cross-lane reduction operation which applies the logical XOR operation (
^
) to lane elements, and the identity value is0
.- Returns:
- the logical XOR all the lane elements of this vector
-
xorLanes
public abstract short xorLanes(VectorMask<Short> m)
Logically XORs all lane elements of this vector, selecting lane elements controlled by a mask.This is an associative cross-lane reduction operation which applies the logical XOR operation (
^
) 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
-
lane
public abstract short lane(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 ShortVector with(int i, short 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 short[] toArray()
Returns an array containing the lane elements of this vector.This method behaves as if it
intoArray(short[], int)
stores} this vector into an allocated array and returns the array as follows:short[] a = new short[this.length()]; this.intoArray(a, 0); return a;
- Returns:
- an array containing the the lane elements of this vector
-
intoArray
public abstract void intoArray(short[] a, int offset)
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 indexoffset + N
.- Parameters:
a
- the arrayoffset
- the offset into the array- Throws:
IndexOutOfBoundsException
- ifoffset < 0
, oroffset > a.length - this.length()
-
intoArray
public abstract void intoArray(short[] a, int offset, VectorMask<Short> 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 indexoffset + N
.- Parameters:
a
- the arrayoffset
- the offset into the arraym
- the mask- Throws:
IndexOutOfBoundsException
- ifoffset < 0
, or for any vector lane indexN
where the mask at laneN
is setoffset >= a.length - N
-
intoArray
public void intoArray(short[] a, int a_offset, int[] indexMap, int i_offset)
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 indexa_offset + indexMap[i_offset + N]
.- Parameters:
a
- the arraya_offset
- 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 mapi_offset
- the offset into the index map- Throws:
IndexOutOfBoundsException
- ifi_offset < 0
, ori_offset > indexMap.length - this.length()
, or for any vector lane indexN
the result ofa_offset + indexMap[i_offset + N]
is< 0
or>= a.length
-
intoArray
public void intoArray(short[] a, int a_offset, VectorMask<Short> m, int[] indexMap, int i_offset)
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 indexa_offset + indexMap[i_offset + N]
.- Parameters:
a
- the arraya_offset
- 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 mapi_offset
- the offset into the index map- Throws:
IndexOutOfBoundsException
- ifj < 0
, ori_offset > indexMap.length - this.length()
, or for any vector lane indexN
where the mask at laneN
is set the result ofa_offset + indexMap[i_offset + N]
is< 0
or>= a.length
-
-