Advertisement
Not a member of Pastebin yet?
Sign Up,
it unlocks many cool features!
- #Arreglos realizado por:
- #Luis Jimenez R
- #Sebastian Quiroga R
- #Andres Sanchez C
- # Algoritmo
- #############################
- # #
- # Text Segment #
- # #
- #############################
- .text
- .globl main
- main: # comienzo del programa
- li $v0, 4 # llama al servicio de imprimir una cadena
- la $a0, prompt_indice # carga como argumento la cadena
- syscall # imprime la cadena
- li $v0, 5 # llama al servicio de leer un entero
- syscall # lee un entero
- move $t0, $v0 # carga el ?ndice de la ra?z
- li $v0, 4 # llama al servicio de imprimir una cadena
- la $a0, prompt_radi # carga como argumento la cadena
- syscall # imprime la cadena
- li $v0, 6 # llama al servicio de leer un flotante
- syscall # lee un flotante
- mov.s $f12, $f0 # guarda el radicando en $f12
- move $a0, $t0 # carga el indice de la raiz
- rem $t0, $a0, 2 # calcula el modulo
- beqz $t0, comprobar_neg # si el indice es par, hay que comprobar si el radicando
- # es negativo
- j cont_radi # si no es negativo contin?a el proceso
- comprobar_neg: # si el ?ndice es par, comprueba si el radicando es
- # negativo
- l.s $f1, flot1 # carga 0.0 en $f1 para hacer la comprobaci?n
- c.lt.s $f12, $f1 # comprueba si $f12 es negativo
- bc1t, imaginaria # si es negativo, sale del algoritmo, porque la soluci?n es
- # imaginaria
- cont_radi:
- mov.s $f1, $f12 # guarda el radicando (argumento) en $f1
- l.s $f0, flot2 # carga 1.0 en $f0
- c.eq.s $f1, $f0 # comprueba si el flotante a radicalizar es igual que 1
- bc1t inm # si es igual que 1, sale devolviendo 1
- l.s $f0, flot1 # carga 0.0 en $f0
- c.eq.s $f1, $f0 # comprueba si el flotante a radicalizar es igual que 0
- bc1t inm # si es igual que 0, sale devolviendo 0
- l.s $f0, flot2 # carga $f0 con 1.0 si el numero es menor que 1
- l.s $f2, flot3 # carga $f2 con 2.0
- j raiz_loop # salta a calcular la raiz para un numero menor que 1
- # ***** CALCULAR LA RAIZ *****
- raiz_loop: # bucle que va comprobando si un n?mero es el que estamos
- # buscando
- add.s $f3, $f1, $f0 # carga en $f3 la suma de $f1 y $f0
- div.s $f4, $f3, $f2 # carga en $f4 la distancia media entre $f3 y $f2
- mul.s $f5, $f4, $f4 # guarda en $f5 el cuadrado de la media entre $f1 y $f0
- move $t0, $a0 # carga
- comprobar_indice: # si el ?ndice es distinto de 2
- beq $t0, 2, seguir # cuando se haya multiplicado el posible radicando por si
- # mismo tantas veces como indique el ?ndice, se sigue el
- # proceso de determinar si ese radicando es el que buscamos
- mul.s $f5, $f5, $f4 # multiplica el radicando por si mismo
- sub $t0, $t0, 1 # decrementa el ?ndice
- j comprobar_indice # vuelve a multiplicar el posible radicando por si mismo
- seguir: # contin?a con la comprobaci?n del posible radicando
- c.eq.s $f5, $f12 # comprueba si el radicando elevado al ?ndice $a0 es el que
- # buscamos
- bc1t encontrado # si es el que buscamos, no comprobamos mas, saltamos a
- # encontrado
- c.eq.s $f0, $f4 # comprobamos que no estamos comprobando el mismo n?mero
- # que el anterior (error de precisi?n)
- bc1t encontrado # si se ha llegado al l?mite de precisi?n, el resultado
- # (aproximado) es $f4
- c.eq.s $f1, $f4 # comprobamos que no estamos comprobando el mismo n?mero
- # que el anterior (error de precisi?n)
- bc1t encontrado # si se ha llegado al l?mite de precisi?n, el resultado
- # (aproximado) es $f4
- c.lt.s $f5, $f12 # si el posible radicando que hemos analizado elevado al
- # ?ndice es menor que $f12
- bc1t menor # analizamos un numero mayor
- j mayor # si no, analizamos un n?mero menor
- menor: # si el t?rmino que hemos analizado es menor que el que
- # estamos buscando
- c.lt.s $f1, $f0 # determina si $f1 es menor que $f0
- bc1t guardar_f0 # guarda el t?rmino mayor (que est? en $f0)
- j guardar_f1 # guarda el t?rmino mayor (que est? en $f1)
- mayor: # si el t?rmino que hemos analizado es mayor que el que
- # estamos buscando
- c.lt.s $f1, $f0 # determina si $f1 es menor que $f10
- bc1t guardar_f1 # guarda el t?rmino menor (que est? en $f1)
- j guardar_f0 # guarda el t?rmino menor (que est? en $f10)
- guardar_f0: # guarda $f0
- mov.s $f1, $f4 # guarda en $f1 $f4 para hacer la siguiente comprobaci?n
- j raiz_loop # comprueba el siguiente n?mero
- guardar_f1: # guarda $f1
- mov.s $f0, $f4 # guarda en $f0 $f4 para hacer la siguiente comprobaci?n
- j raiz_loop # comprueba el siguiente n?mero
- # ***** RESULTADOS INMEDIATOS *****
- inm: # si son raices inmediatas (0 ? 1) con cualquier ?ndice
- li $v0, 2 # llama al servicio de imprimir un flotante
- syscall # imprime el resultado
- li $v0, 10 # llama al servicio de terminar programa
- syscall # termina el programa
- # ***** MOSTRAR EL RESULTADO *****
- encontrado: # si ha encontrado ya la ra?z, o ha encontrado un resultado
- # aproximado
- li $v0, 4 # llama al servicio de imprimir una cadena
- la $a0, prompt_result # carga como argumento la cadena ("\nEl resultado es: ")
- syscall # imprime la cadena
- li $v0, 2 # llama al servicio de imprimir un flotante
- mov.s $f12, $f4 # carga $f4 como argumento
- syscall # imprime la ra?z del n?mero
- li $v0, 10 # llama al servicio de terminar programa
- syscall # termina el programa
- imaginaria:
- la $v0, 4 # llama al servicio de imprimir una cadena
- la $a0, prompt_imagin # carga la cadena ("\nel resultado es imaginario")
- syscall # imprime la cadena
- li $v0, 10 # llama al servicio de terminar el programa
- syscall # termina el programa
- .data
- prompt_indice: .asciiz "Introduzca el indice de la raiz: "
- prompt_radi: .asciiz "\nIntroduzca el argumento: "
- prompt_result: .asciiz "\nEl resultado es: "
- prompt_imagin: .asciiz "\nel resultado es imaginario"
- flot1: .float 0.0
- flot2: .float 1.0
- flot3: .float 2.0
- #
- # fin de algoritmo de radicalizaci?n 1.0.asm
- #
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
