#ESTA PARTE DEL CODIGO NO CREEMOS NECESARIO EXPLICARLA DEBIDO A... #HICIESTEIS VOSOTROS ########################################

#ESTA PARTE DEL CODIGO NO CREEMOS NECESARIO EXPLICARLA DEBIDO A QUE LA
#HICIESTEIS VOSOTROS
########################################
# Segmento de datos
########################################
.data 0x10010000
# Reservamos espacio para almacenar las matrices
# las matrices pueden inicializarse aquí y así se evita la tediosa labor de cargar su valor
# cada vez que se pretenda depurar errores.
A: .space 104
B: .space 104
C: .space 104
# se almacenan diferentes menús
pantalla: .ascii "\n Fundamentos de Computadores "
.ascii "\n Telemática "
.ascii "\n Cartagena. Curso 2000/01 "
.ascii "\n\n"
.ascii "\n −−−−−−−−−−−−−−−−−−−−−−−−−−−− "
.ascii "\n Opciones "
.ascii "\n −−−−−−−−−−−−−−−−−−−−−−−−−−−− "
.ascii "\n 1. Introducir una matriz."
.ascii "\n 2. Visualizar una matriz."
.ascii "\n 3. Calcular la traspuesta."
.ascii "\n 4. Determinante."
.ascii "\n 5. Sumar dos matrices."
.ascii "\n 6. Multiplicar por escalar."
1
.ascii "\n 7. Salir del programa."
.ascii "\n\n"
.ascii "\n −−−−−−−−−−−−−−−−−−−−−−−−−−−− "
.asciiz "\n\t Seleccione alguna de las opciones: "
# Se almacenan las direcciones a las que saltar en función de la opción seleccionada
etiquetas_menu: .word opcion1, opcion2, opcion3, opcion4, opcion5, opcion6, opcion7
# Menú de introducción
elegir_matriz: .ascii "\n −−−−−−−−−−−−−−−−−−−−−−−−−−−− "
.ascii "\n Opciones "
.ascii "\n −−−−−−−−−−−−−−−−−−−−−−−−−−−− "
.ascii "\n 1. Introducir matriz A. "
.ascii "\n 2. Introducir matriz B. "
.ascii "\n\n"
.ascii "\n −−−−−−−−−−−−−−−−−−−−−−−−−−−− "
.asciiz "\n\t Seleccione la matriz que desea introducir: "
etiquetas_mat: .word opcionA, opcionB
# Menú de visualización
v_elegir_matriz: .ascii "\n −−−−−−−−−−−−−−−−−−−−−−−−−−−− "
.ascii "\n Opciones "
.ascii "\n −−−−−−−−−−−−−−−−−−−−−−−−−−−− "
.ascii "\n 1. Visualizar matriz A. "
.ascii "\n 2. Visualizar matriz B. "
.ascii "\n 3. Visualizar matriz C. "
.ascii "\n\n"
.ascii "\n −−−−−−−−−−−−−−−−−−−−−−−−−−−− "
.asciiz "\n\t Seleccione la matriz que desea visualizar: "
2
etiquetas_vmat: .word v_opcionA, v_opcionB, v_opcionC,
ret: .asciiz "\n"
tab: .asciiz "\t"
# identificadores de matriz
matrizA: .asciiz "A"
matrizB: .asciiz "B"
matrizC: .asciiz "C"
datosde: .asciiz "Datos de la matriz "
abrecor: .asciiz "["
cierracor: .asciiz "]= "
coma: .asciiz ", "
numerofilas: .asciiz "Introduzca el número de filas: "
numerocolumnas: .asciiz "Introduzca el número de columnas: "
# mensajes de error
mensajerror: .asciiz "\nLa matriz que desea visualizar NO TIENE datos."
mmensajeerror: .asciiz "\nNo puede multiplicar dos matrices que no tengan igual número de filas y columnas
respectivamente."
smensajeerror: .asciiz "\nNo puede sumar/restar dos matrices que no tengan igual dimensión."
Det_error: .asciiz "\nNo puede calcularse un determinate superior a 3x3."
peticionescalar: .asciiz "\nIntroduzca el escalar por el que desea multiplicar la matriz A: "
# Opciones implementadas
opc1: .asciiz "Procedimiento para introducir una mátriz"
opc2: .asciiz "Procedimiento para visualizar una mátriz"
opc3: .asciiz "Procedimiento para calcular la traspuesta de la matriz A y la guarda en C"
opc4: .asciiz "Procedimiento para calcular el determinante"
opc5: .asciiz "Procedimiento para sumar dos matrices. 0 Suma 1 Resta "
opc6: .asciiz "Procedimiento para multiplicar por escalar"
3
opc7: .asciiz "Procedimiento para salir del programa"
#MESAJES QUE SE MUESTRAN EN LA VENTANA CUANDO SE EJECUTA EL CÓDIGO
mensajedepu: .asciiz "\nHasta aquí ha llegado bien." #ESTE ES BUESTRO
mensaje_det: .asciiz "El determinante de A es : "
########################################
#
# Segmento de código
#
########################################
# Programa principal.....
# Se muestra el menú de opciones posibles y se espera que el usuario seleccione una de ellas
.text
.globl __start
__start:
jal limpiar
jal mostrar_menu
li $8, 4
addi $2, $2, −1
mult $8, $2
mflo $9
la $10, etiquetas_menu
add $11, $10, $9
lw $11, 0($11)
jr $11
opcion1: jal introducir
j __start
4
opcion2: jal visualizar
j __start
opcion3: jal traspu
j __start
opcion4: jal determinante
j __start
opcion5: jal sumar
j __start
opcion6: jal multescalar
j __start
opcion7: jal abandonar
#rutina de comprobacion de la existencia de datos
#dentro de la matriz
vacio: la $4,mensajerror
li $2,4
syscall
li $2,5
syscall
jr $31
########################################
# Muestra el menú de opciones y
# recoge la opción seleccionada.
# Sale del menú cuando se selecciona
# una opción posible.
########################################
mostrar_menu: addi $29, $29, −8 #PARA ELLO USAMOS UNA PILA
5
sw $8, 4($29)
sw $31, 0($29)
li $2, 4
la $4, pantalla
syscall
li $2, 5
syscall
slti $8, $2, 8 #máxima opción 7
beq $8, $0, mostrar_menu
lw $8, 4($29)
lw $31, 0($29)
addi $29, $29, 8
jr $31
########################################
# Opcion1. Introducir una matriz
########################################
introducir: addi $29, $29, −8
sw $8, 4($29)
sw $31, 0($29)
li $2, 4
la $4, opc1
syscall
li $2, 4
la $4, elegir_matriz
syscall
li $2, 5
6
syscall
slti $8, $2, 3
beq $8, $0, introducir
li $8, 4
addi $2, $2, −1
mult $8, $2
mflo $9
la $10, etiquetas_mat
add $11, $10, $9
lw $11, 0($11)
jal limpiar
jr $11
opcionA: la $4, A
la $5, matrizA
jal pedir
jal pausa
jal continuar
opcionB: la $4, B
la $5, matrizB
jal pedir
jal pausa
jal continuar
continuar: lw $8, 4($29)
lw $31, 0($29)
addi $29, $29, 8
jr $31
7
########################################
# Pedir matriz
# en $4 se pasa la dirección de la matriz a cargar
# en $5 tenemos el identificador
# los datos de entrada se almacenan de la siguiente forma
# Primero destinando media palabra para ello el número de filas de la matriz
# Segundo destinando media palabra para ello el número de columnas de la matriz
# Seguidamente se almacenan cada una de las componentes de la matriz destinando un byte
########################################
pedir: addi $sp, $sp, −20
sw $10, 16($sp) # número de columnas
sw $9, 12($sp) # número de filas
sw $8, 8($sp) # registro intermedio
sw $4, 4($sp)
sw $5, 0($sp)
li $2, 4
la $4, datosde
syscall
li $2, 4
lw $4, 0($sp)
syscall
li $2, 4
la $4, ret
syscall
fil: li $2, 4
la $4, numerofilas
8
syscall
li $2, 5
syscall
blez $2, fil
lw $8, 4($sp)
sh $2, 0($8)
move $9, $2
col: li $2, 4
la $4, numerocolumnas
syscall
li $2, 5
syscall
blez $2, col
lw $8, 4($sp)
sh $2, 2($8)
move $10, $2
lw $8, 4($sp)
addi $8, $8, 4
# repetir hasta número de filas
li $11, 0
rep_i: li $12, 0
rep_j: li $2, 4
lw $4, 0($sp)
syscall
li $2, 4
la $4, abrecor
9
syscall
li $2, 1
move $4, $11
syscall
li $2, 4
la $4, coma
syscall
li $2, 1
move $4, $12
syscall
li $2, 4
la $4, cierracor
syscall
li $2, 5
syscall
# Guardar el dato recogido.........................................
sb $2, 0($8)
add $8, $8, 1
addi $12, $12, 1
bne $12, $10, rep_j
li $2, 4
la $4, ret
syscall
addi $11, $11, 1
bne $11, $9, rep_i
lw $10, 16($sp) # número de columnas
10
lw $9, 12($sp) # número de filas
lw $8, 8($sp)
lw $4, 4($sp)
lw $5, 0($sp)
addi $sp, $sp, 20
jr $31
########################################
# Opcion2. Visualizar una matriz
########################################
visualizar: addi $29, $29, −8
sw $8, 4($29)
sw $31, 0($29)
li $2, 4
la $4, opc1
syscall
li $2, 4
la $4, v_elegir_matriz
syscall
li $2, 5
syscall
slti $8, $2, 4
beq $8, $0, visualizar
li $8, 4
addi $2, $2, −1
mult $8, $2
mflo $9
11
la $10, etiquetas_vmat
add $11, $10, $9
lw $11, 0($11)
jal limpiar
jr $11
v_opcionA: la $4, A
la $5, matrizA
li $6, 0
jal mostrar
jal pausa
jal continuar
v_opcionB: la $4, B
la $5, matrizB
li $6, 0
jal mostrar
jal pausa
jal continuar
v_opcionC: la $4, C
la $5, matrizC
li $6, 1
jal mostrar
jal pausa
jal continuar
# OPCION D ELIMINADA POR QUE NO NECESITAMOS USARLA
# YA QUE PASAMOS LOS DATOS SIEMPRE A LA MATRIZ C
jr $31
12
########################################
# mostrar: Procedimiento que muestra la matriz pasada como argumento
# entradas: $4: dirección donde comienza la matriz a mostrar
# $5: identificador de la matriz a visualizar
########################################
mostrar: addi $sp, $sp, −20
sw $10, 16($sp) # número de columnas
sw $9, 12($sp) # número de filas
sw $8, 8($sp) # registro intermedio
sw $4, 4($sp)
sw $5, 0($sp)
li $2, 4
la $4, datosde
syscall
li $2, 4
lw $4, 0($sp)
syscall
li $2, 4
la $4, ret
syscall
lw $8, 4($sp)
lh $9, 0($8)
lh $10, 2($8)
addi $8, $8, 4
beq $9, $0, verror
beq $10, $0, verror
13
j vcontinuar
verror: li $2, 4
la $4, mensajerror
syscall
j vsalir
vcontinuar:
# repetir hasta número de filas
li $11, 0
vrep_i: li $12, 0
vrep_j: li $2, 4
lw $4, 0($sp)
syscall
li $2, 4
la $4, abrecor
syscall
li $2, 1
move $4, $11
syscall
li $2, 4
la $4, coma
syscall
li $2, 1
move $4, $12
syscall
li $2, 4
la $4, cierracor
14
syscall
beq $6, $0, vbyte
# Cargar el dato correspondiente.........................................
# La matriz de resultado de operaciones C no tiene como componentes #datos de tipo byte
# sino palabra, por ello si deseamos ver la matriz C debemos acceder a #palabra e ir de 4 en 4
lw $4, 0($8)
add $8, $8, 4
j vcont
vbyte: lb $4, 0($8)
add $8, $8, 1
vcont: li $2, 1
syscall
li $2, 4
la $4, tab
syscall
addi $12, $12, 1
bne $12, $10, vrep_j
li $2, 4
la $4, ret
syscall
addi $11, $11, 1
bne $11, $9, vrep_i
vsalir: lw $10, 16($sp) # número de columnas
lw $9, 12($sp) # número de filas
lw $8, 8($sp)
lw $4, 4($sp)
15
lw $5, 0($sp)
addi $sp, $sp, 20
jr $31
########################################
# Opcion3. Calcular la traspuesta
# Procedimiento que calcula la traspuesta de A y la guarda en C
########################################
traspu:
li $2, 4
la $4, opc3
syscall
# implementar aquí......................
addi $sp,$sp,−4 #AQUI RESERVAMOS UNA PALABRA EN PILA
sw $31,0($sp) #AQUI GUARDAMOS LA POSCION DE RETORNO EN PILA
lh $9,A #LEEMOS LOS PRIMEROS BYTES DE LA MATRIZ A
beqz $9, vacio #SI NO HAY FILAS ESTA VACIA SI HAY
lh $10,A+2 #LEEMOS LA SEGUNDA Y ULTIMA PALBRA Y
sh $10,C #GUARDAMOS ENTONCES LAS DIMENSIONES EN C
sh $9,C+2 #FILAS Y COLUMNAS C Y C+2
la $13,A+4 #CARGAMOS EL PRIMER ELEMENTO MATRIZ A
li $11,0 #POMEMOS A 0 EL REG 11 DONDE METEREMOS DATOS
columnas: li $12,0 #INICIALIZAMOS LAS COLUMNAS A 0
trasponer: lb $14,0($13) #CARGAMOS EN $14 EL PRIMER BYTE DE MATRIZ A
move $4,$9 #CARGAMOS EN LOS DATOS EN LOS REGISTROS $4 $6 $5
move $6,$11 #QUE SON LOS QUE HEMOS USADO EN LA RUTINA
move $5,$12 #POSICION PARA CALCULAR LA POSICION DE LOS
16
li $7,4 #DATOS DENTRO DE LA MATRIZ Y PODER GIRARLA
jal posicion #AQUÍ LLAMAMOS A LA SUBSODICHA RUTINA
la $15,C #AL VOLVER DE LA RUTINA CARGAMOS C EN $15
add $15,$15,$2 #Y LE SUMAMOS (i*n+j)*tamaño+4 == DESPLAZAMIENTO
sw $14,0($15) #ALMACENAMOS EL ELEMENTO Y PASAMOS AL SIGUIENTE
addi $13,$13,1 #Y PASAMOS AL SIGUIENTE ELEMENTO DE A FILA
addi $12,$12,1 # Y TAMBIEN COLUMNA
bne $12, $10,trasponer #SI NO HEMOS LLEGADO AL FIN REPETIMOS
addi $11,$11,1 #INCREMENTAMOS LAS FILAS Y SI NO SON IGUAL
bne $11,$9,columnas #A LAS COLUMNAS DICHAS AL PRINCIPIO SEGUIMOS
lw $31,0($sp) #SI HEMOS LLEGADO AL FINAL, LEEMOS LA DIREC DE
addi $sp,$sp,4 #RETORNO DE LA PILA Y VOLVEMOS AL MENU PRINCIPAL
jr $31
########################################
#Opcion 4: Calcular el determinante de A ########################################
determinante:li $2, 4 #AQUÍ EMPEZAMOS A IMPLEMENTAR LA FUNCION QUE
la $4, opc4 #CALCULA EL VALOR DEL DETERMINANTE DE LA
syscall #MATRIZ "A"
la $4,A #LEEMOS LA DIRECCION DE LA MATRIZ
li $16,−1 #Y CARGAMOS LOS VALORES PARA PODER HACER
li $17,1 #UNA COMPARACION Y PODER ASI DECIDIR SU
li $18,2 #RANGO Y LLEVAR LOS DATOS AL METODO NECESARIO
li $19,3 #TAMBIEN HEMOS CARGADO EL −1 PARA HACER RESTAS
lb $5,2($4) #LEEMOS LAS COLUMNAS DE LA MATRIZ "A" (A=$4)
beq $5,$0, vacio #SI NO HAY COLUMNAS NO HAY MATRIZ =ERROR VACIO
lb $6,0($4) #SI HAY COLUMNAS LEEMOS LA FILAS QUE HAY
17
beq $6,$0, vacio #SI NO HAY FILAS NO HAY MATRIZ = ERROR DE VACIO
bne $5,$6, error_det #SI LAS FILAS<> A LAS COLUMNAS NO SE PUEDE
beq $5,$17, orden_1 #AQUÍ CALCULAMOS EL ORDEN DE LA MATRIZ SI ES
beq $5,$18, orden_2 #DE ORDEN1, 2, Ó 3 PARA ELEGIR LA RUTINA DE
beq $5,$19, orden_3 #CALCULO APROPIADA, SI ES IGUAL O MAYOR QUE
bge $5,4, error_det #ORDEN 4 ERROR NO PUEDO CALCULARLO (Bge)
orden_1: lb $7,4($4) #SI SU ORDEN ES UNO NO HAY TU TIA EL DATOS ES
j result #ES EL RESULTADO Y LO PASAMOS EN $7
orden_2: lb $8,4($4) #PASAMOS LA PARATE ALTA DE $4=A HACIA $8
lb $9,7($4) #LEMOS EL DATO 1,1 Y 2,2 DE LA MATRIZ
mult $8,$9 #AQUI LOS MULTIPLICAMOS Y SU RESULTADO
mflo $5 #NOS LO COGEMOS DE LO Y GUARDAMOS EN $5
lb $8,5($4) #LEEMOS EL DATO 1,2 Y TAMBIEN LEEMOS
lb $9,6($4) #EL DATO 2,1 DE LA MATRIZ Y A CONTINUACION
mult $8,$9 #LOS MULTIPLICAMOS Y EL RESULTADO LO MOVEMOS
mflo $6 #DE LO HACIA $6 DONDE LO MULTIPLICAMOS POR
mult $6,$16 #EL REGISTRO $16 QUE VALE −1 Y RESTAMOS LOS
mflo $6 #LOS DOS TERMINOS CON UNA SIMPLE SUMA PORQUE
add $7,$6,$5 #LE HEMOS CAMBIADO EL SIGNO Y GURADAMOS EL
j result #RESULTADO EN $7 PARA IPRIMIRLO EN PANTALLA
orden_3: lb $8,4($4) #SI EL DETERMINANTE ES DE ORDEN 3 USAMOS SARROUS
lb $9,8($4) #LEEMOS EL DATO 1,1 Y 2,2 LO MULTPLICO A CONTINUA
mult $8,$9 #CION Y EL RESULTADO TRAIGO DE LO A $9 Y LEO EL
mflo $9 #BIT QUE ME QUEDA DE LA DIAGONAL PPAL EL 3,3 Y
lb $8,12($4) #LO MULTIPLICO POR EL RESULTADO DE ANTES Y ESTO
mult $8,$9 #QUE ME DA LO GUARDO EN EL REGISTRO $5
18
mflo $5
lb $8,5($4) #SEGUIMOS CON SARROUS, AQUI LEEMOS LOS DATOS
lb $9,9($4) # LEEMOS EL DATO 1,2 Y EL 2,3 LOS MULTIPLICAMOS
mult $8,$9 #Y EL RESULTADO NOS LO TRAEMOS DE LO Y LO
mflo $9 #PASAMOS AL REGISTRO $9 QUE LO MULTIPLICAMOS
lb $8,10($4) #CON ESTE DATO QUE COGEMOS DE A POSICION 3,1
mult $8,$9 #Y EL RESULTADO LO ALMACENAMOS DESDE LO
mflo $6 # AL REGISTRO $6 Y SUMAMOS LOS DOS PRIMEROS
add $7,$5,$6 #RESULTADOS Y LOS GUARDAMOS EN $7
lb $8,6($4) #AQUI HACEMOS EL SEGUNDO TRIANGULO CON LOS DATOS
lb $9,7($4) #CORRESPONDIENTES A LAS POSICIONES 1,3 Y 2,1 DE
mult $8,$9 #LA MATRIZ, LOS MULTIPLICO Y GUARDO SU RESULTADO
mflo $9 #EN EL REGISTRO $9
lb $8,11($4) #AQUI LEO EL DATO DE LA MATRIZ 3,2 PARA MULTIPLI
mult $8,$9 #CARLO POR EL RESULTADO ANTERIOR, PARA SUMMARLO
mflo $6 # AL VALOR QUE OBTUBE LA DIAGONAL Y DEL PRIMER
add $7,$6,$7 #TRIANGULO, Y LO GUARDO TODO EN $7
lb $8,6($4) #AHORA CALCULO LA DIAGONAL INVERSA CON LOS DATOS
lb $9,8($4) #QUE EN TEORIA OCUPAN LA POSICION 1,3 MULTIPLICADO
mult $8,$9 #POR EL DE LA POSICION 2,2 Y RECOJO EL RESULTADO
mflo $9 #EL REGISTRO $9, A CONTINUACION SIGO CALCULANDO
lb $8,10($4) #EL ULTIMO DATO DE LA DIAGONAL INVERSA EL 3,1
mult $8,$9 #Y AQUI LO MULTIPLICO POR EL VALOR DE EL PRODUCTO
mflo $9 #DE LOS DOS ANTERIORES EL RESULTADO LO CARGO EN $9
mult $9,$16 #CON ESTO LO MULTPLICO POR −1 Y LO HAGO NEGATIVO
mflo $6 #PARA ASÍ NO TENER QUE RESTAR, SOLO LO SUMO A $6
19
add $7,$6,$7 #QUE ES EL RESULTADO DE ANTES AL CUAL TENGO QUE
#SEGUIR RESTANDOLE EL RESULTADO DE LOS 2 TRIANGULO
lb $8,5($4) #AQUI LEO LOS DATOS 1,2 Y 2,1 PARA EMPEZAR A
lb $9,7($4) #CALCULAR EL PRIMER TIRIANGULO,
mult $8,$9 #LOS MULTIPLICO Y EL RESULTADO ME LO TRAIGO
mflo $9 #Y LO GUARDO EN $9
lb $8,12($4) #AQUI CALCULO EL TERCER VERTICE DE LA POSICION
mult $8,$9 #3,3 Y LO SUMO A LO ANTERIOR GUARDANDOLO TODO
mflo $9 #EN $9, A CONTINUACION LO MULTIPLICO POR −1
mult $9,$16 #PARA HACER UNA SUMA EN VEZ DE UNA RESTA
mflo $6
add $7,$6,$7 #Y AQUI SE LO SUMO A LOS VALORES ANTERIORES
lb $8,4($4) #POR FIN CALCULO EL ULTIMO TRIANGULO CORRESPO
lb $9,9($4) #DIENTE A LOS DATOS DE LAS POSICIONES 1,1
mult $8,$9 #2,3 Y 3,2 REPITIENDO LAS OPERACIONES COMO
mflo $9
lb $8,11($4)
mult $8,$9 #ANTES Y MULTIPLICANDO EL VALOR OBTENIDO
mflo $9 #POR −1 SUMANDOLO AL TOTAL QUE LLEVAVA Y
mult $9,$16
mflo $6 #LO GUARDO EN EL REGISTRO $7
add $7,$6,$7
bne $10,255,result #AQUÍ SALTA A LA RUTINA PARA MOSTRAR LA SOLUCION
jr $31
result: move $10,$0 #PONEMOS A CERO $10
li $2, 4 #INTRODUCIMOS UN SALTO DE CARRO
20
la $4, ret
syscall
li $2, 4
la $4, mensaje_det #PONEMOS LA FRASE DEL RESULTADO
syscall
move $4,$7 #MOVEMOS EL RESULTADO A $4 PARA PODER
li $2,1
syscall
li $2, 5 #IMPRIMIRLO EN PANTALLA
syscall
jr $31 #AQUÍ VOLVEMOS AL MENU PPAL
error_det: move $10,$0 #SI POR CASUALIDAD NOS DA UNA ERROR
la $4,det_error #DEL ORDEN AQUÍ TRATAMOS ESE ERROR
li $2,4 #DANDO UN MESAJE EN PANTALLA
syscall
li $2,5 #CON ESTO METEMOS UNA PAUSA
syscall
jr $31 #CON ESTO REGRESAMOS AL MENU PPAL
########################################
# Pausa
########################################
pausa:
li $2, 5
syscall
jr $31
########################################
21
# Limpiar la pantalla
# introduce 25 "\n"
########################################
limpiar: addi $29, $29, −8
sw $9, 4($29)
sw $8, 0($29)
li $8, 0
bucle: li $2, 4
la $4, ret
syscall
addi $8, $8, 1
slti $9, $8, 25
beq $9, $0, bucle
lw $9, 4($29)
lw $8, 0($29)
addi $29, $29, 8
jr $31
########################################
# Opcion 5: Sumar dos matrices (c <= a+b)
########################################
sumar:
li $2,4
la $4,opc5
syscall
# implementar aquí......................
li $2,5 #AQUI PEDIMOS EL NUMERO 1=RESTA 0=SUMA
22
syscall
move $7,$2 #Y LO GUARDAMOS EN $7
la $4,A #LEEMOS LAS 3 MATRICES A, B Y C
la $5,B
la $6,C
lh $9,0($4) #LEEMOS LAS FILASDE A
lh $11,0($5) #Y TAMBIEN LAS DE B
beqz $9, vacio #COMPROBAMOS SI A O B ESTAN VACIAS Y
beqz $11, vacio #SI LO ESTAN VAMOS A LA RUTINA VACIO
lh $10,2($4) #SINO ESTAN VACIAS LEEMOS LAS COLUMNAS
lh $12,2($5) #DE AMBAS MATRICES
bne $9,$11,error1 #SI NO COINCIDEN LAS FILAS O LAS
bne $10,$12,error1 #COLUMNAS DE AMBAS VAMOS A ERROR1
sh $9,0($6) #SI SI COINCIDEN SALVAMOS EN C EL NUMERO
sh $10,2($6) #DE FILAS Y DE COLUMNAS
addi $4,$4,4 #Y SUMAMOS MEDIA PALABRA A TODAS LAS
addi $5,$5,4 #MATRICES PARA EMPEZAR A COLOCARLE ELEMENTOS
addi $6,$6,4
li $11,0 #RESETEO EL REGISTRO $11
filas: li $12,0 #Y TAMBIEN EL 12 PARA RENICIAR LAS FILAS
colum: lb $13,0($4) #LAS COLUMNAS DE LAS MATRICES A Y B
lb $14,0($5)
beq $7,$0,suma #SI $7 VALE 0 SALTA A LA RUTINA SUMA
li $24,1 #SINO COGEMOS Y PONEMOS $24 (pqsi)LO PONEMOS
bgt $7,$24, __start #A 1 Y SI $7>1 SALTA A __start PORQUE
sub $15,$13,$14 #EL USUARIO SE HA EQUIVOCADO, Y SI ES IGUAL A 1
23
j sigue #RESTAMOS A MENOS B Y LO GUARDAMOS EN $15
suma: add $15,$13,$14 #AQUÍ SUMAMOS A +B
sigue: sw $15,0($6) #UNA VEZ SUMADOS LOS PRIMEROS VALORES
addi $4,$4,1 #INCREMENTAMOS UNA POSICION EN CADA
addi $5,$5,1 #MATRIZ, LA A Y LA B
addi $6,$6,4 #Y PREPARAMOS LA MATRIZ C PARA PASARLE LOS DATOS
addi $12,$12,1 #Y SUMAMOS UNO AL REGISTRO $12 QUE TENIAMOS A 0
bne $12,$10,colum #DONDE LE PASAMOS EL VALOR DE LAS COLUMNAS
addi $11,$11,1 #AQUÍ TAMBIEN PREPARAMOS $11 PARA PASARLE
bne $11,$9,filas #EL VALOR DE LAS FILAS
li $2,5 #AQUI METEMOS UN ENTERO E FORMA DE PAUSA
syscall
jr $31 #Y SIN NADA MAS QUE OFRECER NOS VAMOS
error1: li $2,4 #AQUÍ DESARROLLAMOS LA RUTINA DE ERROR SI
la $4,smensajeerror
syscall #LAS MATRICES NO LLEGAN A SER CUADRADAS
li $2,5
syscall
jr $31
########################################
# Opcion 6: Multiplicar por un escalar (C <= e*A)
########################################
multescalar: li $2, 4
la $4, opc6
syscall
# implementar aquí......................
24
li $2,4 #PREPARAMOS PARA LEER UNA CADENA
la $4,peticionescalar
syscall #IMPRIMIMOS EN PANTALLA LA PETICION DEL Nº
li $2,5 #LEEMOS EL NUMERITO
syscall
move $5,$2 #PONEMOS EL NUMERITO EN $5
la $8,A #LEEMOS LA DIRECCION DE LA MATRIZ A
la $13,C #Y COMO LA DE C TAMBIEN
lh $9,0($8) #LEEMOS LAS DIMENSIONES DE A Y GUARDAMOS
lh $10,2($8) #LA PARTE BAJA EN $9 Y LA ALTA EN $10
sh $9,0($13) #Y SALVAMOS LA PARTE BAJA DE A EN C
beqz $9, vacio #COMPROBAMOS QUE NO ESTA VACIA SINO ERROR
sh $10,2($13) #SALVAMOS LA PARTE ALTA DE A EN C (COLUMNASDE C)
addi $8,$8,4 #INCREMENTAMOS 4 PARA LEER LOS DATOS DE A
addi $13,$13,4 #TAMBIEN INCREMENTAMOS C PARA PREPARARLA
li $11,0 #YRESETEAMOS $11 QUE NOS HACE FALTA
rep_fil: li $12,0 #PONEMOS LAS FILAS A CERO
rep_col: lb $4,0($8) #Y CARGAMOS EL PRIMER DATO DE A EN $4
mul $7,$5,$4 #MULTIPLICAMOS ESE DATO POR EL ESCALAR
addi $8,$8,1 #INCREMENTAMOS LA MATRIZ A EN 1
sw $7,0($13) #Y LO SALVAOS EN LA PRIMERA POSICION DE C
addi $13,$13,4 #INCREMENTAMOS C PARA LA NUEVA PALABRA
addi $12,$12,1 #INCREMENTAMOS LAS COLUMNAS
bne $12,$10,rep_col #SI COLUMNAS DE A DISTINTO DE C REPITE
addi $11,$11,1 #INCREMENTO LAS FILAS
bne $11,$9,rep_fil #Y SI NO LLEGO TODAVIA REPITO EL BUCLE
25
jr $31
########################################
# Opcion 7: Salir del programa. (Exit)
########################################
abandonar:
li $2,4 #CON ESTO COMO QUE TERMINAMOS YA QUE ESTA BIEN
la $4,opc7
syscall
li $2,4 #UNA PAUSA TONTA
la $4,ret
syscall
li $2, 10 #Y NOS SALIMOS DEL PROGRAMA ***ADIOS****
syscall
########################################
# Posición de memoria
# Procedimiento que devuelve el desplazamiento
# que ocupará el dato cuyas coordenadas se pasan como argumento
# entradas: $4: numero de columnas
# $5: i
# $6: j
# $7: tamaño
# salida: $2: desplazamiento: ((i*n+j)*tamaño+4)
########################################
posicion:
# utilizo el mismo procedimiento para acceder a datos de tipo byte o palabra
# la unica diferencia es que se haya utilizado el parámetro 4 ($7) no metiendo
26
# nada (0 = utilizado para direccionar bytes ) o pasando 4 (utilizado para acceder a palabras)
beq $7, $0, ini #AQUI IMPLEMETAMOS UNOS CONTADORES PARA ESCANEAR
j cont #LAS MATRICES Y ASÍ SABER EN QUE POSICION STAN
ini: add $7, $0, 1 #LOS DATOS Y PODER TRASPONERLOS .
cont: mult $4, $5 # i*n
mflo $2 #AQUI APLICAMOS LA FORMULA QUE NOS
add $2, $2, $6 # i*n+j #INDICASTEIS ARRIBA PARA CALCULARLO
mult $2, $7
mflo $2
add $2, $2, 4 # (i*n+j)*tamaño+4
move $7, $0
jr $31 #CON ESTO NOS VOLVEMOS AL MENU PRINCIPAL (por si habia dudas)
#######################Aquí se acabó todo ################################
INDICE DE COLORES
plantilla original
codigo fuente realizado por nosotros
comentarios esplicativo del codigo fuente
comentarios diversos
CODIGO
FUENTE
EJECUTABLE
27