remove SimplexesList, simplify tile

vis/include/geometry.hpp

@@ -3,6 +3,7 @@
 #include <tc/core.hpp>
 #include <cmath>
 #include <optional>
+#include <numeric>
 #include <iostream>
 #include "combo_iterator.hpp"
 
@@ -25,75 +26,43 @@ size_t num_gens_from_key(size_t key) {
     return count;
 }
 
-struct SimplexesList;
-
 struct Simplexes {
     int dim;
     std::vector<int> vals;
 
-    explicit Simplexes(int dim): dim(dim) {}
+    Simplexes() : dim(0), vals() {}
+
+    explicit Simplexes(int dim) : dim(dim), vals() {}
+
     Simplexes(int dim, std::vector<int> &vals) : dim(dim), vals(vals) {}
-    explicit Simplexes(SimplexesList &sl);
+
+    explicit Simplexes(const std::vector<Simplexes> &parts) {
+        dim = parts[0].dim;
+
+        size_t count = 0;
+        for (const auto &part : parts) {
+            count += part.size();
+        }
+        vals.reserve(count);
+
+        for (const auto &part : parts) {
+            vals.insert(vals.end(), part.vals.begin(), part.vals.end());
+        }
+    }
 
     [[nodiscard]] size_t size() const {
         return vals.size();
     }
 
-    void reorient() {
+    void flip() {
         if (dim == 0)
             return;
         for (int i = 0; i < vals.size(); i += dim + 1) {
             std::swap(vals[i], vals[i + 1]);
         }
     }
-
-    void print() {
-        if (vals.empty()) {
-            std::cout << "[]" << std::endl;
-        }
-        std::cout << "[(" << vals[0];
-        for (int i = 1; i < dim+1; i++) {
-            std::cout << "," << vals[i];
-        }
-        std::cout << ")";
-        for (int i = dim+1; i < vals.size(); i+= dim+1) {
-            std::cout << ", (" << vals[i];
-            for (int j = i+1; j < i+dim+1; j++) {
-                std::cout << "," << vals[j];
-            }
-            std::cout << ")";
-        }
-        std::cout << "]";
-    }
 };
 
-struct SimplexesList {
-    int dim;
-    std::vector<int> vals;
-    int elem_size;
-    Simplexes temp;
-
-    explicit SimplexesList(Simplexes &s) : dim(s.dim), elem_size(s.size()), temp(s.dim) {
-        temp.vals.reserve(s.size());
-    }
-
-    void reserve(size_t i) {
-        vals.reserve(elem_size * i);
-    }
-
-    Simplexes& get(size_t i) {
-        temp.vals.clear();
-        temp.vals.insert(temp.vals.end(), vals.begin()+elem_size*i, vals.begin()+elem_size*(i+1));
-        return temp;
-    }
-
-    void push_back(Simplexes s) {
-        vals.insert(vals.end(), s.vals.begin(), s.vals.end());
-    }
-};
-
-Simplexes::Simplexes(SimplexesList &sl): Simplexes(sl.dim, sl.vals) {}
-
 struct GeomGen {
     std::vector<std::vector<std::optional<tc::Cosets>>> coset_memo;
     std::vector<std::optional<Simplexes>> triangulate_memo;
@@ -194,7 +163,7 @@ struct GeomGen {
             ret.vals.push_back(map[val]);
         }
         if (get_parity(g_gens, sg_gens) == 1)
-            ret.reorient();
+            ret.flip();
         return ret;
     }
 
@@ -204,22 +173,17 @@ struct GeomGen {
         auto table = solve_g(g_gens);
         auto path = _solve(g_gens, sg_gens).path;
 
-        auto simplex_map = [table](const Simplexes& items, int gen) -> Simplexes {
+        auto simplex_map = [table](Simplexes from, int gen) -> Simplexes {
-            Simplexes ret(items.dim);
+            for (auto &coset : from.vals) {
-            ret.vals.reserve(items.vals.size());
+                coset = table.get(coset, gen);
-            // Move the simplexes
-            for (const auto coset : items.vals) {
-                ret.vals.push_back(table.get(coset,gen));
             }
-            // Reorient the simplexes
+            from.flip();
-            ret.reorient();
+            return from;
-            return ret;
         };
 
-        SimplexesList ret(base);
+        auto r = path.walk<Simplexes, int>(base, group_gens(), simplex_map);
-        path.walk<SimplexesList, Simplexes, int>(ret, base, group_gens(), simplex_map);
 
-        return Simplexes(ret);
+        return Simplexes(r);
     }
 
     Simplexes triangulate(std::vector<int> &g_gens);