ABAP Keyword Documentation →  ABAP − Reference →  Processing Internal Data →  Numeric Calculations

# arith_exp - Arithmetic Expressions

Other versions: 7.31 | 7.40 | 7.54

## Syntax

``````
... [+|-] operand1
[{+|-||/|DIV|MOD|} [+|-] operand2
[{+|-||/|DIV|MOD|**} [+|-] operand3
... ]] ...
``````

### Effect

An arithmetic expression expresses a calculation. The result of an arithmetic expression is a numeric value of the calculation type assigned to the arithmetic expression. In an arithmetic expression `arith_exp`, the arithmetic operators `+`, `-`, , `/`, `DIV`, `MOD`, or `*` can be used to join an operand `operand1` with one or more operands `operand2`, `operand3` ... Brackets are also possible. The calculation is made in accordance with calculation rules specified by the calculation type in question.

Arithmetic expressions can occur in the reading positions of certain statements, in particular on the right side of an assignment with the assignment operator `=`. When used as the operand of the lossless operator `EXACT`, an arithmetic expression can be checked for a lossless calculation.

The operand positions `operand` are general expression positions, which means that numeric data objects, built-in functions, functional methods, or compound arithmetic expressions can be specified. The arithmetic operators `+`, `-`, , `/`, `DIV`, `MOD`, and `*` join two adjacent operands. When the expression is evaluated, a numeric value is calculated and associated with the next adjacent operand. The priority of this join depends on the operators used.

Each operand can be preceded by the signs `+` or `-`, in any order and separated by one or more blanks. The effect of using a sign is the same as specifying the expression +1 * or `-1 *` in its place, which means that a sign has the same priority as a multiplication.

If functional methods or character-like expressions are specified as operands, they are specified from left to right and from inside to outside before the remainder of the expression is evaluated. The return values are buffered to be used in the corresponding operand positions. Here, character-like processing functions and string expressions are only possible as arguments of description functions.

Notes

• It must be noted whether the value of a data object that is also used as an operand is changed in a specified functional method. Even if an operand of this type precedes the functional method, its value will always be changed by the method before it is evaluated.
• Arithmetic expressions, string expressions, and bit expressions cannot be combined. Built-in functions that are used as operands for arithmetic expressions can, however, contain string expressions or bit expressions as arguments.
• If an arithmetic expression is specified as an argument of one of the overloaded numeric functions, the entire function works like an arithmetic expression.
• A simple arithmetic expression `+|- literal` comprising an operator `+|-`, blank, and an unsigned numeric literal `literal` has the same value as the corresponding numeric literal `+|-literal` prefixed directly with a sign. The expression is handled like an expression, however, and never evaluated before runtime, which means that the numeric literal should always be used in these cases for performance reasons.

Example

The following program excerpt computes the hyperbolic sine with the Eulerian formula in the explicit calculation type `decfloat34` and with the built-in function `sinh` in calculation type `f` and displays the difference.

``````REPORT kellerh_test1.

TYPES:
BEGIN OF line,
x       TYPE string,
result1 TYPE string,
result2 TYPE string,
diff    TYPE string,
END OF  line.
DATA
output TYPE TABLE OF line WITH EMPTY KEY.

DO 2001 TIMES.
TRY.
DATA(x) = sy-index - 1001.
DATA(result1) = CONV decfloat34(
( exp( x ) - exp( -1 * x ) ) / 2 ).
DATA(result2) =  sinh( x ).
DATA(diff)    =  abs( result1 - result2 ).
IF diff <> 0.
APPEND VALUE #(
x       = |{ x }|
result1 = |{ result1 STYLE = SCIENTIFIC }|
result2 = |{ result2 STYLE = SCIENTIFIC }|
diff    = |{ diff    STYLE = SCIENTIFIC }| ) TO output.
ENDIF.
CATCH cx_sy_conversion_overflow cx_sy_arithmetic_overflow.
ENDTRY.
ENDDO.
cl_demo_output=>display( output ).
``````

### Handleable Exceptions

CX_SY_ARG_OUT_OF_DOMAIN

• Cause: Illegal argument in powers
Runtime error: `COMPUTE_POW_DOMAIN`

CX_SY_ARITHMETIC_OVERFLOW

• Cause: Overflow in arithmetic operation (type `p`)
Runtime error: `BCD_OVERFLOW`
• Cause: Overflow in arithmetic operation (all operands type `p`)
Runtime error: `COMPUTE_BCD_OVERFLOW`
• Cause: Overflow in `cosh`
Runtime error: `COMPUTE_COSH_OVERFLOW`
• Cause: Overflow or underflow in `exp`
Runtime error: `COMPUTE_EXP_RANGE`
• Cause: Overflow in addition (type `decfloat`)
Runtime error: `COMPUTE_DECFLOAT_ADD_OVERFLOW`
• Cause: Overflow in subtraction (type `decfloat`)
Runtime error: `COMPUTE_DECFLOAT_SUB_OVERFLOW`
• Cause: Overflow in multiplication (type `decfloat`)
Runtime error: `COMPUTE_DECFLOAT_MUL_OVERFLOW`
• Cause: Overflow in division (type `decfloat`)
Runtime error: `COMPUTE_DECFLOAT_DIV_OVERFLOW`
• Cause: Overflow in division (type `decfloat`)
Runtime error: `COMPUTE_DECFLOAT_DIV_OVERFLOW`
• Cause: Overflow in division (type `f`)
Runtime error: `COMPUTE_FLOAT_DIV_OVERFLOW`
• Cause: Overflow in subtraction (type `f`)
Runtime error: `COMPUTE_FLOAT_MINUS_OVERFLOW`
• Cause: Overflow in addition (type `f`)
Runtime error: `COMPUTE_FLOAT_PLUS_OVERFLOW`
• Cause: Overflow in multiplication (type `f`)
Runtime error: `COMPUTE_FLOAT_TIMES_OVERFLOW`
• Cause: Overflow in |-2147483648|
Runtime error: `COMPUTE_INT_ABS_OVERFLOW`
• Cause: Integer overflow in division
Runtime error: `COMPUTE_INT_DIV_OVERFLOW`
• Cause: Integer overflow after subtraction
Runtime error: `COMPUTE_INT_MINUS_OVERFLOW`
• Cause: Integer overflow while adding
Runtime error: `COMPUTE_INT_PLUS_OVERFLOW`
• Cause: Integer overflow in multiplication
Runtime error: `COMPUTE_INT_TIMES_OVERFLOW`
• Cause: Invalid call of `log10`
Runtime error: `COMPUTE_LOG10_ERROR`
• Cause: Invalid call of `log`
Runtime error: `COMPUTE_LOG_ERROR`
• Cause: Overflow or underflow in powers
Runtime error: `COMPUTE_POW_RANGE`
• Cause: Overflow in `sinh`
Runtime error: `COMPUTE_SINH_OVERFLOW`
• Cause: Overflow in function `round` or `rescale`
Runtime error: `COMPUTE_ROUND_RESCALE_OVERFLOW`

CX_SY_CONVERSION_NO_NUMBER

• Cause: Operand cannot be interpreted as a number
Runtime error: `CONVT_NO_NUMBER`

CX_SY_CONVERSION_OVERFLOW

• Cause: Overflow in arithmetic operation (type `p`, with specified length)
Runtime error: `BCD_FIELD_OVERFLOW`
• Cause: Operand too big or (interim) result too big
Runtime error: `CONVT_OVERFLOW`

CX_SY_PRECISION_LOSS

• Cause: Result of `cos` not exact
Runtime error: `COMPUTE_COS_LOSS`
• Cause: Result of `sin` not exact
Runtime error: `COMPUTE_SIN_LOSS`
• Cause: Result of `tan` not exact
Runtime error: `COMPUTE_TAN_LOSS`

CX_SY_UNSUPPORTED_FUNCTION

• Cause: Invalid function for calculation type `decfloat34`
Runtime error: `COMPUTE_UNSUPPORTED_DECF_FUNC`

CX_SY_ZERODIVIDE

• Cause: Division by 0 (type `p`)
Runtime error: `BCD_ZERODIVIDE`
• Cause: Division by 0 (type `f`)
Runtime error: `COMPUTE_FLOAT_ZERODIVIDE`
• Cause: Division by 0 (types (`b`, `s`), `i`, `int8`)
Runtime error: `COMPUTE_INT_ZERODIVIDE`
• Cause: Division by 0 (type `decfloat`)
Runtime error: `COMPUTE_DECFLOAT_ZERODIVIDE`

### Non-Handleable Exceptions

• Cause: `p` field does not contain the correct BCD format
Runtime error: `BCD_BADDATA`
• Cause: `p` field does not contain a correct sign
Runtime error: `BCD_NO_SIGN`

### Continue

arith_exp - Arithmetic Operators

arith_exp - ( )

arith_exp - Calculation Type and Calculation Rules

arith_exp - Lossless Calculations