snappy 3.3__cp310-cp310-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl

snappy/hyperboloid/distances.py

@@ -0,0 +1,259 @@
+from .triangle import R13IdealTriangle
+from .line import R13Line
+from .point import R13Point
+from .horoball import R13Horoball
+from . import r13_dot
+
+from ..math_basics import is_RealIntervalFieldElement # type: ignore
+from ..sage_helper import _within_sage # type: ignore
+
+if _within_sage:
+    from ..sage_helper import Infinity
+
+__all__ = ['distance_r13_lines',
+           'lower_bound_distance_r13_line_triangle']
+
+# Pick a value so that pari does not throw an exception when
+# computing exp(r) and arcsinh(exp(r)/2).
+#
+# Pari throws an overflow error for exp(1e-20) instead of just returning 0.
+# Pari throws an out of memory error for
+# snappy.number.Number('1e-1000000').arcsinh().
+# 
+_numeric_log_of_zero = -1e4
+
+def distance_r13_lines(line0 : R13Line, line1 : R13Line):
+    """
+    Computes distance between two hyperbolic lines.
+    """
+
+    p00 = r13_dot(line0.points[0], line1.points[0])
+    p01 = r13_dot(line0.points[0], line1.points[1])
+    p10 = r13_dot(line0.points[1], line1.points[0])
+    p11 = r13_dot(line0.points[1], line1.points[1])
+
+    pp = line0.inner_product * line1.inner_product
+
+    t0 = _safe_sqrt((p00 * p11) / pp)
+    t1 = _safe_sqrt((p01 * p10) / pp)
+
+    p = (t0 + t1 - 1) / 2
+
+    return 2 * _safe_sqrt(p).arcsinh()
+
+def distance_r13_horoballs(horoball_defining_vec0,
+                           horoball_defining_vec1):
+    p = -r13_dot(horoball_defining_vec0, horoball_defining_vec1) / 2
+    return _safe_log(p)
+
+def distance_r13_horoball_line(horoball_defining_vec, # Light-like
+                               line : R13Line):
+
+    p = (r13_dot(line.points[0], horoball_defining_vec) *
+         r13_dot(line.points[1], horoball_defining_vec))
+    s = -2 * p / line.inner_product
+
+    return _safe_log(s)/2
+
+def distance_r13_horoball_plane(horoball_defining_vec, # Light-like
+                                plane_defining_vec): # Unit space-like
+    p = r13_dot(horoball_defining_vec, plane_defining_vec)
+    return _safe_log_of_abs(p)
+
+def distance_r13_horoball_point(horoball_defining_vec, # Light-like
+                                pt): # Unit-time-like
+    p = r13_dot(horoball_defining_vec, pt)
+    return (-p).log()
+
+def distance_r13_point_line(pt, # Unit time-like
+                            line : R13Line):
+    """
+    This also works if line is degenerate and starts and ends at some point.
+    """
+
+    return _safe_arccosh(cosh_distance_r13_point_line(pt, line))
+
+def cosh_distance_r13_point_line(pt, # Unit time-like
+                                 line : R13Line):
+    p = (r13_dot(line.points[0], pt) *
+         r13_dot(line.points[1], pt))
+    s = _safe_div(2 * p, -line.inner_product)
+    return _safe_sqrt(s)
+
+def distance_r13_point_plane(pt, # Unit time-like
+                             plane_defining_vec): # Unit space-like
+    p = r13_dot(pt, plane_defining_vec)
+    return p.arcsinh().abs()
+
+def distance_r13_points(pt0, # Unit time-like
+                        pt1): # Unit time-like
+    """
+    Computes the hyperbolic distance between two points (represented
+    by unit time vectors) in the hyperboloid model.
+    """
+    p = r13_dot(pt0, pt1)
+
+    # Due to rounding errors, the resulting number or interval can be
+    # slightly less than 1 or contain numbers slightly less than 1,
+    # respectively - resulting in NaN's. Avoid this here.
+    return _safe_arccosh(-p)
+
+def lower_bound_distance_to_r13_triangle(
+        geometric_object, triangle : R13IdealTriangle, verified : bool):
+    if isinstance(geometric_object, R13Horoball):
+        return lower_bound_distance_r13_horoball_triangle(
+            geometric_object.defining_vec, triangle, verified)
+    if isinstance(geometric_object, R13Line):
+        return lower_bound_distance_r13_line_triangle(
+            geometric_object, triangle, verified)
+    if isinstance(geometric_object, R13Point):
+        return lower_bound_distance_r13_point_triangle(
+            geometric_object.point, triangle, verified)
+    raise ValueError(
+        "Distance between %r and triangle not supported" % geometric_object)
+
+def lower_bound_distance_r13_horoball_triangle(
+        horoball_defining_vec,
+        triangle : R13IdealTriangle, verified : bool):
+
+    if verified:
+        epsilon = 0
+    else:
+        RF = horoball_defining_vec[0].parent()
+        epsilon = _compute_epsilon(RF)
+
+    for bounding_plane, edge in zip(triangle.bounding_planes,
+                                    triangle.edges):
+        if r13_dot(horoball_defining_vec, bounding_plane) > epsilon:
+            return distance_r13_horoball_line(horoball_defining_vec, edge)
+
+    return distance_r13_horoball_plane(
+        horoball_defining_vec, triangle.plane)
+
+def lower_bound_distance_r13_line_triangle(
+        line : R13Line, triangle : R13IdealTriangle, verified : bool):
+
+    if verified:
+        epsilon = 0
+    else:
+        RF = line.points[0][0].parent()
+        epsilon = _compute_epsilon(RF)
+
+    a0 = r13_dot(triangle.plane, line.points[0])
+    a1 = r13_dot(triangle.plane, line.points[1])
+
+    abs0 = abs(a0)
+    abs1 = abs(a1)
+
+    pt = abs1 * line.points[0] + abs0 * line.points[1]
+
+    for bounding_plane, edge in zip(triangle.bounding_planes,
+                                    triangle.edges):
+        if r13_dot(pt, bounding_plane) > epsilon:
+            return distance_r13_lines(line, edge)
+
+    p = a0 * a1
+
+    if p > 0:
+        return (-2 * p / line.inner_product).sqrt().arcsinh()
+
+    RF = line.points[0][0].parent()
+    return RF(0)
+
+def lower_bound_distance_r13_point_triangle(
+        point,
+        triangle : R13IdealTriangle, verified : bool):
+
+    if verified:
+        epsilon = 0
+    else:
+        RF = point[0].parent()
+        epsilon = _compute_epsilon(RF)
+
+    for bounding_plane, edge in zip(triangle.bounding_planes,
+                                    triangle.edges):
+        if r13_dot(point, bounding_plane) > epsilon:
+            return distance_r13_point_line(point, edge)
+
+    return distance_r13_point_plane(point, triangle.plane)
+
+def _compute_epsilon(RF):
+    return RF(0.5) ** (RF.prec() // 2)
+
+def _safe_sqrt(p):
+    """
+    Compute the sqrt of a number that is known to be non-negative
+    though might not be non-negative because of floating point
+    issues. When using interval arithmetic, this means that
+    while the upper bound will be non-negative, the lower bound
+    we computed might be negative because it is too conservative.
+
+    Example of a quantity that can be given to this function:
+    negative inner product of two vectors in the positive
+    light cone. This is because we know that the inner product
+    of two such vectors is always non-positive.
+    """
+
+    if p >= 0:
+        return p.sqrt()
+
+    if is_RealIntervalFieldElement(p):
+        RIF = p.parent()
+        return p.intersection(RIF(0, Infinity)).sqrt()
+    else:
+        RF = p.parent()
+        return RF(0)
+
+def _safe_log(p):
+    if is_RealIntervalFieldElement(p):
+        RIF = p.parent()
+        p = p.intersection(RIF(0, Infinity))
+    else:
+        if p <= 0:
+            RF = p.parent()
+            return RF(_numeric_log_of_zero)
+    return p.log()
+
+def _safe_log_of_abs(p):
+    return _safe_log_non_neg(p.abs())
+
+def _safe_log_non_neg(p):
+    if p == 0:
+        if is_RealIntervalFieldElement(p):
+            RIF = p.parent()
+            return RIF(-Infinity)
+        else:
+            RF = p.parent()
+            return RF(_numeric_log_of_zero)
+    else:
+        return p.log()
+
+def _safe_arccosh(p):
+    if is_RealIntervalFieldElement(p):
+        RIF = p.parent()
+        p = p.intersection(RIF(1, Infinity))
+    else:
+        if p < 1:
+            RF = p.parent()
+            return RF(0)
+    return p.arccosh()
+
+def _safe_div(a, b):
+    """
+    Compute a / b where be is known to be non-negative and we should
+    return infinity if b is zero.
+    """
+
+    if b > 0:
+        return a / b
+    
+    if is_RealIntervalFieldElement(b):
+        RIF = b.parent()
+        if b == 0:
+            return RIF(Infinity)
+        else:
+            return a / b.intersection(RIF(0, Infinity))
+    else:
+        RIF = b.parent()
+        return RIF(1e20)
+

snappy/hyperboloid/horoball.py

@@ -0,0 +1,19 @@
+__all__ = ['R13Horoball']
+
+class R13Horoball:
+    """
+    Horoball defined by { x : r13_dot(x, l) > -1 } where l is a
+    light-like vector.
+    """
+
+    def __init__(self,
+                 defining_vec): # Light-like vector
+        self.defining_vec = defining_vec
+
+    def transformed(self,
+                    m): # O13-matrix
+        """
+        Returns image of the horoball under given O13-matrix m.
+        """
+
+        return R13Horoball(m * self.defining_vec)

snappy/hyperboloid/line.py

@@ -0,0 +1,35 @@
+from ..hyperboloid import r13_dot
+
+__all__ = [ 'R13Line' ]
+
+class R13Line:
+    """
+    A line in the hyperboloid model - represented by two
+    like-like vectors spanning the line.
+
+    For distance computations, the inner product between the two
+    vectors is stored as well.
+    """
+
+    def __init__(self,
+                 points, # Two light-like vectors
+                 inner_product=None): # Optional: their inner product
+        """
+        inner_product can be given if known, otherwise, will be computed.
+        """
+        self.points = points
+        if inner_product is None:
+            self.inner_product = r13_dot(points[0], points[1])
+        else:
+            self.inner_product = inner_product
+
+    def transformed(self,
+                    m): # O13-matrix
+        """
+        Returns image of the line under given O13-matrix m.
+        """
+
+        return R13Line(
+            [ m * point for point in self.points],
+            self.inner_product)
+

snappy/hyperboloid/point.py

@@ -0,0 +1,9 @@
+__all__ = [ 'R13Point' ]
+
+class R13Point:
+    def __init__(self, point):
+        self.point = point
+
+    def transformed(self,
+                    m): # O13-matrix
+        return R13Point(m * self.point)

snappy/hyperboloid/triangle.py

@@ -0,0 +1,29 @@
+from .line import R13Line
+from . import (time_r13_normalise,
+               space_r13_normalise,
+               r13_dot)
+
+from typing import Sequence
+
+__all__ = ['R13IdealTriangle']
+
+class R13IdealTriangle:
+    def __init__(self,
+                 plane, # one space-like normal vector
+                 bounding_planes, # three space-like normal vectors
+                 edges : Sequence[R13Line] # Same order as bounding_planes
+                 ):
+        self.plane = plane
+        self.bounding_planes = bounding_planes
+        self.edges = edges
+
+def triangle_bounding_plane(v_opp, v0, v1):
+    m = time_r13_normalise(
+        -(r13_dot(v1, v_opp) * v0 + r13_dot(v0, v_opp) * v1))
+
+    return _make_r13_unit_tangent_vector(m - v_opp, m)
+
+def _make_r13_unit_tangent_vector(direction, point):
+    s = r13_dot(direction, point)
+    return space_r13_normalise(direction + s * point)
+

snappy/infowindow.py

@@ -0,0 +1,65 @@
+# -*- coding: utf-8 -*-
+import sys
+import os
+import datetime
+from .gui import *
+from .version import version as SnapPy_version
+from IPython import __version__ as IPython_version
+
+snappy_path = os.path.dirname(__file__)
+icon_file = os.path.join(snappy_path, 'info_icon.gif')
+
+
+class InfoWindow(Tk_.Toplevel):
+    def __init__(self, root, title, content, root_attr_name):
+        self.root = root
+        self.root_attr_name = root_attr_name
+        setattr(root, root_attr_name, self)
+        Tk_.Toplevel.__init__(self, self.root, class_='snappy')
+        self.title(title)
+        self.content = content
+        self.image = Tk_.PhotoImage(file=icon_file)
+        self.style = SnapPyStyle()
+        self.body()
+
+    def body(self):
+        self.resizable(False, False)
+        box = ttk.Frame(self)
+        icon = ttk.Label(box, image=self.image)
+        icon.grid(row=0, column=0, pady=30, sticky=Tk_.N)
+        message = Tk_.Message(box, text=self.content)
+        message.grid(row=0, column=1, padx=20, pady=10)
+        box.pack()
+
+    def destroy(self):
+        if hasattr(self.root, self.root_attr_name):
+            delattr(self.root, self.root_attr_name)
+        Tk_.Toplevel.destroy(self)
+
+
+about_snappy_text = """
+For information on how to use SnapPy, please see the Help menu.
+
+SnapPy is a program for studying the topology and geometry of 3-manifolds, with a focus on hyperbolic structures. It was written by Marc Culler, Nathan Dunfield, Matthias Gӧrner, and Jeff Weeks, with additional contributions by many others.  Its homepage is
+
+     http://snappy.computop.org/
+
+This is version %s of SnapPy, running on Python %s using Tk %s and IPython %s.
+
+Development of SnapPy was made possible in part by generous support from the National Science Foundation of the United States.
+
+SnapPy is copyright © 2009-%d by Marc Culler, Nathan Dunfield, Matthias Gӧrner, Jeff Weeks, and others and is distributed under the GNU Public License, version 2 or later.
+""" % (SnapPy_version,
+       sys.version.split()[0],
+       Tk_.Tcl().eval('info patchlevel'),
+       IPython_version,
+       datetime.datetime.now().year)
+
+
+def about_snappy(window):
+    return InfoWindow(window, 'About SnapPy', about_snappy_text, 'about_snappy')
+
+
+if __name__ == '__main__':
+    root = Tk_.Tk()
+    info = InfoWindow(root, title='About SnapPy', content=about_snappy_text)