4.5.6 Highest Precedence Operators
highest precedence unary operator abs
(absolute value) is predefined
for every specific numeric type T
, with the following specification:
function "abs"(Right : T) return T
highest precedence unary operator not
(logical negation) is predefined
for every boolean type T
, every modular type T
, and for
every one-dimensional array type T
whose components are of a boolean
type, with the following specification:
function "not"(Right : T) return T
The result of the operator not for a modular
type is defined as the difference between the high bound of the base
range of the type and the value of the operand. For a binary modulus,
this corresponds to a bit-wise complement of the binary representation
of the value of the operand.
The operator not
that applies to a one-dimensional
array of boolean components yields a one-dimensional boolean array with
the same bounds; each component of the result is obtained by logical
negation of the corresponding component of the operand (that is, the
component that has the same index value).
check is made that each component of the result belongs to the component
subtype; the exception Constraint_Error is raised if this check fails.
highest precedence exponentiation
operator ** is predefined for
every specific integer type T
with the following specification:
function "**"(Left : T; Right : Natural) return T
Exponentiation is also
predefined for every specific floating point type as well as root_real,
with the following specification (where T is root_real
or the floating point type):
function "**"(Left : T; Right : Integer'Base) return T
The right operand of an exponentiation
is the exponent
. The value of X**N with the value of the exponent
N positive is the same as the value of X*X*...X (with N–1 multiplications)
except that the multiplications are associated in an arbitrary order.
With N equal to zero, the result is one. With the value of N negative
(only defined for a floating point operand), the result is the reciprocal
of the result using the absolute value of N as the exponent.
The implementation of exponentiation
for the case of a negative exponent is allowed to raise Constraint_Error
if the intermediate result of the repeated multiplications is outside
the safe range of the type, even though the final result (after taking
the reciprocal) would not be. (The best machine approximation to the
final result in this case would generally be 0.0.)
implied by the specification given above for exponentiation of an integer
type, a check is made that the exponent is not negative.
is raised if this check fails.
Ada 2005 and 2012 Editions sponsored in part by Ada-Europe