Questo sito utilizza cookies, anche di terze parti, per mostrare pubblicità e servizi in linea con il tuo account. Leggi l'informativa sui cookies.
Username: Password: oppure
Altri Linguaggi - [MIPS] Calcolo del prodotto scalare tra due matrici
Forum - Altri Linguaggi - [MIPS] Calcolo del prodotto scalare tra due matrici

Avatar
4001 (Normal User)
Newbie


Messaggi: 2
Iscritto: 03/04/2012

Segnala al moderatore
Postato alle 11:52
Martedì, 03/04/2012
Buongiorno a tutti, sono nuovo del forum!
Dopo ricerche di tutti i tipi mi rivolgo a voi sperando di trovare qualcuno che mi faccia capire dove sbaglio.
Per un progetto devo creare un programma MIPS che crei delle matrici quadrate di numeri interi (10x10 max) e ne calcoli il prodotto scalare di ciascun elemento, mettendo poi i risultati in una terza matrice.
Ora, le due matrici riesco a crearle senza, credo, problemi.
I problemi nascono quando devo moltiplicare i singoli elementi e metterli nella terza matrice (che dovrei anche stampare per capire che almeno sto facendo giusto).
Per l'uso dei registri: Ho usato $s0 per memorizzare il "lato" di ogni matrice, in modo da immetterlo da input ed averlo uguale per tutte le matrici. Idem per i due registri $t2, $t3 che utilizzo come indici i e j per scorrere le matrici.

Una nota. Sono sicuro di aver fatto confusione con i registri e a questo punto mi risulta difficile uscire da questo casino. Spero che un occhio esterno veda dove sto sbagliando, perchè comincio a non capirci più nulla. Il MIPS lo sto studiando da poco e sebbene sia affascinante mi sta provocando gran mal di testa..

vi allego il codice, spero di non essere stato troppo prolisso ma abbastanza dettagliato. se avete domande chiedete pure. Grazie a chi vorrà/potrà aiutarmi.

Codice sorgente - presumibilmente Plain Text

  1. .data
  2.  
  3. string1: .asciiz "\ninserisci un numero che andrà nella riga "
  4. string2: .asciiz "\ne nella colonna "
  5. string3: .asciiz "\ninserisci un valore per il lato della matrice quadrata compreso tra 1 e 10: "
  6. string4: .asciiz "\ninserisci un valore nella seconda matrice-operando nella riga : "
  7. string5: .asciiz "\ne nella colonna "
  8.  
  9. capo: .asciiz "\n"
  10.  
  11. M: .word 0:100
  12. M1: .word 0:100
  13. M2: .word 0:100
  14.  
  15. .text
  16. .globl main
  17.  
  18. main: #lettura
  19.  
  20.         li $v0, 4
  21.         la $a0, string3
  22.         syscall
  23.        
  24.         li $v0, 5
  25.         syscall
  26.  
  27.         #qui va messo un controllo per avere 1 < N < 10
  28.  
  29.         add $s0, $v0, $zero
  30.        
  31.         li $t2, 0 #indice riga
  32.         li $t3, 0 #indice colonna
  33.         la $s1, M #indirizzo iniziale matrice M
  34.        
  35.  
  36. cicloR: bge $t2, $s0, MAT1 #se l'indice riga è più grande del limite
  37. cicloC: bge $t3, $s0, fineC #se l'indice colonna è più grande del limite
  38.  
  39.         #stampo riga
  40.         li $v0, 4
  41.         la $a0, string1
  42.         syscall
  43.  
  44.         li $v0, 1
  45.         add $a0, $t2, $zero
  46.         syscall
  47.  
  48.         #stampo colonna
  49.         li $v0, 4
  50.         la $a0, string2
  51.         syscall
  52.        
  53.         li $v0, 1
  54.         add $a0 $t3, $zero
  55.         syscall
  56.        
  57.         #a capo
  58.         li $v0, 4
  59.         la $a0, capo
  60.         syscall
  61.  
  62.         #leggo il numero
  63.         li $v0, 5
  64.         syscall
  65.  
  66.         add $s7, $v0, $zero
  67.  
  68.        
  69.         j incremento
  70.  
  71. incremento:
  72.         lw $s7, 0($s1)
  73.         #stampa a video il numero in posizione
  74.         #li $v0, 1
  75.         #add $a0, $s7, $zero
  76.         #syscall
  77.        
  78.         #invio
  79.         li $v0, 4
  80.         la $a0, capo
  81.         syscall
  82.  
  83.         addi $t4, $s1, 4 #scorre le righe con incrementi di 4
  84.         addi $t3, $t3, 1 #scorre le colonne con incrementi di 1
  85.  
  86.         j cicloC
  87.        
  88. fineC:  li $t3, 0
  89.         addi $t2, $t2, 1
  90.         j cicloR
  91.  
  92.         #####################################################################
  93.  
  94. MAT1:   #add $s0, $v0, $zero
  95.        
  96.         li $t2, 0 #indice riga
  97.         li $t3, 0 #indice colonna
  98.         la $s2, M1 #indirizzo iniziale matrice M1
  99.        
  100.         li $t2, 0 #riazzera gli indici
  101.         li $t3, 0 #riazzera gli indici
  102.  
  103. cicloR1: bge $t2, $s0, MAT2 #se l'indice riga è più grande del limite
  104.  
  105. cicloC1: bge $t3, $s0, fineC1 #se l'indice colonna è più grande del limite
  106.  
  107.         #stampo riga
  108.         li $v0, 4
  109.         la $a0, string4
  110.         syscall
  111.  
  112.         li $v0, 1
  113.         add $a0, $t2, $zero
  114.         syscall
  115.  
  116.         #stampo colonna
  117.         li $v0, 4
  118.         la $a0, string5
  119.         syscall
  120.        
  121.         li $v0, 1
  122.         add $a0 $t3, $zero
  123.         syscall
  124.        
  125.         #a capo
  126.         li $v0, 4
  127.         la $a0, capo
  128.         syscall
  129.  
  130.         #leggo il numero
  131.         li $v0, 5
  132.         syscall
  133.  
  134.         add $s5, $v0, $zero
  135.         j incremento1
  136.  
  137. incremento1:
  138.        
  139.         lw $s5, 0($s2)
  140.         #li $v0, 1
  141.         #add $a0, $s5, $zero
  142.         #syscall
  143.        
  144.         li $v0, 4
  145.         la $a0, capo
  146.         syscall
  147.  
  148.         addi $t0, $t0, 4
  149.         addi $t3, $t3, 1
  150.  
  151.         j cicloC1
  152.  
  153. fineC1:        
  154.         li $t3, 0
  155.         addi $t2, $t2, 1
  156.         j cicloR1
  157. ##########
  158.         # matrice risultati
  159.  
  160. MAT2:   #add $s0, $v0, $zero
  161.        
  162.         li $t2, 0 #indice riga
  163.         li $t3, 0 #indice colonna
  164.         la $t0, M2 #indirizzo iniziale matrice M2
  165.        
  166.         li $t2, 0 #riazzera gli indici
  167.         li $t3, 0 #riazzera gli indici
  168.         add $t1, $zero, $zero
  169. ciclo:
  170.  
  171. cicloR2: bge $t2, $s0, fineR2 #se l'indice riga è più grande del limite
  172.  
  173. cicloC2: bge $t3, $s0, fineC2 #se l'indice colonna è più grande del limite
  174.        
  175.         sub $s4, $s0, 1
  176.         mul $s8, $s0, $s0
  177.                
  178.         #prodotto scalare
  179.         mul $t6, $s7, $s5
  180.  
  181.         li $v0, 1
  182.         move $a0, $t6
  183.         syscall
  184.        
  185.         #a capo
  186.         li $v0, 4
  187.         la $a0, capo
  188.         syscall
  189.  
  190.         #add $t6, $a0, $t6
  191.        
  192.         #addi $s7, $s7, 4
  193.         #addi $s5, $s5, 4
  194.        
  195.         addi $t1, $t1, 1
  196.         bne $t1, $s4, ciclo
  197.         j fineR2
  198.        
  199.        
  200. incremento2:
  201.         li $v0, 1
  202.         add $a0, $t6, $zero
  203.         syscall
  204.        
  205.         li $v0, 4
  206.         la $a0, capo
  207.         syscall
  208.  
  209.         addi $t0, $t0, 4
  210.         addi $t3, $t3, 1
  211.  
  212.  
  213.         j cicloC2
  214.        
  215.  
  216. fineC2:        
  217.         li $t3, 0
  218.         addi $t2, $t2, 1
  219.         j cicloR2
  220.        
  221. ###########
  222. fineR2:
  223.         li $v0, 10
  224.         syscall



PM Quote