[C]Prodotto di matrici allocate dinamicamente

[devil_prince]

Ragazzi devo fare il prodotto di matrici, però allocandole (sia le matrici di partenza che quella risultate) dinamicamente. Questo è quello che ho fatto fin ora:

#include <stdio.h>
#include <stdlib.h>

void main ()
{
    int i, j, k, m, n, p, *A, *B, *C, D[100][100];

    puts("-------------------------------");
    puts("PRODOTTO DI MATRICI\n");
    puts("-------------------------------");
    /*input dei parametri m p ed n*/
    printf("Inserire le righe per la prima matrice (parametro -m-): ");
    scanf("%d",&m);
    printf("Inserire le colonne per la prima matrice e righe per la seconda matrice (parametro -p-): ");
    scanf("%d",&p);
    printf("Inserire le colonne per la seconda matrice (parametro -n-): ");
    scanf("%d",&n);
    /*allocazione delle matrici*/
    A=malloc(m*p*sizeof(int));
    B=malloc(p*n*sizeof(int));
    C=malloc(m*n*sizeof(int));


    /*Azzeramento della matrice C*/
    for(i=0;i<m;i++){
        for(j=0;j<n;j++){
        *(C+i*m*j)=0;}
        }


    /*inserimento degli elementi per le matrici A e B*/
    for(i=0;i<m;i++){
        for(j=0;j<p;j++){
        printf("Inserire l'elemento dell'array A di posto (%d,%d): ",i,j);
        scanf("%d",&D[i][j]);}
        }
    printf("Ecco la matrice A allocata dinamicamente\n");
     for(i=0;i<m;i++){             //assegnati i valori alla matrice di appoggio li copiamo in A
        for(j=0;j<p;j++)
        {   *(A+i*p*j)=D[i][j];
            printf("%d ",*(A+i*p*j));}
        puts("\n");}



    for(i=0;i<m;i++){               //azzeriamo la matrice di appoggi
        for(j=0;j<n;j++){
        D[i][j]=0;}
        }
    for(i=0;i<p;i++){                  //assegnati i valori alla matrice di appoggio li copiamo in B
        for(j=0;j<n;j++){
        printf("Inserire l'elemento dell'array B di posto (%d,%d): ",i,j);
        scanf("%d",&D[i][j]);}
        }
    printf("Ecco la matrice B allocata dinamicamente\n");
     for(i=0;i<p;i++){
        for(j=0;j<n;j++)
        {   *(B+i*n*j)=D[i][j];
            printf("%d ",*(B+i*n*j));}
        puts("\n");}



    /*Prodotto di AxB*/
    for(i=0;i<m;i++){
        for(j=0;j<n;j++){
            for(k=0;k<p;k++){
              *(C+i*m*j) = *(A+i*p*k)**(B+k*p*j)+*(C+i*m*j);}
              }
        }
     printf("Ecco la matrice C allocata dinamicamente\n");
     for(i=0;i<n;i++){
        for(j=0;j<m;j++)
        {printf("%d ",*(C+i*m*j));}
        puts("\n");}
}

le matrici di partenza si allocano bene, ma la matrice C risultante ha valori tutti sballati...sbaglio qualcosa nella formula??

[demos88]

è da un po' che non uso l'allocazione dinamica ma a occhio pare che ci sia qualche errore in tutti gli accessi alla memoria.
Prendendo in esempio l'azzeramento della matrice C

/*Azzeramento della matrice C*/
    for(i=0;i<m;i++){
        for(j=0;j<n;j++){
           *(C+i*m*j)=0;
        }
    }

Se ho ben inteso, i che va da 0 a m rappresenta la riga, mentre j da 0 a n la colonna. Tu quindi scrivi da sinistra verso destra una riga alla volta.
Inteso questo, mi vien qualche dubbio su come siano allocati in memoria i dati.
L'indirizzo inferiore si ottiene con i=j=0 e quindi è l'indirizzo di C ed è giusto. Il limite maggiore invece si ha per i=m-1 e j=n-1. Posti per esempio m=n=10, tu allochi 4*10*10=400byte ma il limite maggiore durante l'inserimento arriva ad essere un offset rispetto a C di 9*10*9=810. Sei fuori dall'allocazione che avevi previsto per C... infatti l'indirizzamento corretto sarebbe *(C + i*m + j), ma questo sarebbe giusto se scrivessi char da 1 byte... tu stai scrivendo int da 4 byte (do per scontato che sizeof(int)=4, controlla per sicurezza), quindi l'indirizzamento giusto per te è *(C + 4*(i*m + j)). Facciamo la verifica del limite maggiore: in tal caso si ha un offset massimo di 4*(9*10 + 9)=396, ed è giusto
Innanzi tutto prova a cambiare questo su tutte le matrici, probabilmente scrivendo una matrice andavi a sovrascrivere le altre matrici ma addirittura scrivevi a indirizzi forse occupati da altri dati, quindi mescolavi parecchio i valori. Il motivo per cui ti sembrasse giusta l'allocazione delle prime 2 matrici è banale: tu andavi a scrivere in una locazione di memoria sbagliata e la leggevi subito dopo, è ovvio che leggi il valore che hai appena inserito.

ps: non sono sicuro che ti servano quegli azzeramenti, di fatto tu azzeri la matrice per scriverci poi sopra, tanto vale scriverci sopra direttamente, no?

[BlackShark92]

allora, se usi la calloc non hai alcun bisogno di azzerare la memoria, lo fa da sè.
La sintassi è calloc(numero_di_elementi, dimensione_dell'elemento)

[Lazy Bit]

Non vorrei sbagliarmi ma dovresti usare i puntatori di puntatori: int** matrix, altrimenti la matrice ti viene riconosciuta come unico blocco e non puoi usare la notazione matrix[i][j]. Ricorda di liberare la memoria con free(matrix).

[BlackShark92]

Originariamente inviato da Lazy Bit

Non vorrei sbagliarmi ma dovresti usare i puntatori di puntatori: int** matrix, altrimenti la matrice ti viene riconosciuta come unico blocco e non puoi usare la notazione matrix[i][j]. Ricorda di liberare la memoria con free(matrix).

Ah certo, quello è ovvio, meno male che lo hai fatto notare. Così stai allocando un vettore, invece se vuoi una matrice la devi dichiarare come puntatore a puntatori, ovvero int **A (con 2 star)

[Lazy Bit]

In teoria si potrebbe allocare un unico blocco, utilizzando un normale puntatore, come ha fatto Devil Prince, ma nel caso le matrici contenessero parecchi elementi, sarebbe difficile trovare un intero blocco di grandi dimensioni. Invece, utilizzando i puntatori a puntatori, i blocchi sarebbero di dimensioni ridotte e meglio gestibili (utilizzando la notazione matrix[i][j]).

Comunque, anche se ciò non risolverà il problema, la formula per il calcolo del prodotto di matrici è scorretta, perché la matrice prodotto è C[M, N], e si devono moltiplicare gli elementi riga per colonna. Quindi la formula corretta sarà la seguente:

for(i = 0; i < m; i++)
{
     for(j = 0; j < n; j++)
     {
         for(k = 0; k < m; k++)
         {
             c[i][j] += a[i][k] * b[k][j];
         }
     }
}

L'inizializzazione della matrice a zero non è necessaria. Appena avrò un po' di tempo, inserirò l'algoritmo completo.

PS: Per verificare la correttezza della formula, prova a creare una matrice in modo statico, con dimensioni definite a priori. Una volta avuta la conferma, potrai cercare di allocare la matrice dinamicamente.

[BlackShark92]

Originariamente inviato da Lazy Bit

In teoria si potrebbe allocare un unico blocco, utilizzando un normale puntatore, come ha fatto Devil Prince, ma nel caso le matrici contenessero parecchi elementi, sarebbe difficile trovare un intero blocco di grandi dimensioni. Invece, utilizzando i puntatori a puntatori, i blocchi sarebbero di dimensioni ridotte e meglio gestibili (utilizzando la notazione matrix[i][j]).

Comunque, anche se ciò non risolverà il problema, la formula per il calcolo del prodotto di matrici è scorretta, perché la matrice prodotto è C[M, N], non C[M, P]. Quindi la formula corretta sarà la seguente:

for(i = 0; i < m; i++)
    {
        for(j = 0; j < n; j++)
        {
            for(k = 0; k < m; k++)
            {
                c[i][j] = a[i][k] * b[k][j];
            }
        }
    }

L'inizializzazione della matrice a zero non è necessaria. Appena avrò un po' di tempo, inserirò l'algoritmo completo.

Ti manca un più lì...l'elemento c[i][j]esimo è dato dalla somma di quei prodotti lì...
Ecco qua

int matXmatt(double **matrice1, int nrighe1, int ncolon1, double **matrice2, int nrighe2, int ncolon2, double **res) {
    int i, j, k;
    if (ncolon1!=nrighe2) return -1;
    else {for (i=0; i<nrighe1; i++) {
            for (j=0; j<ncolon2; j++) { res[i][j]= 0.0;
                                        for (k=0; k<ncolon1; k++)
                                        res[i][j]+= matrice1[i][k]*matrice2[k][j];
            }
                                    }
    return 0;
    }
}

Ho messo anche il controllo per gli errori

[Lazy Bit]

Originariamente inviato da BlackShark92

Ti manca un più lì...l'elemento c[i][j]esimo è dato dalla somma di quei prodotti lì...

Giusto!