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

rename "Mults" class to "Rel"; rename variables where appropriate. now all instances of "mult" refer to a multiplicity, not a relation.

Browse Source
This commit is contained in:
David Allemang
2019-12-30 18:31:50 -05:00
parent 18d6e24518
commit 0c94d48235
3 changed files with 63 additions and 52 deletions
Download Patch File Download Diff File Expand all files Collapse all files

19
include/groups.h
View File

@@ -4,21 +4,24 @@
#include <vector> #include <vector>
namespace tc { namespace tc {
struct Mult { struct Rel {
std::array<int, 2> gens; std::array<int, 2> gens;
int mult; int mult;
}; };
/**
* A presentation of a coxeter group. Contains a number of generators and some relations of the form (ab)^n = e
*/
struct Group { struct Group {
int ngens; const int ngens;
std::vector<std::vector<int>> _mults; std::vector<std::vector<int>> _mults; // lookup table for multiplicities
std::string name; std::string name;
explicit Group(int ngens, const std::vector<Mult> &rels = {}, std::string name = "G"); explicit Group(int ngens, const std::vector<Rel> &rels = {}, std::string name = "G");
void setmult(Mult m); void setmult(Rel rel);
[[nodiscard]] std::vector<Mult> get_mults() const; [[nodiscard]] std::vector<Rel> get_rels() const;
[[nodiscard]] Group product(const Group &other) const; [[nodiscard]] Group product(const Group &other) const;
@@ -29,6 +32,10 @@ namespace tc {
Group operator^(const Group &g, const int &p); 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); Group schlafli(const std::vector<int> &mults);
namespace group { namespace group {

43
src/groups.cpp
View File

@@ -1,48 +1,47 @@
#include "groups.h" #include "groups.h"
//#include <utility>
#include <iterator> #include <iterator>
#include <sstream> #include <sstream>
namespace tc { namespace tc {
Group::Group(int ngens, const std::vector<Mult> &rels, std::string name) : ngens(ngens), name(std::move(name)) { Group::Group(int ngens, const std::vector<Rel> &rels, std::string name) : ngens(ngens), name(std::move(name)) {
_mults.resize(ngens); _mults.resize(ngens);
for (int i = 0; i < ngens; i++) { for (int i = 0; i < ngens; i++) {
_mults[i].resize(ngens, 2); _mults[i].resize(ngens, 2);
} }
for (Mult m : rels) { for (Rel rel : rels) {
if (m.gens[0] < m.gens[1]) if (rel.gens[0] < rel.gens[1])
_mults[m.gens[0]][m.gens[1]] = m.mult; _mults[rel.gens[0]][rel.gens[1]] = rel.mult;
else else
_mults[m.gens[1]][m.gens[0]] = m.mult; _mults[rel.gens[1]][rel.gens[0]] = rel.mult;
} }
} }
void Group::setmult(Mult m) { void Group::setmult(Rel rel) {
if (m.gens[0] < m.gens[1]) if (rel.gens[0] < rel.gens[1])
_mults[m.gens[0]][m.gens[1]] = m.mult; _mults[rel.gens[0]][rel.gens[1]] = rel.mult;
else else
_mults[m.gens[1]][m.gens[0]] = m.mult; _mults[rel.gens[1]][rel.gens[0]] = rel.mult;
} }
std::vector<Mult> Group::get_mults() const { std::vector<Rel> Group::get_rels() const {
std::vector<Mult> mults; std::vector<Rel> rels;
for (int i = 0; i < ngens - 1; i++) { for (int i = 0; i < ngens - 1; i++) {
for (int j = i + 1; j < ngens; j++) { for (int j = i + 1; j < ngens; j++) {
mults.push_back({i, j, _mults[i][j]}); rels.push_back({i, j, _mults[i][j]});
} }
} }
return mults; return rels;
} }
Group Group::product(const Group &other) const { Group Group::product(const Group &other) const {
int off = ngens; int off = ngens;
Group g(ngens + other.ngens, get_mults()); Group g(ngens + other.ngens, get_rels());
for (Mult m : other.get_mults()) { for (Rel rel : other.get_rels()) {
g.setmult({off + m.gens[0], off + m.gens[1], m.mult}); g.setmult({off + rel.gens[0], off + rel.gens[1], rel.mult});
} }
std::stringstream ss; std::stringstream ss;
@@ -55,9 +54,9 @@ namespace tc {
Group Group::power(int p) const { Group Group::power(int p) const {
Group g(ngens * p); Group g(ngens * p);
for (Mult m : get_mults()) { for (Rel rel : get_rels()) {
for (int off = 0; off < g.ngens; off += ngens) { for (int off = 0; off < g.ngens; off += ngens) {
g.setmult({off + m.gens[0], off + m.gens[1], m.mult}); g.setmult({off + rel.gens[0], off + rel.gens[1], rel.mult});
} }
} }
@@ -76,12 +75,12 @@ namespace tc {
return g.power(p); return g.power(p);
} }
Group schlafli(const std::vector<int> &mults, const std::string name) { Group schlafli(const std::vector<int> &mults, const std::string& name) {
int ngens = mults.size() + 1; int ngens = (int) mults.size() + 1;
Group g(ngens, {}, name); Group g(ngens, {}, name);
for (int i = 0; i < mults.size(); i++) { for (int i = 0; i < (int) mults.size(); i++) {
g.setmult({i, i + 1, mults[i]}); g.setmult({i, i + 1, mults[i]});
} }

53
src/solver.cpp
View File

@@ -4,12 +4,15 @@
namespace tc { namespace tc {
struct RelTable { struct RelTable {
Mult mult; Rel rel;
std::vector<int *> lst_ptr; std::vector<int *> lst_ptr;
std::vector<int> gen; std::vector<int> gen;
explicit RelTable(tc::Mult mult) : mult(mult) { int &mult = rel.mult;
std::array<int, 2> &gens = rel.gens;
explicit RelTable(Rel rel) : rel(rel) {
} }
int add_row() { int add_row() {
@@ -27,12 +30,12 @@ namespace tc {
std::vector<std::vector<RelTable *>> gen_map; // which relations involve which generators 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) { explicit RelationSet(const Group &g, const Cosets &cosets) : gen_map(g.ngens), cosets(cosets) {
const std::vector<Mult> &mults = g.get_mults(); const std::vector<Rel> &rels = g.get_rels();
tables.reserve(mults.size()); tables.reserve(rels.size());
for (const auto &mult : mults) { for (const auto &rel : rels) {
RelTable &table = tables.emplace_back(mult); RelTable &table = tables.emplace_back(rel);
gen_map[mult.gens[0]].push_back(&table); gen_map[rel.gens[0]].push_back(&table);
gen_map[mult.gens[1]].push_back(&table); gen_map[rel.gens[1]].push_back(&table);
} }
} }
@@ -48,8 +51,8 @@ namespace tc {
table.lst_ptr[idx] = new int; table.lst_ptr[idx] = new int;
if ((cosets.get(idx, table.mult.gens[0]) != idx) and if ((cosets.get(idx, table.gens[0]) != idx) and
(cosets.get(idx, table.mult.gens[1]) != idx)) { (cosets.get(idx, table.gens[1]) != idx)) {
table.gen[idx] = 0; table.gen[idx] = 0;
} else { } else {
table.gen[idx] = -1; table.gen[idx] = -1;
@@ -97,24 +100,26 @@ namespace tc {
coset = fact_idx / group.ngens; coset = fact_idx / group.ngens;
gen = fact_idx % group.ngens; gen = fact_idx % group.ngens;
for (RelTable *rel : rels.gen_map[gen]) { for (RelTable *pTable : rels.gen_map[gen]) {
if (rel->lst_ptr[target] == nullptr) { RelTable &table = *pTable;
rel->lst_ptr[target] = rel->lst_ptr[coset];
rel->gen[target] = rel->gen[coset] + 1;
if (rel->gen[coset] < 0) if (table.lst_ptr[target] == nullptr) {
rel->gen[target] -= 2; table.lst_ptr[target] = table.lst_ptr[coset];
table.gen[target] = table.gen[coset] + 1;
if (rel->gen[target] == rel->mult.mult) { if (table.gen[coset] < 0)
lst = *(rel->lst_ptr[target]); table.gen[target] -= 2;
delete rel->lst_ptr[target];
gen_ = rel->mult.gens[(int) (rel->mult.gens[0] == gen)]; 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_); facts.push_back(lst * group.ngens + gen_);
} else if (rel->gen[target] == -rel->mult.mult) { } else if (table.gen[target] == -table.mult) {
gen_ = rel->mult.gens[rel->mult.gens[0] == gen]; gen_ = table.gens[table.gens[0] == gen];
facts.push_back(target * group.ngens + gen_); facts.push_back(target * group.ngens + gen_);
} else if (rel->gen[target] == rel->mult.mult - 1) { } else if (table.gen[target] == table.mult - 1) {
*(rel->lst_ptr[target]) = target; *(table.lst_ptr[target]) = target;
} }
} }
} }