math.z80

; this source file contains some math routines
; fast: decoding note codes, 8*8 multiplication (for vibrato and fractional note lengths), 16/8 division (for glissando)
; small: 24*24, 32*24, 16*32, 24*16, 16/8, 40*8, 40/24 (used by cpuspeed.z80) (not all of them are used anymore, but they're all macros so it doesn't matter)
; also: fasmg float^integer exponentiation, used in cpuspeed.z80

; input:
;  C: note code ($XY as defined in format.asm) (range is not checked)
; output:
;  HL: frequency
; destroys:
;  AF,B=0
decode_note:
  ld a,c
  and $f0
  rrca
  rrca
  rrca
  add a,general_tuning and $00ff
  ld l,a
  ld h,general_tuning shr 8
  ld a,[hl]
  inc l
  ld h,[hl]
  ld l,a

  ld a,11
  sub c
  and $0f
  ld b,a
.loop:
  srl h
  rr l
  djnz .loop
  ret nc
  inc hl
  ret


; input:
;  B: note code
; output:
;  A: frequency
; destroys:
;  F,B,HL
macro decode_note_bass
  local not_less_rshift,loop,after

  ld a,b
  and $f0
  rrca
  rrca
  rrca
  rrca
  cp bass_lowest
  jr nc,not_less_rshift
  dec b
not_less_rshift:
  add a,bass_tuning and $00ff
  ld l,a
  ld h,bass_tuning shr 8
  ld l,[hl]

  ld a,b
  dec a
  and $0f
  ld b,a
  ld a,l
  jq z,after

loop:
  srl a
  djnz loop
  adc a,0

after:
end macro


; E * H -> HL
e_mul_h:
  ld d,0
  sla h
  sbc a,a
  and e
  ld l,a
repeat 6
  add hl,hl
  jr nc,$+3
  add hl,de
end repeat
  add hl,hl
  ret nc
  add hl,de
  ret


; inputs:
;  A: diff
;  HL: base freq
; outputs:
;  HL: A * HL >> 11
; destroys:
;  AF, BC=0, DE
; 400-490cc
calc_vib_diff:
  ex de,hl
  ld bc,$0800
  ld l,c
  ld h,c

.loop:
  add hl,hl
  rla
  jr nc,.not_add
  add hl,de
  adc a,c
.not_add:
  djnz .loop

  ld l,a
  ld a,h
  ld h,l
  srl h
  rra
  srl h
  rra
  srl h
  rra
  ld l,a
  ret nc
  inc hl
  ret



;hl_div_c:
;  ld b,16
;  add hl,hl
;  ld a,h
;  jr c,.overflow
;.loop:
;  cp c
;  jr c,.zero
;  sub c
;  inc l
;.zero:
;  sla l
;  rla
;  jr c,.overflow
;  djnz .loop

; HL / B -> 
hl_div_b:
  add hl,hl
  ld a,h
  jr c,.2_0
repeat 7
  cp b
  jr c,$+4
  sub b
  inc l

  sla l
  rla
  jr c,.2_#%
.1_#%:
end repeat
  cp b
  ret c
  sub b
  inc l
  ret

.2_0:
repeat 7
  sub b
  rl l
  rla
  jr nc,.1_#%
.2_#%:
end repeat
  sub b
  inc l
  ret


;hl_div_c:
;  ld b,16
;  xor a
;.loop:
;  add hl,hl
;  rla
;  jr c,.overflow
;  cp c
;  jr c,.nofit
;.overflow:
;  inc l
;  sub c
;.nofit:
;  djnz .loop
;  ret

; 24*24 multiplication (29 bytes, 1631-2639cc)
; input:
;  IYLDE, HLC, 24-bit operands
; outputs:
;  HLCAIX: output
; destroys:
;  F, B=0
macro iylde_mul_hlc
  local no_carry,loop

  ld ix,0
  xor a
  ld b,24
loop:
  add ix,ix
  adc a,a
  rl c
  adc hl,hl
  jq nc,no_carry
  add ix,de
  adc a,iyl
  jq nc,no_carry
  inc b
  jq nz,no_carry
  inc hl
no_carry:
  djnz loop

end macro

; 32*24 multiplication (38 bytes, 1706-3194cc)
; input:
;  CDE: 24-bit number
;  DE'BC: 32-bit number
; output:
;  C'DE'HL'HL: 56-bit result
;  DEBC': 32-bit input
; destroys:
;  F, B=0
macro de_mul_debc
  local loop,no_carry,no_add

  ld hl,0
  exx
  ld hl,0
  ld b,24

loop:
  add hl,hl
  exx
  adc hl,hl
  rl e
  rl d
  rl c
  exx
  jq nc,no_add

  add hl,de
  exx
  adc hl,bc
  jq nc,no_carry
  inc e
  jq nz,no_carry
  inc d
  jq nz,no_carry
  inc c
no_carry:
  exx
no_add:

  djnz loop
end macro

; 16*32 multiplication (30 bytes, 2608-4048cc)
; input:
;  BC: 16-bit number
;  DEHL: 32-bit number
; output:
;  DEHLIX: 48-bit number
; destroys:
;  A=0, F
macro bc_mul_dehl
  local loop,no_carry,no_add

  ld a,32
  ld ix,0

loop:
  add ix,ix
  adc hl,hl
  rl e
  rl d
  jq c,no_add

  add ix,bc
  jq nc,no_carry
  inc l
  jq nz,no_carry
  inc h
  jq nz,no_carry
  inc de
no_carry:
no_add:

  dec a
  jq nz,loop
end macro

; 24*16 multiplication (25 bytes, 979-1475cc)
; input:
;  IYL-DE, HL: operands
; output:
;  HL-A-IX
; destroys:
;  B=0, F
macro iylde_mul_hl
  local loop,no_carry,no_add
  ld ix,0
  xor a
  ld b,16
loop:
  add ix,ix
  rla
  adc hl,hl
  jr nc,no_add
  add ix,de
  adc a,iyl
  jr nc,no_carry
  inc hl
no_carry:
no_add:
  djnz loop
; adc hl,hl TODO: why tf was this here
end macro

; 16/8 division (18 bytes, 774-870cc)
; input:
;  HL, C
; output:
;  HL: result
;  A: remainder
; destroys:
;  B=0,F
macro hl_div_c
  local loop,too_big,no_sub

  ld b,16
  xor a
loop:
  add hl,hl
  rla
  jr c,too_big
  cp c
  jr c,no_sub
too_big:
  sub c
  inc l
no_sub:
  djnz loop
end macro

; 40*8 multiplication (35 bytes, 688-1080cc)
; input:
;  BBC'HL, C
; output:
;  CAHL'IX
; destroys:
;  swaps shadows
;  D=0,F
macro bBChl_mul_c
  local loop,no_carry,no_add

  xor a
  ld ix,0
  exx
  ld l,a
  ld h,a

  ld d,8
loop:
  ex af,af'

  add ix,ix
  adc hl,hl
  rla
  exx
  rl c
  jr nc,no_add
  add ix,hl
  exx
  adc hl,bc
  exx
  add a,b
  jr nc,no_carry
  inc c
no_carry:
no_add:
  exx
  dec d
  jr nz,loop
end macro

; 40/24 division (44 bytes, 2922-3630cc)
; input:
;  CHLIX, IYL-DE'
; output:
;  CHLIX, AHL'
; destroys:
;  B=0,F
macro chlix_div_iylDE
  local loop,yes_sub,too_big

  ld b,24
  exx
  xor a
  ld l,a
  ld h,a
  exx

loop:
  add ix,ix
  inc ixl
  adc hl,hl
  rl c
  exx
  adc hl,hl
  rla

  jr c,too_big

  sbc hl,de
  sbc a,iyl
  jr nc,yes_sub
  add hl,de
  adc a,iyl
  dec ixl
yes_sub:
  exx
  djnz loop
  jr done

too_big:
  sbc hl,de
  sbc a,iyl
  exx
  djnz loop

done:
end macro




macro exp_float_int base*,exponent*,return*
  local result,unit,exp
  unit = base
  result = 1
  exp = exponent

  if exp < 0
    exp = -exp
  end if

  while exp > 0
    if exp and 1 = 1
      result = result * unit
    end if
    unit = unit * unit
    exp = exp shr 1
  end while

  exp = exponent
  if exp < 0
    result = 1 / result
  end if

  return := result
end macro