add giac algo in the doc

Author: fchapoton

src/sage/symbolic/relation.py

@@ -489,27 +489,29 @@ def test_relation_maxima(relation):
     """
     m = relation._maxima_()
 
-    #Handle some basic cases first
+    # Handle some basic cases first
     if repr(m) in ['0=0']:
         return True
     elif repr(m) in ['0#0', '1#1']:
         return False
 
-    if relation.operator() == operator.eq: # operator is equality
+    if relation.operator() == operator.eq:  # operator is equality
         try:
-            s = m.parent()._eval_line('is (equal(%s,%s))'%(repr(m.lhs()),repr(m.rhs())))
+            s = m.parent()._eval_line('is (equal(%s,%s))' % (repr(m.lhs()),
+                                                             repr(m.rhs())))
         except TypeError:
             raise ValueError("unable to evaluate the predicate '%s'" % repr(relation))
 
     elif relation.operator() == operator.ne: # operator is not equal
         try:
-            s = m.parent()._eval_line('is (notequal(%s,%s))'%(repr(m.lhs()),repr(m.rhs())))
+            s = m.parent()._eval_line('is (notequal(%s,%s))' % (repr(m.lhs()),
+                                                                repr(m.rhs())))
         except TypeError:
             raise ValueError("unable to evaluate the predicate '%s'" % repr(relation))
 
-    else: # operator is < or > or <= or >=, which Maxima handles fine
+    else:  # operator is < or > or <= or >=, which Maxima handles fine
         try:
-            s = m.parent()._eval_line('is (%s)'%repr(m))
+            s = m.parent()._eval_line('is (%s)' % repr(m))
         except TypeError:
             raise ValueError("unable to evaluate the predicate '%s'" % repr(relation))
 
@@ -580,6 +582,7 @@ def string_to_list_of_solutions(s):
 # Solving #
 ###########
 
+
 def solve(f, *args, **kwds):
     r"""
     Algebraically solve an equation or system of equations (over the
@@ -621,7 +624,7 @@ def solve(f, *args, **kwds):
 
     - ``algorithm`` - string (default: 'maxima'); to use SymPy's
       solvers set this to 'sympy'. Note that SymPy is always used
-      for diophantine equations.
+      for diophantine equations. Another choice is 'giac'.
 
     - ``domain`` - string (default: 'complex'); setting this to 'real'
       changes the way SymPy solves single equations; inequalities
@@ -907,7 +910,6 @@ def solve(f, *args, **kwds):
         sage: solve(abs(x + 3) - 2*abs(x - 3),x,algorithm='sympy',domain='real')
         [x == 1, x == 9]
 
-
     We cannot translate all results from SymPy but we can at least
     print them::
 
@@ -1080,12 +1082,12 @@ def solve(f, *args, **kwds):
 
     for v in variables:
         if not is_SymbolicVariable(v):
-            raise TypeError("%s is not a valid variable."%repr(v))
+            raise TypeError("%s is not a valid variable." % repr(v))
 
     try:
         f = [s for s in f if s is not True]
     except TypeError:
-        raise ValueError("Unable to solve %s for %s"%(f, args))
+        raise ValueError("Unable to solve %s for %s" % (f, args))
 
     if any(s is False for s in f):
         return []
@@ -1113,8 +1115,9 @@ def solve(f, *args, **kwds):
                         l.append(r)
                     return l
                 else:
-                    return [[v._sage_() == ex._sage_() for v,ex in d.iteritems()]
-                                         for d in ret]
+                    return [[v._sage_() == ex._sage_()
+                             for v, ex in d.iteritems()]
+                            for d in ret]
             elif isinstance(ret, list):
                 l = []
                 for sol in ret:
@@ -1292,6 +1295,7 @@ def _solve_expression(f, x, explicit_solutions, multiplicities,
         raise NotImplementedError("to_poly_solve does not return multiplicities")
     # check if all variables are assumed integer;
     # if so, we have a Diophantine
+
     def has_integer_assumption(v):
         from sage.symbolic.assumptions import assumptions, GenericDeclaration
         alist = assumptions()
@@ -1336,15 +1340,15 @@ def has_integer_assumption(v):
         else:
             raise
     if explicit_solutions:
-        P.eval('solveexplicit: false') # switches Maxima back to default
+        P.eval('solveexplicit: false')  # switches Maxima back to default
 
     if s == 'all':
         if solution_dict:
-            ans = [ {x: f.parent().var('r1')} ]
+            ans = [{x: f.parent().var('r1')}]
         else:
             ans = [x == f.parent().var('r1')]
         if multiplicities:
-            return ans,[]
+            return ans, []
         else:
             return ans
 
@@ -1538,7 +1542,6 @@ def solve_mod(eqns, modulus, solution_dict=False):
        techniques, etc. But for a lot of toy problems this function as
        is might be useful. At least it establishes an interface.
 
-
     TESTS:
 
     Make sure that we short-circuit in at least some cases::
@@ -1573,7 +1576,7 @@ def solve_mod(eqns, modulus, solution_dict=False):
 
     if not isinstance(eqns, (list, tuple)):
         eqns = [eqns]
-    eqns = [eq if is_Expression(eq) else (eq.lhs()-eq.rhs()) for eq in eqns]
+    eqns = [eq if is_Expression(eq) else (eq.lhs() - eq.rhs()) for eq in eqns]
     modulus = Integer(modulus)
     if modulus < 1:
         raise ValueError("the modulus must be a positive integer")
@@ -1590,14 +1593,13 @@ def solve_mod(eqns, modulus, solution_dict=False):
 
     has_solution = True
     for p,i in factors:
-        solution =_solve_mod_prime_power(eqns, p, i, vars)
+        solution = _solve_mod_prime_power(eqns, p, i, vars)
         if len(solution) > 0:
             solutions.append(solution)
         else:
             has_solution = False
             break
 
-
     ans = []
     if has_solution:
         for solution in cartesian_product_iterator(solutions):
@@ -1612,6 +1614,7 @@ def solve_mod(eqns, modulus, solution_dict=False):
     else:
         return ans
 
+
 def _solve_mod_prime_power(eqns, p, m, vars):
     r"""
     Internal help function for solve_mod, does little checking since it expects
@@ -1663,7 +1666,7 @@ def _solve_mod_prime_power(eqns, p, m, vars):
 
        Currently this constructs possible solutions by building up
        from the smallest prime factor of the modulus.  The interface
-       is good, but the algorithm is horrible if the modulus isn't the
+       is good, but the algorithm is horrible if the modulus is not the
        product of many small primes! Sage *does* have the ability to
        do something much faster in certain cases at least by using the
        Chinese Remainder Theorem, Groebner basis, linear algebra
@@ -1697,7 +1700,8 @@ def _solve_mod_prime_power(eqns, p, m, vars):
         else:
             shifts = cartesian_product_iterator([range(p) for _ in range(len(vars))])
             pairs = cartesian_product_iterator([shifts, ans])
-            possibles = (tuple(vector(t)+vector(shift)*(mrunning//p)) for shift, t in pairs)
+            possibles = (tuple(vector(t) + vector(shift) * (mrunning // p))
+                         for shift, t in pairs)
         ans = list(t for t in possibles if all(e(*t) == 0 for e in eqns_mod))
         if not ans:
             return ans
@@ -1734,7 +1738,7 @@ def solve_ineq_univar(ineq):
 
     ALGORITHM:
 
-    Calls Maxima command solve_rat_ineq
+    Calls Maxima command ``solve_rat_ineq``
 
     AUTHORS:
 
@@ -1746,12 +1750,13 @@ def solve_ineq_univar(ineq):
     ineq0 = ineq._maxima_()
     ineq0.parent().eval("if solve_rat_ineq_loaded#true then (solve_rat_ineq_loaded:true,load(\"solve_rat_ineq.mac\")) ")
     sol = ineq0.solve_rat_ineq().sage()
-    if repr(sol)=="all":
+    if repr(sol) == "all":
         from sage.rings.infinity import Infinity
-        sol = [ineqvar[0]<Infinity]
+        sol = [ineqvar[0] < Infinity]
     return sol
 
-def solve_ineq_fourier(ineq,vars=None):
+
+def solve_ineq_fourier(ineq, vars=None):
     """
     Solves system of inequalities using Maxima and Fourier elimination
 
@@ -1799,7 +1804,7 @@ def solve_ineq_fourier(ineq,vars=None):
 
     ALGORITHM:
 
-    Calls Maxima command fourier_elim
+    Calls Maxima command ``fourier_elim``
 
     AUTHORS:
 
@@ -1809,7 +1814,7 @@ def solve_ineq_fourier(ineq,vars=None):
         setvars = set([])
         for i in (ineq):
             setvars = setvars.union(set(i.variables()))
-            vars =[i for i in setvars]
+            vars = [i for i in setvars]
     ineq0 = [i._maxima_() for i in ineq]
     ineq0[0].parent().eval("if fourier_elim_loaded#true then (fourier_elim_loaded:true,load(\"fourier_elim\"))")
     sol = ineq0[0].parent().fourier_elim(ineq0,vars)
@@ -1821,9 +1826,10 @@ def solve_ineq_fourier(ineq,vars=None):
         sol = []
     if repr(sol) == "[universalset]":
         from sage.rings.infinity import Infinity
-        sol = [[i<Infinity for i in vars]]
+        sol = [[i < Infinity for i in vars]]
     return sol
 
+
 def solve_ineq(ineq, vars=None):
     """
     Solves inequalities and systems of inequalities using Maxima.
@@ -1888,8 +1894,8 @@ def solve_ineq(ineq, vars=None):
 
     ALGORITHM:
 
-    Calls solve_ineq_fourier if inequalities are list and
-    solve_ineq_univar of the inequality is symbolic expression. See
+    Calls ``solve_ineq_fourier`` if inequalities are list and
+    ``solve_ineq_univar`` of the inequality is symbolic expression. See
     the description of these commands for more details related to the
     set of inequalities which can be solved. The list is empty if
     there is no solution.