LEMON/LEMON-main Changeset - r778:a143f19f465b

Repositories » LEMON » LEMON-main

Summary
Changelog
Files
Switch To
- loading...
Options
- Lightweight changelog
- Search
Pull Requests

Changeset - r778:a143f19f465b

« 776:eff1ca

779:c160bf »

r778:a143f19f465b

Tue, 29 Sep 2009 13:03:34

[Not Reviewed]

0 comments (0 inline)

kpeter (Peter Kovacs)
kpeter@inf.elte.hu

Make some graph member functions static (#311, #68)

0 6 0

default

6 files changed with 25 insertions and 25 deletions:

lemon/bits/graph_extender.h

lemon/edge_set.h

lemon/full_graph.h

lemon/hypercube_graph.h

lemon/smart_graph.h

lemon/static_graph.h

↑ Collapse diff ↑

lemon/bits/graph_extender.h

Show inline comments

@@ -47,29 +47,29 @@

    typedef typename Parent::Node Node;
    typedef typename Parent::Arc Arc;

    int maxId(Node) const {
      return Parent::maxNodeId();
    }

    int maxId(Arc) const {
      return Parent::maxArcId();
    }

    Node fromId(int id, Node) const {
    static Node fromId(int id, Node) {
      return Parent::nodeFromId(id);
    }

    Arc fromId(int id, Arc) const {
    static Arc fromId(int id, Arc) {
      return Parent::arcFromId(id);
    }

    Node oppositeNode(const Node &node, const Arc &arc) const {
      if (node == Parent::source(arc))
        return Parent::target(arc);
      else if(node == Parent::target(arc))
        return Parent::source(arc);
      else
        return INVALID;
    }

@@ -346,33 +346,33 @@
    int maxId(Node) const {
      return Parent::maxNodeId();
    }

    int maxId(Arc) const {
      return Parent::maxArcId();
    }

    int maxId(Edge) const {
      return Parent::maxEdgeId();
    }

    Node fromId(int id, Node) const {
    static Node fromId(int id, Node) {
      return Parent::nodeFromId(id);
    }

    Arc fromId(int id, Arc) const {
    static Arc fromId(int id, Arc) {
      return Parent::arcFromId(id);
    }

    Edge fromId(int id, Edge) const {
    static Edge fromId(int id, Edge) {
      return Parent::edgeFromId(id);
    }

    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);
      else
        return INVALID;
    }


lemon/edge_set.h

Show inline comments

@@ -858,25 +858,25 @@
    void first(Node& node) const {
      _graph->first(node);
    }

    void next(Node& node) const {
      _graph->next(node);
    }

    void first(Arc& arc) const {
      arc.id = arcs.size() - 1;
    }

    void next(Arc& arc) const {
    static void next(Arc& arc) {
      --arc.id;
    }

    void firstOut(Arc& arc, const Node& node) const {
      arc.id = (*_nodes)[node].first_out;
    }

    void nextOut(Arc& arc) const {
      arc.id = arcs[arc.id].next_out;
    }

    void firstIn(Arc& arc, const Node& node) const {
@@ -1164,33 +1164,33 @@
    void first(Node& node) const {
      _graph->first(node);
    }

    void next(Node& node) const {
      _graph->next(node);
    }

    void first(Arc& arc) const {
      arc.id = arcs.size() - 1;
    }

    void next(Arc& arc) const {
    static void next(Arc& arc) {
      --arc.id;
    }

    void first(Edge& arc) const {
      arc.id = arcs.size() / 2 - 1;
    }

    void next(Edge& arc) const {
    static void next(Edge& arc) {
      --arc.id;
    }

    void firstOut(Arc& arc, const Node& node) const {
      arc.id = (*_nodes)[node].first_out;
    }

    void nextOut(Arc& arc) const {
      arc.id = arcs[arc.id].next_out;
    }

    void firstIn(Arc& arc, const Node& node) const {

lemon/full_graph.h

Show inline comments

@@ -42,25 +42,25 @@
 		    int _arc_num;
 		    FullDigraphBase() {}
 		    void construct(int n) { _node_num = n; _arc_num = n * n; }
 		  public:
 		    typedef True NodeNumTag;
 		    typedef True ArcNumTag;
 		    Node operator()(int ix) const { return Node(ix); }
-		    int index(const Node& node) const { return node._id; }
+		    static int index(const Node& node) { return node._id; }
 		    Arc arc(const Node& s, const Node& t) const {
 		      return Arc(s._id * _node_num + t._id);
+		    }
 		    int nodeNum() const { return _node_num; }
 		    int arcNum() const { return _arc_num; }
 		    int maxNodeId() const { return _node_num - 1; }
 		    int maxArcId() const { return _arc_num - 1; }
 		    Node source(Arc arc) const { return arc._id / _node_num; }
@@ -200,25 +200,25 @@
 		    /// Returns the node with the given index. Since it is a static
 		    /// digraph its nodes can be indexed with integers from the range
 		    /// <tt>[0..nodeNum()-1]</tt>.
 		    /// \sa index()
 		    Node operator()(int ix) const { return Parent::operator()(ix); }
 		    /// \brief Returns the index of the given node.
 		    ///
 		    /// Returns the index of the given node. Since it is a static
 		    /// digraph its nodes can be indexed with integers from the range
 		    /// <tt>[0..nodeNum()-1]</tt>.
 		    /// \sa operator()
-		    int index(const Node& node) const { return Parent::index(node); }
+		    static int index(const Node& node) { return Parent::index(node); }
 		    /// \brief Returns the arc connecting the given nodes.
 		    ///
 		    /// Returns the arc connecting the given nodes.
 		    Arc arc(const Node& u, const Node& v) const {
 		      return Parent::arc(u, v);
+		    }
 		    /// \brief Number of nodes.
 		    int nodeNum() const { return Parent::nodeNum(); }
 		    /// \brief Number of arcs.
 		    int arcNum() const { return Parent::arcNum(); }
@@ -274,25 +274,25 @@
 		    int _eid(int u, int v) const {
 		      if (u < (_node_num - 1) / 2) {
 		        return u * _node_num + v;
 		      } else {
 		        return (_node_num - 1 - u) * _node_num - v - 1;
+		      }
+		    }
 		  public:
 		    Node operator()(int ix) const { return Node(ix); }
-		    int index(const Node& node) const { return node._id; }
+		    static int index(const Node& node) { return node._id; }
 		    Edge edge(const Node& u, const Node& v) const {
 		      if (u._id < v._id) {
 		        return Edge(_eid(u._id, v._id));
 		      } else if (u._id != v._id) {
 		        return Edge(_eid(v._id, u._id));
 		      } else {
 		        return INVALID;
+		      }
+		    }
 		    Arc arc(const Node& s, const Node& t) const {
@@ -571,25 +571,25 @@
 		    /// Returns the node with the given index. Since it is a static
 		    /// graph its nodes can be indexed with integers from the range
 		    /// <tt>[0..nodeNum()-1]</tt>.
 		    /// \sa index()
 		    Node operator()(int ix) const { return Parent::operator()(ix); }
 		    /// \brief Returns the index of the given node.
 		    ///
 		    /// Returns the index of the given node. Since it is a static
 		    /// graph its nodes can be indexed with integers from the range
 		    /// <tt>[0..nodeNum()-1]</tt>.
 		    /// \sa operator()
-		    int index(const Node& node) const { return Parent::index(node); }
+		    static int index(const Node& node) { return Parent::index(node); }
 		    /// \brief Returns the arc connecting the given nodes.
 		    ///
 		    /// Returns the arc connecting the given nodes.
 		    Arc arc(const Node& s, const Node& t) const {
 		      return Parent::arc(s, t);
+		    }
 		    /// \brief Returns the edge connects the given nodes.
 		    ///
 		    /// Returns the edge connects the given nodes.
 		    Edge edge(const Node& u, const Node& v) const {

lemon/hypercube_graph.h

Show inline comments

@@ -253,25 +253,25 @@
 		    bool projection(Node node, int n) const {
 		      return static_cast<bool>(node._id & (1 << n));
+		    }
 		    int dimension(Edge edge) const {
 		      return edge._id >> (_dim-1);
+		    }
 		    int dimension(Arc arc) const {
 		      return arc._id >> _dim;
+		    }
-		    int index(Node node) const {
+		    static int index(Node node) {
 		      return node._id;
+		    }
 		    Node operator()(int ix) const {
 		      return Node(ix);
+		    }
 		  private:
 		    int _dim;
 		    int _node_num, _edge_num;
 		  };
@@ -328,25 +328,25 @@
 		    /// \brief The dimension id of an arc.
 		    ///
 		    /// Gives back the dimension id of the given arc.
 		    /// It is in the [0..dim-1] range.
 		    int dimension(Arc arc) const {
 		      return Parent::dimension(arc);
+		    }
 		    /// \brief The index of a node.
 		    ///
 		    /// Gives back the index of the given node.
 		    /// The lower bits of the integer describes the node.
-		    int index(Node node) const {
+		    static int index(Node node) {
 		      return Parent::index(node);
+		    }
 		    /// \brief Gives back a node by its index.
 		    ///
 		    /// Gives back a node by its index.
 		    Node operator()(int ix) const {
 		      return Parent::operator()(ix);
+		    }
 		    /// \brief Number of nodes.
 		    int nodeNum() const { return Parent::nodeNum(); }

lemon/smart_graph.h

Show inline comments

@@ -499,41 +499,41 @@
    static bool direction(Arc e) {
      return (e._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 = nodes.size() - 1;
    }

    void next(Node& node) const {
    static void next(Node& node) {
      --node._id;
    }

    void first(Arc& arc) const {
      arc._id = arcs.size() - 1;
    }

    void next(Arc& arc) const {
    static void next(Arc& arc) {
      --arc._id;
    }

    void first(Edge& arc) const {
      arc._id = arcs.size() / 2 - 1;
    }

    void next(Edge& arc) const {
    static void next(Edge& arc) {
      --arc._id;
    }

    void firstOut(Arc &arc, const Node& v) const {
      arc._id = nodes[v._id].first_out;
    }
    void nextOut(Arc &arc) const {
      arc._id = arcs[arc._id].next_out;
    }

    void firstIn(Arc &arc, const Node& v) const {
      arc._id = ((nodes[v._id].first_out) ^ 1);

lemon/static_graph.h

Show inline comments

@@ -83,30 +83,30 @@
 		    void first(Arc& e) const { e.id = arc_num - 1; }
 		    static void next(Arc& e) { --e.id; }
 		    void firstOut(Arc& e, const Node& n) const {
 		      e.id = node_first_out[n.id] != node_first_out[n.id + 1] ?
 		        node_first_out[n.id] : -1;
+		    }
 		    void nextOut(Arc& e) const { e.id = arc_next_out[e.id]; }
 		    void firstIn(Arc& e, const Node& n) const { e.id = node_first_in[n.id]; }
 		    void nextIn(Arc& e) const { e.id = arc_next_in[e.id]; }
 		    int id(const Node& n) const { return n.id; }
 		    Node nodeFromId(int id) const { return Node(id); }
 		    static int id(const Node& n) { return n.id; }
 		    static Node nodeFromId(int id) { return Node(id); }
 		    int maxNodeId() const { return node_num - 1; }
 		    int id(const Arc& e) const { return e.id; }
 		    Arc arcFromId(int id) const { return Arc(id); }
 		    static int id(const Arc& e) { return e.id; }
 		    static Arc arcFromId(int id) { return Arc(id); }
 		    int maxArcId() const { return arc_num - 1; }
 		    typedef True NodeNumTag;
 		    typedef True ArcNumTag;
 		    int nodeNum() const { return node_num; }
 		    int arcNum() const { return arc_num; }
 		  private:
 		    template <typename Digraph, typename NodeRefMap>
 		    class ArcLess {
@@ -259,43 +259,43 @@
 		  public:
 		    /// \brief Constructor
 		    ///
 		    /// Default constructor.
 		    StaticDigraph() : Parent() {}
 		    /// \brief The node with the given index.
 		    ///
 		    /// This function returns the node with the given index.
 		    /// \sa index()
-		    Node node(int ix) const { return Parent::nodeFromId(ix); }
+		    static Node node(int ix) { return Parent::nodeFromId(ix); }
 		    /// \brief The arc with the given index.
 		    ///
 		    /// This function returns the arc with the given index.
 		    /// \sa index()
-		    Arc arc(int ix) const { return Parent::arcFromId(ix); }
+		    static Arc arc(int ix) { return Parent::arcFromId(ix); }
 		    /// \brief The index of the given node.
 		    ///
 		    /// This function returns the index of the the given node.
 		    /// \sa node()
-		    int index(Node node) const { return Parent::id(node); }
+		    static int index(Node node) { return Parent::id(node); }
 		    /// \brief The index of the given arc.
 		    ///
 		    /// This function returns the index of the the given arc.
 		    /// \sa arc()
-		    int index(Arc arc) const { return Parent::id(arc); }
+		    static int index(Arc arc) { return Parent::id(arc); }
 		    /// \brief Number of nodes.
 		    ///
 		    /// This function returns the number of nodes.
 		    int nodeNum() const { return node_num; }
 		    /// \brief Number of arcs.
 		    ///
 		    /// This function returns the number of arcs.
 		    int arcNum() const { return arc_num; }
 		    /// \brief Build the digraph copying another digraph.

0 comments (0 inline)

...	...	@@ -47,29 +47,29 @@
47	47
48	48	typedef typename Parent::Node Node;
49	49	typedef typename Parent::Arc Arc;
50	50
51	51	int maxId(Node) const {
52	52	return Parent::maxNodeId();
53	53	}
54	54
55	55	int maxId(Arc) const {
56	56	return Parent::maxArcId();
57	57	}
58	58
59		Node fromId(int id, Node) ~~const~~ {
	59	static Node fromId(int id, Node) {
60	60	return Parent::nodeFromId(id);
61	61	}
62	62
63		Arc fromId(int id, Arc) ~~const~~ {
	63	static Arc fromId(int id, Arc) {
64	64	return Parent::arcFromId(id);
65	65	}
66	66
67	67	Node oppositeNode(const Node &node, const Arc &arc) const {
68	68	if (node == Parent::source(arc))
69	69	return Parent::target(arc);
70	70	else if(node == Parent::target(arc))
71	71	return Parent::source(arc);
72	72	else
73	73	return INVALID;
74	74	}
75	75
...	...	@@ -346,33 +346,33 @@
346	346	int maxId(Node) const {
347	347	return Parent::maxNodeId();
348	348	}
349	349
350	350	int maxId(Arc) const {
351	351	return Parent::maxArcId();
352	352	}
353	353
354	354	int maxId(Edge) const {
355	355	return Parent::maxEdgeId();
356	356	}
357	357
358		Node fromId(int id, Node) ~~const~~ {
	358	static Node fromId(int id, Node) {
359	359	return Parent::nodeFromId(id);
360	360	}
361	361
362		Arc fromId(int id, Arc) ~~const~~ {
	362	static Arc fromId(int id, Arc) {
363	363	return Parent::arcFromId(id);
364	364	}
365	365
366		Edge fromId(int id, Edge) ~~const~~ {
	366	static Edge fromId(int id, Edge) {
367	367	return Parent::edgeFromId(id);
368	368	}
369	369
370	370	Node oppositeNode(const Node &n, const Edge &e) const {
371	371	if( n == Parent::u(e))
372	372	return Parent::v(e);
373	373	else if( n == Parent::v(e))
374	374	return Parent::u(e);
375	375	else
376	376	return INVALID;
377	377	}
378	378

...	...	@@ -858,25 +858,25 @@
858	858	void first(Node& node) const {
859	859	_graph->first(node);
860	860	}
861	861
862	862	void next(Node& node) const {
863	863	_graph->next(node);
864	864	}
865	865
866	866	void first(Arc& arc) const {
867	867	arc.id = arcs.size() - 1;
868	868	}
869	869
870		void next(Arc& arc) ~~const~~ {
	870	static void next(Arc& arc) {
871	871	--arc.id;
872	872	}
873	873
874	874	void firstOut(Arc& arc, const Node& node) const {
875	875	arc.id = (*_nodes)[node].first_out;
876	876	}
877	877
878	878	void nextOut(Arc& arc) const {
879	879	arc.id = arcs[arc.id].next_out;
880	880	}
881	881
882	882	void firstIn(Arc& arc, const Node& node) const {
...	...	@@ -1164,33 +1164,33 @@
1164	1164	void first(Node& node) const {
1165	1165	_graph->first(node);
1166	1166	}
1167	1167
1168	1168	void next(Node& node) const {
1169	1169	_graph->next(node);
1170	1170	}
1171	1171
1172	1172	void first(Arc& arc) const {
1173	1173	arc.id = arcs.size() - 1;
1174	1174	}
1175	1175
1176		void next(Arc& arc) ~~const~~ {
	1176	static void next(Arc& arc) {
1177	1177	--arc.id;
1178	1178	}
1179	1179
1180	1180	void first(Edge& arc) const {
1181	1181	arc.id = arcs.size() / 2 - 1;
1182	1182	}
1183	1183
1184		void next(Edge& arc) ~~const~~ {
	1184	static void next(Edge& arc) {
1185	1185	--arc.id;
1186	1186	}
1187	1187
1188	1188	void firstOut(Arc& arc, const Node& node) const {
1189	1189	arc.id = (*_nodes)[node].first_out;
1190	1190	}
1191	1191
1192	1192	void nextOut(Arc& arc) const {
1193	1193	arc.id = arcs[arc.id].next_out;
1194	1194	}
1195	1195
1196	1196	void firstIn(Arc& arc, const Node& node) const {

...	...	@@ -499,41 +499,41 @@
499	499	static bool direction(Arc e) {
500	500	return (e._id & 1) == 1;
501	501	}
502	502
503	503	static Arc direct(Edge e, bool d) {
504	504	return Arc(e._id * 2 + (d ? 1 : 0));
505	505	}
506	506
507	507	void first(Node& node) const {
508	508	node._id = nodes.size() - 1;
509	509	}
510	510
511		void next(Node& node) ~~const~~ {
	511	static void next(Node& node) {
512	512	--node._id;
513	513	}
514	514
515	515	void first(Arc& arc) const {
516	516	arc._id = arcs.size() - 1;
517	517	}
518	518
519		void next(Arc& arc) ~~const~~ {
	519	static void next(Arc& arc) {
520	520	--arc._id;
521	521	}
522	522
523	523	void first(Edge& arc) const {
524	524	arc._id = arcs.size() / 2 - 1;
525	525	}
526	526
527		void next(Edge& arc) ~~const~~ {
	527	static void next(Edge& arc) {
528	528	--arc._id;
529	529	}
530	530
531	531	void firstOut(Arc &arc, const Node& v) const {
532	532	arc._id = nodes[v._id].first_out;
533	533	}
534	534	void nextOut(Arc &arc) const {
535	535	arc._id = arcs[arc._id].next_out;
536	536	}
537	537
538	538	void firstIn(Arc &arc, const Node& v) const {
539	539	arc._id = ((nodes[v._id].first_out) ^ 1);

RhodeCode

Login to your account