WikiTI - User contributions [en]

83Plus:BCALLs:4012

2010-07-30T06:14:16Z

Quigibo: /* Comments */

[[Category:83Plus:BCALLs:By Name:Math|DivHLByA]] [[Category:83Plus:BCALLs:By Name|DivHLByA]] [[Category:83Plus:BCALLs:By Address|4012 - DivHLByA]]
== Synopsis ==
'''Official Name:''' DivHLByA

'''BCALL Address:''' 4012

Divides the value in HL by the value in A.

=== Inputs ===
* HL: integer
* A: integer

=== Outputs ===
* HL = HL / A
* A = HL mod A

=== Registers Destroyed ===
* none

== Comments ==
Simple enough to implement if speed is important. However, it may return invalid results if A is larger than 127 since the routine does not correctly handle overflows.

== Example ==
ld hl,13
ld a,5
B_CALL DivHLByA ;should return HL=2, A=3

Category:83Plus:Quirks

2010-07-21T21:45:01Z

Quigibo:

{{stub}}

The TI-83+ family of calculators has some interesting quirks in the hardware.

*The calculator will crash if PC is greater than or equal to C000, provided an even-numbered RAM page is swapped in the upper bank. This is the default (page 80h). This is where the 8kb limit comes from
*Later models of calculators are missing RAM pages
*Later models of calculators have a longer LCD delay
*If a LD A,I or LD A,R instruction is interrupted, then the P/V flag is reset, even if interrupts were enabled beforehand.

Z80 Routines:Math:Multiplication

2010-07-03T19:33:21Z

Quigibo: /* 16*16 multiplication */

[[Category:Z80 Routines:Math|Multiplication]]
[[Category:Z80 Routines|Multiplication]]

== Introduction ==

All these routines use the restoring multiplication algorithm, adapted to the z80 architecture to maximize speed.
They can easily be unrolled to gain some speed.

== Unsigned versions ==

=== 8*8 multiplication ===

The following routine multiplies h by e and places the result in hl

<nowiki>
mult_h_e
ld l, 0
ld d, l

sla h ; optimised 1st iteration
jr nc, $+3
ld l, e

ld b, 7
_loop:
add hl, hl
jr nc, $+3
add hl, de

djnz _loop

ret
</nowiki>

=== 16*8 multiplication ===

The following routine multiplies de by a and places the result in ahl (which means a is the most significant byte of the product, l the least significant and h the intermediate one...)

<nowiki>
mult_a_de
ld c, 0
ld h, c
ld l, h

add a, a ; optimised 1st iteration
jr nc, $+4
ld h,d
ld l,e

ld b, 7
_loop:
add hl, hl
rla
jr nc, $+4
add hl, de
adc a, c ; yes this is actually adc a, 0 but since c is free we set it to zero and so we can save 1 byte and up to 3 T-states per iteration

djnz _loop

ret
</nowiki>

=== 16*16 multiplication ===

The following routine multiplies bc by de and places the result in dehl.

<nowiki>
mult_de_bc
ld hl, 0

sla e ; optimised 1st iteration
rl d
jr nc, $+4
ld h, b
ld l, c

ld a, 15
_loop:
add hl, hl
rl e
rl d
jr nc, $+6
add hl, bc
jr nc, $+3
inc de

dec a
jr nz, _loop

ret
</nowiki>

== Signed versions ==



=== 8*8 multiplication ===

=== 16*8 multiplication ===

Z80 Routines:Math:Multiplication

2010-07-03T19:33:05Z

Quigibo: /* 16*16 multiplication */ It is actually less T states and the same size to do ld hl,0 than ld h,0 / ld l,h

[[Category:Z80 Routines:Math|Multiplication]]
[[Category:Z80 Routines|Multiplication]]

== Introduction ==

All these routines use the restoring multiplication algorithm, adapted to the z80 architecture to maximize speed.
They can easily be unrolled to gain some speed.

== Unsigned versions ==

=== 8*8 multiplication ===

The following routine multiplies h by e and places the result in hl

<nowiki>
mult_h_e
ld l, 0
ld d, l

sla h ; optimised 1st iteration
jr nc, $+3
ld l, e

ld b, 7
_loop:
add hl, hl
jr nc, $+3
add hl, de

djnz _loop

ret
</nowiki>

=== 16*8 multiplication ===

The following routine multiplies de by a and places the result in ahl (which means a is the most significant byte of the product, l the least significant and h the intermediate one...)

<nowiki>
mult_a_de
ld c, 0
ld h, c
ld l, h

add a, a ; optimised 1st iteration
jr nc, $+4
ld h,d
ld l,e

ld b, 7
_loop:
add hl, hl
rla
jr nc, $+4
add hl, de
adc a, c ; yes this is actually adc a, 0 but since c is free we set it to zero and so we can save 1 byte and up to 3 T-states per iteration

djnz _loop

ret
</nowiki>

=== 16*16 multiplication ===

The following routine multiplies bc by de and places the result in dehl.

<nowiki>
mult_de_bc
ld hl,0

sla e ; optimised 1st iteration
rl d
jr nc, $+4
ld h, b
ld l, c

ld a, 15
_loop:
add hl, hl
rl e
rl d
jr nc, $+6
add hl, bc
jr nc, $+3
inc de

dec a
jr nz, _loop

ret
</nowiki>

== Signed versions ==



=== 8*8 multiplication ===

=== 16*8 multiplication ===

Z80 Routines:Math:Logarithm

2010-06-17T20:32:42Z

Quigibo:

[[Category:Z80 Routines:Math|Logarithm]]
[[Category:Z80 Routines|Logarithm]]

= Introduction =

== Integer Log of base 2 ==

<nowiki>
; input: hl (16-bit integer unsigned)
; output: a = log2(hl) (rounded down and from -1 to 15) (8-bit integer signed)
log2:
ld a,16
scf
log2loop:
adc hl,hl
dec a
jr nc,log2loop
ret
</nowiki>

== Integer Log of base 10 ==

Since log10=log2(hl)/log2(10).
We can multiply by 1/log2(10).
<nowiki>

</nowiki>

== Integer Log of base B ==

The same trick as above.
<nowiki>
;unfinished
logB:
; input: hl = number
; b = base
; output: a = log hl base b

ret
</nowiki>