28

Mar

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 floating_point_definition ::=

**di****gits** *static_*expression [real_range_specification]

3 real_range_specification ::=

**ran****ge** *static_*simple_expression .. *static_*simple_expression

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** Reason: **We have added Max_Base_Digits to package System. It corresponds to the requested decimal precision of *root_real*. System.Max_Digits corresponds to the maximum value for Digits that may be specified in the absence of a real_range_specification, for upward compatibility. These might not be the same if root_real has a base range that does not include ± 10.0**(4*Max_Base_Digits).

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** Implementation defined: **What combinations of requested decimal precision and range are supported for floating point types.

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** Implementation Note: **For example, if a 2's complement representation is used for the mantissa rather than a sign-mantissa or 1's complement representation, then there is usually one extra negative machine number.

8.b** To be honest: **If the Signed_Zeros attribute is True, then minus zero could in a sense be considered a value of the type. However, for most purposes, minus zero behaves the same as plus zero.

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** Implementation Note: **In most cases, the safe range and base range are the same. However, for some hardware, values near the boundaries of the base range might result in excessive inaccuracies or spurious overflows when used with certain predefined operations. For such hardware, the safe range would omit such values.

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** To be honest: **The conversion mentioned above is not an *implicit subtype conversion* (which is something that happens at overload resolution, see §4.6), although it happens implicitly. Therefore, the freezing rules are not invoked on the type (which is important so that representation items can be given for the type). {*subtype conversion (bounds of a floating point type)* [partial]}

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** Implementation defined: **The predefined floating point types declared in Standard.

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** Implementation Advice: **Long_Float should be declared in Standard if the target supports 11 or more digits of precision. No other named float subtypes should be declared in Standard.

17.a** Implementation Note: **To promote portability, implementations should explicitly declare the floating point (sub)types Float and Long_Float in Standard, and leave other predefined float types anonymous. For implementations that already support Short_Float, etc., upward compatibility argues for keeping such declarations in Standard during the transition period, but perhaps generating a warning on use. A separate package Interfaces in the predefined environment is available for pre-declaring types such as Float_32, IEEE_Float_64, etc. See §B.2.

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

19* Examples of floating point types and subtypes:*

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** Reason: **This change was felt to be justified by the possibility of improved performance on machines with extended-range floating point registers. An implementation need not take advantage of this relaxation in the range checking; it can hide completely the use of extended range registers if desired, presumably at some run-time expense.

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.

- Login to post comments