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 b  
    154154def is_SymbolicEquation(x):
    155155    """
    156156    Returns True if *x* is a symbolic equation.
    157    
     157
    158158    EXAMPLES:
    159159
    160160    The following two examples are symbolic equations::
    161    
     161
    162162        sage: from sage.symbolic.expression import is_SymbolicEquation
    163163        sage: is_SymbolicEquation(sin(x) == x)
    164164        True
     
    166166        True
    167167        sage: is_SymbolicEquation(x)
    168168        False
    169    
     169
    170170    This is not, since ``2==3`` evaluates to the boolean
    171171    ``False``::
    172    
     172
    173173        sage: is_SymbolicEquation(2 == 3)
    174174        False
    175    
     175
    176176    However here since both 2 and 3 are coerced to be symbolic, we
    177177    obtain a symbolic equation::
    178    
     178
    179179        sage: is_SymbolicEquation(SR(2) == SR(3))
    180180        True
    181181
     
    190190        value.   Otherwise, a TypeError is raised.
    191191
    192192        EXAMPLES::
    193        
     193
    194194            sage: var('x')
    195195            x
    196196            sage: b = -17/3
     
    210210
    211211    def __init__(self, SR, x=0):
    212212        """
    213         Nearly all expressions are created by calling new_Expression_from_*, 
    214         but we need to make sure this at least doesn't leave self._gobj 
     213        Nearly all expressions are created by calling new_Expression_from_*,
     214        but we need to make sure this at least doesn't leave self._gobj
    215215        uninitialized and segfault.
    216216
    217217        TESTS::
     
    250250        __setstate__().
    251251
    252252        In order to pickle Expression objects, we return a tuple containing
    253        
     253
    254254         * 0  - as pickle version number
    255255                in case we decide to change the pickle format in the feature
    256256         * names of symbols of this expression
     
    266266            (0,
    267267             ['x', 'y', 'z'],
    268268             ...)
    269        
     269
    270270        """
    271271        cdef GArchive ar
    272272        ar.archive_ex(self._gobj, "sage_ex")
     
    318318    def _repr_(self, simplify=None):
    319319        """
    320320        Return string representation of this symbolic expression.
    321        
    322         EXAMPLES::
    323        
     321
     322        EXAMPLES::
     323
    324324            sage: var("x y")
    325325            (x, y)
    326326            sage: repr(x+y)
    327327            'x + y'
    328328
    329329        TESTS::
    330        
     330
    331331            # printing of modular number equal to -1 as coefficient
    332332            sage: k.<a> = GF(9); k(2)*x
    333333            2*x
     
    356356            -I
    357357            sage: y + 3*(x^(-1))
    358358            y + 3/x
    359            
     359
    360360        Printing the exp function::
    361        
     361
    362362            sage: x.parent(1).exp()
    363363            e
    364364            sage: x.exp()
     
    386386            (n + A/B)^(n + 1)
    387387
    388388        Powers where the base or exponent is a Python object::
    389        
     389
    390390            sage: (2/3)^x
    391391            (2/3)^x
    392392            sage: x^CDF(1,2)
     
    414414
    415415            sage: f = sin(e + 2)
    416416            sage: f._interface_(sage.calculus.calculus.maxima)
    417             sin(%e+2)           
     417            sin(%e+2)
    418418        """
    419419        if is_a_constant(self._gobj):
    420420            return self.pyobject()._interface_(I)
     
    455455            sage: f = pi + I*e
    456456            sage: f._pari_init_()
    457457            '(Pi)+((exp(1))*(I))'
    458         """       
     458        """
    459459        from sage.symbolic.expression_conversions import InterfaceInit
    460460        return InterfaceInit(I)(self)
    461        
     461
    462462    def _gap_init_(self):
    463463        """
    464464        Conversion of symbolic object to GAP always results in a GAP
    465465        string.
    466        
    467         EXAMPLES::
    468        
     466
     467        EXAMPLES::
     468
    469469            sage: gap(e + pi^2 + x^3)
    470470            pi^2 + x^3 + e
    471471        """
     
    475475        """
    476476        Conversion of a symbolic object to Singular always results in a
    477477        Singular string.
    478        
    479         EXAMPLES::
    480        
     478
     479        EXAMPLES::
     480
    481481            sage: singular(e + pi^2 + x^3)
    482482            pi^2 + x^3 + e
    483483        """
     
    486486    def _magma_init_(self, magma):
    487487        """
    488488        Return string representation in Magma of this symbolic expression.
    489        
     489
    490490        Since Magma has no notation of symbolic calculus, this simply
    491491        returns something that evaluates in Magma to a a Magma string.
    492        
    493         EXAMPLES::
    494        
    495             sage: x = var('x')                     
     492
     493        EXAMPLES::
     494
     495            sage: x = var('x')
    496496            sage: f = sin(cos(x^2) + log(x))
    497497            sage: f._magma_init_(magma)
    498498            '"sin(log(x) + cos(x^2))"'
     
    506506    def _latex_(self):
    507507        r"""
    508508        Return string representation of this symbolic expression.
    509        
    510         EXAMPLES:
    511 
    512 
    513         TESTS::
    514        
     509
     510        EXAMPLES:
     511
     512
     513        TESTS::
     514
    515515            sage: var('x,y,z')
    516516            (x, y, z)
    517517            sage: latex(y + 3*(x^(-1)))
     
    549549            {\left(A B\right)}^{n - 1}
    550550
    551551        Powers where the base or exponent is a Python object::
    552        
     552
    553553            sage: latex((2/3)^x)
    554554            \left(\frac{2}{3}\right)^{x}
    555555            sage: latex(x^CDF(1,2))
     
    586586    def _mathml_(self):
    587587        """
    588588        Returns a MathML representation of this object.
    589        
     589
    590590        EXAMPLES::
    591591
    592592            sage: mathml(pi)
     
    601601        except TypeError:
    602602            return mathml(repr(self))
    603603        return mathml(obj)
    604    
     604
    605605    def _integer_(self, ZZ=None):
    606606        """
    607607        EXAMPLES::
    608        
     608
    609609            sage: f = x^3 + 17*x -3
    610610            sage: ZZ(f.coeff(x^3))
    611611            1
     
    617617            <type 'sage.rings.integer.Integer'>
    618618
    619619        Coercion is done if necessary::
    620        
     620
    621621            sage: f = x^3 + 17/1*x
    622622            sage: ZZ(f.coeff(x))
    623623            17
     
    626626
    627627        If the symbolic expression is just a wrapper around an integer,
    628628        that very same integer is returned::
    629        
     629
    630630            sage: n = 17; SR(n)._integer_() is n
    631631            True
    632632        """
     
    641641    def __int__(self):
    642642        """
    643643        EXAMPLES::
    644        
     644
    645645            sage: int(sin(2)*100)
    646646            90
    647647            sage: int(log(8)/log(2))
     
    653653    def __long__(self):
    654654        """
    655655        EXAMPLES::
    656        
     656
    657657            sage: long(sin(2)*100)
    658658            90L
    659659        """
     
    662662    def _rational_(self):
    663663        """
    664664        EXAMPLES::
    665        
     665
    666666            sage: f = x^3 + 17/1*x - 3/8
    667667            sage: QQ(f.coeff(x^2))
    668668            0
     
    677677
    678678        If the symbolic expression is just a wrapper around a rational,
    679679        that very same rational is returned::
    680        
     680
    681681            sage: n = 17/1; SR(n)._rational_() is n
    682682            True
    683683        """
     
    719719        only variables, and functions whose arguments contain a variable.
    720720
    721721        EXAMPLES::
    722        
     722
    723723            sage: f = sqrt(2) * cos(3); f
    724724            sqrt(2)*cos(3)
    725725            sage: f._convert(RDF)
     
    740740            log(10)
    741741            sage: t._convert(QQ)
    742742            2.30258509299405
    743            
     743
    744744        ::
    745745
    746746            sage: (0.25 / (log(5.74 /x^0.9, 10))^2 / 4)._convert(QQ)
    747747            0.331368631904900/log(287/50/x^0.900000000000000)^2
    748748            sage: (0.25 / (log(5.74 /x^0.9, 10))^2 / 4)._convert(CC)
    749749            0.331368631904900/log(5.74000000000000/x^0.900000000000000)^2
    750        
     750
    751751        When converting to an exact domain, powers remain unevaluated::
    752752
    753753            sage: f = sqrt(2) * cos(3); f
     
    764764
    765765        The precision of the approximation is determined by the precision of
    766766        the input R.
    767        
     767
    768768        EXAMPLES::
    769769
    770770            0.090909090909090909090909090909090909090909090909090909090909
     
    781781    def _real_mpfi_(self, R):
    782782        """
    783783        Returns this expression as a real interval.
    784        
     784
    785785        EXAMPLES::
    786786
    787787            sage: RIF(sqrt(2))
     
    795795    def _complex_mpfi_(self, R):
    796796        """
    797797        Returns this expression as a complex interval.
    798        
     798
    799799        EXAMPLES::
    800800
    801801            sage: CIF(pi)
     
    822822
    823823        The precision of the approximation is determined by the precision of
    824824        the input R.
    825        
    826         EXAMPLES::
    827 
    828             sage: ComplexField(200)(SR(1/11)) 
     825
     826        EXAMPLES::
     827
     828            sage: ComplexField(200)(SR(1/11))
    829829            0.090909090909090909090909090909090909090909090909090909090909
    830830            sage: zeta(x).subs(x=I)._complex_mpfr_field_(ComplexField(70))
    831831            0.0033002236853241028742 - 0.41815544914132167669*I
     
    856856
    857857        EXAMPLES::
    858858
    859             sage: CDF(SR(1/11)) 
     859            sage: CDF(SR(1/11))
    860860            0.0909090909091
    861861            sage: zeta(x).subs(x=I)._complex_double_(CDF)
    862862            0.00330022368532 - 0.418155449141*I
     
    875875        Otherwise, raise a TypeError.
    876876
    877877        OUTPUT:
    878        
     878
    879879        - float - double precision evaluation of self
    880        
    881         EXAMPLES::
    882        
     880
     881        EXAMPLES::
     882
    883883            sage: float(SR(12))
    884884            12.0
    885885            sage: float(SR(2/3))
     
    905905        EXAMPLES::
    906906
    907907            sage: complex(I)
    908             1j
     908            1j
    909909            sage: complex(erf(3*I))
    910910            Traceback (most recent call last):
    911911            ...
     
    915915            return self._eval_self(complex)
    916916        except TypeError:
    917917            raise TypeError, "unable to simplify to complex approximation"
    918    
     918
    919919    def _sympy_(self):
    920920        """
    921921        Returns a Sympy version of this object.
     
    930930        """
    931931        from sage.symbolic.expression_conversions import sympy
    932932        return sympy(self)
    933        
     933
    934934    def _algebraic_(self, field):
    935935        """
    936936        Convert a symbolic expression to an algebraic number.
    937        
     937
    938938        EXAMPLES::
    939939
    940940            sage: QQbar(sqrt(2) + sqrt(8))
     
    947947            1 + 1*I
    948948            sage: QQbar(e^(pi*I/3))
    949949            0.500000000000000? + 0.866025403784439?*I
    950        
     950
    951951            sage: QQbar(sqrt(2))
    952952            1.414213562373095?
    953953            sage: AA(abs(1+I))
     
    964964        """
    965965        from sage.symbolic.expression_conversions import algebraic
    966966        return algebraic(self, field)
    967    
     967
    968968    def __hash__(self):
    969969        """
    970970        Return hash of this expression.
    971971
    972972        EXAMPLES::
    973        
     973
    974974        The hash of an object in Python or its coerced version into
    975975        the symbolic ring is the same::
    976976
    977             sage: hash(SR(3/1)) 
     977            sage: hash(SR(3/1))
    978978            3
    979979            sage: hash(SR(19/23))
    980980            4
     
    990990            <type 'int'>
    991991            sage: t = hash(x^y); type(t)
    992992            <type 'int'>
    993             sage: type(hash(x+y)) 
     993            sage: type(hash(x+y))
    994994            <type 'int'>
    995995            sage: d = {x+y: 5}
    996996            sage: d
     
    998998
    999999        In this example hashing is important otherwise the answer is
    10001000        wrong::
    1001        
     1001
    10021002            sage: uniq([x-x, -x+x])
    10031003            [0]
    10041004
     
    10521052    def __richcmp__(left, right, int op):
    10531053        """
    10541054        Create a formal symbolic inequality or equality.
    1055        
    1056         EXAMPLES::
    1057        
     1055
     1056        EXAMPLES::
     1057
    10581058            sage: var('x, y')
    10591059            (x, y)
    10601060            sage: x + 2/3 < y^2
     
    10971097        elif op == Py_NE:
    10981098            e = g_ne(l._gobj, r._gobj)
    10991099        elif op == Py_GE:
    1100             e = g_ge(l._gobj, r._gobj)       
     1100            e = g_ge(l._gobj, r._gobj)
    11011101        else:
    11021102            raise TypeError
    11031103        return new_Expression_from_GEx(l._parent, e)
     
    11061106        r"""
    11071107        Assume that this equation holds. This is relevant for symbolic
    11081108        integration, among other things.
    1109        
     1109
    11101110        EXAMPLES: We call the assume method to assume that `x>2`::
    1111        
     1111
    11121112            sage: (x > 2).assume()
    1113        
     1113
    11141114        Bool returns True below if the inequality is *definitely* known to
    11151115        be True.
    1116        
    1117         ::
    1118        
     1116
     1117        ::
     1118
    11191119            sage: bool(x > 0)
    11201120            True
    11211121            sage: bool(x < 0)
    11221122            False
    1123        
     1123
    11241124        This may or may not be True, so bool returns False::
    1125        
     1125
    11261126            sage: bool(x > 3)
    11271127            False
    1128        
     1128
    11291129        If you make inconsistent or meaningless assumptions,
    11301130        Sage will let you know::
    11311131
     
    11401140            sage: forget()
    11411141
    11421142        TESTS::
    1143        
     1143
    11441144            sage: v,c = var('v,c')
    11451145            sage: assume(c != 0)
    11461146            sage: integral((1+v^2/c^2)^3/(1-v^2/c^2)^(3/2),v)
     
    11611161    def forget(self):
    11621162        """
    11631163        Forget the given constraint.
    1164        
    1165         EXAMPLES::
    1166        
     1164
     1165        EXAMPLES::
     1166
    11671167            sage: var('x,y')
    11681168            (x, y)
    11691169            sage: forget()
     
    11891189        """
    11901190        Return string that when evaluated in Maxima defines the assumption
    11911191        determined by this expression.
    1192        
     1192
    11931193        EXAMPLES::
    11941194
    11951195            sage: f = x+2 > sqrt(3)
     
    14001400        Return True if self is a relational expression.
    14011401
    14021402        EXAMPLES::
    1403        
     1403
    14041404            sage: x = var('x')
    14051405            sage: eqn = (x-1)^2 == x^2 - 2*x + 3
    14061406            sage: eqn.is_relational()
     
    14161416        of the relation.  Otherwise, raise a ValueError.
    14171417
    14181418        EXAMPLES::
    1419        
     1419
    14201420            sage: x = var('x')
    14211421            sage: eqn = (x-1)^2 == x^2 - 2*x + 3
    14221422            sage: eqn.left_hand_side()
     
    14381438        of the relation.  Otherwise, raise a ValueError.
    14391439
    14401440        EXAMPLES::
    1441        
     1441
    14421442            sage: x = var('x')
    14431443            sage: eqn = (x-1)^2 <= x^2 - 2*x + 3
    14441444            sage: eqn.right_hand_side()
     
    14571457    def __nonzero__(self):
    14581458        """
    14591459        Return True unless this symbolic expression can be shown by Sage
    1460         to be zero.  Note that deciding if an expression is zero is 
     1460        to be zero.  Note that deciding if an expression is zero is
    14611461        undecidable in general.
    14621462
    14631463        EXAMPLES::
    1464        
     1464
    14651465            sage: x = var('x')
    14661466            sage: forget()
    14671467            sage: SR(0).__nonzero__()
     
    14791479            sage: pol = 1/(k-1) - 1/k - 1/k/(k-1)
    14801480            sage: pol.is_zero()
    14811481            True
    1482        
     1482
    14831483            sage: f = sin(x)^2 + cos(x)^2 - 1
    14841484            sage: f.is_zero()
    14851485            True
     
    14881488
    14891489        First, a bunch of tests of nonzero (which is called by bool)
    14901490        for symbolic relations::
    1491        
     1491
    14921492            sage: x = var('x')
    14931493            sage: bool((x-1)^2 == x^2 - 2*x + 1)
    14941494            True
     
    15221522            True
    15231523
    15241524        Next, tests to ensure assumptions are correctly used::
    1525        
     1525
    15261526            sage: x, y, z = var('x, y, z')
    15271527            sage: assume(x>=y,y>=z,z>=x)
    15281528            sage: bool(x==z)
     
    15491549            False
    15501550            sage: bool(x != 0)
    15511551            True
    1552             sage: bool(x == 1) 
     1552            sage: bool(x == 1)
    15531553            False
    15541554
    15551555        The following must be true, even though we don't
    15561556        know for sure that x isn't 1, as symbolic comparisons
    1557         elsewhere rely on x!=y unless we are sure it is not 
     1557        elsewhere rely on x!=y unless we are sure it is not
    15581558        true; there is no equivalent of Maxima's ``unknown``.
    15591559        Since it is False that x==1, it is True that x != 1.
    15601560
    15611561        ::
    15621562
    1563             sage: bool(x != 1) 
     1563            sage: bool(x != 1)
    15641564            True
    15651565            sage: forget()
    15661566            sage: assume(x>y)
     
    15831583            if res:
    15841584                if self.operator() == operator.ne: # this hack is necessary to catch the case where the operator is != but is False because of assumptions made
    15851585                    m = self._maxima_()
    1586                     s = m.parent()._eval_line('is (notequal(%s,%s))'%(repr(m.lhs()),repr(m.rhs()))) 
     1586                    s = m.parent()._eval_line('is (notequal(%s,%s))'%(repr(m.lhs()),repr(m.rhs())))
    15871587                    if s == 'false':
    15881588                        return False
    15891589                    else:
     
    16241624            # lot of basic Sage objects can't be put into maxima.
    16251625            from sage.symbolic.relation import test_relation_maxima
    16261626            return test_relation_maxima(self)
    1627                            
     1627
    16281628        self_is_zero = self._gobj.is_zero()
    16291629        if self_is_zero:
    16301630            return False
     
    16351635        """
    16361636        Test this relation at several random values, attempting to find
    16371637        a contradiction. If this relation has no variables, it will also
    1638         test this relation after casting into the domain. 
    1639 
    1640         Because the interval fields never return false positives, we can be 
    1641         assured that if True or False is returned (and proof is False) then 
    1642         the answer is correct. 
     1638        test this relation after casting into the domain.
     1639
     1640        Because the interval fields never return false positives, we can be
     1641        assured that if True or False is returned (and proof is False) then
     1642        the answer is correct.
    16431643
    16441644        INPUT::
    1645        
     1645
    16461646           ntests -- (default 20) the number of iterations to run
    16471647           domain -- (optional) the domain from which to draw the random values
    1648                      defaults to CIF for equality testing and RIF for 
     1648                     defaults to CIF for equality testing and RIF for
    16491649                     order testing
    1650            proof --  (default True) if False and the domain is an interval field, 
     1650           proof --  (default True) if False and the domain is an interval field,
    16511651                     regard overlapping (potentially equal) intervals as equal,
    1652                      and return True if all tests succeeded. 
     1652                     and return True if all tests succeeded.
    16531653
    16541654        OUTPUT::
    16551655
     
    16581658            NotImplemented - no contradiction found
    16591659
    16601660        EXAMPLES::
    1661        
     1661
    16621662            sage: (3 < pi).test_relation()
    16631663            True
    16641664            sage: (0 >= pi).test_relation()
     
    16771677            (x, y)
    16781678            sage: (x < y).test_relation()
    16791679            False
    1680            
     1680
    16811681        TESTS::
    16821682
    16831683            sage: all_relations = [op for name, op in sorted(operator.__dict__.items()) if len(name) == 2]
    1684             sage: all_relations 
     1684            sage: all_relations
    16851685            [<built-in function eq>, <built-in function ge>, <built-in function gt>, <built-in function le>, <built-in function lt>, <built-in function ne>]
    16861686            sage: [op(3, pi).test_relation() for op in all_relations]
    16871687            [False, False, False, True, True, True]
     
    17761776        # Nothing failed, so it *may* be True, but this method doesn't wasn't
    17771777        # able to find anything.
    17781778        return NotImplemented
    1779    
     1779
    17801780    def negation(self):
    17811781        """
    1782         Returns the negated version of self, that is the relation that is 
     1782        Returns the negated version of self, that is the relation that is
    17831783        False iff self is True.
    1784        
     1784
    17851785        EXAMPLES::
    17861786
    17871787            sage: (x < 5).negation()
     
    18071807        elif op == greater_or_equal:
    18081808            falsify = operator.lt
    18091809        return falsify(self.lhs(), self.rhs())
    1810    
     1810
    18111811    def contradicts(self, soln):
    18121812        """
    18131813        Returns ``True`` if this relation is violated by the given variable assignment(s).
    1814        
    1815         EXAMPLES::
    1816        
     1814
     1815        EXAMPLES::
     1816
    18171817            sage: (x<3).contradicts(x==0)
    18181818            False
    18191819            sage: (x<3).contradicts(x==3)
     
    18331833        Return True if this expression is a unit of the symbolic ring.
    18341834
    18351835        EXAMPLES::
    1836        
     1836
    18371837            sage: SR(1).is_unit()
    18381838            True
    18391839            sage: SR(-1).is_unit()
     
    18631863        Add left and right.
    18641864
    18651865        EXAMPLES::
    1866        
     1866
    18671867            sage: var("x y")
    18681868            (x, y)
    18691869            sage: x + y + y + x
     
    18771877            2*x + y > 2*x
    18781878
    18791879        TESTS::
    1880        
     1880
    18811881            sage: x + ( (x+y) > x )
    18821882            2*x + y > 2*x
    18831883
     
    19601960    cpdef ModuleElement _sub_(left, ModuleElement right):
    19611961        """
    19621962        EXAMPLES::
    1963        
     1963
    19641964            sage: var("x y")
    19651965            (x, y)
    19661966            sage: x - y
     
    19741974            y > 0
    19751975
    19761976        TESTS::
    1977        
     1977
    19781978            sage: x - ( (x+y) > x )
    19791979            -y > 0
    19801980
     
    20122012    cpdef RingElement _mul_(left, RingElement right):
    20132013        """
    20142014        Multiply left and right.
    2015        
    2016         EXAMPLES::
    2017        
     2015
     2016        EXAMPLES::
     2017
    20182018            sage: var("x y")
    20192019            (x, y)
    20202020            sage: x*y*y
     
    20312031            -x - y > -x
    20322032
    20332033        TESTS::
    2034        
     2034
    20352035            sage: x * ( (x+y) > x )
    20362036            (x + y)*x > x^2
    20372037
     
    21362136        Divide left and right.
    21372137
    21382138        EXAMPLES::
    2139        
     2139
    21402140            sage: var("x y")
    21412141            (x, y)
    21422142            sage: x/y/y
     
    21532153            -x - y > -x
    21542154
    21552155        TESTS::
    2156        
     2156
    21572157            sage: x / ( (x+y) > x )
    21582158            x/(x + y) > 1
    21592159
     
    22622262        this function won't be called.
    22632263
    22642264        EXAMPLES::
    2265        
     2265
    22662266            sage: x,y = var('x,y')
    22672267            sage: x.__cmp__(y)
    22682268            -1
     
    23102310            x^(sin(x)^cos(y))
    23112311
    23122312        TESTS::
    2313        
     2313
    23142314            sage: (Mod(2,7)*x^2 + Mod(2,7))^7
    23152315            (2*x^2 + 2)^7
    23162316            sage: k = GF(7)
     
    23312331            Infinity
    23322332
    23332333        Test powers of exp::
    2334            
     2334
    23352335            sage: exp(2)^5
    23362336            e^10
    23372337            sage: exp(x)^5
     
    23472347            (1+3j)^sqrt(2)
    23482348        """
    23492349        cdef Expression base, nexp
    2350        
     2350
    23512351        try:
    23522352            # self is an Expression and exp might not be
    23532353            base = self
     
    23792379            :meth:`_derivative`
    23802380
    23812381        EXAMPLES::
    2382        
     2382
    23832383            sage: var("x y")
    23842384            (x, y)
    23852385            sage: t = (x^2+y)^2
     
    24012401            (tan(x*y)^2 + 1)*x*sin(y^2 + x) + 2*y*cos(y^2 + x)*tan(x*y)
    24022402
    24032403        ::
    2404        
     2404
    24052405            sage: h = sin(x)/cos(x)
    24062406            sage: derivative(h,x,x,x)
    24072407            6*sin(x)^4/cos(x)^4 + 8*sin(x)^2/cos(x)^2 + 2
     
    24092409            6*sin(x)^4/cos(x)^4 + 8*sin(x)^2/cos(x)^2 + 2
    24102410
    24112411        ::
    2412        
     2412
    24132413            sage: var('x, y')
    24142414            (x, y)
    24152415            sage: u = (sin(x) + cos(y))*(cos(x) - sin(y))
    24162416            sage: derivative(u,x,y)
    2417             sin(x)*sin(y) - cos(x)*cos(y)           
     2417            sin(x)*sin(y) - cos(x)*cos(y)
    24182418            sage: f = ((x^2+1)/(x^2-1))^(1/4)
    24192419            sage: g = derivative(f, x); g # this is a complex expression
    24202420            1/2*(x/(x^2 - 1) - (x^2 + 1)*x/(x^2 - 1)^2)/((x^2 + 1)/(x^2 - 1))^(3/4)
     
    24272427            sage: f = y^(sin(x))
    24282428            sage: derivative(f, x)
    24292429            y^sin(x)*log(y)*cos(x)
    2430        
    2431         ::
    2432        
     2430
     2431        ::
     2432
    24332433            sage: g(x) = sqrt(5-2*x)
    24342434            sage: g_3 = derivative(g, x, 3); g_3(2)
    24352435            -3
    2436        
    2437         ::
    2438        
     2436
     2437        ::
     2438
    24392439            sage: f = x*e^(-x)
    24402440            sage: derivative(f, 100)
    24412441            x*e^(-x) - 100*e^(-x)
    2442        
    2443         ::
    2444        
     2442
     2443        ::
     2444
    24452445            sage: g = 1/(sqrt((x^2-1)*(x+5)^6))
    24462446            sage: derivative(g, x)
    24472447            -((x + 5)^6*x + 3*(x + 5)^5*(x^2 - 1))/((x + 5)^6*(x^2 - 1))^(3/2)
    24482448
    24492449        TESTS::
    2450        
     2450
    24512451            sage: t.derivative()
    24522452            Traceback (most recent call last):
    24532453            ...
     
    24602460    def _derivative(self, symb=None, deg=1):
    24612461        """
    24622462        Return the deg-th (partial) derivative of self with respect to symb.
    2463        
    2464         EXAMPLES::
    2465        
     2463
     2464        EXAMPLES::
     2465
    24662466            sage: var("x y")
    24672467            (x, y)
    24682468            sage: b = (x+y)^5
     
    24802480
    24812481        Raise error if no variable is specified and there are multiple
    24822482        variables::
    2483        
     2483
    24842484            sage: b._derivative()
    24852485            Traceback (most recent call last):
    24862486            ...
     
    25212521    def gradient(self, variables=None):
    25222522        r"""
    25232523        Compute the gradient of a symbolic function.
    2524        
     2524
    25252525        This function returns a vector whose components are the derivatives
    25262526        of the original function with respect to the arguments of the
    25272527        original function. Alternatively, you can specify the variables as
    25282528        a list.
    2529        
    2530         EXAMPLES::
    2531        
     2529
     2530        EXAMPLES::
     2531
    25322532            sage: x,y = var('x y')
    25332533            sage: f = x^2+y^2
    25342534            sage: f.gradient()
     
    25472547        if variables is None:
    25482548            variables = self.arguments()
    25492549        return vector([self.derivative(x) for x in variables])
    2550    
     2550
    25512551    def hessian(self):
    25522552        r"""
    25532553        Compute the hessian of a function. This returns a matrix components
    25542554        are the 2nd partial derivatives of the original function.
    2555        
    2556         EXAMPLES::
    2557        
     2555
     2556        EXAMPLES::
     2557
    25582558            sage: x,y = var('x y')
    25592559            sage: f = x^2+y^2
    25602560            sage: f.hessian()
     
    25862586        - a power series
    25872587
    25882588        To truncate the power series and obtain a normal expression, use the
    2589         truncate command. 
    2590        
    2591         EXAMPLES:
    2592        
     2589        truncate command.
     2590
     2591        EXAMPLES:
     2592
    25932593        We expand a polynomial in `x` about 0, about `1`, and also truncate
    25942594        it back to a polynomial::
    2595        
     2595
    25962596            sage: var('x,y')
    25972597            (x, y)
    25982598            sage: f = (x^3 - sin(y)*x^2 - 5*x + 3); f
     
    26092609            x^3 - x^2*sin(y) - 5*x + 3
    26102610
    26112611        We computer another series expansion of an analytic function::
    2612        
     2612
    26132613            sage: f = sin(x)/x^2
    26142614            sage: f.series(x,7)
    26152615            1*x^(-1) + (-1/6)*x + 1/120*x^3 + (-1/5040)*x^5 + Order(x^7)
     
    26242624        the fractions 1/5 and 1/239.
    26252625
    26262626        ::
    2627        
     2627
    26282628            sage: x = var('x')
    26292629            sage: f = atan(x).series(x, 10); f
    26302630            1*x + (-1/3)*x^3 + 1/5*x^5 + (-1/7)*x^7 + 1/9*x^9 + Order(x^10)
     
    26412641        r"""
    26422642        Expands this symbolic expression in a truncated Taylor or
    26432643        Laurent series in the variable `v` around the point `a`,
    2644         containing terms through `(x - a)^n`. Functions in more 
     2644        containing terms through `(x - a)^n`. Functions in more
    26452645        variables is also supported.
    2646        
    2647         INPUT:
    2648        
    2649         -  ``*args`` - the following notation is supported 
    2650            
     2646
     2647        INPUT:
     2648
     2649        -  ``*args`` - the following notation is supported
     2650
    26512651           - ``x, a, n`` - variable, point, degree
    2652        
     2652
    26532653           - ``(x, a), (y, b), n`` - variables with points, degree of polynomial
    2654        
    2655         EXAMPLES::
    2656        
     2654
     2655        EXAMPLES::
     2656
    26572657            sage: var('a, x, z')
    26582658            (a, x, z)
    26592659            sage: taylor(a*log(z), z, 2, 3)
    26602660            1/24*(z - 2)^3*a - 1/8*(z - 2)^2*a + 1/2*(z - 2)*a + a*log(2)
    26612661
    2662         ::
     2662        ::
    26632663
    26642664            sage: taylor(sqrt (sin(x) + a*x + 1), x, 0, 3)
    26652665            1/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
    26662666
    2667         ::
     2667        ::
    26682668
    26692669            sage: taylor (sqrt (x + 1), x, 0, 5)
    26702670            7/256*x^5 - 5/128*x^4 + 1/16*x^3 - 1/8*x^2 + 1/2*x + 1
    26712671
    2672         ::
     2672        ::
    26732673
    26742674            sage: taylor (1/log (x + 1), x, 0, 3)
    26752675            -19/720*x^3 + 1/24*x^2 - 1/12*x + 1/x + 1/2
    26762676
    2677         ::
     2677        ::
    26782678
    26792679            sage: taylor (cos(x) - sec(x), x, 0, 5)
    26802680            -1/6*x^4 - x^2
    26812681
    2682         ::
     2682        ::
    26832683
    26842684            sage: taylor ((cos(x) - sec(x))^3, x, 0, 9)
    26852685            -1/2*x^8 - x^6
    26862686
    2687         ::
     2687        ::
    26882688
    26892689            sage: taylor (1/(cos(x) - sec(x))^3, x, 0, 5)
    26902690            -15377/7983360*x^4 - 6767/604800*x^2 + 11/120/x^2 + 1/2/x^4 - 1/x^6 - 347/15120
    26912691
    2692  
     2692
    26932693        Ticket #7472 fixed (Taylor polynomial in more variables) ::
    2694  
    2695             sage: x,y=var('x y'); taylor(x*y^3,(x,1),(y,1),4) 
     2694
     2695            sage: x,y=var('x y'); taylor(x*y^3,(x,1),(y,1),4)
    26962696            (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
    2697             sage: expand(_) 
    2698             x*y^3 
     2697            sage: expand(_)
     2698            x*y^3
    26992699
    27002700        """
    27012701        from sage.all import SR, Integer
     
    27292729        - expression
    27302730
    27312731        EXAMPLES::
    2732        
     2732
    27332733            sage: f = sin(x)/x^2
    27342734            sage: f.truncate()
    27352735            sin(x)/x^2
     
    27502750        sums are multiplied out, numerators of rational expressions which
    27512751        are sums are split into their respective terms, and multiplications
    27522752        are distributed over addition at all levels.
    2753        
     2753
    27542754        EXAMPLES:
    27552755
    27562756        We expand the expression `(x-y)^5` using both
    27572757        method and functional notation.
    2758        
    2759         ::
    2760        
     2758
     2759        ::
     2760
    27612761            sage: x,y = var('x,y')
    27622762            sage: a = (x-y)^5
    27632763            sage: a.expand()
    27642764            x^5 - 5*x^4*y + 10*x^3*y^2 - 10*x^2*y^3 + 5*x*y^4 - y^5
    27652765            sage: expand(a)
    27662766            x^5 - 5*x^4*y + 10*x^3*y^2 - 10*x^2*y^3 + 5*x*y^4 - y^5
    2767            
     2767
    27682768        We expand some other expressions::
    2769        
     2769
    27702770            sage: expand((x-1)^3/(y-1))
    27712771            x^3/(y - 1) - 3*x^2/(y - 1) + 3*x/(y - 1) - 1/(y - 1)
    27722772            sage: expand((x+sin((x+y)^2))^2)
     
    27832783            (16*x - 13)^2 == 9/2*x^2 + 15*x + 25/2
    27842784
    27852785        TESTS:
    2786        
     2786
    27872787            sage: var('x,y')
    27882788            (x, y)
    27892789            sage: ((x + (2/3)*y)^3).expand()
     
    28042804                return self.operator()(self.lhs(), self.rhs().expand())
    28052805            else:
    28062806                raise ValueError, "side must be 'left', 'right', or None"
    2807            
     2807
    28082808        _sig_on
    28092809        cdef GEx x = self._gobj.expand(0)
    28102810        _sig_off
     
    28172817        Expands trigonometric and hyperbolic functions of sums of angles
    28182818        and of multiple angles occurring in self. For best results, self
    28192819        should already be expanded.
    2820        
    2821         INPUT:
    2822        
     2820
     2821        INPUT:
     2822
    28232823        -  ``full`` - (default: False) To enhance user control
    28242824           of simplification, this function expands only one level at a time
    28252825           by default, expanding sums of angles or multiple angles. To obtain
    28262826           full expansion into sines and cosines immediately, set the optional
    28272827           parameter full to True.
    2828        
     2828
    28292829        -  ``half_angles`` - (default: False) If True, causes
    28302830           half-angles to be simplified away.
    2831        
     2831
    28322832        -  ``plus`` - (default: True) Controls the sum rule;
    28332833           expansion of sums (e.g. 'sin(x + y)') will take place only if plus
    28342834           is True.
    2835        
     2835
    28362836        -  ``times`` - (default: True) Controls the product
    28372837           rule, expansion of products (e.g. sin(2\*x)) will take place only
    28382838           if times is True.
    2839        
    2840        
     2839
     2840
    28412841        OUTPUT: a symbolic expression
    2842        
    2843         EXAMPLES::
    2844        
     2842
     2843        EXAMPLES::
     2844
    28452845            sage: sin(5*x).expand_trig()
    28462846            sin(x)^5 - 10*sin(x)^3*cos(x)^2 + 5*sin(x)*cos(x)^4
    28472847            sage: cos(2*x + var('y')).expand_trig()
    28482848            -sin(2*x)*sin(y) + cos(2*x)*cos(y)
    2849        
     2849
    28502850        We illustrate various options to this function::
    2851        
     2851
    28522852            sage: f = sin(sin(3*cos(2*x))*x)
    28532853            sage: f.expand_trig()
    28542854            sin(-(sin(cos(2*x))^3 - 3*sin(cos(2*x))*cos(cos(2*x))^2)*x)
     
    28882888        sin's and cos's of x into those of multiples of x. It also
    28892889        tries to eliminate these functions when they occur in
    28902890        denominators.
    2891        
    2892         INPUT: 
    2893 
    2894         - ``self`` - a symbolic expression 
     2891
     2892        INPUT:
     2893
     2894        - ``self`` - a symbolic expression
    28952895
    28962896        - ``var`` - (default: None) the variable which is used for
    28972897          these transformations. If not specified, all variables are
    28982898          used.
    2899        
     2899
    29002900        OUTPUT: a symbolic expression
    2901        
     2901
    29022902        EXAMPLES::
    29032903
    29042904            sage: y=var('y')
     
    29322932        Check if self matches the given pattern.
    29332933
    29342934        INPUT:
    2935        
     2935
    29362936        -  ``pattern`` - a symbolic expression, possibly containing wildcards
    29372937           to match for
    29382938
     
    29462946        See also http://www.ginac.de/tutorial/Pattern-matching-and-advanced-substitutions.html
    29472947
    29482948        EXAMPLES::
    2949        
     2949
    29502950            sage: var('x,y,z,a,b,c,d,e,f')
    29512951            (x, y, z, a, b, c, d, e, f)
    29522952            sage: w0 = SR.wild(0); w1 = SR.wild(1); w2 = SR.wild(2)
     
    30623062    def has(self, pattern):
    30633063        """
    30643064        EXAMPLES::
    3065        
     3065
    30663066            sage: var('x,y,a'); w0 = SR.wild(); w1 = SR.wild()
    30673067            (x, y, a)
    30683068            sage: (x*sin(x + y + 2*a)).has(y)
     
    30703070
    30713071        Here "x+y" is not a subexpression of "x+y+2*a" (which has the
    30723072        subexpressions "x", "y" and "2*a")::
    3073        
     3073
    30743074            sage: (x*sin(x + y + 2*a)).has(x+y)
    30753075            False
    30763076            sage: (x*sin(x + y + 2*a)).has(x + y + w0)
     
    30783078
    30793079        The following fails because "2*(x+y)" automatically gets converted to
    30803080        "2*x+2*y" of which "x+y" is not a subexpression::
    3081        
     3081
    30823082            sage: (x*sin(2*(x+y) + 2*a)).has(x+y)
    30833083            False
    30843084
    3085         Although x^1==x and x^0==1, neither "x" nor "1" are actually of the 
     3085        Although x^1==x and x^0==1, neither "x" nor "1" are actually of the
    30863086        form "x^something"::
    3087        
     3087
    30883088            sage: (x+1).has(x^w0)
    30893089            False
    30903090
     
    30943094        coeff() function instead.
    30953095
    30963096        ::
    3097        
     3097
    30983098            sage: (4*x^2 - x + 3).has(w0*x)
    30993099            True
    31003100            sage: (4*x^2 + x + 3).has(w0*x)
     
    31123112    def substitute(self, in_dict=None, **kwds):
    31133113        """
    31143114        EXAMPLES::
    3115        
     3115
    31163116            sage: var('x,y,z,a,b,c,d,e,f')
    31173117            (x, y, z, a, b, c, d, e, f)
    31183118            sage: w0 = SR.wild(0); w1 = SR.wild(1)
    31193119            sage: t = a^2 + b^2 + (x+y)^3
    3120            
     3120
    31213121            # substitute with keyword arguments (works only with symbols)
    31223122            sage: t.subs(a=c)
    31233123            (x + y)^3 + b^2 + c^2
    3124            
     3124
    31253125            # substitute with a dictionary argument
    31263126            sage: t.subs({a^2: c})
    31273127            (x + y)^3 + b^2 + c
     
    31343134            (x + y)^3 + a^3 + b^3
    31353135
    31363136            sage: t.subs(w0==w0^2)
    3137             (x^2 + y^2)^18 + a^16 + b^16           
     3137            (x^2 + y^2)^18 + a^16 + b^16
    31383138
    31393139            # more than one keyword argument is accepted
    31403140            sage: t.subs(a=b, b=c)
     
    32213221        return new_Expression_from_GEx(self._parent, self._gobj.subs_map(smap))
    32223222
    32233223    subs = substitute
    3224    
     3224
    32253225    cpdef Expression _subs_expr(self, expr):
    32263226        """
    32273227        EXAMPLES::
    3228        
     3228
    32293229            sage: var('x,y,z,a,b,c,d,e,f')
    32303230            (x, y, z, a, b, c, d, e, f)
    32313231            sage: w0 = SR.wild(0); w1 = SR.wild(1)
     
    32733273        of key for value in self.  The substitutions can also be given
    32743274        as a number of symbolic equalities key == value; see the
    32753275        examples.
    3276        
     3276
    32773277        .. warning::
    32783278
    32793279           This is a formal pattern substitution, which may or may not
     
    32813281           present in Sage are determined by Maxima's subst
    32823282           command. Sometimes patterns are not replaced even though
    32833283           one would think they should be - see examples below.
    3284        
    3285         EXAMPLES::
    3286        
     3284
     3285        EXAMPLES::
     3286
    32873287            sage: f = x^2 + 1
    32883288            sage: f.subs_expr(x^2 == x)
    32893289            x + 1
    3290        
    3291         ::
    3292        
     3290
     3291        ::
     3292
    32933293            sage: var('x,y,z'); f = x^3 + y^2 + z
    32943294            (x, y, z)
    32953295            sage: f.subs_expr(x^3 == y^2, z == 1)
    32963296            2*y^2 + 1
    32973297
    32983298        Or the same thing giving the substitutions as a dictionary::
    3299        
     3299
    33003300            sage: f.subs_expr({x^3:y^2, z:1})
    33013301            2*y^2 + 1
    3302        
     3302
    33033303            sage: f = x^2 + x^4
    33043304            sage: f.subs_expr(x^2 == x)
    33053305            x^4 + x
    33063306            sage: f = cos(x^2) + sin(x^2)
    33073307            sage: f.subs_expr(x^2 == x)
    33083308            sin(x) + cos(x)
    3309        
    3310         ::
    3311        
     3309
     3310        ::
     3311
    33123312            sage: f(x,y,t) = cos(x) + sin(y) + x^2 + y^2 + t
    33133313            sage: f.subs_expr(y^2 == t)
    33143314            (x, y, t) |--> x^2 + 2*t + sin(y) + cos(x)
    3315        
     3315
    33163316        The following seems really weird, but it *is* what Maple does::
    3317        
     3317
    33183318            sage: f.subs_expr(x^2 + y^2 == t)
    33193319            (x, y, t) |--> x^2 + y^2 + t + sin(y) + cos(x)
    33203320            sage: maple.eval('subs(x^2 + y^2 = t, cos(x) + sin(y) + x^2 + y^2 + t)')          # optional requires maple
     
    33223322            sage: maxima.quit()
    33233323            sage: maxima.eval('cos(x) + sin(y) + x^2 + y^2 + t, x^2 + y^2 = t')
    33243324            'sin(y)+y^2+cos(x)+x^2+t'
    3325        
     3325
    33263326        Actually Mathematica does something that makes more sense::
    3327        
     3327
    33283328            sage: mathematica.eval('Cos[x] + Sin[y] + x^2 + y^2 + t /. x^2 + y^2 -> t')       # optional -- requires mathematica
    33293329            2 t + Cos[x] + Sin[y]
    33303330        """
     
    33553355        """
    33563356        from sage.symbolic.expression_conversions import SubstituteFunction
    33573357        return SubstituteFunction(self, original, new)()
    3358    
     3358
    33593359    def __call__(self, *args, **kwds):
    33603360        """
    33613361        Calls the :meth:`subs` on this expression.
    33623362
    33633363        EXAMPLES::
    3364        
     3364
    33653365            sage: var('x,y,z')
    33663366            (x, y, z)
    33673367            sage: (x+y)(x=z^2, y=x^y)
     
    33743374        Return sorted tuple of variables that occur in this expression.
    33753375
    33763376        EXAMPLES::
    3377        
     3377
    33783378            sage: (x,y,z) = var('x,y,z')
    33793379            sage: (x+y).variables()
    33803380            (x, y)
     
    33863386            (x, y, z)
    33873387
    33883388        """
    3389         from sage.symbolic.ring import SR       
     3389        from sage.symbolic.ring import SR
    33903390        cdef GExSet sym_set
    33913391        g_list_symbols(self._gobj, sym_set)
    33923392        res = []
     
    34313431            1
    34323432
    34333433        ::
    3434        
     3434
    34353435            sage: x,y,z = var('x,y,z')
    34363436            sage: (x+y).number_of_arguments()
    34373437            2
     
    34433443            3
    34443444            sage: (sin(x+y)).number_of_arguments()
    34453445            2
    3446        
    3447         ::
    3448        
     3446
     3447        ::
     3448
    34493449            sage: ( 2^(8/9) - 2^(1/9) )(x-1)
    34503450            Traceback (most recent call last):
    34513451            ...
     
    34583458        Returns the number of arguments of this expression.
    34593459
    34603460        EXAMPLES::
    3461        
     3461
    34623462            sage: var('a,b,c,x,y')
    34633463            (a, b, c, x, y)
    34643464            sage: a.number_of_operands()
     
    34793479        Returns the number of arguments of this expression.
    34803480
    34813481        EXAMPLES::
    3482        
     3482
    34833483            sage: var('a,b,c,x,y')
    34843484            (a, b, c, x, y)
    34853485            sage: len(a)
     
    34983498        Returns a list containing the operands of this expression.
    34993499
    35003500        EXAMPLES::
    3501        
     3501
    35023502            sage: var('a,b,c,x,y')
    35033503            (a, b, c, x, y)
    35043504            sage: (a^2 + b^2 + (x+y)^2).operands()
     
    35173517        Returns the topmost operator in this expression.
    35183518
    35193519        EXAMPLES::
    3520        
     3520
    35213521            sage: x,y,z = var('x,y,z')
    35223522            sage: (x+y).operator()
    35233523            <built-in function add>
     
    35513551            D[0](f)(x)
    35523552            sage: a.operator()
    35533553            D[0](f)
    3554            
     3554
    35553555        TESTS:
    35563556            sage: (x <= y).operator()
    35573557            <built-in function le>
     
    36143614    def __index__(self):
    36153615        """
    36163616        EXAMPLES::
    3617        
     3617
    36183618            sage: a = range(10)
    36193619            sage: a[:SR(5)]
    36203620            [0, 1, 2, 3, 4]
    36213621        """
    3622         return int(self._integer_())   
     3622        return int(self._integer_())
    36233623
    36243624    def iterator(self):
    36253625        """
    36263626        Return an iterator over the arguments of this expression.
    36273627
    36283628        EXAMPLES::
    3629        
     3629
    36303630            sage: x,y,z = var('x,y,z')
    36313631            sage: list((x+y+z).iterator())
    36323632            [x, y, z]
     
    36403640##     def __getitem__(self, ind):
    36413641##         """
    36423642##         EXAMPLES::
    3643        
     3643
    36443644##             sage: x,y,z = var('x,y,z')
    36453645##             sage: e = x + x*y + z^y + 3*y*z; e
    36463646##             x*y + 3*y*z + z^y + x
     
    37273727        TESTS:
    37283728
    37293729        We test the evaluation of different infinities available in Pynac::
    3730        
     3730
    37313731            sage: t = x - oo; t
    37323732            -Infinity
    37333733            sage: t.n()
     
    37643764            res = x.pyobject()
    37653765        else:
    37663766            raise TypeError, "cannot evaluate symbolic expresssion numerically"
    3767            
     3767
    37683768        # Important -- the  we get might not be a valid output for numerical_approx in
    37693769        # the case when one gets infinity.
    37703770        if isinstance(res, AnInfinity):
     
    37813781        result. This may lead to misleading results.
    37823782
    37833783        EXAMPLES::
    3784            
     3784
    37853785            sage: t = sqrt(Integer('1'*1000)).round(); t
    37863786            33333333333333330562872877837571095953933917311168389275365130348599729268937180234955282892214983624063325870179809380946753270304893256291223685906477377407805362767048122713900447143840625646189582982153140391592656164907437770144711391823061825859553426442610175266854303816282031207413258045024789468633297982051760989540057817134748449866609872506236671598268343900233203388804404405970909678015833968186200327087593697947284709714538428657648875107834928345435181446453242319048564666814955520
    37873787
     
    38013801        EXAMPLES:
    38023802
    38033803        We will use several symbolic variables in the examples below::
    3804        
     3804
    38053805            sage: var('x, y, z, t, a, w, n')
    38063806            (x, y, z, t, a, w, n)
    3807        
    3808         ::
    3809        
     3807
     3808        ::
     3809
    38103810            sage: u = sin(x) + x*cos(y)
    38113811            sage: g = u.function(x,y)
    38123812            sage: g(x,y)
     
    38153815            t*cos(z) + sin(t)
    38163816            sage: g(x^2, x^y)
    38173817            x^2*cos(x^y) + sin(x^2)
    3818        
    3819         ::
    3820        
     3818
     3819        ::
     3820
    38213821            sage: f = (x^2 + sin(a*w)).function(a,x,w); f
    38223822            (a, x, w) |--> x^2 + sin(a*w)
    38233823            sage: f(1,2,3)
    38243824            sin(3) + 4
    3825        
     3825
    38263826        Using the :meth:`function` method we can obtain the above function
    38273827        `f`, but viewed as a function of different variables::
    3828        
     3828
    38293829            sage: h = f.function(w,a); h
    38303830            (w, a) |--> x^2 + sin(a*w)
    3831        
     3831
    38323832        This notation also works::
    3833        
     3833
    38343834            sage: h(w,a) = f
    38353835            sage: h
    38363836            (w, a) |--> x^2 + sin(a*w)
    3837        
     3837
    38383838        You can even make a symbolic expression `f` into a function
    38393839        by writing ``f(x,y) = f``::
    3840        
     3840
    38413841            sage: f = x^n + y^n; f
    38423842            x^n + y^n
    38433843            sage: f(x,y) = f
     
    38653865    def coefficient(self, s, int n=1):
    38663866        """
    38673867        Returns the coefficient of `s^n` in this symbolic expression.
    3868        
     3868
    38693869        INPUT:
    38703870
    38713871        - ``s`` - expression
     
    38803880        is not done automatically.
    38813881
    38823882        EXAMPLES::
    3883        
     3883
    38843884            sage: var('x,y,a')
    38853885            (x, y, a)
    38863886            sage: f = 100 + a*x + x^3*sin(x*y) + x*y + x/y + 2*sin(x*y)/x; f
     
    39063906
    39073907            sage: var('a, x, y, z')
    39083908            (a, x, y, z)
    3909             sage: f = (a*sqrt(2))*x^2 + sin(y)*x^(1/2) + z^z   
     3909            sage: f = (a*sqrt(2))*x^2 + sin(y)*x^(1/2) + z^z
    39103910            sage: f.coefficient(sin(y))
    3911             sqrt(x)       
     3911            sqrt(x)
    39123912            sage: f.coefficient(x^2)
    39133913            sqrt(2)*a
    39143914            sage: f.coefficient(x^(1/2))
     
    39273927    def coefficients(self, x=None):
    39283928        r"""
    39293929        Coefficients of this symbolic expression as a polynomial in x.
    3930        
    3931         INPUT:
    3932        
     3930
     3931        INPUT:
     3932
    39333933        -  ``x`` - optional variable
    3934        
    3935         OUTPUT: 
     3934
     3935        OUTPUT:
    39363936
    39373937        - A list of pairs (expr, n), where expr is a symbolic
    39383938          expression and n is a power.
    3939        
    3940         EXAMPLES::
    3941        
     3939
     3940        EXAMPLES::
     3941
    39423942            sage: var('x, y, a')
    39433943            (x, y, a)
    39443944            sage: p = x^3 - (x-3)*(x^2+x) + 1
     
    39503950            [[x^2 + x + 1, 0], [-2*sqrt(2)*x, 1], [2, 2]]
    39513951            sage: p.coefficients(x)
    39523952            [[2*a^2 + 1, 0], [-2*sqrt(2)*a + 1, 1], [1, 2]]
    3953        
     3953
    39543954        A polynomial with wacky exponents::
    3955        
     3955
    39563956            sage: p = (17/3*a)*x^(3/2) + x*y + 1/x + x^x
    39573957            sage: p.coefficients(x)
    39583958            [[1, -1], [x^x, 0], [y, 1], [17/3*a, 3/2]]
     
    39693969        return S[1:]
    39703970
    39713971    coeffs = coefficients
    3972    
     3972
    39733973    def leading_coefficient(self, s):
    39743974        """
    39753975        Return the leading coefficient of s in self.
    3976        
    3977         EXAMPLES::
    3978        
     3976
     3977        EXAMPLES::
     3978
    39793979            sage: var('x,y,a')
    39803980            (x, y, a)
    39813981            sage: f = 100 + a*x + x^3*sin(x*y) + x*y + x/y + 2*sin(x*y)/x; f
     
    39913991        return new_Expression_from_GEx(self._parent, self._gobj.lcoeff(ss._gobj))
    39923992
    39933993    leading_coeff = leading_coefficient
    3994    
     3994
    39953995    def trailing_coefficient(self, s):
    39963996        """
    39973997        Return the trailing coefficient of s in self, i.e., the coefficient
    39983998        of the smallest power of s in self.
    3999        
    4000         EXAMPLES::
    4001        
     3999
     4000        EXAMPLES::
     4001
    40024002            sage: var('x,y,a')
    40034003            (x, y, a)
    40044004            sage: f = 100 + a*x + x^3*sin(x*y) + x*y + x/y + 2*sin(x*y)/x; f
     
    40144014        return new_Expression_from_GEx(self._parent, self._gobj.tcoeff(ss._gobj))
    40154015
    40164016    trailing_coeff = trailing_coefficient
    4017    
     4017
    40184018    def low_degree(self, s):
    40194019        """
    40204020        Return the exponent of the lowest nonpositive power of s in self.
     
    40244024        - an integer <= 0.
    40254025
    40264026        EXAMPLES::
    4027        
     4027
    40284028            sage: var('x,y,a')
    40294029            (x, y, a)
    40304030            sage: f = 100 + a*x + x^3*sin(x*y) + x*y + x/y^10 + 2*sin(x*y)/x; f
     
    40504050        - an integer >= 0.
    40514051
    40524052        EXAMPLES::
    4053        
     4053
    40544054            sage: var('x,y,a')
    40554055            (x, y, a)
    40564056            sage: f = 100 + a*x + x^3*sin(x*y) + x*y + x/y^10 + 2*sin(x*y)/x; f
     
    40724072        Express this symbolic expression as a polynomial in *x*. If
    40734073        this is not a polynomial in *x*, then some coefficients may be
    40744074        functions of *x*.
    4075        
     4075
    40764076        .. warning::
    40774077
    40784078           This is different from :meth:`polynomial` which returns
    40794079           a Sage polynomial over a given base ring.
    4080        
    4081         EXAMPLES::
    4082        
     4080
     4081        EXAMPLES::
     4082
    40834083            sage: var('a, x')
    40844084            (a, x)
    40854085            sage: p = expand((x-a*sqrt(2))^2 + x + 1); p
     
    40874087            sage: p.poly(a)
    40884088            -2*sqrt(2)*a*x + 2*a^2 + x^2 + x + 1
    40894089            sage: bool(p.poly(a) == (x-a*sqrt(2))^2 + x + 1)
    4090             True           
     4090            True
    40914091            sage: p.poly(x)
    40924092            -(2*sqrt(2)*a - 1)*x + 2*a^2 + x^2 + 1
    40934093        """
     
    41214121        r"""
    41224122        Return this symbolic expression as an algebraic polynomial
    41234123        over the given base ring, if possible.
    4124        
     4124
    41254125        The point of this function is that it converts purely symbolic
    41264126        polynomials into optimised algebraic polynomials over a given
    41274127        base ring.
    4128        
     4128
    41294129        .. warning::
    41304130
    41314131           This is different from meth:`poly` which is used to rewrite
    41324132           self as a polynomial in terms of one of the variables.
    4133        
    4134         INPUT:
    4135        
     4133
     4134        INPUT:
     4135
    41364136        -  ``base_ring`` - a ring
    4137        
    4138         EXAMPLES::
    4139        
     4137
     4138        EXAMPLES::
     4139
    41404140            sage: f = x^2 -2/3*x + 1
    41414141            sage: f.polynomial(QQ)
    41424142            x^2 - 2/3*x + 1
    41434143            sage: f.polynomial(GF(19))
    41444144            x^2 + 12*x + 1
    4145        
     4145
    41464146        Polynomials can be useful for getting the coefficients of an
    41474147        expression::
    4148        
     4148
    41494149            sage: g = 6*x^2 - 5
    41504150            sage: g.coefficients()
    41514151            [[-5, 0], [6, 2]]
     
    41534153            [-5, 0, 6]
    41544154            sage: g.polynomial(QQ).dict()
    41554155            {0: -5, 2: 6}
    4156        
    4157         ::
    4158        
     4156
     4157        ::
     4158
    41594159            sage: f = x^2*e + x + pi/e
    41604160            sage: f.polynomial(RDF)
    41614161            2.71828182846*x^2 + x + 1.15572734979
    41624162            sage: g = f.polynomial(RR); g
    41634163            2.71828182845905*x^2 + x + 1.15572734979092
    41644164            sage: g.parent()
    4165             Univariate Polynomial Ring in x over Real Field with 53 bits of precision           
     4165            Univariate Polynomial Ring in x over Real Field with 53 bits of precision
    41664166            sage: f.polynomial(RealField(100))
    41674167            2.7182818284590452353602874714*x^2 + x + 1.1557273497909217179100931833
    41684168            sage: f.polynomial(CDF)
    41694169            2.71828182846*x^2 + x + 1.15572734979
    41704170            sage: f.polynomial(CC)
    41714171            2.71828182845905*x^2 + x + 1.15572734979092
    4172        
     4172
    41734173        We coerce a multivariate polynomial with complex symbolic
    41744174        coefficients::
    4175        
     4175
    41764176            sage: x, y, n = var('x, y, n')
    41774177            sage: f = pi^3*x - y^2*e - I; f
    41784178            pi^3*x - y^2*e - I
     
    41824182            (-2.71828182845905)*y^2 + 31.0062766802998*x - 1.00000000000000*I
    41834183            sage: f.polynomial(ComplexField(70))
    41844184            (-2.7182818284590452354)*y^2 + 31.006276680299820175*x - 1.0000000000000000000*I
    4185        
     4185
    41864186        Another polynomial::
    4187        
     4187
    41884188            sage: f = sum((e*I)^n*x^n for n in range(5)); f
    41894189            x^4*e^4 - I*x^3*e^3 - x^2*e^2 + I*x*e + 1
    41904190            sage: f.polynomial(CDF)
    41914191            54.5981500331*x^4 - 20.0855369232*I*x^3 - 7.38905609893*x^2 + 2.71828182846*I*x + 1.0
    41924192            sage: f.polynomial(CC)
    41934193            54.5981500331442*x^4 - 20.0855369231877*I*x^3 - 7.38905609893065*x^2 + 2.71828182845905*I*x + 1.00000000000000
    4194        
     4194
    41954195        A multivariate polynomial over a finite field::
    4196        
     4196
    41974197            sage: f = (3*x^5 - 5*y^5)^7; f
    41984198            (3*x^5 - 5*y^5)^7
    41994199            sage: g = f.polynomial(GF(7)); g
     
    42034203        """
    42044204        from sage.symbolic.expression_conversions import polynomial
    42054205        return polynomial(self, base_ring=base_ring, ring=ring)
    4206    
     4206
    42074207    def _polynomial_(self, R):
    42084208        """
    42094209        Coerce this symbolic expression to a polynomial in `R`.
    4210        
    4211         EXAMPLES::
    4212        
     4210
     4211        EXAMPLES::
     4212
    42134213            sage: var('x,y,z,w')
    42144214            (x, y, z, w)
    4215        
    4216         ::
    4217        
     4215
     4216        ::
     4217
    42184218            sage: R = QQ[x,y,z]
    42194219            sage: R(x^2 + y)
    42204220            x^2 + y
     
    42244224            sage: R = GF(7)[z]
    42254225            sage: R(z^3 + 10*z)
    42264226            z^3 + 3*z
    4227        
     4227
    42284228        .. note::
    42294229
    42304230           If the base ring of the polynomial ring is the symbolic ring,
    42314231           then a constant polynomial is always returned.
    4232        
    4233         ::
    4234        
     4232
     4233        ::
     4234
    42354235            sage: R = SR[x]
    42364236            sage: a = R(sqrt(2) + x^3 + y)
    42374237            sage: a
     
    42404240            <class 'sage.rings.polynomial.polynomial_element_generic.Polynomial_generic_dense_field'>
    42414241            sage: a.degree()
    42424242            0
    4243        
     4243
    42444244        We coerce to a double precision complex polynomial ring::
    4245        
     4245
    42464246            sage: f = e*x^3 + pi*y^3 + sqrt(2) + I; f
    42474247            pi*y^3 + x^3*e + sqrt(2) + I
    42484248            sage: R = CDF[x,y]
    42494249            sage: R(f)
    42504250            2.71828182846*x^3 + 3.14159265359*y^3 + 1.41421356237 + 1.0*I
    4251        
     4251
    42524252        We coerce to a higher-precision polynomial ring
    4253        
    4254         ::
    4255        
     4253
     4254        ::
     4255
    42564256            sage: R = ComplexField(100)[x,y]
    42574257            sage: R(f)
    42584258            2.7182818284590452353602874714*x^3 + 3.1415926535897932384626433833*y^3 + 1.4142135623730950488016887242 + 1.0000000000000000000000000000*I
     
    42764276        This shows that the issue at trac #4246 is fixed (attempting to
    42774277        coerce an expression containing at least one variable that's not in
    42784278        `R` raises an error)::
    4279        
     4279
    42804280            sage: x, y = var('x y')
    42814281            sage: S = PolynomialRing(Integers(4), 1, 'x')
    42824282            sage: S(x)
     
    42964296        """
    42974297        from sage.symbolic.all import SR
    42984298        from sage.rings.all import is_MPolynomialRing
    4299        
     4299
    43004300        base_ring = R.base_ring()
    43014301        if base_ring == SR:
    43024302            if is_MPolynomialRing(R):
     
    43044304            else:
    43054305                return R([self])
    43064306        return self.polynomial(None, ring=R)
    4307    
     4307
    43084308    def power_series(self, base_ring):
    43094309        """
    43104310        Return algebraic power series associated to this symbolic
    43114311        expression, which must be a polynomial in one variable, with
    43124312        coefficients coercible to the base ring.
    4313        
     4313
    43144314        The power series is truncated one more than the degree.
    4315        
    4316         EXAMPLES::
    4317        
     4315
     4316        EXAMPLES::
     4317
    43184318            sage: theta = var('theta')
    43194319            sage: f = theta^3 + (1/3)*theta - 17/3
    43204320            sage: g = f.power_series(QQ); g
     
    43414341        http://trac.sagemath.org/sage_trac/ticket/694 on Ginac dies
    43424342        after about 10 seconds.  Singular easily does that GCD now.
    43434343        Since Ginac only handles poly gcd over QQ, we should change
    4344         ginac itself to use Singular. 
    4345        
    4346         EXAMPLES::
    4347        
     4344        ginac itself to use Singular.
     4345
     4346        EXAMPLES::
     4347
    43484348            sage: var('x,y')
    43494349            (x, y)
    43504350            sage: SR(10).gcd(SR(15))
     
    43794379        OUTPUT:
    43804380
    43814381        - expression
    4382            
    4383         EXAMPLES::
    4384        
     4382
     4383        EXAMPLES::
     4384
    43854385            sage: var('x,y,z')
    43864386            (x, y, z)
    43874387            sage: f = 4*x*y + x*z + 20*y^2 + 21*y*z + 4*z^2 + x^2*y^2*z^2
     
    44014401    def collect_common_factors(self):
    44024402        """
    44034403        EXAMPLES::
    4404        
     4404
    44054405            sage: var('x')
    44064406            x
    44074407            sage: (x/(x^2 + x)).collect_common_factors()
     
    44154415    def __abs__(self):
    44164416        """
    44174417        Return the absolute value of this expression.
    4418        
    4419         EXAMPLES::
    4420        
     4418
     4419        EXAMPLES::
     4420
    44214421            sage: var('x, y')
    44224422            (x, y)
    44234423
    44244424        The absolute value of a symbolic expression::
    4425        
     4425
    44264426            sage: abs(x^2+y^2)
    44274427            abs(x^2 + y^2)
    44284428
    44294429        The absolute value of a number in the symbolic ring::
    4430        
     4430
    44314431            sage: abs(SR(-5))
    44324432            5
    44334433            sage: type(abs(SR(-5)))
     
    44394439        """
    44404440        Return the value of the Heaviside step function, which is 0 for
    44414441        negative x, 1/2 for 0, and 1 for positive x.
    4442        
    4443         EXAMPLES::
    4444        
     4442
     4443        EXAMPLES::
     4444
    44454445            sage: x = var('x')
    44464446            sage: SR(1.5).step()
    44474447            1
     
    44614461        symbolic expression.
    44624462
    44634463        It can be somewhat arbitrary when self is not real.
    4464        
     4464
    44654465        EXAMPLES:
    44664466            sage: x = var('x')
    44674467            sage: SR(-2).csgn()
     
    44824482    def conjugate(self):
    44834483        """
    44844484        Return the complex conjugate of this symbolic expression.
    4485        
    4486         EXAMPLES::
    4487 
    4488             sage: a = 1 + 2*I 
     4485
     4486        EXAMPLES::
     4487
     4488            sage: a = 1 + 2*I
    44894489            sage: a.conjugate()
    44904490            -2*I + 1
    44914491            sage: a = sqrt(2) + 3^(1/3)*I; a
     
    45124512        r"""
    45134513        The complex norm of this symbolic expression, i.e.,
    45144514        the expression times its complex conjugate.
    4515        
    4516         EXAMPLES::
    4517        
    4518             sage: a = 1 + 2*I 
     4515
     4516        EXAMPLES::
     4517
     4518            sage: a = 1 + 2*I
    45194519            sage: a.norm()
    45204520            5
    45214521            sage: a = sqrt(2) + 3^(1/3)*I; a
     
    45344534        Return the real part of this symbolic expression.
    45354535
    45364536        EXAMPLES::
    4537        
     4537
    45384538            sage: x = var('x')
    45394539            sage: x.real_part()
    45404540            real_part(x)
     
    45614561
    45624562            sage: sqrt(-2).imag_part()
    45634563            sqrt(2)
    4564        
     4564
    45654565        We simplify `\ln(\exp(z))` to `z`.  This should only
    45664566        be for `-\pi<{\rm Im}(z)<=\pi`, but Maxima does not
    45674567        have a symbolic imaginary part function, so we cannot
     
    45744574            sage: f.simplify()
    45754575            z
    45764576            sage: forget()
    4577        
     4577
    45784578        A more symbolic example::
    4579        
     4579
    45804580            sage: var('a, b')
    45814581            (a, b)
    45824582            sage: f = log(a + b*I)
     
    45844584            arctan2(real_part(b) + imag_part(a), real_part(a) - imag_part(b))
    45854585
    45864586        TESTS::
    4587        
     4587
    45884588            sage: x = var('x')
    45894589            sage: x.imag_part()
    45904590            imag_part(x)
     
    46484648    def cos(self):
    46494649        """
    46504650        Return the cosine of self.
    4651        
     4651
    46524652        EXAMPLES::
    46534653
    46544654            sage: var('x, y')
     
    46684668            sage: SR(RR(1)).cos().n()
    46694669            0.540302305868140
    46704670            sage: SR(float(1)).cos().n()
    4671             0.540302305868140           
     4671            0.540302305868140
    46724672
    46734673        TESTS::
    46744674
     
    47234723        """
    47244724        Return the arcsin of x, i.e., the number y between -pi and pi
    47254725        such that sin(y) == x.
    4726        
     4726
    47274727        EXAMPLES::
    47284728
    47294729            sage: x.arcsin()
     
    48164816    def arctan2(self, x):
    48174817        """
    48184818        Return the inverse of the 2-variable tan function on self and x.
    4819        
     4819
    48204820        EXAMPLES::
    48214821
    48224822            sage: var('x,y')
     
    48624862            0.0
    48634863            sage: SR(0).arctan2(0)
    48644864            0
    4865            
     4865
    48664866            sage: SR(I).arctan2(1)
    48674867            arctan2(I, 1)
    48684868            sage: SR(CDF(0,1)).arctan2(1)
     
    49004900        r"""
    49014901        Return sinh of self.
    49024902
    4903         We have $\sinh(x) = (e^{x} - e^{-x})/2$. 
     4903        We have $\sinh(x) = (e^{x} - e^{-x})/2$.
    49044904
    49054905        EXAMPLES::
    49064906
     
    49384938        r"""
    49394939        Return cosh of self.
    49404940
    4941         We have $\cosh(x) = (e^{x} + e^{-x})/2$. 
     4941        We have $\cosh(x) = (e^{x} + e^{-x})/2$.
    49424942
    49434943        EXAMPLES::
    49444944
     
    49744974        r"""
    49754975        Return tanh of self.
    49764976
    4977         We have $\tanh(x) = \sinh(x) / \cosh(x)$. 
     4977        We have $\tanh(x) = \sinh(x) / \cosh(x)$.
    49784978
    49794979        EXAMPLES::
    49804980
     
    50065006    def arcsinh(self):
    50075007        """
    50085008        Return the inverse hyperbolic sine of self.
    5009        
     5009
    50105010        EXAMPLES::
    50115011
    50125012            sage: x.arcsinh()
     
    51835183    def zeta(self):
    51845184        """
    51855185        EXAMPLES::
    5186        
     5186
    51875187            sage: x, y = var('x, y')
    51885188            sage: (x/y).zeta()
    51895189            zeta(x/y)
     
    51985198            sage: plot(lambda x: SR(x).zeta(), -10,10).show(ymin=-3,ymax=3)
    51995199
    52005200        TESTS::
    5201            
     5201
    52025202            sage: t = SR(1).zeta(); t
    52035203            zeta(1)
    52045204            sage: t.n()
     
    52085208        cdef GEx x = g_zeta(self._gobj)
    52095209        _sig_off
    52105210        return new_Expression_from_GEx(self._parent, x)
    5211    
     5211
    52125212    def factorial(self):
    52135213        """
    52145214        Return the factorial of self.
    5215        
     5215
    52165216        OUTPUT:
    52175217            symbolic expression
    5218        
     5218
    52195219        EXAMPLES:
    52205220            sage: var('x, y')
    52215221            (x, y)
     
    52345234    def binomial(self, k):
    52355235        """
    52365236        Return binomial coefficient "self choose k".
    5237        
     5237
    52385238        OUTPUT:
    52395239            symbolic expression
    5240        
     5240
    52415241        EXAMPLES:
    52425242            sage: var('x, y')
    52435243            (x, y)
     
    52605260
    52615261        OUTPUT:
    52625262            symbolic expression
    5263        
     5263
    52645264        EXAMPLES:
    52655265            sage: n = var('n')
    52665266            sage: t = (17*n^3).Order(); t
     
    52735273    def gamma(self):
    52745274        """
    52755275        Return the Gamma function evaluated at self.
    5276        
     5276
    52775277        EXAMPLES:
    52785278            sage: x = var('x')
    52795279            sage: x.gamma()
     
    53225322        This is the logarithm of gamma of self, where
    53235323        gamma is a complex function such that gamma(n)
    53245324        equals factorial(n-1).
    5325        
     5325
    53265326        EXAMPLES::
    53275327
    53285328            sage: x = var('x')
     
    53495349        Return the default variable, which is by definition the first
    53505350        variable in self, or `x` is there are no variables in self.
    53515351        The result is cached.
    5352        
    5353         EXAMPLES::
    5354        
     5352
     5353        EXAMPLES::
     5354
    53555355            sage: sqrt(2).default_variable()
    5356             x       
     5356            x
    53575357            sage: x, theta, a = var('x, theta, a')
    53585358            sage: f = x^2 + theta^3 - a^x
    53595359            sage: f.default_variable()
    53605360            a
    5361        
     5361
    53625362        Note that this is the first *variable*, not the first *argument*::
    5363        
     5363
    53645364            sage: f(theta, a, x) = a + theta^3
    53655365            sage: f.default_variable()
    53665366            a
     
    53805380        Returns a simplified version of this symbolic expression
    53815381        by combining all terms with the same denominator into a single
    53825382        term.
    5383        
    5384         EXAMPLES::
    5385        
     5383
     5384        EXAMPLES::
     5385
    53865386            sage: var('x, y, a, b, c')
    53875387            (x, y, a, b, c)
    53885388            sage: f = x*(x-1)/(x^2 - 7) + y^2/(x^2-7) + 1/(x+1) + b/a + c/a; f
     
    53915391            ((x - 1)*x + y^2)/(x^2 - 7) + (b + c)/a + 1/(x + 1)
    53925392        """
    53935393        return self.parent()(self._maxima_().combine())
    5394    
     5394
    53955395    def numerator(self):
    53965396        """
    53975397        Returns the numerator of this symbolic expression.  If the
    53985398        expression is not a quotient, then this will return the
    53995399        expression itself.
    5400        
    5401         EXAMPLES::
    5402        
     5400
     5401        EXAMPLES::
     5402
    54035403            sage: a, x, y = var('a,x,y')
    54045404            sage: f = x*(x-a)/((x^2 - y)*(x-a)); f
    54055405            x/(x^2 - y)
     
    54235423        """
    54245424        Returns the denominator of this symbolic expression.  If the
    54255425        expression is not a quotient, then this will just return 1.
    5426        
    5427         EXAMPLES::
    5428        
     5426
     5427        EXAMPLES::
     5428
    54295429            sage: x, y, z, theta = var('x, y, z, theta')
    54305430            sage: f = (sqrt(x) + sqrt(y) + sqrt(z))/(x^10 - y^10 - sqrt(theta))
    54315431            sage: f.denominator()
     
    54455445        r"""
    54465446        Return the partial fraction expansion of ``self`` with
    54475447        respect to the given variable.
    5448        
    5449         INPUT:
    5450        
    5451        
     5448
     5449        INPUT:
     5450
     5451
    54525452        -  ``var`` - variable name or string (default: first
    54535453           variable)
    5454        
    5455        
     5454
     5455
    54565456        OUTPUT: Symbolic expression
    5457        
    5458         EXAMPLES::
    5459        
     5457
     5458        EXAMPLES::
     5459
    54605460            sage: f = x^2/(x+1)^3
    54615461            sage: f.partial_fraction()
    54625462            1/(x + 1) - 2/(x + 1)^2 + 1/(x + 1)^3
    54635463            sage: f.partial_fraction()
    54645464            1/(x + 1) - 2/(x + 1)^2 + 1/(x + 1)^3
    5465        
     5465
    54665466        Notice that the first variable in the expression is used by
    54675467        default::
    5468        
     5468
    54695469            sage: y = var('y')
    54705470            sage: f = y^2/(y+1)^3
    54715471            sage: f.partial_fraction()
    54725472            1/(y + 1) - 2/(y + 1)^2 + 1/(y + 1)^3
    5473        
     5473
    54745474            sage: f = y^2/(y+1)^3 + x/(x-1)^3
    54755475            sage: f.partial_fraction()
    54765476            y^2/(y^3 + 3*y^2 + 3*y + 1) + 1/(x - 1)^2 + 1/(x - 1)^3
    5477        
     5477
    54785478        You can explicitly specify which variable is used::
    5479        
     5479
    54805480            sage: f.partial_fraction(y)
    54815481            x/(x^3 - 3*x^2 + 3*x - 1) + 1/(y + 1) - 2/(y + 1)^2 + 1/(y + 1)^3
    54825482        """
     
    54875487    def simplify(self):
    54885488        """
    54895489        Returns a simplified version of this symbolic expression.
    5490        
     5490
    54915491        .. note::
    54925492
    54935493           Currently, this just sends the expression to Maxima
     
    55075507            x^(-a + 1)*sin(2)
    55085508        """
    55095509        return self._parent(self._maxima_())
    5510    
     5510
    55115511    def simplify_full(self):
    55125512        """
    55135513        Applies simplify_factorial, simplify_trig, simplify_rational, and simplify_radical
    55145514        to self (in that order).
    5515        
     5515
    55165516        ALIAS: simplify_full and full_simplify are the same.
    5517        
    5518         EXAMPLES::
    5519        
     5517
     5518        EXAMPLES::
     5519
    55205520            sage: a = log(8)/log(2)
    55215521            sage: a.simplify_full()
    55225522            3
    5523        
    5524         ::
    5525        
     5523
     5524        ::
     5525
    55265526            sage: f = sin(x)^2 + cos(x)^2
    55275527            sage: f.simplify_full()
    55285528            1
    5529        
    5530         ::
    5531        
     5529
     5530        ::
     5531
    55325532            sage: f = sin(x/(x^2 + x))
    55335533            sage: f.simplify_full()
    55345534            sin(1/(x + 1))
     
    55525552    full_simplify = simplify_full
    55535553
    55545554    def simplify_trig(self,expand=True):
    5555         r""" 
     5555        r"""
    55565556        Optionally expands and then employs identities such as
    55575557        `\sin(x)^2 + \cos(x)^2 = 1`, `\cosh(x)^2 - \sinh(x)^2 = 1`,
    55585558        `\sin(x)\csc(x) = 1`, or `\tanh(x)=\sinh(x)/\cosh(x)`
    55595559        to simplify expressions containing tan, sec, etc., to sin,
    55605560        cos, sinh, cosh.
    5561        
     5561
    55625562        INPUT:
    55635563
    55645564        - ``self`` - symbolic expression
     
    55685568          angles occurring in ``self`` first. For best results,
    55695569          ``self`` should be expanded. See also :meth:`expand_trig` to
    55705570          get more controls on this expansion.
    5571        
     5571
    55725572        ALIAS: :meth:`trig_simplify` and :meth:`simplify_trig` are the same
    5573        
    5574         EXAMPLES::
    5575        
     5573
     5574        EXAMPLES::
     5575
    55765576            sage: f = sin(x)^2 + cos(x)^2; f
    55775577            sin(x)^2 + cos(x)^2
    55785578            sage: f.simplify()
     
    55915591            sage: f=tan(3*x)
    55925592            sage: f.simplify_trig()
    55935593            (4*cos(x)^2 - 1)*sin(x)/(4*cos(x)^3 - 3*cos(x))
    5594             sage: f.simplify_trig(False)           
     5594            sage: f.simplify_trig(False)
    55955595            sin(3*x)/cos(3*x)
    5596        
     5596
    55975597        """
    55985598        # much better to expand first, since it often doesn't work
    55995599        # right otherwise!
     
    56105610
    56115611        INPUT:
    56125612
    5613         - ``self`` - symbolic expression 
     5613        - ``self`` - symbolic expression
    56145614
    56155615        - ``method`` - (default: 'full') string which switches the
    5616           method for simplifications. Possible values are 
     5616          method for simplifications. Possible values are
    56175617
    56185618          - 'simple' (simplify rational functions into quotient of two
    5619             polynomials), 
     5619            polynomials),
    56205620
    56215621          - 'full' (apply repeatedly, if necessary)
    56225622
     
    56345634        DETAILS: We call Maxima functions ratsimp, fullratsimp and
    56355635        xthru. If each part of the expression has to be simplified
    56365636        separately, we use Maxima function map.
    5637        
    5638         EXAMPLES::
    5639        
     5637
     5638        EXAMPLES::
     5639
    56405640            sage: f = sin(x/(x^2 + x))
    56415641            sage: f
    56425642            sin(x/(x^2 + x))
    56435643            sage: f.simplify_rational()
    56445644            sin(1/(x + 1))
    5645        
    5646         ::
    5647        
     5645
     5646        ::
     5647
    56485648            sage: f = ((x - 1)^(3/2) - (x + 1)*sqrt(x - 1))/sqrt((x - 1)*(x + 1)); f
    56495649            ((x - 1)^(3/2) - sqrt(x - 1)*(x + 1))/sqrt((x - 1)*(x + 1))
    56505650            sage: f.simplify_rational()
     
    56635663            sage: f.simplify_rational(map=True)
    56645664            x - log(x)/(x + 2) - 1
    56655665
    5666         Here is an example from the Maxima documentation of where 
     5666        Here is an example from the Maxima documentation of where
    56675667        ``method='simple'`` produces an (possibly useful) intermediate
    56685668        step::
    56695669
     
    57065706
    57075707    def simplify_factorial(self):
    57085708        """
    5709         Simplify by combining expressions with factorials, and by 
     5709        Simplify by combining expressions with factorials, and by
    57105710        expanding binomials into factorials.
    5711        
     5711
    57125712        ALIAS: factorial_simplify and simplify_factorial are the same
    5713        
     5713
    57145714        EXAMPLES:
    57155715
    57165716        Some examples are relatively clear::
    5717        
     5717
    57185718            sage: var('n,k')
    57195719            (n, k)
    57205720            sage: f = factorial(n+1)/factorial(n); f
     
    57365736            factorial(-k + n)*factorial(k)*binomial(n, k)
    57375737            sage: f.simplify_factorial()
    57385738            factorial(n)
    5739        
     5739
    57405740        A more complicated example, which needs further processing::
    57415741
    57425742            sage: f = factorial(x)/factorial(x-2)/2 + factorial(x+1)/factorial(x)/2; f
     
    57565756        exponentials, and radicals, by converting it into a form which is
    57575757        canonical over a large class of expressions and a given ordering of
    57585758        variables
    5759        
     5759
    57605760        DETAILS: This uses the Maxima radcan() command. From the Maxima
    57615761        documentation: "All functionally equivalent forms are mapped into a
    57625762        unique form. For a somewhat larger class of expressions, produces a
     
    57665766        time consuming. This is the cost of exploring certain relationships
    57675767        among the components of the expression for simplifications based on
    57685768        factoring and partial fraction expansions of exponents."
    5769        
    5770         ALIAS: radical_simplify, simplify_radical, exp_simplify, simplify_exp 
     5769
     5770        ALIAS: radical_simplify, simplify_radical, exp_simplify, simplify_exp
    57715771        are all the same
    5772        
    5773         EXAMPLES::
    5774        
     5772
     5773        EXAMPLES::
     5774
    57755775            sage: var('x,y,a')
    57765776            (x, y, a)
    5777        
    5778         ::
    5779        
     5777
     5778        ::
     5779
    57805780            sage: f = log(x*y)
    57815781            sage: f.simplify_radical()
    57825782            log(x) + log(y)
    5783        
    5784         ::
    5785        
     5783
     5784        ::
     5785
    57865786            sage: f = (log(x+x^2)-log(x))^a/log(1+x)^(a/2)
    57875787            sage: f.simplify_radical()
    57885788            log(x + 1)^(1/2*a)
    5789        
    5790         ::
    5791        
     5789
     5790        ::
     5791
    57925792            sage: f = (e^x-1)/(1+e^(x/2))
    57935793            sage: f.simplify_exp()
    57945794            e^(1/2*x) - 1
     
    58135813        this transformation in optional parameter ``method``.
    58145814
    58155815        INPUT:
    5816        
     5816
    58175817        - ``self`` - expression to be simplified
    58185818
    58195819        - ``method`` - (default: None) optional, governs the condition
    58205820          on a1 and a2 which must be satisfied to contract expression
    5821           a1*log(b1) + a2*log(b2). Values are 
    5822          
    5823           - None (use Maxima default, integers), 
    5824 
    5825           - 'one' (1 and -1), 
    5826 
    5827           - 'ratios' (integers and fractions of integers), 
    5828 
    5829           - 'constants' (constants), 
    5830 
    5831           - 'all' (all expressions). 
     5821          a1*log(b1) + a2*log(b2). Values are
     5822
     5823          - None (use Maxima default, integers),
     5824
     5825          - 'one' (1 and -1),
     5826
     5827          - 'ratios' (integers and fractions of integers),
     5828
     5829          - 'constants' (constants),
     5830
     5831          - 'all' (all expressions).
    58325832
    58335833          See also examples below.
    5834            
     5834
    58355835        DETAILS: This uses the Maxima logcontract() command. From the
    58365836        Maxima documentation: "Recursively scans the expression expr,
    58375837        transforming subexpressions of the form a1*log(b1) +
     
    58425842        logconcoeffp:'logconfun$ logconfun(m):=featurep(m,integer) or
    58435843        ratnump(m)$ . Then logcontract(1/2*log(x)); will give
    58445844        log(sqrt(x))."
    5845        
     5845
    58465846        ALIAS: :meth:`log_simplify` and :meth:`simplify_log` are the
    58475847        same
    58485848
    58495849        EXAMPLES::
    5850        
     5850
    58515851            sage: x,y,t=var('x y t')
    5852        
     5852
    58535853        Only two first terms are contracted in the following example ,
    58545854        the logarithm with coefficient 1/2 is not contracted::
    5855        
     5855
    58565856            sage: f = log(x)+2*log(y)+1/2*log(t)
    58575857            sage: f.simplify_log()
    58585858            log(x*y^2) + 1/2*log(t)
    5859            
     5859
    58605860        To contract all terms in previous example use option ``method``::
    5861        
     5861
    58625862            sage: f.simplify_log(method='ratios')
    58635863            log(sqrt(t)*x*y^2)
    58645864
     
    58665866        has no influence to future calls (we changed some default
    58675867        Maxima flag, and have to ensure that this flag has been
    58685868        restored)::
    5869        
     5869
    58705870            sage: f.simplify_log('one')
    58715871            1/2*log(t) + log(x) + 2*log(y)
    58725872
    58735873            sage: f.simplify_log('ratios')
    5874             log(sqrt(t)*x*y^2)     
     5874            log(sqrt(t)*x*y^2)
    58755875
    58765876            sage: f.simplify_log()
    5877             log(x*y^2) + 1/2*log(t)     
    5878 
    5879         To contract terms with no coefficient (more precisely, with 
     5877            log(x*y^2) + 1/2*log(t)
     5878
     5879        To contract terms with no coefficient (more precisely, with
    58805880        coefficients 1 and -1) use option ``method``::
    5881        
    5882             sage: f = log(x)+2*log(y)-log(t)   
    5883             sage: f.simplify_log('one')   
     5881
     5882            sage: f = log(x)+2*log(y)-log(t)
     5883            sage: f.simplify_log('one')
    58845884            2*log(y) + log(x/t)
    58855885
    58865886        ::
     
    58925892            sage: f.simplify_log('ratios')
    58935893            log(x*y/(x + 1)^(1/3))
    58945894
    5895         `\pi` is irrational number, to contract logarithms in the following example 
     5895        `\pi` is irrational number, to contract logarithms in the following example
    58965896        we have to put ``method`` to ``constants`` or ``all``::
    58975897
    5898             sage: f = log(x)+log(y)-pi*log((x+1)) 
     5898            sage: f = log(x)+log(y)-pi*log((x+1))
    58995899            sage: f.simplify_log('constants')
    59005900            log(x*y/(x + 1)^pi)
    59015901
     
    59065906            sage: (x*log(9)).simplify_log('all')
    59075907            log(9^x)
    59085908
    5909         TESTS::   
    5910        
    5911         This shows that the issue at trac #7344 is fixed:: 
     5909        TESTS::
     5910
     5911        This shows that the issue at trac #7344 is fixed::
    59125912
    59135913            sage: (log(sqrt(2)-1)+log(sqrt(2)+1)).simplify_full()
    59145914            0
    5915            
     5915
    59165916        AUTHORS:
    5917        
    5918         - Robert Marik (11-2009) 
     5917
     5918        - Robert Marik (11-2009)
    59195919        """
    59205920        from sage.calculus.calculus import maxima
    59215921        maxima.eval('domain: real$ savelogexpand:logexpand$ logexpand:false$')
     
    59285928        elif method == 'constants':
    59295929            maxima.eval('logconfun(m):= constantp(m)$')
    59305930        elif method == 'all':
    5931             maxima.eval('logconfun(m):= true$') 
     5931            maxima.eval('logconfun(m):= true$')
    59325932        elif method is not None:
    59335933            raise NotImplementedError, "unknown method, see the help for available methods"
    59345934        res = self.parent()(self._maxima_().logcontract())
    59355935        maxima.eval('domain: complex$')
    59365936        if method is not None:
    59375937            maxima.eval('logconcoeffp:false$')
    5938         maxima.eval('logexpand:savelogexpand$')             
     5938        maxima.eval('logexpand:savelogexpand$')
    59395939        return res
    59405940
    59415941    log_simplify = simplify_log
    59425942
    59435943    def expand_log(self,method='products'):
    5944         r""" 
    5945         Simplifies symbolic expression, which can contain logs. 
     5944        r"""
     5945        Simplifies symbolic expression, which can contain logs.
    59465946
    59475947        Expands logarithms of powers, logarithms of products and
    59485948        logarithms of quotients.  The option ``method`` specifies
    59495949        which expression types should be expanded.
    59505950
    59515951        INPUT:
    5952        
     5952
    59535953        - ``self`` - expression to be simplified
    59545954
    59555955        - ``method`` - (default: 'products') optional, governs which
    5956           expression is expanded. Possible values are 
    5957          
    5958           - 'nothing' (no expansion), 
    5959 
    5960           - 'powers' (log(a^r) is expanded), 
    5961 
    5962           - 'products' (like 'powers' and also log(a*b) are expanded), 
    5963          
    5964           - 'all' (all possible expansion). 
    5965 
    5966           See also examples below.       
    5967        
     5956          expression is expanded. Possible values are
     5957
     5958          - 'nothing' (no expansion),
     5959
     5960          - 'powers' (log(a^r) is expanded),
     5961
     5962          - 'products' (like 'powers' and also log(a*b) are expanded),
     5963
     5964          - 'all' (all possible expansion).
     5965
     5966          See also examples below.
     5967
    59685968        DETAILS: This uses the Maxima simplifier and sets
    59695969        ``logexpand`` option for this simplifier. From the Maxima
    59705970        documentation: "Logexpand:true causes log(a^b) to become
     
    59745974        a#1. (log(1/b), for integer b, always simplifies.) If it is
    59755975        set to false, all of these simplifications will be turned
    59765976        off. "
    5977        
     5977
    59785978        ALIAS: :meth:`log_expand` and :meth:`expand_log` are the same
    59795979
    59805980        EXAMPLES::
    59815981
    59825982        By default powers and products (and quotients) are expanded,
    59835983        but not quotients of integers::
    5984        
     5984
    59855985            sage: (log(3/4*x^pi)).log_expand()
    59865986            pi*log(x) + log(3/4)
    59875987
     
    59985998        The expression ``log((3*x)^6)`` is not expanded with
    59995999        ``method='powers'``, since it is converted into product
    60006000        first::
    6001        
     6001
    60026002            sage: (log((3*x)^6)).log_expand('powers')
    60036003            log(729*x^6)
    60046004
     
    60066006        has no influence to future calls (we changed some default
    60076007        Maxima flag, and have to ensure that this flag has been
    60086008        restored)::
    6009        
     6009
    60106010            sage: (log(3/4*x^pi)).log_expand()
    60116011            pi*log(x) + log(3/4)
    60126012
     
    60156015
    60166016            sage: (log(3/4*x^pi)).log_expand()
    60176017            pi*log(x) + log(3/4)
    6018                
     6018
    60196019        AUTHORS:
    6020        
    6021         - Robert Marik (11-2009) 
     6020
     6021        - Robert Marik (11-2009)
    60226022        """
    60236023        from sage.calculus.calculus import maxima
    60246024        maxima.eval('domain: real$ savelogexpand:logexpand$')
     
    60356035        maxima.eval('logexpand:%s'%maxima_method)
    60366036        res = self._maxima_()
    60376037        res = res.sage()
    6038         maxima.eval('domain: complex$ logexpand:savelogexpand$')             
    6039         return res   
    6040 
    6041     log_expand = expand_log 
     6038        maxima.eval('domain: complex$ logexpand:savelogexpand$')
     6039        return res
     6040
     6041    log_expand = expand_log
    60426042
    60436043
    60446044    def factor(self, dontfactor=[]):
    60456045        """
    60466046        Factors self, containing any number of variables or functions, into
    60476047        factors irreducible over the integers.
    6048        
    6049         INPUT:
    6050        
    6051        
     6048
     6049        INPUT:
     6050
     6051
    60526052        -  ``self`` - a symbolic expression
    6053        
     6053
    60546054        -  ``dontfactor`` - list (default: []), a list of
    60556055           variables with respect to which factoring is not to occur.
    60566056           Factoring also will not take place with respect to any variables
    60576057           which are less important (using the variable ordering assumed for
    60586058           CRE form) than those on the 'dontfactor' list.
    6059        
    6060        
    6061         EXAMPLES::
    6062        
     6059
     6060
     6061        EXAMPLES::
     6062
    60636063            sage: x,y,z = var('x, y, z')
    60646064            sage: (x^3-y^3).factor()
    60656065            (x - y)*(x^2 + x*y + y^2)
     
    60736073        dontfactor is empty) the factorization is done using Singular
    60746074        instead of Maxima, so the following is very fast instead of
    60756075        dreadfully slow::
    6076        
     6076
    60776077            sage: var('x,y')
    60786078            (x, y)
    60796079            sage: (x^99 + y^99).factor()
     
    60996099        """
    61006100        Returns a list of the factors of self, as computed by the
    61016101        factor command.
    6102        
    6103         INPUT:
    6104        
     6102
     6103        INPUT:
     6104
    61056105        -  ``self`` - a symbolic expression
    6106        
     6106
    61076107        -  ``dontfactor`` - see docs for :meth:`factor`
    6108        
     6108
    61096109        .. note::
    61106110
    61116111           If you already have a factored expression and just want to
    61126112           get at the individual factors, use :meth:`_factor_list`
    61136113           instead.
    6114        
    6115         EXAMPLES::
    6116        
     6114
     6115        EXAMPLES::
     6116
    61176117            sage: var('x, y, z')
    61186118            (x, y, z)
    61196119            sage: f = x^3-y^3
    61206120            sage: f.factor()
    61216121            (x - y)*(x^2 + x*y + y^2)
    6122        
     6122
    61236123        Notice that the -1 factor is separated out::
    6124        
     6124
    61256125            sage: f.factor_list()
    61266126            [(x - y, 1), (x^2 + x*y + y^2, 1)]
    6127        
     6127
    61286128        We factor a fairly straightforward expression::
    6129        
     6129
    61306130            sage: factor(-8*y - 4*x + z^2*(2*y + x)).factor_list()
    61316131            [(z - 2, 1), (z + 2, 1), (x + 2*y, 1)]
    61326132
    61336133        A more complicated example::
    6134        
     6134
    61356135            sage: var('x, u, v')
    61366136            (x, u, v)
    6137             sage: f = expand((2*u*v^2-v^2-4*u^3)^2 * (-u)^3 * (x-sin(x))^3) 
     6137            sage: f = expand((2*u*v^2-v^2-4*u^3)^2 * (-u)^3 * (x-sin(x))^3)
    61386138            sage: f.factor()
    61396139            -(x - sin(x))^3*(4*u^3 - 2*u*v^2 + v^2)^2*u^3
    6140             sage: g = f.factor_list(); g                     
     6140            sage: g = f.factor_list(); g
    61416141            [(x - sin(x), 3), (4*u^3 - 2*u*v^2 + v^2, 2), (u, 3), (-1, 1)]
    61426142
    61436143        This function also works for quotients::
    6144        
     6144
    61456145            sage: f = -1 - 2*x - x^2 + y^2 + 2*x*y^2 + x^2*y^2
    61466146            sage: g = f/(36*(1 + 2*y + y^2)); g
    61476147            1/36*(x^2*y^2 + 2*x*y^2 - x^2 + y^2 - 2*x - 1)/(y^2 + 2*y + 1)
     
    61496149            1/36*(y - 1)*(x^2 + 2*x + 1)/(y + 1)
    61506150            sage: g.factor_list(dontfactor=[x])
    61516151            [(y - 1, 1), (y + 1, -1), (x^2 + 2*x + 1, 1), (1/36, 1)]
    6152                    
     6152
    61536153        This example also illustrates that the exponents do not have to be
    61546154        integers::
    6155        
     6155
    61566156            sage: f = x^(2*sin(x)) * (x-1)^(sqrt(2)*x); f
    61576157            (x - 1)^(sqrt(2)*x)*x^(2*sin(x))
    61586158            sage: f.factor_list()
     
    61646164        r"""
    61656165        Turn an expression already in factored form into a list of (prime,
    61666166        power) pairs.
    6167        
     6167
    61686168        This is used, e.g., internally by the :meth:`factor_list`
    61696169        command.
    6170        
    6171         EXAMPLES::
    6172        
     6170
     6171        EXAMPLES::
     6172
    61736173            sage: g = factor(x^3 - 1); g
    61746174            (x - 1)*(x^2 + x + 1)
    61756175            sage: v = g._factor_list(); v
     
    61846184            return [tuple(self.operands())]
    61856185        else:
    61866186            return [(self, 1)]
    6187    
     6187
    61886188    ###################################################################
    61896189    # solve
    61906190    ###################################################################
     
    61936193        Returns roots of ``self`` that can be found exactly,
    61946194        possibly with multiplicities.  Not all roots are guaranteed to
    61956195        be found.
    6196        
     6196
    61976197        .. warning::
    61986198
    61996199           This is *not* a numerical solver - use ``find_root`` to
    62006200           solve for self == 0 numerically on an interval.
    6201        
    6202         INPUT:
    6203        
     6201
     6202        INPUT:
     6203
    62046204        - ``x`` - variable to view the function in terms of
    62056205          (use default variable if not given)
    6206          
     6206
    62076207        - ``explicit_solutions`` - bool (default True); require that
    62086208          roots be explicit rather than implicit
    6209          
     6209
    62106210        - ``multiplicities`` - bool (default True); when True, return
    62116211          multiplicities
    6212            
     6212
    62136213        - ``ring`` - a ring (default None): if not None, convert
    62146214          self to a polynomial over ring and find roots over ring
    62156215
    6216         OUTPUT: 
    6217        
     6216        OUTPUT:
     6217
    62186218        list of pairs (root, multiplicity) or list of roots
    6219        
     6219
    62206220        If there are infinitely many roots, e.g., a function like
    62216221        `\sin(x)`, only one is returned.
    6222        
    6223         EXAMPLES::
    6224        
     6222
     6223        EXAMPLES::
     6224
    62256225            sage: var('x, a')
    62266226            (x, a)
    6227        
     6227
    62286228        A simple example::
    6229        
     6229
    62306230            sage: ((x^2-1)^2).roots()
    62316231            [(-1, 2), (1, 2)]
    62326232            sage: ((x^2-1)^2).roots(multiplicities=False)
    62336233            [-1, 1]
    6234        
     6234
    62356235        A complicated example::
    6236        
     6236
    62376237            sage: f = expand((x^2 - 1)^3*(x^2 + 1)*(x-a)); f
    62386238            -a*x^8 + x^9 + 2*a*x^6 - 2*x^7 - 2*a*x^2 + 2*x^3 + a - x
    6239        
     6239
    62406240        The default variable is `a`, since it is the first in
    62416241        alphabetical order::
    6242        
     6242
    62436243            sage: f.roots()
    62446244            [(x, 1)]
    6245        
     6245
    62466246        As a polynomial in `a`, `x` is indeed a root::
    6247        
     6247
    62486248            sage: f.poly(a)
    62496249            x^9 - 2*x^7 + 2*x^3 - (x^8 - 2*x^6 + 2*x^2 - 1)*a - x
    62506250            sage: f(a=x)
    62516251            0
    6252        
     6252
    62536253        The roots in terms of `x` are what we expect::
    6254        
     6254
    62556255            sage: f.roots(x)
    62566256            [(a, 1), (-I, 1), (I, 1), (1, 3), (-1, 3)]
    6257        
     6257
    62586258        Only one root of `\sin(x) = 0` is given::
    6259        
    6260             sage: f = sin(x)   
     6259
     6260            sage: f = sin(x)
    62616261            sage: f.roots(x)
    62626262            [(0, 1)]
    6263        
     6263
    62646264        .. note::
    62656265
    62666266            It is possible to solve a greater variety of equations
    6267             using ``solve()`` and the keyword ``to_poly_solve``, 
    6268             but only at the price of possibly encountering 
     6267            using ``solve()`` and the keyword ``to_poly_solve``,
     6268            but only at the price of possibly encountering
    62696269            approximate solutions.  See documentation for f.solve
    62706270            for more details.
    62716271
    62726272        We derive the roots of a general quadratic polynomial::
    6273        
     6273
    62746274            sage: var('a,b,c,x')
    62756275            (a, b, c, x)
    62766276            sage: (a*x^2 + b*x + c).roots(x)
    62776277            [(-1/2*(b + sqrt(-4*a*c + b^2))/a, 1), (-1/2*(b - sqrt(-4*a*c + b^2))/a, 1)]
    62786278
    62796279        By default, all the roots are required to be explicit rather than
    6280         implicit. To get implicit roots, pass ``explicit_solutions=False`` 
     6280        implicit. To get implicit roots, pass ``explicit_solutions=False``
    62816281        to ``.roots()`` ::
    6282        
     6282
    62836283            sage: var('x')
    62846284            x
    62856285            sage: f = x^(1/9) + (2^(8/9) - 2^(1/9))*(x - 1) - x^(8/9)
     
    62926292
    62936293        Another example, but involving a degree 5 poly whose roots don't
    62946294        get computed explicitly::
    6295        
     6295
    62966296            sage: f = x^5 + x^3 + 17*x + 1
    62976297            sage: f.roots()
    62986298            Traceback (most recent call last):
     
    63046304            [x^5 + x^3 + 17*x + 1]
    63056305
    63066306        Now let's find some roots over different rings::
    6307        
     6307
    63086308            sage: f.roots(ring=CC)
    63096309            [(-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)]
    63106310            sage: (2.5*f).roots(ring=RR)
     
    63176317            [-0.05881152231844944?, -1.331099917875796? - 1.522416551837318?*I, -1.331099917875796? + 1.522416551837318?*I, 1.360505679035020? - 1.518808722099650?*I, 1.360505679035020? + 1.518808722099650?*I]
    63186318
    63196319        Root finding over finite fields::
    6320        
     6320
    63216321            sage: f.roots(ring=GF(7^2, 'a'))
    63226322            [(3, 1), (4*a + 6, 2), (3*a + 3, 2)]
    63236323
    63246324        TESTS::
    6325        
     6325
    63266326            sage: (sqrt(3) * f).roots(ring=QQ)
    63276327            Traceback (most recent call last):
    63286328            ...
     
    63476347    def solve(self, x, multiplicities=False, solution_dict=False, explicit_solutions=False, to_poly_solve=False):
    63486348        r"""
    63496349        Analytically solve the equation ``self == 0`` or an univarite
    6350         inequality for the variable `x`. 
    6351        
     6350        inequality for the variable `x`.
     6351
    63526352        .. warning::
    63536353
    63546354           This is not a numerical solver - use ``find_root`` to solve
    63556355           for self == 0 numerically on an interval.
    6356        
    6357         INPUT:
    6358        
    6359        
     6356
     6357        INPUT:
     6358
     6359
    63606360        -  ``x`` - variable to solve for
    6361        
     6361
    63626362        -  ``multiplicities`` - bool (default: False); if True,
    63636363           return corresponding multiplicities.  This keyword is
    63646364           incompatible with ``to_poly_solve=True`` and does not make
    6365            any sense when solving inequality.
    6366        
     6365           any sense when solving inequality.
     6366
    63676367        -  ``solution_dict`` - bool (default: False); if True,
    63686368           return a list of dictionaries containing solutions. Not used
    6369            when solving inequality. 
     6369           when solving inequality.
    63706370
    63716371        -  ``explicit_solutions`` - bool (default: False); require that
    63726372           all roots be explicit rather than implicit. Not used
    6373            when solving inequality. 
    6374        
    6375         -  ``to_poly_solve`` - bool (default: False); use Maxima's
    6376            ``to_poly_solver`` package to search for more possible 
     6373           when solving inequality.
     6374
     6375        -  ``to_poly_solve`` - bool (default: False) or string; use Maxima's
     6376           ``to_poly_solver`` package to search for more possible
    63776377           solutions, but possibly encounter approximate solutions.
    63786378           This keyword is incompatible with ``multiplicities=True``
    6379            and is not used when solving inequality.
    6380        
    6381         EXAMPLES::
    6382        
     6379           and is not used when solving inequality. Setting ``to_poly_solve``
     6380           to 'force' (string) omits Maxima's solve command (usefull when
     6381           some solution of trigonometric equations are lost).
     6382
     6383        EXAMPLES::
     6384
    63836385            sage: z = var('z')
    63846386            sage: (z^5 - 1).solve(z)
    63856387            [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]
     
    63896391
    63906392        A simple example to show use of the keyword
    63916393        ``multiplicities``::
    6392        
     6394
    63936395            sage: ((x^2-1)^2).solve(x)
    63946396            [x == -1, x == 1]
    63956397            sage: ((x^2-1)^2).solve(x,multiplicities=True)
     
    64226424            sage: solve(Q*sqrt(Q^2 + 2) - 1, Q)
    64236425            [Q == 1/sqrt(Q^2 + 2)]
    64246426            sage: solve(Q*sqrt(Q^2 + 2) - 1, Q, to_poly_solve=True)
    6425                         [Q == 1/sqrt(-sqrt(2) + 1), Q == 1/sqrt(sqrt(2) + 1)]
     6427                        [Q == 1/sqrt(-sqrt(2) + 1), Q == 1/sqrt(sqrt(2) + 1)]
    64266428
    64276429        In some cases there may be infinitely many solutions indexed
    64286430        by a dummy variable.  If it begins with ``z``, it is implicitly
     
    64306432
    64316433            sage: solve( sin(x)==cos(x), x, to_poly_solve=True)
    64326434            [x == 1/4*pi + pi*z45]
    6433        
     6435
    64346436        An effort is made to only return solutions that satisfy the current assumptions::
    6435        
     6437
    64366438            sage: solve(x^2==4, x)
    64376439            [x == -2, x == 2]
    64386440            sage: assume(x<0)
     
    64496451            [x == -sqrt(-z + 2)]
    64506452            sage: solve((x-z)^2==2, x)
    64516453            [x == z - sqrt(2), x == z + sqrt(2)]
    6452            
     6454
    64536455        There is still room for improvement::
    6454        
     6456
    64556457            sage: assume(x, 'integer')
    64566458            sage: assume(z, 'integer')
    64576459            sage: solve((x-z)^2==2, x)
    64586460            [x == z - sqrt(2), x == z + sqrt(2)]
    6459            
     6461
    64606462            sage: forget()
    64616463
    64626464        In some cases it may be worthwhile to directly use to_poly_solve,
     
    64996501            sage: (x^2>1).solve(x)
    65006502            [[x < -1], [x > 1]]
    65016503
    6502         Catch error message from Maxima::
     6504        Catch error message from Maxima::
    65036505
    65046506            sage: solve(acot(x),x)
    65056507            []
    65066508
    6507         ::
     6509        ::
    65086510
    65096511            sage: solve(acot(x),x,to_poly_solve=True)
    65106512            []
    65116513
    6512         Trac #7491 fixed:: 
     6514        Trac #7491 fixed::
    65136515
    65146516            sage: y=var('y')
    65156517            sage: solve(y==y,y)
    65166518            [y == r1]
    65176519            sage: solve(y==y,y,multiplicities=True)
    65186520            ([y == r1], [])
    6519        
     6521
    65206522            sage: from sage.symbolic.assumptions import GenericDeclaration
    65216523            sage: GenericDeclaration(x, 'rational').assume()
    65226524            sage: solve(x^2 == 2, x)
    65236525            []
    65246526            sage: forget()
    65256527
     6528        Trac #8390 fixed::
     6529
     6530            sage: solve(sin(x)==1/2,x)
     6531            [x == 1/6*pi]
     6532
     6533        ::
     6534
     6535            sage: solve(sin(x)==1/2,x,to_poly_solve=True)
     6536            [x == 1/6*pi]
     6537
     6538        ::
     6539
     6540            sage: solve(sin(x)==1/2,x,to_poly_solve='force')
     6541            [x == 5/6*pi + 2*pi*z87, x == 1/6*pi + 2*pi*z85]
    65266542        """
    65276543        import operator
    65286544        cdef Expression ex
     
    65616577        if explicit_solutions:
    65626578            P.eval('solveexplicit: true') # switches Maxima to looking for only explicit solutions
    65636579        try:
    6564             s = m.solve(x).str()
     6580            if to_poly_solve != 'force':
     6581                s = m.solve(x).str()
     6582            else: # omit Maxima's solve command
     6583                s = str([])
    65656584        except TypeError, mess: # if Maxima's solve has an error, we catch it
    65666585            if "Error executing code in Maxima" in str(mess):
    65676586                s = str([])
     
    65746593            if solution_dict:
    65756594                ans = (dict([[x,self.parent().var('r1')]]))
    65766595            else:
    6577                 ans = ([x == self.parent().var('r1')])               
    6578             if multiplicities: 
     6596                ans = ([x == self.parent().var('r1')])
     6597            if multiplicities:
    65796598                return ans,[]
    65806599            else:
    65816600                return ans
     
    65986617        # but also allows for the possibility of approximate   #
    65996618        # solutions being returned.                            #
    66006619        ########################################################
    6601         if to_poly_solve and not multiplicities: 
     6620        if to_poly_solve and not multiplicities:
    66026621            if len(X)==0: # if Maxima's solve gave no solutions, only try it
    66036622                try:
    66046623                    s = m.to_poly_solve(x)
     
    66126631                    from sage.calculus.calculus import symbolic_expression_from_maxima_element
    66136632                    try:
    66146633                        Y = symbolic_expression_from_maxima_element((eq._maxima_()).to_poly_solve(x)) # try to solve it using to_poly_solve
    6615                         X.remove(eq) 
     6634                        X.remove(eq)
    66166635                        X.extend([y[0] for y in Y]) # replace with the new solutions
    66176636                    except TypeError, mess:
    66186637                        if "Error executing code in Maxima" in str(mess) or "unable to make sense of Maxima expression" in str(mess):
     
    66476666        """
    66486667        Numerically find a root of self on the closed interval [a,b] (or
    66496668        [b,a]) if possible, where self is a function in the one variable.
    6650        
    6651         INPUT:
    6652        
     6669
     6670        INPUT:
     6671
    66536672        -  ``a, b`` - endpoints of the interval
    6654        
     6673
    66556674        -  ``var`` - optional variable
    6656        
     6675
    66576676        -  ``xtol, rtol`` - the routine converges when a root
    66586677           is known to lie within xtol of the value return. Should be = 0. The
    66596678           routine modifies this to take into account the relative precision
    66606679           of doubles.
    6661        
     6680
    66626681        -  ``maxiter`` - integer; if convergence is not
    66636682           achieved in maxiter iterations, an error is raised. Must be = 0.
    6664        
     6683
    66656684        -  ``full_output`` - bool (default: False), if True,
    66666685           also return object that contains information about convergence.
    6667        
    6668        
     6686
     6687
    66696688        EXAMPLES:
    66706689
    66716690        Note that in this example both f(-2) and f(3) are positive,
    66726691        yet we still find a root in that interval::
    6673        
     6692
    66746693            sage: f = x^2 - 1
    66756694            sage: f.find_root(-2, 3)
    66766695            1.0
     
    66876706            10
    66886707            sage: result.root
    66896708            1.0
    6690        
     6709
    66916710        More examples::
    6692        
     6711
    66936712            sage: (sin(x) + exp(x)).find_root(-10, 10)
    66946713            -0.588532743981862...
    66956714            sage: sin(x).find_root(-1,1)
    66966715            0.0
    66976716            sage: (1/tan(x)).find_root(3,3.5)
    66986717            3.1415926535...
    6699        
     6718
    67006719        An example with a square root::
    6701        
     6720
    67026721            sage: f = 1 + x + sqrt(x+2); f.find_root(-2,10)
    67036722            -1.6180339887498949
    6704        
     6723
    67056724        Some examples that Ted Kosan came up with::
    6706        
     6725
    67076726            sage: t = var('t')
    67086727            sage: v = 0.004*(9600*e^(-(1200*t)) - 2400*e^(-(300*t)))
    67096728            sage: v.find_root(0, 0.002)
    67106729            0.001540327067911417...
    6711        
    6712         With this expression, we can see there is a 
     6730
     6731        With this expression, we can see there is a
    67136732        zero very close to the origin::
    67146733
    67156734            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
    67166735            sage: show(plot(a, 0, .002), xmin=0, xmax=.002)
    6717        
     6736
    67186737        It is easy to approximate with ``find_root``::
    67196738
    67206739            sage: a.find_root(0,0.002)
    67216740            0.0004110514049349...
    6722        
    6723         Using solve takes more effort, and even then gives 
     6741
     6742        Using solve takes more effort, and even then gives
    67246743        only a solution with free (integer) variables::
    67256744
    67266745            sage: a.solve(t)
     
    67306749            sage: b.solve(t)
    67316750            []
    67326751            sage: b.solve(t, to_poly_solve=True)
    6733             [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)]
     6752            [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)]
    67346753            sage: n(1/900*log(-3/4*sqrt(41) + 25/4))
    67356754            0.000411051404934985
    67366755
    67376756        We illustrate that root finding is only implemented in one
    67386757        dimension::
    6739        
     6758
    67406759            sage: x, y = var('x,y')
    67416760            sage: (x-y).find_root(-2,2)
    67426761            Traceback (most recent call last):
    67436762            ...
    67446763            NotImplementedError: root finding currently only implemented in 1 dimension.
    6745        
    6746         TESTS:
    6747        
     6764
     6765        TESTS:
     6766
    67486767        Test the special case that failed for the first attempt to fix
    67496768        #3980::
    6750        
     6769
    67516770            sage: t = var('t')
    67526771            sage: find_root(1/t - x,0,2)
    67536772            Traceback (most recent call last):
     
    67606779        if self.number_of_arguments() == 0:
    67616780            if bool(self == 0):
    67626781                return a
    6763             else: 
     6782            else:
    67646783                raise RuntimeError, "no zero in the interval, since constant expression is not 0."
    67656784        elif self.number_of_arguments() == 1:
    67666785            f = self._fast_float_(self.default_variable())
     
    67756794        Numerically find the maximum of the expression ``self``
    67766795        on the interval [a,b] (or [b,a]) along with the point at which the
    67776796        maximum is attained.
    6778        
     6797
    67796798        See the documentation for
    67806799        ``self.find_minimum_on_interval`` for more details.
    6781        
    6782         EXAMPLES::
    6783        
     6800
     6801        EXAMPLES::
     6802
    67846803            sage: f = x*cos(x)
    67856804            sage: f.find_maximum_on_interval(0,5)
    67866805            (0.5610963381910451, 0.8603335890...)
     
    67906809        minval, x = (-self).find_minimum_on_interval(a, b, var=var, tol=tol,
    67916810                                                     maxfun=maxfun)
    67926811        return -minval, x
    6793        
     6812
    67946813    def find_minimum_on_interval(self, a, b, var=None, tol=1.48e-08, maxfun=500):
    67956814        r"""
    67966815        Numerically find the minimum of the expression ``self``
    67976816        on the interval [a,b] (or [b,a]) and the point at which it attains
    67986817        that minimum. Note that ``self`` must be a function of
    67996818        (at most) one variable.
    6800        
    6801         INPUT:
    6802        
     6819
     6820        INPUT:
     6821
    68036822        -  ``var`` - variable (default: first variable in
    68046823           self)
    6805        
     6824
    68066825        -  ``a,b`` - endpoints of interval on which to minimize
    68076826           self.
    6808        
     6827
    68096828        -  ``tol`` - the convergence tolerance
    6810        
     6829
    68116830        -  ``maxfun`` - maximum function evaluations
    6812        
    6813        
    6814         OUTPUT:
    6815        
     6831
     6832
     6833        OUTPUT:
     6834
    68166835        - ``minval`` - (float) the minimum value that self takes on in the
    68176836          interval [a,b]
    6818        
     6837
    68196838        - ``x`` - (float) the point at which self takes on the minimum value
    6820        
    6821         EXAMPLES::
    6822        
     6839
     6840        EXAMPLES::
     6841
    68236842            sage: f = x*cos(x)
    68246843            sage: f.find_minimum_on_interval(1, 5)
    68256844            (-3.288371395590..., 3.4256184695...)
     
    68306849            sage: show(f.plot(0, 20))
    68316850            sage: f.find_minimum_on_interval(1, 15)
    68326851            (-9.477294259479..., 9.5293344109...)
    6833        
     6852
    68346853        ALGORITHM:
    68356854
    68366855        Uses ``scipy.optimize.fminbound`` which uses Brent's method.
    6837        
     6856
    68386857        AUTHORS:
    68396858
    68406859        - William Stein (2007-12-07)
     
    68536872        """
    68546873        Returns an object which provides fast floating point
    68556874        evaluation of this symbolic expression.
    6856        
     6875
    68576876        See :mod:`sage.ext.fast_eval` for more information.
    68586877
    68596878        EXAMPLES::
     
    68846903        """
    68856904        from sage.symbolic.expression_conversions import fast_callable
    68866905        return fast_callable(self, etb)
    6887    
     6906
    68886907    def show(self):
    68896908        """
    68906909        Show this symbolic expression, i.e., typeset it nicely.
    6891        
    6892         EXAMPLES::
    6893        
     6910
     6911        EXAMPLES::
     6912
    68946913            sage: (x^2 + 1).show()
    68956914            x^{2}  + 1
    68966915        """
     
    69006919    def plot(self, *args, **kwds):
    69016920        """
    69026921        Plot a symbolic expression. All arguments are passed onto the standard plot command.
    6903        
     6922
    69046923        EXAMPLES:
    69056924
    69066925        This displays a straight line::
    6907        
     6926
    69086927            sage: sin(2).plot((x,0,3))
    6909        
     6928
    69106929        This draws a red oscillatory curve::
    6911        
     6930
    69126931            sage: sin(x^2).plot((x,0,2*pi), rgbcolor=(1,0,0))
    6913        
     6932
    69146933        Another plot using the variable theta::
    6915        
     6934
    69166935            sage: var('theta')
    69176936            theta
    69186937            sage: (cos(theta) - erf(theta)).plot((theta,-2*pi,2*pi))
    6919        
     6938
    69206939        A very thick green plot with a frame::
    6921        
     6940
    69226941            sage: sin(x).plot((x,-4*pi, 4*pi), thickness=20, rgbcolor=(0,0.7,0)).show(frame=True)
    6923        
     6942
    69246943        You can embed 2d plots in 3d space as follows::
    6925        
     6944
    69266945            sage: plot(sin(x^2), (x,-pi, pi), thickness=2).plot3d(z = 1)
    6927        
     6946
    69286947        A more complicated family::
    6929        
     6948
    69306949            sage: G = sum([plot(sin(n*x), (x,-2*pi, 2*pi)).plot3d(z=n) for n in [0,0.1,..1]])
    69316950            sage: G.show(frame_aspect_ratio=[1,1,1/2])
    6932        
     6951
    69336952        A plot involving the floor function::
    6934        
     6953
    69356954            sage: plot(1.0 - x * floor(1/x), (x,0.00001,1.0))
    6936        
     6955
    69376956        Sage used to allow symbolic functions with "no arguments";
    69386957        this no longer works::
    6939        
     6958
    69406959            sage: plot(2*sin, -4, 4)
    69416960            Traceback (most recent call last):
    69426961            ...
    69436962            TypeError: unsupported operand parent(s) for '*': 'Integer Ring' and '<class 'sage.functions.trig.Function_sin'>'
    6944            
     6963
    69456964        You should evaluate the function first::
    69466965
    69476966            sage: plot(2*sin(x), -4, 4)
    6948        
    6949         TESTS::
    6950        
     6967
     6968        TESTS::
     6969
    69516970            sage: f(x) = x*(1 - x)
    69526971            sage: plot(f,0,1)
    69536972        """
     
    70277046            # of an interface so we just use the fast_callable function.
    70287047            return fast_callable(self, vars=vars)
    70297048
    7030     ############   
     7049    ############
    70317050    # Calculus #
    70327051    ############
    70337052    def sum(self, *args, **kwds):
     
    71957214        return nintegral(self, *args, **kwds)
    71967215
    71977216    nintegrate = nintegral
    7198    
     7217
    71997218    def minpoly(self, *args, **kwds):
    72007219        """
    72017220        Return the minimal polynomial of this symbolic expression.
    7202        
     7221
    72037222        EXAMPLES::
    72047223
    72057224            sage: golden_ratio.minpoly()
     
    73057324           is included for backward compatibility reasons only.
    73067325
    73077326        EXAMPLES::
    7308        
     7327
    73097328            sage: var('x,y'); f = x + 3 < y - 2
    73107329            (x, y)
    73117330            sage: f.multiply_both_sides(7)
     
    73207339        Since the direction of the inequality never changes when doing
    73217340        arithmetic with equations, you can multiply or divide the
    73227341        equation by a quantity with unknown sign::
    7323        
     7342
    73247343            sage: f*(1+I)
    73257344            (I + 1)*x + 3*I + 3 < (I + 1)*y - 2*I - 2
    73267345            sage: f = sqrt(2) + x == y^3
     
    73287347            I*x + I*sqrt(2) == I*y^3
    73297348            sage: f.multiply_both_sides(-1)
    73307349            -x - sqrt(2) == -y^3
    7331        
     7350
    73327351        Note that the direction of the following inequalities is
    73337352        not reversed::
    7334        
     7353
    73357354            sage: (x^3 + 1 > 2*sqrt(3)) * (-1)
    73367355            -x^3 - 1 > -2*sqrt(3)
    73377356            sage: (x^3 + 1 >= 2*sqrt(3)) * (-1)
    73387357            -x^3 - 1 >= -2*sqrt(3)
    73397358            sage: (x^3 + 1 <= 2*sqrt(3)) * (-1)
    7340             -x^3 - 1 <= -2*sqrt(3)       
     7359            -x^3 - 1 <= -2*sqrt(3)
    73417360        """
    73427361        if not is_a_relational(self._gobj):
    73437362            raise TypeError, "this expression must be a relation"
    73447363        return self * x
    7345    
     7364
    73467365    def divide_both_sides(self, x, checksign=None):
    73477366        """
    73487367        Returns a relation obtained by dividing both sides of this
     
    73627381            sage: eqn.divide_both_sides(theta)
    73637382            (x^3 + theta)/theta < sin(theta*x)/theta
    73647383            sage: eqn/theta
    7365             (x^3 + theta)/theta < sin(theta*x)/theta       
     7384            (x^3 + theta)/theta < sin(theta*x)/theta
    73667385        """
    73677386        if not is_a_relational(self._gobj):
    73687387            raise TypeError, "this expression must be a relation"
     
    73737392    # implemented using a lot from cln, and I had to mostly delete
    73747393    # their implementations.   They are pretty specialized for
    73757394    # physics apps, maybe.
    7376     # This doesn't work / isn't implemented yet / just segfaults. 
     7395    # This doesn't work / isn't implemented yet / just segfaults.
    73777396    #def Li(self, x):
    73787397    #    """
    73797398    #    """
     
    74237442        Return this iterator object itself.
    74247443
    74257444        EXAMPLES::
    7426        
     7445
    74277446            sage: x,y,z = var('x,y,z')
    74287447            sage: i = (x+y).iterator()
    74297448            sage: iter(i) is i
     
    74367455        Return the next component of the expression.
    74377456
    74387457        EXAMPLES::
    7439        
     7458
    74407459            sage: x,y,z = var('x,y,z')
    74417460            sage: i = (x+y).iterator()
    74427461            sage: i.next()
     
    74547473    Construct a new iterator over a symbolic expression.
    74557474
    74567475    EXAMPLES::
    7457    
     7476
    74587477        sage: x,y,z = var('x,y,z')
    74597478        sage: i = (x+y).iterator() #indirect doctest
    74607479    """
     
    74847503    elif lop == not_equal or rop == not_equal:
    74857504        raise TypeError, "incompatible relations"
    74867505    elif lop == equal:
    7487        return rop
     7506        return rop
    74887507    elif rop == equal:
    7489        return lop
     7508        return lop
    74907509    elif lop in [less, less_or_equal] and rop in [less, less_or_equal]:
    7491        return less
     7510        return less
    74927511    elif lop in [greater, greater_or_equal] and rop in [greater, greater_or_equal]:
    7493        return greater
     7512        return greater
    74947513    else:
    74957514        raise TypeError, "incompatible relations"