modification des paramétres de la fonction multiniveau -> réduction de paramétre en entrée + modification de la fonction de partitionnement aléatoire

src/tests/boost_graph/graph_partitioning.hpp

@@ -51,34 +51,33 @@ public:
                Connections& parent_connections)
     {
 		std::cout<<"**"<<cluster_number<<"**"<<std::endl;
-        UnorientedGraph* g = new UnorientedGraph();
         OrientedGraph go;
-        std::vector<double> Cut;
+        
+        std::vector<std::string> parameters;
+		parameters.push_back("HEM");
+		parameters.push_back(partitioning_method_name);
+		parameters.push_back("diff");
+		parameters.push_back("ratio");
 
         generator.generate(go);
 
-        make_unoriented_graph(go, *g);
-
         Edges edge_partie;
         Connections connections;
 
         output_edges = OutputEdgeList(cluster_number);
 
         if (contraction_coef_flag) {
-            graphs = Multiniveau(num_vertices(*g) / contraction_coef,
-                                 g, &go,
-                                 cluster_number,10, "HEM",
-                                 partitioning_method_name,
-                                 "diff", "ratio", edge_partie ,
+            graphs = Multiniveau(num_vertices(go) / contraction_coef,
+                                 &go,cluster_number,10, 
+                                 parameters, edge_partie ,
                                  output_edges, input_edges,
-                                 parent_connections,false, Cut, 2);
+                                 parent_connections,false, 2);
         } else {
-            graphs = Multiniveau(contraction_coef, g, &go,
-                                 cluster_number,10, "HEM",
-                                 partitioning_method_name,
-                                 "diff", "ratio", edge_partie ,
+            graphs = Multiniveau(contraction_coef, &go,
+                                 cluster_number,10,
+                                 parameters, edge_partie ,
                                  output_edges, input_edges,
-                                 parent_connections,false, Cut, 2);
+                                 parent_connections,false, 2);
         }
 
         // std::cout << "*********************************" << std::endl;

src/tests/boost_graph/partitioning/gggp.cpp

@@ -576,11 +576,11 @@ void Pseudo_random_partitioning(UnorientedGraph *g, EntiersEntiers &Partition,
 
 
 EntiersEntiers Random_partitioning(UnorientedGraph *g,
-                                uint nbr_parties)
+                                uint parts_number)
 {
 	EntiersEntiers Partition;
 	Entiers random_order; //gestion d'un tableau contenant tout les sommets et ranger de façon aléatoire
-
+	uint cpt = 0;
 	for (uint i=0 ; i<num_vertices(*g) ; i++)
 		random_order.push_back(i);
 	for (uint j=0 ; j<num_vertices(*g)-1 ; j++) {
@@ -589,21 +589,18 @@ EntiersEntiers Random_partitioning(UnorientedGraph *g,
 		random_order.at(j) = random_order.at(rand_pos);
 		random_order.at(rand_pos) = tmp;
 	}
-
-	uint size = num_vertices(*g)/nbr_parties;
-	for(uint j = 0 ; j < nbr_parties-1 ; j++){
+	
+	for(uint j = 0 ; j < parts_number ; j++){
 		Entiers *part = new Entiers();
-		for(uint i = j*size; i<(j+1)*size; i++){
-			part->push_back(random_order.at(i));
-		}
 		Partition.push_back(part);
 	}
-
-	Entiers *part = new Entiers();
-	for(uint i = (nbr_parties-1)*size; i < random_order.size(); i++){
-		part->push_back(random_order.at(i));
+	
+	for(uint id = 0; id < random_order.size(); id++){
+		Partition.at(cpt)->push_back(random_order.at(id));
+		cpt++;
+		if(cpt == parts_number)
+			cpt = 0;
 	}
-	Partition.push_back(part);
 
 	for(uint i = 0 ; i < Partition.size() ; i++){
 		sort(Partition.at(i)->begin(),Partition.at(i)->end());
@@ -613,21 +610,24 @@ EntiersEntiers Random_partitioning(UnorientedGraph *g,
 }
 
 OrientedGraphs Multiniveau(uint niveau_contraction,
-                           UnorientedGraph *g,
                            OrientedGraph *go,
                            int nbr_parties,
                            int nbr_tirage,
-                           std::string contraction,
-                           std::string type_methode,
-                           std::string choix_affinage,
-                           std::string type_cut,
+                           const std::vector<std::string> &parameters,
                            Edges& /* edge_partie */,
                            OutputEdgeList& outputedgelist,
                            InputEdgeList& inputedgelist,
-                           Connections& connections, bool rec,
-                           std::vector<double> &Cut /*Paramètre à vérifier*/, int distance)
+                           Connections& connections, bool rec, int distance)
 {   
-    boost::timer t;    
+	/* std::vector<std::string> parameters :
+	 * 0 -> std::string contraction    : nom de la méthode de contraction
+	 * 1 -> std::string type_methode   : nom de la méthode de partitionnement
+	 * 2 -> std::string choix_affinage : nom de la méthode d'affinage
+	 * 3 -> std::string type_cut       : nom de la fonction objectif étudiée
+	 */
+    boost::timer t;
+    UnorientedGraph *g = new UnorientedGraph();
+	make_unoriented_graph(*go, *g); 
     EntiersEntiers Partition;
     Entiers *part = new Entiers();
     Base_Graph baseg;
@@ -643,7 +643,7 @@ OrientedGraphs Multiniveau(uint niveau_contraction,
 	
 	    while(stop != true)
 	    {
-	    	if(contraction == "HEM")
+	    	if(parameters.at(0) == "HEM")
 				stop = contraction_HEM_degree(baseg.at(cpt),baseg,liste_corr,niveau_contraction,val_cpt);
 	    		//stop = contraction_HEM(baseg.at(cpt),baseg,liste_corr,niveau_contraction,val_cpt);
 	    	else
@@ -691,8 +691,8 @@ OrientedGraphs Multiniveau(uint niveau_contraction,
 			Plot_UnorientedGraph_All(baseg.at(baseg.size()-1),Partition,"../../sortie_graphe/Tests/Graphes/txt/Niveau_contraction/contraction_final.txt", false);
 		}
 	    
-	    if(type_methode == "gggp" || type_methode == "ggp"){
-			bissectionRec(baseg.at(baseg.size()-1),Partition,nbr_parties,type_cut,nbr_tirage,type_methode, distance);
+	    if(parameters.at(1) == "gggp" || parameters.at(1) == "ggp"){
+			bissectionRec(baseg.at(baseg.size()-1),Partition,nbr_parties, parameters.at(3), nbr_tirage, parameters.at(1), distance);
 	    }
 	    else
 	    	Partition = Random_partitioning(baseg.at(baseg.size()-1),nbr_parties);
@@ -834,14 +834,14 @@ OrientedGraphs Multiniveau(uint niveau_contraction,
 					Plot_UnorientedGraph_All(baseg.at(baseg.size()-2-y),Partition,nom.at(y), true);
 				}
 	
-	    		double cut = Cut_cluster(Partition,*baseg.at(baseg.size()-2-y),type_cut);
+	    		double cut = Cut_cluster(Partition,*baseg.at(baseg.size()-2-y),parameters.at(3));
 	    		//std::cout<<"Cout de coupe avant affinage : "<<cut<<std::endl;
-	    		if(choix_affinage == "charge")
+	    		if(parameters.at(2) == "charge")
 	    			Affinage_equilibrage_charge(baseg.at(baseg.size()-2-y),Partition);
-	    		else if(choix_affinage == "locale"){
-	    			Affinage_recherche_locale(baseg.at(baseg.size()-2-y),Partition,cut,type_cut);}
+	    		else if(parameters.at(2) == "locale"){
+	    			Affinage_recherche_locale(baseg.at(baseg.size()-2-y),Partition,cut,parameters.at(3));}
 	    		else	
-	    			Affinache_gain_diff(baseg.at(baseg.size()-2-y), Partition, cut, type_cut, poids_moy);
+	    			Affinache_gain_diff(baseg.at(baseg.size()-2-y), Partition, cut, parameters.at(3), poids_moy);
 				//std::cout<<"Cout de coupe après affinage : "<<cut<<std::endl;
 				
 				if(rec == true){
@@ -870,10 +870,6 @@ OrientedGraphs Multiniveau(uint niveau_contraction,
 		for(uint i =0; i < Partition.size(); i++){
 			std::cout<<"Poids partie "<<i<<" : "<<Cluster_Weight(*g,*Partition.at(i))<<std::endl;
 		}*/
-				
-		double best_cut = Cut_cluster(Partition,*g,type_cut);
-		//std::cout<<"Fct Obj : "<<best_cut<<std::endl;
-		Cut.push_back(best_cut);
 		
 		Graphes = Graph_Partition(Partition, go, g, outputedgelist,
 	                                             inputedgelist, connections);
@@ -886,16 +882,12 @@ OrientedGraphs Multiniveau(uint niveau_contraction,
 	
 		UnorientedGraph *copie_g = new UnorientedGraph();
 		boost::copy_graph(*g,*copie_g);
-	    if(type_methode == "gggp" || type_methode == "ggp"){
-			bissectionRec(copie_g,Partition,nbr_parties,type_cut,nbr_tirage,type_methode, distance);
+	    if(parameters.at(1) == "gggp" || parameters.at(1) == "ggp"){
+			bissectionRec(copie_g,Partition,nbr_parties,parameters.at(3),nbr_tirage,parameters.at(1), distance);
 		}
 		else
 			Partition = Random_partitioning(copie_g,nbr_parties);
 			
-		double best_cut = Cut_cluster(Partition,*g,type_cut);
-		//std::cout<<"Fct Obj : "<<best_cut<<std::endl;
-		Cut.push_back(best_cut);
-		
 		Graphes = Graph_Partition(Partition, go, copie_g, outputedgelist,
                                              inputedgelist, connections);
 	}

src/tests/boost_graph/partitioning/gggp.hpp

@@ -48,19 +48,20 @@ void Pseudo_random_partitioning(UnorientedGraph *g, EntiersEntiers &Partition,
                                 uint nbr_parties);
 
 EntiersEntiers Random_partitioning(UnorientedGraph *g,
-                                uint nbr_parties);
+                                uint parts_number);
 
-OrientedGraphs Multiniveau(uint niveau_contraction, UnorientedGraph *g,
+OrientedGraphs Multiniveau(uint niveau_contraction,
                            OrientedGraph *go, int nbr_parties, int nbr_tirage,
-                           std::string contraction,
+                           const std::vector<std::string> &parameters, 
+                           /*std::string contraction,
                            std::string type_methode,
                            std::string choix_affinage,
-                           std::string type_cut,
+                           std::string type_cut,*/
                            Edges &edge_partie,
                            OutputEdgeList &outputedgeslist,
                            InputEdgeList &inputedgelist,
                            Connections &connections,
-                           bool rec, std::vector<double> &Cut,
+                           bool rec,
                            int distance = -1);
 void Optimisation_method_neighbour(UnorientedGraph *g, EntiersEntiers &Partition, int index_partition, int nbr_tirage, const std::string &name_cut, const std::string &name_strat);
 void Optimisation_method_neighbour_distance(UnorientedGraph *g, EntiersEntiers &Partition, int index_partition, int nbr_tirage, int distance, const std::string &name_cut, 

src/tests/boost_graph/partitioning/graph_build.hpp

@@ -30,6 +30,7 @@
 #include <tests/boost_graph/partitioning/defs.hpp>
 #include <tests/boost_graph/partitioning/utils.hpp>
 #include <fstream>
+
 namespace paradevs { namespace tests { namespace boost_graph {
 
 void build_graph(OrientedGraph& og, unsigned int edge_number);

src/tests/boost_graph/partitioning/main.cpp

@@ -53,8 +53,8 @@ int main()
     Entiers niveau = {4,3,2};
     //int nbr_couches = 150;//nbr_sommets*3/100;
     
-    build_graph(*go, 38);
-    //build_generator_graph(go, nbr_sommets, nbr_sources , 2 , 5 ,niveau);
+    //build_graph(*go, 38);
+    build_generator_graph(go, nbr_sommets, nbr_sources , 2 , 4 ,niveau);
     /*std::vector<std::pair<int,int>> vertex_selection;
     std::pair<int,int> tmp;
     tmp.first = 0;
@@ -247,10 +247,15 @@ int main()
 	/*** ***/
 
 	int nbr_parties = 4;
-	int niveau_contraction = num_vertices(*go)/2;
-	std::vector<double> Cut;
+	int niveau_contraction = num_vertices(*go)/10;
 	int nbr_tirage = 2;
 	
+	std::vector<std::string> parameters;
+	parameters.push_back("HEM");
+	parameters.push_back("rand");
+	parameters.push_back("diff");
+	parameters.push_back(type_cut);
+	
 	for(uint i =1; i<nbr_tirage; i++){
 		Edges edge_partie;
 		OutputEdgeList outputedgeslist(nbr_parties);
@@ -261,36 +266,19 @@ int main()
 			make_unoriented_graph(*go, *g);
 			Adjacent_Matrix_Txt(g,"../../Classif_R/Graphe/txt/Madj.txt");
 			Weight_Matrix_Txt(g,"../../Classif_R/Graphe/txt/Mwei.txt");
-			OrientedGraphs graphs = Multiniveau(niveau_contraction, g, go, nbr_parties, 10 ,"HEM", "gggp",
-										"diff", type_cut, edge_partie ,
+			delete g;
+			OrientedGraphs graphs = Multiniveau(niveau_contraction, go, nbr_parties,
+										10 , parameters, edge_partie ,
 										outputedgeslist, inputedgelist,
-										connections,true,Cut,2);  	
+										connections,true,2);  	
 										std::cout<<std::endl;
-		}else{
-			UnorientedGraph *g = new UnorientedGraph();
-			make_unoriented_graph(*go, *g);
-			OrientedGraphs graphs = Multiniveau(niveau_contraction, g, go, nbr_parties, num_vertices(*go)*2/100,"HEM", "gggp",
-										"diff", type_cut, edge_partie ,
+		}else
+			OrientedGraphs graphs = Multiniveau(niveau_contraction, go, nbr_parties, 
+										num_vertices(*go)*2/100, 
+										parameters, edge_partie ,
 										outputedgeslist, inputedgelist,
-										connections,true,Cut,2);  	
-										std::cout<<std::endl;
-		}
-	}
-	//std::ofstream fichier_cut ("../../sortie_graphe/Tests/Cut/cut_s200_nc10_d0_c1_t10_p8_gggp.txt", std::ios::out);
-	double moy = 0.;
-	
-	for(int cpt = 0; cpt <Cut.size(); cpt ++){
-		//if(cpt!=Cut.size()-1)
-			//fichier_cut<<Cut.at(cpt)<<";";
-		//else
-			//fichier_cut<<Cut.at(cpt);
-		moy += Cut.at(cpt);
-		//std::cout<<Cut.at(cpt)<<std::endl;
+										connections,true,2); 
 	}
-	//fichier_cut.close();
-	
-	moy/= Cut.size();
-	std::cout<<"Critère : "<<moy<<std::endl;
 	
 	delete go;