The following functions define the semantics of arithmetic operators defined in [XQuery 4.0: An XML Query Language] and [XML Path Language (XPath) 4.0] on these numeric types.
The parameters and return types for the above operators are in most cases declared to be of type xs:numeric, which permits the basic numeric types: xs:integer, xs:decimal, xs:float and xs:double, and types derived from them. In general the two-argument functions require that both arguments are of the same primitive type, and they return a value of this same type. The exceptions are op:numeric-divide, which returns an xs:decimal if called with two xs:integer operands, and op:numeric-integer-divide which always returns an xs:integer.
If the two operands of an arithmetic expression are not of the same type, they may be converted to a common type as described in [TITLE OF XP40 SPEC, TITLE OF id-arithmetic-expressions SECTION]XP40. If the two operands of an arithmetic expression are not of the same type, they may be converted to a common type as described in [XML Path Language (XPath) 4.0] section 4.9 Arithmetic Expressions. If the two operands of an arithmetic expression are not of the same type, they may be converted to a common type as described in [XML Path Language (XPath) 4.0][TITLE OF XP40 section SPEC, TITLE OF id-arithmetic-expressions SECTION]XP404.9 Arithmetic Expressions.
The result type of operations depends on their argument datatypes and is defined in the following table:
| Operator | Returns |
|---|
op:operation(xs:integer, xs:integer) | xs:integer (except for op:numeric-divide(integer, integer), which returns xs:decimal) |
op:operation(xs:decimal, xs:decimal) | xs:decimal |
op:operation(xs:float, xs:float) | xs:float |
op:operation(xs:double, xs:double) | xs:double |
op:operation(xs:integer) | xs:integer |
op:operation(xs:decimal) | xs:decimal |
op:operation(xs:float) | xs:float |
op:operation(xs:double) | xs:double |
The basic rules for addition, subtraction, and multiplication of ordinary numbers are not set out in this specification; they are taken as given. In the case of xs:double and xs:float the rules are as defined in [IEEE 754-2019]. The rules for handling division and modulus operations, as well as the rules for handling special values such as infinity and NaN, and exception conditions such as overflow and underflow, are described more explicitly since they are not necessarily obvious.
On overflow and underflow situations during arithmetic operations, conforming implementations must behave as follows:
For xs:float and xs:double operations, overflow behavior must be conformant with [IEEE 754-2019]. This specification allows the following options:
For xs:float and xs:double operations, underflow behavior must be conformant with [IEEE 754-2019]. This specification allows the following options:
For xs:decimal operations, overflow behavior must raise a dynamic error [err:FOAR0002]. On underflow, 0.0 must be returned.
For xs:integer operations, implementations that support limited-precision integer operations must select from the following options:
They may choose to always raise a dynamic error [err:FOAR0002].
They may provide an implementation-defined mechanism that allows users to choose between raising an error and returning a result that is modulo the largest representable integer value. See [ISO 10967].
The functions op:numeric-add, op:numeric-subtract, op:numeric-multiply, op:numeric-divide, op:numeric-integer-divide and op:numeric-mod are each defined for pairs of numeric operands, each of which has the same type:xs:integer, xs:decimal, xs:float, or xs:double. The functions op:numeric-unary-plus and op:numeric-unary-minus are defined for a single operand whose type is one of those same numeric types.
For xs:float and xs:double arguments, if either argument is NaN, the result is NaN.
For xs:decimal values, let N be the number of digits of precision supported by the implementation, and let M (M <= N) be the minimum limit on the number of digits required for conformance (18 digits for XSD 1.0, 16 digits for XSD 1.1). Then for addition, subtraction, and multiplication operations, the returned result should be accurate to N digits of precision, and for division and modulus operations, the returned result should be accurate to at least M digits of precision. The actual precision is implementation-defined. If the number of digits in the mathematical result exceeds the number of digits that the implementation retains for that operation, the result is truncated or rounded in an implementation-defined manner.
Note:
This specification does not determine whether xs:decimal operations are fixed point or floating point. In an implementation using floating point it is possible for very simple operations to require more digits of precision than are available; for example, adding 1e100 to 1e-100 requires 200 digits of precision for an accurate representation of the result.
The [IEEE 754-2019] specification also describes handling of two exception conditions called divideByZero and invalidOperation. The IEEE divideByZero exception is raised not only by a direct attempt to divide by zero, but also by operations such as log(0). The IEEE invalidOperation exception is raised by attempts to call a function with an argument that is outside the function’s domain (for example, sqrt(-1) or log(-1)). Although IEEE defines these as exceptions, it also defines “default non-stop exception handling” in which the operation returns a defined result, typically positive or negative infinity, or NaN. With this function library, these IEEE exceptions do not cause a dynamic error at the application level; rather they result in the relevant function or operator returning the defined non-error result. The underlying IEEE exception may be notified to the application or to the user by some implementation-defined warning condition, but the observable effect on an application using the functions and operators defined in this specification is simply to return the defined result (typically -INF, +INF, or NaN) with no error.
The [IEEE 754-2019] specification distinguishes two NaN values: a quiet NaN and a signaling NaN. These two values are not distinguishable in the XDM model: the value spaces of xs:float and xs:double each include only a single NaN value. This does not prevent the implementation distinguishing them internally, and triggering different implementation-defined warning conditions, but such distinctions do not affect the observable behavior of an application using the functions and operators defined in this specification.
Note:
Although comparison of numeric values across heterogeneous types has changed to convert both values to xs:decimal, arithmetic operations continue to use xs:double as the common type.