richard
/
maximum_planar_subgraph
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Fix: changed data types to remove compile warnings

This commit is contained in:
Richard Wong 2024-03-04 09:00:25 +09:00
parent 808d7e6dae
commit fbbc957fda
Signed by: richard
GPG Key ID: 5BD36BA2E9EE33D0
4 changed files with 37 additions and 38 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
deferred_planarity_test/src/main.cpp
View File

@ -27,7 +27,7 @@ vector<int> generate_mutated_post_order(const ogdf::Graph &G, vector<int> post_o
vector<int> generate_guided_post_order(const ogdf::Graph &G, vector<int> post_order);
void vector_printer(const vector<int>& state) {
for (int i = 0; i < state.size(); ++i) {
for (int i = 0; i < static_cast<int>(state.size()); ++i) {
std::cout << state[i] << ",";
}
std::cout << std::endl;
@ -67,8 +67,7 @@ vector<int> repeated_mutation(const ogdf::Graph &G, int k_max, int mutate_point)
void test_correctness(const ogdf::Graph &G) {
vector<int> state_old = generate_post_order(G);
int num_removed_edges;
num_removed_edges = compute_removed_edge_size(G, state_old);
compute_removed_edge_size(G, state_old);
}

48
deferred_planarity_test/src/mps.cpp
View File

@ -11,8 +11,8 @@ maximal_planar_subgraph_finder::maximal_planar_subgraph_finder() {}
//Destructor
maximal_planar_subgraph_finder::~maximal_planar_subgraph_finder() {
for (int i = 0; i < _node_list.size(); ++i) delete _node_list[i];
for (int i = 0; i < _new_node_list.size(); ++i) delete _new_node_list[i];
for (size_t i = 0; i < _node_list.size(); ++i) delete _node_list[i];
for (size_t i = 0; i < _new_node_list.size(); ++i) delete _new_node_list[i];
}
node*
@ -24,7 +24,7 @@ maximal_planar_subgraph_finder::get_new_node(node_type t) {
vector<int>
maximal_planar_subgraph_finder::return_post_order() {
vector<int> post_order;
for (int i = 0; i < _post_order_list.size(); ++i) {
for (size_t i = 0; i < _post_order_list.size(); ++i) {
post_order.push_back(_post_order_list[i]->node_id());
}
return post_order;
@ -36,7 +36,7 @@ maximal_planar_subgraph_finder::postOrderTraversal() {
node::init_mark();
// always start with node 0
int postOrderID = 0;
for (int i = 0; i < _node_list.size(); ++i) {
for (size_t i = 0; i < _node_list.size(); ++i) {
if (!_node_list[i]->is_marked()) {
_node_list[i]->DFS_visit(_post_order_list, postOrderID);
}
@ -62,7 +62,7 @@ maximal_planar_subgraph_finder::guidedPostOrderTraversal(vector<int> post_order)
unordered_map<int, int> node_id_to_pos;
int j = 0;
// we flip the post_order vector around
for (int i = post_order.size() - 1; i >= 0; --i) {
for (size_t i = post_order.size() - 1; i >= 0; --i) {
node_id_to_pos[post_order[i]] = j++;
}
int postOrderID = 0;
@ -97,14 +97,14 @@ maximal_planar_subgraph_finder::mutatedPostOrderTraversal(vector<int> post_order
node::init_mark();
vector<int> rev_post_order;
for (int i = post_order.size() - 1; i >= 0; --i) {
for (size_t i = post_order.size() - 1; i >= 0; --i) {
rev_post_order.push_back(post_order[i]);
}
int postOrderID = 0;
int traversal_index = 0;
// Define the range [0, n]
int n = _node_list.size() - 1; // Change 'n' to your desired upper bound
// int n = _node_list.size() - 1; // Change 'n' to your desired upper bound
// set loop variables
int start = rev_post_order[0];
@ -135,7 +135,7 @@ maximal_planar_subgraph_finder::mutatedPostOrderTraversal(vector<int> post_order
void
maximal_planar_subgraph_finder::print_post_order() {
int current_index;
for (int i = 0; i < _post_order_list.size(); ++i) {
for (size_t i = 0; i < _post_order_list.size(); ++i) {
current_index = _post_order_list[i]->node_id();
std::cout << current_index << ",";
}
@ -157,12 +157,12 @@ void
maximal_planar_subgraph_finder::sort_adj_list() {
vector<vector<node*> > vecList;
vecList.resize(_post_order_list.size());
for (int i = 0; i < _post_order_list.size(); ++i) {
for (size_t i = 0; i < _post_order_list.size(); ++i) {
for (int j = 0; j < _post_order_list[i]->degree(); ++j) {
vecList[_post_order_list[i]->adj(j)->post_order_index()].push_back(_post_order_list[i]);
}
}
for (int i = 0; i < _post_order_list.size(); ++i) {
for (size_t i = 0; i < _post_order_list.size(); ++i) {
_post_order_list[i]->set_adj_list(vecList[i]);
}
}
@ -171,20 +171,20 @@ maximal_planar_subgraph_finder::sort_adj_list() {
//Order the edges properly.
void
maximal_planar_subgraph_finder::determine_edges() {
for (int i = 0; i < _post_order_list.size(); ++i) {
for (size_t i = 0; i < _post_order_list.size(); ++i) {
if (_post_order_list[i]->parent() == 0) continue;
_post_order_list[i]->set_1st_label(_post_order_list[i]->parent()->post_order_index());
_edge_list.push_back(pair<node*, node*> (_post_order_list[i]->parent(), _post_order_list[i]));
}
for (int i = 0; i < _post_order_list.size(); ++i) {
for (size_t i = 0; i < _post_order_list.size(); ++i) {
for (int j = 0; j < _post_order_list[i]->degree(); ++j) {
if (_post_order_list[i]->adj(j)->post_order_index() > i) break;
if (_post_order_list[i]->adj(j)->get_1st_label() == i) continue;
if (_post_order_list[i]->adj(j)->post_order_index() > static_cast<int>(i)) break;
if (_post_order_list[i]->adj(j)->get_1st_label() == static_cast<int>(i)) continue;
_back_edge_list.push_back(pair<node*, node*> (_post_order_list[i], _post_order_list[i]->adj(j)));
_is_back_edge_eliminate.push_back(false);
}
}
for (int i = 0; i < _post_order_list.size(); ++i) {
for (size_t i = 0; i < _post_order_list.size(); ++i) {
_post_order_list[i]->set_1st_label(INT_MAX);
}
}
@ -194,7 +194,7 @@ void
maximal_planar_subgraph_finder::back_edge_traversal() {
node* i_node = 0;
node* current_node = 0;
for (int i = 0; i < _back_edge_list.size(); ++i) {
for (size_t i = 0; i < _back_edge_list.size(); ++i) {
current_node = _back_edge_list[i].second;
i_node = _back_edge_list[i].first;
if (!back_edge_traversal(current_node, i_node->post_order_index())) _is_back_edge_eliminate[i] = true;
@ -471,7 +471,7 @@ maximal_planar_subgraph_finder::trim(node* u) {
new_AE_root = get_new_node(AE_VIRTUAL_ROOT);
new_AE_root->init_AE(node_list[0]);
//Eliminate the children other than the path.
for (int i = 1; i < node_list.size(); ++i) {
for (size_t i = 1; i < node_list.size(); ++i) {
for (int j = 0; j < node_list[i]->child_num(); ++j) {
if (node_list[i]->child(j) != node_list[i-1]) eliminate(node_list[i]->child(j));
}
@ -481,7 +481,7 @@ maximal_planar_subgraph_finder::trim(node* u) {
else {
node_list[0]->set_to_boundary_path(down, node_list[1]);
node_list[node_list.size()-1]->set_to_boundary_path(up, node_list[node_list.size()-2]);
for (int i = 1; i < node_list.size()-1; ++i) {
for (size_t i = 1; i < node_list.size()-1; ++i) {
node_list[i]->set_to_boundary_path(node_list[i-1], node_list[i+1]);
}
}
@ -489,7 +489,7 @@ maximal_planar_subgraph_finder::trim(node* u) {
up_next = up->get_next(node_list[node_list.size()-1]);
down_next = down->get_next(node_list[0]);
//Unfold the c-nodes in the node_list.
for (int i = 0; i < node_list.size(); ++i) {
for (size_t i = 0; i < node_list.size(); ++i) {
if (node_list[i]->type() == C_NODE) c_node_extension(node_list[i]);
}
//Return the new boundary.
@ -663,7 +663,7 @@ maximal_planar_subgraph_finder::parallel_search_sentinel(node* n0, node* n0_prev
}
//If the c-node found is top-tier, then assign all the traversed node a pointer to c-node.
for (int i = 0; i < traversed.size(); ++i) traversed[i]->set_c_node(c);
for (size_t i = 0; i < traversed.size(); ++i) traversed[i]->set_c_node(c);
return pair<node*, node*>((node*)0, (node*)0);
}
@ -711,7 +711,7 @@ pair<node*, node*> maximal_planar_subgraph_finder::count_sentinel_elimination(pa
node*
maximal_planar_subgraph_finder::construct(node* u) {
//Basic works.
int i_label = u->get_1st_label();
// int i_label = u->get_1st_label(); // unused
node* node_i = _post_order_list[u->get_1st_label()];
parenting_labeling_shaving(u, node_i);
@ -759,7 +759,7 @@ maximal_planar_subgraph_finder::construct(node* u) {
node*
maximal_planar_subgraph_finder::construct(node* c, node* p) {
//Basic works.
int i_label = c->get_1st_label();
// int i_label = c->get_1st_label(); // unused var
node* node_i = _post_order_list[c->get_1st_label()];
parenting_labeling_shaving(p, node_i);
//note: Now, c must have exactly two children left, and c has a parent-link to p, p has achild link to c, too.
@ -830,11 +830,11 @@ maximal_planar_subgraph_finder::parenting_labeling_shaving(node* u, node* node_i
u_i_path.push_back(u_i_path[u_i_path.size()-1]->parent());
if (u_i_path[u_i_path.size()-1] == node_i) break;
}
for (int i = 0; i < u_i_path.size()-2; ++i) {
for (size_t i = 0; i < u_i_path.size()-2; ++i) {
u_i_path[i]->add_child(u_i_path[i+1]);
u_i_path[i+1]->set_parent(u_i_path[i]);
}
for (int i = 0; i < u_i_path.size()-2; ++i) {
for (size_t i = 0; i < u_i_path.size()-2; ++i) {
for (int j = 0; j < u_i_path[i+1]->child_num(); ++j) {
if (u_i_path[i+1]->child(j) == u_i_path[i]) {
u_i_path[i+1]->remove_child(j);

2
deferred_planarity_test/src/mps_test.cpp
View File

@ -175,7 +175,7 @@ void maximal_planar_subgraph_finder::init_from_graph(const ogdf::Graph &G) {
// count the number of removed edges
int maximal_planar_subgraph_finder::output_removed_edge_size() {
int sum = 0;
for (int i = 0; i < _back_edge_list.size(); ++i) {
for (size_t i = 0; i < _back_edge_list.size(); ++i) {
if (_is_back_edge_eliminate[i]) ++sum;
}
return sum;

18
deferred_planarity_test/src/node.cpp
View File

@ -37,7 +37,7 @@ void node::set_post_order_index(int i) {_post_order_index = i;}
//Only used when consturcting c-node
//The first node calling this function would not be labeled.
void node::recursively_labeling() {
for (int i = 0; i < _children.size(); ++i) {
for (size_t i = 0; i < _children.size(); ++i) {
_children[i]->_label.second = ARTIFICIAL_EDGE;
_children[i]->recursively_labeling();
}
@ -58,7 +58,7 @@ void node::set_adj_list(vector<node*> vec) {_adj_list = vec;}
void node::DFS_visit(vector<node*> &dfsList, int &index) {
mark();
for (int i = 0; i < _adj_list.size(); ++i) {
for (size_t i = 0; i < _adj_list.size(); ++i) {
if (!_adj_list[i]->is_marked()) {
_adj_list[i]->_parent = this;
_adj_list[i]->DFS_visit(dfsList, index);
@ -128,7 +128,7 @@ void node::guided_DFS_visit(vector<node *> &dfsList,
for (int i = 0; i < neighbor_list.size(); ++i) {
for (size_t i = 0; i < neighbor_list.size(); ++i) {
if (!neighbor_list[i]->is_marked()) {
neighbor_list[i]->_parent = this;
neighbor_list[i]->guided_DFS_visit(dfsList, node_list, return_index, node_id_to_pos);
@ -157,7 +157,7 @@ void node::mutated_DFS_visit(vector<node*> &dfsList,
// create an unordered set to efficiently check for presence of an element
std::unordered_set<int> neighbor_set;
for (int i = 0; i < _adj_list.size(); ++i) {
for (size_t i = 0; i < _adj_list.size(); ++i) {
neighbor_set.insert(_adj_list[i]->node_id());
}
// when an element in rev_post_order is found in neighbor_set, we add that to neighbor_list
@ -165,7 +165,7 @@ void node::mutated_DFS_visit(vector<node*> &dfsList,
// it is ok if the neighbor was already visited before,
// it would've been marked and will be subsequently ignored
vector<node *> neighbor_list;
for (int i = 0; i < rev_post_order.size(); ++i) {
for (size_t i = 0; i < rev_post_order.size(); ++i) {
if (neighbor_set.find(rev_post_order[i]) != neighbor_set.end()) {
neighbor_list.push_back(node_list[rev_post_order[i]]);
}
@ -185,7 +185,7 @@ void node::mutated_DFS_visit(vector<node*> &dfsList,
#ifdef DEBUG_MUTATION
std::cout << "current node:" << this->node_id() << std::endl;
for (int i = 0; i < neighbor_list.size(); ++i) {
for (size_t i = 0; i < neighbor_list.size(); ++i) {
std::cout << neighbor_list[i]->node_id() << "(" << neighbor_list[i]->is_marked() << ")" << ",";
}
std::cout << std::endl;
@ -196,7 +196,7 @@ void node::mutated_DFS_visit(vector<node*> &dfsList,
// next node will receive incremented index
traversal_index++;
for (int i = 0; i < neighbor_list.size(); ++i)
for (size_t i = 0; i < neighbor_list.size(); ++i)
{
if (!neighbor_list[i]->is_marked())
{
@ -229,7 +229,7 @@ void node::remove_child(int i) {
}
void node::remove_child(node* n) {
for (int i = 0; i < _children.size(); ++i) {
for (size_t i = 0; i < _children.size(); ++i) {
if (_children[i] == n) {
_children[i] = _children[_children.size()-1];
_children.resize(_children.size()-1);
@ -305,7 +305,7 @@ void node::init_AE(node* u) {
if (u->child_num() == 0) return;
_children = u->_children;
u->clear_children();
for (int i = 0; i < _children.size(); ++i) {
for (size_t i = 0; i < _children.size(); ++i) {
_children[i]->set_parent(this);
}
set_parent(u);