Attached please find the polynomial header. It describes the spec for our Polyno

Question

Attached please find the polynomial header. It describes the spec for our Polynomial_T class, and will give us the baseline and set expectations for this exercise. Some of the methods are marked optional. Please take time and read that file, it will help you a lot, provide a guidline of how to approach the elephant.

In the 'private members' section please make a choice of the data structure you'd like to use (dynamic array, vector or linked list), and then take out what becomes not relevant. This choice should not affect the signatures of any methods - they stay the same, it is the contract. But it will certainly affect the implementation (your polynomial.cpp file)

If you decide on the linked list, make use of the Node class (D2L Content folder), tweak it as needed, store the value pair (exponent and coefficient) , rename the class to Term_T (to be intuitive), rename the header file (term.h). Then include term.h in polynomial.h.

--------

// FILE polynomial.h
// CLASS: Polynomial_T (in the namespace csc161)
//
// Definition:
// 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:
// 1. This version works by storing the coefficients in
// a dynamic array. The coefficient for the x^k term is stored
// in location [k] of the dynamic array. When a new term is
// added beyond the current size of the array, then the
// dynamic array is replaced by a new, larger array.
// 2. Note that two functions have been implemented as inline functions
// in this file (the degree and operator() functions).
//   
//
// MEMBER CONSTANTS:
// const static size_t MAX_DEGREE
// The size of the initial array to store the coefficients.
//
// CONSTRUCTOR:
// POSTCONDITION: Creates a polynomial shell with all zero
// coefficients.
//
// MODIFICATION MEMBER FUNCTIONS:
//   
// void assign_coef(double p_coefficient, unsigned int p_exponent)
// POSTCONDITION: Sets the coefficient for the specified exponent.
//
// void clear( )
// POSTCONDITION: All coefficients of this polynomial are set to zero.
//
// void reserve(unsigned int p_additionalTerms)
// POSTCONDITION: Allocates additional memory to store additional terms.
// This guarantees that member functions will not need to worry about it.
//
// CONSTANT MEMBER FUNCTIONS:
// double getCoefficient(unsigned int p_exponent) const
// POSTCONDITION: Returns coefficient at specified exponent of this
// polynomial.
//
// unsigned int getDegree( ) 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_T derivative( ) const
// POSTCONDITION: The return value is the first derivative of this
// polynomial.
//
// double eval(double p_x) const
// POSTCONDITION: The return value is the value of this polynomial with the
// given value for the variable x.
//
// unsigned int nextTerm(unsigned int p_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 previousTerm(unsigned int p_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 <climits>.
//
// CONSTANT OPERATORS:
// double operator( ) (double p_x) const
// Same as the eval member function.
//
// NON-MEMBER BINARY OPERATORS for the polynomial Class
// Polynomial_T operator -(const Polynomial_T& p1, const Polynomial_T& 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_T operator +(const Polynomial_T& p1, const Polynomial_T& 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_T operator *(const Polynomial_T& p1, const Polynomial_T& 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 FUNCTIONS for the polynomial Class
// ostream& operator << (ostream& out, const Polynomial_T& p)
// POSTCONDITION: The polynomial has been printed to ostream out, which,
// in turn, has been returned to the calling function.
//
//
// 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 POLY_H
#define POLY_H
#include <iostream> // Provides ostream
#include <vector> // If you decide on Vector

namespace csc161
{
  
class Polynomial_T
{
public:
   // CONSTANTS
   static const unsigned int MAX_DEGREE = 30;
  
// CONSTRUCTORS and DESTRUCTOR
   Polynomial_T();
   Polynomial_T(const Polynomial_T& source); // Copy constructor
   ~Polynomial_T( );

   // MODIFICATION MEMBER FUNCTIONS
   void operator =(const Polynomial_T& source);
   void assign_coef(double p_coefficient, unsigned int p_exponent);
   void clear( );
void reserve(unsigned int p_additionalTerms);
  
   // CONSTANT MEMBER FUNCTIONS
   double getCoefficient(unsigned int p_exponent) const;
   unsigned int getDegree( ) const { return current_degree; }
   Polynomial_T derivative( ) const;
   double eval(double p_x) const;
   unsigned int nextTerm(unsigned int p_e) const; // Helpers, might not be needed, if trivial
   unsigned int previousTerm(unsigned int p_e) const; // Helper, might not be needed, if trivial
  
   // CONSTANT OPERATORS - optional, we will cover this next time
   double operator( ) (double x) const { return eval(x); }
  
   // PRIVATE MEMBERS
private:

   // Make a choice of data structure, leave only applies
   double *coef; // Pointer to the dynamic array that stores coefs (if you decide on array)

   vector<double> coef_v; // Vector to store coefs (if you decide on vector)

   Term_T *coef; // Head of linked list (if you decide to on linked list).
   // Rename Node class to Term_T, change to store exponent and coef; include
   // term.h etc
   ///// Choice made. Please note that this might affect how data must be entered, if zeros are explicit etc.

   unsigned int size; // Current size of the coef data container (array, vector)
   unsigned int current_degree; // Current degree of the polynomial

};
  
// NON-MEMBER BINARY OPERATORS
Polynomial_T operator +(const Polynomial_T& p1, const Polynomial_T& p2);
Polynomial_T operator -(const Polynomial_T& p1, const Polynomial_T& p2); // Optional
Polynomial_T operator *(const Polynomial_T& p1, const Polynomial_T& p2); // Optional
  
// NON-MEMBER OUTPUT FUNCTIONS
std::ostream& operator << (std::ostream& out, const Polynomial_T& p);
  
}
#endif

Explanation / Answer

Polynomial.cpp

Polynomial.h

Term.cpp

Term.h

main.cpp

Related Questions

Navigate

• Browse (All)
• Browse A
• Subjects

Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.