I'm having trouble writing a polynomial code.

Question

I'm having trouble with a polynomial code I'm supposed to conjour it. It's simply a code that adds, subtracts, and multiplies polynomials. However, there are a few methods I do not know how to come up with (I left them blank), and when I test the code write now, it doesn't work. Here's the code -- can anyone help?
public class Polynomial implements Cloneable {
     private int m_degree;
     private double[] m_coefficient;
     // This is the default constructor
     public Polynomial() {
          super();
          m_degree = 0;
          m_coefficient = new double[5];
     // This allows the user to build a polynomial by putting a constant in
     public Polynomial(double constant) {
          this();
          m_coefficient[0] = constant;
     public Polynomial(Polynomial source) {
     // These are the getters
     public double getCoefficient(int degree) {
          return m_coefficient[degree];
     public int getDegree() {
          return m_degree;
     // These are the setters
     public void addToCoefficient(double amount, int degree) {
          m_coefficient[degree] += amount;
     public void assignCoefficient(double newCoefficient, int degree) {
          m_coefficient[degree] = newCoefficient;
     public void clear() {
          for (int i = 0; i < m_coefficient.length; i++) {
               m_coefficient[i] = 0;
     public void reserve(int degree) {
     // These are other, useful methods
     public int nextTerm(int k) {
          int value = 0;
          return value;
     public double eval(double x) {
          double value = 0;
          // This goes through all the exponents in the polynomial
          for (int i = 0; i < getDegree(); i++) {
               // += allows you to add instead of overriding the next term
               value += getCoefficient(i) * Math.pow(x, i);
          return value;
     // Here is our addition method
     public static Polynomial add(Polynomial p1, Polynomial p2) {
          Polynomial newPolynomial = new Polynomial();
          // We have to find the bigger polynomial so we know how to set the loop
          if (p1.getDegree() >= p2.getDegree()) {
               for (int i = 0; i < p1.getDegree(); i++) {
                    newPolynomial.addToCoefficient(p1.getCoefficient(i)
                              + p2.getCoefficient(i), i);
          } else {
               for (int i = 0; i < p2.getDegree(); i++) {
                    newPolynomial.addToCoefficient(p1.getCoefficient(i)
                              + p2.getCoefficient(i), i);
          return newPolynomial;
     // Here is our subtraction method
     public static Polynomial subtract(Polynomial p1, Polynomial p2) {
          Polynomial newPolynomial = new Polynomial();
          // We have to find the bigger polynomial so we know how to set the loop
          if (p1.getDegree() >= p2.getDegree()) {
               for (int i = 0; i < p1.getDegree(); i++) {
                    newPolynomial.addToCoefficient(p1.getCoefficient(i)
                              - p2.getCoefficient(i), i);
          } else {
               for (int i = 0; i < p2.getDegree(); i++) {
                    // The order is important with subtraction so they cannot be
                    // switched
                    // The equation is allowed to be negative, but the exponent
                    // cannot be
                    newPolynomial.addToCoefficient(p1.getCoefficient(i)
                              - p2.getCoefficient(i), i);
          return newPolynomial;
     // Here is our multiplication method
     public static Polynomial multiply(Polynomial p1, Polynomial p2) {
          Polynomial newPolynomial = new Polynomial();
          if (p1.getDegree() >= p2.getDegree()) {
               for (int i = 0; i < p1.getDegree(); i++) {
                    newPolynomial.addToCoefficient(p1.getCoefficient(i)
                              * p2.getCoefficient(i), i);
          } else {
               for (int i = 0; i < p2.getDegree(); i++) {
                    newPolynomial.addToCoefficient(p1.getCoefficient(i)
                              * p2.getCoefficient(i), i);
          return newPolynomial;
     // Here is our clone method
     public Polynomial clone() {
          Polynomial poly;
          try {
               poly = (Polynomial) super.clone();
          } catch (CloneNotSupportedException e) {
               throw new RuntimeException(
                         "Class does not implement cloneable interface");
          return poly;
}

Answer 1

We've been working with arrays, and we have to write a code that adds, subtracts, and multiplies polynomials. I'm having trouble with a few of the methods. I've assigned m_degree and m_coefficient as the fields I need to use.
Right now, as my code stands, when I test it with a polynomial in main, it doesn't work. So right now, there's a mistake preventing what I have so far from properly functioning.
I am also having trouble writing the following methods:
reserve: We have to allocate memory to the polynomial every time it changes so we make sure we always have enough space to work with it.
nextTerm: We need this to jump to the next term in the polynomial, but I'm not quite sure how to do it. I didn't even realize it was possible.
I'm horrible at commenting and explaining my code, but if you read over it just a little bit, you may be able to get the gist of what I'm trying to do. Thanks for any help, and sorry if I can't explain well.
public class Polynomial implements Cloneable {
private int m_degree;
private double[] m_coefficient;
// This is the default constructor
public Polynomial() {
super();
m_degree = 0;
m_coefficient = new double[5];
// This allows the user to build a polynomial by putting a constant in
public Polynomial(double constant) {
this();
m_coefficient[0] = constant;
public Polynomial(Polynomial source) {
// These are the getters
public double getCoefficient(int degree) {
return m_coefficient[degree];
public int getDegree() {
return m_degree;
// These are the setters
public void addToCoefficient(double amount, int degree) {
m_coefficient[degree] += amount;
public void assignCoefficient(double newCoefficient, int degree) {
m_coefficient[degree] = newCoefficient;
public void clear() {
for (int i = 0; i < m_coefficient.length; i++) {
m_coefficient[i] = 0;
public void reserve(int degree) {
// These are other, useful methods
public int nextTerm(int k) {
int value = 0;
return value;
public double eval(double x) {
double value = 0;
// This goes through all the exponents in the polynomial
for (int i = 0; i < getDegree(); i++) {
// += allows you to add instead of overriding the next term
value += getCoefficient(i) * Math.pow(x, i);
return value;
// Here is our addition method
public static Polynomial add(Polynomial p1, Polynomial p2) {
Polynomial newPolynomial = new Polynomial();
// We have to find the bigger polynomial so we know how to set the loop
if (p1.getDegree() >= p2.getDegree()) {
for (int i = 0; i < p1.getDegree(); i++) {
newPolynomial.addToCoefficient(p1.getCoefficient(i)
+ p2.getCoefficient(i), i);
} else {
for (int i = 0; i < p2.getDegree(); i++) {
newPolynomial.addToCoefficient(p1.getCoefficient(i)
+ p2.getCoefficient(i), i);
return newPolynomial;
// Here is our subtraction method
public static Polynomial subtract(Polynomial p1, Polynomial p2) {
Polynomial newPolynomial = new Polynomial();
// We have to find the bigger polynomial so we know how to set the loop
if (p1.getDegree() >= p2.getDegree()) {
for (int i = 0; i < p1.getDegree(); i++) {
newPolynomial.addToCoefficient(p1.getCoefficient(i)
- p2.getCoefficient(i), i);
} else {
for (int i = 0; i < p2.getDegree(); i++) {
// The order is important with subtraction so they cannot be
// switched
// The equation is allowed to be negative, but the exponent
// cannot be
newPolynomial.addToCoefficient(p1.getCoefficient(i)
- p2.getCoefficient(i), i);
return newPolynomial;
// Here is our multiplication method
public static Polynomial multiply(Polynomial p1, Polynomial p2) {
Polynomial newPolynomial = new Polynomial();
if (p1.getDegree() >= p2.getDegree()) {
for (int i = 0; i < p1.getDegree(); i++) {
newPolynomial.addToCoefficient(p1.getCoefficient(i)
* p2.getCoefficient(i), i);
} else {
for (int i = 0; i < p2.getDegree(); i++) {
newPolynomial.addToCoefficient(p1.getCoefficient(i)
* p2.getCoefficient(i), i);
return newPolynomial;
// Here is our clone method
public Polynomial clone() {
Polynomial poly;
try {
poly = (Polynomial) super.clone();
} catch (CloneNotSupportedException e) {
throw new RuntimeException(
"Class does not implement cloneable interface");
return poly;
}