We've already seen the standard arithmetic operators.
The addition, `+`

, and subtraction, `-`

, operators use full 32-bit integers, but, for efficiency, multiplication, `*`

, and division, `/`

, use restricted values.
You can use `*`

only to multiply 16-bit integers, and the result will be a 32-bit integer.
Similarly, you can use `/`

only to divide a 32-bit integer by a 16-bit integer, and the result will be a 16-bit integer.
The restrictions do not affect most calculations, but if you really need to use all 32-bit integers (and you can cope with overflows, etc.) you can use the `Mul`

and `Div`

functions.
`Mul(a,b)`

corresponds to `a*b`

, and `Div(a,b)`

corresponds to `a/b`

.

We've also met the logic operators `AND`

and `OR`

, which we know are really bit-wise operators.
You can also use the functions `And`

and `Or`

to do exactly the same as `AND`

and `OR`

(respectively).
So, for instance, `And(a,b)`

is the same as `a AND b`

.
The reason for these functions is because there are `Not`

and `Eor`

(bit-wise) functions, too (and there aren't operators for these).
`Not(a)`

swaps one and zero bits, so, for instance, `Not(TRUE)`

is `FALSE`

and `Not(FALSE)`

is `TRUE`

.
`Eor(a,b)`

is the exclusive version of `Or`

and does almost the same, except that `Eor(1,1)`

is 0 whereas `Or(1,1)`

is 1 (and this extends to all the bits).
So, basically, `Eor`

tells you which bits are different, or, logically, if the truth values are different.
Therefore, `Eor(TRUE,TRUE)`

is `FALSE`

and `Eor(TRUE,FALSE)`

is `TRUE`

.

There's a collection of other functions related to maths, logic or numbers in general:

`Abs(`

`expression`)-
Returns the absolute value of
`expression`. The absolute value of a number is that number without any minus sign (i.e., its the size of a number, disregarding its sign). So,`Abs(9)`

is 9, and`Abs(-9)`

is also 9. `Sign(`

`expression`)-
Returns the sign of
`expression`, which is the value one if it is (strictly) positive,*-1*if it is (strictly) negative and zero if it is zero. `Even(`

`expression`)-
Returns
`TRUE`

if`expression`represents an even number, and`FALSE`

otherwise. Obviously, a number is either odd or even! `Odd(`

`expression`)-
Returns
`TRUE`

if`expression`represents an odd number, and`FALSE`

otherwise. `Max(`

`exp1`,`exp2`)-
Returns the maximum of
`exp1`and`exp2`. `Min(`

`exp1`,`exp2`)-
Returns the minimum of
`exp1`and`exp2`. `Bounds(`

`exp`,`minexp`,`maxexp`)-
Returns the value of
`exp`bounded to the limits`minexp`(minimum bound) and`maxexp`(maximum bound). That is, if`exp`lies between the bounds then`exp`is returned, but if it is less than`minexp`then`minexp`is returned or if it is greater than`maxexp`then`maxexp`is returned. This is useful for, say, constraining a calculated value to be a valid (integer) percentage (i.e., a value between zero and one hundred).The following code fragments are equivalent:

y:=Bounds(x, min, max) y:=IF x<min THEN min ELSE IF x>max THEN max ELSE x

`Mod(`

`exp1`,`exp2`)-
Returns the 16-bit remainder (or modulus) of the division of the 32-bit
`exp1`by the 16-bit`exp2`as the regular return value (see 7.4 Multiple Return Values), and the 16-bit result of the division as the first optional return value. For example, the first assignment in the following code sets`a`

to 5 (since 26=(7*3)+5),`b`

to 3,`c`

to*-5*and`d`

to*-3*. It is important to notice that if`exp1`is negative then the modulus will also be negative. This is because of the way integer division works: it simply discards fractional parts rather rounding.a,b:=Mod(26,7) c,d:=Mod(-26,7)

`Rnd(`

`expression`)-
Returns a random number in the range 0 to
*(n-1)*, where`expression`represents the value*n*. These numbers are pseudo-random, so although you appear to get a random value from each call, the sequence of numbers you get will probably be the same each time you run your program. Before you use`Rnd`

for the first time in your program you should call it with a negative number. This decides the starting point for the pseudo-random numbers. `RndQ(`

`expression`)-
Returns a random 32-bit value, based on the seed
`expression`. This function is quicker than`Rnd`

, but returns values in the 32-bit range, not a specified range. The seed value is used to select different sequences of pseudo-random numbers, and the first call to`RndQ`

should use a large value for the seed. `Shl(`

`exp1`,`exp2`)-
Returns the value represented by
`exp1`shifted`exp2`bits to the left. For example,`Shl(%0001110,2)`

is`%0111000`

and`Shl(%0001011,3)`

is`%1011000`

. Shifting a number one bit to the left is generally the same as multiplying it by two (although this isn't true when you shift large positive or large negative values). (The new bits shifted in at the right are always zeroes.) `Shr(`

`exp1`,`exp2`)-
Returns the value represented by
`exp1`shifted`exp2`bits to the right. For example,`Shr(%0001110,2)`

is`%0000011`

and`Shr(%1011010,3)`

is`%0001011`

. For positive`exp1`, shifting one bit to the right is the same as dividing by two. (The new bits shifted in at the left are zeroes if`exp1`is positive, and ones otherwise, hence preserving the**sign**of the expression.) `Long(`

`addr`), Int(`addr`), Char(`addr`)-
Returns the
`LONG`

,`INT`

or`CHAR`

value at the address`addr`. These functions should be used only when setting up a pointer and dereferencing it in the normal way would make your program cluttered and less readable. Use of functions like these is often called**peeking**memory (especially in dialects of the BASIC language). `PutLong(`

`addr`,`exp`), PutInt(`addr`,`exp`), PutChar(`addr`,`exp`)-
Writes the
`LONG`

,`INT`

or`CHAR`

value represented by`exp`to the address`addr`. Again, these functions should be used only when really necessary. Use of functions like these is often called**poking**memory.

Go to the Next or Previous section, the Detailed Contents, or the Amiga E Encyclopedia.