M	EQU	Byte Ptr 0[BX]
	TITLE	'INTEGER MULTIPLY DIVIDE AND 16-BIT OPERATIONS'
;*****************************************************************************
;                                                                            *
;       16-BIT OPERATIONS                                                    *
;                                                                            *
;*****************************************************************************
;       Revision : Jan. 05, 1983   File "XREG.A86"
	PUBLIC	ABSHL   ;Absolute <HL>
	PUBLIC	NEGHL   ;Negate <HL>
	PUBLIC	SUBDH   ;Subtract <HL> = <DE> - <HL>
	PUBLIC	CMPS    ;Signed Compare <DE> >= <HL> ?
	PUBLIC	CMPDH   ;Binary (unsigned) Compare <DE> >= <HL> ?
	PUBLIC	GETMAX  ;Returns larger value of <hl>, <de> in <hl>
	PUBLIC	GETMIN  ;Returns smaller value of <hl>, <de> in <hl>
	PUBLIC	GETMN0  ;Returns Min (hl,de) or 
			;Zero if Min (hl,de) is a Negative value
	PUBLIC	MUL8    ;<HL> = <HL> * 8
	PUBLIC	MIDH    ;Integer Multiply <HL> = <DE> * <HL>
	PUBLIC	DIDH    ;Integer Devide <HL> = <DE> div <HL>
	PUBLIC	IMOD    ;Integer Mod <HL> = Mod (<DE> div <HL>)
	PUBLIC	MULFRA  ;Fraction Multiply <DE> = <HL> * <DE>
			;         <HL> = Integer, <DE> = Fraction
	PUBLIC	DIVFRA  ;Fraction Devide <DE> = <HL> div <BC>
			;         <HL>/<BC> must be a fraction
;----------------------------------------------------------------------------+
;	ABSHL   ABSOLUTE AND NEGATE FUNCTIONS : BX=ABS(BX), BX=-BX           +
;----------------------------------------------------------------------------+
;Input  :	<BX> source value
;Output :	<BX> the absolute or negative (2's complement) of input value
abshl:	INC	BH			;test positive hl value
	DEC	BH
	JS	L@1
	RET
L@1:
	NEG	BX			;negate BX
	RET
;
;----------------------------------------------------------------------------+
;	SUBDH   SUBTRACT BX FROM DX : BX = DX - BX                           +
;----------------------------------------------------------------------------+
;Input  :	<de> = minuend
;	        <hl> = subtrahend
;Output :	<hl> = result
;		carry = on,  de <  hl
;		      = off, de >= hl
subdh:	MOV	AL,DL
	SUB	AL,BL			;subtract l from e
	MOV	BL,AL			;store partial result
	MOV	AL,DH
	SBB	AL,BH			;subtract h from d
	MOV	BH,AL			;store result
	RET
;
;----------------------------------------------------------------------------+
;	CMPS    COMPARE DE AND HL (SIGNED VALUES <DE> - <HL>)                +
;----------------------------------------------------------------------------+
;Input	:	<de> = value 1
;		<hl> = value 2
;Output :	carry = on,  de <  hl
;		      = off, de >= hl
;               Uses <a>
cmps:
;	Test sing bits
	MOV	AL,DH
	AND	AL,BH
	JNS	cmpj01
;	Both negative
	MOV	AL,DL
	SUB	AL,BL			;subtract l from e
	MOV	AL,DH
	SBB	AL,BH			;subtract h from d
;       if carry set ==> dl > hl
	JNZ	L@2	
	RET				;if de=hl leave carry off
L@2:
	CMC				;complement carry 
	RET
;	Test if both positive or different signs
cmpj01:
	MOV	AL,DH
	OR	AL,BH
	JNS	cmpj02
;	de and hl have different signs : carry off if de>=0 (de>hl)
	XOR	AL,AL
	OR	AL,DH
	JS	L@3
	RET
L@3:
	CMC
	RET				;carry on if hl>=0 (de<hl)
cmpj02:
;	both positive : de-hl sets carry if de<hl
	MOV	AL,DL
	SUB	AL,BL			;subtract l from e
	MOV	AL,DH
	SBB	AL,BH			;subtract h from d
	RET				;carry set for de<hl, off for de>=hl
;----------------------------------------------------------------------------+
;	CMPDH   COMPARE DE AND HL (UNSIGNED BINARY)                          +
;----------------------------------------------------------------------------+
;Input	:	<de> = value 1
;		<hl> = value 2
;Output :	carry = on,  de <  hl
;		      = off, de >= hl
;               zero  = on,  de  = hl
cmpdh:	MOV	AL,DH
	CMP	AL,BH			;compare higher byte d,h
	JZ	L@4	
	RET				;carry set for d<h, carry off for d>h
L@4:
	MOV	AL,DL			;d=h
	CMP	AL,BL			;compare lower byte e,l
	RET				;carry set for e<l, carry off for e>=l
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;                                                                            ;
;   GETMIN  :   RETURNS IN <HL> THE SMALLER VALUE OF <HL> AND <DE>           ;
;                                                                            ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;on entry:	                      
;		values in <BX>, <DX>
;on exit:	Smaller value in <BX>

GETMIN:	CMP	BX,DX
	JNLE	L@5
	RET
L@5:
	MOV	BX,DX
	RET
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;                                                                            ;
;   GETMN0  :   RETURNS IN <HL> THE SMALLER VALUE OF <HL> AND <DE>           ;
;               IF SMALLER  VALUE IS NAGATIVE, THEN RETURNS ZERO             ;
;                                                                            ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;on entry:	                      
;		values in <BX>, <DX>
;on exit:	Smaller value of <BX>, <DX> or zero in <BX>
GETMN0:	CMP	BX,DX
	JLE	GMINJ1
	MOV	BX,DX
GMINJ1:				;Check <BX> < 0 ?
	MOV	AL,BH
	OR	AL,BH
	JS	L@6
	RET
L@6:
	MOV	BX,0
	RET
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;                                                                            ;
;   GETMAX  :   RETURNS IN <BX> THE LARGER VALUE OF <BX> AND <DX>            ;
;                                                                            ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;on entry:	                      
;		values in <BX>, <DX>
;on exit:	larger value in <BX>
GETMAX:	CMP	BX,DX
	JL	L@7
	RET
L@7:
	MOV	BX,DX
	RET
	EJECT
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;                                                                            ;
;               INTEGER MULTIPLICATION <hl> = <hl> * 8                       ;
;                                                                            ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;on entry:	                      
;		<hl> has multiplicant
;on exit:	<hl> has product
;               <a>  used
MUL8:
	PUSH	CX			;Stack <b>
	MOV	CH,3			;Left shift <hl> 3 times
MUL01:
	XOR	AL,AL
	MOV	AL,BL
	RCL	AL,1			;Left shift <hl> Thru carry
	MOV	BL,AL
	MOV	AL,BH
	RCL	AL,1
	MOV	BH,AL
	DEC	CH
	JNZ	MUL01
	POP	CX
	RET
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;                                                                            ;
;               INTEGER MULTIPLICATION                                       ;
;                                                                            ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;on entry:	<de> has multiplicand
;		<hl> has multiplier
;on exit:	<hl> has product
;		<de> has multiplicand
;               <bc> unchanged
;registers used: <a> and flags
;this routine version ensures that the multiplier is
;the smaller of the two operands, so that if either is
;a one byte value, execution time is halved.
;code length: 64 bytes
;execution time: 257 clock cycles (8080) - best case
;		 613 clock cycles (8080) - worst case
;		 539 clock cycles (8080) - typical
midh:
	PUSH	CX			;save <bc>
	MOV	AL,BH			;is <h> less than <d>?
	CMP	AL,DH
	JB	mpy3			;don't exchange if so
	XCHG	BX,DX			;smallest operand now in <hl>
mpy3:
	MOV	CH,BH			;<bc> gets multiplier
	MOV	CL,BL
	MOV	BX,0			;clear partial product
	MOV	AL,CH			;get hi byte of multiplier
	OR	AL,AL			;see if it is zero
	PUSH	CX			;save the multiplier
	JZ	L@8	
	CALL	mpy			;multiply hi byte if non-zero
L@8:
	POP	CX			;get the saved multiplier
	MOV	AL,CL			;now multiply by lo byte
	CALL	mpy
	POP	CX			;Restore <bc>, cleanup stack
	RET
;       Replace this macro to reduce code size
;--------------------------------------------------------------|
;mpy:                                                          |
;	rept	7	;in-line for speed                     |
;	dad	h	;shift partial product                 |
;	ral		;next multiplier bit                   |
;	jnc	$+4	;add multiplicand if...                |
;	dad	d	;...multiplier set                     |
;	endm                                                   |
;	dad	h	;break out of macro on last            |
;	ral		;...iteration so we can do a...        |
;	rnc		;...return instead of jump             |
;	dad	d                                              |
;	ret                                                    |
;--------------------------------------------------------------|
mpy:	MOV	CL,8
mpy1:
	SHL	BX,1
	RCL	AL,1			;next multiplier bit
	JNB	mpy7			;add multiplicand if ...
	LAHF				;... multiplier set
	ADD	BX,DX
	RCR	SI,1
	SAHF
	RCL	SI,1
mpy7:	DEC	CL			;done ?
	JNZ	mpy1
	RET
	EJECT
;
;----------------------------------------------------------------------------+
;       integer divide routine                                               +
;----------------------------------------------------------------------------+
;on entry:	<de> has dividend
;		<hl> has divisor
;on exit:	<hl> has quotient
;               <bc> has remainder
;all registers used
didh:
	MOV	AL,BH
	XOR	AL,DH			;sgn(result) = sgn(op1) xor sgn(op2)
	LAHF				;save sign of result in sign flag
	XCHG	AL,AH
	PUSH	AX
	XCHG	AL,AH
	XOR	AL,DH			;test sign of divisor
	JNS	L@9	
	CALL	neghl			;negate it if neg
L@9:
	XCHG	BX,DX			;divisor to <de>, <hl>=dividend
	MOV	AL,BH
	OR	AL,AL			;test sign of dividend
	JNS	L@10	
	CALL	neghl			;negate dividend if neg
L@10:
;now test for small divisor and/or small dividend and
;take appropriate shortcut
	JZ	id1			;if 1-byte dividend, gen 8 dig quot
	MOV	CH,16			;else 16-bit quotient
	MOV	AL,DH			;is divisor 1-byte value?
	OR	AL,AL
	JNZ	id4			;long-loop if not
	OR	AL,DL			;less than 128? (7-bit value)
	JNS	id5			;short loop if so
id4:	MOV	AL,CH			;<a> counts bits for long-divisor
	MOV	CX,0			;clear remainder
idiv1:	LAHF				;save # digits to go
	XCHG	AL,AH
	PUSH	AX
	SHL	BX,1			;this starts a 32-bit left shift...
	MOV	AL,CL			;... with <hl> as lo order word...
	RCL	AL,1			;and <bc> as hi order word
	MOV	CL,AL			;carry bit communicates between bytes
	MOV	AL,CH
	RCL	AL,1
	MOV	CH,AL
	MOV	AL,CL			;now compare divisor, dividend
	SUB	AL,DL
	MOV	AL,CH
	SBB	AL,DH			;carry bit tells story
	JB	idiv2			;carry set if divisor larger
	MOV	CH,AL			;otherwise subtract divisor...
	MOV	AL,CL			;...from current dividend
	SUB	AL,DL
	MOV	CL,AL
	INC	BX			;increment quotient
idiv2:	POP	AX			;retrieve # digits remaining
	XCHG	AL,AH
	SAHF
	DEC	AL			;one less to go
	JNZ	idiv1			;loop till done
id3:	POP	AX			;get sign of result
	XCHG	AL,AH
	SAHF
	JS	L@11	
	RET				;done if positive
L@11:
neghl:	SUB	AL,AL			;else, negate
	SUB	AL,BL
	MOV	BL,AL
	SBB	AL,BH
	SUB	AL,BL			;remove <l> from hi byte
	MOV	BH,AL
	RET
id1:	MOV	CH,8			;only 8-bit quotient
	MOV	BH,BL			;put 8-bit dividend in <h>
	MOV	BL,AL			;clear <l>
	OR	AL,DH			;<a>=0. test hi divisor
	JNZ	id4			;do long-divisor loop if 2 bytes
	OR	AL,DL			;7-bit value?
	JS	id4			;do long-divisor loop if > 127
id5:	SUB	AL,AL			;clear remainder
id2:	SHL	BX,1			;short divisor loop. next dividend...
	RCL	AL,1			;...bit to <a>
	CMP	AL,DL			;exceeds divisor?
	JB	id6			;don't subtract if not
	SUB	AL,DL			;else subtract divisor
	INC	BX			;update quotient
id6:	DEC	CH			;one less quotient bit to go
	JNZ	id2
	MOV	CL,AL			;remainder to <bc> (<b>=0)
	JMPS	id3			;take care of quotient sign
;routine to return in <hl> the stacked integer modulo
;the integer passed in <hl>.
imod:
	POP	CX			;get return address
	POP	DX			;dividend to <de>
	PUSH	CX			;restore return addr
	CALL	didh			;divide <de> by <hl>, remainder in <bc>
	MOV	BH,CH			;move remainder to <hl>
	MOV	BL,CL
	RET
	EJECT
	TITLE	'FRACTION MULTIPLY AND DIVIDE ROUTINES'
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;                                                                            ;
;  MULFRA : Multiply 16-bits fraction and integer, returns 16-bits result    ;
;                                                                            ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;  Revision : Dec. 15, 1982
;  CALL MULFRA
;    <DE> = Fraction Multiplier
;    <HL> = Integer  Multiplicant
;  RET
;    <HL> = 16-bits Result
;    <BC> = Unchanged
MULFRA:
	PUSH	CX			;Save <bc>
;       test sign of integer, ensure that it is positive before doing
;       the multiplication
	XOR	AL,AL
	OR	AL,BH
;****
;       push    psw     ;Saves the sign for result
;****
	JNS	L@12	
	CALL	neghl			;if negative then make it positive
L@12:
	PUSH	BX
	MOV	CL,16			;do 16-bit multiply
	XOR	AL,AL			;Clear work registers
	MOV	BX,0
FRAL01:	MOV	AL,DH
	RCR	AL,1
	MOV	DH,AL
	MOV	AL,DL
	RCR	AL,1
	MOV	DL,AL
	JNB	NOADD			; No bit, no add.
	MOV	AL,CL			; Save the counter for a moment.
	POP	CX			; Get operator number 2.
	LAHF				; Add this to the temp result.
	ADD	BX,CX
	RCR	SI,1
	SAHF
	RCL	SI,1
	PUSH	CX			; Save op2.
	MOV	CL,AL			; Move the counter back.
NOADD:	MOV	AL,BH
	RCR	AL,1
	MOV	BH,AL
	MOV	AL,BL
	RCR	AL,1
	MOV	BL,AL
	DEC	CL
	JNZ	FRAL01
	JNB	FRAJ01			;If Carry is set, 
	LAHF				;add one to result
	INC	BX
	SAHF
;----------------------------------------------------------------------------+
;       Reset the sign for the result                                        +
;                                                                            +
;       POP     D       ; Op 2 no longer needed                              +
;       POP     PSW     ; the sign of multiplicant                           +
;       CM      NEGHL   ; get correct sign for the result                    +
;       XCHG            ; Move the result to DE.                             +
;                                                                            +
;----------------------------------------------------------------------------+
FRAJ01:
;      clean up stack 
	POP	DX			; Op 2 no longer needed
	POP	CX			; Restore <bc> register
	RET
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;                                                                            ;
;  DIVFRA : Fractional Divide 2 16-bit integers, returns fractional result   ;
;                                                                            ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;  CALL DIVFRA
;    <HL> = DIVIDEND, must be smaller than the divisor
;    <BC> = DIVISOR
;  RET
;    <DE> = The Fraction result
DIVFRA:
;       make both operands positive
	CALL	abshl			; set dividend positive
	PUSH	BX
	MOV	BH,CH
	MOV	BL,CL
	CALL	abshl			; set divisor positive
	MOV	CH,BH
	MOV	CL,BL
	POP	BX
	MOV	AL,16			; hl/bc => de   (must be a fraction)
	LAHF
	XCHG	AL,AH
	PUSH	AX
	MOV	DX,0			;clear work register
divl01:	XCHG	BX,DX
	SHL	BX,1			; temp=temp*2
	XCHG	BX,DX
	SHL	BX,1
	MOV	AL,BL
	SUB	AL,CL
	MOV	BL,AL
	MOV	AL,BH
	SBB	AL,CH
	MOV	BH,AL
	JNB	gezero			; op1-op2 >= 0
	ADD	BX,CX
	JMPS	divj02
gezero:	INC	DX
divj02:	POP	AX
	XCHG	AL,AH
	SAHF
	DEC	AL
	LAHF
	XCHG	AL,AH
	PUSH	AX
	JNZ	divl01
	POP	AX			; clear the junk
	XCHG	AL,AH
	SAHF
	RET
	END