Elite on the BBC Micro and NES

# Maths (Arithmetic): MU11

## [BBC Micro disc version, Flight]

```       Name: MU11                                                    [Show more]
Type: Subroutine
Category: Maths (Arithmetic)
Summary: Calculate (A P) = P * X
Context: See this subroutine in context in the source code
Variations: See code variations for this subroutine in the different versions
References: This subroutine is called as follows:
* SQUA2 calls MU11

Do the following multiplication of two unsigned 8-bit numbers:

(A P) = P * X

This uses the same shift-and-add approach as MULT1, but it's simpler as we
are dealing with unsigned numbers in P and X. See the deep dive on
"Shift-and-add multiplication" for a discussion of how this algorithm works.

.MU11

DEX                    \ Set T = X - 1
STX T                  \
\ We subtract 1 as the C flag will be set when we want
\ to do an addition in the loop below

LDA #0                 \ Set A = 0 so we can start building the answer in A

LDX #8                 \ Set up a counter in X to count the 8 bits in P

LSR P                  \ Set P = P >> 1
\ and C flag = bit 0 of P

\ We are now going to work our way through the bits of
\ P, and do a shift-add for any bits that are set,
\ keeping the running total in A. We just did the first
\ shift right, so we now need to do the first add and
\ loop through the other bits in P

.MUL6

BCC P%+4               \ If C (i.e. the next bit from P) is set, do the
\
\   A = A + T + C
\     = A + X - 1 + 1
\     = A + X

ROR A                  \ Shift A right to catch the next digit of our result,
\ which the next ROR sticks into the left end of P while
\ also extracting the next bit of P

ROR P                  \ Add the overspill from shifting A to the right onto
\ the start of P, and shift P right to fetch the next
\ bit for the calculation into the C flag

DEX                    \ Decrement the loop counter

BNE MUL6               \ Loop back for the next bit until P has been rotated
\ all the way

RTS                    \ Return from the subroutine
```