# Forth-eV Wiki

### Webseiten-Werkzeuge

projects:4th_lesson_5

#### Lesson 5

```\       Lesson 5 - Numbers
\       The Forth Course
\          Dept. of Computer Science and Engineering
\          Oakland University, Rochester, MI 48309
comment:

Lesson 5

NUMBERS

5.1  DOUBLE NUMBERS                     5-2

5.2  DOUBLE COMPARISON OPERATORS        5-4

5.3  MULTIPLICATION AND DIVISION        5-5

5.4  FLOORED DIVISION                   5-6

5.5  16-BIT OPERATORS                   5-9

5.6  DOUBLE NUMBER MULTIPLICATION       5-11

5.7  EXERCISES                          5-12

5.1  DOUBLE NUMBERS

A double number is a 32-bit integer that is stored as two 16-bit
words on the stack with the HI-word on top of the stack as follows:

___________
| HI-word | <---top of stack
|---------|
| LO-word |
|---------|

The stack picture of a double number will be indicated as

( d -- )

A double number is entered from the keyboard by including a decimal
point anywhere in the number.  For example, if you type

1234.56

the integer value 123456 which is equal to the hex value 1E240
will be stored in the top two words of the stack as follows:

___________
| 0 0 0 1 | <---top of stack
|---------|
| E 2 4 0 |
|---------|

The variable DPL will contain the number of places after the decimal
point, 2 in this case.

The Forth word D. can be used to print the value of a double
number on the screen.  Thus, if after entering 1234.56 you type D.
the value 123456 will be printed on the screen.

The following are some double number words:

D+      ( d d -- dsum )
Add two double numbers leaving a double sum.

DNEGATE ( d -- d )
Change the sign of a double number.

S>D     ( n -- d )
Sign extend a single number to a double number.

DABS    ( d -- d )
Take the absolute value of a double number.

D2*     ( d -- d*2 )
32-bit shift left -- multiply d by 2.

D2/     ( d -- d/2 )
32-bit shift right -- divide d by 2.

DMIN    ( d1 d2 -- d3 )
d3 is the lesser of d1 and d2.

DMAX    ( d1 d2 -- d3 )
d3 is the greater of d1 and d2.

D-      ( d1 d2 -- d1-d2 )
Subtract two double numbers leaving a double difference.

Note: the definition of D- is

: D-    DNEGATE D+ ;

?DNEGATE        ( d1 n -- d2 )
If n < 0 then DNEGATE d1.

Note: the definition of ?DNEGATE is

: ?DNEGATE      ( d1 n -- d2 )
0<
IF
DNEGATE
THEN ;

5.2  DOUBLE COMPARISON OPERATORS

The following are the definitions of comparison operators for
double numbers:

: D0=           ( d -- f )        \ flag is TRUE if d = 0
OR 0= ;

: D=            ( d1 d2 -- f )    \ flag is TRUE if d1 = d2
D- D0= ;

: DU<           ( ud1 ud2 -- f )  \ flag is TRUE if ud1 < ud2
ROT SWAP                \ ud1L ud2L ud1H ud2H
2DUP U<                 \ ud1L ud2L ud1H ud2H f
IF                      \ ud1L ud2L ud1H ud2H
2DROP 2DROP TRUE     \ f
ELSE
<>                   \ ud1L ud2L f
IF                   \ ud1L ud2L
2DROP FALSE       \ f
ELSE
U<                \ f
THEN
THEN ;

: D<            ( d1 d2 -- f )    \ flag is TRUE if d1 < d2
2 PICK                  \ d1L d1H d2L d2H d1H
OVER =                  \ d1L D1H D2L D2H f
IF                      \ d1L D1H D2L D2H
DU<                  \ f
ELSE
NIP ROT DROP         \ D1H D2H
<                    \ f
THEN ;

: D>            ( di d2 -- f )    \ flag is TRUE if d1 >= d2
2SWAP
D< ;

5.3  MULTIPLICATION AND DIVISION

The basic multiplication and division operations upon which all
other multiplication and division words are based are

UM*     ( un1 un2 -- ud )
UM* multiplies the unsigned 16-bit integer un1 by the
unsigned 16-bit integer un2 and returns the unsigned
32-bit product ud.  This word uses the 8088/8086 MUL
instruction.

UM/MOD  ( ud un -- urem uquot )
UM/MOD divides the unsigned 32-bit integer ud by the 16-bit
unsigned integer un and returns the unsigned quotient uquot
and the unsigned remainder urem.  This word uses the
8088/8086 DIV instruction.  If the high-word of ud is
greater than or equal to un then the quotient will not fit
in 16 bits.  Under these conditions the 8088/8086 DIV
instruction would produce a "Divide by zero" trap error.
The Forth word UM/MOD checks for this case and returns a
hex value of FFFF for both the quotient and remainder if
the quotient is too large to fit in 16 bits.

The following F-PC word will multiply two signed 16-bit integers and
leave a 32-bit signed product.

: *D            ( n1 n2 -- d )
2DUP XOR >R             \ save sign of product
ABS SWAP ABS
UM*                     \ unsigned multiply
R> ?DNEGATE ;           \ fix sign

The following F-PC word will divide an unsigned 32-bit integer by
a 16-bit unsigned integer and leave an unsigned 16-bit remainded
and a 32-bit unsigned quotient.  This word will not have the
overflow problem of UM/MOD.

: MU/MOD        ( ud un -- urem udquot )
>R 0 R@                 \ udL udH 0 un
UM/MOD                  \ udL remH quotH
R>                      \ udL remH quotH un
SWAP >R                 \ udL remH un
UM/MOD                  \ remL quotL
R> ;                    \ remL quotL quotH

5.4  FLOORED DIVISION

The two signed division words

/MOD    ( n1 n2 -- rem quot )

M/MOD   ( d n1 -- rem quot )

perform floored division.  Type the following four examples and
try to predict what will be displayed on the screen.

26 7 /MOD . .

-26 7 /MOD . .

26 -7 /MOD . .

-26 -7 /MOD . .

The results can be summarized as follows:

Dividend  Divisor   Quotient   Remainder

26       7          3           5
-26       7         -4           2
26      -7         -4          -2
-26      -7          3          -5

Did you expect these results?  The second and third results may
seem strange to you, but they are ok because all we need is the
divisor times the quotient plus the remainder to be equal to
the dividend.  Note that

3 *  7 + 5 =  26
-4 *  7 + 2 = -26
-4 * -7 - 2 =  26
3 * -7 - 5 = -26

This is called floored division and is characterized by the sign
of the remainder being the same as the sign of the divisor.

This is not the only way to do division.  In fact, the 8088/8086
IDIV instruction does NOT do floored division.  In this case
the sign of the remainder is the same as the sign of the dividend
and the magnitude of the quotient is always the same.

To see this define the following code word that uses the IDIV
instruction:
comment;
PREFIX
CODE ?M/MOD
POP  BX
POP  DX
POP  AX
IDIV BX
2PUSH
END-CODE

comment:
Now type

26 7 ?M/MOD . .

-26 7 ?M/MOD . .

26 -7 ?M/MOD . .

-26 -7 ?M/MOD . .

These new results can be summarized as follows:

Dividend  Divisor   Quotient   Remainder

26       7          3           5
-26       7         -3          -5
26      -7         -3           5
-26      -7          3          -5

Note that in this case the divisor times the quotient plus the
remainder is still equal to the dividend.  Although you might
like the looks of this version of division rather than the floored
division, the floored division has the advantage of resolving an
ambiguity around zero.  To see this, try the following.

Floored division
3  4 /MOD . .   0  3
-3  4 /MOD . .  -1  1
3 -4 /MOD . .  -1 -1
-3 -4 /MOD . .   0 -3

Non-floored division
3  4 ?M/MOD . .   0  3
-3  4 ?M/MOD . .   0 -3
3 -4 ?M/MOD . .   0  3
-3 -4 ?M/MOD . .   0 -3

Note that the non-floored division can not tell the difference
between 3 4 ?M/MOD and 3 -4 ?M/MOD or between -3 4 ?M/MOD and
-3 -4 ?M/MOD.

Here is how M/MOD is defined:

: M/MOD         ( d n -- rem quot )
?DUP                    \ return d if n = 0
IF                      \ dL dH n
DUP >R               \ save n
2DUP XOR >R          \ save sign
>R                   \ dL dH
DABS R@ ABS          \ |dL dH| |n|
UM/MOD               \ urem uquot
SWAP R>              \ uquot urem n
?NEGATE              \ uquot rem (sign=divisor)
SWAP R>              \ rem uquot xor
0<
IF                   \ rem uquot
NEGATE            \ rem quot
OVER              \ rem quot rem
IF                \ rem quot
1-             \ floor quot toward -infinity
R@             \ rem quot n
ROT -          \ quot floor.rem = n - rem
SWAP           \ rem quot
THEN
THEN
R> DROP
THEN ;

/MOD could then defined as follows:

: /MOD          ( n1 n2 -- rem quot )
>R S>D R>
M/MOD ;

F-PC actually defines /MOD as a code word which uses IDIV
followed by a flooring of the remainder and quotient.

5.5  16-BIT OPERATORS

The following is the way that the arithmetic operators that operate
on 16-bit numbers and leave 16-bit results could be defined.
Actually, F-PC defines many of these as equivalent code words
for speed.

: *             ( n1 n2 -- n )  \ signed multiply
UM* DROP ;

Although this may seem strange, it is true that
if you simply throw away the high word of an
unsigned 32-bit product you will get the correct
16-bit signed answer.  Of course, the product
must be in the range -32768 to +32767.

: /             ( n1 n2 -- n )  \ signed division
/MOD NIP ;

: MOD           ( n1 n2 -- rem )
/MOD DROP ;

: */MOD         ( n1 n2 n3 -- rem n1*n2/n3 )
>R                      \ n1 n2
*D                      \ n1*n2 (32-bit product)
R>                      \ n1*n2 n3
M/MOD ;                 \ rem quot

Note that the quotient is equal to n1*n2/n3
where the intermediate product n1*n2 retains
32 bits.

: */            ( n1 n2 n3 -- n1*n2/n3 )
*/MOD NIP ;

Suppose you would like to compute n1*n2/n3 rounded to the nearest
integer.  We can write

n1*n2/n3 = Q + R/n3

where Q is the quotient and R is the remainder.  To round we add
1/2 to the fractional part of the answer.  That is,

n1*n2/n3 = Q + R/n3 + 1/2

which we can write as

n1*n2/n3 = Q + (2*R + n3)/2*n3

We can then define */R to compute n1*n2/n3 rounded as follows:
comment;

: */R           ( n1 n2 n3 -- n1*n2/n3 rounded )
DUP 2SWAP               \ n3 n3 n1 n2
ROT                     \ n3 n1 n2 n3
*/MOD                   \ n3 R Q
-ROT 2*                 \ Q n3 2*R
OVER +                  \ Q n3 2*R+n3
SWAP 2*                 \ Q 2*R+n3 2*n3
/ + ;

comment:

5.6  DOUBLE NUMBER MULTIPLICATION

Sometimes it is necessary to multiply a double number (32-bits)
by a single number (16-bits) and obtain a double number result.
Of course, in general, if you multiply a 32-bit number by a
16-bit number you could get as much as a 48-bit product.  However,
in many cases you will know that the result can't exceed 32-bits,
even though it will be greater than 16-bits.

Suppose that A, B, C, D, E, F and G are 16-bit numbers.  Then we
can represent the multiplication of the 32-bit number A:B by the
16 bit number C as follows:

A      B
-----  -----
C
X           -----
___________________________

D      E
-----  -----
G      F
-----  -----
___________________________

pH      pL
-----  -----

In this diagram, multiplying B times C gives the 32-bit result D:E.
Multiplying A times C gives the 32-bit result G:F.  Adding these
two partial products, shifted by 16-bits as shown, will produce
the complete 48-bit product.  However, we are going to drop the G
and limit the result to 32 bits.  The low word of this product
will be pL = E and the high word will be pH = D + F.  Therefore,
we can define the following word to do this multiplication.
comment;

: DUM*          ( ud un -- ud )
DUP                     \ B A C C
ROT                     \ B C C A
*                       \ B C F
-ROT                    \ F B C
UM*                     \ F E D
ROT                     \ E D F
+ ;                     \ pL pH

comment:
5.7  EXERCISES

5.1  An imaging system uses a video camera to measure the volume of
ball bearings.  The system measures the diameter of the ball
bearings in terms of pixel counts.  The maximum pixel count
(corresponding to a diameter) is 256.  The system is adjusted
so that 100 pixels corresponds to 1 cm.  The ball bearings
measured with this device range in diameter from 0.25 to 2.5 cm.

Write a Forth word called VOLUME that will expect a diameter in
pixel counts on the stack and will leave the volume of the ball
bearing, rounded to the nearest cubic mm, on the stack.

Note:  The volume of a sphere is (4/3)*pi*R**3 where R is the
radius and pi can be appoximated (to better than 7 places)
by 355/113.

Test your program with the following values of the diameter:

25      50      100     150     200     250

comment;

```
projects/4th_lesson_5.txt · Zuletzt geändert: 2013-06-06 21:27 (Externe Bearbeitung)

### Seiten-Werkzeuge 