regina 7.3.1.1__cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl

regina/sageRegina/testsuite/callbacks.test

@@ -0,0 +1,281 @@
+# Regina - A Normal Surface Theory Calculator
+# Python Test Suite Component
+#
+# Copyright (c) 2015-2023, Ben Burton
+# For further details contact Ben Burton (bab@debian.org).
+#
+# Tests the use of pure Python functions as C++ callbacks.
+#
+# This file is a single component of Regina's python test suite.  To run
+# the python test suite, move to the main python directory in the source
+# tree and run "make check".
+#
+# 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, write to the Free
+# Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston,
+# MA 02110-1301, USA.
+
+########################################################################
+# Callback actions that we pass to retriangulate() or rewrite():
+########################################################################
+
+def display(sig, tri):
+    # A callback that uses both sig and tri arguments.
+    print('    ' + sig, tri.size())
+    return False
+
+sigs = None
+def collect(sig, tri):
+    # A callback that uses a global variable.
+    global sigs
+    sigs.append(sig)
+
+count = None
+def stopAfter10(sig, tri):
+    # A callback that uses a global variable, and that also uses the
+    # return value to terminate the search.
+    global count
+    count = count + 1
+    return (count >= 10)
+
+########################################################################
+# Callback actions that we pass to enumerateCovers():
+########################################################################
+
+def displayCover(tri, type):
+    t = Triangulation3(tri)
+    t.intelligentSimplify()
+    print('    ' + str(type) + ': ' + t.homology().str())
+
+########################################################################
+# Callback actions that we pass to isomorphism searches:
+########################################################################
+
+isoCount = None
+def stopAfter5Iso(iso):
+    # A callback that uses a global variable, and that also uses the
+    # return value to terminate the search.
+    global isoCount
+    isoCount = isoCount + 1
+    return (isoCount >= 5)
+
+def displayIso(iso):
+    print(iso.detail())
+    return False
+
+########################################################################
+# Full tests that we can run on a triangulation or link:
+########################################################################
+
+def printBanner(name, test, height, threads):
+    print(name + ' -> ' + test + ', height = ' + str(height) + \
+        ', threads = ' + str(threads))
+
+def testDisplay(obj, name, height, threads):
+    printBanner(name, 'display', height, threads)
+    if obj.__class__ == Link:
+        obj.rewrite(height, threads, display)
+    else:
+        obj.retriangulate(height, threads, display)
+
+def testStopAfter10(obj, name, height, threads):
+    printBanner(name, 'stop after 10', height, threads)
+    global count
+    count = 0
+    if obj.__class__ == Link:
+        ans = obj.rewrite(height, threads, stopAfter10)
+    else:
+        ans = obj.retriangulate(height, threads, stopAfter10)
+    if ans:
+        print('    search terminated early, count:', count)
+    else:
+        print('    search ran to completion, count:', count)
+
+def testCollect(obj, name, height, threads):
+    printBanner(name, 'collect', height, threads)
+    global sigs
+    sigs = []
+    if obj.__class__ == Link:
+        ans = obj.rewrite(height, threads, collect)
+    else:
+        ans = obj.retriangulate(height, threads, collect)
+    sigs.sort()
+    for i in sigs:
+        print('    ' + i)
+
+def testCovers(link, name, sheets):
+    print(name + ' -> all covers, sheets = ' + str(sheets))
+    tri = SnapPeaTriangulation(link.complement())
+    tri.enumerateCovers(sheets, SnapPeaTriangulation.all_covers, displayCover)
+
+def testIso(inner, innerName, outer, outerName, countOnly = False):
+    comp = innerName + ' vs ' + outerName
+    if not countOnly:
+        print(comp + ' -> isomorphisms, display')
+        inner.findAllIsomorphisms(outer, displayIso)
+        print(comp + ' -> subcomplexes, display')
+        inner.findAllSubcomplexesIn(outer, displayIso)
+    
+    global isoCount
+    print(comp + ' -> isomorphisms, stop after 5')
+    isoCount = 0
+    ans = inner.findAllIsomorphisms(outer, stopAfter5Iso)
+    if ans:
+        print('    search terminated early, count:', isoCount)
+    else:
+        print('    search ran to completion, count:', isoCount)
+    print(comp + ' -> subcomplexes, stop after 5')
+    
+    isoCount = 0
+    ans = inner.findAllSubcomplexesIn(outer, stopAfter5Iso)
+    if ans:
+        print('    search terminated early, count:', isoCount)
+    else:
+        print('    search ran to completion, count:', isoCount)
+
+########################################################################
+# Individual test cases:
+########################################################################
+
+tri = Example3.poincare()
+testDisplay(tri, 'Poincare homology sphere', 1, 1)
+testDisplay(tri, 'Poincare homology sphere', 1, 2)
+testStopAfter10(tri, 'Poincare homology sphere', 1, 1)
+testStopAfter10(tri, 'Poincare homology sphere', 1, 2)
+testCollect(tri, 'Poincare homology sphere', 1, 1)
+testCollect(tri, 'Poincare homology sphere', 1, 2)
+testIso(tri, 'Poincare homology sphere', tri, 'Poincare homology sphere', True)
+print()
+
+tri = Example3.weeks()
+testDisplay(tri, 'Weeks manifold', 0, 1)
+testDisplay(tri, 'Weeks manifold', 0, 2)
+testStopAfter10(tri, 'Weeks manifold', 1, 1)
+testStopAfter10(tri, 'Weeks manifold', 1, 2)
+testCollect(tri, 'Weeks manifold', 0, 1)
+testCollect(tri, 'Weeks manifold', 0, 2)
+testIso(tri, 'Weeks manifold', tri, 'Weeks manifold')
+print()
+
+tri = Example4.cappellShaneson()
+testDisplay(tri, 'Cappell-Shaneson knot complement', 0, 1)
+testDisplay(tri, 'Cappell-Shaneson knot complement', 0, 2)
+testStopAfter10(tri, 'Cappell-Shaneson knot complement', 2, 1)
+testStopAfter10(tri, 'Cappell-Shaneson knot complement', 2, 2)
+testCollect(tri, 'Cappell-Shaneson knot complement', 2, 1)
+testCollect(tri, 'Cappell-Shaneson knot complement', 2, 2)
+testIso(tri, 'Cappell-Shaneson knot complement', tri, 'Cappell-Shaneson knot complement')
+print()
+
+inner = Example3.lst(1,2)
+outer = Example3.lens(8,3)
+testIso(inner, 'LST(1,2,3)', outer, 'L(8,3)')
+print()
+
+link = ExampleLink.trefoil()
+testDisplay(link, 'Trefoil', 0, 1)
+testDisplay(link, 'Trefoil', 0, 2)
+print()
+
+link = ExampleLink.figureEight()
+testStopAfter10(link, 'Figure eight knot', 1, 1)
+testStopAfter10(link, 'Figure eight knot', 1, 2)
+testCollect(link, 'Figure eight knot', 1, 1)
+testCollect(link, 'Figure eight knot', 1, 2)
+print()
+
+link = ExampleLink.monster()
+testStopAfter10(link, 'Monster unknot', 1, 1)
+testStopAfter10(link, 'Monster unknot', 1, 2)
+print()
+
+link = ExampleLink.trefoil()
+testCovers(link, 'Trefoil', 2)
+testCovers(link, 'Trefoil', 3)
+testCovers(link, 'Trefoil', 4)
+testCovers(link, 'Trefoil', 5)
+print()
+
+########################################################################
+# Test facet pairing enumeration:
+########################################################################
+
+def displayPairing(f, autos):
+    print('    ' + f.str(), ' -> automorphisms: ', len(autos))
+
+print('Enumerating facet pairings:')
+FacetPairing3.findAllPairings(3, BoolSet(False), 0, displayPairing)
+FacetPairing5.findAllPairings(2, BoolSet(False), 0, displayPairing)
+print()
+
+########################################################################
+# Test splitting surface signature enumeration:
+########################################################################
+
+def displaySig(s, autos):
+    print('    ' + s.str(), ' -> automorphisms: ', len(autos))
+
+print('Enumerating splitting surface signatures:')
+dummy = SigCensus.formCensus(3, displaySig)
+print()
+
+########################################################################
+# Test enumeration of knots:
+########################################################################
+
+def displayKnot(k):
+    print('    ' + k.brief())
+
+print('Enumerating knots:')
+g = ModelLinkGraph.fromPlantri('bcdd,aeec,abfd,acfa,bffb,ceed')
+g.generateMinimalLinks(displayKnot)
+print()
+
+########################################################################
+# Test location of saturated regions:
+########################################################################
+
+def displayRegion(r):
+    print(r.detail())
+    s = SatRegion(r) # this is a non-trivial copy constructor
+    if r.detail() != s.detail():
+        print('ERROR - Does not match:\n' + s.detail())
+
+print('Finding regions:')
+t = Triangulation3.rehydrate('jofdiaabcceffhiiiedkgiilpsw')
+dummy = SatRegion.find(t, False, displayRegion)
+print()
+
+########################################################################
+# Test the non-callback version of SnapPeaTriangulation::enumerateCovers():
+########################################################################
+
+# Now that triangulations are not packets, we cannot use packet listeners
+# to verify the lifetimes of the covers that are returned.  For now just
+# test that the routine seems to do the right thing.
+
+print('Enumerating covers:')
+c = [ (a[0].isoSig(), a[1]) for a in \
+    ExampleSnapPea.whiteheadLink().enumerateCovers(3, \
+    SnapPeaTriangulation.CoverEnumerationType.all_covers) ]
+c.sort()
+for i in c:
+    print('  ' + i[0], i[1])
+
+print()

regina/sageRegina/testsuite/census.out

@@ -0,0 +1,120 @@
+0:1 0:0 1:0 | 0:2 1:2 1:1
+cMabdd
+cMabcc
+cMabcd
+1:0 1:1 1:2 | 0:0 0:1 0:2
+cPbbaa
+cPbbac
+cPbbbe
+cPbbde
+
+0:1 0:0 1:0 | 0:2 1:2 1:1
+cMabdd
+cMabcc
+cMabcd
+1:0 1:1 1:2 | 0:0 0:1 0:2
+cPbbaa
+cPbbac
+cPbbbe
+cPbbde
+
+0:1 0:0 1:0 | 0:2 1:2 1:1
+cMabdd
+cMabcc
+cMabcd
+1:0 1:1 1:2 | 0:0 0:1 0:2
+cPbbaa
+cPbbac
+cPbbbe
+cPbbde
+
+0:1 0:0 1:0 1:1 | 0:2 0:3 1:3 1:2
+cMcabbjqw
+cMcabbjxr
+cMcabbjaj
+cMcabbjak
+cMcabbjqs
+cMcabbgqw
+cMcabbgaj
+1:0 1:1 1:2 1:3 | 0:0 0:1 0:2 0:3
+cPcbbbqxh
+
+0:1 0:0 1:0 1:1 | 0:2 0:3 1:3 1:2
+cMcabbjqw
+cMcabbjxr
+cMcabbjaj
+cMcabbjak
+cMcabbjqs
+cMcabbgqw
+cMcabbgaj
+1:0 1:1 1:2 1:3 | 0:0 0:1 0:2 0:3
+cPcbbbqxh
+
+0:1 0:0 1:0 1:1 | 0:2 0:3 1:3 1:2
+cMcabbjqw
+cMcabbjxr
+cMcabbjaj
+cMcabbjak
+cMcabbjqs
+cMcabbgqw
+cMcabbgaj
+1:0 1:1 1:2 1:3 | 0:0 0:1 0:2 0:3
+cPcbbbqxh
+
+0:1 0:0 0:3 0:2 1:0 | 0:4 1:2 1:1 1:4 1:3
+cAkaabb2aoa2aoa
+cAkaabb+aoaqbga
+cAkaabb+aoa+aoa
+cAkaabb+a+a+a+a
+cAkaabb+aKa+aKa
+0:1 0:0 1:0 1:1 1:2 | 0:2 0:3 0:4 1:4 1:3
+cMkabbb2a-ataqb
+cMkabbb2aHaua2a
+cMkabbb2a4aaaca
+cMkabbb+aaa0bPb
+cMkabbb2aaaaa2a
+cMkabbb+aAa3blb
+cMkabbb+aaaaa+a
+1:0 1:1 1:2 1:3 1:4 | 0:0 0:1 0:2 0:3 0:4
+cPkbbbbaaaaaaaa
+cPkbbbb4aaaaa4a
+cPkbbbb-a-a-aUa
+
+0:1 0:0 0:3 0:2 1:0 | 0:4 1:2 1:1 1:4 1:3
+cAkaabb2aoa2aoa
+cAkaabb+aoaqbga
+cAkaabb+aoa+aoa
+cAkaabb+a+a+a+a
+cAkaabb+aKa+aKa
+0:1 0:0 1:0 1:1 1:2 | 0:2 0:3 0:4 1:4 1:3
+cMkabbb2a-ataqb
+cMkabbb2aHaua2a
+cMkabbb2a4aaaca
+cMkabbb+aaa0bPb
+cMkabbb2aaaaa2a
+cMkabbb+aAa3blb
+cMkabbb+aaaaa+a
+1:0 1:1 1:2 1:3 1:4 | 0:0 0:1 0:2 0:3 0:4
+cPkbbbbaaaaaaaa
+cPkbbbb4aaaaa4a
+cPkbbbb-a-a-aUa
+
+0:1 0:0 0:3 0:2 1:0 | 0:4 1:2 1:1 1:4 1:3
+cAkaabb2aoa2aoa
+cAkaabb+aoaqbga
+cAkaabb+aoa+aoa
+cAkaabb+a+a+a+a
+cAkaabb+aKa+aKa
+0:1 0:0 1:0 1:1 1:2 | 0:2 0:3 0:4 1:4 1:3
+cMkabbb2a-ataqb
+cMkabbb2aHaua2a
+cMkabbb2a4aaaca
+cMkabbb+aaa0bPb
+cMkabbb2aaaaa2a
+cMkabbb+aAa3blb
+cMkabbb+aaaaa+a
+1:0 1:1 1:2 1:3 1:4 | 0:0 0:1 0:2 0:3 0:4
+cPkbbbbaaaaaaaa
+cPkbbbb4aaaaa4a
+cPkbbbb-a-a-aUa
+

regina/sageRegina/testsuite/census.test

@@ -0,0 +1,157 @@
+# Regina - A Normal Surface Theory Calculator
+# Python Test Suite Component
+#
+# Copyright (c) 2007-2023, Ben Burton
+# For further details contact Ben Burton (bab@debian.org).
+#
+# Tests the census generation code.
+#
+# This file is a single component of Regina's python test suite.  To run
+# the python test suite, move to the main python directory in the source
+# tree and run "make check".
+#
+# 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, write to the Free
+# Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston,
+# MA 02110-1301, USA.
+
+s = None
+partial = None
+
+#######################################################################
+
+def foundGluings2(g):
+	print(g.triangulate().isoSig())
+
+def auto2(p, isos):
+	print(p.str())
+	GluingPermSearcher2.findAllPerms(p, isos, False, foundGluings2)
+
+def best2(p, isos):
+	print(p.str())
+	b = GluingPermSearcher2.bestSearcher(p, isos, False)
+	b.runSearch(foundGluings2)
+
+FacetPairing2.findAllPairings(2, False, 0, auto2)
+print()
+FacetPairing2.findAllPairings(2, False, 0, best2)
+print()
+
+def foundPartial2(g):
+	if s.isComplete():
+		print('Depth too large: found complete set')
+	partial.append(s.taggedData())
+
+def partial2(p, isos):
+	global s, partial
+	print(p.str())
+	
+	partial = []
+	s = GluingPermSearcher2(p, isos, False)
+	s.partialSearch(2, foundPartial2)
+	for i in partial:
+		s = GluingPermSearcher2.fromTaggedData(i)
+		s.runSearch(foundGluings2)
+
+FacetPairing2.findAllPairings(2, False, 0, partial2)
+print()
+
+#######################################################################
+
+def foundGluings3(g):
+	t = g.triangulate()
+	# Note: intelligentSimplify might reduce vertices but keep the
+	# same number of tetrahedra.
+	if not t.intelligentSimplify():
+		print(t.isoSig())
+
+def auto3(p, isos):
+	print(p.str())
+	GluingPermSearcher3.findAllPerms(p, isos, True, True, PURGE_NON_MINIMAL, \
+		foundGluings3)
+
+def best3(p, isos):
+	print(p.str())
+	b = GluingPermSearcher3.bestSearcher(p, isos, True, True, PURGE_NON_MINIMAL)
+	b.runSearch(foundGluings3)
+
+FacetPairing3.findAllPairings(2, False, 0, auto3)
+print()
+FacetPairing3.findAllPairings(2, False, 0, best3)
+print()
+
+def foundPartial3(g):
+	if s.isComplete():
+		print('Depth too large: found complete set')
+	partial.append(s.taggedData())
+
+def partial3(p, isos):
+	global s, partial
+	print(p.str())
+	
+	partial = []
+	s = CompactSearcher(p, isos, True, PURGE_NON_MINIMAL)
+	s.partialSearch(2, foundPartial3)
+	for i in partial:
+		s = GluingPermSearcher3.fromTaggedData(i)
+		s.runSearch(foundGluings3)
+
+FacetPairing3.findAllPairings(2, False, 0, partial3)
+print()
+
+#######################################################################
+
+def foundGluings4(g):
+	print(g.triangulate().isoSig())
+
+def auto4(p, isos):
+	print(p.str())
+	GluingPermSearcher4.findAllPerms(p, isos, True, True, foundGluings4)
+
+def best4(p, isos):
+	print(p.str())
+	b = GluingPermSearcher4.bestSearcher(p, isos, True, True)
+	b.runSearch(foundGluings4)
+
+FacetPairing4.findAllPairings(2, False, 0, auto4)
+print()
+FacetPairing4.findAllPairings(2, False, 0, best4)
+print()
+
+def foundPartial4(g):
+	if s.isComplete():
+		print('Depth too large: found complete set')
+	partial.append(s.taggedData())
+
+def partial4(p, isos):
+	global s, partial
+	print(p.str())
+	
+	partial = []
+	s = GluingPermSearcher4(p, isos, True, True)
+	s.partialSearch(2, foundPartial4)
+	for i in partial:
+		s = GluingPermSearcher4.fromTaggedData(i)
+		s.runSearch(foundGluings4)
+
+FacetPairing4.findAllPairings(2, False, 0, partial4)
+print()
+
+#######################################################################
+

regina/sageRegina/testsuite/clone.out

@@ -0,0 +1,18 @@
+True
+True
+True
+True
+True
+True
+True
+True
+True
+True
+True
+True
+True
+True
+True
+True
+True
+True

regina/sageRegina/testsuite/clone.test

@@ -0,0 +1,101 @@
+# Regina - A Normal Surface Theory Calculator
+# Python Test Suite Component
+#
+# Copyright (c) 2015-2023, Ben Burton
+# For further details contact Ben Burton (bab@debian.org).
+#
+# Tests the behaviour of the packet cloning functions.
+#
+# This file is a single component of Regina's python test suite.  To run
+# the python test suite, move to the main python directory in the source
+# tree and run "make check".
+#
+# 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, write to the Free
+# Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston,
+# MA 02110-1301, USA.
+
+root = Container()
+
+# Note: Since Regina 7.0, when cloning a packet tree, the cloned surface
+# lists point to the *original* triangulations.
+
+# 3-D surface test:
+
+tri = PacketOfTriangulation3(Example3.poincare())
+list = PacketOfNormalSurfaces(tri, NS_STANDARD)
+tri.append(list)
+root.append(tri)
+
+tri2 = tri.cloneAsSibling(True)
+list2 = tri2.firstChild()
+
+s = list.surface(0)
+s2 = list2.surface(0)
+
+print(tri.samePacket(list.triangulation().packet()))
+print(tri.samePacket(list2.triangulation().packet()))
+print(not tri2.samePacket(list2.triangulation().packet()))
+
+print(tri.samePacket(s.triangulation().packet()))
+print(tri.samePacket(s2.triangulation().packet()))
+print(not tri2.samePacket(s2.triangulation().packet()))
+
+# 4-D hypersurface test:
+
+tri = PacketOfTriangulation4(Example4.s3xs1())
+list = PacketOfNormalHypersurfaces(tri, HS_STANDARD)
+tri.append(list)
+root.append(tri)
+
+tri2 = tri.cloneAsSibling(True)
+list2 = tri2.firstChild()
+
+s = list.hypersurface(0)
+s2 = list2.hypersurface(0)
+
+print(tri.samePacket(list.triangulation().packet()))
+print(tri.samePacket(list2.triangulation().packet()))
+print(not tri2.samePacket(list2.triangulation().packet()))
+
+print(tri.samePacket(s.triangulation().packet()))
+print(tri.samePacket(s2.triangulation().packet()))
+print(not tri2.samePacket(s2.triangulation().packet()))
+
+# Angle structure test:
+
+tri = PacketOfTriangulation3(Example3.whiteheadLink())
+list = PacketOfAngleStructures(tri)
+tri.append(list)
+root.append(tri)
+
+tri2 = tri.cloneAsSibling(True)
+list2 = tri2.firstChild()
+
+s = list.structure(0)
+s2 = list2.structure(0)
+
+print(tri.samePacket(list.triangulation().packet()))
+print(tri.samePacket(list2.triangulation().packet()))
+print(not tri2.samePacket(list2.triangulation().packet()))
+
+print(tri.samePacket(s.triangulation().packet()))
+print(tri.samePacket(s2.triangulation().packet()))
+print(not tri2.samePacket(s2.triangulation().packet()))
+

regina/sageRegina/testsuite/constructors.out

@@ -0,0 +1,14 @@
+0 a
+2 cPcbbbiht
+2 cPcbbbiht
+4 eLPkbdcddhgggb
+4 eLPkbdcddhgggb
+2 cPcbbbiht
+2 cPcbbbiht
+2 cPcbbbiht
+Could not construct
+2 cPcbbbiht
+Invalid constructor arguments
+Invalid constructor arguments
+Could not construct
+Invalid constructor arguments