sympy/core/tests/test_arit.py

   1 from sympy import Symbol, sin, cos, exp, O, sqrt, Rational, Real, re, pi, \
   2         sympify, sqrt, Add, Mul, Pow, I
   3 from sympy.utilities.pytest import XFAIL
   4
   5 x = Symbol("x")
   6 y = Symbol('y')
   7
   8 def test_bug1():
   9     assert re(x) != x
  10     x.series(x,0,1)
  11     assert re(x) != x
  12
  13 a = Symbol("a")
  14 b = Symbol("b", positive=True)
  15 c = Symbol("c")
  16
  17 def test_Symbol():
  18     e=a*b
  19     assert e==a*b
  20     assert a*b*b==a*b**2
  21     assert a*b*b+c==c+a*b**2
  22     assert a*b*b-c==-c+a*b**2
  23
  24 def test_arit0():
  25     p = Rational(5)
  26     e=a*b
  27     assert e == a*b
  28     e=a*b+b*a
  29     assert e == 2*a*b
  30     e=a*b+b*a+a*b+p*b*a
  31     assert e == 8*a*b
  32     e=a*b+b*a+a*b+p*b*a+a
  33     assert e == a+8*a*b
  34     e=a+a
  35     assert e == 2*a
  36     e=a+b+a
  37     assert e == b+2*a
  38     e=a+b*b+a+b*b
  39     assert e == 2*a+2*b**2
  40     e=a+Rational(2)+b*b+a+b*b+p
  41     assert e == 7+2*a+2*b**2
  42     e=(a+b*b+a+b*b)*p
  43     assert e == 5*(2*a+2*b**2)
  44     e=(a*b*c+c*b*a+b*a*c)*p
  45     assert e == 15*a*b*c
  46     e=(a*b*c+c*b*a+b*a*c)*p-Rational(15)*a*b*c
  47     assert e == Rational(0)
  48     e = Rational(50)*(a-a)
  49     assert e == Rational(0)
  50     e=b*a-b-a*b+b
  51     assert e == Rational(0)
  52     e=a*b+c**p
  53     assert e == a*b+c**5
  54     e=a/b
  55     assert e == a*b**(-1)
  56     e=a*2*2
  57     assert e == 4*a
  58     e=2+a*2/2
  59     assert e == 2+a
  60     e=2-a-2
  61     assert e == -a
  62     e=2*a*2
  63     assert e == 4*a
  64     e=2/a/2
  65     assert e == a**(-1)
  66     e=2**a**2
  67     assert e == 2**(a**2)
  68     e = -(1+a)
  69     assert e == -1 -a
  70     e = Rational(1,2)*(1+a)
  71     assert e == Rational(1,2) + a/2
  72
  73 def testdiv():
  74     e=a/b
  75     assert e == a*b**(-1)
  76     e=a/b+c/2
  77     assert e == a*b**(-1)+Rational(1)/2*c
  78     e=(1-b)/(b-1)
  79     assert e == (1+-b)*((-1)+b)**(-1)
  80
  81 def testpow():
  82     n1 = Rational(1)
  83     n2 = Rational(2)
  84     n5 = Rational(5)
  85     e=a*a
  86     assert e == a**2
  87     e=a*a*a
  88     assert e == a**3
  89     e=a*a*a*a**Rational(6)
  90     assert e == a**9
  91     e=a*a*a*a**Rational(6)-a**Rational(9)
  92     assert e == Rational(0)
  93     e=a**(b+c)*a**(-b)
  94     assert e == a**c
  95     e=a**(b+c)*a*a**(-b)*a**(-c)/a
  96     assert e == Rational(1)
  97     e=a**(b-b)
  98     assert e == Rational(1)
  99     e=(a-a)**b
 100     assert e == Rational(0)
 101     e=(a+Rational(1)-a)**b
 102     assert e == Rational(1)
 103
 104     e=(a+b+c)**n2
 105     assert e == (a+b+c)**2
 106     assert e.expand() == 2*b*c+2*a*c+2*a*b+a**2+c**2+b**2
 107
 108     e=(a+b)**n2
 109     assert e == (a+b)**2
 110     assert e.expand() == 2*a*b+a**2+b**2
 111
 112     e=(a+b)**(n1/n2)
 113     assert e == (a+b)**(Rational(1)/2)
 114     assert e.expand() == (a+b)**(Rational(1)/2)
 115
 116     n=n5**(n1/n2)
 117     assert n == Rational(5)**(Rational(1)/2)
 118     e=n*a*b-n*b*a
 119     assert e == Rational(0)
 120     e=n*a*b+n*b*a
 121     assert e == 2*a*b*5**(Rational(1)/2)
 122     assert e.diff(a) == 2*b*5**(Rational(1)/2)
 123     assert e.diff(a) == 2*b*5**(Rational(1)/2)
 124     e=a/b**2
 125     assert e == a*b**(-2)
 126
 127     assert sqrt(2*(1+sqrt(2))) == (2*(1+2**(Rational(1,2))))**(Rational(1,2))
 128
 129     x = Symbol('x')
 130     y = Symbol('y')
 131
 132     assert ((x*y)**3).expand() == y**3 * x**3
 133     assert ((x*y)**-3).expand() == y**-3 * x**-3
 134
 135     assert (x**5*(3*x)**(3)).expand() == 27 * x**8
 136     assert (x**5*(-3*x)**(3)).expand() == -27 * x**8
 137     assert (x**5*(3*x)**(-3)).expand() == Rational(1,27) * x**2
 138     assert (x**5*(-3*x)**(-3)).expand() == -Rational(1,27) * x**2
 139
 140     n = Symbol('k', even=False)
 141     k = Symbol('k', even=True)
 142
 143     assert (-1)**x == (-1)**x
 144     assert (-1)**n == (-1)**n
 145     assert (-2)**k == 2**k
 146     assert (-1)**k == 1
 147
 148 @XFAIL
 149 def test_pow2():
 150     # XXX These fail - they are maybe discutable,
 151     # let's see SAGE and similar.
 152     assert ((-x)**2)**Rational(1,3) == ((-x)**Rational(1,3))**2
 153     assert (-x)**Rational(2,3) == x**Rational(2,3)
 154     assert (-x)**Rational(5,7) == -x**Rational(5,7)
 155
 156 def test_pow_issue417():
 157     assert 4**Rational(1, 4) == 2**Rational(1, 2)
 158
 159 def test_pow3():
 160     assert 2**(Rational(3)/2) == 2 * 2**Rational(1, 2)
 161     assert 2**(Rational(3)/2) == sqrt(8)
 162
 163 def test_expand():
 164     p = Rational(5)
 165     e = (a+b)*c
 166     assert e == c*(a+b)
 167     assert (e.expand()-a*c-b*c) == Rational(0)
 168     e=(a+b)*(a+b)
 169     assert e == (a+b)**2
 170     assert e.expand() == 2*a*b+a**2+b**2
 171     e=(a+b)*(a+b)**Rational(2)
 172     assert e == (a+b)**3
 173     assert e.expand() == 3*b*a**2+3*a*b**2+a**3+b**3
 174     assert e.expand() == 3*b*a**2+3*a*b**2+a**3+b**3
 175     e=(a+b)*(a+c)*(b+c)
 176     assert e == (a+c)*(a+b)*(b+c)
 177     assert e.expand() == 2*a*b*c+b*a**2+c*a**2+b*c**2+a*c**2+c*b**2+a*b**2
 178     e=(a+Rational(1))**p
 179     assert e == (1+a)**5
 180     assert e.expand() == 1+5*a+10*a**2+10*a**3+5*a**4+a**5
 181     e=(a+b+c)*(a+c+p)
 182     assert e == (5+a+c)*(a+b+c)
 183     assert e.expand() == 5*a+5*b+5*c+2*a*c+b*c+a*b+a**2+c**2
 184     x=Symbol("x")
 185     s=exp(x*x)-1
 186     e=s.series(x,0,5)/x**2
 187     assert e.expand() ==  1+x**2/2+O(x**3)
 188
 189     # Check that this isn't too slow
 190     x = Symbol('x')
 191     W = 1
 192     for i in range(1, 21):
 193         W = W * (x-i)
 194     W = W.expand()
 195     assert W.has(-1672280820*x**15)
 196
 197
 198 def test_power_expand():
 199     """Test for Pow.expand()"""
 200     a = Symbol('a')
 201     b = Symbol('b')
 202     p = (a+b)**2
 203     assert p.expand() == a**2 + b**2 + 2*a*b
 204
 205     p = (1+2*(1+a))**2
 206     assert p.expand() == 9 + 4*(a**2) + 12*a
 207
 208 def test_real_mul():
 209     Real(0) * pi * x == Real(0)
 210     Real(1) * pi * x == pi * x
 211     len((Real(2) * pi * x).args) == 3
 212
 213 def test_ncmul():
 214     A = Symbol("A", commutative=False)
 215     B = Symbol("B", commutative=False)
 216     C = Symbol("C", commutative=False)
 217     assert A*B != B*A
 218     assert A*B*C != C*B*A
 219     assert A*b*B*3*C == 3*b*A*B*C
 220     assert A*b*B*3*C != 3*b*B*A*C
 221     assert A*b*B*3*C == 3*A*B*C*b
 222
 223     assert A+B == B+A
 224     assert (A+B)*C != C*(A+B)
 225
 226     assert C*(A+B)*C != C*C*(A+B)
 227
 228     assert (C*(A+B)).expand() == C*A+C*B
 229     assert (C*(A+B)).expand() != A*C+B*C
 230
 231     assert A*A == A**2
 232     assert (A+B)*(A+B) == (A+B)**2
 233     assert ((A+B)**2).expand() == A**2 + A*B + B*A +B**2
 234
 235     assert A**-1  * A == 1
 236     assert A/A == 1
 237     assert A/(A**2) == 1/A
 238
 239     assert A/(1+A) == A/(1+A)
 240
 241 def test_ncpow():
 242     x = Symbol('x', commutative=False)
 243     y = Symbol('y', commutative=False)
 244
 245     assert (x**2)*(y**2) != (y**2)*(x**2)
 246     assert (x**-2)*y != y*(x**2)
 247
 248 def test_powerbug():
 249     x=Symbol("x")
 250     assert x**1 != (-x)**1
 251     assert x**2 == (-x)**2
 252     assert x**3 != (-x)**3
 253     assert x**4 == (-x)**4
 254     assert x**5 != (-x)**5
 255     assert x**6 == (-x)**6
 256
 257     assert x**128 == (-x)**128
 258     assert x**129 != (-x)**129
 259
 260     assert (2*x)**2 == (-2*x)**2
 261
 262 def test_Add_Mul_is_integer():
 263     x = Symbol('x')
 264
 265     k = Symbol('k', integer=True)
 266     n = Symbol('n', integer=True)
 267
 268     assert (2*k).is_integer == True
 269     assert (-k).is_integer == True
 270     assert (k/3).is_integer == False
 271     assert (x*k*n).is_integer == None
 272
 273     assert (k+n).is_integer == True
 274     assert (k+x).is_integer == None
 275     assert (k+n*x).is_integer == None
 276     assert (k+n/3).is_integer == False
 277
 278 def test_Add_Mul_is_bounded():
 279     x = Symbol('x', real=True, bounded=False)
 280
 281     assert sin(x).is_bounded == True
 282     assert (x*sin(x)).is_bounded == False
 283     assert (1024*sin(x)).is_bounded == True
 284     assert (sin(x)*exp(x)).is_bounded == False
 285     assert (sin(x)*cos(x)).is_bounded == True
 286     assert (x*sin(x)*exp(x)).is_bounded == False
 287
 288     assert (sin(x)-67).is_bounded == True
 289     assert (sin(x)+exp(x)).is_bounded == False
 290
 291 def test_Mul_is_even_odd():
 292     x = Symbol('x', integer=True)
 293
 294     k = Symbol('k', odd=True)
 295     n = Symbol('n', odd=True)
 296     m = Symbol('m', even=True)
 297
 298     assert (2*x).is_even == True
 299     assert (2*x).is_odd == False
 300
 301     assert (3*x).is_even == None
 302     assert (3*x).is_odd == None
 303
 304     assert (k/3).is_integer == False
 305     assert (k/3).is_even    == False
 306     assert (k/3).is_odd     == False
 307
 308     assert (2*n).is_even == True
 309     assert (2*n).is_odd == False
 310
 311     assert (2*m).is_even == True
 312     assert (2*m).is_odd == False
 313
 314     assert (-n).is_even == False
 315     assert (-n).is_odd == True
 316
 317     assert (k*n).is_even == False
 318     assert (k*n).is_odd == True
 319
 320     assert (k*m).is_even == True
 321     assert (k*m).is_odd == False
 322
 323     assert (k*n*m).is_even == True
 324     assert (k*n*m).is_odd == False
 325
 326     assert (k*m*x).is_even == True
 327     assert (k*m*x).is_odd == False
 328
 329 def test_Add_is_even_odd():
 330     x = Symbol('x', integer=True)
 331
 332     k = Symbol('k', odd=True)
 333     n = Symbol('n', even=True)
 334
 335     assert (2+k).is_even == False
 336     assert (2+k).is_odd == True
 337
 338     assert (7-k).is_even == True
 339     assert (7-k).is_odd == False
 340
 341     assert (11-n).is_even == False
 342     assert (11-n).is_odd == True
 343
 344     assert (-8+n).is_even == True
 345     assert (-8+n).is_odd == False
 346
 347     assert (n+k).is_even == False
 348     assert (n+k).is_odd == True
 349
 350     assert (n-k).is_even == False
 351     assert (n-k).is_odd == True
 352
 353     assert (n+2*k).is_even == True
 354     assert (n+2*k).is_odd == False
 355
 356     assert (k+n+x).is_odd == None
 357     assert (k+n-x).is_even == None
 358
 359     assert (2*k+n*x).is_odd == None
 360     assert (2*k+n*x).is_even == None
 361
 362 def test_Mul_is_negative_positive():
 363     x = Symbol('x', real=True)
 364     y = Symbol('y', real=False)
 365
 366     k = Symbol('k', negative=True)
 367     n = Symbol('n', positive=True)
 368     u = Symbol('u', nonnegative=True)
 369     v = Symbol('v', nonpositive=True)
 370
 371     assert k.is_negative == True
 372     assert (-k).is_negative == False
 373     assert (2*k).is_negative == True
 374
 375     assert (2*n)._eval_is_negative() == False
 376     assert (2*n).is_negative == False
 377
 378     assert n.is_negative == False
 379     assert (-n).is_negative == True
 380     assert (2*n).is_negative == False
 381
 382     assert (n*k).is_negative == True
 383     assert (2*n*k).is_negative == True
 384     assert (-n*k).is_negative == False
 385     assert (n*k*y).is_negative == False     # y.is_real=F;  !real -> !neg
 386
 387     assert u.is_negative == False
 388     assert (-u).is_negative == None
 389     assert (2*u).is_negative == False
 390
 391     assert v.is_negative == None
 392     assert (-v).is_negative == False
 393     assert (2*v).is_negative == None
 394
 395     assert (u*v).is_negative == None
 396
 397     assert (k*u).is_negative == None
 398     assert (k*v).is_negative == False
 399
 400     assert (n*u).is_negative == False
 401     assert (n*v).is_negative == None
 402
 403     assert (v*k*u).is_negative == False
 404     assert (v*n*u).is_negative == None
 405
 406     assert (-v*k*u).is_negative == None
 407     assert (-v*n*u).is_negative == False
 408
 409     assert (17*v*k*u).is_negative == False
 410     assert (17*v*n*u).is_negative == None
 411
 412     assert (k*v*n*u).is_negative == False
 413
 414     assert (x*k).is_negative == None
 415     assert (u*v*n*x*k).is_negative == None
 416
 417     assert k.is_positive == False
 418     assert (-k).is_positive == True
 419     assert (2*k).is_positive == False
 420
 421     assert n.is_positive == True
 422     assert (-n).is_positive == False
 423     assert (2*n).is_positive == True
 424
 425     assert (n*k).is_positive == False
 426     assert (2*n*k).is_positive == False
 427     assert (-n*k).is_positive == True
 428     assert (-n*k*y).is_positive == False    # y.is_real=F;  !real -> !neg
 429
 430     assert u.is_positive == None
 431     assert (-u).is_positive == False
 432     assert (2*u).is_positive == None
 433
 434     assert v.is_positive == False
 435     assert (-v).is_positive == None
 436     assert (2*v).is_positive == False
 437
 438     assert (u*v).is_positive == False
 439
 440     assert (k*u).is_positive == False
 441     assert (k*v).is_positive == None
 442
 443     assert (n*u).is_positive == None
 444     assert (n*v).is_positive == False
 445
 446     assert (v*k*u).is_positive == None
 447     assert (v*n*u).is_positive == False
 448
 449     assert (-v*k*u).is_positive == False
 450     assert (-v*n*u).is_positive == None
 451
 452     assert (17*v*k*u).is_positive == None
 453     assert (17*v*n*u).is_positive == False
 454
 455     assert (k*v*n*u).is_positive == None
 456
 457     assert (x*k).is_positive == None
 458     assert (u*v*n*x*k).is_positive == None
 459
 460 def test_Mul_is_negative_positive_2():
 461     a = Symbol('a', nonnegative=True)
 462     b = Symbol('b', nonnegative=True)
 463     c = Symbol('c', nonpositive=True)
 464     d = Symbol('d', nonpositive=True)
 465
 466     assert (a*b).is_nonnegative == True
 467     assert (a*b).is_negative    == False
 468     assert (a*b).is_zero        == None
 469     assert (a*b).is_positive    == None
 470
 471     assert (c*d).is_nonnegative == True
 472     assert (c*d).is_negative    == False
 473     assert (c*d).is_zero        == None
 474     assert (c*d).is_positive    == None
 475
 476     assert (a*c).is_nonpositive == True
 477     assert (a*c).is_positive    == False
 478     assert (a*c).is_zero        == None
 479     assert (a*c).is_negative    == None
 480
 481
 482 def test_Mul_is_nonpositive_nonnegative():
 483     x = Symbol('x', real=True)
 484
 485     k = Symbol('k', negative=True)
 486     n = Symbol('n', positive=True)
 487     u = Symbol('u', nonnegative=True)
 488     v = Symbol('v', nonpositive=True)
 489
 490     assert k.is_nonpositive == True
 491     assert (-k).is_nonpositive == False
 492     assert (2*k).is_nonpositive == True
 493
 494     assert n.is_nonpositive == False
 495     assert (-n).is_nonpositive == True
 496     assert (2*n).is_nonpositive == False
 497
 498     assert (n*k).is_nonpositive == True
 499     assert (2*n*k).is_nonpositive == True
 500     assert (-n*k).is_nonpositive == False
 501
 502     assert u.is_nonpositive == None
 503     assert (-u).is_nonpositive == True
 504     assert (2*u).is_nonpositive == None
 505
 506     assert v.is_nonpositive == True
 507     assert (-v).is_nonpositive == None
 508     assert (2*v).is_nonpositive == True
 509
 510     assert (u*v).is_nonpositive == True
 511
 512     assert (k*u).is_nonpositive == True
 513     assert (k*v).is_nonpositive == None
 514
 515     assert (n*u).is_nonpositive == None
 516     assert (n*v).is_nonpositive == True
 517
 518     assert (v*k*u).is_nonpositive == None
 519     assert (v*n*u).is_nonpositive == True
 520
 521     assert (-v*k*u).is_nonpositive == True
 522     assert (-v*n*u).is_nonpositive == None
 523
 524     assert (17*v*k*u).is_nonpositive == None
 525     assert (17*v*n*u).is_nonpositive == True
 526
 527     assert (k*v*n*u).is_nonpositive == None
 528
 529     assert (x*k).is_nonpositive == None
 530     assert (u*v*n*x*k).is_nonpositive == None
 531
 532     assert k.is_nonnegative == False
 533     assert (-k).is_nonnegative == True
 534     assert (2*k).is_nonnegative == False
 535
 536     assert n.is_nonnegative == True
 537     assert (-n).is_nonnegative == False
 538     assert (2*n).is_nonnegative == True
 539
 540     assert (n*k).is_nonnegative == False
 541     assert (2*n*k).is_nonnegative == False
 542     assert (-n*k).is_nonnegative == True
 543
 544     assert u.is_nonnegative == True
 545     assert (-u).is_nonnegative == None
 546     assert (2*u).is_nonnegative == True
 547
 548     assert v.is_nonnegative == None
 549     assert (-v).is_nonnegative == True
 550     assert (2*v).is_nonnegative == None
 551
 552     assert (u*v).is_nonnegative == None
 553
 554     assert (k*u).is_nonnegative == None
 555     assert (k*v).is_nonnegative == True
 556
 557     assert (n*u).is_nonnegative == True
 558     assert (n*v).is_nonnegative == None
 559
 560     assert (v*k*u).is_nonnegative == True
 561     assert (v*n*u).is_nonnegative == None
 562
 563     assert (-v*k*u).is_nonnegative == None
 564     assert (-v*n*u).is_nonnegative == True
 565
 566     assert (17*v*k*u).is_nonnegative == True
 567     assert (17*v*n*u).is_nonnegative == None
 568
 569     assert (k*v*n*u).is_nonnegative == True
 570
 571     assert (x*k).is_nonnegative == None
 572     assert (u*v*n*x*k).is_nonnegative == None
 573
 574 def test_Add_is_even_odd():
 575     x = Symbol('x', integer=True)
 576
 577     k = Symbol('k', odd=True)
 578     n = Symbol('n', odd=True)
 579     m = Symbol('m', even=True)
 580
 581     assert (k+7).is_even == True
 582     assert (k+7).is_odd == False
 583
 584     assert (-k+7).is_even == True
 585     assert (-k+7).is_odd == False
 586
 587     assert (k-12).is_even == False
 588     assert (k-12).is_odd == True
 589
 590     assert (-k-12).is_even == False
 591     assert (-k-12).is_odd == True
 592
 593     assert (k+n).is_even == True
 594     assert (k+n).is_odd == False
 595
 596     assert (k+m).is_even == False
 597     assert (k+m).is_odd == True
 598
 599     assert (k+n+m).is_even == True
 600     assert (k+n+m).is_odd == False
 601
 602     assert (k+n+x+m).is_even == None
 603     assert (k+n+x+m).is_odd == None
 604
 605 def test_Add_is_negative_positive():
 606     x = Symbol('x', real=True)
 607
 608     k = Symbol('k', negative=True)
 609     n = Symbol('n', positive=True)
 610     u = Symbol('u', nonnegative=True)
 611     v = Symbol('v', nonpositive=True)
 612
 613     assert (k-2).is_negative == True
 614     assert (k+17).is_negative == None
 615     assert (-k-5).is_negative == None
 616     assert (-k+123).is_negative == False
 617
 618     assert (k-n).is_negative == True
 619     assert (k+n).is_negative == None
 620     assert (-k-n).is_negative == None
 621     assert (-k+n).is_negative == False
 622
 623     assert (k-n-2).is_negative == True
 624     assert (k+n+17).is_negative == None
 625     assert (-k-n-5).is_negative == None
 626     assert (-k+n+123).is_negative == False
 627
 628     assert (-2*k+123*n+17).is_negative == False
 629
 630     assert (k+u).is_negative == None
 631     assert (k+v).is_negative == True
 632     assert (n+u).is_negative == False
 633     assert (n+v).is_negative == None
 634
 635     assert (u-v).is_negative == False
 636     assert (u+v).is_negative == None
 637     assert (-u-v).is_negative == None
 638     assert (-u+v).is_negative == None
 639
 640     assert (u-v+n+2).is_negative == False
 641     assert (u+v+n+2).is_negative == None
 642     assert (-u-v+n+2).is_negative == None
 643     assert (-u+v+n+2).is_negative == None
 644
 645     assert (k+x).is_negative == None
 646     assert (k+x-n).is_negative == None
 647
 648     assert (k-2).is_positive == False
 649     assert (k+17).is_positive == None
 650     assert (-k-5).is_positive == None
 651     assert (-k+123).is_positive == True
 652
 653     assert (k-n).is_positive == False
 654     assert (k+n).is_positive == None
 655     assert (-k-n).is_positive == None
 656     assert (-k+n).is_positive == True
 657
 658     assert (k-n-2).is_positive == False
 659     assert (k+n+17).is_positive == None
 660     assert (-k-n-5).is_positive == None
 661     assert (-k+n+123).is_positive == True
 662
 663     assert (-2*k+123*n+17).is_positive == True
 664
 665     assert (k+u).is_positive == None
 666     assert (k+v).is_positive == False
 667     assert (n+u).is_positive == True
 668     assert (n+v).is_positive == None
 669
 670     assert (u-v).is_positive == None
 671     assert (u+v).is_positive == None
 672     assert (-u-v).is_positive == None
 673     assert (-u+v).is_positive == False
 674
 675     assert (u-v-n-2).is_positive == None
 676     assert (u+v-n-2).is_positive == None
 677     assert (-u-v-n-2).is_positive == None
 678     assert (-u+v-n-2).is_positive == False
 679
 680     assert (n+x).is_positive == None
 681     assert (n+x-k).is_positive == None
 682
 683 def test_Add_is_nonpositive_nonnegative():
 684     x = Symbol('x', real=True)
 685
 686     k = Symbol('k', negative=True)
 687     n = Symbol('n', positive=True)
 688     u = Symbol('u', nonnegative=True)
 689     v = Symbol('v', nonpositive=True)
 690
 691     assert (u-2).is_nonpositive == None
 692     assert (u+17).is_nonpositive == False
 693     assert (-u-5).is_nonpositive == True
 694     assert (-u+123).is_nonpositive == None
 695
 696     assert (u-v).is_nonpositive == None
 697     assert (u+v).is_nonpositive == None
 698     assert (-u-v).is_nonpositive == None
 699     assert (-u+v).is_nonpositive == True
 700
 701     assert (u-v-2).is_nonpositive == None
 702     assert (u+v+17).is_nonpositive == None
 703     assert (-u-v-5).is_nonpositive == None
 704     assert (-u+v-123).is_nonpositive == True
 705
 706     assert (-2*u+123*v-17).is_nonpositive == True
 707
 708     assert (k+u).is_nonpositive == None
 709     assert (k+v).is_nonpositive == True
 710     assert (n+u).is_nonpositive == False
 711     assert (n+v).is_nonpositive == None
 712
 713     assert (k-n).is_nonpositive == True
 714     assert (k+n).is_nonpositive == None
 715     assert (-k-n).is_nonpositive == None
 716     assert (-k+n).is_nonpositive == False
 717
 718     assert (k-n+u+2).is_nonpositive == None
 719     assert (k+n+u+2).is_nonpositive == None
 720     assert (-k-n+u+2).is_nonpositive == None
 721     assert (-k+n+u+2).is_nonpositive == False
 722
 723     assert (u+x).is_nonpositive == None
 724     assert (v-x-n).is_nonpositive == None
 725
 726     assert (u-2).is_nonnegative == None
 727     assert (u+17).is_nonnegative == True
 728     assert (-u-5).is_nonnegative == False
 729     assert (-u+123).is_nonnegative == None
 730
 731     assert (u-v).is_nonnegative == True
 732     assert (u+v).is_nonnegative == None
 733     assert (-u-v).is_nonnegative == None
 734     assert (-u+v).is_nonnegative == None
 735
 736     assert (u-v+2).is_nonnegative == True
 737     assert (u+v+17).is_nonnegative == None
 738     assert (-u-v-5).is_nonnegative == None
 739     assert (-u+v-123).is_nonnegative == False
 740
 741     assert (2*u-123*v+17).is_nonnegative == True
 742
 743     assert (k+u).is_nonnegative == None
 744     assert (k+v).is_nonnegative == False
 745     assert (n+u).is_nonnegative == True
 746     assert (n+v).is_nonnegative == None
 747
 748     assert (k-n).is_nonnegative == False
 749     assert (k+n).is_nonnegative == None
 750     assert (-k-n).is_nonnegative == None
 751     assert (-k+n).is_nonnegative == True
 752
 753     assert (k-n-u-2).is_nonnegative == False
 754     assert (k+n-u-2).is_nonnegative == None
 755     assert (-k-n-u-2).is_nonnegative == None
 756     assert (-k+n-u-2).is_nonnegative == None
 757
 758     assert (u-x).is_nonnegative == None
 759     assert (v+x+n).is_nonnegative == None
 760
 761 def test_Pow_is_integer():
 762     x = Symbol('x')
 763
 764     k = Symbol('k', integer=True)
 765     n = Symbol('n', nni=True)
 766     m = Symbol('m', pi=True)
 767
 768     assert (k**2).is_integer == True
 769     assert (k**(-2)).is_integer == False
 770
 771     assert (2**k).is_integer == None
 772     assert (2**(-k)).is_integer == None
 773
 774     assert (2**n).is_integer == True
 775     assert (2**(-n)).is_integer == None
 776
 777     assert (2**m).is_integer == True
 778     assert (2**(-m)).is_integer == False
 779
 780     assert (x**2).is_integer == None
 781     assert (2**x).is_integer == None
 782
 783     assert (k**n).is_integer == True
 784     assert (k**(-n)).is_integer == None
 785
 786     assert (k**x).is_integer == None
 787     assert (x**k).is_integer == None
 788
 789     assert (k**(n*m)).is_integer == True
 790     assert (k**(-n*m)).is_integer == None
 791
 792
 793 def test_Pow_is_real():
 794     x = Symbol('x', real=True)
 795     y = Symbol('y', real=True, positive=True)
 796
 797     assert (x**2).is_real   == True
 798     assert (x**3).is_real   == True
 799     assert (x**x).is_real   == None
 800     assert (y**x).is_real   == True
 801
 802     assert (x**Rational(1,3)).is_real   == None
 803     assert (y**Rational(1,3)).is_real   == True
 804
 805 @XFAIL
 806 def test_Pow_is_bounded():
 807     x = Symbol('x', real=True)
 808
 809     assert (x**2).is_bounded == None
 810
 811     assert (sin(x)**2).is_bounded == True
 812     assert (sin(x)**x).is_bounded == None
 813     assert (sin(x)**exp(x)).is_bounded == None
 814
 815     # XXX This first one fails
 816     assert (1/sin(x)).is_bounded == False
 817     assert (1/exp(x)).is_bounded == False
 818
 819 def test_Pow_is_even_odd():
 820     x = Symbol('x')
 821
 822     k = Symbol('k', even=True)
 823     n = Symbol('n', odd=True)
 824     m = Symbol('m', nni=True)
 825
 826     assert (k**2).is_even == True
 827     assert (n**2).is_even == False
 828     assert (2**k).is_even == None
 829
 830     assert (k**m).is_even == True
 831     assert (n**m).is_even == False
 832
 833     assert (k**x).is_even == None
 834     assert (n**x).is_even == None
 835
 836     assert (k**2).is_odd == False
 837     assert (n**2).is_odd == True
 838     assert (3**k).is_odd == None
 839
 840     assert (k**m).is_odd == False
 841     assert (n**m).is_odd == True
 842
 843     assert (k**x).is_odd == None
 844     assert (n**x).is_odd == None
 845
 846 def test_Pow_is_negative_positive():
 847     x = Symbol('x', real=True)
 848
 849     k = Symbol('k', pi=True)
 850     n = Symbol('n', even=True)
 851     m = Symbol('m', odd=True)
 852
 853     z = Symbol('z')
 854
 855     assert (2**x).is_positive == True
 856     assert ((-2)**x).is_positive == None
 857     assert ((-2)**n).is_positive == True
 858     assert ((-2)**m).is_positive == False
 859
 860     assert (k**2).is_positive == True
 861     assert (k**(-2)).is_positive == True
 862
 863     assert (k**x).is_positive == True
 864     assert ((-k)**x).is_positive == None
 865     assert ((-k)**n).is_positive == True
 866     assert ((-k)**m).is_positive == False
 867
 868     assert (2**x).is_negative == False
 869     assert ((-2)**x).is_negative == None
 870     assert ((-2)**n).is_negative == False
 871     assert ((-2)**m).is_negative == True
 872
 873     assert (k**2).is_negative == False
 874     assert (k**(-2)).is_negative == False
 875
 876     assert (k**x).is_negative == False
 877     assert ((-k)**x).is_negative == None
 878     assert ((-k)**n).is_negative == False
 879     assert ((-k)**m).is_negative == True
 880
 881     assert (2**z).is_positive   == None
 882     assert (2**z).is_negative   == None
 883
 884 def test_Pow_is_nonpositive_nonnegative():
 885     x = Symbol('x', real=True)
 886
 887     k = Symbol('k', nni=True)
 888     l = Symbol('l',  pi=True)
 889     n = Symbol('n', even=True)
 890     m = Symbol('m', odd=True)
 891
 892     assert (2**x).is_nonnegative == True
 893     assert ((-2)**x).is_nonnegative == None
 894     assert ((-2)**n).is_nonnegative == True
 895     assert ((-2)**m).is_nonnegative == False
 896
 897     assert (k**2).is_nonnegative == True
 898     assert (k**(-2)).is_nonnegative == True
 899
 900     assert (k**x).is_nonnegative == None    # NOTE (0**x).is_real = U
 901     assert (l**x).is_nonnegative == True
 902     assert (l**x).is_positive    == True
 903     assert ((-k)**x).is_nonnegative == None
 904     assert ((-k)**n).is_nonnegative == True
 905     assert ((-k)**m).is_nonnegative == None
 906
 907     assert (2**x).is_nonpositive == False
 908     assert ((-2)**x).is_nonpositive == None
 909     assert ((-2)**n).is_nonpositive == False
 910     assert ((-2)**m).is_nonpositive == True
 911
 912     assert (k**2).is_nonpositive == None
 913     assert (k**(-2)).is_nonpositive == None
 914
 915     assert (k**x).is_nonpositive == None
 916     assert ((-k)**x).is_nonpositive == None
 917     assert ((-k)**n).is_nonpositive == None
 918     assert ((-k)**m).is_nonpositive == True
 919
 920
 921 def test_Mul_is_imaginary_real():
 922     r = Symbol('r', real=True)
 923     i = Symbol('i', imaginary=True)
 924     ii= Symbol('ii',imaginary=True)
 925     x = Symbol('x')
 926
 927     assert    I  .is_imaginary  == True
 928     assert    I  .is_real       == False
 929     assert  (-I) .is_imaginary  == True
 930     assert  (-I) .is_real       == False
 931     assert (3*I) .is_imaginary  == True
 932     assert (3*I) .is_real       == False
 933     assert (I*I) .is_imaginary  == False
 934     assert (I*I) .is_real       == True
 935
 936     assert (r*i) .is_imaginary  == True
 937     assert (r*i) .is_real       == False
 938
 939     assert (x*i) .is_imaginary  == None
 940     assert (x*i) .is_real       == None
 941
 942     assert (i*ii).is_imaginary  == False
 943     assert (i*ii).is_real       == True
 944
 945     assert (r*i*ii).is_imaginary == False
 946     assert (r*i*ii).is_real      == True
 947
 948
 949
 950 def test_Add_is_comparable():
 951     assert (x+y).is_comparable  == False
 952     assert (x+1).is_comparable  == False
 953     assert (Rational(1,3) - sqrt(8)).is_comparable == True
 954
 955 def test_Mul_is_comparable():
 956     assert (x*y).is_comparable  == False
 957     assert (x*2).is_comparable  == False
 958     assert (sqrt(2)*Rational(1,3)).is_comparable == True
 959
 960
 961 def test_Pow_is_comparable():
 962     assert (x**y).is_comparable == False
 963     assert (x**2).is_comparable == False
 964     assert (Rational(1,3)**Rational(1,2)).is_comparable == True
 965
 966
 967 def test_Add_is_positive_2():
 968     e = Rational(1,3) - sqrt(8)
 969     assert e.is_positive    == False
 970     assert e.is_negative    == True
 971
 972     e = pi - 1
 973     assert e.is_positive    == True
 974     assert e.is_negative    == False
 975
 976
 977 def test_Add_is_irrational():
 978     i = Symbol('i', irrational=True)
 979
 980     assert i.is_irrational  == True
 981     assert i.is_rational    == False
 982
 983     assert (i+1).is_irrational  == True
 984     assert (i+1).is_rational    == False
 985
 986 def test_issue432():
 987     class MightyNumeric(tuple):
 988         def __rdiv__(self, other):
 989             return "something"
 990     assert sympify(1)/MightyNumeric((1,2)) == "something"
 991
 992 def test_issue432b():
 993     class Foo:
 994         def __init__(self):
 995             self.field = 1.0
 996         def __mul__(self, other):
 997             self.field = self.field * other
 998         def __rmul__(self, other):
 999             self.field = other * self.field
1000     f = Foo()
1001     x = Symbol("x")
1002     assert f*x == x*f
1003
1004 def test_bug3():
1005     a = Symbol("a")
1006     b = Symbol("b", positive=True)
1007     e = 2*a + b
1008     f = b + 2*a
1009     assert e == f
1010
1011 def test_suppressed_evaluation():
1012     a = Add(1,3,2,evaluate=False)
1013     b = Mul(1,3,2,evaluate=False)
1014     c = Pow(3,2,evaluate=False)
1015     assert a != 6
1016     assert a.func is Add
1017     assert a.args == (1,3,2)
1018     assert b != 6
1019     assert b.func is Mul
1020     assert b.args == (1,3,2)
1021     assert c != 9
1022     assert c.func is Pow
1023     assert c.args == (3,2)
1024
1025
1026 def test_Add_as_coeff_terms():
1027     assert (x+1).as_coeff_terms()   == ( 1, (x+1,) )
1028     assert (x+2).as_coeff_terms()   == ( 1, (x+2,) )
1029     assert (x+3).as_coeff_terms()   == ( 1, (x+3,) )
1030
1031     assert (x-1).as_coeff_terms()   == (-1, (1-x,) )
1032     assert (x-2).as_coeff_terms()   == (-1, (2-x,) )
1033     assert (x-3).as_coeff_terms()   == (-1, (3-x,) )
1034
1035     n = Symbol('n', integer=True)
1036     assert (n+1).as_coeff_terms()   == ( 1, (n+1,) )
1037     assert (n+2).as_coeff_terms()   == ( 1, (n+2,) )
1038     assert (n+3).as_coeff_terms()   == ( 1, (n+3,) )
1039
1040     assert (n-1).as_coeff_terms()   == (-1, (1-n,) )
1041     assert (n-2).as_coeff_terms()   == (-1, (2-n,) )
1042     assert (n-3).as_coeff_terms()   == (-1, (3-n,) )
1043
1044
1045 def test_issue974():
1046     assert -1/(-1-x)    == 1/(1+x)
1047