Discussion :

[Nasku]

Salut à tous !!!

SVP; je suis en train de développer une bibliothèque dédiée au résolution des problème de la programmation linéaire et non-linéaire; bref...

Dans une certaine étape, j'ai une matrice dont je veux fixer les éléments positifs selon la dernière ligne de la matrice comme suit:

Un élément de la colonne j de la dernière ligne de la matrice, je doit lui faire correspondre tous les éléments positifs de la même colonne.

A priori, c'est facile à faire, et j'ai une "Hashtable" pour faire correspondre la colonne et chaque ligne;

J'ai utilisé ce morceau de programme :

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
 
Hashtable<Integer, ArrayList<Integer>> fixePositifElement(DoubleVector c, DoubleMatrix a){
		Hashtable<Integer, ArrayList<Integer>> h = new Hashtable<Integer, ArrayList<Integer>>();
		ArrayList<ArrayList<Integer>> list = new ArrayList<ArrayList<Integer>>();
		ArrayList<Integer> subList = new ArrayList<Integer>();
		ArrayList<Integer> listKey = new ArrayList<Integer>();
		for(int j = 0; j < c.dimension(); j++){
			if(c.getComponent(j) > 0){
				subList = new ArrayList<Integer>();
				for(int i = 0; i < a.rows(); i++){
					if(a.getElement(i, j) > 0){
					subList.add(i);	
					}
				}
				list.add(subList);
				listKey.add(j);
			}
		} 
		for(int i = 0; i < list.size(); i++)
			h.put(listKey.get(i), list.get(i));
                System.out.println(h);
		return h;
	}

Mais quand je le test, l'application se bloque à la dernière ligne; il ne sort pas de l'application sachant que les résultats obtenus à cette étape sont justes.

Merci de votre aide

-----------------------------
Juste une remarque, j'utilise une certaine bibliothèque nommé : Jsci pour gérer les matrices et vecteurs où j'ai les classes :
"DoubleVector" et "DoubleMatrix"

[tchize_]

vous voulez dire que "ça bloque" après le system.out.println? Si oui, regardez du coté de l'appelant de votre méthode, c'est lui qui bloque, pas votre méthode.

[Nasku]

Bonsoir;

Bon, je ne voie pas comment l'appelant peut blocker ma procédure, mais en tous les cas voilà la procédure ou je fait l'appel de ma première procédure:

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
36
37
38
39
40
41
 
public void resolveSimplexe(){
		FormeStandard fs = new FormeStandard(LP);
		DoubleMatrix P = fs.getP();
		DoubleVector C = new DoubleVector(P.columns()-1);
		DoubleMatrix A = new DoubleMatrix(P.rows()-1, P.columns()-1);
		DoubleVector b = new DoubleVector(P.rows()-1);
		boolean bool = true;
		for(int j = 0; j < C.dimension(); j++)
			C.setComponent(j, P.getElement(P.rows()-1, j));
		for(int i = 0; i < A.rows(); i++)
			for(int j = 0; j < A.columns(); j++)
				A.setElement(i, j, P.getElement(i, j));
		for(int i = 0; i < b.dimension(); i++)
			b.setComponent(i, P.getElement(i, P.columns()-1));
		while (bool){
			if(!positifCost(C)){
				System.out.println("J* = {"+J+"} est une base optimale"+
					" et x* = ("+x+") est une solution optimale"+
					"et Z* = "+Z);
				bool = false;
			}
			else {
				if(!positifElement(C, A)){
					System.out.println("Pas de solution optimale");
					bool = false;
				}
				else{ 
                                                   H = fixePositifElement(C, A);
					fixePivot(b, C, A);
					pivotage(r, s, P);
					J = detectNewBase(P);
					for(int i = 0; i < x.dimension(); i++)
						if(J.contains(i))
							x.setComponent(i, P.getElement(i, P.columns()-1)); //Sol. de base
						else x.setComponent(i, 0); //Hors base
					Z = P.getElement(P.rows()-1, P.columns()-1);
				}
			}
		}
	}

La procédure de fixe Pivot est la suivante:

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
 
void fixePivot(DoubleVector b, DoubleVector c, DoubleMatrix a){
		int row = 0, col = 0, val = 0; double min = 0;
 
		for(int j = 0; j < a.columns(); j++){
			if(H.containsKey(j)){
				int i = (H.get(j)).get(0);
				row = i;
				col = j;
				min = b.getComponent(i) / a.getElement(i, j);
				break;
			}
		}
 
		for(int j = 0; j < a.columns(); j++){
			if(H.containsKey(j)){
				for(int i = 0; i < (H.get(j)).size(); i++){
					val = (H.get(j)).get(i);
					if(min > (b.getComponent(val) / a.getElement(val, j))){
						row = val;
						col = j;
						min = b.getComponent(val) / a.getElement(val, j);
					}
				}	
			}
		}
		s = col;
		r = row;
 
	}

Sachant que r(int), s(int) et H(Hashtable) sont des varaibles globales.
Sur ma console, il reste afficher le résultat de l'avant dernière ligne sur la procédure cité déjà avant (fixePositifElement), et il l'affiche sans arrêter, comme si j'ai mis une boucle infini d'affichage de cette instruction sans entrer dans la l'instruction suivante.

N.B.
J'ai essayé de mettre le contenu de fixePositifElement dans fixePivot dans la tête de la procédure, mais la procédure se blocke de la même façon à la dernière ligne en affichant r et s sans arreter

Merci de votre aide d'avance

[tchize_]

Bonsoir;

Bon, je ne voie pas comment l'appelant peut blocker ma procédure,

En java on parle de méthode Et ce n'est pas l'appelant qui bloque la méthode, c'est l'appelant qui bloque *après* le retour de la méthode, nuance.

Pourriez vous remplacer votre boucle while par ceci et nous dire ce qui sort, on y verra un peu plus clair.

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
		while (bool){
			if(!positifCost(C)){
				System.out.println("J* = {"+J+"} est une base optimale"+
					" et x* = ("+x+") est une solution optimale"+
					"et Z* = "+Z);
				bool = false;
			}
			else {
				if(!positifElement(C, A)){
					System.out.println("Pas de solution optimale");
					bool = false;
				}
				else{ 
                                        System.out.println("appel fixePositifElement");
                                                   H = fixePositifElement(C, A);
                                        System.out.println("appel fixePivot");
					fixePivot(b, C, A);
                                        System.out.println("appel pivotage");
					pivotage(r, s, P);
                                        System.out.println("appel detectNewBase");
					J = detectNewBase(P);
                                        System.out.println("boucle");
					for(int i = 0; i < x.dimension(); i++)
						if(J.contains(i)){
                                                        System.out.println("appel getElement en boucle");
							x.setComponent(i, P.getElement(i, P.columns()-1)); //Sol. de base1
}
						else x.setComponent(i, 0); //Hors base
 
                                        System.out.println("appel getElement");
					Z = P.getElement(P.rows()-1, P.columns()-1);
				}
			}
		}

Ou, a défaut, si vous êtes dans un IDE, lancer votre programme en debug, faites du pas à pas dans la boucle et, quand c'est "bloqué", le mettre en pause et nous donner son stacktrace.

[dinobogan]

Sauf erreur de ma part, tu n'as pas donné le code ou tu affiches r et s.
Sinon, de manière générale, il est préférable d'éviter les variables globales lorsque c'est uniquement pour faciliter la communication d'info entre plusieurs méthodes. Puisque ce ne sont pas des propriétés de l'objet, elles n'ont rien à faire dans la classe.
Tu devrais plutôt utiliser une mini classe qui ne contient que 3 données membres : r, s et H. Une même instance est transmise en paramètre des méthodes qui en ont besoin. Elles peuvent ainsi modifier les données. Tu limiteras les effets de bords et la relecture de code sera un peu plus facile.

[Nasku]

Bonjour;

J'ai fait comme vous avez proposé, et j'ai eu sur la console une chose qui m'a étonné:

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
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
 
appel getElement en boucle
appel getElement
appel fixePositifElement
appel fixePivot
appel pivotage
appel detectNewBase
appel boucle
appel getElement en boucle
appel getElement
appel fixePositifElement
appel fixePivot
appel pivotage
appel detectNewBase
appel boucle
appel getElement en boucle
appel getElement
appel fixePositifElement
appel fixePivot
appel pivotage
appel detectNewBase
appel boucle
appel getElement en boucle
appel getElement
appel fixePositifElement
appel fixePivot
appel pivotage
appel detectNewBase
appel boucle
appel getElement en boucle
appel getElement
appel fixePositifElement
appel fixePivot
appel pivotage
appel detectNewBase
appel boucle
appel getElement en boucle
appel getElement
appel fixePositifElement
appel fixePivot
appel pivotage
appel detectNewBase
appel boucle
appel getElement en boucle
appel getElement
appel fixePositifElement
appel fixePivot
appel pivotage
appel detectNewBase
appel boucle
appel getElement en boucle
appel getElement
appel fixePositifElement
appel fixePivot
appel pivotage
appel detectNewBase
appel boucle
appel getElement en boucle
appel getElement
appel fixePositifElement
appel fixePivot
appel pivotage
appel detectNewBase
appel boucle
appel getElement en boucle
appel getElement
appel fixePositifElement
appel fixePivot
appel pivotage
appel detectNewBase
appel boucle
appel getElement en boucle
appel getElement
appel fixePositifElement
appel fixePivot
appel pivotage
appel detectNewBase
appel boucle
appel getElement en boucle
appel getElement
appel fixePositifElement
appel fixePivot
appel pivotage
appel detectNewBase
appel boucle
appel getElement en boucle
appel getElement
appel fixePositifElement
appel fixePivot
appel pivotage
appel detectNewBase
appel boucle
appel getElement en boucle
appel getElement
appel fixePositifElement
appel fixePivot
appel pivotage
appel detectNewBase
appel boucle
appel getElement en boucle
appel getElement
appel fixePositifElement
appel fixePivot
appel pivotage
appel detectNewBase
appel boucle
appel getElement en boucle
appel getElement
appel fixePositifElement
appel fixePivot
appel pivotage
appel detectNewBase
appel boucle
appel getElement en boucle
appel getElement
appel fixePositifElement
appel fixePivot
appel pivotage
appel detectNewBase
appel boucle
appel getElement en boucle
         .
         .

et c'est loin d'être fini, et la vérité je n'ai rien compris.

N.B.
Juste pour votre information; quand je dis qu'il blocke, je ne veux pas dire qu'il y a une erreur , mais il ne cesse d'afficher la même instruction.

[tchize_]

c'est pas un blocage alors C'est une boucle infinie, donc votre condition d'arrêt de la boucle (bool à false) n'est jamais remplie. Revoyez votre algorithme, sa condition d'arrêt n'est jamais remplie! positifCost(C) ne deviens jamais faux et positifElement(C, A) ne deviens jamais faux non plus.

[Nasku]

Merci beaucoup;

Tu as raison, j'ai oublié l'update de mes paramètres locaux (C, A, b).

Merci encore une fois tchize_ !!!!!!!!!