MathUtils (Apache Velocity 2.3 API)

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 ( new Integer(10), new Integer(1)) will return an Integer-Object with the value 11
add ( new Long(10), new Integer(1)) will return an Long-Object with the value 11
add ( new Integer(10), new Float(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 (new Integer (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 and Description
`protected static int`	`BASE_BIGDECIMAL`
`protected static int`	`BASE_BIGINTEGER`
`protected static int`	`BASE_DOUBLE`
`protected static int`	`BASE_FLOAT`
`protected static int`	`BASE_LONG` The constants are used to determine in which context we have to calculate.
`protected static BigDecimal`	`DECIMAL_ZERO` A BigDecimal representing the number 0

Constructor Summary

Constructors
Constructor and Description

MathUtils()

Constructors
Constructor and Description
`MathUtils()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and 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 Detail
  - 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 Detail
  - MathUtils
```
public MathUtils()
```
- Method Detail
  - 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)

Class MathUtils

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

DECIMAL_ZERO

BASE_LONG

BASE_FLOAT

BASE_DOUBLE

BASE_BIGINTEGER

BASE_BIGDECIMAL

Constructor Detail

MathUtils

Method Detail

toBigDecimal

toBigInteger

isZero

isInteger

wrapPrimitive

findCalculationBase

add

subtract

multiply

divide

modulo

compare

negate