//  Implementation for 1st version of the Polynomial class.  Each
//  coefficient, including zeroes, is represented up to the maximum
//  degree.

#include <iostream>
#include <cassert>
using namespace std;

#include "polynomial.h"

//  In the constructors and destructors and throughout the code, note
//  the use of the vector member functions.

Polynomial::Polynomial() 
{}

Polynomial::Polynomial( double a0 )
{
  coefficients_.push_back( a0 );
}

Polynomial::Polynomial( const Polynomial & old )
{
  coefficients_ = old.coefficients_;   // vector assignment operator
}

Polynomial::~Polynomial( )
{}


const Polynomial & 
Polynomial::operator = ( const Polynomial& right )
{
  if ( this != &right )
    coefficients_ = right.coefficients_; 
  return *this;
}



double 
Polynomial::operator() ( double x ) const
{
  if ( coefficients_.size() == 0 ) return 0.0;

  double value=coefficients_[0];          // result
  double x_i = 1.0;                       // x^i, built incrementally
  for ( int i=1; i<coefficients_.size(); ++i ) {
    x_i *= x;
    value += coefficients_[i] * x_i;
  }
  return value;
}


double 
Polynomial::get_coefficient( int exponent ) const
{
  assert( exponent >= 0 );
  if ( exponent >= coefficients_.size() )
    return 0.0;
  else
    return coefficients_[exponent];
}


//  Find the maximum degree.  Start at the largest represented
//  exponent and go down until a term with non-zero exponent is found.
//  Usually, the while loop will have no iterations, but the code does
//  not attempt to reduce the highest degree represented when the
//  coefficient of the highest exponent is assigned 0.

int 
Polynomial::max_degree() const
{
  int max_d = coefficients_.size()-1;
  while ( max_d >= 0 && coefficients_[max_d] == 0.0 )
    -- max_d;
  return max_d;
}


//  Assign the coefficient for the given exponent.  If this exponent
//  is larger than the largest store, expand the vector by padding
//  with an appropriate number of 0's.

void 
Polynomial::assign_coefficient( double coefficient, int exponent )
{
  assert( exponent >= 0 );
  if ( exponent >= coefficients_.size() ) {
    for ( int i=coefficients_.size(); i<exponent; ++i ) 
      coefficients_.push_back( 0.0 );
    coefficients_.push_back( coefficient );
  }
  else
    coefficients_[exponent] = coefficient;
}


//  Just copy the coefficients of the higher-degree polynomial to the
//  result and add the coefficients, term by term, from the lower
//  degree polynomial.

Polynomial operator+ (const Polynomial& f, const Polynomial& g)
{
  Polynomial h;
  int f_size = f.coefficients_.size();
  int g_size = g.coefficients_.size();

  if ( f_size > g_size ) {
    h.coefficients_ = f.coefficients_;
    for( int i=0; i<g_size; ++i )
      h.coefficients_[i] += g.coefficients_[i];
  }
  else {
    h.coefficients_ = g.coefficients_;
    for( int i=0; i<f_size; ++i )
      h.coefficients_[i] += f.coefficients_[i];
  }

  return h;
}


//  Subtraction uses multiplication and addition.  It would be
//  slightly faster to do this directly.

Polynomial operator- (const Polynomial& f, const Polynomial& g)
{
  return f + (-1)*g;
}


// Multiplication requires first establishing the proper size vector
// and initializing the coefficients to 0.  Then, each pair of terms
// from the original polynomials are multiplied (multiplying the
// coefficients and adding the exponents).

Polynomial operator* (const Polynomial& f, const Polynomial& g )
{
  Polynomial h;
  int max_degree = (f.coefficients_.size()-1) + (g.coefficients_.size()-1);
  h.coefficients_.resize( max_degree+1, 0.0 );
  for ( int i=0; i<f.coefficients_.size(); ++i )
    for ( int j=0; j<g.coefficients_.size(); ++j )
      h.coefficients_[i+j] += f.coefficients_[i] * g.coefficients_[j];
  return h;
}


// Copy the polynomial and then scale each coefficent.

Polynomial operator* (double a, const Polynomial& f)
{
  Polynomial h( f );
  for ( int i=0; i<h.coefficients_.size(); ++i )
    h.coefficients_[i] *= a;
  return h;
}


Polynomial operator* (const Polynomial& f, double a)
{
  return a*f;
}

//  The output operator has a few special case checks to make sure the
//  appearance is somewhat natural.

ostream& operator<< ( ostream& ostr, const Polynomial& f )
{
  bool first_out = true;
  for ( int i=0; i<f.coefficients_.size(); ++i ) {
    if ( f.coefficients_[i] != 0.0 ) {
      if ( first_out )
	first_out = false;
      else
	ostr << " + ";
      ostr << f.coefficients_[i];
      if ( i != 0) ostr << " x^" << i;
    }
  }
  if ( first_out ) ostr << "0";    // output when all 0 coefficients
  return ostr;
}