www.riscos.com Technical Support: 

The computer treats any number which is preceded by an & sign as a hexadecimal (hex) number.
Whereas decimal numbers can contain ten separate digits, from 0 to 9, hexadecimal numbers can contain sixteen separate digits, 0 to 9 and A to F. The first 16 hexadecimal numbers and their decimal equivalents are given below:
Hex  Decimal  Hex  Decimal 

&0  0  &8  8 
&1  1  &9  9 
&2  2  &A  10 
&3  3  &B  11 
&4  4  &C  12 
&5  5  &D  13 
&6  6  &E  14 
&7  7  &F  15 
The next hexadecimal number is &10 which is equivalent to 16 in decimal notation. Thus, in hexadecimal notation, one in a column represents a power of sixteen rather than a power of ten. For example, &100 represents 256 which is 162.
You can enter numbers in binary notation, i.e. in base 2, by preceding them with the percent sign %.
Binary numbers consist entirely of the digits 0 and 1. The following table gives the binary equivalents of the decimal values 1 to 10.
Binary  Decimal  Binary  Decimal 

%1  1  %110  6 
%10  2  %111  7 
%11  3  %1000  8 
%100  4  %1001  9 
%101  5  %1010  10 
A one in a particular column represents a power of two:
2^{7}  2^{6}  2^{5}  2^{4}  2^{3}  2^{2}  2^{1}  2^{0} 
128  64  32  16  8  4  2  1 
Thus:
%1000101 = 1*64 + 0*32 + 0*16 + 0*8 + 1*4 + 0*2 + 1*1 = 69
Binary digits are usually referred to as bits.
There are three operators which act upon the 32 bits of an integer, shifting it either left or right by a given number of places.
The simplest shift is <<. This shifts the bits of an integer to the left by a given number of places and inserts zeros in the righthand bits. For example:
A% = 10 B% = A% << 1 C% = A% << 2 D% = A% << 3
This leaves the variables with the following values:
Variable  Value 

A%  10 (%00000000000000000000000000001010) 
B%  20 (%00000000000000000000000000010100) 
C%  40 (%00000000000000000000000000101000) 
D%  80 (%00000000000000000000000001010000) 
The >>> operator shifts the bits of an integer to the right a given number of times, losing the bits which were in those positions and introducing zeros at the left. For example:
A% = %1010 B% = A% >>> 1 C% = A% >>> 2 D% = A% >>> 3
This leaves the variables with the following values:
Variable  Value 

A%  10 (%00000000000000000000000000001010) 
B%  5 (%00000000000000000000000000000101) 
C%  2 (%00000000000000000000000000000010) 
D%  1 (%00000000000000000000000000000001) 
The >> operator is similar to >>>, but instead of introducing zeros at the top at each stage, the leftmost bit is set to either one or zero depending on what the current setting is. The leftmost bit of an integer is normally used to indicate whether the integer is positive (leftmost bit = zero) or negative (leftmost bit = one). Consequently, this operator can be used to perform a division by a power of two on a number, retaining its sign. For example:
A = 1610612740 B = 536870912
A% = %10100000000000000000000000000000 B% = %00100000000000000000000000000000 C% = A% >>> 2 D% = B% >>> 2 E% = A% >> 2 F% = B% >> 2
This leaves the variables with the following binary values:
Variable  Value 

C%  %001010000000000000000000000000000 (671088640) 
D%  %000010000000000000000000000000000 (134217728) 
E%  %111010000000000000000000000000000 (402653184) 
F%  %000010000000000000000000000000000 (134217728) 
The left shift operator can perform multiplication. The expression val<<n is equivalent to val * 2^n. So fred<<3 is the same as fred*8. Although using shift can be faster than the equivalent multiply, you should bear in mind that bits may be shifted off the end of the number, so leading to incorrect results which will not be trapped as errors. For example, &10000<<16 yields 0, whereas the correct 'multiply' result is &100000000 (which cannot be represented in a 32bit integer, and would be converted to floating point by BASIC).
The two right shift operators perform a similar role in division. The >> operator gives division of 'signed' numbers by a power of two. This means that both positive and negative numbers may be divided; the result is always rounded towards the integer less than or equal to the exact value. For example, 3>>1 is the same as INT(3/2)=2, not 3 DIV 2, which is 1. The >>> operator ignores the sign when shifting negative numbers, so should only be used to divide positive numbers by a power of two.
The operators AND, OR and EOR produce a result which depends upon the bits of two integer operands:
Inputs  AND  OR  EOR  

0  0  0  0  0 
0  1  0  1  1 
1  0  0  1  1 
1  1  1  1  0 
For example:
A% = %1010 B% = %1100 C% = A% AND B% D% = A% OR B% E% = A% EOR B%
This leaves the variables with the following values:
Variable  Value 

A%  10 (%1010) 
B%  12 (%1100) 
C%  8 (%1000) 
D%  14 (%1110) 
E%  6 (%0110) 
The logical operators AND, OR and EOR are symmetrical, like + and *. Thus X AND Y = Y AND X for all possible values of X and Y. This applies to the other two operators as well.
The truth values TRUE and FALSE have the values 1 and 0 respectively. This means that:
TRUE AND TRUE gives TRUE (1 AND 1 = 1) TRUE AND FALSE gives FALSE (1 AND 0 = 0) FALSE AND FALSE gives FALSE ( 0 AND 0 = 0)
TRUE OR TRUE gives TRUE (1 OR 1 = 1) TRUE OR FALSE gives TRUE (1 OR 0 = 1) FALSE OR FALSE gives FALSE ( 0 OR 0 = 0)
TRUE EOR TRUE gives FALSE (1 EOR 1 = 0) TRUE EOR FALSE gives TRUE (1 EOR 0 = 1) FALSE EOR FALSE gives FALSE ( 0 EOR 0 = 0)