ACTUALIZACIÓN LIBRERÍA MATH

   Debido a que ahora vamos a necesitar alguna de las funciones matemáticas publicadas al comienzo del blog, y a que ya nos encontramos programando sobre TASM2.0, voy a refrescar estas librerías, pasando al nuevo fromato de código y comentándolas un poco más.

     Estas librerías son necesarias para realizar el progra,a de ejemplo de circulo que pondré más adelante. Para poder determinar el centro y radio de un circulo a partir de dos pintos elegidos por el ratón en pantalla.
    no pongo todas. Solo las que usaré para realizar un ejemplo como el de dibujos de líneas con el ratón, pero de circulos.
  En este caso, como se trata de refrescar algo que ya he puesto, pondré en unas sola entrada la definición de la cabecera y de cada una de las librerías.

; Copyright (C) 2013  José Ángel Moneo Fernández

;    This program is free software: you can redistribute it and/or modify
;    it under the terms of the GNU General Public License as published by
;    the Free Software Foundation, either version 3 of the License, or
;   (at your option) any later version.

;    This program is distributed in the hope that it will be useful,
;    but WITHOUT ANY WARRANTY; without even the implied warranty of
;    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;    GNU General Public License for more details.

;    You should have received a copy of the GNU General Public License
;    along with this program.  If not, see <http://www.gnu.org/licenses/>.

Cabecera matemática

MATH.MAC
@b = 2
@o = 8
@d = 10
@h = 16

;valor absoluto del dato 16bits
abs macro dato
local positivo
        add dato,0       
        jns  positivo1    
        neg dato
endm

;suma datos 32bits
suma macro ope1,ope2,res
ifndef _suma
       extrn _suma:near
endif
        lea ax,ope1
        push ax
        lea ax,ope2
        push ax
        lea ax,res
        push ax
        call _suma

     endm
    
;resta datos 32bits    
resta macro ope1,ope2,res
ifndef _resta
       extrn _resta:near
endif
        lea ax,ope1
        push ax
        lea ax,ope2
        push ax
        lea ax,res
        push ax
        call _resta

     endm


;multiplica dato 32 bits
mult macro ope1,ope2,res
ifndef _mult
       extrn _mult:near
endif
        lea ax,ope1
        push ax
        lea ax,ope2
        push ax
        lea ax,res
        push ax
        call _mult

     endm
    
    
;divide dato 32 bits    
divi macro ope1,ope2,res
ifndef _divi
       extrn _divi:near
endif
        lea ax,ope1
        push ax
        lea ax,ope2
        push ax
        lea ax,res
        push ax
        call _divi

     endm
    
    
;sqr devuelve en ax el resultado de la raiz de 32 bits
sqr macro oper
ifndef _sqr
        extrn _sqr:near
endif
        lea ax,oper
        push ax
        call _sqr

      endm

;factorial numeros de 32bits
;fac calcula el factorial del int fuente y lo devuelve en destino
fac macro fuente,destino
ifndef _fac
       extrn _fac:near
endif
        lea ax,fuente
        push ax
        lea ax,destino
        push ax
        call _fac

  endm
 
;potencia numeros de 32bits
;fuente es un puntero de una variable de 16 bits
;potencia es una variable de 16 bits
;destino es un puntero a una variable de 32 bits
;pot calcula x a la n siendo x=fuente,n=potenc y devuelve el resultado en destino
pot macro fuente,potenc,destino
ifndef _pot
       extrn _pot:near
endif
        lea ax,fuente
        push ax
        mov ax,potenc
        push ax
        lea ax,destino
        push ax
        call _pot

  endm
 
;exp numeros de 32bits 
exp macro potenc,destino
ifndef _exp
       extrn _exp:near
endif
        lea ax,potenc
        push ax
        mov ax,destino
        push ax
        call _exp

  endm

;compara numeros de 32bits
cmpi macro destino,fuente
local fin

     push ax
     mov ax,fuente+2
     cmp destino+2,ax
     jne fin
     mov ax,fuente
     cmp destino,ax
 fin:
     pop ax
     endm





Librerías Matemáticas

POT.ASM

; eleva un úmero de 16 bits a otro número dando el resultado en un número de 32 bits
;op1 puntero a varialbe de 16 bits
;op2 numero de 16 bits
;res puntero a variable de 16 bits
model compact,pascal

.code
      public _pot
_pot proc uses bx di cx,op1,op2,res
      extrn _mult:near
 mov cx,op2
        mov bx,op1
        mov di,res
        mov word ptr [di],1
        mov word ptr [di+2],0
 otro:
        cmp cx,0
        jz fin
        push bx
        push bx
        push di
        call _mult
        dec cx
        jmp otro
   fin:
               ret
_pot endp
end


MULT.ASM
;multiplica dos numeros de 32 bits  y el resultado lo lleva a otro de 16 bits
;op1 puntero a nuemro de 32 bits
;op2 puntero a nuemro de 32 bits
;res puntero a número de 32 bits
; multiplica en formato de 32 bits, pero el resultado debe de ser como máximo de 32 bits
;multiplica número sin signo.
.model compact,pascal

.code    
       public _mult
_mult proc uses bx dx cx si di,op1,op2,res
        mov si,op1
        mov bx,op2
        mov di,res
        mov ax,[bx+2]
        push ax
        mov ax,[si]
        push ax
        mov ax,[si]
        mov cx,[bx]
        mul cx
        mov [di],ax
        push dx
        mov ax,[si+2]
        mul cx
        pop dx
        add ax,dx
        mov [di+2],ax
        pop ax
        pop cx
        mul cx
        add [di+2],ax

        ret
_mult endp

end



SUMA.ASM
; codigo
;suma dos números de 32 bits
;sum1 puntero a variable de 32 bits
;sum2 puntero a varialbe de 32 bits
;res puntero a variable de 32 bits
.model compact,pascal
.code
        public _suma
_suma proc uses bx si di,sum1,sum2,res

        mov si,sum1
        mov bx,sum2
        mov di,res
        mov ax,[si]
        add ax,[bx]
        mov [di],ax
        mov ax,[si+2]
        adc ax,[bx+2]
        mov [di+2],ax

        ret
_suma endp

end


SQR.ASM

INCLUDE MATH.MAC
; raiz cuadrada. devuelve en ax el resultado
;Calcula la raiz de un número de 32 bis
; p1 puntero a variable de 32 bits
;El valor de una raíz cuadrada lo vamos a ir a aproximando de está forma:
; Para una raiz N, y teniendo una aproximación APROX, mi siguiente aproximación va a ser igual a:
;APROX = APROX - (APROX ^2 - N) / (2 * APROX)
;Este proceso lo repetimos hasta que la aproximación no cambie, o cuando los cambios de ésta sean mínimos (depende de que tan precisa quieres la raíz)
;SOLO PODREMOS CALCULAR RAICES DE NUMEROS HASTA 4.294.836.225, YA QUE EL RESULTADO DE LA RAIZ LO DEVOLVEREMOS EN AX

model compact,pascal
.data 
APROX DW 0,0
AAPROX DW 0,0
APROX2 DW 0,0
APROX3 DW 0,0
APROX4 DW 0,0
N DW 0,0

.code
      public _sqr
_sqr proc uses bx CX si,p1

        mov bx,p1   ;SE RECOGE EL PUNTERO A LA VARIBLE
        mov si,offset N     ; SE ASIGNA SI AL PUNTERO A LA VARIALBE N
        mov ax,[bx]       ;COPIAMOS EL DATO PASADO 
        mov [si],ax        ;N=P1
        mov ax,[bx+2]
        mov [si+2],ax
        MOV CX,2          ;MULTIPLICADOR 2
        ;COMIENZA LA ITARACIÓN
        mov AX,1       ;APROX=1
    sig:        
        MOV APROX,AX
        MUL CX       ;2*APROX
        MOV AAPROX,AX
        MOV AAPROX+2,DX
        POT APROX,2,APROX2         ;APROX^2
        RESTA APROX2,N,APROX3
        DIVI  APROX3,AAPROX,APROX4
        MOV AX, APROX
        SUB AX, APROX4
        CMP AX, APROX
        jne sig
  

        ret
_sqr endp

end



DIVI.ASM
;; solo divide por numeros menores de ffffh
title dividir
include main.mac

.model  compact,pascal
.data 
aux dw 0,0
.code
      public _divi
_divi proc uses bx dx cx si di,dividendo,divisor,resultado

        mov si,dividendo
        mov di,resultado
        mov bx,divisor
        mov word ptr [di+2],0
        mov word ptr [di],0
        xor dx,dx
        cmp word ptr [bx+2],0
        jz normal
        mov ax,[si+2]
        cmp ax,[bx+2]
        jb fin
        mov cx,[bx+2]
        div cx
        mov [di],ax
comprueba:
        mul word ptr [bx]
        mov aux,ax
        mov aux+2,dx
        mov ax,[di]
        mul word ptr [bx+2]
        add aux+2,ax
        mov ax,aux+2
        cmp ax,[si+2]
        ja no_cabe
        jne fin
        mov ax,aux
        cmp ax,[si]
        jbe fin
no_cabe:
        dec word ptr [di]
        mov ax,[di]
        jmp comprueba


  normal:
        mov cx,[bx]
        mov ax,[si+2]
        div cx
        mov [di+2],ax
        mov ax,[si]
        div cx
        mov [di],ax
   fin:

        ret
_divi endp





RESTA.ASM
; codigo
    public _resta
model compact,pascal

.code
_resta proc uses bx si di,min,subs,res

        mov si,min
        mov bx,subs
        mov di,res
        mov ax,[si]
        sub ax,[bx]
        mov [di],ax
        mov ax,[si+2]
        sbb ax,[bx+2]
        mov [di+2],ax

        ret
_resta endp


end