split definitions and declarations, move to "tc" namespace

CMakeLists.txt

@@ -3,4 +3,4 @@ project(test)
 
 set(CMAKE_CXX_STANDARD 17)
 
-add_executable(test test.cpp)
+add_executable(test test.cpp groups.cpp solver.cpp)

groups.cpp

@@ -1,52 +1,132 @@
-#include "solver.cpp"
+#include "groups.h"
 
-Group A(const int n) {
+namespace tc {
+    Group::Group(int ngens, const std::vector<Mult> &rels) : ngens(ngens) {
+        _mults.resize(ngens);
+        for (int i = 0; i < ngens; i++) {
+            _mults[i].resize(ngens, 2);
+        }
+
+        for (Mult m : rels) {
+            if (m.gen0 < m.gen1)
+                _mults[m.gen0][m.gen1] = m.mult;
+            else
+                _mults[m.gen1][m.gen0] = m.mult;
+        }
+    }
+
+    void Group::setmult(Mult m) {
+        if (m.gen0 < m.gen1)
+            _mults[m.gen0][m.gen1] = m.mult;
+        else
+            _mults[m.gen1][m.gen0] = m.mult;
+    }
+
+    std::vector<Mult> Group::get_mults() const {
+        std::vector<Mult> mults;
+        for (int i = 0; i < ngens - 1; i++) {
+            for (int j = i + 1; j < ngens; j++) {
+                mults.push_back({i, j, _mults[i][j]});
+            }
+        }
+        return mults;
+    }
+
+    Group Group::product(const Group &other) const {
+        int off = ngens;
+
+        Group g(ngens + other.ngens, get_mults());
+
+        for (Mult m : other.get_mults()) {
+            g.setmult({off + m.gen0, off + m.gen1, m.mult});
+        }
+
+        return g;
+    }
+
+    Group Group::power(int p) const {
+        Group g(ngens * p);
+
+        for (Mult m : get_mults()) {
+            for (int off = 0; off < g.ngens; off += ngens) {
+                g.setmult({off + m.gen0, off + m.gen1, m.mult});
+            }
+        }
+
+        return g;
+    }
+
+    Group operator*(const Group &g, const Group &h) {
+        return g.product(h);
+    }
+
+    Group operator^(const Group &g, const int &p) {
+        return g.power(p);
+    }
+
+    Group schlafli(const std::vector<int> &mults) {
+        int ngens = mults.size() + 1;
+        Group g(ngens);
+        for (int i = 0; i < mults.size(); i++) {
+            g.setmult({i, i + 1, mults[i]});
+        }
+        return g;
+    }
+
+    namespace group {
+        Group A(const int n) {
             if (n == 0)
                 return Group(0);
 
-    return Group::schlafli(std::vector<int>(n-1,3));
+            return schlafli(std::vector<int>(n - 1, 3));
-}
+        }
 
-Group B(const int n) {
+        Group B(const int n) {
-    std::vector<int> mults(n-1,3);
+            std::vector<int> mults(n - 1, 3);
             mults[0] = 4;
-    return Group::schlafli(mults);
+            return schlafli(mults);
-}
+        }
 
-Group D(const int n) {
+        Group D(const int n) {
-    std::vector<int> mults(n-1,3);
+            std::vector<int> mults(n - 1, 3);
-    mults[n-2] = 2;
+            mults[n - 2] = 2;
-    Group g = Group::schlafli(mults);
+            Group g = schlafli(mults);
-    g.setmult({1,n-1,3});
+            g.setmult({1, n - 1, 3});
             return g;
-}
+        }
 
-Group E(const int n) {
+        Group E(const int n) {
-    std::vector<int> mults(n-1,3);
+            std::vector<int> mults(n - 1, 3);
-    mults[n-2] = 2;
+            mults[n - 2] = 2;
-    Group g = Group::schlafli(mults);
+            Group g = schlafli(mults);
-    g.setmult({2,n-1,3});
+            g.setmult({2, n - 1, 3});
             return g;
-}
+        }
 
-Group F4() {
+        Group F4() {
-    return Group::schlafli({3,4,3});
+            return schlafli({3, 4, 3});
-}
+        }
 
-Group G2() {
+        Group G2() {
-    return Group::schlafli({6});
+            return schlafli({6});
-}
+        }
 
-Group H(const int n) {
+        Group H(const int n) {
-    std::vector<int> mults(n-1,3);
+            std::vector<int> mults(n - 1, 3);
             mults[0] = 5;
-    return Group::schlafli(mults);
+            return schlafli(mults);
-}
+        }
 
-Group I2(const int n) {
+        Group I2(const int n) {
-    return Group::schlafli({n});
+            return schlafli({n});
-}
+        }
 
-Group T(const int n) {
+        Group T(const int n, const int m) {
-    return I2(n)^2;
+            return I2(n) * I2(m);
+        }
+
+        Group T(const int n) {
+            return I2(n) ^ 2;
+        }
+    }
 }

groups.h

@@ -2,40 +2,12 @@
 
 #include <vector>
 
-struct Cosets {
+namespace tc {
-    int ngens;
+    struct Mult {
-    std::vector<int> data;
-    int len;
-
-    Cosets(int ngens, const std::vector<int> &data);
-
-    void add_row();
-
-    void put(int coset, int gen, int target);
-
-    void put(int idx, int target);
-
-    [[nodiscard]] int get(int coset, int gen) const;
-
-    [[nodiscard]] int get(int idx) const;
-};
-
-struct Mult {
         int gen0, gen1, mult;
-};
+    };
 
-struct RelTable {
+    struct Group {
-    int gens[2]{};
-    int mult;
-    std::vector<int *> lst_ptr;
-    std::vector<int> gen;
-
-    explicit RelTable(Mult m);
-
-    int add_row();
-};
-
-struct Group {
         int ngens;
         std::vector<std::vector<int>> _mults;
 
@@ -48,4 +20,33 @@ struct Group {
         [[nodiscard]] Group product(const Group &other) const;
 
         [[nodiscard]] Group power(int p) const;
-};
+    };
+
+    Group operator*(const Group &g, const Group &h);
+
+    Group operator^(const Group &g, const int &p);
+
+    Group schlafli(const std::vector<int> &mults);
+
+    namespace group {
+        Group A(int n);
+
+        Group B(int n);
+
+        Group D(int n);
+
+        Group E(int n);
+
+        Group F4();
+
+        Group G2();
+
+        Group H(int n);
+
+        Group I2(int n);
+
+        Group T(int n, int m);
+
+        Group T(int n);
+    }
+}

solver.cpp

@@ -1,147 +1,61 @@
-#include <vector>
+#include "solver.h"
+
 #include <algorithm>
-#include <queue>
-#include <utility>
 #include <functional>
-#include <iostream>
 
-struct Cosets {
+namespace tc {
-    int ngens;
+    Cosets::Cosets(int ngens, const std::vector<int> &data) : ngens(ngens), data(data) {
-    std::vector<int> data;
-    int len;
-
-    Cosets(int ngens, std::vector<int> data): ngens(ngens), data(data) {
         len = data.size() / ngens;
     }
 
-    void add_row() {
+    void Cosets::add_row() {
         len++;
-        data.resize(data.size()+ngens, -1);
+        data.resize(data.size() + ngens, -1);
     }
 
-    void put(int coset, int gen, int target) {
+    void Cosets::put(int coset, int gen, int target) {
         data[coset * ngens + gen] = target;
         data[target * ngens + gen] = coset;
     }
 
-    void put(int idx, int target) {
+    void Cosets::put(int idx, int target) {
         int coset = idx / ngens;
         int gen = idx % ngens;
         data[idx] = target;
         data[target * ngens + gen] = coset;
     }
 
-    int get(int coset, int gen) {
+    int Cosets::get(int coset, int gen) const {
         return data[coset * ngens + gen];
     }
 
-    int get(int idx) {
+    int Cosets::get(int idx) const {
         return data[idx];
     }
-};
 
-struct Mult {
+    RelTable::RelTable(Mult m) : mult(m.mult) {
-    int gen0, gen1, mult;
-};
-
-struct RelTable {
-    int gens[2];
-    int mult;
-    std::vector<int*> lst_ptr;
-    std::vector<int> gen;
-    
-    RelTable(Mult m): mult(m.mult) {
         gens[0] = m.gen0;
         gens[1] = m.gen1;
     }
 
-    int add_row() {
+    int RelTable::add_row() {
         int idx = lst_ptr.size();
         lst_ptr.push_back(nullptr);
         gen.push_back(-1);
         return idx;
     }
-};
 
-struct Group {
+    Cosets solve(const Group &group, const std::vector<int> &sub_gens) {
-    int ngens;
+        std::vector<int> init_row(group.ngens, -1);
-    std::vector<std::vector<int>> _mults;
-
-    Group(int ngens, std::vector<Mult> rels = {}): ngens(ngens) {
-        _mults.resize(ngens);
-        for (int i = 0; i < ngens; i++) {
-            _mults[i].resize(ngens, 2);
-        }
-
-        for (Mult m : rels) {
-            if (m.gen0 < m.gen1)
-                _mults[m.gen0][m.gen1] = m.mult;
-            else
-                _mults[m.gen1][m.gen0] = m.mult;
-        }
-    }
-
-    void setmult(Mult m) {
-        if (m.gen0 < m.gen1)
-            _mults[m.gen0][m.gen1] = m.mult;
-        else
-            _mults[m.gen1][m.gen0] = m.mult;
-    }
-
-    std::vector<Mult> get_mults() const {
-        std::vector<Mult> mults; 
-        for (int i = 0; i < ngens - 1; i++) {
-            for (int j = i+1; j < ngens; j++) {
-                mults.push_back({i,j,_mults[i][j]});
-            }
-        }
-        return mults;
-    }
-
-    Group operator*(const Group &other) {
-        int off = ngens;
-
-        Group g(ngens + other.ngens, get_mults());
-        
-        for (Mult m : other.get_mults()) {
-            g.setmult({off + m.gen0, off + m.gen1, m.mult});
-        }
-
-        return g;
-    }
-
-    Group operator^(int p) {
-        Group g(ngens * p);
-
-        for (Mult m : get_mults()) {
-            for (int off = 0; off < g.ngens; off += ngens) {
-                g.setmult({off + m.gen0, off + m.gen1, m.mult});
-            }
-        }
-
-        return g;
-    }
-
-    static Group schlafli(std::vector<int> mults) {
-        int ngens = mults.size() + 1;
-        Group g(ngens);
-        for (int i = 0; i < mults.size(); i++) {
-            g.setmult({i, i+1, mults[i]});
-        }
-        return g;
-    }
-
-    Cosets solve(std::vector<int> sub_gens = {}) {
-        std::vector<int> init_row(ngens, -1);
         for (int i : sub_gens) {
             init_row[i] = 0;
         }
 
-        Cosets cosets(ngens, init_row);
+        Cosets cosets(group.ngens, init_row);
         std::vector<RelTable> rel_tables;
-        std::vector<std::vector<int>> gen_map(ngens);
+        std::vector<std::vector<int>> gen_map(group.ngens);
         int rel_idx;
-        for (Mult m : get_mults()) {
+        for (Mult m : group.get_mults()) {
             rel_idx = rel_tables.size();
             gen_map[m.gen0].push_back(rel_idx);
             gen_map[m.gen1].push_back(rel_idx);
@@ -155,8 +69,7 @@ struct Group {
             if (cosets.get(rel.gens[0]) + cosets.get(rel.gens[1]) == -2) {
                 rel.lst_ptr[idx] = new int;
                 rel.gen[idx] = 0;
-            }
+            } else {
-            else {
                 rel.lst_ptr[idx] = &null_lst_ptr;
                 rel.gen[idx] = -1;
             }
@@ -181,8 +94,8 @@ struct Group {
             std::vector<int> facts;
             facts.push_back(idx);
 
-            coset = idx / ngens;
+            coset = idx / group.ngens;
-            gen = idx % ngens;
+            gen = idx % group.ngens;
 
             while (!facts.empty()) {
                 fact_idx = facts.back();
@@ -193,12 +106,12 @@ struct Group {
 
                 cosets.put(fact_idx, target);
 
-                coset = fact_idx / ngens;
+                coset = fact_idx / group.ngens;
-                gen = fact_idx % ngens;
+                gen = fact_idx % group.ngens;
 
                 for (int rel_idx : gen_map[gen]) {
                     RelTable &rel = rel_tables[rel_idx];
-                    if ( rel.lst_ptr[target] == nullptr ) {
+                    if (rel.lst_ptr[target] == nullptr) {
                         rel.lst_ptr[target] = rel.lst_ptr[coset];
                         rel.gen[target] = rel.gen[coset] + 1;
 
@@ -208,30 +121,27 @@ struct Group {
                         if (rel.gen[target] == rel.mult) {
                             lst = *(rel.lst_ptr[target]);
                             delete rel.lst_ptr[target];
-                            gen_ = rel.gens[(int)(rel.gens[0] == gen)];
+                            gen_ = rel.gens[(int) (rel.gens[0] == gen)];
-                            facts.push_back(lst*ngens + gen_);
+                            facts.push_back(lst * group.ngens + gen_);
-                        }
+                        } else if (rel.gen[target] == -rel.mult) {
-                        else if (rel.gen[target] == -rel.mult) {
                             gen_ = rel.gens[rel.gens[0] == gen];
-                            facts.push_back(target*ngens + gen_);
+                            facts.push_back(target * group.ngens + gen_);
-                        }
+                        } else if (rel.gen[target] == rel.mult - 1) {
-                        else if (rel.gen[target] == rel.mult - 1) {
                             *(rel.lst_ptr[target]) = target;
                         }
                     }
                 }
 
-                std::sort(facts.begin(), facts.end(), std::greater<int>());
+                std::sort(facts.begin(), facts.end(), std::greater<>());
             }
 
             for (RelTable &rel : rel_tables) {
                 if (rel.lst_ptr[target] == nullptr) {
-                    if ( (cosets.get(target, rel.gens[0]) != target) and 
+                    if ((cosets.get(target, rel.gens[0]) != target) and
-                         (cosets.get(target, rel.gens[1]) != target) ) {
+                        (cosets.get(target, rel.gens[1]) != target)) {
                         rel.lst_ptr[target] = new int;
                         rel.gen[target] = 0;
-                    }
+                    } else {
-                    else {
                         rel.lst_ptr[target] = &null_lst_ptr;
                         rel.gen[target] = -1;
                     }
@@ -241,4 +151,4 @@ struct Group {
 
         return cosets;
     }
-};
+}

solver.h

@@ -0,0 +1,37 @@
+#pragma once
+
+#include "groups.h"
+#include <vector>
+
+namespace tc {
+    struct Cosets {
+        int ngens;
+        std::vector<int> data;
+        int len;
+
+        Cosets(int ngens, const std::vector<int> &data);
+
+        void add_row();
+
+        void put(int coset, int gen, int target);
+
+        void put(int idx, int target);
+
+        [[nodiscard]] int get(int coset, int gen) const;
+
+        [[nodiscard]] int get(int idx) const;
+    };
+
+    struct RelTable {
+        int gens[2]{};
+        int mult;
+        std::vector<int *> lst_ptr;
+        std::vector<int> gen;
+
+        explicit RelTable(Mult m);
+
+        int add_row();
+    };
+
+    Cosets solve(const Group &g, const std::vector<int> &sub_gens = {});
+}

test.cpp

@@ -1,12 +1,13 @@
-#include "groups.cpp"
+#include "solver.h"
+#include "groups.h"
 #include <chrono>
 #include <iostream>
 
 int main() {
-    Group g = T(100);
+    tc::Group g = tc::group::T(2, 5000);
 
     auto s = std::chrono::system_clock::now();
-    auto cosets = g.solve();
+    auto cosets = solve(g);
     auto e = std::chrono::system_clock::now();
 
     std::chrono::duration<double> diff = e - s;