--- ais/ai-00315.txt 2003/05/24 00:51:42 1.2 +++ ais/ai-00315.txt 2003/11/27 02:01:15 1.3 @@ -1,15 +1,213 @@ -!standard A.5.3 (00) 02-09-30 AI95-00315/00 +!standard A.5.3 (00) 03-11-04 AI95-00315/01 !class amendment 02-09-30 !status received 02-09-26 !priority Low !difficulty Medium -!subject Full support for IEEE 754 +!subject Full support for IEC 559:1989 !summary +A new mode, named IEEE mode, is defined to provide support for IEC 559:1989 + !problem !proposal + +The IEEE mode is a mode "stricter than strict". That is, all the requirements +for strict mode apply, plus some others. It is unspecified which mode is the +default, if the three modes actually differ, and how the user selects a +particular mode. + +In the IEEE mode, Interfaces.IEEE_Float_32 must be present. Other types in +Interfaces, e.g. IEEE_Float_64, must be present if *fully* supported by the +hardware. By *fully* supported, we mean that all the requirements of IEC +559:1989, with the possible exception of those pertaining to binary <-> decimal +conversions, are satisfied by the underlying hardware. If a format is supported +by the hardware, but some of its operations trap to software, we do not require +the existence of a corresponding type in Interfaces. + +Float must be functionally equivalent to IEEE_Float_32. If Long_Float and +IEEE_Float_64 both exist, they must be functionally equivalent. The attributes +of IEEE_Float_32 and IEEE_Float_64, if present, must have the value specified in +AARM G.2.2(11.a-g) (with Signed_Zeros = True). + +The permission of G.2.1(16) does not apply. Furthermore, the accuracy rules in +G.2.1(7-8) apply to the function Sqrt in any instantiation of +Ada.Numerics.Elementary_Functions. + +The value returned by Sqrt (-0.0) must be -0.0. No exception is raised in this +case. + +The attributes Image and Value and the procedures Put and Get in any +instantiation of Ada.Text_IO.Float_IO comply with the following accuracy +requirements: + +o If the argument has the form M * 10.0 ** N where M is an integer in the range + -Max_M .. Max_M and N is an integer in the range -Max_N .. Max_N, then the + conversion is exact. + +o Otherwise if the rounding mode is Round_To_Nearest the error of the converted + result does not exceed by more than 0.47 units in the destination's least + significant digit the error that would be incurred by rounding to the nearest + value, provided that overflow/underflow does not occur. + +o In the directed rounding modes the error has the correct sign and does not + exceed 1.47 units of the last place. + +Max_M is 1E9 - 1 for IEEE_Float_32 and 1E17 - 1 for IEEE_Float_64. Max_N is 13 +for IEEE_Float_32 and 27 for IEEE_Float_64. + +Image, Value, Put and Get are monotonic. If the rounding mode is +Round_To_Nearest applying Image followed by Value, or Put followed by Get, is +the identity as long as the strings have at least 9 significant digits for +IEEE_Float_32 and 17 significant digits for IEEE_Float_64. + +The operators "<=", "<", "=", ">", ">=" for a floating-point type return False +in the unordered case. The operator "/=" returns True in the unordered case. +(Note that this means that 'not (X < Y)' may be distinct from 'X >= Y'. +Optimizers, beware!) + +The arithmetic operators properly operate on NaNs and infinities, and comply +with the current rounding mode. + +For every subtype S of a floating-point type T, the following additional +attributes are defined: + + S'Infinity returns a value of type T that represents +oo. + + S'Quiet_NaN returns a value of type T that is a quiet NaN; if the + hardware supports several representations for quiet NaNs, + it is implementation defined which one is returned by this + attribute. + + S'Signalling_NaN returns a value of type T that is a signalling NaN; if the + hardware supports several representations for signalling + NaNs, it is implementation defined which one is returned by + this attribute. + + S'Is_NaN A function with the specification: + + function S'Is_NaN (X : T) return Boolean; + + returns True if X is a quiet or signalling NaN. + + S'Finite A function with the specification: + + function S'Finite (X : T) return Boolean; + + returns True if X is neither an infinity nor a NaN. + + S'Unordered A function with the specification: + + function S'Unordered (X, Y : T) return Boolean; + + returns True if X and Y are unordered. + +All these attributes are static if their prefix and arguments (if any) are. + +The following predefined package is added: + +package Ada.Numerics.IEEE is + + type Rounding_Mode is (Round_To_Nearest, + Round_Towards_Zero, + Round_Up, + Round_Down); + procedure Set_Rounding_Mode (R : Rounding_Mode); + function Get_Rounding_Mode return Rounding_Mode; + + type Format is (Single, + Single_Extended, + Double, + Double_Extended); + procedure Set_Rounding_Precision (F : Format); + function Get_Rounding_Precision return Format; + + -- The following is called "exception" by IEC 559:1989... + type Event is (Invalid_Operation, + Division_By_Zero, + Overflow, + Underflow, + Inexact); + procedure Set_Flag (E : Event; To : Boolean); + function Get_Flag (E : Event) return Boolean; + + type Flags is array (Event) of Boolean; + procedure Set_Flags (F : Flags); + function Get_Flags return Flags; + + -- Is this the right level of granularity? + type Operation is (Add, + Subtract, + Multiply, + Divide, + Remainder, + Sqrt, + Float_Float_Conversion, + Float_Integer_Conversion, + Integer_Float_Conversion, + Rounding, + Binary_Decimal_Conversion, + Decimal_Binary_Conversion, + Comparison); + + generic + type T is digits <>; + package Traps is + type Handler is access function (E : Event; + Op : Operation; + Fmt : Format; + Result : T; + Arg1, Arg2 : T) return T; + procedure Enable_Trap (H : Handler; E : Event); + procedure Disable_Trap (E : Event); + function Trap_Is_Enabled (E : Event) return Boolean; + function Get_Handler (E : Event) return Handler; + end Traps; + +end Ada.Numerics.IEEE; + +This package operates on global, system-wide state that is modified or used by +a variety of floating-point operations. Only basic facilities are provided +here. It is expected that more elaborate facilities can be built as needed by +the user (e.g using protected objects to deal with race conditions or +controlled objects to protect against aborts.) + +The rounding mode specifies how arithmetic operations round the (infinitely +precise) mathematical result to the destination format. When a partition +starts, the rounding mode is Round_To_Nearest. + +Some machines (e.g. the x86 family) always operate on an extended +floating-point format. The rounding precision makes it possible to reduce the +precision of the computations. This is important to avoid double rounding in +precision-reducing operations. Set_Rounding_Precision has no effect on hardware +that perform all computations in the destination format. When a partition +starts, the rounding precision must correspond to the most precise supported +format. + +Events (called exceptions in IEC 559:1989, but we cannot use that name) +describe conditions that may happen as part of some floating-point operation. +Event flags may be read/written either one by one or as a whole. + +An event may cause a trap. If it doesn't cause a trap, execution proceeds +normally. If it causes a trap, the corresponding handler is called. IEC +559:1989 describes the arguments that are passed to the handler. The value of +Result, Arg1 and Arg2 are converted to type T before calling the handler. This +conversion never causes a trap (although it may result in infinities being +passed to the handler). If some of the arguments Result, Arg1 and Arg2 are not +relevant for a given event, the value T'Quiet_NaN is passed to the handler. + +The handler may return a value, in which case execution proceeds as if this +value had been the actual result of the operation. + +The value null for a handler represents the Ada default, which is to ignore +Underflow and Inexact, raise Constraint_Error on Division_By_Zero and Overflow, +and is unspecified for Invalid_Operation. The Ada default is in effect when a +partition starts. + +The correspondence between Ada operations and IEEE operations is unspecified. +Therefore, relying on the operation passed to the handler may be unreliable, +unless code statements are used. !discussion

Questions? Ask the ACAA Technical Agent