The BBC and Master Computer Public Domain Library

Floating-Point Division

Submitted by Steve Fewell

Routine: adivb
Name: Floating-Point Division (FWA=FWB/FWA)
Starting Address: &A5FA
Entry criteria: The FWA contains the Divisor and the FWB contains the Dividend.
Exit: The routine evaluates the expression FWB / FWA and puts the resulting Floating-Point number is the FWA.

Description:
Store the sign of the result in the FWA Sign byte [FWB sign EOR FWA sign]. If FWA & FWB signs are different, then the result will be negative, otherwise it will be positive.

Add #&82 to the FWB exponent, to remove the #&80 offset for the exponent. [E.g. 128+130 = 2], rotate the overflow (if FWB was > =1 then there will be an overflow) into the FWA overflow byte (low bit). Subtract the FWA Exponent from the "FWB Exponent + #&82" result to obtain the results exponent [this automatically adds the #&80 again] store the result as the FWA exponent. Decrement the FWA overflow if a borrow occurred during the subtraction. The overflow considerations cater for very large and very small numbers. The FWB exponent - the FWA exponent gives the unnormalised exponent of the result.

This routine uses the Binary Division method known as "Shift and Subtract".
At a higher level, the routine is doing the following:
   * Set the Quotient to 0
   * Align the leftmost digits in the dividend and divisor (already done in BASIC!)
   * Repeat:
      * If the portion of the dividend above the divisor is greater than or equal
      to the divisor then (1)Subtract the divisor from that portion of
      the Dividend and (2) Concatentate 1 to the right hand end of the quotient;
      Otherwise, concatentate 0 to the right hand end of the quotient.
      * Shift the divisor to the right for one bit.
   * Until the dividend is less than the divisor
   * The quotient is correct and the dividend is the remainder.

Description of the Mantissa division:
Initialize some variables: Y = 4 (Number of bytes to process);  ?&3C = 4 (backup of Y);  A = ?&3D (FWB Mantissa byte 1); and X = 8 (Number of bits left in current byte). For speed optimizations, the first byte of the FWB Mantissa is stored in A. The result will be stored in bytes &43 to &46. &3B is temporary storage for the current byte of the Result.

*1) [A622] Compare the FWB Mantissa (bytes 1 to 4) with the FWA Mantissa (stopping when the bytes differ). If the first differing byte in the FWB Mantissa is less than the first differing byte in the FWA Mantissa then [A64F] (FWB < FWA). Multiply the result byte (&3B) by 2 [shift the bits left a place] (this adds a binary 0 to the LSB end of the value) and go on to the next bit (step *3)).

*2) Otherwise, [A638] Subtract the FWA Mantissa (the divisor) from the FWB Mantissa, multiply the result byte (&3B) by 2 [shift the bits left a place] and add 1. (This tags a 1 on to the end of the result). Then go on to the next bit (Step 3).

*3) To move on to the next bit, the bits in the FWB Mantissa are shifted along one position (loosing the most significant bit). X is decremented. [A620] if X is not zero, and the bit that was just lost from the FWB Mantissa was 1, then go to step *2) to subtract and update the result again.

*4) [A620] If X hasn't reached zero then go back to step *1) to process the next bit.

*5) Decrement Y. If Y is less than zero, then jump to step *7) as all of the required bytes have been processed. Otherwise, store the current result byte (&3B), which is now complete in the next result location (that is location &46 for the first byte, &43 for the last byte, as we calculate the result most significant byte first). Next, store Y in &3C [temporary storage during processing of steps *1) to *4)]. Set X to the number of bits that need processing in the next FWB Mantissa byte - for the first 4 bytes, 8 bits are processed, and in the last (least significant) byte, only 2 bits need to be processed. The number of bytes to process is stored in BASIC ROM locations &A5E5 to &A5E8.

*6) [A620] If the bit that was just lost from the FWB Mantissa was 1, then go to step *2) to subtract and update the result again, otherwise go back to step *1) to process the next bit.

*7) Now, all of the bits have been processed, and we have a result, normalise the result [&81F7].
Next exit by rounding the FWA Mantissa to 4 bytes (loosing the rounding byte).

943.34 / 33.33 = 28.3030303030303030303030

FWA = 3333000000  Exponent = 2
FWB = 9433400000  Exponent = 3

*1) FWB > FWA, so do step *2) subtraction ==>
*2) FWB = 91001, Result = Result + 1 = 1
      FWB = 87668, Result = Result + 1 = 2
      FWB = 84335, Result = Result + 1 = 3
      FWB = 81002, Result = Result + 1 = 4
      FWB = 77669, Result = Result + 1 = 5
      FWB = 74336, Result = Result + 1 = 6
      FWB = 71003, Result = Result + 1 = 7
      FWB = 67670, Result = Result + 1 = 8
      FWB = 64337, Result = Result + 1 = 9
      FWB = 61004, Result = Result + 1 = 10
      FWB = 57671, Result = Result + 1 = 11
      FWB = 54338, Result = Result + 1 = 12
      FWB = 51005, Result = Result + 1 = 13
      FWB = 47672, Result = Result + 1 = 14
      FWB = 44339, Result = Result + 1 = 15
      FWB = 41006, Result = Result + 1 = 16
      FWB = 37673, Result = Result + 1 = 17
      FWB = 34340, Result = Result + 1 = 18
      FWB = 31007, Result = Result + 1 = 19
      FWB = 27674, Result = Result + 1 = 20 @
      FWB = 24341, Result = Result + 1 = 21
      FWB = 21008, Result = Result + 1 = 22
      FWB = 17675, Result = Result + 1 = 23
      FWB = 14342, Result = Result + 1 = 24
      FWB = 11009, Result = Result + 1 = 25
      FWB = 07676, Result = Result + 1 = 26
      FWB = 04343, Result = Result + 1 = 27
      FWB = 01010, Result = Result + 1 = 28
*3) FWB = 1010, Result = Result * 10 = 280
*1) FWB < FWA, So Result = Result + Carry [3] = 283,
*3) FWB = 010, Result = Result * 10 = 2830
*1) FWB < FWA, So Result = Result + Carry [3] = 28303,
*3) FWB = 10, Result = Result * 10 = 283030
*1) FWB < FWA, So Result = Result + Carry [3] = 2830303,
*3) FWB = 0, Result = Result * 10 = 28303030.

Result Exponent = FWB Exponent (3) - FWA Exponent (2) + 1 = 2, So result is 28.30303030

This disassembly also contains code that is not used within Floating-Point division.
Code at &A68A is the call point for Floating-Point Minus
Code at &A68D is the call point for Floating-Point Addition
&A68A just compliments the FWA and then continues with Floating-Point Addition.
&A68D Unpacks the variable pointed to by (&2A, &2B) into the FWB and then, if FWB is not zero,
calls the Floating-Point addition routine (&8368).

Disassembly for the Floating-Point Division routine