Ticket #3674: sage-trac3674new-extra2.patch

a/sage/schemes/elliptic_curves/ell_point.py

@@ -818 +818 @@
-        if disc < 0: #Connected Case
-            # Here we use formulae equivalent to those in Cohen, but better
-            # behaved when roots are close together
+
+            # For some curves (e.g. 3314b3) the default precision is not enough!
+            while len(real_roots)!=1:
+                precision*=2
+                RR=rings.RealField(precision)
+                real_roots = pol.roots(RR,multiplicities=False) 
-            try:
-                assert len(real_roots) == 1
-            except:
-                raise ValueError, ' no or more than one real root despite disc < 0'
-            e1 = real_roots[0]
-CC
+rings.ComplexField(precision)
-            roots.remove(e1)
-            e2,e3 = roots
-            zz = (e1-e2).sqrt() # complex
@@ -843 +849 @@
-            return z
-
-        else:                    #Disconnected Case, disc > 0
+            # For some curves (e.g. 2370i5) the default precision is not enough!
+            while len(real_roots)!=3:
+                precision*=2
+                RR=rings.RealField(precision)
+                real_roots = pol.roots(RR,multiplicities=False) 
+
-            real_roots.sort() # increasing order
-            real_roots.reverse() # decreasing order e1>e2>e3
-            try:

a/sage/schemes/elliptic_curves/ell_rational_field.py

@@ -1525 +1525 @@
-            points = self.gens()
-        else:
-            for P in points:
-is
+==
-
-        r = len(points)
-        if precision is None:
@@ -3886 +3886 @@
-            bounded by $H_q$.  The bound $H_q$ will be computed at
-            runtime.
-            """
+            from sage.misc.all import cartesian_product_iterator
+            from sage.groups.generic import multiples
-            xs=set()
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-            return xs
+            
+            # Below this point we keep earlier experimental code which
+            # is slower when either N or r is large
+            
+#           if r==2:
+#               for P in multiples(mw_base[0],N+1):
+#                   for Q in multiples(mw_base[1],N+1):
+#                       for R in set([Q+P,Q-P]):
+#                           use_t(R)
+#               return xs
+#           
+#           if r==3:
+#               for P in multiples(mw_base[0],N+1):
+#                   for Q in multiples(mw_base[1],N+1):
+#                       PQ = [P+Q,P-Q]
+#                       PQ = set(PQ + [-R for R in PQ]) # {\pm P\pm Q}
+#                       for R in multiples(mw_base[2],N+1):
+#                           for S in PQ:
+#                               use_t(R+S)
+#               return xs
+#           
+#           # general rank
+#           mults=[list(multiples(mw_base[i],N+1)) for i in range(r)]
+#           for i in range(r-1):
+#               mults[i] = [-P for P in mults[i] if not P.is_zero()] + mults[i]
+#           for Pi in cartesian_product_iterator(mults):
+#               use_t(sum(Pi,self(0)))
+#           return xs
+#
+#  older, even slower  code:
+#
+#           for i in range(ceil(((2*H_q+1)**r)/2)):
+#               koeffs = Z(i).digits(base=2*H_q+1)
+#               koeffs = [0]*(r-len(koeffs)) + koeffs # pad with 0s
+#               P = sum([(koeffs[j]-H_q)*mw_base[j] for j in range(r)],self(0))
+#               for Q in tors_points: # P + torsion points (includes 0)
+#                   tmp = P + Q
+#                   if not tmp.is_zero():
+#                       x = tmp[0]
+#                       if x.is_integral():
+#                           xs.add(x)
+#           return xs
-        ##############################  end  #################################
-    
-        # END Internal functions #############################################