Add MutableOrientedHyperbolicSurface

doc/examples/graphics_configuration.md

@@ -12,6 +12,8 @@ kernelspec:
   name: sagemath
 ---
 
+# TODO: Update these examples and make sure that all parameters understood by graphical surfaces are documented here.
+
 # Graphics Configuration
 
 ## Rearranging Polygons

doc/examples/straight_line_flow.md

@@ -49,17 +49,17 @@ TB = s.tangent_bundle()
 jupyter:
   outputs_hidden: false
 ---
-baricenter = sum(s.polygon(0).vertices()) / 5
+barycenter = sum(s.polygon(0).vertices()) / 5
 ```
 
-Define the tangent vector based at the baricenter of polygon 0 aimed downward.
+Define the tangent vector based at the barycenter of polygon 0 aimed downward.
 
 ```{code-cell}
 ---
 jupyter:
   outputs_hidden: true
 ---
-v = TB(0, baricenter, (0, -1))
+v = TB(0, barycenter, (0, -1))
 ```
 
 Convert to a straight-line trajectory. Trajectories are unions of segments in polygons.
@@ -117,7 +117,7 @@ Lets do it again but in the slope one direction.
 jupyter:
   outputs_hidden: false
 ---
-v = TB(0, baricenter, (1, 1))
+v = TB(0, barycenter, (1, 1))
 ```
 
 ```{code-cell}

doc/news/hyperbolic_surface.rst

@@ -0,0 +1,39 @@
+**Added:**
+
+* Added ``is_right_triangle()`` and ``is_isosceles_triangle()`` to polygons.
+
+* Added categories for hyperbolic surfaces, namely ``HyperbolicPolygonalSurfaces`` and ``HyperbolicIsometrySurfaces``.
+
+* Added ``angle()`` method to points on a surface to return the total angle at a point.
+
+* Added ``adjacencies()`` method to polygons that reports the edges adjacent to the vertices in order. This is necessary for hyperbolic polygons of infinite area where some vertices might not be adjacent to two edges.
+
+**Changed:**
+
+* Changed surface plotting quite a bit to make the same code work for hyperbolic surfaces and similarity surfaces. Edge labels can now only be configured differently for adjacent edges, non-adjacent edges, self-glued edges, and boundary edges. The new defaults there should make it much easier to interactively build a surface.
+
+**Fixed:**
+
+* Fixed merging of hyperbolic sets of vertices.
+
+* Fixed ``vertices()`` of hyperbolic polygons with marked vertices in some edge cases.
+
+* Fixed ``angle(numerical=True)`` of polygons which are now consistently returned as elements in RR.
+
+* Fixed implementation of ``an_element()`` for testing to also create points on non-similarity surfaces.
+
+* Fixed vectors returned by methods. The returned vectors are now immutable in more places.
+
+* Fixed computation of pole of hyperbolic geodesics so it works without extending the base ring.
+
+* Fixed handling of points at vertices of surfaces with boundary.
+
+* Fixed complicated printing of hyperbolic segments. Now, segments are printed as ``start → end`` instead of giving the intersection of the half planes that define the segment.
+
+**Deprecated:**
+
+* Deprecated ``angles()`` method of surfaces.
+
+**Removed:**
+
+* Removed ``plot_polygon()`` on surfaces. All plotting is now in graphical surfaces. (This function can largely be emulated by hiding all but one polygon in a graphical surface before plotting.)

flatsurf/__init__.py

@@ -19,7 +19,7 @@
     translation_surfaces,
 )
 
-from flatsurf.geometry.surface import MutableOrientedSimilaritySurface
+from flatsurf.geometry.surface import MutableOrientedSimilaritySurface, MutableOrientedHyperbolicSurface
 
 from flatsurf.geometry.gl2r_orbit_closure import GL2ROrbitClosure
 

flatsurf/geometry/categories/__init__.py

@@ -137,7 +137,7 @@
     sage: TranslationSurfaces.FiniteType.WithoutBoundary.ParentMethods.stratum(S)
     Traceback (most recent call last):
     ...
-    AttributeError: ... no attribute 'angles'
+    AttributeError: ... no attribute 'angle'
 
 So this approach is quite brittle and might need a mix with the above to work::
 
@@ -171,7 +171,11 @@
 from flatsurf.geometry.categories.euclidean_polygonal_surfaces import (
     EuclideanPolygonalSurfaces,
 )
+from flatsurf.geometry.categories.hyperbolic_polygonal_surfaces import (
+    HyperbolicPolygonalSurfaces,
+)
 from flatsurf.geometry.categories.similarity_surfaces import SimilaritySurfaces
+from flatsurf.geometry.categories.hyperbolic_isometry_surfaces import HyperbolicIsometrySurfaces
 from flatsurf.geometry.categories.cone_surfaces import ConeSurfaces
 from flatsurf.geometry.categories.dilation_surfaces import DilationSurfaces
 from flatsurf.geometry.categories.half_translation_surfaces import (

flatsurf/geometry/categories/cone_surfaces.py

@@ -202,6 +202,72 @@ def _is_cone_surface(surface, limit=None):
 
             return True
 
+    class ElementMethods:
+        r"""
+        Provides methods available to all points on cone surfaces.
+
+        If you want to add methods to such points, you most likely want to put
+        them here.
+        """
+
+        def angle(self, numerical=False):
+            r"""
+            Return the total angle at this ``point`` in multiples of 2π.
+
+            INPUT:
+
+            - ``numerical`` -- a boolean (default: ``False``); whether to
+              return a numerical approximation or the exact angle.
+
+            EXAMPLES::
+
+                sage: from flatsurf import polygons, similarity_surfaces
+                sage: T = polygons.triangle(3, 4, 5)
+                sage: S = similarity_surfaces.billiard(T)
+                sage: [v.angle() for v in S.vertices()]
+                [1/4, 5/12, 1/3]
+
+                sage: [v.angle(numerical=True) for v in S.vertices()]
+                [0.250000000000000, 0.416666666666667, 0.333333333333333]
+
+            At an interior point of a polygon the total angle is 2π::
+
+                sage: p = S(0, S.polygon(0).centroid())
+                sage: p.angle()
+                1
+
+            """
+            surface = self.parent()
+
+            if numerical:
+                from sage.all import RR
+                angle = RR(0)
+            else:
+                from sage.all import ZZ
+                angle = ZZ(0)
+
+            if not self.is_vertex():
+                label, coordinates = self.representative()
+                position = surface.polygon(label).get_point_position(coordinates)
+                if position.is_in_interior():
+                    angle += 1
+                elif surface.opposite_edge(label, position.get_edge()) == (label, position.get_edge()):
+                    # point on self-glued edge
+                    from sage.all import ZZ
+                    angle += ZZ(1) / 2
+                else:
+                    # point on non-self-glued edge
+                    angle += 1
+
+                return angle
+
+            for label, edge in self.edges():
+                angle += surface.polygon(label).angle(edge, numerical=numerical)
+                if surface.opposite_edge(label, edge) is None:
+                    raise ValueError("vertex at boundary does not have a total angle")
+
+            return angle
+
     class FiniteType(SurfaceCategoryWithAxiom):
         r"""
         The category of cone surfaces built from finitely many polygons.
@@ -326,6 +392,9 @@ def angles(self, numerical=False, return_adjacent_edges=False):
                             sage: T = polygons.triangle(3, 4, 5)
                             sage: S = similarity_surfaces.billiard(T)
                             sage: S.angles()
+                            doctest:warning
+                            ...
+                            UserWarning: angles() has been deprecated and will be removed in a future version of sage-flatsurf; use [vertex.angle() for vertex in self.vertices()] instead; if you need the adjacent edges use vertex.edges().
                             [1/3, 1/4, 5/12]
                             sage: S.angles(numerical=True)   # abs tol 1e-14
                             [0.333333333333333, 0.250000000000000, 0.416666666666667]
@@ -334,6 +403,9 @@ def angles(self, numerical=False, return_adjacent_edges=False):
                             [(1/3, [(0, 1), (1, 2)]), (1/4, [(0, 0), (1, 0)]), (5/12, [(1, 1), (0, 2)])]
 
                         """
+                        import warnings
+                        warnings.warn("angles() has been deprecated and will be removed in a future version of sage-flatsurf; use [vertex.angle() for vertex in self.vertices()] instead; if you need the adjacent edges use vertex.edges().")
+
                         if not numerical and any(
                             not p.is_rational() for p in self.polygons()
                         ):
@@ -440,6 +512,6 @@ def _test_genus(self, **options):
 
                             tester.assertAlmostEqual(
                                 self.genus(),
-                                sum(a - 1 for a in self.angles(numerical=True)) / 2.0
+                                float(sum(v.angle(numerical=True) - 1 for v in self.vertices()) / 2.0)
                                 + 1,
                             )