Implement Class "polynomial" with a Linked List I already wrote a program but it is failing all the tests HELP PLEASE I mostly need help with assign_coef and add_to_coef

LINKED LISTS

// FILE: poly2.h

// CLASS PROVIDED:

// class polynomial (in the namespace main_savitch_5)

// A polynomial has one variable x, real number coefficients, and

// non-negative integer exponents. Such a polynomial can be viewed

// as having the form:

// A[n]*x^n + A[n-1]*x^(n-1) + ... A[2]*x^2 + A[1]*x + A[0]

// where the A[n] are the real number coefficients and x^i represents

// the variable x raised to the i power. The coefficient A[0] is

// called the "constant" or "zeroth" term of the polynomial.

//

// NOTES TO STUDENT:

// 1. This version works by storing the coefficients in

// a doubly-linked list with each node holding the coefficient and

// exponent for one term. The terms are kept in order from smallest

// to largest exponent. Each polynomial also maintains a pointer to the

// most recently accessed node.

// 2. Note that two functions have been implemented as inline functions

// in this file (the degree and operator() functions).

//

// CONSTRUCTOR for the polynomial class

// POSTCONDITION: This polynomial has been created with all zero

// coefficients, except for coefficient c for the specified exponent.

// When used as a default constructor (using default values for

// both arguments), the result is a polynomial with all zero

// coefficients.

//

// MODIFICATION MEMBER FUNCTIONS for the polynomial class

// void add_to_coef(double amount, unsigned int exponent)

// POSTCONDITION: Adds the given amount to the coefficient of the

// specified exponent.

//

// void assign_coef(double coefficient, unsigned int exponent)

// POSTCONDITION: Sets the coefficient for the specified exponent.

//

// void clear( )

// POSTCONDITION: All coefficients of this polynomial are set to zero.

//

// CONSTANT MEMBER FUNCTIONS for the polynomial class

// double coefficient(unsigned int exponent) const

// POSTCONDITION: Returns coefficient at specified exponent of this

// polynomial.

//

// unsigned int degree( ) const

// POSTCONDITION: The function returns the value of the largest exponent

// with a non-zero coefficient.

// If all coefficients are zero, then the function returns zero.

//

// polynomial derivative( ) const

// POSTCONDITION: The return value is the first derivative of this

// polynomial.

//

// double eval(double x) const

// POSTCONDITION: The return value is the value of this polynomial with the

// given value for the variable x.

//

// void find_root(

// double& answer,

// bool& success,

// unsigned int& iterations,

// double starting_guess = 0,

// unsigned int maximum_iterations = 100,

// double epsilon = 1e-8

// )

// const

// PRECONDITION: epsilon > 0.

// POSTCONDITION: This function uses Newton's method to search for a root

// of the polynomial (i.e., a value of x for which the polynomial is zero).

// The method requires some starting guess for the value of the root. This

// guess is improved over a series of iterations (with the maximum allowed

// iterations defined by the parameter maximum_iterations). There are three

// possible outcomes:

// 1. SUCCESS:

// The method hits a near-root (a value of x for which the absolute

// value of the polynomial is no more than epsilon). In this case, the

// function sets answer to equal this near-root, success is set to true,

// and iterations is set to the number of iterations required.

// 2. FLAT FAILURE:

// Newton's method fails because the guess hits a very flat area of the

// polynomial (a point where first derivative is no more than epsilon).

// In this case, the function sets answer equal to the guess that caused

// flat failure, success is set to false, and iterations is the number

// of iterations carried out (which will be less than

// maximum_iterations).

// 3. MAXIMUM ITERATIONS REACHED:

// The maximum number of iterations is reached without success or flat

// failure. In this case, the function sets answer to the last guess

// tried, success is set to false, and iterations is set to

// maximum_iterations.

//

// unsigned int next_term(unsigned int e) const

// POSTCONDITION: The return value is the next exponent n which is LARGER

// than e such that coefficient(n) != 0.

// If there is no such term, then the return value is zero.

//

// unsigned int previous_term(unsigned int e) const

// POSTCONDITION: The return value is the next exponent n which is SMALLER

// than e such that coefficient(n) != 0.

// If there is no such term, then the return value is UINT_MAX

// from .

//

// CONSTANT OPERATORS for the polynomial class

// double operator( ) (double x) const

// Same as the eval member function.

//

// NON-MEMBER BINARY OPERATORS for the polynomial Class

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

// POSTCONDITION: return-value is a polynomial with each coefficient

// equal to the difference of the coefficients of p1 & p2 for any given

// exponent.

//

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

// POSTCONDITION: return-value is a polynomial with each coefficient

// equal to the sum of the coefficients of p1 & p2 for any given

// exponent.

//

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

// POSTCONDITION: Each term of p1 has been multiplied by each term of p2,

// and the answer is the sum of all these term-by-term products.

// For example, if p1 is 2x^2 + 3x + 4 and p2 is 5x^2 - 1x + 7, then the

// return value is 10x^4 + 13x^3 + 31x^2 + 17x + 28.

//

// NON-MEMBER OUTPUT FUNCTION for the polynomial Class

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

// POSTCONDITION: The polynomial has been printed to ostream out, which,

// in turn, has been returned to the calling function.

// [CS 24 Note - std::endl is printed following the polynomial]

//

// DYNAMIC MEMORY

// Since this class uses dynamic memory, the copy constructor and assignment

// operator are overridden, and there is a destructor implemented. Also,

// if there is insufficient dynamic memory, the following functions throw

// a bad_alloc exception: the constructors, assignment, reserve, add_to_coef,

// assign_coef, and any function that returns a polynomial.

#ifndef POLY2_H

#define POLY2_H

#include // Provides NULL

#include // Provides ostream

namespace main_savitch_5

{

// a node class for internal use - not part of polynomial interface

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 = NULL,

polynode* init_back = NULL

)

{

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:

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;

// Set recent_ptr to the node that contains the requested exponent

// If requested exponent is 0, then set recent_ptr to head of list

// If exponent >= current degree, set recent_ptr to tail of list

// If exponent < exponent in recent node, move recent_ptr backward as far as needed

// Else move recent_ptr forward as far as needed

};

// 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 FUNCTION

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

}

#endif

Test code:

// FILE: polytest2.cxx

// An Interactive test program for the polynomial ADT

#include // Provides toupper

#include // Provides cout and cin

#include // Provides EXIT_SUCCESS

#include "poly2.h" // Provides the polynomial class

using namespace std;

using namespace main_savitch_5;

const unsigned int MANY = 3; // Number of polynomials allowed in this test program.

// PROTOTYPES for functions used by this test program:

void print_menu();

// Postcondition: The menu has been written to cout.

size_t set_current( );

// Postcondition: Return value is index for a new current polynomial.

char get_command();

// Postcondition: The user has been prompted for a character.

// The entered charatcer will be returned, translated to upper case.

void view(const polynomial& test);

//Postcondition: The polynomial passed has been sent to cout.

void view_all(const polynomial a[]);

//Postcondition: All polynomials has been written to cout.

void test_add(polynomial& test);

// Postcondition: The user has been prompted for a coefficent and degree of

// the term added. The resulting polynomial has been written to cout.

void test_assign(polynomial& test);

// Postcondition: The user has been prompted for the degree and the coeffinient

// to be set. The resulting polynomial has been written to cout.

void test_clear(polynomial& test);

// Postcondition: test.clear( ) has been activated.

// to be set. The resulting polynomial has been written to cout.

void test_eval(const polynomial& test);

// Post conditon: The user has been prompted for the x value. The evaluation

// of the polynomial is written to cout.

void test_np(const polynomial& test);

// Post conditon: The user has been prompted for the e value. The

// value of test.next_term(e) and test.previous_term(e) are written to cout.

int main()

{

polynomial p[MANY];

size_t current_index = 0;

char command;

size_t i;

cout << "Polynomials ";

for (i = 0; i < MANY; ++i)

cout << char('A' + i) << ' ';

cout << "have all been initialized." << endl;

do

{

print_menu();

command = toupper(get_command());

switch(command)

{

case 'S': current_index = set_current( );

break;

case '1': test_assign(p[current_index]);

break;

case '2': test_add(p[current_index]);

break;

case 'C': test_clear(p[current_index]);

break;

case 'V':

cout << char(current_index + 'A') << ": ";

view(p[current_index]);

break;

case 'A': view_all(p);

break;

case 'E': test_eval(p[current_index]);

break;

case 'N': test_np(p[current_index]);

break;

case 'D':

cout << char(current_index + 'A') << ".derivative: ";

view(p[current_index].derivative( ));

break;

case '+':

cout << "A + B: ";

view(p[0] + p[1]);

break;

case '-':

cout << "A - B: ";

view(p[0] - p[1]);

break;

case '*':

cout << "A * B: ";

view(p[0] * p[1]);

break;

case 'Q': // Do nothing..

break;

default: cout << "Invalid command." << endl;

break;

}

}

while(command != 'Q');

return (EXIT_SUCCESS);

}

void print_menu()

{

cout << "----------------- The Commands -----------------" << endl;

cout << "S - set the current Polynomial to work on" << endl;

cout << " - - - - - - - - - - - -" << endl;

cout << "1 - use the assign_coef function" << endl;

cout << "2 - use the add_to_coef function" << endl;

cout << "C - use the clear function" << endl;

cout << "V - view the current polynomial by using <<" << endl;

cout << "A - view all polynomials by using <<" << endl;

cout << "E - evaluate current polynomial by using () op" << endl;

cout << "N - use the next_term and previous_term functions" << endl;

// cout << "G - use the gif function" << endl;

cout << "D - view derivative of current polynomial" << endl;

cout << "+ - view A + B" << endl;

cout << "- - view A - B" << endl;

cout << "* - view A * B" << endl;

cout << " - - - - - - - - - - - -" << endl;

cout << "Q - quit this interactive test program" << endl;

cout << "-------------------------------------------------" << endl;

}

char get_command()

{

char command;

cout << ">";

cin >> command;

return(toupper(command));

}

void view(const polynomial& test)

{

cout << test

<< " (degree is " << test.degree( ) << ")" << endl;

}

size_t set_current( )

{

size_t i;

char command;

do

{

cout << "Polynomials ";

for (i = 0; i < MANY; ++i)

cout << char('A' + i) << ' ';

cout << "." << endl;

cout << "Enter the polynomial you want to work on: ";

command = toupper(get_command());

}

while ((command < 'A') || (command >= char('A' + MANY)));

return command - 'A';

}

void test_add(polynomial& test)

{

double coefficient;

unsigned int exponent;

cout << "Enter exponent: ";

cin >> exponent;

cout << "Enter coefficient: ";

cin >> coefficient;

test.add_to_coef(coefficient, exponent);

cout << "After adding: ";

view(test);

}

void test_assign(polynomial& test)

{

double coefficient;

unsigned int exponent;

cout << "Enter exponent: ";

cin >> exponent;

cout << "Enter coefficient: ";

cin >> coefficient;

test.assign_coef(coefficient, exponent);

cout << "After assigning: ";

view(test);

}

void test_eval(const polynomial& test)

{

double x_value;

cout << "Enter the x value: ";

cin >> x_value;

cout << "For the poly: ";

view(test);

cout << "The evaluation returned is " << test(x_value) << endl;

}

void view_all(const polynomial p[])

{

size_t i;

cout << endl;

for (i = 0; i < MANY; ++i)

{

cout << char(i + 'A') << ": ";

view(p[i]);

}

}

void test_clear(polynomial& test)

{

test.clear( );

cout << "After clearing: ";

view(test);

}

void test_np(const polynomial& test)

{

unsigned int exponent;

cout << "Enter exponent: ";

cin >> exponent;

cout << "For polynomial: ";

view(test);

cout << "next_term(" << exponent << ") = "

<< test.next_term(exponent) << endl;

cout << "previous_term(" << exponent << ") = "

<< test.previous_term(exponent) << endl;

}