#ifndef POLYNOMIAL_H
#define POLYNOMIAL_H
#include <cstdlib>
#include <iostream>

namespace csci301128_polynomial
{
    class polynomial
    {

      public:
        // MEMBER CONSTANT
        static const size_t MAX_CAPACITY = 10;
        typedef double Data;

        // CONSTRUCTORS
        polynomial (size_t cap = MAX_CAPACITY);
        polynomial (const polynomial& original);

        // DESTRUCTOR
        ~polynomial();

        // MODFICATION MEMBER FUNCTIONS
        void operator = (const polynomial& original);
        void empty () { degree = 0; };
        void insert (const Data& entry, const size_t& entry_degree);

        // CONSTANT MEMBER FUNCTIONS
        std::size_t degree_poly() const { return degree; };
        polynomial operator + (const polynomial& p1);
        polynomial operator * (const Data& real_const);
        polynomial derivative ();

        // FRIEND FUNCTIONS
        friend polynomial operator * ( const double& real_const, const polynomial &or$
        friend std::istream& operator >> (std::istream& in_s, polynomial &original);
        friend std::ostream& operator << (std::ostream& out_s, const polynomial &orig$

      private:

        double *coeff;
        size_t degree;
        size_t capacity;

        // PRIVATE FUNCTIONS:
        void resize ( size_t new_cap );
    };

}
#endif

#include <cstdlib>
#include <iomanip>
#include <cassert>
#include <iostream>
#include <fstream>
#include "polynomial.h"
using namespace std;

namespace csci301128_polynomial
{

  polynomial::polynomial (size_t in_capacity)
  {
    coeff = new Data[in_capacity];
    capacity = in_capacity;
    degree = 0;
  }

  polynomial::polynomial (const polynomial& original)
  {
    capacity = original.capacity;
    coeff = new Data[capacity];
    degree = original.degree;
  }

  polynomial::~polynomial ( )
  {
  {
    delete [] coeff;
  }

  void polynomial::operator = (const polynomial& original)
  {
    Data *new_data;

    if ( this == &original )
      return;

    if (capacity != original.capacity)
    {
      new_data = new Data[original.capacity];
      delete [] coeff;
      coeff = new_data;
      capacity = original.capacity;
    }

    degree = original.degree;
    for (size_t i=0; i < degree+1; ++i)
    for (size_t i=0; i < degree+1; ++i)
      coeff[i] = original.coeff[i];
  }

// void empty() is an inline function

  void polynomial::insert (const Data& entry, const size_t& entry_degree)
  {
    if (entry_degree == capacity)
      resize (degree+1);
    coeff[entry_degree] = entry;
    if (entry_degree > degree)
      degree = entry_degree;
  }

// size_t degree_poly () const is an inline function

  polynomial polynomial::operator + (const polynomial& p1)
  {
  polynomial p2;
    for (size_t i = 0; i < degree+1; ++i)
      p2.coeff[i] =  p1.coeff[i] + coeff[i];

  return p2;
  }

  polynomial polynomial::operator * (const Data& real_const)
  {
    polynomial new_coeff;
    size_t i;
    for ( i = 0; i < degree+1; ++i)
      new_coeff.coeff[i] = coeff[i] * real_const;

    return new_coeff;
  }

  polynomial polynomial::derivative ()
  {
    polynomial new_coeff;
    size_t i;
    size_t temp_deg = degree;
    for ( i = degree; i = 0; --i)
    {
      new_coeff.coeff[i-1] = coeff[i] * temp_deg;
      --temp_deg;
    }
  }

  polynomial operator * (const double& real_const, const polynomial &original)
  {
  polynomial new_coeff;
  size_t i;
  for ( i=0; i < original.degree+1; ++i)
    new_coeff.coeff[i] = original.coeff[i] * real_const;

  return new_coeff;
  }

  istream& operator >> ( istream& in_s, polynomial &original )
  {
  size_t exponent;
  double coefficient;

  original.empty();
  do
  {
    cin >> coefficient >> exponent;
    original.insert(coefficient, exponent);
  } while (cin.peek() != '\n');

  return in_s;
  }

  ostream& operator << ( ostream& out_s, const polynomial& original)
  {
  size_t i;
  for (i=0; i < original.degree+1; i++)
  cout << original.coeff[i] << " " << i << " ";
  cout << endl;
  return out_s;
  }

  void polynomial::resize (size_t new_cap)
  {
    Data *new_coeff;

    if (new_cap == capacity)
      return;

    if (new_cap < degree)
      new_cap = degree;

    new_coeff = new Data[new_cap];
    for (size_t i=0; i < degree+1; ++i)
      new_coeff = coeff;
    delete [] coeff;
    coeff = new_coeff;
    capacity = new_cap;
  }
}

#include <cstdlib>
#include <iomanip>
#include <cctype>
#include <iostream>
#include "polynomial.h"

using namespace std;
using namespace csci301128_polynomial;

void menu();
char get_choice();

int main()
{

polynomial p1, p2, p3, p4;
char choice;


cin >> p1;
cout << p1 << endl;;

p2 = p1;
cout << p2 << endl;
p3 = p1+p2;
cout << p3 << endl;
p4 = p1.derivative();
cout << p4;

cout << p1.degree_poly() << endl;
p1.~polynomial();
return EXIT_SUCCESS;
}