Program 4A: Linear Regression Analysis

/*
*/

#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:
  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>


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 );
}

/*
*/

/*
*/

#ifndef PAIRED_NUMBER_LIST_H
#define PAIRED_NUMBER_LIST_H

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

class paired_number_list : public number_list
{
 public:
  //modifiers
  void add_entry( double x, double y );
  void reset( void );
  paired_number_list( void );
  //number of entries
  int entry_count( void ) const;

  double x_sum( void ) const;
  double x_mean( void ) const;
  double x_standard_deviation( void ) const;

  double y_sum( void ) const;
  double y_mean( void ) const;
  double y_standard_deviation( void ) const;

  double beta_1_numerator( void ) const;
  double beta_1_denominator( void ) const;
  double beta_1( void ) const;
  double beta_0( void ) const;
 protected:
  number_list m_xs;
  number_list m_ys;
};


#endif
/*
*/

/*
*/

#include "paired_number_list.h"
#ifndef CONTRACT_H
#include "contract.h"
#endif

void
paired_number_list::reset( void )
{
  m_xs.clear();
  m_ys.clear();
}

paired_number_list::paired_number_list( void ) 
{
  reset();
}


int
paired_number_list::entry_count( void ) const
{
  REQUIRE( m_xs.entry_count() == m_ys.entry_count() );
  return m_xs.entry_count();
}

void
paired_number_list::add_entry( double x, double y )
{
  m_xs.add_entry( x );
  m_ys.add_entry( y );
}

double
paired_number_list::x_sum( void ) const
{
  return m_xs.sum();
}

double
paired_number_list::x_mean( void ) const
{
  return m_xs.mean();
}

double
paired_number_list::x_standard_deviation( void ) const
{
  return m_xs.standard_deviation();
}

double
paired_number_list::y_sum( void ) const
{
  return m_ys.sum();
}

double
paired_number_list::y_mean( void ) const
{
  return m_ys.mean();
}

double
paired_number_list::y_standard_deviation( void ) const
{
  return m_ys.standard_deviation();
}

double
paired_number_list::beta_1_numerator( void ) const
{
  double Result = 0;
  list<double>::const_iterator x_iter;
  list<double>::const_iterator y_iter;

  for( x_iter = m_xs.begin(), y_iter = m_ys.begin();
       (x_iter != m_xs.end()) && (y_iter != m_ys.end());
       ++x_iter, ++y_iter )
    {
      Result += (*x_iter)*(*y_iter);
    }
  Result -= static_cast<double>(entry_count())*x_mean()*y_mean();
  return Result;
}

double
paired_number_list::beta_1_denominator( void ) const
{
  double Result = 0;
  list<double>::const_iterator x_iter;
  list<double>::const_iterator y_iter;
  for( x_iter = m_xs.begin(), y_iter = m_ys.begin();
       (x_iter != m_xs.end()) && (y_iter != m_ys.end());
       ++x_iter, ++y_iter )
    {
      Result += (*x_iter)*(*x_iter);
    }
  Result -=  static_cast<double>(entry_count())*x_mean()*x_mean();
  return Result;
}

double
paired_number_list::beta_1( void ) const
{
  return beta_1_numerator() / beta_1_denominator();
}

double
paired_number_list::beta_0( void ) const
{
  return y_mean() - beta_1() * x_mean();
}

/*
*/

/*
*/

#ifndef READABLE_PAIRED_NUMBER_LIST_H
#define READABLE_PAIRED_NUMBER_LIST_H

#ifndef PAIRED_NUMBER_LIST_H
#include "paired_number_list.h"
#endif
#ifndef SIMPLE_INPUT_PARSER_H
#include "simple_input_parser.h"
#endif

class readable_paired_number_list : public paired_number_list, public simple_input_parser
{
 public:
  virtual void parse_last_line( void );
  virtual void reset( void );
  void clear_error_flag( void );
  void check_error( bool condition, const std::string& message );
  void report_error( const std::string& message );
  readable_paired_number_list::readable_paired_number_list( void );
 protected:
  int line_number;
  bool error_found;
};

#endif
/*
*/

/*
*/


#include "readable_paired_number_list.h"

void
readable_paired_number_list::parse_last_line( void )
{
  clear_error_flag();
  //split the string around the comma
  std::string::size_type comma_index = last_line().find( ',' );
  check_error( comma_index == last_line().npos, "No comma" );
  std::string x_string = last_line().substr( 0, comma_index );
  std::string y_string = last_line().substr( comma_index + 1, last_line().length() );
  //get values for each double and ensure they're valid
  char* conversion_end = NULL;
  double new_x = strtod( x_string.c_str(), &conversion_end );
  check_error( conversion_end == x_string.data(), "X invalid" );
  double new_y = strtod( y_string.c_str(), &conversion_end );
  check_error( conversion_end == y_string.data(), "Y invalid" );
  //add the entry
  if ( ! error_found ) 
    {
      cout << "added: " << new_x << ", " << new_y << "\n";
      add_entry( new_x, new_y );
    }
}

void
readable_paired_number_list::clear_error_flag( void ) 
{
  error_found = false;
}

void
readable_paired_number_list::reset( void ) 
{
  line_number = 0;
  clear_error_flag();
}

readable_paired_number_list::readable_paired_number_list( void ) :
paired_number_list(),
simple_input_parser()
{
  reset();
}

void
readable_paired_number_list::check_error( bool condition, const std::string& message )
{
  if ( condition ) 
    {
      error_found = true;
      report_error( message );
    }
}

void
readable_paired_number_list::report_error( const std::string& message )
{
  cerr << "input:" << line_number << ":" << message << ":" << last_line() << "\n";
}

/*
*/

/*
*/

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

#ifndef READABLE_PAIRED_NUMBER_LIST_H
#include "readable_paired_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 4A: Calculate the linear regression parameters from
a set of comma-separated values, from standard input.
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
      readable_paired_number_list a_list;
      a_list.set_input_stream( input_stream );
      a_list.parse_until_eof();
      cout << a_list.entry_count() << " entries processed.\n";
      //output the mean, as appropriate
      if ( a_list.entry_count() > 0 )
	{
	  cout << "Beta 0: " << a_list.beta_0() << "\n";
	  cout << "Beta 1: " << a_list.beta_1() << "\n";
	}
      else
	{
	  cout << "Too few entries to calculate\n";
	}
    }
}

/*
*/

class NUMBER_LIST

inherit 
   LINKED_LIST[DOUBLE];
   
creation {ANY} 
   make

feature {ANY} 
   
   line_counter: INTEGER;
   
   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 PAIRED_NUMBER_LIST
   
creation
   make

feature { NONE }
   
   xs : NUMBER_LIST
   
   ys : NUMBER_LIST
   
feature {ANY}
   
   add_entry( new_x, new_y : DOUBLE ) is
      do
	 xs.add_last( new_x )
	 ys.add_last( new_y )
	 std_output.put_double( new_x )
	 std_output.put_string( ", " )
	 std_output.put_double( new_y )
	 std_output.put_string( "%N" )
      end
   
   count : INTEGER is
      do
	 Result := xs.count
      end
   
   x_sum : DOUBLE is
      do
	 Result := xs.sum
      end
   
   x_mean : DOUBLE is
      do
	 Result := xs.mean
      end
   
   x_standard_deviation : DOUBLE is
      do
	 Result := xs.standard_deviation
      end
   
   y_sum : DOUBLE is
      do
	 Result := ys.sum
      end
   
   y_mean : DOUBLE is
      do
	 Result := ys.mean
      end
   
   y_standard_deviation : DOUBLE is
      do
	 Result := ys.standard_deviation
      end
   
   entry_count : INTEGER is
      do
	 Result := xs.count
      end
   
   beta_1_numerator : DOUBLE is
      local
	 index : INTEGER
      do
	 Result := 0
	 from
	    index := xs.lower
	 until
	    not ( xs.valid_index( index ) and ys.valid_index( index ) )
	 loop
	    Result := Result + xs.item(index) * ys.item( index )
	    index := index + 1
	 end
	 Result := Result - entry_count.to_double * x_mean * y_mean
      end
   
   beta_1_denominator : DOUBLE is
      local
	 index : INTEGER
      do
	 Result := 0
	 from
	    index := xs.lower
	 until
	    not ( xs.valid_index( index ) and ys.valid_index( index ) )
	 loop
	    Result := Result + xs.item(index) * xs.item( index )
	    index := index + 1
	 end
	 Result := Result - entry_count.to_double * x_mean * x_mean
      end
   
   beta_1 : DOUBLE is
      do
	 Result := beta_1_numerator / beta_1_denominator
      end
   
   beta_0 : DOUBLE is
      do
	 Result := y_mean - beta_1 * x_mean
      end
   
   make is
      do
	 !!xs.make
	 !!ys.make
      end
   
   reset is
      do
	 xs.clear
	 ys.clear
      end
   
invariant
   
   xs.count = ys.count
   
end -- PAIRED_NUMBER_LIST

class READABLE_PAIRED_NUMBER_LIST
   
inherit
   SIMPLE_INPUT_PARSER
      redefine
	 parse_last_line
      end
   
   PAIRED_NUMBER_LIST
      redefine
	 make
      end
   
creation
   make

feature {ANY}
   
   make is
      do
	 Precursor
      end
	 
   parse_last_line is
	 --read comma-separated numbers
      local
	 comma_index : INTEGER
	 x_string : STRING
	 y_string : STRING
	 new_x : INTEGER
	 new_y : INTEGER
      do
	 clear_error_flag
	 comma_index := last_line.index_of( ',' )
	 check_for_error( comma_index = last_line.count + 1, "No comma" )
	 x_string := last_line.substring( 1, comma_index - 1 )
	 y_string := last_line.substring( comma_index + 1, last_line.count )
	 check_for_error( not ( x_string.is_double or x_string.is_integer), "invalid X" )
	 check_for_error( not (y_string.is_double or y_string.is_integer), "invalid Y" )
	 if not error_flag then
	    add_entry( double_from_string( x_string ), double_from_string( y_string ) )
	 end
      end
   
   double_from_string ( string : STRING ) : DOUBLE is
      require
	 string.is_double or string.is_integer
      do
	 if string.is_double then
	    Result := string.to_double
	 elseif string.is_integer then
	    Result := string.to_integer.to_double
	 end
      end
   
   error_flag : BOOLEAN
   
   clear_error_flag is
      do
	 error_flag := false
      end
   
   check_for_error( condition : BOOLEAN; message : STRING ) is
      do
	 if condition then
	    error_flag := true
	    report_error( message )
	 end
      end
   
   report_error( message : STRING ) is
      do
	 std_error.put_string( message + ":" + last_line + "%N" )
      end
   
end

                                                        

class MAIN

creation
   make
   
feature { ANY }
   
   make is
      local
	 number_list : READABLE_PAIRED_NUMBER_LIST
      do
	 !!number_list.make
	 number_list.set_input( io )
	 number_list.parse_until_eof
	 --now output results
	 if ( number_list.count > 0 ) then
	    std_output.put_string( "Beta 0: " )
	    std_output.put_double( number_list.beta_0 )
	    std_output.put_string( "%NBeta 1: " )
	    std_output.put_double( number_list.beta_1 )
	    std_output.put_string( "%N" )
	 else
	    std_output.put_string( "Not enough entries for calculations" )   
	 end --if
      end
   
end-- MAIN