Thread: Algebra project

Note that the expression =(x+1)(x+2)(x+3) has three polynomial operands and is shorthand for the expression (x + 1) * (x + 2) * (x + 3). There may be a standard polynomial class for you to use to evaluate this, though I'm not sure about that. If not, my first crack at defining a polynomial class would be something like this:

(NOTE: I have not compiled or tested the code appearing below. It may, and probably does, have numerous bugs in it. It is intended as a presentation of a concept, not as a working example):

Define a polynomial as a container of terms and a term as a aggregate type of coefficient and base with base as an aggregate type of variable and exponent. Then multiplication of polynomials can be accomplished by taking each term in one polynomial times each term in the other polynomial. Multiplication of terms involves multiplication of coefficients and addition of exponents of bases of the same type.

Code:

class Term(
{
   int coeff;
   char var;
   int exp;
   friend Term & operator*(Term &, Term &);
   friend ostream & operator<<(ostream &, Term &);
};
 
Term & operator *(Term & lhs, Term & rhs)
{
   Term result;
   result.coeff = lhs.coeff * rhs.coeff;
   result.var = lhs.var;
   result.exp = lhs.exp + rhs.exp;
   return result;
}
 
ostream & operator<<(ostream & os, Term & t)
{
   os << t.coeff << t.var << '^' << t.exp;
   return os;
}
 
class Polynomial
{
   vector<Term> terms;
   friend Polynomial & operator*(Polynomial &, Polynomial &);
   friend ostream & operator<<<<(ostream &, Polynomial &);
};

Polynomial & operator*(Polynomial & lhs, Polynomial & lhs)
{
  int i, j, k = 0;
  Polynomial result
  for(i = 0; i < lhs.terms.size(); ++i)
  {
	 for(j = 0; j < rhs.terms.size(); ++j)
	 {
		result[k++] = lhs[i] * rhs[j];
	 }
  }
 
  //collect like terms here;
 
  return result;
}
 
ostream & operator<<(ostream & os, Polynomial & p)
{
   int i;
   for(i = 0; i < p.terms.size() - 1; ++i)
   {
	  os << p[i] << " + ";
	  os << p.[i];
   }
   return os;
}

This is similar to the approach I've been using to evaluate first order polynomial equations for a single unknown with nested parenthesis. The trick has been to be able to tokenize the original string input such that individual terms/polynomials/operands can be identified with more complex expressions than the type described above.

The attached file is my initial attempt at developing a program to solve first order polynomials with a single unknown. It doesn't use binary trees or iterators. It's overly commented as is my want. It doesn't validate input and could be spruced up a fair amount, but it served my purpose. The code is not rigorously tested, yet it seems to handle equations that don't have nested parenthesis or variable denominators. It's serving as the basis for my current project to handle those examples. Feel free to ask questions, provide constructive criticism, etc.