A C++ Matrix Template Class

Listing 3: Polynomial template class

// poly.h - polynomial template class
//
#include <stdexcept>
#include <vector>
#include <memory>
#include <function>
#include <stdlib>

template<class T>
class polynomial {
   public:
      ~polynomial();
      // constructors
      // initializes the constant term
      polynomial( const T& x0 = T(0.0) );
      // initializes from an array of coefficients
      polynomial( unsigned nc, const T *init );
      // copy constructor
      polynomial( const polynomial<T>& cp );

      // evaluate the function for a given x
      T operator()( const T& x ) const;
      // chain a polynomial
      polynomial<T> operator()( const polynomial<T>& P ) const;
      // access coefficient array
      T& operator[](int);
      const T& operator[](int) const;

      // equality
      bool operator==( const polynomial<T>& A ) const;
      bool operator!() const {
         return *this == polynomial<T>(0.0);
      }

      // assignment
      polynomial<T>& operator=( const polynomial<T>& cp );

      polynomial<T>& operator+=( const polynomial<T>& P );
      polynomial<T> operator+( const polynomial<T>& P ) const {
         return polynomial<T>(*this) += P;
      }
      polynomial<T>& operator-=( const polynomial<T>& P );
      polynomial<T> operator-( const polynomial<T>& P ) const {
         return polynomial<T>(*this) -= P;
      }
      polynomial<T> operator-() const;
      polynomial<T> operator+() const {
         return *this;
      }
      // same as multiplying by x ^ i
      polynomial<T> operator<<( int i ) const {
         return polynomial<T>(*this) <<= i;
      }
      // same as multiplying by x ^ -i
      polynomial<T> operator>> ( int i ) const {
         return operator<<(-i);
      }
      polynomial<T>& operator<<=( int i ) {
         ofs-=i;
         return *this;
      }
      polynomial<T>& operator>>=( int i ) {
         return operator<<=(-i);
      }
      polynomial<T> operator*( const polynomial<T>& P ) const;
      polynomial<T>& operator*=( const polynomial<T>& P ) {
         return *this = (*this * P);
      }
      polynomial<T> operator/( const polynomial<T>& D ) const;
      polynomial<T>& operator/=( const polynomial<T>& D ) {
         return *this = operator/(D);
      }

      // returns the deriviative function
      polynomial<T> derivative() const;

      // returns the integral function for the interval from c to x
      polynomial<T> integral( const T& c ) const;

      int upper() const;
      int lower() const;

   private:
      std::vector<T> C;
      unsigned n;   // number of elements in array
      int ofs;      // array offset
      const T T0;   // additive identity of template parameter
};

//not shown: implementation of constructors, destructor, operators
// derivative()const, integral (const T & c) const,
// -- mb
// ...

//not shown: integral(const T& c) const, inserters -- mb
// ...
/* End of File */