[W] Algoritmo logarítmico de radicalización

[The Shadow]

Código:

# Algoritmo logarítmico de radicalización 1.0 para MIPS

#############################
#                           #
#       Text Segment        #
#                           #
#############################

.text
.globl main

#----------------------- Algoritmo logarítmico de radicalización --------------------------



main: # comienzo del programa

li $v0, 4 # llama al servicio de imprimir una cadena
la $a0, prompt_indice # carga como argumento la cadena ("Introduzca el índice de
# la raíz: ")
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 en $t0

li $v0, 4 # llama al servicio de imprimir una cadena
la $a0, prompt_radi # carga como argumento la cadena ("\nIntroduzca el
# radicando de la raíz: ")
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 índice de la raíz

rem $t0, $a0, 2 # calcula el módulo entre el índice y 2
beqz $t0, comprobar_neg # si el índice 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

li.s $f1, 0.0 # 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 de la raíz en $f1

li.s $f0 1.0 # 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

li.s $f0 0.0 # 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

li.s $f0 1.0 # carga $f0 con 1.0 si el número es menor que 1
li.s $f2 2.0 # carga $f2 con 2.0
j raiz_loop # salta a calcular la raíz para un número menor que 1



# ***** CALCULAR LA RAÍZ DEL NÚMERO *****



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 número 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:

li $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 Segment        #
#                           #
#############################

.data

prompt_indice: .asciiz "Introduzca el índice de la raíz: "
prompt_radi: .asciiz "\nIntroduzca el radicando de la raíz: "
prompt_result: .asciiz "\nEl resultado es: "
prompt_imagin: .asciiz "\nel resultado es imaginario"

#
# fin de algoritmo de radicalización 1.0.asm
#

Fuente: LWP
Autor: Anonimo