Квадратный корень на i8080

[shoorick]

Тем временем реализовал деление на 10 сдвигами:

unsigned divu10(unsigned n) {
   unsigned q, r;
   q = (n >> 1) + (n >> 2);
   q = q + (q >> 4);
   q = q + (q >> 8);
   q = q + (q >> 16);
   q = q >> 3;
   r = n - q*10;
   return q + ((r + 6) >> 4);
// return q + (r > 9);
}

-- отсюда

Скрытый текст

;=======================================================================
;   HL [A] = HL/10  
;-----------------------------------------------------------------------
proc udiv10
;-----------------------------------------------------------------------
    ora  a
    mov  a,h
    rar   
    mov  b,a
    mov  a,l
    rar
    mov  c,a ; bc = n >> 1
    ora  a
    mov  a,b
    rar
    mov  d,a
    mov  a,c
    rar
    add  c
    mov  e,a
    mov  c,a
    mov  a,d
    adc  b
    mov  b,a
    mov  d,a       ; bc = de = (hl>>1)+(hl>>2) = q
    xchg           ; de = n ; bc = hl = q
    xra  a
    call shr_hl.s4 ; hl = q >> 4 
    dad  b         ; hl = q = q + (q>>4)
    mov  c,h
    mvi  b,0
    dad  b         ; hl = q = q + (q>>8)
    xra  a
    call shr_hl.s3 ; hl = q = q >> 3
    mov  b,h
    mov  c,l       ; bc = q
    dad  h
    dad  h
    dad  b
    dad  h         ; hl = q*10
    mov  a,e
    sub  l
    adi  6
    rar
    rar
    rar
    rar
    ani  15        ; a = (r+6)>>4
    add  c
    mov  l,a
    mov  a,b
    aci  0
    mov  h,a       ; hl = q + ((r+6)>>4) = n/10
    mov  a,l
    add  a
    add  a
    add  l
    add  a         ; a = l*10
    sub  e
    cma 
    inr  a         ; a = e - l*10 (remainder)
	ret
;-----------------------------------------------------------------------
.dummy = shr_hl	
;-----------------------------------------------------------------------
endp    
;=======================================================================
;
;=======================================================================
;   FOR .s1-.s7 A MUST BE 0 !
;-----------------------------------------------------------------------
proc shr_hl
;-----------------------------------------------------------------------
    xra  a
.s1:    
    dad  h
    ral
.s2:    
    dad  h
    ral
.s3:    
    dad  h
    ral
.s4:    
    dad  h
    ral
.s5:    
    dad  h
    ral
.s6:    
    dad  h
    ral
.s7:    
    dad  h
    ral
    mov  l,h
    mov  h,a
	ret
;-----------------------------------------------------------------------
endp
;=======================================================================

[свернуть]

-- надо будет ускорить вывод чисел
++++++++++++++++++++++++++
оказалось, что исходный вариант делит хорошо, но остаток у него левый причем не всегда, а когда аргумент равен 10*х и 10*х+1
поэтому доточил в конце вычисление правильного остатка уж даже не знаю, но надеюсь, что быстрее, чем просто деление на 10
(уже влом такты считать)

[Advertiser]

[shoorick]

32-битный кубический корень
как обычно взял исходник на си из тех же мест, не смог обойтись стеком - использовал память,
доперепилил

int icbrt2(unsigned x) {
   int s;
   unsigned y, b, bs, y2;

   y2 = 0;
   y = 0;
   for (s = 30; s >= 0; s = s - 3) {
      y2 = 4*y2;
      y = 2*y;
      b = 3*(y2 + y) + 1;
      bs = b << s;
      if (x >= bs && b == (bs >> s)) {
         x = x - bs;
         y2 = y2 + 2*y + 1;
         y = y + 1;
      }
   }
   return y;
}

это процедурка

Скрытый текст

;=======================================================================
;    BC = CBRT(DEHL)
;-----------------------------------------------------------------------
cbrt32:
;-----------------------------------------------------------------------
    shld .x 
    xchg     
    shld .x+2 
    lxi  b,0
    mov  h,b
    mov  l,c
    shld .y2
    shld .y2+2 
    mvi  a,30  
;-----------------------------------------------------------------------
.loop:
    sta  .s
;-----------------------------------------------------------------------
    lhld .y2+2
    xchg
    lhld .y2
    mvi  a,2
    call shl_dehl_a 
    shld .y2
    xchg
    shld .y2+2 ; y2=4*y2
    xchg
    mov  a,c
    add  a
    mov  c,a
    mov  a,b
    adc  a
    mov  b,a ; y=2*y
    dad  b   
    jnc  .m1
    inx  d
.m1:         ; dehl = y2 + y
    xra  a
    push b
    mov  b,h  
    mov  c,l
    dad  b
    aci  0
    dad  b
    aci  0
    xchg
    mov  b,h
    mov  c,l
    dad  b
    dad  b    
    add  l
    mov  l,a
    mov  a,h
    aci  0
    mov  h,a
    xchg
    inx  h
    mov  a,l
    ora  h
    jnz  .m2
    inx  d
.m2:    
    pop  b  ; dehl = b = 3*(y2 + y)+1
    lda  .s
    call shl_dehl_a ; dehl = bs = b << s
    lda  .x
    sub  l
    mov  l,a
    lda  .x+1
    sbb  h
    mov  h,a
    lda  .x+2
    sbb  e
    mov  e,a
    lda  .x+3
    sbb  d
    mov  d,a ; dehl = x - bs
    jc   .skip
    shld .x ; x = x - bs
    xchg
    shld .x+2
    lhld .y2+2
    xchg
    lhld .y2
    dad  b
    jnc  .m3
    inx  d
.m3:
    dad  b
    jnc  .m4
    inx  d
.m4:
    inx  h
    mov  a,l
    ora  h
    jnz  .m5
    inx  d
.m5:    
    shld .y2
    xchg
    shld .y2+2 ; y2 = y2 + 2*y + 1
    inx  b ; y = y + 1
.skip:
    lda  .s
    sui  3
    jnc  .loop
;-----------------------------------------------------------------------
    ret 
;-----------------------------------------------------------------------
.x  dd ?
.y2 dd ? 
.s  db ? 
;=======================================================================

[свернуть]

а это - служебная сдвигайка влево

Скрытый текст

;=======================================================================
;   DEHL = DEHL << A
;-----------------------------------------------------------------------
proc shl_dehl_a
;-----------------------------------------------------------------------
    ora  a
    rz
;-----------------------------------------------------------------------
    cpi  32
    jnc  .zero_dehl
    push psw
    ani  7
    inr  a
.loop:
    dcr  a
    jz   .move
    xchg
    dad  h
    xchg
    dad  h
    jnc  .loop
    inx  d
    jmp  .loop
.move:    
    pop  psw
    ani  18h
    rar
    rar
    rar
    rar
    jnc  .next  
    mov  d,e
    mov  e,h
    mov  h,l
    mvi  l,0
.next:
    rar
    rnc
    xchg    
    lxi  h,0
    ret
.zero_dehl:
    lxi  d,0
    lxi  h,0
    ret
;-----------------------------------------------------------------------
endp
;=======================================================================

[свернуть]

Приблизительный 64-битный квадратный корень.
Использует указанные выше процедуры.
При необходимости сначала побайтно сдвигает аргумент, а потом соответственно и результат, поэтому для аргументов >32 бит является приблизительным.

Скрытый текст

;=======================================================================
;   DEHL = SQRT([HL]) APPROX FOR > 32 BIT (VIA 32-BIT SQRT)
;-----------------------------------------------------------------------
proc sqrt64a
;-----------------------------------------------------------------------
    lxi  b,7
    dad  b
    mvi  b,4
    xra  a
.loop:
    cmp  m
    jnz  .ok
    dcx  h
    dcr  b
    jnz  .loop
.ok:
    push b
    mov  d,m
    dcx  h
    mov  e,m
    dcx  h
    mov  a,m
    dcx  h
    mov  l,m
    mov  h,a
    call sqrt32
    lxi  d,0
    mov  h,b
    mov  l,c
    pop  psw
    add  a
    rz
    add  a
    jmp  shl_dehl_a
;-----------------------------------------------------------------------
endp
;=======================================================================

[свернуть]