Increase node count by using bit vector structure.

Author: highperformancecoder

models/starComplexity.cc

@@ -170,9 +170,6 @@ struct EvalStack
     auto numStars=data.pos.size();
     auto recipeSize=2*numStars-1;
 
-    // suitable up to 10 node networks
-    constexpr unsigned maxNodes=11, maxStars=2*maxNodes-1;
-    static_assert(sizeof(linkRep)*8 > (maxNodes*(maxNodes-1))/2);
     assert(nodes<=maxNodes);
     auto elemStars=&data.elemStars[0];
     auto pos=&data.pos[0];
@@ -214,7 +211,7 @@ struct EvalStack
 };
 
 // constant representing no graph at all
-constexpr linkRep noGraph=~linkRep(0);
+const linkRep noGraph=~linkRep(0);
 
 class OutputBuffer
 {
@@ -434,7 +431,7 @@ NautyRep toNautyRep(linkRep g, unsigned nodes)
   NautyRep n(nodes);
   for (unsigned i=0; i<nodes; ++i)
     for (unsigned j=0; j<i; ++j)
-      if (g&(1<<(i*(i-1)/2+j)))
+      if (g&(linkRep(1)<<(i*(i-1)/2+j)))
         n(i,j)=n(j,i)=true;
   return n;
 }

models/starComplexity.h

@@ -1,4 +1,98 @@
-using linkRep=unsigned long long;
+// hard code maximum number of nodes
+constexpr unsigned maxNodes=22, maxStars=2*maxNodes-1;
+
+//using linkRep=unsigned long long;
+
+#include "netcomplexity.h"
+
+class linkRep
+{
+public:
+  using Impl=/*long long*/ unsigned;
+private:
+  constexpr static unsigned size=maxNodes*(maxNodes-1)/(16*sizeof(Impl))+1;
+  Impl data[linkRep::size];
+  CLASSDESC_ACCESS(linkRep);
+public:
+  linkRep()=default;
+  linkRep(unsigned long long x) {
+    static_assert(sizeof(data)>=sizeof(x));
+    memcpy(data,&x,sizeof(x));
+    memset(((char*)data)+sizeof(x),0,sizeof(data)-sizeof(x));
+  }
+  const linkRep& operator|=(const linkRep& x) {
+    for (unsigned i=0; i<size; ++i) data[i]|=x.data[i];
+    return *this;
+  }
+  linkRep operator|(linkRep x) {return x|=*this;}
+  const linkRep& operator&=(const linkRep& x) {
+    for (unsigned i=0; i<size; ++i) data[i]&=x.data[i];
+    return *this;
+  }
+  linkRep operator&(linkRep x) {return x&=*this;}
+  
+  linkRep operator~() const {
+    linkRep r;
+    for (unsigned i=0; i<size; ++i) r.data[i]=~data[i];
+    return r;
+  }
+  linkRep operator<<(int n) {
+    linkRep r;
+    auto d=div(n, int(8*sizeof(Impl)));
+    for (unsigned i=0; i<size-d.quot; ++i)
+      r.data[i+d.quot]=data[i]<<d.rem;
+    return r;
+  }
+  operator const void*() const {
+    for (unsigned i=0; i<size; ++i)
+      if (data[i]) return data;
+    return nullptr;
+  }
+
+  bool operator<(const linkRep& x) const {
+    for (unsigned i=0; i<size; ++i)
+      {
+        if (data[i]<x.data[i]) return true;
+        if (data[i]>x.data[i]) return false;
+      }
+    return false;
+  }
+  std::vector<linkRep::Impl> dataAsVector() const {
+    return std::vector<Impl>(data,data+size);
+  }
+  void dataFromVector(const std::vector<linkRep::Impl>& x) {
+    memcpy(data,x.data(),std::min(size_t(size),x.size())*sizeof(linkRep::Impl));
+  }
+};
+
+// Convert to/from a JSON array for Python conversion
+#define CLASSDESC_json_pack___linkRep
+#define CLASSDESC_json_unpack___linkRep
+
+#include "json_pack_base.h"
+namespace classdesc_access
+{
+  template <> struct access_json_pack<linkRep> {
+    template <class _CD_ARG_TYPE>
+    void operator()(classdesc::json_pack_t& targ, const classdesc::string& desc,_CD_ARG_TYPE& arg)
+    {
+      std::vector<linkRep::Impl> tmp=arg.dataAsVector();
+      targ<<tmp;
+    }
+  };
+    
+  template <> struct access_json_unpack<linkRep> {
+    template <class _CD_ARG_TYPE>
+    void operator()(classdesc::json_pack_t& targ, const classdesc::string& desc,_CD_ARG_TYPE& arg)
+    {
+      std::vector<linkRep::Impl> tmp;
+      targ>>tmp;
+      arg.dataFromVector(tmp);
+    }
+  };
+}
+
+static_assert(sizeof(linkRep)*8 > (maxNodes*(maxNodes-1))/2);
 
 #include <map>
 #include <unordered_map>

models/starComplexity.py

@@ -2,7 +2,7 @@
 #print(ecolab.device())
 
 from starComplexity import starC
-nodes=11
+nodes=22
 # computed from max_{l\in[0,L]}min(n+L-l,2l) where L=n(n-1)/2
 maxStars=0
 L=int(0.5*nodes*(nodes-1))
@@ -13,9 +13,9 @@
 print('maxStars=',maxStars)
 maxStars=9
 
-#starC.blockSize(256)
+starC.blockSize(256)
 #starC.blockSize(4096)
-starC.blockSize(17920)
+#starC.blockSize(17920)
 #starC.blockSize(40320)
 
 starC.generateElementaryStars(nodes)
@@ -25,5 +25,8 @@
 print('g','links','*','C','C*','omega(g)','omega(g\')',sep=',')
 for i in starC.starMap.keys():
     c=starC.complexity(i)
-    print(i,bin(i).count('1'),starC.symmStar(i),c.complexity(),c.starComplexity(),starC.counts[i],starC.counts[starC.complement(i)],sep=',')
+    links=0
+    for j in i:
+        links+=bin(j).count('1')
+    print(links,starC.symmStar(i),c.complexity(),c.starComplexity(),starC.counts[i],starC.counts[starC.complement(i)()],sep=',')