Successfully building and running version. Returns wrong permutation matrices

Sancar Adali · Sancar Adali · commit 0cd7448b9119 · 2016-12-20T17:50:02.000-05:00
diff --git a/.gitignore b/.gitignore
@@ -1 +1,2 @@
 *.o
+.Rproj.user
diff --git a/data/A_G.RData b/data/A_G.RData
diff --git a/data/A_H.RData b/data/A_H.RData
diff --git a/inst/include/tmp.txt b/inst/include/tmp.txt
diff --git a/man/rcpp_hello.Rd b/man/rcpp_hello.Rd
@@ -17,24 +17,26 @@ A named list containing
 Runs the graph matching algorithm for graphs represented by \code{A} and \code{B}. Returns an \R \code{list} containing the permutation matrix \code{Pmat} and other computed variables.
 }
 \examples{
-A<-matrix( sample(c(0,1),125, replace = TRUE,prob=c(0.75,0.25)),15,15)
+B<-matrix( sample(c(0,1),225, replace = TRUE,prob=c(0.75,0.25)),15,15)
+diag(A)<- 1
 perm <- sample.int(15)
-B<-A [perm,perm]
+A<-B [perm,perm]
 
 # parameters copied from test_simple example or graphm
 algorithm_params<-list(
 # Already provided as A and B matrices
 # *******************ALGORITHMS********************************
 # used algorithms and what should be used as
 #initial solution in corresponding algorithms
-algo="PATH",
-algo_init_sol="unif",
+algo="I QCV PATH",
+algo_init_sol="unif unif unif",
 solution_file="solution_im.txt",
 # coeficient of linear combination between
 # (1-alpha_ldh)*||graph_1-P*graph_2*P^T||^2_F +alpha_ldh*C_matrix
 alpha_ldh=0 ,
 cdesc_matrix="A" ,
 cscore_matrix="A" ,
+#C_matrix = "none",
 # **************PARAMETERS SECTION*****************************
 hungarian_max=10000 ,
 algo_fw_xeps=0.01 ,
@@ -73,4 +75,20 @@ graph_dot_print = 1
 print( algorithm_params)
  result <- run_graph_match(A, B, algorithm_params)
  print(result$Pmat)
+
+
+
+
+ algorithm_params["algo"]<- "I U RANK QCV rand PATH"
+ algorithm_params["algo_init_sol"] <- "unif unif unif unif unif unif"
+ algorithm_params["alpha_ldh"] <- 0.44
+ anotherresult <- run_graph_match(a,b, algorithm_params)
+
+C<-matrix( runif(	min = 0, max = 1,n= 225),15,15)
+diag(C)<- 1
+B <- C*B
+perm <- sample.int(15)
+A<-B [perm,perm]
+weightedmatrixresult <- run_graph_match(A,B, algorithm_params)
+
 }
diff --git a/src/Makevars.win b/src/Makevars.win
@@ -4,7 +4,7 @@
 # combine with standard arguments for R
 RCPPGSL_LDFLAGS = `$(R_HOME)/bin/Rscript -e "RcppGSL:::LdFlags()"`
 #RCPPGSL_CFLAGS
-PKG_CPPFLAGS = $(GSL_CFLAGS) -I$(LIB_GSL)/include -I../inst/include  -I../inst -Wall -Wno-unused-variable -Wno-unused-but-set-variable  -Wno-long-long -Wno-sign-compare  -pedantic -pthread -fPIC -O2 -g
+PKG_CPPFLAGS = $(GSL_CFLAGS) -I$(LIB_GSL)/include -I../inst/include  -I../inst -Wall -Wno-unused-but-set-variable  -Wno-long-long -Wno-sign-compare  -pedantic -pthread -fPIC -O2 -g
 
 
 GRAPHM_OBJ =  ./algorithm_ca.o ./algorithm_ext.o ./algorithm_fsol.o  ./algorithm_iden.o ./algorithm_lp.o ./algorithm.o ./algorithm_path.o ./algorithm_qcv.o ./algorithm_rand.o ./algorithm_rank.o ./algorithm_umeyama.o ./algorithm_unif.o ./experiment.o ./graph.o ./hungarian.o  ./rpc.o
diff --git a/src/graphm/experiment.cpp b/src/graphm/experiment.cpp
@@ -37,7 +37,7 @@ void experiment::run_experiment(graph &g, graph &h)
 	parameter pdebug_f = get_param("debugprint_file");
 	pdebug.strvalue=pdebug_f.strvalue;
 	std::string sverbfile=get_param_s("verbose_file");
-	bool bverbose=(get_param_i("verbose_mode")==1);
+	bool bverbose= 1; //(get_param_i("verbose_mode")==1);
 	std::ofstream fverbose;
 	if (sverbfile.compare("cout")==0){
 		fverbose.open("Rconsoleout.txt");
@@ -53,14 +53,14 @@ void experiment::run_experiment(graph &g, graph &h)
 	std::string sexp_type=get_param_s("exp_type");
 	std::string salgo_match=get_param_s("algo");
 	std::istrstream istr(salgo_match.c_str());
-	std::vector<std::string>v_salgo_match;
+	std::vector<std::string> v_salgo_match;
 	std::string stemp;
 	while (istr>>stemp)
 		v_salgo_match.push_back(stemp);
 	//used initialization algorithms
 	std::string salgo_init=get_param_s("algo_init_sol");
 	std::istrstream istrinit(salgo_init.c_str());
-	std::vector<std::string>v_salgo_init;
+	std::vector<std::string> v_salgo_init;
 	while (istrinit>>stemp)
 		v_salgo_init.push_back(stemp);
 	if (v_salgo_init.size()!=v_salgo_match.size())
@@ -78,11 +78,20 @@ void experiment::run_experiment(graph &g, graph &h)
 
 
 	if (get_param_i("graph_dot_print")==1){ g.printdot("g.dot");h.printdot("h.dot");};
+
+
+
+	int N1 =0;
+	N1 = g.get_adjmatrix()->size1;
+
+	int N2 =0;
+	N2 = h.get_adjmatrix()->size1;
+	char fname[4];
 	// Matrix of local similarities between graph vertices
-	std::string strfile=get_param_s("C_matrix");
-	int N1 =g.get_adjmatrix()->size1;
-	int N2 =h.get_adjmatrix()->size1;
  	gsl_matrix* gm_ldh=gsl_matrix_alloc(N1,N2);
+
+
+ 	std::string strfile=get_param_s("C_matrix");
 	FILE *f=fopen(strfile.c_str(),"r");
 	if (f!=NULL){
 		gsl_set_error_handler_off();
@@ -102,7 +111,7 @@ void experiment::run_experiment(graph &g, graph &h)
 	if (get_param_i("C_matrix_dist")==1)
 		gsl_matrix_scale(gm_ldh,-1);
 
-	if (bverbose) *gout<<"Graph synhronization"<<std::endl;
+	if (bverbose) *gout<<"Graph synchronization"<<std::endl;
 	synchronize(g,h,&gm_ldh);
 
 	//Cycle over all algoirthms
@@ -114,18 +123,24 @@ void experiment::run_experiment(graph &g, graph &h)
 			algo_i->set_ldhmatrix(gm_ldh);
 			match_result mres_i=algo_i->gmatch(g,h,NULL,NULL,dalpha_ldh);
 			delete algo_i;
+			char fname[5];
+			printout(itoa(a,fname,10));
 			//main algorithm
 			algorithm* algo=get_algorithm(v_salgo_match[a]);
 			algo->read_config(get_config_string());
 			algo->set_ldhmatrix(gm_ldh);
 			match_result mres_a=algo->gmatch(g,h,(mres_i.gm_P_exact!=NULL)?mres_i.gm_P_exact:mres_i.gm_P, NULL,dalpha_ldh);
+			if (bverbose) {
+				*gout<<"Finished matching with " <<itoa(a,fname,10) << "th algorithm of experiment" <<std::endl;
+			}
 			mres_a.vd_trace.clear();
 			mres_a.salgo=v_salgo_match[a];
 			v_mres.push_back(mres_a);
 			delete algo;
+			printout(itoa(a,fname,10));
 		};
 	gsl_matrix_free(gm_ldh);
-	printout();
+	//printout("after_experiment");
 }
 experiment::~experiment()
 {
@@ -190,14 +205,15 @@ int experiment::get_algo_len(){
 
 
 gsl_matrix* experiment::get_P_result(int algo_index){
-	if ( algo_index<this->v_mres.size() && algo_index>=0 ){
-//		if ( this->v_mres[algo_index].gm_P_exact != NULL){
-//			return this->v_mres[algo_index].gm_P_exact;
-//		} else{
-			return this->v_mres[algo_index].gm_P;
-//		}
+	if ((algo_index >= 0 ) && ( algo_index < this->v_mres.size()) ) {
+		if ( this->v_mres[algo_index].gm_P_exact != NULL){
+			return this->v_mres[algo_index].gm_P_exact;
+		} else{
+			return this->v_mres.at(algo_index).gm_P;
+		}
 	} else {
-		return NULL;
+		throw std::runtime_error("Out-of-bounds error for  experiment results vector\n ");
+
 	}
 }
 
@@ -248,6 +264,7 @@ void experiment::printout(std::string fname_out,std::string sformat)
 			fout<<v_mres.at(a).salgo<<" ";
 		fout.precision(2);
 		fout<<std::endl;
+		if (v_mres.size() >0 ){
 		for (int i=0;i<v_mres.at(0).gm_P->size1;i++)
 		{
 			for (int a=0;a<v_mres.size();a++)
@@ -261,6 +278,7 @@ void experiment::printout(std::string fname_out,std::string sformat)
 			};
 			fout<<std::endl;
 		};
+		}
 
 	};
 }
diff --git a/src/graphm/experiment.h b/src/graphm/experiment.h
@@ -40,6 +40,8 @@
 #include <strstream>
 #include <stdexcept>
 #include <exception>
+#include <cstdlib>
+#include <algorithm>
 /**
 Experiment class. It implements all extern routines for graph matching experiments
 
diff --git a/src/graphm/graph.h b/src/graphm/graph.h
@@ -50,6 +50,7 @@ class graph : public rpc
     int load_graph(std::string fgraph,char ftype='A',char cformat='D',std::string fvertexlst_name="");
     //adjacency matrix control
     const gsl_matrix*  get_adjmatrix(){return gm_A;};
+
     int set_adjmatrix(const gsl_matrix* _gm_A);
     gsl_matrix* get_descmatrix(char dmt);
     int printout(std::string fname_out);
diff --git a/src/graphmatch_rcpp.cpp b/src/graphmatch_rcpp.cpp
@@ -63,6 +63,7 @@ Rcpp::List run_graph_match(const RcppGSL::Matrix& A, const RcppGSL::Matrix& B, c
   	  }
   	}
   }
+  int expected_result_count=0;
   if (!Rf_isNull(algorithm_params["algo"]) ) {
   	string str(as<string>(algorithm_params["algo"]));
   	string buf; // Have a buffer string
@@ -72,64 +73,81 @@ Rcpp::List run_graph_match(const RcppGSL::Matrix& A, const RcppGSL::Matrix& B, c
   	while (ss >> buf)
   		algo_list.push_back(buf);
 
+  	expected_result_count = algo_list.size();
+
   } else{
-  	algorithm_params["algo"] = "PATH";
-  	algorithm_params["algo_init_sol"] = "unif";
+    //algorithm_params["algo"] = "PATH";
+  	//algorithm_params["algo_init_sol"] = "unif";
 
   	exp.set_param("algo",std::string("PATH"));
   	exp.set_param("algo_init_sol",std::string("unif"));
-
+ // 	expected_result_count = 1;
   }
 
   //exp.read_config(conc_params_string);
+  exp.printout("before_Exp.txt","Parameters");
   int P_nr = max(A.nrow(),B.ncol());
   Rcpp::NumericMatrix P(P_nr);
+  std::vector<Rcpp::NumericMatrix> P_matrix_list ;
   try {
+
   	exp.run_experiment(graphm_obj_A, graphm_obj_B);
 
   	int exp_count = exp.get_algo_len();
 
-  	exp.printout("test.txt");
-
-  	std::vector<Rcpp::NumericMatrix> P_matrix_list ;
-
-  	for (int exp_i = 0;  exp_i < exp_count; exp_i++) {
-  		RcppGSL::Matrix P_tmp ( exp.get_P_result(exp_i) )	;
-  		if ( P_tmp != NULL ) {
-  			int mat_size = P_tmp.nrow()*P_tmp.ncol();
-  			try{
-  				for (int j =0 ; j< P_tmp.nrow(); j++){
-  					for (int k =0 ; k< P_tmp.ncol(); k++){
-  						P(j,k) = P_tmp(j,k);
-  					}
-
-
-  				}
-  			}
-  			catch (...){
-  				Rf_error("could not copy graphm result to Rcpp matrix");
-  				return Rcpp::List();
-
-  			}
-  		}
-  		else{
-  			Rf_error("graphm returned NULL as matrix pointer");
-  			return Rcpp::List();
-  		}
-
-
-  		P_matrix_list.push_back(P);
-
-  		P_tmp.free();
-
-  		}
-  	Rcpp::List  res = Rcpp::List::create(
-  			Rcpp::Named("debugprint_file") = algorithm_params["debugprint_file"],
-                                          Rcpp::Named("Pmat") = P_matrix_list,
-                                          Rcpp::Named("exp_count") = exp_count
-  		);
-
-  	return res;
+  	exp.printout("experiment ran.txt");
+
+    Rf_warning("exp count is %d",exp_count);
+
+   	for (int exp_i = 0;  exp_i < exp_count; exp_i++) {
+   		try{
+
+   		exp.get_P_result(exp_i);
+   		}
+   		catch (...){
+   			Rf_warning("Unable to get perm mat results from graphm experiment object ");
+   		}
+   		//RcppGSL::Matrix P_tmp (A.nrow(),B.ncol())	;
+
+   		RcppGSL::Matrix P_tmp ( exp.get_P_result(exp_i) )	;
+   		if ( P_tmp != NULL ) {
+   			int mat_size = P_tmp.nrow();
+   			mat_size *= P_tmp.ncol();
+   			if (P_tmp.nrow()==0 || P_tmp.ncol()==0 ) {
+   				Rf_error("0 sized P_tmp: Permutation matrix");
+   				return Rcpp::List();
+   			}
+   			try{
+   				for (int j =0 ; j< P_tmp.nrow(); j++){
+   					for (int k =0 ; k< P_tmp.ncol(); k++){
+   						P(j,k) = P_tmp(j,k);
+   					}
+
+   				}
+   			}
+   			catch (...){
+   				Rf_error("could not copy graphm result to Rcpp matrix");
+   				return Rcpp::List();
+  //
+   			}
+   		}	else {
+   			Rf_error("graphm returned NULL as matrix pointer");
+   			return Rcpp::List();
+   		}
+  //
+  //
+   		P_matrix_list.push_back(P);
+
+   		P_tmp.free();
+
+   		}
+   	Rcpp::List  res = Rcpp::List::create(
+   			Rcpp::Named("debugprint_file") = algorithm_params["debugprint_file"],
+                                           Rcpp::Named("Pmat") = P_matrix_list,
+                                           Rcpp::Named("exp_count") = exp_count
+   		);
+
+   	return res;
 
   } catch( std::exception &ex) {
   	Rf_error(ex.what());
