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.