TEST_F(GraphCreatorFileTest, testCreateKTree)
{
    Graph::Graph *mg;
    mg = creator->initialize_ktree(100, 50);
    EXPECT_EQ(100, mg->get_num_nodes())
    ;
}
Esempio n. 2
0
TEST_F(GraphCreatorFileTest, testGraph)
{
	Graph::Graph *g = creator->create_graph();
	EXPECT_EQ(128, g->get_num_nodes());
	EXPECT_EQ(1471, g->get_num_edges());

	vector<Graph::Node> n;
	n = g->get_nodes();

	EXPECT_EQ(128, n.size());

	list<int> nbrlist = n[35].get_nbrs();
	vector<int> nbrs(nbrlist.begin(), nbrlist.end());
	EXPECT_EQ(75, nbrs[20]);

	nbrlist = n[127].get_nbrs();
	nbrs.clear();
	nbrs.insert(nbrs.end(), nbrlist.begin(), nbrlist.end());
	EXPECT_EQ(111, nbrs[2]);

	nbrlist = n[0].get_nbrs();
	nbrs.clear();
	nbrs.insert(nbrs.end(), nbrlist.begin(), nbrlist.end());
	EXPECT_EQ(1, nbrs[0]);
	EXPECT_EQ(64, nbrs[6l]);
	EXPECT_EQ(8, nbrs[3l]);

}
void remove_all_edges(int i){
    list<int>::iterator it;
    Graph::Node *n = mg->get_node(i);
    list<int> nbrs = n->get_nbrs();
    for(it = nbrs.begin(); it != nbrs.end(); ++it){
        mg->remove_edge(i, *it);
    }
}
Esempio n. 4
0
 int get_lowest_degree() {
     int n = mg->get_num_nodes();
     int min = INT_MAX;
     int i = 0;
     for(i = 0; i < n; i++) {
         if(min > mg->get_degree(i)) {
             min = mg->get_degree(i);
         }
     }
     return min;
 }
Esempio n. 5
0
 int get_highest_degree() {
     int n = mg->get_num_nodes();
     int max = 0;
     int i = 0;
     for(i = 0; i < n; i++) {
         if(max < mg->get_degree(i)) {
             max = mg->get_degree(i);
         }
     }
     return max;
 }
Esempio n. 6
0
/******************************************************************************
 *                         Create Cluster Graph                               *
 ******************************************************************************/
static
void create_cluster_graph(Graph::Graph& g,
    std::vector<int> clusters,
    int nCluster,
    std::vector<WgtType>& radii,
    Graph::Graph& cg)
{
    // Steps
    //   1. get the linkage between cluster
    //   2. link the edge
    using namespace std;
    vector< vector<int> > cls_connection(nCluster, vector<int>(nCluster, 0));
    vector<int> cls_nodes;
    vector<int> nbors;


    // Step 1
    for (int c=0; c<nCluster; ++c)
    {
        cls_nodes.clear();
        cls_nodes.resize(0);

        for (int i=0; i<g.get_num_vtxs(); ++i)
            if (clusters.at(i) == c) cls_nodes.push_back(i);


        for (int i=0; i<cls_nodes.size(); ++i)
        {
            nbors = g.adj(cls_nodes.at(i));
            for (int n=0; n<nbors.size(); ++n)
            {
                if (clusters.at(nbors.at(n)) != c)
                    cls_connection.at(c).at(clusters.at(nbors.at(n))) += 1;
            }
        }
    }
    // Step 2
    for (int i=0; i<nCluster; ++i)
    {
        for (int j=i+1; j<nCluster; ++j)
            if (cls_connection.at(i).at(j) != 0) cg.add_edge(i, j, radii.at(i) + radii.at(j));
    }
}
Esempio n. 7
0
void NearestNeighborGraph(const vector<Vector3>& pc,int k,Graph::Graph<int,int>& G)
{
  vector<Vector> copy(pc.size());
  for(size_t i=0;i<copy.size();i++) {
    copy[i].resize(3);
    pc[i].get(copy[i]);
  }
  G.Resize(pc.size());
  for(size_t i=0;i<pc.size();i++) 
    G.nodes[i] = (int)i;
  KDTree* tree = KDTree::Create(copy,3,pc.size());
  vector<Real> dist(k);
  vector<int> inds(k);
  for(size_t i=0;i<pc.size();i++) {
    tree->KClosestPoints(copy[i],k,&dist[0],&inds[0]);
    for(int j=0;j<k;j++) {
      if(inds[j] == (int)i) continue;
      G.AddEdge((int)i,inds[j],0);
    }
  }
}
Esempio n. 8
0
int main(int argc, char **argv){
    //usage check
    if((argc == 1) ||
       ((argc == 2) && (strcmp(argv[1],"-h") == 0)) ||
       ((argc == 2) && (strcmp(argv[1], "--help") == 0))){
        usage(argv[0]);
        exit(-1);
    }

    Graph::Graph *g;

    clock_t begin, end;

    Graph::GraphProperties prop;
    Graph::GraphReader ngr;

    //create the graph object
    g = new Graph::Graph();

    //read the graph from the filename, assume it is an edgelist
    ngr.read_graph(g, argv[1], "Edge", false);
    //ngr.read_graph(g, argv[1], "ADJLIST", false);
    printf("Read %d vertices and %d edges\n", g->get_num_nodes(), g->get_num_edges());

    printf("Simplifying graph\n");
    begin = clock();
    prop.make_simple(g);    //remove self loops and duplicate edges
    end = clock();
    printf("Time: %f\n", double(end - begin) / CLOCKS_PER_SEC);

    //compute normalized expansion
    begin = clock();
    vector<double> norm_hops;
    prop.expansion(g, norm_hops);
    end = clock();
    printf("Alg Time (expansion): %f\n", double(end - begin) / CLOCKS_PER_SEC);
} // main
Esempio n. 9
0
static
void force_direct_with_torque(char* outfilePath, Graph::Graph& g, Graph::Graph& cg,
	std::vector< std::pair<int, int> > c_edges,
	DenseMat& cluster_dist_mat,
	std::vector<int>& clusters,
	std::vector< std::vector<CoordType> >& center_coord,
	std::vector< WgtType >& radii,
	std::vector< std::vector<CoordType> >& coord,
	int iteration,
	double initStep)
{

	// Iteration Steps
	// 1. calculate repulsive displacement
	// 2. calculate attractive displacement
	// 3. calculate rotate angle
	// 4. shift and rotate the cluster nodes and corresponding nodes
	using namespace std;
	using namespace boost::posix_time;

	// algorithm declaration
	double step = initStep;
	double curr_energy = INFINITY_ENERGY;
	double pre_energy;

	// for iteration dumping
	fstream fo;

	// [modified!] clusters_nodes
	vector<VtxType> cluster_nodes; // id: vtx id of clustered graph
                                  // val: vtx id in whole graph

	// force equilibrium declaration
	vector< pair<WgtType, WgtType> > node_disp(cg.get_num_vtxs());
	vector< WgtType > rotate_angles(cg.get_num_vtxs());
	pair<WgtType, WgtType> pos_diff;
	double rep_force;
	double att_force;
	double disp_x;
	double disp_y;
	double disp_val;
	int e_u;  // u in c-edge (u, v)
	int e_v;  // v in c-edge (u, v)
	double disp_u_x;
	double disp_u_y;
	double disp_v_x;
	double disp_v_y;
	

	CoordType c_x;  // center of u's x coord
    CoordType c_y;
    CoordType new_x; // relative to center nodes' x coordinates
    CoordType new_y; // relative to center nodes' x coordinates

    double angle;   // perform rotation for current node

    // dump before force process
    fo.open("out/"+string(outfilePath)+"_start.coord", fstream::out);
	for (int i=0; i<coord.size(); ++i)
	{
		fo << coord.at(i).at(0) << " " << coord.at(i).at(1) << endl;
	}
	fo.close();
	// center coord
	fo.open("out/"+string(outfilePath)+"_start.center", fstream::out);
	for (int i=0; i<center_coord.size(); ++i)
	{
		fo << center_coord.at(i).at(0) << " " << center_coord.at(i).at(1) << endl;
	}
	fo.close();

	// angle
	fo.open("out/"+string(outfilePath)+"_start.angle", fstream::out);
	for (int i=0; i<rotate_angles.size(); ++i)
	{
		fo << rotate_angles.at(i) << endl;
	}
	fo.close();

	for (int t=0; t<iteration; t++)
	{
		pre_energy = curr_energy;
		curr_energy = 0;
		// step 1: repulsive force placement
		for (int i=0; i<cg.get_num_vtxs(); ++i)
		{
			node_disp.at(i) = make_pair(0, 0);
			for (int j=0; j<cg.get_num_vtxs(); ++j)
			{
				if (i != j)
				{
					pos_diff = make_pair(center_coord.at(i).at(0)-center_coord.at(j).at(0),
										 center_coord.at(i).at(1)-center_coord.at(j).at(1));
					rep_force = repulsive_force(pos_diff, radii.at(i), radii.at(j));
					disp_x = node_disp.at(i).first + pos_diff.first/pos_diff_dist(pos_diff)*rep_force;
					disp_y = node_disp.at(i).second + pos_diff.second/pos_diff_dist(pos_diff)*rep_force;
					node_disp.at(i) = make_pair(disp_x+node_disp.at(i).first, disp_y+node_disp.at(i).second);
					if (t==0)
					{
						cout << "pos diff of cv_" << i << " = " << pos_diff.first << ", " << pos_diff.second << endl;	
						cout << "repulsive_force of cv_" << i << " = " << rep_force << endl;
						cout << "disp = " << disp_x << ", " << disp_y << endl;
						cout << "node disp = " << node_disp.at(i).first << ", " << node_disp.at(i).second << endl;
					} 
					
				}
			}

		}

		// step 2: attractive force placement
		for (int e=0; e<c_edges.size(); ++e)
		{
			e_u = c_edges.at(e).first;
			e_v = c_edges.at(e).second;

			// \delta <- e.u.pos - e.v.pos
			pos_diff = make_pair(center_coord.at(e_u).at(0)-center_coord.at(e_v).at(0),
								 center_coord.at(e_u).at(1)-center_coord.at(e_v).at(1));

			att_force = attractive_force(pos_diff, radii.at(e_u), radii.at(e_v));

			// e.u.disp <- e.u.disp - unit-direction * att_force(abs(\delta))
			disp_u_x = node_disp.at(e_u).first - pos_diff.first/pos_diff_dist(pos_diff)*att_force;
			disp_u_y = node_disp.at(e_u).second - pos_diff.second/pos_diff_dist(pos_diff)*att_force;
			node_disp.at(e_u) = make_pair(disp_u_x+node_disp.at(e_u).first, disp_u_y+node_disp.at(e_u).second);

			// e.v.disp <- e.v.disp - unit-direction * att_force(abs(\delta))
			disp_v_x = node_disp.at(e_v).first + pos_diff.first/pos_diff_dist(pos_diff)*att_force;
			disp_v_y = node_disp.at(e_v).second + pos_diff.second/pos_diff_dist(pos_diff)*att_force;
			node_disp.at(e_v) = make_pair(disp_v_x+node_disp.at(e_v).first, disp_v_y+node_disp.at(e_v).second);
			if (t==0)
			{
				cout << "pos diff of cv_" << e << " = " << pos_diff.first << ", " << pos_diff.second << endl;	
				cout << "attractive_force of cv_" << e << " = " << att_force << endl;
				cout << "disp = " << disp_v_x << ", " << disp_v_y << endl;
			} 
		}

		// step 3: torque equilibrium
		fill(rotate_angles.begin(), rotate_angles.end(), 0);
		for (int i=0; i<cg.get_num_vtxs(); ++i)
		{
			cluster_nodes.resize(0);
        	for (int c=0; c<clusters.size(); ++c)
            	if (clusters.at(c) == i) cluster_nodes.push_back(c);
			
			calculate_rotate_angle(g, i, cluster_nodes, clusters,
				coord, center_coord, radii, rotate_angles);

		}

		// step 4: shift and rotate the cluster nodes and corresponding nodes
		for (int i=0; i<cg.get_num_vtxs(); ++i)
		{
			cluster_nodes.resize(0);
        	for (int c=0; c<clusters.size(); ++c)
            	if (clusters.at(c) == i) cluster_nodes.push_back(c);

			disp_val = sqrt(pow(node_disp.at(i).first, 2) + pow(node_disp.at(i).second, 2));
			c_x = center_coord.at(i).at(0);
			c_y = center_coord.at(i).at(1);
			c_x += step * node_disp.at(i).first/disp_val;
			c_y += step * node_disp.at(i).second/disp_val;

			for (int j=0; j<cluster_nodes.size(); ++j)
			{
				angle = rotate_angles.at(i);
				// shift nodes
				coord.at(cluster_nodes.at(j)).at(0) -= center_coord.at(i).at(0);
				coord.at(cluster_nodes.at(j)).at(1) -= center_coord.at(i).at(1);

				// rotate nodes
				new_x = coord.at(cluster_nodes.at(j)).at(0);
        		new_y = coord.at(cluster_nodes.at(j)).at(1);
				coord.at(cluster_nodes.at(j)).at(0) = new_x*cos(angle) + new_y*sin(angle);
        		coord.at(cluster_nodes.at(j)).at(1) = -new_x*sin(angle) + new_y*cos(angle);

				// match to new center
				coord.at(cluster_nodes.at(j)).at(0) += c_x;
				coord.at(cluster_nodes.at(j)).at(1) += c_y;

			}

			center_coord.at(i).at(0) = c_x;
			center_coord.at(i).at(1) = c_y;


		}
		

		// update step
		calculate_energy(cluster_dist_mat, center_coord, curr_energy);
		update_step(step, pre_energy, curr_energy);

		cout << "curr_energy=" << curr_energy << endl;
		cout << "step=" << step << endl;

		// check convergence


		// dump information of each iteration
		if (t < 5)
		{
			// coordinates
			fo.open("out/"+string(outfilePath)+"_"+to_string(t)+".coord", fstream::out);
			for (int i=0; i<coord.size(); ++i)
			{
				fo << coord.at(i).at(0) << " " << coord.at(i).at(1) << endl;
			}
			fo.close();

			// center coord
			fo.open("out/"+string(outfilePath)+"_"+to_string(t)+".center", fstream::out);
			for (int i=0; i<center_coord.size(); ++i)
			{
				fo << center_coord.at(i).at(0) << " " << center_coord.at(i).at(0) << endl;
			}
			fo.close();

			// angle
			fo.open("out/"+string(outfilePath)+"_"+to_string(t)+".angle", fstream::out);
			for (int i=0; i<rotate_angles.size(); ++i)
			{
				fo << rotate_angles.at(i) << endl;
			}
			fo.close();
		}
	}

}
Esempio n. 10
0
static
void calculate_rotate_angle(Graph::Graph& g, int cls, std::vector<int>& cluster_nodes,
	std::vector<int>& clusters,
	std::vector< std::vector<CoordType> >& coord,
	std::vector< std::vector<CoordType> >& center_coord,
	std::vector<WgtType>& radii,
	std::vector< WgtType >& rotate_angles)
{
	using namespace std;
	// torque
    int r_u; // current node id
    int r_v; // adjacent node id
    CoordType n_c_x; // center of neighbor's in different cluster
    CoordType n_c_y;
    CoordType r_u_x; // x components of raidus of u
    CoordType r_u_y;
    CoordType c_x;  // center of u's x coord
    CoordType c_y;
    vector<VtxType> nbors; // current node id
    double sin_coeff = 0.0;
    double cos_coeff = 0.0;
    pair<CoordType, CoordType> force;
    pair<CoordType, CoordType> arm;
    double force_val;
    double arm_val;
    double t_angle; // angle of torque

    // topo algo
    for (int j=0; j<cluster_nodes.size(); ++j)
    {
		r_u = cluster_nodes.at(j);
        r_u_x = coord.at(r_u).at(0);
        r_u_y = coord.at(r_u).at(1);
        c_x = center_coord.at(cls).at(0);
        c_y = center_coord.at(cls).at(1);
        arm = make_pair(r_u_x - c_x, r_u_y - c_y);
        arm_val = sqrt( pow(arm.first, 2) + pow(arm.second, 2));

		nbors = g.adj(r_u);
		for (int n=0; n<nbors.size(); ++n)
		{
			r_v = nbors.at(n);
			if ( clusters.at(r_u) != clusters.at(r_v) )
			{
				n_c_x = center_coord.at(clusters.at(r_v)).at(0);
            	n_c_y = center_coord.at(clusters.at(r_v)).at(1);

				// Rotate Step 1: calculate force and angle
				force = make_pair(n_c_x-r_u_x, n_c_y-r_u_y);
                force_val = sqrt( pow(force.first, 2) + pow(force.second, 2));
                force = make_pair(force.first/force_val, force.second/force_val);
                t_angle = (arm_val/radii.at(cls))*M_PI/2*sgn(arm.first*force.second-arm.second*force.first)*(arm.first*force.first+arm.second*force.second);
                rotate_angles.at(cls) += t_angle;
			}
		}

    }

	// for (int j=0; j<cluster_nodes.size(); ++j)
	// {
	// 	r_u = cluster_nodes.at(j);
 //        r_u_x = coord.at(r_u).at(0);
 //        r_u_y = coord.at(r_u).at(1);
 //        c_x = center_coord.at(cls).at(0);
 //        c_y = center_coord.at(cls).at(1);
 //        arm = make_pair(r_u_x - c_x, r_u_y - c_y);
 //        arm_val = sqrt( pow(arm.first, 2) + pow(arm.second, 2));

	// 	nbors = g.adj(r_u);
	// 	for (int n=0; n<nbors.size(); ++n)
	// 	{
	// 		r_v = nbors.at(n);
	// 		if ( clusters.at(r_u) != clusters.at(r_v) )
	// 		{
	// 			n_c_x = center_coord.at(clusters.at(r_v)).at(0);
 //            	n_c_y = center_coord.at(clusters.at(r_v)).at(1);

	// 			// Rotate Step 1: calculate force and angle
	// 			force = make_pair(n_c_x-r_u_x, n_c_y-r_u_y);
 //                force_val = sqrt( pow(force.first, 2) + pow(force.second, 2));
 //                t_angle = acos( (arm.first*force.first+arm.second*force.second) / (arm_val*force_val) );

 //                // Rotate Step 2
 //                // force_val = 1; // make force to be unit
 //                force_val = 1/force_val; // make force to be inverse to the distance
 //                sin_coeff += arm_val*force_val*cos(t_angle);
 //                cos_coeff += arm_val*force_val*sin(t_angle);
	// 		}
	// 	}
	// }

	// // Step 3
 //    cout << sin_coeff << " " << cos_coeff << endl;
 //    rotate_angles.at(cls) = atan(-cos_coeff/sin_coeff) * M_PI / 180;

}
Esempio n. 11
0
int main(int argc, char **argv){
    string infile;
    string outfilename;
    string outprefix;
    string apspinputfilename;
    string lcc_apspinputfilename;
    ofstream outfile;
    ofstream timing_file;
    bool record_timings = false;
    bool file_append = false;
    bool run_largest_cc = true;
    string intype ("edge");
    std::map<string, bool> req_methods;
    std::map<string, bool> val_methods;
    ORB_t t1, t2;
    int spectrum_spread = 0;
    create_map(allowed_methods, val_methods);
    parse_options(argc, argv, infile, intype, outfilename, outprefix, req_methods, record_timings, file_append, run_largest_cc, &spectrum_spread, apspinputfilename, lcc_apspinputfilename);
    if(outfilename.length() == 0){
        if(outprefix.length() != 0){
            outfilename = outprefix + ".stats";
        }
        else {
            outfilename = "graph-stats.txt";
        }
    }
    if(outprefix.length() == 0){
        outprefix = infile;
    }

    // we'd like higher precision when printing values
    std::cout.precision(10);
    #ifdef MPI_VERSION
    MPI_Init(&argc, &argv);
    int myrank;
    MPI_Comm_rank(MPI_COMM_WORLD, &myrank);
    if(myrank == 0){
    #endif
    cout << "done parsing options" << endl;
    cout << "Input  file: " << infile << endl;
    cout << "Input  type: " << intype << endl;
    cout << "Output file: " << outfilename << endl;
    cout << "Appending  : ";
    cout << std::boolalpha << file_append << endl;
    cout << "Methods    :";
    for(map<string, bool>::iterator it = req_methods.begin(); it != req_methods.end(); ++it){
        cout << " " << it->first;
        if(val_methods[it->first] != true){
            cerr << "Error: " << it->first << " is not a valid method! " << endl;
        }
    }
    cout << endl;
    cout << "Calibrating timers" << endl;
    #ifdef MPI_VERSION
} // main

    #endif
    ORB_calibrate();

    // let's do some calculations

    Graph::Graph *g = new(Graph::Graph);
    Graph::GraphReader gr;
    Graph::GraphProperties gp;
    Graph::GraphUtil gu;

    #ifdef MPI_VERSION
    //int myrank;
    //MPI_Comm_rank(MPI_COMM_WORLD, &myrank);
    if(myrank == 0){
    #endif

    // Set up output streams
    if(file_append == false){
        outfile.open(outfilename.c_str());
    }
    else {
        outfile.open(outfilename.c_str(), ios_base::out | ios_base::app);
    }
    if(!outfile.is_open()){
        cerr << "Error opening " << outfilename << " for writing, exiting" << endl;
        exit(1);
    }

    #ifdef MPI_VERSION
}
    #endif

    // Read in the graph and start recording things to output streams
    cout << "Reading graph" << endl;
    ORB_read(t1);
    if(gr.read_graph(g, infile, intype, false) == -1){
        exit(1);
    }
    ORB_read(t2);

    if(outfile.tellp() == 0){
        outfile << "filename " << infile << endl;
        outfile << "input_num_nodes " << g->get_num_nodes() << endl;
        outfile << "input_num_edges " << g->get_num_edges() << endl;
    }

    if(record_timings){
        string of = outfilename + ".timings";

        #ifdef MPI_VERSION
        if(0 == myrank){
        #endif
        if(file_append == false){
            timing_file.open(of.c_str());
        }
        else {
            timing_file.open(of.c_str(), ios_base::out | ios_base::app);
        }
        if(!timing_file.is_open()){
            cerr << "Error opening " << timing_file << " for writing, exiting" << endl;
            exit(1);
        }
        if(false == file_append){
            outfile << "timing_file " << of << endl;
        }
        #ifdef MPI_VERSION
    }
        #endif
    }

    print_time(timing_file, "Time(read_graph)", t1, t2);

    if(apspinputfilename.length() != 0){
        cout << "Reading APSP matrix from " << apspinputfilename << endl;
        vector< vector<int> > *apsp_dists = new vector< vector<int> >;
        ORB_read(t1);
        read_apsp_matrix(apspinputfilename, *apsp_dists);
        ORB_read(t2);
        print_time(timing_file, "Time(read_apsp_matrix)", t1, t2);
        g->set_shortest_path_dist(apsp_dists);
    }

    outfile.precision(16);
    vector<int> components;
    ORB_read(t1);
    gu.label_all_components(g, &components);
    ORB_read(t2);
    print_time(timing_file, "Time(label_all_components)", t1, t2);
    bool is_connected = gp.is_connected(g);
    cout << "Connected components: " << g->get_num_connected_components() << endl;
    //cout << "Graph is connected: " << std::boolalpha << is_connected << endl;

    run_all_methods(g, outfile, timing_file, outprefix, req_methods, file_append, spectrum_spread);
    outfile.close();
    timing_file.close();

    // some algorithms only make sense to run on a connected graph/component
    if(not is_connected and run_largest_cc){  // run everything against the other algorithms
        cout << "Graph is not connected, re-running stats on largest connected component" << endl;
        outfilename = outprefix + ".largest_component.stats";
        if(file_append == false){
            outfile.open(outfilename.c_str());
        }
        else {
            outfile.open(outfilename.c_str(), ios_base::out | ios_base::app);
        }
        if(!outfile.is_open()){
            cerr << "Error opening " << outfilename << " for writing, exiting" << endl;
            exit(1);
        }

        // get the largest component
        Graph::Graph *largest_component = gu.get_largest_component_graph(g);
        cerr << "Deleting g" << endl;
        delete(g);  // delete g here to save on memory
        cerr << "g deleted" << endl;
        if(outfile.tellp() == 0){
            #ifdef MPI_VERSION
            if(0 == myrank){
            #endif
            outfile << "largest_component_from " << infile << endl;
            outfile << "input_num_nodes " << largest_component->get_num_nodes() << endl;
            outfile << "input_num_edges " << largest_component->get_num_edges() << endl;
            #ifdef MPI_VERSION
        }
            #endif
        }
        if(record_timings){
            string of = outfilename + ".timings";
            if(file_append == false){
                timing_file.open(of.c_str());
                #ifdef MPI_VERSION
                if(0 == myrank){
                #endif
                outfile << "timing_file " << of << endl;
                #ifdef MPI_VERSION
            }
                #endif
            }
            else {
                timing_file.open(of.c_str(), ios_base::out | ios_base::app);
            }

            if(!timing_file.is_open()){
                cerr << "Error opening " << timing_file << " for writing, exiting" << endl;
                exit(1);
            }
        }
        if(lcc_apspinputfilename.length() != 0){
            cout << "Reading LCC APSP matrix from " << lcc_apspinputfilename << endl;
            vector< vector<int> > *apsp_dists = new vector< vector<int> >;
            ORB_read(t1);
            read_apsp_matrix(lcc_apspinputfilename, *apsp_dists);
            ORB_read(t2);
            print_time(timing_file, "Time(read_apsp_matrix)", t1, t2);
            largest_component->set_shortest_path_dist(apsp_dists);
        }

        outprefix = outprefix + ".largest_component";

        outfile.precision(16);
        cerr << "Running methods on largest component" << endl;
        run_all_methods(largest_component, outfile, timing_file, outprefix, req_methods, file_append, spectrum_spread);
        outfile.close();
        timing_file.close();
    }

    #ifdef MPI_VERSION
    MPI_Finalize();
    #endif

    exit(0);
} // main
Esempio n. 12
0
std::string to_string(const graph::Graph &g) {
	return "graph " + g.state();
}
Esempio n. 13
0
static
void calculate_nodes_radii(Graph::Graph& g,
    DenseMat& distMat,
    std::vector<int>& clusters,
    std::vector<int>& cluster_nodes,
    std::vector< std::vector<CoordType> >& intra_coord,
    std::vector<WgtType>& nodes_radii)
{
    // Steps
    // 1. Calculate cluster radius
    // 2. get the inter/intra cluster degree of each vtxs
    // 3. calculate radial constriants
    using namespace std;

    // Step 1
    // get the corresponding cluster distance
    // minus central node

    // [modified!] clusters_nodes

    DenseMat clsDistMat(intra_coord.size()-1, intra_coord.size()-1);
    VtxType rr;
    VtxType cc;
    for (int c=0; c<clsDistMat.cols(); ++c)
    {
        for (int r=0; r<clsDistMat.rows(); ++r)
        {
            rr = cluster_nodes.at(r);
            cc = cluster_nodes.at(c);
            clsDistMat(c, r) = distMat(cc, rr);
        }
    }
    cout << "cls distance matrix" << endl;
    cout << clsDistMat << endl;
    // find the maximum pair distance
    double cls_radius = clsDistMat.maxCoeff()/2;

    // Step 2
    vector<VtxType> intra_deg(cluster_nodes.size(), 0);
    vector<VtxType> inter_deg(cluster_nodes.size(), 0);
    vector<VtxType> nbors;
    for (int i=0; i<cluster_nodes.size(); ++i)
    {
        nbors = g.adj( cluster_nodes.at(i) );
        for (int n=0; n<nbors.size(); ++n)
        {
            if (clusters.at( cluster_nodes.at(i) ) == clusters.at( nbors.at(n) ))
            {
                intra_deg.at(i) += 1;
            }
            else
            {
                inter_deg.at(i) += 1;
            }
        }
    }
    cout << "intra_deg=" << intra_deg.size() << endl;
    cout << "inter_deg=" << inter_deg.size() << endl;


    // Step 3
    const int offset = 1;
    double min_inter = *min_element(inter_deg.begin(), inter_deg.end());
    double max_inter = *max_element(inter_deg.begin(), inter_deg.end());
    cout << "radius" << endl;
    for (int i=0; i<nodes_radii.size(); ++i)
    {
        nodes_radii.at(i) = cls_radius*( (inter_deg.at(i)-min_inter+offset) / (max_inter-min_inter+offset) );
    }



}
Esempio n. 14
0
int main(int argc, char** argv)
{
  std::fstream f;
  std::string line;
  f.open(/*"tsp_test.txt"*/argv[1]);
  std::vector<std::string> strs;
  getline(f,line);
  boost::split(strs,line,boost::is_any_of("\t "));
  int n = atoi(strs[0].c_str());
  Graph::Graph* g = new Graph::Graph();
  /*  while(getline(f,line))                                                             //FILL BY EDGES
    {
      boost::split(strs,line,boost::is_any_of("\t "));
      g->addEdge(atoi(strs[0].c_str())-1,atoi(strs[1].c_str())-1,atoi(strs[2].c_str()));

      }*/

  while(getline(f,line))
    {
      boost::split(strs,line,boost::is_any_of("\t "));
      g->addVertexEuclid(atoi(strs[0].c_str()) , atoi(strs[1].c_str()));
    }

  /*  int min;
  try{
    min = g->SSP();
    std::cout<<"ans is "<< min<<std::endl;
  }
  catch(Graph::Exception& e)
    {
      std::cout<<"exception: "<<e.what()<<std::endl;
    }
  
  */
  std::vector<std::pair<std::vector<Graph::Vertex*>,double>  >paths = g->TSPEuclid();//g->TSPEuclidRec(g->getVertex(1));
  int num = 1;

  std::pair<std::vector<Graph::Vertex*>, double> minimalpath = paths.front();
  

  for(std::vector<std::pair< std::vector <Graph::Vertex*>, double> >::iterator i = paths.begin(); i!=paths.end(); ++i)
    {
      //      std::cout<<"path number "<<num<<std::endl;
      /*for(std::vector<Graph::Vertex*>::iterator j = (std::get<0>(*i)).begin();j!=(std::get<0>(*i)).end();++j)
	{
	  std::cout<<"->"<<(*j)->getName();
	  }*/
      if((std::get<1>(*i)) < (std::get<1>(minimalpath)))
	minimalpath = (*i);
      num++;
      //      std::cout<<std::endl<<"lenght = "<<std::get<1>(*i)<<std::endl;
      //      std::cout<<std::endl<<std::endl;
	
    }
  for(std::vector<Graph::Vertex*>::iterator j = (std::get<0>(minimalpath)).begin();j!=(std::get<0>(minimalpath)).end();++j)
    {
      std::cout<<"->"<<(*j)->getName();
    }
  std::cout<<std::endl<<"minimal path cost = "<<std::get<1>(minimalpath)<<std::endl;
  f.close();
  return 0;
}
Esempio n. 15
0
int main(int argc, char **argv){
#if !WIN32 & !CYGWIN
    ORB_t t1, t2;

    char *intype, *outtype, *infile, *outfile;

    // Check for a cry for help
    if((argc == 1) || ((argc == 2) && (strcmp(argv[1],"-h") == 0)) || ((argc == 2) && (strcmp(argv[1],"--help") == 0))
       || ((argc == 2) && (strcmp(argv[1],"--h") == 0) ) ){
        usage(argv[0]);
        exit(0);
    }

    if(argc != 5){
        usage(argv[0]);
        exit(1);
    }

    intype = argv[1];
    outtype = argv[2];
    infile = argv[3];
    outfile = argv[4];

    Graph::Graph *g;
    int seed = 0;

    cout << "calibrating timers\n";

    ORB_calibrate();
    if(!seed){
        // Set the seed to a rand int in 0,2^24
        seed = Graph::rand_int(0,0xffffff);
    }
    // Spin the RNG seed times
    for(int ss = 0; ss < seed; ss++){
        Graph::lcgrand(0);
    }

    Graph::GraphCreatorFile *gcf;

    Graph::GraphProperties prop;
    Graph::GraphReader ngr;
    Graph::GraphWriter writer;

    g = new Graph::Graph();

    cout << "Input type : " << intype << endl;
    cout << "Output type: " << outtype << endl;
    cout << "Reading graph" << endl;
    ORB_read(t1);
    ngr.read_graph(g, infile, intype, false);
    ORB_read(t2);
    print_time("Time(read_graph)", t1, t2);

    // if we don't get rid of duplicate edges, bad things happen
    // when trying to output the graph
    //prop.make_simple(g);

    fprintf(stderr, "edges read in: %d nodes read in: %d\n", g->get_num_edges(), g->get_num_nodes());

    cout << "Writing graph\n";
    ORB_read(t1);
    writer.write_graph(g, outfile, outtype);
    ORB_read(t2);
    print_time("Time(write_graph)", t1, t2);

    return 0;
#else
	fprintf(stderr,"Can't build under Cygwin or Windows\n");
	return 1;
#endif
} // main
TEST_F(GraphCreatorFileTest, testGraph)
{
    Graph::Graph *mg = creator->create_mutable_graph();
    EXPECT_EQ(128, mg->get_num_nodes())
    ;
    EXPECT_EQ(1471, mg->get_num_edges())
    ;

    vector<Graph::Node> n;
    n = mg->get_nodes();

    EXPECT_EQ(128, n.size())
    ;

    list<int> nbrlist = n[35].get_nbrs();
    vector<int> nbrs(nbrlist.begin(), nbrlist.end());
    EXPECT_EQ(75, nbrs[20])
    ;

    nbrlist = n[127].get_nbrs();
    nbrs.clear();
    nbrs.insert(nbrs.end(), nbrlist.begin(), nbrlist.end());
    EXPECT_EQ(111, nbrs[2])
    ;

    nbrlist = n[0].get_nbrs();
    nbrs.clear();
    nbrs.insert(nbrs.end(), nbrlist.begin(), nbrlist.end());
    EXPECT_EQ(1, nbrs[0])
    ;
    EXPECT_EQ(64, nbrs[6l])
    ;
    EXPECT_EQ(8, nbrs[3l])
    ;

    EXPECT_EQ(24, mg->get_degree(35))
    ;
    EXPECT_EQ(28, mg->get_degree(75))
    ;
    mg->remove_edge(35, 75);
    EXPECT_EQ(23, mg->get_degree(35))
    ;
    EXPECT_EQ(27, mg->get_degree(75))
    ;

    mg->remove_vertex(35);
    EXPECT_EQ(0, mg->get_degree(35))
    ;
    EXPECT_EQ(27, mg->get_degree(75))
    ;
}