syscall

LABO 03 CAL – (07)

========== Prob 01 ========== li $v0,1
# Código ok move $a0,$t0
.text syscall
.globl main1
li $v0,10 # syscall code 10 es para "exit".
main1: syscall
li $v0,5
syscall .data
move $t1,$v0 nom:
li $t2,65 .asciiz "El resultado es: "

mul $t0,$t1,$t2 ========== Prob 03 ==========

## Secuencia
li $v0,4 .globl main3 # especifica a main como un
la $a0,nom simbolo global
syscall
.data
li $v0,1 datos: .word 11,22,33,44,55,66,77,88,99
move $a0,$t0 # 9 enteros
syscall n: .word 9

li $v0,10 # syscall code 10 es para "exit". elementos: .asciiz "Los elementos de la

syscall direccion de destino son :"
elem: .word 0
.data nlinea: .asciiz "\n"
nom:
.asciiz "El resultado es: " main3:
.text
========== Prob 02 ========== la $t0, datos # t0 apunta a
# Código ok datos[0]
.text la $t1, n # t1 apunta a n
.globl main2 lw $t1, ($t1) # t1 tiene el
valor de n
main2: li $s0, 0 # suma = 0

li $v0,5 # Registro de valores

syscall
move $t1,$v0 # Guarda los elementos
la $t1, elem # t1 apunta a
li $v0,5 elem
syscall sw $s0, ($t1) # Memoria[t1] =
move $t2,$v0 s0

li $v0,5 #Imprime los elementos

syscall la $a0,elementos # imprime
move $t3,$v0 li $v0,4 # mensaje
syscall
li $v0,5
syscall la $s0,elem
move $t4,$v0 lw $t1,($s0)
move $a0,$t1
li $v0,5 li $v0,1 #
syscall syscall
move $t5,$v0

li $v0,5 # El programa se ha terminado.

syscall Sale.
move $t6,$v0 li $v0, 10
syscall # Sale
add $t0,$t1,$t2
add $t0,$t0,$t3 ========== Prob 04 ==========
add $t0,$t0,$t4 .text
add $t0,$t0,$t5 .globl main4
add $t0,$t0,$t6
main4:
li $v0,4 li $v0,5
la $a0,nom syscall
move $t1,$v0 move $t0, $t1 # $t0 va almacenar
li $t1,966 ahora el contenido de $t1
move $t1, $t2 # $t1 va almacenar
## pone el mas grande de $t0 y $t1 en $t2. ahora el contenido de $t2
bgt $t0, $t1, t0_smaller # si $t0 < $t1, branch
a t0_bigger, addi $t9, $t9, 1 # Incrementa
# move $t2, $t1 # de otro modo, copia $t1 a el contador en $t9
$t2. b loop2 # salta a loop
b endif # y luego salta a endif
loopexit1:
t0_smaller: la $a0,ans1
move $t2, $t0 # copia $t0 a $t2 li $v0,4
endif: ## Imprime $t2. syscall

li $v0,4 la $a0,nlinea
la $a0,nom li $v0,4
syscall syscall

li $v0,1 move $a0,$t2

move $a0,$t0 li $v0,1
syscall syscall

li $v0,10 # syscall code 10 es para "exit". li $v0,10 # termina y sale del

syscall programa
syscall
.data
nom: .data
.asciiz "Numero Ingresado esmenor que 966 "
ans1: .asciiz "El veinteavo termino de la
========== Prob 05 ========== serie es :"
# ej_fibonacci.asm
# Calcula el noveno termino de la serie de nlinea: .asciiz "\n"
fibonacci
# f(n)=f(n-1)+f(n-2) loopexit2:
# El noveno termino de la serie : la $a0,ans2
1,1,2,3,5,8,13,21,34,55,..... es 34 li $v0,4
syscall
.text
.globl main5 move $a0,$t2
li $v0,1
main5: syscall
li $t0, 1 # usa $t0 para
almacenar f(n-2) li $v0,10 # termina y sale del
li $t1, 1 # usa $t1 para programa
almacenar f(n-1) syscall
li $t8, 0 # empieza el loop
li $t9, 0 .data
ans2: .asciiz "El Treintavo termino de la
loop1: serie es :"
bge $t8, 18 loopexit1# si $t8 >= 18, sale
a loopexit LABO 04 CAL – (06)
========== Prob 01 ==========
add $t2, $t0, $t1 # Usa $t2 para # promedio_numeros.asm - imprime la suma y el
almacenar f(n) promedio de los elementos de un arreglo.
move $t0, $t1 # $t0 va almacenar
ahora el contenido de $t1 .data
move $t1, $t2 # $t1 va almacenar datos: .double 111.56, 12, 455.76,
ahora el contenido de $t2 689.32, 999.95, 1000.24, 77.88 , 10.0, 8.0
# 11 enteros
addi $t8, $t8, 1 # Incrementa n: .double 8
el contador en $t8 nw: .word 8
b loop1 # salta a loop adicion: .asciiz "La suma es :"
promedio: .asciiz "El promedio es :"
loop2: suma: .double 0
bge $t9, 28 loopexit2 # si $t8 >= 28, prom: .double 0
sale a loopexit nlinea: .asciiz "\n"

add $t2, $t0, $t1 # Usa $t2 para .text

almacenar f(n)
 la $a1, nw # t1 apunta a n syscall
lw $t1, ($a1) # t1 tiene el valor
de n move $a0,$t2
li $v0,1
la $a0, datos # t0 apunta a syscall
datos[0]
la $a0,endl
# Calcula la suma de los datos li $v0,4
ciclo: syscall
#lw $t2, ($t0) # t2 =
datos[t0] la $a0,ans2
l.d $f10, 0($a0) li $v0,4
add.d $f12,$f12,$f10 # suma = syscall
suma + datos[t0]
addi $a0, $a0, 8 # t0 = t0 move $a0,$t3
+ 4 (siguiente elemento de datos) li $v0,1
addi $t1, $t1, -1 # n = n syscall
- 1
bgtz $t1, ciclo # if (n .data
> 0) goto ciclo array: .word
53,9,77,66,12,115,18,26,44,14,19,78,8,12,13
# Calcula el promedio count: .word 15
la $a0, n # t1 ans1: .asciiz " Min: = "
apunta a n endl: .asciiz "\n"
l.d $f10, ($a0) # t1 ans2: .asciiz "max = "
tiene el valor de n
div.d $f12, $f12,$f10 # prom = ========== Prob 04 ==========
suma / n # Código ok
# C = (F - 32) * 5/9 Conversion
#Imprime la suma
li $v0,3 # mensaje .data
syscall num: .double 1000.98
# El programa se ha terminado. str2 : .asciiz "el Numero Ingresado es menor
Sale. que 1000.98 "
li $v0, 10 str1 : .asciiz "el Numero Ingresado es mayor
syscall # Sale que 1000.98 "
========== Prob 03 ========== .text
.text .globl __start
.globl __start
__start: __start:
la $t0, array li $v0,7 #el ingreso del numero
lw $t1, count se guarda en $f0. lee double
lw $t2,($t0) # inicializo con el valor syscall
mÃnimo
lw $t3,($t0) jal compara # llamo a la subrutina
add $t0,$t0,4 #el puntero aqui va a llamada calculo
empezar en a {1}
add $t1,$t1,-1 #Decremento el contador li $v0,10 # syscall code 10 es
, $t1=$t1-1 para "exit".
syscall
loop:
lw $t4,($t0) #Carga la palabra compara:
siguiente desde el arreglo la $a0, num
bge $t4,$t2,notMin l.d $f12, 0($a0) ## el $f12
move $t2,$t4 almacena el valor de numero

notMin: notMin: ble $t4,$t3,notMax

ble $t4,$t3, notMax # salta si a[i] <= max
move $t3,$t4
## imprimir
notMax: li $v0,3 #el ingreso del
add $t1,$t1,-1 numero real se guarda en $f0
add $t0,$t0,4 syscall
bnez $t1,loop
li $v0, 4 # llamada al sistema para
la $a0,ans1 imprimir cadena
li $v0,4
 la $a0, str1# dirección de la calculo:
cadena a imprimir la $a0, num1
syscall # imprime la cadena l.d $f12, 0($a0) ## el $f12
almacena el valor de numero1
notMax: add $t1,$t1,-1 # decrementa
contador la $a0, num2
l.d $f10, 0($a0) ## el $f12
li $v0, 4 # llamada al sistema almacena el valor de numero1
para imprimir cadena
la $a0, str2 # dirección de la la $a0, num3
cadena a imprimir l.d $f2, 0($a0) ## el $f12
syscall # imprime la cadena almacena el valor de numero1

sub.d $f12,$f0,$f12 ## resta

## retorna al progrma principal $f12= $f0 - $f12
jr $ra mul.d $f12,$f12,$f10
div.d $f12,$f12,$f2

LABO 06 DIR ## imprimir

========== Prob 01 ========== li $v0,3 #el ingreso del
# Código ok numero real se guarda en $f0
syscall
.text
.globl __start ## retorna al progrma principal
jr $ra
__start:
li $v0,7 #el ingreso del
numero real se guarda en $f0. lee double ========== Prob 03 ==========
syscall # Código ok
add.d $f12,$f12,$f0 # aerea

li $v0,7 #el ingreso del .data

numero real se guarda en $f0. lee double pi: .double 3.141592653589793
syscall
add.d $f12,$f12,$f0 .text
.globl main
li $v0,3 #el ingreso del
numero real se guarda en $f0 main:
syscall li $v0,7 #el ingreso del dato
R (radio) se guarda en $f0. lee double
### Salir del programa syscall
jal area # llamo a la subrutina
li $v0,10 # syscall code 10 es llamada calculo
para "exit".
syscall li $v0,10 # syscall code 10 es
para "exit".
========== Prob 02 ========== syscall
# Código ok
# C = (F - 32) * 5/9 Conversion area:
la $a0, pi
.data l.d $f12, 0($a0) ## el $f12
num1: .double 32 almacena el valor de numero1
num2: .double 5
num3: .double 9 mul.d $f12,$f12,$f0 ## $f12 =
pi x radio
.text mul.d $f12,$f12,$f0 ## $f12 =
.globl __start pi x radio x radio

__start: ## imprimir
li $v0,7 #el ingreso del dato li $v0,3 #el ingreso del
F se guarda en $f0. lee double numero real se guarda en $f0
syscall syscall

jal calculo # llamo a la ## retorna al progrma principal

subrutina llamada calculo jr $ra

li $v0,10 # syscall code 10 es

para "exit".
syscall