Add some groups, upgrade parameter handling, implement ezmults

main.cpp

@@ -156,7 +156,7 @@ struct Mult {
 Table mults(std::vector<Mult> ms) {
     Table res;
     for (const auto &m : ms) {
-	int N = res.size();
+	     int N = res.size();
         res.emplace_back(m.multiplicity * 2, m.to);
         for (int i = 0; i < m.multiplicity * 2; i += 2) {
             res[N][i] = m.from;
@@ -165,28 +165,93 @@ Table mults(std::vector<Mult> ms) {
     return res;
 }
 
-Table torus(int res) {
+Table ezmults(int ngens, std::vector<Mult> ms) {
-    return mults({
+   bool table[ngens][ngens];
-        {0, 1, res},
+
-        {1, 2, 2},
+   for (int i=0; i<ngens; i++) {
-        {2, 3, res},
+      for (int j=0; j<ngens; j++) {
-        {0, 2, 2},
+         table[i][j] = false;
-        {0, 3, 2},
+      }
-        {1, 3, 2},
+   }
-    });
+
+   for (const auto &m : ms) {
+      table[m.from][m.to] = true;
+      table[m.to][m.from] = true;
+   }
+
+   Table res = mults(ms);
+   for (int i=0; i<ngens; i++) {
+      for (int j=i+1; j<ngens; j++) {
+         if (!table[i][j]) {
+            res.push_back({i,j,i,j});
+         }
+      }
+   }
+   return res;
 }
 
 /*
- * duododeca
+ * Order 4*res*res
- * mults({
- *      {0, 1, 5},
- *      {1, 2, 3},
- *      {2, 3, 3},
- *      {0, 2, 2},
- *      {0, 3, 2},
- *      {1, 3, 2},
- *  })
  */
+std::pair<Table,int> torus(int res) {
+    return std::make_pair(ezmults(4,{
+        {0,1,res},
+        {2,3,res},
+    }),4);
+}
+
+/*
+ * Order 14,400
+ */
+std::pair<Table,int> H4() {
+   return std::make_pair(ezmults(4,{
+      {0,1,5},
+      {1,2,3},
+      {2,3,3},
+   }),4);
+}
+
+/*
+ * Order 51,840
+ */
+std::pair<Table,int> E6() {
+   return std::make_pair(ezmults(6,{
+      {0,1,3},
+      {1,2,3},
+      {2,3,3},
+      {2,4,3},
+      {4,5,3},
+   }),6);
+}
+
+/*
+ * Order 2,903,040
+ */
+std::pair<Table,int> E7() {
+   return std::make_pair(ezmults(7,{
+      {0,1,3},
+      {1,2,3},
+      {2,3,3},
+      {2,4,3},
+      {4,5,3},
+      {5,6,3},
+   }),7);
+}
+
+/*
+ * Order 696,729,600
+ */
+std::pair<Table,int> E8() {
+   return std::make_pair(ezmults(8,{
+      {0,1,3},
+      {1,2,3},
+      {2,3,3},
+      {2,4,3},
+      {4,5,3},
+      {5,6,3},
+      {6,7,3},
+   }),8);
+}
 
 int main(int argc, char *argv[]) {
     if (argc < 2) {
@@ -195,18 +260,47 @@ int main(int argc, char *argv[]) {
         return 1;
     }
 
-    int N = std::strtol(argv[1], nullptr, 10);
+    int type = std::strtol(argv[1], nullptr, 10);
+    int arg = 0;
+    std::pair<Table,int> res;
+    switch (type) {
+      case 0:
+         if (argc < 3) {
+            std::cerr << "Must provide a size for torus!" << std::endl;
+            return 2;
+         }
+         arg = std::strtol(argv[2], nullptr, 10);
+         res = torus(arg);
+         break;
+      case 1:
+         res = H4();
+         break;
+      case 2:
+         res = E6();
+         break;
+      case 3:
+         res = E7();
+         break;
+      case 4:
+         res = E8();
+         break;
+      default:
+         std::cerr << "Not a valid type!" << std::endl;
+         return 3;
+    }
 
-    const Table &rels = torus(N);
+    const Table &rels = res.first;
+    const int ngens = res.second;
 
     auto s = std::chrono::system_clock::now();
-    auto cosets = solve_tc(4, {}, rels);
+    auto cosets = solve_tc(ngens, {}, rels);
     auto e = std::chrono::system_clock::now();
 
     std::chrono::duration<float> diff = e - s;
     size_t order = cosets.size();
 
-    std::cout << N << "," << diff.count() << "," << order << std::endl;
+    // ngens,type,arg,time,order
+    std::cout << ngens << ',' << type << ',' << arg  << ',' << diff.count() << ',' << order << std::endl;
 
     return 0;
 }