Normalization routine

We have already studied the normalization routine ("nrm2x") in the floating point article. In this routine the number is set up in normalized form (mantissa and exponent).

There are 2 normalization processes :

- left scaling (shift to the left and decrease exponent), in the case of non significant zeros (nrm23),

shift left a[w]
c - 1 -> c[x] 

On exit, we go to nrm24, address 02317 ; in the case of A register = 0 control may fall through nrm24, putting a zero in register C.

- right scaling (shift to the right and increase exponent) in the case of “fraction overflow” (nrm24)

Routine nrm24’s task is right scaling. We have a fraction overflow when an addition exceeds the 10 bits length of the mantissa, and we have to a shifting right and a rounding to register A fraction part.

In this case, the least significant digit of the number in register A occupies the digit reserved for the exponent sign. So if we double the A exponent, we will have an overflow in fraction part sign.

This is the task of the 3 first lines of nrm24 and of the label "mpy28" in the floating point multiplication code:

nrm24: a -> b[x]
a + b -> a[w]
if a[s] >= 1 then go to mpy28

1) Floating point 4 operations.

Let’s take the example of the subtraction of 10 - .0000000004

On entry in routine “nrm24” the registers are:

02326: .1..1.1.1.          nrm24:               a -> b[x]
A=09999999999600  B=00000000000600  C=00000000000000
D=00000000000000  M=00000000000000  P=c  S=0.....678..b

Then, we double register A exponent and the A fraction part sign byte becomes “1” signalling thus the “fraction overflow”.

02327: 111...111.                   a + b -> a[w]

A=10000000000200  B=00000000000600  C=00000000000000
D=00000000000000  M=00000000000000  P=c  S=0.....678..b

In this case, we branch to “mpy28” and after one shift right of A and one exponent increment of C, we exit thru nrm21, etc.

02334: ....1.111.                     0 -> b[w]

A=01000000000001  B=00000000000000  C=01000000000001
D=00000000000000  M=00000000000000  P=c  S=0.....678..b

The end of normalization is quite simple (see flow chart):

The whole result (fraction part and exponent) is placed in C ( a exchange c[m] ) then in A
( c -> a[w] ) and B finally is zeroed ( 0 -> b[w] ).

nrm26: if s2 = 0 then go to rtn21

     return
rtn21:   select rom 1                 ; goto rtn11

rtn11:   if s1 = 0  then go to rtn12
            return
rtn12:   select rom 0                 ; goto 00333
00333:            jsb of13
....

The process will call next the output format routine (jsb of13) whose task is to create mask and display registers (see the "output format" article) and to end in the display and waiting loop.

2) Other math routines.

The same scheme is used in the other math routines (see the relevant article for details).
Let’s have a look at the trace of the logarithm algorithm:
 

After the ln computation, control goes to “nrm21” to normalized the result, before bailing out to rtn21 (the “2” mean Rom 2) and then to “rtn12” and finally to address 333 where a call is issued to format the output context before ending at address 367 “fst2zx” to call “dsp1”.

Let’s take now the example of the square root routine, where the same path is followed, but via the relay “tnm12”. 

Finally, in the exponential routine e^x same process, exception made of the inter ROMs relays used.     

J. Laporte
Monday, 27 February 2006