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 Summary

Fields
Modifier and Type
Field
Description
`protected static final int`
`BASE_BIGDECIMAL`
`protected static final int`
`BASE_BIGINTEGER`
`protected static final int`
`BASE_DOUBLE`
`protected static final int`
`BASE_FLOAT`
`protected static final int`
`BASE_LONG`
The constants are used to determine in which context we have to calculate.
`protected static final BigDecimal`
`DECIMAL_ZERO`
A BigDecimal representing the number 0

## Constructor Summary

Constructors
Constructor
Description
`MathUtils()`

## Method Summary

Modifier and Type
Method
Description
`static Number`
`add(Number op1, Number op2)`
Add two numbers and return the correct value / type.
`static int`
`compare(Number op1, Number op2)`
Compare two numbers.
`static Number`
`divide(Number op1, Number op2)`
Divide two numbers.
`static int`
`findCalculationBase(Number op)`
Find the Number-type to be used for a single number
`static boolean`
`isInteger(Number n)`
Test, whether the given object is an integer value (Byte, Short, Integer, Long, BigInteger)
`static boolean`
`isZero(Number n)`
Compare the given Number to 0.
`static Number`
`modulo(Number op1, Number op2)`
Modulo two numbers.
`static Number`
`multiply(Number op1, Number op2)`
Multiply two numbers and return the correct value / type.
`static Number`
`negate(Number op)`
Negate a number
`static Number`
`subtract(Number op1, Number op2)`
Subtract two numbers and return the correct value / type.
`static BigDecimal`
`toBigDecimal(Number n)`
Convert the given Number to a BigDecimal
`static BigInteger`
`toBigInteger(Number n)`
Convert the given Number to a BigInteger
`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.

### Methods inherited from class java.lang.Object

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

## 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:
  - Constant Field Values

### BASE_FLOAT

protected static final int BASE_FLOAT

See Also:
  - Constant Field Values

### BASE_DOUBLE

protected static final int BASE_DOUBLE

See Also:
  - Constant Field Values

### BASE_BIGINTEGER

protected static final int BASE_BIGINTEGER

See Also:
  - Constant Field Values

### BASE_BIGDECIMAL

protected static final int BASE_BIGDECIMAL

See Also:
  - Constant Field Values

## 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)