Contents Index Search Previous Next
3.5.9 Fixed Point Types
1
{fixed point type}
{ordinary fixed point type}
{decimal fixed point type}
A fixed point type is either an ordinary fixed point
type, or a decimal fixed point type.
{delta (of a
fixed point type)} The error bound of
a fixed point type is specified as an absolute value, called the
delta
of the fixed point type.
Syntax
2
fixed_point_definition
::= ordinary_fixed_point_definition |
decimal_fixed_point_definition
3
ordinary_fixed_point_definition
::=
delta static_expression real_range_specification
4
decimal_fixed_point_definition
::=
delta static_expression digits static_expression [
real_range_specification]
5
digits_constraint
::=
digits static_expression [
range_constraint]
Name Resolution Rules
6
{expected type (fixed point
type delta) [partial]} For a type defined
by a
fixed_point_definition, the
delta of the type is specified by the value of the
expression
given after the reserved word
delta; this
expression
is expected to be of any real type.
{expected type
(decimal fixed point type digits) [partial]} {digits
(of a decimal fixed point subtype)} {decimal
fixed point type} For a type defined by
a
decimal_fixed_point_definition
(a
decimal fixed point type), the number of significant decimal
digits for its first subtype (the
digits of the first subtype)
is specified by the
expression given
after the reserved word
digits; this
expression
is expected to be of any integer type.
Legality Rules
7
In a fixed_point_definition
or digits_constraint, the expressions
given after the reserved words delta and digits shall be
static; their values shall be positive.
8
{small (of a fixed point type)}
The set of values of a fixed point type comprise
the integral multiples of a number called the
small of the type.
{ordinary fixed point type} For
a type defined by an
ordinary_fixed_point_definition
(an
ordinary fixed point type), the
small may be specified
by an
attribute_definition_clause
(see
13.3); if so specified, it shall be no
greater than the
delta of the type. If not specified, the
small
of an ordinary fixed point type is an implementation-defined power of
two less than or equal to the
delta.
8.a
Implementation defined: The
small of an ordinary fixed point type.
9
For a decimal fixed point type, the small
equals the delta; the delta shall be a power of 10. If
a real_range_specification is given,
both bounds of the range shall be in the range -(10**digits-1)*delta
.. +(10**digits-1)*delta.
10
A fixed_point_definition
is illegal if the implementation does not support a fixed point type
with the given small and specified range or digits.
10.a
Implementation defined: What
combinations of small, range, and digits are supported
for fixed point types.
11
For a subtype_indication
with a digits_constraint, the subtype_mark
shall denote a decimal fixed point subtype.
11.a
To be honest: Or, as
an obsolescent feature, a floating point subtype is permitted -- see
J.3.
Static Semantics
12
{base range (of a fixed point
type) [partial]} The base range (see
3.5)
of a fixed point type is symmetric around zero, except possibly for an
extra negative value in some implementations.
13
{base
range (of an ordinary fixed point type) [partial]} An
ordinary_fixed_point_definition
defines an ordinary fixed point type whose base range includes at least
all multiples of
small that are between the bounds specified in
the
real_range_specification. The
base range of the type does not necessarily include the specified bounds
themselves.
{constrained (subtype)} {unconstrained
(subtype)} An
ordinary_fixed_point_definition
also defines a constrained first subtype of the type, with each bound
of its range given by the closer to zero of:
14
- the value of the conversion to the
fixed point type of the corresponding expression
of the real_range_specification;
{implicit subtype conversion (bounds of a fixed point
type) [partial]}
14.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 fixed
point type) [partial]}
15
- the corresponding bound of the base
range.
16
{base range (of a decimal
fixed point type) [partial]} A
decimal_fixed_point_definition
defines a decimal fixed point type whose base range includes at least
the range -(10**
digits-1)*
delta .. +(10**
digits-1)*
delta.
{constrained (subtype)} {unconstrained
(subtype)} A
decimal_fixed_point_definition
also defines a constrained first subtype of the type. If a
real_range_specification
is given, the bounds of the first subtype are given by a conversion of
the values of the
expressions of
the
real_range_specification.
{implicit
subtype conversion (bounds of a decimal fixed point type) [partial]}
Otherwise, the range of the first subtype is -(10**
digits-1)*
delta
.. +(10**
digits-1)*
delta.
16.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 decimal
fixed point type) [partial]}
Dynamic Semantics
17
{elaboration (fixed_point_definition)
[partial]} The elaboration of a
fixed_point_definition
creates the fixed point type and its first subtype.
18
For a
digits_constraint
on a decimal fixed point subtype with a given
delta, if it does
not have a
range_constraint, then
it specifies an implicit range -(10**
D-1)*
delta .. +(10**
D-1)*
delta,
where
D is the value of the
expression.
{compatibility (digits_constraint with a decimal fixed
point subtype)} A
digits_constraint
is
compatible with a decimal fixed point subtype if the value
of the
expression is no greater
than the
digits of the subtype, and if it specifies (explicitly
or implicitly) a range that is compatible with the subtype.
18.a
Discussion: Except for
the requirement that the digits specified be no greater than the
digits of the subtype being constrained, a digits_constraint
is essentially equivalent to a range_constraint.
18.b
Consider
the following example:
18.c
type D is delta 0.01 digits 7 range -0.00 .. 9999.99;
18.d/1
The compatibility rule implies
that the digits_constraint "digits
6" specifies an implicit range of "-9999.99 99.9999
.. 9999.99 99.9999". Thus, "digits 6"
is not compatible with the constraint of D, but "digits 6
range 0.00 .. 9999.99" is compatible.
18.e
A value of a scalar type belongs
to a constrained subtype of the type if it belongs to the range of the
subtype. Attributes like Digits and Delta have no affect on this fundamental
rule. So the obsolescent forms of digits_constraints
and delta_constraints that are called
``accuracy constraints'' in RM83 don't really represent constraints on
the values of the subtype, but rather primarily affect compatibility
of the ``constraint'' with the subtype being ``constrained.'' In this
sense, they might better be called ``subtype assertions'' rather than
``constraints.''
18.f
Note that the digits_constraint
on a decimal fixed point subtype is a combination of an assertion about
the digits of the subtype being further constrained, and a constraint
on the range of the subtype being defined, either explicit or implicit.
19
{elaboration (digits_constraint)
[partial]} The elaboration of a
digits_constraint
consists of the elaboration of the
range_constraint,
if any.
{Range_Check [partial]} {check,
language-defined (Range_Check)} If a
range_constraint
is given, a check is made that the bounds of the range are both in the
range -(10**
D-1)*
delta .. +(10**
D-1)*
delta,
where
D is the value of the (static)
expression
given after the reserved word
digits.
{Constraint_Error
(raised by failure of run-time check)} If
this check fails, Constraint_Error is raised.
Implementation Requirements
20
The implementation shall support at least 24
bits of precision (including the sign bit) for fixed point types.
20.a
Reason: This is sufficient
to represent Standard.Duration with a small no more than 50 milliseconds.
Implementation Permissions
21
Implementations are permitted to support only
smalls that are a power of two. In particular, all decimal fixed
point type declarations can be disallowed. Note however that conformance
with the Information Systems Annex requires support for decimal smalls,
and decimal fixed point type declarations with digits up to at
least 18.
21.a
Implementation Note: The
accuracy requirements for multiplication, division, and conversion (see
G.2.1, ``Model of
Floating Point Arithmetic'') are such that support for arbitrary
smalls should be practical without undue implementation effort.
Therefore, implementations should support fixed point types with arbitrary
values for small (within reason). One reasonable limitation would
be to limit support to fixed point types that can be converted to the
most precise floating point type without loss of precision (so that Fixed_IO
is implementable in terms of Float_IO).
22
36 The
base range of an ordinary fixed point type need not include the specified
bounds themselves so that the range specification can be given in a natural
way, such as:
23
type Fraction is delta 2.0**(-15) range -1.0 .. 1.0;
24
With 2's complement hardware, such
a type could have a signed 16-bit representation, using 1 bit for the
sign and 15 bits for fraction, resulting in a base range of -1.0 .. 1.0-2.0**(-15).
Examples
25
Examples of
fixed point types and subtypes:
26
type Volt is delta 0.125 range 0.0 .. 255.0;
27
-- A pure fraction which requires all the available
-- space in a word can be declared as the type Fraction:
type Fraction is delta System.Fine_Delta range -1.0 .. 1.0;
-- Fraction'Last = 1.0 - System.Fine_Delta
28
type Money is delta 0.01 digits 15; -- decimal fixed point
subtype Salary is Money digits 10;
-- Money'Last = 10.0**13 - 0.01, Salary'Last = 10.0**8 - 0.01
Inconsistencies With Ada 83
28.a
{inconsistencies with Ada
83} In Ada 95, S'Small always equals S'Base'Small,
so if an implementation chooses a small for a fixed point type
smaller than required by the delta, the value of S'Small in Ada
95 might not be the same as it was in Ada 83.
Extensions to Ada 83
28.b
{extensions to Ada 83}
Decimal fixed point types are new, though their capabilities
are essentially similar to that available in Ada 83 with a fixed point
type whose small equals its delta equals a power of 10.
However, in the Information Systems Annex, additional requirements are
placed on the support of decimal fixed point types (e.g. a minimum of
18 digits of precision).
Wording Changes from Ada 83
28.c
The syntax rules for fixed_point_constraint
and fixed_accuracy_definition are
removed. The syntax rule for fixed_point_definition
is new. A syntax rule for delta_constraint
is included in the Obsolescent features (to be compatible with Ada 83's
fixed_point_constraint).
Contents Index Search Previous Next Legal