allemang.d/toddcox-visualize
1
0
Fork 0
mirror of https://github.com/allemangD/toddcox-visualize.git synced 2025-11-10 12:02:47 -05:00
Code Issues Packages Projects Releases Wiki Activity

break apart into modules; add vendor dependencies; add OpenGL boilerplate to get started

Browse Source
This commit is contained in:
David Allemang
2020-01-04 01:30:19 -05:00
parent a8d9451502
commit d602837659
14 changed files with 93 additions and 2 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
tc/CMakeLists.txt Normal file
View File

@@ -0,0 +1,6 @@
add_library(tc STATIC
src/groups.cpp
src/solver.cpp
src/cosets.cpp)
target_include_directories(tc PUBLIC include)

30
tc/include/tc/cosets.h Normal file
View File

@@ -0,0 +1,30 @@
#pragma once
#include "groups.h"
#include <vector>
namespace tc {
struct Action {
int coset = -1;
int gen = -1;
};
struct Cosets {
int ngens;
std::vector<int> data;
std::vector<Action> path;
int len;
explicit Cosets(int ngens);
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;
};
}

92
tc/include/tc/groups.h Normal file
View File

@@ -0,0 +1,92 @@
#pragma once
#include <array>
#include <vector>
namespace tc {
struct Rel {
std::array<int, 2> gens;
int mult;
};
/**
* A presentation of a coxeter group. Contains a number of generators and some relations of the form (ab)^n = e
*/
struct Group {
const int ngens;
std::vector<std::vector<int>> _mults; // lookup table for multiplicities
std::string name;
explicit Group(int ngens, const std::vector<Rel> &rels = {}, std::string name = "G");
void setmult(Rel rel);
[[nodiscard]] std::vector<Rel> get_rels() const;
[[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);
/**
* Construct a group from a (simplified) Schlafli Symbol of the form [a, b, ..., c]
* @param mults: The sequence of multiplicites between adjacent generators.
*/
Group schlafli(const std::vector<int> &mults);
namespace group {
/**
* Simplex
*/
Group A(int dim);
/**
* Cube, Orthoplex
*/
Group B(int dim);
/**
* Demicube, Orthoplex
*/
Group D(int dim);
/**
* E groups
*/
Group E(int dim);
/**
* 24 Cell
*/
Group F4();
/**
* Hexagon
*/
Group G2();
/**
* Icosahedron
*/
Group H(int dim);
/**
* Polygonal
*/
Group I2(int n);
/**
* Toroidal. I2(n) * I2(m)
*/
Group T(int n, int m);
/**
* Toroidal. T(n, n)
*/
Group T(int n);
}
}

7
tc/include/tc/solver.h Normal file
View File

@@ -0,0 +1,7 @@
#pragma once
#include "cosets.h"
namespace tc {
Cosets solve(const Group &g, const std::vector<int> &sub_gens = {});
}

41
tc/src/cosets.cpp Normal file
View File

@@ -0,0 +1,41 @@
#include "tc/cosets.h"
namespace tc {
Cosets::Cosets(int ngens) : ngens(ngens), len(0) {
}
void Cosets::add_row() {
len++;
data.resize(data.size() + ngens, -1);
path.resize(path.size() + 1);
}
void Cosets::put(int coset, int gen, int target) {
data[coset * ngens + gen] = target;
data[target * ngens + gen] = coset;
if (path[target].coset == -1) {
path[target] = {coset, gen};
}
}
void Cosets::put(int idx, int target) {
int coset = idx / ngens;
int gen = idx % ngens;
data[idx] = target;
data[target * ngens + gen] = coset;
if (path[target].coset == -1) {
path[target] = {coset, gen};
}
}
int Cosets::get(int coset, int gen) const {
return data[coset * ngens + gen];
}
int Cosets::get(int idx) const {
return data[idx];
}
}

196
tc/src/groups.cpp Normal file
View File

@@ -0,0 +1,196 @@
#include "tc/groups.h"
#include <iterator>
#include <sstream>
namespace tc {
Group::Group(int ngens, const std::vector<Rel> &rels, std::string name) : ngens(ngens), name(std::move(name)) {
_mults.resize(ngens);
for (int i = 0; i < ngens; i++) {
_mults[i].resize(ngens, 2);
}
for (Rel rel : rels) {
if (rel.gens[0] < rel.gens[1])
_mults[rel.gens[0]][rel.gens[1]] = rel.mult;
else
_mults[rel.gens[1]][rel.gens[0]] = rel.mult;
}
}
void Group::setmult(Rel rel) {
if (rel.gens[0] < rel.gens[1])
_mults[rel.gens[0]][rel.gens[1]] = rel.mult;
else
_mults[rel.gens[1]][rel.gens[0]] = rel.mult;
}
std::vector<Rel> Group::get_rels() const {
std::vector<Rel> rels;
for (int i = 0; i < ngens - 1; i++) {
for (int j = i + 1; j < ngens; j++) {
rels.push_back({i, j, _mults[i][j]});
}
}
return rels;
}
Group Group::product(const Group &other) const {
int off = ngens;
Group g(ngens + other.ngens, get_rels());
for (Rel rel : other.get_rels()) {
g.setmult({off + rel.gens[0], off + rel.gens[1], rel.mult});
}
std::stringstream ss;
ss << name << "*" << other.name;
g.name = ss.str();
return g;
}
Group Group::power(int p) const {
Group g(ngens * p);
for (Rel rel : get_rels()) {
for (int off = 0; off < g.ngens; off += ngens) {
g.setmult({off + rel.gens[0], off + rel.gens[1], rel.mult});
}
}
std::stringstream ss;
ss << name << "^" << p;
g.name = ss.str();
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, const std::string& name) {
int ngens = (int) mults.size() + 1;
Group g(ngens, {}, name);
for (int i = 0; i < (int) mults.size(); i++) {
g.setmult({i, i + 1, mults[i]});
}
return g;
}
Group schlafli(const std::vector<int> &mults) {
std::stringstream ss;
ss << "[";
if (!mults.empty()) {
copy(mults.begin(), mults.end() - 1, std::ostream_iterator<int>(ss, ","));
ss << mults.back();
}
ss << "]";
return schlafli(mults, ss.str());
}
namespace group {
Group A(const int dim) {
if (dim == 0)
return Group(0, {}, "A(0)");
const std::vector<int> &mults = std::vector<int>(dim - 1, 3);
std::stringstream ss;
ss << "A(" << dim << ")";
return schlafli(mults, ss.str());
}
Group B(const int dim) {
std::vector<int> mults(dim - 1, 3);
mults[0] = 4;
std::stringstream ss;
ss << "B(" << dim << ")";
return schlafli(mults, ss.str());
}
Group D(const int dim) {
std::vector<int> mults(dim - 1, 3);
mults[dim - 2] = 2;
Group g = schlafli(mults);
g.setmult({1, dim - 1, 3});
std::stringstream ss;
ss << "D(" << dim << ")";
g.name = ss.str();
return g;
}
Group E(const int dim) {
std::vector<int> mults(dim - 1, 3);
mults[dim - 2] = 2;
Group g = schlafli(mults);
g.setmult({2, dim - 1, 3});
std::stringstream ss;
ss << "E(" << dim << ")";
g.name = ss.str();
return g;
}
Group F4() {
return schlafli({3, 4, 3}, "F4");
}
Group G2() {
return schlafli({6}, "G2");
}
Group H(const int dim) {
std::vector<int> mults(dim - 1, 3);
mults[0] = 5;
std::stringstream ss;
ss << "H(" << dim << ")";
return schlafli(mults, ss.str());
}
Group I2(const int n) {
std::stringstream ss;
ss << "I2(" << n << ")";
return schlafli({n}, ss.str());
}
Group T(const int n, const int m) {
Group g = I2(n) * I2(m);
std::stringstream ss;
ss << "T(" << n << "," << m << ")";
g.name = ss.str();
return g;
}
Group T(const int n) {
Group g = I2(n) ^2;
std::stringstream ss;
ss << "T(" << n << ")";
g.name = ss.str();
return g;
}
}
}

135
tc/src/solver.cpp Normal file
View File

@@ -0,0 +1,135 @@
#include "tc/solver.h"
#include <algorithm>
namespace tc {
struct RelTable {
Rel rel;
std::vector<int *> lst_ptr;
std::vector<int> gen;
int &mult = rel.mult;
std::array<int, 2> &gens = rel.gens;
explicit RelTable(Rel rel) : rel(rel) {
}
int add_row() {
int idx = lst_ptr.size();
lst_ptr.push_back(nullptr);
gen.push_back(-1);
return idx;
}
};
struct RelationSet {
const Cosets &cosets;
std::vector<RelTable> tables;
std::vector<std::vector<RelTable *>> gen_map; // which relations involve which generators
explicit RelationSet(const Group &g, const Cosets &cosets) : gen_map(g.ngens), cosets(cosets) {
const std::vector<Rel> &rels = g.get_rels();
tables.reserve(rels.size());
for (const auto &rel : rels) {
RelTable &table = tables.emplace_back(rel);
gen_map[rel.gens[0]].push_back(&table);
gen_map[rel.gens[1]].push_back(&table);
}
}
void add_row() {
for (auto &table : tables) {
table.add_row();
}
}
void fill_row(int idx) {
for (auto &table : tables) {
if (table.lst_ptr[idx] != nullptr) continue;
table.lst_ptr[idx] = new int;
if ((cosets.get(idx, table.gens[0]) != idx) and
(cosets.get(idx, table.gens[1]) != idx)) {
table.gen[idx] = 0;
} else {
table.gen[idx] = -1;
}
}
}
};
Cosets solve(const Group &group, const std::vector<int> &sub_gens) {
Cosets cosets(group.ngens);
cosets.add_row();
for (const auto &i : sub_gens) {
cosets.put(0, i, 0);
}
RelationSet rels(group, cosets);
rels.add_row();
rels.fill_row(0);
int idx = 0;
int coset, gen, target, fact_idx, lst, gen_;
while (true) {
while (idx < cosets.data.size() and cosets.get(idx) >= 0)
idx++;
if (idx == cosets.data.size())
break;
target = cosets.len;
cosets.add_row();
rels.add_row();
std::vector<int> facts = {idx};
while (!facts.empty()) {
fact_idx = facts.back();
facts.pop_back();
if (cosets.get(fact_idx) != -1)
continue;
cosets.put(fact_idx, target);
coset = fact_idx / group.ngens;
gen = fact_idx % group.ngens;
for (RelTable *pTable : rels.gen_map[gen]) {
RelTable &table = *pTable;
if (table.lst_ptr[target] == nullptr) {
table.lst_ptr[target] = table.lst_ptr[coset];
table.gen[target] = table.gen[coset] + 1;
if (table.gen[coset] < 0)
table.gen[target] -= 2;
if (table.gen[target] == table.rel.mult) {
lst = *(table.lst_ptr[target]);
delete table.lst_ptr[target];
gen_ = table.gens[table.gens[0] == gen];
facts.push_back(lst * group.ngens + gen_);
} else if (table.gen[target] == -table.mult) {
gen_ = table.gens[table.gens[0] == gen];
facts.push_back(target * group.ngens + gen_);
} else if (table.gen[target] == table.mult - 1) {
*(table.lst_ptr[target]) = target;
}
}
}
std::sort(facts.begin(), facts.end(), std::greater<>());
}
rels.fill_row(target);
}
return cosets;
}
}