1

{*floating point type*}
For floating point types, the error bound is specified
as a relative precision by giving the required minimum number of significant
decimal digits.

2

3

4

{*requested decimal
precision (of a floating point type)*} The
*requested decimal precision*, which is the minimum number of significant
decimal digits required for the floating point type, is specified by
the value of the expression given after the
reserved word **digits**. {*expected
type (requested decimal precision)* [partial]} This
expression is expected to be of any integer
type.

5

{*expected type (real_range_specification
bounds)* [partial]} Each simple_expression
of a real_range_specification is expected
to be of any real type[; the types need not be the same].

6

{*Max_Base_Digits*}
The requested decimal precision shall be specified
by a static expression whose value is positive
and no greater than System.Max_Base_Digits. Each simple_expression
of a real_range_specification shall also be
static. {*Max_Digits*} If
the real_range_specification is omitted, the
requested decimal precision shall be no greater than System.Max_Digits.

6.a

7

A floating_point_definition
is illegal if the implementation does not support a floating point type
that satisfies the requested decimal precision and range.

7.a

8

The set of values for a floating point type is the
(infinite) set of rational numbers. {*machine
numbers (of a floating point type)*} The
*machine numbers* of a floating point type are the values of the
type that can be represented exactly in every unconstrained variable
of the type. {*base range (of a floating
point type)* [partial]} The base range
(see 3.5) of a floating point type is symmetric
around zero, except that it can include some extra negative values in
some implementations.

8.a

8.b

9

{*base decimal precision
(of a floating point type)*} The *base
decimal precision* of a floating point type is the number of decimal
digits of precision representable in objects of the type. {*safe
range (of a floating point type)*} The
*safe range* of a floating point type is that part of its base range
for which the accuracy corresponding to the base decimal precision is
preserved by all predefined operations.

9.a

10

{*base decimal precision
(of a floating point type)* [partial]} A
floating_point_definition defines a floating
point type whose base decimal precision is no less than the requested
decimal precision. {*safe range (of a
floating point type)* [partial]} {*base
range (of a floating point type)* [partial]} If
a real_range_specification is given, the safe
range of the floating point type (and hence, also its base range) includes
at least the values of the simple expressions given in the real_range_specification.
If a real_range_specification is not given,
the safe (and base) range of the type includes at least the values of
the range –10.0**(4*D) .. +10.0**(4*D) where D is the requested
decimal precision. [The safe range might include other values as well.
The attributes Safe_First and Safe_Last give the actual bounds of the
safe range.]

11

A floating_point_definition
also defines a first subtype of the type. {*constrained
(subtype)*} {*unconstrained
(subtype)*} If a real_range_specification
is given, then the subtype is constrained to a range whose bounds are
given by a conversion of the values of the simple_expressions
of the real_range_specification to the type
being defined. Otherwise, the subtype is unconstrained.

11.a.1/1

12

{*Float*}
There is a predefined, unconstrained, floating point
subtype named Float[, declared in the visible part of package Standard].

13

{*elaboration (floating_point_definition)*
[partial]} [The elaboration of a floating_point_definition
creates the floating point type and its first subtype.]

14

{*Float*}
In an implementation that supports floating point
types with 6 or more digits of precision, the requested decimal precision
for Float shall be at least 6.

15

{*Long_Float*}
If Long_Float is predefined for an implementation,
then its requested decimal precision shall be at least 11.

16

{*Short_Float*}
{*Long_Float*}
An implementation is allowed to provide additional
predefined floating point types[, declared in the visible part of Standard],
whose (unconstrained) first subtypes have names of the form Short_Float,
Long_Float, Short_Short_Float, Long_Long_Float, etc. Different predefined
floating point types are allowed to have the same base decimal precision.
However, the precision of Float should be no greater than that of Long_Float.
Similarly, the precision of Short_Float (if provided) should be no greater
than Float. Corresponding recommendations apply to any other predefined
floating point types. There need not be a named floating point type corresponding
to each distinct base decimal precision supported by an implementation.

16.a

17

{*Long_Float*}
An implementation should support Long_Float in addition
to Float if the target machine supports 11 or more digits of precision.
No other named floating point subtypes are recommended for package Standard.
Instead, appropriate named floating point subtypes should be provided
in the library package Interfaces (see B.2).

17.a.1/2

17.a

NOTES

18

35 If a floating point subtype is unconstrained,
then assignments to variables of the subtype involve only Overflow_Checks,
never Range_Checks.

19

20

21

22

22.a

{*inconsistencies with Ada 83*} No
Range_Checks, only Overflow_Checks, are performed on variables (or parameters)
of an unconstrained floating point subtype. This is upward compatible
for programs that do not raise Constraint_Error. For those that do raise
Constraint_Error, it is possible that the exception will be raised at
a later point, or not at all, if extended range floating point registers
are used to hold the value of the variable (or parameter).

22.b

22.c

The syntax rules for floating_point_constraint
and floating_accuracy_definition are removed.
The syntax rules for floating_point_definition
and real_range_specification are new.

22.d

A syntax rule for digits_constraint
is given in 3.5.9, “Fixed
Point Types”. In J.3 we indicate
that a digits_constraint may be applied to
a floating point subtype_mark as well (to
be compatible with Ada 83's floating_point_constraint).

22.e

Discussion of model numbers is postponed to
3.5.8 and G.2.
The concept of safe numbers has been replaced by the concept of the safe
range of values. The bounds of the safe range are given by T'Safe_First
.. T'Safe_Last, rather than -T'Safe_Large .. T'Safe_Large, since on some
machines the safe range is not perfectly symmetric. The concept of machine
numbers is new, and is relevant to the definition of Succ and Pred for
floating point numbers.

Sponsored by **Ada-Europe**