Blocage d'une procédure

Version imprimable

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:

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"

28/12/2010, 23h34
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.

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:

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:

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 8O

Merci de votre aide d'avance

Citation:

Envoyé par Nasku

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:

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.

29/12/2010, 09h36
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.

Bonjour;

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

Code:

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.

29/12/2010, 11h42
tchize_

c'est pas un blocage alors 8O 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.
29/12/2010, 13h10
Nasku

Merci beaucoup;

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

Merci encore une fois tchize_ !!!!!!!!!:ccool: