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
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
|
/**************************************************************************
* *
* Regina - A Normal Surface Theory Calculator *
* Computational Engine *
* *
* Copyright (c) 1999-2011, Ben Burton *
* For further details contact Ben Burton (bab@debian.org). *
* *
* This program is free software; you can redistribute it and/or *
* modify it under the terms of the GNU General Public License as *
* published by the Free Software Foundation; either version 2 of the *
* License, or (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, but *
* WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU *
* General Public License for more details. *
* *
* You should have received a copy of the GNU General Public *
* License along with this program; if not, write to the Free *
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, *
* MA 02110-1301, USA. *
* *
**************************************************************************/
/* end stub */
/*! \file subcomplex/nlayeredchainpair.h
* \brief Deals with layered chain pair components of a triangulation.
*/
#ifndef __NLAYEREDCHAINPAIR_H
#ifndef __DOXYGEN
#define __NLAYEREDCHAINPAIR_H
#endif
#include "regina-core.h"
#include "subcomplex/nlayeredchain.h"
namespace regina {
class NComponent;
/**
* \weakgroup subcomplex
* @{
*/
/**
* Represents a layered chain pair component of a triangulation.
*
* A layered chain pair consists of two layered chains (as described by
* class NLayeredChain) glued together in a particular way.
*
* Orient the hinge edges and diagonals of each chain so they all point
* in the same direction around the solid tori formed by each layered
* chain (a \e diagonal is an edge between the two top faces or an edge
* between the two bottom faces of a layered chain).
*
* The two top faces of the first chain are glued to a top and bottom
* face of the second chain, and the two bottom faces of the first chain
* are glued to a top and bottom face of the second chain.
*
* The four oriented diagonals are all identified as a single edge. Of the
* remaining unglued edges (two hinge edges and two non-hinge edges per chain),
* each hinge edge of one chain must be identified to a non-hinge edge of
* the other chain and vice versa. From here the face identifications are
* uniquely determined.
*
* Note that a layered chain pair in which one of the chains contains
* only one tetrahedron is in fact a layered loop with a twist
* (see class NLayeredLoop).
*
* All optional NStandardTriangulation routines are implemented for this
* class.
*/
class REGINA_API NLayeredChainPair : public NStandardTriangulation {
private:
NLayeredChain* chain[2];
/**< The two layered chains that make up this pair. */
public:
/**
* Destroys this layered chain pair.
*/
virtual ~NLayeredChainPair();
/**
* Returns a newly created clone of this structure.
*
* @return a newly created clone.
*/
NLayeredChainPair* clone() const;
/**
* Returns the requested layered chain used to form this structure.
* If the two chains have different lengths, the shorter chain
* will be chain 0 and the longer chain will be chain 1.
*
* @param which specifies which chain to return; this must be 0
* or 1.
* @return the requested layered chain.
*/
const NLayeredChain* getChain(int which) const;
/**
* Determines if the given triangulation component is a layered
* chain pair.
*
* @param comp the triangulation component to examine.
* @return a newly created structure containing details of the
* layered chain pair, or \c null if the given component is
* not a layered chain pair.
*/
static NLayeredChainPair* isLayeredChainPair(const NComponent* comp);
NManifold* getManifold() const;
NAbelianGroup* getHomologyH1() const;
std::ostream& writeName(std::ostream& out) const;
std::ostream& writeTeXName(std::ostream& out) const;
void writeTextLong(std::ostream& out) const;
private:
/**
* Creates a new uninitialised structure.
*/
NLayeredChainPair();
};
/*@}*/
// Inline functions for NLayeredChainPair
inline NLayeredChainPair::NLayeredChainPair() {
chain[0] = chain[1] = 0;
}
inline NLayeredChainPair::~NLayeredChainPair() {
if (chain[0]) delete chain[0];
if (chain[1]) delete chain[1];
}
inline const NLayeredChain* NLayeredChainPair::getChain(int which) const {
return chain[which];
}
inline std::ostream& NLayeredChainPair::writeName(std::ostream& out) const {
return out << "C("
<< chain[0]->getIndex() << ',' << chain[1]->getIndex() << ')';
}
inline std::ostream& NLayeredChainPair::writeTeXName(std::ostream& out) const {
return out << "C_{"
<< chain[0]->getIndex() << ',' << chain[1]->getIndex() << '}';
}
inline void NLayeredChainPair::writeTextLong(std::ostream& out) const {
out << "Layered chain pair (chain lengths "
<< chain[0]->getIndex() << ", " << chain[1]->getIndex() << ')';
}
} // namespace regina
#endif
|
