C++: Polynomial Class) Develop class Polynomial. The internal representation of

ID: 3822085 • Letter: C

Question

C++: Polynomial Class) Develop class Polynomial. The internal representation of a Polynomial
is an array of terms. Each term contains a coefficient and an exponent, e.g., the term
2x^4 has the coefficient 2 and the exponent 4. Develop a complete class containing proper constructor
and destructor functions as well as set and get functions. The class should also provide the following
overloaded operator capabilities:
a) Overload the addition operator (+) to add two Polynomials.
b) Overload the subtraction operator (-) to subtract two Polynomials.
c) Overload the assignment operator to assign one Polynomial to another.
d) Overload the multiplication operator (*) to multiply two Polynomials.
e) Overload the addition assignment operator (+=), subtraction assignment operator (-=),
and multiplication assignment operator (*=).

Need 5 files: main.cpp, Term.hpp, Term.cpp, Polynomial.hpp, Polynomial.hpp

Here is the current code thus far, need help with the Polynomial.hpp, Polynomial.cpp, and main.cpp. The term.hpp and term.cpp should be good.

//Term.hpp

#pragma once
#include <iostream>

using namespace std;

class Term {
   friend ostream &operator<<(ostream &, const Term &);
   friend istream &operator >> (istream &, Term &);
public:
   Term();
   Term(int c, int e);
   ~Term();
   void setCoefficient();
   void setExponent();
   void getCoefficient();
   void getExponent();
private:
   int coefficient;
   int exponent;
};

//Term.cpp

#include <iostream>
#include "polynomial.hpp"
#include "term.hpp"

using namespace std;
using std::setw;

Term::Term(int c, int e) //constructor
{
setCoefficient(1);
setExponent(2);
}

Term::~Term() //destructor
{

}

void Term::setCoefficient(int c)
{
coefficient = c;
}

void Term::setExponent(int e)
{
exponent = e;
}

void Term::getCoefficient()
{
return coefficient;
}

void Term::getExponent()
{
return exponent;
}

ostream &operator<<(ostream &output, const Term &term)
{
output << "C:" << term.coefficient << " E:" << term.exponent;
return output;
}

istream &operator >> (istream &input, Term &term)
{
   input.ignore();
   input >> term.coefficient;
   input.ignore(3) //skips the C: and the space
   input >> term.exponent;
   return input;
}

//polynomial.hpp

#pragma once
#include <iostream>
#include <vector>
#include "term.hpp"

using namespace std;

class Polynomial{
friend ostream &operator<<(ostream &, const Polynomial &);
friend istream &operator >> (istream &, Polynomial &);

public:
   Polynomial();
   ~Polynomial();
   Polynomial &operator+(const Polynomial&);
   Polynomial &operator-(const Polynomial&);
   Polynomial &operator=(const Polynomial&);
   Polynomial &operator+=(const Polynomial&);
   Polynomial &operator-=(const Polynomial&);
   void setCoefficient(int);
   void setExponent(int);
   int getCoefficient(int);
   int getExponent(int);

private:
   Term c[20];
   Term e[20];
   int index;

};

//polynomial.cpp

#include <iostream>
#include <vector>
#include <cstdlib>
#include <ctime>
#include "polynomial.hpp"
#include "term.hpp"

using namespace std;

Polynomial::Polynomial()
{
srand(time(NULL));

   for (int i = 0; i < 20; i++)
   {
       c[i].setCoefficient(rand()%5);
       c[i].setExponent(rand()%5);
   }
}

Polynomial::~Polynomial()
{

}

int Polynomial :: getExponent(int index)
{
//return e[index];
}

int Polynomial :: getCoefficient(int index)
{
//return c[index];
}

Polynomial &Polynomial :: operator+(const Polynomial &plus)
{
}

Polynomial &Polynomial :: operator-(const Polynomial &subt)
{
}

Polynomial &Polynomial :: operator=(const Polynomial &equal)
{
}

Polynomial &Polynomial :: operator+=(const Polynomial &equal)
{
}

Polynomial &Polynomial :: operator-=(const Polynomial &equal)
{
}

//main.cpp

#include <iostream>
#include <cmath>
#include <cstdlib>
#include "polynomial.hpp"

using namespace std;

int main()
{
   Term t1;
   Term t2;
   Term t3;
   Polynomial p1;
   Polynomial p2;
   Polynomial p3;

return 0;
}

Explanation / Answer

Term.hpp

#ifndef TERM_H
#define TERM_H

#include <iostream>

using namespace std;
class Term {
void operator=(const Term &term);
friend ostream &operator<<(ostream &, const Term &);
friend istream &operator>>(istream &, Term &);
public:
Term();
Term(int c, int e);
~Term();
void setCoefficient(int c);
void setExponent(int e);
int getCoefficient();
int getExponent();
private:
int coefficient;
int exponent;
};

Term.cpp

#include <iostream>
#include "term.hpp"

using namespace std;
//using std::setw;

Term::Term(int c, int e) //constructor
{
setCoefficient(c);
setExponent(e);
}

Term::~Term() //destructor
{
}

void Term::setCoefficient(int c)
{
coefficient = c;
}
void Term::setExponent(int e)
{
exponent = e;
}
int Term::getCoefficient()
{
return coefficient;
}
int Term::getExponent()
{
return exponent;
}
void Term::operator=(const Term &term)
{
coefficient=term.coefficient;
exponent=term.exponent;
}
ostream &operator<<(ostream &output, const Term &term)
{
output << "Coefficient: " << term.coefficient << " Exponent: " << term.exponent;
return output;
}
istream &operator >> (istream &input, Term &term)
{
input.ignore();
input >> term.coefficient;
//input.ignore(3) //skips the C: and the space
input >> term.exponent;
return input;
}

Polynomial.hpp

#ifndef POLYNOMIAL_H
#define POLYNOMIAL_H

#include <iostream>
#include <vector>
#include "term.hpp"
using namespace std;
class Polynomial{
friend ostream &operator<<(ostream &, const Polynomial &);
friend istream &operator >> (istream &, Polynomial &);
public:
Polynomial();
~Polynomial();
int getSize();
void getTerm(int index);
bool addTerm(int c,int e);
bool deleteTerm(int c);
Polynomial &operator+(const Polynomial&);
Polynomial &operator-(const Polynomial&);
Polynomial &operator=(const Polynomial&);
Polynomial &operator+=(const Polynomial&);
Polynomial &operator-=(const Polynomial&);
Polynomial &operator*(const Polynomial&);
Polynomial &operator*=(const Polynomial&);
Term terms[20];
//Term c[20]; You do not have to make two arrays as the term already consists of coefficients and exponents
//Term e[20]; The polynomial would be the array of terms
int size; // size of the polynomial
};

Polynomial.cpp

#include <iostream>
#include <vector>
#include <cstdlib>
#include <ctime>
#include "polynomial.hpp"
#include "term.hpp"
using namespace std;

Polynomial::Polynomial()
{
size=0;
/*srand(time(NULL));
for (int i = 0; i < 20; i++)
{
terms[i].setCoefficient(rand()%5);
terms[i].setExponent(rand()%5);
}*/
}

Polynomial::~Polynomial()
{
delete []terms;
}

Term Polynomial :: getTerm(int index)
{
return terms[index];
}

bool Polynomial::addTerm(int c,int e)   //return true if term is added, else return false
{
   if(c==0)   // Term with exponent 0 would make the whole term 0 , 0*x^2=0
       return false;

   else
   {
       Term newTerm(c,e);
       if(size==0)
       {
           terms[0]=newTerm;
       }
       else if(newTerm.getExponent()>terms[0].getExponent())
       {
           for(int i=size-1;i>=0;i--)
           {
               terms[i+1]=terms[i];
           }
           terms[0]=newTerm;
       }
       else if(newTerm.getExponent()<terms[size].getExponent())
       {
           terms[size+1]=newTerm;
       }
       else
       {
           for(i=0;i<size;i++)
           {
               if(terms[i].getExponent()==e) // 2*x^3+4*x^3
               {
                   int sum=terms[i].getCoefficient()+c;
                   if(sum)
                       terms[i].setCoefficient(sum);   // 2*x^3+4*x^3 = 6*x^3
                   else
                       deleteTerm(e);       // 2*x^3 + -2*x^3 = 0
               }
               return true;
           }
           for(int i=0;i<size;i++)
           {
               if(terms[i].getExponent()<e)
               {
                   for(int j=size-1;j>i;j--)
                   {
                       terms[j+1]=terms[j];
                   }
                   terms[i]=newTerm;
                   break;
               }
           }
       }
       size++;
       return true;
   }
}

bool Polynomial::deleteTerm(int e)   // return true if terms is found and deleted, else return false
{
   if(size==0)
       return false;
   for(int i=0;i<size;i++)
   {
       if(terms[i].getExponent()==e)
       {
           for(int j=i;j<size;j++)
               terms[j]=terms[j+1];
           size--;
           return true;
       }
   }
   return false;
}

int Polynomial::getSize()
{
   return size;
}
Polynomial &Polynomial :: operator+(const Polynomial &plus)
{
   Polynomial p;
   for(int i=0;i<size;i++)
       p.addTerm(terms[i].getCoefficient(), terms[i].getExponent());
   for(int i=0;i<plus.getSize();i++)
       p.addTerm(plus.getTerm[i].getCoefficient(),plus.getTerm[i].getExponent());
   return p;
}
Polynomial &Polynomial :: operator-(const Polynomial &subt)
{
   Polynomial p;
   for(int i=0;i<size;i++)
       p.addTerm(terms[i].getCoefficient(), terms[i].getExponent());
   for(int i=0;i<subt.getSize();i++)
       p.addTerm(subt.getTerm[i].getCoefficient(),subt.getTerm[i].getExponent());
   return p;
}
Polynomial &Polynomial :: operator=(const Polynomial &equal)
{
   size=equal.getSize();
   for(int i=0;i<size;i++)
       addTerm(equal.getTerm[i].getCoefficient(),equal.getTerm[i].getExponent())
   return this;
}
Polynomial &Polynomial :: operator+=(const Polynomial &equal)
{
   for(int i=0;i<equal.getSize();i++)
       addTerm(equal.getTerm[i].getCoefficient(),equal.getTerm[i].getExponent());
   return this;
}
Polynomial &Polynomial :: operator-=(const Polynomial &equal)
{
   for(int i=0;i<equal.getSize();i++)
       addTerm(equal.getTerm[i].getCoefficient(),equal.getTerm[i].getExponent());
   return this;
}

Polynomial &Polynomial::operator*(const Polynomial &mul)
{
   Polynomial p;
   int c,e;
   int i,j;
   for(i=0;i<size;i++)
   {
       for(j=0;j<mul.getSize();j++)
       {
           c = terms[i].getCoefficient()*mul.terms[j].getCoefficient();
           e = terms[i].getExponent()+mul.terms[j].getExponent();
           p.addTerm(c,e);
       }
   }
   return p;
}

Polynomial &Polynomial::operator*=(const Polynomial &mul)
{
   int c,e;
   int i,j;
   for(i=0;i<size;i++)
   {
       for(j=0;j<mul.getSize();j++)
       {
           c = terms[i].getCoefficient()*mul.terms[j].getCoefficient();
           e = terms[i].getExponent()+mul.terms[j].getExponent();
           addTerm(c,e);
       }
   }
   return this;
}

Sorry but I could not make main file due to shortage of time. You can also try making polynomial using linked list, that would be more efficient.

Navigate

C++: Please write code for following problem: A file filter reads an input file,

C++: Programming Example: Pig Latin Strings converts a string into the pig Latin

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

C++: Polynomial Class) Develop class Polynomial. The internal representation of

Question

Explanation / Answer

Related Questions

Navigate