#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