 java.lang.Object

 jdk.incubator.vector.Vector<Float>

 jdk.incubator.vector.FloatVector


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

Method Summary
Modifier and Type Method Description FloatVector
acos()
Calculates the arc cosine of this vector.FloatVector
acos(Mask<Float> m)
Calculates the arc cosine of this vector, selecting lane elements controlled by a mask.abstract FloatVector
add(float s)
Adds this vector to the broadcast of an input scalar.abstract FloatVector
add(float s, Mask<Float> m)
Adds this vector to broadcast of an input scalar, selecting lane elements controlled by a mask.abstract float
addAll()
Adds all lane elements of this vector.abstract float
addAll(Mask<Float> m)
Adds all lane elements of this vector, selecting lane elements controlled by a mask.FloatVector
asin()
Calculates the arc sine of this vector.FloatVector
asin(Mask<Float> m)
Calculates the arc sine of this vector, selecting lane elements controlled by a mask.FloatVector
atan()
Calculates the arc tangent of this vector.FloatVector
atan(Mask<Float> m)
Calculates the arc tangent of this vector, selecting lane elements controlled by a mask.abstract FloatVector
atan2(float s)
Calculates the arc tangent of this vector divided by the broadcast of an an input scalar.abstract FloatVector
atan2(float s, Mask<Float> m)
Calculates the arc tangent of this vector divided by the broadcast of an an input scalar, selecting lane elements controlled by a mask.FloatVector
atan2(Vector<Float> v)
Calculates the arc tangent of this vector divided by an input vector.FloatVector
atan2(Vector<Float> v, Mask<Float> m)
Calculates the arc tangent of this vector divided by an input vector, selecting lane elements controlled by a mask.abstract FloatVector
blend(float s, Mask<Float> m)
Blends the lane elements of this vector with those of the broadcast of an input scalar, selecting lanes controlled by a mask.static FloatVector
broadcast(Species<Float> s, float e)
Returns a vector where all lane elements are set to the primitive valuee
.FloatVector
cbrt()
Calculates the cube root of this vector.FloatVector
cbrt(Mask<Float> m)
Calculates the cube root of this vector, selecting lane elements controlled by a mask.FloatVector
cos()
Calculates the trigonometric cosine of this vector.FloatVector
cos(Mask<Float> m)
Calculates the trigonometric cosine of this vector, selecting lane elements controlled by a mask.FloatVector
cosh()
Calculates the hyperbolic cosine of this vector.FloatVector
cosh(Mask<Float> m)
Calculates the hyperbolic cosine of this vector, selecting lane elements controlled by a mask.abstract FloatVector
div(float s)
Divides this vector by the broadcast of an input scalar.abstract FloatVector
div(float s, Mask<Float> m)
Divides this vector by the broadcast of an input scalar, selecting lane elements controlled by a mask.abstract FloatVector
div(Vector<Float> v)
Divides this vector by an input vector.abstract FloatVector
div(Vector<Float> v, Mask<Float> m)
Divides this vector by an input vector, selecting lane elements controlled by a mask.abstract Mask<Float>
equal(float s)
Tests if this vector is equal to the broadcast of an input scalar.FloatVector
exp()
Calculates the broadcast of Euler's numbere
raised to the power of this vector.FloatVector
exp(Mask<Float> m)
Calculates the broadcast of Euler's numbere
raised to the power of this vector, selecting lane elements controlled by a mask.FloatVector
expm1()
Calculates the broadcast of Euler's numbere
raised to the power of this vector minus the broadcast of1
.FloatVector
expm1(Mask<Float> m)
Calculates the broadcast of Euler's numbere
raised to the power of this vector minus the broadcast of1
, selecting lane elements controlled by a mask More specifically as if the following (ignoring any differences in numerical accuracy):abstract FloatVector
fma(float s1, float s2)
Calculates the product of this vector and the broadcast of a first input scalar summed with the broadcast of a second input scalar.abstract FloatVector
fma(float s1, float s2, Mask<Float> m)
Calculates the product of this vector and the broadcast of a first input scalar summed with the broadcast of a second input scalar, selecting lane elements controlled by a mask More specifically as if the following:abstract FloatVector
fma(Vector<Float> v1, Vector<Float> v2)
Calculates the product of this vector and a first input vector summed with a second input vector.FloatVector
fma(Vector<Float> v1, Vector<Float> v2, Mask<Float> m)
Calculates the product of this vector and a first input vector summed with a second input vector, selecting lane elements controlled by a mask.static FloatVector
fromArray(Species<Float> species, float[] a, int i)
Loads a vector from an array starting at offset.static FloatVector
fromArray(Species<Float> species, float[] a, int i, int[] indexMap, int j)
Loads a vector from an array using indexes obtained from an index map.static FloatVector
fromArray(Species<Float> species, float[] a, int i, Mask<Float> m)
Loads a vector from an array starting at offset and using a mask.static FloatVector
fromArray(Species<Float> species, float[] a, int i, Mask<Float> m, int[] indexMap, int j)
Loads a vector from an array using indexes obtained from an index map and using a mask.static FloatVector
fromByteArray(Species<Float> species, byte[] a, int ix)
Loads a vector from a byte array starting at an offset.static FloatVector
fromByteArray(Species<Float> species, byte[] a, int ix, Mask<Float> m)
Loads a vector from a byte array starting at an offset and using a mask.static FloatVector
fromByteBuffer(Species<Float> species, ByteBuffer bb, int ix)
Loads a vector from abyte buffer
starting at an offset into the byte buffer.static FloatVector
fromByteBuffer(Species<Float> species, ByteBuffer bb, int ix, Mask<Float> m)
Loads a vector from abyte buffer
starting at an offset into the byte buffer and using a mask.abstract float
get(int i)
Gets the lane element at lane indexi
abstract Mask<Float>
greaterThan(float s)
Tests if this vector is greater than the broadcast of an input scalar.abstract Mask<Float>
greaterThanEq(float s)
Tests if this vector is greater than or equal to the broadcast of an input scalar.abstract FloatVector
hypot(float s)
Calculates square root of the sum of the squares of this vector and the broadcast of an input scalar.abstract FloatVector
hypot(float s, Mask<Float> m)
Calculates square root of the sum of the squares of this vector and the broadcast of an input scalar, selecting lane elements controlled by a mask.FloatVector
hypot(Vector<Float> v)
Calculates square root of the sum of the squares of this vector and an input vector.FloatVector
hypot(Vector<Float> v, Mask<Float> m)
Calculates square root of the sum of the squares of this vector and an input vector, selecting lane elements controlled by a mask.abstract void
intoArray(float[] a, int i)
Stores this vector into an array starting at offset.abstract void
intoArray(float[] a, int i, int[] indexMap, int j)
Stores this vector into an array using indexes obtained from an index map.abstract void
intoArray(float[] a, int i, Mask<Float> m)
Stores this vector into an array starting at offset and using a mask.abstract void
intoArray(float[] a, int i, Mask<Float> m, int[] indexMap, int j)
Stores this vector into an array using indexes obtained from an index map and using a mask.abstract Mask<Float>
lessThan(float s)
Tests if this vector is less than the broadcast of an input scalar.abstract Mask<Float>
lessThanEq(float s)
Tests if this vector is less or equal to the broadcast of an input scalar.FloatVector
log()
Calculates the natural logarithm of this vector.FloatVector
log(Mask<Float> m)
Calculates the natural logarithm of this vector, selecting lane elements controlled by a mask.FloatVector
log10()
Calculates the base 10 logarithm of this vector.FloatVector
log10(Mask<Float> m)
Calculates the base 10 logarithm of this vector, selecting lane elements controlled by a mask.FloatVector
log1p()
Calculates the natural logarithm of the sum of this vector and the broadcast of1
.FloatVector
log1p(Mask<Float> m)
Calculates the natural logarithm of the sum of this vector and the broadcast of1
, selecting lane elements controlled by a mask.abstract FloatVector
max(float s)
Returns the maximum of this vector and the broadcast of an input scalar.abstract float
maxAll()
Returns the maximum lane element of this vector.abstract float
maxAll(Mask<Float> m)
Returns the maximum lane element of this vector, selecting lane elements controlled by a mask.abstract FloatVector
min(float s)
Returns the minimum of this vector and the broadcast of an input scalar.abstract float
minAll()
Returns the minimum lane element of this vector.abstract float
minAll(Mask<Float> m)
Returns the minimum lane element of this vector, selecting lane elements controlled by a mask.abstract FloatVector
mul(float s)
Multiplies this vector with the broadcast of an input scalar.abstract FloatVector
mul(float s, Mask<Float> m)
Multiplies this vector with the broadcast of an input scalar, selecting lane elements controlled by a mask.abstract float
mulAll()
Multiplies all lane elements of this vector.abstract float
mulAll(Mask<Float> m)
Multiplies all lane elements of this vector, selecting lane elements controlled by a mask.abstract Mask<Float>
notEqual(float s)
Tests if this vector is not equal to the broadcast of an input scalar.abstract FloatVector
pow(float s)
Calculates this vector raised to the power of the broadcast of an input scalar.abstract FloatVector
pow(float s, Mask<Float> m)
Calculates this vector raised to the power of the broadcast of an input scalar, selecting lane elements controlled by a mask.FloatVector
pow(Vector<Float> v)
Calculates this vector raised to the power of an input vector.FloatVector
pow(Vector<Float> v, Mask<Float> m)
Calculates this vector raised to the power of an input vector, selecting lane elements controlled by a mask.static FloatVector
random(Species<Float> s)
Returns a vector where each lane element is set to a randomly generated primitive value.static FloatVector
scalars(Species<Float> s, float... es)
Returns a vector where each lane element is set to a given primitive value.FloatVector
sin()
Calculates the trigonometric sine of this vector.FloatVector
sin(Mask<Float> m)
Calculates the trigonometric sine of this vector, selecting lane elements controlled by a mask.static FloatVector
single(Species<Float> s, float 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.FloatVector
sinh()
Calculates the hyperbolic sine of this vector.FloatVector
sinh(Mask<Float> m)
Calculates the hyperbolic sine of this vector, selecting lane elements controlled by a mask.abstract FloatVector
sqrt()
Calculates the square root of this vector.FloatVector
sqrt(Mask<Float> m)
Calculates the square root of this vector, selecting lane elements controlled by a mask.abstract FloatVector
sub(float s)
Subtracts the broadcast of an input scalar from this vector.abstract FloatVector
sub(float s, Mask<Float> m)
Subtracts the broadcast of an input scalar from this vector, selecting lane elements controlled by a mask.FloatVector
tan()
Calculates the trigonometric tangent of this vector.FloatVector
tan(Mask<Float> m)
Calculates the trigonometric tangent of this vector, selecting lane elements controlled by a mask.FloatVector
tanh()
Calculates the hyperbolic tangent of this vector.FloatVector
tanh(Mask<Float> m)
Calculates the hyperbolic tangent of this vector, selecting lane elements controlled by a mask.float[]
toArray()
Returns an array containing the lane elements of this vector.abstract FloatVector
with(int i, float e)
Replaces the lane element of this vector at lane indexi
with valuee
.static FloatVector
zero(Species<Float> 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<Float> SPECIES_64
Species representingFloatVector
s ofShape.S_64_BIT
.

SPECIES_128
public static final Species<Float> SPECIES_128
Species representingFloatVector
s ofShape.S_128_BIT
.

SPECIES_256
public static final Species<Float> SPECIES_256
Species representingFloatVector
s ofShape.S_256_BIT
.

SPECIES_512
public static final Species<Float> SPECIES_512
Species representingFloatVector
s ofShape.S_512_BIT
.

SPECIES_MAX
public static final Species<Float> SPECIES_MAX
Species representingFloatVector
s ofShape.S_Max_BIT
.

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


Method Detail

zero
public static FloatVector zero(Species<Float> 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 FloatVector fromByteArray(Species<Float> 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 FloatVector fromByteArray(Species<Float> species, byte[] a, int ix, Mask<Float> 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 FloatVector fromArray(Species<Float> species, float[] 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 FloatVector fromArray(Species<Float> species, float[] a, int i, Mask<Float> 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 FloatVector fromArray(Species<Float> species, float[] 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 FloatVector fromArray(Species<Float> species, float[] a, int i, Mask<Float> 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 FloatVector fromByteBuffer(Species<Float> 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 FloatVector fromByteBuffer(Species<Float> species, ByteBuffer bb, int ix, Mask<Float> 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 FloatVector broadcast(Species<Float> s, float 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 FloatVector scalars(Species<Float> s, float... 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 FloatVector single(Species<Float> s, float 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 FloatVector random(Species<Float> s)
Returns a vector where each lane element is set to a randomly generated primitive value. The semantics are equivalent to callingThreadLocalRandom.nextFloat()
 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 FloatVector add(float 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 FloatVector add(float s, Mask<Float> 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 FloatVector sub(float 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 FloatVector sub(float s, Mask<Float> 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 FloatVector mul(float 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 FloatVector mul(float s, Mask<Float> 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 FloatVector min(float 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 FloatVector max(float 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<Float> equal(float 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<Float> notEqual(float 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<Float> lessThan(float 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<Float> lessThanEq(float 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<Float> greaterThan(float 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<Float> greaterThanEq(float 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 FloatVector blend(float s, Mask<Float> 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

div
public abstract FloatVector div(Vector<Float> v)
Divides this vector by an input vector.This is a vector binary operation where the primitive division operation (
/
) is applied to lane elements. Parameters:
v
 the input vector Returns:
 the result of dividing this vector by the input vector

div
public abstract FloatVector div(float s)
Divides this vector by the broadcast of an input scalar.This is a vector binary operation where the primitive division operation (
/
) is applied to lane elements. Parameters:
s
 the input scalar Returns:
 the result of dividing this vector by the broadcast of an input scalar

div
public abstract FloatVector div(Vector<Float> v, Mask<Float> m)
Divides this vector by an input vector, selecting lane elements controlled by a mask.This is a vector binary operation where the primitive division operation (
/
) is applied to lane elements. Parameters:
v
 the input vectorm
 the mask controlling lane selection Returns:
 the result of dividing this vector by the input vector

div
public abstract FloatVector div(float s, Mask<Float> m)
Divides 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 division operation (
/
) is applied to lane elements. Parameters:
s
 the input scalarm
 the mask controlling lane selection Returns:
 the result of dividing this vector by the broadcast of an input scalar

sqrt
public abstract FloatVector sqrt()
Calculates the square root of this vector.This is a vector unary operation where the
Math.sqrt(double)
operation is applied to lane elements. Returns:
 the square root of this vector

sqrt
public FloatVector sqrt(Mask<Float> m)
Calculates the square root of this vector, selecting lane elements controlled by a mask.This is a vector unary operation where the
Math.sqrt(double)
operation is applied to lane elements. Parameters:
m
 the mask controlling lane selection Returns:
 the square root of this vector

tan
public FloatVector tan()
Calculates the trigonometric tangent of this vector.This is a vector unary operation with same semantic definition as
Math.tan(double)
operation applied to lane elements. The implementation is not required to return same results asMath.tan(double)
, but adheres to rounding, monotonicity, and special case semantics as defined in theMath.tan(double)
specifications. The computed result will be within 1 ulp of the exact result. Returns:
 the tangent of this vector

tan
public FloatVector tan(Mask<Float> m)
Calculates the trigonometric tangent of this vector, selecting lane elements controlled by a mask.Semantics for rounding, monotonicity, and special cases are described in
tan()
 Parameters:
m
 the mask controlling lane selection Returns:
 the tangent of this vector

tanh
public FloatVector tanh()
Calculates the hyperbolic tangent of this vector.This is a vector unary operation with same semantic definition as
Math.tanh(double)
operation applied to lane elements. The implementation is not required to return same results asMath.tanh(double)
, but adheres to rounding, monotonicity, and special case semantics as defined in theMath.tanh(double)
specifications. The computed result will be within 2.5 ulps of the exact result. Returns:
 the hyperbolic tangent of this vector

tanh
public FloatVector tanh(Mask<Float> m)
Calculates the hyperbolic tangent of this vector, selecting lane elements controlled by a mask.Semantics for rounding, monotonicity, and special cases are described in
tanh()
 Parameters:
m
 the mask controlling lane selection Returns:
 the hyperbolic tangent of this vector

sin
public FloatVector sin()
Calculates the trigonometric sine of this vector.This is a vector unary operation with same semantic definition as
Math.sin(double)
operation applied to lane elements. The implementation is not required to return same results asMath.sin(double)
, but adheres to rounding, monotonicity, and special case semantics as defined in theMath.sin(double)
specifications. The computed result will be within 1 ulp of the exact result. Returns:
 the sine of this vector

sin
public FloatVector sin(Mask<Float> m)
Calculates the trigonometric sine of this vector, selecting lane elements controlled by a mask.Semantics for rounding, monotonicity, and special cases are described in
sin()
 Parameters:
m
 the mask controlling lane selection Returns:
 the sine of this vector

sinh
public FloatVector sinh()
Calculates the hyperbolic sine of this vector.This is a vector unary operation with same semantic definition as
Math.sinh(double)
operation applied to lane elements. The implementation is not required to return same results asMath.sinh(double)
, but adheres to rounding, monotonicity, and special case semantics as defined in theMath.sinh(double)
specifications. The computed result will be within 2.5 ulps of the exact result. Returns:
 the hyperbolic sine of this vector

sinh
public FloatVector sinh(Mask<Float> m)
Calculates the hyperbolic sine of this vector, selecting lane elements controlled by a mask.Semantics for rounding, monotonicity, and special cases are described in
sinh()
 Parameters:
m
 the mask controlling lane selection Returns:
 the hyperbolic sine of this vector

cos
public FloatVector cos()
Calculates the trigonometric cosine of this vector.This is a vector unary operation with same semantic definition as
Math.cos(double)
operation applied to lane elements. The implementation is not required to return same results asMath.cos(double)
, but adheres to rounding, monotonicity, and special case semantics as defined in theMath.cos(double)
specifications. The computed result will be within 1 ulp of the exact result. Returns:
 the cosine of this vector

cos
public FloatVector cos(Mask<Float> m)
Calculates the trigonometric cosine of this vector, selecting lane elements controlled by a mask.Semantics for rounding, monotonicity, and special cases are described in
cos()
 Parameters:
m
 the mask controlling lane selection Returns:
 the cosine of this vector

cosh
public FloatVector cosh()
Calculates the hyperbolic cosine of this vector.This is a vector unary operation with same semantic definition as
Math.cosh(double)
operation applied to lane elements. The implementation is not required to return same results asMath.cosh(double)
, but adheres to rounding, monotonicity, and special case semantics as defined in theMath.cosh(double)
specifications. The computed result will be within 2.5 ulps of the exact result. Returns:
 the hyperbolic cosine of this vector

cosh
public FloatVector cosh(Mask<Float> m)
Calculates the hyperbolic cosine of this vector, selecting lane elements controlled by a mask.Semantics for rounding, monotonicity, and special cases are described in
cosh()
 Parameters:
m
 the mask controlling lane selection Returns:
 the hyperbolic cosine of this vector

asin
public FloatVector asin()
Calculates the arc sine of this vector.This is a vector unary operation with same semantic definition as
Math.asin(double)
operation applied to lane elements. The implementation is not required to return same results asMath.asin(double)
, but adheres to rounding, monotonicity, and special case semantics as defined in theMath.asin(double)
specifications. The computed result will be within 1 ulp of the exact result. Returns:
 the arc sine of this vector

asin
public FloatVector asin(Mask<Float> m)
Calculates the arc sine of this vector, selecting lane elements controlled by a mask.Semantics for rounding, monotonicity, and special cases are described in
asin()
 Parameters:
m
 the mask controlling lane selection Returns:
 the arc sine of this vector

acos
public FloatVector acos()
Calculates the arc cosine of this vector.This is a vector unary operation with same semantic definition as
Math.acos(double)
operation applied to lane elements. The implementation is not required to return same results asMath.acos(double)
, but adheres to rounding, monotonicity, and special case semantics as defined in theMath.acos(double)
specifications. The computed result will be within 1 ulp of the exact result. Returns:
 the arc cosine of this vector

acos
public FloatVector acos(Mask<Float> m)
Calculates the arc cosine of this vector, selecting lane elements controlled by a mask.Semantics for rounding, monotonicity, and special cases are described in
acos()
 Parameters:
m
 the mask controlling lane selection Returns:
 the arc cosine of this vector

atan
public FloatVector atan()
Calculates the arc tangent of this vector.This is a vector unary operation with same semantic definition as
Math.atan(double)
operation applied to lane elements. The implementation is not required to return same results asMath.atan(double)
, but adheres to rounding, monotonicity, and special case semantics as defined in theMath.atan(double)
specifications. The computed result will be within 1 ulp of the exact result. Returns:
 the arc tangent of this vector

atan
public FloatVector atan(Mask<Float> m)
Calculates the arc tangent of this vector, selecting lane elements controlled by a mask.Semantics for rounding, monotonicity, and special cases are described in
atan()
 Parameters:
m
 the mask controlling lane selection Returns:
 the arc tangent of this vector

atan2
public FloatVector atan2(Vector<Float> v)
Calculates the arc tangent of this vector divided by an input vector.This is a vector binary operation with same semantic definition as
Math.atan2(double, double)
operation applied to lane elements. The implementation is not required to return same results asMath.atan2(double, double)
, but adheres to rounding, monotonicity, and special case semantics as defined in theMath.atan2(double, double)
specifications. The computed result will be within 2 ulps of the exact result. Parameters:
v
 the input vector Returns:
 the arc tangent of this vector divided by the input vector

atan2
public abstract FloatVector atan2(float s)
Calculates the arc tangent of this vector divided by the broadcast of an an input scalar.This is a vector binary operation with same semantic definition as
Math.atan2(double, double)
operation applied to lane elements. The implementation is not required to return same results asMath.atan2(double, double)
, but adheres to rounding, monotonicity, and special case semantics as defined in theMath.atan2(double, double)
specifications. The computed result will be within 1 ulp of the exact result. Parameters:
s
 the input scalar Returns:
 the arc tangent of this vector over the input vector

atan2
public FloatVector atan2(Vector<Float> v, Mask<Float> m)
Calculates the arc tangent of this vector divided by an input vector, selecting lane elements controlled by a mask.Semantics for rounding, monotonicity, and special cases are described in
atan2(jdk.incubator.vector.Vector<java.lang.Float>)
 Parameters:
v
 the input vectorm
 the mask controlling lane selection Returns:
 the arc tangent of this vector divided by the input vector

atan2
public abstract FloatVector atan2(float s, Mask<Float> m)
Calculates the arc tangent of this vector divided by the broadcast of an an input scalar, selecting lane elements controlled by a mask.Semantics for rounding, monotonicity, and special cases are described in
atan2(jdk.incubator.vector.Vector<java.lang.Float>)
 Parameters:
s
 the input scalarm
 the mask controlling lane selection Returns:
 the arc tangent of this vector over the input vector

cbrt
public FloatVector cbrt()
Calculates the cube root of this vector.This is a vector unary operation with same semantic definition as
Math.cbrt(double)
operation applied to lane elements. The implementation is not required to return same results asMath.cbrt(double)
, but adheres to rounding, monotonicity, and special case semantics as defined in theMath.cbrt(double)
specifications. The computed result will be within 1 ulp of the exact result. Returns:
 the cube root of this vector

cbrt
public FloatVector cbrt(Mask<Float> m)
Calculates the cube root of this vector, selecting lane elements controlled by a mask.Semantics for rounding, monotonicity, and special cases are described in
cbrt()
 Parameters:
m
 the mask controlling lane selection Returns:
 the cube root of this vector

log
public FloatVector log()
Calculates the natural logarithm of this vector.This is a vector unary operation with same semantic definition as
Math.log(double)
operation applied to lane elements. The implementation is not required to return same results asMath.log(double)
, but adheres to rounding, monotonicity, and special case semantics as defined in theMath.log(double)
specifications. The computed result will be within 1 ulp of the exact result. Returns:
 the natural logarithm of this vector

log
public FloatVector log(Mask<Float> m)
Calculates the natural logarithm of this vector, selecting lane elements controlled by a mask.Semantics for rounding, monotonicity, and special cases are described in
log()
 Parameters:
m
 the mask controlling lane selection Returns:
 the natural logarithm of this vector

log10
public FloatVector log10()
Calculates the base 10 logarithm of this vector.This is a vector unary operation with same semantic definition as
Math.log10(double)
operation applied to lane elements. The implementation is not required to return same results asMath.log10(double)
, but adheres to rounding, monotonicity, and special case semantics as defined in theMath.log10(double)
specifications. The computed result will be within 1 ulp of the exact result. Returns:
 the base 10 logarithm of this vector

log10
public FloatVector log10(Mask<Float> m)
Calculates the base 10 logarithm of this vector, selecting lane elements controlled by a mask.Semantics for rounding, monotonicity, and special cases are described in
log10()
 Parameters:
m
 the mask controlling lane selection Returns:
 the base 10 logarithm of this vector

log1p
public FloatVector log1p()
Calculates the natural logarithm of the sum of this vector and the broadcast of1
.This is a vector unary operation with same semantic definition as
Math.log1p(double)
operation applied to lane elements. The implementation is not required to return same results asMath.log1p(double)
, but adheres to rounding, monotonicity, and special case semantics as defined in theMath.log1p(double)
specifications. The computed result will be within 1 ulp of the exact result. Returns:
 the natural logarithm of the sum of this vector and the broadcast
of
1

log1p
public FloatVector log1p(Mask<Float> m)
Calculates the natural logarithm of the sum of this vector and the broadcast of1
, selecting lane elements controlled by a mask.Semantics for rounding, monotonicity, and special cases are described in
log1p()
 Parameters:
m
 the mask controlling lane selection Returns:
 the natural logarithm of the sum of this vector and the broadcast
of
1

pow
public FloatVector pow(Vector<Float> v)
Calculates this vector raised to the power of an input vector.This is a vector binary operation with same semantic definition as
Math.pow(double, double)
operation applied to lane elements. The implementation is not required to return same results asMath.pow(double, double)
, but adheres to rounding, monotonicity, and special case semantics as defined in theMath.pow(double, double)
specifications. The computed result will be within 1 ulp of the exact result. Parameters:
v
 the input vector Returns:
 this vector raised to the power of an input vector

pow
public abstract FloatVector pow(float s)
Calculates this vector raised to the power of the broadcast of an input scalar.This is a vector binary operation with same semantic definition as
Math.pow(double, double)
operation applied to lane elements. The implementation is not required to return same results asMath.pow(double, double)
, but adheres to rounding, monotonicity, and special case semantics as defined in theMath.pow(double, double)
specifications. The computed result will be within 1 ulp of the exact result. Parameters:
s
 the input scalar Returns:
 this vector raised to the power of the broadcast of an input scalar.

pow
public FloatVector pow(Vector<Float> v, Mask<Float> m)
Calculates this vector raised to the power of an input vector, selecting lane elements controlled by a mask.Semantics for rounding, monotonicity, and special cases are described in
pow(jdk.incubator.vector.Vector<java.lang.Float>)
 Parameters:
v
 the input vectorm
 the mask controlling lane selection Returns:
 this vector raised to the power of an input vector

pow
public abstract FloatVector pow(float s, Mask<Float> m)
Calculates this vector raised to the power of the broadcast of an input scalar, selecting lane elements controlled by a mask.Semantics for rounding, monotonicity, and special cases are described in
pow(jdk.incubator.vector.Vector<java.lang.Float>)
 Parameters:
s
 the input scalarm
 the mask controlling lane selection Returns:
 this vector raised to the power of the broadcast of an input scalar.

exp
public FloatVector exp()
Calculates the broadcast of Euler's numbere
raised to the power of this vector.This is a vector unary operation with same semantic definition as
Math.exp(double)
operation applied to lane elements. The implementation is not required to return same results asMath.exp(double)
, but adheres to rounding, monotonicity, and special case semantics as defined in theMath.exp(double)
specifications. The computed result will be within 1 ulp of the exact result. Returns:
 the broadcast of Euler's number
e
raised to the power of this vector

exp
public FloatVector exp(Mask<Float> m)
Calculates the broadcast of Euler's numbere
raised to the power of this vector, selecting lane elements controlled by a mask.Semantics for rounding, monotonicity, and special cases are described in
exp()
 Parameters:
m
 the mask controlling lane selection Returns:
 the broadcast of Euler's number
e
raised to the power of this vector

expm1
public FloatVector expm1()
Calculates the broadcast of Euler's numbere
raised to the power of this vector minus the broadcast of1
. More specifically as if the following (ignoring any differences in numerical accuracy):this.exp().sub(this.species().broadcast(1))
This is a vector unary operation with same semantic definition as
Math.expm1(double)
operation applied to lane elements. The implementation is not required to return same results asMath.expm1(double)
, but adheres to rounding, monotonicity, and special case semantics as defined in theMath.expm1(double)
specifications. The computed result will be within 1 ulp of the exact result. Returns:
 the broadcast of Euler's number
e
raised to the power of this vector minus the broadcast of1

expm1
public FloatVector expm1(Mask<Float> m)
Calculates the broadcast of Euler's numbere
raised to the power of this vector minus the broadcast of1
, selecting lane elements controlled by a mask More specifically as if the following (ignoring any differences in numerical accuracy):this.exp(m).sub(this.species().broadcast(1), m)
Semantics for rounding, monotonicity, and special cases are described in
expm1()
 Parameters:
m
 the mask controlling lane selection Returns:
 the broadcast of Euler's number
e
raised to the power of this vector minus the broadcast of1

fma
public abstract FloatVector fma(Vector<Float> v1, Vector<Float> v2)
Calculates the product of this vector and a first input vector summed with a second input vector. More specifically as if the following (ignoring any differences in numerical accuracy):this.mul(v1).add(v2)
This is a vector ternary operation where the
Math.fma(double, double, double)
operation is applied to lane elements. Parameters:
v1
 the first input vectorv2
 the second input vector Returns:
 the product of this vector and the first input vector summed with the second input vector

fma
public abstract FloatVector fma(float s1, float s2)
Calculates the product of this vector and the broadcast of a first input scalar summed with the broadcast of a second input scalar. More specifically as if the following:this.fma(this.species().broadcast(s1), this.species().broadcast(s2))
This is a vector ternary operation where the
Math.fma(double, double, double)
operation is applied to lane elements. Parameters:
s1
 the first input scalars2
 the second input scalar Returns:
 the product of this vector and the broadcast of a first input scalar summed with the broadcast of a second input scalar

fma
public FloatVector fma(Vector<Float> v1, Vector<Float> v2, Mask<Float> m)
Calculates the product of this vector and a first input vector summed with a second input vector, selecting lane elements controlled by a mask. More specifically as if the following (ignoring any differences in numerical accuracy):this.mul(v1, m).add(v2, m)
This is a vector ternary operation where the
Math.fma(double, double, double)
operation is applied to lane elements. Parameters:
v1
 the first input vectorv2
 the second input vectorm
 the mask controlling lane selection Returns:
 the product of this vector and the first input vector summed with the second input vector

fma
public abstract FloatVector fma(float s1, float s2, Mask<Float> m)
Calculates the product of this vector and the broadcast of a first input scalar summed with the broadcast of a second input scalar, selecting lane elements controlled by a mask More specifically as if the following:this.fma(this.species().broadcast(s1), this.species().broadcast(s2), m)
This is a vector ternary operation where the
Math.fma(double, double, double)
operation is applied to lane elements. Parameters:
s1
 the first input scalars2
 the second input scalarm
 the mask controlling lane selection Returns:
 the product of this vector and the broadcast of a first input scalar summed with the broadcast of a second input scalar

hypot
public FloatVector hypot(Vector<Float> v)
Calculates square root of the sum of the squares of this vector and an input vector. More specifically as if the following (ignoring any differences in numerical accuracy):this.mul(this).add(v.mul(v)).sqrt()
This is a vector binary operation with same semantic definition as
Math.hypot(double, double)
operation applied to lane elements. The implementation is not required to return same results asMath.hypot(double, double)
, but adheres to rounding, monotonicity, and special case semantics as defined in theMath.hypot(double, double)
specifications. The computed result will be within 1 ulp of the exact result. Parameters:
v
 the input vector Returns:
 square root of the sum of the squares of this vector and an input vector

hypot
public abstract FloatVector hypot(float s)
Calculates square root of the sum of the squares of this vector and the broadcast of an input scalar. More specifically as if the following (ignoring any differences in numerical accuracy):this.mul(this).add(this.species().broadcast(v * v)).sqrt()
This is a vector binary operation with same semantic definition as
Math.hypot(double, double)
operation applied to lane elements. The implementation is not required to return same results asMath.hypot(double, double)
, but adheres to rounding, monotonicity, and special case semantics as defined in theMath.hypot(double, double)
specifications. The computed result will be within 1 ulp of the exact result. Parameters:
s
 the input scalar Returns:
 square root of the sum of the squares of this vector and the broadcast of an input scalar

hypot
public FloatVector hypot(Vector<Float> v, Mask<Float> m)
Calculates square root of the sum of the squares of this vector and an input vector, selecting lane elements controlled by a mask. More specifically as if the following (ignoring any differences in numerical accuracy):this.mul(this, m).add(v.mul(v), m).sqrt(m)
Semantics for rounding, monotonicity, and special cases are described in
hypot(jdk.incubator.vector.Vector<java.lang.Float>)
 Parameters:
v
 the input vectorm
 the mask controlling lane selection Returns:
 square root of the sum of the squares of this vector and an input vector

hypot
public abstract FloatVector hypot(float s, Mask<Float> m)
Calculates square root of the sum of the squares of this vector and the broadcast of an input scalar, selecting lane elements controlled by a mask. More specifically as if the following (ignoring any differences in numerical accuracy):this.mul(this, m).add(this.species().broadcast(v * v), m).sqrt(m)
Semantics for rounding, monotonicity, and special cases are described in
hypot(jdk.incubator.vector.Vector<java.lang.Float>)
 Parameters:
s
 the input scalarm
 the mask controlling lane selection Returns:
 square root of the sum of the squares of this vector and the broadcast of an input scalar

addAll
public abstract float addAll()
Adds all lane elements of this vector.This is a vector reduction operation where the addition operation (
+
) is applied to lane elements, and the identity value is0.0
.The value of a floatingpoint sum is a function both of the input values as well as the order of addition operations. The order of addition operations of this method is intentionally not defined to allow for JVM to generate optimal machine code for the underlying platform at runtime. If the platform supports a vector instruction to add all values in the vector, or if there is some other efficient machine code sequence, then the JVM has the option of generating this machine code. Otherwise, the default implementation of adding vectors sequentially from left to right is used. For this reason, the output of this method may vary for the same input values.
 Returns:
 the addition of all the lane elements of this vector

addAll
public abstract float addAll(Mask<Float> m)
Adds all lane elements of this vector, selecting lane elements controlled by a mask.This is a vector reduction operation where the addition operation (
+
) is applied to lane elements, and the identity value is0.0
.The value of a floatingpoint sum is a function both of the input values as well as the order of addition operations. The order of addition operations of this method is intentionally not defined to allow for JVM to generate optimal machine code for the underlying platform at runtime. If the platform supports a vector instruction to add all values in the vector, or if there is some other efficient machine code sequence, then the JVM has the option of generating this machine code. Otherwise, the default implementation of adding vectors sequentially from left to right is used. For this reason, the output of this method may vary on the same input values.
 Parameters:
m
 the mask controlling lane selection Returns:
 the addition of the selected lane elements of this vector

mulAll
public abstract float mulAll()
Multiplies all lane elements of this vector.This is a vector reduction operation where the multiplication operation (
*
) is applied to lane elements, and the identity value is1.0
.The order of multiplication operations of this method is intentionally not defined to allow for JVM to generate optimal machine code for the underlying platform at runtime. If the platform supports a vector instruction to multiply all values in the vector, or if there is some other efficient machine code sequence, then the JVM has the option of generating this machine code. Otherwise, the default implementation of multiplying vectors sequentially from left to right is used. For this reason, the output of this method may vary on the same input values.
 Returns:
 the multiplication of all the lane elements of this vector

mulAll
public abstract float mulAll(Mask<Float> m)
Multiplies all lane elements of this vector, selecting lane elements controlled by a mask.This is a vector reduction operation where the multiplication operation (
*
) is applied to lane elements, and the identity value is1.0
.The order of multiplication operations of this method is intentionally not defined to allow for JVM to generate optimal machine code for the underlying platform at runtime. If the platform supports a vector instruction to multiply all values in the vector, or if there is some other efficient machine code sequence, then the JVM has the option of generating this machine code. Otherwise, the default implementation of multiplying vectors sequentially from left to right is used. For this reason, the output of this method may vary on the same input values.
 Parameters:
m
 the mask controlling lane selection Returns:
 the multiplication of all the lane elements of this vector

minAll
public abstract float 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 isFloat.POSITIVE_INFINITY
. Returns:
 the minimum lane element of this vector

minAll
public abstract float minAll(Mask<Float> 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 isFloat.POSITIVE_INFINITY
. Parameters:
m
 the mask controlling lane selection Returns:
 the minimum lane element of this vector

maxAll
public abstract float 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 isFloat.NEGATIVE_INFINITY
. Returns:
 the maximum lane element of this vector

maxAll
public abstract float maxAll(Mask<Float> 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 isFloat.NEGATIVE_INFINITY
. Parameters:
m
 the mask controlling lane selection Returns:
 the maximum lane element of this vector

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

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

intoArray
public abstract void intoArray(float[] 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(float[] a, int i, Mask<Float> 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(float[] 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(float[] a, int i, Mask<Float> 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

