/* Questo programma crea e stampa su file un prototipo di istogramma. 
 I dati sono generati estraendo numeri casuali uniformemente distribuiti in [0,1]. */

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

#define MAX_NSAMPLE 1000000 
#define MAX_NBINS 100

int GetInput(double data[], int);
void MakeHistogram(double data[], int bin[], double, double, int, int);
void WriteHistogram(int bin[], double, double, int);



main(){
	
	int NData,k;					  /* NData e' il numero di eventi nel campione */
	
	int NBins, NInBin[MAX_NBINS]={0}; /* NInBin contera' il numero di eventi (elementi del 
										campione) all'interno di ciascun bin dell'istogramma */ 
	
	double min,max;               /* Estremi dell'intervallo entro cui si vuol costruire 
									 l'istogramma */
	
	double DataSet[MAX_NSAMPLE]; /* Vettore che contiene gli elementi del campione */
	
	int seed;
	seed=time(0);
	srand48(seed);

	NData=GetInput(DataSet); 
	
	printf("Valore minimo?\n");
	scanf("%lf",&min);
	printf("\n Valore massimo?\n");
	scanf("%lf",&max);
	
	do{
		printf("\n Inserire il numero di intervalli \n");
		scanf("%d",&NBins);
	}while(NBins<=0 || NBins > MAX_NBINS);
	
	MakeHistogram(DataSet,NInBin,min,max,NBins,NData);
	
	WriteHistogram(NInBin,min,max,NBins);

}


/* Questa e' la funzione che determina (chiedendolo) il numero, N, dei dati 
 di cui faremo l'istogramma e li genera secondo una qualche ricetta */

int GetInput(double DataGet[]){
	int N, k;
	
	do{
		printf("Inserire il numero totale di dati\n");
		scanf("%d",&N);
		
	}while(N<0 || N>MAX_NSAMPLE);
	
	/* In questo caso i dati sono N numeri uniformemente distribuiti fra zero e uno con 
	 i quali viene popolato l'array DataSet */
	for (k=0; k<N; k++) {
		*(DataGet+k)=(double)lrand48()/RAND_MAX;
	}
	
	return N;
}




/* Questa e' la funzione che crea l'istogramma */

void MakeHistogram(double DataPut[], int NHisto[], double min, double max, int NB,int ND){
	int i,j,counter;
	double DataValue;
	double InvWidth=(double)NB/(max-min);
	
	for(i=0;i<ND;i++){
		DataValue = *(DataPut+i); /* DataValue e' una variabile superflua che ha lo scopo 
									di rendere (un po') piu' leggibile il codice */
		
		j = (DataValue-min)*InvWidth; /*Identifico il bin a cui appartiene l'elemento i 
										dell'array dei dati (nota che j>0 se tutti i dati 
										sono "a destra" di min. Che succede se cosi' non e'?)*/
		
		
		
		if(j<NB)(*(NHisto+j))++;   /* Incremento il contatore degli elementi nel bin, 
									   scartando dati che ricadono fuori */
			
	}
}




/* Questa e' la funzione che scrive l'istogramma (e la "variabile") su un file */

void WriteHistogram(int NHisto[],double min, double max, int NB){
	int i;
	double Width, x, y, Norm=0.; /* x e y sono variabili di comodo per facilitare la lettura
									delle righe in cui si scrive su file */
	
	FILE *fhisto;
	
	Width=(max-min)/(double)NB;
	
	if((fhisto = fopen("Histo.dat","w")) == NULL){
		printf("Non e' stato possibile aprire il file \n");
		exit(EXIT_FAILURE); /* Uscita dal programma: EXIT_FAILURE e' - definito come - uguale 
								ad 1 */
	}
	
	for(i=0;i<NB;i++){
		Norm += NHisto[i]; /* Calcolo il fattore di normalizzazione dell'istogramma */
	}
	
	Norm=Norm*Width;
	
	for(i=0;i<NB;i++){
		x = min+(i+0.5)*Width;			/* Assegno, convenzionalmente, il valore del "bin" 
									al suo punto di mezzo */
		y = (double)NHisto[i];
		fprintf(fhisto,"%.4f %f\n",x,y/Norm);
	}
	
	fclose(fhisto);
}


/* Il programma come scritto adesso chiede all'utente di inserire gli estremi dell'intervallo 
 in cui si costruisce l'istogramma. Questo puo' essere pericoloso: cosa accaderebbe, ad esempio,
 se si scegliessero valori di min e max tali che ci sono elementi nel campione "fuori" 
 dall'intervallo? Per lavorare in sicurezza, si puo' migliorare il codice in modo che calcoli 
 i valori di min e max a partire dai dati mediante apposite funzioni (min potrebbe essere il piu'
 piccolo valore del campione -- o un numero leggermente minore del piu' piccolo valore del 
 campione -- e max il piu' grande valore del campione). Sapete farlo? */