update latex_table.cpp

stat/Makefile

@@ -19,4 +19,4 @@ run:
 	- rm sort.tex
 	./latex_table.sh
 	./win arch.result
-	cat bold_table.tex | sort -k1 > sort.tex
+	cat bold_table.tex | sort -k1 -t ' ' > sort.tex

stat/filename.sh

@@ -3,7 +3,7 @@
 # bio col fb inf int rec ret sci soc tec web
 #~/massive-graphs/${dir}/focus/*.dim; do
 
-SOURCE_DIR="./all_satur_color_gc_arch"
+SOURCE_DIR="$1"
 
 find "$SOURCE_DIR" -maxdepth 1 -mindepth 1| while read dir
 do

stat/latex_table.cpp

@@ -2,7 +2,7 @@
 //
 //       Filename:  latex_table.cpp
 //
-//    Description:  
+//    Description:  generate latex table
 //
 //        Version:  1.0
 //        Created:  2018年 02月 19日 星期一 16:42:17 CST
@@ -21,11 +21,18 @@
 #include <limits>
 using namespace std;
 
+bool small = true;
+
 string basename(string name) {
 	size_t begin = name.find_last_of('/');
 	return name.substr(begin + 1, name.size() - begin);
 }
 
+template<class T1, class T2>
+bool better(T1 a, T2 b) {
+	return small ? a < b : a > b;
+}
+
 int main(int argc, char const *argv[]) {
 	int solver_count = argc - 1;
 
@@ -56,19 +63,19 @@ int main(int argc, char const *argv[]) {
 	// =====================================================================================
 	//       caculate data
 	// =====================================================================================
-	vector<int> max_size (solver_count);
+	vector<int> best_size (solver_count);
 	vector<double> avg_size (solver_count);
 	vector<double> avg_time (solver_count);
 	vector<int> is_exact (solver_count, 0);
 
-	int g_max_size = 0;
-	double g_max_avg_size = 0;
+	int g_best_size = small ? std::numeric_limits<int>::max() : 0;
+	double g_avg_best_size = small ? std::numeric_limits<double>::max() : 0;
 	double g_min_avg_t = std::numeric_limits<double>::max();
 
 	for (int i = 0; i < solver_count; ++i) {
 		int okay_count = 0;
 
-		int m_s = size_matrix[i][0];
+		int best_s = size_matrix[i][0];
 		double avg_s = size_matrix[i][0];
 		double avg_t = time_matrix[i][0];
 
@@ -77,28 +84,25 @@ int main(int argc, char const *argv[]) {
 		}
 
 		for (size_t j = 1; j < size_matrix[i].size(); ++j) {
-			if (m_s < size_matrix[i][j]) {
-				m_s = size_matrix[i][j];
+			if (better(size_matrix[i][j], best_s)) {
+				best_s = size_matrix[i][j];
 			}
-			avg_s += size_matrix[i][j];
 
-			if (size_matrix[i][j] != 0) {
-				okay_count++;
-			}
-		}
+			avg_s += size_matrix[i][j];
 
-		for (size_t j = 1; j < time_matrix[i].size(); ++j) {
 			avg_t += time_matrix[i][j];
-		}
 
-		for (size_t j = 0; j < exact_matrix[i].size(); ++j) {
 			if (exact_matrix[i][j] == 'x') {
 				is_exact[i] = 1;
 			}
+
+			if (size_matrix[i][j] != 0) {
+				okay_count++;
+			}
 		}
 
 
-		max_size[i] = m_s;
+		best_size[i] = best_s;
 		if (okay_count != 0) {
 			avg_size[i] = round(avg_s / okay_count * 100) / 100;
 			avg_time[i] = round(avg_t / okay_count * 100) / 100;
@@ -112,17 +116,17 @@ int main(int argc, char const *argv[]) {
 			continue;
 		}
 
-		if (g_max_size < max_size[i]) {
-			g_max_size = max_size[i];
+		if (better(best_size[i], g_best_size)) {
+			g_best_size = best_size[i];
 		}
-		if (g_max_avg_size < avg_size[i]) {
-			g_max_avg_size = avg_size[i];
+		if (better(avg_size[i], g_avg_best_size)) {
+			g_avg_best_size = avg_size[i];
 		}
 		if (g_min_avg_t > avg_time[i]) {
 			g_min_avg_t = avg_time[i];
 		}
 	}
-	
+
 	// =====================================================================================
 	//       generate latex table
 	// =====================================================================================
@@ -163,10 +167,10 @@ int main(int argc, char const *argv[]) {
 	int avg_s_win_count = 0;
 	int avg_t_win_count = 0;
 	for (int i = 0; i < solver_count; ++i) {
-		if (max_size[i] == g_max_size) {
+		if (best_size[i] == g_best_size) {
 			s_win_count++;
 		}
-		if (avg_size[i] == g_max_avg_size) {
+		if (avg_size[i] == g_avg_best_size) {
 			avg_s_win_count++;
 		}
 		if (avg_time[i] == g_min_avg_t) {
@@ -175,7 +179,7 @@ int main(int argc, char const *argv[]) {
 	}
 
 	for (int i = 0; i < solver_count; ++i) {
-		if (max_size[i] == 0) {
+		if (best_size[i] == 0) {
 			out_latex << "N/A" << " & " << "N/A";
 			if (i == solver_count - 1) {
 				out_latex << " \\\\" << std::endl;
@@ -186,29 +190,29 @@ int main(int argc, char const *argv[]) {
 			continue;
 		}
 		// size
-		if (max_size[i] != avg_size[i]) { // max size equals to avg size
+		if (best_size[i] != avg_size[i]) {  // max size dosen't equal to avg size
 			if (s_win_count != solver_count) {
-				bf_write(max_size[i], max_size[i] == g_max_size);
+				bf_write(best_size[i], best_size[i] == g_best_size);
 			}
 			else {
-				bf_write(max_size[i], false);
+				bf_write(best_size[i], false);
 			}
 
 			out_latex << "(";
 			if (avg_s_win_count != solver_count) {
-				bf_write(avg_size[i], avg_size[i] == g_max_avg_size);
+				bf_write(avg_size[i], avg_size[i] == g_avg_best_size);
 			}
 			else {
 				bf_write(avg_size[i], false);
 			}
 			out_latex << ")";
 		}
-		else { // max size dosen't equal to avg size
+		else {
 			if (s_win_count != solver_count || avg_s_win_count != solver_count) {
-				bf_write(max_size[i], max_size[i] == g_max_size || avg_size[i] == g_max_avg_size);
+				bf_write(best_size[i], best_size[i] == g_best_size || avg_size[i] == g_avg_best_size);
 			}
 			else {
-				bf_write(max_size[i], false);
+				bf_write(best_size[i], false);
 			}
 		}
 
@@ -242,8 +246,8 @@ int main(int argc, char const *argv[]) {
 	vector<bool> win (solver_count, false);
 	// if (s_win_count != solver_count || avg_s_win_count != solver_count) {
 		for (int i = 0; i < solver_count; ++i) {
-			if (max_size[i] == g_max_size && avg_size[i] == g_max_avg_size) {
-			// if (max_size[i] == g_max_size) {
+			if (best_size[i] == g_best_size && avg_size[i] == g_avg_best_size) {
+			// if (best_size[i] == g_best_size) {
 				win[i] = true;
 			}
 		}
@@ -269,9 +273,9 @@ int main(int argc, char const *argv[]) {
 	out_arch << std::endl;
 
 	// okay solver
-	out_arch << (max_size[0] != 0 ? 1 : 0);
+	out_arch << (best_size[0] != 0 ? 1 : 0);
 	for (int i = 1; i < solver_count; ++i) {
-		out_arch << '\t' << (max_size[i] != 0 ? 1 : 0);
+		out_arch << '\t' << (best_size[i] != 0 ? 1 : 0);
 	}
 	out_arch << endl;
 
@@ -281,7 +285,7 @@ int main(int argc, char const *argv[]) {
 		out_arch << '\t' << (is_exact[i] != 0 ? 1 : 0);
 	}
 	out_arch << endl;
-	
+
 
 	out_arch.close();