Discussion :

[ShadStrike]

Bonjour,
Je travaille sur l’implémentation Java du Type abstrait Polynôme, il s'appuis sur le type abstrait Monôme déjà implémenter et cela dans le cadre de mes études.
Le type Polynôme doit être une arraylist j'ai donc chercher comment l'utiliser ici : http://javasearch.developpez.com/j2s...ArrayList.html
Mais j'ai quelque problème:

Quand je définie une taille ou essaye de l’agrandir l’opération n'effectue aucun changement:

Si je fait:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
ArrayList<Monôme> Poly = new ArrayList<Monôme>(10);
Poly.ensureCapacity(100);
Poly.add(2,new Monôme(4,2));

J'obtient:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
Exception in thread "main" java.lang.IndexOutOfBoundsException: Index: 2, Size: 0
	at java.util.ArrayList.rangeCheckForAdd(ArrayList.java:612)
	at java.util.ArrayList.add(ArrayList.java:426)
	at test.run.main(run.java:9)

Le but est de ranger les monôme dans la case de leur exposant -1, 8^3 serait au rang 2 cela pour ensuite faciliter les opération somme et multiplication de Polynôme.


j'ai fais des test de taille et avec sa:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package test;
import java.util.*;
 
public class run {
	public static void main(String[] args)
	{
		ArrayList<Monôme> Poly = new ArrayList<Monôme>(10);
		Poly.ensureCapacity(999999);
		System.out.println(Poly.size());
		Poly.add(new Monôme(4,2));
		Poly.add(new Monôme(5,3));
		System.out.println(Poly.size());
		System.out.println(Poly);
 
            }
 
}

il me retourne:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
0
2
[4.0xe2, 5.0xe3]

Pourquoi il garde une taille de 0?

[joel.drigo]

Salut,

Tu n'as aucun besoin d'appeler ensureCapacity() : cette méthode sert uniquement à dimensionner le tableau de stockage interne de la classe ArrayList, pas sa taille. Sa taille, c'est son nombre d'éléments. La classe ArrayList gère, toute seule, l'augmentation de sa taille, et la dimension du tableau interne de stockage, en fonction de ce qu'on y ajoute. On peut éventuellement utiliser ensureCapacity() si on veut ajouter beaucoup d'éléments à la suite, dans un temps très court, pour éviter des "redimensionnements" successifs du tableau interne (qui se fait par création d'un nouveau tableau plus grand, et une copie de tableau), lorsqu'on a un besoin de hautes performances. En aucun cas pour ajouter 1 seul élément !

Pour ajouter un élément à une classe implémentant l'interface java.util.List, comme ArrayList, on utilise la méthode add() à un paramètre, qui est l'élément à ajouter. La méthode add() à 2 paramètres, sert à insérer avant, ou après le dernier élément, comme l'indique sa javadoc. Le premier argument est l'index de l'élément avant lequel on veut ajouter, ou la taille de la liste, pour ajouter après le dernier. Aucune autre valeur d'index est acceptée (0<=index<=size()), sous peine d'obtenir l'exception que tu obtiens, et ce, quelque soit la taille du tableau interne de stockage.


EDIT: j'avais pas regardé tout ton code. Tu te rends compte de ce que fait ensureCapacity(999999) ?

[ShadStrike]

enfaîte le ensureCapacity(999999) était juste pour le test.
Donc je ne peut inserer un élément a la nème position que si il existe un élémement a la nème ou nème-1 position?

J'ai essayer de remplir avec de monome null voici mon code:

Polynome.java

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
import java.util.*;
public class Polynôme {
 
	List<Monôme> Poly = new ArrayList<Monôme>();
 
	/**
         * construit un polynôme vide
         */
	public Polynôme()
	{
		Poly.add(new Monôme(0,0));
	}
 
	/**
         * ajoute un monôme à un polynôme
         * @param mono
         * @throws PolynômeException 
         */
	public void ajouterMonôme(Monôme mono) throws PolynômeException
	{
		Monôme mono2 = this.Poly.get(mono.exposant());
		if (mono.exposant() > this.Poly.size()){
			for (int i=this.Poly.size();i < mono.exposant();i++){
				if (i >= this.Poly.size() || this.Poly.get(i) == null){
					this.Poly.add(new Monôme(0,0));}
				}
			this.Poly.add(mono);
		}
		else if (mono2.estNul())
			this.Poly.set(mono.exposant(),mono);
		else
			throw new PolynômeException();
	}

testPolynome

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
public class client {
	public static void main(String[] args) throws PolynômeException
	{
		Polynôme A = new Polynôme();
		A.ajouterMonôme(new Monôme(5,0));
		A.ajouterMonôme(new Monôme(6,1));
		A.ajouterMonôme(new Monôme(1,2));
 
            }
 
}

Et j'ai toujours un problème de taille

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
Exception in thread "main" java.lang.IndexOutOfBoundsException: Index: 1, Size: 1
	at java.util.ArrayList.rangeCheck(ArrayList.java:604)
	at java.util.ArrayList.get(ArrayList.java:382)
	at Polynôme.ajouterMonôme(Polynôme.java:21)
	at client.main(client.java:8)

Pourtant la fonction ajouterMonôme créé des monôme vide jusqu’à ce que on arrive au rang voulu je ne comprend pas.

Le but est de pouvoir par la suite effectuer des opération somme et produit entre polynôme, si il sont ranger de manière anarchique dans la liste je ne vois pas trop comment faire alors que si a un exposant correspond un rang de la liste sa devient plus simple.

[joel.drigo]

Les indices des éléments dans les List (comme dans les tableau) en java vont de 0 à n-1 (entre 0 inclus et n exclu), où n est le nombre d'éléments (qu'on appelle la taille de la liste).

Quand tu écris :

Code java :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
for (int i=this.Poly.size();i < mono.exposant();i++){                if (i >= this.Poly.size() || this.Poly.get(i) == null){
                    this.Poly.add(new Monôme(0,0));} 
    ...                }

Ton indice de boucle i commence à la valeur n, valeur d'indice exclue, donc le get(i) plante à la première itération (c'est le sens de l'exception

IndexOutOfBoundsException : indice en dehors des limites).

[ShadStrike]

Je doit donc utiliser i-1 et pas i c'est bien sa?

[thelvin]

Ou simplement estimer que i doit être inférieur ou égal à l'exposant.

Après tout, un monôme doit toujours être situé à l'index correspondant à son exposant.
(... Et donc la classe Monôme ne sert pas à grand-chose...)

[joel.drigo]

Si j'ai bien compris tu veux placer un monôme d'exposant i en position i dans la liste.

Le plus simple est de raisonner d'abord comme si la liste était remplie. Pour placer un monôme d'exposant i en position i, il suffit d'écrire (en admettant que i n'est jamais négatif) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
int i = monome.getExposant();
liste.set(i, monome);

Maintenant, on ne peut appeler cette méthode que si i est compris entre 0 inclus et la taille de la liste exclue, donc on ajoute un test :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
int i = monome.getExposant();
if ( i<liste.size() ) {
   liste.set(i, monome);
}

Et maintenant, on gère le "else". On doit ajouter le monôme d'exposant i, à l'indice i, qui n'existe pas encore, donc faire liste.add(i, monome), ce qu'on ne pourra faire que si la liste à un nombre d'éléments suffisant, soit que i==liste.size(). Commençons par :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
int i = monome.getExposant();
if ( i<liste.size() ) {
   liste.set(i, monome);
} else {
 
   ...
 
   liste.add(monome); // ceci est l'équivalent de liste.add(liste.size(), monome);
}

Il ne reste qu'à remplacer les "..." par une boucle qui ajoute suffisamment de monômes du type 0xⁱ. C'est-à-dire, si on reprend la règle du placement d'un monôme énoncée au début, ajouter un monôme 0x^liste.size(), tant que liste.size()<i.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
int i = monome.getExposant();
if ( i<liste.size() ) {
   liste.set(i, monome);
} else {
 
   while( liste.size()<i ) {
       liste.add(new Monome(0, liste.size()));
   }
 
   liste.add(monome);
}