#include "khist.h"

void DumpData(float * v, int n)
{
  int i;
  for (i=0; i<n ; i++) 
    printf("%12.6f\n",v[i]);
  printf("\n");
}

void SimplePrintHisto(float * hist,long BINS,float maxr, float minr, float bnwth)
{
  long n;
  printf("# Histogram\n");
  NTOE(minr);
  NTOE(maxr);
  for (n=0; n<BINS; n++){
    printf("Bin %f to %f \t  %f \n", (minr+n*bnwth), ((minr+(n+1)*bnwth)), hist[n]);
  }
  printf("\n\n");
}
       
void DumpHisto(float * hist,long nbins,float max, float min, float binwidth)
{
  long n;
  for (n=0; n<nbins; n++){
    printf("%14.9f\t%14.9f\n", (min+n*binwidth), hist[n]);
  }
}

void NormalizeHisto(float * hist,long nbins,float sum)
{
  long n;
  for (n=0; n<nbins; n++){
    hist[n] /= sum ;
  }
}

float * ReadHugeAmountOfDataForHisto(long *n) 
{
  long i = 0, j, max = 5000 ;
  int SuccessfulConversion ;
  float * v = vector(0,max-1);
  float * v2 ;
  STDERR("ReadHugeAmountOfDataForHisto(): BEGINS");
  do {
    if (i==max) {
      long max2 = 2*max;
      STDERR_PREFIX("Getting More Space. ");
      ITOE(max);
      v2 = vector(0,max2-1);
      for (j=0; j<max;j++) {
	v2[j] = v[j];
      }
      free_vector(v,0,max-1);
      v = v2 ;
      max = max2;
    }
    {
      float f ;
      SuccessfulConversion = scanf("%f",&f);
      if (SuccessfulConversion == 1) {
	v[i] = f;
	if (i==0) {
	  fprintf(stderr,"First falue is v[0]=%f\n",v[0]);
	}
	i++ ;
      } else {
	*n = i /* + 1 */;
	fprintf(stderr,"Last value is v[%d]=%f\n",i,v[i]);
	break ;
      }
    }
  } while (SuccessfulConversion == 1) ;
  STDERR_PREFIX("Total Number Read "); ITOE(*n);
  v2 = vector(0,*n);
  for (j=0; j<*n;j++) {
    v2[j] = v[j];
  }
  free_vector(v,0,max-1);
  return v2;
}
       

void histo (float *stream, 
	    long numpoints, 
	    long arsize, float *valmax, float *valmin, float *binwdth, 
	    float *bin)
     /*    
	The logic of this subr. is simple.  Loop through stream, find 
	valmax, valmin, rngwdth (total width of the range = abs(valmax-valmin)).
	From that, get bindwdth = rngwdth/arsize.  Then loop through the 
	stream again, and drop the datapoints into bins! SIMPLE 
	Variables are:
	valmax: maximum value of points in stream
	valmin: minimum    "  "    "     "     " 
	arsize: number of bins requested by calling routine (PASSED IN)
	stream: the one dimensional array of data points
	binwdth: width of the bins
	rngwdth: the range of the bins
	*/
{
  float rngwdth;
  long binum;
  long i;

  DumpData(stream, numpoints);

  /* First, loop through to find the max, min */
  *valmax = -INFINITY; *valmin = INFINITY;
  NTOE(numpoints);
  NTOE(arsize);
  for (i=0;i<numpoints; i++){
    if (stream[i] < *valmin) *valmin = stream[i];
    if (stream[i] > *valmax) *valmax = stream[i];
  }
  NTOE(*valmax);
  NTOE(*valmin);
  
  /* Now find rngwdth, binwdth */
  rngwdth = abs(*valmax-*valmin);
  *binwdth = rngwdth/ ((float)arsize);
  NTOE(rngwdth);
  NTOE(*binwdth);
  
  /* First initialize the array */
  for (i=0; i<arsize; i++) 
    bin[i] = 0; 
  
  /* Now loop through stream and drop each point into a bin 
     according to it's value. */
  for (i = 0; i< numpoints; i++)
    bin[ (long)((stream[i] - *valmin)/(*binwdth)) ]++; ;
}

Statistic * AllocateStats(void)
{
  static i = 0;
  Statistic * S = (Statistic * ) calloc(sizeof(Statistic),1);
  S->name = "NoName";
  S->is_initialized = true ;
  S->min =  INFINITY ;
  S->max = -INFINITY ;
  i++;
  return S ;
}

Statistic * StatsOnFloats(float v[], long n)
{
  long i;
  Statistic * S = AllocateStats();
  InitStats(S);
  NTOE(n);
  S->name = "StatsOnFloats" ;
  for (i=0; i<n;i++){
    IncrementStats(S,(double)v[i]);
  }
  return S;
}



float nhisto (float *v, long n, long nbins, float max, float min, float *bins) 
{
  float binwidth ;
  float rngwdth;
  long i;

  /* Now find rngwdth, binwdth */
  rngwdth = fabs(max-min);
  binwidth = rngwdth/ ((float) nbins);
  NTOE(max);
  NTOE(min);
  NTOE(rngwdth);
  NTOE(binwidth);
  
  /* First initialize the array */
  for (i=0; i<n; i++) 
    bins[i] = 0; 
  
  /* Now loop through stream and drop each point into a bin 
     according to it's value. */
  for (i = 0; i< n; i++)
    if (min <= v[i] && v[i] <= max)  
      bins[ (long)((v[i] - min)/binwidth) ]++; ;
  return binwidth ;
}