Implement Class \"polynomial\" with a Linked List // FILE: poly2.h // CLASS PROV
ID: 3838691 • Letter: I
Question
Implement Class "polynomial" with a Linked List
// FILE: poly2.h
// CLASS PROVIDED:
// class polynomial (in the namespace main_savitch_3)
// 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 TO STUDENT:
// 1. This version works by storing the coefficients in
// a doubly-linked list with each node holding the coefficient and
// exponent for one term. The terms are kept in order from smallest
// to largest exponent. Each polynomial also maintains a pointer to the
// most recently accessed node.
// 2. Note that two functions have been implemented as inline functions
// in this file (the degree and operator() functions).
//
// CONSTRUCTOR for the polynomial class
// POSTCONDITION: This polynomial has been created with all zero
// coefficients, except for coefficient c for the specified exponent.
// When used as a default constructor (using default values for
// both arguments), the result is a polynomial with all zero
// coefficients.
//
// MODIFICATION MEMBER FUNCTIONS for the polynomial class
// void add_to_coef(double amount, unsigned int exponent)
// POSTCONDITION: Adds the given amount to the coefficient of the
// specified exponent.
//
// void assign_coef(double coefficient, unsigned int exponent)
// POSTCONDITION: Sets the coefficient for the specified exponent.
//
// void clear( )
// POSTCONDITION: All coefficients of this polynomial are set to zero.
//
// CONSTANT MEMBER FUNCTIONS for the polynomial class
// double coefficient(unsigned int exponent) const
// POSTCONDITION: Returns coefficient at specified exponent of this
// polynomial.
//
// unsigned int degree( ) 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 derivative( ) const
// POSTCONDITION: The return value is the first derivative of this
// polynomial.
//
// double eval(double x) const
// POSTCONDITION: The return value is the value of this polynomial with the
// given value for the variable x.
//
// void find_root(
// double& answer,
// bool& success,
// unsigned int& iterations,
// double starting_guess = 0,
// unsigned int maximum_iterations = 100,
// double epsilon = 1e-8
// )
// const
// PRECONDITION: epsilon > 0.
// POSTCONDITION: This function uses Newton's method to search for a root
// of the polynomial (i.e., a value of x for which the polynomial is zero).
// The method requires some starting guess for the value of the root. This
// guess is improved over a series of iterations (with the maximum allowed
// iterations defined by the parameter maximum_iterations). There are three
// possible outcomes:
// 1. SUCCESS:
// The method hits a near-root (a value of x for which the absolute
// value of the polynomial is no more than epsilon). In this case, the
// function sets answer to equal this near-root, success is set to true,
// and iterations is set to the number of iterations required.
// 2. FLAT FAILURE:
// Newton's method fails because the guess hits a very flat area of the
// polynomial (a point where first derivative is no more than epsilon).
// In this case, the function sets answer equal to the guess that caused
// flat failure, success is set to false, and iterations is the number
// of iterations carried out (which will be less than
// maximum_iterations).
// 3. MAXIMUM ITERATIONS REACHED:
// The maximum number of iterations is reached without success or flat
// failure. In this case, the function sets answer to the last guess
// tried, success is set to false, and iterations is set to
// maximum_iterations.
//
// unsigned int next_term(unsigned int 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 previous_term(unsigned int 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 for the polynomial class
// double operator( ) (double x) const
// Same as the eval member function.
//
// NON-MEMBER BINARY OPERATORS for the polynomial Class
// polynomial operator -(const polynomial& p1, const polynomial& 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 operator +(const polynomial& p1, const polynomial& 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 operator *(const polynomial& p1, const polynomial& 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 FUNCTION for the polynomial Class
// ostream& operator << (ostream& out, const polynomial& p)
// POSTCONDITION: The polynomial has been printed to ostream out, which,
// in turn, has been returned to the calling function.
// [CS 24 Note - std::endl is printed following the polynomial]
//
// 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 POLY2_H
#define POLY2_H
#include <cstdlib> // Provides NULL
#include <iostream> // Provides ostream
namespace main_savitch_5
{
// a node class for internal use - not part of polynomial interface
class polynode
{
public:
// CONSTRUCTOR: Creates a node containing a specified initial
// coefficient (init_coef), initial exponent (init_exponent), and
// initial links forward and backward (init_fore and init_back).
polynode(
double init_coef = 0.0,
unsigned int init_exponent = 0,
polynode* init_fore = NULL,
polynode* init_back = NULL
)
{
coef_field = init_coef;
exponent_field = init_exponent;
link_fore = init_fore;
link_back = init_back;
}
// Member functions to set the fields:
void set_coef(double new_coef)
{ coef_field = new_coef; }
void set_exponent(unsigned int new_exponent)
{ exponent_field = new_exponent; }
void set_fore(polynode* new_fore)
{ link_fore = new_fore; }
void set_back(polynode* new_back)
{ link_back = new_back; }
// Const member functions to retrieve current coefficient or exponent:
double coef( ) const { return coef_field; }
unsigned int exponent( ) const { return exponent_field; }
// Two slightly different member functions to retrieve each link:
const polynode* fore( ) const { return link_fore; }
polynode* fore( ) { return link_fore; }
const polynode* back( ) const { return link_back; }
polynode* back( ) { return link_back; }
private:
double coef_field;
unsigned int exponent_field;
polynode *link_fore;
polynode *link_back;
};
class polynomial
{
public:
// CONSTRUCTORS and DESTRUCTOR
polynomial(double c = 0.0, unsigned int exponent = 0);
polynomial(const polynomial& source);
~polynomial( );
// MODIFICATION MEMBER FUNCTIONS
polynomial& operator =(const polynomial& source);
void add_to_coef(double amount, unsigned int exponent);
void assign_coef(double coefficient, unsigned int exponent);
void clear( );
// CONSTANT MEMBER FUNCTIONS
double coefficient(unsigned int exponent) const;
unsigned int degree( ) const { return current_degree; }
polynomial derivative( ) const;
double eval(double x) const;
void find_root(
double& answer,
bool& success,
unsigned int& iterations,
double guess = 0,
unsigned int maximum_iterations = 100,
double epsilon = 1e-8
)
const;
unsigned int next_term(unsigned int e) const;
unsigned int previous_term(unsigned int e) const;
// CONSTANT OPERATORS
double operator( ) (double x) const { return eval(x); }
private:
polynode *head_ptr; // Head pointer for list of terms
polynode *tail_ptr; // Tail pointer for list of terms
mutable polynode *recent_ptr; // Most recently used term
unsigned int current_degree; // Current degree of the polynomial
// A private member function to aid the other functions:
void set_recent(unsigned int exponent) const;
// Set recent_ptr to the node that contains the requested exponent
// If requested exponent is 0, then set recent_ptr to head of list
// If exponent >= current degree, set recent_ptr to tail of list
// If exponent < exponent in recent node, move recent_ptr backward as far as needed
// Else move recent_ptr forward as far as needed
};
// NON-MEMBER BINARY OPERATORS
polynomial operator +(const polynomial& p1, const polynomial& p2);
polynomial operator -(const polynomial& p1, const polynomial& p2);
polynomial operator *(const polynomial& p1, const polynomial& p2);
// NON-MEMBER OUTPUT FUNCTION
std::ostream& operator << (std::ostream& out, const polynomial& p);
}
#endif
Test code:
// FILE: polytest2.cxx
// An Interactive test program for the polynomial ADT
// Written by: Kenneth R. Glover - gloverk@colorado.edu
#include <cctype> // Provides toupper
#include <iostream> // Provides cout and cin
#include <cstdlib> // Provides EXIT_SUCCESS
#include "poly2.h" // Provides the polynomial class
using namespace std;
using namespace main_savitch_5;
const unsigned int MANY = 3; // Number of polynomials allowed in this test program.
// PROTOTYPES for functions used by this test program:
void print_menu();
// Postcondition: The menu has been written to cout.
size_t set_current( );
// Postcondition: Return value is index for a new current polynomial.
char get_command();
// Postcondition: The user has been prompted for a character.
// The entered charatcer will be returned, translated to upper case.
void view(const polynomial& test);
//Postcondition: The polynomial passed has been sent to cout.
void view_all(const polynomial a[]);
//Postcondition: All polynomials has been written to cout.
void test_add(polynomial& test);
// Postcondition: The user has been prompted for a coefficent and degree of
// the term added. The resulting polynomial has been written to cout.
void test_assign(polynomial& test);
// Postcondition: The user has been prompted for the degree and the coeffinient
// to be set. The resulting polynomial has been written to cout.
void test_clear(polynomial& test);
// Postcondition: test.clear( ) has been activated.
// to be set. The resulting polynomial has been written to cout.
void test_eval(const polynomial& test);
// Post conditon: The user has been prompted for the x value. The evaluation
// of the polynomial is written to cout.
void test_np(const polynomial& test);
// Post conditon: The user has been prompted for the e value. The
// value of test.next_term(e) and test.previous_term(e) are written to cout.
int main()
{
polynomial p[MANY];
size_t current_index = 0;
char command;
size_t i;
cout << "Polynomials ";
for (i = 0; i < MANY; ++i)
cout << char('A' + i) << ' ';
cout << "have all been initialized." << endl;
do
{
print_menu();
command = toupper(get_command());
switch(command)
{
case 'S': current_index = set_current( );
break;
case '1': test_assign(p[current_index]);
break;
case '2': test_add(p[current_index]);
break;
case 'C': test_clear(p[current_index]);
break;
case 'V':
cout << char(current_index + 'A') << ": ";
view(p[current_index]);
break;
case 'A': view_all(p);
break;
case 'E': test_eval(p[current_index]);
break;
case 'N': test_np(p[current_index]);
break;
case 'D':
cout << char(current_index + 'A') << ".derivative: ";
view(p[current_index].derivative( ));
break;
case '+':
cout << "A + B: ";
view(p[0] + p[1]);
break;
case '-':
cout << "A - B: ";
view(p[0] - p[1]);
break;
case '*':
cout << "A * B: ";
view(p[0] * p[1]);
break;
case 'Q': // Do nothing..
break;
default: cout << "Invalid command." << endl;
break;
}
}
while(command != 'Q');
return (EXIT_SUCCESS);
}
void print_menu()
{
cout << "----------------- The Commands -----------------" << endl;
cout << "S - set the current Polynomial to work on" << endl;
cout << " - - - - - - - - - - - -" << endl;
cout << "1 - use the assign_coef function" << endl;
cout << "2 - use the add_to_coef function" << endl;
cout << "C - use the clear function" << endl;
cout << "V - view the current polynomial by using <<" << endl;
cout << "A - view all polynomials by using <<" << endl;
cout << "E - evaluate current polynomial by using () op" << endl;
cout << "N - use the next_term and previous_term functions" << endl;
// cout << "G - use the gif function" << endl;
cout << "D - view derivative of current polynomial" << endl;
cout << "+ - view A + B" << endl;
cout << "- - view A - B" << endl;
cout << "* - view A * B" << endl;
cout << " - - - - - - - - - - - -" << endl;
cout << "Q - quit this interactive test program" << endl;
cout << "-------------------------------------------------" << endl;
}
char get_command()
{
char command;
cout << ">";
cin >> command;
return(toupper(command));
}
void view(const polynomial& test)
{
cout << test
<< " (degree is " << test.degree( ) << ")" << endl;
}
size_t set_current( )
{
size_t i;
char command;
do
{
cout << "Polynomials ";
for (i = 0; i < MANY; ++i)
cout << char('A' + i) << ' ';
cout << "." << endl;
cout << "Enter the polynomial you want to work on: ";
command = toupper(get_command());
}
while ((command < 'A') || (command >= char('A' + MANY)));
return command - 'A';
}
void test_add(polynomial& test)
{
double coefficient;
unsigned int exponent;
cout << "Enter exponent: ";
cin >> exponent;
cout << "Enter coefficient: ";
cin >> coefficient;
test.add_to_coef(coefficient, exponent);
cout << "After adding: ";
view(test);
}
void test_assign(polynomial& test)
{
double coefficient;
unsigned int exponent;
cout << "Enter exponent: ";
cin >> exponent;
cout << "Enter coefficient: ";
cin >> coefficient;
test.assign_coef(coefficient, exponent);
cout << "After assigning: ";
view(test);
}
void test_eval(const polynomial& test)
{
double x_value;
cout << "Enter the x value: ";
cin >> x_value;
cout << "For the poly: ";
view(test);
cout << "The evaluation returned is " << test(x_value) << endl;
}
void view_all(const polynomial p[])
{
size_t i;
cout << endl;
for (i = 0; i < MANY; ++i)
{
cout << char(i + 'A') << ": ";
view(p[i]);
}
}
void test_clear(polynomial& test)
{
test.clear( );
cout << "After clearing: ";
view(test);
}
void test_np(const polynomial& test)
{
unsigned int exponent;
cout << "Enter exponent: ";
cin >> exponent;
cout << "For polynomial: ";
view(test);
cout << "next_term(" << exponent << ") = "
<< test.next_term(exponent) << endl;
cout << "previous_term(" << exponent << ") = "
<< test.previous_term(exponent) << endl;
}
Explanation / Answer
Understanding your problem statement I am providing you two ways to achieve it
Please find the below-working code
Solution 01:
******************
package poly;
import java.io.*;
import java.util.StringTokenizer;
/**
* This class implements a term of a polynomial.
*
*
*
*/
class Term {
/**
* Coefficient of term.
*/
public float coeff;
/**
* Degree of term.
*/
public int degree;
/**
* Initializes an instance with given coefficient and degree.
*
* @param coeff Coefficient
* @param degree Degree
*/
public Term(float coeff, int degree) {
this.coeff = coeff;
this.degree = degree;
}
/* (non-Javadoc)
* @see java.lang.Object#equals(java.lang.Object)
*/
public boolean equals(Object other) {
return other != null &&
other instanceof Term &&
coeff == ((Term)other).coeff &&
degree == ((Term)other).degree;
}
/* (non-Javadoc)
* @see java.lang.Object#toString()
*/
public String toString() {
if (degree == 0) {
return coeff + "";
} else if (degree == 1) {
return coeff + "x";
} else {
return coeff + "x^" + degree;
}
}
}
/**
* This class implements a linked list node that contains a Term instance.
*
* @author runb-cs112
*
*/
class Node {
/**
* Term instance.
*/
Term term;
/**
* Next node in linked list.
*/
Node next;
/**
* Initializes this node with a term with given coefficient and degree,
* pointing to the given next node.
*
* @param coeff Coefficient of term
* @param degree Degree of term
* @param next Next node
*/
public Node(float coeff, int degree, Node next) {
term = new Term(coeff, degree);
this.next = next;
}
}
/**
* This class implements a polynomial.
*
* @author runb-cs112
*
*/
public class Polynomial {
/**
* Pointer to the front of the linked list that stores the polynomial.
*/
Node poly;
/**
* Initializes this polynomial to empty, i.e. there are no terms.
*
*/
public Polynomial() {
poly = null;
}
/**
* Reads a polynomial from an input stream (file or keyboard). The storage format
* of the polynomial is:
* <pre>
* <coeff> <degree>
* <coeff> <degree>
* ...
* <coeff> <degree>
* </pre>
* with the guarantee that degrees will be in descending order. For example:
* <pre>
* 4 5
* -2 3
* 2 1
* 3 0
* </pre>
* which represents the polynomial:
* <pre>
* 4*x^5 - 2*x^3 + 2*x + 3
* </pre>
*
* @param br BufferedReader from which a polynomial is to be read
* @throws IOException If there is any input error in reading the polynomial
*/
public Polynomial(BufferedReader br) throws IOException {
String line;
StringTokenizer tokenizer;
float coeff;
int degree;
poly = null;
while ((line = br.readLine()) != null) {
tokenizer = new StringTokenizer(line);
coeff = Float.parseFloat(tokenizer.nextToken());
degree = Integer.parseInt(tokenizer.nextToken());
poly = new Node(coeff, degree, poly);
}
}
/**
* Returns the polynomial obtained by adding the given polynomial p
* to this polynomial - DOES NOT change this polynomial
*
* @param p Polynomial to be added
* @return A new polynomial which is the sum of this polynomial and p.
*
*/
private Node addInsert(Node ins, Node list){
Node temp = new Node(ins.term.coeff, ins.term.degree, null);
//if list is empty GOOD
if(list==null){
return temp;
}
else{
Node curr = list;
Node prev = null;
//traverses list. if greater than, move on.
//if equal, make new node with added coeffs
//if less, inserts before it (aka, prev.next)
while(curr!=null)
if(temp.term.degree>curr.term.degree){
if(curr.next==null){
curr.next=temp;
return list;
}
prev=curr;
curr=curr.next;
}
else if(temp.term.degree==curr.term.degree){
if(curr.term.coeff+temp.term.coeff==0){
if(prev==null)
return curr.next;
else{
prev.next=curr.next;
return list;}
}
if(prev==null)
list = new Node(curr.term.coeff+temp.term.coeff, curr.term.degree, curr.next);
else{
prev.next= new Node(curr.term.coeff+temp.term.coeff, curr.term.degree, curr.next);
}
return list;
}
else if(temp.term.degree<curr.term.degree){
temp.next=curr;
prev.next=temp;
return list;
}
}
return null;
}
public Polynomial add(Polynomial p) {
//possible cases - p is empty, Polynomial is empty,
Node sumaaa = null;
Node curr = this.poly;
Node currp = p.poly;
//fills sumaaa with nodes from curr
while(curr!=null){
sumaaa = addInsert(curr, sumaaa);
curr=curr.next;
}
//fills sumaaa with nodes from currp
while(currp!=null){
sumaaa = addInsert(currp,sumaaa);
currp=currp.next;
}
Polynomial sum = new Polynomial();
sum.poly=sumaaa;
return sum;
}
/**
* Returns the polynomial obtained by multiplying the given polynomial p
* with this polynomial - DOES NOT change this polynomial
*
* @param p Polynomial with which this polynomial is to be multiplied
* @return A new polynomial which is the product of this polynomial and p.
*/
public Polynomial multiply(Polynomial p){
Node fact1 = this.poly;
Node fact2 = p.poly;
Node t = null;
Node prod = null;
Polynomial product = new Polynomial();
while(fact1!=null){
while(fact2!=null){
t = new Node(fact1.term.coeff*fact2.term.coeff,
fact1.term.degree+fact2.term.degree, null);
fact2=fact2.next;
prod = addInsert(t, prod);
}
fact1=fact1.next;
fact2=p.poly;
}
product.poly=prod;
return product;
}
/**
* Evaluates this polynomial at the given value of x
*
* @param x Value at which this polynomial is to be evaluated
* @return Value of this polynomial at x
*/
public float evaluate(float x) {
float value=0;
Node curr=poly;
while (curr!=null){
value+=curr.term.coeff*((float)Math.pow(x, curr.term.degree));
curr=curr.next;
}
return value;
}
/* (non-Javadoc)
* @see java.lang.Object#toString()
*/
public String toString() {
String retval;
if (poly == null) {
return "0";
} else {
retval = poly.term.toString();
for (Node current = poly.next ;
current != null ;
current = current.next) {
retval = current.term.toString() + " + " + retval;
}
return retval;
}
}
}
********************
Solution no 02:
The below code makes the use of StringTokenizer function
*****************
package polynomial;
import java.io.*;
import java.util.StringTokenizer;
/**
* This class implements a term of a polynomial.
*
*
*
*/
class Term {
/**
* Coefficient of term.
*/
public float coeff;
/**
* Degree of term.
*/
public int degree;
/**
* Initializes an instance with given coefficient and degree.
*
* @param coeff
* Coefficient
* @param degree
* Degree
*/
public Term(float coeff, int degree) {
this.coeff = coeff;
this.degree = degree;
}
/*
* (non-Javadoc)
*
* @see java.lang.Object#equals(java.lang.Object)
*/
public boolean equals(Object other) {
return other != null && other instanceof Term
&& coeff == ((Term) other).coeff
&& degree == ((Term) other).degree;
}
/*
* (non-Javadoc)
*
* @see java.lang.Object#toString()
*/
public String toString() {
if (degree == 0) {
return coeff + "";
} else if (degree == 1) {
return coeff + "x";
} else {
return coeff + "x^" + degree;
}
}
}
/**
* This class implements a linked list node that contains a Term instance.
*
*
*
*/
class Node {
/**
* Term instance.
*/
Term term;
/**
* Next node in linked list.
*/
Node next;
/**
* Initializes this node with a term with given coefficient and degree,
* pointing to the given next node.
*
* @param coeff
* Coefficient of term
* @param degree
* Degree of term
* @param next
* Next node
*/
public Node(float coeff, int degree, Node next) {
term = new Term(coeff, degree);
this.next = next;
}
}
/**
* This class implements a polynomial.
*
*
*
*/
public class Polynomial {
/**
* Pointer to the front of the linked list that stores the polynomial.
*/
Node poly;
/**
* Initializes this polynomial to empty, i.e. there are no terms.
*
*/
public Polynomial() {
poly = null;
}
/**
* Reads a polynomial from an input stream (file or keyboard). The storage
* format of the polynomial is:
*
* <pre>
* <coeff> <degree>
* <coeff> <degree>
* ...
* <coeff> <degree>
* </pre>
*
* with the guarantee that degrees will be in descending order. For example:
*
* <pre>
* 4 5
* -2 3
* 2 1
* 3 0
* </pre>
*
* which represents the polynomial:
*
* <pre>
* 4 * x ˆ 5 - 2 * x ˆ 3 + 2 * x + 3
* </pre>
*
* @param br
* BufferedReader from which a polynomial is to be read
* @throws IOException
* If there is any input error in reading the polynomial
*/
public Polynomial(BufferedReader br) throws IOException {
String line;
StringTokenizer tokenizer;
float coeff;
int degree;
poly = null;
while ((line = br.readLine()) != null) {
tokenizer = new StringTokenizer(line);
coeff = Float.parseFloat(tokenizer.nextToken());
degree = Integer.parseInt(tokenizer.nextToken());
poly = new Node(coeff, degree, poly);
}
}
/**
* Returns the polynomial obtained by adding the given polynomial p to this
* polynomial - DOES NOT change this polynomial
*
* @param p
* Polynomial to be added
* @return A new polynomial which is the sum of this polynomial and p.
*/
public Polynomial add(Polynomial p) {
/*
* What's up.
*
* This code makes sure you didn't give me crap.
*
* GIGO, right?
*/
if (p.poly == null) {
return this;
} else if (this.poly == null) {
return p;
} else {
Polynomial retPol = new Polynomial();
retPol.poly = new Node(0, 0, null);
Node front = retPol.poly;
Node entered = p.poly; // this is the input
Node thisPol = this.poly; // this is from this structure
/*
* The code below does the actual addition
* by simultaneously looping through two
* polynomials.
*
* It's not the best way, it doesn't sort.
* But it works.
*
*/
while (entered != null || thisPol != null) {
boolean bothExist = (entered != null & thisPol != null);
boolean bothEqual = false;
if (bothExist) {
bothEqual = (entered.term.degree == thisPol.term.degree);
}
if (bothExist && bothEqual) {
retPol.poly.term = new Term(entered.term.coeff
+ thisPol.term.coeff, thisPol.term.degree);
thisPol = thisPol.next;
entered = entered.next;
} else {
if (entered != null && ((thisPol == null) || entered.term.degree < thisPol.term.degree)) {
retPol.poly.term = entered.term;
entered = entered.next;
} else {
retPol.poly.term = thisPol.term;
thisPol = thisPol.next;
}
}
retPol.poly.next = new Node(0, 0, null);
retPol.poly = retPol.poly.next;
}
/*
* This removes any zero entries, including the one my code adds in
* arbitrarily by default.
*
* Also, hello TA looking for arrays. Or Professor.
*
* There are no arrays here.
*/
Node previous = null;
Node current = front;
while (current != null) {
if (current.term.coeff == 0) {
current = current.next;
if (previous == null) {
previous = current;
} else {
previous.next = current;
}
} else {
previous = current;
current = current.next;
}
}
retPol.poly = front;
if (retPol.poly.term.coeff == 0 && retPol.poly.next.term.coeff == 0) {
Polynomial zero = new Polynomial();
zero.poly = new Node (0, 0, null);
return zero;
}
else
return retPol;
}
}
/**
* Returns the polynomial obtained by multiplying the given polynomial p
* with this polynomial - DOES NOT change this polynomial
*
* @param p
* Polynomial with which this polynomial is to be multiplied
* @return A new polynomial which is the product of this polynomial and p.
*/
public Polynomial multiply(Polynomial p) {
if (p.poly == null || this.poly == null) {
Polynomial zero = new Polynomial();
zero.poly = new Node (0, 0, null);
return zero;
} else {
Polynomial retPol = new Polynomial();
retPol.poly = new Node(0, 0, null);
Node front = retPol.poly;
Node entered = p.poly;
Node thisPol = this.poly;
int heighestMultiple = 0;
int lowestMultiple = 99999999;
while (entered != null) {
thisPol = this.poly;
while (thisPol != null) {
if (thisPol.term.degree + entered.term.degree > heighestMultiple)
heighestMultiple = thisPol.term.degree + entered.term.degree;
if (thisPol.term.degree + entered.term.degree < lowestMultiple)
lowestMultiple = thisPol.term.degree + entered.term.degree;
thisPol = thisPol.next;
}
entered = entered.next;
}
entered = p.poly;
Node create = front;
for (int i = lowestMultiple; i <= heighestMultiple; i++) {
create.term.degree = i;
create.term.coeff = 0;
create.next = new Node (0, 0, null);
create = create.next;
}
entered = p.poly;
while (entered != null) {
thisPol = this.poly;
while (thisPol != null) {
int degree = entered.term.degree + thisPol.term.degree;
create = front;
while (create != null) {
if (create.term.degree == degree) {
create.term.coeff = entered.term.coeff * thisPol.term.coeff;
}
create = create.next;
}
thisPol = thisPol.next;
}
entered = entered.next;
}
create = front;
while (create != null) {
if (create.term.degree == heighestMultiple) {
create.next = null;
create = create.next;
}
else
create = create.next;
}
retPol.poly = front;
return retPol;
}
}
/**
* Evaluates this polynomial at the given value of x
*
* @param x
* Value at which this polynomial is to be evaluated
* @return Value of this polynomial at x
*/
public float evaluate(float x) {
float retVal = 0;
Node currentMonomial = this.poly;
while (currentMonomial != null) {
float currentValue = (float) Math.pow(x,
currentMonomial.term.degree);
currentValue *= currentMonomial.term.coeff;
retVal += currentValue;
currentMonomial = currentMonomial.next;
}
return retVal;
}
/*
* (non-Javadoc)
*
* @see java.lang.Object#toString()
*/
public String toString() {
String retval;
if (poly == null) {
return "0";
} else {
retval = poly.term.toString();
for (Node current = poly.next; current != null; current = current.next) {
retval = current.term.toString() + " + " + retval;
}
return retval;
}
}
}
**************
P.S HAVE A LOOK AT THE BOTH THE SOLUTIONS AND KINDLY CHOOS WHICH YOU FEEL EASY
Related Questions
drjack9650@gmail.com
Navigate
Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.