[Assembly] operazioni con le matrici

[InfoLuca]

Salve a tutti,vi prego di aiutarmi, sono esasperato

Scrivere una procedura assembly che, data una matrice M di word di
dimensione 5x5, restituisca una matrice R (di dimensione 5x2) contenente
le sole colonne di indice dispari di M. Scrivere, inoltre, il programma
principale che invochi opportunamente la suddetta procedura.
Ad esempio si consideri la matrice M riportata sulla destra, la procedura
dovrà restituire la matrice R riportata sulla sinistra.

M:

2	5	8	-4	7
-21	3	-12	-10	-11
5	31	4	0	14
+8	3	89	9	-56
-23	-45	-97	8	30

R:

5	-4
3	-10
31	0
3	9
-45	8

Come posso implementarlo in Assembly? premetto che uso TASM su windows, e come editor pspad.

vi ringrazio infinitamente...

[MItaly]

Come è fornita la matrice iniziale? Si chiede di acquisirla da tastiera/file/... o è in memoria? L'output in che formato deve essere? Cos'hai scritto finora?

[InfoLuca]

Ciao, innanzi tutto volevo ringraziarti per la tempestività della risposta e del tuo interesse,
Ho modificato il messaggio postando direttamente il testo dell'esercizio.

La matrice può essere fornita direttamente, non so come risolvere l'esercizio in quanto non so come gestire le matrici, mi sono affacciato da poco sull'assembly e non si trova praticamente nulla in rete riguardanti esercizi del genere.

non ho messo ancora mano al codice perchè non riesco a capire come potrei gestire la matrice.

[oregon]

La matrice è data e quindi la puoi scrivere nel tuo programma come sequenza di valori.

[InfoLuca]

non uccidermi se ti posto un "obrobrio", ho creato prima il programma in java e poi ho provato a tradurlo in assembly, ma sono consapevole che sia tutto sbagliato

public static void main (String[]args){
            //stampa colonne dispari di matrice
        int[][] mat= leggiMatrice();
                ArrayList r = new ArrayList();
                int index;
        for (int i=0; i<mat.length; i++)
        for (int j=0; j<mat[0].length; j++){
        System.out.println ("Mat= "+mat[i][j]);
                
                 index=j%2;
                 if(index != 0){

                    r.add(mat[i][j]);
                    
                    
                }
                }
  
                    System.out.println("R: "+r);
    }

e questo è quello che ho scritto in ASSEMBLY:

.MODEL SMALL
.STACK 100H
.DATA
MAT DW 2,5,8,-4,7,-21,3,-12,-10,-11,5,-31,4,0,14,8,3,89,9,-56,-23,-45,-97,8,30  ;definisco matrice M sotto forma di vettore
 
N EQU 5
M EQU 5
R DW 0,0,0,0,0,0,0,0,0,0   ;definisco matrice R sotto forma di vettore inizializzata a 0

.CODE
.STARTUP
   
            MOV EDX,MAT
            MOV AX,0
            MOV BX,0         ;bx=i
            MOV CX,0         ;cx=j
           
    CICLO1: 
                              
            CMP BX,N
            JGE FINE
            INC BX
            JMP CICLO2
            
     CICLO2:
                   
            CMP CX, M
            JGE ANALIZZA
            INC CX
            JMP FINE
            
    ANALIZZA: 
            MOV DX,CX
            DIV DX,2 ; DOVREI DIVIDERE L'INDICE DI COLONNA PER 2 E VEDERE SE C'è IL RESTO PER DETERMINARE SE è PARI O DISPARI
            ;????????????   NON SO COME VERIFICARE SE DX CHE CONTIENE L'INDICE DI COLONNA è PARI O DISPARI
            ;NEL CASO L'INDICE è DISPARI DEVO COPIARE ELEMENTI.....HELP ME XD!!!
    FINE:
           MOV AH,4CH          ;ri do il controllo al DOS
           INT 21H
    
    END

se mi date qualche dritta per risolvere l'esercizio ve ne sono immensamente grato

[InfoLuca]

gironzolando qua e la ho cercato di creare uno "schemino" per la gestione delle matrici, dovrei adattarlo al mio rpoblema....non so quanto sia giusto, anche perchè ci sono alcuni passaggi non chiari.

.MODEL SMALL
.STACK 100h
.DATA
     M DW 2,5,8,-4,7,-21,3,-12,-10,-11,5,31,4,0,14,8,3,89,9,-56,-23,-45,-97,8,30 ;DEFINISCO MATRICE M
     DIM $-M     
     N equ 5                                        ;N=RIGHE DI M
     RC equ 2                                        ;RC= COLONNE DI R
     R DW 0,0,0,0,0,0,0,0,0,0        ;INIZIALIZZO MATRICE RISULTATO R

.START
.STARTUP

            SUB ESP,4       ;alloco spazio nello stack
            PUSH DWORD N
            PUSH DWORD DIM
            PUSH M
            CALL NOMEMETODO
            POP ECX   

NOMEMETODO:
            PUSH EBP               ;
            MOV EBP,ESP
            ADD EBP,8
            MOV EDI,[EBP]
            MOV EAX,0       ;in eax metto lo spazio occupato dalle righe (=5)
            MOV EBX,0        ; indice di colonna (m) che ogni volta incremento di 2
            MOV ECX,0        ;variabile di supporto "temp"      
            MOV ESI,[EBP+8]   ; ESI= N
            SHL ESI,1        ;tengo in esi N*2      ;

SCANSIONERIGA:
            CMP EBX, ESI      ;confronta indice colonne 
            JE CAMBIARIGA
            MOV DX,[EDI+EBX]   ;COPIO ELEMENTO MATRICE IN DX
            ADD EBX,2           ;incremento di 2 ebx
           ; .... analizzo elemento es CMP;IN DX DOVREI AD OGNI ITERAZIONE L'ELEMENTO DI M
           ;.... per esempio lo metto in R 
           JMP SCANSIONERIGA
CAMBIARIGA:
            CMP EAX,[EBP+4]
            JE FINE
            ADD EAX,ESI
            ADD EDI,EAX
            MOV EBX,0
            JMP SCANSIONERIGA
FINE:      
           MOV [EBP+16],ECX
           POP EBP
           RET 16

[InfoLuca]

nessuno sa aiutarmi?

[InfoLuca]

help me please XD

[M.A.W. 1968]

Purtroppo ho pochissimo tempo. Qual è il punto sul quale incontri difficoltà? Hai un'idea di cosa siano il row-major e il column-major order per la memorizzazione di matrici dense bi- e multidimensionali? Riesci a descrivere almeno l'algoritmo che devi applicare per "estrarre" le colonne come richiesto?

[InfoLuca]

Purtroppo ho pochissimo tempo. Qual è il punto sul quale incontri difficoltà? Hai un'idea di cosa siano il row-major e il column-major order per la memorizzazione di matrici dense bi- e multidimensionali? Riesci a descrivere almeno l'algoritmo che devi applicare per "estrarre" le colonne come richiesto?

Innanzi tutto ti ringrazio per la risposta, ci avevo perso le speranze

Dunque il problema come spiegato sopra si tratta di estrarre le colonne di indice dispari da una matrice 5x5 e di ritornare quindi una matrice 5x2 contenenti le suddette colonne.

Ho cercato di risolvere il problema con l'ultimo codice che ho postato, per avere giusto uno schema su cui pogiarmi, ma purtroppo non ne so molto, e non conosco quello che tu dici.

L'algoritmo in sostanza dovrebbe funzionare grossomodo così:

mat[25] = 1,2,3,4,5,6,7,8,.... (linearizzo la matrice trattandola come un vettore)
vettore risultato R;
indexR=0;
indexC=0;
for(i=0,i<=mat.length, i++)
if(indexC= DISPARI)
copia colonna di indice index in R
se no salta all'altra colonna e ripeti test