From ea7c12f8a1d5b13a07f7ab6c2ca8f4e7f6debf7c Mon Sep 17 00:00:00 2001
From: Jan Travnicek <Jan.Travnicek@fit.cvut.cz>
Date: Wed, 9 Nov 2016 16:11:20 +0100
Subject: [PATCH] enable and fix additional warnings for alib2algo_experimental
---
alib2algo_experimental/makefile | 4 +-
.../src/graph/datastructs/BinomialHeap.h | 4 +-
.../src/graph/datastructs/FibonacciHeap.h | 4 +-
.../src/graph/embedding/HopcroftTarjan.cpp | 163 +++++++++---------
.../src/graph/isomorphism/HopcroftGraph.cpp | 44 ++---
.../src/graph/shortestpath/BellmanFord.cpp | 12 +-
.../src/graph/shortestpath/Dijkstra.cpp | 6 +-
.../src/graph/sort/TopologicalSort.cpp | 8 +-
.../src/graph/spanningtree/Edmonds.cpp | 4 +-
.../src/graph/spanningtree/JarnikPrim.cpp | 6 +-
.../src/graph/spanningtree/Kruskal.cpp | 2 +-
.../graph/minimumcut/FordFulkersonTest.cpp | 4 +-
12 files changed, 129 insertions(+), 132 deletions(-)
diff --git a/alib2algo_experimental/makefile b/alib2algo_experimental/makefile
index 38bca86b66..bf9f76e926 100644
--- a/alib2algo_experimental/makefile
+++ b/alib2algo_experimental/makefile
@@ -10,6 +10,8 @@ endef
export NEW_LINE
+CXX_FLAGS := -Wall -pedantic -Wextra -Werror -Wshadow -Wpointer-arith -Wcast-qual -Wdelete-non-virtual-dtor -Wredundant-decls
+
space := $(eval) $(eval)
LDFLAGS_DEBUG:=-rdynamic -shared
@@ -54,7 +56,7 @@ FORCE:
$${NEW_LINE}\
export NEW_LINE$${NEW_LINE}\
$${NEW_LINE}\
- CXXFLAGS:= -pipe -std=c++11 \$$(CXX_OTHER_FLAGS) -c -Wall -pedantic -Wextra -Werror -fPIC \$$(addprefix -I, \$$(realpath $(INCLUDE_PATHS))) -I\$$(realpath \$$(SOURCES_BASE_DIR)/../src/)$${NEW_LINE}\
+ CXXFLAGS:= -pipe -std=c++11 \$$(CXX_OTHER_FLAGS) -c $(CXX_FLAGS) -fPIC \$$(addprefix -I, \$$(realpath $(INCLUDE_PATHS))) -I\$$(realpath \$$(SOURCES_BASE_DIR)/../src/)$${NEW_LINE}\
$${NEW_LINE}\
SOURCES:= \$$(shell find \$$(SOURCES_BASE_DIR)/\$$(SRCDIR) -maxdepth 1 -type f -name \"*.cpp\")$${NEW_LINE}\
DEPENDENCIES:= \$$(patsubst \$$(SOURCES_BASE_DIR)/\$$(SRCDIR)%.cpp, \$$(OBJECTS_BASE_DIR)/\$$(SRCDIR)%.d, \$$(SOURCES))$${NEW_LINE}\
diff --git a/alib2algo_experimental/src/graph/datastructs/BinomialHeap.h b/alib2algo_experimental/src/graph/datastructs/BinomialHeap.h
index ca5f9d6117..e6a77ffa33 100644
--- a/alib2algo_experimental/src/graph/datastructs/BinomialHeap.h
+++ b/alib2algo_experimental/src/graph/datastructs/BinomialHeap.h
@@ -38,8 +38,8 @@ class BinomialHeap {
Node * parent;
Node * child;
Node * sibling;
- Node( const elem_t & value, uint degree = 0, Node * parent = NULL, Node * child = NULL, Node * sibling = NULL )
- : value(value), degree(degree), parent(parent), child(child), sibling(sibling) {}
+ Node( const elem_t & val, uint deg = 0, Node * par = NULL, Node * chld = NULL, Node * sib = NULL )
+ : value(val), degree(deg), parent(par), child(chld), sibling(sib) {}
};
Node * _head; ///< head of a singly linked list of binomial trees
diff --git a/alib2algo_experimental/src/graph/datastructs/FibonacciHeap.h b/alib2algo_experimental/src/graph/datastructs/FibonacciHeap.h
index 7bc4683eb3..f7d7dc065e 100644
--- a/alib2algo_experimental/src/graph/datastructs/FibonacciHeap.h
+++ b/alib2algo_experimental/src/graph/datastructs/FibonacciHeap.h
@@ -41,8 +41,8 @@ class FibonacciHeap {
Node * child;
Node * prev;
Node * next;
- Node(const elem_t & value, uint degree = 0, Node * parent = NULL, Node * child = NULL, Node * prev = NULL, Node * next = NULL)
- : value(value), degree(degree), mark(false), parent(parent), child(child), prev(prev), next(next) {}
+ Node(const elem_t & val, uint deg = 0, Node * par = NULL, Node * chld = NULL, Node * pr = NULL, Node * ne = NULL)
+ : value(val), degree(deg), mark(false), parent(par), child(chld), prev(pr), next(ne) {}
};
Node * _max; ///< pointer to cyclic doubly linked list of trees
diff --git a/alib2algo_experimental/src/graph/embedding/HopcroftTarjan.cpp b/alib2algo_experimental/src/graph/embedding/HopcroftTarjan.cpp
index 438318e6aa..557e94217a 100644
--- a/alib2algo_experimental/src/graph/embedding/HopcroftTarjan.cpp
+++ b/alib2algo_experimental/src/graph/embedding/HopcroftTarjan.cpp
@@ -21,14 +21,11 @@ namespace embedding
// Helpers
-using node = Node;
-using edge = DirectedEdge;
-
template <typename T>
-using edge_array = std::unordered_map<edge, T>;
+using edge_array = std::unordered_map<DirectedEdge, T>;
template <typename T>
-using node_array = std::unordered_map<node, T>;
+using node_array = std::unordered_map<Node, T>;
template<typename T>
inline void conc(T &container, T &l)
@@ -40,7 +37,7 @@ class GraphWrapper {
public:
explicit GraphWrapper(DirectedGraph *g) : m_g(g) { }
- std::vector<DirectedEdge> adj_edges(const node &n) const
+ std::vector<DirectedEdge> adj_edges(const Node &n) const
{
std::vector<DirectedEdge> out;
const auto &edges = m_g->neighborEdges(n);
@@ -58,7 +55,7 @@ public:
return out;
}
- edge first_adj_edge(const node &n) const
+ DirectedEdge first_adj_edge(const Node &n) const
{
return adj_edges(n).front();
}
@@ -68,7 +65,7 @@ public:
return m_g->getNodes();
}
- node first_node() const
+ Node first_node() const
{
return *m_g->getNodes().begin();
}
@@ -88,7 +85,7 @@ public:
m_sortedEdges = sorted;
}
- void del_edge(const edge &e)
+ void del_edge(const DirectedEdge &e)
{
m_g->removeEdge(e);
}
@@ -111,9 +108,7 @@ private:
edge_array<int> m_sortedEdges;
};
-using graph = GraphWrapper;
-
-bool createReversal(const graph &g, edge_array<edge> &reversal)
+bool createReversal(const GraphWrapper &g, edge_array<DirectedEdge> &reversal)
{
std::vector<DirectedEdge> edges = g.all_edges();
@@ -148,10 +143,10 @@ class Block
{
private:
std::list<int> Latt, Ratt; // list of attachments
- std::list<edge> Lseg, Rseg; // list of segments represented by their defining edges
+ std::list<DirectedEdge> Lseg, Rseg; // list of segments represented by their defining edges
public:
- Block(const edge &e, std::list<int> &A)
+ Block(const DirectedEdge &e, std::list<int> &A)
{
Lseg.push_back(e);
conc(Latt, A);
@@ -161,7 +156,7 @@ public:
void flip()
{
std::list<int> ha;
- std::list<edge> he;
+ std::list<DirectedEdge> he;
// we first interchange |Latt| and |Ratt| and then |Lseg| and |Rseg|
conc(ha, Ratt);
conc(Ratt, Latt);
@@ -237,10 +232,10 @@ public:
return false;
// |Latt| and |Ratt| are empty; we record the placement of the subsegments in |alpha|.
- for (const edge &e : Lseg)
+ for (const DirectedEdge &e : Lseg)
alpha[e] = LEFT;
- for (const edge &e : Rseg)
+ for (const DirectedEdge &e : Rseg)
alpha[e] = RIGHT;
return true;
@@ -259,40 +254,40 @@ public:
// or $\{w0\}$. Also if |Ratt| is non-empty then all subsequent sets are contained
// in $\{w0\}$. So we indeed compute an ordered set of attachments.
- for (const edge &e : Lseg)
+ for (const DirectedEdge &e : Lseg)
alpha[e] = LEFT;
- for (const edge &e : Rseg)
+ for (const DirectedEdge &e : Rseg)
alpha[e] = RIGHT;
}
};
-static void dfs_in_reorder(const graph &G, std::list<edge> &Del, node v, int &dfs_count,
+static void dfs_in_reorder(const GraphWrapper &G, std::list<DirectedEdge> &Del, Node v, int &dfs_count,
node_array<bool> &reached,
node_array<int> &dfsnum,
node_array<int> &lowpt1, node_array<int> &lowpt2,
- node_array<node> &parent);
+ node_array<Node> &parent);
-static void reorder(graph &G, node_array<int> &dfsnum, node_array<node> &parent)
+static void reorder(GraphWrapper &G, node_array<int> &dfsnum, node_array<Node> &parent)
{
node_array<bool> reached;
int dfs_count = 0;
- std::list<edge> Del;
+ std::list<DirectedEdge> Del;
node_array<int> lowpt1, lowpt2;
dfs_in_reorder(G, Del, G.first_node(), dfs_count, reached, dfsnum, lowpt1, lowpt2, parent);
// remove forward and reversals of tree edges
- for (const edge &e : Del)
+ for (const DirectedEdge &e : Del)
G.del_edge(e);
// we now reorder adjacency lists as described in \cite[page 101]{Me:book}
edge_array<int> cost;
- for (const edge &e : G.all_edges()) {
- node v = e.getFromNode();
- node w = e.getToNode();
+ for (const DirectedEdge &e : G.all_edges()) {
+ Node v = e.getFromNode();
+ Node w = e.getToNode();
cost[e] = ((dfsnum[w] < dfsnum[v]) ?
2 * dfsnum[w] :
((lowpt2[w] >= dfsnum[v]) ?
@@ -302,18 +297,18 @@ static void reorder(graph &G, node_array<int> &dfsnum, node_array<node> &parent)
G.sort_edges(cost);
}
-static void dfs_in_reorder(const graph &G, std::list<edge> &Del, node v, int &dfs_count,
+static void dfs_in_reorder(const GraphWrapper &G, std::list<DirectedEdge> &Del, Node v, int &dfs_count,
node_array<bool> &reached,
node_array<int> &dfsnum,
node_array<int> &lowpt1, node_array<int> &lowpt2,
- node_array<node> &parent)
+ node_array<Node> &parent)
{
dfsnum[v] = dfs_count++;
lowpt1[v] = lowpt2[v] = dfsnum[v];
reached[v] = true;
- for (const edge &e : G.adj_edges(v)) {
- node w = e.getToNode();
+ for (const DirectedEdge &e : G.adj_edges(v)) {
+ Node w = e.getToNode();
if (!reached[w]) { // e is a tree edge
parent.erase(w);
parent.insert({w, v});
@@ -330,8 +325,8 @@ static void dfs_in_reorder(const graph &G, std::list<edge> &Del, node v, int &df
// we know |lowpt1[v]| at this point and now make a second pass over all
// adjacent edges of |v| to compute |lowpt2|
- for (const edge &e : G.adj_edges(v)) {
- node w = e.getToNode();
+ for (const DirectedEdge &e : G.adj_edges(v)) {
+ Node w = e.getToNode();
if (parent.at(w) == v) { // tree edge
if (lowpt1[w] != lowpt1[v])
lowpt2[v] = std::min(lowpt2[v], lowpt1[w]);
@@ -342,39 +337,39 @@ static void dfs_in_reorder(const graph &G, std::list<edge> &Del, node v, int &df
}
}
-static bool strongly_planar(edge e0, const graph &G, std::list<int> &Att,
+static bool strongly_planar(DirectedEdge e0, const GraphWrapper &G, std::list<int> &Att,
edge_array<int> &alpha,
node_array<int> &dfsnum,
- node_array<node> &parent)
+ node_array<Node> &parent)
{
- node x = e0.getFromNode();
+ Node x = e0.getFromNode();
- node y = e0.getToNode();
+ Node y = e0.getToNode();
- edge e = G.first_adj_edge(y);
+ DirectedEdge e = G.first_adj_edge(y);
- node wk = y;
+ Node wk = y;
while (dfsnum[e.getToNode()] > dfsnum[wk]) { // e is a tree edge
wk = e.getToNode();
e = G.first_adj_edge(wk);
}
- node w0 = e.getToNode();
+ Node w0 = e.getToNode();
- node w = wk;
+ Node w = wk;
std::stack<Block*> S;
while (w != x) {
int count = 0;
- for (const edge &e : G.adj_edges(w)) {
+ for (const DirectedEdge &ed : G.adj_edges(w)) {
count++;
if (count != 1) { // no action for first edge
std::list<int> A;
- if (dfsnum[w] < dfsnum[e.getToNode()]) { // tree edge
- if (!strongly_planar(e, G, A, alpha, dfsnum, parent)) {
+ if (dfsnum[w] < dfsnum[ed.getToNode()]) { // tree edge
+ if (!strongly_planar(ed, G, A, alpha, dfsnum, parent)) {
while (!S.empty()) {
delete S.top();
S.pop();
@@ -383,10 +378,10 @@ static bool strongly_planar(edge e0, const graph &G, std::list<int> &Att,
}
}
else {
- A.push_back(dfsnum[e.getToNode()]); // a back edge
+ A.push_back(dfsnum[ed.getToNode()]); // a back edge
}
- Block *B = new Block(e, A);
+ Block *B = new Block(ed, A);
while (true) {
if (B->left_interlace(S))
@@ -449,23 +444,23 @@ static bool strongly_planar(edge e0, const graph &G, std::list<int> &Att,
return true;
}
-static void embedding(edge e0, int t, const graph &G,
+static void embedding(DirectedEdge e0, int t, const GraphWrapper &G,
edge_array<int> &alpha,
node_array<int> &dfsnum,
- std::list<edge> &T, std::list<edge> &A, int &cur_nr,
- edge_array<int> &sort_num, node_array<edge> &tree_edge_into,
- node_array<node> &parent, edge_array<edge> &reversal)
+ std::list<DirectedEdge> &T, std::list<DirectedEdge> &A, int &cur_nr,
+ edge_array<int> &sort_num, node_array<DirectedEdge> &tree_edge_into,
+ node_array<Node> &parent, edge_array<DirectedEdge> &reversal)
{
- node x = e0.getFromNode();
+ Node x = e0.getFromNode();
- node y = e0.getToNode();
+ Node y = e0.getToNode();
tree_edge_into.erase(y);
tree_edge_into.insert({y, e0});
- edge e = G.first_adj_edge(y);
+ DirectedEdge e = G.first_adj_edge(y);
- node wk = y;
+ Node wk = y;
while (dfsnum[e.getToNode()] > dfsnum[wk]) { // e is a tree edge
wk = e.getToNode();
@@ -474,32 +469,32 @@ static void embedding(edge e0, int t, const graph &G,
e = G.first_adj_edge(wk);
}
- node w0 = e.getToNode();
- edge back_edge_into_w0 = e;
+ Node w0 = e.getToNode();
+ DirectedEdge back_edge_into_w0 = e;
- node w = wk;
+ Node w = wk;
- std::list<edge> Al, Ar;
- std::list<edge> Tprime, Aprime;
+ std::list<DirectedEdge> Al, Ar;
+ std::list<DirectedEdge> Tprime, Aprime;
T.clear();
T.push_back(e); // |e = (wk,w0)| at this point, line (2)
while (w != x) {
int count = 0;
- for (const edge &e : G.adj_edges(w)) {
+ for (const DirectedEdge &ed : G.adj_edges(w)) {
count++;
if (count != 1) { // no action for first edge
- if (dfsnum[w] < dfsnum[e.getToNode()]) { // tree edge
- int tprime = ((t == alpha[e]) ? LEFT : RIGHT);
- embedding(e, tprime, G, alpha, dfsnum, Tprime, Aprime, cur_nr, sort_num, tree_edge_into, parent, reversal);
+ if (dfsnum[w] < dfsnum[ed.getToNode()]) { // tree edge
+ int tprime = ((t == alpha[ed]) ? LEFT : RIGHT);
+ embedding(ed, tprime, G, alpha, dfsnum, Tprime, Aprime, cur_nr, sort_num, tree_edge_into, parent, reversal);
}
else { // back edge
- Tprime.push_back(e); // $e$
- Aprime.push_back(reversal.at(e)); // reversal of $e$
+ Tprime.push_back(ed); // $e$
+ Aprime.push_back(reversal.at(ed)); // reversal of $e$
}
- if (t == alpha[e]) {
+ if (t == alpha[ed]) {
conc(Tprime, T);
conc(T, Tprime); // $T = Tprime\ conc\ T$
conc(Al, Aprime); // $Al = Al\ conc\ Aprime$
@@ -514,8 +509,8 @@ static void embedding(edge e0, int t, const graph &G,
T.push_back(reversal.at(tree_edge_into.at(w))); // $(w_{j-1},w_j)$
- for (const edge &e : T)
- sort_num[e] = cur_nr++;
+ for (const DirectedEdge &ed : T)
+ sort_num[ed] = cur_nr++;
// |w|'s adjacency list is now computed; we clear |T| and prepare for the
// next iteration by moving all darts incident to |parent[w]| from |Al| and
@@ -552,7 +547,7 @@ static void embedding(edge e0, int t, const graph &G,
// combinatorial embedding of |Gin| by suitably reordering
// its adjacency lists.
// |Gin| must be bidirected in that case.
-bool PLANAR(graph &G, bool embed, HopcroftTarjan::Result &res)
+bool PLANAR(GraphWrapper &G, bool embed, HopcroftTarjan::Result &res)
{
int n = G.number_of_nodes();
@@ -566,21 +561,21 @@ bool PLANAR(graph &G, bool embed, HopcroftTarjan::Result &res)
node_array<int> nr;
edge_array<int> cost;
int cur_nr = 0;
- int n = G.number_of_nodes();
+ int nn = G.number_of_nodes();
- for (const node &v : G.all_nodes())
+ for (const Node &v : G.all_nodes())
nr[v] = cur_nr++;
- for (const edge &e : G.all_edges())
+ for (const DirectedEdge &e : G.all_edges())
cost[e] = ((nr[e.getFromNode()] < nr[e.getToNode()]) ?
- n * nr[e.getFromNode()] + nr[e.getToNode()] :
- n * nr[e.getToNode()] + nr[e.getFromNode()]);
+ nn * nr[e.getFromNode()] + nr[e.getToNode()] :
+ nn * nr[e.getToNode()] + nr[e.getFromNode()]);
G.sort_edges(cost);
- std::vector<edge> L = G.all_edges();
+ std::vector<DirectedEdge> L = G.all_edges();
while (!L.empty()) {
- edge e = L.front();
+ DirectedEdge e = L.front();
L.erase(L.begin());
// check whether the first edge on |L| is equal to the reversal of |e|. If so,
// delete it from |L|, if not, add the reversal to |G|
@@ -593,19 +588,19 @@ bool PLANAR(graph &G, bool embed, HopcroftTarjan::Result &res)
// An undirected planar graph has at most $3n-6$ edges; a directed graph may have twice as many
- edge_array<edge> reversal;
+ edge_array<DirectedEdge> reversal;
if (!createReversal(G, reversal))
throw exception::CommonException("HopcroftTarjan: Graph not bidirected");
node_array<int> dfsnum;
- node_array<node> parent;
- for (const node &n : G.all_nodes())
- parent.insert({n, node("HopcroftTarjan_invalid")}); // no default constructor -,-
+ node_array<Node> parent;
+ for (const Node &an : G.all_nodes())
+ parent.insert({an, Node("HopcroftTarjan_invalid")}); // no default constructor -,-
reorder(G, dfsnum, parent);
edge_array<int> alpha;
- for (const edge &e : G.all_edges())
+ for (const DirectedEdge &e : G.all_edges())
alpha[e] = 0;
{
@@ -618,11 +613,11 @@ bool PLANAR(graph &G, bool embed, HopcroftTarjan::Result &res)
}
if (embed) {
- std::list<edge> T, A; // lists of edges of |H|
+ std::list<DirectedEdge> T, A; // lists of edges of |H|
int cur_nr = 0;
edge_array<int> sort_num;
- node_array<edge> tree_edge_into;
+ node_array<DirectedEdge> tree_edge_into;
embedding(G.first_adj_edge(G.first_node()), LEFT, G, alpha, dfsnum, T, A,
cur_nr, sort_num, tree_edge_into, parent, reversal);
@@ -632,7 +627,7 @@ bool PLANAR(graph &G, bool embed, HopcroftTarjan::Result &res)
conc(T, A);
- for (const edge &e : T)
+ for (const DirectedEdge &e : T)
sort_num[e] = cur_nr++;
std::vector<const DirectedEdge*> edgs(sort_num.size());
diff --git a/alib2algo_experimental/src/graph/isomorphism/HopcroftGraph.cpp b/alib2algo_experimental/src/graph/isomorphism/HopcroftGraph.cpp
index 7ba36ccec1..679c7eabb3 100644
--- a/alib2algo_experimental/src/graph/isomorphism/HopcroftGraph.cpp
+++ b/alib2algo_experimental/src/graph/isomorphism/HopcroftGraph.cpp
@@ -168,8 +168,8 @@ void Graph::removeDistinguishedEdgeAndVertex(EdgeEnd *e)
if (wl == o)
wl = vl;
- v->forEachEdge([=](EdgeEnd *e) {
- e->otheredge->vertex = w;
+ v->forEachEdge([=](EdgeEnd *ee) {
+ ee->otheredge->vertex = w;
return true;
});
@@ -181,8 +181,8 @@ void Graph::removeDistinguishedEdgeAndVertex(EdgeEnd *e)
w->vedge = wk;
w->updateDegree();
- w->forEachEdge([=](EdgeEnd *e) {
- e->vertex->updateDegree();
+ w->forEachEdge([=](EdgeEnd *ee) {
+ ee->vertex->updateDegree();
return true;
});
@@ -206,14 +206,14 @@ void Graph::removeFourDegreeExceptionVertex(Vertex *v, EdgeEnd *e)
//H_DEBUG("remove four degree exception vertex" << v->dump() << e->dump());
// Out: e <ccw> dest
- auto reconnectEdge = [=](EdgeEnd *e, EdgeEnd *dest) {
- e->vertex = dest->otheredge->vertex;
- e->ccwedge = dest;
- e->cwedge = dest->otheredge->cwedge;
- dest->otheredge->cwedge = e->otheredge;
+ auto reconnectEdge = [=](EdgeEnd *ee, EdgeEnd *dest) {
+ ee->vertex = dest->otheredge->vertex;
+ ee->ccwedge = dest;
+ ee->cwedge = dest->otheredge->cwedge;
+ dest->otheredge->cwedge = ee->otheredge;
if (dest->otheredge->ccwedge == dest->otheredge)
- dest->otheredge->ccwedge = e->otheredge;
- e->cwedge->otheredge->ccwedge = e->otheredge;
+ dest->otheredge->ccwedge = ee->otheredge;
+ ee->cwedge->otheredge->ccwedge = ee->otheredge;
};
EdgeEnd *er = e;
@@ -468,14 +468,14 @@ void Graph::init(const UndirectedGraph &graph)
auto &vec = sortedNodeEdges[othernode];
for (size_t i = vec.size(); i-- > 0; ) {
bool isMultiEdge = false;
- EdgeEnd *e = vec[i]->otheredge;
- if (e->ccwedge && e->ccwedge->vertex == e->otheredge->vertex)
+ EdgeEnd *e2 = vec[i]->otheredge;
+ if (e2->ccwedge && e2->ccwedge->vertex == e2->otheredge->vertex)
isMultiEdge = true;
- if (e->cwedge && e->cwedge->vertex == e->otheredge->vertex)
+ if (e2->cwedge && e2->cwedge->vertex == e2->otheredge->vertex)
isMultiEdge = true;
- if (isMultiEdge && e->vertex == v && e->otheredge->vertex == vertex) {
+ if (isMultiEdge && e2->vertex == v && e2->otheredge->vertex == vertex) {
vec.erase(vec.begin() + i);
- edge = e;
+ edge = e2;
break;
}
}
@@ -705,26 +705,26 @@ bool Vertex::isDegreeIsolated() const
std::vector<Face*> Vertex::neighborFaces(Direction direction) const
{
- std::vector<Face*> out;
+ std::vector<Face*> res;
forEachEdge([&](EdgeEnd *e) {
- out.push_back(e->ccwface);
+ res.push_back(e->ccwface);
return true;
}, direction);
- return out;
+ return res;
}
std::vector<EdgeEnd*> Vertex::neighborEdges(Direction direction) const
{
- std::vector<EdgeEnd*> out;
+ std::vector<EdgeEnd*> res;
forEachEdge([&](EdgeEnd *e) {
- out.push_back(e);
+ res.push_back(e);
return true;
}, direction);
- return out;
+ return res;
}
void Vertex::forEachEdge(std::function<bool(EdgeEnd*)> callback, Direction direction) const
diff --git a/alib2algo_experimental/src/graph/shortestpath/BellmanFord.cpp b/alib2algo_experimental/src/graph/shortestpath/BellmanFord.cpp
index 7d3236d5ec..6bb132e1d1 100644
--- a/alib2algo_experimental/src/graph/shortestpath/BellmanFord.cpp
+++ b/alib2algo_experimental/src/graph/shortestpath/BellmanFord.cpp
@@ -73,16 +73,16 @@ static BellmanFord::Result bellmanford_impl(const UndirectedGraph &graph, const
const Node &u = e.getFirstNode();
const Node &v = e.getSecondNode();
- auto f = [&ew, &d](const Node &u, const Node &v) {
- auto du = d.find(u);
- auto dv = d.find(v);
+ auto f = [&ew, &d](const Node &up, const Node &vp) {
+ auto du = d.find(up);
+ auto dv = d.find(vp);
if (du == d.end()) {
return;
}
if (dv == d.end() || du->second + ew < dv->second) {
- d[v] = du->second + ew;
+ d[vp] = du->second + ew;
}
};
@@ -95,8 +95,8 @@ static BellmanFord::Result bellmanford_impl(const UndirectedGraph &graph, const
const Node &u = e.getFirstNode();
const Node &v = e.getSecondNode();
- auto f = [&e, &d, &graph](const Node &u, const Node &v) {
- if (d.at(u) + graph.getEdgeValue(e) < d.at(v)) {
+ auto f = [&e, &d, &graph](const Node &up, const Node &vp) {
+ if (d.at(up) + graph.getEdgeValue(e) < d.at(vp)) {
throw exception::CommonException("BellmanFord: Found negative-weight cycle!");
}
};
diff --git a/alib2algo_experimental/src/graph/shortestpath/Dijkstra.cpp b/alib2algo_experimental/src/graph/shortestpath/Dijkstra.cpp
index 3f7cbe4361..bfcef0813a 100644
--- a/alib2algo_experimental/src/graph/shortestpath/Dijkstra.cpp
+++ b/alib2algo_experimental/src/graph/shortestpath/Dijkstra.cpp
@@ -25,9 +25,9 @@ public:
class Value
{
public:
- Value(const Node &node, int value)
- : node(node)
- , value(value)
+ Value(const Node &n, int v)
+ : node(n)
+ , value(v)
{
}
diff --git a/alib2algo_experimental/src/graph/sort/TopologicalSort.cpp b/alib2algo_experimental/src/graph/sort/TopologicalSort.cpp
index 500bae3ddd..e0e4e07eab 100644
--- a/alib2algo_experimental/src/graph/sort/TopologicalSort.cpp
+++ b/alib2algo_experimental/src/graph/sort/TopologicalSort.cpp
@@ -17,12 +17,12 @@ static TopologicalSort::Result topsort_impl(const DirectedGraph &graph) {
std::unordered_map<Node, bool> visited;
for (const Node &n : graph.getNodes()) {
- traverse::Dfs::dfs(graph, n, [&s, &visited](const Node &n, const Node&, int, int) {
- if (visited.find(n) != visited.end()) {
+ traverse::Dfs::dfs(graph, n, [&s, &visited](const Node &node, const Node&, int, int) {
+ if (visited.find(node) != visited.end()) {
return false;
}
- visited.insert({n, true});
- s.push_front(n);
+ visited.insert({node, true});
+ s.push_front(node);
return true;
});
}
diff --git a/alib2algo_experimental/src/graph/spanningtree/Edmonds.cpp b/alib2algo_experimental/src/graph/spanningtree/Edmonds.cpp
index 64e59edacb..e394ea26ad 100644
--- a/alib2algo_experimental/src/graph/spanningtree/Edmonds.cpp
+++ b/alib2algo_experimental/src/graph/spanningtree/Edmonds.cpp
@@ -39,8 +39,8 @@ struct Edge {
std::vector<Edge*> fChildren;
bool deleted;
- Edge( const DirectedEdge & edge, uint from, uint to, int weight )
- : e(edge), from(from), to(to), weight(weight), origWeight(weight), fParent(NULL), deleted(false) {}
+ Edge( const DirectedEdge & edge, uint f, uint t, int w )
+ : e(edge), from(f), to(t), weight(w), origWeight(w), fParent(NULL), deleted(false) {}
};
static int compareEdges( Edge * const & e1, Edge * const & e2 )
diff --git a/alib2algo_experimental/src/graph/spanningtree/JarnikPrim.cpp b/alib2algo_experimental/src/graph/spanningtree/JarnikPrim.cpp
index 5d56949758..5749136b8e 100644
--- a/alib2algo_experimental/src/graph/spanningtree/JarnikPrim.cpp
+++ b/alib2algo_experimental/src/graph/spanningtree/JarnikPrim.cpp
@@ -21,9 +21,9 @@ public:
class Value {
public:
- Value(const Node &node, int value)
- : node(node)
- , value(value)
+ Value(const Node &n, int v)
+ : node(n)
+ , value(v)
{
}
diff --git a/alib2algo_experimental/src/graph/spanningtree/Kruskal.cpp b/alib2algo_experimental/src/graph/spanningtree/Kruskal.cpp
index accb54e24b..be551c6ca4 100644
--- a/alib2algo_experimental/src/graph/spanningtree/Kruskal.cpp
+++ b/alib2algo_experimental/src/graph/spanningtree/Kruskal.cpp
@@ -23,7 +23,7 @@ namespace spanningtree {
struct WeightedEdge {
UndirectedEdge edge;
int weight;
- WeightedEdge( const UndirectedEdge & edge, int weight ) : edge(edge), weight(weight) {}
+ WeightedEdge( const UndirectedEdge & e, int w ) : edge(e), weight(w) {}
};
bool isWeightSmaller( const WeightedEdge & e1, const WeightedEdge & e2)
diff --git a/alib2algo_experimental/test-src/graph/minimumcut/FordFulkersonTest.cpp b/alib2algo_experimental/test-src/graph/minimumcut/FordFulkersonTest.cpp
index 2af49d058c..ffb10823a3 100644
--- a/alib2algo_experimental/test-src/graph/minimumcut/FordFulkersonTest.cpp
+++ b/alib2algo_experimental/test-src/graph/minimumcut/FordFulkersonTest.cpp
@@ -131,7 +131,7 @@ void testDirNetwork( uint netID, const Type1 * netDef, const Type2 cutDef, uint
graph::minimumcut::Cut cut = graph::minimumcut::FordFulkerson::fordfulkerson( graph, source, sink );
CPPUNIT_ASSERT_EQUAL( cutSize, (uint)cut.size() );
- for (uint i = 0; i < cutSize; i++) {
+ for (i = 0; i < cutSize; i++) {
CPPUNIT_ASSERT( cut.find( std::make_pair( id2node[cutDef[i].node1ID], id2node[cutDef[i].node2ID] ) ) != cut.end() );
}
}
@@ -163,7 +163,7 @@ void testUndirNetwork( uint netID, const Type1 * netDef, const Type2 cutDef, uin
graph::minimumcut::Cut cut = graph::minimumcut::FordFulkerson::fordfulkerson( graph, source, sink );
CPPUNIT_ASSERT_EQUAL( cutSize, (uint)cut.size() );
- for (uint i = 0; i < cutSize; i++) {
+ for (i = 0; i < cutSize; i++) {
CPPUNIT_ASSERT( cut.find( std::make_pair( id2node[cutDef[i].node1ID], id2node[cutDef[i].node2ID] ) ) != cut.end() );
}
}
--
GitLab