doubly linked list polynomials

[blueliger22]

namespace main_savitch_5

{

    class polynode

    {

		public:

		// CONSTRUCTOR: Creates a node containing a specified initial

		// coefficient (init_coef), initial exponent (init_exponent), and

		// initial links forward and backward (init_fore and init_back).

		polynode(

			double init_coef = 0.0,

			unsigned int init_exponent = 0,

			polynode* init_fore = nullptr,

			polynode* init_back = nullptr

	    )

	    {

			coef_field = init_coef;

			exponent_field = init_exponent;

			link_fore = init_fore;

			link_back = init_back;

	    }



		// Member functions to set the fields: 

    	void set_coef(double new_coef)

	    { coef_field = new_coef; }

    	void set_exponent(unsigned int new_exponent)

	    { exponent_field = new_exponent; }

    	void set_fore(polynode* new_fore)

	    { link_fore = new_fore; }

    	void set_back(polynode* new_back)

	    { link_back = new_back; }



		// Const member functions to retrieve current coefficient or exponent:

		double coef( ) const { return coef_field; }

		unsigned int exponent( ) const { return exponent_field; }



		// Two slightly different member functions to retrieve each link:

		const polynode* fore( ) const { return link_fore; }

		polynode* fore( )             { return link_fore; }

		const polynode* back( ) const { return link_back; }

    	polynode* back( )             { return link_back; }

	

    private:

		double coef_field;

		unsigned int exponent_field;

		polynode *link_fore;

		polynode *link_back;

    };



    class polynomial

    {

		public:

			// CONSTRUCTORS and DESTRUCTOR

			polynomial(double c = 0.0, unsigned int exponent = 0);

			polynomial(const polynomial& source);

			~polynomial( );



			// MODIFICATION MEMBER FUNCTIONS

			polynomial& operator =(const polynomial& source);

			void add_to_coef(double amount, unsigned int exponent);

			void assign_coef(double coefficient, unsigned int exponent);

			void clear( );

	

			// CONSTANT MEMBER FUNCTIONS

			double coefficient(unsigned int exponent) const;

			unsigned int degree( ) const { return current_degree; }

			polynomial derivative( ) const;

			double eval(double x) const;

			void find_root(

				double& answer,

				bool& success,

				unsigned int& iterations,

				double guess = 0,

				unsigned int maximum_iterations = 100,

				double epsilon = 1e-8

			) const;

			unsigned int next_term(unsigned int e) const;

			unsigned int previous_term(unsigned int e) const;

	

			// CONSTANT OPERATORS

			double operator( ) (double x) const { return eval(x); }

	

		private:

			double EPSILON;

			

			polynode *head_ptr;             // Head pointer for list of terms

			polynode *tail_ptr;             // Tail pointer for list of terms

			mutable polynode *recent_ptr;   // Most recently used term

			unsigned int current_degree;    // Current degree of the polynomial

			// A private member function to aid the other functions:

			void set_recent(unsigned int exponent) const;

    };

    

    // NON-MEMBER BINARY OPERATORS

    polynomial operator +(const polynomial& p1, const polynomial& p2);

    polynomial operator -(const polynomial& p1, const polynomial& p2);

    polynomial operator *(const polynomial& p1, const polynomial& p2);

    

    // NON-MEMBER OUTPUT FUNCTIONS

    std::ostream& operator << (std::ostream& out, const polynomial& p);

}



    



#endif


{

	polynomial::polynomial(double c, unsigned int exponent)

	{

		// store machine epsilon

		EPSILON = std::numeric_limits<double>::epsilon();

		// write the rest

		

		 coef[exponent] = c;

    }



    polynomial& polynomial::operator=(const polynomial& source)

    {

		// store machine epsilon

		EPSILON = std::numeric_limits<double>::epsilon();

		// write the rest

		return *this;

	}

	

    polynomial::polynomial(const polynomial& source)

    {

		// store machine epsilon

		EPSILON = std::numeric_limits<double>::epsilon();

		// write the rest

		current_array_size = source.current_array_size;

		coef = new double[current_array_size];

		copy (source.coef, source.coef + current_array_size, coef);

    }



    polynomial::~polynomial()

    {

		delete [] coef;

		coef = NULL;

		clear();

    }



    void polynomial::clear()

    {

		fill_n (coef, current_array_size, 0.0);

    }

    

    double polynomial::coefficient(unsigned int exponent) const

    {

		return (coef[exponent]);

		return 0;

    }



    void polynomial::add_to_coef(double amount, unsigned int exponent)

    {

		reserve (exponent + 1);

		coef[exponent] += amount;

	}



    void polynomial::assign_coef(double coefficient, unsigned int exponent)

    {

    }



    unsigned int polynomial::next_term(unsigned int exponent) const

    {

			return 0;

    }



	unsigned int polynomial::previous_term(unsigned int exponent) const

    {

		return UINT_MAX;

    }

    

    void polynomial::set_recent(unsigned int exponent) const

    {

	}

    

    double polynomial::eval(double x) const

    {

		double total = 0;

		return total;

    }



    polynomial polynomial::derivative() const

    {

		polynomial p_prime;

		return p_prime;

    }

    

    polynomial operator+(const polynomial& p1, const polynomial& p2)

    {

		polynomial p;

		return p;

    }

    

    polynomial operator-(const polynomial& p1, const polynomial& p2)

    {

		polynomial p;

		return p;

    }

    

    polynomial operator*(const polynomial& p1, const polynomial& p2)

    {		

		polynomial p;

		return p;

    }



    ostream& operator << (ostream& out, const polynomial& p)

    {

		return out;

    }

    

    void polynomial::find_root(

	double& answer,

	bool& success,

	unsigned int& iterations,

	double guess,

	unsigned int maximum_iterations,

	double epsilon) const

    {

	}

}

[TwilightSpectre]

Do you have a question? Or are you just posting 440 lines of code because you feel like it?