Go to the first, previous, next, last section, table of contents.
Static Semantics

The 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

The highest precedence unary operator not (logical negation) is
predefined for every boolean type T, every modular type T, and for every
onedimensional 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
bitwise complement of the binary representation of the value of the
operand.

The operator not that applies to a onedimensional array of boolean
components yields a onedimensional 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). A check is made that each component of the result
belongs to the component subtype; the exception Constraint_Error is
raised if this check fails.

The 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 expression
X**N with the value of the exponent N positive is equivalent to the
expression X*X*...X (with N1 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.
Implementation Permissions

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.)
NOTES

(19) As implied by the specification given above for exponentiation of
an integer type, a check is made that the exponent is not negative.
Constraint_Error is raised if this check fails.
Go to the first, previous, next, last section, table of contents.