# Class VectorMath

java.lang.Object
jdk.incubator.vector.VectorMath

public final class VectorMath extends Object
The class `VectorMath` contains methods for performing scalar numeric operations in support of vector numeric operations.

Since:
  24

## Method Summary

Modifier and Type
Method
Description
`static byte`
`addSaturating(byte a, byte b)`
Adds two `byte` values using saturation arithmetic.
`static int`
`addSaturating(int a, int b)`
Adds two `int` values using saturation arithmetic.
`static long`
`addSaturating(long a, long b)`
Adds two `long` values using saturation arithmetic.
`static short`
`addSaturating(short a, short b)`
Adds two `short` values using saturation arithmetic.
`static byte`
`addSaturatingUnsigned(byte a, byte b)`
Adds two `byte` values using saturation arithmetic and numerically treating the values as unsigned.
`static int`
`addSaturatingUnsigned(int a, int b)`
Adds two `int` values using saturation arithmetic and numerically treating the values as unsigned.
`static long`
`addSaturatingUnsigned(long a, long b)`
Adds two `long` values using saturation arithmetic and numerically treating the values as unsigned.
`static short`
`addSaturatingUnsigned(short a, short b)`
Adds two `short` values using saturation arithmetic and numerically treating the values as unsigned.
`static byte`
`maxUnsigned(byte a, byte b)`
Returns the greater of two `byte` values numerically treating the values as unsigned.
`static int`
`maxUnsigned(int a, int b)`
Returns the greater of two `int` values numerically treating the values as unsigned.
`static long`
`maxUnsigned(long a, long b)`
Returns the greater of two `long` values numerically treating the values as unsigned.
`static short`
`maxUnsigned(short a, short b)`
Returns the greater of two `short` values numerically treating the values as unsigned.
`static byte`
`minUnsigned(byte a, byte b)`
Returns the smaller of two `byte` values numerically treating the values as unsigned.
`static int`
`minUnsigned(int a, int b)`
Returns the smaller of two `int` values numerically treating the values as unsigned.
`static long`
`minUnsigned(long a, long b)`
Returns the smaller of two `long` values numerically treating the values as unsigned.
`static short`
`minUnsigned(short a, short b)`
Returns the smaller of two `short` values numerically treating the values as unsigned.
`static byte`
`subSaturating(byte a, byte b)`
Subtracts two `byte` values using saturation arithmetic.
`static int`
`subSaturating(int a, int b)`
Subtracts two `int` values using saturation arithmetic.
`static long`
`subSaturating(long a, long b)`
Subtracts two `long` values using saturation arithmetic.
`static short`
`subSaturating(short a, short b)`
Subtracts two `short` values using saturation arithmetic.
`static byte`
`subSaturatingUnsigned(byte a, byte b)`
Subtracts two `byte` values using saturation arithmetic and numerically treating the values as unsigned.
`static int`
`subSaturatingUnsigned(int a, int b)`
Subtracts two `int` values using saturation arithmetic and numerically treating the values as unsigned.
`static long`
`subSaturatingUnsigned(long a, long b)`
Subtracts two `long` values using saturation arithmetic and numerically treating the values as unsigned.
`static short`
`subSaturatingUnsigned(short a, short b)`
Subtracts two `short` values using saturation arithmetic and numerically treating the values as unsigned.

### Methods declared in class Object

`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

## Method Details

### minUnsigned

public static long minUnsigned(long a, long b)
Returns the smaller of two `long` values numerically treating the values as unsigned. That is, the result is the operand closer to the value of the expression `0L`. If the operands have the same value, the result is that same value.

Parameters:
  `a` - the first operand.
  `b` - the second operand.
Returns:
  the smaller of `a` and `b`.
See Also:
  - `VectorOperators.UMIN`

### maxUnsigned

public static long maxUnsigned(long a, long b)
Returns the greater of two `long` values numerically treating the values as unsigned. That is, the result is the operand closer to the value of the expression `0xFFFFFFFF_FFFFFFFFL` numerically treating it as unsigned. If the operands have the same value, the result is that same value.

Parameters:
  `a` - the first operand.
  `b` - the second operand.
Returns:
  the larger of `a` and `b`.
See Also:
  - `VectorOperators.UMAX`

### addSaturating

public static long addSaturating(long a, long b)
Adds two `long` values using saturation arithmetic. The lower and upper (inclusive) bounds are `Long.MIN_VALUE` and `Long.MAX_VALUE`, respectively.

If the result of the addition would otherwise overflow from a positive value to a negative value then the result is clamped to the upper bound `Long.MAX_VALUE`. If the result of the addition would otherwise underflow from a negative value to a positive value then the result is clamped to lower bound `Long.MIN_VALUE`.

Parameters:
  `a` - the first operand.
  `b` - the second operand.
Returns:
  the saturating addition of the operands.
See Also:
  - `VectorOperators.SADD`

### subSaturating

public static long subSaturating(long a, long b)
Subtracts two `long` values using saturation arithmetic. The lower and upper (inclusive) bounds are `Long.MIN_VALUE` and `Long.MAX_VALUE`, respectively.

If the result of the subtraction would otherwise overflow from a positive value to a negative value then the result is clamped to the upper bound `Long.MAX_VALUE`. If the result of the subtraction would otherwise underflow from a negative value to a positive value then the result is clamped to lower bound `Long.MIN_VALUE`.

Parameters:
  `a` - the first operand.
  `b` - the second operand.
Returns:
  the saturating difference of the operands.
See Also:
  - `VectorOperators.SSUB`

### addSaturatingUnsigned

public static long addSaturatingUnsigned(long a, long b)
Adds two `long` values using saturation arithmetic and numerically treating the values as unsigned. The lower and upper (inclusive) bounds are `0L` and `0xFFFFFFFF_FFFFFFFFL`, respectively, numerically treating them as unsigned.

If the result of the unsigned addition would otherwise overflow from the greater of the two operands to a lesser value then the result is clamped to the upper bound `0xFFFFFFFF_FFFFFFFFL`.

Parameters:
  `a` - the first operand.
  `b` - the second operand.
Returns:
  the saturating addition of the operands.
See Also:
  - `VectorOperators.SUADD`

### subSaturatingUnsigned

public static long subSaturatingUnsigned(long a, long b)
Subtracts two `long` values using saturation arithmetic and numerically treating the values as unsigned. The lower and upper (inclusive) bounds are `0L` and `0xFFFFFFFF_FFFFFFFFL`, respectively, numerically treating them as unsigned.

If the result of the unsigned subtraction would otherwise underflow from the lesser of the two operands to a greater value then the result is clamped to the lower bound `0L`.

Parameters:
  `a` - the first operand.
  `b` - the second operand.
Returns:
  the saturating difference of the operands.
See Also:
  - `VectorOperators.SUSUB`

### minUnsigned

public static int minUnsigned(int a, int b)
Returns the smaller of two `int` values numerically treating the values as unsigned. That is, the result is the operand closer to the value of the expression `0`. If the operands have the same value, the result is that same value.

Parameters:
  `a` - the first operand.
  `b` - the second operand.
Returns:
  the smaller of `a` and `b`.
See Also:
  - `VectorOperators.UMIN`

### maxUnsigned

public static int maxUnsigned(int a, int b)
Returns the greater of two `int` values numerically treating the values as unsigned. That is, the result is the operand closer to the value of the expression `0xFFFFFFFF` numerically treating it as unsigned. If the operands have the same value, the result is that same value.

Parameters:
  `a` - the first operand.
  `b` - the second operand.
Returns:
  the larger of `a` and `b`.
See Also:
  - `VectorOperators.UMAX`

### addSaturating

public static int addSaturating(int a, int b)
Adds two `int` values using saturation arithmetic. The lower and upper (inclusive) bounds are `Integer.MIN_VALUE` and `Integer.MAX_VALUE`, respectively.

If the result of the addition would otherwise overflow from a positive value to a negative value then the result is clamped to the upper bound `Integer.MAX_VALUE`. If the result of the addition would otherwise underflow from a negative value to a positive value then the result is clamped to lower bound `Integer.MIN_VALUE`.

Parameters:
  `a` - the first operand.
  `b` - the second operand.
Returns:
  the saturating addition of the operands.
See Also:
  - `VectorOperators.SADD`

### subSaturating

public static int subSaturating(int a, int b)
Subtracts two `int` values using saturation arithmetic. The lower and upper (inclusive) bounds are `Integer.MIN_VALUE` and `Integer.MAX_VALUE`, respectively.

If the result of the subtraction would otherwise overflow from a positive value to a negative value then the result is clamped to the upper bound `Integer.MAX_VALUE`. If the result of the subtraction would otherwise underflow from a negative value to a positive value then the result is clamped to lower bound `Integer.MIN_VALUE`.

Parameters:
  `a` - the first operand.
  `b` - the second operand.
Returns:
  the saturating difference of the operands.
See Also:
  - `VectorOperators.SSUB`

### addSaturatingUnsigned

public static int addSaturatingUnsigned(int a, int b)
Adds two `int` values using saturation arithmetic and numerically treating the values as unsigned. The lower and upper (inclusive) bounds are `0` and `0xFFFFFFFF`, respectively, numerically treating them as unsigned.

If the result of the unsigned addition would otherwise overflow from the greater of the two operands to a lesser value then the result is clamped to the upper bound `0xFFFFFFFF`.

Parameters:
  `a` - the first operand.
  `b` - the second operand.
Returns:
  the saturating addition of the operands.
See Also:
  - `VectorOperators.SUADD`

### subSaturatingUnsigned

public static int subSaturatingUnsigned(int a, int b)
Subtracts two `int` values using saturation arithmetic and numerically treating the values as unsigned. The lower and upper (inclusive) bounds are `0` and `-0xFFFFFFFF`, respectively, numerically treating them as unsigned.

If the result of the unsigned subtraction would otherwise underflow from the lesser of the two operands to a greater value then the result is clamped to the lower bound `0`.

Parameters:
  `a` - the first operand.
  `b` - the second operand.
Returns:
  the saturating difference of the operands.
See Also:
  - `VectorOperators.SUSUB`

### minUnsigned

public static short minUnsigned(short a, short b)
Returns the smaller of two `short` values numerically treating the values as unsigned. That is, the result is the operand closer to the value of the expression `0`. If the operands have the same value, the result is that same value.

Parameters:
  `a` - the first operand.
  `b` - the second operand.
Returns:
  the smaller of `a` and `b`.
See Also:
  - `VectorOperators.UMIN`

### maxUnsigned

public static short maxUnsigned(short a, short b)
Returns the greater of two `short` values numerically treating the values as unsigned. That is, the result is the operand closer to the value of the expression `0xFFFF` numerically treating it as unsigned. If the operands have the same value, the result is that same value.

Parameters:
  `a` - the first operand.
  `b` - the second operand.
Returns:
  the larger of `a` and `b`.
See Also:
  - `VectorOperators.UMAX`

### addSaturating

public static short addSaturating(short a, short b)
Adds two `short` values using saturation arithmetic. The lower and upper (inclusive) bounds are `Short.MIN_VALUE` and `Short.MAX_VALUE`, respectively.

If the result of the addition would otherwise overflow from a positive value to a negative value then the result is clamped to the upper bound `Short.MAX_VALUE`. If the result of the addition would otherwise underflow from a negative value to a positive value then the result is clamped to lower bound `Short.MIN_VALUE`.

Parameters:
  `a` - the first operand.
  `b` - the second operand.
Returns:
  the saturating addition of the operands.
See Also:
  - `VectorOperators.SADD`

### subSaturating

public static short subSaturating(short a, short b)
Subtracts two `short` values using saturation arithmetic. The lower and upper (inclusive) bounds are `Short.MIN_VALUE` and `Short.MAX_VALUE`, respectively.

If the result of the subtraction would otherwise overflow from a positive value to a negative value then the result is clamped to the upper bound `Short.MAX_VALUE`. If the result of the subtraction would otherwise underflow from a negative value to a positive value then the result is clamped to lower bound `Short.MIN_VALUE`.

Parameters:
  `a` - the first operand.
  `b` - the second operand.
Returns:
  the saturating difference of the operands.
See Also:
  - `VectorOperators.SSUB`

### addSaturatingUnsigned

public static short addSaturatingUnsigned(short a, short b)
Adds two `short` values using saturation arithmetic and numerically treating the values as unsigned. The lower and upper (inclusive) bounds are `0` and `0xFFFF`, respectively, numerically treating them as unsigned.

If the result of the unsigned addition would otherwise overflow from the greater of the two operands to a lesser value then the result is clamped to the upper bound `0xFFFF`.

Parameters:
  `a` - the first operand.
  `b` - the second operand.
Returns:
  the saturating addition of the operands.
See Also:
  - `VectorOperators.SUADD`

### subSaturatingUnsigned

public static short subSaturatingUnsigned(short a, short b)
Subtracts two `short` values using saturation arithmetic and numerically treating the values as unsigned. The lower and upper (inclusive) bounds are `0` and `0xFFFF`, respectively, numerically treating them as unsigned.

If the result of the unsigned subtraction would otherwise underflow from the lesser of the two operands to a greater value then the result is clamped to the lower bound `0`.

Parameters:
  `a` - the first operand.
  `b` - the second operand.
Returns:
  the saturating difference of the operands.
See Also:
  - `VectorOperators.SUSUB`

### minUnsigned

public static byte minUnsigned(byte a, byte b)
Returns the smaller of two `byte` values numerically treating the values as unsigned. That is, the result is the operand closer to the value of the expression `0`. If the operands have the same value, the result is that same value.

Parameters:
  `a` - the first operand.
  `b` - the second operand.
Returns:
  the smaller of `a` and `b`.
See Also:
  - `VectorOperators.UMIN`

### maxUnsigned

public static byte maxUnsigned(byte a, byte b)
Returns the greater of two `byte` values numerically treating the values as unsigned. That is, the result is the operand closer to the value of the expression `0xFF` numerically treating it as unsigned. If the operands have the same value, the result is that same value.

Parameters:
  `a` - the first operand.
  `b` - the second operand.
Returns:
  the larger of `a` and `b`.
See Also:
  - `VectorOperators.UMAX`

### addSaturating

public static byte addSaturating(byte a, byte b)
Adds two `byte` values using saturation arithmetic. The lower and upper (inclusive) bounds are `Byte.MIN_VALUE` and `Byte.MAX_VALUE`, respectively.

If the result of the addition would otherwise overflow from a positive value to a negative value then the result is clamped to the upper bound `Byte.MAX_VALUE`. If the result of the addition would otherwise underflow from a negative value to a positive value then the result is clamped to lower bound `Byte.MIN_VALUE`.

Parameters:
  `a` - the first operand.
  `b` - the second operand.
Returns:
  the saturating addition of the operands.
See Also:
  - `VectorOperators.SADD`

### subSaturating

public static byte subSaturating(byte a, byte b)
Subtracts two `byte` values using saturation arithmetic. The lower and upper (inclusive) bounds are `Byte.MIN_VALUE` and `Byte.MAX_VALUE`, respectively.

If the result of the subtraction would otherwise overflow from a positive value to a negative value then the result is clamped to the upper bound `Byte.MAX_VALUE`. If the result of the subtraction would otherwise underflow from a negative value to a positive value then the result is clamped to lower bound `Byte.MIN_VALUE`.

Parameters:
  `a` - the first operand.
  `b` - the second operand.
Returns:
  the saturating difference of the operands.
See Also:
  - `VectorOperators.SSUB`

### addSaturatingUnsigned

public static byte addSaturatingUnsigned(byte a, byte b)
Adds two `byte` values using saturation arithmetic and numerically treating the values as unsigned. The lower and upper (inclusive) bounds are `0` and `0xFF`, respectively, numerically treating them as unsigned.

If the result of the unsigned addition would otherwise overflow from the greater of the two operands to a lesser value then the result is clamped to the upper bound `0xFF`.

Parameters:
  `a` - the first operand.
  `b` - the second operand.
Returns:
  the saturating addition of the operands.
See Also:
  - `VectorOperators.SUADD`

### subSaturatingUnsigned

public static byte subSaturatingUnsigned(byte a, byte b)
Subtracts two `byte` values using saturation arithmetic and numerically treating the values as unsigned. The lower and upper (inclusive) bounds are `0` and `0xFF`, respectively, numerically treating them as unsigned.

If the result of the unsigned subtraction would otherwise underflow from the lesser of the two operands to a greater value then the result is clamped to the lower bound `0`.

Parameters:
  `a` - the first operand.
  `b` - the second operand.
Returns:
  the saturating difference of the operands.
See Also:
  - `VectorOperators.SUSUB`