/* Media di un array di valori */

void media(const int numval, const double *x, double *med){ int i; *med=0; for(i=0;i<numval;i++){ *med+=x[i]; } *med/=(double)numval; }

Nel programma richiamare media con argomenti:

media(Numero_Valori, Array, &Media);

/* Deviazione standard di un array di valori */

void devstand(int n, const double med, double *devst, const double *x) { int i; double sumdiff=0; for(i=0;i<n;i++){ sumdiff+=(x[i]-med)*(x[i]-med); n=n-1; *devst=sqrt(sumdiff/(double)n); } }

Nel programma richiamare devstand con argomenti:

devstand(Numero_Valori, Media, &DeviazioneStandard, Array);

/* Prodotto scalare e vettoriale */

void ProdVecScal3(const double *a, const double *b, double *z, double *Val){ int i; *Val = 0.; for(i = 0; i< 3; i++) { *Val = *Val + a[i] * b[i]; } z[0]= a[1]*b[2]-a[2]*b[1]; z[1]= a[2]*b[0]-a[0]*b[2]; z[2]= a[0]*b[1]-a[1]*b[0]; }

Nel programma richiamare ProdVecScal3 con argomenti:

ProdVecScal3 (Vettore1, Vettore2, &ProdVett, &ProdScal);

/* Massimo e minimo di Array */

void max(const int dim, const double *a, double *max){ *max=0; int i; for (i=0; i<dim; i++) { if (*max<a[i]){ *max=a[i]; } else { *max=*max; } } }

void min(const int dim, const double *a, double *min){ *min=0; int i; for (i=0; i<dim; i++) { if (*min>a[i]){ *min=a[i]; } else { *min=*min; } } } Nel programma richiamare le funzioni con argomenti:

void max(dim, Array, &Massimo); void min(dim, Array, &Minimo);

L’algoritmo per il calcolo di massimo e minimo può essere usato genericamente per calcolare massimo e minimo di un insieme di valori.

/* Creazione di una matrice statica */

double mat[n][m];

Includere nella dichiarazione delle variabili. In questo caso n e m vanno specificati già in fase di dichiarazione e non possono essere più modificati.

/* Creazione di una matrice dinamica */

double **mat; int n, m;

scanf("%d , %d", &n, &m); //L’utente inserisce il numero di righe ‘n' e colonne ‘m’ mat=(double **)calloc(n, sizeof(double*)); for(i=0;i<n;i++){ mat[i]=(double *)calloc(m, sizeof(double)); } free(mat); //IMPORTANTE: inserire alle fine prima di return 0;

Se, invece di double, si vogliono altri tipi di valori, va cambiato dappertutto.

/* Creazione di un array monodimensionale dinamico */

double *v; int n;

scanf("%d", &n); //L’utente inserisce il numero componenti ‘n' v=(double *)malloc(n*sizeof(double));

free(v); //IMPORTANTE: inserire alle fine prima di return 0;

Se, invece di double, si vogliono altri tipi di valori, va cambiato dappertutto.

/* Riempimento di un vettore */

Supponiamo di aver dichiarato un array a[] (o statico o dinamico con malloc) di dimensione dim e di volerlo riempire tramite tastiera (in questo caso sono double):

for(i=0;i<dim;i++){ scanf(“%lf”, &a[i]); }

se invece lo si vuole riempire con il risultato di un’operazione:

for(i=0;i<dim;i++){ a[i]=OPERAZIONE; \\come una somma, un altro vettore, ecc. }

/* Riempimento di una matrice */

Supponiamo di aver dichiarato una matrice a[][] (o statica o dinamica con calloc) di dimensione nXm e di volerla riempire tramite tastiera (in questo caso sono double):

for(i=0;i<n;i++){ for(j=0;j<m;j++){ scanf("%lf", &a[i][j]); } }

se invece la si vuole riempire con il risultato di un’operazione:

for(i=0;i<n;i++){ for(j=0;j<m;j++){ a[i][j]=OPERAZIONE; } }

/* Stampa di una matrice */

Supponiamo di aver dichiarato e riempito una matrice a[][] (o statica o dinamica con calloc) di dimensione nXm e di volerla stampare a schermo in forma matriciale:

for(i=0;i<n;i++){ for(j=0;j<m;j++){ printf(“%lf “, a[i][j]); //stampa tutta la riga } printf(“\n”); //va a capo alla fine della riga }

/* Lettura e scrittura di un file */

FILE *input, *output; const int MAX=100; char in[MAX], out[MAX]; //Nomi file di input e output

scanf("%s", in); //Prendo da tastiera il nome del file da cui leggere input=fopen(in, “r"); //Apro il file e verifico che sia aperto if(input==NULL){ printf("Impossibile aprire il file.\n"); exit(1); } fscanf(input, “%tipo_dato_da_leggere”, &variabile_da_riempire); [Esempio fscanf(input, “%lf”, &x);]

scanf("%s", out); //Prendo da tastiera il nome del file su cui scrivere output=fopen(out, “w"); //Apro il file e verifico che sia aperto if(output==NULL){ printf("Impossibile aprire il file.\n"); exit(1); }

fprintf(output, “%tipo_dato_da_scrivere”, variabile_da_scrivere); [Esempio fprintf(output, “%lf”, x);]

/* Lettura matrice da file */ Supponiamo di voler una matrice a[n][m] e di volerla riempire tramite file da cui viene presa anche la dimensione della stessa:

fscanf(input, "%d , %d", &n, &m); //Prendo da file n e m della matrice a=(double **)calloc(n, sizeof(double*)); //Alloco la matrice for(i=0;i<n;i++){ a[i]=(double *)calloc(m, sizeof(double)); } for(i=0;i<n;i++){ //Scrivo nella matrice da file for(j=0;j<m;j++){ fscanf(input, "%lf", &a[i][j]); } }

/* Generare un numero di punti casuali in un rettangolo */

- Prima del main:

struct point { double x; double y; };

- Dichiarazione array di N punti: struct point *pts; pts=(struct point *)malloc(N*sizeof(struct point));

- Generazione numeri casuali:

srand48(seed); for(i=0; i<N; i++){ pts[i].x=drand48(); pts[i].y=drand48(); }

- Per un rettangolo di lati a e b:

for(i=0; i<N; i++){ pts[i].x=a*drand48(); //a e b vanno dichiarati prima e chiesti all’utente pts[i].y=b*drand48(); }

/* Ordinare un array */

void OrdinaCrescente(double *a, const int N) { int i, j, min; double temp;

for (i=0; i < N-1; i++) { min = i; for (j= i+1; j < N; j++){ if (a[j] < a[min]) { min = j; } } temp = a[min]; a[min] = a[i]; a[i] = temp; } }

void OrdinaDecrescente(double *a, const int N) { int i, j, max; double temp;

for (i=0; i < N-1; i++) { max = i; for (j= i+1; j < N; j++){ if (a[j] > a[max]) { max = j; } } temp = a[max]; a[max] = a[i]; a[i] = temp; } }

/* Generare un array distribuito gaussianamente */

void gauss(double *x){ double PI = acos(-1.0L), Theta, R; int seed=23354; srand(seed); Theta = 2.0L * PI * drand48(); R = sqrt(-2.0L * log(drand48())); *x = R * cos(Theta); }

Nel programma:

int main(){ double x[n], z[n]; \\Array di dimensione n, oppure *x e poi malloc

for(i=0;i<n;i++){ gauss(&x[i]); \\elementi di x distribuiti normalmente con valor medio 0 e varianza 1 z[i]=a+b*x[i]; \\elementi di z distribuiti normalmente con valor medio a e varianza b }

return 0; }

/* Generare array di punti uniformemente in un cerchio */

struct point{ double x; double y; };

int main(){

int N, i; struct point *pts=NULL; double PI=acos(-1.0L), r, theta; const long int seed=123456;

//Chiedere all’utente quanti punti

pts=(struct point *)malloc(N*sizeof(struct point)); srand48(seed); for(i=0;i<N;i++){ r=drand48(); theta=2.0L*PI*drand48(); pts[i].x=r*cos(theta); pts[i].y=r*sin(theta); } return 0; }

/* Calcolare la distanza di un array di punti dall’origine */

void DistanzaOrigine(const int N, struct point *pts, double *dist){ for(i=0;i<N;i++){ dist[i]=sqrt(pts[i].x*pts[i].x+pts[i].y*pts[i].y); } }

Nel programma richiamare DistanzaOrigine con argomenti:

DistanzaOrigine(Numero_Valori, Punti, &Distanza);

dove Distanza è un array della stessa dimensione del numero di punti.

/* Calcolare la distanza tra tutti i punti di un array */

int main() { struct point *p=NULL; int N; double *dist=NULL; int i, j, t=0;

p=(struct point *)malloc(N*sizeof(struct point)); dist=(double *)malloc((N*(N-1)/2)*sizeof(double)); for(j=0;j<N;j++){ for(i=j+1;i<N;i++){ dist[t]=sqrt((p[j].x-p[i].x)*(p[j].x-p[i].x) +(p[j].y-p[i].y)*(p[j].y-p[i].y)); t+=1; } }

return 0; }

/* Esame Matrice */

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

int main(){

FILE *input, *output; const int MAX=100; char inp[MAX], out[MAX]; int n, m, i, j; double **mat1, **mat2; printf("Inserire il nome del file contenente la matrice:\n"); scanf("%s", inp); input=fopen(inp, "r"); if(input==NULL){ printf("Impossibile aprire il file.\n"); exit(1); } fscanf(input, "%d , %d", &n, &m); mat1=(double **)calloc(n, sizeof(double*)); for(i=0;i<n;i++){ mat1[i]=(double *)calloc(m, sizeof(double)); } for(i=0;i<n;i++){ for(j=0;j<m;j++){ fscanf(input, "%lf", &mat1[i][j]); } } mat2=(double **)calloc(n, sizeof(double*)); for(i=0;i<n;i++){ mat2[i]=(double *)calloc(m, sizeof(double)); } for(i=0;i<n;i++){ for(j=0;j<m;j++){ if(j==0){ mat2[i][j]=mat1[i][j]; } else { if(mat1[i][j-1]==1){ mat2[i][j]=0; } else { mat2[i][j]=mat1[i][j]; } } } } printf("Inserire il nome del file su cui scrivere la nuove matrice:\n"); scanf("%s", out); output=fopen(out, "w"); if(output==NULL){ printf("Impossibile aprire il file.\n"); exit(1); } for(i=0;i<n;i++){ for(j=0;j<m;j++){ fprintf(output, "%.0lf ", mat2[i][j]); } fprintf(output, "\n"); } return 0; }

/* Esame Cerchio */

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

struct point{ double x; double y; double d; };

void OrdinaCrescente(struct point *a, const int N) { int i, j, min; struct point temp;

for (i=0; i < N-1; i++) { min = i; for (j= i+1; j < N; j++){ if (a[j].d < a[min].d) { min = j; } } temp = a[min]; a[min] = a[i]; a[i] = temp; } }

int main(){ FILE *output1, *output2; const int MAX=100; char out1[MAX], out2[MAX]; int N, i; struct point *pts=NULL; double PI=acos(-1.0L), r, theta; const long int seed=123456; printf("Quanti punti generare?\n"); scanf("%d", &N); pts=(struct point *)malloc(N*sizeof(struct point)); srand48(seed); for(i=0;i<N;i++){ r=drand48(); theta=2.0L*PI*drand48(); pts[i].x=r*cos(theta); pts[i].y=r*sin(theta); pts[i].d=r; } printf("File di output non ordinato: "); scanf("%s", out1); output1=fopen(out1, "w"); if(output1==NULL){ printf("Impossibile aprire il file.\n"); exit(404); } for(i=0;i<N;i++){ fprintf(output1, "%lf %lf - Distanza=%lf\n", pts[i].x, pts[i].y, pts[i].d); }

|———————————————————————————————————— CONTINUA —————————————————————————————————————|

|———————————————————————————————————— CONTINUA —————————————————————————————————————| printf("File di output ordinato: "); scanf("%s", out2); output2=fopen(out2, "w"); if(output2==NULL){ printf("Impossibile aprire il file.\n"); exit(404); } OrdinaCrescente(pts, N); for(i=0;i<N;i++){ fprintf(output2, "%lf %lf - Distanza=%lf\n", pts[i].x, pts[i].y, pts[i].d); } fclose(output1); fclose(output2); free(pts); return 0; }