 
Mathematics in another way
Many articles have been written about the mathpack which is incorporated in the mainrom of any MSX computer. I found some routines which can be made easily and a lot faster in assembly. The routine IADD (i.e. HL=DE+HL) can be done with just one assembly instruction: ADD HL,DE but to be conform to what IADD does an EX DE,HL has to be added. The routine ISUB (i.e. HL=DEHL) can be done in very much the same way, with the only exception the register exchange is necessary. The routines IMULT (i.e. HL=DE*HL, the routine published here isn’t the fastest multiplication routine though) and IDIV (i.e. HL=DE\HL) are included in this little source as well and note that IMOD (i.e. HL=DE MOD HL) uses the same routine as IDIV, with the exception the modulus is returned in HL:
MLlisting:
MATHPACK.ASM 
IADD: EX DE,HL ; HL = DE + HL
ADD HL,DE
RET
ISUB: EX DE,HL ; HL = DE  HL
AND A ; Reset Carry
SBC HL,DE
RET
IMULT: EX DE,HL ; HL = DE * HL
PUSH HL ; Keep for subtraction later
PUSH HL ; Counter
POP BC
IMLTLP: ADD HL,DE ; ADD DE to HL BC times
DEC BC
LD A,B ; Check if counter reached zero
OR C
JR NZ,IMLTLP
POP DE ; Result is DE too high
SBC HL,DE ; so correct this
RET
IDIV: EX DE,HL ; HL = DE \ HL
LD A,E ; Division by zero?
OR D
JR NZ,IDIVDO ; Continue of not
LD HL,0
LD DE,0
SCF ; Set Carry to indicate an error
RET
IDIVDO: LD C,L ; AC = HL
LD A,H
LD HL,0 ; HL = Modulus
LD B,16 ; 16bit division
OR A ; Start with carry reset
IDIVLP: RL C ; AC = AC * 2
RLA ; (set Carry to bit 0)
RL L ; HL = HL * 2
RL H ; (reset Carry again (HL = 0))
PUSH HL
SBC HL,DE
CCF ; Carry set when Ok
JR C,IDIVDN ; Modulus cannot be >= Value
EX (SP),HL ; Restore Modulus
IDIVDN: INC SP ; Get Modulus from Stack
INC SP
DJNZ IDIVLP ; Repeat for all bits
; Shift last Carrybit to divider
EX DE,HL ; DE = Modulus
RL C ; Carry to C
LD L,C ; HL = AC
RLA
LD H,A
OR A ; Reset Carry (valid result)
RET
IMOD: CALL IDIV ; HL = DE MOD HL
EX DE,HL ; Modulus in HL
RET



Explanations
The source contains 5 major calls which result in 4 routines. The first two are addition and subtraction. Because of the simplicity of these routines explaining how these work would be nonsense now. The routines for multiplication, division and modulus mathematics are explained right now.
Multiplication using IMULT
There are a few methods for multiplying one value with another. In a way, two methods are explained in this first Assembly Line. The first method is quite simple to make and understand. I agree on the fact there are methods which are much faster and a second and faster solution will be provided in the next Assembly Line. In here I have taken a rather lazy approach. The routine actually does DE * HL  DE. That is because I didn’t reset one of the register pairs first. We need to multiply 123 with 234. The routine does the following, a step by step explanation: We make 123 a counter which is usually put in BC. The loop does HL = HL + DE exactly 123 times, so HL = 123 + 234, so HL = 357. Then HL = 357 + 234, so HL = 581. Then HL = 581 + 234, so HL = 815 and after 123 times the result in HL would be 28905 because we started with 123 already in HL. So to correct the result we need to subtract 123 from HL. HL will become 28782.
Division using IDIV
Just like multiplication there are a few methods to divide a value from another and in a way, two methods are explained in this first Assembly Line. First, we check whether we are going to attempt an illegal division by zero. According to correct math only 1 division by zero is legal, but not tested in this routine.
Modulus using IMOD
For IMOD the exact same routine is called like IDIV and by swapping DE and HL the modulus result is written in HL. For more information about the actual division routine, read “Division using IDIV”.
The source of IDIV and IMOD can be found right with the following reference [1] as the original file doesn’t have these routines.
More math appeared with the MSX turbo R, which contains two very useful instructions to do very fast multiplication: MULUB and MULUW. Note that both instructions are located in the R800 processor and the Z80 processor still needs routines to do the multiplication part. MULUB needs two 8bit registers as input and the 16bit result is output in HL. MULUW is a bit different. It needs two 16bit registers as input and the 32bit result is output to registers DE and HL (format DEHL). Clicking on the instruction the Z80 equivalents of MULUB A,B (reference [2]) and MULUW HL,BC (reference [3]) can be found. Both routines check whether they are running on Z80 or R800 CPU, so both the R800 instruction as the Z80 routine which does the same multiplication are included in both sources including the check. I am aware of the fact a little bug remains in the Z80 equivalent of MULUW HL,BC.
Another way of dividing
Referring to a telephone conversation I once had with Jan van der Meer — who has passed away a few years ago — of a way to divide a number by 6 the easy way, he came up with a different solution to divide two bytes by each other. The source can be found in this reference [4] and in a nutshell, this is how it works: the routine subtracts the divider from the value you want the value from until you reach 0 or a value which lies below the divider. This will be the modulus. The result is the number of times the divider could go into the value.
MSX Assembly Page
A lot has happened between the release of the last two issues of MCCW. A dedicated website for MSX assembly programmers (either current or future ones) has become a quite worthy place with resources, articles, sources, downloads and links to other pages which have info about MSX assembly quite useful to programmers. Together with the MSX Resource Center development forum the MSX Assembly Page will be the most valuable to all MSX assembly programmers. There is also an MSX development IRC channel. Information and the channel location, as well as a CGI:IRC client to it is available at MSX Banzai!.
I hope to meet many developers on the MSX development IRC channel. I also think we can help each other with a variety of programming problems and solutions, faster routines and other MSX development related issues.
A short note from the editors:
This article isn’t finished at all. We think that it lacks a thorough explanation of what is going on. The author did not have time to improve it, though. It may be beneficial to very experienced MSX programmers anyway. Of course I do not need to mention that there will be no Assembly Line part 2 and beyond.
