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

double * NewVecDouble(const int n);
double * ResizeVecDouble(double * x, const int newdimx);
double * BubbleSort(double *x, const int dimx); 
void swap(double * a, double *b);

int main(){

  double * x=NULL;
  double casuale;
  const double max_rand = 0.99;
  int n=0,i=0;

  /* In questo modo inizializzo il generatore di numeri casuali in modo 
     diverso per ogni esecuzione del programma. Infatti time(NULL) 
     restituisce il numero di secondi dal 1 Gennaio 1970 al tempo di 
     esecuzione del programma, ed e' quindi un buon intero per inizializzare
     ogni volta in modo differente il generatore di numeri casuali.  
     Una soluzione meno raffinata ma ugualmente accettabile sarebbe di chiedere in
     input il "seme" della sequenza, da usare al posto di time(NULL) .
  */
  srand48(time(NULL));

  /* Alloco un vettore di un elemento e lo inizializzo a zero */
  x = NewVecDouble(1);

  /* Qui estraggo gli elementi a caso e ridimensiono il vettore ad ogni 
     estrazione. uso il do-while perche' voglio che nel vettore ci sia
     anche l'ultimo elemento, quello > max_rand=0.99 per controllare che 
     tutto sia OK.
  */
  
  do{
    /* Qui "allungo" il vettore x lasciando inalterata la parte gia' riempita.
       Attenzione al +1: la dimensione del vettore e' infatti pari all'indice
       dell'ultimo elemento riempito maggiorata di 1 visto che gli indici 
       partono da zero.*/

    x = ResizeVecDouble(x,n+1);
    casuale = drand48();
    /* Un modo compatto per riempire l'elemento x[n] e SUCCESSIVAMENTE incrementare n */
    x[n++] = casuale;
  }while (casuale<max_rand);

  /* Stampiamo in output il vettore generato */

  for(i=0;i<n;i++){
    printf("L'elemento x[%d] = %lf\n",i,x[i]);
  }

  /* Ordiniamo il vettore */
  x = BubbleSort(x,n);

  /* Stampiamo in output il vettore ordinato */

  printf("Dopo l'ordinamento:\n");
  for(i=0;i<n;i++){
    printf("L'elemento x[%d] = %lf\n",i,x[i]);
  }
  return 0;
}

double * NewVecDouble(const int n){
  double * x;
  x = (double *)calloc(n,sizeof(double));
  if(x == NULL) {
    fprintf(stderr,"Non ho spazio in memoria per allocare un vettore !\n");
    exit(1);
  }
  return(x);
}

double * ResizeVecDouble(double * x, const int newdimx){
  x = (double *)realloc(x,newdimx*sizeof(double));
  if(x == NULL) {
    fprintf(stderr,"Non ho spazio in memoria per allocare un vettore !\n");
    exit(1);
  }
  return(x);
}

double * BubbleSort(double * x, const int dimx){

  int last=0,i=0,j=0;

  last = dimx;
  for(i=0;i<dimx;i++){
    for(j=1;j<last;j++){
      if(x[j]<x[j-1]){
	swap(&x[j],&x[j-1]);
	}
    }
    last--;
  }
  
  return(x);
}

void swap(double * a, double *b){
  double temp;
  temp = *a;
  *a = *b;
  *b = temp;
}