diff --git a/bnb/bnb.cpp b/bnb/bnb.cpp
index 66e1bbd925a797555e8eb0dc6ef1dbf87b38a18d..c2d9261dc58600d7b1f294a96e24a1dbfa3b9d5b 100644
--- a/bnb/bnb.cpp
+++ b/bnb/bnb.cpp
@@ -11,7 +11,7 @@ namespace gp_bnb {
// trail_state implementation.
// --------------------------------------------------------------------------------------
-void trail_state::push_node(vertex_id node, subgraph alt) {
+void trail_state::push_node(node_id node, subgraph alt) {
stack_.push_back({node, alt});
}
@@ -23,12 +23,12 @@ void trail_state::pop() {
// solver implementation.
// --------------------------------------------------------------------------------------
-solver::solver(graph& g) : nodes_(g), partition_(partition{g}) {
+solver::solver(graph& g) : graph_(g), partition_(partition{g}) {
}
void solver::solve() {
//anfangs upper bound?
- best_objective_ = nodes_.num_vertices();
+ best_objective_ = graph_.num_nodes();
//partition vector initializieren
@@ -56,11 +56,11 @@ void solver::solve() {
}
//wende dann die entsprechende alternative an
expand(node, alt);
- }else if(trail_.length() == nodes_.num_vertices()) {
+ }else if(trail_.length() == graph_.num_nodes()) {
//falls wir an einem blatt im suchbaum sind
// Memorize the new solution.
- best_solution_.resize(nodes_.num_vertices());
- for(vertex_id node = 0; node < nodes_.num_vertices(); node++){
+ best_solution_.resize(graph_.num_nodes());
+ for(node_id node = 0; node < graph_.num_nodes(); node++){
best_solution_[node] = partition_.assigned_subgraph_of(node);
}
best_objective_ = partition_.current_objective();
@@ -73,7 +73,7 @@ void solver::solve() {
}
}
-void solver::expand(vertex_id node, subgraph sg) {
+void solver::expand(node_id node, subgraph sg) {
// Search for an alternative BEFORE assigning the node.
// Because the node is not assigned, this calculation is easy.
auto alt = next_possible_subgraph(node, static_cast<subgraph>(-sg));
@@ -82,9 +82,9 @@ void solver::expand(vertex_id node, subgraph sg) {
std::cerr << " Alternative " << alt << std::endl;
}
- std::vector<unsigned int> neighbors = nodes_.get_adjacency(node);
+ std::vector<unsigned int> neighbors = graph_.get_adjacency(node);
- partition_.assign_vertex(node, sg);
+ partition_.assign_node(node, sg);
trail_.push_node(node, alt);
}
@@ -96,11 +96,11 @@ void solver::backtrack() {
std::cout << "Unassign node " << node << std::endl;
trail_.pop();
- partition_.unassign_vertex(node);
+ partition_.unassign_node(node);
}
// Finds the next partition in which the given node can be placed.
-subgraph solver::next_possible_subgraph(vertex_id node, subgraph m) {
+subgraph solver::next_possible_subgraph(node_id node, subgraph m) {
// This function is only correct if the node is not assigned yet.
assert(partition_.assigned_subgraph_of(node) == subgraph::none);
@@ -108,7 +108,7 @@ subgraph solver::next_possible_subgraph(vertex_id node, subgraph m) {
subgraph sg = m;
//falls in einer partition schon die hälfte der knoten: nicht als alt wählen
- if((partition_.num_vertices_of(sg) * 2) < nodes_.num_vertices()){
+ if((partition_.num_nodes_of(sg) * 2) < graph_.num_nodes()){
return sg;
}
else{
diff --git a/bnb/graph.cpp b/bnb/graph.cpp
index 314bbdb2c4cb96e0d62a7d636778121ef04a7e41..f1464d196ad202ec26f444cc118ba8fe9050d76a 100644
--- a/bnb/graph.cpp
+++ b/bnb/graph.cpp
@@ -1,12 +1,12 @@
#include <gp-bnb/graph.hpp>
-graph::graph(std::vector<std::vector<unsigned int>> a) : vertices_(a.size()), adjacency_list_(a) {
+graph::graph(std::vector<std::vector<unsigned int>> a) : nodes_(a.size()), adjacency_list_(a) {
}
-unsigned int graph::num_vertices() const {
- return vertices_;
+unsigned int graph::num_nodes() const {
+ return nodes_;
}
-std::vector<unsigned int> graph::get_adjacency(vertex_id v) const {
+std::vector<unsigned int> graph::get_adjacency(node_id v) const {
return adjacency_list_[v-1];
}
diff --git a/bnb/main.cpp b/bnb/main.cpp
index b1b56119e704a316ec2568195a9d4ab4633c2487..e6cb7df90f6471a313cf9e5f6b88faac9420d69a 100755
--- a/bnb/main.cpp
+++ b/bnb/main.cpp
@@ -12,6 +12,6 @@ int main() {
std::string graphFile = "../test/inputs/delaunay_n10.graph";
auto g = metis_reader().read(graphFile);
- std::cout << "Number of nodes: " << g.num_vertices() << std::endl;
+ std::cout << "Number of nodes: " << g.num_nodes() << std::endl;
}
diff --git a/bnb/partition.cpp b/bnb/partition.cpp
index 4d864044967dd61a4b3b014aef2a5daea17085a3..d9cdc1f2070dc22f497d4edd88cbb6a78fee8890 100644
--- a/bnb/partition.cpp
+++ b/bnb/partition.cpp
@@ -2,60 +2,60 @@
#include <gp-bnb/partition.hpp>
-partition::partition(graph& g) : supergraph_(g) {
- // Assigns all vertices to none
- for (unsigned int i = 0; i < g.num_vertices(); i++) {
- vertex_assignments_[i] = none;
+partition::partition(graph& g) : graph_(g) {
+ // Assigns all nodes to none
+ for (unsigned int i = 0; i < g.num_nodes(); i++) {
+ node_assignments_[i] = none;
}
- // Initializes vertex counting map
- vertices_[sg_a] = 0;
- vertices_[sg_b] = 0;
- vertices_[none] = g.num_vertices();
+ // Initializes node counting map
+ nodes_[sg_a] = 0;
+ nodes_[sg_b] = 0;
+ nodes_[none] = g.num_nodes();
}
-unsigned int partition::num_vertices_of(subgraph sg) const {
- return vertices_.at(sg);
+unsigned int partition::num_nodes_of(subgraph sg) const {
+ return nodes_.at(sg);
}
unsigned int partition::current_objective() const {
return current_objective_;
}
-partition::subgraph partition::assigned_subgraph_of(vertex_id v) const {
- return vertex_assignments_[v-1];
+partition::subgraph partition::assigned_subgraph_of(node_id v) const {
+ return node_assignments_[v-1];
}
-void partition::assign_vertex(vertex_id v, subgraph sg) {
- assert(vertex_assignments_[v-1] != none);
+void partition::assign_node(node_id v, subgraph sg) {
+ assert(node_assignments_[v-1] != none);
// Increments current objectives
- for (auto const& target : supergraph_.get_adjacency(v)) {
- if (vertex_assignments_[target-1] == -sg) {
+ for (auto const& target : graph_.get_adjacency(v)) {
+ if (node_assignments_[target-1] == -sg) {
current_objective_++;
}
}
- // Assigns vertex to subgraph
- vertex_assignments_[v-1] = sg;
- vertices_[sg]++;
- vertices_[none]--;
+ // Assigns node to subgraph
+ node_assignments_[v-1] = sg;
+ nodes_[sg]++;
+ nodes_[none]--;
}
-void partition::unassign_vertex(vertex_id v) {
- subgraph sg = vertex_assignments_[v-1];
+void partition::unassign_node(node_id v) {
+ subgraph sg = node_assignments_[v-1];
assert(sg == none);
// Decrements current objectives
- for (auto const& target : supergraph_.get_adjacency(v)) {
- if (vertex_assignments_[target-1] == -sg) {
+ for (auto const& target : graph_.get_adjacency(v)) {
+ if (node_assignments_[target-1] == -sg) {
current_objective_--;
}
}
// Reverts assignment to subgraph
- vertex_assignments_[v-1] = none;
- vertices_[sg]--;
- vertices_[none]++;
+ node_assignments_[v-1] = none;
+ nodes_[sg]--;
+ nodes_[none]++;
}
diff --git a/include/gp-bnb/bnb.hpp b/include/gp-bnb/bnb.hpp
index d5220fd436085ebef5f4a33bf326ff5a592cf8cc..a79f4783e8b9ee3812813a5d324ae04dd73545a2 100644
--- a/include/gp-bnb/bnb.hpp
+++ b/include/gp-bnb/bnb.hpp
@@ -16,7 +16,7 @@ struct trail_state {
private:
struct decision {
// Index of node that is assigned at a certain level of the search tree.
- vertex_id node;
+ node_id node;
// Next alternative (or none if no alternative exists).
subgraph alt;
@@ -24,7 +24,7 @@ private:
public:
// Extends the current path by adding another node.
- void push_node(vertex_id node, subgraph alt);
+ void push_node(node_id node, subgraph alt);
// Reduces the current path by removing the last node.
void pop();
@@ -33,7 +33,7 @@ public:
return stack_.size();
}
- vertex_id node_at(size_t n) const {
+ node_id node_at(size_t n) const {
return stack_[n].node;
}
@@ -54,7 +54,7 @@ struct solver {
// Read-only access to the nodes.
const graph &nodes() const {
- return nodes_;
+ return graph_;
}
// Read-only access to the optimal solution.
@@ -63,7 +63,7 @@ struct solver {
}
// Expand a search tree node, i.e., assigns an node to a partition and update all data structures.
- void expand(vertex_id node, subgraph sg);
+ void expand(node_id node, subgraph sg);
// Performs backtracking after the solver ran into a dead end,
// i.e., the current branch has been pruned.
@@ -73,9 +73,9 @@ struct solver {
void solve();
private:
- subgraph next_possible_subgraph(vertex_id node, subgraph sg);
+ subgraph next_possible_subgraph(node_id node, subgraph sg);
- graph nodes_;
+ graph graph_;
partition partition_;
trail_state trail_;
diff --git a/include/gp-bnb/graph.hpp b/include/gp-bnb/graph.hpp
index 68fed41b2ff14af4ced46eaa6b1c73193588f72d..5d70407f93b001653d6cc6952cbcabc83e3462ff 100644
--- a/include/gp-bnb/graph.hpp
+++ b/include/gp-bnb/graph.hpp
@@ -3,7 +3,7 @@
#include <vector>
-using vertex_id = unsigned int;
+using node_id = unsigned int;
// Represents the input graph to be partitioned
class graph {
@@ -14,19 +14,19 @@ public:
*/
graph(std::vector<std::vector<unsigned int>> a);
- /** @brief Returns the number of vertices of the graph
- * @return Number of vertices
+ /** @brief Returns the number of nodes of the graph
+ * @return Number of nodes
*/
- unsigned int num_vertices() const;
+ unsigned int num_nodes() const;
- /** @brief Provides access to the adjacency of a vertex
- * @param Vertex Id
- * @return Adjacency of the vertex
+ /** @brief Provides access to the adjacency of a node
+ * @param Node Id
+ * @return Adjacency of the node
*/
- std::vector<unsigned int> get_adjacency(vertex_id v) const;
+ std::vector<unsigned int> get_adjacency(node_id v) const;
private:
- unsigned int vertices_;
+ unsigned int nodes_;
std::vector<std::vector<unsigned int>> adjacency_list_;
};
diff --git a/include/gp-bnb/partition.hpp b/include/gp-bnb/partition.hpp
index fefd132c7f384de07d17cab28333f481286f0256..b10b425851468358a2b1785066e86e50a3c2b6e1 100644
--- a/include/gp-bnb/partition.hpp
+++ b/include/gp-bnb/partition.hpp
@@ -5,7 +5,7 @@
#include <vector>
#include <gp-bnb/graph.hpp>
-using vertex_id = unsigned int;
+using node_id = unsigned int;
// Represents potential solutions
class partition {
@@ -17,38 +17,38 @@ public:
*/
partition(graph& g);
- /** @brief Gets the number of vertices of an element of the partition
+ /** @brief Gets the number of nodes of an element of the partition
* @param Subgraph A, B or none
- * @return Number of vertices of sg
+ * @return Number of nodes of sg
*/
- unsigned int num_vertices_of(subgraph sg) const;
+ unsigned int num_nodes_of(subgraph sg) const;
/** @brief Gets the number of edges between subgraph A and B
* @return Objective to be minimized
*/
unsigned int current_objective() const;
- /** @brief Gets the assignment of a vertex
- * @param Vertex Id
+ /** @brief Gets the assignment of a node
+ * @param Node Id
* @return Subgraph A, B or none
*/
- subgraph assigned_subgraph_of(vertex_id v) const;
+ subgraph assigned_subgraph_of(node_id v) const;
- /** @brief Assigns a vertex to a subgraph
- * @param Vertex Id
+ /** @brief Assigns a node to a subgraph
+ * @param Node Id
* @param Subgraph A or B
*/
- void assign_vertex(vertex_id v, subgraph sg);
+ void assign_node(node_id v, subgraph sg);
- /** @brief Reverts the assignment of a vertex to a subgraph
- * @param Vertex Id
+ /** @brief Reverts the assignment of a node to a subgraph
+ * @param Node Id
*/
- void unassign_vertex(vertex_id v);
+ void unassign_node(node_id v);
private:
- graph supergraph_;
- std::vector<subgraph> vertex_assignments_;
- std::map<subgraph,unsigned int> vertices_;
+ graph graph_;
+ std::vector<subgraph> node_assignments_;
+ std::map<subgraph,unsigned int> nodes_;
unsigned int current_objective_ = 0;
};