Package org.apache.velocity.runtime.parser.node

Class MathUtils

java.lang.Object
org.apache.velocity.runtime.parser.node.MathUtils
public abstract class MathUtils extends Object
Utility-class for all arithmetic-operations.

All operations (+ - / *) return a Number which type is the type of the bigger argument.
Example:
add ( Integer.valueOf(10), Integer.valueOf(1)) will return an Integer-Object with the value 11
add ( Long.valueOf(10), Integer.valueOf(1)) will return an Long-Object with the value 11
add ( Integer.valueOf(10), Float.valueOf(1)) will return an Float-Object with the value 11

Overflow checking:
For integral values (byte, short, int) there is an implicit overflow correction (the next "bigger" type will be returned). For example, if you call add (Integer.valueOf(Integer.MAX_VALUE), 1) a Long-object will be returned with the correct value of Integer.MAX_VALUE+1.
In addition to that the methods multiply,add and substract implement overflow checks for long-values. That means that if an overflow occurs while working with long values a BigInteger will be returned.
For all other operations and types (such as Float and Double) there is no overflow checking.
Since:
1.5
Author:
Peter Romianowski

  • Field Details

    • DECIMAL_ZERO

      protected static final BigDecimal DECIMAL_ZERO
      A BigDecimal representing the number 0

    • BASE_LONG

      protected static final int BASE_LONG
      The constants are used to determine in which context we have to calculate.
      See Also:

    • BASE_FLOAT

      protected static final int BASE_FLOAT
      See Also:

    • BASE_DOUBLE

      protected static final int BASE_DOUBLE
      See Also:

    • BASE_BIGINTEGER

      protected static final int BASE_BIGINTEGER
      See Also:

    • BASE_BIGDECIMAL

      protected static final int BASE_BIGDECIMAL
      See Also:

  • Constructor Details

    • MathUtils

      public MathUtils()

  • Method Details

    • toBigDecimal

      public static BigDecimal toBigDecimal(Number n)
      Convert the given Number to a BigDecimal
      Parameters:
      n -
      Returns:
      The number as BigDecimal

    • toBigInteger

      public static BigInteger toBigInteger(Number n)
      Convert the given Number to a BigInteger
      Parameters:
      n -
      Returns:
      The number as BigInteger

    • isZero

      public static boolean isZero(Number n)
      Compare the given Number to 0.
      Parameters:
      n -
      Returns:
      True if number is 0.

    • isInteger

      public static boolean isInteger(Number n)
      Test, whether the given object is an integer value (Byte, Short, Integer, Long, BigInteger)
      Parameters:
      n -
      Returns:
      True if n is an integer.

    • wrapPrimitive

      public static Number wrapPrimitive(long value, Class<?> type)
      Wrap the given primitive into the given class if the value is in the range of the destination type. If not the next bigger type will be chosen.
      Parameters:
      value -
      type -
      Returns:
      Number object representing the primitive.

    • findCalculationBase

      public static int findCalculationBase(Number op)
      Find the Number-type to be used for a single number
      Parameters:
      op - operand
      Returns:
      constant indicating type of Number to use in calculations

    • add

      public static Number add(Number op1, Number op2)
      Add two numbers and return the correct value / type. Overflow detection is done for integer values (byte, short, int, long) only!
      Parameters:
      op1 -
      op2 -
      Returns:
      Addition result.

    • subtract

      public static Number subtract(Number op1, Number op2)
      Subtract two numbers and return the correct value / type. Overflow detection is done for integer values (byte, short, int, long) only!
      Parameters:
      op1 -
      op2 -
      Returns:
      Subtraction result.

    • multiply

      public static Number multiply(Number op1, Number op2)
      Multiply two numbers and return the correct value / type. Overflow detection is done for integer values (byte, short, int, long) only!
      Parameters:
      op1 -
      op2 -
      Returns:
      Multiplication result.

    • divide

      public static Number divide(Number op1, Number op2)
      Divide two numbers. The result will be returned as Integer-type if and only if both sides of the division operator are Integer-types. Otherwise a Float, Double, or BigDecimal will be returned.
      Parameters:
      op1 -
      op2 -
      Returns:
      Division result.

    • modulo

      public static Number modulo(Number op1, Number op2) throws ArithmeticException
      Modulo two numbers.
      Parameters:
      op1 -
      op2 -
      Returns:
      Modulo result.
      Throws:
      ArithmeticException - If at least one parameter is a BigDecimal

    • compare

      public static int compare(Number op1, Number op2)
      Compare two numbers.
      Parameters:
      op1 -
      op2 -
      Returns:
      1 if n1 > n2, -1 if n1 < n2 and 0 if equal.

    • negate

      public static Number negate(Number op)
      Negate a number
      Parameters:
      op - n
      Returns:
      -n (unary negation of n)