# Uses of Class
jdk.incubator.vector.Float16

Packages that use Float16
Package
Description
jdk.incubator.vector
Incubating Feature. Will be removed in a future release.

## Uses of Float16 in jdk.incubator.vector

Subclasses with type arguments of type Float16 in jdk.incubator.vector
Modifier and Type
Class
Description
`class`
`Float16Vector`
A specialized `Vector` representing an ordered immutable sequence of 16-bit data values in the IEEE 754 binary16 format.
Classes in jdk.incubator.vector that implement interfaces with type arguments of type Float16
Modifier and Type
Class
Description
`final class`
`Float16`
The `Float16` is a class holding 16-bit data in IEEE 754 binary16 format.
Fields in jdk.incubator.vector declared as Float16
Modifier and Type
Field
Description
`static final Float16`
Float16.`MAX_VALUE`
A constant holding the largest positive finite value of type `Float16`, (2-2-10)·215, numerically equal to 65504.0.
`static final Float16`
Float16.`MIN_NORMAL`
A constant holding the smallest positive normal value of type `Float16`, 2-14.
`static final Float16`
Float16.`MIN_VALUE`
A constant holding the smallest positive nonzero value of type `Float16`, 2-24.
`static final Float16`
Float16.`NaN`
A constant holding a Not-a-Number (NaN) value of type `Float16`.
`static final Float16`
Float16.`NEGATIVE_INFINITY`
A constant holding the negative infinity of type `Float16`.
`static final Float16`
Float16.`POSITIVE_INFINITY`
A constant holding the positive infinity of type `Float16`.
Fields in jdk.incubator.vector with type parameters of type Float16
Modifier and Type
Field
Description
`static final VectorOperators.Conversion<Byte,Float16>`
VectorOperators.`B2H`
Convert `byteVal` to `(Float16)byteVal`.
`static final VectorOperators.Conversion<Double,Float16>`
VectorOperators.`D2H`
Convert `doubleVal` to `(Float16)doubleVal`.
`static final VectorOperators.Conversion<Float,Float16>`
VectorOperators.`F2H`
Convert `floatVal` to `(Float16)floatVal`.
`static final VectorOperators.Conversion<Float16,Byte>`
VectorOperators.`H2B`
Convert `Float16Val` to `(byte)Float16Val`.
`static final VectorOperators.Conversion<Float16,Double>`
VectorOperators.`H2D`
Convert `Float16Val` to `(double)Float16Val`.
`static final VectorOperators.Conversion<Float16,Float>`
VectorOperators.`H2F`
Convert `Float16Val` to `(float)Float16Val`.
`static final VectorOperators.Conversion<Float16,Integer>`
VectorOperators.`H2I`
Convert `Float16Val` to `(int)Float16Val`.
`static final VectorOperators.Conversion<Float16,Long>`
VectorOperators.`H2L`
Convert `Float16Val` to `(long)Float16Val`.
`static final VectorOperators.Conversion<Float16,Short>`
VectorOperators.`H2S`
Convert `Float16Val` to `(short)Float16Val`.
`static final VectorOperators.Conversion<Integer,Float16>`
VectorOperators.`I2H`
Convert `intVal` to `(Float16)intVal`.
`static final VectorOperators.Conversion<Long,Float16>`
VectorOperators.`L2H`
Convert `longVal` to `(Float16)longVal`.
`static final VectorOperators.Conversion<Short,Float16>`
VectorOperators.`S2H`
Convert `shortVal` to `(Float16)shortVal`.
`static final VectorSpecies<Float16>`
Float16Vector.`SPECIES_128`
Species representing `Float16Vector`s of `VectorShape.S_128_BIT`.
`static final VectorSpecies<Float16>`
Float16Vector.`SPECIES_256`
Species representing `Float16Vector`s of `VectorShape.S_256_BIT`.
`static final VectorSpecies<Float16>`
Float16Vector.`SPECIES_512`
Species representing `Float16Vector`s of `VectorShape.S_512_BIT`.
`static final VectorSpecies<Float16>`
Float16Vector.`SPECIES_64`
Species representing `Float16Vector`s of `VectorShape.S_64_BIT`.
`static final VectorSpecies<Float16>`
Float16Vector.`SPECIES_MAX`
Species representing `Float16Vector`s of `VectorShape.S_Max_BIT`.
`static final VectorSpecies<Float16>`
Float16Vector.`SPECIES_PREFERRED`
Preferred species for `Float16Vector`s.
Methods in jdk.incubator.vector that return Float16
Modifier and Type
Method
Description
`static Float16`
Float16.`abs(Float16 f16)`
Returns the absolute value of the argument.
`static Float16`
Float16.`add(Float16 addend, Float16 augend)`
Adds two `Float16` values together as per the `+` operator semantics using the round to nearest rounding policy.
`static Float16`
Float16.`copySign(Float16 magnitude, Float16 sign)`
Returns the first floating-point argument with the sign of the second floating-point argument.
`static Float16`
Float16.`divide(Float16 dividend, Float16 divisor)`
Divides two `Float16` values as per the `/` operator semantics using the round to nearest rounding policy.
`static Float16`
Float16.`fma(Float16 a, Float16 b, Float16 c)`
Returns the fused multiply add of the three arguments; that is, returns the exact product of the first two arguments summed with the third argument and then rounded once to the nearest `Float16`.
`static Float16`
Float16.`max(Float16 a, Float16 b)`
Returns the larger of two `Float16` values.
`static Float16`
Float16.`min(Float16 a, Float16 b)`
Returns the smaller of two `Float16` values.
`static Float16`
Float16.`multiply(Float16 multiplier, Float16 multiplicand)`
Multiplies two `Float16` values as per the `*` operator semantics using the round to nearest rounding policy.
`static Float16`
Float16.`negate(Float16 f16)`
Returns the negation of the argument.
`static Float16`
Float16.`nextDown(Float16 v)`
Returns the floating-point value adjacent to `v` in the direction of negative infinity.
`static Float16`
Float16.`nextUp(Float16 v)`
Returns the floating-point value adjacent to `v` in the direction of positive infinity.
`static Float16`
Float16.`scalb(Float16 v, int scaleFactor)`
Returns `v` × 2`scaleFactor` rounded as if performed by a single correctly rounded floating-point multiply.
`static Float16`
Float16.`shortBitsToFloat16(short bits)`
Returns the `Float16` value corresponding to a given bit representation.
`static Float16`
Float16.`signum(Float16 f)`
Returns the signum function of the argument; zero if the argument is zero, 1.0 if the argument is greater than zero, -1.0 if the argument is less than zero.
`static Float16`
Float16.`sqrt(Float16 radicand)`
Returns the square root of the operand.
`static Float16`
Float16.`subtract(Float16 minuend, Float16 subtrahend)`
Subtracts two `Float16` values as per the `-` operator semantics using the round to nearest rounding policy.
`static Float16`
Float16.`ulp(Float16 f16)`
Returns the size of an ulp of the argument.
`static Float16`
Float16.`valueOf(double d)`
Returns a `Float16` value rounded from the `double` argument using the round to nearest rounding policy.
`static Float16`
Float16.`valueOf(float f)`
Returns a `Float16` value rounded from the `float` argument using the round to nearest rounding policy.
`static Float16`
Float16.`valueOf(int value)`
Returns the value of an `int` converted to `Float16`.
`static Float16`
Float16.`valueOf(long value)`
Returns the value of a `long` converted to `Float16`.
`static Float16`
Float16.`valueOf(String s)`
Returns a `Float16` holding the floating-point value represented by the argument string.
`static Float16`
Float16.`valueOf(BigDecimal v)`
Returns a `Float16` value rounded from the `BigDecimal` argument using the round to nearest rounding policy.
Methods in jdk.incubator.vector that return types with arguments of type Float16
Modifier and Type
Method
Description
`abstract VectorMask<Float16>`
Float16Vector.`compare(VectorOperators.Comparison op, long e)`
Tests this vector by comparing it with an input scalar, according to the given comparison operation.
`final VectorMask<Float16>`
Float16Vector.`compare(VectorOperators.Comparison op, long e, VectorMask<Float16> m)`
Tests this vector by comparing it with an input scalar, according to the given comparison operation, in lanes selected by a mask.
`abstract VectorMask<Float16>`
Float16Vector.`compare(VectorOperators.Comparison op, short e)`
Tests this vector by comparing it with an input scalar, according to the given comparison operation.
`final VectorMask<Float16>`
Float16Vector.`compare(VectorOperators.Comparison op, short e, VectorMask<Float16> m)`
Tests this vector by comparing it with an input scalar, according to the given comparison operation, in lanes selected by a mask.
`abstract VectorMask<Float16>`
Float16Vector.`compare(VectorOperators.Comparison op, Vector<Float16> v)`
Tests this vector by comparing it with another input vector, according to the given comparison operation.
`final VectorMask<Float16>`
Float16Vector.`eq(short e)`
Tests if this vector is equal to an input scalar.
`final VectorMask<Float16>`
Float16Vector.`eq(Vector<Float16> v)`
Tests if this vector is equal to another input vector.
`final VectorMask<Float16>`
Float16Vector.`lt(short e)`
Tests if this vector is less than an input scalar.
`final VectorMask<Float16>`
Float16Vector.`lt(Vector<Float16> v)`
Tests if this vector is less than another input vector.
`abstract VectorMask<Float16>`
Float16Vector.`test(VectorOperators.Test op)`
Tests the lanes of this vector according to the given operation.
`abstract VectorMask<Float16>`
Float16Vector.`test(VectorOperators.Test op, VectorMask<Float16> m)`
Test selected lanes of this vector, according to the given operation.
Methods in jdk.incubator.vector with parameters of type Float16
Modifier and Type
Method
Description
`static Float16`
Float16.`abs(Float16 f16)`
Returns the absolute value of the argument.
`static Float16`
Float16.`add(Float16 addend, Float16 augend)`
Adds two `Float16` values together as per the `+` operator semantics using the round to nearest rounding policy.
`static int`
Float16.`compare(Float16 f1, Float16 f2)`
Compares the two specified `Float16` values.
`int`
Float16.`compareTo(Float16 anotherFloat16)`
Compares two `Float16` objects numerically.
`static Float16`
Float16.`copySign(Float16 magnitude, Float16 sign)`
Returns the first floating-point argument with the sign of the second floating-point argument.
`static Float16`
Float16.`divide(Float16 dividend, Float16 divisor)`
Divides two `Float16` values as per the `/` operator semantics using the round to nearest rounding policy.
`static short`
Float16.`float16ToRawShortBits(Float16 f16)`
Returns a representation of the specified floating-point value according to the IEEE 754 floating-point binary16 bit layout.
`static short`
Float16.`float16ToShortBits(Float16 f16)`
Returns a representation of the specified floating-point value according to the IEEE 754 floating-point binary16 bit layout.
`static Float16`
Float16.`fma(Float16 a, Float16 b, Float16 c)`
Returns the fused multiply add of the three arguments; that is, returns the exact product of the first two arguments summed with the third argument and then rounded once to the nearest `Float16`.
`static int`
Float16.`getExponent(Float16 f16)`
Returns the unbiased exponent used in the representation of a `Float16`.
`static int`
Float16.`hashCode(Float16 value)`
Returns a hash code for a `Float16` value; compatible with `Float16.hashCode()`.
`static boolean`
Float16.`isFinite(Float16 f16)`
Returns `true` if the argument is a finite floating-point value; returns `false` otherwise (for NaN and infinity arguments).
`static boolean`
Float16.`isInfinite(Float16 f16)`
Returns `true` if the specified number is infinitely large in magnitude, `false` otherwise.
`static boolean`
Float16.`isNaN(Float16 f16)`
Returns `true` if the specified number is a Not-a-Number (NaN) value, `false` otherwise.
`static Float16`
Float16.`max(Float16 a, Float16 b)`
Returns the larger of two `Float16` values.
`static Float16`
Float16.`min(Float16 a, Float16 b)`
Returns the smaller of two `Float16` values.
`static Float16`
Float16.`multiply(Float16 multiplier, Float16 multiplicand)`
Multiplies two `Float16` values as per the `*` operator semantics using the round to nearest rounding policy.
`static Float16`
Float16.`negate(Float16 f16)`
Returns the negation of the argument.
`static Float16`
Float16.`nextDown(Float16 v)`
Returns the floating-point value adjacent to `v` in the direction of negative infinity.
`static Float16`
Float16.`nextUp(Float16 v)`
Returns the floating-point value adjacent to `v` in the direction of positive infinity.
`static Float16`
Float16.`scalb(Float16 v, int scaleFactor)`
Returns `v` × 2`scaleFactor` rounded as if performed by a single correctly rounded floating-point multiply.
`static Float16`
Float16.`signum(Float16 f)`
Returns the signum function of the argument; zero if the argument is zero, 1.0 if the argument is greater than zero, -1.0 if the argument is less than zero.
`static Float16`
Float16.`sqrt(Float16 radicand)`
Returns the square root of the operand.
`static Float16`
Float16.`subtract(Float16 minuend, Float16 subtrahend)`
Subtracts two `Float16` values as per the `-` operator semantics using the round to nearest rounding policy.
`static String`
Float16.`toHexString(Float16 f16)`
Returns a hexadecimal string representation of the `Float16` argument.
`static String`
Float16.`toString(Float16 f16)`
Returns a string representation of the `Float16` argument.
`static Float16`
Float16.`ulp(Float16 f16)`
Returns the size of an ulp of the argument.
Method parameters in jdk.incubator.vector with type arguments of type Float16
Modifier and Type
Method
Description
`final Float16Vector`
Float16Vector.`add(short e, VectorMask<Float16> m)`
Adds this vector to the broadcast of an input scalar, selecting lane elements controlled by a mask.
`final Float16Vector`
Float16Vector.`add(Vector<Float16> v)`
Adds this vector to a second input vector.
`final Float16Vector`
Float16Vector.`add(Vector<Float16> v, VectorMask<Float16> m)`
Adds this vector to a second input vector, selecting lanes under the control of a mask.
`final Float16Vector`
Float16Vector.`add(Vector<Float16> v, VectorMask<Float16> m)`
Adds this vector to a second input vector, selecting lanes under the control of a mask.
`final Float16Vector`
Float16Vector.`blend(long e, VectorMask<Float16> m)`
Replaces selected lanes of this vector with a scalar value under the control of a mask.
`final Float16Vector`
Float16Vector.`blend(short e, VectorMask<Float16> m)`
Replaces selected lanes of this vector with a scalar value under the control of a mask.
`abstract Float16Vector`
Float16Vector.`blend(Vector<Float16> v, VectorMask<Float16> m)`
Replaces selected lanes of this vector with corresponding lanes from a second input vector under the control of a mask.
`abstract Float16Vector`
Float16Vector.`blend(Vector<Float16> v, VectorMask<Float16> m)`
Replaces selected lanes of this vector with corresponding lanes from a second input vector under the control of a mask.
`static Float16Vector`
Float16Vector.`broadcast(VectorSpecies<Float16> species, long e)`
Returns a vector of the given species where all lane elements are set to the primitive value `e`.
`static Float16Vector`
Float16Vector.`broadcast(VectorSpecies<Float16> species, short e)`
Returns a vector of the given species where all lane elements are set to the primitive value `e`.
`final VectorMask<Float16>`
Float16Vector.`compare(VectorOperators.Comparison op, long e, VectorMask<Float16> m)`
Tests this vector by comparing it with an input scalar, according to the given comparison operation, in lanes selected by a mask.
`final VectorMask<Float16>`
Float16Vector.`compare(VectorOperators.Comparison op, short e, VectorMask<Float16> m)`
Tests this vector by comparing it with an input scalar, according to the given comparison operation, in lanes selected by a mask.
`abstract VectorMask<Float16>`
Float16Vector.`compare(VectorOperators.Comparison op, Vector<Float16> v)`
Tests this vector by comparing it with another input vector, according to the given comparison operation.
`abstract Float16Vector`
Float16Vector.`compress(VectorMask<Float16> m)`
Compresses the lane elements of this vector selecting lanes under the control of a specific mask.
`final Float16Vector`
Float16Vector.`div(short e, VectorMask<Float16> m)`
Divides this vector by the broadcast of an input scalar, selecting lane elements controlled by a mask.
`final Float16Vector`
Float16Vector.`div(Vector<Float16> v)`
Divides this vector by a second input vector.
`final Float16Vector`
Float16Vector.`div(Vector<Float16> v, VectorMask<Float16> m)`
Divides this vector by a second input vector under the control of a mask.
`final Float16Vector`
Float16Vector.`div(Vector<Float16> v, VectorMask<Float16> m)`
Divides this vector by a second input vector under the control of a mask.
`final VectorMask<Float16>`
Float16Vector.`eq(Vector<Float16> v)`
Tests if this vector is equal to another input vector.
`abstract Float16Vector`
Float16Vector.`expand(VectorMask<Float16> m)`
Expands the lane elements of this vector under the control of a specific mask.
`final Float16Vector`
Float16Vector.`fma(Vector<Float16> b, Vector<Float16> c)`
Multiplies this vector by a second input vector, and sums the result with a third.
`static Float16Vector`
Float16Vector.`fromArray(VectorSpecies<Float16> species, short[] a, int offset)`
Loads a vector from an array of type `short[]` holding IEEE 754 binary16 values starting at an offset.
`static Float16Vector`
Float16Vector.`fromArray(VectorSpecies<Float16> species, short[] a, int offset, int[] indexMap, int mapOffset)`
Gathers a new vector composed of elements from an array of type `short[]` holding IEEE 754 binary16 values, using indexes obtained by adding a fixed `offset` to a series of secondary offsets from an index map.
`static Float16Vector`
Float16Vector.`fromArray(VectorSpecies<Float16> species, short[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Float16> m)`
Gathers a new vector composed of elements from an array of type `short[]` holding IEEE 754 binary16 values, under the control of a mask, and using indexes obtained by adding a fixed `offset` to a series of secondary offsets from an index map.
`static Float16Vector`
Float16Vector.`fromArray(VectorSpecies<Float16> species, short[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Float16> m)`
Gathers a new vector composed of elements from an array of type `short[]` holding IEEE 754 binary16 values, under the control of a mask, and using indexes obtained by adding a fixed `offset` to a series of secondary offsets from an index map.
`static Float16Vector`
Float16Vector.`fromArray(VectorSpecies<Float16> species, short[] a, int offset, VectorMask<Float16> m)`
Loads a vector from an array of type `short[]` holding IEEE 754 binary16 values starting at an offset and using a mask.
`static Float16Vector`
Float16Vector.`fromArray(VectorSpecies<Float16> species, short[] a, int offset, VectorMask<Float16> m)`
Loads a vector from an array of type `short[]` holding IEEE 754 binary16 values starting at an offset and using a mask.
`static Float16Vector`
Float16Vector.`fromMemorySegment(VectorSpecies<Float16> species, MemorySegment ms, long offset, ByteOrder bo)`
Loads a vector from a memory segment starting at an offset into the memory segment.
`static Float16Vector`
Float16Vector.`fromMemorySegment(VectorSpecies<Float16> species, MemorySegment ms, long offset, ByteOrder bo, VectorMask<Float16> m)`
Loads a vector from a memory segment starting at an offset into the memory segment and using a mask.
`static Float16Vector`
Float16Vector.`fromMemorySegment(VectorSpecies<Float16> species, MemorySegment ms, long offset, ByteOrder bo, VectorMask<Float16> m)`
Loads a vector from a memory segment starting at an offset into the memory segment and using a mask.
`final void`
Float16Vector.`intoArray(short[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Float16> m)`
Scatters this vector into an array of type `short[]`, under the control of a mask, and using indexes obtained by adding a fixed `offset` to a series of secondary offsets from an index map.
`final void`
Float16Vector.`intoArray(short[] a, int offset, VectorMask<Float16> m)`
Stores this vector into an array of type `short[]` starting at offset and using a mask.
`final void`
Float16Vector.`intoMemorySegment(MemorySegment ms, long offset, ByteOrder bo, VectorMask<Float16> m)`
Stores this vector into a memory segment starting at an offset using explicit byte order and a mask.
`final Float16Vector`
Float16Vector.`lanewise(VectorOperators.Binary op, long e, VectorMask<Float16> m)`
Combines the corresponding lane values of this vector with those of a second input vector, with selection of lane elements controlled by a mask.
`final Float16Vector`
Float16Vector.`lanewise(VectorOperators.Binary op, short e, VectorMask<Float16> m)`
Combines the lane values of this vector with the value of a broadcast scalar, with selection of lane elements controlled by a mask.
`abstract Float16Vector`
Float16Vector.`lanewise(VectorOperators.Binary op, Vector<Float16> v)`
Combines the corresponding lane values of this vector with those of a second input vector.
`abstract Float16Vector`
Float16Vector.`lanewise(VectorOperators.Binary op, Vector<Float16> v, VectorMask<Float16> m)`
Combines the corresponding lane values of this vector with those of a second input vector, with selection of lane elements controlled by a mask.
`abstract Float16Vector`
Float16Vector.`lanewise(VectorOperators.Binary op, Vector<Float16> v, VectorMask<Float16> m)`
Combines the corresponding lane values of this vector with those of a second input vector, with selection of lane elements controlled by a mask.
`final Float16Vector`
Float16Vector.`lanewise(VectorOperators.Ternary op, short e1, short e2, VectorMask<Float16> m)`
Combines the lane values of this vector with the values of two broadcast scalars, with selection of lane elements controlled by a mask.
`final Float16Vector`
Float16Vector.`lanewise(VectorOperators.Ternary op, short e1, Vector<Float16> v2)`
Combines the lane values of this vector with the values of another vector and a broadcast scalar.
`final Float16Vector`
Float16Vector.`lanewise(VectorOperators.Ternary op, short e1, Vector<Float16> v2, VectorMask<Float16> m)`
Combines the lane values of this vector with the values of another vector and a broadcast scalar, with selection of lane elements controlled by a mask.
`final Float16Vector`
Float16Vector.`lanewise(VectorOperators.Ternary op, short e1, Vector<Float16> v2, VectorMask<Float16> m)`
Combines the lane values of this vector with the values of another vector and a broadcast scalar, with selection of lane elements controlled by a mask.
`final Float16Vector`
Float16Vector.`lanewise(VectorOperators.Ternary op, Vector<Float16> v1, short e2)`
Combines the lane values of this vector with the values of another vector and a broadcast scalar.
`final Float16Vector`
Float16Vector.`lanewise(VectorOperators.Ternary op, Vector<Float16> v1, short e2, VectorMask<Float16> m)`
Combines the lane values of this vector with the values of another vector and a broadcast scalar, with selection of lane elements controlled by a mask.
`final Float16Vector`
Float16Vector.`lanewise(VectorOperators.Ternary op, Vector<Float16> v1, short e2, VectorMask<Float16> m)`
Combines the lane values of this vector with the values of another vector and a broadcast scalar, with selection of lane elements controlled by a mask.
`abstract Float16Vector`
Float16Vector.`lanewise(VectorOperators.Ternary op, Vector<Float16> v1, Vector<Float16> v2)`
Combines the corresponding lane values of this vector with the lanes of a second and a third input vector.
`abstract Float16Vector`
Float16Vector.`lanewise(VectorOperators.Ternary op, Vector<Float16> v1, Vector<Float16> v2, VectorMask<Float16> m)`
Combines the corresponding lane values of this vector with the lanes of a second and a third input vector, with selection of lane elements controlled by a mask.
`abstract Float16Vector`
Float16Vector.`lanewise(VectorOperators.Ternary op, Vector<Float16> v1, Vector<Float16> v2, VectorMask<Float16> m)`
Combines the corresponding lane values of this vector with the lanes of a second and a third input vector, with selection of lane elements controlled by a mask.
`abstract Float16Vector`
Float16Vector.`lanewise(VectorOperators.Unary op, VectorMask<Float16> m)`
Operates on the lane values of this vector, with selection of lane elements controlled by a mask.
`final VectorMask<Float16>`
Float16Vector.`lt(Vector<Float16> v)`
Tests if this vector is less than another input vector.
`final Float16Vector`
Float16Vector.`max(Vector<Float16> v)`
Computes the larger of this vector and a second input vector.
`final Float16Vector`
Float16Vector.`min(Vector<Float16> v)`
Computes the smaller of this vector and a second input vector.
`final Float16Vector`
Float16Vector.`mul(short e, VectorMask<Float16> m)`
Multiplies this vector by the broadcast of an input scalar, selecting lane elements controlled by a mask.
`final Float16Vector`
Float16Vector.`mul(Vector<Float16> v)`
Multiplies this vector by a second input vector.
`final Float16Vector`
Float16Vector.`mul(Vector<Float16> v, VectorMask<Float16> m)`
Multiplies this vector by a second input vector under the control of a mask.
`final Float16Vector`
Float16Vector.`mul(Vector<Float16> v, VectorMask<Float16> m)`
Multiplies this vector by a second input vector under the control of a mask.
`final Float16Vector`
Float16Vector.`pow(Vector<Float16> b)`
Raises this vector to the power of a second input vector.
`abstract Float16Vector`
Float16Vector.`rearrange(VectorShuffle<Float16> shuffle)`
Rearranges the lane elements of this vector, selecting lanes under the control of a specific shuffle.
`abstract Float16Vector`
Float16Vector.`rearrange(VectorShuffle<Float16> s, Vector<Float16> v)`
Rearranges the lane elements of two vectors, selecting lanes under the control of a specific shuffle, using both normal and exceptional indexes in the shuffle to steer data.
`abstract Float16Vector`
Float16Vector.`rearrange(VectorShuffle<Float16> s, Vector<Float16> v)`
Rearranges the lane elements of two vectors, selecting lanes under the control of a specific shuffle, using both normal and exceptional indexes in the shuffle to steer data.
`abstract Float16Vector`
Float16Vector.`rearrange(VectorShuffle<Float16> s, VectorMask<Float16> m)`
Rearranges the lane elements of this vector, selecting lanes under the control of a specific shuffle and a mask.
`abstract Float16Vector`
Float16Vector.`rearrange(VectorShuffle<Float16> s, VectorMask<Float16> m)`
Rearranges the lane elements of this vector, selecting lanes under the control of a specific shuffle and a mask.
`abstract short`
Float16Vector.`reduceLanes(VectorOperators.Associative op, VectorMask<Float16> m)`
Returns a value accumulated from selected lanes of this vector, controlled by a mask.
`abstract Float16Vector`
Float16Vector.`selectFrom(Vector<Float16> v)`
Using index values stored in the lanes of this vector, assemble values stored in second vector `v`.
`abstract Float16Vector`
Float16Vector.`selectFrom(Vector<Float16> v1, Vector<Float16> v2)`
Using values stored in the lanes of this vector, assemble values stored in the second vector `v1` and third vector `v2`.
`abstract Float16Vector`
Float16Vector.`selectFrom(Vector<Float16> s, VectorMask<Float16> m)`
Using index values stored in the lanes of this vector, assemble values stored in second vector, under the control of a mask.
`abstract Float16Vector`
Float16Vector.`selectFrom(Vector<Float16> s, VectorMask<Float16> m)`
Using index values stored in the lanes of this vector, assemble values stored in second vector, under the control of a mask.
`abstract Float16Vector`
Float16Vector.`slice(int origin, Vector<Float16> v1)`
Slices a segment of adjacent lanes, starting at a given `origin` lane in the current vector, and continuing (as needed) into an immediately following vector.
`final Float16Vector`
Float16Vector.`slice(int origin, Vector<Float16> w, VectorMask<Float16> m)`
Slices a segment of adjacent lanes under the control of a mask, starting at a given `origin` lane in the current vector, and continuing (as needed) into an immediately following vector.
`final Float16Vector`
Float16Vector.`slice(int origin, Vector<Float16> w, VectorMask<Float16> m)`
Slices a segment of adjacent lanes under the control of a mask, starting at a given `origin` lane in the current vector, and continuing (as needed) into an immediately following vector.
`final Float16Vector`
Float16Vector.`sub(short e, VectorMask<Float16> m)`
Subtracts an input scalar from this vector under the control of a mask.
`final Float16Vector`
Float16Vector.`sub(Vector<Float16> v)`
Subtracts a second input vector from this vector.
`final Float16Vector`
Float16Vector.`sub(Vector<Float16> v, VectorMask<Float16> m)`
Subtracts a second input vector from this vector under the control of a mask.
`final Float16Vector`
Float16Vector.`sub(Vector<Float16> v, VectorMask<Float16> m)`
Subtracts a second input vector from this vector under the control of a mask.
`abstract VectorMask<Float16>`
Float16Vector.`test(VectorOperators.Test op, VectorMask<Float16> m)`
Test selected lanes of this vector, according to the given operation.
`abstract Float16Vector`
Float16Vector.`unslice(int origin, Vector<Float16> w, int part)`
Reverses a slice(), inserting the current vector as a slice within another "background" input vector, which is regarded as one or the other input to a hypothetical subsequent `slice()` operation.
`abstract Float16Vector`
Float16Vector.`unslice(int origin, Vector<Float16> w, int part, VectorMask<Float16> m)`
Reverses a slice(), inserting (under the control of a mask) the current vector as a slice within another "background" input vector, which is regarded as one or the other input to a hypothetical subsequent `slice()` operation.
`abstract Float16Vector`
Float16Vector.`unslice(int origin, Vector<Float16> w, int part, VectorMask<Float16> m)`
Reverses a slice(), inserting (under the control of a mask) the current vector as a slice within another "background" input vector, which is regarded as one or the other input to a hypothetical subsequent `slice()` operation.
`static Float16Vector`
Float16Vector.`zero(VectorSpecies<Float16> species)`
Returns a vector of the given species where all lane elements are set to zero, the default primitive value.