
The language defines the following six categories of operators (given in
order of increasing precedence). The corresponding operator_symbols, and
only those, can be used as designators in declarations of functions for
userdefined operators. See section 6.6 Overloading of Operators.
Syntax

logical_operator ::= and  or  xor

relational_operator ::= =  /=  <  <=  >  >=

binary_adding_operator ::= +    &

unary_adding_operator ::= +  

multiplying_operator ::= *  /  mod  rem

highest_precedence_operator ::= **  abs  not
Static Semantics

For a sequence of operators of the same precedence level, the operators
are associated with their operands in textual order from left to right.
Parentheses can be used to impose specific associations.

For each form of type definition, certain of the above operators are
predefined; that is, they are implicitly declared immediately after the
type definition. For each such implicit operator declaration, the
parameters are called Left and Right for binary operators; the single
parameter is called Right for unary operators. An expression of the form
X op Y, where op is a binary operator, is equivalent to a function_call
of the form "op"(X, Y). An expression of the form op Y, where op is a
unary operator, is equivalent to a function_call of the form "op"(Y).
The predefined operators and their effects are described in subclauses
See section 4.5.1 Logical Operators and Shortcircuit Control Forms through See section 4.5.6 Highest Precedence Operators.
Dynamic Semantics

The predefined operations on integer types either yield the
mathematically correct result or raise the exception Constraint_Error.
For implementations that support the Numerics Annex, the predefined
operations on real types yield results whose accuracy is defined in
See section G Numerics (normative), or raise the exception Constraint_Error.
Implementation Requirements

The implementation of a predefined operator that delivers a result of an
integer or fixed point type may raise Constraint_Error only if the
result is outside the base range of the result type.

The implementation of a predefined operator that delivers a result of a
floating point type may raise Constraint_Error only if the result is
outside the safe range of the result type.
Implementation Permissions

For a sequence of predefined operators of the same precedence level (and
in the absence of parentheses imposing a specific association), an
implementation may impose any association of the operators with operands
so long as the result produced is an allowed result for the
lefttoright association, but ignoring the potential for failure of
languagedefined checks in either the lefttoright or chosen order of
association.
NOTES

(11) The two operands of an expression of the form X op Y, where op is a
binary operator, are evaluated in an arbitrary order, as for any
function_call, See section 6.4 Subprogram Calls.
Examples

Examples of precedence:

not Sunny or Warm  same as (not Sunny) or Warm
X > 4.0 and Y > 0.0  same as (X > 4.0) and (Y > 0.0)

4.0*A**2  same as (4.0 * (A**2))
abs(1 + A) + B  same as (abs (1 + A)) + B
Y**(3)  parentheses are necessary
A / B * C  same as (A/B)*C
A + (B + C)  evaluate B + C before adding it to A