generics don't crash, but don't work either

vis/include/geometry.hpp

@@ -26,63 +26,44 @@ size_t num_gens_from_key(size_t key) {
     return count;
 }
 
-struct Mesh {
+template<unsigned N>
-//    int dim;
+struct Primitive {
-    std::vector<int> vals;
+    std::array<unsigned, N> inds;
 
-    Mesh() : vals() {}
+    Primitive() = default;
 
-    explicit Mesh(std::vector<int> &vals) : vals(vals) {}
+    Primitive(const Primitive<N> &) = default;
 
-    explicit Mesh(const std::vector<Mesh> &parts) {
+    Primitive(const Primitive<N - 1> &sub, unsigned root) {
-        size_t count = 0;
+        std::copy(sub.inds.begin(), sub.inds.end(), inds.begin());
-        for (const auto &part : parts) {
+        inds[N - 1] = root;
-            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 {
+    ~Primitive() = default;
-        return vals.size();
+
+    inline void flip() {
+        if (N > 1) std::swap(inds[0], inds[1]);
     }
 
-    void flip() {
+    void apply(const tc::Cosets &table, int gen) {
-//        if (dim == 0)
+        for (auto &ind : inds) {
-//            return;
+            ind = table.get(ind, gen);
-//        for (int i = 0; i < vals.size(); i += dim + 1) {
+        }
-//            std::swap(vals[i], vals[i + 1]);
+        flip();
-//        }
     }
 };
 
-struct GeomGen {
+std::vector<int> gens(const tc::Group &context) {
-    std::vector<std::vector<std::optional<tc::Cosets>>> coset_memo;
+    std::vector<int> g_gens(context.ngens);
-    std::vector<std::optional<Mesh>> triangulate_memo;
+    std::iota(g_gens.begin(), g_gens.end(), 0);
-    tc::Group &context;
+    return g_gens;
+}
 
-    explicit GeomGen(tc::Group &g) : context(g) {
+std::vector<int> recontext_gens(
-        size_t num_sg = std::pow(2, g.ngens);
+    const tc::Group &context,
-        coset_memo.resize(num_sg);
+    std::vector<int> g_gens,
-        triangulate_memo.resize(num_sg);
+    std::vector<int> sg_gens) {
-        for (size_t i = 0; i < num_sg; i++) {
-            auto num_sg_sg = std::pow(2, num_gens_from_key(i));
-            coset_memo[i].resize(num_sg_sg, std::nullopt);
-        }
-    }
 
-    std::vector<int> group_gens() {
-        std::vector<int> gens(context.ngens);
-        for (int i = 0; i < context.ngens; i++) {
-            gens[i] = i;
-        }
-        return gens;
-    }
-
-    std::vector<int> prepare_gens(std::vector<int> &g_gens, std::vector<int> &sg_gens) {
     std::sort(g_gens.begin(), g_gens.end());
 
     int inv_gen_map[context.ngens];
@@ -98,118 +79,375 @@ struct GeomGen {
     std::sort(s_sg_gens.begin(), s_sg_gens.end());
 
     return s_sg_gens;
+
+//    std::sort(g_gens.begin(), g_gens.end());
+//
+//    std::vector<int> inv_g_map(g_gens.size());
+//    for (int i = 0; i < g_gens.size(); ++i) {
+//        inv_g_map[g_gens[i]] = i;
+//    }
+//
+//    std::transform(sg_gens.begin(), sg_gens.end(), sg_gens.begin(),
+//        [inv_g_map](const auto &gen) {
+//            return inv_g_map[gen];
+//        }
+//    );
+//
+//    std::sort(sg_gens.begin(), sg_gens.end());
+//    return sg_gens;
+}
+
+int get_parity(
+    const tc::Group &context,
+    const std::vector<int> &g_gens,
+    const std::vector<int> &sg_gens
+) {
+    if (g_gens.size() != sg_gens.size() + 1) return 0;
+
+    const auto proper_sg_gens = recontext_gens(context, g_gens, sg_gens);
+
+    int i = 0;
+    for (; i < sg_gens.size(); ++i) {
+        if (proper_sg_gens[i] != i) {
+            break;
+        }
     }
 
-    int get_parity(std::vector<int> &g_gens, std::vector<int> &sg_gens) {
+    return i & 1;
-        if (g_gens.size() != sg_gens.size() + 1)
+}
-            return 0;
-        auto s_sg_gens = prepare_gens(g_gens, sg_gens);
-        const int loop_max = g_gens.size() - 1;
-        for (int i = 0; i < loop_max; i++) {
-            if (s_sg_gens[i] != i)
-                return i % 2;
-        }
-        return loop_max % 2;
-    }
 
-    tc::Cosets _solve(std::vector<int> &g_gens, std::vector<int> &sg_gens) {
+tc::Cosets solve(
-        auto s_sg_gens = prepare_gens(g_gens, sg_gens);
+    const tc::Group &context,
+    const std::vector<int> &g_gens,
+    const std::vector<int> &sg_gens
+) {
+    const auto proper_sg_gens = recontext_gens(context, g_gens, sg_gens);
+    return context.subgroup(g_gens).solve(proper_sg_gens);
+}
 
-        size_t group_key = get_key_from_gens(g_gens);
+tc::Cosets solve_sg(
-        size_t subgroup_key = get_key_from_gens(s_sg_gens);
+    const tc::Group &context,
+    const std::vector<int> &sg_gens
+) {
+    return solve(context, gens(context), sg_gens);
+}
 
-        if (!coset_memo[group_key][subgroup_key]) {
+tc::Cosets solve_g(
-            tc::SubGroup g = context.subgroup(g_gens);
+    const tc::Group &context,
-            coset_memo[group_key][subgroup_key] = g.solve(s_sg_gens);
+    const std::vector<int> &g_gens
-        }
+) {
-        return *coset_memo[group_key][subgroup_key];
-    }
-
-    tc::Cosets solve(std::vector<int> g_gens, std::vector<int> sg_gens) {
-        return _solve(g_gens, sg_gens);
-    }
-
-    tc::Cosets solve_sg(std::vector<int> &sg_gens) {
-        auto g_gens = group_gens();
-        return _solve(g_gens, sg_gens);
-    }
-
-    tc::Cosets solve_g(std::vector<int> &g_gens) {
     std::vector<int> sg_gens;
-        return _solve(g_gens, sg_gens);
+    return solve(context, g_gens, sg_gens);
-    }
+}
 
-    tc::Cosets solve() {
+tc::Cosets solve(
+    const tc::Group &context
+) {
     std::vector<int> sg_gens;
-        return solve_sg(sg_gens);
+    return solve_sg(context, sg_gens);
+}
+
+template<unsigned N>
+struct Mesh {
+    std::vector<Primitive<N>> prims;
+
+    Mesh() : prims() {}
+
+    Mesh(const Mesh<N> &) = default;
+
+    explicit Mesh(std::vector<Primitive<N>> &prims) : prims(prims) {}
+
+    [[nodiscard]] size_t size() const {
+        return prims.size();
     }
 
-    Mesh recontext(std::vector<int> &g_gens, std::vector<int> &sg_gens, const Mesh &items) {
+    void apply(const tc::Cosets &table, int gen) {
-        auto s_sg_gens = prepare_gens(g_gens, sg_gens);
+        for (auto &prim : prims) {
-        auto table = solve_g(g_gens);
+            prim.apply(table, gen);
-        auto path = solve_g(sg_gens).path;
-
-        auto coset_map = [table](int coset, int gen) { return table.get(coset, gen); };
-
-        auto map = path.walk<int, int>(0, s_sg_gens, coset_map);
-
-        Mesh ret;
-        ret.vals.reserve(items.size());
-        for (const auto val : items.vals) {
-            ret.vals.push_back(map[val]);
         }
-        if (get_parity(g_gens, sg_gens) == 1)
-            ret.flip();
-        return ret;
     }
 
-    Mesh tile(std::vector<int> &g_gens, std::vector<int> &sg_gens, const Mesh &items) {
+    void flip() {
-        Mesh base = recontext(g_gens, sg_gens, items);
+        for (auto &prim : prims) {
-        auto s_sg_gens = prepare_gens(g_gens, sg_gens);
+            prim.flip();
-        auto table = solve_g(g_gens);
-        auto path = _solve(g_gens, sg_gens).path;
-
-        auto simplex_map = [table](Mesh from, int gen) -> Mesh {
-            for (auto &coset : from.vals) {
-                coset = table.get(coset, gen);
         }
-            from.flip();
+    }
+
+    Mesh<N> recontext(
+        const tc::Group &context,
+        const std::vector<int> &g_gens,
+        const std::vector<int> &sg_gens
+    ) {
+        const auto proper_sg_gens = recontext_gens(context, g_gens, sg_gens);
+        // todo memo recontext
+        const auto table = solve_g(context, g_gens);
+        const auto path = solve_g(context, sg_gens).path;
+
+        auto map = path.template walk<int, int>(0, proper_sg_gens, [table](int coset, int gen) {
+            return table.get(coset, gen);
+        });
+
+        Mesh<N> res = *this;
+        for (Primitive<N> &prim : res.prims) {
+            for (auto &ind : prim.inds) {
+                ind = map[ind];
+            }
+        }
+
+        if (get_parity(context, g_gens, sg_gens) == 1)
+            res.flip();
+
+        return res;
+    }
+
+    Mesh<N> tile(
+        const tc::Group &context,
+        const std::vector<int> &g_gens,
+        const std::vector<int> &sg_gens
+    ) {
+        Mesh<N> base = recontext(context, g_gens, sg_gens);
+        const auto proper_sg_gens = recontext_gens(context, g_gens, sg_gens);
+
+        // todo memo tile
+        const auto table = solve_g(context, g_gens);
+        const auto path = solve(context, g_gens, sg_gens).path;
+
+        const auto all = path.template walk<Mesh<N>, int>(base, g_gens, [table](Mesh<N> from, int gen) {
+            from.apply(table, gen);
             return from;
-        };
+        });
 
-        auto r = path.walk<Mesh, int>(base, group_gens(), simplex_map);
+        return merge(all);
-
-        return Mesh(r);
     }
 
-    Mesh triangulate(std::vector<int> &g_gens);
+    Mesh<N + 1> fan(int root) {
-
+        std::vector<Primitive<N + 1>> res(prims.size());
-    Mesh _triangulate(std::vector<int> &g_gens) {
+        std::transform(prims.begin(), prims.end(), res.begin(),
-        Mesh S;
+            [root](const Primitive<N> &prim) {
-        if (g_gens.empty()) {
+                return Primitive<N + 1>(prim, root);
-            S.vals.push_back(0);
-            return S;
             }
-        for (std::vector<int> sg_gens : Combos(g_gens, g_gens.size() - 1)) {
+        );
-            auto sub_simps = triangulate(sg_gens);
+        return Mesh<N + 1>(res);
-            int start = sub_simps.size();
-            sub_simps = tile(g_gens, sg_gens, sub_simps);
-            for (int l = start; l < sub_simps.size(); l += g_gens.size()) {
-                for (int m = l; m < l + g_gens.size(); m++) {
-                    S.vals.push_back(sub_simps.vals[m]);
     }
-                S.vals.push_back(0);
-            }
-        }
-        return S;
-    }
-
 };
 
-Mesh GeomGen::triangulate(std::vector<int> &g_gens) {
+template<unsigned N>
-    int key = get_key_from_gens(g_gens);
+Mesh<N> merge(const std::vector<Mesh<N>> &meshes) {
-    if (!triangulate_memo[key]) {
+    size_t size = 0;
-        triangulate_memo[key] = _triangulate(g_gens);
+    for (const auto &mesh : meshes) {
+        size += mesh.size();
     }
-    return *triangulate_memo[key];
+
+    std::vector<Primitive<N>> prims;
+    prims.reserve(size);
+    for (const auto &mesh : meshes) {
+        prims.insert(prims.end(), mesh.prims.begin(), mesh.prims.end());
+    }
+
+    return Mesh(prims);
 }
+
+template<unsigned N>
+Mesh<N> triangulate(
+    const tc::Group &context,
+    const std::vector<int> &g_gens
+) {
+    if (g_gens.size() + 1 != N)
+        throw std::logic_error("g_gens size must be one less than N");
+
+    const auto &combos = Combos(g_gens, g_gens.size() - 1);
+
+    std::vector<Mesh<N>> meshes;
+    for (const auto &sg_gens : combos) {
+        Mesh<N - 1> base = triangulate<N - 1>(context, sg_gens);
+        Mesh<N - 1> raised = base.tile(context, g_gens, sg_gens);
+        raised.prims.erase(raised.prims.begin(), raised.prims.begin() + base.size());
+        Mesh<N> fan = raised.fan(0);
+        meshes.push_back(fan);
+    }
+
+    return merge(meshes);
+}
+
+template<>
+Mesh<1> triangulate<1>(
+    const tc::Group &context,
+    const std::vector<int> &g_gens
+) {
+    if (not g_gens.empty())
+        throw std::logic_error("g_gens must be empty for a trivial Mesh");
+
+    Mesh<1> res;
+    res.prims.emplace_back();
+    return res;
+}
+
+//template<unsigned N>
+//struct GeomGen {
+//    std::vector<std::vector<std::optional<tc::Cosets>>> coset_memo;
+//    std::vector<std::optional<Mesh<N>>> triangulate_memo;
+//    tc::Group &context;
+//
+//    explicit GeomGen(tc::Group &g) : context(g) {
+//        size_t num_sg = std::pow(2, g.ngens);
+//        coset_memo.resize(num_sg);
+//        triangulate_memo.resize(num_sg);
+//        for (size_t i = 0; i < num_sg; i++) {
+//            auto num_sg_sg = std::pow(2, num_gens_from_key(i));
+//            coset_memo[i].resize(num_sg_sg, std::nullopt);
+//        }
+//    }
+//
+//    std::vector<int> group_gens() {
+//        std::vector<int> gens(context.ngens);
+//        for (int i = 0; i < context.ngens; i++) {
+//            gens[i] = i;
+//        }
+//        return gens;
+//    }
+//
+//    std::vector<int> prepare_gens(std::vector<int> &g_gens, std::vector<int> &sg_gens) {
+//        std::sort(g_gens.begin(), g_gens.end());
+//
+//        int inv_gen_map[context.ngens];
+//        for (size_t i = 0; i < g_gens.size(); i++) {
+//            inv_gen_map[g_gens[i]] = i;
+//        }
+//
+//        std::vector<int> s_sg_gens;
+//        s_sg_gens.reserve(sg_gens.size());
+//        for (const auto gen : sg_gens) {
+//            s_sg_gens.push_back(inv_gen_map[gen]);
+//        }
+//        std::sort(s_sg_gens.begin(), s_sg_gens.end());
+//
+//        return s_sg_gens;
+//    }
+//
+//    int get_parity(std::vector<int> &g_gens, std::vector<int> &sg_gens) {
+//        if (g_gens.size() != sg_gens.size() + 1)
+//            return 0;
+//        auto s_sg_gens = prepare_gens(g_gens, sg_gens);
+//        const int loop_max = g_gens.size() - 1;
+//        for (int i = 0; i < loop_max; i++) {
+//            if (s_sg_gens[i] != i)
+//                return i % 2;
+//        }
+//        return loop_max % 2;
+//    }
+//
+//    tc::Cosets _solve(std::vector<int> &g_gens, std::vector<int> &sg_gens) {
+//        auto s_sg_gens = prepare_gens(g_gens, sg_gens);
+//
+//        size_t group_key = get_key_from_gens(g_gens);
+//        size_t subgroup_key = get_key_from_gens(s_sg_gens);
+//
+//        if (!coset_memo[group_key][subgroup_key]) {
+//            tc::SubGroup g = context.subgroup(g_gens);
+//            coset_memo[group_key][subgroup_key] = g.solve(s_sg_gens);
+//        }
+//        return *coset_memo[group_key][subgroup_key];
+//    }
+//
+//    tc::Cosets solve(std::vector<int> g_gens, std::vector<int> sg_gens) {
+//        return _solve(g_gens, sg_gens);
+//    }
+//
+//    tc::Cosets solve_sg(std::vector<int> &sg_gens) {
+//        auto g_gens = group_gens();
+//        return _solve(g_gens, sg_gens);
+//    }
+//
+//    tc::Cosets solve_g(std::vector<int> &g_gens) {
+//        std::vector<int> sg_gens;
+//        return _solve(g_gens, sg_gens);
+//    }
+//
+//    tc::Cosets solve() {
+//        std::vector<int> sg_gens;
+//        return solve_sg(sg_gens);
+//    }
+//
+//    Mesh<N> recontext(std::vector<int> &g_gens, std::vector<int> &sg_gens, const Mesh<N> &items) {
+//        auto s_sg_gens = prepare_gens(g_gens, sg_gens);
+//        auto table = solve_g(g_gens);
+//        auto path = solve_g(sg_gens).path;
+//
+//        auto coset_map = [table](int coset, int gen) { return table.get(coset, gen); };
+//
+//        auto map = path.template walk<int, int>(0, s_sg_gens, coset_map);
+//
+//        Mesh<N> ret;
+//        ret.vals.reserve(items.size());
+//        for (const auto val : items.vals) {
+//            ret.vals.push_back(map[val]);
+//        }
+//        if (get_parity(g_gens, sg_gens) == 1)
+//            ret.flip();
+//        return ret;
+//    }
+//
+//    Mesh<N> tile(std::vector<int> &g_gens, std::vector<int> &sg_gens, const Mesh<N> &items) {
+//        Mesh<N> base = recontext(g_gens, sg_gens, items);
+//        auto s_sg_gens = prepare_gens(g_gens, sg_gens);
+//        auto table = solve_g(g_gens);
+//        auto path = _solve(g_gens, sg_gens).path;
+//
+//        auto simplex_map = [table](Mesh<N> from, int gen) -> Mesh<N> {
+//            for (auto &prim : from.prims) {
+//                prim.apply(table, gen);
+//            }
+//            from.flip();
+//            return from;
+//        };
+//
+//        auto r = path.template walk<Mesh<N>, int>(base, group_gens(), simplex_map);
+//
+//        return merge(r);
+//    }
+//
+//    Mesh<N> triangulate(std::vector<int> &g_gens);
+//
+//    Mesh<1> _triangulate(std::vector<int> &g_gens) {
+//        Mesh<1> m;
+//        m.prims.emplace_back();
+//        return m;
+//    }
+//
+//    Mesh<N> _triangulate(std::vector<int> &g_gens) {
+//
+//        Mesh<N> S;
+//        if (g_gens.empty()) {
+//            S.prims.push_back(Primitive<N>());
+//            return S;
+//        }
+//
+//        GeomGen<N - 1> gg(context);
+//        for (std::vector<int> sg_gens : Combos(g_gens, g_gens.size() - 1)) {
+//            Mesh<N - 1> sub_simps = gg.triangulate(sg_gens);
+//            int start = sub_simps.size();
+//            Mesh<N - 1> raised = tile(g_gens, sg_gens, sub_simps);
+//
+//            for (const Primitive<N - 1> &prim : raised.prims) {
+//                S.prims.push_back(Primitive<N>(prim, 0));
+//            }
+//
+////            for (int l = start; l < raised.size(); l += g_gens.size()) {
+////                for (int m = l; m < l + g_gens.size(); m++) {
+////                    S.vals.push_back(raised.vals[m]);
+////                }
+////                S.vals.push_back(0);
+////            }
+//        }
+//        return S;
+//    }
+//};
+//
+//template<unsigned N>
+//Mesh<N> GeomGen<N>::triangulate(std::vector<int> &g_gens) {
+//    int key = get_key_from_gens(g_gens);
+//    if (!triangulate_memo[key]) {
+//        triangulate_memo[key] = _triangulate(g_gens);
+//    }
+//    return *triangulate_memo[key];
+//}

vis/src/main.cpp

@@ -97,8 +97,10 @@ int main(int argc, char *argv[]) {
 
     //region points
     auto group = tc::group::H(4);
-    GeomGen gg(group);
+//    GeomGen<4> gg4(group);
-    auto res = gg.solve();
+//    GeomGen<3> gg3(group);
+//    auto res = gg4.solve();
+    auto res = group.solve();
     auto mirrors = mirror(group);
 
     auto corners = plane_intersections(mirrors);
@@ -107,7 +109,7 @@ int main(int argc, char *argv[]) {
 //    auto start = barycentric(corners, {0.05f, 0.1f, 0.2f, 1.00f});
     auto points = res.path.walk<glm::vec4, glm::vec4>(start, mirrors, reflect);
 
-    auto g_gens = gg.group_gens();
+    auto g_gens = gens(group);
 
     std::vector<GLuint> vaos;
     std::vector<GLuint> ibos;
@@ -120,17 +122,18 @@ int main(int argc, char *argv[]) {
 //    };
     auto chosen = combos;
 
-    for (auto sg_gens : chosen) {
+    for (const auto& sg_gens : chosen) {
-        auto s = gg.tile(g_gens, sg_gens, gg.triangulate(sg_gens));
+        const Mesh<4> &base = triangulate<4>(group, sg_gens);
-        const std::vector<int> data = s.vals;
+        const auto &s = base;
+//         s = tile(context, g_gens, sg_gens, base);
 
         GLuint vao = utilCreateVertexArray();
         GLuint ibo = utilCreateBuffer();
-        unsigned count = data.size();
+        unsigned count = s.size();
 
         glBindVertexArray(vao);
         glBindBuffer(GL_ARRAY_BUFFER, ibo);
-        glBufferData(GL_ARRAY_BUFFER, sizeof(int) * count, &data[0], GL_STATIC_DRAW);
+        glBufferData(GL_ARRAY_BUFFER, sizeof(Primitive<4>) * count, &s.prims[0], GL_STATIC_DRAW);
         glEnableVertexAttribArray(0);
         glVertexAttribIPointer(0, 4, GL_INT, 0, nullptr);
         glBindBuffer(GL_ARRAY_BUFFER, 0);