This section discusses arithmetic operators on the
numeric datatypes defined in [XML Schema
Part 2: Datatypes]. It uses an approach that permits
lightweight implementation whenever possible.
6.1 Numeric
Types
The operators described in this section are defined on
the following numeric types. Each type whose name is
indented is derived from the type whose name appears
nearest above with one less level of indent.
| xs:decimal |
|
|
xs:integer |
| xs:float |
| xs:double |
They also apply to types derived by restriction from
these types.
Note:
The value space for xs:float and
xs:double, as defined in the errata to [XML Schema Part 2: Datatypes],
defines only a single zero. [IEEE
754-1985] arithmetic, however, can produce distinct
results of positive zero and negative zero. The value
space for atomic values of type xs:float
and xs:double, as defined in this suite of
documents, contains this extra value of negative zero
which compares equal to positive zero. The value
negative zero will never be obtained from the typed
value of a node. However, negative zero may be produced
as the result of a computation; for example, the unary
minus operator produces negative zero if its operand is
positive zero.
6.2
Operators on Numeric Values
The following functions are defined to back up
operators defined in [XQuery 1.0: An
XML Query Language] and [XPath
2.0] on these numeric types.
The arguments and return types for the arithmetic
operators are the basic numeric types:
xs:integer, xs:decimal,
xs:float and xs:double, and
types derived from them. For simplicity, each operator is
defined to operate on operands of the same type and to
return the same type. The one exception is op:numeric-divide,
which returns an xs:decimal if called with
two xs:integer operands.)
Operands of type xdt:untypedAtomic are
converted to xs:double, except for arguments
to 6.2.5
op:numeric-integer-divide which are converted to
xs:integer. If the two operands are not of
the same type, subtype substitution and type
promotion may be used to obtain two operands of the
same type. Appendix B of [XQuery 1.0:
An XML Query Language] describes the semantics of
these operations in detail.
-
Subtype substitution: A derived type may
substitute for its base type. In particular,
xs:integer may be used where
xs:decimal is expected.
-
Type promotion: xs:decimal
may be promoted to xs:float, and
xs:float may be promoted to
xs:double.
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 |
These rules define any operation on any pair of
arithmetic types. Consider the following example:
op:operation(xs:int, xs:double) => op:operation(xs:double, xs:double)
For this operation, xs:int must be
converted to xs:double. This can be done,
since by the rules above: xs:int can be
substituted for xs:integer,
xs:integer can be promoted to
xs:decimal, xs:decimal can be
promoted to xs:float, and
xs:float can be promoted to
xs:double. As far as possible, the
promotions should be done in a single step. Specifically,
when a decimal is promoted to a double, it must not be
converted to a float and then to double, as this risks
loss of precision.
As another example, a user may define
height as a derived type of
xs:integer with a minimum value of 20 and a
maximum value of 100. He may then derive
oddHeight using a pattern to restrict the
value to odd integers.
op:operation(oddHeight, xs:integer) => op:operation(xs:integer, xs:integer)
oddHeight can be substituted for its base
type height and height can be
substituted for its base type
xs:integer.
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-1985]. This
specification allows a number of options:
-
For xs:float and
xs:double operations, underflow behavior
·must· be conformant with [IEEE 754-1985]. This
specification allows a number of options:
-
Raising an error ("underflow on float or
double operation") via an underflow trap.
-
Returning 0.0E0 or +/-
2**Emin or a denormalized value; where
Emin is the smallest possible
xs:float or xs:double
exponent.
-
For xs:decimal operations, overflow
behavior ·must· raise an error
("overflow on decimal operation"). On underflow,
0.0 must be returned.
-
For xs:integer operations,
implementations ·may· choose to always
raise an error ("overflow on integer operation").
Alternatively, implementations ·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.
The number of digits of precision returned by various
numeric functions is ·implementation dependent·.
6.2.1 op:numeric-add
op:numeric-add($operand1 as numeric, $operand2 as numeric) as numeric
Backs up the "+" operator and returns the arithmetic
sum of its operands: ($operand1 +
$operand2).
6.2.2
op:numeric-subtract
op:numeric-subtract($operand1 as numeric, $operand2 as numeric) as numeric
Backs up the "-" operator and returns the arithmetic
difference of its operands: ($operand1 -
$operand2).
6.2.3
op:numeric-multiply
op:numeric-multiply($operand1 as numeric, $operand2 as numeric) as numeric
Backs up the "*" operator and returns the arithmetic
product of its operands: ($operand1 *
$operand2).
6.2.4
op:numeric-divide
op:numeric-divide($operand1 as numeric, $operand2 as numeric) as numeric
Backs up the "div" operator and returns the
arithmetic quotient of its operands: ($operand1
div $operand2).
As a special case, if the types of both
$operand1 and $operand2 are
xs:integer, then the return type is
xs:decimal.
For xs:decimal and
xs:integer operands, if the divisor is
0, then an error is raised ("Division by
zero"). For xs:float and
xs:double operands, floating point
division is performed as specified in [IEEE 754-1985] and
INF or -INF is returned if
the divisor is zero.
6.2.5
op:numeric-integer-divide
op:numeric-integer-divide( |
$operand1 |
as xs:integer, |
$operand2 |
as xs:integer) as |
