Ticket #9880: trac_9880-fix_doctests-be.rebased-5.5.rc0.patch

File trac_9880-fix_doctests-be.rebased-5.5.rc0.patch, 54.4 KB (added by burcin, 8 years ago)
  • sage/calculus/calculus.py

    # HG changeset patch
    # User Burcin Erocal <burcin@erocal.org>
    # Date 1322237282 -3600
    # Node ID f74c5d35564ec5cacafd9f1dfc1309218cd64c34
    # Parent  a2c98344304083277ed8b550baf9a74988f3fbdb
    [mq]: trac_9880-fix_doctests-be.patch
    
    diff --git a/sage/calculus/calculus.py b/sage/calculus/calculus.py
    a b  
    109109    [   (r, theta) |--> cos(theta) (r, theta) |--> -r*sin(theta)]
    110110    [   (r, theta) |--> sin(theta)  (r, theta) |--> r*cos(theta)]
    111111    sage: T.diff().det() # Jacobian
    112     (r, theta) |--> r*sin(theta)^2 + r*cos(theta)^2
     112    (r, theta) |--> r*cos(theta)^2 + r*sin(theta)^2
    113113
    114114When the order of variables is ambiguous, Sage will raise an
    115115exception when differentiating::
     
    206206::
    207207
    208208    sage: f(x,y) = log(x)*cos(y); f
    209     (x, y) |--> log(x)*cos(y)
     209    (x, y) |--> cos(y)*log(x)
    210210
    211211Then we have fixed an order of variables and there is no ambiguity
    212212substituting or evaluating::
     
    269269    sage: ComplexField(200)(sin(I))
    270270    1.1752011936438014568823818505956008151557179813340958702296*I
    271271    sage: f = sin(I) + cos(I/2); f
    272     sin(I) + cos(1/2*I)
     272    cos(1/2*I) + sin(I)
    273273    sage: CC(f)
    274274    1.12762596520638 + 1.17520119364380*I
    275275    sage: ComplexField(200)(f)
     
    370370Check that the problem with Taylor expansions of the gamma function
    371371(Trac #9217) is fixed::
    372372
    373     sage: taylor(gamma(1/3+x),x,0,3)      # random output - remove this in trac #9880
     373    sage: taylor(gamma(1/3+x),x,0,3)
    374374    -1/432*((36*(pi*sqrt(3) + 9*log(3))*euler_gamma^2 + 27*pi^2*log(3) + 72*euler_gamma^3 + 243*log(3)^3 + 18*(6*pi*sqrt(3)*log(3) + pi^2 + 27*log(3)^2 + 12*psi(1, 1/3))*euler_gamma + 324*psi(1, 1/3)*log(3) + (pi^3 + 9*(9*log(3)^2 + 4*psi(1, 1/3))*pi)*sqrt(3))*gamma(1/3) - 72*gamma(1/3)*psi(2, 1/3))*x^3 + 1/24*(6*pi*sqrt(3)*log(3) + 4*(pi*sqrt(3) + 9*log(3))*euler_gamma + pi^2 + 12*euler_gamma^2 + 27*log(3)^2 + 12*psi(1, 1/3))*x^2*gamma(1/3) - 1/6*(6*euler_gamma + pi*sqrt(3) + 9*log(3))*x*gamma(1/3) + gamma(1/3)
    375375    sage: map(lambda f:f[0].n(), _.coeffs())  # numerical coefficients to make comparison easier; Maple 12 gives same answer
    376376    [2.6789385347..., -8.3905259853..., 26.662447494..., -80.683148377...]
     
    379379
    380380    sage: k = var("k")
    381381    sage: sum(1/(1+k^2), k, -oo, oo)
    382     -1/2*I*psi(I + 1) - 1/2*I*psi(I) + 1/2*I*psi(-I) + 1/2*I*psi(-I + 1)
     382    -1/2*I*psi(I + 1) + 1/2*I*psi(-I + 1) - 1/2*I*psi(I) + 1/2*I*psi(-I)
    383383
    384384Ensure that ticket #8624 is fixed::
    385385
     
    487487    ::
    488488
    489489        sage: symbolic_sum(k * binomial(n, k), k, 1, n)
    490         n*2^(n - 1)
     490        2^(n - 1)*n
    491491
    492492    ::
    493493
     
    16861686    Trac #8459 fixed::
    16871687
    16881688        sage: maxima('3*li[2](u)+8*li[33](exp(u))').sage()
    1689         3*polylog(2, u) + 8*polylog(33, e^u)
     1689        8*polylog(33, e^u) + 3*polylog(2, u)
    16901690
    16911691    Check if #8345 is fixed::
    16921692
  • sage/calculus/desolvers.py

    diff --git a/sage/calculus/desolvers.py b/sage/calculus/desolvers.py
    a b  
    140140        sage: y = function('y', x)
    141141        sage: de = diff(y,x,2) - y == x
    142142        sage: desolve(de, y)
    143         k1*e^x + k2*e^(-x) - x
     143        k2*e^(-x) + k1*e^x - x
    144144       
    145145
    146146    ::
    147147
    148148        sage: f = desolve(de, y, [10,2,1]); f
    149         -x + 5*e^(-x + 10) + 7*e^(x - 10)
     149        -x + 7*e^(x - 10) + 5*e^(-x + 10)
    150150
    151151    ::
    152152
     
    162162
    163163        sage: de = diff(y,x,2) + y == 0
    164164        sage: desolve(de, y)
    165         k1*sin(x) + k2*cos(x)
     165        k2*cos(x) + k1*sin(x)
    166166
    167167    ::
    168168
    169169        sage: desolve(de, y, [0,1,pi/2,4])
    170         4*sin(x) + cos(x)
     170        cos(x) + 4*sin(x)
    171171
    172172    ::
    173173
     
    219219    ::
    220220
    221221        sage: desolve(diff(y,x)*sin(y) == cos(x),y,[pi/2,1])
    222         -cos(y(x)) == sin(x) - cos(1) - 1
     222        -cos(y(x)) == -cos(1) + sin(x) - 1
    223223
    224224    Linear equation - Sage returns the expression on the right hand side only::
    225225
    226226        sage: desolve(diff(y,x)+(y) == cos(x),y)
    227         1/2*((sin(x) + cos(x))*e^x + 2*c)*e^(-x)
     227        1/2*((cos(x) + sin(x))*e^x + 2*c)*e^(-x)
    228228
    229229    ::
    230230
    231231        sage: desolve(diff(y,x)+(y) == cos(x),y,show_method=True)
    232         [1/2*((sin(x) + cos(x))*e^x + 2*c)*e^(-x), 'linear']
     232        [1/2*((cos(x) + sin(x))*e^x + 2*c)*e^(-x), 'linear']
    233233
    234234    ::
    235235
    236236        sage: desolve(diff(y,x)+(y) == cos(x),y,[0,1])
    237         1/2*(e^x*sin(x) + e^x*cos(x) + 1)*e^(-x)
     237        1/2*(cos(x)*e^x + e^x*sin(x) + 1)*e^(-x)
    238238
    239239    This ODE with separated variables is solved as
    240240    exact. Explanation - factor does not split `e^{x-y}` in Maxima
     
    312312    ::
    313313       
    314314        sage: desolve(diff(y,x,2)+2*diff(y,x)+y == cos(x),y,[0,3,pi/2,2])
    315         3*((e^(1/2*pi) - 2)*x/pi + 1)*e^(-x) + 1/2*sin(x)
     315        3*(x*(e^(1/2*pi) - 2)/pi + 1)*e^(-x) + 1/2*sin(x)
    316316       
    317317    ::
    318318       
    319319        sage: desolve(diff(y,x,2)+2*diff(y,x)+y == cos(x),y,[0,3,pi/2,2],show_method=True)
    320         [3*((e^(1/2*pi) - 2)*x/pi + 1)*e^(-x) + 1/2*sin(x), 'variationofparameters']
     320        [3*(x*(e^(1/2*pi) - 2)/pi + 1)*e^(-x) + 1/2*sin(x), 'variationofparameters']
    321321       
    322322    ::
    323323       
     
    342342    ::
    343343       
    344344        sage: desolve(diff(y,x,2)+2*diff(y,x)+y == 0,y,[0,3,pi/2,2])
    345         (2*(2*e^(1/2*pi) - 3)*x/pi + 3)*e^(-x)
     345        (2*x*(2*e^(1/2*pi) - 3)/pi + 3)*e^(-x)
    346346       
    347347    ::
    348348       
    349349        sage: desolve(diff(y,x,2)+2*diff(y,x)+y == 0,y,[0,3,pi/2,2],show_method=True)
    350         [(2*(2*e^(1/2*pi) - 3)*x/pi + 3)*e^(-x), 'constcoeff']
     350        [(2*x*(2*e^(1/2*pi) - 3)/pi + 3)*e^(-x), 'constcoeff']
    351351       
    352352    TESTS:
    353353   
     
    702702        sage: de2 = diff(y,t) - x + 1 == 0
    703703        sage: desolve_system([de1, de2], [x,y])
    704704        [x(t) == (x(0) - 1)*cos(t) - (y(0) - 1)*sin(t) + 1,
    705          y(t) == (x(0) - 1)*sin(t) + (y(0) - 1)*cos(t) + 1]
     705         y(t) == (y(0) - 1)*cos(t) + (x(0) - 1)*sin(t) + 1]
    706706         
    707707    Now we give some initial conditions::
    708708   
  • sage/calculus/functional.py

    diff --git a/sage/calculus/functional.py b/sage/calculus/functional.py
    a b  
    9393        (a, x)
    9494        sage: f = exp(sin(a - x^2))/x
    9595        sage: derivative(f, x)
    96         -2*e^(sin(-x^2 + a))*cos(-x^2 + a) - e^(sin(-x^2 + a))/x^2
     96        -2*cos(-x^2 + a)*e^(sin(-x^2 + a)) - e^(sin(-x^2 + a))/x^2
    9797        sage: derivative(f, a)
    98         e^(sin(-x^2 + a))*cos(-x^2 + a)/x
     98        cos(-x^2 + a)*e^(sin(-x^2 + a))/x
    9999   
    100100    Syntax for repeated differentiation::
    101101   
     
    167167    ::
    168168   
    169169        sage: integral(x/(x^3-1), x)
    170         1/3*sqrt(3)*arctan(1/3*(2*x + 1)*sqrt(3)) + 1/3*log(x - 1) - 1/6*log(x^2 + x + 1)
     170        1/3*sqrt(3)*arctan(1/3*sqrt(3)*(2*x + 1)) - 1/6*log(x^2 + x + 1) + 1/3*log(x - 1)
    171171   
    172172    ::
    173173   
     
    214214    Note, however, that::
    215215   
    216216        sage: integral( exp(-x^2)*ln(x), x, 0, oo)
    217         -1/4*(euler_gamma + 2*log(2))*sqrt(pi)
     217        -1/4*sqrt(pi)*(euler_gamma + 2*log(2))
    218218   
    219219    This definite integral is easy::
    220220   
     
    371371    Taylor polynomial in two variables::
    372372
    373373        sage: x,y=var('x y'); taylor(x*y^3,(x,1),(y,-1),4)
    374         (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
     374        (x - 1)*(y + 1)^3 - 3*(x - 1)*(y + 1)^2 + (y + 1)^3 + 3*(x - 1)*(y + 1) - 3*(y + 1)^2 - x + 3*y + 3
    375375    """
    376376    if not isinstance(f, Expression):
    377377        f = SR(f)
     
    382382    EXAMPLES::
    383383   
    384384        sage: a = (x-1)*(x^2 - 1); a
    385         (x - 1)*(x^2 - 1)
     385        (x^2 - 1)*(x - 1)
    386386        sage: expand(a)
    387387        x^3 - x^2 - x + 1
    388388   
  • sage/calculus/functions.py

    diff --git a/sage/calculus/functions.py b/sage/calculus/functions.py
    a b  
    5454    Two-by-two Wronskian of sin(x) and e^x::
    5555   
    5656        sage: wronskian(sin(x), e^x, x)
    57         e^x*sin(x) - e^x*cos(x)
     57        -cos(x)*e^x + e^x*sin(x)
    5858
    5959    Or don't put x last::
    6060   
    6161        sage: wronskian(x, sin(x), e^x)
    62         (e^x*sin(x) + e^x*cos(x))*x - 2*e^x*sin(x)
     62        (cos(x)*e^x + e^x*sin(x))*x - 2*e^x*sin(x)
    6363
    6464    Example where one of the functions is constant::
    6565   
  • sage/calculus/test_sympy.py

    diff --git a/sage/calculus/test_sympy.py b/sage/calculus/test_sympy.py
    a b  
    157157    sage: type(e)
    158158    <type 'sage.symbolic.expression.Expression'>
    159159    sage: e
    160     sin(y) + cos(x)
     160    cos(x) + sin(y)
    161161    sage: e = sage.all.cos(var("y")**3)**4+var("x")**2
    162162    sage: e = e._sympy_()
    163163    sage: e
  • sage/calculus/tests.py

    diff --git a/sage/calculus/tests.py b/sage/calculus/tests.py
    a b  
    2626::
    2727
    2828    sage: christoffel(3,3,2, [t,r,theta,phi], m)
    29     -sin(theta)*cos(theta)
     29    -cos(theta)*sin(theta)
    3030    sage: X = christoffel(1,1,1,[t,r,theta,phi],m)
    3131    sage: X
    32      1/2/((1/r - 1)*r^2)
     32    1/2/(r^2*(1/r - 1))
    3333    sage: X.rational_simplify()
    3434     -1/2/(r^2 - r)
    3535
     
    6868    sage: g(x) = cos(x) + x^3
    6969    sage: u = f(x+t) + g(x-t)
    7070    sage: u
    71     -(t - x)^3 + sin((t + x)^2) + cos(-t + x)
     71    -(t - x)^3 + cos(-t + x) + sin((t + x)^2)
    7272    sage: u.diff(t,2) - u.diff(x,2)
    7373    0
    7474
     
    9595    sage: derivative(arctan(x), x)
    9696    1/(x^2 + 1)
    9797    sage: derivative(x^n, x, 3)
    98     (n - 2)*(n - 1)*n*x^(n - 3)
     98    (n - 1)*(n - 2)*n*x^(n - 3)
    9999    sage: derivative( function('f')(x), x)
    100100    D[0](f)(x)   
    101101    sage: diff( 2*x*f(x^2), x)
    102102    4*x^2*D[0](f)(x^2) + 2*f(x^2)
    103103    sage: integrate( 1/(x^4 - a^4), x)
    104     1/4*log(-a + x)/a^3 - 1/4*log(a + x)/a^3 - 1/2*arctan(x/a)/a^3
     104    -1/2*arctan(x/a)/a^3 - 1/4*log(a + x)/a^3 + 1/4*log(-a + x)/a^3
    105105    sage: expand(integrate(log(1-x^2), x))
    106     x*log(-x^2 + 1) - 2*x - log(x - 1) + log(x + 1)
     106    x*log(-x^2 + 1) - 2*x + log(x + 1) - log(x - 1)
    107107    sage: integrate(log(1-x^2)/x, x)
    108     1/2*log(-x^2 + 1)*log(x^2) + 1/2*polylog(2, -x^2 + 1)
     108    1/2*log(x^2)*log(-x^2 + 1) + 1/2*polylog(2, -x^2 + 1)
    109109    sage: integrate(exp(1-x^2),x)
    110     1/2*sqrt(pi)*e*erf(x)
     110    1/2*sqrt(pi)*erf(x)*e
    111111    sage: integrate(sin(x^2),x)
    112     1/8*((I + 1)*sqrt(2)*erf((1/2*I + 1/2)*sqrt(2)*x) + (I - 1)*sqrt(2)*erf((1/2*I - 1/2)*sqrt(2)*x))*sqrt(pi)
     112    1/8*sqrt(pi)*((I + 1)*sqrt(2)*erf((1/2*I + 1/2)*sqrt(2)*x) + (I - 1)*sqrt(2)*erf((1/2*I - 1/2)*sqrt(2)*x))
    113113
    114114    sage: integrate((1-x^2)^n,x)
    115115    integrate((-x^2 + 1)^n, x)
    116116    sage: integrate(x^x,x)
    117117    integrate(x^x, x)
    118118    sage: integrate(1/(x^3+1),x)
    119     1/3*sqrt(3)*arctan(1/3*(2*x - 1)*sqrt(3)) + 1/3*log(x + 1) - 1/6*log(x^2 - x + 1)
     119    1/3*sqrt(3)*arctan(1/3*sqrt(3)*(2*x - 1)) - 1/6*log(x^2 - x + 1) + 1/3*log(x + 1)
    120120    sage: integrate(1/(x^3+1), x, 0, 1)
    121     1/9*pi*sqrt(3) + 1/3*log(2)
     121    1/9*sqrt(3)*pi + 1/3*log(2)
    122122
    123123::
    124124
     
    159159    sage: diff(sin(x), x, 3)
    160160    -cos(x)
    161161    sage: diff(x*sin(cos(x)), x)
    162     -x*sin(x)*cos(cos(x)) + sin(cos(x))
     162    -x*cos(cos(x))*sin(x) + sin(cos(x))
    163163    sage: diff(tan(x), x)
    164164    tan(x)^2 + 1
    165165    sage: f = function('f'); f
     
    190190::
    191191
    192192    sage: integrate( x/(x^3-1), x)
    193     1/3*sqrt(3)*arctan(1/3*(2*x + 1)*sqrt(3)) + 1/3*log(x - 1) - 1/6*log(x^2 + x + 1)
     193    1/3*sqrt(3)*arctan(1/3*sqrt(3)*(2*x + 1)) - 1/6*log(x^2 + x + 1) + 1/3*log(x - 1)
    194194    sage: integrate(exp(-x^2), x)
    195195    1/2*sqrt(pi)*erf(x)   
    196196    sage: integrate(exp(-x^2)*log(x), x)       # todo: maple can compute this exactly.
     
    208208    sage: function('f, g')
    209209    (f, g)
    210210    sage: diff(f(t)*g(t),t)
    211     f(t)*D[0](g)(t) + g(t)*D[0](f)(t)
     211    g(t)*D[0](f)(t) + f(t)*D[0](g)(t)
    212212    sage: diff(f(t)/g(t), t)
    213     -f(t)*D[0](g)(t)/g(t)^2 + D[0](f)(t)/g(t)
     213    D[0](f)(t)/g(t) - f(t)*D[0](g)(t)/g(t)^2
    214214    sage: diff(f(t) + g(t), t)
    215215    D[0](f)(t) + D[0](g)(t)   
    216216    sage: diff(c*f(t), t)
  • sage/calculus/var.pyx

    diff --git a/sage/calculus/var.pyx b/sage/calculus/var.pyx
    a b  
    220220    method to replace functions::
    221221   
    222222        sage: k.substitute_function(supersin, sin)
    223         2*sin(x)*cos(x)
     223        2*cos(x)*sin(x)
    224224    """
    225225    if len(args) > 0:
    226226        return function(s, **kwds)(*args)
     
    254254        ...
    255255        NameError: name 'x' is not defined
    256256        sage: expand((e + i)^2)
    257         2*I*e + e^2 - 1
     257        e^2 + 2*I*e - 1
    258258        sage: k
    259259        15       
    260260    """
  • sage/calculus/wester.py

    diff --git a/sage/calculus/wester.py b/sage/calculus/wester.py
    a b  
    2929
    3030    sage: # (YES) Evaluate  e^(Pi*Sqrt(163)) to 50 decimal digits
    3131    sage: a = e^(pi*sqrt(163)); a
    32     e^(pi*sqrt(163))
     32    e^(sqrt(163)*pi)
    3333    sage: print RealField(150)(a)
    3434    2.6253741264076874399999999999925007259719820e17
    3535
     
    156156
    157157    sage: # (YES) Factorize x^100-1.
    158158    sage: factor(x^100-1)
    159     (x - 1)*(x + 1)*(x^2 + 1)*(x^4 - x^3 + x^2 - x + 1)*(x^4 + x^3 + x^2 + x + 1)*(x^8 - x^6 + x^4 - x^2 + 1)*(x^20 - x^15 + x^10 - x^5 + 1)*(x^20 + x^15 + x^10 + x^5 + 1)*(x^40 - x^30 + x^20 - x^10 + 1)
     159    (x^40 - x^30 + x^20 - x^10 + 1)*(x^20 + x^15 + x^10 + x^5 + 1)*(x^20 - x^15 + x^10 - x^5 + 1)*(x^8 - x^6 + x^4 - x^2 + 1)*(x^4 + x^3 + x^2 + x + 1)*(x^4 - x^3 + x^2 - x + 1)*(x^2 + 1)*(x + 1)*(x - 1)
    160160    sage: # Also, algebraically
    161161    sage: x = polygen(QQ)
    162162    sage: factor(x^100 - 1)
     
    193193    sage: f = (x^2+2*x+3)/(x^3+4*x^2+5*x+2); f
    194194    (x^2 + 2*x + 3)/(x^3 + 4*x^2 + 5*x + 2)
    195195    sage: f.partial_fraction()
    196     -2/(x + 1) + 2/(x + 1)^2 + 3/(x + 2)
     196    3/(x + 2) - 2/(x + 1) + 2/(x + 1)^2
    197197
    198198::
    199199
     
    233233    sage: eqn = prod(x-i for i in range(1,5 +1)) < 0
    234234    sage: # but don't know how to solve
    235235    sage: eqn
    236     (x - 5)*(x - 4)*(x - 3)*(x - 2)*(x - 1) < 0
     236    (x - 1)*(x - 2)*(x - 3)*(x - 4)*(x - 5) < 0
    237237
    238238::
    239239
     
    287287
    288288    sage: # (YES) (2^(1/3) + 4^(1/3))^3 - 6*(2^(1/3) + 4^(1/3))-6 = 0
    289289    sage: a = (2^(1/3) + 4^(1/3))^3 - 6*(2^(1/3) + 4^(1/3)) - 6; a
    290     (2^(1/3) + 4^(1/3))^3 - 6*2^(1/3) - 6*4^(1/3) - 6
     290    (4^(1/3) + 2^(1/3))^3 - 6*4^(1/3) - 6*2^(1/3) - 6
    291291    sage: bool(a==0)
    292292    True
    293293    sage: abs(float(a)) < 1e-10
     
    339339    sage: assume(r>0)
    340340    sage: f = (4*r+4*sqrt(r)+1)^(sqrt(r)/(2*sqrt(r)+1))*(2*sqrt(r)+1)^(2*sqrt(r)+1)^(-1)-2*sqrt(r)-1
    341341    sage: f
    342     (2*sqrt(r) + 1)^(1/(2*sqrt(r) + 1))*(4*r + 4*sqrt(r) + 1)^(sqrt(r)/(2*sqrt(r) + 1)) - 2*sqrt(r) - 1
     342    (4*r + 4*sqrt(r) + 1)^(sqrt(r)/(2*sqrt(r) + 1))*(2*sqrt(r) + 1)^(1/(2*sqrt(r) + 1)) - 2*sqrt(r) - 1
    343343    sage: bool(f == 0)
    344344    False
    345345    sage: [abs(float(f(r=i))) < 1e-10 for i in [0.1,0.3,0.5]]
     
    362362    sage: a = tan(z); a
    363363    tan(z)
    364364    sage: a.real()
    365     tan(real_part(z))/(tan(real_part(z))^2*tan(imag_part(z))^2 + 1)
     365    tan(real_part(z))/(tan(imag_part(z))^2*tan(real_part(z))^2 + 1)
    366366    sage: a.imag()
    367     tanh(imag_part(z))/(tan(real_part(z))^2*tan(imag_part(z))^2 + 1)
     367    tanh(imag_part(z))/(tan(imag_part(z))^2*tan(real_part(z))^2 + 1)
    368368
    369369
    370370::
     
    455455    [  1   d d^2 d^3]
    456456    sage: d = m.determinant()
    457457    sage: d.factor()
    458     (c - d)*(b - d)*(b - c)*(a - d)*(a - c)*(a - b)
     458    (a - b)*(a - c)*(a - d)*(b - c)*(b - d)*(c - d)
    459459
    460460::
    461461
     
    555555    sage: # (YES) Taylor expansion of Ln(x)^a*Exp(-b*x) at x=1.
    556556    sage: a,b = var('a,b')
    557557    sage: taylor(log(x)^a*exp(-b*x), x, 1, 3)
    558     -1/48*(x - 1)^3*((6*b + 5)*(x - 1)^a*a^2 + (x - 1)^a*a^3 + 8*(x - 1)^a*b^3 + 2*(6*b^2 + 5*b + 3)*(x - 1)^a*a)*e^(-b) + 1/24*(x - 1)^2*((12*b + 5)*(x - 1)^a*a + 3*(x - 1)^a*a^2 + 12*(x - 1)^a*b^2)*e^(-b) - 1/2*(x - 1)*((x - 1)^a*a + 2*(x - 1)^a*b)*e^(-b) + (x - 1)^a*e^(-b)
     558    -1/48*(a^3*(x - 1)^a + a^2*(6*b + 5)*(x - 1)^a + 8*b^3*(x - 1)^a + 2*(6*b^2 + 5*b + 3)*a*(x - 1)^a)*(x - 1)^3*e^(-b) + 1/24*(3*a^2*(x - 1)^a + a*(12*b + 5)*(x - 1)^a + 12*b^2*(x - 1)^a)*(x - 1)^2*e^(-b) - 1/2*(a*(x - 1)^a + 2*b*(x - 1)^a)*(x - 1)*e^(-b) + (x - 1)^a*e^(-b)
    559559   
    560560::
    561561
  • sage/functions/hyperbolic.py

    diff --git a/sage/functions/hyperbolic.py b/sage/functions/hyperbolic.py
    a b  
    9595        :meth:`sage.symbolic.expression.Expression.simplify`::
    9696
    9797            sage: sinh(arccosh(x),hold=True).simplify()
    98             sqrt(x - 1)*sqrt(x + 1)
     98            sqrt(x + 1)*sqrt(x - 1)
    9999
    100100        """
    101101        GinacFunction.__init__(self, "sinh", latex_name=r"\sinh")
     
    274274            sage: bool(diff(sech(x), x) == diff(1/cosh(x), x))
    275275            True
    276276            sage: diff(sech(x), x)
    277             -tanh(x)*sech(x)
     277            -sech(x)*tanh(x)
    278278        """
    279279        x = args[0]
    280280        return -sech(x)*tanh(x)
     
    666666        EXAMPLES::
    667667       
    668668            sage: diff(acsch(x), x)
    669             -1/(sqrt(1/x^2 + 1)*x^2)
     669            -1/(x^2*sqrt(1/x^2 + 1))
    670670        """
    671671        x = args[0]
    672672        return -1/(x**2 * (1 + x**(-2)).sqrt())
  • sage/functions/orthogonal_polys.py

    diff --git a/sage/functions/orthogonal_polys.py b/sage/functions/orthogonal_polys.py
    a b  
    433433        sage: gen_legendre_P(2, 0, t) == legendre_P(2, t)
    434434        True
    435435        sage: gen_legendre_P(3, 1, t)
    436         -3/2*sqrt(-t^2 + 1)*(5*t^2 - 1)
     436        -3/2*(5*t^2 - 1)*sqrt(-t^2 + 1)
    437437        sage: gen_legendre_P(4, 3, t)
    438         105*sqrt(-t^2 + 1)*(t^2 - 1)*t
     438        105*(t^2 - 1)*sqrt(-t^2 + 1)*t
    439439        sage: gen_legendre_P(7, 3, I).expand()
    440440        -16695*sqrt(2)
    441441        sage: gen_legendre_P(4, 1, 2.5)
  • sage/functions/other.py

    diff --git a/sage/functions/other.py b/sage/functions/other.py
    a b  
    927927            sage: gamma_inc(2,0)
    928928            1
    929929            sage: gamma_inc(1/2,2)
    930             -(erf(sqrt(2)) - 1)*sqrt(pi)
     930            -sqrt(pi)*(erf(sqrt(2)) - 1)
    931931            sage: gamma_inc(1/2,1)
    932             -(erf(1) - 1)*sqrt(pi)
     932            -sqrt(pi)*(erf(1) - 1)
    933933            sage: gamma_inc(1/2,0)
    934934            sqrt(pi)
    935935            sage: gamma_inc(x,0)
     
    20082008            sage: var('a')
    20092009            a
    20102010            sage: conjugate(a*sqrt(-2)*sqrt(-3))
    2011             conjugate(a)*conjugate(sqrt(-3))*conjugate(sqrt(-2))
     2011            conjugate(sqrt(-2))*conjugate(sqrt(-3))*conjugate(a)
    20122012
    20132013        Test pickling::
    20142014
  • sage/functions/piecewise.py

    diff --git a/sage/functions/piecewise.py b/sage/functions/piecewise.py
    a b  
    11301130            sage: f(x) = x^2
    11311131            sage: f = Piecewise([[(-1,1),f]])
    11321132            sage: f._fourier_series_helper(3, 1, lambda n: 1)
    1133             -4*cos(pi*x)/pi^2 + cos(2*pi*x)/pi^2 + 1/3
     1133            cos(2*pi*x)/pi^2 - 4*cos(pi*x)/pi^2 + 1/3
    11341134        """
    11351135        from sage.all import pi, sin, cos, srange
    11361136        x = var('x')
     
    11571157            sage: f(x) = x^2
    11581158            sage: f = Piecewise([[(-1,1),f]])
    11591159            sage: f.fourier_series_partial_sum(3,1)
    1160             -4*cos(pi*x)/pi^2 + cos(2*pi*x)/pi^2 + 1/3
     1160            cos(2*pi*x)/pi^2 - 4*cos(pi*x)/pi^2 + 1/3
    11611161            sage: f1(x) = -1
    11621162            sage: f2(x) = 2
    11631163            sage: f = Piecewise([[(-pi,pi/2),f1],[(pi/2,pi),f2]])
    11641164            sage: f.fourier_series_partial_sum(3,pi)
    1165             -3*sin(2*x)/pi + 3*sin(x)/pi - 3*cos(x)/pi - 1/4
     1165            -3*cos(x)/pi - 3*sin(2*x)/pi + 3*sin(x)/pi - 1/4
    11661166        """
    11671167        return self._fourier_series_helper(N, L, lambda n: 1)
    11681168 
     
    11831183            sage: f(x) = x^2
    11841184            sage: f = Piecewise([[(-1,1),f]])
    11851185            sage: f.fourier_series_partial_sum_cesaro(3,1)
    1186             -8/3*cos(pi*x)/pi^2 + 1/3*cos(2*pi*x)/pi^2 + 1/3
     1186            1/3*cos(2*pi*x)/pi^2 - 8/3*cos(pi*x)/pi^2 + 1/3
    11871187            sage: f1(x) = -1
    11881188            sage: f2(x) = 2
    11891189            sage: f = Piecewise([[(-pi,pi/2),f1],[(pi/2,pi),f2]])
    11901190            sage: f.fourier_series_partial_sum_cesaro(3,pi)
    1191             -sin(2*x)/pi + 2*sin(x)/pi - 2*cos(x)/pi - 1/4
     1191            -2*cos(x)/pi - sin(2*x)/pi + 2*sin(x)/pi - 1/4
    11921192        """
    11931193        return self._fourier_series_helper(N, L, lambda n: 1-n/N)
    11941194
     
    12091209            sage: f(x) = x^2
    12101210            sage: f = Piecewise([[(-1,1),f]])
    12111211            sage: f.fourier_series_partial_sum_hann(3,1)
    1212             -3*cos(pi*x)/pi^2 + 1/4*cos(2*pi*x)/pi^2 + 1/3
     1212            1/4*cos(2*pi*x)/pi^2 - 3*cos(pi*x)/pi^2 + 1/3
    12131213            sage: f1(x) = -1
    12141214            sage: f2(x) = 2
    12151215            sage: f = Piecewise([[(-pi,pi/2),f1],[(pi/2,pi),f2]])
    12161216            sage: f.fourier_series_partial_sum_hann(3,pi)
    1217             -3/4*sin(2*x)/pi + 9/4*sin(x)/pi - 9/4*cos(x)/pi - 1/4
     1217            -9/4*cos(x)/pi - 3/4*sin(2*x)/pi + 9/4*sin(x)/pi - 1/4
    12181218        """
    12191219        from sage.all import cos, pi
    12201220        return self._fourier_series_helper(N, L, lambda n: (1+cos(pi*n/N))/2)
     
    12361236            sage: f(x) = x^2
    12371237            sage: f = Piecewise([[(-1,1),f]])
    12381238            sage: f.fourier_series_partial_sum_filtered(3,1,[1,1,1])
    1239             -4*cos(pi*x)/pi^2 + cos(2*pi*x)/pi^2 + 1/3
     1239            cos(2*pi*x)/pi^2 - 4*cos(pi*x)/pi^2 + 1/3
    12401240            sage: f1(x) = -1
    12411241            sage: f2(x) = 2
    12421242            sage: f = Piecewise([[(-pi,pi/2),f1],[(pi/2,pi),f2]])
    12431243            sage: f.fourier_series_partial_sum_filtered(3,pi,[1,1,1])
    1244             -3*sin(2*x)/pi + 3*sin(x)/pi - 3*cos(x)/pi - 1/4
     1244            -3*cos(x)/pi - 3*sin(2*x)/pi + 3*sin(x)/pi - 1/4
    12451245        """
    12461246        return self._fourier_series_helper(N, L, lambda n: F[n])
    12471247       
     
    15481548            sage: x, s, w = var('x, s, w')
    15491549            sage: f = Piecewise([[(0,1),1],[(1,2), 1-x]])
    15501550            sage: f.laplace(x, s)
    1551             (s + 1)*e^(-2*s)/s^2 - e^(-s)/s + 1/s - e^(-s)/s^2
     1551            -e^(-s)/s + (s + 1)*e^(-2*s)/s^2 + 1/s - e^(-s)/s^2
    15521552            sage: f.laplace(x, w)
    1553             (w + 1)*e^(-2*w)/w^2 - e^(-w)/w + 1/w - e^(-w)/w^2
     1553            -e^(-w)/w + (w + 1)*e^(-2*w)/w^2 + 1/w - e^(-w)/w^2
    15541554           
    15551555        ::
    15561556       
  • sage/functions/special.py

    diff --git a/sage/functions/special.py b/sage/functions/special.py
    a b  
    584584                sage: n(bessel_J(3,10,"maxima"))
    585585                0.0583793793051...
    586586                sage: spherical_hankel2(2,x)
    587                 (-I*x^2 - 3*x + 3*I)*e^(-I*x)/x^3
     587                -(I*x^2 + 3*x - 3*I)*e^(-I*x)/x^3
    588588            """
    589589            MaximaFunction.__init__(self, name)
    590590
     
    13381338    EXAMPLES::
    13391339   
    13401340        sage: spherical_hankel2(2, x)
    1341         (-I*x^2 - 3*x + 3*I)*e^(-I*x)/x^3
     1341        -(I*x^2 + 3*x - 3*I)*e^(-I*x)/x^3
    13421342   
    13431343    Here I = sqrt(-1).
    13441344    """
  • sage/functions/trig.py

    diff --git a/sage/functions/trig.py b/sage/functions/trig.py
    a b  
    204204            sage: bool(diff(sec(x), x) == diff(1/cos(x), x))
    205205            True
    206206            sage: diff(sec(x), x)
    207             tan(x)*sec(x)
     207            sec(x)*tan(x)
    208208        """
    209209        return sec(x)*tan(x)
    210210       
     
    296296            sage: bool(diff(csc(x), x) == diff(1/sin(x), x))
    297297            True
    298298            sage: diff(csc(x), x)
    299             -csc(x)*cot(x)
     299            -cot(x)*csc(x)
    300300        """
    301301        return -csc(x)*cot(x)
    302302   
     
    687687        EXAMPLES::
    688688
    689689            sage: diff(acsc(x), x)
    690             -1/(sqrt(-1/x^2 + 1)*x^2)
     690            -1/(x^2*sqrt(-1/x^2 + 1))
    691691        """
    692692        return -1/(x**2 * (1 - x**(-2)).sqrt())
    693693
     
    750750        EXAMPLES::
    751751       
    752752            sage: diff(asec(x), x)
    753             1/(sqrt(-1/x^2 + 1)*x^2)
     753            1/(x^2*sqrt(-1/x^2 + 1))
    754754        """
    755755        return 1/(x**2 * (1 - x**(-2)).sqrt())
    756756   
  • sage/functions/wigner.py

    diff --git a/sage/functions/wigner.py b/sage/functions/wigner.py
    a b  
    243243        sage: clebsch_gordan(1.5,0.5,1, 1.5,-0.5,1)
    244244        1/2*sqrt(3)
    245245        sage: clebsch_gordan(3/2,1/2,1, -1/2,1/2,0)
    246         -sqrt(1/6)*sqrt(3)
     246        -sqrt(3)*sqrt(1/6)
    247247
    248248    NOTES:
    249249
  • sage/misc/functional.py

    diff --git a/sage/misc/functional.py b/sage/misc/functional.py
    a b  
    578578    ::
    579579
    580580        sage: sum(k * binomial(n, k), k, 1, n)
    581         n*2^(n - 1)
     581        2^(n - 1)*n
    582582
    583583    ::
    584584
     
    707707        sage: integral(sin(x)^2, x, algorithm='maxima')
    708708        1/2*x - 1/4*sin(2*x)
    709709        sage: integral(sin(x)^2, x, algorithm='sympy')
    710         -1/2*sin(x)*cos(x) + 1/2*x
     710        -1/2*cos(x)*sin(x) + 1/2*x
    711711
    712712    TESTS:
    713713
  • sage/rings/qqbar.py

    diff --git a/sage/rings/qqbar.py b/sage/rings/qqbar.py
    a b  
    619619
    620620            sage: x = polygen(SR)
    621621            sage: p = (x - sqrt(-5)) * (x - sqrt(3)); p
    622             x^2 + (-sqrt(-5) - sqrt(3))*x + sqrt(-5)*sqrt(3)
     622            x^2 + (-sqrt(3) - sqrt(-5))*x + sqrt(3)*sqrt(-5)
    623623            sage: p = QQbar.common_polynomial(p)
    624624            sage: a = QQbar.polynomial_root(p, CIF(RIF(-0.1, 0.1), RIF(2, 3))); a
    625625            0.?e-18 + 2.236067977499790?*I
  • sage/symbolic/callable.py

    diff --git a/sage/symbolic/callable.py b/sage/symbolic/callable.py
    a b  
    1515    sage: f(x, y, z) = sin(x+y+z)
    1616    sage: g(w, t) = cos(w - t)
    1717    sage: f + g
    18     (t, w, x, y, z) |--> sin(x + y + z) + cos(-t + w)
     18    (t, w, x, y, z) |--> cos(-t + w) + sin(x + y + z)
    1919
    2020::
    2121
  • sage/symbolic/constants.py

    diff --git a/sage/symbolic/constants.py b/sage/symbolic/constants.py
    a b  
    130130    sage: f^2
    131131    (I*e + I)^2
    132132    sage: _.expand()
    133     -2*e - e^2 - 1
     133    -e^2 - 2*e - 1
    134134   
    135135::
    136136
     
    180180floating point rings::
    181181
    182182    sage: a = pi + e + golden_ratio + log2 + euler_gamma + catalan + khinchin + twinprime + mertens; a
    183     pi + euler_gamma + catalan + golden_ratio + log2 + khinchin + twinprime + mertens + e
     183    mertens + twinprime + khinchin + log2 + golden_ratio + catalan + euler_gamma + pi + e
    184184    sage: parent(a)
    185185    Symbolic Ring
    186186    sage: RR(a)
  • sage/symbolic/expression.pyx

    diff --git a/sage/symbolic/expression.pyx b/sage/symbolic/expression.pyx
    a b  
    7878    sage: var('a,b,c')
    7979    (a, b, c)
    8080    sage: expand((u + v + a + b + c)^2)
    81     a^2 + b^2 + 2*a*b + c^2 + 2*a*c + 2*b*c + u^2 + 2*a*u + 2*b*u + 2*c*u + v^2 + 2*a*v + 2*b*v + 2*c*v + 2*u*v
     81    a^2 + 2*a*b + b^2 + 2*a*c + 2*b*c + c^2 + 2*a*u + 2*b*u + 2*c*u + u^2 + 2*a*v + 2*b*v + 2*c*v + 2*u*v + v^2
    8282
    8383TESTS:
    8484
     
    120120    sage: a.real_part()
    121121    4*sqrt(3)/(sqrt(3) + 5)
    122122    sage: a.imag_part()
    123     sqrt(abs(4*(sqrt(3) - 5)*(sqrt(3) + 5) + 48))/(sqrt(3) + 5)
     123    sqrt(abs(4*(sqrt(3) + 5)*(sqrt(3) - 5) + 48))/(sqrt(3) + 5)
    124124"""
    125125
    126126###############################################################################
     
    691691            sage: latex((x+2)/(x^3+1))
    692692            \frac{x + 2}{x^{3} + 1}
    693693            sage: latex((x+2)*(x+1)/(x^3+1))
    694             \frac{{\left(x + 1\right)} {\left(x + 2\right)}}{x^{3} + 1}
     694            \frac{{\left(x + 2\right)} {\left(x + 1\right)}}{x^{3} + 1}
    695695            sage: latex((x+2)/(x^3+1)/(x+1))
    696696            \frac{x + 2}{{\left(x^{3} + 1\right)} {\left(x + 1\right)}}
    697697
     
    25462546
    25472547            # check if comparison of constant terms in Pynac add objects work
    25482548            sage: (y-1)*(y-2)
    2549             (y - 2)*(y - 1)
     2549            (y - 1)*(y - 2)
    25502550
    25512551        Check if Pynac can compute inverses of Python longs (:trac:`13107`)::
    25522552
     
    28412841       
    28422842            sage: x,y = var('x,y')
    28432843            sage: x.__cmp__(y)
    2844             -1
     2844            1
    28452845            sage: x < y
    28462846            x < y
    28472847            sage: cmp(x,y)
    2848             -1
     2848            1
    28492849            sage: cmp(SR(0.5), SR(0.7))
    28502850            -1
    28512851            sage: SR(0.5) < SR(0.7)
     
    28782878            sage: a = sqrt(3)
    28792879            sage: b = x^2+1
    28802880            sage: a.__cmp__(b)   # indirect doctest
    2881             1
     2881            -1
    28822882        """
    28832883        return print_order_compare(left._gobj, (<Expression>right)._gobj)
    28842884
     
    31123112       
    31133113            sage: h = sin(x)/cos(x)
    31143114            sage: derivative(h,x,x,x)
    3115             6*sin(x)^4/cos(x)^4 + 8*sin(x)^2/cos(x)^2 + 2
     3115            8*sin(x)^2/cos(x)^2 + 6*sin(x)^4/cos(x)^4 + 2
    31163116            sage: derivative(h,x,3)
    3117             6*sin(x)^4/cos(x)^4 + 8*sin(x)^2/cos(x)^2 + 2
     3117            8*sin(x)^2/cos(x)^2 + 6*sin(x)^4/cos(x)^4 + 2
    31183118
    31193119        ::
    31203120       
     
    33263326            sage: g = f.series(x==1, 4); g
    33273327            (-sin(y) - 1) + (-2*sin(y) - 2)*(x - 1) + (-sin(y) + 3)*(x - 1)^2 + 1*(x - 1)^3
    33283328            sage: h = g.truncate(); h
    3329             (x - 1)^3 - (x - 1)^2*(-sin(y) - 3) - 2*(x - 1)*(-2*sin(y) + 1) - sin(y) - 1
     3329            (x - 1)^3 - (x - 1)^2*(sin(y) - 3) - 2*(x - 1)*(sin(y) + 1) - sin(y) - 1
    33303330            sage: h.expand()
    33313331            x^3 - x^2*sin(y) - 5*x + 3
    33323332
     
    34263426        Check that ticket #7472 is fixed (Taylor polynomial in more variables)::
    34273427 
    34283428            sage: x,y=var('x y'); taylor(x*y^3,(x,1),(y,1),4)
    3429             (x - 1)*(y - 1)^3 + (y - 1)^3 + 3*(x - 1)*(y - 1)^2 + 3*(y - 1)^2 + 3*(x - 1)*(y - 1) + x + 3*y - 3
     3429            (x - 1)*(y - 1)^3 + 3*(x - 1)*(y - 1)^2 + (y - 1)^3 + 3*(x - 1)*(y - 1) + 3*(y - 1)^2 + x + 3*y - 3
    34303430            sage: expand(_)
    34313431            x*y^3
    34323432
     
    34943494            sage: x,y = var('x,y')
    34953495            sage: a = (x-y)^5
    34963496            sage: a.expand()
    3497             x^5 - y^5 + 5*x*y^4 - 10*x^2*y^3 + 10*x^3*y^2 - 5*x^4*y
     3497            x^5 - 5*x^4*y + 10*x^3*y^2 - 10*x^2*y^3 + 5*x*y^4 - y^5
    34983498            sage: expand(a)
    3499             x^5 - y^5 + 5*x*y^4 - 10*x^2*y^3 + 10*x^3*y^2 - 5*x^4*y
     3499            x^5 - 5*x^4*y + 10*x^3*y^2 - 10*x^2*y^3 + 5*x*y^4 - y^5
    35003500           
    35013501        We expand some other expressions::
    35023502       
    35033503            sage: expand((x-1)^3/(y-1))
    35043504            x^3/(y - 1) - 3*x^2/(y - 1) + 3*x/(y - 1) - 1/(y - 1)
    35053505            sage: expand((x+sin((x+y)^2))^2)
    3506             x^2 + sin((x + y)^2)^2 + 2*x*sin((x + y)^2)
     3506            x^2 + 2*x*sin((x + y)^2) + sin((x + y)^2)^2
    35073507
    35083508        We can expand individual sides of a relation::
    35093509
     
    35203520            sage: var('x,y')
    35213521            (x, y)
    35223522            sage: ((x + (2/3)*y)^3).expand()
    3523             x^3 + 8/27*y^3 + 4/3*x*y^2 + 2*x^2*y
     3523            x^3 + 2*x^2*y + 4/3*x*y^2 + 8/27*y^3
    35243524            sage: expand( (x*sin(x) - cos(y)/x)^2 )
    35253525            x^2*sin(x)^2 - 2*cos(y)*sin(x) + cos(y)^2/x^2
    35263526            sage: f = (x-y)*(x+y); f
    3527             (x - y)*(x + y)
     3527            (x + y)*(x - y)
    35283528            sage: f.expand()
    35293529            x^2 - y^2
    35303530        """
     
    35813581        EXAMPLES::
    35823582       
    35833583            sage: sin(5*x).expand_trig()
    3584             sin(x)^5 - 10*cos(x)^2*sin(x)^3 + 5*cos(x)^4*sin(x)
     3584            5*cos(x)^4*sin(x) - 10*cos(x)^2*sin(x)^3 + sin(x)^5
    35853585            sage: cos(2*x + var('y')).expand_trig()
    35863586            cos(2*x)*cos(y) - sin(2*x)*sin(y)
    35873587       
     
    35893589       
    35903590            sage: f = sin(sin(3*cos(2*x))*x)
    35913591            sage: f.expand_trig()
    3592             sin(-(sin(cos(2*x))^3 - 3*cos(cos(2*x))^2*sin(cos(2*x)))*x)
     3592            sin((3*cos(cos(2*x))^2*sin(cos(2*x)) - sin(cos(2*x))^3)*x)
    35933593            sage: f.expand_trig(full=True)
    3594             sin(-((cos(sin(x)^2)*sin(cos(x)^2) - cos(cos(x)^2)*sin(sin(x)^2))^3 - 3*(cos(cos(x)^2)*cos(sin(x)^2) + sin(cos(x)^2)*sin(sin(x)^2))^2*(cos(sin(x)^2)*sin(cos(x)^2) - cos(cos(x)^2)*sin(sin(x)^2)))*x)
     3594            sin((3*(cos(cos(x)^2)*cos(sin(x)^2) + sin(cos(x)^2)*sin(sin(x)^2))^2*(cos(sin(x)^2)*sin(cos(x)^2) - cos(cos(x)^2)*sin(sin(x)^2)) - (cos(sin(x)^2)*sin(cos(x)^2) - cos(cos(x)^2)*sin(sin(x)^2))^3)*x)
    35953595            sage: sin(2*x).expand_trig(times=False)
    35963596            sin(2*x)
    35973597            sage: sin(2*x).expand_trig(times=True)
     
    36443644            sage: y=var('y')
    36453645            sage: f=sin(x)*cos(x)^3+sin(y)^2
    36463646            sage: f.reduce_trig()
    3647             -1/2*cos(2*y) + 1/4*sin(2*x) + 1/8*sin(4*x) + 1/2
     3647            -1/2*cos(2*y) + 1/8*sin(4*x) + 1/4*sin(2*x) + 1/2
    36483648
    36493649        To reduce only the expressions involving x we use optional parameter::
    36503650
    36513651            sage: f.reduce_trig(x)
    3652             sin(y)^2 + 1/4*sin(2*x) + 1/8*sin(4*x)
     3652            sin(y)^2 + 1/8*sin(4*x) + 1/4*sin(2*x)
    36533653
    36543654        ALIASES: :meth:`trig_reduce` and :meth:`reduce_trig` are the same
    36553655        """
     
    37083708            (c, b)
    37093709            sage: ((a+b)*(a+c)).match((w0+b)*(w0+c))
    37103710            {$0: a}
    3711             sage: print ((a+b)*(a+c)).match((w0+w1)*(w0+w2))
    3712             {$2: b, $0: a, $1: c}
     3711            sage: t = ((a+b)*(a+c)).match((w0+w1)*(w0+w2))
     3712            sage: t[w0], t[w1], t[w2]
     3713            (a, c, b)
     3714            sage: print ((a+b)*(a+c)).match((w0+w1)*(w1+w2))
     3715            None
    37133716            sage: t = (a*(x+y)+a*z+b).match(a*w0+w1)
    37143717            sage: t[w0], t[w1]
    3715             (z, a*(x + y) + b)
     3718            (x + y, a*z + b)
    37163719            sage: print (a+b+c+d+e+f).match(c)
    37173720            None
    37183721            sage: (a+b+c+d+e+f).has(c)
     
    37823785            sage: (1+x+x^2+x^3).find(x)
    37833786            [x]
    37843787            sage: (1+x+x^2+x^3).find(x^w0)
    3785             [x^3, x^2]
     3788            [x^2, x^3]
    37863789
    37873790            sage: (1+x+x^2+x^3).find(y)
    37883791            []
     
    37993802        while itr.is_not_equal(found.end()):
    38003803            res.append(new_Expression_from_GEx(self._parent, itr.obj()))
    38013804            itr.inc()
     3805        res.sort()
    38023806        return res
    38033807
    38043808    def has(self, pattern):
     
    46404644            sage: f
    46414645            (x, y) |--> x^n + y^n
    46424646            sage: f(2,3)
    4643             2^n + 3^n
     4647            3^n + 2^n
    46444648        """
    46454649        # we override type checking in CallableSymbolicExpressionRing,
    46464650        # since it checks for old SymbolicVariable's
     
    50035007            sage: bool(p.poly(a) == (x-a*sqrt(2))^2 + x + 1)
    50045008            True           
    50055009            sage: p.poly(x)
    5006             2*a^2 + x^2 - (-2*sqrt(2)*a - 1)*x + 1
     5010            2*a^2 - (2*sqrt(2)*a - 1)*x + x^2 + 1
    50075011        """
    50085012        from sage.symbolic.ring import SR
    50095013        f = self._maxima_()
     
    53615365            (x, y, z)
    53625366            sage: f = 4*x*y + x*z + 20*y^2 + 21*y*z + 4*z^2 + x^2*y^2*z^2
    53635367            sage: f.collect(x)
    5364             x^2*y^2*z^2 + 20*y^2 + x*(4*y + z) + 4*z^2 + 21*y*z
     5368            x^2*y^2*z^2 + x*(4*y + z) + 20*y^2 + 21*y*z + 4*z^2
    53655369            sage: f.collect(y)
    5366             (x^2*z^2 + 20)*y^2 + (4*x + 21*z)*y + 4*z^2 + x*z
     5370            (x^2*z^2 + 20)*y^2 + (4*x + 21*z)*y + x*z + 4*z^2
    53675371            sage: f.collect(z)
    5368             (x^2*y^2 + 4)*z^2 + 20*y^2 + 4*x*y + (x + 21*y)*z
     5372            (x^2*y^2 + 4)*z^2 + 4*x*y + 20*y^2 + (x + 21*y)*z
    53695373
    53705374        TESTS:
    53715375
     
    62626266        To prevent automatic evaluation use the ``hold`` argument::
    62636267
    62646268            sage: arccosh(x).sinh()
    6265             sqrt(x - 1)*sqrt(x + 1)
     6269            sqrt(x + 1)*sqrt(x - 1)
    62666270            sage: arccosh(x).sinh(hold=True)
    62676271            sinh(arccosh(x))
    62686272
     
    62716275            sage: sinh(arccosh(x),hold=True)
    62726276            sinh(arccosh(x))
    62736277            sage: sinh(arccosh(x))
    6274             sqrt(x - 1)*sqrt(x + 1)
     6278            sqrt(x + 1)*sqrt(x - 1)
    62756279
    62766280        To then evaluate again, we currently must use Maxima via
    62776281        :meth:`simplify`::
    62786282
    62796283            sage: a = arccosh(x).sinh(hold=True); a.simplify()
    6280             sqrt(x - 1)*sqrt(x + 1)
     6284            sqrt(x + 1)*sqrt(x - 1)
    62816285
    62826286        TESTS::
    62836287
     
    71717175            sage: f.numerator()
    71727176            sqrt(x) + sqrt(y) + sqrt(z)
    71737177            sage: f.denominator()
    7174             -sqrt(theta) + x^10 - y^10
     7178            x^10 - y^10 - sqrt(theta)
    71757179
    71767180            sage: f.numerator(normalize=False)
    7177             -(sqrt(x) + sqrt(y) + sqrt(z))
     7181            (sqrt(x) + sqrt(y) + sqrt(z))
    71787182            sage: f.denominator(normalize=False)
    7179             sqrt(theta) - x^10 + y^10
     7183            x^10 - y^10 - sqrt(theta)
    71807184
    71817185            sage: y = var('y')
    71827186            sage: g = x + y/(x + 2); g
     
    73847388        EXAMPLES::
    73857389
    73867390            sage: t = log(sqrt(2) - 1) + log(sqrt(2) + 1); t
    7387             log(sqrt(2) - 1) + log(sqrt(2) + 1)
     7391            log(sqrt(2) + 1) + log(sqrt(2) - 1)
    73887392            sage: res = t.maxima_methods().logcontract(); res
    7389             log((sqrt(2) - 1)*(sqrt(2) + 1))
     7393            log((sqrt(2) + 1)*(sqrt(2) - 1))
    73907394            sage: type(res)
    73917395            <type 'sage.symbolic.expression.Expression'>
    73927396        """
     
    75897593
    75907594            sage: f=tan(3*x)
    75917595            sage: f.simplify_trig()
    7592             -(4*cos(x)^2 - 1)*sin(x)/(-4*cos(x)^3 + 3*cos(x))
     7596            (4*cos(x)^2 - 1)*sin(x)/(4*cos(x)^3 - 3*cos(x))
    75937597            sage: f.simplify_trig(False)           
    75947598            sin(3*x)/cos(3*x)
    75957599       
     
    76467650        ::
    76477651       
    76487652            sage: f = ((x - 1)^(3/2) - (x + 1)*sqrt(x - 1))/sqrt((x - 1)*(x + 1)); f
    7649             ((x - 1)^(3/2) - sqrt(x - 1)*(x + 1))/sqrt((x - 1)*(x + 1))
     7653            -((x + 1)*sqrt(x - 1) - (x - 1)^(3/2))/sqrt((x + 1)*(x - 1))
    76507654            sage: f.simplify_rational()
    7651             -2*sqrt(x - 1)/sqrt(x^2 - 1)
     7655            2*sqrt(x - 1)/sqrt(x^2 - 1)
    76527656
    76537657        With ``map=True`` each term in a sum is simplified separately
    76547658        and thus the resuls are shorter for functions which are
     
    76817685            sage: f.simplify_rational()
    76827686            (2*x^2 + 5*x + 4)/(x^3 + 5*x^2 + 8*x + 4)
    76837687            sage: f.simplify_rational(algorithm='noexpand')
    7684             ((x + 2)^2 + (x + 1)*x)/((x + 1)*(x + 2)^2)
     7688            ((x + 2)^2 + (x + 1)*x)/((x + 2)^2*(x + 1))
    76857689        """
    76867690        self_m = self._maxima_()
    76877691        if algorithm == 'full':
     
    77337737        ::
    77347738
    77357739            sage: f = binomial(n, k)*factorial(k)*factorial(n-k); f
    7736             binomial(n, k)*factorial(-k + n)*factorial(k)
     7740            binomial(n, k)*factorial(k)*factorial(-k + n)
    77377741            sage: f.simplify_factorial()
    77387742            factorial(n)
    77397743       
    77407744        A more complicated example, which needs further processing::
    77417745
    77427746            sage: f = factorial(x)/factorial(x-2)/2 + factorial(x+1)/factorial(x)/2; f
    7743             1/2*factorial(x)/factorial(x - 2) + 1/2*factorial(x + 1)/factorial(x)
     7747            1/2*factorial(x + 1)/factorial(x) + 1/2*factorial(x)/factorial(x - 2)
    77447748            sage: g = f.simplify_factorial(); g
    77457749            1/2*(x - 1)*x + 1/2*x + 1/2
    77467750            sage: g.simplify_rational()
     
    78277831            sage: e1 = 1/(sqrt(5)+sqrt(2))
    78287832            sage: e2 = (sqrt(5)-sqrt(2))/3
    78297833            sage: e1.simplify_radical()
    7830             1/(sqrt(2) + sqrt(5))
     7834            1/(sqrt(5) + sqrt(2))
    78317835            sage: e2.simplify_radical()
    7832             -1/3*sqrt(2) + 1/3*sqrt(5)
     7836            1/3*sqrt(5) - 1/3*sqrt(2)
    78337837            sage: (e1-e2).simplify_radical()
    78347838            0
    78357839        """
     
    79547958
    79557959            sage: log_expr = (log(sqrt(2)-1)+log(sqrt(2)+1))
    79567960            sage: log_expr.simplify_log('all')
    7957             log((sqrt(2) - 1)*(sqrt(2) + 1))
     7961            log((sqrt(2) + 1)*(sqrt(2) - 1))
    79587962            sage: _.simplify_rational()
    79597963            0
    79607964            sage: log_expr.simplify_full()   # applies both simplify_log and simplify_rational
     
    80368040        To expand also log(3/4) use ``algorithm='all'``::
    80378041
    80388042            sage: (log(3/4*x^pi)).log_expand('all')
    8039             pi*log(x) + log(3) - log(4)
     8043            pi*log(x) - log(4) + log(3)
    80408044
    80418045        To expand only the power use ``algorithm='powers'``.::
    80428046
     
    80598063            pi*log(x) + log(3/4)
    80608064
    80618065            sage: (log(3/4*x^pi)).log_expand('all')
    8062             pi*log(x) + log(3) - log(4)
     8066            pi*log(x) - log(4) + log(3)
    80638067
    80648068            sage: (log(3/4*x^pi)).log_expand()
    80658069            pi*log(x) + log(3/4)
     
    81108114       
    81118115            sage: x,y,z = var('x, y, z')
    81128116            sage: (x^3-y^3).factor()
    8113             (x^2 + y^2 + x*y)*(x - y)
     8117            (x^2 + x*y + y^2)*(x - y)
    81148118            sage: factor(-8*y - 4*x + z^2*(2*y + x))
    8115             (x + 2*y)*(z - 2)*(z + 2)
     8119            (x + 2*y)*(z + 2)*(z - 2)
    81168120            sage: f = -1 - 2*x - x^2 + y^2 + 2*x*y^2 + x^2*y^2
    81178121            sage: F = factor(f/(36*(1 + 2*y + y^2)), dontfactor=[x]); F
    81188122            1/36*(x^2 + 2*x + 1)*(y - 1)/(y + 1)
     
    81258129            sage: var('x,y')
    81268130            (x, y)
    81278131            sage: (x^99 + y^99).factor()
    8128             (x^60 + y^60 + x^3*y^57 - x^9*y^51 - x^12*y^48 + x^18*y^42
    8129             + x^21*y^39 - x^27*y^33 - x^30*y^30 - x^33*y^27 + x^39*y^21
    8130             + x^42*y^18 - x^48*y^12 - x^51*y^9 + x^57*y^3)*(x^20 + y^20
    8131             + x*y^19 - x^3*y^17 - x^4*y^16 + x^6*y^14 + x^7*y^13 - x^9*y^11
    8132             - x^10*y^10 - x^11*y^9 + x^13*y^7 + x^14*y^6 - x^16*y^4
    8133             - x^17*y^3 + x^19*y)*(x^10 + y^10 - x*y^9 + x^2*y^8 - x^3*y^7
    8134             + x^4*y^6 - x^5*y^5 + x^6*y^4 - x^7*y^3 + x^8*y^2 - x^9*y)*(x^6
    8135             + y^6 - x^3*y^3)*(x^2 + y^2 - x*y)*(x + y)
     8132            (x^60 + x^57*y^3 - x^51*y^9 - x^48*y^12 + x^42*y^18+ x^39*y^21
     8133            - x^33*y^27 - x^30*y^30 - x^27*y^33 + x^21*y^39+ x^18*y^42
     8134            - x^12*y^48 - x^9*y^51 + x^3*y^57 + y^60)*(x^20 + x^19*y
     8135            - x^17*y^3 - x^16*y^4 + x^14*y^6 + x^13*y^7 - x^11*y^9
     8136            - x^10*y^10 - x^9*y^11 + x^7*y^13 + x^6*y^14 - x^4*y^16
     8137            - x^3*y^17 + x*y^19 + y^20)*(x^10 - x^9*y + x^8*y^2 - x^7*y^3
     8138            + x^6*y^4 - x^5*y^5 + x^4*y^6 - x^3*y^7 + x^2*y^8 - x*y^9
     8139            + y^10)*(x^6 - x^3*y^3 + y^6)*(x^2 - x*y + y^2)*(x + y)
    81368140        """
    81378141        from sage.calculus.calculus import symbolic_expression_from_maxima_string, symbolic_expression_from_string
    81388142        if len(dontfactor) > 0:
     
    81738177            (x, y, z)
    81748178            sage: f = x^3-y^3
    81758179            sage: f.factor()
    8176             (x^2 + y^2 + x*y)*(x - y)
     8180            (x^2 + x*y + y^2)*(x - y)
    81778181       
    81788182        Notice that the -1 factor is separated out::
    81798183       
    81808184            sage: f.factor_list()
    8181             [(x^2 + y^2 + x*y, 1), (x - y, 1)]
     8185            [(x^2 + x*y + y^2, 1), (x - y, 1)]
    81828186       
    81838187        We factor a fairly straightforward expression::
    81848188       
    81858189            sage: factor(-8*y - 4*x + z^2*(2*y + x)).factor_list()
    8186             [(x + 2*y, 1), (z - 2, 1), (z + 2, 1)]
     8190            [(x + 2*y, 1), (z + 2, 1), (z - 2, 1)]
    81878191
    81888192        A more complicated example::
    81898193       
     
    81918195            (x, u, v)
    81928196            sage: f = expand((2*u*v^2-v^2-4*u^3)^2 * (-u)^3 * (x-sin(x))^3)
    81938197            sage: f.factor()
    8194             (-4*u^3 + 2*u*v^2 - v^2)^2*u^3*(-x + sin(x))^3
     8198            -(-4*u^3 + 2*u*v^2 - v^2)^2*u^3*(x - sin(x))^3
    81958199            sage: g = f.factor_list(); g                     
    8196             [(4*u^3 - 2*u*v^2 + v^2, 2), (u, 3), (x - sin(x), 3), (-1, 1)]
     8200            [(-4*u^3 + 2*u*v^2 - v^2, 2), (u, 3), (x - sin(x), 3), (-1, 1)]
    81978201
    81988202        This function also works for quotients::
    81998203       
     
    82038207            sage: g.factor(dontfactor=[x])
    82048208            1/36*(x^2 + 2*x + 1)*(y - 1)/(y + 1)
    82058209            sage: g.factor_list(dontfactor=[x])
    8206             [(x^2 + 2*x + 1, 1), (y - 1, 1), (y + 1, -1), (1/36, 1)]
     8210            [(x^2 + 2*x + 1, 1), (y + 1, -1), (y - 1, 1), (1/36, 1)]
    82078211                   
    82088212        This example also illustrates that the exponents do not have to be
    82098213        integers::
     
    83728376        A complicated example::
    83738377       
    83748378            sage: f = expand((x^2 - 1)^3*(x^2 + 1)*(x-a)); f
    8375             x^9 - a*x^8 - 2*x^7 + 2*a*x^6 + 2*x^3 - 2*a*x^2 + a - x
     8379            -a*x^8 + x^9 + 2*a*x^6 - 2*x^7 - 2*a*x^2 + 2*x^3 + a - x
    83768380       
    83778381        The default variable is `a`, since it is the first in
    83788382        alphabetical order::
     
    89198923            sage: a.solve(t)
    89208924            []
    89218925            sage: b = a.simplify_radical(); b
    8922             -23040*(25.0*e^(900*t) - 2.0*e^(1800*t) - 32.0)*e^(-2400*t)
     8926            23040*(2.0*e^(1800*t) - 25.0*e^(900*t) + 32.0)*e^(-2400*t)
    89238927            sage: b.solve(t)
    89248928            []
    89258929            sage: b.solve(t, to_poly_solve=True)
  • sage/symbolic/expression_conversions.py

    diff --git a/sage/symbolic/expression_conversions.py b/sage/symbolic/expression_conversions.py
    a b  
    232232            sage: c.get_fake_div(-x)
    233233            FakeExpression([x], <built-in function neg>)
    234234            sage: c.get_fake_div((2*x^3+2*x-1)/((x-2)*(x+1)))
    235             FakeExpression([2*x^3 + 2*x - 1, FakeExpression([x - 2, x + 1], <built-in function mul>)], <built-in function div>)
     235            FakeExpression([2*x^3 + 2*x - 1, FakeExpression([x + 1, x - 2], <built-in function mul>)], <built-in function div>)
    236236
    237237        Check if #8056 is fixed, i.e., if numerator is 1.::
    238238
     
    14251425
    14261426        sage: f = (2*x^3+2*x-1)/((x-2)*(x+1))
    14271427        sage: f._fast_callable_(etb)
    1428         div(add(add(mul(ipow(v_0, 3), 2), mul(v_0, 2)), -1), mul(add(v_0, -2), add(v_0, 1)))
     1428        div(add(add(mul(ipow(v_0, 3), 2), mul(v_0, 2)), -1), mul(add(v_0, 1), add(v_0, -2)))
    14291429
    14301430    """
    14311431    return FastCallableConverter(ex, etb)()
  • sage/symbolic/function.pyx

    diff --git a/sage/symbolic/function.pyx b/sage/symbolic/function.pyx
    a b  
    10401040        Test pickling expressions with symbolic functions::
    10411041           
    10421042            sage: u = loads(dumps(foo(x)^2 + foo(y) + x^y)); u
    1043             x^y + foo(x)^2 + foo(y)
     1043            foo(x)^2 + x^y + foo(y)
    10441044            sage: u.subs(y=0)
    10451045            foo(x)^2 + foo(0) + 1
    10461046            sage: u.subs(y=0).n()
  • sage/symbolic/function_factory.py

    diff --git a/sage/symbolic/function_factory.py b/sage/symbolic/function_factory.py
    a b  
    185185        -b*sin(a)
    186186
    187187        sage: g.substitute_function(cr, (sin(x) + cos(x)).function(x))
    188         -(sin(a) - cos(a))*b
     188        b*(cos(a) - sin(a))
    189189
    190190    In Sage 4.0, basic arithmetic with unevaluated functions is no
    191191    longer supported::
  • sage/symbolic/getitem.pyx

    diff --git a/sage/symbolic/getitem.pyx b/sage/symbolic/getitem.pyx
    a b  
    6464
    6565        sage: x,y,z = var('x,y,z')
    6666        sage: e = x + x*y + z^y + 3*y*z; e
    67         x*y + 3*y*z + z^y + x
     67        x*y + 3*y*z + x + z^y
    6868        sage: e.op[1]
    6969        3*y*z
    7070        sage: e.op[1,1]
    7171        z
    7272        sage: e.op[-1]
    73         x
     73        z^y
    7474        sage: e.op[1:]
    75         [3*y*z, z^y, x]
     75        [3*y*z, x, z^y]
    7676        sage: e.op[:2]
    7777        [x*y, 3*y*z]
    7878        sage: e.op[-2:]
    79         [z^y, x]
     79        [x, z^y]
    8080        sage: e.op[:-2]
    8181        [x*y, 3*y*z]
    8282        sage: e.op[-5]
  • sage/symbolic/integration/integral.py

    diff --git a/sage/symbolic/integration/integral.py b/sage/symbolic/integration/integral.py
    a b  
    456456                 x y  + Sqrt[--] FresnelS[Sqrt[--] x]
    457457                             2                 Pi
    458458        sage: print f.integral(x)
    459         y^z*x + 1/8*((I + 1)*sqrt(2)*erf((1/2*I + 1/2)*sqrt(2)*x) + (I - 1)*sqrt(2)*erf((1/2*I - 1/2)*sqrt(2)*x))*sqrt(pi)
     459        x*y^z + 1/8*sqrt(pi)*((I + 1)*sqrt(2)*erf((1/2*I + 1/2)*sqrt(2)*x) + (I - 1)*sqrt(2)*erf((1/2*I - 1/2)*sqrt(2)*x))
    460460
    461461    Alternatively, just use algorithm='mathematica_free' to integrate via Mathematica
    462462    over the internet (does NOT require a Mathematica license!)::
     
    489489    ::
    490490
    491491        sage: A = integral(1/ ((x-4) * (x^3+2*x+1)), x); A
    492         1/73*log(x - 4) - 1/73*integrate((x^2 + 4*x + 18)/(x^3 + 2*x + 1), x)
     492        -1/73*integrate((x^2 + 4*x + 18)/(x^3 + 2*x + 1), x) + 1/73*log(x - 4)
    493493
    494494    We now show that floats are not converted to rationals
    495495    automatically since we by default have keepfloat: true in maxima.
     
    519519
    520520        sage: assume(a>0)
    521521        sage: integrate(1/(x^3 *(a+b*x)^(1/3)), x)
    522         2/9*sqrt(3)*b^2*arctan(1/3*(2*(b*x + a)^(1/3) + a^(1/3))*sqrt(3)/a^(1/3))/a^(7/3) + 2/9*b^2*log((b*x + a)^(1/3) - a^(1/3))/a^(7/3) - 1/9*b^2*log((b*x + a)^(2/3) + (b*x + a)^(1/3)*a^(1/3) + a^(2/3))/a^(7/3) + 1/6*(4*(b*x + a)^(5/3)*b^2 - 7*(b*x + a)^(2/3)*a*b^2)/((b*x + a)^2*a^2 - 2*(b*x + a)*a^3 + a^4)
     522        2/9*sqrt(3)*b^2*arctan(1/3*sqrt(3)*(2*(b*x + a)^(1/3) + a^(1/3))/a^(1/3))/a^(7/3) - 1/9*b^2*log((b*x + a)^(2/3) + (b*x + a)^(1/3)*a^(1/3) + a^(2/3))/a^(7/3) + 2/9*b^2*log((b*x + a)^(1/3) - a^(1/3))/a^(7/3) + 1/6*(4*(b*x + a)^(5/3)*b^2 - 7*(b*x + a)^(2/3)*a*b^2)/((b*x + a)^2*a^2 - 2*(b*x + a)*a^3 + a^4)
    523523
    524524    TESTS:
    525525
     
    527527    see #3013::
    528528
    529529        sage: integrate(sin(x)*cos(10*x)*log(x), x)
    530         1/198*(11*cos(9*x) - 9*cos(11*x))*log(x) + 1/44*Ei(-11*I*x) + 1/44*Ei(11*I*x) - 1/36*Ei(-9*I*x) - 1/36*Ei(9*I*x)
     530        -1/198*(9*cos(11*x) - 11*cos(9*x))*log(x) + 1/44*Ei(11*I*x) - 1/36*Ei(9*I*x) - 1/36*Ei(-9*I*x) + 1/44*Ei(-11*I*x)
    531531
    532532    It is no longer possible to use certain functions without an
    533533    explicit variable.  Instead, evaluate the function at a variable,
     
    554554        Is  50015104*y^2-50015103  positive, negative, or zero?
    555555        sage: assume(y>1)
    556556        sage: res = integral(f,x,0.0001414, 1.); res
    557         2*y*arctan(1/y) - 2*y*arctan(0.0001414/y) - 0.0001414*log(y^2 + 1.999396e-08) + log(y^2 + 1.0) - 1.9997172
     557        -2*y*arctan(0.0001414/y) + 2*y*arctan(1/y) + log(y^2 + 1.0) - 0.0001414*log(y^2 + 1.999396e-08) - 1.9997172
    558558        sage: nres = numerical_integral(f.subs(y=2), 0.0001414, 1.); nres
    559559        (1.4638323264144..., 1.6251803529759...e-14)
    560560        sage: res.subs(y=2).n()
     
    604604        sage: integrate( ((F(x)-G(x))^2).expand(), x, -infinity, infinity).n()
    605605        -6.26376265908397e-17
    606606        sage: integrate( (F(x)-G(x))^2, x, -infinity, infinity).n()
    607         -6.26376265908397e-17
     607        0
    608608
    609609    This was broken before Maxima 5.20::
    610610
  • sage/symbolic/maxima_wrapper.py

    diff --git a/sage/symbolic/maxima_wrapper.py b/sage/symbolic/maxima_wrapper.py
    a b  
    1717        EXAMPLES::
    1818
    1919            sage: t = sin(x)^2 + cos(x)^2; t
    20             sin(x)^2 + cos(x)^2
     20            cos(x)^2 + sin(x)^2
    2121            sage: res = t.maxima_methods().trigsimp(); res
    2222            1
    2323            sage: type(res)
     
    3838        EXAMPLES::
    3939
    4040            sage: t = log(sqrt(2) - 1) + log(sqrt(2) + 1); t
    41             log(sqrt(2) - 1) + log(sqrt(2) + 1)
     41            log(sqrt(2) + 1) + log(sqrt(2) - 1)
    4242            sage: u = t.maxima_methods(); u
    43             MaximaWrapper(log(sqrt(2) - 1) + log(sqrt(2) + 1))
     43            MaximaWrapper(log(sqrt(2) + 1) + log(sqrt(2) - 1))
    4444            sage: type(u)
    4545            <class 'sage.symbolic.maxima_wrapper.MaximaWrapper'>
    4646            sage: u.logcontract()
    47             log((sqrt(2) - 1)*(sqrt(2) + 1))
     47            log((sqrt(2) + 1)*(sqrt(2) - 1))
    4848            sage: u.logcontract().parent()
    4949            Symbolic Ring
    5050
     
    7070        EXAMPLES::
    7171
    7272            sage: t = sin(x)^2 + cos(x)^2; t
    73             sin(x)^2 + cos(x)^2
     73            cos(x)^2 + sin(x)^2
    7474            sage: u = t.maxima_methods()
    7575            sage: import sagenb.misc.support as s
    7676            sage: s.completions('u.airy_',globals(),system='python')
     
    7878            sage: type(u.airy_ai)
    7979            <class 'sage.symbolic.maxima_wrapper.MaximaFunctionElementWrapper'>
    8080            sage: u.airy_ai()
    81             airy_ai(sin(x)^2 + cos(x)^2)
     81            airy_ai(cos(x)^2 + sin(x)^2)
    8282        """
    8383        if self._maxima_exp is None:
    8484            self._maxima_exp = self._exp._maxima_()
     
    9696        EXAMPLES::
    9797
    9898            sage: t = log(sqrt(2) - 1) + log(sqrt(2) + 1); t
    99             log(sqrt(2) - 1) + log(sqrt(2) + 1)
     99            log(sqrt(2) + 1) + log(sqrt(2) - 1)
    100100            sage: u = t.maxima_methods().sage()
    101101            sage: u is t
    102102            True
     
    108108        EXAMPLES::
    109109
    110110            sage: t = log(sqrt(2) - 1) + log(sqrt(2) + 1); t
    111             log(sqrt(2) - 1) + log(sqrt(2) + 1)
     111            log(sqrt(2) + 1) + log(sqrt(2) - 1)
    112112            sage: u = t.maxima_methods()
    113113            sage: SR(u) is t # indirect doctest
    114114            True
     
    120120        EXAMPLES::
    121121
    122122            sage: t = log(sqrt(2) - 1) + log(sqrt(2) + 1); t
    123             log(sqrt(2) - 1) + log(sqrt(2) + 1)
     123            log(sqrt(2) + 1) + log(sqrt(2) - 1)
    124124            sage: u = t.maxima_methods(); u
    125             MaximaWrapper(log(sqrt(2) - 1) + log(sqrt(2) + 1))
     125            MaximaWrapper(log(sqrt(2) + 1) + log(sqrt(2) - 1))
    126126            sage: loads(dumps(u))
    127             MaximaWrapper(log(sqrt(2) - 1) + log(sqrt(2) + 1))
     127            MaximaWrapper(log(sqrt(2) + 1) + log(sqrt(2) - 1))
    128128        """
    129129        return (MaximaWrapper, (self._exp,))
    130130
     
    133133        EXAMPLES::
    134134
    135135            sage: t = log(sqrt(2) - 1) + log(sqrt(2) + 1); t
    136             log(sqrt(2) - 1) + log(sqrt(2) + 1)
     136            log(sqrt(2) + 1) + log(sqrt(2) - 1)
    137137            sage: u = t.maxima_methods(); u
    138             MaximaWrapper(log(sqrt(2) - 1) + log(sqrt(2) + 1))
     138            MaximaWrapper(log(sqrt(2) + 1) + log(sqrt(2) - 1))
    139139            sage: u._repr_()
    140             'MaximaWrapper(log(sqrt(2) - 1) + log(sqrt(2) + 1))'
     140            'MaximaWrapper(log(sqrt(2) + 1) + log(sqrt(2) - 1))'
    141141        """
    142142        return "MaximaWrapper(%s)"%(self._exp)
  • sage/symbolic/relation.py

    diff --git a/sage/symbolic/relation.py b/sage/symbolic/relation.py
    a b  
    1010    a*x^2 + b*x + c == 0
    1111    sage: print solve(qe, x)
    1212    [
    13     x == -1/2*(b + sqrt(-4*a*c + b^2))/a,
    14     x == -1/2*(b - sqrt(-4*a*c + b^2))/a
     13    x == -1/2*(b + sqrt(b^2 - 4*a*c))/a,
     14    x == -1/2*(b - sqrt(b^2 - 4*a*c))/a
    1515    ]
    1616
    1717
     
    238238    sage: var('x,y,z,w')
    239239    (x, y, z, w)
    240240    sage: f =  (x+y+w) == (x^2 - y^2 - z^3);   f
    241     w + x + y == x^2 - y^2 - z^3
     241    w + x + y == -z^3 + x^2 - y^2
    242242    sage: f.variables()
    243243    (w, x, y, z)
    244244
     
    276276    x == y - 5
    277277    sage: h =  x^3 + sqrt(2) == x*y*sin(x)
    278278    sage: h
    279     sqrt(2) + x^3 == x*y*sin(x)
     279    x^3 + sqrt(2) == x*y*sin(x)
    280280    sage: h - sqrt(2)
    281281    x^3 == x*y*sin(x) - sqrt(2)
    282282    sage: h + f
    283     x + sqrt(2) + x^3 + 3 == x*y*sin(x) + y - 2
     283    x^3 + x + sqrt(2) + 3 == x*y*sin(x) + y - 2
    284284    sage: f = x + 3 < y - 2
    285285    sage: g = 2 < x+10
    286286    sage: f - g
     
    648648
    649649       sage: x,y=var('x y'); c1(x,y)=(x-5)^2+y^2-16; c2(x,y)=(y-3)^2+x^2-9
    650650       sage: solve([c1(x,y),c2(x,y)],[x,y])                               
    651        [[x == -9/68*sqrt(55) + 135/68, y == -15/68*sqrt(5)*sqrt(11) + 123/68], [x == 9/68*sqrt(55) + 135/68, y == 15/68*sqrt(5)*sqrt(11) + 123/68]]
     651       [[x == -9/68*sqrt(55) + 135/68, y == -15/68*sqrt(11)*sqrt(5) + 123/68], [x == 9/68*sqrt(55) + 135/68, y == 15/68*sqrt(11)*sqrt(5) + 123/68]]
    652652       
    653653    TESTS::
    654654
  • sage/symbolic/ring.pyx

    diff --git a/sage/symbolic/ring.pyx b/sage/symbolic/ring.pyx
    a b  
    318318            sage: x,y = var('x,y')
    319319            sage: w0 = SR.wild(0); w1 = SR.wild(1)
    320320            sage: pattern = sin(x)*w0*w1^2; pattern
    321             $0*$1^2*sin(x)
     321            $1^2*$0*sin(x)
    322322            sage: f = atan(sin(x)*3*x^2); f
    323323            arctan(3*x^2*sin(x))
    324324            sage: f.has(pattern)