Ticket #10750: trac_10750-solve.patch

sage/symbolic/relation.py

@@ -479 +479 @@
        are no solutions, return an empty list (rather than a list containing
        an empty dictionary). Likewise, if there's only a single solution,
        return a list containing one dictionary with that solution.
-    
+
+    If solving a single equation, some additional keyword arguments are available:
+
+    - ``multiplicities`` - bool (default: False); if True, return
+       corresponding multiplicities.  This keyword is incompatible
+       with ``to_poly_solve=True`` and does not make any sense when
+       solving an inequality.
+
+    - ``explicit_solutions`` - bool (default: False); require that all
+      roots be explicit rather than implicit. Not used when solving
+      an inequality.
+
+    - ``to_poly_solve`` - bool (default: False) or string; use
+      Maxima's ``to_poly_solver`` package to search for more possible
+      solutions, but possibly encounter approximate solutions.  This
+      keyword is incompatible with ``multiplicities=True`` and is not
+      used when solving an inequality. Setting ``to_poly_solve`` to
+      the string 'force' omits Maxima's solve command (useful when
+      finding solutions of some trigonometric equations).
+
+    For examples using these keywords, see the documentation for the
+    :meth:`solve <sage.symbolic.expression.Expression.solve>` method
+    for single equations.
+
     EXAMPLES::
-    
+
         sage: x, y = var('x, y')
         sage: solve([x+y==6, x-y==4], x, y)
         [[x == 5, y == 1]]
@@ -522 +545 @@
 
     .. note::
 
-        For more details about solving a single equations, see
-        the documentation for its solve.
+        For more details about solving a single equation, see the
+        documentation for its :meth:`solve
+        <sage.symbolic.expression.Expression.solve>` method.
 
     ::
 
@@ -554 +578 @@
     a new variable.  In the following example, ``r1`` is a real free
     variable (because of the ``r``)::
 
-        sage: solve([x+y == 3, 2*x+2*y == 6],x,y)
+        sage: solve(x+y == 3,x,y)
         [[x == -r1 + 3, y == r1]]
 
+    (This also illustrates solving a single equation with respect to
+    more than one variable.)
+
     Especially with trigonometric functions, the dummy variable may
     be implicitly an integer (hence the ``z``)::
 
@@ -646 +673 @@
         []
     """
     from sage.symbolic.expression import is_Expression
-    if is_Expression(f): # f is a single expression
-        ans = f.solve(*args,**kwds)
-        return ans
+    from sage.symbolic.ring import is_SymbolicVariable
+    # f is a single expression and there is a single variable
+    if is_Expression(f):
+        if len(args) == 1 and is_SymbolicVariable(args[0]):
+            ans = f.solve(*args,**kwds)
+            return ans
+        else:
+            f = [f]
 
     if not isinstance(f, (list, tuple)):
         raise TypeError("The first argument must be a symbolic expression or a list of symbolic expressions.")
 
     if len(f)==1 and is_Expression(f[0]):
         # f is a list with a single expression
-        return f[0].solve(*args,**kwds)
+        if len(args) == 1 and is_SymbolicVariable(args[0]):
+            ans = f[0].solve(*args,**kwds)
+            return ans
 
     # f is a list of such expressions or equations
-    from sage.symbolic.ring import is_SymbolicVariable
 
     if len(args)==0:
         raise TypeError, "Please input variables to solve for."
     if is_SymbolicVariable(args[0]):
         variables = args
     else:
-        variables = tuple(args[0])
-    
+        try:
+            variables = tuple(args[0])
+        except TypeError:
+            raise TypeError, "%s is not a valid variable."%args[0]
+
     for v in variables:
         if not is_SymbolicVariable(v):
             raise TypeError, "%s is not a valid variable."%v