[Lemon-commits] Balazs Dezso: FullBpGraph implementation (#69)
Lemon HG
hg at lemon.cs.elte.hu
Fri Mar 1 17:49:46 CET 2013
details: http://lemon.cs.elte.hu/hg/lemon/rev/5ef0ab7b61cd
changeset: 1188:5ef0ab7b61cd
user: Balazs Dezso <deba [at] inf.elte.hu>
date: Sun Nov 14 22:48:32 2010 +0100
description:
FullBpGraph implementation (#69)
diffstat:
lemon/bits/graph_extender.h | 13 +-
lemon/core.h | 2 +-
lemon/full_graph.h | 430 ++++++++++++++++++++++++++++++++++++++++++++
lemon/smart_graph.h | 13 +-
test/bpgraph_test.cc | 80 ++++++++-
5 files changed, 523 insertions(+), 15 deletions(-)
diffs (truncated from 627 to 300 lines):
diff --git a/lemon/bits/graph_extender.h b/lemon/bits/graph_extender.h
--- a/lemon/bits/graph_extender.h
+++ b/lemon/bits/graph_extender.h
@@ -841,11 +841,14 @@
return Parent::edgeFromId(id);
}
+ Node u(Edge e) const { return this->redNode(e); }
+ Node v(Edge e) const { return this->blueNode(e); }
+
Node oppositeNode(const Node &n, const Edge &e) const {
- if( n == Parent::u(e))
- return Parent::v(e);
- else if( n == Parent::v(e))
- return Parent::u(e);
+ if( n == u(e))
+ return v(e);
+ else if( n == v(e))
+ return u(e);
else
return INVALID;
}
@@ -856,7 +859,7 @@
using Parent::direct;
Arc direct(const Edge &edge, const Node &node) const {
- return Parent::direct(edge, Parent::u(edge) == node);
+ return Parent::direct(edge, Parent::redNode(edge) == node);
}
// Alterable extension
diff --git a/lemon/core.h b/lemon/core.h
--- a/lemon/core.h
+++ b/lemon/core.h
@@ -164,7 +164,7 @@
typedef BpGraph::RedIt RedIt; \
typedef BpGraph::RedMap<bool> BoolRedMap; \
typedef BpGraph::RedMap<int> IntRedMap; \
- typedef BpGraph::RedMap<double> DoubleRedMap \
+ typedef BpGraph::RedMap<double> DoubleRedMap; \
typedef BpGraph::BlueNode BlueNode; \
typedef BpGraph::BlueIt BlueIt; \
typedef BpGraph::BlueMap<bool> BoolBlueMap; \
diff --git a/lemon/full_graph.h b/lemon/full_graph.h
--- a/lemon/full_graph.h
+++ b/lemon/full_graph.h
@@ -621,6 +621,436 @@
};
+ class FullBpGraphBase {
+
+ protected:
+
+ int _red_num, _blue_num;
+ int _node_num, _edge_num;
+
+ public:
+
+ typedef FullBpGraphBase Graph;
+
+ class Node;
+ class Arc;
+ class Edge;
+
+ class Node {
+ friend class FullBpGraphBase;
+ protected:
+
+ int _id;
+ explicit Node(int id) { _id = id;}
+
+ public:
+ Node() {}
+ Node (Invalid) { _id = -1; }
+ bool operator==(const Node& node) const {return _id == node._id;}
+ bool operator!=(const Node& node) const {return _id != node._id;}
+ bool operator<(const Node& node) const {return _id < node._id;}
+ };
+
+ class Edge {
+ friend class FullBpGraphBase;
+ protected:
+
+ int _id;
+ explicit Edge(int id) { _id = id;}
+
+ public:
+ Edge() {}
+ Edge (Invalid) { _id = -1; }
+ bool operator==(const Edge& arc) const {return _id == arc._id;}
+ bool operator!=(const Edge& arc) const {return _id != arc._id;}
+ bool operator<(const Edge& arc) const {return _id < arc._id;}
+ };
+
+ class Arc {
+ friend class FullBpGraphBase;
+ protected:
+
+ int _id;
+ explicit Arc(int id) { _id = id;}
+
+ public:
+ operator Edge() const {
+ return _id != -1 ? edgeFromId(_id / 2) : INVALID;
+ }
+
+ Arc() {}
+ Arc (Invalid) { _id = -1; }
+ bool operator==(const Arc& arc) const {return _id == arc._id;}
+ bool operator!=(const Arc& arc) const {return _id != arc._id;}
+ bool operator<(const Arc& arc) const {return _id < arc._id;}
+ };
+
+
+ protected:
+
+ FullBpGraphBase()
+ : _red_num(0), _blue_num(0), _node_num(0), _edge_num(0) {}
+
+ void construct(int redNum, int blueNum) {
+ _red_num = redNum; _blue_num = blueNum;
+ _node_num = redNum + blueNum; _edge_num = redNum * blueNum;
+ }
+
+ public:
+
+ typedef True NodeNumTag;
+ typedef True EdgeNumTag;
+ typedef True ArcNumTag;
+
+ int nodeNum() const { return _node_num; }
+ int redNum() const { return _red_num; }
+ int blueNum() const { return _blue_num; }
+ int edgeNum() const { return _edge_num; }
+ int arcNum() const { return 2 * _edge_num; }
+
+ int maxNodeId() const { return _node_num - 1; }
+ int maxRedId() const { return _red_num - 1; }
+ int maxBlueId() const { return _blue_num - 1; }
+ int maxEdgeId() const { return _edge_num - 1; }
+ int maxArcId() const { return 2 * _edge_num - 1; }
+
+ bool red(Node n) const { return n._id < _red_num; }
+ bool blue(Node n) const { return n._id >= _red_num; }
+
+ Node source(Arc a) const {
+ if (a._id & 1) {
+ return Node((a._id >> 1) % _red_num);
+ } else {
+ return Node((a._id >> 1) / _red_num + _red_num);
+ }
+ }
+ Node target(Arc a) const {
+ if (a._id & 1) {
+ return Node((a._id >> 1) / _red_num + _red_num);
+ } else {
+ return Node((a._id >> 1) % _red_num);
+ }
+ }
+
+ Node redNode(Edge e) const {
+ return Node(e._id % _red_num);
+ }
+ Node blueNode(Edge e) const {
+ return Node(e._id / _red_num + _red_num);
+ }
+
+ static bool direction(Arc a) {
+ return (a._id & 1) == 1;
+ }
+
+ static Arc direct(Edge e, bool d) {
+ return Arc(e._id * 2 + (d ? 1 : 0));
+ }
+
+ void first(Node& node) const {
+ node._id = _node_num - 1;
+ }
+
+ static void next(Node& node) {
+ --node._id;
+ }
+
+ void firstRed(Node& node) const {
+ node._id = _red_num - 1;
+ }
+
+ static void nextRed(Node& node) {
+ --node._id;
+ }
+
+ void firstBlue(Node& node) const {
+ if (_red_num == _node_num) node._id = -1;
+ else node._id = _node_num - 1;
+ }
+
+ void nextBlue(Node& node) const {
+ if (node._id == _red_num) node._id = -1;
+ else --node._id;
+ }
+
+ void first(Arc& arc) const {
+ arc._id = 2 * _edge_num - 1;
+ }
+
+ static void next(Arc& arc) {
+ --arc._id;
+ }
+
+ void first(Edge& arc) const {
+ arc._id = _edge_num - 1;
+ }
+
+ static void next(Edge& arc) {
+ --arc._id;
+ }
+
+ void firstOut(Arc &a, const Node& v) const {
+ if (v._id < _red_num) {
+ a._id = 2 * (v._id + _red_num * (_blue_num - 1)) + 1;
+ } else {
+ a._id = 2 * (_red_num - 1 + _red_num * (v._id - _red_num));
+ }
+ }
+ void nextOut(Arc &a) const {
+ if (a._id & 1) {
+ a._id -= 2 * _red_num;
+ if (a._id < 0) a._id = -1;
+ } else {
+ if (a._id % (2 * _red_num) == 0) a._id = -1;
+ else a._id -= 2;
+ }
+ }
+
+ void firstIn(Arc &a, const Node& v) const {
+ if (v._id < _red_num) {
+ a._id = 2 * (v._id + _red_num * (_blue_num - 1));
+ } else {
+ a._id = 2 * (_red_num - 1 + _red_num * (v._id - _red_num)) + 1;
+ }
+ }
+ void nextIn(Arc &a) const {
+ if (a._id & 1) {
+ if (a._id % (2 * _red_num) == 1) a._id = -1;
+ else a._id -= 2;
+ } else {
+ a._id -= 2 * _red_num;
+ if (a._id < 0) a._id = -1;
+ }
+ }
+
+ void firstInc(Edge &e, bool& d, const Node& v) const {
+ if (v._id < _red_num) {
+ d = true;
+ e._id = v._id + _red_num * (_blue_num - 1);
+ } else {
+ d = false;
+ e._id = _red_num - 1 + _red_num * (v._id - _red_num);
+ }
+ }
+ void nextInc(Edge &e, bool& d) const {
+ if (d) {
+ e._id -= _red_num;
+ if (e._id < 0) e._id = -1;
+ } else {
+ if (e._id % _red_num == 0) e._id = -1;
+ else --e._id;
+ }
+ }
+
+ static int id(Node v) { return v._id; }
+ int redId(Node v) const {
+ LEMON_DEBUG(v._id < _red_num, "Node has to be red");
+ return v._id;
+ }
+ int blueId(Node v) const {
+ LEMON_DEBUG(v._id >= _red_num, "Node has to be blue");
+ return v._id - _red_num;
+ }
+ static int id(Arc e) { return e._id; }
+ static int id(Edge e) { return e._id; }
+
+ static Node nodeFromId(int id) { return Node(id);}
+ static Arc arcFromId(int id) { return Arc(id);}
+ static Edge edgeFromId(int id) { return Edge(id);}
+
+ bool valid(Node n) const {
+ return n._id >= 0 && n._id < _node_num;
+ }
+ bool valid(Arc a) const {
+ return a._id >= 0 && a._id < 2 * _edge_num;
+ }
+ bool valid(Edge e) const {
+ return e._id >= 0 && e._id < _edge_num;
+ }
+
+ Node redNode(int index) const {
+ return Node(index);
+ }
More information about the Lemon-commits
mailing list