arith_exp - Calculation Type
An arithmetic expression is assigned a calculation type that specifies how the arithmetic expression is to be handled. The calculation type is determined at program runtime from those data types involved that can be identified. The calculation type only needs to be determined statically if the target field is an inline declaration, where generically typed operands are included using a standard type.
Determining the Calculation Type
The calculation type corresponds to one of the numeric data types
decfloat34. It is determined according to the following hierarchy, and in this order of priority:
decfloat34, the calculation type is
for if the operator
**is used, the calculation type is
p, the calculation type is
s), the calculation type is
The data type that has the largest value range therefore determines the calculation type. An exception to this is that each
decimal floating point number
produces the calculation type
decfloat34, and that using the operator
** is handled like a data type of type
Involved data types include:
- as the right side of an assignment in an arithmetic
expression, the data types of all operands of the whole arithmetic expression and the data type of the
result, if not an inline declaration
resultis an inline declaration, the calculation type derived from the data types of the arithmetic expression determines the data type of the declared variable.
- as the operand of a relational expression in an arithmetic expression, the data types of all operands of the entire relational expression. The approach taken does not involve first determining the calculation type of each arithmetic expression involved and then deriving the comparison type. All operands of the relational expression are used to determine the calculation type (which is also the comparison type) regardless of the arithmetic expressions they belong to.
- in an arithmetic expression after the statement
CASE, the operands of the arithmetic expression, ignoring the operands specified after
- as actual parameters for input parameters of methods in an arithmetic expression, the data types of all operands of the whole arithmetic expression and the typing of the formal parameter, provided that it is fully typed. If the formal parameter is typed generically, then only the operands of the expression are evaluated.
- as actual parameters for input parameters of function modules, the data types of all operands of the entire arithmetic expression. The typing of the formal parameter is ignored.
- as an argument of a predefined function in an arithmetic expression, the data types of all operands of the entire arithmetic expression and the type of the input parameter, if determined in full. An overloaded numeric function containing an arithmetic expression as an argument, on the other hand, operates like an arithmetic operator and is handled in its position like an arithmetic expression.
- as an embedded expression in a string template in an arithmetic expression, only the operands of the expression are evaluated.
- as an argument in a constructor expression in an arithmetic expression, the calculation type is determined as in an
assignment. The left side of the assignment is
either the result of the constructor expression with the type
typespecified in front of the parentheses or a structure component.
For operands with complete numeric data types, this data type is used. Operands with other data types are handled as follows:
In the case of operands not specified as data objects, the type is determined as follows:
- In the case of operands specified as non-overloaded integrated functions, the data type of the return value applies.
- Operands belonging to overloaded general numeric
functions, and to the overloaded power function
ipow, are used to determine the calculation type.
- When a floating point function is used, the calculation type is either
- In the case of operands specified as functional method calls, the data type of the return value applies.
- In the case of operands specified as constructor expressions, the data type specified by
- In the case of operands specified as table expressions, the data type of the result applies.
- If operands are specified as generically typed field symbols or formal parameters and an existing variable is used as the target field of an assignment, then these operands (together with the data type) contribute to the calculation type assigned to them at runtime.
- If operands are specified as generically typed field symbols or formal parameters and an inline declaration
DATA(var)is used as the target field of an assignment, the generic types contribute to the statically detectable calculation type (used to determine the data type of the declaration) as follows.
p. If no type with a higher priority is involved, the type
pwith length 8 (no decimal places) is used for the declaration.
- Determining a calculation type before performing the calculation and by taking into consideration all operands including the result field (in the case of an arithmetic expression, as the right side of an
assignment or as an actual parameter) is a special
ABAP feature that differs considerably from the way in which other programming languages perform calculations.
To avoid unnecessary conversions, all operands and one result field should have the same numeric data
type. Another difference is that intermediate results are rounded to whole numbers for calculation type
i; in other programming languages, the decimal places are simply removed.
- In the case of arithmetic expressions used as operands of
relational expressions in
logical expressions joined using
the rule above only ever applies to the relational expression in question. The calculation type is not
determined while skipping the Boolean operators
- If the calculation type is
f, the accuracy is only approximately 15 decimal places and whole numbers are only represented accurately up to an absolute value of 2**53 (that is, 9,007,199,254,740,992). Other intermediate results are rounded. This is especially important when using the operator
**, which can lead to calculation type
fif no decimal floating point number is involved.
- To stop the operator
**producing the calculation type
f, the predefined function
ipowcan be used for integer exponents. Here, the calculation type is determined by the argument.
- The conversion operator
CONVcan be used to convert parts of arithmetic expressions to other types and hence modify the calculation type.
Meaning of the Calculation Type
Before the calculation is made, all operands (where this is required) are converted to the calculation type, in accordance with the conversion rules for elementary data types.
The calculation type determines the calculation method and the calculation accuracy:
- Calculation type
The arithmetic expression is calculated using integer arithmetic, in which each intermediate result that is not an integer (after a division) is rounded to the nearest integer. Each intermediate result must fall within the value range of the data type
i, otherwise this raises the handleable exception CX_SY_ARITHMETIC_OVERFLOW.
- Calculation type
Fixed point arithmetic The arithmetic expression is calculated to an internal accuracy of 31 decimal places and using a special decimal floating point arithmetic for intermediate results. During the calculation, the decimal point for numbers of type
pis not fixed. If an overflow occurs because an intermediate result is greater than 10^31 - 1, the whole expression is recalculated to an internal accuracy of 63 decimal places, or a maximum value of 10^63 -1 for intermediate results. If another overflow occurs, the handleable exception CX_SY_ARITHMETIC_OVERFLOW is raised. An overflow always occurs if the level of accuracy is not sufficient for all decimal places before the decimal separator. Surplus decimal places do not raise an exception, but are rounded to the nearest whole number for each intermediate result.
- Calculation type
The arithmetic expression is calculated using the binary floating point arithmetic of the current platform. Each intermediate result must fall within the value range of the data type
f, otherwise the handleable exception CX_SY_ARITHMETIC_OVERFLOW is raised. Since the decimal places of a floating point number are represented internally using a dual fraction, there is not an exact equivalent for every number that can be represented in the decimal system. This can result in rounding errors in the intermediate results.
- Calculation type
The arithmetic expression is calculated with decimal floating point arithmetic according to norm IEEE-754-2008, where (as for all calculation types) division by 0 does not raise an exception if the dividend is 0. Each intermediate result must fall within the value range of the data type
decfloat34, otherwise the handleable exception CX_SY_ARITHMETIC_OVERFLOW is raised. Intermediate results are rounded to the nearest whole number. The scaling of each intermediate result is defined such that the smallest possible exponent is selected if the result is not precise, and the following procedure is used to determine the scaling if the result is precise:
- For addition and subtraction, the exponent of the result is the smaller of the exponents of the two operands.
- For multiplication, the exponent of the result is the sum of the exponents of the two operands.
- For division, the exponent of the result is the difference between the exponents of the dividend and of the divisor.
- If the
sqrtfunction is used, the exponent is the integer part of half of the exponent of the operand.
Handling the Result
After the calculation is performed, the result of the arithmetic expression is handled as follows:
- in the case of an arithmetic expression as the right side of an assignment statement, the result is converted to the data type of the result field if the calculation type is different.
- in the case of an arithmetic expression as an operand of a relational expression, no conversion takes place, since the calculation type and the comparison type are identical.
- in the case of an arithmetic expression used as an actual parameter for input values of methods,
and if the formal parameter is fully typed, the result is converted into the formal parameter type in
the static method call and passed. If the formal parameter is generically typed, it takes on the calculation type; in the case of calculation type
p, the number of decimal places is determined based on the accuracy required in the calculation.