/* 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);
Lalgoritmo 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);

//Lutente 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);

//Lutente 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 unoperazione:

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 unoperazione:

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]);
}
printf(\n);
}

//stampa tutta la riga

//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];
scanf("%s", in);

//Nomi file di input e output

//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();
pts[i].y=b*drand48();
}

//a e b vanno dichiarati prima e chiesti allutente

/* 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];
for(i=0;i<n;i++){
gauss(&x[i]);
z[i]=a+b*x[i];
}
return 0;
}

\\Array di dimensione n, oppure *x e poi malloc

\\elementi di x distribuiti normalmente

con valor medio 0 e varianza 1
\\elementi di z distribuiti normalmente
con valor medio a e varianza b

/* 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 allutente 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 dallorigine */

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;