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

snappy/snap/t3mlite/tetrahedron.py

@@ -1,31 +1,34 @@
-#$Id: tetrahedron.py,v 1.2 2002/09/20 03:52:16 culler Exp $
+# $Id: tetrahedron.py,v 1.2 2002/09/20 03:52:16 culler Exp $
 #   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.
 
 from .simplex import *
+from .perm4 import Perm4, inv
+
 import sys
 
+
 class Tetrahedron:
-    def __init__(self, name = ''):
+    def __init__(self, name=''):
         self.Index = -1
         self.Name = name
         self.Neighbor = {F0:None,F1:None,F2:None,F3:None}  # Tetrahedra
-        self.Gluing   = {F0:None,F1:None,F2:None,F3:None}  # Permutations
-        self.Class    = [None]*16             # list of equivalence classes
-        self.Checked  = 0                     # flag
+        self.Gluing = {F0:None,F1:None,F2:None,F3:None}  # Permutations
+        self.Class = [None]*16             # list of equivalence classes
+        self.Checked = 0                     # flag
 
     def __repr__(self):
-        if self.Index != -1: 
-            return ( 'tet'+ str(self.Index) )
+        if self.Index != -1:
+            return ( 'tet' + str(self.Index) )
         else:
             return '< floating tetrahedron ' + ' at ' + str(id(self)) + '>'
 
     def attach(self, two_subsimplex, tet, perm_data):
-        if tet == None:
+        if tet is None:
             self.Neighbor[two_subsimplex] = None
             self.Gluing[two_subsimplex] = None
         else:
@@ -34,31 +37,30 @@ class Tetrahedron:
             self.Gluing[two_subsimplex] = perm
             tet.Neighbor[perm.image(two_subsimplex)] = self
             tet.Gluing[perm.image(two_subsimplex)] = inv(self.Gluing[two_subsimplex])
-# Reverse the orientation.  Vertices are relabelled by a transposition
-# and gluings are adjusted.
-#
+
+    # Reverse the orientation.  Vertices are relabelled by a transposition
+    # and gluings are adjusted.
     def reverse(self):
-        transpo = Perm4((1,0,2,3))
+        transpo = Perm4((1, 0, 2, 3))
         nhbr = self.Neighbor.copy()
         gluing = self.Gluing.copy()
         for two_subsimplex in TwoSubsimplices:
             relabeled = transpo.image(two_subsimplex)
-            if not nhbr[two_subsimplex] == None:
-                perm = (gluing[two_subsimplex]*transpo).tuple()
+            if nhbr[two_subsimplex] is not None:
+                perm = (gluing[two_subsimplex] * transpo).tuple()
             else:
                 perm = None
             self.attach(relabeled, nhbr[two_subsimplex], perm)
 
-# Unglues and removes references to self from neighbor.
-#
+    # Unglues and removes references to self from neighbor.
     def detach(self, two_subsimplex):
         neighbor = self.Neighbor[two_subsimplex]
-        if neighbor == None:
+        if neighbor is None:
             return
         neighbors_subsimplex = self.Gluing[two_subsimplex].image(two_subsimplex)
         self.Neighbor[two_subsimplex] = None
         self.Gluing[two_subsimplex] = None
-        if (neighbor.Neighbor and 
+        if (neighbor.Neighbor and
                 neighbor.Neighbor[neighbors_subsimplex] == self):
             neighbor.Neighbor[neighbors_subsimplex] = None
             neighbor.Gluing[neighbors_subsimplex] = None
@@ -72,9 +74,9 @@ class Tetrahedron:
         self.clear_Class()
 
     def clear_Class(self):
-        self.Class    = [None]*16              # list of equivalence classes
+        self.Class = [None]*16              # list of equivalence classes
 
-    def info(self, out = sys.stdout):
+    def info(self, out=sys.stdout):
         if len(self.Name) == 0:
             out.write(repr(self) + "\t%s\n" %
                       ([self.Neighbor.get(s) for s in TwoSubsimplices]))
@@ -84,7 +86,7 @@ class Tetrahedron:
 
         out.write("\t%s\n" % ([self.Gluing.get(s) for s in TwoSubsimplices]))
 
-        out.write("\tVertices: " + repr(self.Class[V0]) 
+        out.write("\tVertices: " + repr(self.Class[V0])
                                  + repr(self.Class[V1])
                                  + repr(self.Class[V2])
                                  + repr(self.Class[V3]) + '\n')
@@ -97,7 +99,7 @@ class Tetrahedron:
             out.write("\tEdges: " + s + '\n')
             s = ""
             for edge in OneSubsimplices[3:]:
-                s = (s + "%s : %-10s   " % 
+                s = (s + "%s : %-10s   " %
                      (SubsimplexName[edge], self.Class[edge]))
             out.write("\t       " + s + '\n')
 
@@ -105,4 +107,3 @@ class Tetrahedron:
 
     def get_orientation_of_edge(self, a, b):
         return self.Class[a | b].orientation_with_respect_to(self, a, b)
-

snappy/snap/t3mlite/vertex.py

@@ -1,16 +1,11 @@
-#$Id: vertex.py,v 1.3 2003/03/07 17:29:28 culler Exp $
+# $Id: vertex.py,v 1.3 2003/03/07 17:29:28 culler Exp $
 #   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.
 
-from .simplex import *
-from .tetrahedron import *
-from .corner import *
-from .edge import *
-
 class Vertex:
     def __init__(self):
         self.Index = -1
@@ -19,9 +14,10 @@ class Vertex:
         self.Edges = []        # incident Edges
         # An Edge will appear twice if both its endpoints
         # are equal to this Vertex
+
     def __repr__(self):
         if self.Index > -1:
-            return ('v' + str(self.Index) 
+            return ('v' + str(self.Index)
                     + ' (' + self.IntOrBdry + ') ')
         else:
             return '< floating vertex' + str(id(self)) + ' >'
@@ -36,12 +32,11 @@ class Vertex:
                 pass
         self.Index = -1
 
-
-# The link of a vertex in an Mcomplex is a surface
-# of arbitrary genus, possibly with non-empty boundary.
-# For now I am pretending that links are closed and orientable
     def link_genus(self):
+        # The link of a vertex in an Mcomplex is a surface
+        # of arbitrary genus, possibly with non-empty boundary.
+        # For now I am pretending that links are closed and orientable
         sum = 12
         for edge in self.Edges:
             sum = sum - 6 + edge.valence()
-        return sum/12
+        return sum//12

snappy/snap/test.py

@@ -1,16 +1,47 @@
-from __future__ import print_function
-from ..sage_helper import _within_sage, doctest_modules
-from ..pari import pari
+from snappy import testing
 import snappy
-import snappy.snap as snap
-import doctest, collections, getopt, sys
+
+from snappy.sage_helper import _within_sage
+from snappy.pari import pari
+
+from snappy import snap
+
+modules = [
+    snap,
+    snap.t3mlite.linalg,
+    snap.t3mlite.mcomplex,
+    snap.t3mlite.perm4,
+    snap.t3mlite.spun,
+    snap.character_varieties,
+    snap.slice_obs_HKL,
+    snap.nsagetools,
+    snap.polished_reps,
+    snap.interval_reps,
+    snap.fundamental_polyhedron,
+    snap.peripheral.dual_cellulation,
+    snap.peripheral.link,
+    snap.peripheral.peripheral
+]
+
+def run_doctests(verbose=False, print_info=True):
+    globs = {'Manifold':snappy.Manifold,
+             'ManifoldHP':snappy.ManifoldHP,
+             'Triangulation':snappy.Triangulation,
+             'Mcomplex':snappy.snap.t3mlite.Mcomplex,
+             'LinkSurface':snappy.snap.peripheral.link.LinkSurface}
+    return testing.doctest_modules(modules,
+                                   verbose=verbose,
+                                   print_info=print_info,
+                                   extraglobs=globs)
+
+run_doctests.__name__ = snap.__name__
 
 def _test_gluing_equations(manifold, shapes):
     """
     Given a manifold and exact shapes, test whether the rectangular gluing
     equations are fulfilled.
     """
-    one_minus_shapes = [ 1 - shape for shape in shapes ]
+    one_minus_shapes = [1 - shape for shape in shapes]
     for A, B, c in manifold.gluing_equations('rect'):
         val = c
         for a, shape in zip(A, shapes):
@@ -21,6 +52,7 @@ def _test_gluing_equations(manifold, shapes):
             return False
     return True
 
+
 def test_polished(dec_prec=200):
     def test_manifold(manifold):
         eqns = manifold.gluing_equations('rect')
@@ -28,18 +60,19 @@ def test_polished(dec_prec=200):
         return snap.shapes.gluing_equation_error(eqns, shapes)
 
     def test_census(name, census):
-        manifolds = [M for M in census]
+        manifolds = list(census)
         print('Checking gluing equations for %d %s manifolds' % (len(manifolds), name))
         max_error = pari(0)
         for i, M in enumerate(manifolds):
             max_error = max(max_error, test_manifold(M))
-            print('\r   ' + repr( (i, M) ).ljust(35) + '   Max error so far: %.2g' % float(max_error), end = '')
+            print('\r   ' + repr( (i, M) ).ljust(35) + '   Max error so far: %.2g' % float(max_error), end='')
         print()
 
     test_census('cusped census', snappy.OrientableCuspedCensus(filter='cusps>1')[-100:])
     test_census('closed census', snappy.OrientableClosedCensus()[-100:])
     test_census('4-component links', [M for M in snappy.LinkExteriors(num_cusps=4) if M.solution_type() == 'all tetrahedra positively oriented'])
 
+
 def test_holonomy(dec_prec=200):
     def test_manifold(manifold):
         # This has several internal checks which raise exceptions
@@ -51,6 +84,7 @@ def test_holonomy(dec_prec=200):
         for manifold in census()[-100:]:
             test_manifold(manifold)
 
+
 def test_fields(bits_prec=200, degree=20):
     for census in [snappy.OrientableCuspedCensus, snappy.OrientableClosedCensus]:
         print('Fields of 100 manifolds in ', census)
@@ -78,6 +112,7 @@ def test_fields(bits_prec=200, degree=20):
                             print('Problem with', manifold,
                                   '(gluing equations violated)')
 
+
 def test_ZHS(bits_prec=500, degree=20):
     for manifold in snappy.OrientableClosedCensus:
         if manifold.homology().order() == 1:
@@ -88,54 +123,12 @@ def test_ZHS(bits_prec=500, degree=20):
             else:
                 print(manifold, ans)
 
+
 def big_test():
     test_polished()
     if _within_sage:
         test_holonomy()
         test_fields()
 
-
-def run_doctests(verbose=False, print_info=True):
-    from snappy.snap.t3mlite import linalg
-    from snappy.snap.t3mlite import spun
-    from snappy.snap.t3mlite import mcomplex
-    from snappy.snap import slice_obs_HKL
-    from snappy.snap import character_varieties
-    from snappy.snap import nsagetools
-    from snappy.snap import polished_reps
-    from snappy.snap import interval_reps
-    from snappy.snap import fundamental_polyhedron
-    from snappy.snap.peripheral import dual_cellulation
-    from snappy.snap.peripheral import link
-    from snappy.snap.peripheral import peripheral
-
-    modules = [
-        mcomplex,
-        linalg,
-        spun,
-        character_varieties,
-        nsagetools,
-        slice_obs_HKL,
-        polished_reps,
-        snap,
-        interval_reps,
-        fundamental_polyhedron,
-        dual_cellulation,
-        link,
-        peripheral,
-    ]
-
-    globs = {'Manifold':snappy.Manifold,
-             'ManifoldHP':snappy.ManifoldHP,
-             'Triangulation':snappy.Triangulation,
-             'Mcomplex':snappy.snap.t3mlite.Mcomplex,
-             'LinkSurface':snappy.snap.peripheral.link.LinkSurface
-    }
-
-    return doctest_modules(modules, extraglobs=globs,
-                           verbose=verbose, print_info=print_info)
-
 if __name__ == '__main__':
-    optlist, args = getopt.getopt(sys.argv[1:], 'v', ['verbose'])
-    verbose = len(optlist) > 0
-    run_doctests(verbose)
+    testing.run_doctests_as_main(run_doctests)

snappy/snap/utilities.py

@@ -7,30 +7,33 @@ interpreter.
 """
 
 from ..sage_helper import _within_sage
-from snappy.number import SnapPyNumbers, Number, is_exact
+from snappy.number import SnapPyNumbers, Number
 from itertools import chain
 from ..pari import pari, PariError
 from .fundamental_polyhedron import Infinity
 if _within_sage:
-    from sage.all import matrix as sage_matrix, vector as sage_vector
-    from sage.rings.real_mpfr import RealField_class
-    from ..sage_helper import ComplexField_class
-    is_field = lambda R: isinstance(R, (SnapPyNumbers, RealField_class, ComplexField_class))
+    from ..sage_helper import matrix as sage_matrix, vector as sage_vector
+    from ..sage_helper import RealField_class, ComplexField_class
+
+    def is_field(R):
+        return isinstance(R, (SnapPyNumbers, RealField_class,
+                              ComplexField_class))
 else:
-    is_field = lambda R: isinstance(R, SnapPyNumbers)
+    def is_field(R):
+        return isinstance(R, SnapPyNumbers)
 
 
-class MatrixBase(object):
+class MatrixBase():
     """Base class for Vector2 and Matrix2x2. Do not instantiate."""
     _base_ring = None
 
     def __len__(self):
         return 2
-    
+
     def _pari_(self):
         # force left multiplication by Numbers to use rmul
         raise PariError
-    
+
     def base_ring(self):
         """If a base ring was set when initializing the matrix, then this
         method will return that ring.  Otherwise, the base ring is a
@@ -38,8 +41,7 @@ class MatrixBase(object):
         of the elements.  If a new Number is created using the computed
         base ring and combined with the entries of this matrix, then the
         precision of the result will be determined by the precisions of
-        the entries.  
-
+        the entries.
         """
         if self._base_ring:
             return self._base_ring
@@ -48,9 +50,10 @@ class MatrixBase(object):
             return SnapPyNumbers(precision=precision)
 
     def list(self):
-        #Override this
+        # Override this
         return []
-        
+
+
 class Vector2(MatrixBase):
     """A 2-dimensional vector whose entries are snappy Numbers."""
     def __init__(self, *args):
@@ -61,11 +64,11 @@ class Vector2(MatrixBase):
             self._base_ring = None
             number = Number
         if len(args) == 1:
-            args = args[0]    
+            args = args[0]
         if len(args) == 2:
-            self.x, self.y = [number(t) for t in args]
+            self.x, self.y = (number(t) for t in args)
         else:
-            raise ValueError('Invalid initialization for a Vector2.') 
+            raise ValueError('Invalid initialization for a Vector2.')
 
     def __getitem__(self, index):
         if index == 0:
@@ -74,12 +77,12 @@ class Vector2(MatrixBase):
             return self.y
         else:
             raise IndexError('Invalid Vector2 index.')
-        
+
     def __repr__(self):
         entries = [str(e) for e in self.list()]
         size = max(map(len, entries))
-        entries = tuple(('%%-%d.%ds'%(size,size))%x for x in entries)
-        return '[ %s ]\n[ %s ]'%entries
+        entries = tuple(('%%-%d.%ds' % (size, size)) % x for x in entries)
+        return '[ %s ]\n[ %s ]' % entries
 
     def __add__(self, other):
         return Vector2(self.x + other.x, self.y + other.y)
@@ -87,19 +90,18 @@ class Vector2(MatrixBase):
     def __sub__(self, other):
         return Vector2(self.x - other.x, self.y - other.y)
 
-    def __mul__(self, other):        
+    def __mul__(self, other):
         if isinstance(other, Matrix2x2):
             return Vector2(self.x * other.a + self.y * other.c,
                            self.x * other.b + self.y * other.d)
-        elif isinstance(other, Number):
+        if isinstance(other, Number):
             return Vector2(self.x * other, self.y * other)
-        else:
-            try:
-                return self*base_ring()(other)
-            except:
-                return NotImplemented
+        try:
+            return self * self.base_ring()(other)
+        except (TypeError, ValueError):
+            return NotImplemented
 
-    def __rmul__(self, other):        
+    def __rmul__(self, other):
         return Vector2(self.x * other, self.y * other)
 
     def __div__(self, other):
@@ -107,7 +109,7 @@ class Vector2(MatrixBase):
 
     def __truediv__(self, other):
         return Vector2(self.x / other, self.y / other)
-    
+
     def __neg__(self):
         return Vector2(-self.x, -self.y)
 
@@ -116,16 +118,16 @@ class Vector2(MatrixBase):
 
     def sage(self):
         return sage_vector([self.x.sage(), self.y.sage()])
-    
+
     def norm(self, p=2):
         if p == 1:
             return self.x.abs() + self.y.abs()
-        elif p == 2:
-            precision = self.base_ring().precision()
-            return ((self.x*self.x).abs() + (self.y*self.y).abs()).sqrt()
-        elif p == Infinity:
+        if p == 2:
+            return ((self.x * self.x).abs() + (self.y * self.y).abs()).sqrt()
+        if p == Infinity:
             return max(self.x.abs(), self.y.abs())
-        
+
+
 class Matrix2x2(MatrixBase):
     """A 2x2 matrix class whose entries are snappy Numbers."""
     def __init__(self, *args):
@@ -136,32 +138,32 @@ class Matrix2x2(MatrixBase):
             self._base_ring = None
             number = Number
         if len(args) == 1:
-            args = tuple(chain(*args[0]))    
+            args = tuple(chain(*args[0]))
         if len(args) == 4:
-            self.a, self.b, self.c, self.d = [number(x) for x in args]
+            self.a, self.b, self.c, self.d = (number(x) for x in args)
         else:
-            raise ValueError('Invalid initialization for a Matrix2x2.') 
+            raise ValueError('Invalid initialization for a Matrix2x2.')
 
     def __repr__(self):
         entries = [str(e) for e in self.list()]
         size = max(map(len, entries))
-        entries = tuple(('%%-%d.%ds'%(size,size))%x for x in entries)
-        return '[ %s  %s ]\n[ %s  %s ]'%entries
+        entries = tuple(('%%-%d.%ds' % (size, size)) % x for x in entries)
+        return '[ %s  %s ]\n[ %s  %s ]' % entries
 
     def __getitem__(self, index):
         if isinstance(index, int):
             if index == 0:
                 return [self.a, self.b]
-            elif index == 1:
+            if index == 1:
                 return [self.c, self.d]
         elif isinstance(index, tuple) and len(index) == 2:
             i, j = index
-            if   i == 0:
+            if i == 0:
                 return self.a if j == 0 else self.b
-            elif i == 1:
+            if i == 1:
                 return self.c if j == 0 else self.d
         raise IndexError('Invalid 2x2 matrix index.')
-            
+
     def __add__(self, other):
         return Matrix2x2(self.a + other.a,
                          self.b + other.b,
@@ -186,11 +188,10 @@ class Matrix2x2(MatrixBase):
         if isinstance(other, Number):
             return Matrix2x2(self.a * other, self.b * other,
                              self.c * other, self.d * other)
-        else:
-            try:
-                return self*base_ring()(other)
-            except:
-                return NotImplemented
+        try:
+            return self * self.base_ring()(other)
+        except (TypeError, ValueError):
+            return NotImplemented
 
     def __rmul__(self, other):
         # Assumes that other is a scalar. This will not be
@@ -210,13 +211,13 @@ class Matrix2x2(MatrixBase):
 
     def __neg__(self):
         return Matrix2x2(-self.a, -self.b, -self.c, -self.d)
-    
+
     def __invert__(self):
         try:
-            D = 1/self.det()
+            D = 1 / self.det()
         except ZeroDivisionError:
-            raise ZeroDivisionError('matrix %s is not invertible.'%self)
-        return Matrix2x2(self.d*D, -self.b*D, -self.c*D, self.a*D)
+            raise ZeroDivisionError('matrix %s is not invertible.' % self)
+        return Matrix2x2(self.d * D, -self.b * D, -self.c * D, self.a * D)
 
     def adjoint(self):
         return Matrix2x2(self.d, -self.b, -self.c, self.a)
@@ -225,29 +226,29 @@ class Matrix2x2(MatrixBase):
         return self.a * self.d - self.b * self.c
 
     det = determinant
-    
+
     def trace(self):
         return self.a + self.d
 
     def eigenvalues(self):
-        #WARNING: This can take infinitely long!!!! (WHY???)
+        # WARNING: This can take infinitely long!!!! (WHY???)
         R = self.base_ring()
         x = pari('x')
         a, b, c, d = map(pari, self.list())
-        p = x*x - (a + d)*x + (a*d - b*c)
+        p = x * x - (a + d) * x + (a * d - b * c)
         roots = p.polroots(precision=R.precision())
         return map(R, roots)
 
     def norm(self, p=2):
         if p == 1:
             return max(self.a.abs() + self.c.abs(), self.b.abs() + self.d.abs())
-        elif p == 'frob':
-            return sum([x*x for x in self.list()]).sqrt()
-        elif p == Infinity:
+        if p == 'frob':
+            return sum([x * x for x in self.list()]).sqrt()
+        if p == Infinity:
             return max(self.a.abs() + self.b.abs(), self.c.abs() + self.d.abs())
-        elif p == 2:
+        if p == 2:
             return max([x.abs() for x in self.eigenvalues()])
-        
+
     def list(self):
         return [self.a, self.b, self.c, self.d]
 
@@ -257,13 +258,14 @@ class Matrix2x2(MatrixBase):
 
     def sage(self):
         return sage_matrix(2, 2, [x.sage() for x in self.list()])
-    
+
+
 def indexset(n):
     """The orders of the non-zero bits in the binary expansion of n."""
     i = 0
     result = []
     while True:
-        mask = 1<<i
+        mask = 1 << i
         if n & mask:
             result.append(i)
         if n < mask:
@@ -271,6 +273,7 @@ def indexset(n):
         i += 1
     return result
 
+
 def powerset(X):
     """Iterator for all finite subsequences of the iterable X"""
     n = 0
@@ -279,9 +282,7 @@ def powerset(X):
         segment.append(x)
         while True:
             try:
-                yield [ segment[i] for i in indexset(n) ]
+                yield [segment[i] for i in indexset(n)]
             except IndexError:
                 break
             n += 1
-
-