Un-template groups.

Templating the groups doesn't improve performance that much, but it severely hinders usability. Switch things to be dynamically sized so that different ranked groups are the same type.

Could also now separate headers and implementation... but will probably leave it for now.

include/tc/groups.hpp

@@ -6,13 +6,11 @@ namespace tc::group {
     /**
      * Universal Coxeter Group
      */
-    template<unsigned int Rank>
-    Group<Rank> U() {
-        std::stringstream ss;
-        ss << "U(" << Rank << ")";
+    Group U(size_t rank) {
+        std::string name = "U(" + std::to_string(rank) + ")";
 
-        Group<Rank> res;
-        res.name = ss.str();
+        Group res(rank);
+        res.name = name;
         res.fill(2);
         return res;
     }
@@ -20,53 +18,47 @@ namespace tc::group {
     /**
      * Simplex
      */
-    template<unsigned int Rank>
-    Group<Rank> A() {
-        std::stringstream ss;
-        ss << "A(" << Rank << ")";
+    Group A(size_t rank) {
+        std::string name = "A(" + std::to_string(rank) + ")";
 
-        if (Rank == 0) {
-            Group<Rank> res;
-            res.name = ss.str();
+        if (rank == 0) {
+            Group res(rank);
+            res.name = name;
             return res;
         }
 
-        tc::Symbol<Rank - 1> mults;
-        mults.fill(3);
+        tc::Symbol symbol(rank - 1);
+        symbol.fill(3);
 
-        return schlafli<Rank>(mults, ss.str());
+        return schlafli(symbol, name);
     }
 
     /**
      * Cube, Orthoplex
      */
-    template<unsigned int Rank>
-    Group<Rank> B() {
-        std::stringstream ss;
-        ss << "B(" << Rank << ")";
+    Group B(size_t rank) {
+        std::string name = "B(" + std::to_string(rank) + ")";
 
-        tc::Symbol<Rank - 1> mults;
-        mults.fill(3);
-        mults(0) = 4;
+        tc::Symbol symbol(rank - 1);
+        symbol.fill(3);
+        symbol(0) = 4;
 
-        return schlafli<Rank>(mults, ss.str());
+        return schlafli(symbol, name);
     }
 
     /**
      * Demicube, Orthoplex
      */
-    template<unsigned int Rank>
-    Group<Rank> D() {
-        std::stringstream ss;
-        ss << "D(" << Rank << ")";
+    Group D(size_t rank) {
+        std::string name = "D(" + std::to_string(rank) + ")";
 
-        tc::Symbol<Rank - 1> mults;
-        mults.fill(3);
-        mults(Rank - 2) = 2;
+        tc::Symbol symbol(rank - 1);
+        symbol.fill(3);
+        symbol((Eigen::Index) rank - 2) = 2;
 
-        Group<Rank> g = schlafli<Rank>(mults, ss.str());
-        g(1, Rank - 1) = 3;
-        g(Rank - 1, 1) = 3;
+        Group g = schlafli(symbol, name);
+        g(1, (Eigen::Index) rank - 1) = 3;
+        g((Eigen::Index) rank - 1, 1) = 3;
 
         return g;
     }
@@ -74,18 +66,16 @@ namespace tc::group {
     /**
      * E groups
      */
-    template<unsigned int Rank>
-    Group<Rank> E() {
-        std::stringstream ss;
-        ss << "E(" << Rank << ")";
+    Group E(size_t rank) {
+        std::string name = "E(" + std::to_string(rank) + ")";
 
-        tc::Symbol<Rank - 1> mults;
-        mults.fill(3);
-        mults(Rank - 2) = 2;
+        tc::Symbol symbol(rank - 1);
+        symbol.fill(3);
+        symbol((Eigen::Index) rank - 2) = 2;
 
-        Group<Rank> g = schlafli<Rank>(mults, ss.str());
-        g(2, Rank - 1) = 3;
-        g(Rank - 1, 2) = 3;
+        Group g = schlafli(symbol, name);
+        g(2, (Eigen::Index) rank - 1) = 3;
+        g((Eigen::Index) rank - 1, 2) = 3;
 
         return g;
     }
@@ -93,59 +83,66 @@ namespace tc::group {
     /**
      * 24 Cell
      */
-    Group<4> F4() {
-        return schlafli<4>({3, 4, 3}, "F4");
+    Group F4() {
+        tc::Symbol symbol(3);
+        symbol << 3, 4, 3;
+        return schlafli(symbol, "F4");
     }
 
     /**
      * Hexagon
      */
-    Group<2> G2() {
-        return schlafli<2>(tc::Symbol<1>(6), "G2");
+    Group G2() {
+        tc::Symbol symbol(1);
+        symbol << 6;
+        return schlafli(symbol, "G2");
     }
 
     /**
      * Icosahedron
      */
-    template<unsigned int Rank>
-    Group<Rank> H() {
-        std::stringstream ss;
-        ss << "H(" << Rank << ")";
+    Group H(size_t rank) {
+        std::string name = "H(" + std::to_string(rank) + ")";
 
-        tc::Symbol<Rank - 1> mults;
-        mults.fill(3);
-        mults(0) = 5;
+        tc::Symbol symbol(rank - 1);
+        symbol.fill(3);
+        symbol(0) = 5;
 
-        return schlafli<Rank>(mults, ss.str());
+        return schlafli(symbol, name);
     }
 
     /**
      * Polygonal
      */
-    Group<2> I2(unsigned int n) {
-        std::stringstream ss;
-        ss << "I2(" << n << ")";
+    Group I2(unsigned int n) {
+        std::string name = "I2(" + std::to_string(n) + ")";
 
-        return schlafli<2>(tc::Symbol<1>(n), ss.str());
+        tc::Symbol symbol(1);
+        symbol << n;
+        return schlafli(symbol, name);
     }
 
     /**
      * Toroidal. I2(n) * I2(m)
      */
-    Group<4> T(unsigned int n, unsigned int m) {
-        std::stringstream ss;
-        ss << "T(" << n << "," << m << ")";
+    Group T(unsigned int n, unsigned int m) {
+        std::string name = "T(" + std::to_string(n) + "," + std::to_string(m) + ")";
 
-        return schlafli<4>({n, 2, m}, ss.str());
+        tc::Symbol symbol(3);
+        symbol << n, 2, m;
+
+        return schlafli(symbol, name);
     }
 
     /**
      * Toroidal. T(n, n)
      */
-    Group<4> T(unsigned int n) {
-        std::stringstream ss;
-        ss << "T(" << n << ")";
+    Group T(unsigned int n) {
+        std::string name = "T(" + std::to_string(n) + ")";
 
-        return schlafli<4>({n, 2, n}, ss.str());
+        tc::Symbol symbol(3);
+        symbol << n, 2, n;
+
+        return schlafli(symbol, name);
     }
 }