From 26ac55bb6c752411563aaefe32702473d2bf674d Mon Sep 17 00:00:00 2001
From: klorel <manuel.jean.ruiz@gmail.com>
Date: Mon, 4 Feb 2013 09:48:46 +0100
Subject: [PATCH 01/14] CREATION DE LA BRANCHE PROJET ZZ

---
 CMakeLists.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 51f8e43..8f9bb4d 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -44,7 +44,7 @@ ENDIF( WITH_PROF )
 
 ADD_SUBDIRECTORY(clustering)
 ADD_SUBDIRECTORY(programs)
-# ADD_SUBDIRECTORY(projet_zz)
+ADD_SUBDIRECTORY(projet_zz)
 
 IF( WITH_TESTS )
     ENABLE_TESTING()

From 371ee3bab6f1370d2f6147ebe0c78070908aa79e Mon Sep 17 00:00:00 2001
From: rogelja <vrogelja@gmail.com>
Date: Mon, 4 Feb 2013 18:30:48 +0100
Subject: [PATCH 02/14] Update projet_zz/main.cpp

---
 projet_zz/main.cpp | 65 ++++++++++++++++++++++++++++++++++++----------
 1 file changed, 51 insertions(+), 14 deletions(-)

diff --git a/projet_zz/main.cpp b/projet_zz/main.cpp
index 53c008b..5e0d242 100644
--- a/projet_zz/main.cpp
+++ b/projet_zz/main.cpp
@@ -1,7 +1,7 @@
 /*
  * main.cpp
  *
- *  Created on: 15 déc. 2012
+ *  Created on: 15 déc. 2012
  *      Author: manuel
  */
 
@@ -19,6 +19,19 @@
 #include "projet_zz/MultiLevelKMInstance.h"
 #include <random>
 
+
+#ifdef _WIN64
+	#define CMD_SUPP 0
+#elif _WIN32
+	#define CMD_SUPP 0
+#elif __APPLE__
+	#define CMD_SUPP  1
+#elif __linux
+	#define CMD_SUPP  1
+#endif
+
+
+
 void usage() {
 	std::cout << "Available instances : \n";
 	for (size_t i(0); i < AvailableInstances::SIZE; ++i) {
@@ -43,30 +56,54 @@ int main(int argc, char ** argv) {
 		size_t const i(atoi(argv[1]));
 		size_t const k(atoi(argv[2]));
 		if (i < AvailableInstances::SIZE) {
-			// écrire dans un fichier les résultats : moyenné sur tous les problèmes
-			// vérifier la cohérence on ne peut détériorer la solution de départ
+			// écrire dans un fichier les résultats : moyenné sur tous les problèmes
+			// vérifier la cohérence on ne peut détériorer la solution de départ
 			// KMEANS : KMEANS classique
 			// on souhaite se comparer au KMEANS normal 
-			// - % temps total dans le KMEANS (sans construction des instances intermédiaires)
-			// - % nombre d'itération en plus KMEANS
-			// - % temps moyen des itérations
-			// - l'écart par rapport au KMEANS normal
+			// - % temps total dans le KMEANS (sans construction des instances intermédiaires)
+			// - % nombre d'itération en plus KMEANS
+			// - % temps moyen des itérations
+			// - l'écart par rapport au KMEANS normal
 
 			AvailableInstances id(static_cast<AvailableInstances>(i));
 			RegisteredInstance instance(id);
 			instance.out();
-			MultiLevelAlgo algo(instance, k);
 			
-			algo.buildMultiLevelData(0,0);
+			
+			MultiLevelAlgo algo(instance, k);
+
+
+			algo.buildMultiLevelData(20*k,20);
 			Partition start(instance.nbObs(), k);
-			// génération du point de départ
+			// génération du point de départ
 			algo.getStartPoint(start);
-			// ----
-			size_t level(0);
+			algo.setStartPoint(start);
+			// ----s
+			size_t level=0;
 			algo.setStep(1);
-			while(true){
+			bool fini = false;
+			int nbfichier=1;
+
+			if (CMD_SUPP == 0)
+				system("rmdir /S /Q Run");
+			else
+				system("rm -r Run");
+			system(" mkdir Run");
+			while(!fini){
+
+
+
+				
+				
+				algo.setfic("./Run/run"+ std::to_string(nbfichier)+".txt");
+
+				algo.initfichier();
 				algo.setStartLevel(level);
-				algo.launch(20*k);
+				algo.launch();
+				if (level ==5)
+					fini=true;
+				level = 5;
+				nbfichier++;
 			}
 		}
 	}

From 2e9176b3a1831385b7904f17f8642a7667be1f4f Mon Sep 17 00:00:00 2001
From: rogelja <vrogelja@gmail.com>
Date: Mon, 4 Feb 2013 18:32:35 +0100
Subject: [PATCH 03/14] Update projet_zz/MultiLevelKMInstance.cpp

---
 projet_zz/MultiLevelKMInstance.cpp | 167 ++++++++++++++++++++++-------
 1 file changed, 126 insertions(+), 41 deletions(-)

diff --git a/projet_zz/MultiLevelKMInstance.cpp b/projet_zz/MultiLevelKMInstance.cpp
index bc515b5..8fe78fb 100644
--- a/projet_zz/MultiLevelKMInstance.cpp
+++ b/projet_zz/MultiLevelKMInstance.cpp
@@ -1,7 +1,7 @@
 /*
 * MultiLevelKMInstance.cpp
 *
-*  Created on: 15 déc. 2012
+*  Created on: 15 déc. 2012
 *      Author: manuel
 */
 
@@ -9,15 +9,21 @@
 #include "../src/HMeans.hpp"
 #include "../src/KMAlgo.hpp"
 #include "../src/Timer.hpp"
-MultiLevelAlgo::MultiLevelAlgo(KMInstance const & instance, size_t k) :
-	_instance(instance), _input(_instance, k) {
-}
+#include <iostream>
+#include <fstream>
+
+
+MultiLevelAlgo::MultiLevelAlgo(KMInstance const & instance, size_t k,Partition startPoint) :
+	_instance(instance), _input(_instance, k),_startPoint(startPoint) {}
+
+
+
 MultiLevelAlgo::~MultiLevelAlgo() {
 	for (auto & ptr : _multiLevelConstraints)
 		delete ptr;
 }
 void MultiLevelAlgo::buildInstance(size_t level, KMInstance & instance,Aggregations & aggregations) {
-	// on enlève toutes les contraintes
+	// on enlève toutes les contraintes
 	_instance.mustLinks().clear();
 	_instance.cannotLinks().clear();
 	for (size_t i(0); i < level; ++i) {
@@ -27,25 +33,30 @@ void MultiLevelAlgo::buildInstance(size_t level, KMInstance & instance,Aggregati
 	}
 	// construit les infos de correspondances entre les instances
 	_instance.buildMustLink(aggregations);
-	// construit l'instance aggrégée
+	// construit l'instance aggrégée
 	instance = KMInstance(_instance, aggregations);
 }
-// @brief construit une suite de problèmes agrégés en agrégeant nbNodesMax noeuds par niveau et en produisant des graphes avec au plus nbNodes noeuds
-// @param nbNodes    : limite pour le graph le plus agrégé 
-// @param nbNodesMax : limite max de noeuds agrégé par étape
-void MultiLevelAlgo::buildMultiLevelData(size_t nbNodes) {
+
+
+// @brief construit une suite de problèmes agrégés en agrégeant nbNodesMax noeuds par niveau et en produisant des graphes avec au plus nbNodes noeuds
+// @param nbNodes    : limite pour le graph le plus agrégé 
+// @param nbNodesMax : limite max de noeuds agrégé par étape
+void MultiLevelAlgo::buildMultiLevelData(size_t nbNodes,size_t nbNodesMax) {
 
 	KMPartition partition(_instance, _instance.nbObs());
-	// on crée les singletons
+	// on crée les singletons
 	for(size_t i(0); i<_instance.nbObs(); ++i)
 		partition.shift(i,i);
 
 	while(partition.nbLabels() > nbNodes ){
 		IndexedList used(partition.usedLabels());
-		// définit un nouveau niveau
+		// définit un nouveau niveau
 		_multiLevelConstraints.push_back(new KMConstraints(_input.nbObs()));
 
-		while(!used.empty()){
+		size_t compteur=0;
+
+
+		while(!used.empty() && compteur < nbNodesMax){
 			size_t const m = used.pop_random();
 			if( !used.empty()){
 				// calculer la distance de ce centre avec les autres
@@ -57,49 +68,51 @@ void MultiLevelAlgo::buildMultiLevelData(size_t nbNodes) {
 				size_t const c(neighbor.begin()->second);
 				_multiLevelConstraints.back()->newCtr(*partition.observations(m).begin(),*partition.observations(c).begin());
 				partition.fusion(m,c);				
-				// si plusieurs plusieurs plus pret : tirer au hazard (aprés)
+				// si plusieurs plusieurs plus pret : tirer au hazard (aprés)
 				used.erase(c);
+				compteur++;
 			}
 		};
-		// ajouter les contraintes associée à ce niveau
+		// ajouter les contraintes associée à ce niveau
 	};
 }
 //
 // _step: 
-// _startLevel : niveau de départ pour le raffinement
-// _startPoint : (attention doit être compatible avec le niveau de plus agrégé)
+// _startLevel : niveau de départ pour le raffinement
+// _startPoint : (attention doit être compatible avec le niveau de plus agrégé)
 void MultiLevelAlgo::refine() {
-	// lancer le KMEANS sur chaque niveau en partant du plus élevé (celui qui contient le moins de noeuds)
-	// à chaque fois on initialise avec le niveau précédent (sauf le premier!)
-	// Pour le premier faire un appel à random(0);
+	// lancer le KMEANS sur chaque niveau en partant du plus élevé (celui qui contient le moins de noeuds)
+	// à chaque fois on initialise avec le niveau précédent (sauf le premier!)
+	// Pour le premier faire un appel à random(0);
 	KMInstance instance;
 	Aggregations aggregations;	
 	Timer timer;
 	// pour chaque level
-	for (size_t level(0); level <= _multiLevelConstraints.size(); ++level) {
-		// ! on parcours à l'envers
+	for (size_t level(_startLevel); level <= _multiLevelConstraints.size(); level+= _step) {
+		// ! on parcours à l'envers
 		buildInstance(_multiLevelConstraints.size() - level, instance,aggregations);
 		KMInput input(instance, _input.maxNbLabels());
 		// initialiser cette input avec la solkution courante
-		// attention il faut utiliser aggregation pour faire les neodus agrégés et la solution courante
-		if(level==0){
-			input.random(0);
-			for (size_t i(0); i < _input.nbObs(); ++i) {
-				_input.shiftForced(i, input.label(aggregations.newIds[i]));
-			}			
-		}else{
+		// attention il faut utiliser aggregation pour faire les neodus agrégés et la solution courante
+		
+		if(level!=_startLevel){	
 			for (size_t i(0); i < _input.nbObs(); ++i) {
 				input.shiftForced(aggregations.newIds[i], _input.label(i));
 			}
 		}
+		
 		// on lance l'algo
-		HMeans<true>()(input);
-		std::cout << std::setw(10)<<_multiLevelConstraints.size() - level;
-		std::cout << std::setw(10)<<input.ite();
-		std::cout << std::setw(10)<<timer.elapsed();
-		std::cout << std::setw(20)<<input.cost();
-		std::cout << std::endl;
+		 HMeans<true>()(input);
+
+
 		
+		writefichier("Niveau de rafinement : " + std::to_string(_multiLevelConstraints.size() - level));
+		writefichier("Nombre d'itération par étape : " + std::to_string(input.ite()));
+		writefichier("Temps écoulé : " + std::to_string(timer.elapsed()));
+		writefichier("Valeur du coût : " + std::to_string(input.cost()));
+		writefichier("\n");
+
+
 		// suavegarde de la solution
 		input.computeCenters();
 		for (size_t i(0); i < _input.nbObs(); ++i) {
@@ -109,13 +122,32 @@ void MultiLevelAlgo::refine() {
 			input.shiftForced(aggregations.newIds[i], _input.label(i));
 		}
 	}
+	if(_startLevel>_multiLevelConstraints.size())
+	{
+		// on lance l'algo
+		 HMeans<true>()(_input);
+
+
+		
+		writefichier("Niveau de rafinement : " + std::to_string(0));
+		writefichier("Nombre d'itération par étape : " + std::to_string(_input.ite()));
+		writefichier("Temps écoulé : " + std::to_string(timer.elapsed()));
+		writefichier("Valeur du coût : " + std::to_string(_input.cost()));
+		writefichier("\n");
+
+
+		// suavegarde de la solution
+		_input.computeCenters();
+	}
 }
-// @brief lance l'algorithme multi-niveau à partir d'une suite d'agrégation, d'une partition de départ et d'un niveau de départ et avec un pas donné
+// @brief lance l'algorithme multi-niveau à partir d'une suite d'agrégation, d'une partition de départ et d'un niveau de départ et avec un pas donné
 // _step: 
-// _startLevel : niveau de départ pour le raffinement
-// _startPoint : (attention doit être compatible avec le niveau de plus agrégé)
-void MultiLevelAlgo::launch(size_t nbNodes) {
-	// initialisation au point de départ
+// _startLevel : niveau de départ pour le raffinement
+// _startPoint : (attention doit être compatible avec le niveau de plus agrégé)
+
+
+void MultiLevelAlgo::launch() {
+	// initialisation au point de départ
 	for (size_t i(0); i < _input.nbObs(); ++i) {
 		_input.shiftForced(i, _startPoint.label(i));
 	}		
@@ -124,7 +156,7 @@ void MultiLevelAlgo::launch(size_t nbNodes) {
 
 }
 
-void MultiLevelAlgo::getStartPoint( Partition & point){
+void MultiLevelAlgo::getStartPoint( Partition  & point){
 	KMInstance instance;
 	Aggregations aggregations;	
 	buildInstance(_multiLevelConstraints.size(), instance,aggregations);
@@ -134,3 +166,56 @@ void MultiLevelAlgo::getStartPoint( Partition & point){
 		point.shift(i, input.label(aggregations.newIds[i]));
 	}	
 }
+
+
+void MultiLevelAlgo::setStartLevel( size_t level){
+	_startLevel=level;
+}
+
+
+
+void MultiLevelAlgo::setStep(size_t step){
+	_step=step;
+}
+
+
+void MultiLevelAlgo::setStartPoint( Partition  & point){
+	_startPoint = point;
+}
+
+
+void MultiLevelAlgo::initfichier()
+{
+
+
+				// Creation du fichier ou écrasement
+				
+					std::ofstream _fichier(_fic.c_str(), std::ios::out |std::ios::trunc);
+
+				 /* --- Cas d'erreur d'ouverture du fichier --- */
+				if ( !_fichier ){
+					  std::cerr << "Erreur de creation du fichier des résultats" << std::endl;
+					  exit(1);
+				}
+
+
+
+}
+
+
+
+
+
+void MultiLevelAlgo::writefichier(std::string str)
+{
+	std::ofstream fichier(_fic.c_str(), std::ios::out |std::ios::app);
+	fichier << std::setw(10) << str << std::endl;
+	fichier.close();
+
+}
+
+void MultiLevelAlgo::setfic(std::string fic)
+{
+	_fic = fic;
+
+}

From f71e60c3807c6af36d5ee4ba7a81ac013cac78c0 Mon Sep 17 00:00:00 2001
From: rogelja <vrogelja@gmail.com>
Date: Mon, 4 Feb 2013 18:34:04 +0100
Subject: [PATCH 04/14] Update projet_zz/MultiLevelKMInstance.h

---
 projet_zz/MultiLevelKMInstance.h | 24 +++++++++++++++---------
 1 file changed, 15 insertions(+), 9 deletions(-)

diff --git a/projet_zz/MultiLevelKMInstance.h b/projet_zz/MultiLevelKMInstance.h
index 955c460..915f2e9 100644
--- a/projet_zz/MultiLevelKMInstance.h
+++ b/projet_zz/MultiLevelKMInstance.h
@@ -1,7 +1,7 @@
 /*
  * MultiLevelKMInstance.h
  *
- *  Created on: 15 déc. 2012
+ *  Created on: 15 déc. 2012
  *      Author: manuel
  */
 
@@ -15,38 +15,44 @@
 class MultiLevelAlgo {
 public:
 public:
-	MultiLevelAlgo(KMInstance const &, size_t k);
+	MultiLevelAlgo(KMInstance const &, size_t k,Partition _startPoint=0);
 	virtual ~MultiLevelAlgo();
 public:
 	// pour lancer les kmmeans
 	void buildInstance(size_t level, KMInstance &, Aggregations &);
 	//
-	void launch(size_t nbNodes);
+	void launch();
 	void refine();
 
 public:
-	// on agrège jusqu'à ce que l'on ait nbNodes noeuds dans le problème équivalent
+	// on agrège jusqu'à ce que l'on ait nbNodes noeuds dans le problème équivalent
 	// nbNodesMax = 0 pas de limite
-	void buildMultiLevelData(size_t nbNodes, size_t nbNodesMax = 0);
+	void buildMultiLevelData(size_t nbNodes, size_t nbNodesMax = 50);
 
 	// initialisation
 	void setStartLevel( size_t );
-	void setStartPoint( Partition const &);
+	void getStartPoint( Partition  &);
 	void setStep(size_t );
 
-	void getStartPoint( Partition & );
+	void setStartPoint( Partition  & );
 	
+	void initfichier( );
+	void writefichier(std::string );
+	void setfic(std::string);
+
 	//Double getDistance(SuperNoeud const & i, SuperNoeud const & j) const;
 public:
-	// l'instance de départ
+	// l'instance de départ
 	KMInstance _instance;
 	KMInput _input;
-	// les contraintes de chaque niveau : incrémentalement
+	// les contraintes de chaque niveau : incrémentalement
 	std::vector<KMConstraints *> _multiLevelConstraints;
 
 	size_t _startLevel;
 	size_t _step;
 	Partition _startPoint;
+	std::string _fic;
+
 
 	Number _totalKMtimer;
 	size_t _totlKMite;

From c426966a3882766c9931af94c3ce574e6e09e6c5 Mon Sep 17 00:00:00 2001
From: Manuel Ruiz <manuel.jean.ruiz@gmail.com>
Date: Mon, 4 Feb 2013 19:58:12 +0100
Subject: [PATCH 05/14] A DEBUGGER LES JEUNES !

---
 projet_zz/MultiLevelKMInstance.cpp | 91 +++++++++---------------------
 projet_zz/MultiLevelKMInstance.h   | 14 ++---
 projet_zz/main.cpp                 | 63 ++++++---------------
 3 files changed, 49 insertions(+), 119 deletions(-)

diff --git a/projet_zz/MultiLevelKMInstance.cpp b/projet_zz/MultiLevelKMInstance.cpp
index 8fe78fb..d36a22d 100644
--- a/projet_zz/MultiLevelKMInstance.cpp
+++ b/projet_zz/MultiLevelKMInstance.cpp
@@ -14,7 +14,10 @@
 
 
 MultiLevelAlgo::MultiLevelAlgo(KMInstance const & instance, size_t k,Partition startPoint) :
-	_instance(instance), _input(_instance, k),_startPoint(startPoint) {}
+	_instance(instance), _input(_instance, k),_startPoint(startPoint) {
+		// par defaut sur la sortie standard.
+		setOut();
+}
 
 
 
@@ -49,13 +52,12 @@ void MultiLevelAlgo::buildMultiLevelData(size_t nbNodes,size_t nbNodesMax) {
 		partition.shift(i,i);
 
 	while(partition.nbLabels() > nbNodes ){
+		std::cout << "partition.nbLabels() : "<<partition.nbLabels()<<std::endl;
 		IndexedList used(partition.usedLabels());
-		// définit un nouveau niveau
+		// definit un nouveau niveau
 		_multiLevelConstraints.push_back(new KMConstraints(_input.nbObs()));
-
+		//
 		size_t compteur=0;
-
-
 		while(!used.empty() && compteur < nbNodesMax){
 			size_t const m = used.pop_random();
 			if( !used.empty()){
@@ -94,24 +96,21 @@ void MultiLevelAlgo::refine() {
 		KMInput input(instance, _input.maxNbLabels());
 		// initialiser cette input avec la solkution courante
 		// attention il faut utiliser aggregation pour faire les neodus agrégés et la solution courante
-		
+
 		if(level!=_startLevel){	
 			for (size_t i(0); i < _input.nbObs(); ++i) {
 				input.shiftForced(aggregations.newIds[i], _input.label(i));
 			}
 		}
-		
-		// on lance l'algo
-		 HMeans<true>()(input);
-
 
-		
-		writefichier("Niveau de rafinement : " + std::to_string(_multiLevelConstraints.size() - level));
-		writefichier("Nombre d'itération par étape : " + std::to_string(input.ite()));
-		writefichier("Temps écoulé : " + std::to_string(timer.elapsed()));
-		writefichier("Valeur du coût : " + std::to_string(input.cost()));
-		writefichier("\n");
+		// on lance l'algo
+		HMeans<true>()(input);
 
+		out()<<"Niveau de rafinement          : " <<_multiLevelConstraints.size() - level;
+		out()<<"Nombre d'itération par etape : " <<input.ite();
+		out()<<"Temps ecoule                  : " <<timer.elapsed();
+		out()<<"Valeur du cout                : " <<input.cost();
+		out()<<std::endl;
 
 		// suavegarde de la solution
 		input.computeCenters();
@@ -125,17 +124,12 @@ void MultiLevelAlgo::refine() {
 	if(_startLevel>_multiLevelConstraints.size())
 	{
 		// on lance l'algo
-		 HMeans<true>()(_input);
-
-
-		
-		writefichier("Niveau de rafinement : " + std::to_string(0));
-		writefichier("Nombre d'itération par étape : " + std::to_string(_input.ite()));
-		writefichier("Temps écoulé : " + std::to_string(timer.elapsed()));
-		writefichier("Valeur du coût : " + std::to_string(_input.cost()));
-		writefichier("\n");
-
-
+		HMeans<true>()(_input);
+		out()<<"Niveau de rafinement         : " <<0;
+		out()<<"Nombre d'iteration par etape : " <<_input.ite();
+		out()<<"Temps ecoule                 : " <<timer.elapsed();
+		out()<<"Valeur du cout               : " <<_input.cost();
+		out()<<std::endl;
 		// suavegarde de la solution
 		_input.computeCenters();
 	}
@@ -145,7 +139,9 @@ void MultiLevelAlgo::refine() {
 // _startLevel : niveau de départ pour le raffinement
 // _startPoint : (attention doit être compatible avec le niveau de plus agrégé)
 
-
+void MultiLevelAlgo::setOut(std::ostream & stream){
+	_out = &stream;
+}
 void MultiLevelAlgo::launch() {
 	// initialisation au point de départ
 	for (size_t i(0); i < _input.nbObs(); ++i) {
@@ -183,39 +179,6 @@ void MultiLevelAlgo::setStartPoint( Partition  & point){
 	_startPoint = point;
 }
 
-
-void MultiLevelAlgo::initfichier()
-{
-
-
-				// Creation du fichier ou écrasement
-				
-					std::ofstream _fichier(_fic.c_str(), std::ios::out |std::ios::trunc);
-
-				 /* --- Cas d'erreur d'ouverture du fichier --- */
-				if ( !_fichier ){
-					  std::cerr << "Erreur de creation du fichier des résultats" << std::endl;
-					  exit(1);
-				}
-
-
-
-}
-
-
-
-
-
-void MultiLevelAlgo::writefichier(std::string str)
-{
-	std::ofstream fichier(_fic.c_str(), std::ios::out |std::ios::app);
-	fichier << std::setw(10) << str << std::endl;
-	fichier.close();
-
-}
-
-void MultiLevelAlgo::setfic(std::string fic)
-{
-	_fic = fic;
-
-}
+std::ostream & MultiLevelAlgo::out(){
+	return *_out;
+}
\ No newline at end of file
diff --git a/projet_zz/MultiLevelKMInstance.h b/projet_zz/MultiLevelKMInstance.h
index 915f2e9..b926267 100644
--- a/projet_zz/MultiLevelKMInstance.h
+++ b/projet_zz/MultiLevelKMInstance.h
@@ -35,25 +35,21 @@ class MultiLevelAlgo {
 	void setStep(size_t );
 
 	void setStartPoint( Partition  & );
-	
-	void initfichier( );
-	void writefichier(std::string );
-	void setfic(std::string);
-
+	void setOut(std::ostream & =std::cout);
 	//Double getDistance(SuperNoeud const & i, SuperNoeud const & j) const;
+
+	std::ostream & out();
 public:
 	// l'instance de départ
 	KMInstance _instance;
 	KMInput _input;
-	// les contraintes de chaque niveau : incrémentalement
+	// les contraintes de chaque niveau : incrementalement
 	std::vector<KMConstraints *> _multiLevelConstraints;
 
 	size_t _startLevel;
 	size_t _step;
 	Partition _startPoint;
-	std::string _fic;
-
-
+	std::ostream * _out;
 	Number _totalKMtimer;
 	size_t _totlKMite;
 
diff --git a/projet_zz/main.cpp b/projet_zz/main.cpp
index 5e0d242..5117033 100644
--- a/projet_zz/main.cpp
+++ b/projet_zz/main.cpp
@@ -19,19 +19,6 @@
 #include "projet_zz/MultiLevelKMInstance.h"
 #include <random>
 
-
-#ifdef _WIN64
-	#define CMD_SUPP 0
-#elif _WIN32
-	#define CMD_SUPP 0
-#elif __APPLE__
-	#define CMD_SUPP  1
-#elif __linux
-	#define CMD_SUPP  1
-#endif
-
-
-
 void usage() {
 	std::cout << "Available instances : \n";
 	for (size_t i(0); i < AvailableInstances::SIZE; ++i) {
@@ -56,55 +43,39 @@ int main(int argc, char ** argv) {
 		size_t const i(atoi(argv[1]));
 		size_t const k(atoi(argv[2]));
 		if (i < AvailableInstances::SIZE) {
-			// écrire dans un fichier les résultats : moyenné sur tous les problèmes
-			// vérifier la cohérence on ne peut détériorer la solution de départ
+			// Ecrire dans un fichier les resultats : moyenne sur tous les problemes
+			// verifier la coherence on ne peut deteriorer la solution de depart
 			// KMEANS : KMEANS classique
 			// on souhaite se comparer au KMEANS normal 
-			// - % temps total dans le KMEANS (sans construction des instances intermédiaires)
-			// - % nombre d'itération en plus KMEANS
-			// - % temps moyen des itérations
-			// - l'écart par rapport au KMEANS normal
+			// - % temps total dans le KMEANS (sans construction des instances intermediaires)
+			// - % nombre d'iteration en plus KMEANS
+			// - % temps moyen des iterations
+			// - l'ecart par rapport au KMEANS normal
 
 			AvailableInstances id(static_cast<AvailableInstances>(i));
 			RegisteredInstance instance(id);
-			instance.out();
-			
-			
+			instance.out();			
 			MultiLevelAlgo algo(instance, k);
-
-
-			algo.buildMultiLevelData(20*k,20);
+			algo.buildMultiLevelData(20*k,500);
 			Partition start(instance.nbObs(), k);
-			// génération du point de départ
+			// generation du point de depart
 			algo.getStartPoint(start);
-			algo.setStartPoint(start);
 			// ----s
-			size_t level=0;
+			size_t level(0);
 			algo.setStep(1);
-			bool fini = false;
+			bool done(false);
 			int nbfichier=1;
-
-			if (CMD_SUPP == 0)
-				system("rmdir /S /Q Run");
-			else
-				system("rm -r Run");
-			system(" mkdir Run");
-			while(!fini){
-
-
-
-				
-				
-				algo.setfic("./Run/run"+ std::to_string(nbfichier)+".txt");
-
-				algo.initfichier();
+			std::ofstream file("output.log");
+			algo.setOut(file);
+			while(!done){					
 				algo.setStartLevel(level);
 				algo.launch();
-				if (level ==5)
-					fini=true;
+				if (level == 5)
+					done=true;
 				level = 5;
 				nbfichier++;
 			}
+			file.close();
 		}
 	}
 	system("pause");

From 48508b678fd75f403d51e669b5d77bf5e7fc401a Mon Sep 17 00:00:00 2001
From: klorel <manuel.jean.ruiz@gmail.com>
Date: Tue, 5 Feb 2013 13:26:04 +0100
Subject: [PATCH 06/14] UPDATE TRAVAIL DE VINCENT

---
 MultiLevelKMInstance.cpp                | 113 ---------
 projet_zz/MultiLevelKMInstance.cpp      | 105 ++++++--
 projet_zz/MultiLevelKMInstance.cpp.orig | 121 ----------
 projet_zz/MultiLevelKMInstance.h        |  22 +-
 projet_zz/main.cpp                      |  74 ++++--
 projet_zz/output.log                    | 308 ++++++++++++++++++++++++
 projet_zz/projetfichier.zip             | Bin 0 -> 5310 bytes
 7 files changed, 456 insertions(+), 287 deletions(-)
 delete mode 100644 MultiLevelKMInstance.cpp
 delete mode 100644 projet_zz/MultiLevelKMInstance.cpp.orig
 create mode 100644 projet_zz/output.log
 create mode 100644 projet_zz/projetfichier.zip

diff --git a/MultiLevelKMInstance.cpp b/MultiLevelKMInstance.cpp
deleted file mode 100644
index 33bb367..0000000
--- a/MultiLevelKMInstance.cpp
+++ /dev/null
@@ -1,113 +0,0 @@
-/*
-* MultiLevelKMInstance.cpp
-*
-*  Created on: 15 déc. 2012
-*      Author: manuel
-*/
-
-#include "../projet_zz/MultiLevelKMInstance.h"
-#include "../src/HMeans.hpp"
-#include "../src/KMAlgo.hpp"
-#include "../src/Timer.hpp"
-MultiLevelAlgo::MultiLevelAlgo(KMInstance const & instance, size_t k) :
-  _instance(instance), _input(_instance, k) {
-}
-MultiLevelAlgo::~MultiLevelAlgo() {
-	for (auto & ptr : _multiLevelConstraints)
-		delete ptr;
-}
-void MultiLevelAlgo::buildInstance(size_t level, KMInstance & instance,Aggregations & aggregations) {
-	// on enlève toutes les contraintes
-	_instance.mustLinks().clear();
-	_instance.cannotLinks().clear();
-	for (size_t i(0); i < level; ++i) {
-		for (auto const & ctr : *_multiLevelConstraints[i]) {
-			_instance.addMustLink(ctr.first, ctr.second);
-		}
-	}
-	// construit les infos de correspondances entre les instances
-	_instance.buildMustLink(aggregations);
-	// construit l'instance aggrégée
-	instance = KMInstance(_instance, aggregations);
-}
-// nbNodes : le nombre de noeuds minimal dans le graph de plus bas niveau
-// critère défini pour ajouter les noeuds : voisin le plus proche
-void MultiLevelAlgo::buildMultiLevelData(size_t nbNodes) {
-
-	KMPartition partition(_instance, _instance.nbObs());
-	// on crée les singletons
-	for(size_t i(0); i<_instance.nbObs(); i++)
-		partition.shift(i,i);
-
-	while(partition.nbLabels() > nbNodes ){
-		IndexedList used(partition.usedLabels());
-		// définit un nouveau niveau
-		_multiLevelConstraints.push_back(new KMConstraints(_input.nbObs()));
-
-		while(!used.empty()){
-			size_t const m = used.pop_random();
-			if( !used.empty()){
-				// calculer la distance de ce centre avec les autres
-				std::multimap<Double, size_t> neighbor;
-				for(auto const & c : partition.usedLabels()){
-					if ( m != c)
-						neighbor.insert( std::make_pair(partition.getDistanceCenter(m,c) , c));
-				}
-				size_t const c(neighbor.begin()->second);
-				_multiLevelConstraints.back()->newCtr(*partition.observations(m).begin(),*partition.observations(c).begin());
-				partition.fusion(m,c);				
-				// si plusieurs plusieurs plus pret : tirer au hazard (aprés)
-				used.erase(c);
-			}
-		};
-		// ajouter les contraintes associée à ce niveau
-	};
-}
-//
-void MultiLevelAlgo::refine() {
-	// lancer le KMEANS sur chaque niveau en partant du plus élevé (celui qui contient le moins de noeuds)
-	// à chaque fois on initialise avec le niveau précédent (sauf le premier!)
-	// Pour le premier faire un appel à random(0);
-	KMInstance instance;
-	Aggregations aggregations;	
-	Timer timer;
-	// pour chaque level
-	for (size_t level(0); level <= _multiLevelConstraints.size(); ++level) {
-		// ! on parcours à l'envers
-		buildInstance(_multiLevelConstraints.size() - level, instance,aggregations);
-		KMInput input(instance, _input.maxNbLabels());
-		// initialiser cette input avec la solkution courante
-		// attention il faut utiliser aggregation pour faire les neodus agrégés et la solution courante
-		if(level==0){
-			input.random(0);
-			for (size_t i(0); i < _input.nbObs(); ++i) {
-				_input.shiftForced(i, input.label(aggregations.newIds[i]));
-			}			
-		}else{
-			for (size_t i(0); i < _input.nbObs(); ++i) {
-				input.shiftForced(aggregations.newIds[i], _input.label(i));
-			}
-		}
-		// on lance l'algo
-		HMeans<false>()(input);
-		std::cout << std::setw(10)<<_multiLevelConstraints.size() - level;
-		std::cout << std::setw(10)<<input.ite();
-		std::cout << std::setw(10)<<timer.elapsed();
-		std::cout << std::setw(20)<<input.cost();
-		std::cout << std::endl;
-		// suavegarde de la solution
-		input.computeCenters();
-		for (size_t i(0); i < _input.nbObs(); ++i) {
-			_input.shiftForced(i, input.label(aggregations.newIds[i]));
-		}
-		for (size_t i(0); i < _input.nbObs(); ++i) {
-			input.shiftForced(aggregations.newIds[i], _input.label(i));
-		}
-	}
-}
-void MultiLevelAlgo::launch(size_t nbNodes) {
-	buildMultiLevelData(nbNodes);
-
-	refine();
-
-}
diff --git a/projet_zz/MultiLevelKMInstance.cpp b/projet_zz/MultiLevelKMInstance.cpp
index bc515b5..1df53f7 100644
--- a/projet_zz/MultiLevelKMInstance.cpp
+++ b/projet_zz/MultiLevelKMInstance.cpp
@@ -9,9 +9,18 @@
 #include "../src/HMeans.hpp"
 #include "../src/KMAlgo.hpp"
 #include "../src/Timer.hpp"
-MultiLevelAlgo::MultiLevelAlgo(KMInstance const & instance, size_t k) :
-	_instance(instance), _input(_instance, k) {
+#include <iostream>
+#include <fstream>
+
+
+MultiLevelAlgo::MultiLevelAlgo(KMInstance const & instance, size_t k,Partition startPoint) :
+	_instance(instance), _input(_instance, k),_startPoint(startPoint) {
+		// par defaut sur la sortie standard.
+		setOut();
 }
+
+
+
 MultiLevelAlgo::~MultiLevelAlgo() {
 	for (auto & ptr : _multiLevelConstraints)
 		delete ptr;
@@ -30,10 +39,12 @@ void MultiLevelAlgo::buildInstance(size_t level, KMInstance & instance,Aggregati
 	// construit l'instance aggrégée
 	instance = KMInstance(_instance, aggregations);
 }
+
+
 // @brief construit une suite de problèmes agrégés en agrégeant nbNodesMax noeuds par niveau et en produisant des graphes avec au plus nbNodes noeuds
 // @param nbNodes    : limite pour le graph le plus agrégé 
 // @param nbNodesMax : limite max de noeuds agrégé par étape
-void MultiLevelAlgo::buildMultiLevelData(size_t nbNodes) {
+void MultiLevelAlgo::buildMultiLevelData(size_t nbNodes,size_t nbNodesMax) {
 
 	KMPartition partition(_instance, _instance.nbObs());
 	// on crée les singletons
@@ -41,11 +52,13 @@ void MultiLevelAlgo::buildMultiLevelData(size_t nbNodes) {
 		partition.shift(i,i);
 
 	while(partition.nbLabels() > nbNodes ){
+		std::cout << "partition.nbLabels() : "<<partition.nbLabels()<<std::endl;
 		IndexedList used(partition.usedLabels());
-		// définit un nouveau niveau
+		// definit un nouveau niveau
 		_multiLevelConstraints.push_back(new KMConstraints(_input.nbObs()));
-
-		while(!used.empty()){
+		//
+		size_t compteur=0;
+		while(!used.empty() && compteur < nbNodesMax){
 			size_t const m = used.pop_random();
 			if( !used.empty()){
 				// calculer la distance de ce centre avec les autres
@@ -59,9 +72,10 @@ void MultiLevelAlgo::buildMultiLevelData(size_t nbNodes) {
 				partition.fusion(m,c);				
 				// si plusieurs plusieurs plus pret : tirer au hazard (aprés)
 				used.erase(c);
+				compteur++;
 			}
 		};
-		// ajouter les contraintes associée à ce niveau
+		// ajouter les contraintes associée à ce niveau
 	};
 }
 //
@@ -70,36 +84,35 @@ void MultiLevelAlgo::buildMultiLevelData(size_t nbNodes) {
 // _startPoint : (attention doit être compatible avec le niveau de plus agrégé)
 void MultiLevelAlgo::refine() {
 	// lancer le KMEANS sur chaque niveau en partant du plus élevé (celui qui contient le moins de noeuds)
-	// à chaque fois on initialise avec le niveau précédent (sauf le premier!)
-	// Pour le premier faire un appel à random(0);
+	// à chaque fois on initialise avec le niveau précédent (sauf le premier!)
+	// Pour le premier faire un appel à random(0);
 	KMInstance instance;
 	Aggregations aggregations;	
 	Timer timer;
 	// pour chaque level
-	for (size_t level(0); level <= _multiLevelConstraints.size(); ++level) {
-		// ! on parcours à l'envers
+	size_t level;
+	for ( level=_startLevel; level <= _multiLevelConstraints.size(); level+= _step) {
+		// ! on parcours à l'envers
 		buildInstance(_multiLevelConstraints.size() - level, instance,aggregations);
 		KMInput input(instance, _input.maxNbLabels());
 		// initialiser cette input avec la solkution courante
 		// attention il faut utiliser aggregation pour faire les neodus agrégés et la solution courante
-		if(level==0){
-			input.random(0);
-			for (size_t i(0); i < _input.nbObs(); ++i) {
-				_input.shiftForced(i, input.label(aggregations.newIds[i]));
-			}			
-		}else{
+
+		if(level!=_startLevel){	
 			for (size_t i(0); i < _input.nbObs(); ++i) {
 				input.shiftForced(aggregations.newIds[i], _input.label(i));
 			}
 		}
+
 		// on lance l'algo
 		HMeans<true>()(input);
-		std::cout << std::setw(10)<<_multiLevelConstraints.size() - level;
-		std::cout << std::setw(10)<<input.ite();
-		std::cout << std::setw(10)<<timer.elapsed();
-		std::cout << std::setw(20)<<input.cost();
-		std::cout << std::endl;
-		
+
+		out()<<"Niveau de rafinement          : " <<_multiLevelConstraints.size() - level<<std::endl;
+		out()<<"Nombre d'itération par etape : " <<input.ite()<<std::endl;
+		out()<<"Temps ecoule                  : " <<timer.elapsed()<<std::endl;
+		out()<<"Valeur du cout                : " <<input.cost()<<std::endl;
+		out()<<std::endl;
+
 		// suavegarde de la solution
 		input.computeCenters();
 		for (size_t i(0); i < _input.nbObs(); ++i) {
@@ -109,12 +122,32 @@ void MultiLevelAlgo::refine() {
 			input.shiftForced(aggregations.newIds[i], _input.label(i));
 		}
 	}
+
+
+	// pb ici traitement du dernier niveau
+
+
+	/*if(level>_multiLevelConstraints.size())
+	{
+		// on lance l'algo
+		HMeans<true>()(_input);
+		out()<<"Niveau de rafinement         : " <<0<<std::endl;
+		out()<<"Nombre d'iteration par etape : " <<_input.ite()<<std::endl;
+		out()<<"Temps ecoule                 : " <<timer.elapsed()<<std::endl;
+		out()<<"Valeur du cout               : " <<_input.cost()<<std::endl;
+		out()<<std::endl;
+
+	}*/
 }
-// @brief lance l'algorithme multi-niveau à partir d'une suite d'agrégation, d'une partition de départ et d'un niveau de départ et avec un pas donné
+// @brief lance l'algorithme multi-niveau à partir d'une suite d'agrégation, d'une partition de départ et d'un niveau de départ et avec un pas donné
 // _step: 
 // _startLevel : niveau de départ pour le raffinement
 // _startPoint : (attention doit être compatible avec le niveau de plus agrégé)
-void MultiLevelAlgo::launch(size_t nbNodes) {
+
+void MultiLevelAlgo::setOut(std::ostream & stream){
+	_out = &stream;
+}
+void MultiLevelAlgo::launch() {
 	// initialisation au point de départ
 	for (size_t i(0); i < _input.nbObs(); ++i) {
 		_input.shiftForced(i, _startPoint.label(i));
@@ -124,7 +157,7 @@ void MultiLevelAlgo::launch(size_t nbNodes) {
 
 }
 
-void MultiLevelAlgo::getStartPoint( Partition & point){
+void MultiLevelAlgo::getStartPoint( Partition  & point){
 	KMInstance instance;
 	Aggregations aggregations;	
 	buildInstance(_multiLevelConstraints.size(), instance,aggregations);
@@ -134,3 +167,23 @@ void MultiLevelAlgo::getStartPoint( Partition & point){
 		point.shift(i, input.label(aggregations.newIds[i]));
 	}	
 }
+
+
+void MultiLevelAlgo::setStartLevel( size_t level){
+	_startLevel=level;
+}
+
+
+
+void MultiLevelAlgo::setStep(size_t step){
+	_step=step;
+}
+
+
+void MultiLevelAlgo::setStartPoint( Partition  & point){
+	_startPoint = point;
+}
+
+std::ostream & MultiLevelAlgo::out(){
+	return *_out;
+}
\ No newline at end of file
diff --git a/projet_zz/MultiLevelKMInstance.cpp.orig b/projet_zz/MultiLevelKMInstance.cpp.orig
deleted file mode 100644
index e4f86db..0000000
--- a/projet_zz/MultiLevelKMInstance.cpp.orig
+++ /dev/null
@@ -1,121 +0,0 @@
-/*
-* MultiLevelKMInstance.cpp
-*
-*  Created on: 15 déc. 2012
-*      Author: manuel
-*/
-
-#include "../projet_zz/MultiLevelKMInstance.h"
-#include "../src/HMeans.hpp"
-#include "../src/KMAlgo.hpp"
-#include "../src/Timer.hpp"
-MultiLevelAlgo::MultiLevelAlgo(KMInstance const & instance, size_t k) :
-	_instance(instance), _input(_instance, k) {
-}
-MultiLevelAlgo::~MultiLevelAlgo() {
-	for (auto & ptr : _multiLevelConstraints)
-		delete ptr;
-}
-void MultiLevelAlgo::buildInstance(size_t level, KMInstance & instance,Aggregations & aggregations) {
-	// on enlève toutes les contraintes
-	_instance.mustLinks().clear();
-	_instance.cannotLinks().clear();
-	for (size_t i(0); i < level; ++i) {
-		for (auto const & ctr : *_multiLevelConstraints[i]) {
-			_instance.addMustLink(ctr.first, ctr.second);
-		}
-	}
-	// construit les infos de correspondances entre les instances
-	_instance.buildMustLink(aggregations);
-	// construit l'instance aggrégée
-	instance = KMInstance(_instance, aggregations);
-}
-// nbNodes : le nombre de noeuds minimal dans le graph de plus bas niveau
-// critère défini pour ajouter les noeuds : voisin le plus proche
-void MultiLevelAlgo::buildMultiLevelData(size_t nbNodes) {
-
-	KMPartition partition(_instance, _instance.nbObs());
-	// on crée les singletons
-	for(size_t i(0); i<_instance.nbObs(); i)
-		partition.shift(i,i);
-
-	while(partition.nbLabels() > nbNodes ){
-		IndexedList used(partition.usedLabels());
-		// définit un nouveau niveau
-		_multiLevelConstraints.push_back(new KMConstraints(_input.nbObs()));
-<<<<<<< HEAD
-		size_t const step(10);
-		for(size_t q(1);q<step; ++q){ 
-			_multiLevelConstraints.back()->newCtr(step*p, step*p+q);
-		}
-	}
-=======
-
-		while(!used.empty()){
-			size_t const m = used.pop_random();
-			if( !used.empty()){
-				// calculer la distance de ce centre avec les autres
-				std::multimap<Double, size_t> neighbor;
-				for(auto const & c : partition.usedLabels()){
-					if ( m != c)
-						neighbor.insert( std::make_pair(partition.getDistanceCenter(m,c) , c));
-				}
-				size_t const c(neighbor.begin()->second);
-				_multiLevelConstraints.back()->newCtr(*partition.observations(m).begin(),*partition.observations(c).begin());
-				partition.fusion(m,c);				
-				// si plusieurs plusieurs plus pret : tirer au hazard (aprés)
-				used.erase(c);
-			}
-		};
-		// ajouter les contraintes associée à ce niveau
-	};
->>>>>>> 7d3b1f782e16f3eb6528661b07e5b6f0dc323357
-}
-//
-void MultiLevelAlgo::refine() {
-	// lancer le KMEANS sur chaque niveau en partant du plus élevé (celui qui contient le moins de noeuds)
-	// à chaque fois on initialise avec le niveau précédent (sauf le premier!)
-	// Pour le premier faire un appel à random(0);
-	KMInstance instance;
-	Aggregations aggregations;	
-	Timer timer;
-	// pour chaque level
-	for (size_t level(0); level <= _multiLevelConstraints.size(); ++level) {
-		// ! on parcours à l'envers
-		buildInstance(_multiLevelConstraints.size() - level, instance,aggregations);
-		KMInput input(instance, _input.maxNbLabels());
-		// initialiser cette input avec la solkution courante
-		// attention il faut utiliser aggregation pour faire les neodus agrégés et la solution courante
-		if(level==0){
-			input.random(0);
-			for (size_t i(0); i < _input.nbObs(); ++i) {
-				_input.shiftForced(i, input.label(aggregations.newIds[i]));
-			}			
-		}else{
-			for (size_t i(0); i < _input.nbObs(); ++i) {
-				input.shiftForced(aggregations.newIds[i], _input.label(i));
-			}
-		}
-		// on lance l'algo
-		HMeans<true>()(input);
-		std::cout << std::setw(10)<<_multiLevelConstraints.size() - level;
-		std::cout << std::setw(10)<<input.ite();
-		std::cout << std::setw(10)<<timer.elapsed();
-		std::cout << std::setw(20)<<input.cost();
-		std::cout << std::endl;
-		// suavegarde de la solution
-		input.computeCenters();
-		for (size_t i(0); i < _input.nbObs(); ++i) {
-			_input.shiftForced(i, input.label(aggregations.newIds[i]));
-		}
-		for (size_t i(0); i < _input.nbObs(); ++i) {
-			input.shiftForced(aggregations.newIds[i], _input.label(i));
-		}
-	}
-}
-void MultiLevelAlgo::launch(size_t nbNodes) {
-	buildMultiLevelData(nbNodes);
-
-	refine();
-
-}
diff --git a/projet_zz/MultiLevelKMInstance.h b/projet_zz/MultiLevelKMInstance.h
index 955c460..e3cc081 100644
--- a/projet_zz/MultiLevelKMInstance.h
+++ b/projet_zz/MultiLevelKMInstance.h
@@ -15,42 +15,44 @@
 class MultiLevelAlgo {
 public:
 public:
-	MultiLevelAlgo(KMInstance const &, size_t k);
+	MultiLevelAlgo(KMInstance const &, size_t k,Partition _startPoint=0);
 	virtual ~MultiLevelAlgo();
 public:
 	// pour lancer les kmmeans
 	void buildInstance(size_t level, KMInstance &, Aggregations &);
 	//
-	void launch(size_t nbNodes);
+	void launch();
 	void refine();
 
 public:
-	// on agrège jusqu'à ce que l'on ait nbNodes noeuds dans le problème équivalent
+	// on agrège jusqu'à ce que l'on ait nbNodes noeuds dans le problème équivalent
 	// nbNodesMax = 0 pas de limite
-	void buildMultiLevelData(size_t nbNodes, size_t nbNodesMax = 0);
+	void buildMultiLevelData(size_t nbNodes, size_t nbNodesMax = 50);
 
 	// initialisation
 	void setStartLevel( size_t );
-	void setStartPoint( Partition const &);
+	void getStartPoint( Partition  &);
 	void setStep(size_t );
 
-	void getStartPoint( Partition & );
-	
+	void setStartPoint( Partition  & );
+	void setOut(std::ostream & =std::cout);
 	//Double getDistance(SuperNoeud const & i, SuperNoeud const & j) const;
+
+	std::ostream & out();
 public:
 	// l'instance de départ
 	KMInstance _instance;
 	KMInput _input;
-	// les contraintes de chaque niveau : incrémentalement
+	// les contraintes de chaque niveau : incrementalement
 	std::vector<KMConstraints *> _multiLevelConstraints;
 
 	size_t _startLevel;
 	size_t _step;
 	Partition _startPoint;
-
+	std::ostream * _out;
 	Number _totalKMtimer;
 	size_t _totlKMite;
 
 };
 
-#endif /* MULTILEVELKMINSTANCE_H_ */
+#endif /* MULTILEVELKMINSTANCE_H_ */
\ No newline at end of file
diff --git a/projet_zz/main.cpp b/projet_zz/main.cpp
index 53c008b..bd723d5 100644
--- a/projet_zz/main.cpp
+++ b/projet_zz/main.cpp
@@ -43,33 +43,73 @@ int main(int argc, char ** argv) {
 		size_t const i(atoi(argv[1]));
 		size_t const k(atoi(argv[2]));
 		if (i < AvailableInstances::SIZE) {
-			// écrire dans un fichier les résultats : moyenné sur tous les problèmes
-			// vérifier la cohérence on ne peut détériorer la solution de départ
+			// Ecrire dans un fichier les resultats : moyenne sur tous les problemes
+			// verifier la coherence on ne peut deteriorer la solution de depart
 			// KMEANS : KMEANS classique
 			// on souhaite se comparer au KMEANS normal 
-			// - % temps total dans le KMEANS (sans construction des instances intermédiaires)
-			// - % nombre d'itération en plus KMEANS
-			// - % temps moyen des itérations
-			// - l'écart par rapport au KMEANS normal
+			// - % temps total dans le KMEANS (sans construction des instances intermediaires)
+			// - % nombre d'iteration en plus KMEANS
+			// - % temps moyen des iterations
+			// - l'ecart par rapport au KMEANS normal
 
 			AvailableInstances id(static_cast<AvailableInstances>(i));
 			RegisteredInstance instance(id);
-			instance.out();
+			instance.out();			
 			MultiLevelAlgo algo(instance, k);
-			
-			algo.buildMultiLevelData(0,0);
+			algo.buildMultiLevelData(20*k,200);
 			Partition start(instance.nbObs(), k);
-			// génération du point de départ
+			// generation du point de depart
 			algo.getStartPoint(start);
-			// ----
-			size_t level(0);
-			algo.setStep(1);
-			while(true){
-				algo.setStartLevel(level);
-				algo.launch(20*k);
+            
+			// ----s
+			size_t level;
+			bool done(false);
+			int nbfichier=1;
+			std::ofstream file("output.log");
+			algo.setOut(file);
+
+			// pour nos tests on va créer une liste sur le premier niveau a traiter
+			// et une deuxieme pour les sauts.
+
+			std::vector<size_t> list_level;
+			std::vector<size_t> list_saut;
+
+
+			list_saut.push_back(1);
+			list_saut.push_back(2);
+			list_saut.push_back(4);
+			list_saut.push_back(8);
+			
+			while(!list_saut.empty()){
+				size_t saut=list_saut.back();
+				algo.out()<< "_________________________________________________________" << std::endl;
+				algo.setStep(saut);
+				list_saut.pop_back();
+				algo.out()<< "Pas de  : " << saut << std::endl;
+	
+
+				list_level.push_back(0);
+				list_level.push_back(2);
+				list_level.push_back(4);
+				list_level.push_back(8);
+				list_level.push_back(16);
+				while(!list_level.empty()){
+				
+					algo.out()<< "_________________________________________________________" << std::endl;
+					level=list_level.back();
+					list_level.pop_back();
+					algo.out()<< "level d'initialisation : " << level << std::endl;
+
+					algo.setStartPoint(start);
+					algo.setStartLevel(level);
+					algo.launch();
+					
+					
+				}
 			}
+			file.close();
 		}
 	}
 	system("pause");
 	return 0; 
-}
+}
\ No newline at end of file
diff --git a/projet_zz/output.log b/projet_zz/output.log
new file mode 100644
index 0000000..4929e7a
--- /dev/null
+++ b/projet_zz/output.log
@@ -0,0 +1,308 @@
+_________________________________________________________
+Pas de  : 8
+_________________________________________________________
+level d'initialisation : 16
+_________________________________________________________
+level d'initialisation : 8
+Niveau de rafinement          : 1
+Nombre d'itération par etape : 20
+Temps ecoule                  : 3.4202
+Valeur du cout                : 1.22197e+007
+
+_________________________________________________________
+level d'initialisation : 4
+Niveau de rafinement          : 5
+Nombre d'itération par etape : 9
+Temps ecoule                  : 1.92311
+Valeur du cout                : 1.56251e+007
+
+_________________________________________________________
+level d'initialisation : 2
+Niveau de rafinement          : 7
+Nombre d'itération par etape : 23
+Temps ecoule                  : 3.10018
+Valeur du cout                : 1.52134e+007
+
+_________________________________________________________
+level d'initialisation : 0
+Niveau de rafinement          : 9
+Nombre d'itération par etape : 28
+Temps ecoule                  : 2.41714
+Valeur du cout                : 1.41478e+007
+
+Niveau de rafinement          : 1
+Nombre d'itération par etape : 19
+Temps ecoule                  : 6.63738
+Valeur du cout                : 7.58921e+006
+
+_________________________________________________________
+Pas de  : 4
+_________________________________________________________
+level d'initialisation : 16
+_________________________________________________________
+level d'initialisation : 8
+Niveau de rafinement          : 1
+Nombre d'itération par etape : 20
+Temps ecoule                  : 5.2443
+Valeur du cout                : 1.22197e+007
+
+_________________________________________________________
+level d'initialisation : 4
+Niveau de rafinement          : 5
+Nombre d'itération par etape : 9
+Temps ecoule                  : 1.6861
+Valeur du cout                : 1.56251e+007
+
+Niveau de rafinement          : 1
+Nombre d'itération par etape : 14
+Temps ecoule                  : 5.44331
+Valeur du cout                : 1.04796e+007
+
+_________________________________________________________
+level d'initialisation : 2
+Niveau de rafinement          : 7
+Nombre d'itération par etape : 23
+Temps ecoule                  : 2.96717
+Valeur du cout                : 1.52134e+007
+
+Niveau de rafinement          : 3
+Nombre d'itération par etape : 30
+Temps ecoule                  : 7.37642
+Valeur du cout                : 1.00593e+007
+
+_________________________________________________________
+level d'initialisation : 0
+Niveau de rafinement          : 9
+Nombre d'itération par etape : 28
+Temps ecoule                  : 1.91511
+Valeur du cout                : 1.41478e+007
+
+Niveau de rafinement          : 5
+Nombre d'itération par etape : 19
+Temps ecoule                  : 4.53826
+Valeur du cout                : 9.14873e+006
+
+Niveau de rafinement          : 1
+Nombre d'itération par etape : 4
+Temps ecoule                  : 6.51337
+Valeur du cout                : 7.57413e+006
+
+_________________________________________________________
+Pas de  : 2
+_________________________________________________________
+level d'initialisation : 16
+_________________________________________________________
+level d'initialisation : 8
+Niveau de rafinement          : 1
+Nombre d'itération par etape : 20
+Temps ecoule                  : 4.97328
+Valeur du cout                : 1.22197e+007
+
+_________________________________________________________
+level d'initialisation : 4
+Niveau de rafinement          : 5
+Nombre d'itération par etape : 9
+Temps ecoule                  : 1.89211
+Valeur du cout                : 1.56251e+007
+
+Niveau de rafinement          : 3
+Nombre d'itération par etape : 12
+Temps ecoule                  : 4.42425
+Valeur du cout                : 1.12004e+007
+
+Niveau de rafinement          : 1
+Nombre d'itération par etape : 4
+Temps ecoule                  : 6.46337
+Valeur du cout                : 1.04806e+007
+
+_________________________________________________________
+level d'initialisation : 2
+Niveau de rafinement          : 7
+Nombre d'itération par etape : 23
+Temps ecoule                  : 2.77616
+Valeur du cout                : 1.52134e+007
+
+Niveau de rafinement          : 5
+Nombre d'itération par etape : 18
+Temps ecoule                  : 5.80633
+Valeur du cout                : 1.13224e+007
+
+Niveau de rafinement          : 3
+Nombre d'itération par etape : 5
+Temps ecoule                  : 7.55843
+Valeur du cout                : 1.00595e+007
+
+Niveau de rafinement          : 1
+Nombre d'itération par etape : 25
+Temps ecoule                  : 12.2407
+Valeur du cout                : 8.41864e+006
+
+_________________________________________________________
+level d'initialisation : 0
+Niveau de rafinement          : 9
+Nombre d'itération par etape : 28
+Temps ecoule                  : 2.57615
+Valeur du cout                : 1.41478e+007
+
+Niveau de rafinement          : 7
+Nombre d'itération par etape : 19
+Temps ecoule                  : 4.90828
+Valeur du cout                : 1.0691e+007
+
+Niveau de rafinement          : 5
+Nombre d'itération par etape : 15
+Temps ecoule                  : 7.09141
+Valeur du cout                : 9.1349e+006
+
+Niveau de rafinement          : 3
+Nombre d'itération par etape : 6
+Temps ecoule                  : 8.7565
+Valeur du cout                : 8.09781e+006
+
+Niveau de rafinement          : 1
+Nombre d'itération par etape : 4
+Temps ecoule                  : 10.5926
+Valeur du cout                : 7.57449e+006
+
+_________________________________________________________
+Pas de  : 1
+_________________________________________________________
+level d'initialisation : 16
+_________________________________________________________
+level d'initialisation : 8
+Niveau de rafinement          : 1
+Nombre d'itération par etape : 20
+Temps ecoule                  : 5.02029
+Valeur du cout                : 1.22197e+007
+
+Niveau de rafinement          : 0
+Nombre d'itération par etape : 3
+Temps ecoule                  : 7.37142
+Valeur du cout                : 1.22148e+007
+
+_________________________________________________________
+level d'initialisation : 4
+Niveau de rafinement          : 5
+Nombre d'itération par etape : 9
+Temps ecoule                  : 1.87311
+Valeur du cout                : 1.56251e+007
+
+Niveau de rafinement          : 4
+Nombre d'itération par etape : 12
+Temps ecoule                  : 4.38725
+Valeur du cout                : 1.18409e+007
+
+Niveau de rafinement          : 3
+Nombre d'itération par etape : 6
+Temps ecoule                  : 6.07735
+Valeur du cout                : 1.12102e+007
+
+Niveau de rafinement          : 2
+Nombre d'itération par etape : 7
+Temps ecoule                  : 7.77344
+Valeur du cout                : 1.07468e+007
+
+Niveau de rafinement          : 1
+Nombre d'itération par etape : 3
+Temps ecoule                  : 9.18453
+Valeur du cout                : 1.04857e+007
+
+Niveau de rafinement          : 0
+Nombre d'itération par etape : 3
+Temps ecoule                  : 10.9056
+Valeur du cout                : 1.04801e+007
+
+_________________________________________________________
+level d'initialisation : 2
+Niveau de rafinement          : 7
+Nombre d'itération par etape : 23
+Temps ecoule                  : 3.16318
+Valeur du cout                : 1.52134e+007
+
+Niveau de rafinement          : 6
+Nombre d'itération par etape : 18
+Temps ecoule                  : 5.52332
+Valeur du cout                : 1.20818e+007
+
+Niveau de rafinement          : 5
+Nombre d'itération par etape : 5
+Temps ecoule                  : 6.81839
+Valeur du cout                : 1.13227e+007
+
+Niveau de rafinement          : 4
+Nombre d'itération par etape : 25
+Temps ecoule                  : 9.71056
+Valeur du cout                : 9.56189e+006
+
+Niveau de rafinement          : 3
+Nombre d'itération par etape : 16
+Temps ecoule                  : 12.0777
+Valeur du cout                : 8.83561e+006
+
+Niveau de rafinement          : 2
+Nombre d'itération par etape : 6
+Temps ecoule                  : 13.5308
+Valeur du cout                : 8.46981e+006
+
+Niveau de rafinement          : 1
+Nombre d'itération par etape : 4
+Temps ecoule                  : 15.1799
+Valeur du cout                : 8.27049e+006
+
+Niveau de rafinement          : 0
+Nombre d'itération par etape : 2
+Temps ecoule                  : 16.647
+Valeur du cout                : 8.2675e+006
+
+_________________________________________________________
+level d'initialisation : 0
+Niveau de rafinement          : 9
+Nombre d'itération par etape : 28
+Temps ecoule                  : 2.87316
+Valeur du cout                : 1.41478e+007
+
+Niveau de rafinement          : 8
+Nombre d'itération par etape : 20
+Temps ecoule                  : 4.75627
+Valeur du cout                : 1.16611e+007
+
+Niveau de rafinement          : 7
+Nombre d'itération par etape : 9
+Temps ecoule                  : 6.09835
+Valeur du cout                : 1.06859e+007
+
+Niveau de rafinement          : 6
+Nombre d'itération par etape : 16
+Temps ecoule                  : 7.85645
+Valeur du cout                : 9.7392e+006
+
+Niveau de rafinement          : 5
+Nombre d'itération par etape : 15
+Temps ecoule                  : 9.96857
+Valeur du cout                : 9.13508e+006
+
+Niveau de rafinement          : 4
+Nombre d'itération par etape : 5
+Temps ecoule                  : 11.3516
+Valeur du cout                : 8.60787e+006
+
+Niveau de rafinement          : 3
+Nombre d'itération par etape : 6
+Temps ecoule                  : 12.9787
+Valeur du cout                : 8.09854e+006
+
+Niveau de rafinement          : 2
+Nombre d'itération par etape : 5
+Temps ecoule                  : 14.7168
+Valeur du cout                : 7.75297e+006
+
+Niveau de rafinement          : 1
+Nombre d'itération par etape : 5
+Temps ecoule                  : 16.63
+Valeur du cout                : 7.57437e+006
+
+Niveau de rafinement          : 0
+Nombre d'itération par etape : 3
+Temps ecoule                  : 18.279
+Valeur du cout                : 7.56795e+006
+
diff --git a/projet_zz/projetfichier.zip b/projet_zz/projetfichier.zip
new file mode 100644
index 0000000000000000000000000000000000000000..ac22c76ce4e45891afd0d9f3cbc5365b9f526147
GIT binary patch
literal 5310
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

literal 0
HcmV?d00001


From 7253b5dce055a278c99a51068ce3b34a5883c69e Mon Sep 17 00:00:00 2001
From: klorel <manuel.jean.ruiz@gmail.com>
Date: Tue, 5 Feb 2013 14:13:47 +0100
Subject: [PATCH 07/14] OK POUR VINCENT ET LUCAS

---
 projet_zz/MultiLevelKMInstance.cpp | 40 +++++++++++----------
 projet_zz/MultiLevelKMInstance.h   | 25 +++++++++++--
 projet_zz/main.cpp                 | 56 +++++++-----------------------
 3 files changed, 57 insertions(+), 64 deletions(-)

diff --git a/projet_zz/MultiLevelKMInstance.cpp b/projet_zz/MultiLevelKMInstance.cpp
index 24ffc34..8e0777f 100644
--- a/projet_zz/MultiLevelKMInstance.cpp
+++ b/projet_zz/MultiLevelKMInstance.cpp
@@ -44,7 +44,7 @@ void MultiLevelAlgo::buildInstance(size_t level, KMInstance & instance,Aggregati
 // @brief construit une suite de problèmes agrégés en agrégeant nbNodesMax noeuds par niveau et en produisant des graphes avec au plus nbNodes noeuds
 // @param nbNodes    : limite pour le graph le plus agrégé 
 // @param nbNodesMax : limite max de noeuds agrégé par étape
-void MultiLevelAlgo::buildMultiLevelData(size_t nbNodes,size_t nbNodesMax) {
+void MultiLevelAlgo::buildMultiLevelData(double nbNodes,double nbNodesMax) {
 
 	KMPartition partition(_instance, _instance.nbObs());
 	// on crée les singletons
@@ -77,6 +77,9 @@ void MultiLevelAlgo::buildMultiLevelData(size_t nbNodes,size_t nbNodesMax) {
 		};
 		// ajouter les contraintes associée à ce niveau
 	};
+	std::cout << "nbNodes     "<<nbNodes <<std::endl;
+	std::cout << "nbNodesMax  "<<nbNodesMax <<std::endl;
+	std::cout << "Built       "<<nbLevels() << " aggregation levels"<<std::endl;
 }
 //
 // _step: 
@@ -90,37 +93,30 @@ void MultiLevelAlgo::refine() {
 	Aggregations aggregations;	
 	Timer timer;
 	// pour chaque level
-	size_t level;
-	for ( level=_startLevel; level <= _multiLevelConstraints.size(); level+= _step) {
+	for ( size_t level(_startLevel); level <= _multiLevelConstraints.size(); level+= _step) {
 		// ! on parcours à l'envers
 		buildInstance(_multiLevelConstraints.size() - level, instance,aggregations);
+		timer.restart();
 		KMInput input(instance, _input.maxNbLabels());
 		// initialiser cette input avec la solkution courante
 		// attention il faut utiliser aggregation pour faire les neodus agrégés et la solution courante
 
-		if(level!=_startLevel){	
-			for (size_t i(0); i < _input.nbObs(); ++i) {
-				input.shiftForced(aggregations.newIds[i], _input.label(i));
-			}
+		for (size_t i(0); i < _input.nbObs(); ++i) {
+			input.shiftForced(aggregations.newIds[i], _input.label(i));
 		}
 
+
 		// on lance l'algo
 		HMeans<true>()(input);
-
-		out()<<"Niveau de rafinement          : " <<_multiLevelConstraints.size() - level<<std::endl;
-		out()<<"Nombre d'itération par etape : " <<input.ite()<<std::endl;
-		out()<<"Temps ecoule                  : " <<timer.elapsed()<<std::endl;
-		out()<<"Valeur du cout                : " <<input.cost()<<std::endl;
-		out()<<std::endl;
-
+		// on stocke les stats
+		
 		// suavegarde de la solution
 		input.computeCenters();
 		for (size_t i(0); i < _input.nbObs(); ++i) {
 			_input.shiftForced(i, input.label(aggregations.newIds[i]));
 		}
-		for (size_t i(0); i < _input.nbObs(); ++i) {
-			input.shiftForced(aggregations.newIds[i], _input.label(i));
-		}
+		// attention à la fin car on souhaite compter le temps des deux boucles au dessus
+		_stats[ level] = MultiLevelAlgoStat( level, input.ite(), timer.elapsed(), input.cost());
 	}
 
 
@@ -148,6 +144,9 @@ void MultiLevelAlgo::setOut(std::ostream & stream){
 	_out = &stream;
 }
 void MultiLevelAlgo::launch() {
+	_stats.clear();
+	std::cout << "Step  : "<<_step		<< std::endl;
+	std::cout << "Level : "<<_startLevel<< std::endl;
 	// initialisation au point de départ
 	for (size_t i(0); i < _input.nbObs(); ++i) {
 		_input.shiftForced(i, _startPoint.label(i));
@@ -156,7 +155,9 @@ void MultiLevelAlgo::launch() {
 	refine();
 
 }
-
+size_t MultiLevelAlgo::nbLevels()const{
+	return _multiLevelConstraints.size();
+}
 void MultiLevelAlgo::getStartPoint( Partition  & point){
 	KMInstance instance;
 	Aggregations aggregations;	
@@ -186,4 +187,7 @@ void MultiLevelAlgo::setStartPoint( Partition  & point){
 
 std::ostream & MultiLevelAlgo::out(){
 	return *_out;
+}
+MultiLevelAlgoStats const & MultiLevelAlgo::stats()const{
+	return _stats;
 }
\ No newline at end of file
diff --git a/projet_zz/MultiLevelKMInstance.h b/projet_zz/MultiLevelKMInstance.h
index 807ca93..db9a100 100644
--- a/projet_zz/MultiLevelKMInstance.h
+++ b/projet_zz/MultiLevelKMInstance.h
@@ -12,6 +12,24 @@
 #include "../src/KMInstance.hpp"
 #include "../src/KMInput.hpp"
 
+
+class MultiLevelAlgoStat{
+public:
+	size_t _level;
+	size_t _ite;
+	double _time;
+	double _cost;
+	MultiLevelAlgoStat(){}
+	MultiLevelAlgoStat(size_t l, size_t i, double t, double c)
+		:_level(l)
+		,_ite(i)
+		,_time(t)
+		,_cost(c){
+	}
+
+};
+
+typedef std::map<size_t, MultiLevelAlgoStat>  MultiLevelAlgoStats;
 class MultiLevelAlgo {
 public:
 public:
@@ -23,11 +41,11 @@ class MultiLevelAlgo {
 	//
 	void launch();
 	void refine();
-
+	size_t nbLevels() const ;
 public:
 	// on agrège jusqu'à ce que l'on ait nbNodes noeuds dans le problème équivalent
 	// nbNodesMax = 0 pas de limite
-	void buildMultiLevelData(size_t nbNodes, size_t nbNodesMax = 50);
+	void buildMultiLevelData(double nbNodes, double nbNodesMax = 50);
 
 	// initialisation
 	void setStartLevel( size_t );
@@ -37,7 +55,7 @@ class MultiLevelAlgo {
 	void setStartPoint( Partition  & );
 	void setOut(std::ostream & =std::cout);
 	//Double getDistance(SuperNoeud const & i, SuperNoeud const & j) const;
-
+	MultiLevelAlgoStats const & stats()const;
 	std::ostream & out();
 public:
 	// l'instance de départ
@@ -52,6 +70,7 @@ class MultiLevelAlgo {
 	std::ostream * _out;
 	Number _totalKMtimer;
 	size_t _totlKMite;
+	MultiLevelAlgoStats _stats;
 
 };
 
diff --git a/projet_zz/main.cpp b/projet_zz/main.cpp
index bd723d5..be6175e 100644
--- a/projet_zz/main.cpp
+++ b/projet_zz/main.cpp
@@ -56,60 +56,30 @@ int main(int argc, char ** argv) {
 			RegisteredInstance instance(id);
 			instance.out();			
 			MultiLevelAlgo algo(instance, k);
-			algo.buildMultiLevelData(20*k,200);
+			algo.buildMultiLevelData(20*k, std::ceil(instance.nbObs()/4.0));
 			Partition start(instance.nbObs(), k);
-			// generation du point de depart
+			 //generation du point de depart
 			algo.getStartPoint(start);
             
 			// ----s
-			size_t level;
 			bool done(false);
-			int nbfichier=1;
 			std::ofstream file("output.log");
 			algo.setOut(file);
-
-			// pour nos tests on va créer une liste sur le premier niveau a traiter
-			// et une deuxieme pour les sauts.
-
-			std::vector<size_t> list_level;
-			std::vector<size_t> list_saut;
-
-
-			list_saut.push_back(1);
-			list_saut.push_back(2);
-			list_saut.push_back(4);
-			list_saut.push_back(8);
-			
-			while(!list_saut.empty()){
-				size_t saut=list_saut.back();
+			//algo.out() << "
+			// pour nos tests on va créer une liste sur le premier niveau a traiter et une deuxieme pour les sauts.
+			// MR : commencer par faire sans saut .... !!!!
+			algo.setStep(1);
+			std::vector<MultiLevelAlgoStats> allStats(algo.nbLevels()+1);
+			for(size_t level(0); level<=algo.nbLevels(); ++level){
 				algo.out()<< "_________________________________________________________" << std::endl;
-				algo.setStep(saut);
-				list_saut.pop_back();
-				algo.out()<< "Pas de  : " << saut << std::endl;
-	
-
-				list_level.push_back(0);
-				list_level.push_back(2);
-				list_level.push_back(4);
-				list_level.push_back(8);
-				list_level.push_back(16);
-				while(!list_level.empty()){
-				
-					algo.out()<< "_________________________________________________________" << std::endl;
-					level=list_level.back();
-					list_level.pop_back();
-					algo.out()<< "level d'initialisation : " << level << std::endl;
-
-					algo.setStartPoint(start);
-					algo.setStartLevel(level);
-					algo.launch();
-					
-					
-				}
+				algo.setStartPoint(start);
+				algo.setStartLevel(level);
+				algo.launch();
+				allStats[level] = algo.stats();
 			}
 			file.close();
 		}
 	}
-	system("pause");
+	std::cin.get();
 	return 0; 
 }
\ No newline at end of file

From d0b5dda006b0ecda836d9912099a6a86239287a9 Mon Sep 17 00:00:00 2001
From: rogelja <vrogelja@gmail.com>
Date: Fri, 8 Feb 2013 18:38:51 +0100
Subject: [PATCH 08/14] Update projet_zz/MultiLevelKMInstance.cpp

---
 projet_zz/MultiLevelKMInstance.cpp | 45 +++++++++++++++---------------
 1 file changed, 23 insertions(+), 22 deletions(-)

diff --git a/projet_zz/MultiLevelKMInstance.cpp b/projet_zz/MultiLevelKMInstance.cpp
index 8e0777f..1b94d29 100644
--- a/projet_zz/MultiLevelKMInstance.cpp
+++ b/projet_zz/MultiLevelKMInstance.cpp
@@ -1,7 +1,7 @@
 /*
 * MultiLevelKMInstance.cpp
 *
-*  Created on: 15 déc. 2012
+*  Created on: 15 déc. 2012
 *      Author: manuel
 */
 
@@ -26,7 +26,7 @@ MultiLevelAlgo::~MultiLevelAlgo() {
 		delete ptr;
 }
 void MultiLevelAlgo::buildInstance(size_t level, KMInstance & instance,Aggregations & aggregations) {
-	// on enlève toutes les contraintes
+	// on enlève toutes les contraintes
 	_instance.mustLinks().clear();
 	_instance.cannotLinks().clear();
 	for (size_t i(0); i < level; ++i) {
@@ -36,18 +36,18 @@ void MultiLevelAlgo::buildInstance(size_t level, KMInstance & instance,Aggregati
 	}
 	// construit les infos de correspondances entre les instances
 	_instance.buildMustLink(aggregations);
-	// construit l'instance aggrégée
+	// construit l'instance aggrégée
 	instance = KMInstance(_instance, aggregations);
 }
 
 
-// @brief construit une suite de problèmes agrégés en agrégeant nbNodesMax noeuds par niveau et en produisant des graphes avec au plus nbNodes noeuds
-// @param nbNodes    : limite pour le graph le plus agrégé 
-// @param nbNodesMax : limite max de noeuds agrégé par étape
+// @brief construit une suite de problèmes agrégés en agrégeant nbNodesMax noeuds par niveau et en produisant des graphes avec au plus nbNodes noeuds
+// @param nbNodes    : limite pour le graph le plus agrégé 
+// @param nbNodesMax : limite max de noeuds agrégé par étape
 void MultiLevelAlgo::buildMultiLevelData(double nbNodes,double nbNodesMax) {
 
 	KMPartition partition(_instance, _instance.nbObs());
-	// on crée les singletons
+	// on crée les singletons
 	for(size_t i(0); i<_instance.nbObs(); ++i)
 		partition.shift(i,i);
 
@@ -70,12 +70,12 @@ void MultiLevelAlgo::buildMultiLevelData(double nbNodes,double nbNodesMax) {
 				size_t const c(neighbor.begin()->second);
 				_multiLevelConstraints.back()->newCtr(*partition.observations(m).begin(),*partition.observations(c).begin());
 				partition.fusion(m,c);				
-				// si plusieurs plusieurs plus pret : tirer au hazard (aprés)
+				// si plusieurs plusieurs plus pret : tirer au hazard (aprés)
 				used.erase(c);
 				compteur++;
 			}
 		};
-		// ajouter les contraintes associée à ce niveau
+		// ajouter les contraintes associée à ce niveau
 	};
 	std::cout << "nbNodes     "<<nbNodes <<std::endl;
 	std::cout << "nbNodesMax  "<<nbNodesMax <<std::endl;
@@ -83,23 +83,23 @@ void MultiLevelAlgo::buildMultiLevelData(double nbNodes,double nbNodesMax) {
 }
 //
 // _step: 
-// _startLevel : niveau de départ pour le raffinement
-// _startPoint : (attention doit être compatible avec le niveau de plus agrégé)
+// _startLevel : niveau de départ pour le raffinement
+// _startPoint : (attention doit être compatible avec le niveau de plus agrégé)
 void MultiLevelAlgo::refine() {
-	// lancer le KMEANS sur chaque niveau en partant du plus élevé (celui qui contient le moins de noeuds)
-	// à chaque fois on initialise avec le niveau précédent (sauf le premier!)
-	// Pour le premier faire un appel à random(0);
+	// lancer le KMEANS sur chaque niveau en partant du plus élevé (celui qui contient le moins de noeuds)
+	// à chaque fois on initialise avec le niveau précédent (sauf le premier!)
+	// Pour le premier faire un appel à random(0);
 	KMInstance instance;
 	Aggregations aggregations;	
 	Timer timer;
 	// pour chaque level
 	for ( size_t level(_startLevel); level <= _multiLevelConstraints.size(); level+= _step) {
-		// ! on parcours à l'envers
+		// ! on parcours à l'envers
 		buildInstance(_multiLevelConstraints.size() - level, instance,aggregations);
 		timer.restart();
 		KMInput input(instance, _input.maxNbLabels());
 		// initialiser cette input avec la solkution courante
-		// attention il faut utiliser aggregation pour faire les neodus agrégés et la solution courante
+		// attention il faut utiliser aggregation pour faire les neodus agrégés et la solution courante
 
 		for (size_t i(0); i < _input.nbObs(); ++i) {
 			input.shiftForced(aggregations.newIds[i], _input.label(i));
@@ -115,7 +115,7 @@ void MultiLevelAlgo::refine() {
 		for (size_t i(0); i < _input.nbObs(); ++i) {
 			_input.shiftForced(i, input.label(aggregations.newIds[i]));
 		}
-		// attention à la fin car on souhaite compter le temps des deux boucles au dessus
+		// attention à la fin car on souhaite compter le temps des deux boucles au dessus
 		_stats[ level] = MultiLevelAlgoStat( level, input.ite(), timer.elapsed(), input.cost());
 	}
 
@@ -135,10 +135,10 @@ void MultiLevelAlgo::refine() {
 
 	}*/
 }
-// @brief lance l'algorithme multi-niveau à partir d'une suite d'agrégation, d'une partition de départ et d'un niveau de départ et avec un pas donné
+// @brief lance l'algorithme multi-niveau à partir d'une suite d'agrégation, d'une partition de départ et d'un niveau de départ et avec un pas donné
 // _step: 
-// _startLevel : niveau de départ pour le raffinement
-// _startPoint : (attention doit être compatible avec le niveau de plus agrégé)
+// _startLevel : niveau de départ pour le raffinement
+// _startPoint : (attention doit être compatible avec le niveau de plus agrégé)
 
 void MultiLevelAlgo::setOut(std::ostream & stream){
 	_out = &stream;
@@ -147,7 +147,7 @@ void MultiLevelAlgo::launch() {
 	_stats.clear();
 	std::cout << "Step  : "<<_step		<< std::endl;
 	std::cout << "Level : "<<_startLevel<< std::endl;
-	// initialisation au point de départ
+	// initialisation au point de départ
 	for (size_t i(0); i < _input.nbObs(); ++i) {
 		_input.shiftForced(i, _startPoint.label(i));
 	}		
@@ -190,4 +190,5 @@ std::ostream & MultiLevelAlgo::out(){
 }
 MultiLevelAlgoStats const & MultiLevelAlgo::stats()const{
 	return _stats;
-}
\ No newline at end of file
+}
+

From a57e8ccf6e58f5426ea19905efc918243b34d1e7 Mon Sep 17 00:00:00 2001
From: rogelja <vrogelja@gmail.com>
Date: Fri, 8 Feb 2013 18:40:00 +0100
Subject: [PATCH 09/14] Update projet_zz/MultiLevelKMInstance.h

---
 projet_zz/MultiLevelKMInstance.h | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/projet_zz/MultiLevelKMInstance.h b/projet_zz/MultiLevelKMInstance.h
index db9a100..3ecbc9a 100644
--- a/projet_zz/MultiLevelKMInstance.h
+++ b/projet_zz/MultiLevelKMInstance.h
@@ -1,7 +1,7 @@
 /*
  * MultiLevelKMInstance.h
  *
- *  Created on: 15 déc. 2012
+ *  Created on: 15 déc. 2012
  *      Author: manuel
  */
 
@@ -43,7 +43,7 @@ class MultiLevelAlgo {
 	void refine();
 	size_t nbLevels() const ;
 public:
-	// on agrège jusqu'à ce que l'on ait nbNodes noeuds dans le problème équivalent
+	// on agrège jusqu'à ce que l'on ait nbNodes noeuds dans le problème équivalent
 	// nbNodesMax = 0 pas de limite
 	void buildMultiLevelData(double nbNodes, double nbNodesMax = 50);
 
@@ -58,7 +58,7 @@ class MultiLevelAlgo {
 	MultiLevelAlgoStats const & stats()const;
 	std::ostream & out();
 public:
-	// l'instance de départ
+	// l'instance de départ
 	KMInstance _instance;
 	KMInput _input;
 	// les contraintes de chaque niveau : incrementalement
@@ -74,4 +74,4 @@ class MultiLevelAlgo {
 
 };
 
-#endif /* MULTILEVELKMINSTANCE_H_ */
\ No newline at end of file
+#endif /* MULTILEVELKMINSTANCE_H_ */

From 5fcecc4414b3a7d351f93c2a39189650d2624e83 Mon Sep 17 00:00:00 2001
From: rogelja <vrogelja@gmail.com>
Date: Fri, 8 Feb 2013 18:41:25 +0100
Subject: [PATCH 10/14] Update projet_zz/main.cpp

---
 projet_zz/main.cpp | 40 ++++++++++++++++++++++++++++++++++------
 1 file changed, 34 insertions(+), 6 deletions(-)

diff --git a/projet_zz/main.cpp b/projet_zz/main.cpp
index be6175e..28f3dcc 100644
--- a/projet_zz/main.cpp
+++ b/projet_zz/main.cpp
@@ -1,7 +1,7 @@
 /*
  * main.cpp
  *
- *  Created on: 15 déc. 2012
+ *  Created on: 15 déc. 2012
  *      Author: manuel
  */
 
@@ -63,23 +63,51 @@ int main(int argc, char ** argv) {
             
 			// ----s
 			bool done(false);
-			std::ofstream file("output.log");
+			std::ofstream file("output.csv");
 			algo.setOut(file);
 			//algo.out() << "
-			// pour nos tests on va créer une liste sur le premier niveau a traiter et une deuxieme pour les sauts.
+			// pour nos tests on va créer une liste sur le premier niveau a traiter et une deuxieme pour les sauts.
 			// MR : commencer par faire sans saut .... !!!!
 			algo.setStep(1);
 			std::vector<MultiLevelAlgoStats> allStats(algo.nbLevels()+1);
 			for(size_t level(0); level<=algo.nbLevels(); ++level){
-				algo.out()<< "_________________________________________________________" << std::endl;
 				algo.setStartPoint(start);
 				algo.setStartLevel(level);
 				algo.launch();
 				allStats[level] = algo.stats();
 			}
+			/*
+			std::vector<double> sumsIte(algo.nbLevels()+1);
+			std::vector<double> sumsTime(algo.nbLevels()+1);
+			std::vector<double> sumsCost(algo.nbLevels()+1);
+			//*/
+			for (size_t level(0); level<=algo.nbLevels(); ++level)
+			{
+				double sumIte = 0.0 , sumTime = 0.0 , sumCost = 0.0 ;
+				size_t cpt = 0 ;
+				for (auto & stat : allStats[level]) {
+					sumIte += (double) stat.second._ite ;
+					sumTime += stat.second._time ;
+					sumCost += stat.second._cost ;
+					cpt++ ;
+				}
+				/*			
+				sumsIte[level] = sumIte / ((double) cpt) ;
+				sumsTime[level] = sumTime / ((double) cpt) ;
+				sumsCost[level] = sumCost / ((double) cpt) ;
+				//*/
+				algo.out() << "_________________________________________________________" << std::endl ;
+				algo.out() << "Niveau de départ : " << level << std::endl ;
+				algo.out() << "Nombre moyen d'itérations :" << sumIte / ((double) cpt)  << std::endl ;
+				algo.out() << "Temps moyen des k-moyennes :" << sumTime / ((double) cpt)  << std::endl ;
+				algo.out() << "Temps total des k-moyennes :" << sumTime  << std::endl ;
+				algo.out() << "Coût moyen :" << sumCost / ((double) cpt)  << std::endl ;
+				algo.out() << "Coût final :" << allStats[level][(--(allStats[level].end()))->first]._cost  << std::endl ;
+				algo.out() << "_________________________________________________________" << std::endl ;
+			}
 			file.close();
 		}
 	}
-	std::cin.get();
+	
 	return 0; 
-}
\ No newline at end of file
+}

From 02bca126773c1efce89fd45598cbf9baf6d07222 Mon Sep 17 00:00:00 2001
From: klorel <manuel.jean.ruiz@gmail.com>
Date: Fri, 15 Feb 2013 17:51:59 +0100
Subject: [PATCH 11/14] BUG !

---
 projet_zz/20130214_output.csv      |  32 +++
 projet_zz/MultiLevelKMInstance.cpp | 389 +++++++++++++++--------------
 projet_zz/main.cpp                 | 160 +++++++-----
 3 files changed, 327 insertions(+), 254 deletions(-)
 create mode 100644 projet_zz/20130214_output.csv

diff --git a/projet_zz/20130214_output.csv b/projet_zz/20130214_output.csv
new file mode 100644
index 0000000..b9ca6a9
--- /dev/null
+++ b/projet_zz/20130214_output.csv
@@ -0,0 +1,32 @@
+ID;Nom instance;Nb Classes;Nb noeud agrege / Niveau ; Nb niveau; Nb d'ite K-means Classique; Score Classique;Temps moyen Classique; Level de depart;Nb d'ite K-means Total; Score Tot;Nb d'iteration moy;temps moyen par niveau;Rapport Scores (%);Rapport iterations total(%); rapport iterations moyen(%);Rapport temps(%)
+8;segmentation;32;105;15;18;3410102.448;3.82322;14;166;3448881.003;11.0667;1.08206;1.137;822.2;-38.52;324.5
+8;segmentation;32;105;15;18;3410102.448;3.82322;13;100;3529480.066;7.14286;0.783902;3.501;455.6;-60.32;187.1
+8;segmentation;32;105;15;18;3410102.448;3.82322;12;138;4500123.153;10.6154;1.07383;31.96;666.7;-41.03;265.1
+8;segmentation;32;105;15;18;3410102.448;3.82322;11;121;3500846.797;10.0833;1.11815;2.661;572.2;-43.98;251
+8;segmentation;32;105;15;18;3410102.448;3.82322;10;106;3441029.73;9.63636;1.12779;0.9069;488.9;-46.46;224.5
+8;segmentation;32;105;15;18;3410102.448;3.82322;9;80;3521620.658;8;1.04886;3.27;344.4;-55.56;174.3
+8;segmentation;32;105;15;18;3410102.448;3.82322;8;61;3499083.608;6.77778;0.952832;2.609;238.9;-62.35;124.3
+8;segmentation;32;105;15;18;3410102.448;3.82322;7;78;3404992.409;9.75;1.2932;-0.1498;333.3;-45.83;170.6
+8;segmentation;32;105;15;18;3410102.448;3.82322;6;77;3435578.691;11;1.61666;0.7471;327.8;-38.89;196
+8;segmentation;32;105;15;18;3410102.448;3.82322;5;49;3431379.338;8.16667;1.34458;0.6239;172.2;-54.63;111
+8;segmentation;32;105;15;18;3410102.448;3.82322;4;35;3542163.893;7;1.16987;3.873;94.44;-61.11;53
+8;segmentation;32;105;15;18;3410102.448;3.82322;3;27;3593621.509;6.75;1.20982;5.382;50;-62.5;26.58
+8;segmentation;32;105;15;18;3410102.448;3.82322;2;37;3509587.271;12.3333;2.10379;2.917;105.6;-31.48;65.08
+8;segmentation;32;105;15;18;3410102.448;3.82322;1;47;3384212.287;23.5;4.05673;-0.7592;161.1;30.56;112.2
+8;segmentation;32;105;15;18;3410102.448;3.82322;0;18;3410102.448;18;3.82322;0;0;0;0
+;;;;;;;;;;;;;;;;
+8;segmentation;63;105;9;24;2098193.361;7.09941;8;69;2187865.439;7.66667;1.2114;4.274;187.5;-68.06;53.57
+8;segmentation;63;105;9;24;2098193.361;7.09941;7;91;2104218.564;11.375;1.93211;0.2872;279.2;-52.6;117.7
+8;segmentation;63;105;9;24;2098193.361;7.09941;6;77;2221910.311;11;1.88239;5.896;220.8;-54.17;85.6
+8;segmentation;63;105;9;24;2098193.361;7.09941;5;76;2114229.762;12.6667;2.39697;0.7643;216.7;-47.22;102.6
+8;segmentation;63;105;9;24;2098193.361;7.09941;4;101;2062935.734;20.2;3.12218;-1.68;320.8;-15.83;119.9
+8;segmentation;63;105;9;24;2098193.361;7.09941;3;47;2086004.167;11.75;2.65465;-0.5809;95.83;-51.04;49.57
+8;segmentation;63;105;9;24;2098193.361;7.09941;2;42;2128901.144;14;3.07484;1.464;75;-41.67;29.93
+8;segmentation;63;105;9;24;2098193.361;7.09941;1;30;2075890.716;15;3.91122;-1.063;25;-37.5;10.18
+8;segmentation;63;105;9;24;2098193.361;7.09941;0;24;2098193.361;24;7.09941;0;0;0;0
+;;;;;;;;;;;;;;;;
+8;segmentation;95;105;3;18;1637693.797;6.35036;2;36;1490017.274;12;3.06351;-9.017;100;-33.33;44.72
+8;segmentation;95;105;3;18;1637693.797;6.35036;1;32;1582173.797;16;4.32325;-3.39;77.78;-11.11;36.16
+8;segmentation;95;105;3;18;1637693.797;6.35036;0;18;1637693.797;18;6.35036;0;0;0;0
+;;;;;;;;;;;;;;;;
+8;segmentation;126;105;1;21;1199768.496;7.86345;0;21;1199768.496;21;7.86345;0;0;0;0
diff --git a/projet_zz/MultiLevelKMInstance.cpp b/projet_zz/MultiLevelKMInstance.cpp
index 1b94d29..fa2e9b3 100644
--- a/projet_zz/MultiLevelKMInstance.cpp
+++ b/projet_zz/MultiLevelKMInstance.cpp
@@ -1,194 +1,195 @@
-/*
-* MultiLevelKMInstance.cpp
-*
-*  Created on: 15 déc. 2012
-*      Author: manuel
-*/
-
-#include "../projet_zz/MultiLevelKMInstance.h"
-#include "../src/HMeans.hpp"
-#include "../src/KMAlgo.hpp"
-#include "../src/Timer.hpp"
-#include <iostream>
-#include <fstream>
-
-
-MultiLevelAlgo::MultiLevelAlgo(KMInstance const & instance, size_t k,Partition startPoint) :
-	_instance(instance), _input(_instance, k),_startPoint(startPoint) {
-		// par defaut sur la sortie standard.
-		setOut();
-}
-
-
-
-MultiLevelAlgo::~MultiLevelAlgo() {
-	for (auto & ptr : _multiLevelConstraints)
-		delete ptr;
-}
-void MultiLevelAlgo::buildInstance(size_t level, KMInstance & instance,Aggregations & aggregations) {
-	// on enlève toutes les contraintes
-	_instance.mustLinks().clear();
-	_instance.cannotLinks().clear();
-	for (size_t i(0); i < level; ++i) {
-		for (auto const & ctr : *_multiLevelConstraints[i]) {
-			_instance.addMustLink(ctr.first, ctr.second);
-		}
-	}
-	// construit les infos de correspondances entre les instances
-	_instance.buildMustLink(aggregations);
-	// construit l'instance aggrégée
-	instance = KMInstance(_instance, aggregations);
-}
-
-
-// @brief construit une suite de problèmes agrégés en agrégeant nbNodesMax noeuds par niveau et en produisant des graphes avec au plus nbNodes noeuds
-// @param nbNodes    : limite pour le graph le plus agrégé 
-// @param nbNodesMax : limite max de noeuds agrégé par étape
-void MultiLevelAlgo::buildMultiLevelData(double nbNodes,double nbNodesMax) {
-
-	KMPartition partition(_instance, _instance.nbObs());
-	// on crée les singletons
-	for(size_t i(0); i<_instance.nbObs(); ++i)
-		partition.shift(i,i);
-
-	while(partition.nbLabels() > nbNodes ){
-		std::cout << "partition.nbLabels() : "<<partition.nbLabels()<<std::endl;
-		IndexedList used(partition.usedLabels());
-		// definit un nouveau niveau
-		_multiLevelConstraints.push_back(new KMConstraints(_input.nbObs()));
-		//
-		size_t compteur=0;
-		while(!used.empty() && compteur < nbNodesMax){
-			size_t const m = used.pop_random();
-			if( !used.empty()){
-				// calculer la distance de ce centre avec les autres
-				std::multimap<Double, size_t> neighbor;
-				for(auto const & c : partition.usedLabels()){
-					if ( m != c)
-						neighbor.insert( std::make_pair(partition.getDistanceCenter(m,c) , c));
-				}
-				size_t const c(neighbor.begin()->second);
-				_multiLevelConstraints.back()->newCtr(*partition.observations(m).begin(),*partition.observations(c).begin());
-				partition.fusion(m,c);				
-				// si plusieurs plusieurs plus pret : tirer au hazard (aprés)
-				used.erase(c);
-				compteur++;
-			}
-		};
-		// ajouter les contraintes associée à ce niveau
-	};
-	std::cout << "nbNodes     "<<nbNodes <<std::endl;
-	std::cout << "nbNodesMax  "<<nbNodesMax <<std::endl;
-	std::cout << "Built       "<<nbLevels() << " aggregation levels"<<std::endl;
-}
-//
-// _step: 
-// _startLevel : niveau de départ pour le raffinement
-// _startPoint : (attention doit être compatible avec le niveau de plus agrégé)
-void MultiLevelAlgo::refine() {
-	// lancer le KMEANS sur chaque niveau en partant du plus élevé (celui qui contient le moins de noeuds)
-	// à chaque fois on initialise avec le niveau précédent (sauf le premier!)
-	// Pour le premier faire un appel à random(0);
-	KMInstance instance;
-	Aggregations aggregations;	
-	Timer timer;
-	// pour chaque level
-	for ( size_t level(_startLevel); level <= _multiLevelConstraints.size(); level+= _step) {
-		// ! on parcours à l'envers
-		buildInstance(_multiLevelConstraints.size() - level, instance,aggregations);
-		timer.restart();
-		KMInput input(instance, _input.maxNbLabels());
-		// initialiser cette input avec la solkution courante
-		// attention il faut utiliser aggregation pour faire les neodus agrégés et la solution courante
-
-		for (size_t i(0); i < _input.nbObs(); ++i) {
-			input.shiftForced(aggregations.newIds[i], _input.label(i));
-		}
-
-
-		// on lance l'algo
-		HMeans<true>()(input);
-		// on stocke les stats
-		
-		// suavegarde de la solution
-		input.computeCenters();
-		for (size_t i(0); i < _input.nbObs(); ++i) {
-			_input.shiftForced(i, input.label(aggregations.newIds[i]));
-		}
-		// attention à la fin car on souhaite compter le temps des deux boucles au dessus
-		_stats[ level] = MultiLevelAlgoStat( level, input.ite(), timer.elapsed(), input.cost());
-	}
-
-
-	// pb ici traitement du dernier niveau
-
-
-	/*if(level>_multiLevelConstraints.size())
-	{
-		// on lance l'algo
-		HMeans<true>()(_input);
-		out()<<"Niveau de rafinement         : " <<0<<std::endl;
-		out()<<"Nombre d'iteration par etape : " <<_input.ite()<<std::endl;
-		out()<<"Temps ecoule                 : " <<timer.elapsed()<<std::endl;
-		out()<<"Valeur du cout               : " <<_input.cost()<<std::endl;
-		out()<<std::endl;
-
-	}*/
-}
-// @brief lance l'algorithme multi-niveau à partir d'une suite d'agrégation, d'une partition de départ et d'un niveau de départ et avec un pas donné
-// _step: 
-// _startLevel : niveau de départ pour le raffinement
-// _startPoint : (attention doit être compatible avec le niveau de plus agrégé)
-
-void MultiLevelAlgo::setOut(std::ostream & stream){
-	_out = &stream;
-}
-void MultiLevelAlgo::launch() {
-	_stats.clear();
-	std::cout << "Step  : "<<_step		<< std::endl;
-	std::cout << "Level : "<<_startLevel<< std::endl;
-	// initialisation au point de départ
-	for (size_t i(0); i < _input.nbObs(); ++i) {
-		_input.shiftForced(i, _startPoint.label(i));
-	}		
-	// lancement du run 
-	refine();
-
-}
-size_t MultiLevelAlgo::nbLevels()const{
-	return _multiLevelConstraints.size();
-}
-void MultiLevelAlgo::getStartPoint( Partition  & point){
-	KMInstance instance;
-	Aggregations aggregations;	
-	buildInstance(_multiLevelConstraints.size(), instance,aggregations);
-	KMInput input(instance, _input.maxNbLabels());
-	input.random(0);	
-	for (size_t i(0); i < _input.nbObs(); ++i) {
-		point.shift(i, input.label(aggregations.newIds[i]));
-	}	
-}
-
-
-void MultiLevelAlgo::setStartLevel( size_t level){
-	_startLevel=level;
-}
-
-
-
-void MultiLevelAlgo::setStep(size_t step){
-	_step=step;
-}
-
-
-void MultiLevelAlgo::setStartPoint( Partition  & point){
-	_startPoint = point;
-}
-
-std::ostream & MultiLevelAlgo::out(){
-	return *_out;
-}
-MultiLevelAlgoStats const & MultiLevelAlgo::stats()const{
-	return _stats;
-}
-
+/*
+* MultiLevelKMInstance.cpp
+*
+*  Created on: 15 déc. 2012
+*      Author: manuel
+*/
+
+#include "../projet_zz/MultiLevelKMInstance.h"
+#include "../src/HMeans.hpp"
+#include "../src/KMAlgo.hpp"
+#include "../src/Timer.hpp"
+#include <iostream>
+#include <fstream>
+
+
+MultiLevelAlgo::MultiLevelAlgo(KMInstance const & instance, size_t k,Partition startPoint) :
+	_instance(instance), _input(_instance, k),_startPoint(startPoint) {
+		// par defaut sur la sortie standard.
+		setOut();
+}
+
+
+
+MultiLevelAlgo::~MultiLevelAlgo() {
+	for (auto & ptr : _multiLevelConstraints)
+		delete ptr;
+}
+void MultiLevelAlgo::buildInstance(size_t level, KMInstance & instance,Aggregations & aggregations) {
+	// on enlève toutes les contraintes
+	_instance.mustLinks().clear();
+	_instance.cannotLinks().clear();
+	for (size_t i(0); i < level; ++i) {
+		for (auto const & ctr : *_multiLevelConstraints[i]) {
+			_instance.addMustLink(ctr.first, ctr.second);
+		}
+	}
+	// construit les infos de correspondances entre les instances
+	_instance.buildMustLink(aggregations);
+	// construit l'instance aggrégée
+	instance = KMInstance(_instance, aggregations);
+}
+
+
+// @brief construit une suite de problèmes agrégés en agrégeant nbNodesMax noeuds par niveau et en produisant des graphes avec au plus nbNodes noeuds
+// @param nbNodes    : limite pour le graph le plus agrégé 
+// @param nbNodesMax : limite max de noeuds agrégé par étape
+void MultiLevelAlgo::buildMultiLevelData(double nbNodes,double nbNodesMax) {
+
+	KMPartition partition(_instance, _instance.nbObs());
+	// on crée les singletons
+	for(size_t i(0); i<_instance.nbObs(); ++i)
+		partition.shift(i,i);
+
+	while(partition.nbLabels() > nbNodes ){
+		std::cout << "partition.nbLabels() : "<<partition.nbLabels()<<std::endl;
+		IndexedList used(partition.usedLabels());
+		// definit un nouveau niveau
+		_multiLevelConstraints.push_back(new KMConstraints(_input.nbObs()));
+		//
+		size_t compteur=0;
+		while(!used.empty() && compteur < nbNodesMax){
+			size_t const m = used.pop_random();
+			if( !used.empty()){
+				// calculer la distance de ce centre avec les autres
+				std::multimap<Double, size_t> neighbor;
+				for(auto const & c : partition.usedLabels()){
+					if ( m != c)
+						neighbor.insert( std::make_pair(partition.getDistanceCenter(m,c) , c));
+				}
+				size_t const c(neighbor.begin()->second);
+				_multiLevelConstraints.back()->newCtr(*partition.observations(m).begin(),*partition.observations(c).begin());
+				partition.fusion(m,c);				
+				// si plusieurs plusieurs plus pret : tirer au hazard (aprés)
+				used.erase(c);
+				compteur++;
+			}
+		};
+		// ajouter les contraintes associée à ce niveau
+	};
+	std::cout << "nbNodes     "<<nbNodes <<std::endl;
+	std::cout << "nbNodesMax  "<<nbNodesMax <<std::endl;
+	std::cout << "Built       "<<nbLevels() << " aggregation levels"<<std::endl;
+}
+//
+// _step: 
+// _startLevel : niveau de départ pour le raffinement
+// _startPoint : (attention doit être compatible avec le niveau de plus agrégé)
+void MultiLevelAlgo::refine() {
+	// lancer le KMEANS sur chaque niveau en partant du plus élevé (celui qui contient le moins de noeuds)
+	// à chaque fois on initialise avec le niveau précédent (sauf le premier!)
+	// Pour le premier faire un appel à random(0);
+	KMInstance instance;
+	Aggregations aggregations;	
+	Timer timer;
+	// pour chaque level
+	for ( size_t level(_startLevel); level <= _multiLevelConstraints.size(); level+= _step) {
+		// ! on parcours à l'envers
+		buildInstance(_multiLevelConstraints.size() - level, instance,aggregations);
+		timer.restart();
+		KMInput input(instance, _input.maxNbLabels());
+		// initialiser cette input avec la solkution courante
+		// attention il faut utiliser aggregation pour faire les neodus agrégés et la solution courante
+
+		for (size_t i(0); i < _input.nbObs(); ++i) {
+			input.shiftForced(aggregations.newIds[i], _input.label(i));
+		}
+
+
+		// on lance l'algo
+		HMeans<true>()(input);
+		// on stocke les stats
+		
+		// suavegarde de la solution
+		input.computeCenters();
+		for (size_t i(0); i < _input.nbObs(); ++i) {
+			_input.shiftForced(i, input.label(aggregations.newIds[i]));
+		}
+		// attention à la fin car on souhaite compter le temps des deux boucles au dessus
+		_stats[ level] = MultiLevelAlgoStat( level, input.ite(), timer.elapsed(), input.cost());
+	}
+
+
+	// pb ici traitement du dernier niveau
+
+
+	/*if(level>_multiLevelConstraints.size())
+	{
+		// on lance l'algo
+		HMeans<true>()(_input);
+		out()<<"Niveau de rafinement         : " <<0<<std::endl;
+		out()<<"Nombre d'iteration par etape : " <<_input.ite()<<std::endl;
+		out()<<"Temps ecoule                 : " <<timer.elapsed()<<std::endl;
+		out()<<"Valeur du cout               : " <<_input.cost()<<std::endl;
+		out()<<std::endl;
+
+	}*/
+}
+// @brief lance l'algorithme multi-niveau à partir d'une suite d'agrégation, d'une partition de départ et d'un niveau de départ et avec un pas donné
+// _step: 
+// _startLevel : niveau de départ pour le raffinement
+// _startPoint : (attention doit être compatible avec le niveau de plus agrégé)
+
+void MultiLevelAlgo::setOut(std::ostream & stream){
+	_out = &stream;
+}
+void MultiLevelAlgo::launch() {
+	_stats.clear();
+	std::cout << "Step  : "<<_step		<< std::endl;
+	std::cout << "Level : "<<_startLevel<< std::endl;
+	// initialisation au point de départ
+	for (size_t i(0); i < _input.nbObs(); ++i) {
+		_input.shiftForced(i, _startPoint.label(i));
+	}		
+	// lancement du run 
+	refine();
+
+}
+size_t MultiLevelAlgo::nbLevels()const{
+	return _multiLevelConstraints.size();
+}
+void MultiLevelAlgo::getStartPoint( Partition  & point){
+	KMInstance instance;
+	Aggregations aggregations;	
+	buildInstance(_multiLevelConstraints.size(), instance,aggregations);
+	KMInput input(instance, _input.maxNbLabels());
+	input.random(0);	
+	for (size_t i(0); i < _input.nbObs(); ++i) {
+		point.shift(i, input.label(aggregations.newIds[i]));
+	}
+	std::cout << "Starting point value : "<<input.computeCost() << std::endl;
+}
+
+
+void MultiLevelAlgo::setStartLevel( size_t level){
+	_startLevel=level;
+}
+
+
+
+void MultiLevelAlgo::setStep(size_t step){
+	_step=step;
+}
+
+
+void MultiLevelAlgo::setStartPoint( Partition  & point){
+	_startPoint = point;
+}
+
+std::ostream & MultiLevelAlgo::out(){
+	return *_out;
+}
+MultiLevelAlgoStats const & MultiLevelAlgo::stats()const{
+	return _stats;
+}
+
diff --git a/projet_zz/main.cpp b/projet_zz/main.cpp
index 28f3dcc..6297c37 100644
--- a/projet_zz/main.cpp
+++ b/projet_zz/main.cpp
@@ -1,9 +1,9 @@
 /*
- * main.cpp
- *
- *  Created on: 15 déc. 2012
- *      Author: manuel
- */
+* main.cpp
+*
+*  Created on: 15 déc. 2012
+*      Author: manuel
+*/
 
 #include "src/common.h"
 #include "src/Partition.hpp"
@@ -18,6 +18,8 @@
 
 #include "projet_zz/MultiLevelKMInstance.h"
 #include <random>
+#include <iostream>
+#include <fstream>
 
 void usage() {
 	std::cout << "Available instances : \n";
@@ -34,80 +36,118 @@ void usage() {
 	std::cout << "The program launch the multi level algorithm\n";
 
 }
+template<class T> void WriteCsv(std::ostream & stream, T const & t){
+	stream << t << ";";
+}
+template<class T> void WriteCsv(std::ostream & stream, T const & t, size_t n){
+	stream << std::setprecision(n) <<t << ";";
+}
 
 int main(int argc, char ** argv) {
 	Number::SetSeed(1);
-	if (argc < 3) {
-		usage();
-	} else {
-		size_t const i(atoi(argv[1]));
-		size_t const k(atoi(argv[2]));
-		if (i < AvailableInstances::SIZE) {
-			// Ecrire dans un fichier les resultats : moyenne sur tous les problemes
-			// verifier la coherence on ne peut deteriorer la solution de depart
-			// KMEANS : KMEANS classique
-			// on souhaite se comparer au KMEANS normal 
-			// - % temps total dans le KMEANS (sans construction des instances intermediaires)
-			// - % nombre d'iteration en plus KMEANS
-			// - % temps moyen des iterations
-			// - l'ecart par rapport au KMEANS normal
+	//liste des instances a tester
+	std::list<size_t> list_instance;
+	list_instance.push_back(0);
+	//list_instance.push_back(1);
+	//list_instance.push_back(4);
+	//list_instance.push_back(7);
+	//list_instance.push_back(8);
+	//list_instance.push_back(9);
+	//list_instance.push_back(12);
+	//list_instance.push_back(15);
+	//list_instance.push_back(16);
+	//list_instance.push_back(19);
+	//list_instance.push_back(22);
+	//list_instance.push_back(25);
+	//list_instance.push_back(28);
+	//list_instance.push_back(29);
 
-			AvailableInstances id(static_cast<AvailableInstances>(i));
-			RegisteredInstance instance(id);
-			instance.out();			
+	// préparation de l'output qu iszera effacer à chaque run !!
+	
+	std::ofstream file("output.csv");
+	
+	file << "id;nom;n;k;amax;nbLevel; ";
+	file << "ite0;score0;CPU0; ";
+	file << "start;";
+	file << "ite;score;CPU;";
+	//file << "Rapport Scores (%);Rapport iterations total(%); rapport iterations moyen(%);Rapport temps(%)";
+	file << std::endl;
+	// ce programme lance les tests sur toutes les instances.
+	std::ofstream debug("debug.log");
+	
+	for(auto const & i : list_instance) {
+		AvailableInstances id(static_cast<AvailableInstances>(i));
+		RegisteredInstance instance(id);
+		instance.out();
+		// on va tester notre algo pour un nombre de classe compris [2 , 15% Nbpoint] en incrementant de 1
+		size_t const kmax( (size_t)std::ceil(instance.nbObs()*0.15) );
+		size_t const amax( (size_t)std::ceil(instance.nbObs()*0.05) );
+		// mais on arrete si notre algo n'est plus en multi-level.
+		for(size_t k(3); k<kmax; ++k)
+		{
 			MultiLevelAlgo algo(instance, k);
-			algo.buildMultiLevelData(20*k, std::ceil(instance.nbObs()/4.0));
+			algo.setOut(debug);
+			// on agrege 20k des noeuds par palier de 5% des noeuds totaux 
+			algo.buildMultiLevelData(20*k, amax);
 			Partition start(instance.nbObs(), k);
-			 //generation du point de depart
+			//generation du point de depart
 			algo.getStartPoint(start);
-            
-			// ----s
-			bool done(false);
-			std::ofstream file("output.csv");
-			algo.setOut(file);
-			//algo.out() << "
-			// pour nos tests on va créer une liste sur le premier niveau a traiter et une deuxieme pour les sauts.
-			// MR : commencer par faire sans saut .... !!!!
-			algo.setStep(1);
-			std::vector<MultiLevelAlgoStats> allStats(algo.nbLevels()+1);
+			// pour le moment on garde un pas constant de 1
+			algo.setStep(1);	
+			std::map<size_t, MultiLevelAlgoStats> allStats;
+
 			for(size_t level(0); level<=algo.nbLevels(); ++level){
+				if(level>0)
+					level=algo.nbLevels();
 				algo.setStartPoint(start);
 				algo.setStartLevel(level);
 				algo.launch();
 				allStats[level] = algo.stats();
 			}
-			/*
+			
 			std::vector<double> sumsIte(algo.nbLevels()+1);
+			std::vector<size_t> nbIte(algo.nbLevels()+1);
+			std::vector<double> score(algo.nbLevels()+1);
 			std::vector<double> sumsTime(algo.nbLevels()+1);
-			std::vector<double> sumsCost(algo.nbLevels()+1);
-			//*/
-			for (size_t level(0); level<=algo.nbLevels(); ++level)
+
+			for( auto const & stat : allStats)
 			{
-				double sumIte = 0.0 , sumTime = 0.0 , sumCost = 0.0 ;
-				size_t cpt = 0 ;
+				size_t const level(stat.first);
+				nbIte[level]=allStats[level].size();
+				score[level]=allStats[level].rbegin()->second._cost;
 				for (auto & stat : allStats[level]) {
-					sumIte += (double) stat.second._ite ;
-					sumTime += stat.second._time ;
-					sumCost += stat.second._cost ;
-					cpt++ ;
-				}
-				/*			
-				sumsIte[level] = sumIte / ((double) cpt) ;
-				sumsTime[level] = sumTime / ((double) cpt) ;
-				sumsCost[level] = sumCost / ((double) cpt) ;
-				//*/
-				algo.out() << "_________________________________________________________" << std::endl ;
-				algo.out() << "Niveau de départ : " << level << std::endl ;
-				algo.out() << "Nombre moyen d'itérations :" << sumIte / ((double) cpt)  << std::endl ;
-				algo.out() << "Temps moyen des k-moyennes :" << sumTime / ((double) cpt)  << std::endl ;
-				algo.out() << "Temps total des k-moyennes :" << sumTime  << std::endl ;
-				algo.out() << "Coût moyen :" << sumCost / ((double) cpt)  << std::endl ;
-				algo.out() << "Coût final :" << allStats[level][(--(allStats[level].end()))->first]._cost  << std::endl ;
-				algo.out() << "_________________________________________________________" << std::endl ;
+					sumsIte	[level]  += stat.second._ite ;
+					sumsTime[level] += stat.second._time ;
+				}							
+			}
+			for( auto const & stat : allStats)
+			{
+				size_t const level(stat.first);
+				//double RapCost	( (scoreTot[level]-sumsCost[algo.nbLevels()])/sumsCost[algo.nbLevels()]);
+				//double RapIte	( (sumsIteTot[level]-sumsIteTot[algo.nbLevels()])/sumsIteTot[algo.nbLevels()]);
+				//double RapTime	( (sumsTimeTot[level]-sumsTimeTot[algo.nbLevels()])/sumsTimeTot[algo.nbLevels()]);
+				//double RapIteMoy( (sumsIte[level]-sumsIte[algo.nbLevels()])/sumsIte[algo.nbLevels()]);
+
+				WriteCsv(file, i, 6);
+				WriteCsv(file, instance.name);
+				WriteCsv(file, instance.nbObs());
+				WriteCsv(file, k);
+				WriteCsv(file, amax);
+				WriteCsv(file, algo.nbLevels()+1);
+				WriteCsv(file, sumsIte [algo.nbLevels()] );
+				WriteCsv(file, score[algo.nbLevels()], 15);
+				WriteCsv(file, sumsTime[algo.nbLevels()], 6);
+				WriteCsv(file, level);
+				WriteCsv(file, sumsIte [level] );
+				WriteCsv(file, score[level], 15);
+				WriteCsv(file, sumsTime[level], 6);
+				file << std::endl;
 			}
-			file.close();
+			break;
 		}
 	}
-	
+	file.close();
+	debug.close();
+	system("pause");
 	return 0; 
 }

From 5536cda294a911f72315d7a65abf3132485f7e4f Mon Sep 17 00:00:00 2001
From: Manuel Ruiz <manuel.jean.ruiz@gmail.com>
Date: Fri, 15 Feb 2013 23:33:07 +0100
Subject: [PATCH 12/14] OK

---
 projet_zz/MultiLevelKMInstance.cpp | 141 +++++++++++++++++++++--------
 projet_zz/MultiLevelKMInstance.h   |   6 +-
 projet_zz/main.cpp                 |  33 +++----
 src/KMConstraints.hpp              |  13 ++-
 src/KMInput.cpp                    |  10 +-
 src/KMInstance.cpp                 |  77 +++++++++-------
 6 files changed, 180 insertions(+), 100 deletions(-)

diff --git a/projet_zz/MultiLevelKMInstance.cpp b/projet_zz/MultiLevelKMInstance.cpp
index fa2e9b3..d5404a8 100644
--- a/projet_zz/MultiLevelKMInstance.cpp
+++ b/projet_zz/MultiLevelKMInstance.cpp
@@ -13,10 +13,11 @@
 #include <fstream>
 
 
-MultiLevelAlgo::MultiLevelAlgo(KMInstance const & instance, size_t k,Partition startPoint) :
-	_instance(instance), _input(_instance, k),_startPoint(startPoint) {
+MultiLevelAlgo::MultiLevelAlgo(KMInstance const & instance, size_t k) :
+	_instance(instance), _input(_instance, k),_startPoint(_instance.nbObs(), k) {
 		// par defaut sur la sortie standard.
 		setOut();
+		_step =1;
 }
 
 
@@ -26,7 +27,6 @@ MultiLevelAlgo::~MultiLevelAlgo() {
 		delete ptr;
 }
 void MultiLevelAlgo::buildInstance(size_t level, KMInstance & instance,Aggregations & aggregations) {
-	// on enlève toutes les contraintes
 	_instance.mustLinks().clear();
 	_instance.cannotLinks().clear();
 	for (size_t i(0); i < level; ++i) {
@@ -34,9 +34,7 @@ void MultiLevelAlgo::buildInstance(size_t level, KMInstance & instance,Aggregati
 			_instance.addMustLink(ctr.first, ctr.second);
 		}
 	}
-	// construit les infos de correspondances entre les instances
 	_instance.buildMustLink(aggregations);
-	// construit l'instance aggrégée
 	instance = KMInstance(_instance, aggregations);
 }
 
@@ -45,7 +43,7 @@ void MultiLevelAlgo::buildInstance(size_t level, KMInstance & instance,Aggregati
 // @param nbNodes    : limite pour le graph le plus agrégé 
 // @param nbNodesMax : limite max de noeuds agrégé par étape
 void MultiLevelAlgo::buildMultiLevelData(double nbNodes,double nbNodesMax) {
-
+	#if 1
 	KMPartition partition(_instance, _instance.nbObs());
 	// on crée les singletons
 	for(size_t i(0); i<_instance.nbObs(); ++i)
@@ -57,8 +55,8 @@ void MultiLevelAlgo::buildMultiLevelData(double nbNodes,double nbNodesMax) {
 		// definit un nouveau niveau
 		_multiLevelConstraints.push_back(new KMConstraints(_input.nbObs()));
 		//
-		size_t compteur=0;
-		while(!used.empty() && compteur < nbNodesMax){
+		size_t compteur(0);
+		while(!used.empty() && compteur < nbNodesMax && partition.nbLabels() > nbNodes ){
 			size_t const m = used.pop_random();
 			if( !used.empty()){
 				// calculer la distance de ce centre avec les autres
@@ -77,9 +75,14 @@ void MultiLevelAlgo::buildMultiLevelData(double nbNodes,double nbNodesMax) {
 		};
 		// ajouter les contraintes associée à ce niveau
 	};
-	std::cout << "nbNodes     "<<nbNodes <<std::endl;
+	std::cout << "nbNodes     "<<partition.nbLabels() <<std::endl;
 	std::cout << "nbNodesMax  "<<nbNodesMax <<std::endl;
 	std::cout << "Built       "<<nbLevels() << " aggregation levels"<<std::endl;
+	#else
+		_multiLevelConstraints.push_back(new KMConstraints(_input.nbObs()));
+		_multiLevelConstraints.back()->newCtr(0,2);
+		_multiLevelConstraints.back()->newCtr(1,2);
+	#endif
 }
 //
 // _step: 
@@ -92,30 +95,52 @@ void MultiLevelAlgo::refine() {
 	KMInstance instance;
 	Aggregations aggregations;	
 	Timer timer;
+	//std::cout << "_input value : "<<_input.computeCost() << std::endl;
 	// pour chaque level
-	for ( size_t level(_startLevel); level <= _multiLevelConstraints.size(); level+= _step) {
+	for ( int level(_startLevel); level >= 0; level-= _step) {
+	//for ( size_t level(_startLevel); level <= _multiLevelConstraints.size(); level+= _step) {
 		// ! on parcours à l'envers
-		buildInstance(_multiLevelConstraints.size() - level, instance,aggregations);
+		buildInstance( level, instance,aggregations);
+		//for (size_t i(0); i < aggregations.v.size(); ++i) {		
+		//	assert(!aggregations.v[i].empty());
+		//	size_t const l(_input.label(*aggregations.v[i].begin()));
+		//	
+		//	for(auto const & j : aggregations.v[i]){
+		//		assert(aggregations.newIds[j] == i);
+		//		assert( _input.label(j) == l);
+		//	}
+		//}
 		timer.restart();
 		KMInput input(instance, _input.maxNbLabels());
-		// initialiser cette input avec la solkution courante
-		// attention il faut utiliser aggregation pour faire les neodus agrégés et la solution courante
-
-		for (size_t i(0); i < _input.nbObs(); ++i) {
-			input.shiftForced(aggregations.newIds[i], _input.label(i));
-		}
-
-
+		//std::cout << input.centers() << std::endl;
+		//input.computeCenters();
+		//for (size_t i(0); i < _input.nbObs(); ++i) {
+		// il faut une solution faisable 
+		for (size_t i(0); i < aggregations.v.size(); ++i) {			
+			input.shiftForced(i, _input.label(*aggregations.v[i].begin() ));			
+		}		
+		//std::cout << input.centers() << std::endl;
+		//input.computeCenters();
+		//std::cout << input.centers() << std::endl;
+		//std::cout << " input value : "<< input.computeCost() << std::endl;
 		// on lance l'algo
-		HMeans<true>()(input);
-		// on stocke les stats
-		
-		// suavegarde de la solution
-		input.computeCenters();
-		for (size_t i(0); i < _input.nbObs(); ++i) {
-			_input.shiftForced(i, input.label(aggregations.newIds[i]));
+		HMeans<false>()(input);
+		// sauvegarde de la solution
+		//for (size_t i(0); i < _input.nbObs(); ++i) {
+		//	_input.shiftForced(i, input.label(aggregations.newIds[i]));
+		//}
+		for (size_t i(0); i < aggregations.v.size(); ++i) {
+			for(auto const & j : aggregations.v[i])
+				_input.shiftForced(j, input.label(i) );			
 		}
-		// attention à la fin car on souhaite compter le temps des deux boucles au dessus
+		//for(auto const & i : aggregations.v){
+		//	assert(!i.empty());
+		//	size_t const l(_input.label(*i.begin()));
+		//	for(auto const & j : i)
+		//		assert( _input.label(j) == l);
+		//}
+		//std::cout << "_input value : "<<_input.computeCost() << std::endl;
+		// on stocke les stats
 		_stats[ level] = MultiLevelAlgoStat( level, input.ite(), timer.elapsed(), input.cost());
 	}
 
@@ -125,13 +150,13 @@ void MultiLevelAlgo::refine() {
 
 	/*if(level>_multiLevelConstraints.size())
 	{
-		// on lance l'algo
-		HMeans<true>()(_input);
-		out()<<"Niveau de rafinement         : " <<0<<std::endl;
-		out()<<"Nombre d'iteration par etape : " <<_input.ite()<<std::endl;
-		out()<<"Temps ecoule                 : " <<timer.elapsed()<<std::endl;
-		out()<<"Valeur du cout               : " <<_input.cost()<<std::endl;
-		out()<<std::endl;
+	// on lance l'algo
+	HMeans<true>()(_input);
+	out()<<"Niveau de rafinement         : " <<0<<std::endl;
+	out()<<"Nombre d'iteration par etape : " <<_input.ite()<<std::endl;
+	out()<<"Temps ecoule                 : " <<timer.elapsed()<<std::endl;
+	out()<<"Valeur du cout               : " <<_input.cost()<<std::endl;
+	out()<<std::endl;
 
 	}*/
 }
@@ -147,10 +172,34 @@ void MultiLevelAlgo::launch() {
 	_stats.clear();
 	std::cout << "Step  : "<<_step		<< std::endl;
 	std::cout << "Level : "<<_startLevel<< std::endl;
-	// initialisation au point de départ
+	// initialisation au point de depart
 	for (size_t i(0); i < _input.nbObs(); ++i) {
 		_input.shiftForced(i, _startPoint.label(i));
+		//file << i << " - "<< _startPoint.label(i)<<std::endl;
 	}		
+	//KMInstance instance;
+	//Aggregations aggregations;	
+	//for ( int level(0); level <= nbLevels(); level+= _step) {
+	//	std::cout << "checking " << level << std::endl;
+	//	buildInstance(level, instance,aggregations);
+	//	KMInput input(instance, _input.maxNbLabels());
+	//	std::cout << input.centers() << std::endl;
+	//	std::ofstream file(std::to_string(level).c_str());
+	//	for(auto const & i : aggregations.v){
+	//		if(i.size()>1)
+	//		DisplayContainer(file , i);
+	//	}
+	//	file.close();
+	//	for(auto const & i : aggregations.v){
+	//		assert(!i.empty());
+	//		size_t const l(_input.label(*i.begin()));
+	//		DisplayContainer(std::cout , i);
+	//		for(auto const & j : i)
+	//			assert( _input.label(j) == l);
+	//	}
+	//}
+	std::cout << "Starting point value : "<<_input.computeCost() << std::endl;
+
 	// lancement du run 
 	refine();
 
@@ -161,13 +210,29 @@ size_t MultiLevelAlgo::nbLevels()const{
 void MultiLevelAlgo::getStartPoint( Partition  & point){
 	KMInstance instance;
 	Aggregations aggregations;	
-	buildInstance(_multiLevelConstraints.size(), instance,aggregations);
+	buildInstance(nbLevels(), instance,aggregations);
 	KMInput input(instance, _input.maxNbLabels());
 	input.random(0);	
+	std::cout << "Starting point value : "<<input.computeCost() << std::endl;
 	for (size_t i(0); i < _input.nbObs(); ++i) {
 		point.shift(i, input.label(aggregations.newIds[i]));
 	}
-	std::cout << "Starting point value : "<<input.computeCost() << std::endl;
+	//KMInput input2(_instance, _input.maxNbLabels());
+	//// initialiser cette input avec la solkution courante
+	//// attention il faut utiliser aggregation pour faire les neodus agrégés et la solution courante
+	//for (size_t i(0); i < _input.nbObs(); ++i) {
+	//	input2.shiftForced(i, point.label(i));
+	//}
+	//std::cout << "Starting point value : "<<input2.computeCost() << std::endl;
+	//for ( int level(nbLevels()); level >= 0; level-= _step) {
+	//	buildInstance(level, instance,aggregations);
+	//	for(auto const & i : aggregations.v){
+	//		assert(!i.empty());
+	//		size_t const l(_input.label(*i.begin()));
+	//		for(auto const & j : i)
+	//			assert( _input.label(j) == l);
+	//	}
+	//}
 }
 
 
@@ -183,7 +248,7 @@ void MultiLevelAlgo::setStep(size_t step){
 
 
 void MultiLevelAlgo::setStartPoint( Partition  & point){
-	_startPoint = point;
+	_startPoint = point;	
 }
 
 std::ostream & MultiLevelAlgo::out(){
diff --git a/projet_zz/MultiLevelKMInstance.h b/projet_zz/MultiLevelKMInstance.h
index 3ecbc9a..11348be 100644
--- a/projet_zz/MultiLevelKMInstance.h
+++ b/projet_zz/MultiLevelKMInstance.h
@@ -33,7 +33,7 @@ typedef std::map<size_t, MultiLevelAlgoStat>  MultiLevelAlgoStats;
 class MultiLevelAlgo {
 public:
 public:
-	MultiLevelAlgo(KMInstance const &, size_t k,Partition _startPoint=0);
+	MultiLevelAlgo(KMInstance const &, size_t k);
 	virtual ~MultiLevelAlgo();
 public:
 	// pour lancer les kmmeans
@@ -64,8 +64,8 @@ class MultiLevelAlgo {
 	// les contraintes de chaque niveau : incrementalement
 	std::vector<KMConstraints *> _multiLevelConstraints;
 
-	size_t _startLevel;
-	size_t _step;
+	int _startLevel;
+	int _step;
 	Partition _startPoint;
 	std::ostream * _out;
 	Number _totalKMtimer;
diff --git a/projet_zz/main.cpp b/projet_zz/main.cpp
index 6297c37..833a550 100644
--- a/projet_zz/main.cpp
+++ b/projet_zz/main.cpp
@@ -47,11 +47,11 @@ int main(int argc, char ** argv) {
 	Number::SetSeed(1);
 	//liste des instances a tester
 	std::list<size_t> list_instance;
-	list_instance.push_back(0);
+	//list_instance.push_back(0);
 	//list_instance.push_back(1);
 	//list_instance.push_back(4);
 	//list_instance.push_back(7);
-	//list_instance.push_back(8);
+	list_instance.push_back(8);
 	//list_instance.push_back(9);
 	//list_instance.push_back(12);
 	//list_instance.push_back(15);
@@ -82,6 +82,8 @@ int main(int argc, char ** argv) {
 		// on va tester notre algo pour un nombre de classe compris [2 , 15% Nbpoint] en incrementant de 1
 		size_t const kmax( (size_t)std::ceil(instance.nbObs()*0.15) );
 		size_t const amax( (size_t)std::ceil(instance.nbObs()*0.05) );
+		std::cout << "amax = "<<amax<<std::endl;
+
 		// mais on arrete si notre algo n'est plus en multi-level.
 		for(size_t k(3); k<kmax; ++k)
 		{
@@ -96,19 +98,18 @@ int main(int argc, char ** argv) {
 			algo.setStep(1);	
 			std::map<size_t, MultiLevelAlgoStats> allStats;
 
-			for(size_t level(0); level<=algo.nbLevels(); ++level){
-				if(level>0)
-					level=algo.nbLevels();
+			for(size_t level(0); level<=algo.nbLevels(); ++level)
+			{				
 				algo.setStartPoint(start);
 				algo.setStartLevel(level);
 				algo.launch();
 				allStats[level] = algo.stats();
 			}
 			
-			std::vector<double> sumsIte(algo.nbLevels()+1);
-			std::vector<size_t> nbIte(algo.nbLevels()+1);
-			std::vector<double> score(algo.nbLevels()+1);
-			std::vector<double> sumsTime(algo.nbLevels()+1);
+			std::map<size_t,double> sumsIte;
+			std::map<size_t,size_t> nbIte;
+			std::map<size_t,double> score;
+			std::map<size_t,double> sumsTime;
 
 			for( auto const & stat : allStats)
 			{
@@ -133,14 +134,14 @@ int main(int argc, char ** argv) {
 				WriteCsv(file, instance.nbObs());
 				WriteCsv(file, k);
 				WriteCsv(file, amax);
-				WriteCsv(file, algo.nbLevels()+1);
-				WriteCsv(file, sumsIte [algo.nbLevels()] );
-				WriteCsv(file, score[algo.nbLevels()], 15);
-				WriteCsv(file, sumsTime[algo.nbLevels()], 6);
+				WriteCsv(file, algo.nbLevels());
+				WriteCsv(file, sumsIte	[0] );
+				WriteCsv(file, score	[0], 15);
+				WriteCsv(file, sumsTime	[0], 6);
 				WriteCsv(file, level);
-				WriteCsv(file, sumsIte [level] );
-				WriteCsv(file, score[level], 15);
-				WriteCsv(file, sumsTime[level], 6);
+				WriteCsv(file, sumsIte	[level] );
+				WriteCsv(file, score	[level], 15);
+				WriteCsv(file, sumsTime	[level], 6);
 				file << std::endl;
 			}
 			break;
diff --git a/src/KMConstraints.hpp b/src/KMConstraints.hpp
index 0abd370..3859ff5 100644
--- a/src/KMConstraints.hpp
+++ b/src/KMConstraints.hpp
@@ -70,13 +70,11 @@ inline KMConstraints::~KMConstraints() {
 }
 
 inline void KMConstraints::newCtr(size_t i, size_t j) {
-  assert(i < _byObs.size() && j < _byObs.size());
-
-	if (i != j) {
-		_all.insert(std::make_pair(std::min(i, j), std::max(i, j)));
-		_byObs[i].insert(j);
-		_byObs[j].insert(i);
-	}
+	assert(i < _byObs.size() && j < _byObs.size());
+	assert(i != j);
+	_all.insert(std::make_pair(std::min(i, j), std::max(i, j)));
+	_byObs[i].insert(j);
+	_byObs[j].insert(i);
 }
 
 inline IntSet const & KMConstraints::get(size_t obs) const {
@@ -100,4 +98,5 @@ inline KMConstraints::const_iterator KMConstraints::end() const {
 
 }
 
+
 #endif /* KMCONSTRAINTS_HPP_ */
diff --git a/src/KMInput.cpp b/src/KMInput.cpp
index e441732..a7ff425 100644
--- a/src/KMInput.cpp
+++ b/src/KMInput.cpp
@@ -47,10 +47,12 @@ KMInput::~KMInput() {
 void KMInput::shiftForced(size_t obs, size_t to) {
 	//	std::cout << "KMInput\n";
 	size_t const from(label(obs));
-	KMPartition::shiftForced(obs, to);
-	_modifiedLabels.insert(from);
-	_modifiedLabels.insert(to);
-	_modifiedObs.insert(obs);
+	if(from != to ){
+		KMPartition::shiftForced(obs, to);
+		_modifiedLabels.insert(from);
+		_modifiedLabels.insert(to);
+		_modifiedObs.insert(obs);
+	}
 }
 bool KMInput::shift(size_t obs, size_t to) {
 	//	std::cout << "KMInput\n";
diff --git a/src/KMInstance.cpp b/src/KMInstance.cpp
index b684bd4..45fa472 100644
--- a/src/KMInstance.cpp
+++ b/src/KMInstance.cpp
@@ -17,20 +17,24 @@ KMInstance::KMInstance(KMInstance const & instance,
 	allocate(aggregations.v.size(), instance.nbAtt());
 	std::fill_n(_weights.begin(), _weights.size(), 0);
 
+	size_t n(0);
 	for (size_t i(0); i < aggregations.v.size(); ++i) {
-		for (auto const & j : aggregations.v[i])
-			for (size_t d(0); d < nbAtt(); ++d)
-				_data.plus(i, d, instance.get(j, d));
-
-		assert(aggregations.v[i].size() > 0);
-		_weights[i] = static_cast<Double>(aggregations.v[i].size());
-		assert(_weights[i]> 0);
-		for (size_t d(0); d < nbAtt(); ++d)
-			_data.get(i, d) /= _weights[i];
-		if (_weights[i] > 1) {
+		if(!aggregations.v[i].empty()){
 			for (auto const & j : aggregations.v[i])
 				for (size_t d(0); d < nbAtt(); ++d)
-					_cst += std::pow(get(i, d) - instance.get(j, d), 2);
+					_data.plus(n, d, instance.get(j, d));
+
+			assert(aggregations.v[i].size() > 0);
+			_weights[n] = static_cast<Double>(aggregations.v[i].size());
+			assert(_weights[n]> 0);
+			for (size_t d(0); d < nbAtt(); ++d)
+				_data.get(n, d) /= _weights[n];
+			if (_weights[n] > 1) {
+				for (auto const & j : aggregations.v[i])
+					for (size_t d(0); d < nbAtt(); ++d)
+						_cst += std::pow(get(n, d) - instance.get(j, d), 2);
+			}
+			++n;
 		}
 	}
 	// les contraintes cannot link
@@ -82,33 +86,42 @@ void KMInstance::readConstraints(std::string const & fileName) {
 }
 
 void KMInstance::buildMustLink(Aggregations & result) const {
-	std::list<IntSet> aggregations;
-	std::vector<std::list<IntSet>::iterator> temp(nbObs(), aggregations.end());
+	result.v.clear();	
 	size_t n(0);
+	std::vector<IntSet> temp(nbObs());
+	// au départ on a des singletons
+	for(size_t i(0); i<nbObs(); ++i){
+		temp[i].insert(i);
+	}
 	result.newIds.assign(nbObs(), -1);
-
-	for (size_t i(0); i < nbObs(); ++i) {
-		auto it(temp[i]);
-		if (it == aggregations.end()) {
-			aggregations.push_front(IntSet());
-			temp[i] = aggregations.begin();
-			temp[i]->insert(i);
-			result.newIds[i] = n;
-			++n;
+	// on fusionne les 
+	for(auto const & p : _must){
+		size_t const i(p.first);
+		size_t const j(p.second);
+		for(auto & si : temp[i]){
+			for(auto & sj : temp[j]){
+				temp[si].insert(temp[sj].begin(),temp[sj].end());
+				temp[sj].insert(temp[si].begin(),temp[si].end());
+			}
 		}
-		for (auto const & j : _must.get(i)) {
-			temp[j] = temp[i];
-			result.newIds[j] = result.newIds[i];
-			temp[j]->insert(j);
+	}
+	std::set<IntSet> trimmer;
+	for(auto & it : temp)
+		if(!trimmer.insert(it).second)
+			it.clear();
+	result.v.reserve(nbObs());
+	for(size_t i(0); i<nbObs(); ++i){
+		if(!(temp[i].empty())){
+			for(auto const & j :temp[i])
+				result.newIds[j]=n;
+			result.v.push_back( temp[i] );
+			++n;
 		}
 	}
-
 	OUT<< "found "<<n<<" aggregated point\n";
-	result.v.assign(n, IntSet());
-	std::copy(aggregations.rbegin(), aggregations.rend(), result.v.begin());
-	for (auto const & id : result.newIds) {
-		assert(id < n);
-	}
+	//for (auto const & id : result.newIds) {
+	//	assert(id < n);
+	//}
 }
 
 bool KMInstance::feasible(IPartition const & p) const {

From 16b745277dab96166814840a271d3244fdfddbed Mon Sep 17 00:00:00 2001
From: klorel <manuel.jean.ruiz@gmail.com>
Date: Sat, 16 Feb 2013 17:03:45 +0100
Subject: [PATCH 13/14] dd

---
 projet_zz/MultiLevelKMInstance.cpp | 161 +++++++++++++++--------------
 projet_zz/main.cpp                 |  85 +++++++--------
 src/KMInstance.cpp                 |  32 +++---
 3 files changed, 137 insertions(+), 141 deletions(-)

diff --git a/projet_zz/MultiLevelKMInstance.cpp b/projet_zz/MultiLevelKMInstance.cpp
index d5404a8..326877a 100644
--- a/projet_zz/MultiLevelKMInstance.cpp
+++ b/projet_zz/MultiLevelKMInstance.cpp
@@ -1,9 +1,9 @@
 /*
-* MultiLevelKMInstance.cpp
-*
-*  Created on: 15 déc. 2012
-*      Author: manuel
-*/
+ * MultiLevelKMInstance.cpp
+ *
+ *  Created on: 15 déc. 2012
+ *      Author: manuel
+ */
 
 #include "../projet_zz/MultiLevelKMInstance.h"
 #include "../src/HMeans.hpp"
@@ -12,21 +12,20 @@
 #include <iostream>
 #include <fstream>
 
-
 MultiLevelAlgo::MultiLevelAlgo(KMInstance const & instance, size_t k) :
-	_instance(instance), _input(_instance, k),_startPoint(_instance.nbObs(), k) {
-		// par defaut sur la sortie standard.
-		setOut();
-		_step =1;
+		_instance(instance), _input(_instance, k), _startPoint(
+				_instance.nbObs(), k) {
+	// par defaut sur la sortie standard.
+	setOut();
+	_step = 1;
 }
 
-
-
 MultiLevelAlgo::~MultiLevelAlgo() {
 	for (auto & ptr : _multiLevelConstraints)
 		delete ptr;
 }
-void MultiLevelAlgo::buildInstance(size_t level, KMInstance & instance,Aggregations & aggregations) {
+void MultiLevelAlgo::buildInstance(size_t level, KMInstance & instance,
+		Aggregations & aggregations) {
 	_instance.mustLinks().clear();
 	_instance.cannotLinks().clear();
 	for (size_t i(0); i < level; ++i) {
@@ -38,36 +37,41 @@ void MultiLevelAlgo::buildInstance(size_t level, KMInstance & instance,Aggregati
 	instance = KMInstance(_instance, aggregations);
 }
 
-
 // @brief construit une suite de problèmes agrégés en agrégeant nbNodesMax noeuds par niveau et en produisant des graphes avec au plus nbNodes noeuds
 // @param nbNodes    : limite pour le graph le plus agrégé 
 // @param nbNodesMax : limite max de noeuds agrégé par étape
-void MultiLevelAlgo::buildMultiLevelData(double nbNodes,double nbNodesMax) {
-	#if 1
+void MultiLevelAlgo::buildMultiLevelData(double nbNodes, double nbNodesMax) {
+#if 1
 	KMPartition partition(_instance, _instance.nbObs());
 	// on crée les singletons
-	for(size_t i(0); i<_instance.nbObs(); ++i)
-		partition.shift(i,i);
+	for (size_t i(0); i < _instance.nbObs(); ++i)
+		partition.shift(i, i);
 
-	while(partition.nbLabels() > nbNodes ){
-		std::cout << "partition.nbLabels() : "<<partition.nbLabels()<<std::endl;
+	while (partition.nbLabels() > nbNodes) {
+//		std::cout << "partition.nbLabels() : " << partition.nbLabels()
+//				<< std::endl;
 		IndexedList used(partition.usedLabels());
 		// definit un nouveau niveau
 		_multiLevelConstraints.push_back(new KMConstraints(_input.nbObs()));
 		//
 		size_t compteur(0);
-		while(!used.empty() && compteur < nbNodesMax && partition.nbLabels() > nbNodes ){
+		while (!used.empty() && compteur < nbNodesMax
+				&& partition.nbLabels() > nbNodes) {
 			size_t const m = used.pop_random();
-			if( !used.empty()){
+			if (!used.empty()) {
 				// calculer la distance de ce centre avec les autres
 				std::multimap<Double, size_t> neighbor;
-				for(auto const & c : partition.usedLabels()){
-					if ( m != c)
-						neighbor.insert( std::make_pair(partition.getDistanceCenter(m,c) , c));
+				for (auto const & c : partition.usedLabels()) {
+					if (m != c)
+						neighbor.insert(
+								std::make_pair(
+										partition.getDistanceCenter(m, c), c));
 				}
 				size_t const c(neighbor.begin()->second);
-				_multiLevelConstraints.back()->newCtr(*partition.observations(m).begin(),*partition.observations(c).begin());
-				partition.fusion(m,c);				
+				_multiLevelConstraints.back()->newCtr(
+						*partition.observations(m).begin(),
+						*partition.observations(c).begin());
+				partition.fusion(m, c);
 				// si plusieurs plusieurs plus pret : tirer au hazard (aprés)
 				used.erase(c);
 				compteur++;
@@ -75,14 +79,15 @@ void MultiLevelAlgo::buildMultiLevelData(double nbNodes,double nbNodesMax) {
 		};
 		// ajouter les contraintes associée à ce niveau
 	};
-	std::cout << "nbNodes     "<<partition.nbLabels() <<std::endl;
-	std::cout << "nbNodesMax  "<<nbNodesMax <<std::endl;
-	std::cout << "Built       "<<nbLevels() << " aggregation levels"<<std::endl;
-	#else
-		_multiLevelConstraints.push_back(new KMConstraints(_input.nbObs()));
-		_multiLevelConstraints.back()->newCtr(0,2);
-		_multiLevelConstraints.back()->newCtr(1,2);
-	#endif
+	std::cout << "nbNodes     " << partition.nbLabels() << std::endl;
+	std::cout << "nbNodesMax  " << nbNodesMax << std::endl;
+	std::cout << "Built       " << nbLevels() << " aggregation levels"
+			<< std::endl;
+#else
+	_multiLevelConstraints.push_back(new KMConstraints(_input.nbObs()));
+	_multiLevelConstraints.back()->newCtr(0,2);
+	_multiLevelConstraints.back()->newCtr(1,2);
+#endif
 }
 //
 // _step: 
@@ -93,14 +98,14 @@ void MultiLevelAlgo::refine() {
 	// à chaque fois on initialise avec le niveau précédent (sauf le premier!)
 	// Pour le premier faire un appel à random(0);
 	KMInstance instance;
-	Aggregations aggregations;	
+	Aggregations aggregations;
 	Timer timer;
 	//std::cout << "_input value : "<<_input.computeCost() << std::endl;
 	// pour chaque level
-	for ( int level(_startLevel); level >= 0; level-= _step) {
-	//for ( size_t level(_startLevel); level <= _multiLevelConstraints.size(); level+= _step) {
+	for (int level(_startLevel); level >= 0; level -= _step) {
+		//for ( size_t level(_startLevel); level <= _multiLevelConstraints.size(); level+= _step) {
 		// ! on parcours à l'envers
-		buildInstance( level, instance,aggregations);
+		buildInstance(level, instance, aggregations);
 		//for (size_t i(0); i < aggregations.v.size(); ++i) {		
 		//	assert(!aggregations.v[i].empty());
 		//	size_t const l(_input.label(*aggregations.v[i].begin()));
@@ -110,28 +115,31 @@ void MultiLevelAlgo::refine() {
 		//		assert( _input.label(j) == l);
 		//	}
 		//}
-		timer.restart();
 		KMInput input(instance, _input.maxNbLabels());
 		//std::cout << input.centers() << std::endl;
 		//input.computeCenters();
 		//for (size_t i(0); i < _input.nbObs(); ++i) {
 		// il faut une solution faisable 
-		for (size_t i(0); i < aggregations.v.size(); ++i) {			
-			input.shiftForced(i, _input.label(*aggregations.v[i].begin() ));			
-		}		
+		for (size_t i(0); i < aggregations.v.size(); ++i) {
+			input.shiftForced(i, _input.label(*aggregations.v[i].begin()));
+		}
 		//std::cout << input.centers() << std::endl;
 		//input.computeCenters();
 		//std::cout << input.centers() << std::endl;
 		//std::cout << " input value : "<< input.computeCost() << std::endl;
 		// on lance l'algo
+		timer.restart();
 		HMeans<false>()(input);
+		_stats[level] = MultiLevelAlgoStat(level, input.ite(), timer.elapsed(),
+				input.cost());
+
 		// sauvegarde de la solution
 		//for (size_t i(0); i < _input.nbObs(); ++i) {
 		//	_input.shiftForced(i, input.label(aggregations.newIds[i]));
 		//}
 		for (size_t i(0); i < aggregations.v.size(); ++i) {
-			for(auto const & j : aggregations.v[i])
-				_input.shiftForced(j, input.label(i) );			
+			for (auto const & j : aggregations.v[i])
+				_input.shiftForced(j, input.label(i));
 		}
 		//for(auto const & i : aggregations.v){
 		//	assert(!i.empty());
@@ -141,42 +149,39 @@ void MultiLevelAlgo::refine() {
 		//}
 		//std::cout << "_input value : "<<_input.computeCost() << std::endl;
 		// on stocke les stats
-		_stats[ level] = MultiLevelAlgoStat( level, input.ite(), timer.elapsed(), input.cost());
 	}
 
-
 	// pb ici traitement du dernier niveau
 
-
 	/*if(level>_multiLevelConstraints.size())
-	{
-	// on lance l'algo
-	HMeans<true>()(_input);
-	out()<<"Niveau de rafinement         : " <<0<<std::endl;
-	out()<<"Nombre d'iteration par etape : " <<_input.ite()<<std::endl;
-	out()<<"Temps ecoule                 : " <<timer.elapsed()<<std::endl;
-	out()<<"Valeur du cout               : " <<_input.cost()<<std::endl;
-	out()<<std::endl;
+	 {
+	 // on lance l'algo
+	 HMeans<true>()(_input);
+	 out()<<"Niveau de rafinement         : " <<0<<std::endl;
+	 out()<<"Nombre d'iteration par etape : " <<_input.ite()<<std::endl;
+	 out()<<"Temps ecoule                 : " <<timer.elapsed()<<std::endl;
+	 out()<<"Valeur du cout               : " <<_input.cost()<<std::endl;
+	 out()<<std::endl;
 
-	}*/
+	 }*/
 }
 // @brief lance l'algorithme multi-niveau à partir d'une suite d'agrégation, d'une partition de départ et d'un niveau de départ et avec un pas donné
 // _step: 
 // _startLevel : niveau de départ pour le raffinement
 // _startPoint : (attention doit être compatible avec le niveau de plus agrégé)
 
-void MultiLevelAlgo::setOut(std::ostream & stream){
+void MultiLevelAlgo::setOut(std::ostream & stream) {
 	_out = &stream;
 }
 void MultiLevelAlgo::launch() {
 	_stats.clear();
-	std::cout << "Step  : "<<_step		<< std::endl;
-	std::cout << "Level : "<<_startLevel<< std::endl;
+	std::cout << "Step  : " << _step << std::endl;
+	std::cout << "Level : " << _startLevel << std::endl;
 	// initialisation au point de depart
 	for (size_t i(0); i < _input.nbObs(); ++i) {
 		_input.shiftForced(i, _startPoint.label(i));
 		//file << i << " - "<< _startPoint.label(i)<<std::endl;
-	}		
+	}
 	//KMInstance instance;
 	//Aggregations aggregations;	
 	//for ( int level(0); level <= nbLevels(); level+= _step) {
@@ -198,22 +203,22 @@ void MultiLevelAlgo::launch() {
 	//			assert( _input.label(j) == l);
 	//	}
 	//}
-	std::cout << "Starting point value : "<<_input.computeCost() << std::endl;
+	std::cout << "Starting point value : " << _input.computeCost() << std::endl;
 
 	// lancement du run 
 	refine();
 
 }
-size_t MultiLevelAlgo::nbLevels()const{
+size_t MultiLevelAlgo::nbLevels() const {
 	return _multiLevelConstraints.size();
 }
-void MultiLevelAlgo::getStartPoint( Partition  & point){
+void MultiLevelAlgo::getStartPoint(Partition & point) {
 	KMInstance instance;
-	Aggregations aggregations;	
-	buildInstance(nbLevels(), instance,aggregations);
+	Aggregations aggregations;
+	buildInstance(nbLevels(), instance, aggregations);
 	KMInput input(instance, _input.maxNbLabels());
-	input.random(0);	
-	std::cout << "Starting point value : "<<input.computeCost() << std::endl;
+	input.random(0);
+	std::cout << "Starting point value : " << input.computeCost() << std::endl;
 	for (size_t i(0); i < _input.nbObs(); ++i) {
 		point.shift(i, input.label(aggregations.newIds[i]));
 	}
@@ -235,26 +240,22 @@ void MultiLevelAlgo::getStartPoint( Partition  & point){
 	//}
 }
 
-
-void MultiLevelAlgo::setStartLevel( size_t level){
-	_startLevel=level;
+void MultiLevelAlgo::setStartLevel(size_t level) {
+	_startLevel = level;
 }
 
-
-
-void MultiLevelAlgo::setStep(size_t step){
-	_step=step;
+void MultiLevelAlgo::setStep(size_t step) {
+	_step = step;
 }
 
-
-void MultiLevelAlgo::setStartPoint( Partition  & point){
-	_startPoint = point;	
+void MultiLevelAlgo::setStartPoint(Partition & point) {
+	_startPoint = point;
 }
 
-std::ostream & MultiLevelAlgo::out(){
+std::ostream & MultiLevelAlgo::out() {
 	return *_out;
 }
-MultiLevelAlgoStats const & MultiLevelAlgo::stats()const{
+MultiLevelAlgoStats const & MultiLevelAlgo::stats() const {
 	return _stats;
 }
 
diff --git a/projet_zz/main.cpp b/projet_zz/main.cpp
index 833a550..6bcf71b 100644
--- a/projet_zz/main.cpp
+++ b/projet_zz/main.cpp
@@ -1,9 +1,9 @@
 /*
-* main.cpp
-*
-*  Created on: 15 déc. 2012
-*      Author: manuel
-*/
+ * main.cpp
+ *
+ *  Created on: 15 déc. 2012
+ *      Author: manuel
+ */
 
 #include "src/common.h"
 #include "src/Partition.hpp"
@@ -36,18 +36,18 @@ void usage() {
 	std::cout << "The program launch the multi level algorithm\n";
 
 }
-template<class T> void WriteCsv(std::ostream & stream, T const & t){
+template<class T> void WriteCsv(std::ostream & stream, T const & t) {
 	stream << t << ";";
 }
-template<class T> void WriteCsv(std::ostream & stream, T const & t, size_t n){
-	stream << std::setprecision(n) <<t << ";";
+template<class T> void WriteCsv(std::ostream & stream, T const & t, size_t n) {
+	stream << std::setprecision(n) << t << ";";
 }
 
 int main(int argc, char ** argv) {
 	Number::SetSeed(1);
 	//liste des instances a tester
 	std::list<size_t> list_instance;
-	//list_instance.push_back(0);
+	//	list_instance.push_back(0);
 	//list_instance.push_back(1);
 	//list_instance.push_back(4);
 	//list_instance.push_back(7);
@@ -63,9 +63,9 @@ int main(int argc, char ** argv) {
 	//list_instance.push_back(29);
 
 	// préparation de l'output qu iszera effacer à chaque run !!
-	
+
 	std::ofstream file("output.csv");
-	
+
 	file << "id;nom;n;k;amax;nbLevel; ";
 	file << "ite0;score0;CPU0; ";
 	file << "start;";
@@ -74,55 +74,49 @@ int main(int argc, char ** argv) {
 	file << std::endl;
 	// ce programme lance les tests sur toutes les instances.
 	std::ofstream debug("debug.log");
-	
-	for(auto const & i : list_instance) {
+	for (auto const & i : list_instance) {
 		AvailableInstances id(static_cast<AvailableInstances>(i));
 		RegisteredInstance instance(id);
 		instance.out();
 		// on va tester notre algo pour un nombre de classe compris [2 , 15% Nbpoint] en incrementant de 1
-		size_t const kmax( (size_t)std::ceil(instance.nbObs()*0.15) );
-		size_t const amax( (size_t)std::ceil(instance.nbObs()*0.05) );
-		std::cout << "amax = "<<amax<<std::endl;
-
+		size_t const kmax((size_t) std::ceil(instance.nbObs() * 0.15));
+		size_t const amax((size_t) std::ceil(instance.nbObs() * 0.10));
+		std::cout << "amax = " << amax << std::endl;
 		// mais on arrete si notre algo n'est plus en multi-level.
-		for(size_t k(3); k<kmax; ++k)
-		{
+		for (size_t k(10); k < kmax; ++k) {
 			MultiLevelAlgo algo(instance, k);
 			algo.setOut(debug);
 			// on agrege 20k des noeuds par palier de 5% des noeuds totaux 
-			algo.buildMultiLevelData(20*k, amax);
+			algo.buildMultiLevelData(20 * k, amax);
 			Partition start(instance.nbObs(), k);
 			//generation du point de depart
 			algo.getStartPoint(start);
 			// pour le moment on garde un pas constant de 1
-			algo.setStep(1);	
+			algo.setStep(1);
 			std::map<size_t, MultiLevelAlgoStats> allStats;
 
-			for(size_t level(0); level<=algo.nbLevels(); ++level)
-			{				
+			for (size_t level(0); level <= algo.nbLevels(); ++level) {
 				algo.setStartPoint(start);
 				algo.setStartLevel(level);
 				algo.launch();
 				allStats[level] = algo.stats();
 			}
-			
-			std::map<size_t,double> sumsIte;
-			std::map<size_t,size_t> nbIte;
-			std::map<size_t,double> score;
-			std::map<size_t,double> sumsTime;
 
-			for( auto const & stat : allStats)
-			{
+			std::map<size_t, double> sumsIte;
+			std::map<size_t, size_t> nbIte;
+			std::map<size_t, double> score;
+			std::map<size_t, double> sumsTime;
+
+			for (auto const & stat : allStats) {
 				size_t const level(stat.first);
-				nbIte[level]=allStats[level].size();
-				score[level]=allStats[level].rbegin()->second._cost;
+				nbIte[level] = allStats[level].size();
+				score[level] = allStats[level].rbegin()->second._cost;
 				for (auto & stat : allStats[level]) {
-					sumsIte	[level]  += stat.second._ite ;
-					sumsTime[level] += stat.second._time ;
-				}							
+					sumsIte[level] += stat.second._ite;
+					sumsTime[level] += stat.second._time;
+				}
 			}
-			for( auto const & stat : allStats)
-			{
+			for (auto const & stat : allStats) {
 				size_t const level(stat.first);
 				//double RapCost	( (scoreTot[level]-sumsCost[algo.nbLevels()])/sumsCost[algo.nbLevels()]);
 				//double RapIte	( (sumsIteTot[level]-sumsIteTot[algo.nbLevels()])/sumsIteTot[algo.nbLevels()]);
@@ -135,13 +129,13 @@ int main(int argc, char ** argv) {
 				WriteCsv(file, k);
 				WriteCsv(file, amax);
 				WriteCsv(file, algo.nbLevels());
-				WriteCsv(file, sumsIte	[0] );
-				WriteCsv(file, score	[0], 15);
-				WriteCsv(file, sumsTime	[0], 6);
+				WriteCsv(file, sumsIte[0]);
+				WriteCsv(file, score[0], 15);
+				WriteCsv(file, sumsTime[0], 6);
 				WriteCsv(file, level);
-				WriteCsv(file, sumsIte	[level] );
-				WriteCsv(file, score	[level], 15);
-				WriteCsv(file, sumsTime	[level], 6);
+				WriteCsv(file, sumsIte[level]);
+				WriteCsv(file, score[level], 15);
+				WriteCsv(file, sumsTime[level], 6);
 				file << std::endl;
 			}
 			break;
@@ -149,6 +143,7 @@ int main(int argc, char ** argv) {
 	}
 	file.close();
 	debug.close();
-	system("pause");
-	return 0; 
+	//	std::cout << "Press ENTER to continue...";
+	//	std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
+	return 0;
 }
diff --git a/src/KMInstance.cpp b/src/KMInstance.cpp
index 45fa472..25a2edb 100644
--- a/src/KMInstance.cpp
+++ b/src/KMInstance.cpp
@@ -19,7 +19,7 @@ KMInstance::KMInstance(KMInstance const & instance,
 
 	size_t n(0);
 	for (size_t i(0); i < aggregations.v.size(); ++i) {
-		if(!aggregations.v[i].empty()){
+		if (!aggregations.v[i].empty()) {
 			for (auto const & j : aggregations.v[i])
 				for (size_t d(0); d < nbAtt(); ++d)
 					_data.plus(n, d, instance.get(j, d));
@@ -86,39 +86,39 @@ void KMInstance::readConstraints(std::string const & fileName) {
 }
 
 void KMInstance::buildMustLink(Aggregations & result) const {
-	result.v.clear();	
+	result.v.clear();
 	size_t n(0);
 	std::vector<IntSet> temp(nbObs());
 	// au départ on a des singletons
-	for(size_t i(0); i<nbObs(); ++i){
+	for (size_t i(0); i < nbObs(); ++i) {
 		temp[i].insert(i);
 	}
 	result.newIds.assign(nbObs(), -1);
 	// on fusionne les 
-	for(auto const & p : _must){
+	for (auto const & p : _must) {
 		size_t const i(p.first);
 		size_t const j(p.second);
-		for(auto & si : temp[i]){
-			for(auto & sj : temp[j]){
-				temp[si].insert(temp[sj].begin(),temp[sj].end());
-				temp[sj].insert(temp[si].begin(),temp[si].end());
+		for (auto & si : temp[i]) {
+			for (auto & sj : temp[j]) {
+				temp[si].insert(temp[sj].begin(), temp[sj].end());
+				temp[sj].insert(temp[si].begin(), temp[si].end());
 			}
 		}
 	}
 	std::set<IntSet> trimmer;
-	for(auto & it : temp)
-		if(!trimmer.insert(it).second)
+	for (auto & it : temp)
+		if (!trimmer.insert(it).second)
 			it.clear();
 	result.v.reserve(nbObs());
-	for(size_t i(0); i<nbObs(); ++i){
-		if(!(temp[i].empty())){
-			for(auto const & j :temp[i])
-				result.newIds[j]=n;
-			result.v.push_back( temp[i] );
+	for (size_t i(0); i < nbObs(); ++i) {
+		if (!(temp[i].empty())) {
+			for (auto const & j : temp[i])
+				result.newIds[j] = n;
+			result.v.push_back(temp[i]);
 			++n;
 		}
 	}
-	OUT<< "found "<<n<<" aggregated point\n";
+//	OUT<< "found "<<n<<" aggregated point\n";
 	//for (auto const & id : result.newIds) {
 	//	assert(id < n);
 	//}

From 7dc4392c14d5f2d22d9b78acb5dff12b6c99f367 Mon Sep 17 00:00:00 2001
From: rogelja <vrogelja@gmail.com>
Date: Mon, 18 Feb 2013 19:48:10 +0100
Subject: [PATCH 14/14] Update projet_zz/main.cpp

---
 projet_zz/main.cpp | 97 +++++++++++++++++++++++++---------------------
 1 file changed, 52 insertions(+), 45 deletions(-)

diff --git a/projet_zz/main.cpp b/projet_zz/main.cpp
index 6bcf71b..948c863 100644
--- a/projet_zz/main.cpp
+++ b/projet_zz/main.cpp
@@ -1,7 +1,7 @@
 /*
  * main.cpp
  *
- *  Created on: 15 déc. 2012
+ *  Created on: 15 déc. 2012
  *      Author: manuel
  */
 
@@ -62,11 +62,11 @@ int main(int argc, char ** argv) {
 	//list_instance.push_back(28);
 	//list_instance.push_back(29);
 
-	// préparation de l'output qu iszera effacer à chaque run !!
+	// préparation de l'output qu iszera effacer à chaque run !!
 
 	std::ofstream file("output.csv");
 
-	file << "id;nom;n;k;amax;nbLevel; ";
+	file << "id;nom;n;k;step;amax;nbLevel; ";
 	file << "ite0;score0;CPU0; ";
 	file << "start;";
 	file << "ite;score;CPU;";
@@ -78,7 +78,7 @@ int main(int argc, char ** argv) {
 		AvailableInstances id(static_cast<AvailableInstances>(i));
 		RegisteredInstance instance(id);
 		instance.out();
-		// on va tester notre algo pour un nombre de classe compris [2 , 15% Nbpoint] en incrementant de 1
+		// on va tester notre algo pour un nombre de classe compris [10 , 15% Nbpoint] en incrementant de 1
 		size_t const kmax((size_t) std::ceil(instance.nbObs() * 0.15));
 		size_t const amax((size_t) std::ceil(instance.nbObs() * 0.10));
 		std::cout << "amax = " << amax << std::endl;
@@ -86,59 +86,66 @@ int main(int argc, char ** argv) {
 		for (size_t k(10); k < kmax; ++k) {
 			MultiLevelAlgo algo(instance, k);
 			algo.setOut(debug);
-			// on agrege 20k des noeuds par palier de 5% des noeuds totaux 
+			// on agrege 20k des noeuds par palier de amax 
 			algo.buildMultiLevelData(20 * k, amax);
 			Partition start(instance.nbObs(), k);
 			//generation du point de depart
 			algo.getStartPoint(start);
-			// pour le moment on garde un pas constant de 1
-			algo.setStep(1);
-			std::map<size_t, MultiLevelAlgoStats> allStats;
-
-			for (size_t level(0); level <= algo.nbLevels(); ++level) {
-				algo.setStartPoint(start);
-				algo.setStartLevel(level);
-				algo.launch();
-				allStats[level] = algo.stats();
-			}
 
+			size_t const stepMax((size_t) std::ceil(algo.nbLevels() * 0.10));
+			
+			std::map<size_t, MultiLevelAlgoStats> allStats;
 			std::map<size_t, double> sumsIte;
 			std::map<size_t, size_t> nbIte;
 			std::map<size_t, double> score;
 			std::map<size_t, double> sumsTime;
 
-			for (auto const & stat : allStats) {
-				size_t const level(stat.first);
-				nbIte[level] = allStats[level].size();
-				score[level] = allStats[level].rbegin()->second._cost;
-				for (auto & stat : allStats[level]) {
-					sumsIte[level] += stat.second._ite;
-					sumsTime[level] += stat.second._time;
+
+			//On fait varier le pas de 1 à stepMax+1 avec stepMax qui est 10% du nb de niveau
+			for (size_t step(1) ; step < stepMax+1 ; ++step)
+			{
+				algo.setStep(step);
+
+				for (size_t level(0); level <= algo.nbLevels(); ++level) {
+					algo.setStartPoint(start);
+					algo.setStartLevel(level);
+					algo.launch();
+					allStats[level] = algo.stats();
+				}
+
+				for (auto const & stat : allStats) {
+					size_t const level(stat.first);
+					nbIte[level] = allStats[level].size();
+					score[level] = allStats[level].rbegin()->second._cost;
+					for (auto & stat : allStats[level]) {
+						sumsIte[level] += stat.second._ite;
+						sumsTime[level] += stat.second._time;
+					}
+				}
+				for (auto const & stat : allStats) {
+					size_t const level(stat.first);
+					//double RapCost	( (scoreTot[level]-sumsCost[algo.nbLevels()])/sumsCost[algo.nbLevels()]);
+					//double RapIte	( (sumsIteTot[level]-sumsIteTot[algo.nbLevels()])/sumsIteTot[algo.nbLevels()]);
+					//double RapTime	( (sumsTimeTot[level]-sumsTimeTot[algo.nbLevels()])/sumsTimeTot[algo.nbLevels()]);
+					//double RapIteMoy( (sumsIte[level]-sumsIte[algo.nbLevels()])/sumsIte[algo.nbLevels()]);
+
+					WriteCsv(file, i, 6);
+					WriteCsv(file, instance.name);
+					WriteCsv(file, instance.nbObs());
+					WriteCsv(file, k);
+					WriteCsv(file, step);
+					WriteCsv(file, amax);
+					WriteCsv(file, algo.nbLevels());
+					WriteCsv(file, sumsIte[0]);
+					WriteCsv(file, score[0], 15);
+					WriteCsv(file, sumsTime[0], 6);
+					WriteCsv(file, level);
+					WriteCsv(file, sumsIte[level]);
+					WriteCsv(file, score[level], 15);
+					WriteCsv(file, sumsTime[level], 6);
+					file << std::endl;
 				}
 			}
-			for (auto const & stat : allStats) {
-				size_t const level(stat.first);
-				//double RapCost	( (scoreTot[level]-sumsCost[algo.nbLevels()])/sumsCost[algo.nbLevels()]);
-				//double RapIte	( (sumsIteTot[level]-sumsIteTot[algo.nbLevels()])/sumsIteTot[algo.nbLevels()]);
-				//double RapTime	( (sumsTimeTot[level]-sumsTimeTot[algo.nbLevels()])/sumsTimeTot[algo.nbLevels()]);
-				//double RapIteMoy( (sumsIte[level]-sumsIte[algo.nbLevels()])/sumsIte[algo.nbLevels()]);
-
-				WriteCsv(file, i, 6);
-				WriteCsv(file, instance.name);
-				WriteCsv(file, instance.nbObs());
-				WriteCsv(file, k);
-				WriteCsv(file, amax);
-				WriteCsv(file, algo.nbLevels());
-				WriteCsv(file, sumsIte[0]);
-				WriteCsv(file, score[0], 15);
-				WriteCsv(file, sumsTime[0], 6);
-				WriteCsv(file, level);
-				WriteCsv(file, sumsIte[level]);
-				WriteCsv(file, score[level], 15);
-				WriteCsv(file, sumsTime[level], 6);
-				file << std::endl;
-			}
-			break;
 		}
 	}
 	file.close();