Contents Prev Next Up

# Arithmetic Instructions

isub
lsub
fsub
dsub
imul
lmul
fmul
dmul
idiv
ldiv
fdiv
ddiv
imod
lmod
fmod
dmod
ineg
lneg
fneg
dneg

```..., value1, value2 => ..., result
```
value1 and value2 should be integers. The values are added and are replaced on the stack by their integer sum.

```..., value1-word1, value1-word2, value2-word1, value2-word2 => ..., result-word1, result-word2
```
value1 and value2 should be long integers. The values are added and are replaced on the stack by their long integer sum.

```..., value1, value2 => ..., result
```
value1 and value2 should be single precision floating point numbers. The values are added and are replaced on the stack by their single precision floating point sum.

```..., value1-word1, value1-word2, value2-word1, value2-word2 => ..., result-word1, result-word2
```
value1 and value2 should be double precision floating point numbers. The values are added and are replaced on the stack by their double precision floating point sum.

### isub

Integer subtract

```..., value1, value2 => ..., result
```
value1 and value2 should be integers. value2 is subtracted from value1, and both values are replaced on the stack by their integer difference.

### lsub

Long integer subtract

```..., value1-word1, value1-word2, value2-word1, value2-word2 => ..., result-word1, result-word2
```
value1 and value2 should be long integers. value2 is subtracted from value1, and both values are replaced on the stack by their long integer difference.

### fsub

Single float subtract

```..., value1, value2 => ..., result
```
value1 and value2 should be single precision floating point numbers. value2 is subtracted from value1, and both values are replaced on the stack by their single precision floating point difference.

### dsub

Double float subtract

```..., value1-word1, value1-word2, value2-word1, value2-word2 => ..., result-word1, result-word2
```
value1 and value2 should be double precision floating point numbers. value2 is subtracted from value1, and both values are replaced on the stack by their double precision floating point difference.

### imul

Integer multiply

```..., value1, value2 => ..., result
```
value1 and value2 should be integers. Both values are replaced on the stack by their integer product.

### lmul

Long integer multiply

```..., value1-word1, value1-word2, value2-word1, value2-word2 => ..., result-word1, result-word2
```
value1 and value2 should be long integers. Both values are replaced on the stack by their long integer product.

### fmul

Single float multiply

```..., value1, value2 => ..., result
```
value1 and value2 should be single precision floating point numbers. Both values are replaced on the stack by their single precision floating point product.

### dmul

Double float multiply

```..., value1-word1, value1-word2, value2-word1, value2-word2 => ..., result-word1, result-word2
```
value1 and value2 should be double precision floating point numbers. Both values are replaced on the stack by their double precision floating point product.

### idiv

Integer divide

```..., value1, value2 => ..., result
```
value1 and value2 should be integers. value1 is divided by value2, and both values are replaced on the stack by their integer quotient.

The result is truncated to the nearest integer that is between it and 0. An attempt to divide by zero results in a "/ by zero" ArithmeticException being thrown.

### ldiv

Long integer divide

```..., value1-word1, value1-word2, value2-word1, value2-word2 => ..., result-word1, result-word2
```
value1 and value2 should be long integers. value1 is divided by value2, and both values are replaced on the stack by their long integer quotient.

The result is truncated to the nearest integer that is between it and 0. An attempt to divide by zero results in a "/ by zero" ArithmeticException being thrown.

### fdiv

Single float divide

```..., value1, value2 => ..., result
```
value1 and value2 should be single precision floating point numbers. value1 is divided by value2, and both values are replaced on the stack by their single precision floating point quotient.

Divide by zero results in the quotient being NaN.

### ddiv

Double float divide

```..., value1-word1, value1-word2, value2-word1, value2-word2 => ..., result-word1, result-word2
```
value1 and value2 should be double precision floating point numbers. value1 is divided by value2, and both values are replaced on the stack by their double precision floating point quotient.

Divide by zero results in the quotient being NaN.

### imod

Integer mod

```..., value1, value2 => ..., result
```
value1 and value2 should both be integers. value1 is divided by value2, and both values are replaced on the stack by their integer remainder.

An attempt to divide by zero results in a "/ by zero" ArithmeticException being thrown.

### lmod

Long integer mod

```..., value1-word1, value1-word2, value2-word1, value2-word2 => ..., result-word1, result-word2
```
value1 and value2 should both be long integers. value1 is divided by value2, and both values are replaced on the stack by their long integer remainder.

An attempt to divide by zero results in a "/ by zero" ArithmeticException being thrown.

### fmod

Single float mod

```..., value1, value2 => ..., result
```
value1 and value2 should both be single precision floating point numbers. value1 is divided by value2, and the quotient is truncated to an integer, and then multiplied by value2. The product is subtracted from value1.The result, as a single precision floating point number, replaces both values on the stack. That is, result = value1 - ((int)(value1/value2)) * value2.

An attempt to divide by zero results in NaN.

### dmod

Double float mod

```..., value1-word1, value1-word2, value2-word1, value2-word2 => ..., result-word1, result-word2
```
value1 and value2 should both be double precision floating point numbers. value1 is divided by value2, and the quotient is truncated to an integer, and then multiplied by value2. The product is subtracted from value1.The result, as a double precision floating point number, replaces both values on the stack. That is, result = value1 - ((int)(value1/value2)) * value2.

An attempt to divide by zero results in NaN.

### ineg

Integer negate

```..., value => ..., result
```
value should be an integer. It is replaced on the stack by its arithmetic negation.

### lneg

Long integer

negate

```..., value-word1, value-word2 => ..., result-word1, result-word2
```
value should be a long integer. It is replaced on the stack by its arithmetic negation.

### fneg

Single float negate

```..., value => ..., result
```
value should be a single precision floating point number. It is replaced on the stack by its arithmetic negation.

### dneg

Double float negate

```..., value-word1, value-word2 => ..., result-word1, result-word2
```
value should be a double precision floating point number. It is replaced on the stack by its arithmetic negation.

Contents Prev Next Up

Generated with CERN WebMaker