matriciraresvasiliu

/*
 * Somma e moltiplica due matrici di numeri reali,
 * acquisite tramite tastiera e stampate poi a video.
 */

#include <stdio.h>
#include <stdlib.h> /* fornisce il sottoprogramma calloc */

/* Tipo di dato per gestire le matrici */
typedef struct
{
    double **matrice; /* matrice           */
    int    n_righe,   /* numero di righe   */
           n_colonne; /* numero di colonne */
} matrice_t;

/* Prototipi dei sottoprogrammi */

void scarta_caratteri_in_eccesso();

void acquisisci_dimensione_matrice(int *dimensione, char messaggio[]);

void alloca_matrice(matrice_t *matrice);

void inizializza_matrice(matrice_t *matrice);

matrice_t somma_due_matrici(matrice_t matrice_A, matrice_t matrice_B);

matrice_t moltiplica_due_matrici(matrice_t matrice_A, matrice_t matrice_B);

void visualizza_matrice(matrice_t matrice, char messaggio[]);

int
main(void)
{
    matrice_t matrice_A, matrice_B; /* matrici da acquisire da tastiera                    */
    matrice_t somma_matrici,        /* matrice che conterra' la somma delle due matrici    */
              prodotto_matrici;     /* matrice che conterra' il prodotto delle due matrici */

    printf("+-- Calcolo della somma e del prodotto tra due matrici --+\n\n");

    /* CONFIGURAZIONE DELLE MATRICI */

    /* acquisizione della dimensione delle matrici */
    acquisisci_dimensione_matrice(&matrice_A.n_righe,
                                  "Inserisci la dimensione della matrice A:\n  numero di righe   = ");
    acquisisci_dimensione_matrice(&matrice_A.n_colonne,
                                  "  numero di colonne = ");

    acquisisci_dimensione_matrice(&matrice_B.n_righe,
                                  "\nInserisci la dimensione della matrice B:\n  numero di righe   = ");
    acquisisci_dimensione_matrice(&matrice_B.n_colonne,
                                  "  numero di colonne = ");

    /* allocamento dinamico delle matrici */
    alloca_matrice(&matrice_A);
    alloca_matrice(&matrice_B);

    printf("\n=========================\n");

    /* acquisizione da tastiera delle matrici */
    printf("\nMatrice A numero di righe: %d; numero di colonne: %d\n", matrice_A.n_righe, matrice_A.n_colonne);
    inizializza_matrice(&matrice_A);

    printf("\nMatrice B numero di righe: %d; numero di colonne: %d\n", matrice_B.n_righe, matrice_B.n_colonne);
    inizializza_matrice(&matrice_B);

    printf("\n=========================\n");

    /* OPERAZIONI TRA MATRICI */

    /* Somma */
    /* se le due matrici non hanno la stessa dimensione la somma non si puo' fare */
    if(matrice_A.n_righe == matrice_B.n_righe && matrice_A.n_colonne == matrice_B.n_colonne)
    {

        /* viene eseguita la somma tra la matrice A e la matrice B */
        somma_matrici = somma_due_matrici(matrice_A, matrice_B);

        /* viene visualizzato il risultato tramite una
           stampa a video della matrice somma       */
        visualizza_matrice(somma_matrici,
                           "Risultato somma tra la matrice A e la matrice B:");
    }
    /* se la somma non si puo' fare viene stampato un messaggio di errore */
    else
    {
        printf("\nImpossibile sommare le due matrici.\n");
        printf("  Le matrici devono avere le dimensioni uguali.\n");
    }

    /* Prodotto */
    /* se il numero di colonne della prima matrice non è uguale al numero
       di righe della seconda matrice il prodotto non si puo' fare     */
    if(matrice_A.n_colonne == matrice_B.n_righe)
    {
        /* viene eseguito il prodotto tra la matrice A e la matrice B */
        prodotto_matrici = moltiplica_due_matrici(matrice_A, matrice_B);

        /* viene visualizzato il risultato tramite una
           stampa a video della matrice prodotto    */
        visualizza_matrice(prodotto_matrici,
                           "Risultato prodotto tra la matrice A e la matrice B:");
    }
    /* se il prodotto non si puo' fare viene stampato un messaggio di errore */
    else
    {
        printf("\nImpossibile moltiplicare le due matrici.\n");
        printf("  Il numero di colonne della prima matrice deve corrispondere");
        printf(" al numero di righe della seconda matrice.\n");
    }

    return(0);
}

/*
 *  Scarta i caratteri inseriti in eccesso.
 */
void
scarta_caratteri_in_eccesso(void)
{
    char scarto; /* carattere da non processare */

    do
    {
        scanf("%c", &scarto);
    }while(scarto != '\n');
}

/*
 * Stampa un messaggio che informa quale dato inserire.
 * Acquisisce la quantita' di righe o colonne della matrice.
 */
void
acquisisci_dimensione_matrice(int *dimensione,  /* output - dimensione della matrice  */
                              char messaggio[]) /* input  - testo da stampare a video */
{
    int stato = 0; /* esito dell'acquisizione scanf
                      0 - dato non valido
                      1 - dato valido            */

    do
    {
        /* Acquisisci il dato */
        printf("%s", messaggio);
        stato = scanf("%d", dimensione);

        /* se il dato non e' un numero stampa un messaggio di errore */
        if(stato == 0)
        {
            printf("  Errore! Input non valido\n\n");

            scarta_caratteri_in_eccesso();
        }
        /* nella matrici ci deve essere almeno una riga/colonna */
        else if(*dimensione < 1)
        {
            printf("  Errore! Il valore deve essere maggiore o uguale a 1.\n\n");

            stato = 0; /* il dato acquisito non e' valido */

            scarta_caratteri_in_eccesso();
        }
    }while(stato == 0); /* esegui il ciclo finche' il dato acquisito non e' valido */

    scarta_caratteri_in_eccesso();
}

/*
 * Alloca dinamicamente la matrice in ingresso.
 */
void
alloca_matrice(matrice_t *matrice) /* output - matrice allocata dinamicamente */
{
    int i; /* indice riga */

    /* alloca dinamicamente tutte le righe della matrice */
    (*matrice).matrice = (double **)calloc((*matrice).n_colonne, sizeof(double));

    /* alloca dinamicamente tutte le colonne della matrice */
    for(i = 0; i < (*matrice).n_colonne; i++)
    {
        ((*matrice).matrice)[i] = (double *)calloc((*matrice).n_colonne, sizeof(double));
    }
}

/*
 * Acquisisce il valore di ogni elemento della matrice.
 */
void
inizializza_matrice(matrice_t *matrice) /* output - matrice inizializzata */
{
    int i, /* indice riga                    */
        j, /* indice colonna                 */
        stato; /* esito dell'acquisizione scanf
                  0 - dato non valido
                  1 - dato valido            */

    for(i = 0; i < (*matrice).n_righe; i++)
    {
        printf("  Inserisci valori riga %d\n", (i+1));
        printf("  Inserisci valore elemento 1: ");

        for(j = 0; j < (*matrice).n_colonne; j++)
        {
            stato = scanf("%lf", &((*matrice).matrice)[i][j]);

            /* se il dato non e' un numero stampa un messaggio di errore */
            if(stato == 0)
            {
                j = (*matrice).n_colonne; /* terminiamo il ciclo                         */
                i--;                      /* rieseguiamo l'acquisizione di tutta la riga */

                printf("  Errore! Input non valido\n\n");
            }
        }

        scarta_caratteri_in_eccesso();
    }
}

/*
 * Somma due matrici.
 * Pre: le due matrici hanno la stessa dimensione.
 * Post: la somma tra le due matrici viene salvata nella matrice in ingresso.
 */
matrice_t
somma_due_matrici(matrice_t matrice_A, matrice_t matrice_B) /* input - matrici da sommare */
{
    int i, /* indice riga    */
        j; /* indice colonna */

    matrice_t somma_matrici;

    /* configurazione della matrice che conterra' la somma */
    somma_matrici.n_righe = matrice_A.n_righe;
    somma_matrici.n_colonne = matrice_A.n_colonne;

    alloca_matrice(&somma_matrici);

    for(i = 0; i < matrice_A.n_righe; i++)
    {
        for(j = 0; j < matrice_A.n_colonne; j++)
        {
            somma_matrici.matrice[i][j] = matrice_A.matrice[i][j] +
                                  matrice_B.matrice[i][j];
        }
    }

    return somma_matrici;
}

/*
 * Moltiplica due matrici.
 * Pre: il numero di colonne della prima matrice e' uguale al numero di righe della seconda.
 * Post: il prodotto tra le due matrici viene salvato nella matrice in ingresso.
 */
matrice_t
moltiplica_due_matrici(matrice_t matrice_A, matrice_t matrice_B) /* input - matrici da moltiplicare */
{
    int i, /* indice riga                    */
        j, /* indice colonna della matrice B */
        k; /* indice colonna della matrice A */

    double prodotto_scalare; /* prodotto scalare della i-esima riga di A
                                e della j-esima colonna di B          */

    matrice_t prodotto_matrici;

    /* configurazione della matrice che conterra' il prodotto */
    prodotto_matrici.n_righe = matrice_A.n_righe;
    prodotto_matrici.n_colonne = matrice_B.n_colonne;

    alloca_matrice(&prodotto_matrici);

    for(i = 0; i < matrice_A.n_righe; i++)
    {
        for(j = 0; j < matrice_B.n_colonne; j++)
        {
            prodotto_scalare = 0;

            /* calcolo del prodotto scalare della i-esima riga di A e
               della j-esima colonna di B                          */
            for(k = 0; k < matrice_A.n_colonne; k++)
            {
                 prodotto_scalare += matrice_A.matrice[i][k] * matrice_B.matrice[k][j];
            }

            prodotto_matrici.matrice[i][j] = prodotto_scalare;
        }
    }

    return prodotto_matrici;
}

/*
 * Stampa a video il messaggio e la matrice in ingresso.
 */
void
visualizza_matrice(matrice_t matrice, /* input - matrice da stampare a video   */
                   char messaggio[])  /* input - messaggio da stampare a video */
{
    int i, /* indice riga    */
        j; /* indice colonna */

    printf("\n%s\n", messaggio);

    for(i = 0; i < matrice.n_righe; i++)
    {
        for(j = 0; j < matrice.n_colonne; j++)
        {
            printf("  %11.4f ", matrice.matrice[i][j]);
        }
        printf("\n");
    }
}