-
Notifications
You must be signed in to change notification settings - Fork 5
/
affine.cpp
128 lines (98 loc) · 3.43 KB
/
affine.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
/*
This is affine.cpp
Coxeter version 3.0 Copyright (C) 2002 Fokko du Cloux
See file main.cpp for full copyright notice
This file contains specific code for affine Coxeter groups. Although
there may be more efficient representations for group elements if extremely
large elments are required (very compact representations are available
that will store elements of essentially unbounded length, certainly
many billions without trouble), we have opted for a more uniform treatment
and use the minimal root approach. So elements are primarily represented
as coxwords.
The constructor will attempt to make the minroot table, and if it fails,
return an error status. This should fail only in very high rank (more than
hundred, say, if then), so it shouldn't cause any real problems.
*/
#include "affine.h"
#include "error.h"
#include "graph.h"
#include "minroots.h"
/* local variables */
namespace affine {
using namespace error;
using namespace graph;
using namespace minroots;
/****************************************************************************
Chapter 0 -- Initialization.
****************************************************************************/
/****************************************************************************
Chapter I -- Constructors and destructors.
This section contains constructors (no destructors!) for the types
in this module.
- AffineCoxGroup(x,l) : base class for all classes in this module;
- AffineBigRankCoxGroup(x,l) : rank > MEDRANK_MAX;
- AffineMedRankCoxGroup(x,l) : rank <= MEDRANK_MAX;
- AffineSmallRankCoxGroup(x,l) : rank <= MEDRANK_MAX/2;
****************************************************************************/
AffineCoxGroup::AffineCoxGroup(const Type& x, const Rank& l):CoxGroup(x,l)
{}
/**
Virtual destructor for the AffineCoxGroup class. Currently, nothing has
to be done.
*/
AffineCoxGroup::~AffineCoxGroup()
{}
AffineBigRankCoxGroup::AffineBigRankCoxGroup(const Type& x, const Rank& l)
: AffineCoxGroup(x,l)
{}
/**
Virtual destructor for the AffineBigRankCoxGroup class. Currently, nothing
has to be done.
*/
AffineBigRankCoxGroup::~AffineBigRankCoxGroup()
{}
GeneralABRCoxGroup::GeneralABRCoxGroup(const Type& x, const Rank& l)
:AffineBigRankCoxGroup(x,l)
{}
GeneralABRCoxGroup::~GeneralABRCoxGroup()
{}
AffineMedRankCoxGroup::AffineMedRankCoxGroup(const Type& x, const Rank& l)
:AffineCoxGroup(x,l)
{
mintable().fill(graph());
/* an error is set here in case of failure */
}
/**
Virtual destructor for the AffineMedRankCoxGroup class. The destruction
of the mintable should be the job of the CoxGroup destructor.
*/
AffineMedRankCoxGroup::~AffineMedRankCoxGroup()
{}
GeneralAMRCoxGroup::GeneralAMRCoxGroup(const Type& x, const Rank& l)
:AffineMedRankCoxGroup(x,l)
{}
/**
Virtual destructor for the GeneralAMRCoxGroup class. Currently, nothing has
to be done.
*/
GeneralAMRCoxGroup::~GeneralAMRCoxGroup()
{}
AffineSmallRankCoxGroup::AffineSmallRankCoxGroup(const Type& x, const Rank& l)
:AffineMedRankCoxGroup(x,l)
{}
/**
Virtual destructor for the AffineSmallRankCoxGroup class. Currently,
nothing has to be done.
*/
AffineSmallRankCoxGroup::~AffineSmallRankCoxGroup()
{}
GeneralASRCoxGroup::GeneralASRCoxGroup(const Type& x, const Rank& l)
:AffineSmallRankCoxGroup(x,l)
{}
/**
Virtual destructor for the GeneralASRCoxGroup class. Currently, nothing has
to be done.
*/
GeneralASRCoxGroup::~GeneralASRCoxGroup()
{}
}