Discussion :

[sana_d]

Bonjour à tous,

je résous un problème de recherche opérationnelle comme suit:
1- je lis les paramètres de mon problème test
2- je le résous
3- j'affiche le résultat

En plus je dispose de plusieurs problèmes tests. Donc, ce que je fais:
pour chaque problème test
j'effectue le 1, 2 et 3
fin pour

Lorsque je parcours cette boucle "for", le premier problème test marche bien mais après ça bloque. Sur la console, aucun message d'erreur, ni bug mais absolument rien (un arrêt étrange qui dure longtemps des heures jusqu'à ce que je ferme seule la console !!).

Je reprends le même programme en éliminant la boucle "for" et en commençant directement par le problème test 2 et ça marche bien !

J'ai pensé donc à la mémoire. Mais tout ce que je définis dans la boucle for est censé être détruit tout seul (mes classes ne contiennent aucun pointeur, et sont toutes de la STL et des int, double, string, ...)

Y'a t il quelqu'un qui pourrait m'expliquer ??

Merci beaucoup !

[Bousk]

je vois, je vois... absolument rien.

Blague à part, comment pourrait-on t'aider sans la moindre once de code ???
"je fais une boucle, je fais 3 actions, la première boucle passe, la 2° bloque, si je commence par la 2° action, ça passe"
Ha oui... kamoulox ou 42 !

Mis à part que tu sembles avoir une boucle infinie dans ta "1° action", on va jamais pouvoir t'en dire plus..

[sana_d]

Voici mon code.

Mais juste pour vous dire que je suis pas experte en programmation.
Je génère mes variables de décisions (en les énumérant dans une classe Quarts_Explicites), j'énumère mes contraintes, je fais retourner ce modèle à un solveur Cplex puis je récupère ma solution.

Le code marche bien pour chaque problème test. Donc, je pense qu'il devrait ne contenir aucune erreur et aussi marcher bien dans une boucle for. Pourquoi bloque-t-il alors?
Remarque : il bloque lors de l'énumération des quarts explicites (ce nombre est exponentiellement grand lorsque la taille du problème augmente).

Mais pourquoi alors il peut énumérer tous les quarts explicites pour un premier problème test et ne pas le faire pour le suivant ? J,ai pensé au fait qu'il ne libère pas la mémoire au bout de la première instance. mais une fois de plus, je me demande comment ça pourrait être le cas alors que les destructeurs de mes classes sont appelés à la sortie d'une itération de la boucle "for" ???

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
class Quart_Explicite
{
public:
	int m_debut; 
	vector<int> m_acts; 
	vector<int> m_per_fin; 
public:
	Quart_Explicite() : m_debut(0), m_acts(vector<int>()), m_per_fin(vector<int>()) { }
	Quart_Explicite(int debut, vector<int> acts, vector<int> per_fin) : m_debut(debut), m_acts(acts), m_per_fin(per_fin) { }
 
};
 
class Quarts_Explicites
{
public:
	vector<vector<vector<Quart_Explicite>>> m_elements;
	double m_temps_enumeration;
public:
	Quarts_Explicites() : m_elements(vector<vector<vector<Quart_Explicite>>>()), m_temps_enumeration(0.0) { }
	Quarts_Explicites(vector<vector<vector<Quart_Explicite>>> elements, double temps_enumeration) : m_elements(elements), m_temps_enumeration(temps_enumeration) { }
 
	void set_dimensions(Employes &mes_employes)
	{
		...
	}
 
	void set_days_off(Employes &mes_employes)
	{
		...
	}
 
	void enumerate(TypeQuarts &mes_types_quarts, int jour_operation, Activites &mes_activites, string &my_path)
	{
		... // le problème est ici :cry:
	}
 
	void set_elements(Data &my_data, string &my_path)
	{
		...
	}
};
 
int main
{
	for(unsigned int ins = 0; ins < my_instances.m_elements.size(); ins ++)
	{
		Data my_data;
		my_data.set_elements(my_instances.m_elements[ins].m_path, my_instances.m_elements[ins].m_period_minute);
 
		cout << my_instances.m_elements[ins].m_path << endl;
 
		clock_t start_main = clock(); 
 
		Quarts_Explicites mes_quarts_explicites;
		mes_quarts_explicites.set_elements(my_data, my_instances.m_elements[ins].m_path);
 
		IloEnv env;
 
		Variables mes_variables(env, my_data.m_employes.m_elements.size(), my_data.m_activites.melements.size());
		mes_variables.set_elements(env, mes_quarts_explicites, my_data.m_activites.melements.size(), my_data.m_horizon);
 
		Set_Covering_Model my_set_covering_model(env);
		Call_To_Cplex my_call_to_cplex;
		my_set_covering_model.set_elements(env, my_data,  mes_quarts_explicites, my_instances.m_elements[ins].m_path, my_call_to_cplex, mes_variables);
 
		clock_t end_main = clock(); 
		double temps_main=(end_main - start_main) / (double)CLOCKS_PER_SEC;
 
		env.end();		
 
		my_output.set_elements(my_instances.m_elements[ins], my_call_to_cplex, mes_quarts_explicites, temps_main);
 
		cout << "/************************************************/" << endl;
	}
	return 0;
}

[sana_d]

je vois, je vois... absolument rien.

Blague à part, comment pourrait-on t'aider sans la moindre once de code ???
"je fais une boucle, je fais 3 actions, la première boucle passe, la 2° bloque, si je commence par la 2° action, ça passe"
Ha oui... kamoulox ou 42 !

Mis à part que tu sembles avoir une boucle infinie dans ta "1° action", on va jamais pouvoir t'en dire plus..

Voilà ! je pense que c'est un peu plus clair maintenant. Non?

[JolyLoic]

Voilà ! je pense que c'est un peu plus clair maintenant. Non?

Assez peu en fait... Il y a encore quelques inconnues, notamment dans le moteur que tu utilises et qui mémorise peut-être un état... Visiblement, ton solveur est wrappé dans des classes, mais que font ces classes ? Sont-elles définies par toi ou par les personnes ayant fournies le solveur ?