Codice:
/** velocità della luce (m/s)*/
#define V 299792458.
/** costante di conversione radianti --> gradi */
#define RAD2DEG 57.29577951308232
/**
Valori booleani */
typedef enum { FALSE=0, TRUE=1 } bool_t;
/** tipi di ordinamento:
NOTORD = nessun ordinamento.
TIME = ordinata per tempi crescenti.
POSITION = ordinata per posizione crescente
*/
typedef enum { NOTORD=0, TIME=1, POSITION=2 } ord_t;
/** flag che indica se la rilevazione contiene rumore (NOISE) o no (OK) */
typedef enum { OK=0, NOISE=2 } flag_t;
/** struttura che realizza l'elemento della lista di registrazioni */
typedef struct elem {
/** posizione registrazione*/
double position;
/** tempo registrazione */
double time;
/** flag rumore/buono */
flag_t flag;
/** puntatore al prossimo elemento */
struct elem * next;
} elem_t;
/** struttura della lista delle registrazioni */
typedef struct {
/** puntatore alla testa della lista */
elem_t * head;
/** numero di elementi presenti in lista */
int nelem;
/** indica se è ordinata e se l'ordinamento e' rispetto al tempo o alla posizione */
ord_t ord;
} lista_t;
lista_t * new_lista ( void ) {
lista_t * l ;
if ( ( l = malloc (sizeof ( lista_t ) ) ) == NULL ) {
return NULL;
}
l->head = NULL ;
l->ord = NOTORD;
return l;
}
static void stampa_lista_r ( FILE * f, elem_t * h ) {
if ( h == NULL ) {
return ;
}
if ( h->flag == OK ) fprintf(f,"::(%.1f,%.15f,OK)\n",h->position, h->time);
if ( h->flag == NOISE ) fprintf(f,"::(%.1f,%.15f,NOISE)\n",h->position, h->time);
stampa_lista_r(f, h->next);
}
void stampa_lista ( FILE * f, lista_t * l ) {
if ( l == NULL ) return ;
if ( l-> head == NULL ) {
fprintf(stdout,"Lista vuota.\n");
return ;
}
stampa_lista_r (f,l->head);
putchar('\n');
return ;
}
/**
legge da file una nuova registrazione (notare il formato analizzando il file dati, ogni registrazione è terminata da '\n')
se il formato è corretto e la conversione è possibile alloca una struttura di tipo elem_t
inizializzando i campi con i valori cotenuti nella riga (nota: il campo next va inizializzato a NULL)
se il formato della riga non e' corretto, si è raggiunto EOF o si è verificato un errore lo segnala ritornando NULL
\param fd descrittore del file
\retval p puntatore alla struttura allocata (!= NULL) se tutto è andato bene
\retval NULL se si è verificato un errore
*/
elem_t* leggi_registrazione (FILE* fd){
elem_t* p;
double x, y;
flag_t k;
if( fd==NULL ) {
perror("Errore in apertura del file");
}
fscanf(fd, "%lf %lf %d", &x, &y, &k);
p = malloc(sizeof (elem_t));
if(p==NULL) return NULL;
else{
(*p).position = x;
(*p).time = y;
(*p).flag = k;
(*p).next = NULL;}
return p;
}
/**
inserisce nella lista
-- se la lista non e' ordinata inserisce in testa alla lista
-- se la lista e' ordinata per posizione (crescente) e se la lista e' ordinata per tempo (crescente) inserisce mantenendo la lista ordinata
\param pelem puntatore all'elemento da inserire
\retval -1 se si e' verificato un errore nell'allocazione del nuovo elemento
\retval 0 altrimenti
*/
void insert(elem_t**p,elem_t*el){
(*el).next = *p;
(*p) = &(*el);}
void inserisci_time(elem_t **p,elem_t *el) {
if((*p)==NULL || (**p).time > (*el).time)
insert(p, el);
else inserisci_time(&(**p).next, el);}
void inserisci_position(elem_t**p,elem_t *el){
if((*p)==NULL || (**p).position > (*el).position)
insert(p, el);
else inserisci_position(&(**p).next, el);}
int inserisci(lista_t*l,elem_t*pelem) {
ord_t ord;elem_t *el,**p;
if (ord==TIME) inserisci_time(**p,*el);
else if(ord==NOTORD)inserisci(l,l->head);
else if(ord==POSITION)inserisci_position(**p,*el);
else return -1;
return 0;}
/**
mette a false il campo ord per indicare che la lista non e' piu' ordinata
\param l lista
*/
void set_nonordinata (lista_t * l) {
(*l).ord = NOTORD;
}
/**
se la lista non e' ordinata rispetto al tempo setta a TIME il campo ord
ed ordina la lista, altrimenti non fa niente
\param l lista
*/
void set_ordinata_time (lista_t * l) {
lista_t tmp;
if((*l).ord == TIME);
else {
(*l).ord = TIME;
while (l->head != NULL) {inserisci(&(tmp.head), l->head);}
(*l).head = tmp.head;
}
}
/**
se la lista non e' ordinata rispetto alla posizione setta a POSITION
il campo ord ed ordina la lista, altrimenti non fa niente
\param l lista
*/
void set_ordinata_position (lista_t * l) {
lista_t tmp;
if((*l).ord == POSITION);
else {
(*l).ord = POSITION;
while(l->head != NULL) {inserisci(&(tmp.head), l->head);}
(*l).head = tmp.head;
}
}
/**
dealloca tutti gli elementi della lista, la struttura lista e annulla il puntatore alla lista stessa
\param pl puntatore al putatore della lista da deallocare
*/
void free_lista (lista_t **pl) {
elem_t *tmp;
elem_t*p;
p=(**pl).head;
while(p!=NULL){tmp=(*p).next;
free(p);
p=tmp;}
free(*pl);
(*pl)=NULL;}
/**
calcola \theta invertendo la formula
t_i - t_j = (x_i - x_j)/2 sin(\theta)
\param pi putatore all'elemento relativo alla rilevazione i
\param pj puntatore all'elemento relativo alla rilevazione j
\item pth puntatore alla variabile che conterra' il valore di theta (non viene modificata se si verifica un errore ) in GRADI
\retval 0 se il valore di theta e' calcolabile (se l'arcsin e' definito)
\retval -1 altrimenti
*/
int compute_theta (elem_t* pi, elem_t* pj, double* pth) {
double t_i, t_j, p_i, p_j, Th, tot;
t_i = (*pi).time;
t_j = (*pj).time;
p_i = (*pi).position;
p_j = (*pj).position;//qui continua a dirmi che i tipo double non è una funzione o un puntatore,boh,comunque errore
tot = (V*(t_i - t_j))/(p_i - p_j);
Th = asin(tot);
Th = Th*RAD2DEG;
return Th;
}
/**
calcola la media dei valori in un file
\param f file in cui leggere i valori (non viene modificato)
\param pm puntatore alla variabile che conterrà la media
\retval 1 se tutto è andato bene
\retval 0 se si è verificato un errore
*/
elem_t* leggi_registrazione_2 (FILE* f){
elem_t* p;
double x, y;
flag_t k;
if( f==NULL ) {
perror("Errore in apertura del file");
}
fscanf(f, "%lf %lf %d", &x, &y, &k);
p = malloc(sizeof (elem_t));
if(p==NULL) return NULL;
else{
(*p).position = x;
(*p).time = 0;
(*p).flag = 0;
(*p).next = NULL;}
return p;
}
int media (FILE * f, double* pm) {
double sum=0,media;
elem_t* leggi_registrazione_2 (FILE* f){
int inserisci(lista_t*l,elem_t*pelem); }
while(p!=NULL) {elem_t* leggi_registrazione_2 (&f)
sum += p->position;
media = sum/nelem;}
return media;
}
/**
calcola la deviazione standard dei valori in un file
\param f file in cui leggere i valori (non viene modificato)
\param ps puntatore alla variabile che conterrà la varianza
\param m media
\retval 1 se tutto è andato bene
\retval 0 se si è verificato un errore
*/
int deviazione (FILE * f, double* ps, double m);
{double tmp, devstd,m;int i;
fscanf(f,"%lf",&tmp);
m=media(f,pm);
devstd=((tmp-media)*(tmp-media))
while tmp != NULL;
for(i=0;i<nelem;i++){devstd=devstd/(nelem-1);}
#endifSalve,dunque ho questo codice da consegnare a brevissimo,il main è a parte,qui ci sono solo le funzioni,si tratta principalmente di ordinare una lista per tempi e posizioni presenti in un file fornito,attraverso cui calcolare una serie di corrispondenti angoli di incidenza(per ogni posizione e tempo) facendone media e deviazione standard,il main per testare le funzioni da parecchi problemi soprattutto relativamente ai tipi dei parametri(che sono elementi di strutture) e ai puntatori,i grossi dubbi sono legati al fatto che avendo ricevuto una grossa mano da un amico non so bene come funzionano i puntatori e i doppi puntatori nelle liste,chi avesse la bontà di ravvisare qualcosa mi farebbe un enorme favore,grazie.
