[Lemon-commits] Balazs Dezso: Porting SmartGraph from svn -r 3481
Lemon HG
hg at lemon.cs.elte.hu
Thu Mar 27 07:41:18 CET 2008
details: http://lemon.cs.elte.hu/hg/lemon/rev/abddaa08b507
changeset: 109:abddaa08b507
user: Balazs Dezso <deba [at] inf.elte.hu>
date: Wed Mar 26 17:28:28 2008 +0100
description:
Porting SmartGraph from svn -r 3481
diffstat:
3 files changed, 761 insertions(+), 3 deletions(-)
lemon/Makefile.am | 1
lemon/smart_graph.h | 757 +++++++++++++++++++++++++++++++++++++++++++++++++++
test/graph_test.cc | 6
diffs (truncated from 802 to 300 lines):
diff -r 889d0c289d19 -r abddaa08b507 lemon/Makefile.am
--- a/lemon/Makefile.am Tue Mar 25 16:36:44 2008 +0100
+++ b/lemon/Makefile.am Wed Mar 26 17:28:28 2008 +0100
@@ -31,6 +31,7 @@
lemon/math.h \
lemon/path.h \
lemon/random.h \
+ lemon/smart_graph.h \
lemon/tolerance.h \
lemon/unionfind.h
diff -r 889d0c289d19 -r abddaa08b507 lemon/smart_graph.h
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/lemon/smart_graph.h Wed Mar 26 17:28:28 2008 +0100
@@ -0,0 +1,757 @@
+/* -*- C++ -*-
+ *
+ * This file is a part of LEMON, a generic C++ optimization library
+ *
+ * Copyright (C) 2003-2008
+ * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
+ * (Egervary Research Group on Combinatorial Optimization, EGRES).
+ *
+ * Permission to use, modify and distribute this software is granted
+ * provided that this copyright notice appears in all copies. For
+ * precise terms see the accompanying LICENSE file.
+ *
+ * This software is provided "AS IS" with no warranty of any kind,
+ * express or implied, and with no claim as to its suitability for any
+ * purpose.
+ *
+ */
+
+#ifndef LEMON_SMART_GRAPH_H
+#define LEMON_SMART_GRAPH_H
+
+///\ingroup graphs
+///\file
+///\brief SmartDigraph and SmartGraph classes.
+
+#include <vector>
+
+#include <lemon/bits/invalid.h>
+
+#include <lemon/bits/base_extender.h>
+#include <lemon/bits/graph_extender.h>
+
+#include <lemon/bits/utility.h>
+#include <lemon/error.h>
+
+#include <lemon/bits/graph_extender.h>
+
+namespace lemon {
+
+ class SmartDigraph;
+ ///Base of SmartDigraph
+
+ ///Base of SmartDigraph
+ ///
+ class SmartDigraphBase {
+ protected:
+
+ struct NodeT
+ {
+ int first_in, first_out;
+ NodeT() {}
+ };
+ struct ArcT
+ {
+ int target, source, next_in, next_out;
+ ArcT() {}
+ };
+
+ std::vector<NodeT> nodes;
+ std::vector<ArcT> arcs;
+
+ public:
+
+ typedef SmartDigraphBase Graph;
+
+ class Node;
+ class Arc;
+
+ public:
+
+ SmartDigraphBase() : nodes(), arcs() { }
+ SmartDigraphBase(const SmartDigraphBase &_g)
+ : nodes(_g.nodes), arcs(_g.arcs) { }
+
+ typedef True NodeNumTag;
+ typedef True ArcNumTag;
+
+ int nodeNum() const { return nodes.size(); }
+ int arcNum() const { return arcs.size(); }
+
+ int maxNodeId() const { return nodes.size()-1; }
+ int maxArcId() const { return arcs.size()-1; }
+
+ Node addNode() {
+ int n = nodes.size();
+ nodes.push_back(NodeT());
+ nodes[n].first_in = -1;
+ nodes[n].first_out = -1;
+ return Node(n);
+ }
+
+ Arc addArc(Node u, Node v) {
+ int n = arcs.size();
+ arcs.push_back(ArcT());
+ arcs[n].source = u._id;
+ arcs[n].target = v._id;
+ arcs[n].next_out = nodes[u._id].first_out;
+ arcs[n].next_in = nodes[v._id].first_in;
+ nodes[u._id].first_out = nodes[v._id].first_in = n;
+
+ return Arc(n);
+ }
+
+ void clear() {
+ arcs.clear();
+ nodes.clear();
+ }
+
+ Node source(Arc a) const { return Node(arcs[a._id].source); }
+ Node target(Arc a) const { return Node(arcs[a._id].target); }
+
+ static int id(Node v) { return v._id; }
+ static int id(Arc a) { return a._id; }
+
+ static Node nodeFromId(int id) { return Node(id);}
+ static Arc arcFromId(int id) { return Arc(id);}
+
+ class Node {
+ friend class SmartDigraphBase;
+ friend class SmartDigraph;
+
+ protected:
+ int _id;
+ explicit Node(int id) : _id(id) {}
+ public:
+ Node() {}
+ Node (Invalid) : _id(-1) {}
+ bool operator==(const Node i) const {return _id == i._id;}
+ bool operator!=(const Node i) const {return _id != i._id;}
+ bool operator<(const Node i) const {return _id < i._id;}
+ };
+
+
+ class Arc {
+ friend class SmartDigraphBase;
+ friend class SmartDigraph;
+
+ protected:
+ int _id;
+ explicit Arc(int id) : _id(id) {}
+ public:
+ Arc() { }
+ Arc (Invalid) : _id(-1) {}
+ bool operator==(const Arc i) const {return _id == i._id;}
+ bool operator!=(const Arc i) const {return _id != i._id;}
+ bool operator<(const Arc i) const {return _id < i._id;}
+ };
+
+ void first(Node& node) const {
+ node._id = nodes.size() - 1;
+ }
+
+ static void next(Node& node) {
+ --node._id;
+ }
+
+ void first(Arc& arc) const {
+ arc._id = arcs.size() - 1;
+ }
+
+ static void next(Arc& arc) {
+ --arc._id;
+ }
+
+ void firstOut(Arc& arc, const Node& node) const {
+ arc._id = nodes[node._id].first_out;
+ }
+
+ void nextOut(Arc& arc) const {
+ arc._id = arcs[arc._id].next_out;
+ }
+
+ void firstIn(Arc& arc, const Node& node) const {
+ arc._id = nodes[node._id].first_in;
+ }
+
+ void nextIn(Arc& arc) const {
+ arc._id = arcs[arc._id].next_in;
+ }
+
+ };
+
+ typedef DigraphExtender<SmartDigraphBase> ExtendedSmartDigraphBase;
+
+ ///\ingroup graphs
+ ///
+ ///\brief A smart directed graph class.
+ ///
+ ///This is a simple and fast digraph implementation.
+ ///It is also quite memory efficient, but at the price
+ ///that <b> it does support only limited (only stack-like)
+ ///node and arc deletions</b>.
+ ///It conforms to the \ref concepts::Digraph "Digraph concept" with
+ ///an important extra feature that its maps are real \ref
+ ///concepts::ReferenceMap "reference map"s.
+ ///
+ ///\sa concepts::Digraph.
+ ///
+ ///\author Alpar Juttner
+ class SmartDigraph : public ExtendedSmartDigraphBase {
+ public:
+
+ typedef ExtendedSmartDigraphBase Parent;
+
+ private:
+
+ ///SmartDigraph is \e not copy constructible. Use DigraphCopy() instead.
+
+ ///SmartDigraph is \e not copy constructible. Use DigraphCopy() instead.
+ ///
+ SmartDigraph(const SmartDigraph &) : ExtendedSmartDigraphBase() {};
+ ///\brief Assignment of SmartDigraph to another one is \e not allowed.
+ ///Use DigraphCopy() instead.
+
+ ///Assignment of SmartDigraph to another one is \e not allowed.
+ ///Use DigraphCopy() instead.
+ void operator=(const SmartDigraph &) {}
+
+ public:
+
+ /// Constructor
+
+ /// Constructor.
+ ///
+ SmartDigraph() {};
+
+ ///Add a new node to the digraph.
+
+ /// \return the new node.
+ ///
+ Node addNode() { return Parent::addNode(); }
+
+ ///Add a new arc to the digraph.
+
+ ///Add a new arc to the digraph with source node \c s
+ ///and target node \c t.
+ ///\return the new arc.
+ Arc addArc(const Node& s, const Node& t) {
+ return Parent::addArc(s, t);
+ }
+
+ /// \brief Using this it is possible to avoid the superfluous memory
+ /// allocation.
+
+ /// Using this it is possible to avoid the superfluous memory
+ /// allocation: if you know that the digraph you want to build will
+ /// be very large (e.g. it will contain millions of nodes and/or arcs)
+ /// then it is worth reserving space for this amount before starting
+ /// to build the digraph.
+ /// \sa reserveArc
+ void reserveNode(int n) { nodes.reserve(n); };
+
+ /// \brief Using this it is possible to avoid the superfluous memory
+ /// allocation.
+
+ /// Using this it is possible to avoid the superfluous memory
+ /// allocation: if you know that the digraph you want to build will
+ /// be very large (e.g. it will contain millions of nodes and/or arcs)
+ /// then it is worth reserving space for this amount before starting
+ /// to build the digraph.
+ /// \sa reserveNode
+ void reserveArc(int m) { arcs.reserve(m); };
+
+ ///Clear the digraph.
+
+ ///Erase all the nodes and arcs from the digraph.
+ ///
+ void clear() {
+ Parent::clear();
+ }
+
+ ///Split a node.
+
+ ///This function splits a node. First a new node is added to the digraph,
+ ///then the source of each outgoing arc of \c n is moved to this new node.
+ ///If \c connect is \c true (this is the default value), then a new arc
+ ///from \c n to the newly created node is also added.
+ ///\return The newly created node.
+ ///
+ ///\note The <tt>Arc</tt>s
+ ///referencing a moved arc remain
+ ///valid. However <tt>InArc</tt>'s and <tt>OutArc</tt>'s
+ ///may be invalidated.
+ ///\warning This functionality cannot be used together with the Snapshot
+ ///feature.
More information about the Lemon-commits
mailing list