Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## 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 ( 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
`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
`protected static Map` | `ints` The `Class`-object is key, the maximum-value is the value
`protected static List` | `typesBySize` The "size" of the number-types - ascending.

Constructor Summary
`MathUtils()`

Method Summary
`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 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` | `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

### ints

    protected static final Map ints

  The `Class`-object is key, the maximum-value is the value

### typesBySize

    protected static final List typesBySize

  The "size" of the number-types - ascending.

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.

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

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

Copyright © 2000-2010 Apache Software Foundation. All Rights Reserved.