pythonised testgraph

Author: highperformancecoder

include/graph.h

@@ -67,6 +67,20 @@ namespace ecolab
     }
   };
 
+  template <class T>
+  struct DotConversion
+  {
+    std::string dot() const {
+      std::ostringstream os;
+      os<<static_cast<const T&>(*this);
+      return os.str();
+    }
+    void importDot(const std::string& dot) {
+      std::istringstream is(dot);
+      is>>static_cast<T&>(*this);
+    }
+  };
+  
   /// To support back_insert_iterators for Graph, define a special
   /// version that converts from BoostGraph edges
   template <class Graph, class BG>
@@ -90,7 +104,7 @@ namespace ecolab
   /**
      Abstract base class for graph algorithms. 
   */
-  struct Graph
+  struct Graph: public DotConversion<Graph>
   {
     typedef Edge value_type;
     typedef std::size_t size_type;
@@ -255,15 +269,12 @@ class ConcreteGraph: public GraphAdaptor<G>
 public:
   ConcreteGraph(unsigned nodes=0): GraphAdaptor<G>(g), g(nodes) {}
   template <class H> explicit ConcreteGraph(const H& g1): GraphAdaptor<G>(g), g(g1) {}
+  template <class H> void asg(const H& g) {operator=(ConcreteGraph(g));}
   bool operator==(const ConcreteGraph& x) {return x.g==g;}
   bool operator!=(const ConcreteGraph& x) {return x.g!=g;}
 };
 
-// default is not directed
-template <class G> bool GraphAdaptor<G>::directed() const
-{return true;}
-
-class DiGraph: private std::set<Edge>
+class DiGraph: private std::set<Edge>, public DotConversion<DiGraph>
 {
   unsigned num_nodes;
   CLASSDESC_ACCESS(DiGraph);
@@ -353,7 +364,7 @@ class BiDirectionalGraph_const_iterator/*:
 
 /// A graph in which each link is bidirectional
 // base class is protected, because viewing this thing as a Graph is not correct
-class BiDirectionalGraph
+class BiDirectionalGraph: public DotConversion<BiDirectionalGraph>
 {
   DiGraph graph; ///< the representation
   CLASSDESC_ACCESS(BiDirectionalGraph);
@@ -369,10 +380,9 @@ class BiDirectionalGraph
     graph.push_back(e);
   }
   void clear(unsigned nodes=0) {graph.clear(nodes);}
-
   BiDirectionalGraph(unsigned nodes=0): graph(nodes) {}
   /// initialise Graph using Graph "duck-typed" object
-  template <class G> BiDirectionalGraph(const G& g) {asg(g);}
+  template <class G> explicit BiDirectionalGraph(const G& g) {asg(g);}
   template <class G> void asg(const G& g) {
     clear(g.nodes());
     for (typename G::const_iterator i=g.begin(); i!=g.end(); ++i) push_back(*i);
@@ -389,8 +399,20 @@ class BiDirectionalGraph
   bool operator<(const BiDirectionalGraph& x) const {return graph<x.graph;}
 };
 
-template <> inline 
-bool GraphAdaptor<BiDirectionalGraph>::directed() const {return false;}
+template <class G>
+struct Directed{ const static bool value=true;};
+
+template <>
+struct Directed<ecolab::BiDirectionalGraph>{ const static bool value=false;};
+
+template <>
+struct Directed<const ecolab::BiDirectionalGraph>{ const static bool value=false;};
+
+template <class G> bool GraphAdaptor<G>::directed() const
+{
+  return Directed<G>::value;
+}
+
 
 // uses the sign of the off-diagonal term to indicate link
 // direction. Links point in the same direction have their weights
@@ -518,11 +540,14 @@ namespace classdesc_access
 
 namespace std
 {
-  /// for use with TCL_obj. Graphviz format is used with the netgraph command.
+  /// Graphviz format is used with the netgraph command.
   std::ostream& operator<<(std::ostream& s, const ecolab::Graph& x);
   template <class G>
   std::ostream& operator<<(std::ostream& s, const ecolab::ConcreteGraph<G>& x)
   {return s<<static_cast<const ecolab::Graph&>(x);}
+  template <class G>
+  std::ostream& operator<<(std::ostream& s, const ecolab::GraphAdaptor<G>& x)
+  {return s<<static_cast<const ecolab::Graph&>(x);}
 
   inline std::ostream& operator<<(std::ostream& s, const ecolab::DiGraph& x)
   {return s<<ecolab::GraphAdaptor<const ecolab::DiGraph>(x);}
@@ -537,18 +562,25 @@ namespace std
 
   inline std::istream& operator>>(std::istream& s, ecolab::DiGraph& x)
   {ecolab::GraphAdaptor<ecolab::DiGraph> g(x); return s>>g;}
+
   inline std::istream& operator>>(std::istream& s, ecolab::BiDirectionalGraph& x)
-  {ecolab::GraphAdaptor<ecolab::BiDirectionalGraph> g(x); return s>>g;}
+  {ecolab::GraphAdaptor<ecolab::BiDirectionalGraph> g(x); std::cout<<g.directed()<<std::endl; return s>>g;}
 }
 
 #if defined(__GNUC__) && !defined(__ICC) && !defined(__clang__)
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wunused-local-typedefs"
 #endif
 
+// override json_pack with above GraphViz serialiser
+//#define CLASSDESC_json_pack___ecolab__GraphAdaptor_G_
+//#define CLASSDESC_json_unpack___ecolab__GraphAdaptor_G_
+//#define CLASSDESC_json_pack___ecolab__DiGraph
+//#define CLASSDESC_json_unpack___ecolab__BiDirectionalGraph
 #include "graph.cd"
 
 #if defined(__GNUC__) && !defined(__ICC) && !defined(__clang__)
 #pragma GCC diagnostic pop
 #endif
 #endif
+

src/ecolab.cc

@@ -16,6 +16,7 @@
 #include "pythonBuffer.h"
 #include "ecolab.h"
 #include "random.h"
+#include "graph.h"
 #ifdef MPI_SUPPORT
 #include "graphcode.h"
 #endif
@@ -241,6 +242,10 @@ namespace ecolab
 #ifdef UNURAN
     CLASSDESC_DECLARE_TYPE(unuran);
 #endif
+    using DiGraph=ConcreteGraph<ecolab::DiGraph>;
+    using BiDirectionalGraph=ConcreteGraph<ecolab::BiDirectionalGraph>;
+    CLASSDESC_DECLARE_TYPE(DiGraph);
+    CLASSDESC_DECLARE_TYPE(BiDirectionalGraph);
   }
 
   // device SYCL kernels are running on

src/graph.cc

@@ -275,19 +275,12 @@ namespace ecolab
       else if (buf=="digraph {") 
         parse_graphviz(s,x,false);
       else
-        {
-//          if (TCL_obj_properties().count(buf)==0)      
-//            throw error("%s does not exist!",buf.c_str());
-//          if (Graph* g=TCL_obj_properties()[buf]->memberPtrCasted<Graph>())
-//            x=*g;
-//          else
-            throw error("unable to assign variable %s, which is not a Graph, "
+        throw error("unable to assign variable %s, which is not a Graph, "
                         "to object of type %s", buf.c_str(), typeid(G).name());
-        }
       return s;
     }
   }
-                            
+
   void ErdosRenyi_generate(Graph& g, unsigned nodes, unsigned links, 
                            urand& uni, random_gen& weight_dist)
   {

test/00/t0025a.sh

@@ -5,41 +5,8 @@
 #
 #  Open source licensed under the MIT license. See LICENSE for details.
 
-
 here=`pwd`
-if test $? -ne 0; then exit 2; fi
-tmp=/tmp/$$
-mkdir $tmp
-if test $? -ne 0; then exit 2; fi
-cd $tmp
-if test $? -ne 0; then exit 2; fi
-
-fail()
-{
-    echo "FAILED" 1>&2
-    cd $here
-    chmod -R u+w $tmp
-    rm -rf $tmp
-    exit 1
-}
-
-pass()
-{
-    echo "PASSED" 1>&2
-    cd $here
-    chmod -R u+w $tmp
-    rm -rf $tmp
-    exit 0
-}
-
-trap "fail" 1 2 3 15
-export LD_LIBRARY_PATH=/usr/local/lib:$LD_LIBRARY_PATH
-
-# insert ecolab script code here
-# use \$ in place of $ to refer to variable contents
-# exit 0 to indicate pass, and exit 1 to indicate failure
-cat >input.tcl <<EOF
-EOF
+. $here/test/common-test.sh
 
 $here/test/testCheckpointableFile
 if test $? -ne 0; then fail; fi

test/00/t0026a.sh

@@ -0,0 +1,14 @@
+#! /bin/sh
+#  @copyright Russell Standish 2000-2013
+#  @author Russell Standish
+#  This file is part of Classdesc
+#
+#  Open source licensed under the MIT license. See LICENSE for details.
+
+here=`pwd`
+. $here/test/common-test.sh
+
+python3 $here/test/testgraph.py
+if test $? -ne 0; then fail; fi
+
+pass

test/00/testgraph.sh

@@ -20,7 +20,7 @@ endif
 GDBM+=-lgdbm
 
 #MODELS=testrefassign testref testgraph test_boostgraph testCacheDBM testCairo accessor vector-pair
-MODELS=testParallel testCacheDBM 
+MODELS=testParallel testCacheDBM testgraph
 # vector-pair - doesn't currently compile - see ticket #161
 #EXTRAMODELS=test_tcl_stl.exe tcl-arrays.exe complex_tcl_args.exe
 #EXES=test_omp_rw_lock testCheckpointableFile test_netcomplexity test_boostgraph test_ecostrstream posTest testarrays pangoTest testParallel

test/Makefile

@@ -16,5 +16,9 @@
 using namespace ecolab;
 
 Testgraph tg;
-make_model(tg);
+CLASSDESC_ADD_GLOBAL(tg);
+using DiGraph1=DiGraph;
+CLASSDESC_DECLARE_TYPE(DiGraph1);
+CLASSDESC_PYTHON_MODULE(testgraph);
+
 

test/testgraph.cc

@@ -13,19 +13,18 @@ struct Testgraph
 {
   ConcreteGraph<DiGraph> g;
   ConcreteGraph<BiDirectionalGraph> dg;
-  void first(TCL_args args) { ///< create a graph with n nodes and l links
-    unsigned n=args, l=args;
-    g=BitRep(n,l); dg=BiDirectionalBitRep(n,l);}
-  void next(TCL_args) { ///< create a graph with n nodes and l links
-    BitRep b(g); b.next_perm(); g=b;
-    BiDirectionalBitRep db(dg); db.next_perm(); dg=db;
+  void first(unsigned n, unsigned l) { ///< create a graph with n nodes and l links
+    g.asg(BitRep(n,l)); dg.asg(BiDirectionalBitRep(n,l));}
+  void next() { ///< create a graph with n nodes and l links
+    BitRep b(g); b.next_perm(); g.asg(b);
+    BiDirectionalBitRep db(dg); db.next_perm(); dg.asg(db);
   }
   array<unsigned> degrees() {
     Degrees d=::degrees(g);
     return array<unsigned>(d.in_degree+d.out_degree);
   }
   urand uni;
-  void randGraph(TCL_args args) {ErdosRenyi_generate(g,args[0],args[1],uni,uni);
+  void randGraph(unsigned nodes, unsigned links) {ErdosRenyi_generate(g,nodes,links,uni,uni);
   }
-  void prefAttach(TCL_args args) {PreferentialAttach_generate(g,args,uni);}
+  void prefAttach(unsigned nodes) {PreferentialAttach_generate(g,nodes,uni);}
 };

test/testgraph.h

@@ -0,0 +1,68 @@
+#!python3
+#  @copyright Russell Standish 2000-2013
+#  @author Russell Standish
+#  This file is part of Classdesc
+#
+#  Open source licensed under the MIT license. See LICENSE for details.
+
+from testgraph import tg
+from ecolab import DiGraph, BiDirectionalGraph
+
+tg.first(4, 4)
+assert tg.g.dot() == "digraph {\n0->1;\n0->2;\n0->3;\n1->0;\n}\n"
+assert tg.dg.dot()== "graph {\n0--1;\n0--2;\n0--3;\n1--2;\n}\n"
+
+# test assignment
+ng=DiGraph()
+ng.importDot(tg.g.dot())
+assert tg.g.dot()==ng.dot(), "dot asg"
+
+ndg=BiDirectionalGraph()
+ndg.importDot(tg.dg.dot())
+assert tg.dg.dot()==ndg.dot(), "bidi dot asg"
+
+ng=DiGraph()
+ndg=BiDirectionalGraph()
+ng.importDot(tg.dg.dot())
+ndg.importDot(tg.dg.dot())
+assert ndg.dot()==tg.dg.dot(), "inbuilt tmp asg"
+
+tg.g.output("pajek","g.net")
+tg.g.output("lgl","g.lgl")
+tg.dg.output("pajek","dg.net")
+tg.dg.output("lgl","dg.lgl")
+
+ng=DiGraph()
+ng.input("pajek","g.net")
+assert ng.dot()==tg.g.dot(), "pajek input"
+
+# LGL loses directionality, so we must symmetrise g
+ng=DiGraph()
+ng2=DiGraph()
+ndg=BiDirectionalGraph()
+ng.input("lgl", "g.lgl")
+# symmetrise g
+ndg.importDot(tg.g.dot())
+ng2.importDot(ndg.dot())
+assert ng.dot()==ng2.dot(), "lgl input"
+
+ng=BiDirectionalGraph()
+ng.input("pajek","dg.net")
+assert ng.dot()==tg.dg.dot(), "pajek bidi inpout"
+
+ng=BiDirectionalGraph()
+ng.input("lgl","dg.lgl")
+assert ng.dot()==tg.dg.dot(), "lgl bidi input"
+
+# by generating a fully connected graph, we ensure that node
+# relabelling in the LGL routines is uniquely determined.
+tg.randGraph(4, 12)
+tg.dg(tg.g())
+ng=BiDirectionalGraph()
+for fmt in ["pajek", "lgl", "dot"]:
+    tg.dg.output(fmt,"g.net")
+    ng.clear()
+    ng.input(fmt, "g.net")
+    assert tg.dg.dot()==ng.dot(), fmt
+
+