## net.sf.saxon.expr
Class Calculator

    java.lang.Object
      net.sf.saxon.expr.Calculator

All Implemented Interfaces:
  Serializable

    public abstract class Calculator

extends Object
implements Serializable

This class evaluates arithmetic expressions; it acts as a helper class to the ArithmeticExpression class. There are many subclasses for the different kinds of arithmetic expression, and static methods that allow the right subclass to be selected, either at compile time or at run time.

See Also:
  Serialized Form

Field Summary
`static Calculator[]` `ANY_ANY` Calculators used for the six operators when the static type information does not allow a more specific calculator to be chosen
`static Calculator[]` `DATETIME_DATETIME` Calculators used when both operands are xs:dateTime, xs:date, or xs:time
`static Calculator[]` `DATETIME_DURATION` Calculators used when the first operand is xs:dateTime, xs:date, or xs:time, and the second is a duration
`static Calculator[]` `DECIMAL_DECIMAL`
`static Calculator[]` `DECIMAL_DOUBLE` Calculators used when the first operand is a decimal
`static Calculator[]` `DECIMAL_FLOAT`
`static Calculator[]` `DECIMAL_INTEGER`
`static Calculator[]` `DECIMAL_PDECIMAL`
`static int` `DIV`
`static Calculator[]` `DOUBLE_DECIMAL`
`static Calculator[]` `DOUBLE_DOUBLE` Calculators used when the first operand is a double
`static Calculator[]` `DOUBLE_FLOAT`
`static Calculator[]` `DOUBLE_INTEGER`
`static Calculator[]` `DOUBLE_PDECIMAL`
`static Calculator[]` `DURATION_DATETIME` Calculators used when the second operand is xs:dateTime, xs:date, or xs:time, and the first is a duration
`static Calculator[]` `DURATION_DURATION` Calculators used when the both operands are durations
`static Calculator[]` `DURATION_NUMERIC` Calculators used when the first operand is a duration and the second is numeric
`static Calculator[]` `FLOAT_DECIMAL`
`static Calculator[]` `FLOAT_DOUBLE` Calculators used when the first operand is a float
`static Calculator[]` `FLOAT_FLOAT`
`static Calculator[]` `FLOAT_INTEGER`
`static Calculator[]` `FLOAT_PDECIMAL`
`static int` `IDIV`
`static Calculator[]` `INTEGER_DECIMAL`
`static Calculator[]` `INTEGER_DOUBLE` Calculators used when the first operand is an integer
`static Calculator[]` `INTEGER_FLOAT`
`static Calculator[]` `INTEGER_INTEGER`
`static int` `MINUS`
`static int` `MOD`
`static Calculator[]` `NUMERIC_DURATION` Calculators used when the second operand is a duration and the first is numeric
`static Calculator[]` `PDECIMAL_DECIMAL`
`static Calculator[]` `PDECIMAL_DOUBLE` Calculators used when the first operand is a precisionDecimal
`static Calculator[]` `PDECIMAL_FLOAT`
`static Calculator[]` `PDECIMAL_INTEGER`
`static Calculator[]` `PDECIMAL_PDECIMAL`
`static int` `PLUS`
`static int` `TIMES`

Constructor Summary
`Calculator()`

Method Summary
`abstract AtomicValue` `compute(AtomicValue a, AtomicValue b, XPathContext c)` Perform an arithmetic operation
`static DecimalValue` `decimalDivide(NumericValue a, NumericValue b)`
`static Calculator` `getCalculator(int typeA, int typeB, int operator, boolean mustResolve)` Factory method to get a calculator for a given combination of types
`static String` `getCalculatorSetName(int typeA, int typeB)` Get the name of the calculator set for a given combination of types
`abstract AtomicType` `getResultType(AtomicType typeA, AtomicType typeB)` Get the type of the result of the calculator, given arguments types typeA and typeB

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Field Detail

### PLUS

    public static final int PLUS

See Also:
  Constant Field Values

### MINUS

    public static final int MINUS

See Also:
  Constant Field Values

### TIMES

    public static final int TIMES

See Also:
  Constant Field Values

### DIV

    public static final int DIV

See Also:
  Constant Field Values

### MOD

    public static final int MOD

See Also:
  Constant Field Values

### IDIV

    public static final int IDIV

See Also:
  Constant Field Values

### ANY_ANY

    public static final Calculator[] ANY_ANY

  Calculators used for the six operators when the static type information does not allow a more specific calculator to be chosen

### DOUBLE_DOUBLE

    public static final Calculator[] DOUBLE_DOUBLE

  Calculators used when the first operand is a double

### DOUBLE_FLOAT

    public static final Calculator[] DOUBLE_FLOAT

### DOUBLE_DECIMAL

    public static final Calculator[] DOUBLE_DECIMAL

### DOUBLE_PDECIMAL

    public static final Calculator[] DOUBLE_PDECIMAL

### DOUBLE_INTEGER

    public static final Calculator[] DOUBLE_INTEGER

### FLOAT_DOUBLE

    public static final Calculator[] FLOAT_DOUBLE

  Calculators used when the first operand is a float

### FLOAT_FLOAT

    public static final Calculator[] FLOAT_FLOAT

### FLOAT_DECIMAL

    public static final Calculator[] FLOAT_DECIMAL

### FLOAT_PDECIMAL

    public static final Calculator[] FLOAT_PDECIMAL

### FLOAT_INTEGER

    public static final Calculator[] FLOAT_INTEGER

### DECIMAL_DOUBLE

    public static final Calculator[] DECIMAL_DOUBLE

  Calculators used when the first operand is a decimal

### DECIMAL_FLOAT

    public static final Calculator[] DECIMAL_FLOAT

### DECIMAL_DECIMAL

    public static final Calculator[] DECIMAL_DECIMAL

### DECIMAL_INTEGER

    public static final Calculator[] DECIMAL_INTEGER

### INTEGER_DOUBLE

    public static final Calculator[] INTEGER_DOUBLE

  Calculators used when the first operand is an integer

### INTEGER_FLOAT

    public static final Calculator[] INTEGER_FLOAT

### INTEGER_DECIMAL

    public static final Calculator[] INTEGER_DECIMAL

### INTEGER_INTEGER

    public static final Calculator[] INTEGER_INTEGER

### PDECIMAL_DOUBLE

    public static final Calculator[] PDECIMAL_DOUBLE

  Calculators used when the first operand is a precisionDecimal

### PDECIMAL_FLOAT

    public static final Calculator[] PDECIMAL_FLOAT

### PDECIMAL_PDECIMAL

    public static final Calculator[] PDECIMAL_PDECIMAL

### PDECIMAL_DECIMAL

    public static final Calculator[] PDECIMAL_DECIMAL

### PDECIMAL_INTEGER

    public static final Calculator[] PDECIMAL_INTEGER

### DECIMAL_PDECIMAL

    public static final Calculator[] DECIMAL_PDECIMAL

### DATETIME_DATETIME

    public static final Calculator[] DATETIME_DATETIME

  Calculators used when both operands are xs:dateTime, xs:date, or xs:time

### DATETIME_DURATION

    public static final Calculator[] DATETIME_DURATION

  Calculators used when the first operand is xs:dateTime, xs:date, or xs:time, and the second is a duration

### DURATION_DATETIME

    public static final Calculator[] DURATION_DATETIME

  Calculators used when the second operand is xs:dateTime, xs:date, or xs:time, and the first is a duration

### DURATION_DURATION

    public static final Calculator[] DURATION_DURATION

  Calculators used when the both operands are durations

### DURATION_NUMERIC

    public static final Calculator[] DURATION_NUMERIC

  Calculators used when the first operand is a duration and the second is numeric

### NUMERIC_DURATION

    public static final Calculator[] NUMERIC_DURATION

  Calculators used when the second operand is a duration and the first is numeric

Constructor Detail

### Calculator

    public Calculator()

Method Detail

### getCalculator

    public static Calculator getCalculator(int typeA,
                                           int typeB,
                                           int operator,
                                           boolean mustResolve)

  Factory method to get a calculator for a given combination of types

  Parameters:
    `typeA` - fingerprint of the primitive type of the first operand
    `typeB` - fingerprint of the primitive type of the second operand
    `operator` - the arithmetic operator in use
    `mustResolve` - indicates that a concrete Calculator is required (rather than an ANY_ANY calculator which needs to be further resolved at run-time)
  Returns:
    null if no suitable Calculator can be found.

### getCalculatorSetName

    public static String getCalculatorSetName(int typeA,
                                              int typeB)

  Get the name of the calculator set for a given combination of types

  Parameters:
    `typeA` - the fingerprint of the primitive type of the first operand
    `typeB` - the fingerprint of the primitive type of the second operand
  Returns:
    null if no suitable Calculator can be found.

### compute

    public abstract AtomicValue compute(AtomicValue a,
                                        AtomicValue b,
                                        XPathContext c)
                                 throws XPathException

  Perform an arithmetic operation

  Parameters:
    `a` - the first operand. Must not be null, and must be an instance of the type implied by the class name.
    `b` - the second operand. Must not be null, and must be an instance of the type implied by the class name.
    `c` - the XPath dynamic evaluation context
  Returns:
    the result of the computation, as a value of the correct primitive type
  Throws:
    `XPathException` - in the event of an arithmetic error

### getResultType

    public abstract AtomicType getResultType(AtomicType typeA,
                                             AtomicType typeB)

  Get the type of the result of the calculator, given arguments types typeA and typeB

  Parameters:
    `typeA` - the type of the first operand
    `typeB` - the type of the second operand
  Returns:
    the type of the result

### decimalDivide

    public static DecimalValue decimalDivide(NumericValue a,
                                             NumericValue b)
                                      throws XPathException

  Throws:
    `XPathException`

Copyright (c) 2004-2010 Saxonica Limited. All rights reserved.