Polynômes en Java

Question

Ma méthode d'ajout fonctionne, mais lorsque je crée un nouvel objet SparsePolynomial (en bas de la méthode add), la valeur du newSparePolynomial change lorsque je le débogue et que je n'arrive pas à savoir où se trouvent les informations supplémentaires vient de. Est-ce que quelqu'un peut m'aider?

Voici une copie de mon code:

import java.util.ArrayList; 

public class SparsePolynomial { 

    private ArrayList<Polynomial> polynomialarraylist = new ArrayList<Polynomial>(); 

    /** 
    * Constructor to get values of an arraylist of integers 
    * @param arraylist that contains the integer values used for the polynomials 
    */ 
    public SparsePolynomial(ArrayList<Integer> arrayList) 
    { 
     //MODIFIDED: polynomialarraylist 
     //EFFECT: constructs the arraylist of polynomials based off the arraylist of integers 
     insertIntoPolynomialArray(arrayList); 
    } 

    /** 
    * Converts the elements of the integer array into polynomials 
    * @param arrayList that contains the polynomials contents 
    */ 
    private void insertIntoPolynomialArray(ArrayList<Integer> arrayList) 
    { 
     //MODIFIED: polynomialarray 
     //EFFECT: inputs the values of the arrayList into the polynomial array based on the position of the digits 
     for(int i = 0; i < arrayList.size(); i++) 
     { 
      Polynomial polynomial = new Polynomial(arrayList.get(i), arrayList.get(i+1)); 
      polynomialarraylist.add(polynomial); 
      System.out.println("coef" + arrayList.get(i)); 
      System.out.println("degree" + arrayList.get(i+1)); 
      i++; 
     } 
    } 


    /** 
    * 
    */ 
    @Override 
    public String toString() 
    { 
     String result = ""; 
     sort(); 
     if (getDegree(0) == 0) 
      return "" + getCoefficient(0); 
     if (getDegree(0) == 1) 
      return getCoefficient(0) + "x + " + getCoefficient(0); 
     result = getCoefficient(0) + "x^" + getDegree(0); 

     for (int j = 1; j < polynomialarraylist.size(); j++) 
     { 
      if(j > polynomialarraylist.size()) 
      { 
       break; 
      } 
      if  
      (getCoefficient(j) == 0) continue; 
      else if 
      (getCoefficient(j) > 0) result = result+ " + " + (getCoefficient(j)); 
      else if 
      (getCoefficient(j) < 0) result = result+ " - " + (-getCoefficient(j)); 
      if(getDegree(j) == 1) result = result + "x"; 
      else if (getDegree(j) > 1) result = result + "x^" + getDegree(j); 
     } 
     return result; 


    } 

    /** 
    * Sorts array 
    * @param array to sort 
    */ 
    private void sort() 
    { 
     ArrayList<Polynomial> temp = polynomialarraylist; 
     ArrayList<Polynomial> temp2 = new ArrayList<Polynomial>(); 
     int polydegreemain = polynomialarraylist.get(0).degree(); 
     temp2.add(polynomialarraylist.get(0)); 
     for(int i = 1; i < polynomialarraylist.size(); i++) 
     { 
      if(i > polynomialarraylist.size()) 
      { 
       break; 
      } 
      int polydegreesecondary = polynomialarraylist.get(i).degree(); 

      if(polydegreemain < polydegreesecondary) 
      { 
       temp.set(i-1, polynomialarraylist.get(i)); 
       temp.set(i, temp2.get(0)); 
      } 

     } 

     polynomialarraylist = temp; 
    } 
    /** 
    * Makes object hashable 
    */ 
    @Override 
    public int hashCode() { 
     final int prime = 31; 
     int result = 1; 
     result = prime 
       * result 
       + ((polynomialarraylist == null) ? 0 : polynomialarraylist 
         .hashCode()); 
     return result; 
    } 

    /** 
    * Checks for equality of two objects 
    */ 
    @Override 
    public boolean equals(Object obj) { 
     if (this == obj) 
      return true; 
     if (obj == null) 
      return false; 
     if (getClass() != obj.getClass()) 
      return false; 
     SparsePolynomial other = (SparsePolynomial) obj; 
     if (polynomialarraylist == null) { 
      if (other.polynomialarraylist != null) 
       return false; 
     } else if (!polynomialarraylist.equals(other.polynomialarraylist)) 
      return false; 
     return true; 
    } 

    public boolean equals(SparsePolynomial Sparse) 
    { 
     if(this == Sparse) 
     { 
     return true; 
     } 
     else 
     { 
     return false; 
     } 
    } 

    public SparsePolynomial add(SparsePolynomial other) 
    { 

     ArrayList<Polynomial> thisPolynomial = createPolynomial(); 
     SparsePolynomial newSparsePolynomial; 
     ArrayList<Polynomial> otherPolynomial = other.createPolynomial(); 
     Polynomial oldsum = new Polynomial(); 
     Polynomial newsum = new Polynomial(); 
     for(int i = 0; i < thisPolynomial.size();i++) 
     { 
      if(thisPolynomial.size() == 1) 
      { 
       newsum = thisPolynomial.get(i); 
       oldsum = newsum; 
       break; 
      } 
      if(i == 0) 
      { 
      newsum = thisPolynomial.get(i).add(thisPolynomial.get(i+1)); 
      oldsum = newsum; 
      i++; 
      } 
      else 
      { 
       newsum = oldsum.add(thisPolynomial.get(i)); 
       oldsum = newsum; 
      } 
     } 
     for(int i = 0; i < otherPolynomial.size(); i++) 
     {  
      newsum = oldsum.add(otherPolynomial.get(i)); 
      oldsum = newsum; 
     } 

     ArrayList<Integer> ints = new ArrayList<Integer>(); 

     for(int i = 0; i < oldsum.degree()+1; i++) 
     { 
      ints.add(oldsum.coefficient(i)); 
      ints.add(i); 
     } 
     newSparsePolynomial = new SparsePolynomial(ints); 

     return newSparsePolynomial; 
    } 

    public SparsePolynomial subtract(SparsePolynomial other) 
    { 
     ArrayList<Polynomial> thisPolynomial = createPolynomial(); 

     ArrayList<Polynomial> otherPolynomial = other.createPolynomial(); 

     Polynomial olddifference = new Polynomial(); 
     Polynomial newdifference = new Polynomial(); 
     for(int i = 0; i < thisPolynomial.size()+1;i++) 
     { 
      if(i == 0) 
      { 
       newdifference = thisPolynomial.get(i).subtract(thisPolynomial.get(i+1)); 
       olddifference = newdifference; 
       i++; 
      } 
      else 
      { 
       newdifference = olddifference.subtract(thisPolynomial.get(i)); 
       olddifference = newdifference; 
      } 
     } 
     for(int i = 0; i < otherPolynomial.size(); i++) 
     { 

      newdifference = olddifference.add(otherPolynomial.get(i)); 
      olddifference = newdifference; 

     } 

     ArrayList<Polynomial> polyarray = createArrayListOfPolynomialsFromPolynomials(olddifference); 

     ArrayList<Integer> ints = new ArrayList<Integer>(); 

     for(int i = 0; i < polyarray.size(); i++) 
     { 
     ints.add(polyarray.get(i).coefficient(polyarray.get(i).degree())); 
     ints.add(polyarray.get(i).degree()); 
     } 

     SparsePolynomial newSparsePolynomial = new SparsePolynomial(ints); 

     return newSparsePolynomial; 
    } 


    private int getDegree(int index) 
    { 
     int degree; 

     degree = polynomialarraylist.get(index).degree(); 

     return degree; 
    } 

    private int getCoefficient(int index) 
    { 
     int coefficient; 

     coefficient = polynomialarraylist.get(index).coefficient(polynomialarraylist.get(index).degree()); 

     return coefficient; 
    } 

    private ArrayList<Polynomial> createPolynomial() 
    { 
     Polynomial polynomial = null; 
     ArrayList<Polynomial> polynomialArray = new ArrayList<Polynomial>(); 
     for(int i = 0; i < polynomialarraylist.size(); i++) 
     { 
      polynomial = new Polynomial(getCoefficient(i), getDegree(i)); 
      polynomialArray.add(polynomial);   
     } 
     return polynomialArray; 
    } 
Polynomial class 

public class Polynomial { 
    // Overview: ... 
    private int[] terms; 
    private int degree; 

    // Constructors 
    public Polynomial() { 
     // Effects: Initializes this to be the zero polynomial 
     terms = new int[1]; 
     degree = 0; 
    } 

    public Polynomial(int constant, int power) { 
     // Effects: if n < 0 throws IllegalArgumentException else 
     // initializes this to be the polynomial c*x^n 
     if(power < 0){ 
      throw new IllegalArgumentException("Polynomial(int, int) constructor"); 
     } 

     if(constant == 0) { 
      terms = new int[1]; 
      degree = 0; 
      return; 
     } 

     terms = new int[power+1]; 

     for(int i=0; i<power; i++) { 
      terms[i] = 0; 
     } 

     terms[power] = constant; 
     degree = power; 
    } 

    private Polynomial(int power) { 
     terms = new int[power+1]; 
     degree = power; 
    } 

    // Methods 
    public int degree() { 
     // Effects: Returns the degree of this, i.e., the largest exponent 
     // with a non-zero coefficient. Returns 0 is this is the zero polynomial 
     return degree; 
    } 

    public int coefficient(int degree) { 
     // Effects: Returns the coefficient of the term of this whose exponent is degree 
     if(degree < 0 || degree > this.degree) { 
      return 0; 
     } 
     else { 
      return terms[degree]; 
     } 
    } 

    public Polynomial subtract(Polynomial other) throws NullPointerException { 
     // Effects: if other is null throws a NullPointerException else 
     // returns the Polynomial this - other 
     return add(other.minus()); 
    } 

    public Polynomial minus() { 
     // Effects: Returns the polynomial - this 
     Polynomial result = new Polynomial(degree); 
     for(int i=0; i<=degree; i++) { 
      result.terms[i] = -this.terms[i]; 
     } 
     return result; 
    } 

    public Polynomial add(Polynomial other) throws NullPointerException { 
     // Effects: If other is null throws NullPointerException else 
     // returns the Polynomial this + other 
     Polynomial larger, smaller; 
     if (degree > other.degree){ 
      larger = this; 
      smaller = other; 
     } 
     else { 
      larger = other; 
      smaller = this; 
     } 

     int newDegree = larger.degree; 

     if (degree == other.degree) { 
      for(int k = degree; k > 0 ; k--) { 
       if (this.terms[k] + other.terms[k] != 0) { 
        break; 
       } 
       else { 
        newDegree --; 
       } 
      } 
     } 


     Polynomial newPoly = new Polynomial(newDegree); 
     int i; 
     for (i=0; i <= smaller.degree && i <= newDegree; i++){ 
      newPoly.terms[i] = smaller.terms[i] + larger.terms[i]; 
     } 

     for(int j=i; j <= newDegree; j++) { 
      newPoly.terms[j] = larger.terms[j]; 
     } 

     return newPoly; 
    } 

    public Polynomial multiply(Polynomial other) throws NullPointerException { 
     // Effects: If other is null throws NullPointerException else 
     // returns the Polynomial this * other 
     if ((other.degree == 0 && other.terms[0] == 0) || 
       (this.degree==0 && this.terms[0] == 0)) { 
        return new Polynomial(); 
     } 

     Polynomial newPoly = new Polynomial(degree + other.degree); 

     newPoly.terms[degree + other.degree] = 0; 

     for(int i=0; i<=degree; i++) { 
      for (int j=0; j<= other.degree; j++) { 
       newPoly.terms[i+j] = newPoly.terms[i+j] + this.terms[i] * other.terms[j]; 
      } 
     } 
     return newPoly; 
    } 

Answer 1

À coup d'œil, ressemble à ceci est un problème

for(int i = 0; i < arrayList.size(); i++) 
{ 
    Polynomial polynomial = new Polynomial(arrayList.get(i), arrayList.get(i+1)); 
    polynomialarraylist.add(polynomial); 
    System.out.println("coef" + arrayList.get(i)); 
    System.out.println("degree" + arrayList.get(i+1)); 
    i++; 
} 

Vous faites i ++ deux fois ici.

Aussi, vous avez posté trop de code. Personne ne veut lire autant. Vous êtes juste chanceux que, en supposant que ce soit le problème, il m'est arrivé d'y jeter un coup d'œil.

également que lèveront une arrayindexoutofboundserror depuis que vous faites .get (i + 1)

Answer 2

le constructeur est mis en place la façon dont il est parce que le get (i) vous obtient le coefficient et le i + 1 obtient le degré du paramètre arraylist puisque lorsque vous appelez add, sans ceux-ci le contenu de l'arraylist sera désactivé

Le constructeur est supposé prendre un Arraylist et les mettre en inisde d'un arraylist de polynomials. utiliser les probabilités comme coefficient et les équivalents comme les degrés des polynômes.