Ada Conformity Assessment Authority |
Home |
Conformity Assessment | Test Suite |
ARG | Ada Standard |

Real types provide approximations
to the real numbers, with relative bounds on errors for floating point
types, and with absolute bounds for fixed point types.

A type defined by a real_type_definition
is implicitly derived from *root_real*, an anonymous predefined
(specific) real type. [Hence, all real types, whether floating point
or fixed point, are in the derivation class rooted at *root_real*.]

{*8652/0099*}
{*AI95-00152-01*}
Note that this derivation does not imply any inheritance of subprograms.
Subprograms are inherited only for types derived by a derived_type_definition
(see 3.4), or a private_extension_declaration
(see 7.3, 7.3.1,
and 12.5.1).

[ Real literals
are all of the type *universal_real*, the universal type (see 3.4.1)
for the class rooted at *root_real*, allowing their use with the
operations of any real type. Certain multiplying
operators have a result type of *universal_fixed* (see 4.5.5),
the universal type for the class of fixed point types, allowing the result
of the multiplication or division to be used where any specific fixed
point type is expected.]

The elaboration of a real_type_definition
consists of the elaboration of the floating_point_definition
or the fixed_point_definition.

An implementation shall perform the run-time evaluation
of a use of a predefined operator of *root_real* with an accuracy
at least as great as that of any floating point type definable by a floating_point_definition.

{*AI95-00114-01*}
{*AI12-0426-1*}
{*AI12-0444-1*}
[For the execution of a predefined operation of a real type, it
is optional to the implementation need not
raise Constraint_Error if the result is outside the base range of the
type, so long as the correct result is produced, or the Machine_Overflows
attribute of the type is False (see G.2.1 G.2).]

{*AI12-0426-1*}
{*AI12-0444-1*}
An implementation may provide *nonstandard real
types*, descendants of *root_real* that are declared outside
of the specification of package Standard, which may
have different need not have all the standard
characteristics than of
a type defined by a real_type_definition.
For example, a nonstandard real type can might
have an asymmetric or unsigned base range, or its predefined operations
can might wrap
around or “saturate” rather than overflow (modular or saturating
arithmetic), or it can have a different might
not conform to the accuracy model than is
standard (see G.2.1 G.2).
Any type descended from a nonstandard real type is also nonstandard.
An implementation may place arbitrary restrictions on the use of such
types; it is implementation defined whether operators that are predefined
for “any real type” are defined for a particular nonstandard
real type. [In any case, such types are not permitted as explicit_generic_actual_parameters
for formal scalar types — see 12.5.2.]

NOTE As stated, real literals are
of the anonymous predefined real type *universal_real*. Other real
types have no literals. However, the overload resolution rules (see 8.6)
allow expressions of the type *universal_real* whenever a real type
is expected.

The syntax rule for real_type_definition
is modified to use the new syntactic categories floating_point_definition
and fixed_point_definition,
instead of floating_point_constraint and fixed_point_constraint,
because the semantics of a type definition are significantly different
than the semantics of a constraint.

All discussion of model numbers, safe ranges,
and machine numbers is moved to 3.5.7, 3.5.8,
and G.2. Values of a fixed point type are now
described as being multiples of the *small* of the fixed point type,
and we have no need for model numbers, safe ranges, etc. for fixed point
types.

Ada 2005 and 2012 Editions sponsored in part by **Ada-Europe**