Context Navigation

Back to Ticket #8459

Ticket #8459: trac-8390.patch

File trac-8390.patch, 104.9 KB (added by robert.marik, 12 years ago)

sage/symbolic/expression.pyx

# HG changeset patch
# User Robert Marik <marik@mendelu.cz>
# Date 1267399874 -3600
# Node ID a1e99a90b1993d275c2235595ef452fed01c955f
# Parent  46b1ee5997ac7e7faafdd86751fe7d121b6c1385
#8390 and reindent.py

diff -r 46b1ee5997ac -r a1e99a90b199 sage/symbolic/expression.pyx

-                      a
 def is_SymbolicEquation(x):
     """
     Returns True if *x* is a symbolic equation.
     EXAMPLES:
     The following two examples are symbolic equations::
         sage: from sage.symbolic.expression import is_SymbolicEquation
         sage: is_SymbolicEquation(sin(x) == x)
         True
 …
         True
         sage: is_SymbolicEquation(x)
         False
     This is not, since ``2==3`` evaluates to the boolean
     ``False``::
         sage: is_SymbolicEquation(2 == 3)
         False
     However here since both 2 and 3 are coerced to be symbolic, we
     obtain a symbolic equation::
         sage: is_SymbolicEquation(SR(2) == SR(3))
         True
 …
         value.   Otherwise, a TypeError is raised.
         EXAMPLES::
             sage: var('x')
+            x
             sage: b = -17/3
 …
     def __init__(self, SR, x=0):
         """
         Nearly all expressions are created by calling new_Expression_from_*,
         but we need to make sure this at least doesn't leave self._gobj
+        Nearly all expressions are created by calling new_Expression_from_*,
+        but we need to make sure this at least doesn't leave self._gobj
         uninitialized and segfault.
         TESTS::
 …
         __setstate__().
         In order to pickle Expression objects, we return a tuple containing
          * 0  - as pickle version number
                 in case we decide to change the pickle format in the feature
          * names of symbols of this expression
 …
             (0,
              ['x', 'y', 'z'],
              ...)
         """
         cdef GArchive ar
         ar.archive_ex(self._gobj, "sage_ex")
 …
     def _repr_(self, simplify=None):
         """
         Return string representation of this symbolic expression.
         EXAMPLES::
+        EXAMPLES::
             sage: var("x y")
             (x, y)
             sage: repr(x+y)
             'x + y'
         TESTS::
             # printing of modular number equal to -1 as coefficient
             sage: k.<a> = GF(9); k(2)*x
 *x
 …
             -I
             sage: y + 3*(x^(-1))
             y + 3/x
         Printing the exp function::
             sage: x.parent(1).exp()
+            e
             sage: x.exp()
 …
             (n + A/B)^(n + 1)
         Powers where the base or exponent is a Python object::
             sage: (2/3)^x
             (2/3)^x
             sage: x^CDF(1,2)
 …
             sage: f = sin(e + 2)
             sage: f._interface_(sage.calculus.calculus.maxima)
             sin(%e+2)
+            sin(%e+2)
         """
         if is_a_constant(self._gobj):
             return self.pyobject()._interface_(I)
 …
             sage: f = pi + I*e
             sage: f._pari_init_()
             '(Pi)+((exp(1))*(I))'
         """
+        """
         from sage.symbolic.expression_conversions import InterfaceInit
         return InterfaceInit(I)(self)
     def _gap_init_(self):
         """
         Conversion of symbolic object to GAP always results in a GAP
         string.
         EXAMPLES::
+        EXAMPLES::
             sage: gap(e + pi^2 + x^3)
             pi^2 + x^3 + e
         """
 …
         """
         Conversion of a symbolic object to Singular always results in a
         Singular string.
         EXAMPLES::
+        EXAMPLES::
             sage: singular(e + pi^2 + x^3)
             pi^2 + x^3 + e
         """
 …
     def _magma_init_(self, magma):
         """
         Return string representation in Magma of this symbolic expression.
         Since Magma has no notation of symbolic calculus, this simply
         returns something that evaluates in Magma to a a Magma string.
         EXAMPLES::
             sage: x = var('x')
+        EXAMPLES::
+            sage: x = var('x')
             sage: f = sin(cos(x^2) + log(x))
             sage: f._magma_init_(magma)
             '"sin(log(x) + cos(x^2))"'
 …
     def _latex_(self):
         r"""
         Return string representation of this symbolic expression.
         EXAMPLES:
         TESTS::
+        EXAMPLES:
+        TESTS::
             sage: var('x,y,z')
             (x, y, z)
             sage: latex(y + 3*(x^(-1)))
 …
             {\left(A B\right)}^{n - 1}
         Powers where the base or exponent is a Python object::
             sage: latex((2/3)^x)
             \left(\frac{2}{3}\right)^{x}
             sage: latex(x^CDF(1,2))
 …
     def _mathml_(self):
         """
         Returns a MathML representation of this object.
         EXAMPLES::
             sage: mathml(pi)
 …
         except TypeError:
             return mathml(repr(self))
         return mathml(obj)
     def _integer_(self, ZZ=None):
         """
         EXAMPLES::
             sage: f = x^3 + 17*x -3
             sage: ZZ(f.coeff(x^3))
 …
             <type 'sage.rings.integer.Integer'>
         Coercion is done if necessary::
             sage: f = x^3 + 17/1*x
             sage: ZZ(f.coeff(x))
 …
         If the symbolic expression is just a wrapper around an integer,
         that very same integer is returned::
             sage: n = 17; SR(n)._integer_() is n
             True
         """
 …
     def __int__(self):
         """
         EXAMPLES::
             sage: int(sin(2)*100)
             sage: int(log(8)/log(2))
 …
     def __long__(self):
         """
         EXAMPLES::
             sage: long(sin(2)*100)
 L
         """
 …
     def _rational_(self):
         """
         EXAMPLES::
             sage: f = x^3 + 17/1*x - 3/8
             sage: QQ(f.coeff(x^2))
 …
         If the symbolic expression is just a wrapper around a rational,
         that very same rational is returned::
             sage: n = 17/1; SR(n)._rational_() is n
             True
         """
 …
         only variables, and functions whose arguments contain a variable.
         EXAMPLES::
             sage: f = sqrt(2) * cos(3); f
             sqrt(2)*cos(3)
             sage: f._convert(RDF)
 …
             log(10)
             sage: t._convert(QQ)
 .30258509299405
         ::
             sage: (0.25 / (log(5.74 /x^0.9, 10))^2 / 4)._convert(QQ)
 .331368631904900/log(287/50/x^0.900000000000000)^2
             sage: (0.25 / (log(5.74 /x^0.9, 10))^2 / 4)._convert(CC)
 .331368631904900/log(5.74000000000000/x^0.900000000000000)^2
         When converting to an exact domain, powers remain unevaluated::
             sage: f = sqrt(2) * cos(3); f
 …
         The precision of the approximation is determined by the precision of
         the input R.
         EXAMPLES::
 .090909090909090909090909090909090909090909090909090909090909
 …
     def _real_mpfi_(self, R):
         """
         Returns this expression as a real interval.
         EXAMPLES::
             sage: RIF(sqrt(2))
 …
     def _complex_mpfi_(self, R):
         """
         Returns this expression as a complex interval.
         EXAMPLES::
             sage: CIF(pi)
 …
         The precision of the approximation is determined by the precision of
         the input R.
         EXAMPLES::
             sage: ComplexField(200)(SR(1/11))
+        EXAMPLES::
+            sage: ComplexField(200)(SR(1/11))
 .090909090909090909090909090909090909090909090909090909090909
             sage: zeta(x).subs(x=I)._complex_mpfr_field_(ComplexField(70))
 .0033002236853241028742 - 0.41815544914132167669*I
 …
         EXAMPLES::
             sage: CDF(SR(1/11))
+            sage: CDF(SR(1/11))
 .0909090909091
             sage: zeta(x).subs(x=I)._complex_double_(CDF)
 .00330022368532 - 0.418155449141*I
 …
         Otherwise, raise a TypeError.
         OUTPUT:
         - float - double precision evaluation of self
         EXAMPLES::
+        EXAMPLES::
             sage: float(SR(12))
 .0
             sage: float(SR(2/3))
 …
         EXAMPLES::
             sage: complex(I)
 j
+j
             sage: complex(erf(3*I))
             Traceback (most recent call last):
             ...
 …
             return self._eval_self(complex)
         except TypeError:
             raise TypeError, "unable to simplify to complex approximation"
     def _sympy_(self):
         """
         Returns a Sympy version of this object.
 …
         """
         from sage.symbolic.expression_conversions import sympy
         return sympy(self)
     def _algebraic_(self, field):
         """
         Convert a symbolic expression to an algebraic number.
         EXAMPLES::
             sage: QQbar(sqrt(2) + sqrt(8))
 …
 + 1*I
             sage: QQbar(e^(pi*I/3))
 .500000000000000? + 0.866025403784439?*I
             sage: QQbar(sqrt(2))
 .414213562373095?
             sage: AA(abs(1+I))
 …
         """
         from sage.symbolic.expression_conversions import algebraic
         return algebraic(self, field)
     def __hash__(self):
         """
         Return hash of this expression.
         EXAMPLES::
         The hash of an object in Python or its coerced version into
         the symbolic ring is the same::
             sage: hash(SR(3/1))
+            sage: hash(SR(3/1))
             sage: hash(SR(19/23))
 …
             <type 'int'>
             sage: t = hash(x^y); type(t)
             <type 'int'>
             sage: type(hash(x+y))
+            sage: type(hash(x+y))
             <type 'int'>
             sage: d = {x+y: 5}
             sage: d
 …
         In this example hashing is important otherwise the answer is
         wrong::
             sage: uniq([x-x, -x+x])
             [0]
 …
     def __richcmp__(left, right, int op):
         """
         Create a formal symbolic inequality or equality.
         EXAMPLES::
+        EXAMPLES::
             sage: var('x, y')
             (x, y)
             sage: x + 2/3 < y^2
 …
         elif op == Py_NE:
             e = g_ne(l._gobj, r._gobj)
         elif op == Py_GE:
             e = g_ge(l._gobj, r._gobj)
+            e = g_ge(l._gobj, r._gobj)
         else:
             raise TypeError
         return new_Expression_from_GEx(l._parent, e)
 …
         r"""
         Assume that this equation holds. This is relevant for symbolic
         integration, among other things.
         EXAMPLES: We call the assume method to assume that `x>2`::
             sage: (x > 2).assume()
         Bool returns True below if the inequality is *definitely* known to
         be True.
         ::
+        ::
             sage: bool(x > 0)
             True
             sage: bool(x < 0)
             False
         This may or may not be True, so bool returns False::
             sage: bool(x > 3)
             False
         If you make inconsistent or meaningless assumptions,
         Sage will let you know::
 …
             sage: forget()
         TESTS::
             sage: v,c = var('v,c')
             sage: assume(c != 0)
             sage: integral((1+v^2/c^2)^3/(1-v^2/c^2)^(3/2),v)
 …
     def forget(self):
         """
         Forget the given constraint.
         EXAMPLES::
+        EXAMPLES::
             sage: var('x,y')
             (x, y)
             sage: forget()
 …
         """
         Return string that when evaluated in Maxima defines the assumption
         determined by this expression.
         EXAMPLES::
             sage: f = x+2 > sqrt(3)
 …
         Return True if self is a relational expression.
         EXAMPLES::
             sage: x = var('x')
             sage: eqn = (x-1)^2 == x^2 - 2*x + 3
             sage: eqn.is_relational()
 …
         of the relation.  Otherwise, raise a ValueError.
         EXAMPLES::
             sage: x = var('x')
             sage: eqn = (x-1)^2 == x^2 - 2*x + 3
             sage: eqn.left_hand_side()
 …
         of the relation.  Otherwise, raise a ValueError.
         EXAMPLES::
             sage: x = var('x')
             sage: eqn = (x-1)^2 <= x^2 - 2*x + 3
             sage: eqn.right_hand_side()
 …
     def __nonzero__(self):
         """
         Return True unless this symbolic expression can be shown by Sage
         to be zero.  Note that deciding if an expression is zero is
+        to be zero.  Note that deciding if an expression is zero is
         undecidable in general.
         EXAMPLES::
             sage: x = var('x')
             sage: forget()
             sage: SR(0).__nonzero__()
 …
             sage: pol = 1/(k-1) - 1/k - 1/k/(k-1)
             sage: pol.is_zero()
             True
             sage: f = sin(x)^2 + cos(x)^2 - 1
             sage: f.is_zero()
             True
 …
         First, a bunch of tests of nonzero (which is called by bool)
         for symbolic relations::
             sage: x = var('x')
             sage: bool((x-1)^2 == x^2 - 2*x + 1)
             True
 …
             True
         Next, tests to ensure assumptions are correctly used::
             sage: x, y, z = var('x, y, z')
             sage: assume(x>=y,y>=z,z>=x)
             sage: bool(x==z)
 …
             False
             sage: bool(x != 0)
             True
             sage: bool(x == 1)
+            sage: bool(x == 1)
             False
         The following must be true, even though we don't
         know for sure that x isn't 1, as symbolic comparisons
         elsewhere rely on x!=y unless we are sure it is not
+        elsewhere rely on x!=y unless we are sure it is not
         true; there is no equivalent of Maxima's ``unknown``.
         Since it is False that x==1, it is True that x != 1.
         ::
             sage: bool(x != 1)
+            sage: bool(x != 1)
             True
             sage: forget()
             sage: assume(x>y)
 …
             if res:
                 if self.operator() == operator.ne: # this hack is necessary to catch the case where the operator is != but is False because of assumptions made
                     m = self._maxima_()
                     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())))
                     if s == 'false':
                         return False
                     else:
 …
             # lot of basic Sage objects can't be put into maxima.
             from sage.symbolic.relation import test_relation_maxima
             return test_relation_maxima(self)
         self_is_zero = self._gobj.is_zero()
         if self_is_zero:
             return False
 …
         """
         Test this relation at several random values, attempting to find
         a contradiction. If this relation has no variables, it will also
         test this relation after casting into the domain.
         Because the interval fields never return false positives, we can be
         assured that if True or False is returned (and proof is False) then
         the answer is correct.
+        test this relation after casting into the domain.
+        Because the interval fields never return false positives, we can be
+        assured that if True or False is returned (and proof is False) then
+        the answer is correct.
         INPUT::
            ntests -- (default 20) the number of iterations to run
            domain -- (optional) the domain from which to draw the random values
                      defaults to CIF for equality testing and RIF for
+                     defaults to CIF for equality testing and RIF for
                      order testing
            proof --  (default True) if False and the domain is an interval field,
+           proof --  (default True) if False and the domain is an interval field,
                      regard overlapping (potentially equal) intervals as equal,
                      and return True if all tests succeeded.
+                     and return True if all tests succeeded.
         OUTPUT::
 …
             NotImplemented - no contradiction found
         EXAMPLES::
             sage: (3 < pi).test_relation()
             True
             sage: (0 >= pi).test_relation()
 …
             (x, y)
             sage: (x < y).test_relation()
             False
         TESTS::
             sage: all_relations = [op for name, op in sorted(operator.__dict__.items()) if len(name) == 2]
             sage: all_relations
+            sage: all_relations
             [<built-in function eq>, <built-in function ge>, <built-in function gt>, <built-in function le>, <built-in function lt>, <built-in function ne>]
             sage: [op(3, pi).test_relation() for op in all_relations]
             [False, False, False, True, True, True]
 …
         # Nothing failed, so it *may* be True, but this method doesn't wasn't
         # able to find anything.
         return NotImplemented
     def negation(self):
         """
         Returns the negated version of self, that is the relation that is
+        Returns the negated version of self, that is the relation that is
         False iff self is True.
         EXAMPLES::
             sage: (x < 5).negation()
 …
         elif op == greater_or_equal:
             falsify = operator.lt
         return falsify(self.lhs(), self.rhs())
     def contradicts(self, soln):
         """
         Returns ``True`` if this relation is violated by the given variable assignment(s).
         EXAMPLES::
+        EXAMPLES::
             sage: (x<3).contradicts(x==0)
             False
             sage: (x<3).contradicts(x==3)
 …
         Return True if this expression is a unit of the symbolic ring.
         EXAMPLES::
             sage: SR(1).is_unit()
             True
             sage: SR(-1).is_unit()
 …
         Add left and right.
         EXAMPLES::
             sage: var("x y")
             (x, y)
             sage: x + y + y + x
 …
 *x + y > 2*x
         TESTS::
             sage: x + ( (x+y) > x )
 *x + y > 2*x
 …
     cpdef ModuleElement _sub_(left, ModuleElement right):
         """
         EXAMPLES::
             sage: var("x y")
             (x, y)
             sage: x - y
 …
             y > 0
         TESTS::
             sage: x - ( (x+y) > x )
             -y > 0
 …
     cpdef RingElement _mul_(left, RingElement right):
         """
         Multiply left and right.
         EXAMPLES::
+        EXAMPLES::
             sage: var("x y")
             (x, y)
             sage: x*y*y
 …
             -x - y > -x
         TESTS::
             sage: x * ( (x+y) > x )
             (x + y)*x > x^2
 …
         Divide left and right.
         EXAMPLES::
             sage: var("x y")
             (x, y)
             sage: x/y/y
 …
             -x - y > -x
         TESTS::
             sage: x / ( (x+y) > x )
             x/(x + y) > 1
 …
         this function won't be called.
         EXAMPLES::
             sage: x,y = var('x,y')
             sage: x.__cmp__(y)
             -1
 …
             x^(sin(x)^cos(y))
         TESTS::
             sage: (Mod(2,7)*x^2 + Mod(2,7))^7
             (2*x^2 + 2)^7
             sage: k = GF(7)
 …
             Infinity
         Test powers of exp::
             sage: exp(2)^5
             e^10
             sage: exp(x)^5
 …
             (1+3j)^sqrt(2)
         """
         cdef Expression base, nexp
         try:
             # self is an Expression and exp might not be
             base = self
 …
             :meth:`_derivative`
         EXAMPLES::
             sage: var("x y")
             (x, y)
             sage: t = (x^2+y)^2
 …
             (tan(x*y)^2 + 1)*x*sin(y^2 + x) + 2*y*cos(y^2 + x)*tan(x*y)
         ::
             sage: h = sin(x)/cos(x)
             sage: derivative(h,x,x,x)
 *sin(x)^4/cos(x)^4 + 8*sin(x)^2/cos(x)^2 + 2
 …
 *sin(x)^4/cos(x)^4 + 8*sin(x)^2/cos(x)^2 + 2
         ::
             sage: var('x, y')
             (x, y)
             sage: u = (sin(x) + cos(y))*(cos(x) - sin(y))
             sage: derivative(u,x,y)
             sin(x)*sin(y) - cos(x)*cos(y)
+            sin(x)*sin(y) - cos(x)*cos(y)
             sage: f = ((x^2+1)/(x^2-1))^(1/4)
             sage: g = derivative(f, x); g # this is a complex expression
 /2*(x/(x^2 - 1) - (x^2 + 1)*x/(x^2 - 1)^2)/((x^2 + 1)/(x^2 - 1))^(3/4)
 …
             sage: f = y^(sin(x))
             sage: derivative(f, x)
             y^sin(x)*log(y)*cos(x)
         ::
+        ::
             sage: g(x) = sqrt(5-2*x)
             sage: g_3 = derivative(g, x, 3); g_3(2)
             -3
         ::
+        ::
             sage: f = x*e^(-x)
             sage: derivative(f, 100)
             x*e^(-x) - 100*e^(-x)
         ::
+        ::
             sage: g = 1/(sqrt((x^2-1)*(x+5)^6))
             sage: derivative(g, x)
             -((x + 5)^6*x + 3*(x + 5)^5*(x^2 - 1))/((x + 5)^6*(x^2 - 1))^(3/2)
         TESTS::
             sage: t.derivative()
             Traceback (most recent call last):
             ...
 …
     def _derivative(self, symb=None, deg=1):
         """
         Return the deg-th (partial) derivative of self with respect to symb.
         EXAMPLES::
+        EXAMPLES::
             sage: var("x y")
             (x, y)
             sage: b = (x+y)^5
 …
         Raise error if no variable is specified and there are multiple
         variables::
             sage: b._derivative()
             Traceback (most recent call last):
             ...
 …
     def gradient(self, variables=None):
         r"""
         Compute the gradient of a symbolic function.
         This function returns a vector whose components are the derivatives
         of the original function with respect to the arguments of the
         original function. Alternatively, you can specify the variables as
         a list.
         EXAMPLES::
+        EXAMPLES::
             sage: x,y = var('x y')
             sage: f = x^2+y^2
             sage: f.gradient()
 …
         if variables is None:
             variables = self.arguments()
         return vector([self.derivative(x) for x in variables])
     def hessian(self):
         r"""
         Compute the hessian of a function. This returns a matrix components
         are the 2nd partial derivatives of the original function.
         EXAMPLES::
+        EXAMPLES::
             sage: x,y = var('x y')
             sage: f = x^2+y^2
             sage: f.hessian()
 …
         - a power series
         To truncate the power series and obtain a normal expression, use the
         truncate command.
         EXAMPLES:
+        truncate command.
+        EXAMPLES:
         We expand a polynomial in `x` about 0, about `1`, and also truncate
         it back to a polynomial::
             sage: var('x,y')
             (x, y)
             sage: f = (x^3 - sin(y)*x^2 - 5*x + 3); f
 …
             x^3 - x^2*sin(y) - 5*x + 3
         We computer another series expansion of an analytic function::
             sage: f = sin(x)/x^2
             sage: f.series(x,7)
 *x^(-1) + (-1/6)*x + 1/120*x^3 + (-1/5040)*x^5 + Order(x^7)
 …
         the fractions 1/5 and 1/239.
         ::
             sage: x = var('x')
             sage: f = atan(x).series(x, 10); f
 *x + (-1/3)*x^3 + 1/5*x^5 + (-1/7)*x^7 + 1/9*x^9 + Order(x^10)
 …
         r"""
         Expands this symbolic expression in a truncated Taylor or
         Laurent series in the variable `v` around the point `a`,
         containing terms through `(x - a)^n`. Functions in more
+        containing terms through `(x - a)^n`. Functions in more
         variables is also supported.
         INPUT:
         -  ``*args`` - the following notation is supported
+        INPUT:
+        -  ``*args`` - the following notation is supported
            - ``x, a, n`` - variable, point, degree
            - ``(x, a), (y, b), n`` - variables with points, degree of polynomial
         EXAMPLES::
+        EXAMPLES::
             sage: var('a, x, z')
             (a, x, z)
             sage: taylor(a*log(z), z, 2, 3)
 /24*(z - 2)^3*a - 1/8*(z - 2)^2*a + 1/2*(z - 2)*a + a*log(2)
         ::
+        ::
             sage: taylor(sqrt (sin(x) + a*x + 1), x, 0, 3)
 /48*(3*a^3 + 9*a^2 + 9*a - 1)*x^3 - 1/8*(a^2 + 2*a + 1)*x^2 + 1/2*(a + 1)*x + 1
         ::
+        ::
             sage: taylor (sqrt (x + 1), x, 0, 5)
 /256*x^5 - 5/128*x^4 + 1/16*x^3 - 1/8*x^2 + 1/2*x + 1
         ::
+        ::
             sage: taylor (1/log (x + 1), x, 0, 3)
             -19/720*x^3 + 1/24*x^2 - 1/12*x + 1/x + 1/2
         ::
+        ::
             sage: taylor (cos(x) - sec(x), x, 0, 5)
             -1/6*x^4 - x^2
         ::
+        ::
             sage: taylor ((cos(x) - sec(x))^3, x, 0, 9)
             -1/2*x^8 - x^6
         ::
+        ::
             sage: taylor (1/(cos(x) - sec(x))^3, x, 0, 5)
             -15377/7983360*x^4 - 6767/604800*x^2 + 11/120/x^2 + 1/2/x^4 - 1/x^6 - 347/15120
         Ticket #7472 fixed (Taylor polynomial in more variables) ::
             sage: x,y=var('x y'); taylor(x*y^3,(x,1),(y,1),4)
+            sage: x,y=var('x y'); taylor(x*y^3,(x,1),(y,1),4)
             (y - 1)^3*(x - 1) + (y - 1)^3 + 3*(y - 1)^2*(x - 1) + 3*(y - 1)^2 + 3*(y - 1)*(x - 1) + x + 3*y - 3
             sage: expand(_)
             x*y^3
+            sage: expand(_)
+            x*y^3
         """
         from sage.all import SR, Integer
 …
         - expression
         EXAMPLES::
             sage: f = sin(x)/x^2
             sage: f.truncate()
             sin(x)/x^2
 …
         sums are multiplied out, numerators of rational expressions which
         are sums are split into their respective terms, and multiplications
         are distributed over addition at all levels.
         EXAMPLES:
         We expand the expression `(x-y)^5` using both
         method and functional notation.
         ::
+        ::
             sage: x,y = var('x,y')
             sage: a = (x-y)^5
             sage: a.expand()
             x^5 - 5*x^4*y + 10*x^3*y^2 - 10*x^2*y^3 + 5*x*y^4 - y^5
             sage: expand(a)
             x^5 - 5*x^4*y + 10*x^3*y^2 - 10*x^2*y^3 + 5*x*y^4 - y^5
         We expand some other expressions::
             sage: expand((x-1)^3/(y-1))
             x^3/(y - 1) - 3*x^2/(y - 1) + 3*x/(y - 1) - 1/(y - 1)
             sage: expand((x+sin((x+y)^2))^2)
 …
             (16*x - 13)^2 == 9/2*x^2 + 15*x + 25/2
         TESTS:
             sage: var('x,y')
             (x, y)
             sage: ((x + (2/3)*y)^3).expand()
 …
                 return self.operator()(self.lhs(), self.rhs().expand())
             else:
                 raise ValueError, "side must be 'left', 'right', or None"
         _sig_on
         cdef GEx x = self._gobj.expand(0)
         _sig_off
 …
         Expands trigonometric and hyperbolic functions of sums of angles
         and of multiple angles occurring in self. For best results, self
         should already be expanded.
         INPUT:
+        INPUT:
         -  ``full`` - (default: False) To enhance user control
            of simplification, this function expands only one level at a time
            by default, expanding sums of angles or multiple angles. To obtain
            full expansion into sines and cosines immediately, set the optional
            parameter full to True.
         -  ``half_angles`` - (default: False) If True, causes
            half-angles to be simplified away.
         -  ``plus`` - (default: True) Controls the sum rule;
            expansion of sums (e.g. 'sin(x + y)') will take place only if plus
            is True.
         -  ``times`` - (default: True) Controls the product
            rule, expansion of products (e.g. sin(2\*x)) will take place only
            if times is True.
         OUTPUT: a symbolic expression
         EXAMPLES::
+        EXAMPLES::
             sage: sin(5*x).expand_trig()
             sin(x)^5 - 10*sin(x)^3*cos(x)^2 + 5*sin(x)*cos(x)^4
             sage: cos(2*x + var('y')).expand_trig()
             -sin(2*x)*sin(y) + cos(2*x)*cos(y)
         We illustrate various options to this function::
             sage: f = sin(sin(3*cos(2*x))*x)
             sage: f.expand_trig()
             sin(-(sin(cos(2*x))^3 - 3*sin(cos(2*x))*cos(cos(2*x))^2)*x)
 …
         sin's and cos's of x into those of multiples of x. It also
         tries to eliminate these functions when they occur in
         denominators.
         INPUT:
         - ``self`` - a symbolic expression
+        INPUT:
+        - ``self`` - a symbolic expression
         - ``var`` - (default: None) the variable which is used for
           these transformations. If not specified, all variables are
           used.
         OUTPUT: a symbolic expression
         EXAMPLES::
             sage: y=var('y')
 …
         Check if self matches the given pattern.
         INPUT:
         -  ``pattern`` - a symbolic expression, possibly containing wildcards
            to match for
 …
         See also http://www.ginac.de/tutorial/Pattern-matching-and-advanced-substitutions.html
         EXAMPLES::
             sage: var('x,y,z,a,b,c,d,e,f')
             (x, y, z, a, b, c, d, e, f)
             sage: w0 = SR.wild(0); w1 = SR.wild(1); w2 = SR.wild(2)
 …
     def has(self, pattern):
         """
         EXAMPLES::
             sage: var('x,y,a'); w0 = SR.wild(); w1 = SR.wild()
             (x, y, a)
             sage: (x*sin(x + y + 2*a)).has(y)
 …
         Here "x+y" is not a subexpression of "x+y+2*a" (which has the
         subexpressions "x", "y" and "2*a")::
             sage: (x*sin(x + y + 2*a)).has(x+y)
             False
             sage: (x*sin(x + y + 2*a)).has(x + y + w0)
 …
         The following fails because "2*(x+y)" automatically gets converted to
         "2*x+2*y" of which "x+y" is not a subexpression::
             sage: (x*sin(2*(x+y) + 2*a)).has(x+y)
             False
         Although x^1==x and x^0==1, neither "x" nor "1" are actually of the
+        Although x^1==x and x^0==1, neither "x" nor "1" are actually of the
         form "x^something"::
             sage: (x+1).has(x^w0)
             False
 …
         coeff() function instead.
         ::
             sage: (4*x^2 - x + 3).has(w0*x)
             True
             sage: (4*x^2 + x + 3).has(w0*x)
 …
     def substitute(self, in_dict=None, **kwds):
         """
         EXAMPLES::
             sage: var('x,y,z,a,b,c,d,e,f')
             (x, y, z, a, b, c, d, e, f)
             sage: w0 = SR.wild(0); w1 = SR.wild(1)
             sage: t = a^2 + b^2 + (x+y)^3
             # substitute with keyword arguments (works only with symbols)
             sage: t.subs(a=c)
             (x + y)^3 + b^2 + c^2
             # substitute with a dictionary argument
             sage: t.subs({a^2: c})
             (x + y)^3 + b^2 + c
 …
             (x + y)^3 + a^3 + b^3
             sage: t.subs(w0==w0^2)
             (x^2 + y^2)^18 + a^16 + b^16
+            (x^2 + y^2)^18 + a^16 + b^16
             # more than one keyword argument is accepted
             sage: t.subs(a=b, b=c)
 …
         return new_Expression_from_GEx(self._parent, self._gobj.subs_map(smap))
     subs = substitute
     cpdef Expression _subs_expr(self, expr):
         """
         EXAMPLES::
             sage: var('x,y,z,a,b,c,d,e,f')
             (x, y, z, a, b, c, d, e, f)
             sage: w0 = SR.wild(0); w1 = SR.wild(1)
 …
         of key for value in self.  The substitutions can also be given
         as a number of symbolic equalities key == value; see the
         examples.
         .. warning::
            This is a formal pattern substitution, which may or may not
 …
            present in Sage are determined by Maxima's subst
            command. Sometimes patterns are not replaced even though
            one would think they should be - see examples below.
         EXAMPLES::
+        EXAMPLES::
             sage: f = x^2 + 1
             sage: f.subs_expr(x^2 == x)
             x + 1
         ::
+        ::
             sage: var('x,y,z'); f = x^3 + y^2 + z
             (x, y, z)
             sage: f.subs_expr(x^3 == y^2, z == 1)
 *y^2 + 1
         Or the same thing giving the substitutions as a dictionary::
             sage: f.subs_expr({x^3:y^2, z:1})
 *y^2 + 1
             sage: f = x^2 + x^4
             sage: f.subs_expr(x^2 == x)
             x^4 + x
             sage: f = cos(x^2) + sin(x^2)
             sage: f.subs_expr(x^2 == x)
             sin(x) + cos(x)
         ::
+        ::
             sage: f(x,y,t) = cos(x) + sin(y) + x^2 + y^2 + t
             sage: f.subs_expr(y^2 == t)
             (x, y, t) |--> x^2 + 2*t + sin(y) + cos(x)
         The following seems really weird, but it *is* what Maple does::
             sage: f.subs_expr(x^2 + y^2 == t)
             (x, y, t) |--> x^2 + y^2 + t + sin(y) + cos(x)
             sage: maple.eval('subs(x^2 + y^2 = t, cos(x) + sin(y) + x^2 + y^2 + t)')          # optional requires maple
 …
             sage: maxima.quit()
             sage: maxima.eval('cos(x) + sin(y) + x^2 + y^2 + t, x^2 + y^2 = t')
             'sin(y)+y^2+cos(x)+x^2+t'
         Actually Mathematica does something that makes more sense::
             sage: mathematica.eval('Cos[x] + Sin[y] + x^2 + y^2 + t /. x^2 + y^2 -> t')       # optional -- requires mathematica
 t + Cos[x] + Sin[y]
         """
 …
         """
         from sage.symbolic.expression_conversions import SubstituteFunction
         return SubstituteFunction(self, original, new)()
     def __call__(self, *args, **kwds):
         """
         Calls the :meth:`subs` on this expression.
         EXAMPLES::
             sage: var('x,y,z')
             (x, y, z)
             sage: (x+y)(x=z^2, y=x^y)
 …
         Return sorted tuple of variables that occur in this expression.
         EXAMPLES::
             sage: (x,y,z) = var('x,y,z')
             sage: (x+y).variables()
             (x, y)
 …
             (x, y, z)
         """
         from sage.symbolic.ring import SR
+        from sage.symbolic.ring import SR
         cdef GExSet sym_set
         g_list_symbols(self._gobj, sym_set)
         res = []
 …
         ::
             sage: x,y,z = var('x,y,z')
             sage: (x+y).number_of_arguments()
 …
             sage: (sin(x+y)).number_of_arguments()
         ::
+        ::
             sage: ( 2^(8/9) - 2^(1/9) )(x-1)
             Traceback (most recent call last):
             ...
 …
         Returns the number of arguments of this expression.
         EXAMPLES::
             sage: var('a,b,c,x,y')
             (a, b, c, x, y)
             sage: a.number_of_operands()
 …
         Returns the number of arguments of this expression.
         EXAMPLES::
             sage: var('a,b,c,x,y')
             (a, b, c, x, y)
             sage: len(a)
 …
         Returns a list containing the operands of this expression.
         EXAMPLES::
             sage: var('a,b,c,x,y')
             (a, b, c, x, y)
             sage: (a^2 + b^2 + (x+y)^2).operands()
 …
         Returns the topmost operator in this expression.
         EXAMPLES::
             sage: x,y,z = var('x,y,z')
             sage: (x+y).operator()
             <built-in function add>
 …
             D[0](f)(x)
             sage: a.operator()
             D[0](f)
         TESTS:
             sage: (x <= y).operator()
             <built-in function le>
 …
     def __index__(self):
         """
         EXAMPLES::
             sage: a = range(10)
             sage: a[:SR(5)]
             [0, 1, 2, 3, 4]
         """
         return int(self._integer_())
+        return int(self._integer_())
     def iterator(self):
         """
         Return an iterator over the arguments of this expression.
         EXAMPLES::
             sage: x,y,z = var('x,y,z')
             sage: list((x+y+z).iterator())
             [x, y, z]
 …
 ##     def __getitem__(self, ind):
 ##         """
 ##         EXAMPLES::
 ##             sage: x,y,z = var('x,y,z')
 ##             sage: e = x + x*y + z^y + 3*y*z; e
 ##             x*y + 3*y*z + z^y + x
 …
         TESTS:
         We test the evaluation of different infinities available in Pynac::
             sage: t = x - oo; t
             -Infinity
             sage: t.n()
 …
             res = x.pyobject()
         else:
             raise TypeError, "cannot evaluate symbolic expresssion numerically"
         # Important -- the  we get might not be a valid output for numerical_approx in
         # the case when one gets infinity.
         if isinstance(res, AnInfinity):
 …
         result. This may lead to misleading results.
         EXAMPLES::
             sage: t = sqrt(Integer('1'*1000)).round(); t
             33333333333333330562872877837571095953933917311168389275365130348599729268937180234955282892214983624063325870179809380946753270304893256291223685906477377407805362767048122713900447143840625646189582982153140391592656164907437770144711391823061825859553426442610175266854303816282031207413258045024789468633297982051760989540057817134748449866609872506236671598268343900233203388804404405970909678015833968186200327087593697947284709714538428657648875107834928345435181446453242319048564666814955520
 …
         EXAMPLES:
         We will use several symbolic variables in the examples below::
             sage: var('x, y, z, t, a, w, n')
             (x, y, z, t, a, w, n)
         ::
+        ::
             sage: u = sin(x) + x*cos(y)
             sage: g = u.function(x,y)
             sage: g(x,y)
 …
             t*cos(z) + sin(t)
             sage: g(x^2, x^y)
             x^2*cos(x^y) + sin(x^2)
         ::
+        ::
             sage: f = (x^2 + sin(a*w)).function(a,x,w); f
             (a, x, w) |--> x^2 + sin(a*w)
             sage: f(1,2,3)
             sin(3) + 4
         Using the :meth:`function` method we can obtain the above function
         `f`, but viewed as a function of different variables::
             sage: h = f.function(w,a); h
             (w, a) |--> x^2 + sin(a*w)
         This notation also works::
             sage: h(w,a) = f
             sage: h
             (w, a) |--> x^2 + sin(a*w)
         You can even make a symbolic expression `f` into a function
         by writing ``f(x,y) = f``::
             sage: f = x^n + y^n; f
             x^n + y^n
             sage: f(x,y) = f
 …
     def coefficient(self, s, int n=1):
         """
         Returns the coefficient of `s^n` in this symbolic expression.
         INPUT:
         - ``s`` - expression
 …
         is not done automatically.
         EXAMPLES::
             sage: var('x,y,a')
             (x, y, a)
             sage: f = 100 + a*x + x^3*sin(x*y) + x*y + x/y + 2*sin(x*y)/x; f
 …
             sage: var('a, x, y, z')
             (a, x, y, z)
             sage: f = (a*sqrt(2))*x^2 + sin(y)*x^(1/2) + z^z
+            sage: f = (a*sqrt(2))*x^2 + sin(y)*x^(1/2) + z^z
             sage: f.coefficient(sin(y))
             sqrt(x)
+            sqrt(x)
             sage: f.coefficient(x^2)
             sqrt(2)*a
             sage: f.coefficient(x^(1/2))
 …
     def coefficients(self, x=None):
         r"""
         Coefficients of this symbolic expression as a polynomial in x.
         INPUT:
+        INPUT:
         -  ``x`` - optional variable
         OUTPUT:
+        OUTPUT:
         - A list of pairs (expr, n), where expr is a symbolic
           expression and n is a power.
         EXAMPLES::
+        EXAMPLES::
             sage: var('x, y, a')
             (x, y, a)
             sage: p = x^3 - (x-3)*(x^2+x) + 1
 …
             [[x^2 + x + 1, 0], [-2*sqrt(2)*x, 1], [2, 2]]
             sage: p.coefficients(x)
             [[2*a^2 + 1, 0], [-2*sqrt(2)*a + 1, 1], [1, 2]]
         A polynomial with wacky exponents::
             sage: p = (17/3*a)*x^(3/2) + x*y + 1/x + x^x
             sage: p.coefficients(x)
             [[1, -1], [x^x, 0], [y, 1], [17/3*a, 3/2]]
 …
         return S[1:]
     coeffs = coefficients
     def leading_coefficient(self, s):
         """
         Return the leading coefficient of s in self.
         EXAMPLES::
+        EXAMPLES::
             sage: var('x,y,a')
             (x, y, a)
             sage: f = 100 + a*x + x^3*sin(x*y) + x*y + x/y + 2*sin(x*y)/x; f
 …
         return new_Expression_from_GEx(self._parent, self._gobj.lcoeff(ss._gobj))
     leading_coeff = leading_coefficient
     def trailing_coefficient(self, s):
         """
         Return the trailing coefficient of s in self, i.e., the coefficient
         of the smallest power of s in self.
         EXAMPLES::
+        EXAMPLES::
             sage: var('x,y,a')
             (x, y, a)
             sage: f = 100 + a*x + x^3*sin(x*y) + x*y + x/y + 2*sin(x*y)/x; f
 …
         return new_Expression_from_GEx(self._parent, self._gobj.tcoeff(ss._gobj))
     trailing_coeff = trailing_coefficient
     def low_degree(self, s):
         """
         Return the exponent of the lowest nonpositive power of s in self.
 …
         - an integer <= 0.
         EXAMPLES::
             sage: var('x,y,a')
             (x, y, a)
             sage: f = 100 + a*x + x^3*sin(x*y) + x*y + x/y^10 + 2*sin(x*y)/x; f
 …
         - an integer >= 0.
         EXAMPLES::
             sage: var('x,y,a')
             (x, y, a)
             sage: f = 100 + a*x + x^3*sin(x*y) + x*y + x/y^10 + 2*sin(x*y)/x; f
 …
         Express this symbolic expression as a polynomial in *x*. If
         this is not a polynomial in *x*, then some coefficients may be
         functions of *x*.
         .. warning::
            This is different from :meth:`polynomial` which returns
            a Sage polynomial over a given base ring.
         EXAMPLES::
+        EXAMPLES::
             sage: var('a, x')
             (a, x)
             sage: p = expand((x-a*sqrt(2))^2 + x + 1); p
 …
             sage: p.poly(a)
             -2*sqrt(2)*a*x + 2*a^2 + x^2 + x + 1
             sage: bool(p.poly(a) == (x-a*sqrt(2))^2 + x + 1)
             True
+            True
             sage: p.poly(x)
             -(2*sqrt(2)*a - 1)*x + 2*a^2 + x^2 + 1
         """
 …
         r"""
         Return this symbolic expression as an algebraic polynomial
         over the given base ring, if possible.
         The point of this function is that it converts purely symbolic
         polynomials into optimised algebraic polynomials over a given
         base ring.
         .. warning::
            This is different from meth:`poly` which is used to rewrite
            self as a polynomial in terms of one of the variables.
         INPUT:
+        INPUT:
         -  ``base_ring`` - a ring
         EXAMPLES::
+        EXAMPLES::
             sage: f = x^2 -2/3*x + 1
             sage: f.polynomial(QQ)
             x^2 - 2/3*x + 1
             sage: f.polynomial(GF(19))
             x^2 + 12*x + 1
         Polynomials can be useful for getting the coefficients of an
         expression::
             sage: g = 6*x^2 - 5
             sage: g.coefficients()
             [[-5, 0], [6, 2]]
 …
             [-5, 0, 6]
             sage: g.polynomial(QQ).dict()
             {0: -5, 2: 6}
         ::
+        ::
             sage: f = x^2*e + x + pi/e
             sage: f.polynomial(RDF)
 .71828182846*x^2 + x + 1.15572734979
             sage: g = f.polynomial(RR); g
 .71828182845905*x^2 + x + 1.15572734979092
             sage: g.parent()
             Univariate Polynomial Ring in x over Real Field with 53 bits of precision
+            Univariate Polynomial Ring in x over Real Field with 53 bits of precision
             sage: f.polynomial(RealField(100))
 .7182818284590452353602874714*x^2 + x + 1.1557273497909217179100931833
             sage: f.polynomial(CDF)
 .71828182846*x^2 + x + 1.15572734979
             sage: f.polynomial(CC)
 .71828182845905*x^2 + x + 1.15572734979092
         We coerce a multivariate polynomial with complex symbolic
         coefficients::
             sage: x, y, n = var('x, y, n')
             sage: f = pi^3*x - y^2*e - I; f
             pi^3*x - y^2*e - I
 …
             (-2.71828182845905)*y^2 + 31.0062766802998*x - 1.00000000000000*I
             sage: f.polynomial(ComplexField(70))
             (-2.7182818284590452354)*y^2 + 31.006276680299820175*x - 1.0000000000000000000*I
         Another polynomial::
             sage: f = sum((e*I)^n*x^n for n in range(5)); f
             x^4*e^4 - I*x^3*e^3 - x^2*e^2 + I*x*e + 1
             sage: f.polynomial(CDF)
 .5981500331*x^4 - 20.0855369232*I*x^3 - 7.38905609893*x^2 + 2.71828182846*I*x + 1.0
             sage: f.polynomial(CC)
 .5981500331442*x^4 - 20.0855369231877*I*x^3 - 7.38905609893065*x^2 + 2.71828182845905*I*x + 1.00000000000000
         A multivariate polynomial over a finite field::
             sage: f = (3*x^5 - 5*y^5)^7; f
             (3*x^5 - 5*y^5)^7
             sage: g = f.polynomial(GF(7)); g
 …
         """
         from sage.symbolic.expression_conversions import polynomial
         return polynomial(self, base_ring=base_ring, ring=ring)
     def _polynomial_(self, R):
         """
         Coerce this symbolic expression to a polynomial in `R`.
         EXAMPLES::
+        EXAMPLES::
             sage: var('x,y,z,w')
             (x, y, z, w)
         ::
+        ::
             sage: R = QQ[x,y,z]
             sage: R(x^2 + y)
             x^2 + y
 …
             sage: R = GF(7)[z]
             sage: R(z^3 + 10*z)
             z^3 + 3*z
         .. note::
            If the base ring of the polynomial ring is the symbolic ring,
            then a constant polynomial is always returned.
         ::
+        ::
             sage: R = SR[x]
             sage: a = R(sqrt(2) + x^3 + y)
             sage: a
 …
             <class 'sage.rings.polynomial.polynomial_element_generic.Polynomial_generic_dense_field'>
             sage: a.degree()
         We coerce to a double precision complex polynomial ring::
             sage: f = e*x^3 + pi*y^3 + sqrt(2) + I; f
             pi*y^3 + x^3*e + sqrt(2) + I
             sage: R = CDF[x,y]
             sage: R(f)
 .71828182846*x^3 + 3.14159265359*y^3 + 1.41421356237 + 1.0*I
         We coerce to a higher-precision polynomial ring
         ::
+        ::
             sage: R = ComplexField(100)[x,y]
             sage: R(f)
 .7182818284590452353602874714*x^3 + 3.1415926535897932384626433833*y^3 + 1.4142135623730950488016887242 + 1.0000000000000000000000000000*I
 …
         This shows that the issue at trac #4246 is fixed (attempting to
         coerce an expression containing at least one variable that's not in
         `R` raises an error)::
             sage: x, y = var('x y')
             sage: S = PolynomialRing(Integers(4), 1, 'x')
             sage: S(x)
 …
         """
         from sage.symbolic.all import SR
         from sage.rings.all import is_MPolynomialRing
         base_ring = R.base_ring()
         if base_ring == SR:
             if is_MPolynomialRing(R):
 …
             else:
                 return R([self])
         return self.polynomial(None, ring=R)
     def power_series(self, base_ring):
         """
         Return algebraic power series associated to this symbolic
         expression, which must be a polynomial in one variable, with
         coefficients coercible to the base ring.
         The power series is truncated one more than the degree.
         EXAMPLES::
+        EXAMPLES::
             sage: theta = var('theta')
             sage: f = theta^3 + (1/3)*theta - 17/3
             sage: g = f.power_series(QQ); g
 …
         http://trac.sagemath.org/sage_trac/ticket/694 on Ginac dies
         after about 10 seconds.  Singular easily does that GCD now.
         Since Ginac only handles poly gcd over QQ, we should change
         ginac itself to use Singular.
         EXAMPLES::
+        ginac itself to use Singular.
+        EXAMPLES::
             sage: var('x,y')
             (x, y)
             sage: SR(10).gcd(SR(15))
 …
         OUTPUT:
         - expression
         EXAMPLES::
+        EXAMPLES::
             sage: var('x,y,z')
             (x, y, z)
             sage: f = 4*x*y + x*z + 20*y^2 + 21*y*z + 4*z^2 + x^2*y^2*z^2
 …
     def collect_common_factors(self):
         """
         EXAMPLES::
             sage: var('x')
+            x
             sage: (x/(x^2 + x)).collect_common_factors()
 …
     def __abs__(self):
         """
         Return the absolute value of this expression.
         EXAMPLES::
+        EXAMPLES::
             sage: var('x, y')
             (x, y)
         The absolute value of a symbolic expression::
             sage: abs(x^2+y^2)
             abs(x^2 + y^2)
         The absolute value of a number in the symbolic ring::
             sage: abs(SR(-5))
             sage: type(abs(SR(-5)))
 …
         """
         Return the value of the Heaviside step function, which is 0 for
         negative x, 1/2 for 0, and 1 for positive x.
         EXAMPLES::
+        EXAMPLES::
             sage: x = var('x')
             sage: SR(1.5).step()
 …
         symbolic expression.
         It can be somewhat arbitrary when self is not real.
         EXAMPLES:
             sage: x = var('x')
             sage: SR(-2).csgn()
 …
     def conjugate(self):
         """
         Return the complex conjugate of this symbolic expression.
         EXAMPLES::
             sage: a = 1 + 2*I
+        EXAMPLES::
+            sage: a = 1 + 2*I
             sage: a.conjugate()
             -2*I + 1
             sage: a = sqrt(2) + 3^(1/3)*I; a
 …
         r"""
         The complex norm of this symbolic expression, i.e.,
         the expression times its complex conjugate.
         EXAMPLES::
             sage: a = 1 + 2*I
+        EXAMPLES::
+            sage: a = 1 + 2*I
             sage: a.norm()
             sage: a = sqrt(2) + 3^(1/3)*I; a
 …
         Return the real part of this symbolic expression.
         EXAMPLES::
             sage: x = var('x')
             sage: x.real_part()
             real_part(x)
 …
             sage: sqrt(-2).imag_part()
             sqrt(2)
         We simplify `\ln(\exp(z))` to `z`.  This should only
         be for `-\pi<{\rm Im}(z)<=\pi`, but Maxima does not
         have a symbolic imaginary part function, so we cannot
 …
             sage: f.simplify()
+            z
             sage: forget()
         A more symbolic example::
             sage: var('a, b')
             (a, b)
             sage: f = log(a + b*I)
 …
             arctan2(real_part(b) + imag_part(a), real_part(a) - imag_part(b))
         TESTS::
             sage: x = var('x')
             sage: x.imag_part()
             imag_part(x)
 …
     def cos(self):
         """
         Return the cosine of self.
         EXAMPLES::
             sage: var('x, y')
 …
             sage: SR(RR(1)).cos().n()
 .540302305868140
             sage: SR(float(1)).cos().n()
 .540302305868140
+.540302305868140
         TESTS::
 …
         """
         Return the arcsin of x, i.e., the number y between -pi and pi
         such that sin(y) == x.
         EXAMPLES::
             sage: x.arcsin()
 …
     def arctan2(self, x):
         """
         Return the inverse of the 2-variable tan function on self and x.
         EXAMPLES::
             sage: var('x,y')
 …
 .0
             sage: SR(0).arctan2(0)
             sage: SR(I).arctan2(1)
             arctan2(I, 1)
             sage: SR(CDF(0,1)).arctan2(1)
 …
         r"""
         Return sinh of self.
         We have $\sinh(x) = (e^{x} - e^{-x})/2$.
+        We have $\sinh(x) = (e^{x} - e^{-x})/2$.
         EXAMPLES::
 …
         r"""
         Return cosh of self.
         We have $\cosh(x) = (e^{x} + e^{-x})/2$.
+        We have $\cosh(x) = (e^{x} + e^{-x})/2$.
         EXAMPLES::
 …
         r"""
         Return tanh of self.
         We have $\tanh(x) = \sinh(x) / \cosh(x)$.
+        We have $\tanh(x) = \sinh(x) / \cosh(x)$.
         EXAMPLES::
 …
     def arcsinh(self):
         """
         Return the inverse hyperbolic sine of self.
         EXAMPLES::
             sage: x.arcsinh()
 …
     def zeta(self):
         """
         EXAMPLES::
             sage: x, y = var('x, y')
             sage: (x/y).zeta()
             zeta(x/y)
 …
             sage: plot(lambda x: SR(x).zeta(), -10,10).show(ymin=-3,ymax=3)
         TESTS::
             sage: t = SR(1).zeta(); t
             zeta(1)
             sage: t.n()
 …
         cdef GEx x = g_zeta(self._gobj)
         _sig_off
         return new_Expression_from_GEx(self._parent, x)
     def factorial(self):
         """
         Return the factorial of self.
         OUTPUT:
             symbolic expression
         EXAMPLES:
             sage: var('x, y')
             (x, y)
 …
     def binomial(self, k):
         """
         Return binomial coefficient "self choose k".
         OUTPUT:
             symbolic expression
         EXAMPLES:
             sage: var('x, y')
             (x, y)
 …
         OUTPUT:
             symbolic expression
         EXAMPLES:
             sage: n = var('n')
             sage: t = (17*n^3).Order(); t
 …
     def gamma(self):
         """
         Return the Gamma function evaluated at self.
         EXAMPLES:
             sage: x = var('x')
             sage: x.gamma()
 …
         This is the logarithm of gamma of self, where
         gamma is a complex function such that gamma(n)
         equals factorial(n-1).
         EXAMPLES::
             sage: x = var('x')
 …
         Return the default variable, which is by definition the first
         variable in self, or `x` is there are no variables in self.
         The result is cached.
         EXAMPLES::
+        EXAMPLES::
             sage: sqrt(2).default_variable()
+            x
+            x
             sage: x, theta, a = var('x, theta, a')
             sage: f = x^2 + theta^3 - a^x
             sage: f.default_variable()
+            a
         Note that this is the first *variable*, not the first *argument*::
             sage: f(theta, a, x) = a + theta^3
             sage: f.default_variable()
+            a
 …
         Returns a simplified version of this symbolic expression
         by combining all terms with the same denominator into a single
         term.
         EXAMPLES::
+        EXAMPLES::
             sage: var('x, y, a, b, c')
             (x, y, a, b, c)
             sage: f = x*(x-1)/(x^2 - 7) + y^2/(x^2-7) + 1/(x+1) + b/a + c/a; f
 …
             ((x - 1)*x + y^2)/(x^2 - 7) + (b + c)/a + 1/(x + 1)
         """
         return self.parent()(self._maxima_().combine())
     def numerator(self):
         """
         Returns the numerator of this symbolic expression.  If the
         expression is not a quotient, then this will return the
         expression itself.
         EXAMPLES::
+        EXAMPLES::
             sage: a, x, y = var('a,x,y')
             sage: f = x*(x-a)/((x^2 - y)*(x-a)); f
             x/(x^2 - y)
 …
         """
         Returns the denominator of this symbolic expression.  If the
         expression is not a quotient, then this will just return 1.
         EXAMPLES::
+        EXAMPLES::
             sage: x, y, z, theta = var('x, y, z, theta')
             sage: f = (sqrt(x) + sqrt(y) + sqrt(z))/(x^10 - y^10 - sqrt(theta))
             sage: f.denominator()
 …
         r"""
         Return the partial fraction expansion of ``self`` with
         respect to the given variable.
         INPUT:
+        INPUT:
         -  ``var`` - variable name or string (default: first
            variable)
         OUTPUT: Symbolic expression
         EXAMPLES::
+        EXAMPLES::
             sage: f = x^2/(x+1)^3
             sage: f.partial_fraction()
 /(x + 1) - 2/(x + 1)^2 + 1/(x + 1)^3
             sage: f.partial_fraction()
 /(x + 1) - 2/(x + 1)^2 + 1/(x + 1)^3
         Notice that the first variable in the expression is used by
         default::
             sage: y = var('y')
             sage: f = y^2/(y+1)^3
             sage: f.partial_fraction()
 /(y + 1) - 2/(y + 1)^2 + 1/(y + 1)^3
             sage: f = y^2/(y+1)^3 + x/(x-1)^3
             sage: f.partial_fraction()
             y^2/(y^3 + 3*y^2 + 3*y + 1) + 1/(x - 1)^2 + 1/(x - 1)^3
         You can explicitly specify which variable is used::
             sage: f.partial_fraction(y)
             x/(x^3 - 3*x^2 + 3*x - 1) + 1/(y + 1) - 2/(y + 1)^2 + 1/(y + 1)^3
         """
 …
     def simplify(self):
         """
         Returns a simplified version of this symbolic expression.
         .. note::
            Currently, this just sends the expression to Maxima
 …
             x^(-a + 1)*sin(2)
         """
         return self._parent(self._maxima_())
     def simplify_full(self):
         """
         Applies simplify_factorial, simplify_trig, simplify_rational, and simplify_radical
         to self (in that order).
         ALIAS: simplify_full and full_simplify are the same.
         EXAMPLES::
+        EXAMPLES::
             sage: a = log(8)/log(2)
             sage: a.simplify_full()
         ::
+        ::
             sage: f = sin(x)^2 + cos(x)^2
             sage: f.simplify_full()
         ::
+        ::
             sage: f = sin(x/(x^2 + x))
             sage: f.simplify_full()
             sin(1/(x + 1))
 …
     full_simplify = simplify_full
     def simplify_trig(self,expand=True):
         r"""
+        r"""
         Optionally expands and then employs identities such as
         `\sin(x)^2 + \cos(x)^2 = 1`, `\cosh(x)^2 - \sinh(x)^2 = 1`,
         `\sin(x)\csc(x) = 1`, or `\tanh(x)=\sinh(x)/\cosh(x)`
         to simplify expressions containing tan, sec, etc., to sin,
         cos, sinh, cosh.
         INPUT:
         - ``self`` - symbolic expression
 …
           angles occurring in ``self`` first. For best results,
           ``self`` should be expanded. See also :meth:`expand_trig` to
           get more controls on this expansion.
         ALIAS: :meth:`trig_simplify` and :meth:`simplify_trig` are the same
         EXAMPLES::
+        EXAMPLES::
             sage: f = sin(x)^2 + cos(x)^2; f
             sin(x)^2 + cos(x)^2
             sage: f.simplify()
 …
             sage: f=tan(3*x)
             sage: f.simplify_trig()
             (4*cos(x)^2 - 1)*sin(x)/(4*cos(x)^3 - 3*cos(x))
             sage: f.simplify_trig(False)
+            sage: f.simplify_trig(False)
             sin(3*x)/cos(3*x)
         """
         # much better to expand first, since it often doesn't work
         # right otherwise!
 …
         INPUT:
         - ``self`` - symbolic expression
+        - ``self`` - symbolic expression
         - ``method`` - (default: 'full') string which switches the
           method for simplifications. Possible values are
+          method for simplifications. Possible values are
           - 'simple' (simplify rational functions into quotient of two
             polynomials),
+            polynomials),
           - 'full' (apply repeatedly, if necessary)
 …
         DETAILS: We call Maxima functions ratsimp, fullratsimp and
         xthru. If each part of the expression has to be simplified
         separately, we use Maxima function map.
         EXAMPLES::
+        EXAMPLES::
             sage: f = sin(x/(x^2 + x))
             sage: f
             sin(x/(x^2 + x))
             sage: f.simplify_rational()
             sin(1/(x + 1))
         ::
+        ::
             sage: f = ((x - 1)^(3/2) - (x + 1)*sqrt(x - 1))/sqrt((x - 1)*(x + 1)); f
             ((x - 1)^(3/2) - sqrt(x - 1)*(x + 1))/sqrt((x - 1)*(x + 1))
             sage: f.simplify_rational()
 …
             sage: f.simplify_rational(map=True)
             x - log(x)/(x + 2) - 1
         Here is an example from the Maxima documentation of where
+        Here is an example from the Maxima documentation of where
         ``method='simple'`` produces an (possibly useful) intermediate
         step::
 …
     def simplify_factorial(self):
         """
         Simplify by combining expressions with factorials, and by
+        Simplify by combining expressions with factorials, and by
         expanding binomials into factorials.
         ALIAS: factorial_simplify and simplify_factorial are the same
         EXAMPLES:
         Some examples are relatively clear::
             sage: var('n,k')
             (n, k)
             sage: f = factorial(n+1)/factorial(n); f
 …
             factorial(-k + n)*factorial(k)*binomial(n, k)
             sage: f.simplify_factorial()
             factorial(n)
         A more complicated example, which needs further processing::
             sage: f = factorial(x)/factorial(x-2)/2 + factorial(x+1)/factorial(x)/2; f
 …
         exponentials, and radicals, by converting it into a form which is
         canonical over a large class of expressions and a given ordering of
         variables
         DETAILS: This uses the Maxima radcan() command. From the Maxima
         documentation: "All functionally equivalent forms are mapped into a
         unique form. For a somewhat larger class of expressions, produces a
 …
         time consuming. This is the cost of exploring certain relationships
         among the components of the expression for simplifications based on
         factoring and partial fraction expansions of exponents."
         ALIAS: radical_simplify, simplify_radical, exp_simplify, simplify_exp
+        ALIAS: radical_simplify, simplify_radical, exp_simplify, simplify_exp
         are all the same
         EXAMPLES::
+        EXAMPLES::
             sage: var('x,y,a')
             (x, y, a)
         ::
+        ::
             sage: f = log(x*y)
             sage: f.simplify_radical()
             log(x) + log(y)
         ::
+        ::
             sage: f = (log(x+x^2)-log(x))^a/log(1+x)^(a/2)
             sage: f.simplify_radical()
             log(x + 1)^(1/2*a)
         ::
+        ::
             sage: f = (e^x-1)/(1+e^(x/2))
             sage: f.simplify_exp()
             e^(1/2*x) - 1
 …
         this transformation in optional parameter ``method``.
         INPUT:
         - ``self`` - expression to be simplified
         - ``method`` - (default: None) optional, governs the condition
           on a1 and a2 which must be satisfied to contract expression
           a1*log(b1) + a2*log(b2). Values are
           - None (use Maxima default, integers),
           - 'one' (1 and -1),
           - 'ratios' (integers and fractions of integers),
           - 'constants' (constants),
           - 'all' (all expressions).
+          a1*log(b1) + a2*log(b2). Values are
+          - None (use Maxima default, integers),
+          - 'one' (1 and -1),
+          - 'ratios' (integers and fractions of integers),
+          - 'constants' (constants),
+          - 'all' (all expressions).
           See also examples below.
         DETAILS: This uses the Maxima logcontract() command. From the
         Maxima documentation: "Recursively scans the expression expr,
         transforming subexpressions of the form a1*log(b1) +
 …
         logconcoeffp:'logconfun$ logconfun(m):=featurep(m,integer) or
         ratnump(m)$ . Then logcontract(1/2*log(x)); will give
         log(sqrt(x))."
         ALIAS: :meth:`log_simplify` and :meth:`simplify_log` are the
         same
         EXAMPLES::
             sage: x,y,t=var('x y t')
         Only two first terms are contracted in the following example ,
         the logarithm with coefficient 1/2 is not contracted::
             sage: f = log(x)+2*log(y)+1/2*log(t)
             sage: f.simplify_log()
             log(x*y^2) + 1/2*log(t)
         To contract all terms in previous example use option ``method``::
             sage: f.simplify_log(method='ratios')
             log(sqrt(t)*x*y^2)
 …
         has no influence to future calls (we changed some default
         Maxima flag, and have to ensure that this flag has been
         restored)::
             sage: f.simplify_log('one')
 /2*log(t) + log(x) + 2*log(y)
             sage: f.simplify_log('ratios')
             log(sqrt(t)*x*y^2)
+            log(sqrt(t)*x*y^2)
             sage: f.simplify_log()
             log(x*y^2) + 1/2*log(t)
         To contract terms with no coefficient (more precisely, with
+            log(x*y^2) + 1/2*log(t)
+        To contract terms with no coefficient (more precisely, with
         coefficients 1 and -1) use option ``method``::
             sage: f = log(x)+2*log(y)-log(t)
             sage: f.simplify_log('one')
+            sage: f = log(x)+2*log(y)-log(t)
+            sage: f.simplify_log('one')
 *log(y) + log(x/t)
         ::
 …
             sage: f.simplify_log('ratios')
             log(x*y/(x + 1)^(1/3))
         `\pi` is irrational number, to contract logarithms in the following example
+        `\pi` is irrational number, to contract logarithms in the following example
         we have to put ``method`` to ``constants`` or ``all``::
             sage: f = log(x)+log(y)-pi*log((x+1))
+            sage: f = log(x)+log(y)-pi*log((x+1))
             sage: f.simplify_log('constants')
             log(x*y/(x + 1)^pi)
 …
             sage: (x*log(9)).simplify_log('all')
             log(9^x)
         TESTS::
         This shows that the issue at trac #7344 is fixed::
+        TESTS::
+        This shows that the issue at trac #7344 is fixed::
             sage: (log(sqrt(2)-1)+log(sqrt(2)+1)).simplify_full()
         AUTHORS:
         - Robert Marik (11-2009)
+        - Robert Marik (11-2009)
         """
         from sage.calculus.calculus import maxima
         maxima.eval('domain: real$ savelogexpand:logexpand$ logexpand:false$')
 …
         elif method == 'constants':
             maxima.eval('logconfun(m):= constantp(m)$')
         elif method == 'all':
             maxima.eval('logconfun(m):= true$')
+            maxima.eval('logconfun(m):= true$')
         elif method is not None:
             raise NotImplementedError, "unknown method, see the help for available methods"
         res = self.parent()(self._maxima_().logcontract())
         maxima.eval('domain: complex$')
         if method is not None:
             maxima.eval('logconcoeffp:false$')
         maxima.eval('logexpand:savelogexpand$')
+        maxima.eval('logexpand:savelogexpand$')
         return res
     log_simplify = simplify_log
     def expand_log(self,method='products'):
         r"""
         Simplifies symbolic expression, which can contain logs.
+        r"""
+        Simplifies symbolic expression, which can contain logs.
         Expands logarithms of powers, logarithms of products and
         logarithms of quotients.  The option ``method`` specifies
         which expression types should be expanded.
         INPUT:
         - ``self`` - expression to be simplified
         - ``method`` - (default: 'products') optional, governs which
           expression is expanded. Possible values are
           - 'nothing' (no expansion),
           - 'powers' (log(a^r) is expanded),
           - 'products' (like 'powers' and also log(a*b) are expanded),
           - 'all' (all possible expansion).
           See also examples below.
+          expression is expanded. Possible values are
+          - 'nothing' (no expansion),
+          - 'powers' (log(a^r) is expanded),
+          - 'products' (like 'powers' and also log(a*b) are expanded),
+          - 'all' (all possible expansion).
+          See also examples below.
         DETAILS: This uses the Maxima simplifier and sets
         ``logexpand`` option for this simplifier. From the Maxima
         documentation: "Logexpand:true causes log(a^b) to become
 …
         a#1. (log(1/b), for integer b, always simplifies.) If it is
         set to false, all of these simplifications will be turned
         off. "
         ALIAS: :meth:`log_expand` and :meth:`expand_log` are the same
         EXAMPLES::
         By default powers and products (and quotients) are expanded,
         but not quotients of integers::
             sage: (log(3/4*x^pi)).log_expand()
             pi*log(x) + log(3/4)
 …
         The expression ``log((3*x)^6)`` is not expanded with
         ``method='powers'``, since it is converted into product
         first::
             sage: (log((3*x)^6)).log_expand('powers')
             log(729*x^6)
 …
         has no influence to future calls (we changed some default
         Maxima flag, and have to ensure that this flag has been
         restored)::
             sage: (log(3/4*x^pi)).log_expand()
             pi*log(x) + log(3/4)
 …
             sage: (log(3/4*x^pi)).log_expand()
             pi*log(x) + log(3/4)
         AUTHORS:
         - Robert Marik (11-2009)
+        - Robert Marik (11-2009)
         """
         from sage.calculus.calculus import maxima
         maxima.eval('domain: real$ savelogexpand:logexpand$')
 …
         maxima.eval('logexpand:%s'%maxima_method)
         res = self._maxima_()
         res = res.sage()
         maxima.eval('domain: complex$ logexpand:savelogexpand$')
         return res
     log_expand = expand_log
+        maxima.eval('domain: complex$ logexpand:savelogexpand$')
+        return res
+    log_expand = expand_log
     def factor(self, dontfactor=[]):
         """
         Factors self, containing any number of variables or functions, into
         factors irreducible over the integers.
         INPUT:
+        INPUT:
         -  ``self`` - a symbolic expression
         -  ``dontfactor`` - list (default: []), a list of
            variables with respect to which factoring is not to occur.
            Factoring also will not take place with respect to any variables
            which are less important (using the variable ordering assumed for
            CRE form) than those on the 'dontfactor' list.
         EXAMPLES::
+        EXAMPLES::
             sage: x,y,z = var('x, y, z')
             sage: (x^3-y^3).factor()
             (x - y)*(x^2 + x*y + y^2)
 …
         dontfactor is empty) the factorization is done using Singular
         instead of Maxima, so the following is very fast instead of
         dreadfully slow::
             sage: var('x,y')
             (x, y)
             sage: (x^99 + y^99).factor()
 …
         """
         Returns a list of the factors of self, as computed by the
         factor command.
         INPUT:
+        INPUT:
         -  ``self`` - a symbolic expression
         -  ``dontfactor`` - see docs for :meth:`factor`
         .. note::
            If you already have a factored expression and just want to
            get at the individual factors, use :meth:`_factor_list`
            instead.
         EXAMPLES::
+        EXAMPLES::
             sage: var('x, y, z')
             (x, y, z)
             sage: f = x^3-y^3
             sage: f.factor()
             (x - y)*(x^2 + x*y + y^2)
         Notice that the -1 factor is separated out::
             sage: f.factor_list()
             [(x - y, 1), (x^2 + x*y + y^2, 1)]
         We factor a fairly straightforward expression::
             sage: factor(-8*y - 4*x + z^2*(2*y + x)).factor_list()
             [(z - 2, 1), (z + 2, 1), (x + 2*y, 1)]
         A more complicated example::
             sage: var('x, u, v')
             (x, u, v)
             sage: f = expand((2*u*v^2-v^2-4*u^3)^2 * (-u)^3 * (x-sin(x))^3)
+            sage: f = expand((2*u*v^2-v^2-4*u^3)^2 * (-u)^3 * (x-sin(x))^3)
             sage: f.factor()
             -(x - sin(x))^3*(4*u^3 - 2*u*v^2 + v^2)^2*u^3
             sage: g = f.factor_list(); g
+            sage: g = f.factor_list(); g
             [(x - sin(x), 3), (4*u^3 - 2*u*v^2 + v^2, 2), (u, 3), (-1, 1)]
         This function also works for quotients::
             sage: f = -1 - 2*x - x^2 + y^2 + 2*x*y^2 + x^2*y^2
             sage: g = f/(36*(1 + 2*y + y^2)); g
 /36*(x^2*y^2 + 2*x*y^2 - x^2 + y^2 - 2*x - 1)/(y^2 + 2*y + 1)
 …
 /36*(y - 1)*(x^2 + 2*x + 1)/(y + 1)
             sage: g.factor_list(dontfactor=[x])
             [(y - 1, 1), (y + 1, -1), (x^2 + 2*x + 1, 1), (1/36, 1)]
         This example also illustrates that the exponents do not have to be
         integers::
             sage: f = x^(2*sin(x)) * (x-1)^(sqrt(2)*x); f
             (x - 1)^(sqrt(2)*x)*x^(2*sin(x))
             sage: f.factor_list()
 …
         r"""
         Turn an expression already in factored form into a list of (prime,
         power) pairs.
         This is used, e.g., internally by the :meth:`factor_list`
         command.
         EXAMPLES::
+        EXAMPLES::
             sage: g = factor(x^3 - 1); g
             (x - 1)*(x^2 + x + 1)
             sage: v = g._factor_list(); v
 …
             return [tuple(self.operands())]
         else:
             return [(self, 1)]
     ###################################################################
     # solve
     ###################################################################
 …
         Returns roots of ``self`` that can be found exactly,
         possibly with multiplicities.  Not all roots are guaranteed to
         be found.
         .. warning::
            This is *not* a numerical solver - use ``find_root`` to
            solve for self == 0 numerically on an interval.
         INPUT:
+        INPUT:
         - ``x`` - variable to view the function in terms of
           (use default variable if not given)
         - ``explicit_solutions`` - bool (default True); require that
           roots be explicit rather than implicit
         - ``multiplicities`` - bool (default True); when True, return
           multiplicities
         - ``ring`` - a ring (default None): if not None, convert
           self to a polynomial over ring and find roots over ring
         OUTPUT:
+        OUTPUT:
         list of pairs (root, multiplicity) or list of roots
         If there are infinitely many roots, e.g., a function like
         `\sin(x)`, only one is returned.
         EXAMPLES::
+        EXAMPLES::
             sage: var('x, a')
             (x, a)
         A simple example::
             sage: ((x^2-1)^2).roots()
             [(-1, 2), (1, 2)]
             sage: ((x^2-1)^2).roots(multiplicities=False)
             [-1, 1]
         A complicated example::
             sage: f = expand((x^2 - 1)^3*(x^2 + 1)*(x-a)); f
             -a*x^8 + x^9 + 2*a*x^6 - 2*x^7 - 2*a*x^2 + 2*x^3 + a - x
         The default variable is `a`, since it is the first in
         alphabetical order::
             sage: f.roots()
             [(x, 1)]
         As a polynomial in `a`, `x` is indeed a root::
             sage: f.poly(a)
             x^9 - 2*x^7 + 2*x^3 - (x^8 - 2*x^6 + 2*x^2 - 1)*a - x
             sage: f(a=x)
         The roots in terms of `x` are what we expect::
             sage: f.roots(x)
             [(a, 1), (-I, 1), (I, 1), (1, 3), (-1, 3)]
         Only one root of `\sin(x) = 0` is given::
             sage: f = sin(x)
+            sage: f = sin(x)
             sage: f.roots(x)
             [(0, 1)]
         .. note::
             It is possible to solve a greater variety of equations
             using ``solve()`` and the keyword ``to_poly_solve``,
             but only at the price of possibly encountering
+            using ``solve()`` and the keyword ``to_poly_solve``,
+            but only at the price of possibly encountering
             approximate solutions.  See documentation for f.solve
             for more details.
         We derive the roots of a general quadratic polynomial::
             sage: var('a,b,c,x')
             (a, b, c, x)
             sage: (a*x^2 + b*x + c).roots(x)
             [(-1/2*(b + sqrt(-4*a*c + b^2))/a, 1), (-1/2*(b - sqrt(-4*a*c + b^2))/a, 1)]
         By default, all the roots are required to be explicit rather than
         implicit. To get implicit roots, pass ``explicit_solutions=False``
+        implicit. To get implicit roots, pass ``explicit_solutions=False``
         to ``.roots()`` ::
             sage: var('x')
+            x
             sage: f = x^(1/9) + (2^(8/9) - 2^(1/9))*(x - 1) - x^(8/9)
 …
         Another example, but involving a degree 5 poly whose roots don't
         get computed explicitly::
             sage: f = x^5 + x^3 + 17*x + 1
             sage: f.roots()
             Traceback (most recent call last):
 …
             [x^5 + x^3 + 17*x + 1]
         Now let's find some roots over different rings::
             sage: f.roots(ring=CC)
             [(-0.0588115223184..., 1), (-1.331099917875... - 1.52241655183732*I, 1), (-1.331099917875... + 1.52241655183732*I, 1), (1.36050567903502 - 1.51880872209965*I, 1), (1.36050567903502 + 1.51880872209965*I, 1)]
             sage: (2.5*f).roots(ring=RR)
 …
             [-0.05881152231844944?, -1.331099917875796? - 1.522416551837318?*I, -1.331099917875796? + 1.522416551837318?*I, 1.360505679035020? - 1.518808722099650?*I, 1.360505679035020? + 1.518808722099650?*I]
         Root finding over finite fields::
             sage: f.roots(ring=GF(7^2, 'a'))
             [(3, 1), (4*a + 6, 2), (3*a + 3, 2)]
         TESTS::
             sage: (sqrt(3) * f).roots(ring=QQ)
             Traceback (most recent call last):
             ...
 …
     def solve(self, x, multiplicities=False, solution_dict=False, explicit_solutions=False, to_poly_solve=False):
         r"""
         Analytically solve the equation ``self == 0`` or an univarite
         inequality for the variable `x`.
+        inequality for the variable `x`.
         .. warning::
            This is not a numerical solver - use ``find_root`` to solve
            for self == 0 numerically on an interval.
         INPUT:
+        INPUT:
         -  ``x`` - variable to solve for
         -  ``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 inequality.
+           any sense when solving inequality.
         -  ``solution_dict`` - bool (default: False); if True,
            return a list of dictionaries containing solutions. Not used
            when solving inequality.
+           when solving inequality.
         -  ``explicit_solutions`` - bool (default: False); require that
            all roots be explicit rather than implicit. Not used
            when solving inequality.
         -  ``to_poly_solve`` - bool (default: False); use Maxima's
            ``to_poly_solver`` package to search for more possible
+           when solving 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 inequality.
+        EXAMPLES::
+           and is not used when solving inequality. Setting ``to_poly_solve``
+           to 'force' (string) omits Maxima's solve command (usefull when
+           some solution of trigonometric equations are lost).
+        EXAMPLES::
             sage: z = var('z')
             sage: (z^5 - 1).solve(z)
             [z == e^(2/5*I*pi), z == e^(4/5*I*pi), z == e^(-4/5*I*pi), z == e^(-2/5*I*pi), z == 1]
 …
         A simple example to show use of the keyword
         ``multiplicities``::
             sage: ((x^2-1)^2).solve(x)
             [x == -1, x == 1]
             sage: ((x^2-1)^2).solve(x,multiplicities=True)
 …
             sage: solve(Q*sqrt(Q^2 + 2) - 1, Q)
             [Q == 1/sqrt(Q^2 + 2)]
             sage: solve(Q*sqrt(Q^2 + 2) - 1, Q, to_poly_solve=True)
                         [Q == 1/sqrt(-sqrt(2) + 1), Q == 1/sqrt(sqrt(2) + 1)]
+                        [Q == 1/sqrt(-sqrt(2) + 1), Q == 1/sqrt(sqrt(2) + 1)]
         In some cases there may be infinitely many solutions indexed
         by a dummy variable.  If it begins with ``z``, it is implicitly
 …
             sage: solve( sin(x)==cos(x), x, to_poly_solve=True)
             [x == 1/4*pi + pi*z45]
         An effort is made to only return solutions that satisfy the current assumptions::
             sage: solve(x^2==4, x)
             [x == -2, x == 2]
             sage: assume(x<0)
 …
             [x == -sqrt(-z + 2)]
             sage: solve((x-z)^2==2, x)
             [x == z - sqrt(2), x == z + sqrt(2)]
         There is still room for improvement::
             sage: assume(x, 'integer')
             sage: assume(z, 'integer')
             sage: solve((x-z)^2==2, x)
             [x == z - sqrt(2), x == z + sqrt(2)]
             sage: forget()
         In some cases it may be worthwhile to directly use to_poly_solve,
 …
             sage: (x^2>1).solve(x)
             [[x < -1], [x > 1]]
         Catch error message from Maxima::
+        Catch error message from Maxima::
             sage: solve(acot(x),x)
             []
         ::
+        ::
             sage: solve(acot(x),x,to_poly_solve=True)
             []
         Trac #7491 fixed::
+        Trac #7491 fixed::
             sage: y=var('y')
             sage: solve(y==y,y)
             [y == r1]
             sage: solve(y==y,y,multiplicities=True)
             ([y == r1], [])
             sage: from sage.symbolic.assumptions import GenericDeclaration
             sage: GenericDeclaration(x, 'rational').assume()
             sage: solve(x^2 == 2, x)
             []
             sage: forget()
+        Trac #8390 fixed::
+            sage: solve(sin(x)==1/2,x)
+            [x == 1/6*pi]
+        ::
+            sage: solve(sin(x)==1/2,x,to_poly_solve=True)
+            [x == 1/6*pi]
+        ::
+            sage: solve(sin(x)==1/2,x,to_poly_solve='force')
+            [x == 5/6*pi + 2*pi*z87, x == 1/6*pi + 2*pi*z85]
         """
         import operator
         cdef Expression ex
 …
         if explicit_solutions:
             P.eval('solveexplicit: true') # switches Maxima to looking for only explicit solutions
         try:
+            s = m.solve(x).str()
+            if to_poly_solve != 'force':
+                s = m.solve(x).str()
+            else: # omit Maxima's solve command
+                s = str([])
         except TypeError, mess: # if Maxima's solve has an error, we catch it
             if "Error executing code in Maxima" in str(mess):
                 s = str([])
 …
             if solution_dict:
                 ans = (dict([[x,self.parent().var('r1')]]))
             else:
                 ans = ([x == self.parent().var('r1')])
             if multiplicities:
+                ans = ([x == self.parent().var('r1')])
+            if multiplicities:
                 return ans,[]
             else:
                 return ans
 …
         # but also allows for the possibility of approximate   #
         # solutions being returned.                            #
         ########################################################
         if to_poly_solve and not multiplicities:
+        if to_poly_solve and not multiplicities:
             if len(X)==0: # if Maxima's solve gave no solutions, only try it
                 try:
                     s = m.to_poly_solve(x)
 …
                     from sage.calculus.calculus import symbolic_expression_from_maxima_element
                     try:
                         Y = symbolic_expression_from_maxima_element((eq._maxima_()).to_poly_solve(x)) # try to solve it using to_poly_solve
                         X.remove(eq)
+                        X.remove(eq)
                         X.extend([y[0] for y in Y]) # replace with the new solutions
                     except TypeError, mess:
                         if "Error executing code in Maxima" in str(mess) or "unable to make sense of Maxima expression" in str(mess):
 …
         """
         Numerically find a root of self on the closed interval [a,b] (or
         [b,a]) if possible, where self is a function in the one variable.
         INPUT:
+        INPUT:
         -  ``a, b`` - endpoints of the interval
         -  ``var`` - optional variable
         -  ``xtol, rtol`` - the routine converges when a root
            is known to lie within xtol of the value return. Should be = 0. The
            routine modifies this to take into account the relative precision
            of doubles.
         -  ``maxiter`` - integer; if convergence is not
            achieved in maxiter iterations, an error is raised. Must be = 0.
         -  ``full_output`` - bool (default: False), if True,
            also return object that contains information about convergence.
         EXAMPLES:
         Note that in this example both f(-2) and f(3) are positive,
         yet we still find a root in that interval::
             sage: f = x^2 - 1
             sage: f.find_root(-2, 3)
 .0
 …
             sage: result.root
 .0
         More examples::
             sage: (sin(x) + exp(x)).find_root(-10, 10)
             -0.588532743981862...
             sage: sin(x).find_root(-1,1)
 .0
             sage: (1/tan(x)).find_root(3,3.5)
 .1415926535...
         An example with a square root::
             sage: f = 1 + x + sqrt(x+2); f.find_root(-2,10)
             -1.6180339887498949
         Some examples that Ted Kosan came up with::
             sage: t = var('t')
             sage: v = 0.004*(9600*e^(-(1200*t)) - 2400*e^(-(300*t)))
             sage: v.find_root(0, 0.002)
 .001540327067911417...
         With this expression, we can see there is a
+        With this expression, we can see there is a
         zero very close to the origin::
             sage: a = .004*(8*e^(-(300*t)) - 8*e^(-(1200*t)))*(720000*e^(-(300*t)) - 11520000*e^(-(1200*t))) +.004*(9600*e^(-(1200*t)) - 2400*e^(-(300*t)))^2
             sage: show(plot(a, 0, .002), xmin=0, xmax=.002)
         It is easy to approximate with ``find_root``::
             sage: a.find_root(0,0.002)
 .0004110514049349...
         Using solve takes more effort, and even then gives
+        Using solve takes more effort, and even then gives
         only a solution with free (integer) variables::
             sage: a.solve(t)
 …
             sage: b.solve(t)
             []
             sage: b.solve(t, to_poly_solve=True)
             [t == 1/450*I*pi*z86 + 1/900*log(3/4*sqrt(41) + 25/4), t == 1/450*I*pi*z84 + 1/900*log(-3/4*sqrt(41) + 25/4)]
+            [t == 1/450*I*pi*z99 + 1/900*log(3/4*sqrt(41) + 25/4), t == 1/450*I*pi*z97 + 1/900*log(-3/4*sqrt(41) + 25/4)]
             sage: n(1/900*log(-3/4*sqrt(41) + 25/4))
 .000411051404934985
         We illustrate that root finding is only implemented in one
         dimension::
             sage: x, y = var('x,y')
             sage: (x-y).find_root(-2,2)
             Traceback (most recent call last):
             ...
             NotImplementedError: root finding currently only implemented in 1 dimension.
         TESTS:
+        TESTS:
         Test the special case that failed for the first attempt to fix
         #3980::
             sage: t = var('t')
             sage: find_root(1/t - x,0,2)
             Traceback (most recent call last):
 …
         if self.number_of_arguments() == 0:
             if bool(self == 0):
                 return a
             else:
+            else:
                 raise RuntimeError, "no zero in the interval, since constant expression is not 0."
         elif self.number_of_arguments() == 1:
             f = self._fast_float_(self.default_variable())
 …
         Numerically find the maximum of the expression ``self``
         on the interval [a,b] (or [b,a]) along with the point at which the
         maximum is attained.
         See the documentation for
         ``self.find_minimum_on_interval`` for more details.
         EXAMPLES::
+        EXAMPLES::
             sage: f = x*cos(x)
             sage: f.find_maximum_on_interval(0,5)
             (0.5610963381910451, 0.8603335890...)
 …
         minval, x = (-self).find_minimum_on_interval(a, b, var=var, tol=tol,
                                                      maxfun=maxfun)
         return -minval, x
     def find_minimum_on_interval(self, a, b, var=None, tol=1.48e-08, maxfun=500):
         r"""
         Numerically find the minimum of the expression ``self``
         on the interval [a,b] (or [b,a]) and the point at which it attains
         that minimum. Note that ``self`` must be a function of
         (at most) one variable.
         INPUT:
+        INPUT:
         -  ``var`` - variable (default: first variable in
            self)
         -  ``a,b`` - endpoints of interval on which to minimize
            self.
         -  ``tol`` - the convergence tolerance
         -  ``maxfun`` - maximum function evaluations
         OUTPUT:
+        OUTPUT:
         - ``minval`` - (float) the minimum value that self takes on in the
           interval [a,b]
         - ``x`` - (float) the point at which self takes on the minimum value
         EXAMPLES::
+        EXAMPLES::
             sage: f = x*cos(x)
             sage: f.find_minimum_on_interval(1, 5)
             (-3.288371395590..., 3.4256184695...)
 …
             sage: show(f.plot(0, 20))
             sage: f.find_minimum_on_interval(1, 15)
             (-9.477294259479..., 9.5293344109...)
         ALGORITHM:
         Uses ``scipy.optimize.fminbound`` which uses Brent's method.
         AUTHORS:
         - William Stein (2007-12-07)
 …
         """
         Returns an object which provides fast floating point
         evaluation of this symbolic expression.
         See :mod:`sage.ext.fast_eval` for more information.
         EXAMPLES::
 …
         """
         from sage.symbolic.expression_conversions import fast_callable
         return fast_callable(self, etb)
     def show(self):
         """
         Show this symbolic expression, i.e., typeset it nicely.
         EXAMPLES::
+        EXAMPLES::
             sage: (x^2 + 1).show()
             x^{2}  + 1
         """
 …
     def plot(self, *args, **kwds):
         """
         Plot a symbolic expression. All arguments are passed onto the standard plot command.
         EXAMPLES:
         This displays a straight line::
             sage: sin(2).plot((x,0,3))
         This draws a red oscillatory curve::
             sage: sin(x^2).plot((x,0,2*pi), rgbcolor=(1,0,0))
         Another plot using the variable theta::
             sage: var('theta')
             theta
             sage: (cos(theta) - erf(theta)).plot((theta,-2*pi,2*pi))
         A very thick green plot with a frame::
             sage: sin(x).plot((x,-4*pi, 4*pi), thickness=20, rgbcolor=(0,0.7,0)).show(frame=True)
         You can embed 2d plots in 3d space as follows::
             sage: plot(sin(x^2), (x,-pi, pi), thickness=2).plot3d(z = 1)
         A more complicated family::
             sage: G = sum([plot(sin(n*x), (x,-2*pi, 2*pi)).plot3d(z=n) for n in [0,0.1,..1]])
             sage: G.show(frame_aspect_ratio=[1,1,1/2])
         A plot involving the floor function::
             sage: plot(1.0 - x * floor(1/x), (x,0.00001,1.0))
         Sage used to allow symbolic functions with "no arguments";
         this no longer works::
             sage: plot(2*sin, -4, 4)
             Traceback (most recent call last):
             ...
             TypeError: unsupported operand parent(s) for '*': 'Integer Ring' and '<class 'sage.functions.trig.Function_sin'>'
         You should evaluate the function first::
             sage: plot(2*sin(x), -4, 4)
         TESTS::
+        TESTS::
             sage: f(x) = x*(1 - x)
             sage: plot(f,0,1)
         """
 …
             # of an interface so we just use the fast_callable function.
             return fast_callable(self, vars=vars)
     ############
+    ############
     # Calculus #
     ############
     def sum(self, *args, **kwds):
 …
         return nintegral(self, *args, **kwds)
     nintegrate = nintegral
     def minpoly(self, *args, **kwds):
         """
         Return the minimal polynomial of this symbolic expression.
         EXAMPLES::
             sage: golden_ratio.minpoly()
 …
            is included for backward compatibility reasons only.
         EXAMPLES::
             sage: var('x,y'); f = x + 3 < y - 2
             (x, y)
             sage: f.multiply_both_sides(7)
 …
         Since the direction of the inequality never changes when doing
         arithmetic with equations, you can multiply or divide the
         equation by a quantity with unknown sign::
             sage: f*(1+I)
             (I + 1)*x + 3*I + 3 < (I + 1)*y - 2*I - 2
             sage: f = sqrt(2) + x == y^3
 …
             I*x + I*sqrt(2) == I*y^3
             sage: f.multiply_both_sides(-1)
             -x - sqrt(2) == -y^3
         Note that the direction of the following inequalities is
         not reversed::
             sage: (x^3 + 1 > 2*sqrt(3)) * (-1)
             -x^3 - 1 > -2*sqrt(3)
             sage: (x^3 + 1 >= 2*sqrt(3)) * (-1)
             -x^3 - 1 >= -2*sqrt(3)
             sage: (x^3 + 1 <= 2*sqrt(3)) * (-1)
             -x^3 - 1 <= -2*sqrt(3)
+            -x^3 - 1 <= -2*sqrt(3)
         """
         if not is_a_relational(self._gobj):
             raise TypeError, "this expression must be a relation"
         return self * x
     def divide_both_sides(self, x, checksign=None):
         """
         Returns a relation obtained by dividing both sides of this
 …
             sage: eqn.divide_both_sides(theta)
             (x^3 + theta)/theta < sin(theta*x)/theta
             sage: eqn/theta
             (x^3 + theta)/theta < sin(theta*x)/theta
+            (x^3 + theta)/theta < sin(theta*x)/theta
         """
         if not is_a_relational(self._gobj):
             raise TypeError, "this expression must be a relation"
 …
     # implemented using a lot from cln, and I had to mostly delete
     # their implementations.   They are pretty specialized for
     # physics apps, maybe.
     # This doesn't work / isn't implemented yet / just segfaults.
+    # This doesn't work / isn't implemented yet / just segfaults.
     #def Li(self, x):
     #    """
     #    """
 …
         Return this iterator object itself.
         EXAMPLES::
             sage: x,y,z = var('x,y,z')
             sage: i = (x+y).iterator()
             sage: iter(i) is i
 …
         Return the next component of the expression.
         EXAMPLES::
             sage: x,y,z = var('x,y,z')
             sage: i = (x+y).iterator()
             sage: i.next()
 …
     Construct a new iterator over a symbolic expression.
     EXAMPLES::
         sage: x,y,z = var('x,y,z')
         sage: i = (x+y).iterator() #indirect doctest
     """
 …
     elif lop == not_equal or rop == not_equal:
         raise TypeError, "incompatible relations"
     elif lop == equal:
        return rop
+        return rop
     elif rop == equal:
        return lop
+        return lop
     elif lop in [less, less_or_equal] and rop in [less, less_or_equal]:
        return less
+        return less
     elif lop in [greater, greater_or_equal] and rop in [greater, greater_or_equal]:
        return greater
+        return greater
     else:
         raise TypeError, "incompatible relations"

Download in other formats:

Original Format