Add order tests

CMakeLists.txt

@@ -15,3 +15,8 @@ target_include_directories(tc INTERFACE include)
 if (TC_BUILD_EXAMPLE)
     add_subdirectory(example)
 endif ()
+
+if (TC_BUILD_TESTING)
+    enable_testing()
+    add_subdirectory(Testing)
+endif()

Testing/CMakeLists.txt

@@ -0,0 +1,22 @@
+cmake_policy(SET CMP0110 NEW)
+
+add_executable(schlafli schlafli.cpp)
+target_link_libraries(schlafli PRIVATE tc)
+
+add_executable(special special.cpp)
+target_link_libraries(special PRIVATE tc)
+
+add_test(NAME "schalfi [6]" COMMAND schlafli "6" "" "12")
+add_test(NAME "schalfi [6] [0]" COMMAND schlafli "6" "0" "6")
+add_test(NAME "schalfi [6] [1]" COMMAND schlafli "6" "1" "6")
+
+add_test(NAME "schalfi [5 3 3] []" COMMAND schlafli "5 3 3" "" "14400")
+add_test(NAME "schalfi [5 3 3] [0 1]" COMMAND schlafli "5 3 3" "0 1" "1440")
+add_test(NAME "schalfi [5 3 3] [1 2 3]" COMMAND schlafli "5 3 3" "1 2 3" "600")
+
+add_test(NAME "special E6" COMMAND special "E6" "" "51840")
+add_test(NAME "special E7" COMMAND special "E7" "" "2903040")
+#add_test(NAME "special E8" COMMAND special "E8" "" "696729600")  # too big.
+add_test(NAME "special B6" COMMAND special "B6" "" "46080")
+add_test(NAME "special B7" COMMAND special "B7" "" "645120")
+add_test(NAME "special B8" COMMAND special "B8" "" "10321920")

Testing/common.hpp

@@ -0,0 +1,31 @@
+#pragma once
+
+#include <string>
+#include <vector>
+#include <sstream>
+
+#include <tc/group.hpp>
+#include <tc/groups.hpp>
+#include <tc/solver.hpp>
+
+std::vector<unsigned int> parse_vec(const std::string &part) {
+    std::istringstream iss(part);
+
+    std::vector<unsigned int> res;
+
+    std::string token;
+    while (std::getline(iss, token, ' ')) {
+        res.push_back(std::stoul(token));
+    }
+
+    return res;
+}
+
+template<unsigned int N>
+int compute(
+    const tc::Group<N> &group,
+    const std::vector<unsigned int> &vgens
+) {
+    auto table = tc::solve<N>(group, vgens);
+    return table.order();
+}

Testing/schlafli.cpp

@@ -0,0 +1,41 @@
+#include "common.hpp"
+
+#include <iostream>
+
+int main(int argc, char **argv) {
+    auto vsymbol = parse_vec(argv[1]);
+    auto vgens = parse_vec(argv[2]);
+    auto target = std::stoul(argv[3]);
+
+    int order;
+    switch (vsymbol.size()) {
+    case 0: {
+        Eigen::Vector<unsigned int, 0> symbol(vsymbol.data());
+        order = compute<1>(tc::schlafli<1>(symbol), vgens);
+        break;
+    }
+    case 1: {
+        Eigen::Vector<unsigned int, 1> symbol(vsymbol.data());
+        order = compute<2>(tc::schlafli<2>(symbol), vgens);
+        break;
+    }
+    case 2: {
+        Eigen::Vector<unsigned int, 2> symbol(vsymbol.data());
+        order = compute<3>(tc::schlafli<3>(symbol), vgens);
+        break;
+    }
+    case 3: {
+        Eigen::Vector<unsigned int, 3> symbol(vsymbol.data());
+        order = compute<4>(tc::schlafli<4>(symbol), vgens);
+        break;
+    }
+    case 4: {
+        Eigen::Vector<unsigned int, 4> symbol(vsymbol.data());
+        order = compute<5>(tc::schlafli<5>(symbol), vgens);
+        break;
+    }
+    }
+
+    std::cout << "Order: " << order << ":" << target << std::endl;
+    return order != target;
+}

Testing/special.cpp

@@ -0,0 +1,39 @@
+#include "common.hpp"
+
+#include <iostream>
+
+int main(int argc, char **argv) {
+    auto name = std::string(argv[1]);
+    auto vgens = parse_vec(argv[2]);
+    auto target = std::stoul(argv[3]);
+
+    unsigned int order;
+
+    if (name == "E6") {
+        auto group = tc::group::E<6>();
+        order = compute<6>(group, vgens);
+    }
+    if (name == "E7") {
+        auto group = tc::group::E<7>();
+        order = compute<7>(group, vgens);
+    }
+    if (name == "E8") {
+        auto group = tc::group::E<8>();
+        order = compute<8>(group, vgens);
+    }
+    if (name == "B6") {
+        auto group = tc::group::B<6>();
+        order = compute<6>(group, vgens);
+    }
+    if (name == "B7") {
+        auto group = tc::group::B<7>();
+        order = compute<7>(group, vgens);
+    }
+    if (name == "B8") {
+        auto group = tc::group::B<8>();
+        order = compute<8>(group, vgens);
+    }
+
+    std::cout << "Order: " << order << ":" << target << std::endl;
+    return order != target;
+}

include/tc/solver.hpp

@@ -160,7 +160,7 @@ namespace tc {
      * Assumes that g is a coxeter group - that is, self-adjoint and the diagonal is 2.
      */
     template<unsigned int Rank>
-    tc::Cosets<Rank> solve(const Group <Rank> &group, const std::vector<int> &sub_gens = {}) {
+    tc::Cosets<Rank> solve(const Group <Rank> &group, const std::vector<unsigned int> &sub_gens = {}) {
         tc::Cosets<Rank> cosets;
         cosets.add_row();
 
@@ -168,7 +168,7 @@ namespace tc {
             return cosets;
         }
 
-        for (int gen: sub_gens) {
+        for (unsigned int gen: sub_gens) {
             if (gen < Rank)
                 cosets.put(0, gen, 0);
         }