Register
- Group
- Member
- Posts
- 82
- Reputation
- 0
- Status
- Offline
|
|
#include <stdio.h>
#include <stdlib.h>
#define MAXDIM 100
typedef struct matrice_t {
int* array;
int row_count;
int column_count;
} matrice;
//Funzioni di accesso alla matrice
void LeggereRiga(matrice m, int row_index, int **out);
void LeggereColonna(matrice m, int column_index, int **out);
int LeggereValore(matrice m, int row_index, int column_index);
void ScrivereRiga(matrice m, const int *row, int row_index);
void ScrivereColonna(matrice m, const int *column, int column_index);
void ScrivereValore(matrice m, int value, int row_index, int column_index);
//Altre operazioni presenti all'interno della matrice
matrice sommaMatrici(matrice a, matrice b);
matrice prodottoScalareMatrice(matrice mat, int scalare);
matrice calcolaTrasposta(matrice mat);
matrice prodottoMatrici(matrice a, matrice b);
//Funzioni per test
void stampaValori(matrice m);
matrice inserimentoValori(matrice m);
int leggereNumero(int limInf, int limSup);
matrice caricaMatrice();
int main(void) {
matrice a; // matrice di numeri interi - matrice
matrice b; // matrice di numeri interi - matrice
matrice somma; //matrice somma di a e b - matrice
matrice prodotto; // matrice prodotto tra a e b - matrice
int scalare; //numero intero da moltiplicare ad a - numero intero
printf("Caricamento della prima matrice: \n");
a = caricaMatrice();
printf("Caricamento della seconda matrice: \n");
b = caricaMatrice();
printf("Matrici inserite: \n");
printf("\tA\n");
stampaValori(a);
printf("\tB\n");
stampaValori(b);
printf("Trasposta della matrice di A\n");
stampaValori(calcolaTrasposta(a));
printf("Inserisci un numero per il prodotto scalare -> ");
scanf("%d", &scalare);
printf("Matrice tra A e B per scalare:\n");
stampaValori(prodottoScalareMatrice(a, scalare));
printf("Calcolo somma tra A e B\n");
somma = sommaMatrici(a, b);
if ((readlines(somma) == -1) && (leggereColonne(somma) == -1)) {
printf(
"Non è possibile calcolare la somma, in quanto A e B non sono dello stesso tipo.\n");
}
else {
printf("Somma della matrice: \n");
stampaValori(somma);
}
printf("Calcola il prodotto tra A e B\n");
prodotto = prodottoMatrici(a, b);
if ((leggereRighe(prodotto) == -1) && (leggereColonne(prodotto) == -1)) {
printf(
"Non è possibile calcolare la somma, in quanto A e B non sono compatibili.\n");
}
else {
printf("Prodotto della matrice: \n");
stampaValori(prodotto);
}
system("pause");
return 0;
}
/*
* Nome: leggereRighe
* Descrizione: La funzione restituisce il numero di righe della matrice
* INPUT: mat - Matrice di dimensione nxm di cui leggere il numero delle righe , n>1 , m>1 - matrice
* OUTPUT: r - numero di righe della matrice mat - numero naturale - >0
*/
void LeggereRiga(matrice m, int row_index, int **out) {
if (row_index > m.row_count)
return;
*out = malloc( sizeof(int) * m.column_count);
int base_index = row_index * m.column_count;
int i = 0;
while (i < m.column_count) {
*out[i] = m.array[i + base_index];
++i;
}
}
/*
* Nome: leggereColonne
* Descrizione: La funzione restituisce il numero di colonne della matrice
* INPUT: mat - Matrice di dimensione nxm di cui leggere il numero delle colone , n>1 , m>1 - matrice
* OUTPUT: c - numero di colonne della matrice mat - numero naturale - >0
*/
void leggereColonna(matrice m, int column_index, int **out) {
if (column_index > m.column_count)
return;
*out = malloc( sizeof(int) * m.row_count);
int i = 0;
while (i < m.column_count) {
*out[i] = m.array[column_index + (i * m.column_count)];
++i;
}
}
/*
* Nome: leggereValore
* Descrizione: La funzione restituisce un valore della matrice
* INPUT: mat - Matrice di dimensione nxm di cui leggere un valore , n>1 , m>1 - matrice
* r - Numero di riga da cui leggere il valore - numero naturale - >0
* c - Numero di colonna da cui leggere il valore - numero naturale - >0
* OUTPUT: valore - Valore che si trova nella r-esima riga e c-esima colonna del campo valori di mat - numero intero
* LAVORO: i - Posizione nel campo di valori di mat - numero intero - >=0 && < n*m
*/
int LeggereValore(matrice m, int row_index, int column_index) {
if (row_index * m.column_count + column_index >= m.row_count * m.column_count)
return -1;
return m.array[row_index * m.column_count + column_index];
}
/*
* Nome: scrivereRighe
* Descrizione: Modifica il numero delle righe della matrice
* INPUT: mat - Matrice di dimensione nxm di cui scrivere il numero delle righe, n>1 , m>1 - matrice
* r - Numero di righe da inserire nel campo righe della matrice mat - numero naturale - >0
* OUTPUT: mat - Matrice di dimensione rxm con il campo righe modificato, r>1 , m>1 - tebella
*/
void ScrivereRiga(matrice m, const int * row, int row_index) {
if (row_index > m.row_count + 1) {
return;
}
int i, padding;
if (row_index == m.row_count + 1) {
++m.row_count;
m.array = realloc(m.array, m.row_count * m.column_count);
}
padding = row_index * m.column_count;
i = 0;
while (i < m.column_count) {
m.array[i + padding] = row[i];
++i;
}
}
/*
* Nome: scrivereColonne
* Descrizione: Modifica il numero delle colonne della matrice
* INPUT: mat - Matrice di dimensione nxm di cui scrivere il numero delle colonne, n>1, m>1 - matrice
* c - Numero di colonne da inserire nel campo colonne della matrice mat - numero naturale - >0
* OUTPUT: mat -Matrice di dimensione nxc con il numero di colonne modificato, n>1, c>1 - tebella
*/
void ScrivereColonna(matrice m, const int *column, int column_index) {
if (column_index > m.column_count + 1) {
return;
}
int i;
if (column_index == m.column_count + 1) {
++m.column_count;
m.array = realloc(m.array, m.row_count * m.column_count);
i = m.row_count*m.column_count-2;
int curr_row=m.row_count-1;
int quantity_shifted = 0;
while(i>column_index){
if(quantity_shifted==m.column_count-1){
--i;
quantity_shifted = 0;
++curr_row;
}
int other_pos = column_index-(m.row_count-curr_row);
m.array[i] = m.array[other_pos];
--i;
++quantity_shifted;
}
}
i = 0;
while (i < m.row_count) {
m.array[i * m.column_count + column_index] = column[i];
++i;
}
}
/*
* Nome: scrivereValore
* Descrizione: La funzione scrive un valore all'interno di una matrice in una specifica posizione
* INPUT: mat - Matrice di dimensione nxm su cui scrivere un valore, n>1, m>1 - matrice
* r - Numero di riga su cui scrivere il valore - numero naturale - >0
* c - Numero di colonna su cui scrivere il valore - numero naturale - >0
* valore : Valore da inserire nella r-esima riga e c-esima colonna della riga nel campo valori di mat - numero intero
* OUTPUT: mat - Matrice con il valore nella r-esima riga e c-esima colonna del campo valori modificato, dimensione nxm, n>1, m>1 - matrice
* LAVORO: i - Posizione nel campo di valori di mat - numero intero - >=0 && < n*m
*/
void ScrivereValore(matrice m, int value, int row_index, int column_index) {
if (row_index * m.column_count + column_index >= m.row_count * m.column_count)
return;
m.array[row_index * m.column_count + column_index] = value;
}
/*
* Nome: sommaMatrici
* Descrizione: La funzione calcola, se possibile, la matrice derivata dalla somma di due matrici dello stesso tipo
* INPUT: a - Matrice di dimensione nxm , n>1, m>1. Da sommare alla matrice b - matrice
* b - Matrice di dimensione nxm , n>1, m>1. Da sommare alla matrice b - matrice
* OUTPUT: s - Matrice derivata dalla somma di a e b, dimensione nxm ,n>1, m>1 (dimensione -1x-1 in caso di errore) - matrice
* LAVORO: i - Indice per scandire le righe di mat e le colonne delle matrici a,b,s - numero intero - <=n
* j - Indice per scandire le colonne di mat e le righe delle matrici a,b,s - numero intero - <=n
*/
matrice sommaMatrici(matrice a, matrice b) {
matrice s;
s.valori = malloc(sizeof(int) * MAXDIM);
int i;
int j;
if ((leggereRighe(a) == leggereRighe(b))
&& (leggereColonne(a) == leggereColonne(b))) {
s = scrivereRighe(s, leggereRighe(a));
s = scrivereColonne(s, leggereColonne(a));
i = 1;
while (i <= leggereRighe(a)) {
j = 1;
while (j <= leggereColonne(a)) {
s = scrivereValore(s, i, j,
leggereValore(a, i, j) + leggereValore(b, i, j));
j++;
}
i++;
}
}
else {
s = scrivereRighe(s, -1);
s = scrivereColonne(s, -1);
}
return s;
}
/*
* Nome: prodottoScalareMatrice
* Descrizione: La funzione calcola il prodotto scalare tra la matrice e un numero
* INPUT: mat - Matrice di dimensione nxm di cui calcolare il prodotto scalare, n>1, m>1 - matrice
* scalare - Valore da moltiplicare a mat - numero intero - /
* OUTPUT: p - Matrice risultato del prodotto di mat per scalare, dimensione nxm, n>1, m>1 - matrice
* LAVORO: i - Indice per scandire le righe di mat e p- numero intero - <=n
* j - Indice per scandire le colonne di mat e p - numero intero - <=m
*/
matrice prodottoScalareMatrice(matrice mat, int scalare) {
matrice p;
p.valori = malloc(sizeof(int) * MAXDIM);
int i;
int j;
p = scrivereRighe(p, leggereRighe(mat));
p = scrivereColonne(p, leggereColonne(mat));
i = 1;
while (i <= leggereRighe(mat)) {
j = 1;
while (j <= leggereColonne(mat)) {
p = scrivereValore(p, i, j, leggereValore(mat, i, j) * scalare);
j++;
}
i++;
}
return p;
}
/*
* Nome: calcolaTrasporta
* Descrizione: La funzione calcola la matrice trasporta di una matrice
* INPUT: mat - Matrice di dimensione nxm di cui calcolare la trasposta, n>1, m>1 - matrice
* OUTPUT: t - Matrice trasposta della matrice mat di dimensione mxn, m>1, n>1 - matrice
* LAVORO: i - Indice per scandire le righe di mat e le colonne di t - numero intero - <=n
* j - Indice per scandire le colonne di mat e le righe di t - numero intero - <=m
*/
matrice calcolaTrasposta(matrice mat) {
matrice t;
t.valori = malloc(sizeof(int) * MAXDIM);
int i;
int j;
t = scrivereRighe(t, leggereColonne(mat));
t = scrivereColonne(t, leggereRighe(mat));
i = 1;
while (i <= leggereRighe(mat)) {
j = 1;
while (j <= leggereColonne(mat)) {
t = scrivereValore(t, j, i, leggereValore(mat, i, j));
j++;
}
i++;
}
return t;
}
/*
*
* Nome: prodottoMatrici
* Descrizione: La funzione calcola, se possibile, la matrice derivata dal prodotto di due matrici "compatibili" (le colonne della prima sono uguali alle righe della seconda)
* INPUT: a - Matrice di dimensione nxm , n>1, m>1. Da moltiplicare alla matrice b - matrice
* b - Matrice di dimensione nxm , n>1, m>1. Da moltiplicare alla matrice b - matrice
* OUTPUT: p - Matrice derivata dal prodotto tra a e b, dimensione nxp , n>1, m>1 (dimensione -1x-1 in caso di errore) - matrice
* LAVORO: i - Indice per scandire le righe - numero intero - <=n
* j - Indice per scandire le colonne - numero intero - <=n
* k - Indice utilizzato per il prodotto riga per colonna - numero intero - <=m
*
*/
matrice prodottoMatrici(matrice a, matrice b) {
matrice p;
p.valori = malloc(sizeof(int) * MAXDIM);
int i;
int j;
int k;
if (leggereColonne(a) == leggereRighe(b)) {
p = scrivereRighe(p, leggereRighe(a));
p = scrivereColonne(p, leggereColonne(b));
i = 1;
while (i <= leggereRighe(a)) {
j = 1;
while (j <= leggereColonne(p)) {
p = scrivereValore(p, i, j, 0);
k = 1;
while (k <= leggereRighe(b)) {
p = ScrivereValore(p, i, j,
leggereValore(p, i, j)
+ (leggereValore(a, i, k)
* leggereValore(b, k, j)));
k++;
}
j++;
}
i++;
}
}
else {
p = scrivereRighe(p, -1);
p = scrivereColonne(p, -1);
}
return p;
}
/*
* Nome: stampaValori
* Descrizione: Stampa a schermo tutti i valori presenti in una matrice
* INPUT: mat - matrice di cui stampare tutti gli elementi dimensione nxm, n>1, m>1 - matrice
* OUTPUT: /
* LAVORO: i: contatore delle righe della matrice mat - numero naturale - >0
* j: contatore delle colonne della matrice mat - numero naturale - >0
*/
void stampaValori(matrice mat) {
int i;
int j;
i = 1;
while (i <= leggereRighe(mat)) {
j = 1;
while (j <= leggereColonne(mat)) {
printf("%d\t", leggereValore(mat, i, j));
j++;
}
i++;
printf("\n");
}
return;
}
/*
* Nome: InserimentoValori
* Descrizione: Consente l'inserimento dei valori all'intero della matrice
* INPUT: mat - matrice di cui inserire gli elementi, dimensione nxm, n>1, m>1 - matrice
* OUTPUT: mat - matrice con gli elementi inseriti, dimensione nxm, n>1, m>1 - matrice
* LAVORO: i: contatore delle righe della matrice mat - numero naturale - >0
* j: contatore delle colonne della matrice mat - numero naturale - >0
* valore: valore da stampare a schermo - numero intero
*/
matrice inserimentoValori(matrice mat) {
int i;
int j;
int valore;
i = 1;
while (i <= leggereRighe(mat)) {
j = 1;
while (j <= leggereColonne(mat)) {
printf("Inserisci elemento in riga %d e colonna %d :", i, j);
scanf("%d", &valore);
mat = scrivereValore(mat, i, j, valore);
j++;
}
i++;
}
return mat;
}
/*
* Nome: CaricaMatrice
* Descrizione: Questa funzione consente di caricare un intera matrice
* INPUT : /
* OUTPUT : mat - Matrice di numeri interi i cui valori sono stati caricati - matrice
* LAVORO: righe - Numero di righe della matrice - numero naturale - 0<r<maxdim
* colonne - Numero di colonne della matrice - numero naturale - 0<c<maxdim
*/
matrice caricaMatrice() {
matrice mat;
mat.valori = malloc(sizeof(int) * MAXDIM);
int righe;
int colonne;
do
{
printf("La matrice può avere al massimo: %d elementi\n", MAXDIM);
printf("Inserisci il numero delle righe:\n");
righe = leggereNumero(1, MAXDIM);
printf("Inserisci il numero delle colonne: \n");
colonne = leggereNumero(1, MAXDIM);
} while ((righe * colonne) > MAXDIM);
mat = scrivereRighe(mat, righe);
mat = scrivereColonne(mat, colonne);
printf("Inserisci i valori: \n");
mat = inserimentoValori(mat);
return mat;
}
/*
* Nome: LeggereNumero
* Descrizione: Consente l'inserimento di un numero compreso in un certo intervallo
* INPUT: limInf - Limite inferiore dell'intervallo - numero intero
* limSup - Limite superiore dell'intervallo - numero intero
* OUTPUT: n - valore letto da tastiera compreso nell'intervallo - numero intero - limInf<=n<=limSup
*/
int leggereNumero(int limInf, int limSup) {
int n;
do {
printf("Inserisci un numero compreso tra %d e %d : -> ", limInf, limSup);
scanf("%d", &n);
} while (n < limInf || n > limSup);
return n;
}
|
|
