Matrix Solver

.data
#A: .word 1, 1, 1, 2 # solucio: 2 1
A: .word 1, 2, 1, 1 # solucio -6 7
#A: .word 1, 1, 2, 2 # no te solucio
#B: .word 3, 4
B: .word 8, 1
#B: .word 6, 6
C: .space 8

.text
.globl main

main:
la $a0, A # $a0 = &A
li $a2, 2 # $a2 = N = 2
addiu $sp, $sp, -16 # Reservando en la pila espacio para la matriz inversa.
la $a1, 0($sp) # Pasando por referencia la dirección del primer espacio para guardar la matriz inversa.
jal inversa # Ejecutando la subrutina que calcula la inversa, devuelve si es posible hacerla o no un 0/1 en $v0.

beq $v1,$zero,endCode # Si el resultado de la subrutina que invierte la matriz es igual a zero, acaba el programa.
la $t0, B # $t0 = &B
lw $t1, 0($t0) # $t1 = B[0]
lw $t2, 4($t0) # $t2 = B[1]
lw $t3, 0($a1) # $t3 = M_Inverted[0][0]
lw $t4, 4($a1) # $t4 = M_Inverted[0][1]
lw $t5, 8($a1) # $t5 = M_Inverted[1][0]
lw $t6, 12($a1) # $t6 = M_Inverted[1][1]

multu $t1, $t3 # B[0]*M_Inverted[0][0]
mflo $s0 # $s0 = B[0]*M_Inverted[0][0]

multu $t2, $t4 # B[1]*M_Inverted[0][1]
mflo $s1 # $s1 = B[1]*M_Inverted[0][1]

multu $t1, $t5 # B[0]*M_Invertida[1][0]
mflo $s2 # $s2 = B[0]*M_Invertida[1][0]

multu $t2, $t6 # B[1]*M_Inverted[1][1]
mflo $s3 # $s3 = B[1]*M_Inverted[1][1]

addu $t0, $s0, $s1 # $t0 = B[0]*M_Inverted[0][0] + B[1]*M_Inverted[0][1]
addu $t1, $s2, $s3 # $t1 = B[0]*M_Invertida[1][0] + B[1]*M_Inverted[1][1]

la $a0, C # $a0 = &C
sw $t0, 0($a0) # C[0] = B[0]*A_invertida[0][0] + B[1]*A_invertida[0][1]
sw $t1, 4($a0) # C[1] = B[0]*A_invertida[1][0] + B[1]*A_invertida[1][1]

b endCode
#################################################

inversa:
addiu $sp, $sp, -20 # Creando el bloque de activación.
sw $ra, 16($sp) # Salvando registros.
sw $s0, 12($sp) # Registro para la Matriz.
sw $s1, 8($sp) # Registro para la Matriz Inversa.
sw $s2, 4($sp) # Registro para Aux.
sw $s3, 0($sp) # Registro para Det.
move $s0, $a0 # $s0 = &M[][]
move $s1, $a1 # $s1 = &M_Inverted[][]
move $s2, $a2 # $s2 = Aux
move $s3, $a3 # $s3 = Det
move $t0, $a2 # $t0 = N

bgt $t0, $zero, Determinant  # Si N es mayor que cero, va a la etiqueta 'Determinant'.
b ignoreDeterminant #Si no se cumple lo anterior, se salta el cálculo del determinante.
Determinant: jal determinant

ignoreDeterminant:
move $s3, $v0 # El valor que nos retorna la función lo metemos en $s3.
beq $s3, $zero, else # Si Det es igual a cero, salta al 'Else'.

# Cálculo de la Matriz Inversa.
li $t9, -1 # $t9 = -1
lw $t0, 0($a0) # $t0 = M[0][0] = 1
lw $t1, 4($a0) # $t1 = M[0][1] = 2
lw $t2, 8($a0) # $t2 = M[1][0] = 1
lw $t3, 12($a0) # $t3 = M[1][1] = 1

div $t3, $s3 # M[1][1] / Det
mflo $t4 # $t4 = M_Inverted[0][0]
sw $t4, 0($a1)

div $t0, $s3 # M[0][0] / Det
mflo $t5 # $t5 = M_Inverted[1][1]
sw $t5, 12($a1)

multu $t9, $t1 # -1 * M[0][1]
mflo $t6 # $t6 = -1 * M[0][1]
div $t6, $s3 # -1 * M[0][1] / Det
mflo $t6 # $t6 = M_Inverted[0][1]
sw $t6, 4($a1)

multu $t9, $t2 # -1 * M[1][0]
mflo $t7 # $t7 = -1 * M[1][0]
div $t7, $s3 # -1 * M[1][0]
mflo $t7 # $t7 = M_Inverted[1][0]
sw $t7,8($a1)

li $s2, 1 # Aux = 1

b return #Evitamos el else, si venimos del if anterior.

else:
li $s2, 0 # Aux = 0

return:
move $v1, $s2 # Añadiendo el valor de Aux al retorno de la subrutina.

lw $ra, 16($sp) # Restaurando los registros.
lw $s0, 12($sp)
lw $s1, 8($sp)
lw $s2, 4($sp)
lw $s3, 0($sp)
addiu $sp, $sp, 20 # Eliminando el bloque de activación.
jr $ra

################################################

determinant:
lw $t0, 0($a0) # $t0 = M[0][0] = 1
lw $t1, 4($a0) # $t1 = M[0][1] = 2
lw $t2, 8($a0) # $t2 = M[1][0] = 1
lw $t3, 12($a0) # $t3 = M[1][1] = 1

multu $t0, $t3 # $t0 * $t3 = M[0][0] * M[1][1]
mflo $t0 # $t0 = M[0][0] * M[1][1]

multu $t1, $t2 # $t1 * $t2 = M[0][1] * M[1][0]
mflo $t1 # $t1 = M[0][1] * M[1][0]

subu $v0, $t0, $t1 # return $v0: $v0 = $t0 - $t1
jr $ra
################################################

endCode: