# Class VectorOperators

java.lang.Object
jdk.incubator.vector.VectorOperators

public final 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 `doubleToLongBits(x)`, `floatToIntBits(x)`, or `float16ToShortBits(x)`. Otherwise, the value is just `x`.
- `ESIZE` — the size in bytes of the operand type
- `EMASK` — the bit mask of the operand type, where `EMASK=(1<<(ESIZE*8))-1`
- `intVal`, `byteVal`, etc. — the operand of a conversion, with the indicated type
- Single-letter type codes used in the names of conversion operator tokens (for example `B2D`, `F2H`, `H2F`, `REINTERPRET_F2I`, `ZERO_EXTEND_B2L`) abbreviate lane types as follows:

  Lane type letter codes
  Letter | Lane type
  --- | ---
  `B` | `byte`
  `S` | `short`
  `I` | `int`
  `L` | `long`
  `F` | `float`
  `D` | `double`
  `H` | `Float16` ("half")

## 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 unless specified otherwise. 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.

## Nested Class Summary

Nested Classes
Modifier and Type
Class
Description
`static interface`
`VectorOperators.Associative`
Type for all reassociating lane-wise binary operators, usable in expressions like `e = v0.``reduceLanes``(ADD)`.
`static interface`
`VectorOperators.Binary`
Type for all lane-wise binary (two-argument) operators, usable in expressions like `w = v0.``lanewise``(ADD, v1)`.
`static interface`
`VectorOperators.Comparison`
Type for all binary lane-wise boolean comparisons on lane values, usable in expressions like `m = v0.``compare``(LT, v1)`.
`static interface`
`VectorOperators.Conversion<E,F>`
Type for all lane-wise conversions on lane values, usable in expressions like `w1 = v0.``convert``(I2D, 1)`.
`static interface`
`VectorOperators.Operator`
Root type for all operator tokens, providing queries for common properties such as arity, argument and return types, symbolic name, and operator name.
`static interface`
`VectorOperators.Ternary`
Type for all lane-wise ternary (three-argument) operators, usable in expressions like `w = v0.``lanewise``(FMA, v1, v2)`.
`static interface`
`VectorOperators.Test`
Type for all unary lane-wise boolean tests on lane values, usable in expressions like `m = v0.``test``(IS_FINITE)`.
`static interface`
`VectorOperators.Unary`
Type for all lane-wise unary (one-argument) operators, usable in expressions like `w = v0.``lanewise``(NEG)`.

## Field Summary

Fields
Modifier and Type
Field
Description
`static final VectorOperators.Unary`
`ABS`
Produce `abs(a)`.
`static final VectorOperators.Unary`
`ACOS`
Produce `acos(a)`.
`static final VectorOperators.Associative`
`ADD`
Produce `a+b`.
`static final VectorOperators.Associative`
`AND`
Produce `a&b`.
`static final VectorOperators.Binary`
`AND_NOT`
Produce `a&~b`.
`static final VectorOperators.Binary`
`ASHR`
Produce `a>>(n&(ESIZE*8-1))`.
`static final VectorOperators.Unary`
`ASIN`
Produce `asin(a)`.
`static final VectorOperators.Unary`
`ATAN`
Produce `atan(a)`.
`static final VectorOperators.Binary`
`ATAN2`
Produce `atan2(a,b)`.
`static final VectorOperators.Conversion<Byte,Double>`
`B2D`
Convert `byteVal` to `(double)byteVal`.
`static final VectorOperators.Conversion<Byte,Float>`
`B2F`
Convert `byteVal` to `(float)byteVal`.
`static final VectorOperators.Conversion<Byte,Float16>`
`B2H`
Convert `byteVal` to `(Float16)byteVal`.
`static final VectorOperators.Conversion<Byte,Integer>`
`B2I`
Convert `byteVal` to `(int)byteVal`.
`static final VectorOperators.Conversion<Byte,Long>`
`B2L`
Convert `byteVal` to `(long)byteVal`.
`static final VectorOperators.Conversion<Byte,Short>`
`B2S`
Convert `byteVal` to `(short)byteVal`.
`static final VectorOperators.Unary`
`BIT_COUNT`
Produce `bitCount(a)`.
`static final VectorOperators.Ternary`
`BITWISE_BLEND`
Produce `a^((a^b)&c)`.
`static final VectorOperators.Unary`
`CBRT`
Produce `cbrt(a)`.
`static final VectorOperators.Binary`
`COMPRESS_BITS`
Produce `compress(a,n)`.
`static final VectorOperators.Unary`
`COS`
Produce `cos(a)`.
`static final VectorOperators.Unary`
`COSH`
Produce `cosh(a)`.
`static final VectorOperators.Conversion<Double,Byte>`
`D2B`
Convert `doubleVal` to `(byte)doubleVal`.
`static final VectorOperators.Conversion<Double,Float>`
`D2F`
Convert `doubleVal` to `(float)doubleVal`.
`static final VectorOperators.Conversion<Double,Float16>`
`D2H`
Convert `doubleVal` to `(Float16)doubleVal`.
`static final VectorOperators.Conversion<Double,Integer>`
`D2I`
Convert `doubleVal` to `(int)doubleVal`.
`static final VectorOperators.Conversion<Double,Long>`
`D2L`
Convert `doubleVal` to `(long)doubleVal`.
`static final VectorOperators.Conversion<Double,Short>`
`D2S`
Convert `doubleVal` to `(short)doubleVal`.
`static final VectorOperators.Binary`
`DIV`
Produce `a/b`.
`static final VectorOperators.Comparison`
`EQ`
Compare `a==b`.
`static final VectorOperators.Unary`
`EXP`
Produce `exp(a)`.
`static final VectorOperators.Binary`
`EXPAND_BITS`
Produce `expand(a,n)`.
`static final VectorOperators.Unary`
`EXPM1`
Produce `expm1(a)`.
`static final VectorOperators.Conversion<Float,Byte>`
`F2B`
Convert `floatVal` to `(byte)floatVal`.
`static final VectorOperators.Conversion<Float,Double>`
`F2D`
Convert `floatVal` to `(double)floatVal`.
`static final VectorOperators.Conversion<Float,Float16>`
`F2H`
Convert `floatVal` to `(Float16)floatVal`.
`static final VectorOperators.Conversion<Float,Integer>`
`F2I`
Convert `floatVal` to `(int)floatVal`.
`static final VectorOperators.Conversion<Float,Long>`
`F2L`
Convert `floatVal` to `(long)floatVal`.
`static final VectorOperators.Conversion<Float,Short>`
`F2S`
Convert `floatVal` to `(short)floatVal`.
`static final VectorOperators.Associative`
`FIRST_NONZERO`
Produce `bits(a)!=0?a:b`.
`static final VectorOperators.Ternary`
`FMA`
Produce `fma(a,b,c)`.
`static final VectorOperators.Comparison`
`GE`
Compare `a>=b`.
`static final VectorOperators.Comparison`
`GT`
Compare `a>b`.
`static final VectorOperators.Conversion<Float16,Byte>`
`H2B`
Convert `Float16Val` to `(byte)Float16Val`.
`static final VectorOperators.Conversion<Float16,Double>`
`H2D`
Convert `Float16Val` to `(double)Float16Val`.
`static final VectorOperators.Conversion<Float16,Float>`
`H2F`
Convert `Float16Val` to `(float)Float16Val`.
`static final VectorOperators.Conversion<Float16,Integer>`
`H2I`
Convert `Float16Val` to `(int)Float16Val`.
`static final VectorOperators.Conversion<Float16,Long>`
`H2L`
Convert `Float16Val` to `(long)Float16Val`.
`static final VectorOperators.Conversion<Float16,Short>`
`H2S`
Convert `Float16Val` to `(short)Float16Val`.
`static final VectorOperators.Binary`
`HYPOT`
Produce `hypot(a,b)`.
`static final VectorOperators.Conversion<Integer,Byte>`
`I2B`
Convert `intVal` to `(byte)intVal`.
`static final VectorOperators.Conversion<Integer,Double>`
`I2D`
Convert `intVal` to `(double)intVal`.
`static final VectorOperators.Conversion<Integer,Float>`
`I2F`
Convert `intVal` to `(float)intVal`.
`static final VectorOperators.Conversion<Integer,Float16>`
`I2H`
Convert `intVal` to `(Float16)intVal`.
`static final VectorOperators.Conversion<Integer,Long>`
`I2L`
Convert `intVal` to `(long)intVal`.
`static final VectorOperators.Conversion<Integer,Short>`
`I2S`
Convert `intVal` to `(short)intVal`.
`static final VectorOperators.Test`
`IS_DEFAULT`
Test `bits(a)==0`.
`static final VectorOperators.Test`
`IS_FINITE`
Test `isFinite(a)`.
`static final VectorOperators.Test`
`IS_INFINITE`
Test `isInfinite(a)`.
`static final VectorOperators.Test`
`IS_NAN`
Test `isNaN(a)`.
`static final VectorOperators.Test`
`IS_NEGATIVE`
Test `bits(a)<0`.
`static final VectorOperators.Conversion<Long,Byte>`
`L2B`
Convert `longVal` to `(byte)longVal`.
`static final VectorOperators.Conversion<Long,Double>`
`L2D`
Convert `longVal` to `(double)longVal`.
`static final VectorOperators.Conversion<Long,Float>`
`L2F`
Convert `longVal` to `(float)longVal`.
`static final VectorOperators.Conversion<Long,Float16>`
`L2H`
Convert `longVal` to `(Float16)longVal`.
`static final VectorOperators.Conversion<Long,Integer>`
`L2I`
Convert `longVal` to `(int)longVal`.
`static final VectorOperators.Conversion<Long,Short>`
`L2S`
Convert `longVal` to `(short)longVal`.
`static final VectorOperators.Comparison`
`LE`
Compare `a<=b`.
`static final VectorOperators.Unary`
`LEADING_ZEROS_COUNT`
Produce `numberOfLeadingZeros(a)`.
`static final VectorOperators.Unary`
`LOG`
Produce `log(a)`.
`static final VectorOperators.Unary`
`LOG10`
Produce `log10(a)`.
`static final VectorOperators.Unary`
`LOG1P`
Produce `log1p(a)`.
`static final VectorOperators.Binary`
`LSHL`
Produce `a<<(n&(ESIZE*8-1))`.
`static final VectorOperators.Binary`
`LSHR`
Produce `(a&EMASK)>>>(n&(ESIZE*8-1))`.
`static final VectorOperators.Comparison`
`LT`
Compare `a<b`.
`static final VectorOperators.Associative`
`MAX`
Produce `max(a,b)`.
`static final VectorOperators.Associative`
`MIN`
Produce `min(a,b)`.
`static final VectorOperators.Associative`
`MUL`
Produce `a*b`.
`static final VectorOperators.Comparison`
`NE`
Compare `a!=b`.
`static final VectorOperators.Unary`
`NEG`
Produce `-a`.
`static final VectorOperators.Unary`
`NOT`
Produce `~a`.
`static final VectorOperators.Associative`
`OR`
Produce `a|b`.
`static final VectorOperators.Binary`
`POW`
Produce `pow(a,b)`.
`static final VectorOperators.Conversion<Double,Long>`
`REINTERPRET_D2L`
Reinterpret bits of `doubleVal` as `long`.
`static final VectorOperators.Conversion<Float,Integer>`
`REINTERPRET_F2I`
Reinterpret bits of `floatVal` as `int`.
`static final VectorOperators.Conversion<Integer,Float>`
`REINTERPRET_I2F`
Reinterpret bits of `intVal` as `float`.
`static final VectorOperators.Conversion<Long,Double>`
`REINTERPRET_L2D`
Reinterpret bits of `longVal` as `double`.
`static final VectorOperators.Unary`
`REVERSE`
Produce `reverse(a)`.
`static final VectorOperators.Unary`
`REVERSE_BYTES`
Produce `reverseBytes(a)`.
`static final VectorOperators.Binary`
`ROL`
Produce `rotateLeft(a,n)`.
`static final VectorOperators.Binary`
`ROR`
Produce `rotateRight(a,n)`.
`static final VectorOperators.Conversion<Short,Byte>`
`S2B`
Convert `shortVal` to `(byte)shortVal`.
`static final VectorOperators.Conversion<Short,Double>`
`S2D`
Convert `shortVal` to `(double)shortVal`.
`static final VectorOperators.Conversion<Short,Float>`
`S2F`
Convert `shortVal` to `(float)shortVal`.
`static final VectorOperators.Conversion<Short,Float16>`
`S2H`
Convert `shortVal` to `(Float16)shortVal`.
`static final VectorOperators.Conversion<Short,Integer>`
`S2I`
Convert `shortVal` to `(int)shortVal`.
`static final VectorOperators.Conversion<Short,Long>`
`S2L`
Convert `shortVal` to `(long)shortVal`.
`static final VectorOperators.Binary`
`SADD`
Produce saturating `a+b`.
`static final VectorOperators.Unary`
`SIN`
Produce `sin(a)`.
`static final VectorOperators.Unary`
`SINH`
Produce `sinh(a)`.
`static final VectorOperators.Unary`
`SQRT`
Produce `sqrt(a)`.
`static final VectorOperators.Binary`
`SSUB`
Produce saturating `a-b`.
`static final VectorOperators.Associative`
`SUADD`
Produce saturating unsigned `a+b`.
`static final VectorOperators.Binary`
`SUB`
Produce `a-b`.
`static final VectorOperators.Binary`
`SUSUB`
Produce saturating unsigned `a-b`.
`static final VectorOperators.Unary`
`TAN`
Produce `tan(a)`.
`static final VectorOperators.Unary`
`TANH`
Produce `tanh(a)`.
`static final VectorOperators.Unary`
`TRAILING_ZEROS_COUNT`
Produce `numberOfTrailingZeros(a)`.
`static final VectorOperators.Comparison`
`UGE`
Unsigned compare `a>=b`.
`static final VectorOperators.Comparison`
`UGT`
Unsigned compare `a>b`.
`static final VectorOperators.Comparison`
`ULE`
Unsigned compare `a<=b`.
`static final VectorOperators.Comparison`
`ULT`
Unsigned compare `a<b`.
`static final VectorOperators.Associative`
`UMAX`
Produce unsigned `max(a,b)`.
`static final VectorOperators.Associative`
`UMIN`
Produce unsigned `min(a,b)`.
`static final VectorOperators.Associative`
`XOR`
Produce `a^b`.
`static final VectorOperators.Conversion<Byte,Integer>`
`ZERO_EXTEND_B2I`
Zero-extend `byteVal` to `int`.
`static final VectorOperators.Conversion<Byte,Long>`
`ZERO_EXTEND_B2L`
Zero-extend `byteVal` to `long`.
`static final VectorOperators.Conversion<Byte,Short>`
`ZERO_EXTEND_B2S`
Zero-extend `byteVal` to `short`.
`static final VectorOperators.Conversion<Integer,Long>`
`ZERO_EXTEND_I2L`
Zero-extend `intVal` to `long`.
`static final VectorOperators.Conversion<Short,Integer>`
`ZERO_EXTEND_S2I`
Zero-extend `shortVal` to `int`.
`static final VectorOperators.Conversion<Short,Long>`
`ZERO_EXTEND_S2L`
Zero-extend `shortVal` to `long`.
`static final VectorOperators.Unary`
`ZOMO`
Produce `a==0?0:-1` (zero or minus one).

## Method Summary

### Methods declared in class Object

`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`
Modifier and Type
Method
Description
`protected Object`
`clone()`
Creates and returns a copy of this object.
`boolean`
`equals(Object obj)`
Indicates whether some other object is "equal to" this one.
`protected void`
`finalize()`
Deprecated, for removal: This API element is subject to removal in a future version.
Finalization is deprecated and subject to removal in a future release.
`final Class<?>`
`getClass()`
Returns the runtime class of this `Object`.
`int`
`hashCode()`
Returns a hash code value for this object.
`final void`
`notify()`
Wakes up a single thread that is waiting on this object's monitor.
`final void`
`notifyAll()`
Wakes up all threads that are waiting on this object's monitor.
`String`
`toString()`
Returns a string representation of the object.
`final void`
`wait()`
Causes the current thread to wait until it is awakened, typically by being notified or interrupted.
`final void`
`wait(long timeoutMillis)`
Causes the current thread to wait until it is awakened, typically by being notified or interrupted, or until a certain amount of real time has elapsed.
`final void`
`wait(long timeoutMillis, int nanos)`
Causes the current thread to wait until it is awakened, typically by being notified or interrupted, or until a certain amount of real time has elapsed.

## Field Details

### NOT

public static final VectorOperators.Unary NOT
Produce `~a`. Integral only.

### ZOMO

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

### ABS

public static final VectorOperators.Unary ABS
Produce `abs(a)`.

### NEG

public static final VectorOperators.Unary NEG
Produce `-a`.

### BIT_COUNT

public static final VectorOperators.Unary BIT_COUNT
Produce `bitCount(a)`. Integral only.

Since:
  19

### TRAILING_ZEROS_COUNT

public static final VectorOperators.Unary TRAILING_ZEROS_COUNT
Produce `numberOfTrailingZeros(a)`. Integral only.

Since:
  19

### LEADING_ZEROS_COUNT

public static final VectorOperators.Unary LEADING_ZEROS_COUNT
Produce `numberOfLeadingZeros(a)`. Integral only.

Since:
  19

### REVERSE

public static final VectorOperators.Unary REVERSE
Produce `reverse(a)`. Integral only.

Since:
  19

### REVERSE_BYTES

public static final VectorOperators.Unary REVERSE_BYTES
Produce `reverseBytes(a)`. Integral only.

Since:
  19

### SIN

public static final VectorOperators.Unary SIN
Produce `sin(a)`. Floating only. Not guaranteed to be semi-monotonic. See section "Operations on floating point vectors" above

### COS

public static final VectorOperators.Unary COS
Produce `cos(a)`. Floating only. Not guaranteed to be semi-monotonic. See section "Operations on floating point vectors" above

### TAN

public static final VectorOperators.Unary TAN
Produce `tan(a)`. Floating only. Not guaranteed to be semi-monotonic. See section "Operations on floating point vectors" above

### ASIN

public static final VectorOperators.Unary ASIN
Produce `asin(a)`. Floating only. Not guaranteed to be semi-monotonic. See section "Operations on floating point vectors" above

### ACOS

public static final VectorOperators.Unary ACOS
Produce `acos(a)`. Floating only. Not guaranteed to be semi-monotonic. See section "Operations on floating point vectors" above

### ATAN

public static final VectorOperators.Unary ATAN
Produce `atan(a)`. Floating only. Not guaranteed to be semi-monotonic. See section "Operations on floating point vectors" above

### EXP

public static final VectorOperators.Unary EXP
Produce `exp(a)`. Floating only. Not guaranteed to be semi-monotonic. See section "Operations on floating point vectors" above

### LOG

public static final VectorOperators.Unary LOG
Produce `log(a)`. Floating only. Not guaranteed to be semi-monotonic. See section "Operations on floating point vectors" above

### LOG10

public static final VectorOperators.Unary LOG10
Produce `log10(a)`. Floating only. Not guaranteed to be semi-monotonic. See section "Operations on floating point vectors" above

### SQRT

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

### CBRT

public static final VectorOperators.Unary CBRT
Produce `cbrt(a)`. Floating only. Not guaranteed to be semi-monotonic. See section "Operations on floating point vectors" above

### SINH

public static final VectorOperators.Unary SINH
Produce `sinh(a)`. Floating only. Not guaranteed to be semi-monotonic. See section "Operations on floating point vectors" above

### COSH

public static final VectorOperators.Unary COSH
Produce `cosh(a)`. Floating only. Not guaranteed to be semi-monotonic. See section "Operations on floating point vectors" above

### TANH

public static final VectorOperators.Unary TANH
Produce `tanh(a)`. Floating only. Not guaranteed to be semi-monotonic. See section "Operations on floating point vectors" above

### EXPM1

public static final VectorOperators.Unary EXPM1
Produce `expm1(a)`. Floating only. Not guaranteed to be semi-monotonic. See section "Operations on floating point vectors" above

### LOG1P

public static final VectorOperators.Unary LOG1P
Produce `log1p(a)`. Floating only. Not guaranteed to be semi-monotonic. See section "Operations on floating point vectors" above

### ADD

public static final VectorOperators.Associative ADD
Produce `a+b`.

### SUB

public static final VectorOperators.Binary SUB
Produce `a-b`.

### MUL

public static final VectorOperators.Associative MUL
Produce `a*b`.

### DIV

public static final VectorOperators.Binary DIV
Produce `a/b`. Floating only.

### MIN

public static final VectorOperators.Associative MIN
Produce `min(a,b)`.

### MAX

public static final VectorOperators.Associative MAX
Produce `max(a,b)`.

### FIRST_NONZERO

public static final VectorOperators.Associative FIRST_NONZERO
Produce `bits(a)!=0?a:b`.

### AND

public static final VectorOperators.Associative AND
Produce `a&b`. Integral only.

### AND_NOT

public static final VectorOperators.Binary AND_NOT
Produce `a&~b`. Integral only.

### OR

public static final VectorOperators.Associative OR
Produce `a|b`. Integral only.

### XOR

public static final VectorOperators.Associative XOR
Produce `a^b`. Integral only.

### SADD

public static final VectorOperators.Binary SADD
Produce saturating `a+b`. Integral only.

See Also:
  - `VectorMath.addSaturating(int, int)`

### SUADD

public static final VectorOperators.Associative SUADD
Produce saturating unsigned `a+b`. Integral only.

See Also:
  - `VectorMath.addSaturatingUnsigned(int, int)`

### SSUB

public static final VectorOperators.Binary SSUB
Produce saturating `a-b`. Integral only.

See Also:
  - `VectorMath.subSaturating(int, int)`

### SUSUB

public static final VectorOperators.Binary SUSUB
Produce saturating unsigned `a-b`. Integral only.

See Also:
  - `VectorMath.subSaturatingUnsigned(int, int)`

### UMIN

public static final VectorOperators.Associative UMIN
Produce unsigned `min(a,b)`. Integral only.

See Also:
  - (int, int)

### UMAX

public static final VectorOperators.Associative UMAX
Produce unsigned `max(a,b)`. Integral only.

See Also:
  - (int, int)

### LSHL

public static final VectorOperators.Binary LSHL
Produce `a<<(n&(ESIZE*8-1))`. Integral only.

### ASHR

public static final VectorOperators.Binary ASHR
Produce `a>>(n&(ESIZE*8-1))`. Integral only.

### LSHR

public static final VectorOperators.Binary LSHR
Produce `(a&EMASK)>>>(n&(ESIZE*8-1))`. Integral only.

### ROL

public static final VectorOperators.Binary ROL
Produce `rotateLeft(a,n)`. Integral only.

### ROR

public static final VectorOperators.Binary ROR
Produce `rotateRight(a,n)`. Integral only.

### COMPRESS_BITS

public static final VectorOperators.Binary COMPRESS_BITS
Produce `compress(a,n)`. Integral, `int` and `long`, only.

Since:
  19

### EXPAND_BITS

public static final VectorOperators.Binary EXPAND_BITS
Produce `expand(a,n)`. Integral, `int` and `long`, only.

Since:
  19

### ATAN2

public static final VectorOperators.Binary ATAN2
Produce `atan2(a,b)`. See Floating only. Not guaranteed to be semi-monotonic. See section "Operations on floating point vectors" above

### POW

public static final VectorOperators.Binary POW
Produce `pow(a,b)`. Floating only. Not guaranteed to be semi-monotonic. See section "Operations on floating point vectors" above

### HYPOT

public static final VectorOperators.Binary HYPOT
Produce `hypot(a,b)`. Floating only. Not guaranteed to be semi-monotonic. See section "Operations on floating point vectors" above

### BITWISE_BLEND

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

### FMA

public static final VectorOperators.Ternary FMA
Produce `fma(a,b,c)`. Floating only.

### IS_DEFAULT

public static final VectorOperators.Test IS_DEFAULT
Test `bits(a)==0`. (Not true of `-0.0`.)

### IS_NEGATIVE

public static final VectorOperators.Test IS_NEGATIVE
Test `bits(a)<0`. (True of `-0.0`.)

### IS_FINITE

public static final VectorOperators.Test IS_FINITE
Test `isFinite(a)`. Floating only.

### IS_NAN

public static final VectorOperators.Test IS_NAN
Test `isNaN(a)`. Floating only.

### IS_INFINITE

public static final VectorOperators.Test IS_INFINITE
Test `isInfinite(a)`. Floating only.

### EQ

public static final VectorOperators.Comparison EQ
Compare `a==b`.

### NE

public static final VectorOperators.Comparison NE
Compare `a!=b`.

### LT

public static final VectorOperators.Comparison LT
Compare `a<b`.

### LE

public static final VectorOperators.Comparison LE
Compare `a<=b`.

### GT

public static final VectorOperators.Comparison GT
Compare `a>b`.

### GE

public static final VectorOperators.Comparison GE
Compare `a>=b`.

### ULT

public static final VectorOperators.Comparison ULT
Unsigned compare `a<b`. Integral only.

See Also:
  - `Integer.compareUnsigned(int, int)`
  - `Long.compareUnsigned(long, long)`

### ULE

public static final VectorOperators.Comparison ULE
Unsigned compare `a<=b`. Integral only.

See Also:
  - `Integer.compareUnsigned(int, int)`
  - `Long.compareUnsigned(long, long)`

### UGT

public static final VectorOperators.Comparison UGT
Unsigned compare `a>b`. Integral only.

See Also:
  - `Integer.compareUnsigned(int, int)`
  - `Long.compareUnsigned(long, long)`

### UGE

public static final VectorOperators.Comparison UGE
Unsigned compare `a>=b`. Integral only.

See Also:
  - `Integer.compareUnsigned(int, int)`
  - `Long.compareUnsigned(long, long)`

### B2D

public static final VectorOperators.Conversion<Byte,Double> B2D
Convert `byteVal` to `(double)byteVal`.

### B2F

public static final VectorOperators.Conversion<Byte,Float> B2F
Convert `byteVal` to `(float)byteVal`.

### B2I

public static final VectorOperators.Conversion<Byte,Integer> B2I
Convert `byteVal` to `(int)byteVal`.

### B2L

public static final VectorOperators.Conversion<Byte,Long> B2L
Convert `byteVal` to `(long)byteVal`.

### B2S

public static final VectorOperators.Conversion<Byte,Short> B2S
Convert `byteVal` to `(short)byteVal`.

### B2H

public static final VectorOperators.Conversion<Byte,Float16> B2H
Convert `byteVal` to `(Float16)byteVal`.

### D2B

public static final VectorOperators.Conversion<Double,Byte> D2B
Convert `doubleVal` to `(byte)doubleVal`.

### D2F

public static final VectorOperators.Conversion<Double,Float> D2F
Convert `doubleVal` to `(float)doubleVal`.

### D2I

public static final VectorOperators.Conversion<Double,Integer> D2I
Convert `doubleVal` to `(int)doubleVal`.

### D2L

public static final VectorOperators.Conversion<Double,Long> D2L
Convert `doubleVal` to `(long)doubleVal`.

### D2S

public static final VectorOperators.Conversion<Double,Short> D2S
Convert `doubleVal` to `(short)doubleVal`.

### D2H

public static final VectorOperators.Conversion<Double,Float16> D2H
Convert `doubleVal` to `(Float16)doubleVal`.

### F2B

public static final VectorOperators.Conversion<Float,Byte> F2B
Convert `floatVal` to `(byte)floatVal`.

### F2D

public static final VectorOperators.Conversion<Float,Double> F2D
Convert `floatVal` to `(double)floatVal`.

### F2I

public static final VectorOperators.Conversion<Float,Integer> F2I
Convert `floatVal` to `(int)floatVal`.

### F2L

public static final VectorOperators.Conversion<Float,Long> F2L
Convert `floatVal` to `(long)floatVal`.

### F2S

public static final VectorOperators.Conversion<Float,Short> F2S
Convert `floatVal` to `(short)floatVal`.

### F2H

public static final VectorOperators.Conversion<Float,Float16> F2H
Convert `floatVal` to `(Float16)floatVal`.

### I2B

public static final VectorOperators.Conversion<Integer,Byte> I2B
Convert `intVal` to `(byte)intVal`.

### I2D

public static final VectorOperators.Conversion<Integer,Double> I2D
Convert `intVal` to `(double)intVal`.

### I2F

public static final VectorOperators.Conversion<Integer,Float> I2F
Convert `intVal` to `(float)intVal`.

### I2L

public static final VectorOperators.Conversion<Integer,Long> I2L
Convert `intVal` to `(long)intVal`.

### I2S

public static final VectorOperators.Conversion<Integer,Short> I2S
Convert `intVal` to `(short)intVal`.

### I2H

public static final VectorOperators.Conversion<Integer,Float16> I2H
Convert `intVal` to `(Float16)intVal`.

### L2B

public static final VectorOperators.Conversion<Long,Byte> L2B
Convert `longVal` to `(byte)longVal`.

### L2D

public static final VectorOperators.Conversion<Long,Double> L2D
Convert `longVal` to `(double)longVal`.

### L2F

public static final VectorOperators.Conversion<Long,Float> L2F
Convert `longVal` to `(float)longVal`.

### L2I

public static final VectorOperators.Conversion<Long,Integer> L2I
Convert `longVal` to `(int)longVal`.

### L2S

public static final VectorOperators.Conversion<Long,Short> L2S
Convert `longVal` to `(short)longVal`.

### L2H

public static final VectorOperators.Conversion<Long,Float16> L2H
Convert `longVal` to `(Float16)longVal`.

### S2B

public static final VectorOperators.Conversion<Short,Byte> S2B
Convert `shortVal` to `(byte)shortVal`.

### S2D

public static final VectorOperators.Conversion<Short,Double> S2D
Convert `shortVal` to `(double)shortVal`.

### S2F

public static final VectorOperators.Conversion<Short,Float> S2F
Convert `shortVal` to `(float)shortVal`.

### S2I

public static final VectorOperators.Conversion<Short,Integer> S2I
Convert `shortVal` to `(int)shortVal`.

### S2L

public static final VectorOperators.Conversion<Short,Long> S2L
Convert `shortVal` to `(long)shortVal`.

### S2H

public static final VectorOperators.Conversion<Short,Float16> S2H
Convert `shortVal` to `(Float16)shortVal`.

### H2B

public static final VectorOperators.Conversion<Float16,Byte> H2B
Convert `Float16Val` to `(byte)Float16Val`.

### H2S

public static final VectorOperators.Conversion<Float16,Short> H2S
Convert `Float16Val` to `(short)Float16Val`.

### H2D

public static final VectorOperators.Conversion<Float16,Double> H2D
Convert `Float16Val` to `(double)Float16Val`.

### H2F

public static final VectorOperators.Conversion<Float16,Float> H2F
Convert `Float16Val` to `(float)Float16Val`.

### H2I

public static final VectorOperators.Conversion<Float16,Integer> H2I
Convert `Float16Val` to `(int)Float16Val`.

### H2L

public static final VectorOperators.Conversion<Float16,Long> H2L
Convert `Float16Val` to `(long)Float16Val`.

### REINTERPRET_D2L

public static final VectorOperators.Conversion<Double,Long> REINTERPRET_D2L
Reinterpret bits of `doubleVal` as `long`. As if by `Double.doubleToRawLongBits(double)`

### REINTERPRET_F2I

public static final VectorOperators.Conversion<Float,Integer> REINTERPRET_F2I
Reinterpret bits of `floatVal` as `int`. As if by `Float.floatToRawIntBits(float)`

### REINTERPRET_I2F

public static final VectorOperators.Conversion<Integer,Float> REINTERPRET_I2F
Reinterpret bits of `intVal` as `float`. As if by `Float.intBitsToFloat(int)`

### REINTERPRET_L2D

public static final VectorOperators.Conversion<Long,Double> REINTERPRET_L2D
Reinterpret bits of `longVal` as `double`. As if by `Double.longBitsToDouble(long)`

### ZERO_EXTEND_B2I

public static final VectorOperators.Conversion<Byte,Integer> ZERO_EXTEND_B2I
Zero-extend `byteVal` to `int`.

### ZERO_EXTEND_B2L

public static final VectorOperators.Conversion<Byte,Long> ZERO_EXTEND_B2L
Zero-extend `byteVal` to `long`.

### ZERO_EXTEND_B2S

public static final VectorOperators.Conversion<Byte,Short> ZERO_EXTEND_B2S
Zero-extend `byteVal` to `short`.

### ZERO_EXTEND_I2L

public static final VectorOperators.Conversion<Integer,Long> ZERO_EXTEND_I2L
Zero-extend `intVal` to `long`.

### ZERO_EXTEND_S2I

public static final VectorOperators.Conversion<Short,Integer> ZERO_EXTEND_S2I
Zero-extend `shortVal` to `int`.

### ZERO_EXTEND_S2L

public static final VectorOperators.Conversion<Short,Long> ZERO_EXTEND_S2L
Zero-extend `shortVal` to `long`.