ABAP Keyword Documentation → ABAP − Reference → Obsolete Language Elements → Obsolete Processing of Internal Data → Obsolete Calculation Statements

# COMPUTE

Other versions:
7.31 | 7.40 | **7.54**

## Obsolete Syntax

`COMPUTE `

*[*EXACT*]* lhs =*|*?= rhs.

### Effect

The keyword `COMPUTE`

can be written before every
assignment with an
assignment operator
`=`

or `?=`

, except when an
inline declaration or a
writable expression
is made on the left side. The keyword `COMPUTE`

is ignored by the assignment unless the addition `EXACT`

is specified.

If the addition `EXACT`

is specified, the statement works as follows:

`lhs = EXACT #( rhs ).`

In this case, `COMPUTE`

performs a
lossless calculation in accordance with the same rules as apply when using the
lossless operator `EXACT`

for
arithmetic expression. Only the
simplified arithmetic expressions described
here can be specified for `rhs`

and `lhs`

cannot have the type `f`

. If a rounding raises an exception, the target variable is not modified.

Note

The keyword `COMPUTE`

is a relic and was originally designed for arithmetic calculations where the right side is an arithmetic expression:

`COMPUTE `*[*EXACT*]* result = arith_exp.

Strictly speaking, the statement applies only in this case; more loosely, it applies even if a string expression or bit expression is specified as a different form of calculation expression on the right side.

Alongside the introduction using a calculation expression on the right side, the following variants also exist:

`COMPUTE destination = dobj.`

`dobj`

is specified on the right side, `COMPUTE`

works like an assignment of data objects.
`COMPUTE destination_ref =`

*|*?= source_ref.

`COMPUTE`

works like an up cast or down cast.
`COMPUTE destination = meth( )`

*|*func( )*|*constr_expr

`COMPUTE`

works like an
assignment of return values.
`COMPUTE destination1 = destination2 = ... = destination = rhs.`

`COMPUTE`

works like a multiple assignment.
This means that the keyword `COMPUTE`

does not produce a calculation. More specifically, `COMPUTE`

does not modify the way a
calculation type is chosen:

- When a data object is assigned to a target object, the type of the source object is always converted to the type of the target object, even if prefixed with
`COMPUTE`

.

- When an arithmetic
expression is assigned, the calculation type is always determined from all operands involved, including the left side, even if not prefixed with
`COMPUTE`

.

For this reason, it is not advisable to specify the keyword `COMPUTE`

before
assignments. If the right side is not a calculation expression, the keyword produces false information. If the right side is a calculation expression, the keyword is ignored if specified.

Note

When `COMPUTE`

is used for assignments to
enumerated variables,
addition`EXACT`

and the lossless operator
`EXACT`

have the special effect that they can enable assignments, which otherwise would not have been possible.

### Programming Guideline

Assignments with the assignment operators `=`

and `?=`

only

Example

It is not possible to have the two commented out assignments of a calculation to the
enumerated variable
`num`

. The assignment is possible using `EXACT`

, because in this case the assignment follows the same
rules as the lossless operator displayed underneath.

```
TYPES:
BEGIN OF ENUM number,
n0, n1, n2,
END OF ENUM number.
DATA num TYPE number.
"num = + 1.
COMPUTE EXACT num = + 1.
num = EXACT number( + 1 ).
```