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
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
|
/*
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::GraphPair
static const char *GraphPair =
R"doc(Represents a closed graph manifold formed by joining two bounded
Seifert fibred spaces along a common torus.
Each Seifert fibred space must have just one boundary component,
corresponding to a puncture in the base orbifold (with no fibre-
reversing twist as one travels around this boundary).
The way in which the two spaces are joined is specified by a 2-by-2
matrix *M*. This matrix expresses the locations of the fibres and base
orbifold of the second Seifert fibred space in terms of the first.
More specifically, suppose that *f0* and *o0* are generators of the
common torus, where *f0* represents a directed fibre in the first
Seifert fibred space and *o0* represents the oriented boundary of the
corresponding base orbifold. Likewise, let *f1* and *o1* be generators
of the common torus representing a directed fibre and the base
orbifold of the second Seifert fibred space. Then the curves *f0*,
*o0*, *f1* and *o1* are 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 GraphPair still requires a non-trivial (but constant
sized) amount of data to be copied even in a move operation.)doc";
namespace GraphPair_ {
// Docstring regina::python::doc::GraphPair_::__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::GraphPair_::__copy
static const char *__copy = R"doc(Creates a clone of the given graph manifold.)doc";
// Docstring regina::python::doc::GraphPair_::__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 presentations of the bounded Seifert fibred spaces, 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::GraphPair_::__init
static const char *__init =
R"doc(Creates a new graph manifold as a pair of joined Seifert fibred
spaces. The two bounded Seifert fibred spaces 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``:
One of the given Seifert fibred spaces does not have precisely one
torus boundary, corresponding to a single untwisted puncture in
its base orbifold.
Parameter ``sfs0``:
the first Seifert fibred space.
Parameter ``sfs1``:
the second 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::GraphPair_::__init_2
static const char *__init_2 =
R"doc(Creates a new graph manifold from a pair of bounded Seifert fibred
spaces, which are moved instead of copied.
Other than its use of move semantics, this behaves identically to the
other constructor that takes the Seifert fibred spaces by const
reference. See that constructor for further details.
Precondition:
The given matching matrix has determinant +1 or -1.
Exception ``InvalidArgument``:
One of the given Seifert fibred spaces does not have precisely one
torus boundary, corresponding to a single untwisted puncture in
its base orbifold.
Parameter ``sfs0``:
the first Seifert fibred space.
Parameter ``sfs1``:
the second 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::GraphPair_::__init_3
static const char *__init_3 =
R"doc(Creates a new graph manifold as a pair of joined Seifert fibred
spaces. The two bounded Seifert fibred spaces and the entire 2-by-2
matching matrix are each passed separately.
Precondition:
The given matching matrix has determinant +1 or -1.
Exception ``InvalidArgument``:
One of the given Seifert fibred spaces does not have precisely one
torus boundary, corresponding to a single untwisted puncture in
its base orbifold.
Parameter ``sfs0``:
the first Seifert fibred space.
Parameter ``sfs1``:
the second Seifert fibred space.
Parameter ``matchingReln``:
the 2-by-2 matching matrix.)doc";
// Docstring regina::python::doc::GraphPair_::__init_4
static const char *__init_4 =
R"doc(Creates a new graph manifold from a pair of bounded Seifert fibred
spaces, which are moved instead of copied.
Other than its use of move semantics, this behaves identically to the
other constructor that takes the Seifert fibred spaces by const
reference. See that constructor for further details.
Precondition:
The given matching matrix has determinant +1 or -1.
Exception ``InvalidArgument``:
One of the given Seifert fibred spaces does not have precisely one
torus boundary, corresponding to a single untwisted puncture in
its base orbifold.
Parameter ``sfs0``:
the first Seifert fibred space.
Parameter ``sfs1``:
the second Seifert fibred space.
Parameter ``matchingReln``:
the 2-by-2 matching matrix.)doc";
// Docstring regina::python::doc::GraphPair_::global_swap
static const char *global_swap =
R"doc(Swaps the contents of the two given graph manifolds.
This global routine simply calls GraphPair::swap(); it is provided so
that GraphPair 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::GraphPair_::matchingReln
static const char *matchingReln =
R"doc(Returns a reference to the 2-by-2 matrix describing how the two
Seifert fibred spaces 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::GraphPair_::sfs
static const char *sfs =
R"doc(Returns a reference to one of the two bounded Seifert fibred spaces
that are joined together.
Parameter ``which``:
0 if the first Seifert fibred space is to be returned, or 1 if the
second space is to be returned.
Returns:
a reference to the requested Seifert fibred space.)doc";
// Docstring regina::python::doc::GraphPair_::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
|
