The BBC and Master Computer Public Domain Library

A6CF Floating-Point Multiplication

Submitted by Steve Fewell

Routine:fpmult
Name: Floating-Point Multiplication
Starting Address: &A6CF
Entry criteria: &4A and &4B (the argp) point to a 5-byte Floating-Point variable to multiply the FWB by.
Exit: The FWA contains the normalised result [FWA=argp variable * FWA].

Description:

If FWA is zero, then the result is zero, so just exit.

Unpack the argp variable to the FWB.
If the FWB is zero then call FWA clear routine to return with a zero result.

Add the FWB exponent to the FWA exponent and subtract #&7F (to account for the #&80 offset)
The FWA overflow byte will contain any overflow that occurred.
This gives the results exponent value, so store it in the FWA exponent.

EOR the FWB sign with the FWA sign byte to obtain the sign of the result and store results
sign in the FWA sign byte. (i.e. neg_num * neg_num = pos_num, pos_num * pos_num = pos_num
neg_num * pos_num = neg_num, & pos_num * neg_num = neg_num).

Store X on the stack during the routine (as X contains the next operator?).
Move the FWA Mantissa to locations &42 to &45 (in reverse order), and clear out
FWA mantissa value (to zero). (i.e. &45 = &31; &44 = &32; &43 = &33; &42 = &34).
Zero The FWB Exponent, the FWB Sign and location &3A (these bytes form the leading zeros
during the multiplication.

(A735): Load the next byte (&42 for the first time, as Y = 0 and X = &FC; so load LSB of Mantissa first).
If the byte is not zero then perform the multiply operation with the byte (A705).
Repeat for all bytes (&42 to &45).
When complete, store any rounding in the FWA Rounding Byte, then if the FWA
Mantissa (Result) Byte 1 top bit is 0 then exit via the normalise FWA routine.
Otherwise, just exit as the number is already normalised.

(A705): Performing the multiplication for the current byte:
X is saved to the stack during this routine and retrived at the end, this is so that
the value of X - which is used in the byte loop (above) - is not overwritten.

The multiplication consists of the following steps:
1) Divide the FWB Mantissa by 2 [bytes &3D to &41]
2) Shift the top bit out of the FWA byte we are looking at (Either: &42, &43, &44 or &45, as the FWA Mantissa has been moved to these temporary locations).
--> If the top bit shifted out was 0 then look at the next byte (4).
--> If the top bit shifted out was 1 then add the FWB Mantissa to the results Mantissa (FWA)(?).
Add the corresponding FWB byte to Y [rounding value]. (?)
3) look at the next byte. When the top bit of all 4 bytes is processed then go back to A735 to work with
the next byte.

Example:
FWA = 718.456 [exp = 8A;Man 1 = B3; Man 2 = 9D; Man 3 = 2F; Man 4 = 1B]
FWB = 47.1173 [exp = 86;Man 1 = BC; Man 2 = 78; Man 3 = 1D; Man 4 = 7E]
Result should be 33851.7068888.

Add exponents: 8A + 86 - 7F = 91.

Move FWA to &45 to &42 and zero some fields, So:
?&45 = &B3 [Temp FWA Mantissa 1]
?&44 = &9D [Temp FWA Mantissa 2]
?&43 = &2F [Temp FWA Mantissa 3]
?&42 = &1B [Temp FWA Mantissa 4]
?&41 = &00 [FWB Rounding]
?&40 = &7E [FWB Mantissa 4]
?&3F = &1D [FWB Mantissa 3]
?&3E = &78 [FWB Mantissa 2]
?&3D = &BC [FWB Mantissa 1]
?&3C = &00
?&3B = &00
?&3A = &00

Process next byte [A735]
Y = 0
X = &FC
A = &1B [?&42], not zero so A705.

Process byte ?&42 [A705]:
Divide FWB by 2: [FWB ?&3D = 5E;?&3E = 3C;?&3F = 0E;?&40 = BF;?&41 = 00]
Multiply Byte (&46,X) by 2 [?&42] = &1B * 2 = &36
Top bit wasn't set, so jump to next byte [A731]
A731:
X = X + 1 = &FD.
X not 0 yet so jump to A710
A710: Multiply Byte (&46,X) by 2 [?&43] = &2F * 2 = &5E
Top bit wasn't set, so jump to next byte [A731]
A731: X = X + 1 = &FE.
X not 0 yet so jump to A710
A710: Multiply Byte (&46,X) by 2 [?&44] = &9D * 2 = &3A
Top bit was set, so Add FWB to result:
Y = Y + ?&42,X [?&40]. Y = &BF.
?&34 = ?&34 + &41,X [&3F] = &00 + &0E = &0E
?&33 = ?&33 + &40,X [&3E] = &00 + &3C = &3C
?&32 = ?&32 + &3F,X [&3D] = &00 + &5E = &5E
?&31 = ?&31 + &3E,X [&3C] = &00 + &00 = &00
A731: X = X + 1 = &FF.
X not 0 yet so jump to A710
A710: Multiply Byte (&46,X) by 2 [?&45] = &B3 * 2 = &66
Top bit was set, so Add FWB to result:
Y = Y + ?&42,X [?&41]. Y = &BF + &00 = &BF.
?&34 = ?&34 + &41,X [&40] = &0E + &BF = &CD
?&33 = ?&33 + &40,X [&3F] = &3C + &0E = &4A
?&32 = ?&32 + &3F,X [&3E] = &5E + &3C = &9A
?&31 = ?&31 + &3E,X [&3D] = &00 + &5E = &5E
A731: X = X + 1 = &00.
X is 0, so X = &FC (old value from stack)

Process next byte [A735]
Y = &BF
X = &FC
A = &36 [?&42], not zero so A705.

Process byte ?&42 [A705]:
Divide FWB by 2: [FWB ?&3D = 2F;?&3E = 1E;?&3F = 07;?&40 = 5F;?&41 = 80]
Multiply Byte (&46,X) by 2 [?&42] = &36 * 2 = &6C
Top bit wasn't set, so jump to next byte [A731]
A731:
X = X + 1 = &FD.
X not 0 yet so jump to A710
A710: Multiply Byte (&46,X) by 2 [?&43] = &5E * 2 = &BC
Top bit wasn't set, so jump to next byte [A731]
A731: X = X + 1 = &FE.
X not 0 yet so jump to A710
A710: Multiply Byte (&46,X) by 2 [?&44] = &3A * 2 = &74
Top bit wasn't set, so jump to next byte [A731]
A731: X = X + 1 = &FF.
X not 0 yet so jump to A710
A710: Multiply Byte (&46,X) by 2 [?&45] = &66 * 2 = &CC
Top bit wasn't set, so jump to next byte [A731]
A731:
X = X + 1 = &00.
X is 0, so X = &FC (old value from stack)

Process next byte [A735]
Y = &BF
X = &FC
A = &6C [?&42], not zero so A705.

Process byte ?&42 [A705]:
Divide FWB by 2: [FWB ?&3D = 17;?&3E = 8F;?&3F = 03;?&40 = AF;?&41 = C0]
Multiply Byte (&46,X) by 2 [?&42] = &6C * 2 = &D8
Top bit wasn't set, so jump to next byte [A731]
A731:
X = X + 1 = &FD.
X not 0 yet so jump to A710
A710: Multiply Byte (&46,X) by 2 [?&43] = &BC * 2 = &78
Top bit was set, so Add FWB to result:
Y = Y + ?&42,X [?&3F = 03]. Y = &C2.
?&34 = ?&34 + &41,X [&3E] = &CD + &8F + 1 = &5D
?&33 = ?&33 + &40,X [&3D] = &4A + &17 + 1 = &62
?&32 = ?&32 + &3F,X [&3C] = &9A + &00 = &9A
?&31 = ?&31 + &3E,X [&3B] = &5E + &00 = &5E
A731: X = X + 1 = &FE.
X not 0 yet so jump to A710
A710: Multiply Byte (&46,X) by 2 [?&44] = &74 * 2 = &E8
Top bit wasn't set, so jump to next byte [A731]
A731: X = X + 1 = &FF.
X not 0 yet so jump to A710
A710: Multiply Byte (&46,X) by 2 [?&45] = &CC * 2 = &98
Top bit was set, so Add FWB to result:
Y = Y + ?&42,X [?&41 = C0]. Y = &82.
?&34 = ?&34 + &41,X [&40] = &5D + &AF + 1 = &0D
?&33 = ?&33 + &40,X [&3F] = &62 + &03 + 1 = &66
?&32 = ?&32 + &3F,X [&3E] = &9A + &8F = &29
?&31 = ?&31 + &3E,X [&3D] = &5E + &17 + 1 = &76
A731:
X = X + 1 = &00.
X is 0, so X = &FC (old value from stack)

Process next byte [A735]
Y = &03
X = &FC
A = &D8 [?&42], not zero so A705.

Process byte ?&42 [A705]:
Divide FWB by 2: [FWB ?&3D = 0B;?&3E = C7;?&3F = 81;?&40 = D7;?&41 = E0]
Multiply Byte (&46,X) by 2 [?&42] = &D8 * 2 = &B0
Top bit was set, so Add FWB to result:
Y = Y + ?&42,X [?&3E = C7]. Y = &49.
?&34 = ?&34 + &41,X [&3D] = &0D + &0B + 1 = &19
?&33 = ?&33 + &40,X [&3C] = &66 + &00 = &66
?&32 = ?&32 + &3F,X [&3B] = &29 + &00 = &29
?&31 = ?&31 + &3E,X [&3A] = &76 + &00 = &76
A731:
X = X + 1 = &FD.
X not 0 yet so jump to A710
A710: Multiply Byte (&46,X) by 2 [?&43] = &78 * 2 = &F0
Top bit wasn't set, so jump to next byte [A731]
A731:
X = X + 1 = &FE.
X not 0 yet so jump to A710
A710: Multiply Byte (&46,X) by 2 [?&44] = &E8 * 2 = &D0
Top bit was set, so Add FWB to result:
Y = Y + ?&42,X [?&40 = D7]. Y = &20.
?&34 = ?&34 + &41,X [&3F] = &19 + &81 + 1 = &9B
?&33 = ?&33 + &40,X [&3E] = &66 + &C7 = &2D
?&32 = ?&32 + &3F,X [&3D] = &29 + &0B + 1 = &35
?&31 = ?&31 + &3E,X [&3C] = &76 + &00 = &76
A731: X = X + 1 = &FF.
X not 0 yet so jump to A710
A710: Multiply Byte (&46,X) by 2 [?&45] = &98 * 2 = &30
Top bit was set, so Add FWB to result:
Y = Y + ?&42,X [?&41 = E0]. Y = &00.
?&34 = ?&34 + &41,X [&40] = &9B + &D7 + 1 = &73
?&33 = ?&33 + &40,X [&3F] = &2D + &81 + 1 = &AF
?&32 = ?&32 + &3F,X [&3E] = &35 + &C7 = &FC
?&31 = ?&31 + &3E,X [&3D] = &76 + &0B = &81
A731:
X = X + 1 = &00.
X is 0, so X = &FC (old value from stack)

Process next byte [A735]
Y = &00
X = &FC
A = &B0 [?&42], not zero so A705.

Process byte ?&42 [A705]:
Divide FWB by 2: [FWB ?&3D = 05;?&3E = E3;?&3F = C0;?&40 = EB;?&41 = F0]
Multiply Byte (&46,X) by 2 [?&42] = &B0 * 2 = &60 (Carry 1)
Top bit was set, so Add FWB to result:
Y = Y + ?&42,X [?&3E = E3]. Y = &E3.
?&34 = ?&34 + &41,X [&3D] = &73 + &05 + 0 = &78
?&33 = ?&33 + &40,X [&3C] = &AF + &00 = &AF
?&32 = ?&32 + &3F,X [&3B] = &FC + &00 = &FC
?&31 = ?&31 + &3E,X [&3A] = &81 + &00 = &81
A731:
X = X + 1 = &FD.
X not 0 yet so jump to A710
A710: Multiply Byte (&46,X) by 2 [?&43] = &F0 * 2 = &E0
Top bit was set, so Add FWB to result:
Y = Y + ?&42,X [?&3F = C0]. Y = &A3.
?&34 = ?&34 + &41,X [&3E] = &78 + &E3 + 1 = &5C
?&33 = ?&33 + &40,X [&3D] = &AF + &05 + 1 = &B5
?&32 = ?&32 + &3F,X [&3C] = &FC + &00 = &FC
?&31 = ?&31 + &3E,X [&3B] = &81 + &00 = &81
A731:
X = X + 1 = &FE.
X not 0 yet so jump to A710
A710: Multiply Byte (&46,X) by 2 [?&44] = &D0 * 2 = &A0
Top bit was set, so Add FWB to result:
Y = Y + ?&42,X [?&40 = EB]. Y = &8E.
?&34 = ?&34 + &41,X [&3F] = &5C + &C0 + 1 = &1D
?&33 = ?&33 + &40,X [&3E] = &B5 + &E3 + 1 = &99
?&32 = ?&32 + &3F,X [&3D] = &FC + &05 + 1 = &02
?&31 = ?&31 + &3E,X [&3C] = &81 + &00 + 1 = &82
A731: X = X + 1 = &FF.
X not 0 yet so jump to A710
A710: Multiply Byte (&46,X) by 2 [?&45] = &30 * 2 = &60
Top bit wasn't set, so jump to next byte [A731]
A731:
X = X + 1 = &00.
X is 0, so X = &FC (old value from stack)

Process next byte [A735]
Y = &8E
X = &FC
A = &60 [?&42], not zero so A705.

Process byte ?&42 [A705]:
Divide FWB by 2: [FWB ?&3D = 02;?&3E = F1;?&3F = E0;?&40 = 75;?&41 = F8]
Multiply Byte (&46,X) by 2 [?&42] = &60 * 2 = &C0 (Carry 0)
Top bit wasn't set, so jump to next byte [A731]
A731:
X = X + 1 = &FD.
X not 0 yet so jump to A710
A710: Multiply Byte (&46,X) by 2 [?&43] = &E0 * 2 = &C0 (Carry 1)
Top bit was set, so Add FWB to result:
Y = Y + ?&42,X [?&3F = E0]. Y = &6E.
?&34 = ?&34 + &41,X [&3E] = &1D + &F1 + 1 = &0F
?&33 = ?&33 + &40,X [&3D] = &99 + &02 + 1 = &9C
?&32 = ?&32 + &3F,X [&3C] = &02 + &00 = &02
?&31 = ?&31 + &3E,X [&3B] = &82 + &00 = &82
A731:
X = X + 1 = &FE.
X not 0 yet so jump to A710
A710: Multiply Byte (&46,X) by 2 [?&44] = &A0 * 2 = &40
Top bit was set, so Add FWB to result:
Y = Y + ?&42,X [?&40 = 75]. Y = &E3.
?&34 = ?&34 + &41,X [&3F] = &0F + &E0 + 0 = &EF
?&33 = ?&33 + &40,X [&3E] = &9C + &F1 + 0 = &8D
?&32 = ?&32 + &3F,X [&3D] = &02 + &02 + 1 = &05
?&31 = ?&31 + &3E,X [&3C] = &82 + &00 + 0 = &82
A731: X = X + 1 = &FF.
X not 0 yet so jump to A710
A710: Multiply Byte (&46,X) by 2 [?&45] = &60 * 2 = &C0
Top bit wasn't set, so jump to next byte [A731]
A731:
X = X + 1 = &00.
X is 0, so X = &FC (old value from stack)

Process next byte [A735]
Y = &E3
X = &FC
A = &C0 [?&42], not zero so A705.

Process byte ?&42 [A705]:
Divide FWB by 2: [FWB ?&3D = 01;?&3E = 78;?&3F = F0;?&40 = 3A;?&41 = FC]
Multiply Byte (&46,X) by 2 [?&42] = &C0 * 2 = &80 (Carry 1)
Top bit was set, so Add FWB to result:
Y = Y + ?&42,X [?&3E = 78]. Y = &5B.
?&34 = ?&34 + &41,X [&3D] = &EF + &01 + 1 = &F1
?&33 = ?&33 + &40,X [&3C] = &8D + &00 + 0 = &8D
?&32 = ?&32 + &3F,X [&3B] = &05 + &00 = &05
?&31 = ?&31 + &3E,X [&3A] = &82 + &00 = &82
A731:
X = X + 1 = &FD.
X not 0 yet so jump to A710
A710: Multiply Byte (&46,X) by 2 [?&43] = &C0 * 2 = &80 (Carry 1)
Top bit was set, so Add FWB to result:
Y = Y + ?&42,X [?&3F = F0]. Y = &4B.
?&34 = ?&34 + &41,X [&3E] = &F1 + &78 + 1 = &6A
?&33 = ?&33 + &40,X [&3D] = &8D + &01 + 1 = &8F
?&32 = ?&32 + &3F,X [&3C] = &05 + &00 = &05
?&31 = ?&31 + &3E,X [&3B] = &82 + &00 = &82
A731:
X = X + 1 = &FE.
X not 0 yet so jump to A710
A710: Multiply Byte (&46,X) by 2 [?&44] = &40 * 2 = &80
Top bit wasn't set, so jump to next byte [A731]
A731: X = X + 1 = &FF.
X not 0 yet so jump to A710
A710: Multiply Byte (&46,X) by 2 [?&45] = &C0 * 2 = &80
Top bit was set, so Add FWB to result:
Y = Y + ?&42,X [?&41 = FC]. Y = &47.
?&34 = ?&34 + &41,X [&40] = &6A + &3A + 1 = &A5
?&33 = ?&33 + &40,X [&3F] = &8F + &F0 + 0 = &7F
?&32 = ?&32 + &3F,X [&3E] = &05 + &78 + 1 = &7E
?&31 = ?&31 + &3E,X [&3D] = &82 + &01 + 0 = &83
A731:
X = X + 1 = &00.
X is 0, so X = &FC (old value from stack)

Process next byte [A735]
Y = &09
X = &FC
A = &80 [?&42], not zero so A705.

Process byte ?&42 [A705]:
Divide FWB by 2: [FWB ?&3D = 00;?&3E = BC;?&3F = 78;?&40 = 1D;?&41 = 7E]
Multiply Byte (&46,X) by 2 [?&42] = &80 * 2 = &00 (Carry 1)
Top bit was set, so Add FWB to result:
Y = Y + ?&42,X [?&3E = BC]. Y = &03.
?&34 = ?&34 + &41,X [&3D] = &A5 + &00 + 1 = &A6
?&33 = ?&33 + &40,X [&3C] = &7F + &00 + 0 = &7F
?&32 = ?&32 + &3F,X [&3B] = &7E + &00 = &7E
?&31 = ?&31 + &3E,X [&3A] = &83 + &00 = &83
A731:
X = X + 1 = &FD.
X not 0 yet so jump to A710
A710: Multiply Byte (&46,X) by 2 [?&43] = &80 * 2 = &00 (Carry 1)
Top bit was set, so Add FWB to result:
Y = Y + ?&42,X [?&3F = 78]. Y = &7B.
?&34 = ?&34 + &41,X [&3E] = &A6 + &BC + 0 = &62
?&33 = ?&33 + &40,X [&3D] = &7F + &00 + 1 = &80
?&32 = ?&32 + &3F,X [&3C] = &7E + &00 = &7E
?&31 = ?&31 + &3E,X [&3B] = &83 + &00 = &83
A731:
X = X + 1 = &FE.
X not 0 yet so jump to A710
A710: Multiply Byte (&46,X) by 2 [?&44] = &80 * 2 = &00 (carry 1)
Top bit was set, so Add FWB to result:
Y = Y + ?&42,X [?&40 = 1D]. Y = &98.
?&34 = ?&34 + &41,X [&3F] = &62 + &78 + 0 = &DA
?&33 = ?&33 + &40,X [&3E] = &80 + &BC + 0 = &3C
?&32 = ?&32 + &3F,X [&3D] = &7E + &00 + 1 = &7F
?&31 = ?&31 + &3E,X [&3C] = &83 + &00 + 0 = &83
A731: X = X + 1 = &FF.
X not 0 yet so jump to A710
A710: Multiply Byte (&46,X) by 2 [?&45] = &80 * 2 = &00 (carry 1)
Top bit was set, so Add FWB to result:
Y = Y + ?&42,X [?&41 = 7E]. Y = &16.
?&34 = ?&34 + &41,X [&40] = &DA + &1D + 1 = &F8
?&33 = ?&33 + &40,X [&3F] = &3C + &78 + 0 = &B4
?&32 = ?&32 + &3F,X [&3E] = &7F + &BC + 0 = &3B
?&31 = ?&31 + &3E,X [&3D] = &83 + &00 + 1 = &84
A731:
X = X + 1 = &00.
X is 0, so X = &FC (old value from stack)


?&45, ?&44, ?&43 and ?&42 are all now zero, so we have our result in FWA: Exponent = 90 (after normalisation)
Mantissa 1 = &4 (minus &80 offset)
Mantissa 2 = &3B
Mantissa 3 = &B4
Mantissa 4 = &F8
Mantissa 5 = &16 (set from Y)
Decimal value = 33851.7069

I think this routine uses the "Binary Multiply - Repeated Shift and Add" method for multiplication.
This method is described below:
* Result = 0
* Repeat
*     Shift 2nd multiplicand left until rightmost digit is lined up with leftmost 1 in the
first multiplicand.
*     Add 2nd multiplicand in that position to the result.
*     Remove the 1 from the 1st multiplicand (done when the value is shifted left).
* Until 1st multiplicand is zero * the result has now been obtained

Disassembly for the Floating-Point Multiplication routine