Go to the first, previous, next, last section, table of contents.

In the strict mode, the predefined arithmetic operations of a fixed
point type shall satisfy the accuracy requirements specified here and
shall avoid or signal overflow in the situations described.
Implementation Requirements

The accuracy requirements for the predefined fixed point arithmetic
operations and conversions, and the results of relations on fixed point
operands, are given below.

The operands of the fixed point adding operators, absolute value, and
comparisons have the same type. These operations are required to yield
exact results, unless they overflow.

Multiplications and divisions are allowed between operands of any two
fixed point types; the result has to be (implicitly or explicitly)
converted to some other numeric type. For purposes of defining the
accuracy rules, the multiplication or division and the conversion are
treated as a single operation whose accuracy depends on three types
(those of the operands and the result). For decimal fixed point types,
the attribute T'Round may be used to imply explicit conversion with
rounding, See section 3.5.10 Operations of Fixed Point Types.

When the result type is a floating point type, the accuracy is as given
in See section G.2.1 Model of Floating Point Arithmetic. For some combinations of the operand and result types
in the remaining cases, the result is required to belong to a small set
of values called the perfect result set; for other combinations, it is
required merely to belong to a generally larger and
implementationdefined set of values called the close result set. When
the result type is a decimal fixed point type, the perfect result set
contains a single value; thus, operations on decimal types are always
fully specified.

When one operand of a fixedfixed multiplication or division is of type
universal_real, that operand is not implicitly converted in the usual
sense, since the context does not determine a unique target type, but
the accuracy of the result of the multiplication or division (i.e.,
whether the result has to belong to the perfect result set or merely the
close result set) depends on the value of the operand of type
universal_real and on the types of the other operand and of the result.

For a fixed point multiplication or division whose (exact) mathematical
result is v, and for the conversion of a value v to a fixed point type,
the perfect result set and close result set are defined as follows:

If the result type is an ordinary fixed point type with a small of s,

if v is an integer multiple of s, then the perfect result set contains
only the value v;

otherwise, it contains the integer multiple of s just below v and the
integer multiple of s just above v.

The close result set is an implementationdefined set of consecutive
integer multiples of s containing the perfect result set as a subset.

If the result type is a decimal type with a small of s,

if v is an integer multiple of s, then the perfect result set contains
only the value v;

otherwise, if truncation applies then it contains only the integer
multiple of s in the direction toward zero, whereas if rounding applies
then it contains only the nearest integer multiple of s (with ties
broken by rounding away from zero).

The close result set is an implementationdefined set of consecutive
integer multiples of s containing the perfect result set as a subset.

If the result type is an integer type,

if v is an integer, then the perfect result set contains only the value
v;

otherwise, it contains the integer nearest to the value v (if v lies
equally distant from two consecutive integers, the perfect result set
contains the one that is further from zero).

The close result set is an implementationdefined set of consecutive
integers containing the perfect result set as a subset.

The result of a fixed point multiplication or division shall belong
either to the perfect result set or to the close result set, as
described below, if overflow does not occur. In the following cases, if
the result type is a fixed point type, let s be its small; otherwise,
i.e. when the result type is an integer type, let s be 1.0.

For a multiplication or division neither of whose operands is of type
universal_real, let l and r be the smalls of the left and right
operands. For a multiplication, if (l*r)/s is an integer or the
reciprocal of an integer (the smalls are said to be "compatible" in
this case), the result shall belong to the perfect result set;
otherwise, it belongs to the close result set. For a division, if
l/(r*s) is an integer or the reciprocal of an integer (i.e., the smalls
are compatible), the result shall belong to the perfect result set;
otherwise, it belongs to the close result set.

For a multiplication or division having one universal_real operand with
a value of v, note that it is always possible to factor v as an integer
multiple of a "compatible" small, but the integer multiple may be
"too big." If there exists a factorization in which that multiple is
less than some implementationdefined limit, the result shall belong to
the perfect result set; otherwise, it belongs to the close result set.

A multiplication P * Q of an operand of a fixed point type F by an
operand of an integer type I, or viceversa, and a division P / Q of an
operand of a fixed point type F by an operand of an integer type I, are
also allowed. In these cases, the result has a type of F; explicit
conversion of the result is never required. The accuracy required in
these cases is the same as that required for a multiplication F(P * Q)
or a division F(P / Q) obtained by interpreting the operand of the
integer type to have a fixed point type with a small of 1.0.

The accuracy of the result of a conversion from an integer or fixed
point type to a fixed point type, or from a fixed point type to an
integer type, is the same as that of a fixed point multiplication of the
source value by a fixed point operand having a small of 1.0 and a value
of 1.0, as given by the foregoing rules. The result of a conversion from
a floating point type to a fixed point type shall belong to the close
result set. The result of a conversion of a universal_real operand to a
fixed point type shall belong to the perfect result set.

The possibility of overflow in the result of a predefined arithmetic
operation or conversion yielding a result of a fixed point type T is
analogous to that for floating point types, except for being related to
the base range instead of the safe range. If all of the permitted
results belong to the base range of T, then the implementation shall
deliver one of the permitted results; otherwise,

if T'Machine_Overflows is True, the implementation shall either deliver
one of the permitted results or raise Constraint_Error;

if T'Machine_Overflows is False, the result is implementation defined.
Go to the first, previous, next, last section, table of contents.