snappy 3.0.3__cp38-cp38-macosx_11_0_arm64.whl → 3.2__cp38-cp38-macosx_11_0_arm64.whl

snappy/snap/t3mlite/spun.py

@@ -6,23 +6,25 @@ of it (though depending very much on snappy), except for borrowing
 some linear algebra code.
 """
 
-import snappy, FXrays
-if snappy._within_sage:
-    from sage.all import gcd
-    from sage.all import vector as Vector
-    from sage.all import matrix as Matrix
+import FXrays
+
+from ...sage_helper import _within_sage
+if _within_sage:
+    from ...sage_helper import vector as Vector, matrix as Matrix, gcd
 else:
     from snappy.snap.t3mlite.linalg import Vector, Matrix, gcd
 
+
 def weak_normalize_slope(slope):
     """For a tuple (a, b), scale it so that gcd(a,b)=1"""
-    a, b = [int(s) for s in slope]
+    a, b = (int(s) for s in slope)
     if a == b == 0:
         return (0, 0)
     g = gcd(a,b)
     a, b = a//g, b//g
     return (a,b)
 
+
 def normalize_slope(slope):
     """
     For a tuple (a, b), scale it so that gcd(a,b)=1 and it lies in the
@@ -40,17 +42,19 @@ def normalize_slope(slope):
     """
     a, b = weak_normalize_slope(slope)
     if a == b == 0:
-        return (0, 0) 
+        return (0, 0)
     if a < 0:
         a, b = -a, -b
     elif a == 0 and b < 0:
         b = -b
     return (a,b)
 
+
 def shift_matrix(n):
     """
     The edge shifts corresponding to each of three quad types, see Figure
-    2.1 and 2.2 of `[DG] <http://arxiv.org/abs/1102.4588>`_
+    2.1 and 2.2 of
+    `Dunfield and Garoufalidis '12 <http://arxiv.org/abs/1102.4588>`_.
     """
     shifts = Matrix(3*n, 3*n)
     for i in range(0, 3*n, 3):
@@ -59,11 +63,12 @@ def shift_matrix(n):
             shifts[i+j, i+((j+1) % 3)] = -1
     return shifts
 
+
 def quad_vector_to_type_and_coeffs(quad_vector):
     """
     For an n-tetrahedra manifold, take a full quad vector
     of length 3n and store the quad type and weight for
-    each tetrahedron.  
+    each tetrahedron.
     """
     quad_types, coefficients = [], []
     quad_vector = list(quad_vector)
@@ -81,25 +86,26 @@ def quad_vector_to_type_and_coeffs(quad_vector):
 
     return quad_types, Vector(coefficients)
 
+
 class SpunSurface:
     """
     A spun normal surface in an ideal triangulation, as introduced by
     Thurston.
 
-    For an quick sketch of this theory see `[DG]
+    For an quick sketch of this theory see `Dunfield and Garoufalidis '12
     <http://arxiv.org/abs/1102.4588>`_ and for more details see
-    `[Tillmann] <http://arxiv.org/abs/math/0406271>`_.
+    `Tillmann '08 <http://arxiv.org/abs/math/0406271>`_.
 
     The quad conventions are (Q02, Q03, Q01) corresponding to
     z -> 0, z' -> 0, and z'' -> 0 respectively, as per Figure 3.1 of
-    `[DG] <http://arxiv.org/abs/1102.4588>`_.  The quad types
-    are numbered 0, 1, 2; the "None" quad type means a
-    tetrahedron contains no quads at all.  
-    """ 
+    `Dunfield and Garoufalidis '12 <http://arxiv.org/abs/1102.4588>`_.
+    The quad types are numbered 0, 1, 2; the "None" quad type means a
+    tetrahedron contains no quads at all.
+    """
     def __init__(self, manifold, quad_vector=None, quad_types=None, index=None):
         self._manifold = manifold
-        self._index=index
-        if quad_types != None:
+        self._index = index
+        if quad_types is not None:
             coefficients = quad_vector
             quad_vector = []
             for c, q in zip(coefficients, quad_types):
@@ -132,11 +138,11 @@ class SpunSurface:
         return True
 
     def __radd__(self, other):
-        if other==0:
+        if other == 0:
             return self
 
     def __add__(self, other):
-        if other==0:
+        if other == 0:
             return self
         if not self.is_compatible(other):
             raise ValueError('Normal surfaces are not compatible')
@@ -146,6 +152,7 @@ class SpunSurface:
         return "<Surface %s: %s %s %s>" % (self._index, self._quad_types,
                                            list(self._coefficients), tuple(self._boundary_slopes))
 
+
 class SpunNormalSurfaceEquations:
     def __init__(self, manifold):
         self.manifold = manifold
@@ -174,7 +181,10 @@ class SpunNormalSurfaceEquations:
             T = regina.Triangulation3(M._to_string())
             ans = []
             tets = range(M.num_tetrahedra())
-            surfaces = regina.NormalSurfaces.enumerate(T, regina.NS_QUAD)
+            if hasattr(regina.NormalSurfaces, 'enumerate'):
+                surfaces = regina.NormalSurfaces.enumerate(T, regina.NS_QUAD)
+            else:
+                surfaces = regina.NormalSurfaces(T, regina.NS_QUAD)
             for i in range(surfaces.size()):
                 S = surfaces.surface(i)
                 coeff_vector = [int(S.quads(tet, quad).stringValue())
@@ -184,7 +194,6 @@ class SpunNormalSurfaceEquations:
         else:
             raise ValueError("Algorithm should be one of {'FXrays', 'regina'}")
 
-
     def is_solution(self, quad_vector):
         return self.quad_equations * quad_vector == 0
 
@@ -192,16 +201,16 @@ class SpunNormalSurfaceEquations:
         return self.slope_matrix*self.shift_matrix*quad_vector
 
 
-
 # The following methods get monkey patched into the manifold
-# classes.  
+# classes.
 
 def _normal_surface_equations(self):
     name = '_normal_surface_equations'
     if name not in self._cache:
         eqns = SpunNormalSurfaceEquations(self)
         self._cache[name] = SpunNormalSurfaceEquations(self)
-    return self._cache[name] 
+    return self._cache[name]
+
 
 def normal_surfaces(self, algorithm='FXrays'):
     """
@@ -220,6 +229,7 @@ def normal_surfaces(self, algorithm='FXrays'):
                                           for i, qv in enumerate(eqns.vertex_solutions(algorithm))]
     return self._cache['normal_surfaces']
 
+
 def normal_boundary_slopes(self, subset='all', algorithm='FXrays'):
     """
     For a one-cusped manifold, returns all the nonempty boundary slopes of
@@ -235,9 +245,9 @@ def normal_boundary_slopes(self, subset='all', algorithm='FXrays'):
 
     If the ``subset`` flag is set to ``'kabaya'``, then it only
     returns boundary slopes associated to vertex surfaces with a quad
-    in every tetrahedron; by Theorem 1.1. of `[DG]
-    <http://arxiv.org/abs/1102.4588>`_ these are all strict boundary
-    slopes.
+    in every tetrahedron; by Theorem 1.1. of
+    `Dunfield and Garoufalidis '12 <http://arxiv.org/abs/1102.4588>`_
+    these are all strict boundary slopes.
 
     >>> N = Manifold('m113')
     >>> N.normal_boundary_slopes()
@@ -275,11 +285,13 @@ def normal_boundary_slopes(self, subset='all', algorithm='FXrays'):
         if subset != 'all':
             raise ValueError("Subset must be one of 'all', 'kabaya', or 'brasile'")
 
-    slopes = set([normalize_slope(S.boundary_slopes()) for S in surfaces])
-    slopes.discard( (0, 0) )
+    slopes = {normalize_slope(S.boundary_slopes()) for S in surfaces}
+    slopes.discard((0, 0))
     return sorted(slopes)
 
+
 if __name__ == "__main__":
     import doctest
-    names = {'Manifold':snappy.Manifold}
+    import snappy
+    names = {'Manifold': snappy.Manifold}
     doctest.testmod(extraglobs=names)

snappy/snap/t3mlite/surface.py

@@ -1,7 +1,7 @@
 #   t3m - software for studying triangulated 3-manifolds
 #   Copyright (C) 2002 Marc Culler, Nathan Dunfield and others
 #
-#   This program is distributed under the terms of the 
+#   This program is distributed under the terms of the
 #   GNU General Public License, version 2 or later, as published by
 #   the Free Software Foundation.  See the file GPL.txt for details.
 
@@ -38,7 +38,7 @@ from .linalg import Vector, Matrix
 # NOTE (3) Our plan is to create (at least) three subclasses of the
 # Surface class: Closed_Surface, Spun_Surface, Bounded_Surface.
 
-#Incidence dictionaries for quads, triangles and octagons
+# Incidence dictionaries for quads, triangles and octagons
 
 MeetsQuad = {E01:Vector((1,1,0)), E02:Vector((1,0,1)), E21:Vector((0,1,1)),
              E32:Vector((1,1,0)), E31:Vector((1,0,1)), E03:Vector((0,1,1))}
@@ -46,8 +46,8 @@ MeetsQuad = {E01:Vector((1,1,0)), E02:Vector((1,0,1)), E21:Vector((0,1,1)),
 MeetsTri = {E01:Vector((1,1,0,0)), E02:Vector((1,0,1,0)), E21:Vector((0,1,1,0)),
             E32:Vector((0,0,1,1)), E31:Vector((0,1,0,1)), E03:Vector((1,0,0,1))}
 
-MeetsOct =  {E01:Vector((1,1,2)), E02:Vector((1,2,1)), E21:Vector((2,1,1)),
-             E32:Vector((1,1,2)), E31:Vector((1,2,1)), E03:Vector((2,1,1))}
+MeetsOct = {E01:Vector((1,1,2)), E02:Vector((1,2,1)), E21:Vector((2,1,1)),
+            E32:Vector((1,1,2)), E31:Vector((1,2,1)), E03:Vector((2,1,1))}
 
 DisjointQuad = {E01:2, E02:1, E21:0,
                 E32:2, E31:1, E03:0}
@@ -56,7 +56,7 @@ QuadWeights = (Vector((1,0,0)), Vector((0,1,0)), Vector((0,0,1)) )
 
 WeightVector = Vector([1,1,1])
 
-TypeVector = Vector([0,1,2]) 
+TypeVector = Vector([0,1,2])
 
 # Used for converting normal surface into tetrahedron edge-shift data.
 # QuadShift[k] is the shifts induced by quad Qk3 along edges (E03, E13, E23).
@@ -71,6 +71,7 @@ NonInteger = 'Error'
 
 # NOTE: The convention is that the order of the quads is (Q03, Q13, Q23)
 
+
 def gcd(x, y):
     if x == 0:
         if y == 0:
@@ -80,11 +81,12 @@ def gcd(x, y):
     x = abs(x)
     y = abs(y)
     while y != 0:
-        r = x%y
+        r = x % y
         x = y
         y = r
     return x
 
+
 def reduce_slope( slope ):
     a, b = slope
     if a == b == 0:
@@ -93,6 +95,7 @@ def reduce_slope( slope ):
     a, b = a/g, b/g
     return (a,b), g
 
+
 class Surface:
 
     def __init__(self, manifold, quadvector):
@@ -126,7 +129,7 @@ class Surface:
         indices of those edges for which the Surface contains an edge-linking
         annulus (and hence has an obvious compression).
         """
-        if not self in manifold.NormalSurfaces:
+        if self not in manifold.NormalSurfaces:
             raise ValueError('That manifold does not contain the Surface!')
         linked_edges = []
         for edge in manifold.Edges:
@@ -134,14 +137,14 @@ class Surface:
             for corner in edge.Corners:
                 quad = DisjointQuad[corner.Subsimplex]
                 if ( self.Coefficients[corner.Tetrahedron.Index] == 0 or
-                     self.Quadtypes[corner.Tetrahedron.Index] != quad ): 
+                     self.Quadtypes[corner.Tetrahedron.Index] != quad ):
                     is_linked = 0
                     break
             if is_linked:
                 linked_edges.append(edge.Index)
         return linked_edges
 
-    def info(self, out = sys.stdout):
+    def info(self, out=sys.stdout):
         if self.type() == "normal":
             out.write("Normal surface\n")
         for i in range(self.Size):
@@ -152,7 +155,8 @@ class Surface:
                 weight = "  Quad Type  Q%d3, weight %d" % (self.Quadtypes[i], quad_weight)
             else:
                 weight = "No quads"
-            out.write(weight  + "\n")
+            out.write(weight + "\n")
+
 
 class ClosedSurface(Surface):
 
@@ -248,7 +252,7 @@ class ClosedSurface(Surface):
         x = A.solve(b)
         # Subtract off as many vertex links as possible.
         for vertex in manifold.Vertices:
-            vert_vec = vertex.IncidenceVector 
+            vert_vec = vertex.IncidenceVector
             m = min([x[i] for i, w in enumerate(vert_vec) if w])
             x -= Vector(m*vert_vec)
 
@@ -265,7 +269,6 @@ class ClosedSurface(Surface):
 
         self.EdgeWeights = Matrix(edge_matrix).dot(self.Weights)
 
-
     def find_euler_characteristic(self, manifold):
         # An EdgeValence is the number of tetrahedra that meet the edge.
         # The number of 2-simplices that meet the edge is larger by 1 in
@@ -320,7 +323,6 @@ class ClosedSurface(Surface):
             if not (bounds_subcomplex or double_bounds_subcomplex):
                 break
 
-
         if bounds_subcomplex or double_bounds_subcomplex:
             thick_or_thin = "thin"
             for tet in manifold.Tetrahedra:
@@ -340,7 +342,7 @@ class ClosedSurface(Surface):
 
         self.BoundingInfo = (bounds_subcomplex, double_bounds_subcomplex, thick_or_thin)
 
-###### It is not a torus unless the edge is a loop!
+# It is not a torus unless the edge is a loop!
     # A surface is an edge linking torus iff all edge weights are 2 except one which
     # is zero.  Returns pair (is linking torus, edge it links around).
 
@@ -357,31 +359,31 @@ class ClosedSurface(Surface):
             elif w != 2:
                 return (0, None)
 
-        return (1,  zero_index)
+        return (1, zero_index)
 
-    def info(self, manifold, out = sys.stdout):
+    def info(self, manifold, out=sys.stdout):
         if self.type() == "normal":
             # check if really boring:
             q, e = self.is_edge_linking_torus()
             if q:
                 out.write("Normal surface #%d is thin linking torus of edge %s\n"
-                          %(manifold.NormalSurfaces.index(self), manifold.Edges[e]))
+                          % (manifold.NormalSurfaces.index(self), manifold.Edges[e]))
                 return
             out.write("Normal surface #%d of Euler characteristic %d\n"
-                      %(manifold.NormalSurfaces.index(self), self.EulerCharacteristic))
+                      % (manifold.NormalSurfaces.index(self), self.EulerCharacteristic))
             # additional message about bounding subcomplex
             b, d, t = self.BoundingInfo
             if b == 1:
-                out.write("  Bounds %s subcomplex\n"  % t)
+                out.write("  Bounds %s subcomplex\n" % t)
             elif d == 1:
-                out.write("  Double bounds %s subcomplex\n" %t)
+                out.write("  Double bounds %s subcomplex\n" % t)
             else:
                 out.write("  doesn't bound subcomplex\n")
         else:
             out.write("Almost-normal surface #%d of Euler characteristic %d\n"
-                      % (manifold.AlmostNormalSurfaces.index(self), 
+                      % (manifold.AlmostNormalSurfaces.index(self),
                          self.EulerCharacteristic))
-        out.write('\n') 
+        out.write('\n')
         for i in range(self.Size):
             quad_weight = self.Coefficients[i]
             if quad_weight == -1:
@@ -392,15 +394,15 @@ class ClosedSurface(Surface):
                 weight = "No quads"
             out.write("  In tetrahedron %s :  %s\n" %
                       (manifold.Tetrahedra[i], weight))
-            out.write("\tTri weights V0: %d V1: %d V2 : %d V3 : %d\n" 
-                      % (self.get_weight(i, V0), 
-                         self.get_weight(i, V1), 
+            out.write("\tTri weights V0: %d V1: %d V2 : %d V3 : %d\n"
+                      % (self.get_weight(i, V0),
+                         self.get_weight(i, V1),
                          self.get_weight(i, V2),
                          self.get_weight(i, V3)))
-            out.write('\n') 
+            out.write('\n')
 
         for i in range(len(self.EdgeWeights)):
-            out.write("  Edge %s has weight %d\n" 
+            out.write("  Edge %s has weight %d\n"
                       % (manifold.Edges[i], self.EdgeWeights[i]))
 
     def casson_split(self, manifold):
@@ -413,7 +415,7 @@ class ClosedSurface(Surface):
         complementary manifold.
 
         """
-        M  = manifold
+        M = manifold
         have_quads = [self.has_quad(i) for i in range(len(M))]
         new_tets = {}
         for i in have_quads:
@@ -421,10 +423,10 @@ class ClosedSurface(Surface):
         for i in have_quads:
             T = new_tets[i]
 
-#-----------------end class ClosedSurface---------------------------------------
+# -----------------end class ClosedSurface---------------------------------------
 
 
-#-----------------begin class SpunSurface--------------------------------------
+# -----------------begin class SpunSurface--------------------------------------
 
 def dot_product(x,y):
     assert len(x) == len(y)
@@ -433,6 +435,7 @@ def dot_product(x,y):
         dot += x[i]*y[i]
     return dot
 
+
 class SpunSurface(Surface):
 
     def __init__(self, manifold, quadvector):
@@ -453,10 +456,10 @@ class SpunSurface(Surface):
             raise OverflowError('Yikes! A non-integral euler characteristic!')
         return -int(intresult)
 
-    def info(self, manifold, out = sys.stdout):
+    def info(self, manifold, out=sys.stdout):
         out.write("SpunSurface.\n Slope: %s; Boundary components: %d; " %
                   reduce_slope(self.BoundarySlope))
-        out.write("Euler characteristic: %d\n"%
+        out.write("Euler characteristic: %d\n" %
                   self.find_euler_characteristic(manifold))
         out.write(" Incompressible: %s\n" % self.Incompressible)
         for i in range(self.Size):
@@ -466,10 +469,10 @@ class SpunSurface(Surface):
                           (i, self.Quadtypes[i], quad_weight))
             else:
                 weight = "  Tet %d: no quads" % i
-            out.write(weight  + "\n")
+            out.write(weight + "\n")
 
 
-#-------------begin class ClosedSurfaceInCusped------------------------
+# -------------begin class ClosedSurfaceInCusped------------------------
 
 class ClosedSurfaceInCusped(ClosedSurface):
     def __init__(self, manifold, quadvector):
@@ -477,8 +480,7 @@ class ClosedSurfaceInCusped(ClosedSurface):
         self.Incompressible = None
         self.BoundarySlope = None
 
-
-    def info(self, manifold, out = sys.stdout):
+    def info(self, manifold, out=sys.stdout):
         out.write("ClosedSurfaceInCusped #%d:  Euler %d;  Incompressible %s\n" %
                   (manifold.ClosedSurfaces.index(self), self.EulerCharacteristic, self.Incompressible))
         # check if really boring:
@@ -490,9 +492,9 @@ class ClosedSurfaceInCusped(ClosedSurface):
         # additional message about bounding subcomplex
         b, d, t = self.BoundingInfo
         if b == 1:
-            out.write("  Bounds %s subcomplex\n"  % t)
+            out.write("  Bounds %s subcomplex\n" % t)
         elif d == 1:
-            out.write("  Double bounds %s subcomplex\n" %t)
+            out.write("  Double bounds %s subcomplex\n" % t)
         else:
             out.write("  Doesn't bound subcomplex\n")
 
@@ -505,15 +507,13 @@ class ClosedSurfaceInCusped(ClosedSurface):
 
             out.write("  In tet %s :  %s\n" %
                       (manifold.Tetrahedra[i], weight))
-            out.write("\tTri weights V0: %d V1: %d V2 : %d V3 : %d\n" 
-                      % (self.get_weight(i, V0), 
-                         self.get_weight(i, V1), 
+            out.write("\tTri weights V0: %d V1: %d V2 : %d V3 : %d\n"
+                      % (self.get_weight(i, V0),
+                         self.get_weight(i, V1),
                          self.get_weight(i, V2),
                          self.get_weight(i, V3)))
-            out.write('\n') 
+            out.write('\n')
 
         for i in range(len(self.EdgeWeights)):
-            out.write("  Edge %s has weight %d\n" 
+            out.write("  Edge %s has weight %d\n"
                       % (manifold.Edges[i], self.EdgeWeights[i]))
-
-

snappy/snap/t3mlite/test.py

@@ -1,6 +1,7 @@
 import snappy
 import snappy.snap.t3mlite as t3m
 
+
 def closed_test():
     for M in snappy.OrientableClosedCensus[:10]:
         N = M.filled_triangulation()
@@ -8,10 +9,12 @@ def closed_test():
         T.find_normal_surfaces()
         T.normal_surface_info()
 
+
 def cusped_test():
     for M in snappy.OrientableCuspedCensus[:10]:
         T = t3m.Mcomplex(M)
         T.find_normal_surfaces()
 
+
 closed_test()
 cusped_test()

snappy/snap/t3mlite/test_vs_regina.py

@@ -1,14 +1,16 @@
-from __future__ import print_function 
-import snappy, regina
+import snappy
+import regina
 import snappy.snap.t3mlite as t3m
 import snappy.snap.t3mlite.spun as spun
 
+
 def hash_t3m_surface(surface):
     ans = [surface.EulerCharacteristic]
-    ans += sorted(list(surface.EdgeWeights))
-    ans += sorted(list(surface.Quadvector))
+    ans += sorted(surface.EdgeWeights)
+    ans += sorted(surface.Quadvector)
     return ans
 
+
 def hash_regina_surface(S):
     T = S.getTriangulation()
     t = T.getNumberOfTetrahedra()
@@ -17,19 +19,22 @@ def hash_regina_surface(S):
     ans += sorted([S.getQuadCoord(i, j) for i in range(t) for j in range(3)])
     return ans
 
+
 def to_regina(snappy_manifold):
     return regina.NTriangulation(snappy_manifold._to_string())
 
+
 def vertex_surfaces(regina_triangulation):
     """
     Enumerate the vertex surfaces of the given triangulation
-    in quad coordinates.  
+    in quad coordinates.
     """
     surfaces = regina.NNormalSurfaceList.enumerate(
         regina_triangulation, regina.NS_QUAD)
     for i in range(surfaces.getNumberOfSurfaces()):
         yield surfaces.getSurface(i)
 
+
 def compare_closed(snappy_manifold):
     N = snappy_manifold.filled_triangulation()
 
@@ -43,12 +48,14 @@ def compare_closed(snappy_manifold):
     all_together = sum(t_hashes, [])
     return t_hashes == r_hashes, len(all_together), sum(all_together)
 
+
 def regina_boundary_slope(surface):
     slope = surface.boundaryIntersections()
     a = int(slope.entry(0,0).stringValue())
     b = int(slope.entry(0,1).stringValue())
     return (b, -a)
 
+
 def compare_cusped(snappy_manifold):
     tri_data = snappy_manifold._to_string()
     T = spun.Manifold(tri_data)
@@ -59,24 +66,21 @@ def compare_cusped(snappy_manifold):
     t = R.getNumberOfTetrahedra()
     regina_surfaces = list(vertex_surfaces(R))
     r_hashes = sorted(
-        sorted(sorted(int(S.getQuadCoord(i, j).stringValue())
-                      for i in range(t) for j in range(3)))
+        sorted(int(S.getQuadCoord(i, j).stringValue())
+                      for i in range(t) for j in range(3))
         for S in regina_surfaces)
     r_slopes = sorted(map(regina_boundary_slope, regina_surfaces))
 
     assert t_hashes == r_hashes and t_slopes == r_slopes
 
 
-def closed_test(N = 10):
+def closed_test(N=10):
     for M in snappy.OrientableClosedCensus[:N]:
         print(M, compare_closed(M))
 
-def cusped_test(N = 100):
+
+def cusped_test(N=100):
     for census in [snappy.CensusKnots, snappy.OrientableCuspedCensus(cusps=1)]:
         for M in census:
             print(M)
             compare_cusped(M)
-
-
-
-