snappy 3.1.1__cp39-cp39-macosx_11_0_arm64.whl → 3.2__cp39-cp39-macosx_11_0_arm64.whl

snappy/geometric_structure/geodesic/tiles_for_geodesic.py

@@ -0,0 +1,101 @@
+from .canonical_keys import canonical_keys_function_for_line
+from .geodesic_start_point_info import GeodesicStartPointInfo
+from .avoid_core_curves import replace_piece_in_core_curve_tube
+
+from ...tiling.tile import Tile, compute_tiles
+from ...tiling.lifted_tetrahedron_set import (LiftedTetrahedronSet,
+                                              get_lifted_tetrahedron_set)
+
+from ...snap.t3mlite import Mcomplex # type: ignore
+
+from typing import Sequence
+
+def compute_tiles_for_geodesic(mcomplex : Mcomplex,
+                               geodesic : GeodesicStartPointInfo,
+                               avoid_core_curves : bool = False,
+                               for_raytracing : bool = False
+                               ) -> Sequence[Tile]:
+    """
+    Computes all GeodesicPiece's needed to cover a tube about the
+    given closed geodesic in the given manifold. The geodesic cannot be
+    a core curve of a filled cusp.
+
+    A GeodesicTube is constructed from a triangulation with a suitable
+    geometric structure and a suitable GeodesicStartPointInfo object.
+
+    To add the necessary geometric structure to a triangulation, call
+    add_r13_geometry and add_r13_planes_to_tetrahedra.
+
+    The GeodesicStartPointInfo object needs to be constructed with a line and
+    GeodesicStartPointInfo.find_tet_or_core_curve be called on it.
+
+    Calling GeodesicStartPointInfo.add_pieces_for_radius will then add the
+    necessary pieces to GeodesicStartPointInfo.pieces to cover the tube of the
+    given radius.
+    """
+
+    if geodesic.core_curve_cusp is not None:
+        raise ValueError(
+            "Cannot tile a tube about a geodesic that is a core curve.")
+
+    if geodesic.line is None:
+        raise ValueError(
+            "Tiling a tube about a geodesic expected GeodesicStartPointInfo with valid "
+            "line.")
+
+    if not geodesic.lifted_tetrahedra:
+        raise ValueError(
+            "Tiling a tube about a geodesic expected GeodesicStartPointInfo with valid "
+            "lifted_tetrahedra.")
+
+    min_neg_prod_distinct = (mcomplex.baseTetInRadius/2).cosh()
+
+    if mcomplex.verified:
+        max_neg_prod_equal = min_neg_prod_distinct
+    else:
+        max_neg_prod_equal = min(
+            min_neg_prod_distinct, 1 + _compute_prod_epsilon(mcomplex.RF))
+        if for_raytracing:
+            min_neg_prod_distinct = max_neg_prod_equal
+
+    lifted_tetrahedron_set : LiftedTetrahedronSet = (
+        get_lifted_tetrahedron_set(
+            base_point=mcomplex.R13_baseTetInCenter,
+            canonical_keys_function=(
+                canonical_keys_function_for_line(geodesic.line)),
+            act_on_base_point_by_inverse=False,
+            max_neg_prod_equal=max_neg_prod_equal,
+            min_neg_prod_distinct=min_neg_prod_distinct,
+            verified=mcomplex.verified))
+
+    if avoid_core_curves:
+        replace_lifted_tetrahedron_function = replace_piece_in_core_curve_tube
+    else:
+        replace_lifted_tetrahedron_function = None
+
+    return compute_tiles(
+        geometric_object=geodesic.line.r13_line,
+        visited_lifted_tetrahedra=lifted_tetrahedron_set,
+        initial_lifted_tetrahedra=geodesic.lifted_tetrahedra,
+        replace_lifted_tetrahedron_function=replace_lifted_tetrahedron_function,
+        verified=mcomplex.verified)
+
+def _compute_prod_epsilon(RF):
+    p = RF.precision()
+
+    # We try to be a factor of at least several magnitudes smaller than
+    # 1/_compute_epsilon_inverse(RF) in hyperboloid_dict.py.
+    #
+    # This factor will even grow larger as the precision increases.
+    #
+    # That way, we will hopefully fail in _equality_predicate
+    # in hyperboloid_dict rather than failing by not hashing together
+    # lifted tetrahedra that should be the same but are not recognised
+    # as such because of numerical error.
+
+    result = RF(1e-6)
+    if p > 53:
+        result *= RF(0.5) ** ((p - 53) / 2)
+
+    return result
+    

snappy/geometric_structure/test.py

@@ -0,0 +1,22 @@
+from snappy import testing
+import snappy
+
+from snappy import geometric_structure
+
+modules = [
+    geometric_structure.cusp_neighborhood.cusp_cross_section_base,
+    geometric_structure.cusp_neighborhood.real_cusp_cross_section,
+    geometric_structure.cusp_neighborhood.complex_cusp_cross_section
+]
+
+def run_doctests(verbose=False, print_info=True):
+    globs = {'Manifold': snappy.Manifold}
+    return testing.doctest_modules(modules,
+                                   verbose=verbose,
+                                   print_info=print_info,
+                                   extraglobs=globs)
+
+run_doctests.__name__ = geometric_structure.__name__
+
+if __name__ == '__main__':
+    testing.run_doctests_as_main(run_doctests)

snappy/gui.py

@@ -4,21 +4,20 @@ import sys
 import time
 import tempfile
 import tkinter as Tk_
-from tkinter import ttk as ttk
+from tkinter import ttk
+from tkinter.ttk import Spinbox
 from tkinter.font import Font, families as font_families
 from tkinter.simpledialog import Dialog, SimpleDialog
 from plink.ipython_tools import IPythonTkRoot
 from . import filedialog
 
-if sys.version_info < (3, 7):
-    class Spinbox(ttk.Entry):
-        def __init__(self, container=None, **kw):
-            ttk.Entry.__init__(self, container, "ttk::spinbox", **kw)
-
-        def set(self, value):
-            self.tk.call(self._w, "set", value)
-else:
-    Spinbox = ttk.Spinbox
+    
+def nominal_font_dict(tk_font):
+    """
+    Like Font.actual() but not messed up by GNOME scaling factors on
+    Linux.
+    """
+    return {key:tk_font.cget(key) for key in tk_font.actual()}
 
 
 class SnapPyStyle:
@@ -41,10 +40,21 @@ class SnapPyStyle:
         else:
             self.windowBG = ttk_style.lookup('TLabelframe', 'background')
             self.groupBG = self.subgroupBG = self.windowBG
-        self.font = ttk_style.lookup('TLabel', 'font')
-        self.font_info = fi = Font(font=self.font).actual()
-        fi['size'] = abs(fi['size']) # Why would the size be negative???
 
+        self.font = ttk_style.lookup('TLabel', 'font')
+        if self.font == '':
+            self.font = 'TkDefaultFont'
+        # TLabel.font and TLabelframe.Label.font differ in Tk 9.0 (at
+        # least on macOS).  We restore the Tk 8.6 behavior.
+        self.ttk_style.configure('TLabelframe.Label',
+                                 font=self.font)
+        self.font_info = fi = nominal_font_dict(Font(font=self.font))
+        fi['size'] = int(str(fi['size']))
+        # On linux the treeview rows are too small, at least with hi-dpi displays.
+        if sys.platform == 'linux':
+            default_font = Font(name='TkDefaultFont', exists=True)
+            line_height = default_font.metrics()['linespace']
+            self.ttk_style.configure('Treeview', rowheight=line_height)
 
 class ViewerWindow(Tk_.Toplevel):
     def __init__(self, view_class, *args, **kwargs):

snappy/horoviewer.py

@@ -146,7 +146,7 @@ Use the View Options to select which components of the scene are drawn.
         self.scene = HoroballScene(nbhd, pgram_var, Ford_var, tri_var,
             horo_var, label_var, flipped=self.flip_var.get(), cutoff=self.cutoff,
             which_cusp=self.which_cusp,togl_widget=self.widget)
-        self.widget.redraw_impl = self.scene.draw
+        self.widget.draw_projection_impl = self.scene.draw
         if isinstance(parent, Tk_.Toplevel):
             parent.config(menu=self.menubar)
             # hacks needed on Sierra
@@ -174,7 +174,7 @@ Use the View Options to select which components of the scene are drawn.
             self.widget.set_background(0.3, 0.3, 0.4)
         else:
             self.widget.set_background(1.0, 1.0, 1.0)
-        self.widget.redraw_if_initialized()
+        self.widget.redraw()
 
     def build_sliders(self):
         nbhd = self.nbhd
@@ -264,7 +264,7 @@ Use the View Options to select which components of the scene are drawn.
             flipped=self.flip_var.get(), cutoff=self.cutoff,
             which_cusp=self.which_cusp, togl_widget=self.widget)
         assert(self.scene is not None)
-        self.widget.redraw_impl = self.scene.draw
+        self.widget.draw_projection_impl = self.scene.draw
         self.configure_sliders()
         self.rebuild()
 
@@ -278,7 +278,7 @@ Use the View Options to select which components of the scene are drawn.
         flipped = self.flip_var.get()
         self.scene.flip(flipped)
         self.widget.flipped = flipped
-        self.widget.redraw_if_initialized()
+        self.widget.redraw()
 
     def configure_sliders(self):
         nbhd = self.nbhd
@@ -331,7 +331,7 @@ Use the View Options to select which components of the scene are drawn.
         self.destroy()
 
     def redraw(self):
-        self.widget.redraw_if_initialized()
+        self.widget.redraw()
 
     def set_zoom(self, x):
         fovy = 1.0 + (100.0-float(x))/15.0
@@ -342,14 +342,14 @@ Use the View Options to select which components of the scene are drawn.
         else:
             self.update_idletasks()
             self.after(50, self.set_zoom, x)
-        self.widget.redraw_if_initialized()
+        self.widget.redraw()
 
     def rebuild(self, full_list=True):
         self.set_ties()
         self.configure_sliders()
         self.widget.make_current()
         self.scene.build_scene(which_cusp=self.which_cusp, full_list=full_list)
-        self.widget.redraw_if_initialized()
+        self.widget.redraw()
 
     def start_radius(self, event):
         self.cusp_moving = True

snappy/hyperboloid/__init__.py

@@ -1,9 +1,6 @@
-from ..matrix import vector, matrix
-from ..math_basics import is_RealIntervalFieldElement
-from ..sage_helper import _within_sage
+from ..matrix import make_vector, make_matrix, mat_solve
 
-if _within_sage:
-    import sage.all
+from ..sage_helper import _within_sage
 
 """
 hyperboloid contains methods relating to the hyperboloid model
@@ -40,27 +37,6 @@ def r13_dot(u, v):
     return -u[0]*v[0] + u[1]*v[1] + u[2]*v[2] + u[3]*v[3]
 
 
-def distance_unit_time_r13_points(u, v):
-    """
-    Computes the hyperbolic distance between two points (represented
-    by unit time vectors) in the hyperboloid model.
-    """
-
-    d = -r13_dot(u, v)
-
-    # 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.
-    if is_RealIntervalFieldElement(d):
-        RIF = d.parent()
-        d = d.intersection(RIF(1, sage.all.Infinity))
-    else:
-        if d < 1:
-            RF = d.parent()
-            d = RF(1)
-    return d.arccosh()
-
-
 def time_r13_normalise(u):
     """
     Given a time-like vector in Minkowski space, returns the normalised
@@ -94,6 +70,51 @@ def o13_inverse(m):
 
     return result
 
+def so13_to_pgl2c(B):
+    """
+    Given an SO13 matrix, returns corresponding complex 2x2-matrix.
+    The determinant of the result is not 1 in general.
+
+    Python implementation of O31_to_Moebius (without normalization).
+    """
+
+    AM0A_00 = B[0,0] + B[1,0]
+    AM1A_00 = B[0,1] + B[1,1]
+    aa = AM0A_00 + AM1A_00
+    bb = AM0A_00 - AM1A_00
+
+    if aa > bb:
+        return _to_complex_matrix(
+            aa,                0               ,
+            B[0,2] + B[1,2],   B[0,3] + B[1,3] ,
+
+            B[2,0] + B[2,1], -(B[3,0] + B[3,1]),
+            B[2,2] + B[3,3],   B[2,3] - B[3,2]   )
+    else:
+        return _to_complex_matrix(
+            B[0,2] + B[1,2], -(B[0,3] + B[1,3]),
+            bb             ,   0               ,
+            B[2,2] - B[3,3], -(B[2,3] + B[3,2]),
+            B[2,0] - B[2,1],   B[3,1] - B[3,0]   )
+
+def so13_to_psl2c(m):
+    """
+    Given an SO13 matrix, returns corresponding complex 2x2-matrix
+    with determinant 1.
+
+    Python implementation of O31_to_Moebius (with normalization).
+    """
+
+    A = so13_to_pgl2c(m)
+    return A / A.det().sqrt()
+
+def r13_to_klein(v):
+    """
+    Given a time-like or light-like vector, gives the respective point
+    in the Klein model or its boundary, respectively.
+    """
+
+    return make_vector([v[1] / v[0], v[2] / v[0], v[3] / v[0]])
 
 def unit_time_vector_to_o13_hyperbolic_translation(v):
     """
@@ -112,7 +133,7 @@ def unit_time_vector_to_o13_hyperbolic_translation(v):
     m[2][2] += 1
     m[3][3] += 1
 
-    return matrix(m)
+    return make_matrix(m)
 
 
 def unnormalised_plane_eqn_from_r13_points(pts):
@@ -123,10 +144,10 @@ def unnormalised_plane_eqn_from_r13_points(pts):
     three given points.
     """
 
-    return vector([  _det_shifted_matrix3(pts, 0),
-                     _det_shifted_matrix3(pts, 1),
-                   - _det_shifted_matrix3(pts, 2),
-                     _det_shifted_matrix3(pts, 3)])
+    return make_vector([  _det_shifted_matrix3(pts, 0),
+                          _det_shifted_matrix3(pts, 1),
+                        - _det_shifted_matrix3(pts, 2),
+                          _det_shifted_matrix3(pts, 3)])
 
 
 def _det_shifted_matrix3(m, i):
@@ -145,3 +166,47 @@ def _det_shifted_matrix3(m, i):
             - m[0][i2] * m[1][i1] * m[2][i0]
             - m[0][i0] * m[1][i2] * m[2][i1]
             - m[0][i1] * m[1][i0] * m[2][i2])
+
+def compute_inradius_and_incenter_from_planes(planes):
+    """
+    Given outside-facing normals for the four faces of a
+    tetrahedron, compute the hyperbolic inradius and the
+    incenter (as unit time vector) of the tetrahedron (in the
+    hyperboloid model).
+    """
+
+    # We need to c and r such that
+    #  * r13_dot(c, c) = -1 and
+    #  * r13_dot(plane, c) = -sinh(r) for every plane
+    #
+    # We instead solve for the following system of linear equations:
+    #  * r13_dot(plane, pt) = -1 for every plane
+
+    RF = planes[0][0].parent()
+    m = make_matrix([[-plane[0], plane[1], plane[2], plane[3]]
+                     for plane in planes])
+    v = make_vector([RF(-1), RF(-1), RF(-1), RF(-1)])
+
+    pt = mat_solve(m, v)
+
+    # And then use the inverse length of pt to scale pt to be
+    # a unit time vector and to compute the r.
+    scale = 1 / (-r13_dot(pt, pt)).sqrt()
+
+    return scale.arcsinh(), scale * pt
+
+def _to_complex_matrix(
+        a, b,    c, d,
+        e, f,    g, h):
+    RF = a.parent()
+    if _within_sage:
+        CF = RF.complex_field()
+        return make_matrix(
+            [ [ CF(a,b), CF(c, d) ],
+              [ CF(e,f), CF(g, h) ] ],
+            ring=CF)
+    else:
+        I = RF('I')
+        return make_matrix(
+            [ [ a + b * I, c + d * I ],
+              [ e + f * I, g + h * I ] ])

snappy/hyperboloid/distances.py

@@ -0,0 +1,245 @@
+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']
+
+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.
+    """
+
+    p = (r13_dot(line.points[0], pt) *
+         r13_dot(line.points[1], pt))
+    s = _safe_div(2 * p, -line.inner_product)
+    return _safe_arccosh(_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 is_RealIntervalFieldElement(p):
+        RIF = p.parent()
+        p = p.intersection(RIF(0, Infinity))
+    else:
+        if p < 0:
+            RF = p.parent()
+            return RF(0)
+    return p.sqrt()
+
+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(-1e20)
+    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(-1e20)
+    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 is_RealIntervalFieldElement(b):
+        RIF = b.parent()
+        if b == 0:
+            return RIF(Infinity)
+        else:
+            return a / b.intersection(RIF(0, Infinity))
+    else:
+        if b <= 0:
+            RIF = b.parent()
+            return RIF(1e20)
+        else:
+            return a / b
+

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)