Polynomial Java Program

[Piet Souris]

the compareTo seems fine, I would just like to add that if the coefficients are 0 then the comparision is also 0. There is by the look of it nothing that enforces the exponent to be 0 when the coefficient is 0.

If you are using a decent IDE, then it will suggest to also override the equals and hashCode methods. It is strongly advised to override these methods indeed. For the sake of this assignment, two PT's are equal when either their coeffficients are 0 or when their exponents are equal. So, 7x^2 equals 3x^2.

I will now try to test yor code, to see what the add and the multiply exactly do.

[Piet Souris]

I have not had time to do some testing, but I isolated the Node class, so that we can have an easier view of its contents. In the Polynomial class that I used as a LinkedList, I have given this role here to the Node class. I came up with this code:

//=========================================================================
class Node {
    
    final PolynomialTerm head;
    final Node tail;
    
    Node() {
        this(new PolynomialTerm(), null);
    }
    
    Node(PolynomialTerm pt, Node tail) {
        head = pt;
        this.tail = tail;
    }
    
    public Node add(PolynomialTerm p) {
        if (p == null) {
            return this;
        }
        int comparison = head.compareTo(p);
        if (comparison > 0) {
            if (tail != null) {
                return new Node(head, tail.add(p));
            }
            else return new Node(head, new Node(p, null));
        }
        else if (comparison == 0) {
            return new Node(head.plus(p), tail);
        }
        else {
            return new Node(p, this);
        }
    }
    
    public Node add(Node node) {
        return this.add(node.head).add(node.tail);
    }
}   // end of class Node

As you see, I added a method Node.add(PolynomialTerm pt) so that it is straightforward to incorporate a new pt, neatly put into its correct place. It is heavily based on recursion, but you see how that simplifies things. It may look impressive, but given the recursive nature of a genuine List, it is standard work.
Now, it culminates in the method Node.add(Node node), that in fact does all the work of adding two LinkedPolynomials. With this Node class, adding two LinkedPolyniomials becomes very easy indeed.

Global Halth Warning: this all is completely untested, so it could be (and probably will be) bugridden.

Yet to add: Node multiply(Node node)

Tomorrow morning I will test your code, but I hope that you like this new Node class.

[Piet Souris]

I jusr ran your latest code (correct me if I'm wrong):

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package sergemetellus;

/**
 *
 * @author Serge Metellus
 */
public class SergeMetellus {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        int[] data = {1,3, 2, 4, 0, 5};
        LinkedPolynomial piet = new LinkedPolynomial(data);
        System.out.println("piet: " + piet);
        LinkedPolynomial syl = new LinkedPolynomial(new int[] {5, 7, 0, 9});
        System.out.println("syl: " + syl);
        LinkedPolynomial som = piet.plus(syl);
        System.out.println("som: " + som);
    }

}

//************************************************************************
class LinkedPolynomial {

    private class Node {

        PolynomialTerm term;
        Node next;

        public Node(PolynomialTerm term, Node n) {
            this.term = term;
            this.next = n;
        }
    }

    private Node firstTerm;

    public LinkedPolynomial() {
        firstTerm = null;
    }

    public LinkedPolynomial(int[] data) {
        for (int i = 0; i < data.length - 1; i += 2) {
            PolynomialTerm term = new PolynomialTerm(data[i], data[i + 1]);
            firstTerm = new Node(term, firstTerm);
        }

    }

    public LinkedPolynomial plus(LinkedPolynomial poly) {
        LinkedPolynomial poly1 = this;
        LinkedPolynomial poly2 = new LinkedPolynomial();
        PolynomialTerm term2;
        Node term = poly.firstTerm;
        Node term1 = poly1.firstTerm;

        while (term != null && term1 != null) {

            term2 = term1.term.plus(term.term);

            poly2.firstTerm = new Node(term2, poly2.firstTerm);
            //poly2.firstTerm = poly.firstTerm.next;
            term = term.next;
            term1 = term1.next;
        }
        return poly2;
    }

    @Override
    public String toString() {
        Node term = this.firstTerm;
        String poly = "";
        while (term != null) {
            switch (term.term.getExponent()) {
                case 0:
                    poly += term.term.getCoefficient() + " + ";
                    break;
                case 1:
                    poly += term.term.getCoefficient() + "x" + "+";
                    break;
                default:
                    poly += term.term.getCoefficient() + "x^" + term.term.getExponent() + " + ";
                    break;
            }
            term = term.next;
        }
        return poly;
    }
}

//************************************************************************
class PolynomialTerm implements Comparable<PolynomialTerm> {

    private int exponent;
    private int coefficient;

    public PolynomialTerm(int exp, int coe) {
        this.exponent = exp;
        this.coefficient = coe;

    }

    public int getExponent() {
        return exponent;
    }

    public int getCoefficient() {
        return coefficient;
    }

    public int value(int x) {
        return (int) Math.pow(x, this.getExponent()) * this.getCoefficient();
    }

    public PolynomialTerm plus(PolynomialTerm term) {
        PolynomialTerm term1;
        if (term.getExponent() == this.getExponent()) {
            term1 = new PolynomialTerm(this.getExponent(), (this.getCoefficient() + term.getCoefficient()));
        } else {
            throw new IllegalArgumentException();
        }
        return term1;
    }

    public PolynomialTerm times(PolynomialTerm term) {
        return new PolynomialTerm(term.getExponent() + this.getExponent(), term.getCoefficient() * this.getCoefficient());
    }

    public PolynomialTerm derivative() {
        PolynomialTerm term;
        if (this.exponent == 0) {
            term = new PolynomialTerm(0, 0);
        } else {
            term = new PolynomialTerm(this.getExponent() - 1, this.getExponent() * this.getCoefficient());
        }

        return term;
    }

    @Override
    public String toString() {
        return "PolynomialTerm{" + coefficient + "x^" + exponent + '}';
    }

    @Override
    public int compareTo(PolynomialTerm o) {
        if (    (this.coefficient == 0 && o.coefficient == 0)
             ||
                (this.exponent == o.exponent)
            ) {
            return 0;
        } else if (this.exponent < o.exponent) {
            return -1;
        } else {
            return 1;
        }
    }
}

The output I got was:

piet: 5 + 4x^2 + 3x+
syl: 9 + 7x^5 +
Exception in thread "main" java.lang.IllegalArgumentException
at sergemetellus.PolynomialTerm.plus(SergeMetellus.java:127)
at sergemetellus.LinkedPolynomial.plus(SergeMetellus.java:66)
at sergemetellus.SergeMetellus.main(SergeMetellus.java:23)

So you see there are some shortcomings.

First of all: your terms in the Nodes are not sorted. You see that when I print out piet and syl.
Next, in the plus method, you send pairs of terms from the two LinkedPolynomials to the plus method of PolynomialTerm. There is a big likelyhood of these terms having different exponents, and so this error is being thrown.

So, things to do are:

1) override the equals and hashCode methods in your PolynomialTerm class, to be on the safe side
2) try to get these PolynomialTerms into descending order. If you look at what I did in my Node class, you see that I add term for term, comparing as I go. I think that is the easiest way.
3) Do write this method 'add(PolynomialTerm pt) to your LinkedPolynomial class, or to the Node class. As you can see in my Node class example, getting that method to work enormously eases all the other methods.

Let us know how you fare. This assignment is interesting, but certainly not easy.

[Campbell Ritchie]

Assuming that is supposed to represent an implementation of Comparable<PolynomialTerm>, I think no.
What would that method return if you compare 3x² with 4x²?
Read the documentation for Comparable in the first part of this post, and decide how you are going to define a total ordering for ComparableTerms. What are you going to do about comparing 4x² with 2x³?

[Piet Souris]

Campbell Ritchie wrote:(...)I think no.
What would that method return if you compare 3x² with 4x²?
(...)

The compareTo method treats these two as equal. What do you think is wrong with that? Think about that we do not want two terms in a Polynomial that have the same exponent.

[Campbell Ritchie]

So 3x² is considered equal to 4x²? If that is the definition of total ordering, then the method is all right.

[Piet Souris]

As it is used now, is that when two PolynomialTerms are comparing to 0 (I. e are to be considered as equal) then the coefficients can be added. It is used when adding two polynomials. The disadvantage is that it might give some problems when defining an equals method for polynomials. Then I would not want 3x^4 to be considered equal to 5x^4. But that is for later. It is like having a Card class, where you have that diamond 7 is unequal to spades 7, however,  when it comes to poker, they are equal ( in value). That is why I , in the beginning of this topic, preferred to have a dedicated Comparator instead of doing it in a Comparable. But the goal for now is getting this plus and multiply of the Polynomial working and the compareTo is suitable.

[Serge Metellus]

after speaking with my professor the plus method is supposed to throw an exception but a polynomial exception if the exponents are not equal. for the ordering i will try something like the one in piet's node class and will get back to you. i still do not see why add(Polynomialterm pt) is necessary when i basically have that method in the polynomial term class. like is said before myy code is working just out of order

[Campbell Ritchie]

It is very easy to create your own Exception class. The hardest part is usually choosing the superclass. Then (99% of the time) you have to implement four constructors and that's it.

[Carey Brown]

public int compareTo(PolynomialTerm o) 
    {
        
        if(this.exponent == o.exponent) 
        {
            if( this.coefficient == o.coefficient )
            {
                return 0;
            }
            if( this.coefficient < o.coefficient )
            {
                 return -1;
            }
            return 1;
        }
        else if(this.exponent < o.exponent)
        {
            return -1;
        } 
        else
        {
            return 1;
        }
       
    }

What about 0^10 compared to 1^3 ??

[Junilu Lacar]

Carey Brown wrote:What about 0^10 compared to 1^3 ??

Or for that matter, 0^10 and 0^100?

[Piet Souris]

This topic is about polynomials, i.e. things of the form sigma (ai * x^î), for i = n, n-1, ---, 0.
That has nothing to do with 0^3, 1^4 and 0^100.

Edkit: that sounds a bit harsher than I intended.
The objects here are indeed these polynomials, i.e. algebraïc entities, like you use in the Galois-theory, to name an example. So say 3x^2 + 7 is a polynomial. Now, you can imagine a function f(x) = 3x^2 + 7, as we all are so familiar with, and determine the value of f(2) and f(0). But, as said, that is something different. This assignment unfortunately also talks about a 'value' function, but that makes the possibility for a confusion only bigger.

[Junilu Lacar]

Piet Souris wrote:This topic is about polynomials, i.e. things of the form sigma (ai * x^î), for i = n, n-1, ---, 0.
That has nothing to do with 0^3, 1^4 and 0^100.

I was under the impression that Carey was using that notation as a shortcut for 0x^10 and 1x^3. I was just following suit: I meant 0x^10 and 0x^100. If coefficient is 0, then it doesn't really matter what x or its exponent is. Seems like coefficient == 0 is a special case for compareTo().

[Junilu Lacar]

Piet Souris wrote:Edkit: that sounds a bit harsher than I intended.

No problem, Piet. I think most of us know you enough to realize you don't mean it to be (most of the time anyway )

[Carey Brown]

Junilu Lacar wrote:Seems like coefficient == 0 is a special case for compareTo().

Thank you. This was what I was trying to point out to the OP.

[Serge Metellus]

i know im late  but here is my multiply/times method

 public LinkedPolynomial times(LinkedPolynomial poly)
    {
        LinkedPolynomial poly1 = this;
        LinkedPolynomial poly2 = new LinkedPolynomial();
        PolynomialTerm term2;
        Node term = poly.firstTerm;
        Node term1 = poly1.firstTerm;
        while(term1 != null)
        {
           term1 = term1.next;
            while(term != null)
            {
                term2 = term.term.times(term1.term);
                poly2.firstTerm = new Node(term2,poly2.firstTerm);
                term = term.next;
                
            }  
        }
        return poly2;
    }

my insert method

public void insert(PolynomialTerm term)
    {
    	LinkedPolynomial poly = this;
        Node term1 = poly.firstTerm;
        while(term1 != null)
        {
                if (term.compareTo(term1.term) == 1) 
                {
                    term1 = new Node(term,term1);
                }    
                else if (term.compareTo(term1.term) == -1)
                {
                    term1 = term1.next;
                }     
                else
                {
                    throw new IllegalArgumentException("Term already exist");
                }        
        }
    }

my multiply method only multiplies one term of one polynomial with all the terms of the other polynomial nut it does not repeat the process with the other terms. my insert method thwos the exception no matter what term i try to insert. i really need help on these last two methods. the assignment is due TONIGHT and i also have the programming final tomorrow morning

[Carey Brown]

Please post the Exception message text. Including line number etc.. Point out which line in your posted listing is the one the Exception points to.

[Serge Metellus]

the exception is line 17
here is the text
Exception in thread "main" java.lang.IllegalArgumentException: Term already exist
at LinkedPolynomial.insert(LinkedPolynomial.java:72)
at PolynomialTester.main(PolynomialTester.java:34)
/home/Surge/.cache/netbeans/8.2/executor-snippets/run.xml:53: Java returned: 1
BUILD FAILED (total time: 0 seconds)

[Carey Brown]

Can you post the most recent code for compareTo() ?

[Serge Metellus]

public int compareTo(PolynomialTerm o) 
    {
        if(this.exponent == o.exponent) 
        {
            return 0;
        }
        else if(this.exponent < o.exponent)
        {
            return -1;
        } 
        else
        {
            return 1;
        }
    }

[Carey Brown]

Serge Metellus wrote:

public void insert(PolynomialTerm term)
    {
    	LinkedPolynomial poly = this;
        Node term1 = poly.firstTerm;
        while(term1 != null)
        {
                if (term.compareTo(term1.term) == 1) 
                {
                    term1 = new Node(term,term1);
                }    
                else if (term.compareTo(term1.term) == -1)
                {
                    term1 = term1.next;
                }     
                else
                {
                    throw new IllegalArgumentException("Term already exist");
                }        
        }
    }

(term:1)-->(term:2)-->(term:4)
and you want to insert term:3, then you advance your current node to (4) but keep track of the previous node, then previous node links to term:3 and term:3 links to term:4.

Not exactly what you have. Can you use Java's LinkedList class?

[Serge Metellus]

no it has to be the custom linked list that i have so far. and what about the times method

[Serge Metellus]

how would i keep track of the previous node if there i did not declare a previous node in the node class and i don't think i am supposed to

[Carey Brown]

I can't recommend strongly enough that as you design code that you implement it in stages and get each stage debugged before going ahead.

public class Node2
{
	static Node2	root;
	int			payload;
	Node2		next;
	
	public static void main( String[] args )
	{
	}

	public Node2( Node2 next, int payload )
	{
		this.next = next;
		this.payload = payload;
	}
	
	public void insert( Node2 root, int payload ) // EDIT
	{
		Node2 prev = null;
		Node2 curr = root;
		while( curr != null && payload >= curr.payload )
		{
			if( payload > curr.payload )
			{
				prev = curr;
				curr = curr.next;
			}
			else
			{
				System.out.println( "ERROR" );
				return;
			}
		}
		if( prev != null )
		{
			prev.next = new Node2(curr,payload);
		}
		else
		{
			root = new Node2(curr,payload);
		}
	}
}

[Serge Metellus]

that is exactly what i have been doing because those are the only two methods i have left to do in this entire program.

Carey Brown wrote:

public class Node2
{
	static Node2	root;
	int			payload;
	Node2		next;
	
	public static void main( String[] args )
	{
	}

	public Node2( Node2 next, int payload )
	{
		this.next = next;
		this.payload = payload;
	}
	
	public void insert( Node2 n, int payload )
	{
		Node2 prev = null;
		Node2 curr = root;
		while( curr != null && payload >= curr.payload )
		{
			if( payload > curr.payload )
			{
				prev = curr;
				curr = curr.next;
			}
			else
			{
				System.out.println( "ERROR" );
				return;
			}
		}
		if( prev != null )
		{
			prev.next = new Node2(curr,payload);
		}
		else
		{
			root = new Node2(curr,payload);
		}
	}
}

^ what is that code?

[Carey Brown]

Serge Metellus wrote:what is that code?

That is an example of how to insert into a linked list.

Sometimes if you take a piece of your project off to the side and get it to work and then reintegrate it back into your project.

[Carey Brown]

In your case "int payload" would be replaced with "PolynomialTerm".

[Serge Metellus]

Okay but insert has to be in the polynomial class not the Node class

[Piet Souris]

At the top of this page I gave a working version of a Node class. I used recursion, since if you look at the requirements halfway page 1 you see that the professor prefers recursive solutions.

I also showed that it is very wise to put the insert and add method into the Node class. I made a special 'add(PolynomialTerm p)' to the Node class, such that adding two Nodes was just one line of code. It also means that adding two Polynomials is just a matter of this line of code: 'return new Polynomial(this.node.add(other.node)'.

In similar fashion, adding a method 'multiply(PT p)' is even simpler and was left to OP. The code would have been:

if (p.coefficient == 0) return new Node();  // Node() is the polynomialterm with coffecient 0)
else return new Node(head.multiply(pt), tail.multiply(pt));

and multiplying two Nodes is, analogue to the add method, just one line of code.

On page 1 I pointed out that in OP's PolynomialTerm class, no special attention was paid to the case when the coefficient == 0. Therefore I added that special line to the compareTo method. That line is now gone again.

I've spent a couple of hours to this topic and I have nothing more to add.

@Carey
why a static root? Why a root at all?

[Serge Metellus]

Piet in the requirements it states that the add and insert have to be in the Polynomilal class which i explained earlier. Also, in the requirements it says that comparable is implement on the exponents ONLY meaning it does not matter what the coefficient is. You seem irritated but i tried to explain everything to you and  blatantly ignored me again and again. also when the coefficient is zero the entire term is zero so AGAIN it does not matter

[Carey Brown]

Piet Souris wrote:@Carey
why a static root? Why a root at all?

This was an example only. Not needed. I edited the code later to pass root (or whatever you want to call it) to insert().

[Andreea Samsanovici]

Can someone tell me how do I create a method that  reads many polynomials?