Package net.sf.saxon.expr

## Class Calculator

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

- Direct Known Subclasses:
    `Calculator.AnyDivAny`, `Calculator.AnyIdivAny`, `Calculator.AnyMinusAny`, `Calculator.AnyModAny`, `Calculator.AnyPlusAny`, `Calculator.AnyTimesAny`, `Calculator.DecimalDivDecimal`, `Calculator.DecimalIdivDecimal`, `Calculator.DecimalMinusDecimal`, `Calculator.DecimalModDecimal`, `Calculator.DecimalPlusDecimal`, `Calculator.DecimalTimesDecimal`, `Calculator.DoubleDivDouble`, `Calculator.DoubleMinusDouble`, `Calculator.DoubleModDouble`, `Calculator.DoublePlusDouble`, `Calculator.DoubleTimesDouble`, `Calculator.FloatDivFloat`, `Calculator.FloatIdivFloat`, `Calculator.FloatMinusFloat`, `Calculator.FloatModFloat`, `Calculator.FloatPlusFloat`, `Calculator.FloatTimesFloat`, `Calculator.IntegerDivInteger`, `Calculator.IntegerIdivInteger`, `Calculator.IntegerMinusInteger`, `Calculator.IntegerModInteger`, `Calculator.IntegerPlusInteger`, `Calculator.IntegerTimesInteger`

      public abstract class Calculator
      extends java.lang.Object

  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.

- - ### Nested Class Summary

    Nested Classes
    Modifier and Type | Class | Description
    --- | --- | ---
    `static class` | `Calculator.AnyDivAny` | Arithmetic: anyAtomicType div AnyAtomicType
    `static class` | `Calculator.AnyIdivAny` | Arithmetic: anyAtomicType idiv AnyAtomicType
    `static class` | `Calculator.AnyMinusAny` | Arithmetic: anyAtomicType - AnyAtomicType
    `static class` | `Calculator.AnyModAny` | Arithmetic: anyAtomicType mod AnyAtomicType
    `static class` | `Calculator.AnyPlusAny` | Arithmetic: anyAtomicType + AnyAtomicType
    `static class` | `Calculator.AnyTimesAny` | Arithmetic: anyAtomicType * AnyAtomicType
    `static class` | `Calculator.DecimalDivDecimal` | Arithmetic: decimal div decimal (including types that promote to decimal, that is, integer)
    `static class` | `Calculator.DecimalIdivDecimal` | Arithmetic: decimal idiv decimal (including types that promote to decimal, that is, integer)
    `static class` | `Calculator.DecimalMinusDecimal` | Arithmetic: decimal - decimal (including types that promote to decimal, that is, integer)
    `static class` | `Calculator.DecimalModDecimal` | Arithmetic: decimal mod decimal (including types that promote to decimal, that is, integer)
    `static class` | `Calculator.DecimalPlusDecimal` | Arithmetic: decimal + decimal (including types that promote to decimal, that is, integer)
    `static class` | `Calculator.DecimalTimesDecimal` | Arithmetic: decimal * decimal (including types that promote to decimal, that is, integer)
    `static class` | `Calculator.DoubleDivDouble` | Arithmetic: double div double (including types that promote to double)
    `static class` | `Calculator.DoubleMinusDouble` | Arithmetic: double - double (including types that promote to double)
    `static class` | `Calculator.DoubleModDouble` | Arithmetic: double mod double (including types that promote to double)
    `static class` | `Calculator.DoublePlusDouble` | Arithmetic: double + double (including types that promote to double)
    `static class` | `Calculator.DoubleTimesDouble` | Arithmetic: double * double (including types that promote to double)
    `static class` | `Calculator.FloatDivFloat` | Arithmetic: float div float (including types that promote to float)
    `static class` | `Calculator.FloatIdivFloat` | Arithmetic: float idiv float (including types that promote to float)
    `static class` | `Calculator.FloatMinusFloat` | Arithmetic: float - float (including types that promote to float)
    `static class` | `Calculator.FloatModFloat` | Arithmetic: float mod float (including types that promote to float)
    `static class` | `Calculator.FloatPlusFloat` | Arithmetic: float + float (including types that promote to float)
    `static class` | `Calculator.FloatTimesFloat` | Arithmetic: float * float (including types that promote to float)
    `static class` | `Calculator.IntegerDivInteger` | Arithmetic: integer div integer
    `static class` | `Calculator.IntegerIdivInteger` | Arithmetic: integer idiv integer
    `static class` | `Calculator.IntegerMinusInteger` | Arithmetic: integer - integer
    `static class` | `Calculator.IntegerModInteger` | Arithmetic: integer mod integer
    `static class` | `Calculator.IntegerPlusInteger` | Arithmetic: integer + integer
    `static class` | `Calculator.IntegerTimesInteger` | Arithmetic: integer * integer

  - ### Field Summary

    Fields
    Modifier and Type | Field | Description
    --- | --- | ---
    `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 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[]` | `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 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 int` | `PLUS` |
    `static int` | `TIMES` |

  - ### Constructor Summary

    Constructors
    Constructor | Description
    --- | ---
    `Calculator()` |

  - ### Method Summary

    All Methods Static Methods Instance Methods Abstract Methods Concrete Methods
    Modifier and Type | Method | Description
    --- | --- | ---
    `java.lang.String` | `code()` | Get a short code to identify the calculator in expression export files
    `abstract AtomicValue` | `compute​(AtomicValue a, AtomicValue b, XPathContext c)` | Perform an arithmetic operation
    `static BigDecimalValue` | `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 java.lang.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
    `static int` | `getTokenFromOperator​(int operator)` | Get the token number corresponding to the operator number
    `static int` | `operatorFromCode​(char code)` |
    `static Calculator` | `reconstructCalculator​(java.lang.String code)` | Get a calculator given the short code used in the exported expression tree

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

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

    - #### getTokenFromOperator

          public static int getTokenFromOperator​(int operator)

      Get the token number corresponding to the operator number
      Parameters:
        `operator` - the Calculator operator code
      Returns:
        the corresponding token

    - #### code

          public java.lang.String code()

      Get a short code to identify the calculator in expression export files
      Returns:
        a short identifying code that can be used to reconstruct the calculator

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

    - #### reconstructCalculator

          public static Calculator reconstructCalculator​(java.lang.String code)

      Get a calculator given the short code used in the exported expression tree
      Parameters:
        `code` - the short code, e.g. i+i for IntegerPlusInteger
      Returns:
        the appropriate Calculator

    - #### operatorFromCode

          public static int operatorFromCode​(char code)

    - #### getCalculatorSetName

          public static java.lang.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 BigDecimalValue decimalDivide​(NumericValue a,
                                                      NumericValue b)
                                               throws XPathException

      Throws:
        `XPathException`