Implement Class "polynomial" with a Linked List

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; }