// Bin Sort Program
// C. Thaxton
//
// This is the solution to exercise 2.4.
//
#include <stdio.h>
#include <string.h>
#include "comphys.h"
#include "comphys.c"

#define numgrains 50
#define numbins 10

float getsd (float avegs, float grains[]);  
void bingrains(float grains[]);
void sortbins();
void writeout0(float avegs, float sd);
void writeout1();
void writeout2();
void writeout3(float grains[]);

int bincount[numbins]={0,0,0,0,0,0,0,0,0,0};
int countindex[numbins]={0,0,0,0,0,0,0,0,0,0};

int main() 
{
   float grains[numgrains];  // Input Data
   float temp=0.0;
   float avegs=0.0,sd=0.0;

   int i=0,j=0;

   FILE *in;

// Go see if input file is there and readable

   if ((in=fopen("grains.dat","r"))==NULL) {
      printf("\nCan not open file for input\n");
      return(1);
   }

// Read in grain data

   for (i=0;i<numgrains;i++) {
      fscanf(in,"%f",&grains[i]);
      avegs=avegs+grains[i]/numgrains;  //compute ave on the fly
   }
   fclose(in);

// Compute standard deviation

   sd=getsd(avegs,grains);

// Output results

   writeout0(avegs,sd);

// Bin the grains by size - bincount holds total number of
// grains in a bin.

   bingrains(grains);

// Output results

   writeout1();
  
// Sort the bins by count in descending order

   sortbins();

// Output results

   writeout2();

// Now, sort the grains by size per quicksort

   qsfloat(grains,0,49);

// Output results
 
   writeout3(grains);

   return(0);
} 
//END MAIN***********************************************

/********************************************************/
// FUNCTION GETSD - Compute standard deviation
// Returns standard devaition (sd)
float getsd (float avegs, float grains[])
{   
   int i=0;
   float sd=0.0;

   for (i=0;i<numgrains;i++) sd += pow((grains[i]-avegs),2);
   sd=sqrt((1.0/numgrains)*sd);
   return(sd);
}
/********************************************************/
// FUNCTION BINGRAINS - Bins grains
// Modifies: bincount

void bingrains(float grains[])
{
   int i,j;
   float lim[numbins];

   for (i=0;i<numbins;i++) bincount[i]=0;
   lim[0]=1.1;  //use loop to define running limit
   for (j=1;j<numbins;j++) lim[j]=lim[j-1]+0.1;
   for (i=0;i<=numgrains-1;i++) {
      for (j=0;j<numbins;j++) {
         if (grains[i]<lim[j]) {bincount[j]++;break;};
      }
   }
}

/********************************************************/
// FUNCTION SORTBINS - Sorts bin by count in descending order
// Modifies: countindex
// Assumption: Bins are 0.1mm and consecutive.
void sortbins()
{
   int i,j,tempj;  
   int maxnum=0;
   float tempbin[numbins]={0,0,0,0,0,0,0,0,0,0};

   for(i=0;i<numbins;i++) tempbin[i]=bincount[i];
   for(i=0;i<numbins;i++) {
      for (j=0;j<numbins;j++) {
         if (tempbin[j]>maxnum) {
            maxnum=tempbin[j];
            tempj=j;
         }
      }
      countindex[i]=tempj;
      tempbin[tempj]=0;
      maxnum=0;
   }
}   

/********************************************************/
// FUNCTION WRITOUT0
void writeout0(float avegs,float sd)
{
   printf ("\nPROGRAM SORT, by C. Thaxton.\n");
   printf ("Counts the number of grains per bin as defined below\n");
   printf ("and then sorts the bins in descending order based on\n");
   printf ("the number of grains per bin.  Reads 50 data points from\n");
   printf ("file 'grains.dat'.\n\n");

   printf ("The average grain size is: %fmm\n",avegs);
   printf ("The standard deviation is: %fmm\n\n",sd);
}

/********************************************************/
// FUNCTION WRITOUT1
void writeout1()
{
   printf ("The number of grains per bin is:\n\n");
   printf ("Bin 1 (1.0-1.1mm) has %d grains in it.\n",bincount[0]);
   printf ("Bin 2 (1.1-1.2mm) has %d grains in it.\n",bincount[1]);
   printf ("Bin 3 (1.2-1.3mm) has %d grains in it.\n",bincount[2]);
   printf ("Bin 4 (1.3-1.4mm) has %d grains in it.\n",bincount[3]);
   printf ("Bin 5 (1.4-1.5mm) has %d grains in it.\n",bincount[4]);
   printf ("Bin 6 (1.5-1.6mm) has %d grains in it.\n",bincount[5]);
   printf ("Bin 7 (1.6-1.7mm) has %d grains in it.\n",bincount[6]);
   printf ("Bin 8 (1.7-1.8mm) has %d grains in it.\n",bincount[7]);
   printf ("Bin 9 (1.8-1.9mm) has %d grains in it.\n",bincount[8]);
   printf ("Bin 10(1.9-2.0mm) has %d grains in it.\n\n",bincount[9]);
}

/********************************************************/
// FUNCTION WRITOUT2 
void writeout2()
{
   int i=0,j=0;

   printf("Sorted in descending order by grain count:\n\n");
   for (i=0;i<numbins;i++) {
      j=countindex[i];
      printf("Bin %d has %d grains in it.\n",j,bincount[j]);
   }
}   

/********************************************************/
// FUNCTION WRITOUT3 
void writeout3(float grains[])
{
   int i=0;
   char response='p';

   while ((response != 'y')&&(response != 'n')) {
   printf("\nWould you like to see the grains that were binned (in ascending order of size): [y/n]\n\n");
   scanf("%s",&response);
   }
   if (response == 'y') {
      for (i=0;i<numgrains;i++) printf("%f\n",grains[i]);
   }
   else printf ("\nGood bye.\n");
}