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
    Modifier and Type
    Method
    Description
    protected Object
    clone()
    Answers a new instance of the same class as the receiver, whose slots have been filled in with the values in the slots of the receiver.
    boolean
    equals(Object o)
    Compares the argument to the receiver, and answers true if they represent the same object using a class specific comparison.
    protected void
    finalize()
    Deprecated, for removal: This API element is subject to removal in a future version.
    May cause performance issues, deadlocks and hangs.
    final Class<? extends Object>
    getClass()
    Answers the unique instance of java.lang.Class which represents the class of the receiver.
    int
    hashCode()
    Answers an integer hash code for the receiver.
    final void
    notify()
    Causes one thread which is waiting on the receiver to be made ready to run.
    final void
    notifyAll()
    Causes all threads which are waiting on the receiver to be made ready to run.
    String
    toString()
    Answers a string containing a concise, human-readable description of the receiver.
    final void
    wait()
    Causes the thread which sent this message to be made not ready to run pending some change in the receiver (as indicated by notify or notifyAll).
    final void
    wait(long time)
    Causes the thread which sent this message to be made not ready to run either pending some change in the receiver (as indicated by notify or notifyAll) or the expiration of the timeout.
    final void
    wait(long time, int frac)
    Causes the thread which sent this message to be made not ready to run either pending some change in the receiver (as indicated by notify or notifyAll) or the expiration of the timeout.

  • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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: