Program 1A

/*
*/

#ifndef NUMBER_LIST_H
#define NUMBER_LIST_H

#include <list>
#include <iostream>

//a class which encapsulates a list of double values, adding the features of
//mean and standard deviation
class number_list : public list< double >
{
 public:
  void read_from_stream( istream& input );
  void read_entry_from_stream( istream& input, int line_number );
  double sum( void ) const;
  double mean( void ) const;
  double standard_deviation( void ) const;
  int entry_count( void ) const;
  void add_entry( double new_entry );
};

#endif

/*
*/

/*
*/

#include "number_list.h"
#include <assert.h>
#include <stdlib.h>
#include <math.h>

void 
number_list::read_from_stream( istream& input )
{
  int line_number = 1;
  while ( !(input.eof()) )
    {
      read_entry_from_stream( input, line_number );
    }
}

void 
number_list::read_entry_from_stream( istream& input, int line_number )
{
  double next_entry;
  const int input_buffer_size = 255;
  char input_buffer[ input_buffer_size ];
  input.getline( input_buffer, input_buffer_size );
  //now convert to floating point using strtod
  char* conversion_end = NULL;
  next_entry = strtod( input_buffer, &conversion_end );
  if ( conversion_end != input_buffer )
    {
      add_entry( next_entry );
    }
  else if ( !(input.eof()) )
    {
      cerr << "(unknown file):" << line_number << ":Error in conversion to double\n";
    }
}

double 
number_list::sum( void ) const
{
  double Result = 0;
  for ( list<double>::const_iterator iter = begin();
	iter != end();
	++iter )
    {
      Result += *iter;
    }
  return Result;
}

double 
number_list::mean( void ) const
{
  assert( entry_count() > 0 );
  return sum() / entry_count();
}

double 
number_list::standard_deviation( void ) const
{
  assert( entry_count() > 1 );
  double sum_of_square_differences = 0;
  for ( list<double>::const_iterator iter = begin();
	iter != end();
	++iter )
    {
      const double this_square_difference = *iter - mean();
      sum_of_square_differences += this_square_difference * this_square_difference;
    }
  return sqrt( sum_of_square_differences / ( entry_count() - 1 ));
}

int 
number_list::entry_count( void ) const
{
  return size();
}

void 
number_list::add_entry( double new_entry )
{
  push_back( new_entry );
}

/*
*/

/*
*/

#include <fstream>
#include <iostream>
#include "string.h"

#ifndef NUMBER_LIST_H
#include "number_list.h"
#endif

istream *
input_stream_from_args( int arg_count, const char** arg_vector )
{
  istream* Result = NULL;
  if ( arg_count == 1 )
    {
      Result = &cin;
    }
  else 
    {
      const char* help_text = "\
PSP exercise 1A: Get the mean and standard deviation of a list\n
of ASCII real numbers, from either standard input or a text\n
file.\n\n\
Usage: \n \
\tpsp_1a\n\n";
      cout << help_text;
    }
  return Result;
}

int main( int arg_count, const char** arg_vector )
{
  //get the input stream, or print the help text as appropriate
  istream* input_stream = input_stream_from_args( arg_count, arg_vector );
  if ( input_stream != NULL ) 
    {
      //read the entries from the input stream
      number_list a_list;
      a_list.read_from_stream( *input_stream );
      cout << a_list.entry_count() << " numbers processed.\n";
      //output the mean, as appropriate
      if ( a_list.entry_count() > 0 )
	{
	  cout << "Mean: " << a_list.mean() << "\n";
	}
      else
	{
	  cout << "Too few entries to calculate mean\n";
	}
      //output the standard deviation, as appropriate
      if ( a_list.entry_count() > 1 )
	{
	  cout << "Standard Deviation: " << a_list.standard_deviation() << "\n";
	}
      else
	{
	  cout << "Too few entries to calculate standard deviation.\n";
	}
    }
}

/*
*/

class NUMBER_LIST

inherit 
   LINKED_LIST[DOUBLE];
   
creation {ANY} 
   make

feature {ANY} 
   
   line_counter: INTEGER;
   
   read_from_stream(input: INPUT_STREAM) is 
      do  
         line_counter := 0;
         from 
         until 
            input.end_of_input
         loop 
            read_entry_from_stream(input);
         end; 
      end -- read_from_stream
   
   report_error(error_type: STRING) is 
      do  
         std_error.put_string("(unknown file):");
         std_error.put_integer(line_counter);
         std_error.put_string(error_type);
         std_error.put_new_line;
      end -- report_error
   
   read_entry_from_stream(input: INPUT_STREAM) is 
      do  
         input.read_line;
         if not input.end_of_input then 
            if input.last_string.is_double then 
               add_last(input.last_string.to_double);
            elseif input.last_string.is_integer then 
               add_last(input.last_string.to_integer.to_double);
            else 
               report_error("Not a double");
            end; 
         end; 
      end -- read_entry_from_stream
   
   sum: DOUBLE is 
      local 
         i: INTEGER;
      do  
         from 
            i := lower;
         until 
            not valid_index(i)
         loop 
            Result := Result + item(i);
            i := i + 1;
         end; 
      end -- sum
   
   mean: DOUBLE is 
      require 
         count > 0; 
      do  
         Result := sum / count.to_double;
      end -- mean
   
   standard_deviation: DOUBLE is 
      require 
         count > 1; 
      local 
         i: INTEGER;
         this_term_difference: DOUBLE;
         top_term: DOUBLE;
      do  
         from 
            i := lower;
         until 
            not valid_index(i)
         loop 
            this_term_difference := item(i) - mean;
            top_term := top_term + this_term_difference ^ 2;
            i := i + 1;
         end; 
         Result := (top_term / (count - 1)).sqrt;
      end -- standard_deviation

end -- NUMBER_LIST

class MAIN

creation
   make
   
feature { ANY }
   
   make is
      local
	 number_list : NUMBER_LIST
      do
	 !!number_list.make
	 number_list.read_from_stream( io )
	 --now output results
	 if ( number_list.count > 0 ) then
	    std_output.put_string( "Mean: " )
	    std_output.put_double( number_list.mean )
	 else
	    std_output.put_string( "Not enough entries for mean" )   
	 end --if
	 std_output.put_new_line
	 if ( number_list.count > 1 ) then
	    std_output.put_string( "Standard Deviation: " )
	    std_output.put_double( number_list.standard_deviation )
	 else
	    std_output.put_string( "Not enough entries for standard deviation" )   
	 end --if
	 std_output.put_new_line
      end
   
end-- MAIN