Fixed tests since precision for periods is lower than expected

Author: mmasdeu

darmonpoints/meromorphic.py

@@ -304,6 +304,6 @@ def _element_constructor_(self, data, param, check=True):
 
     def _repr_(self):
         return (
-            "Meromorphic Multiplicative Functions over %s with parameter %s, p = %s and prec = %s"
-            % (self._base_ring, self._parameter, self._p, self._prec)
+            "Meromorphic Multiplicative Functions over %s with p = %s and prec = %s"
+            % (self._base_ring, self._p, self._prec)
         )

darmonpoints/schottky.py

@@ -30,6 +30,21 @@
 
 infinity = Infinity
 
+def matrix_from_balls(Bp,Bm):
+    K = Bp.parent().base_ring()
+    pi = K.uniformizer()
+    a = K(Bp.center).lift_to_precision()
+    b = K(Bm.center).lift_to_precision()
+    r1 = Bp.radius
+    r2 = Bm.radius
+    delta = Matrix(K,2,2,[1, -a, 1, -b])
+    r = ZZ((delta*Bp).radius - (delta*Bm).radius)
+    gamma0 = Matrix(K,2,2,[pi**-r,0,0,1])
+    gamma = delta.adjugate()*gamma0*delta
+    detval = gamma.determinant().valuation()
+    gamma = pi**ZZ((-detval/2).round()) * gamma
+    assert gamma0 * delta * Bp.complement() == delta * Bm.closure()
+    return gamma
 
 def reduce_word(w):
     r = []
@@ -834,11 +849,11 @@ def period(self, i, j, prec, **kwargs):
         sage: q00 = G.period(0,0, prec)
         sage: q01 = G.period(0,1, prec)
         sage: q11 = G.period(1,1, prec)
-        sage: (q00g/q00-1).valuation() > prec
+        sage: (q00g-q00).valuation() >= prec
         True
-        sage: (q01g/q01-1).valuation() > prec
+        sage: (q01g-q01).valuation() >= prec
         True
-        sage: (q11g/q11-1).valuation() > prec
+        sage: (q11g-q11).valuation() >= prec
         True
         """
         g = len(self._generators)

darmonpoints/theta.py

@@ -228,7 +228,7 @@ def evaluate(self, z, **kwargs):
             z0, wd = G.to_fundamental_domain(z)
             wdab = word_to_abelian(wd, len(G.generators()))
             ans *= prod(
-                G.u_function(g, self.prec).evaluate(self.D, recursive=False) ** i
+                G._u_function(g, self.prec, None).evaluate(self.D, recursive=False) ** i
                 for g, i in zip(G.generators(), wdab)
                 if i != 0
             )