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

snappy/raytracing/finite_raytracing_data.py

@@ -1,7 +1,9 @@
 from snappy.snap import t3mlite as t3m
 from snappy import Triangulation
 
-from snappy.SnapPy import matrix, vector
+from ..matrix import make_matrix, make_vector
+
+from ..upper_halfspace import pgl2c_to_o13
 
 # We could use
 #
@@ -13,14 +15,14 @@ from snappy.SnapPy import matrix, vector
 try:
     import sage.all
     _within_sage = True
-except:
+except ImportError:
     _within_sage = False
     import decorator
 
 if _within_sage:
     from snappy.dev.vericlosed import compute_approx_hyperbolic_structure_orb
     from snappy.dev.vericlosed.polishApproxHyperbolicStructure import *
-    
+
     from snappy.dev.vericlosed.truncatedComplex import *
 
 from .hyperboloid_utilities import *
@@ -29,14 +31,18 @@ from .raytracing_data import *
 
 __all__ = ['FiniteRaytracingData']
 
+
 class FiniteRaytracingData(RaytracingData):
     @staticmethod
-    def from_triangulation(triangulation, weights = None):
+    def from_triangulation(triangulation, weights=None):
+
+        if not _within_sage:
+            raise Exception("Only supported within SageMath :(")
 
         hyperbolic_structure = compute_approx_hyperbolic_structure_orb(triangulation)
         hyperbolic_structure.pick_exact_and_var_edges()
         hyperbolic_structure = polish_approx_hyperbolic_structure(
-            hyperbolic_structure, bits_prec = 212)
+            hyperbolic_structure, bits_prec=212)
 
         r = FiniteRaytracingData(hyperbolic_structure)
 
@@ -54,7 +60,7 @@ class FiniteRaytracingData(RaytracingData):
         return r
 
     def __init__(self, hyperbolic_structure):
-        super(FiniteRaytracingData, self).__init__(
+        super().__init__(
             hyperbolic_structure.mcomplex)
 
     def _compute_matrices(self, hyperbolic_structure):
@@ -63,11 +69,11 @@ class FiniteRaytracingData(RaytracingData):
                 hyperbolic_structure, tet.Index)
 
     def _compute_tet_vertices(self):
-        c = vector(self.RF, [1, 0, 0, 0])
-        
+        c = make_vector([1, 0, 0, 0], ring=self.RF)
+
         def _compute_vertex(tet, perm):
             m = tet.permutahedron_matrices[perm]
-            return GL2C_to_O13(_adjoint(m)) * c
+            return pgl2c_to_o13(_adjoint(m)) * c
 
         for tet in self.mcomplex.Tetrahedra:
             tet.R13_vertices = {
@@ -77,12 +83,12 @@ class FiniteRaytracingData(RaytracingData):
                 t3m.V3 : _compute_vertex(tet, (3,0,1,2)) }
 
     def _compute_edge_ends(self):
-        cs = [ vector(self.RF,[1,  1, 0, 0]),
-               vector(self.RF,[1, -1, 0, 0]) ]
+        cs = [ make_vector([1,  1, 0, 0], ring=self.RF),
+               make_vector([1, -1, 0, 0], ring=self.RF) ]
 
         def _compute_edge_ends(tet, perm):
             m = tet.permutahedron_matrices[perm]
-            return [ GL2C_to_O13(_adjoint(m)) * c for c in cs ]
+            return [ pgl2c_to_o13(_adjoint(m)) * c for c in cs ]
 
         for tet in self.mcomplex.Tetrahedra:
             tet.R13_edge_ends = {
@@ -94,12 +100,12 @@ class FiniteRaytracingData(RaytracingData):
                 t3m.E23 : _compute_edge_ends(tet, (2,3,0,1)) }
 
     def _compute_planes(self):
-        c = vector(self.RF, [0.0, 0.0, 0.0, -1.0])
+        c = make_vector([0.0, 0.0, 0.0, -1.0], ring=self.RF)
 
         def _compute_plane(tet, perm):
             m = tet.permutahedron_matrices[perm]
-            v = c * GL2C_to_O13(m)
-            return vector([-v[0], v[1], v[2], v[3]])
+            v = c * pgl2c_to_o13(m)
+            return make_vector([-v[0], v[1], v[2], v[3]])
 
         for tet in self.mcomplex.Tetrahedra:
             tet.R13_planes = {
@@ -119,10 +125,10 @@ class FiniteRaytracingData(RaytracingData):
             for F in t3m.TwoSubsimplices:
                 for V in t3m.ZeroSubsimplices:
                     if V & F:
-                        v0 = tet.O13_matrices[F] * vector(tet.R13_vertices[V])
+                        v0 = tet.O13_matrices[F] * make_vector(tet.R13_vertices[V])
                         v1 = tet.Neighbor[F].R13_vertices[tet.Gluing[F].image(V)]
 
-                        if abs(R13_dot(v0, v1) - (-1.0)) > 1e-6:
+                        if abs(r13_dot(v0, v1) - (-1.0)) > 1e-6:
                             print("Inconsistency ", tet.Index, F)
                             print(v0)
                             print(v1)
@@ -130,7 +136,7 @@ class FiniteRaytracingData(RaytracingData):
     def get_uniform_bindings(self):
         # self._check_consistency()
 
-        d = super(FiniteRaytracingData, self).get_uniform_bindings()
+        d = super().get_uniform_bindings()
         d['TetrahedraEdges.R13EdgeEnds'] = (
             'vec4[]',
             [ edge_end
@@ -147,69 +153,74 @@ class FiniteRaytracingData(RaytracingData):
         return d
 
     def get_compile_time_constants(self):
-        d = super(FiniteRaytracingData, self).get_compile_time_constants()
+        d = super().get_compile_time_constants()
         d[b'##finiteTrig##'] = 1
         return d
 
     def initial_view_state(self):
-        boost = matrix([[1.0,0.0,0.0,0.0],
-                        [0.0,1.0,0.0,0.0],
-                        [0.0,0.0,1.0,0.0],
-                        [0.0,0.0,0.0,1.0]])
+        boost = make_matrix([[1.0,0.0,0.0,0.0],
+                             [0.0,1.0,0.0,0.0],
+                             [0.0,0.0,1.0,0.0],
+                             [0.0,0.0,0.0,1.0]])
         tet_num = 0
         weight = 0.0
         return (boost, tet_num, weight)
 
-################################################################3
+# 3
 #
 # Helpers
 #
 
+
 _face_to_perm = {
     t3m.F0: t3m.Perm4((1,3,2,0)),
     t3m.F1: t3m.Perm4((0,2,3,1)),
     t3m.F2: t3m.Perm4((0,3,1,2)),
     t3m.F3: t3m.Perm4((0,1,2,3))}
 
+
 def _compute_face_pairing(tet, F):
     tet_perm = _face_to_perm[F]
     m = tet.permutahedron_matrices[tet_perm.tuple()]
-    
+
     other_tet_perm = tet.Gluing[F] * tet_perm
     other_tet = tet.Neighbor[F]
     other_m = other_tet.permutahedron_matrices[other_tet_perm.tuple()]
-    
-    return GL2C_to_O13(_adjoint(other_m) * m)
+
+    return pgl2c_to_o13(_adjoint(other_m) * m)
+
 
 def _adjoint(m):
-    return matrix([[ m[1,1],-m[0,1]],
-                   [-m[1,0], m[0,0]]])
+    return make_matrix([[ m[1,1],-m[0,1]],
+                        [-m[1,0], m[0,0]]])
+
 
 _new_perm_edge_type_old_perm = [
     ((1, 0, 2, 3), 'alpha', t3m.Perm4((0, 1, 2, 3))),
-    ((0, 2, 1, 3), 'beta',  t3m.Perm4((0, 1, 2, 3))),
+    ((0, 2, 1, 3), 'beta', t3m.Perm4((0, 1, 2, 3))),
     ((0, 1, 3, 2), 'gamma', t3m.Perm4((0, 1, 2, 3))),
-    ((1, 2, 0, 3), 'beta',  t3m.Perm4((1, 0, 2, 3))),
+    ((1, 2, 0, 3), 'beta', t3m.Perm4((1, 0, 2, 3))),
     ((1, 0, 3, 2), 'gamma', t3m.Perm4((1, 0, 2, 3))),
     ((2, 0, 1, 3), 'alpha', t3m.Perm4((0, 2, 1, 3))),
     ((0, 2, 3, 1), 'gamma', t3m.Perm4((0, 2, 1, 3))),
-    ((0, 3, 1, 2), 'beta',  t3m.Perm4((0, 1, 3, 2))),
+    ((0, 3, 1, 2), 'beta', t3m.Perm4((0, 1, 3, 2))),
     ((2, 1, 0, 3), 'alpha', t3m.Perm4((1, 2, 0, 3))),
     ((1, 2, 3, 0), 'gamma', t3m.Perm4((1, 2, 0, 3))),
-    ((1, 3, 0, 2), 'beta',  t3m.Perm4((1, 0, 3, 2))),
+    ((1, 3, 0, 2), 'beta', t3m.Perm4((1, 0, 3, 2))),
     ((2, 0, 3, 1), 'gamma', t3m.Perm4((2, 0, 1, 3))),
-    ((0, 3, 2, 1), 'beta',  t3m.Perm4((0, 2, 3, 1))),
+    ((0, 3, 2, 1), 'beta', t3m.Perm4((0, 2, 3, 1))),
     ((3, 0, 1, 2), 'alpha', t3m.Perm4((0, 3, 1, 2))),
     ((2, 1, 3, 0), 'gamma', t3m.Perm4((2, 1, 0, 3))),
-    ((1, 3, 2, 0), 'beta',  t3m.Perm4((1, 2, 3, 0))),
+    ((1, 3, 2, 0), 'beta', t3m.Perm4((1, 2, 3, 0))),
     ((3, 1, 0, 2), 'alpha', t3m.Perm4((1, 3, 0, 2))),
-    ((2, 3, 0, 1), 'beta',  t3m.Perm4((2, 0, 3, 1))),
+    ((2, 3, 0, 1), 'beta', t3m.Perm4((2, 0, 3, 1))),
     ((3, 0, 2, 1), 'alpha', t3m.Perm4((0, 3, 2, 1))),
-    ((2, 3, 1, 0), 'beta',  t3m.Perm4((2, 1, 3, 0))),
+    ((2, 3, 1, 0), 'beta', t3m.Perm4((2, 1, 3, 0))),
     ((3, 1, 2, 0), 'alpha', t3m.Perm4((1, 3, 2, 0))),
     ((3, 2, 0, 1), 'alpha', t3m.Perm4((2, 3, 0, 1))),
     ((3, 2, 1, 0), 'alpha', t3m.Perm4((2, 3, 1, 0))) ]
 
+
 def _matrices_for_tet(hyperbolic_structure, tet_num):
     RF = hyperbolic_structure.vertex_gram_matrices[0].base_ring()
     CF = RF.complex_field()
@@ -224,4 +235,3 @@ def _matrices_for_tet(hyperbolic_structure, tet_num):
         matrices[new_perm] = m * matrices[old_perm.tuple()]
 
     return matrices
-