Discussion :

[Revaroa]

Bonjour,

J'aimerais savoir comment faire pour dire que objet1 est égal à ojet2 sans modifier objet2

Voici mon code :

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
34
35
 
	public Vector<Individu> mutation(Vector<Individu> tabMeilleurs){
 
		// Tableau d'individus mutés
		Vector<Individu> mutants = new Vector<Individu>();
 
		// Taille des meilleurs individus
		int tailleMI = tabMeilleurs.size();
 
		// Taille d'un individu
		int tailleI = tabMeilleurs.get(0).getTailleIndividu();
 
		// Selon taux de mutation
		// Ici pour l'exemple on va muter 7 fois des individus au hasard 
		for(int i=0; i<7; i++){
 
			// Choix aléatoire de l'individu à muter dans N meilleurs
			int positionMI = (int)(Math.random() * (tailleMI));
			System.out.println("Position dans tableau meilleurs individus : " + positionMI);
 
			// Choix au hasard du gène de l'individu à muter
			int positionI = (int)(Math.random() * (tailleI));
 
			// Tire au hasard d'un nombre entre -3 et 3
			int val = (int)(Math.random() * ((3 - (-3)) + 1) + (-3) );
 
			// Un nouveau individu qui est égal au meilleur individu à la positionMI
			Individu individu = tabMI.get(positionMI);
			// Mutation à la positionI par la valeur val de l'individu à la positionMI
			individu.setVal(positionI, val); // setVal est une méthode de la classe Individu
			mutants.add(individu);
 
		}
		return mutants;
	}

Comment faire pour ne pas modifier l'argument de cette méthode car quand le hasard tombe sur le même individu dans le tableau des meilleurs (tabMeilleurs en paramètre) cet individu à été modifié.
Or, je voudrais ici :

Code :

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

1
2
3
4
5
 
// Un nouveau individu qui est égal au meilleur individu à la positionMI
Individu individu = tabMeilleurs.get(positionMI);
// Mutation à la positionI par la valeur val de l'individu à la positionMI
individu.setVal(positionI, val); // setVal est une méthode de la classe Individu

que le tableau des meilleurs reste ce qu'il est mais que je puisse créer un nouveau individu à partir de celui-ci.

Merci d'avance.

[joel.drigo]

Salut,

C'est très confus tout ça. Tu parles de tableau alors que tu manipules des Vector. Que veux dire "ne pas modifier l'argument d'une méthode" ?
Et "que le tableau des meilleurs reste ce qu'il est mais que je puisse créer un nouveau individu à partir de celui-ci." ? Celui-ci c'est le tableau (il n'y a aucun tableau) donc tu demandes comment créer un individu à partir d'un tableau, ou Vector...


J'ai l'impression qu'il y a 2 questions en une :

1. Comment créer un nouvel individu qui soit une copie d'un autre, pour que la modification n'affecte pas l'individu copié ?
2. Comment ne pas copier plusieurs fois le même individu (alors que le hasard permet éventuellement de traiter plusieurs fois le même individu)

C'est bien ça ?

[Revaroa]

J'ai l'impression qu'il y a 2 questions en une :

1. Comment créer un nouvel individu qui soit une copie d'un autre, pour que la modification n'affecte pas l'individu copié ?
2. Comment ne pas copier plusieurs fois le même individu (alors que le hasard permet éventuellement de traiter plusieurs fois le même individu)

C'est bien ça ?

C'est exactement ce que je voudrais arriver à faire.

J'ai essayé çà

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
	public Vector<Individu> mutation(Vector<Individu> tabMeilleurs){
 
		// Tableau d'individus mutés
		Vector<Individu> mutants = new Vector<Individu>();
		// Taille des meilleurs individus
		int tailleMI = tabMeilleurs.size();
		// Taille d'un individu
		int tailleI = tabMeilleurs.get(0).getTailleIndividu();
 
		// Selon taux de mutation
		for(int i=0; i<7; i++){
 
			// Choix aléatoire de l'individu à muter dans N meilleurs
			int positionMI = (int)(Math.random() * (tailleMI-0) + 0);
			// Choix au hasard du gène de l'individu à muter
			int positionI = (int)(Math.random() * (tailleI-0) + 0);
			// Tire au hasard un nombre entre -3 et 3
			int val = (int)(Math.random() * ((3 - (-3)) + 1) + (-3) );
 
			double []t = new double[25];
 
			for(int k=0; k<t.length; k++){
				t[k] = tabMeilleurs.get(positionMI).getVal(k);
			}
 
			Individu individu = new Individu(t); // j'ai créer un nouvel constructeur dans Individu
			individu.setVal(positionI, val);
			mutants.add(individu);
 
		}
		return mutants;
	}

Mais avec cette solution, j'ai dû créer un nouvel constructeur dans la class Individu, en plus qu'il copie plusieurs fois le même individu.

Je cherche une meilleure solution et pour l'instant j'ai fait ça.

Quelques conseils pour améliorer ou complètement modifier le code.

[joel.drigo]

Dans ce cas,

Pour la copie, faire un constructeur spécial est une solution, mais regarde la méthode l'interface Cloneable et sa méthode clone (Tutoriel Developpez).

Pour éviter de traiter plusieurs fois un même élément, la première solution et de stocker les instances d'Individu déjà traitées, ce qui permet de savoir qu'une instance a déjà été traitée. Par exemple, en la stockant dans un HashSet (on peut rendre plus efficace la recherche dans le HashSet en implémentant correctement equals() et hashCode() de Individu). On en stockant les identifants d'individu dans un HashSet<Integer> : tant que positionMI est dans ce set, tu retires positionMI, sinon tu stockes positionMI dans ce set.
Mais le plus simple est encore de copier la liste des positions dans une liste et de mélanger cette liste avec Collections.shuffle(), puis de parcourir simplement cette liste :

Code :

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

1
2
3
4
5
6
7
8
9
10
List<Integer> positionMIs = new ArrayList<>(tabMeilleurs.size());
for(int i=0; i<tabMeilleurs.size(); i++) {
   positionMIs.add(i);
}
for(int mutation=0; mutation<nombreMutations; mutation++) {
   Collections.shuffle(positionMis);
   for(int positionMI : positionMis) {
      ... muter ...
   }
}

Par contre 1 remarque sur ton programme : dans ton programme tu repars à chaque fois des Individu qui se trouvent dans le vecteur : donc tu ne mutes pas 7 fois de suite chaque individu, tu mutes 1 fois chaque individus 7 fois.

Repars à chaque fois de la nouvelle liste mélangée, et tu n'auras pas ce problème (d'ailleurs tu devrais utiliser des ArrayList plutôt que des Vector) :

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
public List<Individu> mutation(List<Individu> tabMeilleurs){
 
    // Tableau d'individus mutés
    List<Individu> mutants = new ArrayList<Individu>(tabMeilleurs);
 
    // Selon taux de mutation
    for(int i=0; i<7; i++){
        Collections.shuffle(mutants); // on mélange
 
        for(int positionMI=0; positionMI<mutants.size(); positionMI++) {
 
              Individu individuMute = mutants.get(positionMI).clone();
 
              // muter individuMute...
 
              mutants.set(positionMI, individuMute); // on remplace l'individu par la mutation
 
        }
 
    }
 
    return mutants;
 
}

[Revaroa]

ok merci beaucoup du conseil et pour ton aide.