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
|
/**************************************************************************
* *
* Regina - A Normal Surface Theory Calculator *
* Python Interface *
* *
* Copyright (c) 1999-2025, 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. *
* *
* As an exception, when this program is distributed through (i) the *
* App Store by Apple Inc.; (ii) the Mac App Store by Apple Inc.; or *
* (iii) Google Play by Google Inc., then that store may impose any *
* digital rights management, device limits and/or redistribution *
* restrictions that are required by its terms of service. *
* *
* 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, see <https://www.gnu.org/licenses/>. *
* *
**************************************************************************/
#include <pybind11/pybind11.h>
#include <pybind11/functional.h>
#include <pybind11/stl.h>
#include "hypersurface/normalhypersurfaces.h"
#include "maths/matrix.h"
#include "progress/progresstracker.h"
#include "triangulation/dim4.h"
#include "../helpers.h"
#include "../docstrings/hypersurface/normalhypersurfaces.h"
using namespace regina::python;
using regina::HyperCoords;
using regina::NormalHypersurface;
using regina::NormalHypersurfaces;
using regina::ProgressTracker;
using regina::Triangulation;
void addNormalHypersurfaces(pybind11::module_& m) {
RDOC_SCOPE_BEGIN_MAIN
m.def("makeMatchingEquations", regina::makeMatchingEquations);
m.def("makeEmbeddedConstraints", regina::makeEmbeddedConstraints);
RDOC_SCOPE_SWITCH(NormalHypersurfaces)
auto l = pybind11::class_<NormalHypersurfaces,
std::shared_ptr<NormalHypersurfaces>>(m, "NormalHypersurfaces",
rdoc_scope)
.def(pybind11::init<const Triangulation<4>&, HyperCoords,
regina::Flags<regina::HyperList>,
regina::Flags<regina::HyperAlg>, ProgressTracker*>(),
pybind11::arg(), pybind11::arg(),
pybind11::arg("which") = regina::HyperList::Default,
pybind11::arg("algHints") = regina::HyperAlg::Default,
pybind11::arg("tracker") = nullptr,
pybind11::call_guard<GILScopedRelease>(),
rdoc::__init)
.def(pybind11::init<const NormalHypersurfaces&>(), rdoc::__copy)
.def("swap", &NormalHypersurfaces::swap, rdoc::swap)
.def("sort", &NormalHypersurfaces::sort<const std::function<
bool(const NormalHypersurface&, const NormalHypersurface&)>&>,
rdoc::sort)
.def("recreateMatchingEquations",
&NormalHypersurfaces::recreateMatchingEquations,
rdoc::recreateMatchingEquations)
.def("coords", &NormalHypersurfaces::coords, rdoc::coords)
.def("which", &NormalHypersurfaces::which, rdoc::which)
.def("algorithm", &NormalHypersurfaces::algorithm, rdoc::algorithm)
.def("allowsNonCompact", &NormalHypersurfaces::allowsNonCompact,
rdoc::allowsNonCompact)
.def("isEmbeddedOnly", &NormalHypersurfaces::isEmbeddedOnly,
rdoc::isEmbeddedOnly)
.def("triangulation", &NormalHypersurfaces::triangulation,
pybind11::return_value_policy::reference_internal,
rdoc::triangulation)
.def("size", &NormalHypersurfaces::size, rdoc::size)
.def("__len__", &NormalHypersurfaces::size, rdoc::size)
.def("hypersurface", &NormalHypersurfaces::hypersurface,
pybind11::return_value_policy::reference_internal,
rdoc::hypersurface)
.def("__getitem__", &NormalHypersurfaces::operator[],
pybind11::return_value_policy::reference_internal, rdoc::__array)
.def("__iter__", [](const NormalHypersurfaces& list) {
return pybind11::make_iterator(list);
}, pybind11::keep_alive<0, 1>(), // iterator keeps list alive
rdoc::__iter__)
.def("vectors", [](const NormalHypersurfaces& list) {
return pybind11::make_iterator(
list.beginVectors(), list.endVectors());
}, pybind11::keep_alive<0, 1>(), // iterator keeps list alive
rdoc::vectors)
;
regina::python::add_output(l);
regina::python::packet_eq_operators(l, rdoc::__eq);
regina::python::add_packet_data(l);
auto wrap = regina::python::add_packet_wrapper<NormalHypersurfaces>(
m, "PacketOfNormalHypersurfaces");
regina::python::add_packet_constructor<const Triangulation<4>&, HyperCoords,
regina::Flags<regina::HyperList>, regina::Flags<regina::HyperAlg>,
ProgressTracker*>(wrap,
pybind11::arg(), pybind11::arg(),
pybind11::arg("which") = regina::HyperList::Default,
pybind11::arg("algHints") = regina::HyperAlg::Default,
pybind11::arg("tracker") = nullptr,
pybind11::call_guard<GILScopedRelease>(),
rdoc::__init);
regina::python::add_global_swap<NormalHypersurfaces>(m, rdoc::global_swap);
RDOC_SCOPE_END
}
|
