/*
   STEM-AND-LEAF: This C++ program makes a quick stem-and-leaf 
 plot of data contained a user-specified file, a required command-line
 argument.
 The data are grouped in horizontal bins of default width 10.
 The user may provide her own integer bin width with an optional
 second command-line argument.
 
 shinnerl@ucla.edu.
 Last modified: 4 Feb. 2002
*/                
#include <cstdio>
#include <cstdlib>
#include <fstream>
#include <iostream>
#include <iomanip>
#include <algorithm>
#include <cmath>

const int MAX  = 500;   // Maximum number of data values in the file histdat 
const int DEFAULT_BIN_WIDTH = 10;

double square( double x ) { return x*x; }

double mean (int a[], int n)
{
   int i=0, sum=0, j=0;
   double average=0.0;
   for(i=0;i < n; ++i)
      sum += a[i];
   average = (double)sum/(double)n;
   return (average);
}

double stdev(int a[], int n)    // Standard Deviation.
{
   int i=0, j=0;
   double sd=0.0, m=0.0, sum=0.0, diff=0.0, total=0.;
   m = mean(a,n);
   sum=0.0;
   for(i=0; i<n; ++i)
   {
      diff = double(a[i]) - m;
      sum = sum + square(diff);
   }
   total = sum / (double)(n-1);
   sd = sqrt(total);                        
   return sd;
}

double median( int a[], int n)  
{
// Precondition: a[] is SORTED.
   double m=0.0;
   if(n%2 ==1) 
      m = (double)a[n/2];
   else
      m =((double)a[n/2] + (double)a[n/2 - 1])/2.0 ;
   return (m);
}

// Compute the lower quartile of the SORTED integer data sample
double lowerquartile( int a[], int n)
{
   double lowq=0.0;
   if( n%4 == 0 || n%4 == 1 )
      lowq = ((double)a[n/4 -1] + (double)a[n/4]) / 2.0;
   else
      lowq = (double)a[n/4];        
   return (lowq);
}


// Compute the upper quartile of the SORTED integer data sample
double upperquartile( int a[], int n)
{
   double uq=0.0;
   if (n%4 == 0 || n%4 == 1)
      uq = ((double)(a[3*n/4 -1] + a[3*n/4])) / 2.0;
   else
      uq = (double)a[3*n/4];        
   return (uq);
}                


void printHist( int scores[], int count, int binWidth, ostream& os ){

   int binLabel = scores[0] / 10,
       binMin   = binLabel*10,
       binMax   = binMin+binWidth-1; // current bin's max. admissible value.

   int j = 0;
   while ( j < count  )
   {
      os.setf(iostream::right);
      if ( binMin/10 == binMax/10 )                // Bin label(s).
          os << setw(7)  << binMin/10 << ": ";
      else
          os << setw(3) << binMin << ','
             << setw(3) << binMax << ": ";
      while((scores[j] <= binMax)  && (j < count))
          os << setw(1) << abs(scores[j++] % 10);  // Bin entry (right digit)
                                                   // abs() for negative data
      binMin  = binMax+1;
      binMax += binWidth;
      os << "\n";
   }                        
}

void printStats( int scores[], int count, int binWidth, ostream& os){

  const int FIELDWIDTH = 6;
  os << "\n   Bin Width:          ";
  os.setf(iostream::left);
  os << setw(FIELDWIDTH) << binWidth;

  os.setf(iostream::right);
  os.setf(iostream::fixed);
  os.setf(iostream::showpoint);
  os.precision(2);
  os << "     Upper Quartile:     " << setw(FIELDWIDTH) 
     << upperquartile(scores, count);

  os << "\n   Mean:               " << setw(FIELDWIDTH) 
     <<  mean(scores, count);

  os << "     Median:             " <<  setw(FIELDWIDTH) 
     << median(scores,count);

  os << "\n   Standard deviation: " <<  setw(FIELDWIDTH) 
     << stdev(scores, count);

  os << "     Lower Quartile:     " <<  setw(FIELDWIDTH) 
     << lowerquartile(scores, count);

  os << "\n   Number of Scores:   " <<  setw(FIELDWIDTH) 
     << count << endl;

}

int getCommandLine( int argc, char* argv[], 
		    ifstream& infile, ofstream& outfile, ostream*& osPtr ){
   bool fail = false;
   int binWidth = DEFAULT_BIN_WIDTH;
   if ( argc >= 2 ) {
      infile.open(argv[1]);
      fail = !infile;
      if (!fail && argc >=3 ){
         binWidth = atoi( argv[2] );
         if (argc >=4 ){
	   outfile.open( argv[3] );
	   fail = !outfile;
	   osPtr = &outfile;
	 }
      }
   }
   else
     fail = true;

   if (fail) {
      cout << "Calling Syntax: hist <input file> [bin width [output file]]\n";
      exit(1);
   }
   return binWidth;
}

int main(int argc, char *argv[]) {

   ifstream infile; 
   ofstream outfile; 
   ostream *osPtr = &cout;
   int binWidth = getCommandLine( argc, argv, infile, outfile, osPtr );

// Create a static array to support large data sets; 
// initialize entire array to 0.
   static int scores[MAX] = {0};  
				  
// Data input from file.
   int count =0;
   while ( infile >> scores[count] )  
      ++count;
   infile.close();

// Display the stem-and-leaf plot and statistics
// to the specified output stream:
   std::sort ( scores, scores+count);
   printHist ( scores, count, binWidth, *osPtr );
   printStats( scores, count, binWidth, *osPtr );
   if (outfile) outfile.close();

  return EXIT_SUCCESS;
}