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

snappy/verify/upper_halfspace/extended_matrix.py

@@ -1,11 +1,12 @@
 from ...sage_helper import _within_sage
 
 if _within_sage:
-    from sage.all import sqrt
+    from ...sage_helper import sqrt
 
 __all__ = ['ExtendedMatrix']
 
-class ExtendedMatrix(object):
+
+class ExtendedMatrix():
     """
     An extended PGL(2,C)-matrix. It consists of a SageMath ``Matrix`` with
     coefficients in SageMath's ``ComplexIntervalField`` together with a flag
@@ -23,7 +24,7 @@ class ExtendedMatrix(object):
 
     """
 
-    def __init__(self, matrix, isOrientationReversing = False):
+    def __init__(self, matrix, isOrientationReversing=False):
         if isinstance(matrix, ExtendedMatrix):
             self.matrix = matrix.matrix
             self.isOrientationReversing = (
@@ -75,7 +76,7 @@ class ExtendedMatrix(object):
                                  "ExtendedMatrix.")
             return m.matrix
         return m
-        
+
     @staticmethod
     def get_orientation_sign(m):
         """
@@ -97,4 +98,3 @@ class ExtendedMatrix(object):
 
         m = ExtendedMatrix.extract_matrix_for_orientation_preserving(m)
         return (m[0,0] + m[1,1]) / sqrt(m.det())
-

snappy/verify/upper_halfspace/finite_point.py

@@ -1,15 +1,15 @@
 from ...sage_helper import _within_sage
 
 if _within_sage:
-    import sage.all
-    from sage.all import matrix, sqrt
-    from sage.functions.hyperbolic import arccosh
+    import sage
+    from ...sage_helper import matrix, sqrt, is_RealIntervalFieldElement, Infinity
 
 from .extended_matrix import ExtendedMatrix
 
 __all__ = ['FinitePoint']
 
-class FinitePoint(object):
+
+class FinitePoint():
     """
     A point in the upper half space model represented by the quaternion
     z + t * j with t > 0. For example, the point (1 + 2 * i) + 3 * j is::
@@ -62,8 +62,8 @@ class FinitePoint(object):
             FinitePoint(1.4500000000000000? + 0.50000000000000000?*I, 0.75000000000000000?)
 
         """
-        
-        return self._translate(m, normalize_matrix = False)
+
+        return self._translate(m, normalize_matrix=False)
 
     def translate_PGL(self, m):
         """
@@ -80,7 +80,7 @@ class FinitePoint(object):
 
         """
 
-        return self._translate(m, normalize_matrix = True)
+        return self._translate(m, normalize_matrix=True)
 
     def _translate(self, m, normalize_matrix):
 
@@ -96,7 +96,7 @@ class FinitePoint(object):
         #    (a*z + b) * (c*z + d) + a * c * t  + t * j
         #  ----------------------------------------------
         #                                 2
-        #            | c * (z + t*j) + d | 
+        #            | c * (z + t*j) + d |
 
         if isinstance(m, ExtendedMatrix):
             mat = m.matrix
@@ -110,29 +110,28 @@ class FinitePoint(object):
 
         if normalize_matrix:
             mat = mat / sqrt(mat.det())
-            
+
         # a * z + b
-        az_b  = mat[0,0] * z + mat[0,1]
+        az_b = mat[0,0] * z + mat[0,1]
         # c * z + d
-        cz_d  = mat[1,0] * z + mat[1,1]
+        cz_d = mat[1,0] * z + mat[1,1]
 
         # Denominator
         # | c * (z + t * j) + d |^2 =
         # | c * z + d + c * t * j | ^2 =
         # | c * z + d| ^ 2 + |c * t|^2
         denom = _abs_sqr(cz_d) + _abs_sqr(mat[1,0] * self.t)
-        
-        num   = ( az_b * cz_d.conjugate() +
+
+        num = ( az_b * cz_d.conjugate() +
                   mat[0,0] * mat[1,0].conjugate() * self.t ** 2)
 
         return FinitePoint(num / denom, self.t / denom)
-        
-    def cosh_dist(self, other):
 
+    def cosh_dist(self, other):
         """
         Returns cosh of the distance of this finite point to another
         finite point::
-        
+
             sage: from sage.all import *
             sage: a = FinitePoint(CIF(1,2),RIF(3))
             sage: b = FinitePoint(CIF(4,5),RIF(6))
@@ -142,7 +141,7 @@ class FinitePoint(object):
         """
 
         # The distance between two points in the upper half plane model is
-        # given by 
+        # given by
         #                                                  2          2
         #                                           (x2-x1)  + (y2-y1)
         #   dist( (x1,y1), (x2, y2) = arcosh(  1 + ---------------------  )
@@ -155,11 +154,25 @@ class FinitePoint(object):
         # t and (x2-x1)^2 is the square of the absolute value of the difference
         # of the two z.
 
-        r = 1 + (((self.t - other.t) ** 2 + _abs_sqr(self.z - other.z))/
+        r = 1 + (((self.t - other.t) ** 2 + _abs_sqr(self.z - other.z)) /
                  (2 * self.t * other.t))
+
+        # Due to rounding-errors, we can get a value that is just slightly
+        # smaller than 1, even though we know that this is mathematically
+        # impossible. This can cause taking arccosh later to fail.
+        #
+        # To avoid this failure, make sure the result is at least 1 - or
+        # in the interval case, ensure that the interval does not contain
+        # values below 1.
+        #
         RIF = r.parent()
-        return r.intersection(RIF(1,sage.all.Infinity))
-                 
+        if _within_sage:
+            if is_RealIntervalFieldElement(r):
+                return r.intersection(RIF(1, Infinity))
+        if r < 1.0:
+            return RIF(1.0)
+        return r
+
     def dist(self, other):
         """
         Returns the distance of this finite point to another finite point::
@@ -167,18 +180,18 @@ class FinitePoint(object):
             sage: from sage.all import *
             sage: a = FinitePoint(CIF(1,2),RIF(3))
             sage: b = FinitePoint(CIF(4,5),RIF(6))
-            sage: a.dist(b) # doctest: +NUMERIC12 
+            sage: a.dist(b) # doctest: +NUMERIC12
             1.158810360429947?
 
         """
-
         # Note: SageMath 8.1 doesn't compute arccosh correctly for a
         # complex interval, but at least it does so for a real interval.
-        return arccosh(self.cosh_dist(other))
-    
+        return self.cosh_dist(other).arccosh()
+
     def __repr__(self):
         return 'FinitePoint(%r, %r)' % (self.z, self.t)
 
+
 ###############################################################################
 # Various helpers
 
@@ -189,7 +202,8 @@ def _abs_sqr(z):
 #
 # TESTING
 
-class _FinitePointTester(object):
+
+class _FinitePointTester():
     """
     A test rig for FinitePoint.
 
@@ -202,18 +216,18 @@ class _FinitePointTester(object):
     def matrix1(self):
         from sage.all import RIF, CIF, matrix
         return matrix(
-            [[CIF(RIF(1.3),RIF(-0.4)), CIF(RIF(5.6),RIF(2.3))],
+            [[CIF(RIF(1.3), RIF(-0.4)), CIF(RIF(5.6), RIF(2.3))],
              [CIF(RIF(-0.3), RIF(0.1)), CIF(1)]])
-    
+
     def extended_matrix1(self, isOrientationReversing):
         return ExtendedMatrix(self.matrix1(), isOrientationReversing)
 
     def matrix2(self):
         from sage.all import RIF, CIF, matrix
         return matrix(
-            [[CIF(RIF(0.3),RIF(-1.4)), CIF(RIF(3.6),RIF(6.3))],
+            [[CIF(RIF(0.3), RIF(-1.4)), CIF(RIF(3.6), RIF(6.3))],
              [CIF(RIF(-0.3), RIF(1.1)), CIF(1)]])
-    
+
     def extended_matrix2(self, isOrientationReversing):
         return ExtendedMatrix(self.matrix2(), isOrientationReversing)
 
@@ -235,7 +249,7 @@ class _FinitePointTester(object):
             raise Exception("Expected distance to be RIF")
         if not isinstance(d_after, RealIntervalFieldElement):
             raise Exception("Expected distance to be RIF")
-        
+
         if not abs(d_before - d_after) < RIF(1e-12):
             raise Exception("Distance changed %r %r" % (d_before, d_after))
 
@@ -267,4 +281,3 @@ class _FinitePointTester(object):
         self.matrix_multiplication_works([m1o, m1o, m2r, m1o])
         self.matrix_multiplication_works([m1o, m1r, m2r, m1o])
         self.matrix_multiplication_works([m2r, m1o, m2r, m1o])
-

snappy/verify/upper_halfspace/ideal_point.py

@@ -1,7 +1,7 @@
 """
 We have two representations of a point in the boundary of the upper half space model
 **H**\\ :sup:`3`:
- 
+
   - :class:`ProjectivePoint` encapsulate it as an element in **CP**\\ :sup:`1`. It uses intervals
     and can thus represent a neighborhood of infinity.
   - as a one point compactification of **C**.
@@ -17,8 +17,8 @@ and is different from the ``Infinity`` that comes from ``sage.all``.
 from ...sage_helper import _within_sage
 
 if _within_sage:
-    import sage.all
-    from sage.all import matrix, prod, sqrt, log
+    from ...sage_helper import I, matrix
+    from ...sage_helper import Infinity as sage_Infinity
 
 from .finite_point import *
 from .extended_matrix import *
@@ -37,6 +37,7 @@ __all__ = [
 # This should come from snappy.snap.transferKernelStructuresEngine.
 Infinity = 'Infinity'
 
+
 def apply_Moebius(m, z):
     """
     Applies the matrix m to the ideal point z::
@@ -60,7 +61,8 @@ def apply_Moebius(m, z):
     if z == Infinity:
         return m[0,0] / m[1,0]
     return (m[0,0] * z + m[0,1]) / (m[1,0] * z + m[1,1])
-    
+
+
 def cross_ratio(z0, z1, z2, z3):
     """
     Computes the cross ratio (according to SnapPea conventions) of
@@ -72,9 +74,10 @@ def cross_ratio(z0, z1, z2, z3):
 
     """
 
-    return ((_diff_1_if_inf(z2, z0) * _diff_1_if_inf(z3, z1)) / 
+    return ((_diff_1_if_inf(z2, z0) * _diff_1_if_inf(z3, z1)) /
             (_diff_1_if_inf(z2, z1) * _diff_1_if_inf(z3, z0)))
 
+
 def compute_midpoint_of_triangle_edge_with_offset(idealPoints, offset):
     """
     The inputs are a list of three IdealPoint's [a, b, c] and an element
@@ -84,10 +87,10 @@ def compute_midpoint_of_triangle_edge_with_offset(idealPoints, offset):
     from c perpendicular to the side a b. Call the intersection of the line
     with the side a b the midpoint. This function returns this point moved
     towards a by hyperbolic distance log(offset)::
-    
+
         sage: from sage.all import CIF, RIF
         sage: compute_midpoint_of_triangle_edge_with_offset( # doctest: +NUMERIC12
-        ...       [ CIF(0), Infinity, CIF(1) ], RIF(5.0)) 
+        ...       [ CIF(0), Infinity, CIF(1) ], RIF(5.0))
         FinitePoint(0, 0.2000000000000000?)
 
     """
@@ -107,28 +110,30 @@ def compute_midpoint_of_triangle_edge_with_offset(idealPoints, offset):
 
     transformedMidpoint = _compute_midpoint_helper(
         b, c, offset)
-    
+
     return _translate(transformedMidpoint, inv_sl_matrix)
 
+
 def compute_midpoint_two_horospheres_from_triangle(
     idealPoints, intersectionLengths):
 
     a, b, c = idealPoints
-    la, lb  = intersectionLengths
+    la, lb = intersectionLengths
 
     if a == Infinity:
-        return _compute_midpoint_helper(b, c, sqrt(lb / la))
+        return _compute_midpoint_helper(b, c, (lb / la).sqrt())
     if b == Infinity:
-        return _compute_midpoint_helper(a, c, sqrt(la / lb))
+        return _compute_midpoint_helper(a, c, (la / lb).sqrt())
 
     (b, c), inv_sl_matrix = (
         _transform_points_to_make_first_one_infinity_and_inv_sl_matrix(
             idealPoints))
 
-    transformedMidpoint = _compute_midpoint_helper(b, c, sqrt(lb / la))
-    
+    transformedMidpoint = _compute_midpoint_helper(b, c, (lb / la).sqrt())
+
     return _translate(transformedMidpoint, inv_sl_matrix)
-    
+
+
 def compute_incenter_of_triangle(idealPoints):
     """
     Computes incenter of the triangle spanned by three ideal points::
@@ -147,12 +152,13 @@ def compute_incenter_of_triangle(idealPoints):
     transformedIdealPoints, inv_sl_matrix = (
         _transform_points_to_make_one_infinity_and_inv_sl_matrix(idealPoints))
 
-    transformedInCenter =(
+    transformedInCenter = (
         _compute_incenter_of_triangle_with_one_point_at_infinity(
             transformedIdealPoints))
 
     return _translate(transformedInCenter, inv_sl_matrix)
 
+
 def compute_inradius_and_incenter(idealPoints):
     """
     Computes inradius and incenter of the tetrahedron spanned by four
@@ -163,10 +169,10 @@ def compute_inradius_and_incenter(idealPoints):
         sage: z1 = CIF(0)
         sage: z2 = CIF(1)
         sage: z3 = CIF(1.2, 1.0)
-        sage: compute_inradius_and_incenter([z0, z1, z2, z3])
+        sage: compute_inradius_and_incenter([z0, z1, z2, z3]) # doctest: +NUMERIC12
         (0.29186158033099?, FinitePoint(0.771123016231387? + 0.2791850380434060?*I, 0.94311979279000?))
     """
-    
+
     if not len(idealPoints) == 4:
         raise Exception("Expected 4 ideal points.")
 
@@ -179,6 +185,7 @@ def compute_inradius_and_incenter(idealPoints):
 
     return inradius, _translate(transformedInCenter, inv_sl_matrix)
 
+
 def Euclidean_height_of_hyperbolic_triangle(idealPoints):
     """
     Computes the Euclidean height of the hyperbolic triangle spanned by three
@@ -191,20 +198,20 @@ def Euclidean_height_of_hyperbolic_triangle(idealPoints):
         sage: z1 = CIF(1)
         sage: Euclidean_height_of_hyperbolic_triangle([z0, z1, Infinity])
         [+infinity .. +infinity]
-        
+
         sage: Euclidean_height_of_hyperbolic_triangle([z0, z1, CIF(0.5, 0.8)]) # doctest: +NUMERIC12
         0.556250000000000?
-        
+
         sage: Euclidean_height_of_hyperbolic_triangle([z0, z1, CIF(10, 0.001)]) # doctest: +NUMERIC12
         5.000000025000000?
 
     """
-    
+
     if Infinity in idealPoints:
         for idealPoint in idealPoints:
             if idealPoint != Infinity:
                 RIF = idealPoint.real().parent()
-                return RIF(sage.all.Infinity)
+                return RIF(sage_Infinity)
 
         raise Exception("What?")
 
@@ -218,26 +225,25 @@ def Euclidean_height_of_hyperbolic_triangle(idealPoints):
             return lengths[i] / 2
 
     # a + b + c
-    length_total   = sum(lengths)
+    length_total = sum(lengths)
     # a * b * c
-    length_product = prod(lengths)
+    length_product = lengths[0] * lengths[1] * lengths[2]
 
-    # - a + b + c, a - b + c, a + b - c
-    terms = [ - lengths[0] + lengths[1] + lengths[2],
-                lengths[0] - lengths[1] + lengths[2],
-                lengths[0] + lengths[1] - lengths[2] ]
-    
     # (-a + b + c) * (a - b + c) * (a + b - c)
-    terms_product = prod(terms)
+    terms_product = (
+        (- lengths[0] + lengths[1] + lengths[2]) *
+        (  lengths[0] - lengths[1] + lengths[2]) *
+        (  lengths[0] + lengths[1] - lengths[2]))
 
     # Compute circumradius R of Euclidean triangle using
     # a * b * c / (4 * A) and Heron's formula.
-    return length_product / sqrt(terms_product * length_total)
+    return length_product / (terms_product * length_total).sqrt()
 
 ################################################################################
 #
 # Various helper functions
 
+
 def _transform_points_to_make_one_infinity_and_inv_sl_matrix(idealPoints):
     """
     Returns a pair (transformedIdealPoints, matrix) where matrix has determinant
@@ -253,13 +259,14 @@ def _transform_points_to_make_one_infinity_and_inv_sl_matrix(idealPoints):
     return _transform_points_to_make_first_one_infinity_and_inv_sl_matrix(
         idealPoints)
 
+
 def _transform_points_to_make_first_one_infinity_and_inv_sl_matrix(idealPoints):
 
     # Determine the matrix
     z = idealPoints[0]
     CIF = z.parent()
-    gl_matrix = matrix(CIF, [[ 0,  1], [ 1, -z]])
-    sl_matrix = CIF(sage.all.I) * gl_matrix
+    gl_matrix = matrix(CIF, [[ 0, 1], [ 1, -z]])
+    sl_matrix = CIF(I) * gl_matrix
     inv_sl_matrix = _adjoint2(sl_matrix)
 
     # Apply it
@@ -267,6 +274,7 @@ def _transform_points_to_make_first_one_infinity_and_inv_sl_matrix(idealPoints):
         [ apply_Moebius(gl_matrix, u) for u in idealPoints[1:] ],
         inv_sl_matrix)
 
+
 def _translate(finitePoint, sl_matrix):
     """
     Apply translation if matrix is not None.
@@ -276,14 +284,17 @@ def _translate(finitePoint, sl_matrix):
         return finitePoint.translate_PSL(sl_matrix)
     return finitePoint
 
+
 def _compute_midpoint_helper(b, c, offset):
     height = abs(c - b) * offset
     return FinitePoint(b, height)
 
+
 def _compute_incenter_of_triangle_with_one_point_at_infinity(nonInfPoints):
     a, b = nonInfPoints
     RIF = a.real().parent()
-    return FinitePoint((a + b) / 2, abs(a - b) * sqrt(RIF(3)) / 2)
+    return FinitePoint((a + b) / 2, abs(a - b) * RIF(3).sqrt() / 2)
+
 
 def _compute_inradius_and_incenter_with_one_point_at_infinity(nonInfPoints):
     """
@@ -293,7 +304,7 @@ def _compute_inradius_and_incenter_with_one_point_at_infinity(nonInfPoints):
 
     if not len(nonInfPoints) == 3:
         raise Exception("Expects three non-infinite points.")
-    
+
     # Pts contains three complex numbers spanning the ideal tetrahedron
     # together with infinity.
 
@@ -302,28 +313,26 @@ def _compute_inradius_and_incenter_with_one_point_at_infinity(nonInfPoints):
     lengths = [ abs(nonInfPoints[(i+2) % 3] - nonInfPoints[(i+1) % 3])
                 for i in range(3) ]
     # a + b + c
-    length_total   = sum(lengths)
+    length_total = sum(lengths)
     # a * b * c
-    length_product = prod(lengths)
+    length_product = lengths[0] * lengths[1] * lengths[2]
 
-    # - a + b + c, a - b + c, a + b - c
-    terms = [ - lengths[0] + lengths[1] + lengths[2],
-                lengths[0] - lengths[1] + lengths[2],
-                lengths[0] + lengths[1] - lengths[2] ]
-    
     # (-a + b + c) * (a - b + c) * (a + b - c)
-    terms_product = prod(terms)
+    terms_product = (
+        ( - lengths[0] + lengths[1] + lengths[2]) *
+        (   lengths[0] - lengths[1] + lengths[2]) *
+        (   lengths[0] + lengths[1] - lengths[2]))
 
     # Heron's formula gives us the area as of the Euclidean triangle as
     # A = sqrt(length_total * terms_product / 16) = r * length_total / 2
     # Thus, we can compute the inradius r as:
-    inRadiusSqr  = terms_product / length_total / 4
-    inRadius     = sqrt(inRadiusSqr)
-    
+    inRadiusSqr = terms_product / length_total / 4
+    inRadius = inRadiusSqr.sqrt()
+
     # The circumradius R of the Euclidean triangle is given by
     # a * b * c / (4 * A), so we can compute it as:
-    circumRadius = length_product / sqrt(terms_product * length_total)
-    
+    circumRadius = length_product / (terms_product * length_total).sqrt()
+
     # Euler's formula gives us the distance d between the incenter and the
     # circumcenter is given d^2 = R^2 - 2 * r * R.
     # We obtain a Euclidean right triangle formed by the in- and circumcenter
@@ -335,19 +344,21 @@ def _compute_inradius_and_incenter_with_one_point_at_infinity(nonInfPoints):
     # R. The other leg of the right triangle which is the Euclidean height h
     # of the Euclidean center of the inscribed sphere is given by Pythagoras
     # h^2 + d^2 = (r + R)^2, so h = r^2 + 4 * r * R
-    eHeightSqr   = inRadiusSqr + 4 * inRadius * circumRadius
-    eHeight      = sqrt(eHeightSqr)
+    eHeightSqr = inRadiusSqr + 4 * inRadius * circumRadius
+    eHeight = eHeightSqr.sqrt()
 
     # Next, we compute the Euclidean height of hyperbolic center of the
     # inscribed sphere
     # We use the geometric mean of the Euclidean heights of the lowest and
     # highest point of the inscribed sphere
     # sqrt( (h + r) * (h - r))
-    height       = sqrt( eHeightSqr - inRadiusSqr )
+    #
+    # height is also equal to  (2 * length_product / length_total).sqrt()
+    height = ( eHeightSqr - inRadiusSqr ).sqrt()
 
-    # Taking the logarithm of the ratio of these two highest gives the 
+    # Taking the logarithm of the ratio of these two highest gives the
     # hyperbolic diameter of the inscribed sphere.
-    radius       = log( (eHeight + inRadius) / (eHeight - inRadius) ) / 2
+    radius = ( (eHeight + inRadius) / (eHeight - inRadius) ).log() / 2
 
     # The barycentric coordinates of the circumcenter are simply a : b : c.
     incenter = sum([ pt * l
@@ -355,6 +366,7 @@ def _compute_inradius_and_incenter_with_one_point_at_infinity(nonInfPoints):
 
     return radius, FinitePoint(incenter, height)
 
+
 def _adjoint2(m):
     """
     Sage matrix.adjoint() produces an unnecessary large interval for
@@ -363,6 +375,7 @@ def _adjoint2(m):
 
     return matrix([[m[1,1], -m[0, 1]], [-m[1, 0], m[0, 0]]])
 
+
 def _diff_1_if_inf(a, b):
     if a == Infinity or b == Infinity:
         return 1
@@ -372,7 +385,8 @@ def _diff_1_if_inf(a, b):
 #
 # TESTING
 
-class _IdealPointTester(object):
+
+class _IdealPointTester():
 
     """
     A test rig for idealPoint
@@ -384,8 +398,7 @@ class _IdealPointTester(object):
     """
 
     def matrices(self):
-        from sage.all import RIF, CIF, matrix
-
+        from ...sage_helper import RIF, CIF
         return [
             matrix.identity(CIF, 2),
             matrix(
@@ -396,8 +409,7 @@ class _IdealPointTester(object):
                  [CIF(RIF(-0.3), RIF(1.1)), CIF(1)]]) ]
 
     def run_tests(self):
-        from sage.all import RIF, CIF
-        
+        from ...sage_helper import RIF, CIF
         bias = RIF(1.5)
 
         triangle = [ CIF(0), Infinity, CIF(1) ]

snappy/verify/volume.py

@@ -5,6 +5,7 @@ if _within_sage:
     from sage.rings.complex_interval_field import ComplexIntervalField
     try:
         import sage.rings.abc
+
         def is_ComplexIntervalField(z):
             return isinstance(z, sage.rings.abc.ComplexIntervalField)
     except ImportError:
@@ -14,7 +15,7 @@ if _within_sage:
 
 __all__ = ['compute_volume']
 
-from . import verifyHyperbolicity
+from . import hyperbolicity
 
 # Sage's handling of pari has a bug when it comes to precision and the dilog.
 # It computes the dilogarithm only to low precision even though higher precision
@@ -27,6 +28,7 @@ from . import verifyHyperbolicity
 # We work around this by converting to snappy.Number where a work-around for this was
 # implemented.
 
+
 def _unprotected_volume_from_shape(z):
     """
     Computes the Bloch-Wigner dilogarithm for z assuming z is of a type that
@@ -55,9 +57,10 @@ def _unprotected_volume_from_shape(z):
     # the interval for the imaginary part of z contains zero if and only if
     # the imaginary part of 1-z contains zero, so the same branch cut is chosen
     # for (1-z).arg() and z.polylog(2).
-    
+
     return (1-z).arg() * z.abs().log() + z.polylog(2).imag()
 
+
 def _volume_from_shape(z):
     """
     Computes the Bloch-Wigner dilogarithm for z which gives the volume of a
@@ -75,10 +78,10 @@ def _volume_from_shape(z):
             # Thus, we convert to ComplexBallField here since the arblib
             # supports a verified interval polylog (albeit giving an interval
             # that seems to be 300 times larger than necessary).
-            
+
             CBF = ComplexBallField(CIF.precision())
             RIF = RealIntervalField(CIF.precision())
-    
+
             return RIF(_unprotected_volume_from_shape(CBF(z)))
         else:
             z = Number(z)
@@ -87,34 +90,34 @@ def _volume_from_shape(z):
     # have to explicitly give a precision to dilog, otherwise you lose
     # precision.
     return z.volume()
-    
-def compute_volume(manifold, verified, bits_prec = None):
+
+
+def compute_volume(manifold, verified, bits_prec=None):
     """
     Computes the volume of the given manifold. If verified is used,
     the hyperbolicity is checked rigorously and the volume is given as
     verified interval.
 
     >>> M = Manifold('m004')
-    >>> vol = M.volume(bits_prec=100)   
+    >>> vol = M.volume(bits_prec=100)
     >>> vol # doctest: +ELLIPSIS
     2.029883212819307250042405108...
-    
+
     sage: ver_vol = M.volume(verified=True)
     sage: vol in ver_vol
     True
     sage: 2.02988321283 in ver_vol
     False
     """
-
     # Compute tetrahedra shapes to arbitrary precision.  If requested,
     # verify that this is indeed a solution to the polynomial gluing
     # equations.
     shape_intervals = manifold.tetrahedra_shapes(
-        'rect', bits_prec = bits_prec, intervals = verified)
-    
+        'rect', bits_prec=bits_prec, intervals=verified)
+
     if verified:
         # If requested, check it is a valid hyperbolic structure
-        verifyHyperbolicity.check_logarithmic_gluing_equations_and_positively_oriented_tets(
+        hyperbolicity.check_logarithmic_gluing_equations_and_positively_oriented_tets(
             manifold, shape_intervals)
 
     # Sum up the volumes of all the tetrahedra

snappy/version.py

@@ -1,3 +1,2 @@
-from __future__ import unicode_literals
-version = '3.0.3'
-release_date = 'December 2021'
+version = '3.2'
+release_date = 'January 2025'