Package Summary Overview Summary

### class:VectorOperators [NONE]
public abstract class VectorOperators extends Object This class consists solely of static constants that describe lane-wise vector operations, plus nested interfaces which classify them. The static constants serve as tokens denoting specifically requested lane operations in vector expressions, such as the token `ADD` in `w = v0.` `lanewise``(ADD, v1)` . The documentation for each individual operator token is very brief, giving a symbolic Java expression for the operation that the token requests. Those symbolic expressions use the following conventional elements: `a`, `b`, `c` — names of lane values Java operators like `+`, `?:`, etc. — expression operators Java method names like `max`, `sin`, etc. — methods in standard classes like `Math`, `Double`, etc. Unqualified method names should be read as if in the context of a static import, and with resolution of overloading. `bits(x)` — a function call which produces the underlying bits of the value `x`. If `x` is a floating point value, this is either `doubleToLongBits(x)` or `floatToIntBits(x)`. Otherwise, the value is just `x`. `ESIZE` — the size in bytes of the operand type `intVal`, `byteVal`, etc. — the operand of a conversion, with the indicated type ## Operations on floating point vectors Lane-wise vector operations that apply to floating point vectors follow the accuracy and monotonicity specifications of the equivalent Java operation or method mentioned in its documentation. If the vector element type is `float` and the Java operation or method only accepts and returns `double` values, then the scalar operation on each lane is adapted to cast operands and the result, specifically widening `float` operands to `double` operands and narrowing the `double` result to a `float`. Certain associative operations that apply to floating point vectors are not truly associative on the floating point lane values. Specifically, `ADD` and `MUL` used with cross-lane reduction operations, such as `FloatVector.reduceLanes(Associative)`. The result of such an operation is a function both of the input values (vector and mask) as well as the order of the scalar operations applied to combine lane values. In such cases the order is intentionally not defined. This allows the JVM to generate optimal machine code for the underlying platform at runtime. If the platform supports a vector instruction to add or 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 is applied, which adds vector elements sequentially from beginning to end. For this reason, the result of such an operation may vary for the same input values. Note that a particular operator token may apply to several different lane types. Thus, these tokens behave like overloaded operators or methods, not like type-specific method handles or lambdas. Also unlike method handles or lambdas, these operators do not possess operational semantics; they have no `apply` or `invoke` method. They are used only to request lane operations from vector objects, and cannot (by themselves) perform operations on individual lane values.

### field:NOT [NONE]
### NOT public static final VectorOperators.Unary NOT Produce `~a`. Integral only.

### field:ZOMO [NONE]
### ZOMO public static final VectorOperators.Unary ZOMO Produce `a==0?0:-1` (zero or minus one). Integral only.

### field:ABS [NONE]
### ABS public static final VectorOperators.Unary ABS Produce `abs(a)`.

### field:NEG [NONE]
### NEG public static final VectorOperators.Unary NEG Produce `-a`.

### field:SIN [NONE]
### SIN public static final VectorOperators.Unary SIN Produce `sin(a)`. Floating only. See section "Operations on floating point vectors" above

### field:COS [NONE]
### COS public static final VectorOperators.Unary COS Produce `cos(a)`. Floating only. See section "Operations on floating point vectors" above

### field:TAN [NONE]
### TAN public static final VectorOperators.Unary TAN Produce `tan(a)`. Floating only. See section "Operations on floating point vectors" above

### field:ASIN [NONE]
### ASIN public static final VectorOperators.Unary ASIN Produce `asin(a)`. Floating only. See section "Operations on floating point vectors" above

### field:ACOS [NONE]
### ACOS public static final VectorOperators.Unary ACOS Produce `acos(a)`. Floating only. See section "Operations on floating point vectors" above

### field:ATAN [NONE]
### ATAN public static final VectorOperators.Unary ATAN Produce `atan(a)`. Floating only. See section "Operations on floating point vectors" above

### field:EXP [NONE]
### EXP public static final VectorOperators.Unary EXP Produce `exp(a)`. Floating only. See section "Operations on floating point vectors" above

### field:LOG [NONE]
### LOG public static final VectorOperators.Unary LOG Produce `log(a)`. Floating only. See section "Operations on floating point vectors" above

### field:LOG10 [NONE]
### LOG10 public static final VectorOperators.Unary LOG10 Produce `log10(a)`. Floating only. See section "Operations on floating point vectors" above

### field:SQRT [NONE]
### SQRT public static final VectorOperators.Unary SQRT Produce `sqrt(a)`. Floating only. See section "Operations on floating point vectors" above

### field:CBRT [NONE]
### CBRT public static final VectorOperators.Unary CBRT Produce `cbrt(a)`. Floating only. See section "Operations on floating point vectors" above

### field:SINH [NONE]
### SINH public static final VectorOperators.Unary SINH Produce `sinh(a)`. Floating only. See section "Operations on floating point vectors" above

### field:COSH [NONE]
### COSH public static final VectorOperators.Unary COSH Produce `cosh(a)`. Floating only. See section "Operations on floating point vectors" above

### field:TANH [NONE]
### TANH public static final VectorOperators.Unary TANH Produce `tanh(a)`. Floating only. See section "Operations on floating point vectors" above

### field:EXPM1 [NONE]
### EXPM1 public static final VectorOperators.Unary EXPM1 Produce `expm1(a)`. Floating only. See section "Operations on floating point vectors" above

### field:LOG1P [NONE]
### LOG1P public static final VectorOperators.Unary LOG1P Produce `log1p(a)`. Floating only. See section "Operations on floating point vectors" above

### field:ADD [NONE]
### ADD public static final VectorOperators.Associative ADD Produce `a+b`.

### field:SUB [NONE]
### SUB public static final VectorOperators.Binary SUB Produce `a-b`.

### field:MUL [NONE]
### MUL public static final VectorOperators.Associative MUL Produce `a*b`.

### field:DIV [NONE]
### DIV public static final VectorOperators.Binary DIV Produce `a/b`. Floating only.

### field:MIN [NONE]
### MIN public static final VectorOperators.Associative MIN Produce `min(a,b)`.

### field:MAX [NONE]
### MAX public static final VectorOperators.Associative MAX Produce `max(a,b)`.

### field:FIRST_NONZERO [NONE]
### FIRST_NONZERO public static final VectorOperators.Associative FIRST_NONZERO Produce `bits(a)!=0?a:b`.

### field:AND [NONE]
### AND public static final VectorOperators.Associative AND Produce `a&b`. Integral only.

### field:AND_NOT [NONE]
### AND_NOT public static final VectorOperators.Binary AND_NOT Produce `a&~b`. Integral only.

### field:OR [NONE]
### OR public static final VectorOperators.Associative OR Produce `a|b`. Integral only.

### field:XOR [NONE]
### XOR public static final VectorOperators.Associative XOR Produce `a^b`. Integral only.

### field:LSHL [NONE]
### LSHL public static final VectorOperators.Binary LSHL Produce `a<<(n&(ESIZE*8-1))`. Integral only.

### field:ASHR [NONE]
### ASHR public static final VectorOperators.Binary ASHR Produce `a>>(n&(ESIZE*8-1))`. Integral only.

### field:LSHR [NONE]
### LSHR public static final VectorOperators.Binary LSHR Produce `a>>>(n&(ESIZE*8-1))`. Integral only.

### field:ROL [NONE]
### ROL public static final VectorOperators.Binary ROL Produce `rotateLeft(a,n)`. Integral only.

### field:ROR [NONE]
### ROR public static final VectorOperators.Binary ROR Produce `rotateRight(a,n)`. Integral only.

### field:ATAN2 [NONE]
### ATAN2 public static final VectorOperators.Binary ATAN2 Produce `atan2(a,b)`. See Floating only. See section "Operations on floating point vectors" above

### field:POW [NONE]
### POW public static final VectorOperators.Binary POW Produce `pow(a,b)`. Floating only. See section "Operations on floating point vectors" above

### field:HYPOT [NONE]
### HYPOT public static final VectorOperators.Binary HYPOT Produce `hypot(a,b)`. Floating only. See section "Operations on floating point vectors" above

### field:BITWISE_BLEND [NONE]
### BITWISE_BLEND public static final VectorOperators.Ternary BITWISE_BLEND Produce `a^((a^b)&c)`. (Bitwise `(c(i)?b(i):a(i))`.) Integral only.

### field:FMA [NONE]
### FMA public static final VectorOperators.Ternary FMA Produce `fma(a,b,c)`. Floating only.

### field:IS_DEFAULT [NONE]
### IS_DEFAULT public static final VectorOperators.Test IS_DEFAULT Test `bits(a)==0`. (Not true of `-0.0`.)

### field:IS_NEGATIVE [NONE]
### IS_NEGATIVE public static final VectorOperators.Test IS_NEGATIVE Test `bits(a)<0`. (True of `-0.0`.)

### field:IS_FINITE [NONE]
### IS_FINITE public static final VectorOperators.Test IS_FINITE Test `isFinite(a)`. Floating only.

### field:IS_NAN [NONE]
### IS_NAN public static final VectorOperators.Test IS_NAN Test `isNaN(a)`. Floating only.

### field:IS_INFINITE [NONE]
### IS_INFINITE public static final VectorOperators.Test IS_INFINITE Test `isInfinite(a)`. Floating only.

### field:EQ [NONE]
### EQ public static final VectorOperators.Comparison EQ Compare `a==b`.

### field:NE [NONE]
### NE public static final VectorOperators.Comparison NE Compare `a!=b`.

### field:LT [NONE]
### LT public static final VectorOperators.Comparison LT Compare `a<b`.

### field:LE [NONE]
### LE public static final VectorOperators.Comparison LE Compare `a<=b`.

### field:GT [NONE]
### GT public static final VectorOperators.Comparison GT Compare `a>b`.

### field:GE [NONE]
### GE public static final VectorOperators.Comparison GE Compare `a>=b`.

### field:UNSIGNED_LT [ADDED]
### UNSIGNED_LT public static final VectorOperators.Comparison UNSIGNED_LT Unsigned compare `a<b`. Integral only.

### field:UNSIGNED_LE [ADDED]
### UNSIGNED_LE public static final VectorOperators.Comparison UNSIGNED_LE Unsigned compare `a<=b`. Integral only.

### field:UNSIGNED_GT [ADDED]
### UNSIGNED_GT public static final VectorOperators.Comparison UNSIGNED_GT Unsigned compare `a>b`. Integral only.

### field:UNSIGNED_GE [ADDED]
### UNSIGNED_GE public static final VectorOperators.Comparison UNSIGNED_GE Unsigned compare `a>=b`. Integral only.

### field:B2D [NONE]
### B2D public static final VectorOperators.Conversion<Byte,​Double> B2D Convert `byteVal` to `(double)byteVal`.

### field:B2F [NONE]
### B2F public static final VectorOperators.Conversion<Byte,​Float> B2F Convert `byteVal` to `(float)byteVal`.

### field:B2I [NONE]
### B2I public static final VectorOperators.Conversion<Byte,​Integer> B2I Convert `byteVal` to `(int)byteVal`.

### field:B2L [NONE]
### B2L public static final VectorOperators.Conversion<Byte,​Long> B2L Convert `byteVal` to `(long)byteVal`.

### field:B2S [NONE]
### B2S public static final VectorOperators.Conversion<Byte,​Short> B2S Convert `byteVal` to `(short)byteVal`.

### field:D2B [NONE]
### D2B public static final VectorOperators.Conversion<Double,​Byte> D2B Convert `doubleVal` to `(byte)doubleVal`.

### field:D2F [NONE]
### D2F public static final VectorOperators.Conversion<Double,​Float> D2F Convert `doubleVal` to `(float)doubleVal`.

### field:D2I [NONE]
### D2I public static final VectorOperators.Conversion<Double,​Integer> D2I Convert `doubleVal` to `(int)doubleVal`.

### field:D2L [NONE]
### D2L public static final VectorOperators.Conversion<Double,​Long> D2L Convert `doubleVal` to `(long)doubleVal`.

### field:D2S [NONE]
### D2S public static final VectorOperators.Conversion<Double,​Short> D2S Convert `doubleVal` to `(short)doubleVal`.

### field:F2B [NONE]
### F2B public static final VectorOperators.Conversion<Float,​Byte> F2B Convert `floatVal` to `(byte)floatVal`.

### field:F2D [NONE]
### F2D public static final VectorOperators.Conversion<Float,​Double> F2D Convert `floatVal` to `(double)floatVal`.

### field:F2I [NONE]
### F2I public static final VectorOperators.Conversion<Float,​Integer> F2I Convert `floatVal` to `(int)floatVal`.

### field:F2L [NONE]
### F2L public static final VectorOperators.Conversion<Float,​Long> F2L Convert `floatVal` to `(long)floatVal`.

### field:F2S [NONE]
### F2S public static final VectorOperators.Conversion<Float,​Short> F2S Convert `floatVal` to `(short)floatVal`.

### field:I2B [NONE]
### I2B public static final VectorOperators.Conversion<Integer,​Byte> I2B Convert `intVal` to `(byte)intVal`.

### field:I2D [NONE]
### I2D public static final VectorOperators.Conversion<Integer,​Double> I2D Convert `intVal` to `(double)intVal`.

### field:I2F [NONE]
### I2F public static final VectorOperators.Conversion<Integer,​Float> I2F Convert `intVal` to `(float)intVal`.

### field:I2L [NONE]
### I2L public static final VectorOperators.Conversion<Integer,​Long> I2L Convert `intVal` to `(long)intVal`.

### field:I2S [NONE]
### I2S public static final VectorOperators.Conversion<Integer,​Short> I2S Convert `intVal` to `(short)intVal`.

### field:L2B [NONE]
### L2B public static final VectorOperators.Conversion<Long,​Byte> L2B Convert `longVal` to `(byte)longVal`.

### field:L2D [NONE]
### L2D public static final VectorOperators.Conversion<Long,​Double> L2D Convert `longVal` to `(double)longVal`.

### field:L2F [NONE]
### L2F public static final VectorOperators.Conversion<Long,​Float> L2F Convert `longVal` to `(float)longVal`.

### field:L2I [NONE]
### L2I public static final VectorOperators.Conversion<Long,​Integer> L2I Convert `longVal` to `(int)longVal`.

### field:L2S [NONE]
### L2S public static final VectorOperators.Conversion<Long,​Short> L2S Convert `longVal` to `(short)longVal`.

### field:S2B [NONE]
### S2B public static final VectorOperators.Conversion<Short,​Byte> S2B Convert `shortVal` to `(byte)shortVal`.

### field:S2D [NONE]
### S2D public static final VectorOperators.Conversion<Short,​Double> S2D Convert `shortVal` to `(double)shortVal`.

### field:S2F [NONE]
### S2F public static final VectorOperators.Conversion<Short,​Float> S2F Convert `shortVal` to `(float)shortVal`.

### field:S2I [NONE]
### S2I public static final VectorOperators.Conversion<Short,​Integer> S2I Convert `shortVal` to `(int)shortVal`.

### field:S2L [NONE]
### S2L public static final VectorOperators.Conversion<Short,​Long> S2L Convert `shortVal` to `(long)shortVal`.

### field:REINTERPRET_D2L [NONE]
### REINTERPRET_D2L public static final VectorOperators.Conversion<Double,​Long> REINTERPRET_D2L Reinterpret bits of `doubleVal` as `long`. As if by `Double.doubleToRawLongBits(double)`

### field:REINTERPRET_F2I [NONE]
### REINTERPRET_F2I public static final VectorOperators.Conversion<Float,​Integer> REINTERPRET_F2I Reinterpret bits of `floatVal` as `int`. As if by `Float.floatToRawIntBits(float)`

### field:REINTERPRET_I2F [NONE]
### REINTERPRET_I2F public static final VectorOperators.Conversion<Integer,​Float> REINTERPRET_I2F Reinterpret bits of `intVal` as `float`. As if by `Float.intBitsToFloat(int)`

### field:REINTERPRET_L2D [NONE]
### REINTERPRET_L2D public static final VectorOperators.Conversion<Long,​Double> REINTERPRET_L2D Reinterpret bits of `longVal` as `double`. As if by `Double.longBitsToDouble(long)`

### field:ZERO_EXTEND_B2I [NONE]
### ZERO_EXTEND_B2I public static final VectorOperators.Conversion<Byte,​Integer> ZERO_EXTEND_B2I Zero-extend `byteVal` to `int`.

### field:ZERO_EXTEND_B2L [NONE]
### ZERO_EXTEND_B2L public static final VectorOperators.Conversion<Byte,​Long> ZERO_EXTEND_B2L Zero-extend `byteVal` to `long`.

### field:ZERO_EXTEND_B2S [NONE]
### ZERO_EXTEND_B2S public static final VectorOperators.Conversion<Byte,​Short> ZERO_EXTEND_B2S Zero-extend `byteVal` to `short`.

### field:ZERO_EXTEND_I2L [NONE]
### ZERO_EXTEND_I2L public static final VectorOperators.Conversion<Integer,​Long> ZERO_EXTEND_I2L Zero-extend `intVal` to `long`.

### field:ZERO_EXTEND_S2I [NONE]
### ZERO_EXTEND_S2I public static final VectorOperators.Conversion<Short,​Integer> ZERO_EXTEND_S2I Zero-extend `shortVal` to `int`.

### field:ZERO_EXTEND_S2L [NONE]
### ZERO_EXTEND_S2L public static final VectorOperators.Conversion<Short,​Long> ZERO_EXTEND_S2L Zero-extend `shortVal` to `long`.