Polynomial Class with rational coefficients - Programmers Heaven

#### Howdy, Stranger!

It looks like you're new here. If you want to get involved, click one of these buttons!

# Polynomial Class with rational coefficients

Posts: 2Member
Good evening!

I am currently working with a program that does basic arithmetic with polynomials that can have rational coefficients. I was able to come up with seperate classes and implementation files for my two classes, Polynomial.h and Rational.h. I can run two different programs, one for each class, fine. I am trying to figure out how to use both classes in order to handle the rational coefficients.

The related files:

[code]

// Polynomial.h
//#include "Rational.h"
class Polynomial
{
public:
static const int maxTerms = 10; // maximum number of terms
Polynomial(); // constructor
Polynomial operator+(const Polynomial &) const; // addition
Polynomial operator-(const Polynomial &) const; // subtraction
Polynomial operator*(const Polynomial &) const; // multiplication
Polynomial &operator=(const Polynomial &); // assignment
Polynomial &operator+=(const Polynomial &);
Polynomial &operator-=(const Polynomial &);
Polynomial &operator*=(const Polynomial &);
void enterTerms();
void printPolynomial() const;
int getNumTerms() const;
int getTermExp(int) const;
int getTermCoeff(int) const;
void setCoeff(int, int);
~Polynomial(); // destructor

private:
int numTerms;
int exp[maxTerms]; // exponent array
int coeff[maxTerms]; // coefficients array
static void polyCombine(Polynomial &); // combine commn terms
}; // end class Polynomial

//=====================================================================

// Polynomial.cpp
#include
#include
#include "Polynomial.h"
//#include "Rational.h"
using namespace std;

Polynomial::Polynomial()
{
for(int t = 0; t < maxTerms; t++)
{
coeff[t] = 0;
exp[t] = 0;
} // end for
numTerms = 0;
} // end Polynomial constructor

Polynomial Polynomial::operator+(const Polynomial &r) const // addition
{
Polynomial temp;
bool expExists;
int s;

// process element with a zero exponent
temp.coeff[0] = coeff[0] + r.coeff[0];

// copy right arrays into temp object; s will be used to keep
// track of first open coefficient element
for(s = 1; (s < maxTerms) && (r.exp[s] != 0); s++)
{
temp.coeff[s] = r.coeff[s];
temp.exp[s] = r.exp[s];
} // end for
for(int x = 1; x < maxTerms; x++)
{
expExists = false; // assume exponent will not be found

for(int t = 1; (t < maxTerms) && (!expExists); t++)
if(exp[x] == temp.exp[t])
{
temp.coeff[t] += coeff[x];
expExists = true; // exponent found
} // end if
// exponent was found, insert into temp
if(!expExists)
{
temp.exp[s] = exp[x];
temp.coeff[s] += coeff[x];
s++;
} // end if
} // endfor
return temp;
} // end operator+

Polynomial Polynomial::operator-(const Polynomial &r) const // subtraction
{
Polynomial temp;
bool expExists;
int s;

// process element with zero exponent
temp.coeff[0] = coeff[0] - r.coeff[0];

// copy left arrays into temp object; s will be used to keep
// track of first open coefficient element
for(s = 1; (s < maxTerms) && (exp[s] != 0); s++)
{
temp.coeff[s] = coeff[s];
temp.exp[s] = exp[s];
} // end for
for (int x = 1; x < maxTerms; x++)
{
expExists = false;

for(int t = 1; (t < maxTerms) && (!expExists); t++)

if(r.exp[x] == temp.exp[t])
{
temp.coeff[t] -= r.coeff[x];
expExists = true;
}
if(!expExists)
{
temp.exp[s] = r.exp[x];
temp.coeff[s] -= r.coeff[x];
s++;
} // end if
} // end for
} // end operator- function

Polynomial Polynomial::operator*(const Polynomial &r) const // multiplication
{
Polynomial temp;
int s = 1;

for(int x = 0; (x < maxTerms) && (x == 0 || coeff[x] != 0); x++)

for(int y = 0; (y < maxTerms) && (y == 0 || r.coeff[y] != 0); y ++)

if(coeff[x] * r.coeff[y])

if((exp[x] == 0) && (r.exp[y] == 0))
temp.coeff[0] += coeff[x] * r.coeff[y];
else
{
temp.coeff[s] = coeff[x] * r.coeff[y];
temp.exp[s] = exp[x] + r.exp[y];
s++;
} // end else
polyCombine(temp); // combine common terms
return temp;
} // end operator* function

Polynomial &Polynomial::operator=(const Polynomial &r) // assignment
{
exp[0] = r.exp[0];
coeff[0] = r.coeff[0];

for(int s = 1; s < maxTerms; s++)
{
if(r.exp[s] != 0)
{
exp[s] = r.exp[s];
coeff[s] = r.coeff[s];
}
else
{
if(exp[s] == 0)
break;

exp[s] = 0;
coeff[s] = 0;
} // end else
} // end for
return *this;
} // end operator= function

Polynomial &Polynomial::operator+=(const Polynomial &r)
{
*this = *this + r;
return *this;
} // end operator+= function

Polynomial &Polynomial::operator-=(const Polynomial &r)
{
*this = *this -r;
return *this;
} // end operator-= function

Polynomial &Polynomial::operator*=(const Polynomial &r)
{
*this = *this * r;
return *this;
}// end operator*= function

void Polynomial::enterTerms()
{
bool found = false;
int c, e, term;

cout << endl << "Enter number of polynomial terms: ";
cin >> numTerms;

for(int n = 0; n < maxTerms && n < numTerms; n++)
{
cout << endl << "Enter coefficient: ";
cin >> c;
cout << "Enter exponent: ";
cin >> e;

if(c != 0)
{
// exponent of zero are forced into first element
if(e == 0)
{
coeff[0] += c;
continue;
} // end if
for(term = 1; (term < maxTerms) && (coeff[term] !=0); term++)

if(e == exp[term])
{
coeff[term] += c;
exp[term] = e;
found = true; // existing exponent updated
} // end if
{
coeff[term] += c;
exp[term] = e;
} // end if
} // end outer if
} // end outer for
} // end enterTerms function

void Polynomial::printPolynomial() const
{
int start;
bool zero = false;

if(coeff[0]) // output constraints
{
cout << coeff[0];
start = 1;
zero = true; // at least one term exists
}
else
{
if(coeff[1])
{
cout << coeff[1] << 'x';
if((exp[1] != 0) && (exp[1] != 1))
cout << '^' << exp[1];
zero = true; // at least one term exists
} // end if
start = 2;
} // end else

// output remaining polynomial terms
for(int x = start; x < maxTerms; x++)
{
if(coeff[x] != 0)
{
cout << showpos << coeff[x] << noshowpos << 'x';

if((exp[x] != 0) && (exp[x] != 1))
cout << '^' << exp[x];

zero = true; // at least one term exists
} // end if
} // end for
if(!zero) // no terms exist in the polynomial
cout << '0';
cout << endl;
} // end printPolynomial function

int Polynomial::getNumTerms() const
{
return numTerms;
} // end getTerms function

int Polynomial::getTermExp(int term) const
{
return exp[term];
} // end getTermExp function

int Polynomial::getTermCoeff(int term) const
{
return coeff[term];
} // end getTermCoeff function

void Polynomial::setCoeff(int term, int coeffs)
{
if(coeff[term] == 0) // no term at this location
cout << "No term at this location, cannot see term." << endl;
else // otherwise set term
coeff[term] = coeffs;
} // end setCoeff function

void Polynomial::polyCombine(Polynomial &w)
{
Polynomial temp = w;

// zero out elements of w
for(int x = 0; x < maxTerms; x++)
{
w.coeff[x] = 0;
w.exp[x] = 0;
}
for(int x = 1; x < maxTerms; x++)
{
for(int y = x + 1; y < maxTerms; y++)
if(temp.exp[x] == temp.exp[y])
{
temp.coeff[x] += temp.coeff[y];
temp.exp[y] = 0;
temp.coeff[y] = 0;
}
}
w = temp;
} // end polyCombine function

Polynomial::~Polynomial() // destructor
{
// empty
}

[/code]

[code]

// Rational.h
#include <iostream>
using namespace std;
class Rational
{
private:
int num;
int denom;

public:
void setNum(int);
void setDenom(int);
int getNum();
int getDenom();

int gcd();
void simplify();

Rational operator+(Rational);
Rational operator-(Rational);
Rational operator*(Rational);
Rational operator/(Rational);
bool operator==(Rational);
bool operator!=(Rational);
bool operator>(Rational);
bool operator<(Rational);
bool operator>=(Rational);
bool operator<=(Rational);
};

//=====================================================================

// Rational.cpp
#include <iostream>
#include "Rational.h"
using namespace std;

void Rational::setNum(int n)
{
num = n;
}

void Rational::setDenom(int n)
{
denom = n;
}

int Rational::getNum()
{
return num;
}
int Rational::getDenom()
{
return denom;
}

int Rational::gcd()
{
int x = num;
int y = denom;
int temp;

while (y)
{
temp = y;
y = x % y;
x = temp;
}
return x;
}

void Rational::simplify()
{
int gcdNum = gcd();

if(gcdNum != 0)
{
num = num / gcdNum;
denom = denom / gcdNum;
}
}

Rational Rational::operator+(Rational passed)
{
Rational Result;

Result.num = num * passed.denom + denom * passed.num;
Result.denom = denom * passed.denom;

return Result;
}

Rational Rational::operator-(Rational passed)
{
Rational Result;

Result.num = num * passed.denom - denom * passed.num;
Result.denom = denom * passed.denom;

return Result;
}

Rational Rational::operator*(Rational passed)
{
Rational Result;

Result.num = num * passed.num;
Result.denom = denom * passed.denom;

return Result;
}

Rational Rational::operator/(Rational passed)
{
Rational Result;
Result.num = num * passed.denom;
Result.denom = denom * passed.num;

return Result;
}

bool Rational::operator==(Rational passed)
{
simplify();
passed.simplify();

return (passed.num == num) && (passed.denom == denom);
}

bool Rational::operator!=(Rational passed)
{
simplify();
passed.simplify();

return (passed.num != num) && (passed.denom != denom);
}

bool Rational::operator>(Rational passed)
{

simplify();
passed.simplify();

return (num * passed.denom) > (passed.num * denom);
}

bool Rational::operator<(Rational passed)
{
simplify();
passed.simplify();

return (num * passed.denom) < (passed.num * denom);
}

bool Rational::operator>=(Rational passed)
{

simplify();
passed.simplify();

return (num * passed.denom) >= (passed.num * denom);
}

bool Rational::operator<=(Rational passed)
{
simplify();
passed.simplify();

return (num * passed.denom) <= (passed.num * denom);
}

//=====================================================================

[/code]

Suggestions?

Thanks!