A polynomial may be represented using a linked list as follows: for every term in the polynomial there is one entry in the linked list consisting of the term's coefficient and degree. The entries are ordered according to ASCENDING values of degree, i.e. lowest degree term first, then next lowest degree term and so on, all the way up to the highest degree term. IMPORTANT: Zero-coefficient terms are NOT stored.

For example, the following polynomial (the symbol '^' is used to mean 'raised to the power'):

 4x^5 - 2x^3 + 2x +3 

can be represented as the linked list of terms:

 (3,0) -> (2,1) -> (-2,3) -> (4,5) 

where each term is a (coefficient,degree) pair.

Notes about representation:

Terms are stored in ASCENDING order of degrees from front to rear in a non-circular linked list.

Zero-coefficient terms are NOT stored.

An EMPTY (zero) polynomial is represented by a linked list with NO NODES in it, i.e. referenced by NULL.

Coefficients are floating point numbers

Degrees are POSITIVE integers, except if there is a constant term, in which case the degree is zero.

There will not be more than one term in the same degree.

If you do not represent all your polynomials (the initial inputs as well as those you get out of doing arithmetic on polynomials) as above, you will lose credit even if your results are mathematically correct.

Implementation and Grading

Download the attached polynomial_project.zip file to your computer. DO NOT unzip it. Instead, follow the instructions on the Eclipse page under the section "Importing a Zipped Project into Eclipse" to get the entire project into your Eclipse workspace.

You will see a project called Polynomial with the following classes in package poly:

Node

Term

Polynomial

Polytest

(Aside from these, there are also three sample input files, described in the Running the Program section below.)

You need to complete the implementation of the Polynomial class where indicated in the following methods:

Method	Grading Points
evaluate	10
add	25
multiply	25

Efficiency is not a requirement for any of the methods. And, you can use Math class methods as needed.

Note: You will get a zero if you use any other data structure (e.g. array/arraylist) anywhere in your implementation, for any reason, even if it has nothing to do with the actual polynomial operations. You must work with linked lists ONLY all the way through.

Observe the following rules while working on Polynomial.java:

Only fill in the code in the methods add, multiply, and evaluate where indicated.

In methods that return a Polynomial (add and multiply), the polynomial that is returned must be represented as described in the "Notes about representation" part of the Background section above. Your method will not get credit if the returned polynomial does not adhere to this representation, even it is mathematically correct. Also see the "Notes about empty (zero) polynomials" at the end of the Running the program section below.

DO NOT remove the import statements at the top of any of the given classes.

DO NOT add any import statements to the original list of imports in Polynomial.java

DO NOT change the headers of ANY of the given methods

DO NOT change/remove any of the given class fields

DO NOT add any new class fields.

YOU MAY add new helper methods, but you must declare them private.

Do not change Node and Term in any way. You will not be submitting them, and we will be using the original versions to test your Polynomial implementation.

If you wish to change Polytest, feel free. You will not be submitting it, and we will not be using it to grade your Polynomial submission.

Running the program

There are three sample input files for you to test (they should be under the project folder in Eclipse):

A file ptest1.txt that contains the polynomial

4x^5 - 2x^3 + 2x + 3 

A file ptest2.txt that contains the polynomial

8x^4 + 4x^3 - 3x + 9 

A file ptest1opp.txt that contains the polynomial

-4x^5 + 2x^3 - 2x - 3 

(the negation of the polynomial in ptest1)

In each of these files, each line is a term, with the first value being the coefficient, and the second value being the degree. The terms are listed in descending order of degrees and the respective non-zero coefficients. Remember that when you store a polynomial in a linked list, you will store it in ascending order of degrees. (This is actually already implemented by the Polynomial constructor when it reads a polynomial from an input file. All you have to do is make sure you stick with this rule when you add and multiply.)

You may assume that we will NOT test with an invalid polynomial file, i.e. every test input file will either have at least one term in the correct format, or will be empty (see Notes about empty (zero) polynomials below). So you don't need to check for validity of input.

Here's a sample run of the driver, Polytest. Apart from ptest1.txt, ptest2.txt, and ptest1opp.txt, a fourth test polynomial file, ptestnull.txt is also used. This is an empty file that stands for a null (zero) polynomial - you will need to create this yourself. See notes after the test run for special instructions regarding zero polynomials.

Enter the name of the polynomial file => ptest1.txt 4.0x^5 + -2.0x^3 + 2.0x + 3.0 1. ADD polynomial 2. MULTIPLY polynomial 3. EVALUATE polynomial 4. QUIT Enter choice # => 1 Enter the file containing the polynomial to add => ptest2.txt 8.0x^4 + 4.0x^3 + -3.0x + 9.0 Sum: 4.0x^5 + 8.0x^4 + 2.0x^3 + -1.0x + 12.0 1. ADD polynomial 2. MULTIPLY polynomial 3. EVALUATE polynomial 4. QUIT Enter choice # => 1 Enter the file containing the polynomial to add => ptest1opp.txt -4.0x^5 + 2.0x^3 + -2.0x + -3.0 Sum: 0 1. ADD polynomial 2. MULTIPLY polynomial 3. EVALUATE polynomial 4. QUIT Enter choice # => 1 Enter the file containing the polynomial to add => ptestnull.txt 0 Sum: 4.0x^5 + -2.0x^3 + 2.0x + 3.0 1. ADD polynomial 2. MULTIPLY polynomial 3. EVALUATE polynomial 4. QUIT Enter choice # => 2 Enter the file containing the polynomial to multiply => ptest2 8.0x^4 + 4.0x^3 + -3.0x + 9.0 Product: 32.0x^9 + 16.0x^8 + -16.0x^7 + -20.0x^6 + 52.0x^5 + 38.0x^4 + -6.0x^3 + -6.0x^2 + 9.0x + 27.0 1. ADD polynomial 2. MULTIPLY polynomial 3. EVALUATE polynomial 4. QUIT Enter choice # => 3 Enter the evaluation point x => 2 Value at 2.0: 119.0 1. ADD polynomial 2. MULTIPLY polynomial 3. EVALUATE polynomial 4. QUIT Enter choice # => 4 

The sample tests we have given you are just for starters. You will need to create other tests of your own on which you can run your code. For every test you run, be careful to keep your test input in the same format as the test files provided, otherwise Polytest will not work correctly. And make sure your test file is in the same folder as the other files, i.e. under Polynomial.

Note on translation from internal to output representation:

The toString method in the Polynomial class returns a string with the terms in descending order, fit for printing. (It process the ascending ordered terms of the input linked list in reverse order.) For illustration, see how the add method in Polytest prints the resulting polynomial:

 System.out.println("Sum: " + Polynomial.toString(Polynomial.add(poly1,poly2)) + " "); 

Notes about empty (zero) polynomials:

If you want to test with an empty polynomial input, you should create a file with nothing in it. In Eclipse, you can do this by right clicking on the project name in the package explorer view, then selecting New, then selecting File. Give a name, and click Finish. You new file will show up under the project name folder in the package explorer view, and the file will be opened in the text editor view. But don't type anything in the file.

Remember that when you add two terms of the same degree, if you get a zero coefficient result term, it should not be added to the result polynomial. As listed in the "Notes about representation" in the Backgroundsection, zero-coefficient terms are not stored.

The string representation of a zero polynomial is "0" - see the toString method of the Polynomial class. So, the Polytest driver will print a zero for a zero polyomial input, or a zero polynomial that results from an operation performed on two polynomials.

Please remember that do not use any other import statement

Here's the Polynomial.java file:

package poly;

import java.io.IOException;

import java.util.Scanner;

/**

* This class implements evaluate, add and multiply for polynomials.

*

* @author

*

*/

public class Polynomial {

/**

* Reads a polynomial from an input stream (file or keyboard). The storage format

* of the polynomial is:

*

*

*

* ...

*

*

* with the guarantee that degrees will be in descending order. For example:

*

* 4 5

* -2 3

* 2 1

* 3 0

*

* which represents the polynomial:

*

* 4*x^5 - 2*x^3 + 2*x + 3

*

*

* @param sc Scanner from which a polynomial is to be read

* @throws IOException If there is any input error in reading the polynomial

* @return The polynomial linked list (front node) constructed from coefficients and

* degrees read from scanner

*/

public static Node read(Scanner sc)

throws IOException {

Node poly = null;

while (sc.hasNextLine()) {

Scanner scLine = new Scanner(sc.nextLine());

poly = new Node(scLine.nextFloat(), scLine.nextInt(), poly);

scLine.close();

}

return poly;

}

/**

* Returns the sum of two polynomials - DOES NOT change either of the input polynomials.

* The returned polynomial MUST have all new nodes. In other words, none of the nodes

* of the input polynomials can be in the result.

*

* @param poly1 First input polynomial (front of polynomial linked list)

* @param poly2 Second input polynomial (front of polynomial linked list

* @return A new polynomial which is the sum of the input polynomials - the returned node

* is the front of the result polynomial

*/

public static Node add(Node poly1, Node poly2) {

/** COMPLETE THIS METHOD **/

// FOLLOWING LINE IS A PLACEHOLDER TO MAKE THIS METHOD COMPILE

// CHANGE IT AS NEEDED FOR YOUR IMPLEMENTATION

return null;

}

/**

* Returns the product of two polynomials - DOES NOT change either of the input polynomials.

* The returned polynomial MUST have all new nodes. In other words, none of the nodes

* of the input polynomials can be in the result.

*

* @param poly1 First input polynomial (front of polynomial linked list)

* @param poly2 Second input polynomial (front of polynomial linked list)

* @return A new polynomial which is the product of the input polynomials - the returned node

* is the front of the result polynomial

*/

public static Node multiply(Node poly1, Node poly2) {

/** COMPLETE THIS METHOD **/

// FOLLOWING LINE IS A PLACEHOLDER TO MAKE THIS METHOD COMPILE

// CHANGE IT AS NEEDED FOR YOUR IMPLEMENTATION

return null;

}

/**

* Evaluates a polynomial at a given value.

*

* @param poly Polynomial (front of linked list) to be evaluated

* @param x Value at which evaluation is to be done

* @return Value of polynomial p at x

*/

public static float evaluate(Node poly, float x) {

/** COMPLETE THIS METHOD **/

// FOLLOWING LINE IS A PLACEHOLDER TO MAKE THIS METHOD COMPILE

// CHANGE IT AS NEEDED FOR YOUR IMPLEMENTATION

return 0;

}

/**

* Returns string representation of a polynomial

*

* @param poly Polynomial (front of linked list)

* @return String representation, in descending order of degrees

*/

public static String toString(Node poly) {

if (poly == null) {

return "0";

}

String retval = poly.term.toString();

for (Node current = poly.next ; current != null ;

current = current.next) {

retval = current.term.toString() + " + " + retval;

}

return retval;

}

}