Improve tc::Group, tc::Cosets API.

This is a combination of many commits:

---------------------------------------------------------------------------

final. add public/private for core classes.

wip - big cleanup cosets.

index<>, cosets<>, and group<> all defined

transparent <void> overrides that operate directly on indices, not names

inheritance hierarchy means one can drop or change generator names

still missing path support.

wip - named cosets

fix lang test

wip - named generators

Move Group docstring away from specialization.

Remove tc::Gen; use Group<void>

remove tc::Rel

add thousands separators for benchmark limits

add generators list to tc::group

remove pair_map

tc/test/CMakeLists.txt

@@ -1,8 +1,5 @@
 include(GoogleTest)
 
-add_executable(test_pair_map test_pair_map.cpp)
-target_link_libraries(test_pair_map tc GTest::gtest_main)
-
 add_executable(test_solve test_solve.cpp)
 target_link_libraries(test_solve tc GTest::gtest_main)
 
@@ -17,6 +14,5 @@ target_compile_definitions(
     MIN_COS_PER_SEC=$<IF:$<CONFIG:Debug>,${MIN_DEBUG_CPS},${MIN_RELEASE_CPS}>
 )
 
-gtest_discover_tests(test_pair_map)
 gtest_discover_tests(test_solve)
 gtest_discover_tests(test_lang)

tc/test/test_lang.cpp

@@ -1,4 +1,4 @@
-#include <tc/group.hpp>
+#include <tc/core.hpp>
 #include <tc/groups.hpp>
 
 #include <gtest/gtest.h>
@@ -20,24 +20,33 @@
 TEST(coxeter, simple) {
     auto g = tc::coxeter("5 3 3");
 
-    ASSERT_EQ(g.rank, 4);
+    ASSERT_EQ(g.rank(), 4);
 
+    EXPECT_EQ(g.get(0, 0), 1);
     EXPECT_EQ(g.get(0, 1), 5);
-    EXPECT_EQ(g.get(1, 2), 3);
-    EXPECT_EQ(g.get(3, 4), 3);
-
     EXPECT_EQ(g.get(0, 2), 2);
     EXPECT_EQ(g.get(0, 3), 2);
-    EXPECT_EQ(g.get(0, 4), 2);
+    
+    EXPECT_EQ(g.get(1, 0), 5);
+    EXPECT_EQ(g.get(1, 1), 1);
+    EXPECT_EQ(g.get(1, 2), 3);
     EXPECT_EQ(g.get(1, 3), 2);
-    EXPECT_EQ(g.get(1, 4), 2);
-    EXPECT_EQ(g.get(2, 4), 2);
+    
+    EXPECT_EQ(g.get(2, 0), 2);
+    EXPECT_EQ(g.get(2, 1), 3);
+    EXPECT_EQ(g.get(2, 2), 1);
+    EXPECT_EQ(g.get(2, 3), 3);
+    
+    EXPECT_EQ(g.get(3, 0), 2);
+    EXPECT_EQ(g.get(3, 1), 2);
+    EXPECT_EQ(g.get(3, 2), 3);
+    EXPECT_EQ(g.get(3, 3), 1);
 }
 
 TEST(coxeter, looping) {
     auto g = tc::coxeter("{5 3 4}");
 
-    ASSERT_EQ(g.rank, 3);
+    ASSERT_EQ(g.rank(), 3);
 
     EXPECT_EQ(g.get(0, 1), 5);
     EXPECT_EQ(g.get(1, 2), 3);

tc/test/test_pair_map.cpp

@@ -1,127 +0,0 @@
-#include <functional>
-#include <iostream>
-#include <unordered_map>
-
-#include <tc/pair_map.hpp>
-
-#include <gtest/gtest.h>
-
-/// helper for comparing against two options
-template<typename T, typename U, typename V>
-testing::AssertionResult AssertEqEither(
-    const char *val_expr,
-    const char *o1_expr,
-    const char *o2_expr,
-    T val, U o1, V o2
-) {
-    if ((val == o1) || (val == o2)) {
-        return testing::AssertionSuccess();
-    }
-
-    return testing::AssertionFailure()
-        << val_expr << " (" << val << ") " << "does not equal " << o1_expr
-        << " (" << o1 << ") " << "or " << o2_expr << " (" << o2 << ")";
-}
-
-#define EXPECT_EQ_EITHER(val, o1, o2) EXPECT_PRED_FORMAT3(AssertEqEither, val, o1, o2)
-
-
-/// Naive symmetric pair hash
-size_t key(size_t i, size_t j) {
-    return ((i + j) << 12) ^ i ^ j;
-}
-
-/// factory to build a simple pair_map
-tc::pair_map<size_t> populate(size_t size) {
-    tc::pair_map<size_t> pm(6);
-
-    for (int i = 0; i < pm.size(); ++i) {
-        for (int j = i; j < pm.size(); ++j) {
-            pm(i, j) = key(i, j);
-        }
-    }
-
-    return pm;
-}
-
-TEST(pair_map, fill) {
-    tc::pair_map<size_t> pm(6, 42);
-
-    for (int i = 0; i < pm.size(); ++i) {
-        for (int j = i; j < pm.size(); ++j) {
-            EXPECT_EQ(pm(i, j), 42);
-        }
-    }
-}
-
-TEST(pair_map, symmetry) {
-    auto pm = populate(6);
-
-    for (int i = 0; i < pm.size(); ++i) {
-        for (int j = i; j < pm.size(); ++j) {
-            EXPECT_EQ(pm(i, j), key(i, j));
-            EXPECT_EQ(pm(j, i), pm(i, j));
-        }
-    }
-}
-
-TEST(pair_map, copy) {
-    auto pm = populate(6);
-    auto pm_ = pm;
-
-    ASSERT_EQ(pm_.size(), 6);
-
-    for (int i = 0; i < pm_.size(); ++i) {
-        for (int j = i; j < pm_.size(); ++j) {
-            EXPECT_EQ(pm_(i, j), pm(i, j));
-            EXPECT_EQ(pm_(i, j), key(i, j));
-        }
-    }
-}
-
-TEST(pair_map, move) {
-    auto pm = populate(6);
-    auto pm_ = std::move(pm);
-
-    ASSERT_EQ(pm_.size(), 6);
-
-    for (int i = 0; i < pm_.size(); ++i) {
-        for (int j = i; j < pm_.size(); ++j) {
-            EXPECT_EQ(pm_(i, j), key(i, j));
-        }
-    }
-}
-
-TEST(pair_map, iterate) {
-    auto pm = populate(6);
-
-    size_t count = 0;
-    for (const auto &[i, j, m]: pm) {
-        EXPECT_EQ(m, key(i, j));
-        count++;
-    }
-    EXPECT_EQ(count, 21);
-}
-
-TEST(pair_map, iterate_ref) {
-    auto pm = populate(6);
-
-    for (const auto &[i, j, m]: pm) {
-        m = 42;
-    }
-
-    for (const auto &[i, j, m]: pm) {
-        EXPECT_EQ(m, 42);
-    }
-}
-
-TEST(pair_map, view) {
-    auto pm = populate(6);
-
-    size_t count = 0;
-    for (const auto &[i, j, m]: pm.of(4)) {
-        EXPECT_EQ_EITHER(4, i, j);
-        count++;
-    }
-    EXPECT_EQ(count, pm.size());
-}

tc/test/test_solve.cpp

@@ -11,15 +11,15 @@ testing::AssertionResult AssertSolveOrder(
     const char *group_expr,
     const char *sub_gens_expr,
     const char *expected_order_expr,
-    const tc::Group &group,
-    const std::vector<tc::Gen> &sub_gens,
-    tc::Coset expected_order
+    const tc::Group<> &group,
+    const std::vector<size_t> &sub_gens,
+    size_t expected_order
 ) {
     auto start = std::clock();
-    auto cosets = tc::solve(group, sub_gens);
+    auto cosets = group.solve(sub_gens);
     auto end = std::clock();
 
-    tc::Coset actual_order = cosets.size();
+    size_t actual_order = cosets.order();
 
     auto total_sec = (double) (end - start) / CLOCKS_PER_SEC;
     auto cosets_per_sec = (double) actual_order / total_sec;
@@ -48,45 +48,45 @@ testing::AssertionResult AssertSolveOrder(
 
 #define EXPECT_SOLVE_ORDER(group, sub_gens, expected_order) EXPECT_PRED_FORMAT3(AssertSolveOrder, group, sub_gens, expected_order);
 
-using v = std::vector<tc::Gen>;
+using v = std::vector<size_t>;
 
-tc::Group A(unsigned int n) {
+tc::Group<> A(unsigned int n) {
     return tc::vcoxeter("3 * {}", {n - 1});
 }
 
-tc::Group B(unsigned int n) {
+tc::Group<> B(unsigned int n) {
     return tc::vcoxeter("4 3 * {}", {n - 2});
 }
 
-tc::Group D(unsigned int n) {
+tc::Group<> D(unsigned int n) {
     return tc::vcoxeter("3 * [1 1 {}]", {n - 3});
 }
 
-tc::Group E(unsigned int n) {
+tc::Group<> E(unsigned int n) {
     return tc::vcoxeter("3 * [1 2 {}]", {n - 4});
 }
 
-tc::Group F4() {
+tc::Group<> F4() {
     return tc::coxeter("3 4 3");
 }
 
-tc::Group G2() {
+tc::Group<> G2() {
     return tc::coxeter("6");
 }
 
-tc::Group H(unsigned int n) {
+tc::Group<> H(unsigned int n) {
     return tc::vcoxeter("5 3 * {}", {n - 2});
 }
 
-tc::Group I2(unsigned int n) {
+tc::Group<> I2(unsigned int n) {
     return tc::vcoxeter("{}", {n});
 }
 
-tc::Group T(unsigned int m, unsigned int n) {
+tc::Group<> T(unsigned int m, unsigned int n) {
     return tc::vcoxeter("{} 2 {}", {m, n});
 }
 
-tc::Group T(unsigned int n) {
+tc::Group<> T(unsigned int n) {
     return T(n, n);
 }