solve vertex table only once

cosets/include/coxeter.hpp

@@ -27,11 +27,12 @@ struct Mults {
 
 struct Table {
    const std::vector<int> gens;
+   const Mults mults;
    std::vector<int> gen_inds;
    std::vector<std::vector<int>> fwd;
    std::vector<std::vector<int>> rev;
 
-   explicit Table(std::vector<int> gens);
+   explicit Table(std::vector<int> gens, Mults mults);
 
    [[nodiscard]] int gen_index(int gen) const;
 
@@ -80,6 +81,10 @@ struct IRow {
 
 Table *solve(const std::vector<int> &gens, const std::vector<int> &subgens, const Mults &mults);
 
+Table *solve(const std::vector<int> &subgens, const Mults &mults);
+
+Table *solve_elems(const Mults &mults);
+
 Mults schlafli(const std::vector<int> &symbol);
 
 std::vector<int> all_gens(int N);

cosets/src/main.cpp

@@ -52,25 +52,34 @@ public:
       u_view = glGetUniformLocation(program, "view");
       u_color = glGetUniformLocation(program, "color");
 
-      const Mults &mults = schlafli({3, 3, 5});
+      const Mults &mults = schlafli({5,3,3});
 //      const glm::vec4 ident = center(mults);
-      const glm::vec4 ident = identity(mults, {10, 1, 1, 1});
+      const glm::vec4 ident = identity(mults, {1,});
       std::cout << "Dimension: " << mults.num_gens << std::endl;
 
       std::cout << "Generation times: " << std::endl;
 
       auto gen_start = std::chrono::high_resolution_clock::now();
 
-      vert_data = vertices(mults, ident);
+      const Table *t_vert = solve_elems(mults);
+      auto gen_solve = std::chrono::high_resolution_clock::now();
+      std::chrono::duration<double> solve_time = gen_solve - gen_start;
+      std::cout
+         << "Table: "
+         << std::setw(5) << std::setprecision(3) << solve_time.count()
+         << std::endl;
+
+
+      vert_data = vertices(t_vert, ident);
       auto gen_vert = std::chrono::high_resolution_clock::now();
-      std::chrono::duration<double> vert_time = gen_vert - gen_start;
+      std::chrono::duration<double> vert_time = gen_vert - gen_solve;
       std::cout
          << "Vertices: "
          << std::setw(5) << std::setprecision(3) << vert_time.count()
          << " (" << vert_data.size() << ")"
          << std::endl;
 
-      edge_data = edges(mults);
+      edge_data = edges(t_vert);
       auto gen_edge = std::chrono::high_resolution_clock::now();
       std::chrono::duration<double> edge_time = gen_edge - gen_vert;
       std::cout
@@ -79,7 +88,7 @@ public:
          << " (" << edge_data.size() / 2 << ")"
          << std::endl;
 
-      face_data = faces(mults);
+      face_data = faces(t_vert);
       auto gen_face = std::chrono::high_resolution_clock::now();
       std::chrono::duration<double> face_time = gen_face - gen_edge;
       std::cout
@@ -147,8 +156,20 @@ public:
       const float sc = 1.5f;
       const float ar = (float) w / (float) h;
 
+      const float c1 = std::cos(angle * .7);
+      const float s1 = std::sin(angle * .7);
+      const float c2 = std::cos(angle * .5);
+      const float s2 = std::sin(angle * .5);
+
       const glm::mat4 proj = glm::ortho(-ar * sc, ar * sc, -sc, sc, -10.f, 10.f);
-      const glm::mat4 view = glm::rotate(id, angle, ax_1) * glm::rotate(id, angle, ax_2);
+      const glm::mat4 view = glm::rotate(id, angle, ax_1) * glm::rotate(id, angle, ax_2)
+         * glm::mat4(
+         c1, 0.0, s1, 0.0,
+         0.0, c2, 0.0, s2,
+         -s1, 0.0, c1, 0.0,
+         0.0, -s2, 0.0, c2
+      )
+      ;
 
       glUseProgram(program);
       glUniformMatrix4fv(u_proj, 1, false, glm::value_ptr(proj));
@@ -166,16 +187,20 @@ public:
 
       glBindVertexArray(vert_vao);
       glUniform4f(u_color, 1, 0, 0, 1);
-//      glDrawArrays(GL_POINTS, 0, vert_data.size());
+      glDrawArrays(GL_POINTS, 0, vert_data.size());
 
       glBindVertexArray(edge_vao);
       glUniform4f(u_color, 1, 0, 0, 1);
       glDrawElements(GL_LINES, edge_data.size(), GL_UNSIGNED_INT, 0);
 
       glBindVertexArray(face_vao);
-      glCullFace(GL_FRONT);
+      glCullFace(GL_NONE);
       glUniform4f(u_color, 1, 1, 1, 1);
-      glDrawElements(GL_TRIANGLES, face_data.size(), GL_UNSIGNED_INT, 0);
+//      glDrawElements(GL_TRIANGLES, face_data.size(), GL_UNSIGNED_INT, 0);
+
+//      glCullFace(GL_FRONT);
+//      glUniform4f(u_color, .3, .3, 1, 1);
+//      glDrawElements(GL_TRIANGLES, face_data.size(), GL_UNSIGNED_INT, 0);
 
       swapbuffers();
    }

cosets/src/util/coxeter.cpp

@@ -53,7 +53,7 @@ std::vector<std::vector<int>> Mults::irelations(Table *table, std::vector<int> g
    return irels;
 }
 
-Table::Table(const std::vector<int> gens) : gens(gens) {
+Table::Table(const std::vector<int> gens, const Mults mults) : gens(gens), mults(mults) {
    add_row();
 
    gen_inds = std::vector<int>(gens[gens.size() - 1] + 1, -1);
@@ -224,7 +224,7 @@ bool IRow::learn(Table *table) {
 }
 
 Table *solve(const std::vector<int> &gens, const std::vector<int> &subgens, const Mults &mults) {
-   auto *table = new Table(gens);
+   auto *table = new Table(gens, mults);
    const auto irels = mults.irelations(table, gens);
 
    for (int gen : subgens)
@@ -260,6 +260,14 @@ Table *solve(const std::vector<int> &gens, const std::vector<int> &subgens, cons
    return table;
 }
 
+Table *solve(const std::vector<int> &subgens, const Mults &mults) {
+   return solve(all_gens(mults.num_gens), subgens, mults);
+}
+
+Table *solve_elems(const Mults &mults) {
+   return solve({}, mults);
+}
+
 Mults schlafli(const std::vector<int> &symbol) {
    Mults mults{};
    for (int i = 0; i < symbol.size(); ++i) {

cosets/src/util/mesh.hpp

@@ -39,14 +39,11 @@ glm::vec4 center(const Mults &mults) {
 }
 
 std::vector<glm::vec4>
-vertices(const Mults &mults, const glm::vec4 ident) {
+vertices(const Table *t_vert, const glm::vec4 ident) {
-   int N = mults.num_gens;
+   const std::vector<glm::vec4> normals = mirror(t_vert->mults);
-   Table *table = solve(all_gens(N), {}, mults);
-
-   const std::vector<glm::vec4> normals = mirror(mults);
 
    std::vector<glm::vec4> verts{};
-   for (const auto &word : table->words()) {
+   for (const auto &word : t_vert->words()) {
       glm::vec4 vert = ident;
       for (const auto &gen : word) {
          vert = reflect(vert, normals[gen]);
@@ -57,16 +54,14 @@ vertices(const Mults &mults, const glm::vec4 ident) {
    return verts;
 }
 
-std::vector<int> edges(const Mults &mults) {
+std::vector<int> edges(const Table *t_vert) {
    std::vector<int> res{};
 
+   Mults mults = t_vert->mults;
    int N = mults.num_gens;
-   const std::vector<int> &gens = all_gens(N);
+   const std::vector<int> &gens = t_vert->gens;
-
-   Table *t_vert = solve(gens, {}, mults);
 
    for (const auto &subgens : combinations(N, 1)) {
-      if (subgens[0] == 0) continue;
       Table *t_edge = solve(subgens, {}, mults);
 
       std::vector<int> edge = t_vert->apply_each(t_edge->words());
@@ -83,23 +78,14 @@ std::vector<int> edges(const Mults &mults) {
    return res;
 }
 
-std::vector<int> faces(const Mults &mults) {
+std::vector<int> faces(const Table *t_vert) {
    std::vector<int> res{};
+   const Mults &mults = t_vert->mults;
    int N = mults.num_gens;
-   const std::vector<int> &gens = all_gens(N);
+   const std::vector<int> &gens = t_vert->gens;
-
-   Table *t_vert = solve(gens, {}, mults);
 
    // for each *kind* of face
    for (const auto &sg_face : combinations(N, 2)) {
-      if (sg_face[0] == 0 and sg_face[1] == 3) continue; // checker
-      if (sg_face[0] == 0 and sg_face[1] == 2) continue; // checker
-//      if (sg_face[0] == 1 and sg_face[1] == 2) continue; // checker
-//      if (sg_face[0] == 1 and sg_face[1] == 3) continue; // checker
-
-      if (sg_face[0] == 0 and sg_face[1] == 1) continue; // flat
-//      if (sg_face[0] == 2 and sg_face[1] == 3) continue; // vertical
-
       Table *cs_face = solve(gens, sg_face, mults);
 
       // for each *kind* of edge