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
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
|
/*
This file contains docstrings for use in the Python bindings.
Do not edit! They were automatically extracted by ../gendoc.sh.
*/
#if defined(__GNUG__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-variable"
#endif
namespace regina::python::doc {
// Docstring regina::python::doc::GraphLoop
static const char *GraphLoop =
R"doc(Represents a closed graph manifold formed by joining a single bounded
Seifert fibred space to itself along a torus.
The Seifert fibred space must have two boundary components, each a
torus corresponding to a puncture in the base orbifold (with no fibre-
reversing twist as one travels around the boundary).
The way in which the two torus boundaries are joined together is
specified by a 2-by-2 matrix *M*. This matrix relates the locations of
the fibres and base orbifold on the two boundary tori.
More specifically, suppose that *f0* and *o0* are generators of the
first boundary torus, where *f0* represents a directed fibre in the
Seifert fibred space and *o0* represents the oriented boundary of the
base orbifold. Likewise, let *f1* and *o1* be generators of the second
boundary torus representing a directed fibre and the oriented boundary
of the base orbifold. Then the tori are joined together so that the
curves *f0*, *o0*, *f1* and *o1* become related as follows:
```
[f1] [f0]
[ ] = M * [ ]
[o1] [o0]
```
See the page on notation for Seifert fibred spaces for details on some
of the terminology used above.
The optional Manifold routine homology() is implemented, but the
optional routine construct() is not.
This class implements C++ move semantics and adheres to the C++
Swappable requirement. It is designed to avoid deep copies wherever
possible, even when passing or returning objects by value. Note,
however, that GraphLoop still requires a non-trivial (but constant
sized) amount of data to be copied even in a move operation.)doc";
namespace GraphLoop_ {
// Docstring regina::python::doc::GraphLoop_::__cmp
static const char *__cmp =
R"doc(Compares representations of two graph manifolds according to an
aesthetic ordering.
The only purpose of this routine is to implement a consistent ordering
of graph manifold representations. The specific ordering used is
purely aesthetic on the part of the author, and is subject to change
in future versions of Regina.
It does not matter whether the two manifolds are homeomorphic; this
routine compares the specific _representations_ of these manifolds
(and so in particular, different representations of the same graph
manifold will be ordered differently).
This operator generates all of the usual comparison operators,
including ``<``, ``<=``, ``>``, and ``>=``.
Python:
This spaceship operator ``x <=> y`` is not available, but the
other comparison operators that it generates _are_ available.
Parameter ``rhs``:
the other representation to compare this with.
Returns:
A result that indicates how this and the given graph manifold
representation should be ordered with respect to each other.)doc";
// Docstring regina::python::doc::GraphLoop_::__copy
static const char *__copy = R"doc(Creates a clone of the given graph manifold.)doc";
// Docstring regina::python::doc::GraphLoop_::__eq
static const char *__eq =
R"doc(Determines whether this and the given object contain precisely the
same presentations of the same graph manifold.
This routine does _not_ test for homeomorphism. Instead it compares
the exact presentations, including the matching matrix and the
specific presentation of the bounded Seifert fibred space, and
determines whether or not these _presentations_ are identical. If you
have two different presentations of the same graph manifold, they will
be treated as not equal by this routine.
Parameter ``compare``:
the presentation with which this will be compared.
Returns:
``True`` if and only if this and the given object contain
identical presentations of the same graph manifold.)doc";
// Docstring regina::python::doc::GraphLoop_::__init
static const char *__init =
R"doc(Creates a new graph manifold as a self-identified Seifert fibred
space. The bounded Seifert fibred space and the four elements of the
2-by-2 matching matrix are all passed separately. The elements of the
matching matrix combine to give the full matrix *M* as follows:
```
[ mat00 mat01 ]
M = [ ]
[ mat10 mat11 ]
```
Precondition:
The given matching matrix has determinant +1 or -1.
Exception ``InvalidArgument``:
The given Seifert fibred space does not have precisely two torus
boundaries, corresponding to two untwisted punctures in its base
orbifold.
Parameter ``sfs``:
the bounded Seifert fibred space.
Parameter ``mat00``:
the (0,0) element of the matching matrix.
Parameter ``mat01``:
the (0,1) element of the matching matrix.
Parameter ``mat10``:
the (1,0) element of the matching matrix.
Parameter ``mat11``:
the (1,1) element of the matching matrix.)doc";
// Docstring regina::python::doc::GraphLoop_::__init_2
static const char *__init_2 =
R"doc(Creates a new graph manifold as a self-identified Seifert fibred
space, which is moved instead of copied.
Other than its use of move semantics, this behaves identically to the
other constructor that takes the Seifert fibred space by const
reference. See that constructor for further details.
Precondition:
The given matching matrix has determinant +1 or -1.
Exception ``InvalidArgument``:
The given Seifert fibred space does not have precisely two torus
boundaries, corresponding to two untwisted punctures in its base
orbifold.
Parameter ``sfs``:
the bounded Seifert fibred space.
Parameter ``mat00``:
the (0,0) element of the matching matrix.
Parameter ``mat01``:
the (0,1) element of the matching matrix.
Parameter ``mat10``:
the (1,0) element of the matching matrix.
Parameter ``mat11``:
the (1,1) element of the matching matrix.)doc";
// Docstring regina::python::doc::GraphLoop_::__init_3
static const char *__init_3 =
R"doc(Creates a new graph manifold as a self-identified Seifert fibred
space. The bounded Seifert fibred space and the entire 2-by-2 matching
matrix are each passed separately.
Precondition:
The given matching matrix has determinant +1 or -1.
Exception ``InvalidArgument``:
The given Seifert fibred space does not have precisely two torus
boundaries, corresponding to two untwisted punctures in its base
orbifold.
Parameter ``sfs``:
the bounded Seifert fibred space.
Parameter ``matchingReln``:
the 2-by-2 matching matrix.)doc";
// Docstring regina::python::doc::GraphLoop_::__init_4
static const char *__init_4 =
R"doc(Creates a new graph manifold as a self-identified Seifert fibred
space, which is moved instead of copied.
Other than its use of move semantics, this behaves identically to the
other constructor that takes the Seifert fibred space by const
reference. See that constructor for further details.
Precondition:
The given matching matrix has determinant +1 or -1.
Exception ``InvalidArgument``:
The given Seifert fibred space does not have precisely two torus
boundaries, corresponding to two untwisted punctures in its base
orbifold.
Parameter ``sfs``:
the bounded Seifert fibred space.
Parameter ``matchingReln``:
the 2-by-2 matching matrix.)doc";
// Docstring regina::python::doc::GraphLoop_::global_swap
static const char *global_swap =
R"doc(Swaps the contents of the two given graph manifolds.
This global routine simply calls GraphLoop::swap(); it is provided so
that GraphLoop meets the C++ Swappable requirements.
Parameter ``a``:
the first graph manifold whose contents should be swapped.
Parameter ``b``:
the second graph manifold whose contents should be swapped.)doc";
// Docstring regina::python::doc::GraphLoop_::matchingReln
static const char *matchingReln =
R"doc(Returns a reference to the 2-by-2 matrix describing how the two
boundary tori of the Seifert fibred space are joined together. See the
class notes for details on precisely how this matrix is represented.
Returns:
a reference to the matching matrix.)doc";
// Docstring regina::python::doc::GraphLoop_::sfs
static const char *sfs =
R"doc(Returns a reference to the bounded Seifert fibred space that is joined
to itself.
Returns:
a reference to the bounded Seifert fibred space.)doc";
// Docstring regina::python::doc::GraphLoop_::swap
static const char *swap =
R"doc(Swaps the contents of this and the given graph manifold.
Parameter ``other``:
the graph manifold whose contents should be swapped with this.)doc";
}
} // namespace regina::python::doc
#if defined(__GNUG__)
#pragma GCC diagnostic pop
#endif
|
