-
.
//SOMMA BINARIA
INPUT
A - Vettore di interi contenente un numero binario - array di interi monodimensionale - contiene n bit
n - numero di bit contenuti in A - numero intero - >0
B - Vettore di interi contenente un numero binario - array di interi monodimensionale - contiene m bit
m - numero di bit contenuti in B - numero intero - >0
OUTPUT
C - Vettore di interi contentente la somma binaria di A e B - array di interi monodimensionale
ALGORITMO
SE(n>m)
ALLORA
c:=somma(A,n,B,m)
ALTRIMENTI
c:=somma(B,m,A,n)
FINE
funzione somma
INPUT
v1 - Vettore di interi contenente un numero binario - array di interi monodimensionale - contiene n bit
n - numero di bit contenuti in v1 - numero intero - >0
v2 - Vettore di interi contenente un numero binario - array di interi monodimensionale - contiene m bit
m - numero di bit contenuti in v2 - numero intero - >0
OUTPUT
C - Vettore di interi contentente la somma binaria di v1 e v2 - array di interi monodimensionale
ALGORITMO
i:=1
carry:=0
MENTRE(i<=m)
MENTRE(i<=n)
somma:=i-esimo elemento di V1+i-esimo elemento di v2+carry
SE(MODULO(somma,2)==0)
ALLORA
i-esimo elemento di C:=0
ALTRIMENTI
i-esimo elemento di C:=1
FINE
SE(somma>1)
ALLORA
carry:=1
ALTRIMENTI
carry:=0
FINE
i:=i+1
FINE
somma:=i-esimo elemento di v1+carry
SE(MODULO(somma,2)==0)
ALLORA
i-esimo elemento di C:=0
ALTRIMENTI
i-esimo elemento di C:=1
FINE
SE(somma>1)
ALLORA
carry:=1
ALTRIMENTI
carry:=0
FINE
i:=i+1
FINE
i-esimo elemento di C:=carry -
.
https://nanoroms.net/nsp-collection/ vedi se trovi quello che ti serve qui -
.
INPUT
tab - tabella contenente i punti delle squadre per ogni giornata – matrice – /
OUPUT
Vet – Per ogni giornata contiene la squadra che aveva piu punti in quella giornata – vettore a una dimensione – dimensione m
ALGORITMO
j:=1
MENTRE (j<=leggiColonne(tab))
squadra:=trovaSquadra(tab,j)
j-esimo elemento di vet:=squadra
j:=j+1
FINE
trovaSquadra
INPUT
tab - tabella contenente i punti delle squadre per ogni giornata – matrice – /
j - giornata di riferimento - numero intero - >0
OUTPUT
squadra - squadra che ha il punteggio piu alto nelle j giornate analizzate
ALGORITMO
squadra:=1
max:=punteggioSquadra(tab,1,j)
i:=2
MENTRE (i<=leggereRighe(tab))
punteggio:=punteggioSquadra(tab,i,j)
SE (punteggio>max) ALLORA
max:=punteggio
squadra:=i
FINE
i:=i+1
FINE
punteggioSquadra
INPUT
tab - tabella contenente i punti delle squadre per ogni giornata – matrice – /
i - squadra di cui analizzare il punteggio nelle j giornate - intero - >0
j - giornata di riferimento - numero intero - >0
OUTPUT
punteggio - punteggio della squadra nelle j giornate - intero - >=0
ALGORITMO
somma:=0
k:=1
MENTRE (k<=j)
somma:=somma+leggiValore(tab,i,k)
k:=k+1
FINE -
.
TRACCIA: Verifica che una matrice sia un quadrato magico (cioč che la somma di ogni riga, la somma di ogni colonna, la somma della diaginale principale e secondaria siano uguali)
//TIPO DI DATO MATRICE CON FUNZIONI DI ACCESSO
INPUT
mat - matrice quadrata di numeri interi di cui bisogna verificare se č un quadrato magico o meno - matrice - /
OUTPUT
esito - indica se la matrice č un quadrato magico o meno - booleano - vero o falso
ALGORITMO
esito:=vero
numeroMagico:=sommaRiga(mat,1)
i:=2
MENTRE (i<=leggereRighe(mat) AND esito=vero)
SE (sommaRiga(mat,i)!=numeroMagico) ALLORA esito:=falso
FINE
i:=i+1
FINE
j:=1
MENTRE (j<=leggereColonne(mat) AND esito=vero)
SE (sommaColonna(mat,j)!=numeroMagico) ALLORA esito:=falso
FINE
j:=j+1
FINE
SE (esito=vero) ALLORA
SE ((sommaDiagonalePrincipale(mat)!=numeroMagico) OR (sommaDiagonaleSecondaria(mat)!=numeroMagico)) ALLORA esito:=falso
FINE
FINE
funzione sommaRiga
INPUT
mat - matrice quadrata di numeri interi di cui bisogna verificare se č un quadrato magico o meno - matrice - /
i - numero di riga di cui controllare la somma - numero intero - >0
OUTPUT
somma - somma della riga - intero -/
ALGORITMO
somma:=0
j:=1
MENTRE (j<=leggereColonne(mat))
somma:=somma+leggereValore(mat,i,j)
j:=j+1
FINE
funzione sommaColonna
INPUT
mat - matrice quadrata di numeri interi di cui bisogna verificare se č un quadrato magico o meno - matrice - /
j - numero di colonna di cui controllare la somma - numero intero - >0
OUTPUT
somma - somma della colonna - intero -/
ALGORITMO
somma:=0
i:=1
MENTRE (i<=leggereRighe(mat))
somma:=somma+leggereValore(mat,i,j)
i:=i+1
FINE
funzione sommaDiagonalePrincipale
INPUT
mat - matrice quadrata di numeri interi di cui bisogna verificare se č un quadrato magico o meno - matrice - /
OUTPUT
somma - somma della diagonale principale - intero -/
ALGORITMO
i:=1
somma:=0
MENTRE (i<=leggereRighe)
somma:=somma+leggereValore(mat,i,i)
i:=i+1
FINE
funzione sommaDiagonaleSecondaria
INPUT
mat - matrice quadrata di numeri interi di cui bisogna verificare se č un quadrato magico o meno - matrice - /
OUTPUT
somma - somma della diagonale secondaria - intero -/
ALGORITMO
i:=1
j:=leggereColonne
somma:=0
MENTRE (i<=leggereRighe)
somma:=somma+leggereValore(mat,i,i)
i:=i+1
j:=j-1
FINE -
.
Realizzare una funzione the riceve come parametro di input una matrice di n righe ed m colonne di numeri interi casuali compresi tra 0 e 20 e individua la colonna in cui la massima differenza (in valore assoluto) tra due elementi consecutivi sia minima.
Esempio ConsWeriamo la seguente matrice costituita da n = 4 righe ed m = 3 colonne: 15 13 7 A= 6 18 4 11 4 12 1395
La massima differenza tra gli elementi consecutivi della prima colonna 6 9 =15-6; per la seconda colonna 6 14 =18-4; per la terza 6 8 = 14-121. Quindi it programma deve stampare la terza colonna la cui massima differenza 6 minima. -
.
int parentesi(char str[], int lungh){
int bool;
int pAperta;
int i=0;
pAperta=0;
while(i < lungh){
if(str[i] == '('){
pAperta++;
} else if(str[i] == ')'){
pAperta--;
}
i++;
}
if(pAperta == 0){
bool=1;
}else{
bool=0;
}
return bool;
} -
.
#include <stdio.h>
#include <stdlib.h>
typedef struct {
int **valori;
int riga;
int col;
} tabella;
int leggi_riga(tabella t);
int leggi_col(tabella t);
int leggi_valore(tabella *t, int riga, int col);
void scrivi_riga(tabella *t, int valore);
void scrivi_col(tabella *t, int valore);
void scrivi_valore(tabella *t, int riga, int col, int valore);
int somma_diagonale_principale(tabella t);
int somma_diagonale_sec(tabella t);
int prodotto_diagonali(int n, int m);
void popola_tabella(tabella *t);
void stampa_tabella(tabella *t);
int main() {
tabella tab;
int dim;
int somma1;
int somma2;
int prodotto;
printf("Inserisci dimensioni tabella: ");
scanf("%d", &dim);
scrivi_riga(&tab, dim);
scrivi_col(&tab, dim);
tab.valori = (int**) malloc(sizeof(int*)*leggi_col(tab));
int i = 0;
while (i < leggi_col(tab)) {
*(tab.valori+i) = (int*) malloc(sizeof(int)*leggi_riga(tab));
i++;
}
popola_tabella(&tab);
stampa_tabella(&tab);
somma1 = somma_diagonale_principale(tab);
somma2 = somma_diagonale_sec(tab);
prodotto = prodotto_diagonali(somma1, somma2);
printf("Somma diagonale principale: %d\n", somma1);
printf("Somma diagonale secondaria: %d\n", somma2);
printf("Prodotto tra le somme delle diagonali: %d\n", prodotto);
system("pause");
}
int leggi_riga(tabella t) {
int a = t.riga;
return a;
}
int leggi_col(tabella t) {
int a = t.col;
return a;
}
int leggi_valore(tabella *t, int riga, int col) {
int a = t->valori[riga][col];
return a;
}
void scrivi_riga(tabella *t, int valore) {
t->riga = valore;
}
void scrivi_col(tabella *t, int valore) {
t->col = valore;
}
void scrivi_valore(tabella *t, int riga, int col, int valore) {
t->valori[riga][col] = valore;
}
int somma_diagonale_principale(tabella t) {
int i = 0;
int tmp = 0;
while (i < leggi_riga(t)) {
tmp += leggi_valore(&t, i, i);
i++;
}
return tmp;
}
int somma_diagonale_sec(tabella t) {
int i = 0;
int tmp = 0;
int col = leggi_riga(t)-1;
while (i < leggi_riga(t)) {
tmp += leggi_valore(&t, i, col-i);
i++;
}
return tmp;
}
int prodotto_diagonali(int n, int m) {
int valore = n * m;
return valore;
}
void popola_tabella(tabella *t) {
int scan;
int x = 0;
while (x < leggi_riga(*t)) {
int y = 0;
while (y < leggi_riga(*t)) {
printf("Inserisci valore in riga %d, colonna %d: ", x, y);
scanf("%d", &scan);
scrivi_valore(t, x, y, scan);
y++;
}
x++;
}
}
void stampa_tabella(tabella *t) {
int z = 0;
while (z < leggi_riga(*t)) {
int k = 0;
while (k < leggi_riga(*t)) {
printf(" %d ", leggi_valore(t, z, k));
k++;
}
z++;
printf("\n");
}
} -
.
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX 100
typedef struct{
char v[MAX+1];
int lun;
}stringa;
void calcoloLunghezza(stringa *frase);
void inverti(stringa *frase);
void stampaStringa(stringa frase);
int main(){
stringa frase;
printf("Inserisci parola: ");
gets(frase.v);
calcoloLunghezza(&frase);
printf("Lunghezza stringa: %d\n", frase.lun);
inverti(&frase);
stampaStringa(frase);
}
void calcoloLunghezza(stringa *frase){
int i = 0;
while(frase->v[i] != '\0'){
i++;
}
frase->lun = i;
return;
}
void inverti(stringa *frase){
int i = 0;
frase->v[i] = frase->v[i] - 32;
i = 1;
while(i<frase->lun){
if(frase->v[i] == ' ') {
if (frase->v[i+1] >= 'A' || frase->v[i+1] <= 'Z') {
frase->v[i+1] = frase->v[i+1] - 32;
}
}
i++;
}
return;
}
void stampaStringa(stringa frase){
int i = 0;
while(i < frase.lun){
printf("%c", frase.v[i]);
i++;
}
return;
} -
.
#include <stdio.h>
#include <stdlib.h>
//Assegnata una matrice di interi di riempimenti N
//ed M, eliminare la colonna in posizione K
typedef struct {
int **valori;
int riga;
int col;
} tabella;
int leggi_riga(tabella t);
int leggi_col(tabella t);
int leggi_valore(tabella *t, int riga, int col);
void scrivi_riga(tabella *t, int valore);
void scrivi_col(tabella *t, int valore);
void scrivi_valore(tabella *t, int riga, int col, int valore);
void caricaTabella(tabella *t);
void stampa_tabella(tabella *t);
void shift(tabella *t, int k);
int main() {
tabella matrice;
int colonne;
int righe;
int k;
colonne = 0;
righe = 0;
printf("Inserisci numero colonne: ");
scanf("%d", &colonne);
printf("Inserisci numero righe : ");
scanf("%d", &righe);
scrivi_col(&matrice, colonne);
scrivi_riga(&matrice, righe);
matrice.valori = (int**) malloc(sizeof(int*)*leggi_col(matrice));
int i = 0;
while (i < leggi_col(matrice)) {
*(matrice.valori+i) = (int*) malloc(sizeof(int)*leggi_riga(matrice));
i++;
}
caricaTabella(&matrice);
printf("Inserisci colonna da eliminare: ");
scanf("%d", &k);
shift(&matrice,k);
stampa_tabella(&matrice);
system("PAUSE");
return 0;
}
int leggi_riga(tabella t) {
int a = t.riga;
return a;
}
int leggi_col(tabella t) {
int a = t.col;
return a;
}
int leggi_valore(tabella *t, int riga, int col) {
int a = t->valori[riga][col];
return a;
}
void scrivi_riga(tabella *t, int valore) {
t->riga = valore;
}
void scrivi_valore(tabella *t, int riga, int col, int valore) {
t->valori[riga][col] = valore;
}
void caricaTabella(tabella *t){
int scan;
int x = 0;
while (x < leggi_riga(*t)) {
int y = 0;
while (y < leggi_riga(*t)) {
printf("Inserisci valore in riga %d, colonna %d: ", x, y);
scanf("%d", &scan);
scrivi_valore(t, x, y, scan);
y++;
}
x++;
}
}
void stampa_tabella(tabella *t) {
int z = 0;
while (z < leggi_riga(*t)) {
int k = 0;
while (k < leggi_col(*t)) {
printf(" %d ", leggi_valore(t, z, k));
k++;
}
z++;
printf("\n");
}
}
void shift(tabella *t, int k){
int i = 0;
int colonne = k;
while(colonne<t->col){
i=0;
while(i<t->riga){
t->valori[i][colonne] = t->valori[i][colonne+1];
i++;
}
colonne++;
}
t->col--;
return;
}
void scrivi_col(tabella *t, int valore) {
t->col = valore;
} -
.
Esercitazione del 13 gennaio 2022
Realizzare una funzione che riceve come parametro di input una tabella quadrata
A di nxn numeri interi, e calcola il prodotto della somma degli elementi della
diagonale principale per la somma degli elementi della diagonale secondaria
Il tipo di dato tabella deve essere rappresentato come un record contenente un vettore dinamico
di interi a 2 dimensioni e due interi rappresentanti le dimensioni.
Realizzare le funzioni accesso al tipo di dato tabella.
NB
Realizzare gli algorit
Ce NON consegnare.
https://teams.microsoft.com/l/meetup-join/...2%22%7d -
.
#include <stdio.h>
#include <stdlib.h>
#define MAXDIM 100
typedef struct {
int valori[MAXDIM];
int righe;
int colonne;
} tabella;
int leggereNumero(int limInf, int limSup);
int leggereRighe(tabella mat);
int leggereColonne(tabella mat);
int leggereValore(tabella mat, int r, int c);
tabella scrivereRighe(tabella mat, int r);
tabella scrivereColonne(tabella mat, int c);
tabella scrivereValore(tabella mat, int r, int c, int valore);
tabella sommaTabelle(tabella a, tabella b);
void stampaValori(tabella t);
tabella inserimentoValori(tabella t);
tabella caricaTabella();
int main(void) {
tabella t;
int Nr;
t = caricaTabella();
printf("\tSTAMPA DI TUTTI I VALORI\n");
Nr = individuaRiga(t);
printf("La riga la cui somma degi elementi č massima č: %d");
system("pause");
return 0;
}
int leggereRighe(tabella tab) {
int r;
r = tab.righe;
return r;
}
int leggereColonne(tabella tab) {
int c;
c = tab.colonne;
return c;
}
int leggereValore(tabella tab, int r, int c) {
int valore;
int i;
i = (r - 1) * leggereColonne(tab) + (c - 1);
valore = tab.valori[i];
return valore;
}
tabella scrivereRighe(tabella tab, int r) {
tab.righe = r;
return tab;
}
tabella scrivereColonne(tabella tab, int c) {
tab.colonne = c;
return tab;
}
tabella scrivereValore(tabella tab, int r, int c, int v) {
int i;
i = (r - 1) * leggereColonne(tab) + (c - 1);
tab.valori[i] = v;
return tab;
}
tabella sommaTabelle(tabella a, tabella b) {
tabella s;
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;
}
void stampaValori(tabella 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;
}
tabella inserimentoValori(tabella tab) {
int i;
int j;
int valore;
i = 1;
while (i <= leggereRighe(tab)) {
j = 1;
while (j <= leggereColonne(tab)) {
printf("Inserisci elemento in riga %d e colonna %d ", i, j);
scanf("%d", &valore);
tab = scrivereValore(tab, i, j, valore);
j++;
}
i++;
}
return tab;
}
tabella caricaTabella() {
tabella tab;
int righe;
int colonne;
do
{
printf ("LA MATRICE PUO' AVERE AL MASSIMO %d elementi\n", MAXDIM);
printf("INSERIRE IL NUMERO DELLE RIGHE\n");
righe = leggereNumero(1, MAXDIM);
printf("INSERIRE IL NUMERO DELLE COLONNE\n");
colonne = leggereNumero(1, MAXDIM);
}
while ((righe*colonne)>MAXDIM);
tab = scrivereRighe(tab, righe);
tab = scrivereColonne(tab, colonne);
printf("INSERIMENTO DEI VALORI\n");
tab = inserimentoValori(tab);
return tab;
}
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;
} -
.
Esercitazione del 12 gennaio 2022
Realizzare una funzione che riceve come parametri di input una tabella di interi
(n righe ed m colonne) e individua l'indice della riga la cui somma degli elementi
e' massima.
Il tipo di dato tabella deve essere rappresentato come un record contenente un vettore statico
di interi a 2 dimensioni e due interi rappresentanti le dimensioni.
Realizzare le funzioni accesso al tipo di dato tabella.
N.B.
Realizzare gli algoritmi di tutte le funzioni individuate e il codice in linguaggio C e consegnare entro le 13.30
-
.
DOMANDE ARCHITETTURA DEGLI ELABORATORI
1) Si descriva il data path di una macchina di Von neuman.
Il data path di una macchina di von neuman non č altro che il percorso dati che fa un’informazione
per poter essere processata. Nella migliore dei casi l’informazione in questione č giŕ presente
all’interno dei registri, ma essa puň trovarsi anche nella memoria. Se si trova nella memoria essa
verrŕ spostata nei registri e potrŕ iniziare il processamento. Il processo , mettiamo per esempio che
noi volessimo fare la somma di 2 numeri , consiste nel prelevare il 2 numeri dai registri , e portarli
alla ALU che si occupa dei calcoli. A questo punto la ALU invierŕ il risultato ai registri. Questi
spostamenti vengono effettuati tramite alcuni bus.
2) Stati di una esecuzione ed interprete.
In genere questi step sono sette:
- Prelevare la successiva istruzione dalla memoria per portarla nell’IR (istructionregister)
- Modificare il PC (programcounter) per farlo puntare all’istruzione seguente
- Determinare il tipo dell’istruzione appena prelevata
- Se l’istruzione usa una parola in memoria, determinare dove si trova
- Se necessario, prelevare la parola per portarla in un registro della CPU
- Eseguire l’istruzione
- Tornare all’inizio per eseguire l’esecuzione successiva
3) Architetture con Pipeline
Quando parliamo di pipeline indichiamo un’architettura costruita con lo scopo di eseguire
operazioni in parallelo. Difatti il concetto di pipeline si basa sul dividere l’esecuzione in piů stadi di
esecuzioni e affidandola a parti hardware dedicati. in questo modo l’esecuzione č piů semplice e
veloce. Un’architettura con una pipeline ad esempio con 5 stadi opera sull’esecuzione in questo
modo :
- Unitŕ di fetch dell’istruzione
- Unitŕ di decodifica dell’istruzione
- Unitŕ di fetch degli operandi
- Unitŕ di esecuzione dell’istruzione
- Unitŕ di memorizzazione del risultato
Esistono anche processori con architettura con 2 pipeline a 5 stati (es. intelpentium). nel caso
specifico del pentium della intel, esso era dotato di un pipeline principale(pipelineu) che poteva
eseguire qualsiasi istruzione del processore, e di una pipeline secondaria(pipelinev) che eseguiva
solo semplici istruzioni. Le prestazioni di un’architettura con pipeline si misura in questo modo:
prendiamo in considerazione k(stadi pipeline), n(numero istruzioni da eseguire), t(il tempo
massimo di un stadio). Quindi il t(pipe) = [k+(n - 1)] * t
Si puň fare un confronto di quanto sia piů veloce un’architettura pipeline rispetto ad una
tradizionale:
𝑇(𝑐𝑜𝑛𝑣𝑒𝑛𝑧𝑖𝑜𝑛𝑎𝑙𝑒)
𝑇(𝑝𝑖𝑝𝑒𝑙𝑖𝑛𝑒)
=
𝑛𝑘𝑡
[𝑘 + (𝑛 − 1)] ∗ 𝑡
=
𝑛𝑘
[𝑘 + (𝑛 − 1)]
In un’architettura con pipeline č soggetta anche a salti, essi sono problemi che minano al corretto
funzionamento della pipeline. Tuttavia ci sono alcune soluzioni a questo problema:
- Flussi multipli (multiple stream)
http://drive.google.com/drive/folders/1etD...cW0?usp=sharing -
.
http://drive.google.com/drive/folders/1etD...cW0?usp=sharing -
.
#define _CRT_SECURE_NO_WARNINGS #include <stdio.h> #include <stdlib.h> #define MAXDIM 100 typedef struct { int* valori; //Numeri interi presenti all�interno della matrice - vettore di interi a una dimensione - dimensione >1 int righe; //numero delle righe della matrice - numero naturale - 0<righe<maxdim int colonne; //numero delle colonne della matrice - numero naturale - 0<colonne<maxdim } matrice; //FUNZIONI DI ACCESSO ALLA MATRICE int leggereRighe(matrice mat); int leggereColonne(matrice mat); int leggereValore(matrice mat, int r, int c); matrice scrivereRighe(matrice mat, int r); matrice scrivereColonne(matrice mat, int c); matrice scrivereValore(matrice mat, int r, int c, int valore); //ALTRE OPERAZIONI SULLA 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 PRIMA MATRICE\n"); a = caricaMatrice(); printf("CARICAMENTO SECONDA MATRICE\n"); b = caricaMatrice(); printf("ECCO LE MATRICI INSERITE \n"); printf("\tA\n"); stampaValori(a); printf("\tB\n"); stampaValori(b); printf("ECCO LA MATRICE TRASPORTA DI A\n"); stampaValori(calcolaTrasposta(a)); printf("Inserisci un numero per il prodotto scalare -> "); scanf("%d", &scalare); printf("ECCO LA MATRICE DERIVATA DA A per SCALARE\n"); stampaValori(prodottoScalareMatrice(a, scalare)); printf("PROVO A CALCOLARE LA SOMMA TRA A e B\n"); somma = sommaMatrici(a, b); if ((leggereRighe(somma) == -1) && (leggereColonne(somma) == -1)) { printf( "NON POSSO CALCOLARE LA SOMMA IN QUANTO A e B NON SONO DELLO STESSO TIPO\n"); } else { printf("MATRICE SOMMA \n"); stampaValori(somma); } printf("PROVO A CALCOLARE IL PRODOTTO TRA A e B\n"); prodotto = prodottoMatrici(a, b); if ((leggereRighe(prodotto) == -1) && (leggereColonne(prodotto) == -1)) { printf( "NON POSSO CALCOLARE LA SOMMA IN QUANTO A e B NON COMPATIBILI\n"); } else { printf("MATRICE PRODOTTO \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 */ int leggereRighe(matrice mat) { int r; r = mat.righe; return r; } /* * 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 */ int leggereColonne(matrice mat) { int c; c = mat.colonne; return c; } /* * 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 mat, int r, int c) { int valore; int i; i = (r - 1) * leggereColonne(mat) + (c - 1); valore = mat.valori[i]; return valore; } /* * 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 */ matrice scrivereRighe(matrice mat, int r) { mat.righe = r; return mat; } /* * 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 */ matrice scrivereColonne(matrice mat, int c) { mat.colonne = c; return mat; } /* * 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 */ matrice scrivereValore(matrice mat, int r, int c, int v) { int i; i = (r - 1) * leggereColonne(mat) + (c - 1); mat.valori[i] = v; return mat; } /* * 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: Permette di inserire tutti i valori all'intero di una 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: La funzione permette 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 PUO' AVERE AL MASSIMO %d elementi\n", MAXDIM); printf("INSERIRE IL NUMERO DELLE RIGHE\n"); righe = leggereNumero(1, MAXDIM); printf("INSERIRE IL NUMERO DELLE COLONNE\n"); colonne = leggereNumero(1, MAXDIM); } while ((righe * colonne) > MAXDIM); mat = scrivereRighe(mat, righe); mat = scrivereColonne(mat, colonne); printf("INSERIMENTO DEI VALORI\n"); mat = inserimentoValori(mat); return mat; } /* * Nome: leggereNumero * Descrizione: Permette di inserire 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; }
Posts written by Mind. |