 (1)
 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 6.6, ``Overloading of Operators''.
(2)
logical_operator ::= and  or  xor
(3)
relational_operator ::= =  /=  <  <=  >  >=
(4)
binary_adding_operator ::= +    &
(5)
unary_adding_operator ::= +  
(6)
multiplying_operator ::= *  /  mod  rem
(7)
highest_precedence_operator ::= **  abs  not
Static Semantics
 (8)
 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.
 (9)
 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 4.5.1 through 4.5.6.
Dynamic Semantics
 (10)
 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 Annex G, or raise
the exception Constraint_Error.
Implementation Requirements
 (11)
 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.
 (12)
 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
 (13)
 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.

 (14)
(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 6.4).
Examples
 (15)
 Examples of precedence:
(16)
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)
(17)
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
Subclauses
 Logical Operators and Shortcircuit Control Forms
 Relational Operators and Membership Tests
 Binary Adding Operators
 Unary Adding Operators
 Multiplying Operators
 Highest Precedence Operators
 Email comments, additions, corrections, gripes, kudos, etc. to:
Magnus Kempe  Magnus.Kempe@di.epfl.ch
Copyright statement
Page last generated: 950312