fix

Author: guojing0

src/sage/rings/number_field/number_field.py

@@ -9292,107 +9292,45 @@ def minkowski_embedding(self, B=None, prec=None):
 
         return sage.matrix.all.matrix(d)
 
-def logarithmic_embedding(self, prec=53):
-    """
-    Return the morphism of ``self`` under the logarithmic embedding
-    in the category Set.
-
-    The logarithmic embedding is defined as a map from the number field ``self`` to `\RR^n`.
-
-    It is defined under Definition 4.9.6 in [Cohen1993]_.
-
-    INPUT:
-
-    - ``prec`` -- desired floating point precision.
-
-    OUTPUT:
-
-    - a tuple of real numbers.
-
-    EXAMPLES::
-
-        sage: CF.<a> = CyclotomicField(97)
-        sage: hom = Hom(CF, EuclideanSpace(1), Sets())
-        sage: f = hom(logarithmic_embedding(CF(0)))
-        sage: f(0)
-        (-1)
-        sage: f(7)
-        (1.94591014905531)
-
-    ::
-
-        sage: F.<a> = NumberField(x^3 + 5)
-        sage: K.<b> = F.extension(x^2 + 2)
-        sage: hom = Hom(K, EuclideanSpace(2), Sets())
-        sage: f = hom(logarithmic_embedding(K(0)))
-        sage: f(0)
-        (-1, -1)
-        sage: f(7)
-        (1.94591014905531, 3.89182029811063)
-    """
-    log_map = self._logarithmic_embedding_helper(prec)
-    log_hom = Hom(self.base_ring(), EuclideanSpace(len(log_map(0))), Sets())
-    return log_hom(K(0)._logarithmic_embedding_helper)
-
-def _logarithmic_embedding_helper(self, prec=53):
-    """
-    Return the image of ``self`` under the logarithmic embedding.
-
-    The logarithmic embedding is defined as a map from the number field ``self`` to `\RR^n`.
-
-    It is defined under Definition 4.9.6 in [Cohen1993]_.
-
-    INPUT:
-
-    - ``prec`` -- desired floating point precision.
+    def logarithmic_embedding(self, prec=53):
+        """
+        Return the morphism of ``self`` under the logarithmic embedding
+        in the category Set.
 
-    OUTPUT:
+        The logarithmic embedding is defined as a map from the number field ``self`` to `\RR^n`.
 
-    - a tuple of real numbers.
+        It is defined under Definition 4.9.6 in [Cohen1993]_.
 
-    EXAMPLES::
+        INPUT:
 
-        sage: CF.<a> = CyclotomicField(97)
-        sage: log_map = CF.logarithmic_embedding()
-        sage: log_map(0)
-        (-1)
-        sage: log_map(7)
-        (1.94591014905531)
+        - ``prec`` -- desired floating point precision.
 
-    ::
+        OUTPUT:
 
-        sage: F.<a> = NumberField(x^3 + 5)
-        sage: K.<b> = F.extension(x^2 + 2)
-        sage: log_map = K.logarithmic_embedding()
-        sage: log_map(0)
-        (-1, -1)
-        sage: log_map(7)
-        (1.94591014905531, 3.89182029811063)
-    """
-    def closure_map(x):
-        """
-        The function closure of the logarithmic embedding.
-        """
-        K = self.base_ring()
-        K_embeddings = K.places(prec)
-        r1, r2 = K.signature()
-        r = r1 + r2 - 1
+        - a tuple of real numbers.
 
-        Reals = RealField(prec)
+        EXAMPLES::
 
-        if x == 0:
-            return vector([-1 for _ in range(r + 1)])
+            sage: CF.<a> = CyclotomicField(97)
+            sage: f = CF(0).logarithmic_embedding()
+            sage: f(0)
+            (-1)
+            sage: f(7)
+            (1.94591014905531)
 
-        x_logs = []
-        for i in range(r1):
-            sigma = K_embeddings[i]
-            x_logs.append(Reals(abs(sigma(x))).log())
-        for i in range(r1, r + 1):
-            tau = K_embeddings[i]
-            x_logs.append(2 * Reals(abs(tau(x))).log())
+        ::
 
-        return vector(x_logs)
-    return closure_map
+            sage: F.<a> = NumberField(x^3 + 5)
+            sage: K.<b> = F.extension(x^2 + 2)
+            sage: f = K(0).logarithmic_embedding()
+            sage: f(0)
+            (-1, -1)
+            sage: f(7)
+            (1.94591014905531, 3.89182029811063)
+        """
+        log_map = self._NumberFieldElement_logarithmic_embedding_helper(prec)
+        log_hom = Hom(self.base_ring(), EuclideanSpace(len(log_map(0))), Sets())
+        return log_hom(K(0)._NumberFieldElement_logarithmic_embedding_helper)
 
     def places(self, all_complex=False, prec=None):
         r"""

src/sage/rings/number_field/number_field_element.pyx

@@ -4117,6 +4117,66 @@ cdef class NumberFieldElement(FieldElement):
         """
         return (self.global_height_non_arch(prec)+self.global_height_arch(prec))/self.number_field().absolute_degree()
 
+    def _logarithmic_embedding_helper(self, prec=53):
+            """
+            Return the image of ``self`` under the logarithmic embedding.
+
+            The logarithmic embedding is defined as a map from the number field ``self`` to `\RR^n`.
+
+            It is defined under Definition 4.9.6 in [Cohen1993]_.
+
+            INPUT:
+
+            - ``prec`` -- desired floating point precision.
+
+            OUTPUT:
+
+            - a tuple of real numbers.
+
+            EXAMPLES::
+
+                sage: CF.<a> = CyclotomicField(97)
+                sage: log_map = CF._logarithmic_embedding_helper()
+                sage: log_map(0)
+                (-1)
+                sage: log_map(7)
+                (1.94591014905531)
+
+            ::
+
+                sage: F.<a> = NumberField(x^3 + 5)
+                sage: K.<b> = F.extension(x^2 + 2)
+                sage: log_map = K._logarithmic_embedding_helper()
+                sage: log_map(0)
+                (-1, -1)
+                sage: log_map(7)
+                (1.94591014905531, 3.89182029811063)
+            """
+            def closure_map(x):
+                """
+                The function closure of the logarithmic embedding.
+                """
+                K = self.base_ring()
+                K_embeddings = K.places(prec)
+                r1, r2 = K.signature()
+                r = r1 + r2 - 1
+
+                Reals = RealField(prec)
+
+                if x == 0:
+                    return vector([-1 for _ in range(r + 1)])
+
+                x_logs = []
+                for i in range(r1):
+                    sigma = K_embeddings[i]
+                    x_logs.append(Reals(abs(sigma(x))).log())
+                for i in range(r1, r + 1):
+                    tau = K_embeddings[i]
+                    x_logs.append(2 * Reals(abs(tau(x))).log())
+
+                return vector(x_logs)
+            return closure_map
+
     def numerator_ideal(self):
         """
         Return the numerator ideal of this number field element.