lemon-0.x: comparison lemon/smart

equal deleted inserted replaced

-:44ab5d7baf9c
+:1a2f137adb26
 ///
 class SmartUGraph : public ExtendedSmartUGraphBase {
 };
-class SmartUBipartiteGraphBase {
+class SmartBpUGraphBase {
 public:
 class NodeSetError : public LogicError {
 virtual const char* exceptionName() const {
-	return "lemon::FullUBipartiteGraph::NodeSetError";
+	return "lemon::SmartBpUGraph::NodeSetError";
 }
 };
 protected:
 NodeT() {}
 NodeT(int _first) : first(_first) {}
 };
 struct EdgeT {
-int upper, next_down;
+int aNode, next_out;
-int lower, next_up;
+int bNode, next_in;
 };
-std::vector<NodeT> upperNodes;
+std::vector<NodeT> aNodes;
-std::vector<NodeT> lowerNodes;
+std::vector<NodeT> bNodes;
 std::vector<EdgeT> edges;
 public:
 class Node {
-friend class SmartUBipartiteGraphBase;
+friend class SmartBpUGraphBase;
 protected:
 int id;
 Node(int _id) : id(_id) {}
 public:
 bool operator!=(const Node i) const {return id!=i.id;}
 bool operator<(const Node i) const {return id<i.id;}
 };
 class Edge {
-friend class SmartUBipartiteGraphBase;
+friend class SmartBpUGraphBase;
 protected:
 int id;
 Edge(int _id) { id = _id;}
 public:
 bool operator==(const Edge i) const {return id==i.id;}
 bool operator!=(const Edge i) const {return id!=i.id;}
 bool operator<(const Edge i) const {return id<i.id;}
 };
-void firstUpper(Node& node) const {
+void firstANode(Node& node) const {
-node.id = 2 * upperNodes.size() - 2;
+node.id = 2 * aNodes.size() - 2;
 if (node.id < 0) node.id = -1;
 }
-void nextUpper(Node& node) const {
+void nextANode(Node& node) const {
 node.id -= 2;
 if (node.id < 0) node.id = -1;
 }
-void firstLower(Node& node) const {
+void firstBNode(Node& node) const {
-node.id = 2 * lowerNodes.size() - 1;
+node.id = 2 * bNodes.size() - 1;
 }
-void nextLower(Node& node) const {
+void nextBNode(Node& node) const {
 node.id -= 2;
 }
 void first(Node& node) const {
-if (upperNodes.size() > 0) {
+if (aNodes.size() > 0) {
-	node.id = 2 * upperNodes.size() - 2;
+	node.id = 2 * aNodes.size() - 2;
 } else {
-	node.id = 2 * lowerNodes.size() - 1;
+	node.id = 2 * bNodes.size() - 1;
 }
 }
 void next(Node& node) const {
 node.id -= 2;
 if (node.id == -2) {
-	node.id = 2 * lowerNodes.size() - 1;
+	node.id = 2 * bNodes.size() - 1;
 }
 }
 void first(Edge& edge) const {
 edge.id = edges.size() - 1;
 }
 void next(Edge& edge) const {
 --edge.id;
 }
-void firstDown(Edge& edge, const Node& node) const {
+void firstOut(Edge& edge, const Node& node) const {
 LEMON_ASSERT((node.id & 1) == 0, NodeSetError());
-edge.id = upperNodes[node.id >> 1].first;
+edge.id = aNodes[node.id >> 1].first;
 }
-void nextDown(Edge& edge) const {
+void nextOut(Edge& edge) const {
-edge.id = edges[edge.id].next_down;
+edge.id = edges[edge.id].next_out;
 }
-void firstUp(Edge& edge, const Node& node) const {
+void firstIn(Edge& edge, const Node& node) const {
 LEMON_ASSERT((node.id & 1) == 1, NodeSetError());
-edge.id = lowerNodes[node.id >> 1].first;
+edge.id = bNodes[node.id >> 1].first;
 }
-void nextUp(Edge& edge) const {
+void nextIn(Edge& edge) const {
-edge.id = edges[edge.id].next_up;
+edge.id = edges[edge.id].next_in;
 }
 static int id(const Node& node) {
 return node.id;
 }
 static Node nodeFromId(int id) {
 return Node(id);
 }
 int maxNodeId() const {
-return upperNodes.size() > lowerNodes.size() ?
+return aNodes.size() > bNodes.size() ?
-	upperNodes.size() * 2 - 2 : lowerNodes.size() * 2 - 1;
+	aNodes.size() * 2 - 2 : bNodes.size() * 2 - 1;
 }
 static int id(const Edge& edge) {
 return edge.id;
 }
 }
 int maxEdgeId() const {
 return edges.size();
 }
-static int upperId(const Node& node) {
+static int aNodeId(const Node& node) {
 return node.id >> 1;
 }
-static Node fromUpperId(int id, Node) {
+static Node fromANodeId(int id, Node) {
 return Node(id << 1);
 }
-int maxUpperId() const {
+int maxANodeId() const {
-return upperNodes.size();
+return aNodes.size();
 }
-static int lowerId(const Node& node) {
+static int bNodeId(const Node& node) {
 return node.id >> 1;
 }
-static Node fromLowerId(int id) {
+static Node fromBNodeId(int id) {
 return Node((id << 1) + 1);
 }
-int maxLowerId() const {
+int maxBNodeId() const {
-return lowerNodes.size();
+return bNodes.size();
 }
-Node upperNode(const Edge& edge) const {
+Node aNode(const Edge& edge) const {
-return Node(edges[edge.id].upper);
+return Node(edges[edge.id].aNode);
 }
-Node lowerNode(const Edge& edge) const {
+Node bNode(const Edge& edge) const {
-return Node(edges[edge.id].lower);
+return Node(edges[edge.id].bNode);
 }
-static bool upper(const Node& node) {
+static bool aNode(const Node& node) {
 return (node.id & 1) == 0;
 }
-static bool lower(const Node& node) {
+static bool bNode(const Node& node) {
 return (node.id & 1) == 1;
 }
-Node addUpperNode() {
+Node addANode() {
 NodeT nodeT;
 nodeT.first = -1;
-upperNodes.push_back(nodeT);
+aNodes.push_back(nodeT);
-return Node(upperNodes.size() * 2 - 2);
+return Node(aNodes.size() * 2 - 2);
 }
-Node addLowerNode() {
+Node addBNode() {
 NodeT nodeT;
 nodeT.first = -1;
-lowerNodes.push_back(nodeT);
+bNodes.push_back(nodeT);
-return Node(lowerNodes.size() * 2 - 1);
+return Node(bNodes.size() * 2 - 1);
 }
 Edge addEdge(const Node& source, const Node& target) {
 LEMON_ASSERT(((source.id ^ target.id) & 1) == 1, NodeSetError());
 EdgeT edgeT;
 if ((source.id & 1) == 0) {
-	edgeT.upper = source.id;
+	edgeT.aNode = source.id;
-	edgeT.lower = target.id;
+	edgeT.bNode = target.id;
 } else {
-	edgeT.upper = target.id;
+	edgeT.aNode = target.id;
-	edgeT.lower = source.id;
+	edgeT.bNode = source.id;
 }
-edgeT.next_down = upperNodes[edgeT.upper >> 1].first;
+edgeT.next_out = aNodes[edgeT.aNode >> 1].first;
-upperNodes[edgeT.upper >> 1].first = edges.size();
+aNodes[edgeT.aNode >> 1].first = edges.size();
-edgeT.next_up = lowerNodes[edgeT.lower >> 1].first;
+edgeT.next_in = bNodes[edgeT.bNode >> 1].first;
-lowerNodes[edgeT.lower >> 1].first = edges.size();
+bNodes[edgeT.bNode >> 1].first = edges.size();
 edges.push_back(edgeT);
 return Edge(edges.size() - 1);
 }
 void clear() {
-upperNodes.clear();
+aNodes.clear();
-lowerNodes.clear();
+bNodes.clear();
 edges.clear();
 }
 };
-typedef ClearableUBipartiteGraphExtender<
+typedef ClearableBpUGraphExtender<
-ExtendableUBipartiteGraphExtender<
+ExtendableBpUGraphExtender<
-MappableUBipartiteGraphExtender<
+MappableBpUGraphExtender<
-IterableUBipartiteGraphExtender<
+IterableBpUGraphExtender<
-AlterableUBipartiteGraphExtender<
+AlterableBpUGraphExtender<
-UBipartiteGraphExtender <
+BpUGraphExtender <
-SmartUBipartiteGraphBase> > > > > >
+SmartBpUGraphBase> > > > > >
-ExtendedSmartUBipartiteGraphBase;
+ExtendedSmartBpUGraphBase;
+/// \ingroup graphs
-class SmartUBipartiteGraph :
+///
-public ExtendedSmartUBipartiteGraphBase {
+/// \brief A smart bipartite undirected graph class.
-};
+///
+/// This is a simple and fast bipartite undirected graph implementation.
+/// It is also quite memory efficient, but at the price
+/// that <b> it does not support node and edge deletions</b>.
+/// Except from this it conforms to
+/// the \ref concept::BpUGraph "BpUGraph" concept.
+/// \sa concept::BpUGraph.
+///
+class SmartBpUGraph : public ExtendedSmartBpUGraphBase {};
 /// @}
 } //namespace lemon

changeset 1939	591e717155ac
parent 1909	2d806130e700
child 1956	a055123339d5