snappy 3.1__cp310-cp310-macosx_11_0_arm64.whl → 3.2__cp310-cp310-macosx_11_0_arm64.whl

snappy/drilling/perturb.py

@@ -1,30 +1,47 @@
 from . import constants
 from . import epsilons
 from . import exceptions
-from .geodesic_tube import add_structures_necessary_for_tube, GeodesicTube
-from .geodesic_info import GeodesicInfo
-from .line import R13Line, distance_r13_lines
 
+from ..geometric_structure.geodesic.tiles_for_geodesic import compute_tiles_for_geodesic
+from ..geometric_structure.geodesic.geodesic_start_point_info import GeodesicStartPointInfo
+from ..geometric_structure.geodesic.check_away_from_core_curve import check_away_from_core_curve_iter
 from ..hyperboloid import ( # type: ignore
     unit_time_vector_to_o13_hyperbolic_translation,
     r13_dot,
-    time_r13_normalise,
-    distance_unit_time_r13_points)
+    time_r13_normalise)
+from ..hyperboloid.line import R13Line
+from ..hyperboloid.distances import distance_r13_lines, distance_r13_points
+from ..tiling.triangle import add_triangles_to_tetrahedra
 from ..snap.t3mlite import Mcomplex # type: ignore
 from ..exceptions import InsufficientPrecisionError # type: ignore
-from ..matrix import vector # type: ignore
+from ..matrix import make_vector # type: ignore
 from ..math_basics import correct_min # type: ignore
 
-from typing import Sequence, List
-
+from typing import Sequence, Tuple, List, Any
+
+# For perturbing, it is sufficient to just find some non-trivial
+# lower bound for the embedding radius of a tube about a geodesic.
+# To just any such bound, set _tube_developing_radius = 0.
+# This will develop the tube just to the point where we can verify
+# that it has positive radius.
+#
+# To stress-test our code, we can develop the tube further, by
+# setting _tube_developing_radius > 0. The isotopy type of
+# the drilled curve will not change no matter how large
+# _tube_developing_radius is. In other words, we still compute
+# a lower bound for the embedding radius which eventually will
+# be the embedding radius up to rounding errors as
+# _tube_developing_radius increases.
+#
+_tube_developing_radius = 0
 
 def perturb_geodesics(
         mcomplex : Mcomplex,
-        geodesics : Sequence[GeodesicInfo],
+        geodesics : Sequence[GeodesicStartPointInfo],
         verbose=False):
     """
     Given a triangulation with structures added by add_r13_geometry
-    and GeodesicInfo's with start points on the line that is a lift
+    and GeodesicStartPointInfo's with start points on the line that is a lift
     of the closed geodesic, perturbs the start point away from the line
     and computes a new end point (as image of the new start point under
     the matrix associated to the geodesic line). The line segment
@@ -32,7 +49,7 @@ def perturb_geodesics(
     curve in the manifold which is guaranteed to be isotopic to the
     closed geodesic.
 
-    If several GeodesicInfo's are given and/or there are filled
+    If several GeodesicStartPointInfo's are given and/or there are filled
     cusps with core curves, the system of simple closed curves
     resulting from the perturbation together with the core curves
     is guaranteed to be isotopic to the original system of closed
@@ -72,34 +89,35 @@ def perturb_geodesics(
     for g in geodesics:
         perturb_geodesic(g, r, mcomplex.verified)
 
-
 def compute_lower_bound_injectivity_radius(
         mcomplex : Mcomplex,
-        geodesics : Sequence[GeodesicInfo]):
+        geodesics : Sequence[GeodesicStartPointInfo]):
 
-    add_structures_necessary_for_tube(mcomplex)
+    if len(geodesics) == 0:
+        raise Exception("No geodesic tubes given")
+    
+    add_triangles_to_tetrahedra(mcomplex)
 
-    tubes = [ GeodesicTube(mcomplex, g) for g in geodesics ]
-    for tube in tubes:
-        tube.add_pieces_for_radius(r=0)
+    min_radius = mcomplex.RF(_tube_developing_radius)
 
-    return compute_lower_bound_injectivity_radius_from_tubes(
-        mcomplex, tubes)
+    distances = []
 
+    tet_to_lines : List[List[R13Line]] = [[] for tet in mcomplex.Tetrahedra ]
 
-def compute_lower_bound_injectivity_radius_from_tubes(
-        mcomplex : Mcomplex,
-        tubes : Sequence[GeodesicTube]):
-    if len(tubes) == 0:
-        raise Exception("No geodesic tubes given")
+    core_curve_epsilon = _compute_core_curve_epsilon(mcomplex)
 
-    distances = []
-
-    tet_to_lines : List[List[R13Line]] = [[] for tet in mcomplex.Tetrahedra]
-    for tube in tubes:
-        distances.append(tube.covered_radius())
-        for p in tube.pieces:
-            tet_to_lines[p.tet.Index].append(p.lifted_geodesic)
+    for geodesic in geodesics:
+        for tile in (
+                check_away_from_core_curve_iter(
+                    compute_tiles_for_geodesic(mcomplex, geodesic),
+                    epsilon=core_curve_epsilon,
+                    obj_name='Geodesic %s' % geodesic.word)):
+            if tile.lower_bound_distance > min_radius:
+                distances.append(tile.lower_bound_distance)
+                break
+            tet_index = tile.lifted_tetrahedron.tet.Index
+            tet_to_lines[tet_index].append(
+                tile.inverse_lifted_geometric_object)
 
     for tet in mcomplex.Tetrahedra:
         for curve in tet.core_curves.values():
@@ -113,11 +131,11 @@ def compute_lower_bound_injectivity_radius_from_tubes(
     return correct_min(distances) / 2
 
 
-def perturb_geodesic(geodesic : GeodesicInfo,
+def perturb_geodesic(geodesic : GeodesicStartPointInfo,
                      injectivity_radius,
                      verified : bool):
     if geodesic.line is None:
-        raise ValueError("GeodesicInfo needs line to be perturbed.")
+        raise ValueError("GeodesicStartPointInfo needs line to be perturbed.")
 
     perturbed_point = perturb_unit_time_point(
         time_r13_normalise(geodesic.unnormalised_start_point),
@@ -138,8 +156,9 @@ def perturb_unit_time_point(point, max_amt, verified : bool):
     RF = point.base_ring()
 
     amt = RF(0.5) * max_amt
-    direction = vector([RF(x) for x in constants.point_perturbation_direction])
-    perturbed_origin = vector(
+    direction = make_vector(
+        [RF(x) for x in constants.point_perturbation_direction])
+    perturbed_origin = make_vector(
         [ amt.cosh() ] + list(amt.sinh() * direction.normalized()))
 
     m = unit_time_vector_to_o13_hyperbolic_translation(point)
@@ -150,9 +169,9 @@ def perturb_unit_time_point(point, max_amt, verified : bool):
 
     space_coords = [ RF(x.center()) for x in perturbed_point[1:4] ]
     time_coord = sum((x**2 for x in space_coords), RF(1)).sqrt()
-    perturbed_point = vector([time_coord] + space_coords)
+    perturbed_point = make_vector([time_coord] + space_coords)
 
-    d = distance_unit_time_r13_points(point, perturbed_point)
+    d = distance_r13_points(point, perturbed_point)
     if not d < RF(0.75) * max_amt:
         raise InsufficientPrecisionError(
             "Could not verify perturbed point is close enough to original "
@@ -160,3 +179,10 @@ def perturb_unit_time_point(point, max_amt, verified : bool):
             "Increasing the precision will probably fix this.")
 
     return perturbed_point
+
+def _compute_core_curve_epsilon(mcomplex):
+    if mcomplex.verified:
+        return 0
+    else:
+        RF = mcomplex.RF
+        return RF(0.5) ** (RF.prec() // 2 - 8)

snappy/drilling/shorten.py

@@ -0,0 +1,36 @@
+from .cusps import CuspPostDrillInfo
+from .barycentric import transpositions, perm_to_index, mark_subtetrahedra_about_edge
+
+from ..snap.t3mlite import Tetrahedron, Perm4, simplex
+
+
+def shorten_in_barycentric_subdivision(tetrahedra, verbose : bool = False):
+    while shorten_one_in_barycentric_subdivision(tetrahedra):
+        if verbose:
+            print("Shortening geodesic by sweeping across triangle.")
+
+def shorten_one_in_barycentric_subdivision(tetrahedra):
+    for tet in tetrahedra:
+        for perm, orientation in zip(Perm4.S4(), tet.marked_subtetrahedra):
+            if orientation != +1:
+                continue
+            other_perm = perm * transpositions[1]
+            j = perm_to_index(other_perm)
+            if tet.marked_subtetrahedra[j] == 0:
+                continue
+            mark_subtetrahedra_about_edge(tet, perm, 0)
+            mark_subtetrahedra_about_edge(tet, other_perm, 0)
+            new_perm = perm * Perm4((1,2,0,3))
+            mark_subtetrahedra_about_edge(tet, new_perm)
+            _remove_post_drill_info_from_vertex(tet, perm.image(simplex.V0))
+            return True
+    return False
+
+def _remove_post_drill_info_from_vertex(tet, v):
+    if tet.post_drill_infos[v].index is None:
+        return
+    tet.post_drill_infos[v] = CuspPostDrillInfo()
+    for f in simplex.FacesAroundVertexCounterclockwise[v]:
+        _remove_post_drill_info_from_vertex(
+            tet.Neighbor[f],
+            tet.Gluing[f].image(v))

snappy/drilling/subdivide.py

@@ -1,6 +1,5 @@
 from .moves import one_four_move, two_three_move
 from .tracing import GeodesicPiece, GeodesicPieceTracker
-from .exceptions import GeodesicStartingPiecesCrossSameFaceError
 
 from . import debug
 
@@ -138,10 +137,6 @@ def _traverse_geodesic_to_subdivide(
     # pointed to by a variable we are interested in where the name
     # the variable if it is not just "piece".
 
-    if (start_piece.prev.endpoints[0].subsimplex ==
-                    start_piece.endpoints[1].subsimplex):
-        raise GeodesicStartingPiecesCrossSameFaceError()
-
     # Following trace_geodesic, we start with
     #
     #    start_piece.prev

snappy/drilling/test.py

@@ -0,0 +1,23 @@
+from snappy import testing
+import snappy
+
+from snappy import drilling
+import snappy.drilling.test_cases
+
+modules = [
+    drilling,
+    drilling.test_cases
+]
+
+def run_doctests(verbose=False, print_info=True):
+    globs = {'Manifold'  : snappy.Manifold,
+             'ManifoldHP': snappy.ManifoldHP}
+    return testing.doctest_modules(modules,
+                                   verbose=verbose,
+                                   print_info=print_info,
+                                   extraglobs=globs)
+
+run_doctests.__name__ = drilling.__name__
+
+if __name__ == '__main__':
+    testing.run_doctests_as_main(run_doctests)

snappy/drilling/test_cases.py

@@ -0,0 +1,126 @@
+"""
+IMPORTANT: Python only recognises this as a doc string if there is
+nothing before it. In particular, add any includes after the doc string.
+
+Test with manifold without symmetry. Note that the code in drilling is
+deterministic but the SnapPea kernel code to remove the finite vertices
+and simplify is not. Thus, we need canonical_retriangulation() to get
+a consistent result:
+
+    >>> from snappy.drilling.exceptions import GeodesicSystemNotSimpleError
+    >>> M = Manifold("v2986")
+    >>> M.drill_word('gB').canonical_retriangulation().triangulation_isosig(ignore_orientation=False)
+    'kLvvAQQkbhijhghgjijxxacvcccccv_baBaaBDbBa'
+
+Test non-simple geodesic and verified computation:
+
+    sage: M = ManifoldHP("m004")
+    sage: try:
+    ...       M.drill_word('bbCC', verified = True)
+    ... except GeodesicSystemNotSimpleError as e:
+    ...     print("Not simple")
+    Not simple
+
+Tests drilling one geodesic that intersects 1-skeleton::
+
+    >>> M = Manifold("m125")
+    >>> M.drill_word('d').canonical_retriangulation().triangulation_isosig(ignore_orientation=False)
+    'svLvLQLAzQMMQdifhjmlknlopnqpqrrroaaaaaaoaaaaaaoaaao_aBbaBaaBeDBb'
+
+Tests drilling two geodesics that intersect each other:
+
+    >>> try: # doctest: +NUMERIC9
+    ...     M.drill_words(['d','Ad'])
+    ... except GeodesicSystemNotSimpleError as e:
+    ...     print("Max tube radius:", e.maximal_tube_radius)
+    Max tube radius: 0.0000000000
+
+Tests drilling geodesics that are entirely in the 2-skeleton::
+
+    >>> M.drill_words(['a','acAADa']).canonical_retriangulation().triangulation_isosig(ignore_orientation=False)
+    'ivvPQQcfhghgfghfaaaaaaaaa_BabBBbBaBBbabbab'
+
+Same test as verified computation::
+
+    sage: M.drill_words(['a','acAADa'], verified = True).canonical_retriangulation().triangulation_isosig(ignore_orientation=False)
+    'ivvPQQcfhghgfghfaaaaaaaaa_BabBBbBaBBbabbab'
+
+Test error when drilling something close to core curve::
+
+    >>> M = Manifold("m125")
+    >>> MM = M.drill_word('d')
+    >>> MM.dehn_fill((1,0),2)
+    >>> bad_word = 'bc'
+    >>> MM.drill_word(bad_word) # doctest: +ELLIPSIS
+    Traceback (most recent call last):
+    ...
+    snappy.geometric_structure.geodesic.check_away_from_core_curve.ObjectCloseToCoreCurve: Geodesic bc is very close to the core curve of cusp 2 and might intersect it. Distance: ...
+
+There are two places where we detect whether the geodesic is close
+to a core curve (rather than tiling forever). Test the other place
+in the GeodesicTube code used to determine the maximal amount we can
+perturb the geodesic:
+
+    >>> drill_words_implementation(MM, [bad_word], verified = False, bits_prec = 53, perturb = True) # doctest: +ELLIPSIS
+    Traceback (most recent call last):
+    ...
+    snappy.geometric_structure.geodesic.check_away_from_core_curve.ObjectCloseToCoreCurve: Geodesic bc is very close to the core curve of cusp 2 and might intersect it. Distance: ...
+
+A particular tricky case in terms testing that the start piece is correctly
+handled by 2-3 moves (in particular, commit f9879d04 introduced a bug):
+
+    >>> Manifold("m004").drill_words(['CAC','CCbC']).canonical_retriangulation().triangulation_isosig(ignore_orientation=False)
+    'qLvvLvAMQQQkcgimopkllmpkonnnpixcaelchapewetvrn_bcaaBbBBbaBaBbB'
+
+
+An interesting case where geodesic intersects triangulation in only one tetrahedron:
+
+    >>> Manifold("m019").drill_word('A').canonical_retriangulation().triangulation_isosig(ignore_orientation=False)
+    'gLLPQccdefffqffqqof_BaaBdcbb'
+
+A bug in an earlier implementation found by Nathan Dunfield (where putting the words in one order caused a failure):
+
+    >>> import sys
+    >>> original_limit = sys.getrecursionlimit()
+    >>> sys.setrecursionlimit(100000)
+    >>> def drilled_isosig(M, words):
+    ...     for i in range(10):
+    ...         try:
+    ...             F = M.drill_words(words).filled_triangulation()
+    ...             return F.canonical_retriangulation().triangulation_isosig(ignore_orientation=False)
+    ...         except RuntimeError:
+    ...             pass
+    >>> drilled_isosig(Manifold('K11n34(0,1)'), ['iFcdbEiFJ', 'iFJ'])
+    'zLLvLLwzAwPQMQzzQkcdgijkjplssrnrotqruvwyxyxyhsgnnighueqdniblsipklpxgcr_BcbDbBba'
+    >>> drilled_isosig(Manifold('K11n34(0,1)'), ['iFJ', 'iFcdbEiFJ'])
+    'zLLvLLwzAwPQMQzzQkcdgijkjplssrnrotqruvwyxyxyhsgnnighueqdniblsipklpxgcr_babBbaBcaB'
+    >>> sys.setrecursionlimit(original_limit)
+
+Stress test by using large perturbation. In particular, this is testing the
+case where two geodesic pieces are adjacent to the same triangle and we
+need to shorten before crushing. We do white-box testing (verbose = True)
+to make sure we really hit the shortening case.
+
+    >>> from snappy.drilling import perturb
+    >>> original_radius = perturb._tube_developing_radius
+    >>> perturb._tube_developing_radius = 1
+    >>> Manifold("m307").drill_word('dadadabCdada', verbose=True).isometry_signature(of_link=True) # doctest: +NUMERIC9
+    Tubes lower bound injectivity radius: 0.380575727320247
+    Number of geodesic pieces: [9]
+    Number of tets after subdividing: 45
+    Shortening geodesic by sweeping across triangle.
+    'oLLwQvvPQQcbeefgemnllnmnmlhhaaaaaahaaaaah_bBbabaab'
+    >>> Manifold("m320").drill_word('daaacDA', verbose=True).isometry_signature(of_link=True) # doctest: +NUMERIC9
+    Tubes lower bound injectivity radius: 0.397319067589326
+    Number of geodesic pieces: [9]
+    Number of tets after subdividing: 49
+    Shortening geodesic by sweeping across triangle.
+    'rLLPwAPvvPQQcccdfehgjiqpooqppqoqffaaaaaaaqaaaqaaa_bBbabaab'
+    >>> perturb._tube_developing_radius = original_radius
+
+"""
+
+from . import drill_words_implementation
+
+if not __doc__:
+    raise Exception("doc string with tests was not recognized.")

snappy/drilling/tracing.py

@@ -1,5 +1,3 @@
-from .geodesic_info import GeodesicInfo
-from .line import R13LineWithMatrix, distance_r13_lines
 from . import constants
 from . import epsilons
 from . import exceptions
@@ -7,6 +5,9 @@ from . import exceptions
 from ..snap.t3mlite import simplex, Tetrahedron, Mcomplex # type: ignore
 
 from ..hyperboloid import r13_dot # type: ignore
+from ..geometric_structure.geodesic.geodesic_start_point_info import GeodesicStartPointInfo
+from ..geometric_structure.geodesic.line import R13LineWithMatrix
+from ..geometric_structure.geodesic.check_away_from_core_curve import check_away_from_core_curve
 from ..exceptions import InsufficientPrecisionError # type: ignore
 
 from typing import Sequence, Optional, List
@@ -188,7 +189,7 @@ def compute_plane_intersection_param(
     return num / denom
 
 
-def trace_geodesic(geodesic : GeodesicInfo, verified : bool):
+def trace_geodesic(geodesic : GeodesicStartPointInfo, verified : bool):
     """
     Traces line segment through the tetrahedra in the hyperboloid
     model (though using time-like but not necessarily unit time-like vectors)
@@ -206,6 +207,8 @@ def trace_geodesic(geodesic : GeodesicInfo, verified : bool):
     too close to a core curve.
     """
 
+    obj_name = "Geodesic %s" % geodesic.word
+
     if geodesic.tet is None:
         raise ValueError(
             "Expected geodesic with tetrahedron to start tracing.")
@@ -290,7 +293,9 @@ def trace_geodesic(geodesic : GeodesicInfo, verified : bool):
                 "problem.")
 
         # Check geodesic does not intersect core curve - if line is given.
-        _verify_away_from_core_curve(line, tet, hit_face, epsilon)
+        if line is not None:
+            check_away_from_core_curve(
+                line.r13_line, tet, hit_face, epsilon, obj_name)
 
         # The crossing of the ray with the exit face is beyond the given
         # end point. Thus, we are at the last piece.
@@ -344,36 +349,3 @@ def trace_geodesic(geodesic : GeodesicInfo, verified : bool):
 
     raise exceptions.UnfinishedTraceGeodesicError(
         constants.trace_max_steps)
-
-
-def _verify_away_from_core_curve(line : Optional[R13LineWithMatrix],
-                                 tet : Tetrahedron,
-                                 face : int,
-                                 epsilon):
-    """
-    If the geodesic is intersecting a core curve, the tracing would
-    fail in that it would never reach the intersection point and thus
-    either hit the iteration limit or breaking down because of
-    rounding-errors.
-
-    This function is catching this case to give a meaningful exception
-    faster. It does so by computing the distance between the lift of
-    the geodesic we are tracing and the lifts of the core curve
-    corresponding to the vertices of the tetrahedra adjacent to the
-    given face.
-    """
-
-    if line is None:
-        return
-
-    for v in simplex.ZeroSubsimplices:
-        if not simplex.is_subset(v, face):
-            continue
-        core_curve : Optional[R13LineWithMatrix] = tet.core_curves.get(v)
-        if core_curve is None:
-            continue
-        d = distance_r13_lines(core_curve.r13_line,
-                               line.r13_line)
-
-        if not d > epsilon:
-            raise exceptions.GeodesicCloseToCoreCurve()

snappy/exceptions.py

@@ -1,13 +1,26 @@
-# Exceptions from the SnapPea kernel
 class SnapPeaFatalError(Exception):
     """
-    This exception is raised by SnapPy when the SnapPea kernel
-    encounters a fatal error.
+    Exception raised by SnapPy when the SnapPea kernel encounters a fatal
+    error.
     """
 
 
 class InsufficientPrecisionError(Exception):
     """
-    This exception is raised when a computation fails and is likely
-    to succeed if higher precision is used.
+    Exception raised when a computation fails and is likely to succeed if
+    higher precision is used.
     """
+
+
+class NonorientableManifoldError(ValueError):
+    """
+    Exception raised when a non-orientable manifold is given to a method
+    only supporting orientable manifolds.
+    """
+    def __init__(self, method_name, manifold):
+        self.method_name = method_name
+        self.manifold = manifold
+
+    def __str__(self):
+        return ('%s only supports orientable manifolds but %s is '
+                'non-orientable.') % (self.method_name, self.manifold)

snappy/exterior_to_link/barycentric_geometry.py

@@ -252,9 +252,7 @@ class BarycentricArc(Arc):
         zeros_e = self.end.zero_coordinates()
         if len(zeros_s) > 1 or len(zeros_e) > 1:
             return True
-        if len(set(zeros_s) & set(zeros_e)) > 0:
-            return True
-        return False
+        return bool(set(zeros_s) & set(zeros_e))
 
     def max_denom(self):
         rationals = list(self.start.vector) + list(self.end.vector)
@@ -344,7 +342,7 @@ class TetrahedronEmbedding():
 
 class TetrahedronEmbeddingCache():
     def __init__(self):
-        self.cache = dict()
+        self.cache = {}
 
     def __call__(self, arrow, vertex_images, bdry_map=None):
         if bdry_map is None:

snappy/exterior_to_link/main.py

@@ -3,6 +3,7 @@ Defines the main function `exterior_to_link`.
 """
 
 import random
+import typing
 from .exceptions import ExteriorToLinkError
 from .simplify_to_base_tri import good_simplification
 from . import put_in_S3
@@ -40,13 +41,13 @@ def filled_is_3sphere(manifold):
 
 
 def exterior_to_link(manifold,
-                     verbose=False,
-                     check_input=True,
-                     check_answer=True,
-                     careful_perturbation=True,
-                     simplify_link=True,
-                     pachner_search_tries=10,
-                     seed=None):
+                     verbose : bool = False,
+                     check_input : bool = True,
+                     check_answer : bool = True,
+                     careful_perturbation : bool = True,
+                     simplify_link : bool = True,
+                     pachner_search_tries :int = 10,
+                     seed : typing.Optional[int] = None) -> 'Link':
     """
     For a triangulation of the exterior of a link in the 3-sphere,
     return a planar diagram for the link.  The peripheral curves whose

snappy/exterior_to_link/mcomplex_with_link.py

@@ -155,7 +155,7 @@ def straighten_arcs(arcs):
     # keep track of where we most recently had success.
     offset = 0
     # We also keep track of arcs obstructing a given triangle
-    obstructions = dict()
+    obstructions = {}
     # Every success reduces the number of arcs by one, so
     # terminates.
     while success:
@@ -590,7 +590,7 @@ def add_core_arc_in_one_tet_solid_torus(mcomplex, tet):
     assert no_fixed_point(tet.Gluing[F2]) and no_fixed_point(tet.Gluing[F3])
     # c0, c1, c2, c3 = [QQ(x) for x in ['1/5', '1/7', '0', '23/35']]  # original
     # c0, c1, c2, c3 = [QQ(x) for x in ['21874/65536', '21841/65536', '0', '21821/65536']]
-    c0, c1, c2, c3 = [QQ(x) for x in ['1/3', '1/3', '0', '1/3']]
+    c0, c1, c2, c3 = (QQ(x) for x in ['1/3', '1/3', '0', '1/3'])
     p1 = BarycentricPoint(c0, c1, c2, c3)
     p2 = p1.permute(tet.Gluing[F2])
     tet.arcs = [BarycentricArc(p1, p2)]

snappy/exterior_to_link/rational_linear_algebra.py

@@ -17,7 +17,7 @@ use_pari_even_inside_sage = False
 from .. import sage_helper
 
 if sage_helper._within_sage and not use_pari_even_inside_sage:
-    from sage.all import QQ, RR, vector, matrix, VectorSpace
+    from ..sage_helper import QQ, RR, vector, matrix, VectorSpace
 
     def rational_sqrt(x):
         """

snappy/exterior_to_link/rational_linear_algebra_wrapped.py

@@ -16,7 +16,7 @@ Notes:
 This file is not currently used by SnapPy, but is kept for possible
 future reference.
 """
-from sage.all import QQ, vector, matrix, VectorSpace
+from ..sage_helper import QQ, vector, matrix, VectorSpace
 
 
 class Vector:

snappy/exterior_to_link/test.py

@@ -1,43 +1,31 @@
+from snappy import testing
 import snappy
-import sys
-import getopt
-from . import (rational_linear_algebra,
-               pl_utils,
-               barycentric_geometry,
-               hyp_utils,
-               link_projection,
-               mcomplex_with_memory,
-               mcomplex_with_expansion,
-               mcomplex_with_link,
-               simplify_to_base_tri,
-               put_in_S3,
-               main)
 
-modules = [rational_linear_algebra,
-           pl_utils,
-           barycentric_geometry,
-           hyp_utils,
-           link_projection,
-           mcomplex_with_memory,
-           mcomplex_with_expansion,
-           mcomplex_with_link,
-           simplify_to_base_tri,
-           put_in_S3,
-           main]
+from snappy import exterior_to_link
 
+modules = [
+    exterior_to_link.rational_linear_algebra,
+    exterior_to_link.pl_utils,
+    exterior_to_link.barycentric_geometry,
+    exterior_to_link.hyp_utils,
+    exterior_to_link.link_projection,
+    exterior_to_link.mcomplex_with_memory,
+    exterior_to_link.mcomplex_with_expansion,
+    exterior_to_link.mcomplex_with_link,
+    exterior_to_link.simplify_to_base_tri,
+    exterior_to_link.put_in_S3,
+    exterior_to_link.main
+]
 
 def run_doctests(verbose=False, print_info=True):
     globs = {'Manifold': snappy.Manifold,
              'Triangulation': snappy.Triangulation}
-    results = snappy.sage_helper.doctest_modules(modules,
-                                                 verbose=verbose,
-                                                 extraglobs=globs,
-                                                 print_info=print_info)
-    return results
+    return testing.doctest_modules(modules,
+                                   verbose=verbose,
+                                   print_info=print_info,
+                                   extraglobs=globs)
 
+run_doctests.__name__ = exterior_to_link.__name__
 
 if __name__ == '__main__':
-    optlist, args = getopt.getopt(sys.argv[1:], 'v', ['verbose'])
-    verbose = len(optlist) > 0
-    results = run_doctests(verbose)
-    sys.exit(results.failed)
+    testing.run_doctests_as_main(run_doctests)