示例#1
0
def test_float_1():
    z = 1.0
    assert ask(Q.commutative(z)) == True
    assert ask(Q.integer(z)) == True
    assert ask(Q.rational(z)) == True
    assert ask(Q.real(z)) == True
    assert ask(Q.complex(z)) == True
    assert ask(Q.irrational(z)) == False
    assert ask(Q.imaginary(z)) == False
    assert ask(Q.positive(z)) == True
    assert ask(Q.negative(z)) == False
    assert ask(Q.even(z)) == False
    assert ask(Q.odd(z)) == True
    assert ask(Q.bounded(z)) == True
    assert ask(Q.infinitesimal(z)) == False
    assert ask(Q.prime(z)) == False
    assert ask(Q.composite(z)) == True

    z = 7.2123
    assert ask(Q.commutative(z)) == True
    assert ask(Q.integer(z)) == False
    assert ask(Q.rational(z)) == True
    assert ask(Q.real(z)) == True
    assert ask(Q.complex(z)) == True
    assert ask(Q.irrational(z)) == False
    assert ask(Q.imaginary(z)) == False
    assert ask(Q.positive(z)) == True
    assert ask(Q.negative(z)) == False
    assert ask(Q.even(z)) == False
    assert ask(Q.odd(z)) == False
    assert ask(Q.bounded(z)) == True
    assert ask(Q.infinitesimal(z)) == False
    assert ask(Q.prime(z)) == False
    assert ask(Q.composite(z)) == False
示例#2
0
def test_negative():
    x, y = symbols('x,y')
    assert ask(Q.negative(x), Q.negative(x)) == True
    assert ask(Q.negative(x), Q.positive(x)) == False
    assert ask(Q.negative(x), ~Q.real(x)) == False
    assert ask(Q.negative(x), Q.prime(x)) == False
    assert ask(Q.negative(x), ~Q.prime(x)) == None

    assert ask(Q.negative(-x), Q.positive(x)) == True
    assert ask(Q.negative(-x), ~Q.positive(x)) == None
    assert ask(Q.negative(-x), Q.negative(x)) == False
    assert ask(Q.negative(-x), Q.positive(x)) == True

    assert ask(Q.negative(x - 1), Q.negative(x)) == True
    assert ask(Q.negative(x + y)) == None
    assert ask(Q.negative(x + y), Q.negative(x)) == None
    assert ask(Q.negative(x + y), Q.negative(x) & Q.negative(y)) == True

    assert ask(Q.negative(x**2)) == None
    assert ask(Q.negative(x**2), Q.real(x)) == False
    assert ask(Q.negative(x**1.4), Q.real(x)) == None

    assert ask(Q.negative(x * y)) == None
    assert ask(Q.negative(x * y), Q.positive(x) & Q.positive(y)) == False
    assert ask(Q.negative(x * y), Q.positive(x) & Q.negative(y)) == True
    assert ask(Q.negative(x * y), Q.complex(x) & Q.complex(y)) == None

    assert ask(Q.negative(x**y)) == None
    assert ask(Q.negative(x**y), Q.negative(x) & Q.even(y)) == False
    assert ask(Q.negative(x**y), Q.negative(x) & Q.odd(y)) == True
    assert ask(Q.negative(x**y), Q.positive(x) & Q.integer(y)) == False

    assert ask(Q.negative(Abs(x))) == False
示例#3
0
def test_negative():
    x, y = symbols('x,y')
    assert ask(Q.negative(x), Q.negative(x)) == True
    assert ask(Q.negative(x), Q.positive(x)) == False
    assert ask(Q.negative(x), ~Q.real(x)) == False
    assert ask(Q.negative(x), Q.prime(x)) == False
    assert ask(Q.negative(x), ~Q.prime(x)) == None

    assert ask(Q.negative(-x), Q.positive(x)) == True
    assert ask(Q.negative(-x), ~Q.positive(x)) == None
    assert ask(Q.negative(-x), Q.negative(x)) == False
    assert ask(Q.negative(-x), Q.positive(x)) == True

    assert ask(Q.negative(x-1), Q.negative(x)) == True
    assert ask(Q.negative(x+y)) == None
    assert ask(Q.negative(x+y), Q.negative(x)) == None
    assert ask(Q.negative(x+y), Q.negative(x) & Q.negative(y)) == True

    assert ask(Q.negative(x**2)) == None
    assert ask(Q.negative(x**2), Q.real(x)) == False
    assert ask(Q.negative(x**1.4), Q.real(x)) == None

    assert ask(Q.negative(x*y)) == None
    assert ask(Q.negative(x*y), Q.positive(x) & Q.positive(y)) == False
    assert ask(Q.negative(x*y), Q.positive(x) & Q.negative(y)) == True
    assert ask(Q.negative(x*y), Q.complex(x) & Q.complex(y)) == None

    assert ask(Q.negative(x**y)) == None
    assert ask(Q.negative(x**y), Q.negative(x) & Q.even(y)) == False
    assert ask(Q.negative(x**y), Q.negative(x) & Q.odd(y)) == True
    assert ask(Q.negative(x**y), Q.positive(x) & Q.integer(y)) == False

    assert ask(Q.negative(Abs(x))) == False
示例#4
0
def test_float_1():
    z = 1.0
    assert ask(Q.commutative(z))      == True
    assert ask(Q.integer(z))          == True
    assert ask(Q.rational(z))         == True
    assert ask(Q.real(z))             == True
    assert ask(Q.complex(z))          == True
    assert ask(Q.irrational(z))       == False
    assert ask(Q.imaginary(z))        == False
    assert ask(Q.positive(z))         == True
    assert ask(Q.negative(z))         == False
    assert ask(Q.even(z))             == False
    assert ask(Q.odd(z))              == True
    assert ask(Q.bounded(z))          == True
    assert ask(Q.infinitesimal(z))    == False
    assert ask(Q.prime(z))            == False
    assert ask(Q.composite(z))        == True

    z = 7.2123
    assert ask(Q.commutative(z))      == True
    assert ask(Q.integer(z))          == False
    assert ask(Q.rational(z))         == True
    assert ask(Q.real(z))             == True
    assert ask(Q.complex(z))          == True
    assert ask(Q.irrational(z))       == False
    assert ask(Q.imaginary(z))        == False
    assert ask(Q.positive(z))         == True
    assert ask(Q.negative(z))         == False
    assert ask(Q.even(z))             == False
    assert ask(Q.odd(z))              == False
    assert ask(Q.bounded(z))          == True
    assert ask(Q.infinitesimal(z))    == False
    assert ask(Q.prime(z))            == False
    assert ask(Q.composite(z))        == False
示例#5
0
def test_I():
    I = S.ImaginaryUnit
    z = I
    assert ask(Q.commutative(z)) == True
    assert ask(Q.integer(z)) == False
    assert ask(Q.rational(z)) == False
    assert ask(Q.real(z)) == False
    assert ask(Q.complex(z)) == True
    assert ask(Q.irrational(z)) == False
    assert ask(Q.imaginary(z)) == True
    assert ask(Q.positive(z)) == False
    assert ask(Q.negative(z)) == False
    assert ask(Q.even(z)) == False
    assert ask(Q.odd(z)) == False
    assert ask(Q.bounded(z)) == True
    assert ask(Q.infinitesimal(z)) == False
    assert ask(Q.prime(z)) == False
    assert ask(Q.composite(z)) == False

    z = 1 + I
    assert ask(Q.commutative(z)) == True
    assert ask(Q.integer(z)) == False
    assert ask(Q.rational(z)) == False
    assert ask(Q.real(z)) == False
    assert ask(Q.complex(z)) == True
    assert ask(Q.irrational(z)) == False
    assert ask(Q.imaginary(z)) == False
    assert ask(Q.positive(z)) == False
    assert ask(Q.negative(z)) == False
    assert ask(Q.even(z)) == False
    assert ask(Q.odd(z)) == False
    assert ask(Q.bounded(z)) == True
    assert ask(Q.infinitesimal(z)) == False
    assert ask(Q.prime(z)) == False
    assert ask(Q.composite(z)) == False

    z = I * (1 + I)
    assert ask(Q.commutative(z)) == True
    assert ask(Q.integer(z)) == False
    assert ask(Q.rational(z)) == False
    assert ask(Q.real(z)) == False
    assert ask(Q.complex(z)) == True
    assert ask(Q.irrational(z)) == False
    assert ask(Q.imaginary(z)) == False
    assert ask(Q.positive(z)) == False
    assert ask(Q.negative(z)) == False
    assert ask(Q.even(z)) == False
    assert ask(Q.odd(z)) == False
    assert ask(Q.bounded(z)) == True
    assert ask(Q.infinitesimal(z)) == False
    assert ask(Q.prime(z)) == False
    assert ask(Q.composite(z)) == False
示例#6
0
def test_I():
    I = S.ImaginaryUnit
    z = I
    assert ask(Q.commutative(z))      == True
    assert ask(Q.integer(z))          == False
    assert ask(Q.rational(z))         == False
    assert ask(Q.real(z))             == False
    assert ask(Q.complex(z))          == True
    assert ask(Q.irrational(z))       == False
    assert ask(Q.imaginary(z))        == True
    assert ask(Q.positive(z))         == False
    assert ask(Q.negative(z))         == False
    assert ask(Q.even(z))             == False
    assert ask(Q.odd(z))              == False
    assert ask(Q.bounded(z))          == True
    assert ask(Q.infinitesimal(z))    == False
    assert ask(Q.prime(z))            == False
    assert ask(Q.composite(z))        == False

    z = 1 + I
    assert ask(Q.commutative(z))      == True
    assert ask(Q.integer(z))          == False
    assert ask(Q.rational(z))         == False
    assert ask(Q.real(z))             == False
    assert ask(Q.complex(z))          == True
    assert ask(Q.irrational(z))       == False
    assert ask(Q.imaginary(z))        == False
    assert ask(Q.positive(z))         == False
    assert ask(Q.negative(z))         == False
    assert ask(Q.even(z))             == False
    assert ask(Q.odd(z))              == False
    assert ask(Q.bounded(z))          == True
    assert ask(Q.infinitesimal(z))    == False
    assert ask(Q.prime(z))            == False
    assert ask(Q.composite(z))        == False

    z = I*(1+I)
    assert ask(Q.commutative(z))      == True
    assert ask(Q.integer(z))          == False
    assert ask(Q.rational(z))         == False
    assert ask(Q.real(z))             == False
    assert ask(Q.complex(z))          == True
    assert ask(Q.irrational(z))       == False
    assert ask(Q.imaginary(z))        == False
    assert ask(Q.positive(z))         == False
    assert ask(Q.negative(z))         == False
    assert ask(Q.even(z))             == False
    assert ask(Q.odd(z))              == False
    assert ask(Q.bounded(z))          == True
    assert ask(Q.infinitesimal(z))    == False
    assert ask(Q.prime(z))            == False
    assert ask(Q.composite(z))        == False
示例#7
0
def test_imaginary():
    x, y, z = symbols('x,y,z')
    I = S.ImaginaryUnit
    assert ask(Q.imaginary(x)) == None
    assert ask(Q.imaginary(x), Q.real(x)) == False
    assert ask(Q.imaginary(x), Q.prime(x)) == False

    assert ask(Q.imaginary(x + 1), Q.real(x)) == False
    assert ask(Q.imaginary(x + 1), Q.imaginary(x)) == False
    assert ask(Q.imaginary(x + I), Q.real(x)) == False
    assert ask(Q.imaginary(x + I), Q.imaginary(x)) == True
    assert ask(Q.imaginary(x + y), Q.imaginary(x) & Q.imaginary(y)) == True
    assert ask(Q.imaginary(x + y), Q.real(x) & Q.real(y)) == False
    assert ask(Q.imaginary(x + y), Q.imaginary(x) & Q.real(y)) == False
    assert ask(Q.imaginary(x + y), Q.complex(x) & Q.real(y)) == None

    assert ask(Q.imaginary(I * x), Q.real(x)) == True
    assert ask(Q.imaginary(I * x), Q.imaginary(x)) == False
    assert ask(Q.imaginary(I * x), Q.complex(x)) == None
    assert ask(Q.imaginary(x * y), Q.imaginary(x) & Q.real(y)) == True

    assert ask(Q.imaginary(x + y + z),
               Q.real(x) & Q.real(y) & Q.real(z)) == False
    assert ask(Q.imaginary(x + y + z),
               Q.real(x) & Q.real(y) & Q.imaginary(z)) == None
    assert ask(Q.imaginary(x + y + z),
               Q.real(x) & Q.imaginary(y) & Q.imaginary(z)) == False
示例#8
0
文件: ntheory.py 项目: BDGLunde/sympy
 def Basic(expr, assumptions):
     _positive = ask(Q.positive(expr), assumptions)
     if _positive:
         _integer = ask(Q.integer(expr), assumptions)
         if _integer:
             _prime = ask(Q.prime(expr), assumptions)
             if _prime is None: return
             return not _prime
         else: return _integer
     else: return _positive
示例#9
0
 def Pow(expr, assumptions):
     """
     Rational ** Integer      -> Rational
     Irrational ** Rational   -> Irrational
     Rational ** Irrational   -> ?
     """
     if ask(Q.integer(expr.exp), assumptions):
         return ask(Q.rational(expr.base), assumptions)
     elif ask(Q.rational(expr.exp), assumptions):
         if ask(Q.prime(expr.base), assumptions):
             return False
示例#10
0
 def Basic(expr, assumptions):
     _positive = ask(Q.positive(expr), assumptions)
     if _positive:
         _integer = ask(Q.integer(expr), assumptions)
         if _integer:
             _prime = ask(Q.prime(expr), assumptions)
             if _prime is None: return
             return not _prime
         else:
             return _integer
     else:
         return _positive
示例#11
0
def test_incompatible_resolutors():
    x = symbols('x')
    class Prime2AskHandler(AskHandler):
        @staticmethod
        def Number(expr, assumptions):
            return True
    register_handler('prime', Prime2AskHandler)
    raises(ValueError, 'ask(Q.prime(4))')
    remove_handler('prime', Prime2AskHandler)

    class InconclusiveHandler(AskHandler):
        @staticmethod
        def Number(expr, assumptions):
            return None
    register_handler('prime', InconclusiveHandler)
    assert ask(Q.prime(3)) == True
示例#12
0
def test_incompatible_resolutors():
    x = symbols('x')
    class Prime2AskHandler(AskHandler):
        @staticmethod
        def Number(expr, assumptions):
            return True
    register_handler('prime', Prime2AskHandler)
    raises(ValueError, 'ask(Q.prime(4))')
    remove_handler('prime', Prime2AskHandler)

    class InconclusiveHandler(AskHandler):
        @staticmethod
        def Number(expr, assumptions):
            return None
    register_handler('prime', InconclusiveHandler)
    assert ask(Q.prime(3)) == True
示例#13
0
def test_E():
    z = S.Exp1
    assert ask(Q.commutative(z)) == True
    assert ask(Q.integer(z)) == False
    assert ask(Q.rational(z)) == False
    assert ask(Q.real(z)) == True
    assert ask(Q.complex(z)) == True
    assert ask(Q.irrational(z)) == True
    assert ask(Q.imaginary(z)) == False
    assert ask(Q.positive(z)) == True
    assert ask(Q.negative(z)) == False
    assert ask(Q.even(z)) == False
    assert ask(Q.odd(z)) == False
    assert ask(Q.bounded(z)) == True
    assert ask(Q.infinitesimal(z)) == False
    assert ask(Q.prime(z)) == False
    assert ask(Q.composite(z)) == False
示例#14
0
def test_zero_0():
    z = Integer(0)
    assert ask(Q.nonzero(z))          == False
    assert ask(Q.commutative(z))      == True
    assert ask(Q.integer(z))          == True
    assert ask(Q.rational(z))         == True
    assert ask(Q.real(z))             == True
    assert ask(Q.complex(z))          == True
    assert ask(Q.imaginary(z))        == False
    assert ask(Q.positive(z))         == False
    assert ask(Q.negative(z))         == False
    assert ask(Q.even(z))             == True
    assert ask(Q.odd(z))              == False
    assert ask(Q.bounded(z))          == True
    assert ask(Q.infinitesimal(z))    == True
    assert ask(Q.prime(z))            == False
    assert ask(Q.composite(z))        == False
示例#15
0
def test_zero_0():
    z = Integer(0)
    assert ask(Q.nonzero(z)) == False
    assert ask(Q.commutative(z)) == True
    assert ask(Q.integer(z)) == True
    assert ask(Q.rational(z)) == True
    assert ask(Q.real(z)) == True
    assert ask(Q.complex(z)) == True
    assert ask(Q.imaginary(z)) == False
    assert ask(Q.positive(z)) == False
    assert ask(Q.negative(z)) == False
    assert ask(Q.even(z)) == True
    assert ask(Q.odd(z)) == False
    assert ask(Q.bounded(z)) == True
    assert ask(Q.infinitesimal(z)) == True
    assert ask(Q.prime(z)) == False
    assert ask(Q.composite(z)) == False
示例#16
0
def test_E():
    z = S.Exp1
    assert ask(Q.commutative(z))      == True
    assert ask(Q.integer(z))          == False
    assert ask(Q.rational(z))         == False
    assert ask(Q.real(z))             == True
    assert ask(Q.complex(z))          == True
    assert ask(Q.irrational(z))       == True
    assert ask(Q.imaginary(z))        == False
    assert ask(Q.positive(z))         == True
    assert ask(Q.negative(z))         == False
    assert ask(Q.even(z))             == False
    assert ask(Q.odd(z))              == False
    assert ask(Q.bounded(z))          == True
    assert ask(Q.infinitesimal(z))    == False
    assert ask(Q.prime(z))            == False
    assert ask(Q.composite(z))        == False
示例#17
0
def _(expr, assumptions):
    _positive = ask(Q.positive(expr), assumptions)
    if _positive:
        _integer = ask(Q.integer(expr), assumptions)
        if _integer:
            _prime = ask(Q.prime(expr), assumptions)
            if _prime is None:
                return
            # Positive integer which is not prime is not
            # necessarily composite
            if expr.equals(1):
                return False
            return not _prime
        else:
            return _integer
    else:
        return _positive
示例#18
0
文件: ntheory.py 项目: EuanFree/sympy
 def Basic(expr, assumptions):
     _positive = ask(Q.positive(expr), assumptions)
     if _positive:
         _integer = ask(Q.integer(expr), assumptions)
         if _integer:
             _prime = ask(Q.prime(expr), assumptions)
             if _prime is None:
                 return
             # Positive integer which is not prime is not
             # necessarily composite
             if expr.equals(1):
                 return False
             return not _prime
         else:
             return _integer
     else:
         return _positive
示例#19
0
def _(expr, assumptions):
    """
    * Rational ** Integer      -> Rational
    * Irrational ** Rational   -> Irrational
    * Rational ** Irrational   -> ?
    """
    if expr.base == E:
        x = expr.exp
        if ask(Q.rational(x), assumptions):
            return ask(~Q.nonzero(x), assumptions)
        return

    if ask(Q.integer(expr.exp), assumptions):
        return ask(Q.rational(expr.base), assumptions)
    elif ask(Q.rational(expr.exp), assumptions):
        if ask(Q.prime(expr.base), assumptions):
            return False
示例#20
0
def test_Rational_number():
    r = Rational(3, 4)
    assert ask(Q.commutative(r)) == True
    assert ask(Q.integer(r)) == False
    assert ask(Q.rational(r)) == True
    assert ask(Q.real(r)) == True
    assert ask(Q.complex(r)) == True
    assert ask(Q.irrational(r)) == False
    assert ask(Q.imaginary(r)) == False
    assert ask(Q.positive(r)) == True
    assert ask(Q.negative(r)) == False
    assert ask(Q.even(r)) == False
    assert ask(Q.odd(r)) == False
    assert ask(Q.bounded(r)) == True
    assert ask(Q.infinitesimal(r)) == False
    assert ask(Q.prime(r)) == False
    assert ask(Q.composite(r)) == False

    r = Rational(1, 4)
    assert ask(Q.positive(r)) == True
    assert ask(Q.negative(r)) == False

    r = Rational(5, 4)
    assert ask(Q.negative(r)) == False
    assert ask(Q.positive(r)) == True

    r = Rational(5, 3)
    assert ask(Q.positive(r)) == True
    assert ask(Q.negative(r)) == False

    r = Rational(-3, 4)
    assert ask(Q.positive(r)) == False
    assert ask(Q.negative(r)) == True

    r = Rational(-1, 4)
    assert ask(Q.positive(r)) == False
    assert ask(Q.negative(r)) == True

    r = Rational(-5, 4)
    assert ask(Q.negative(r)) == True
    assert ask(Q.positive(r)) == False

    r = Rational(-5, 3)
    assert ask(Q.positive(r)) == False
    assert ask(Q.negative(r)) == True
示例#21
0
def test_Rational_number():
    r = Rational(3,4)
    assert ask(Q.commutative(r))      == True
    assert ask(Q.integer(r))          == False
    assert ask(Q.rational(r))         == True
    assert ask(Q.real(r))             == True
    assert ask(Q.complex(r))          == True
    assert ask(Q.irrational(r))       == False
    assert ask(Q.imaginary(r))        == False
    assert ask(Q.positive(r))         == True
    assert ask(Q.negative(r))         == False
    assert ask(Q.even(r))             == False
    assert ask(Q.odd(r))              == False
    assert ask(Q.bounded(r))          == True
    assert ask(Q.infinitesimal(r))    == False
    assert ask(Q.prime(r))            == False
    assert ask(Q.composite(r))        == False

    r = Rational(1,4)
    assert ask(Q.positive(r))         == True
    assert ask(Q.negative(r))         == False

    r = Rational(5,4)
    assert ask(Q.negative(r))         == False
    assert ask(Q.positive(r))         == True

    r = Rational(5,3)
    assert ask(Q.positive(r))         == True
    assert ask(Q.negative(r))         == False

    r = Rational(-3,4)
    assert ask(Q.positive(r))         == False
    assert ask(Q.negative(r))         == True

    r = Rational(-1,4)
    assert ask(Q.positive(r))         == False
    assert ask(Q.negative(r))         == True

    r = Rational(-5,4)
    assert ask(Q.negative(r))         == True
    assert ask(Q.positive(r))         == False

    r = Rational(-5,3)
    assert ask(Q.positive(r))         == False
    assert ask(Q.negative(r))         == True
示例#22
0
def test_nan():
    nan = S.NaN
    assert ask(Q.commutative(nan))   == True
    assert ask(Q.integer(nan))       == False
    assert ask(Q.rational(nan))      == False
    assert ask(Q.real(nan))          == False
    assert ask(Q.extended_real(nan)) == False
    assert ask(Q.complex(nan))       == False
    assert ask(Q.irrational(nan))    == False
    assert ask(Q.imaginary(nan))     == False
    assert ask(Q.positive(nan))      == False
    assert ask(Q.nonzero(nan))       == True
    assert ask(Q.even(nan))          == False
    assert ask(Q.odd(nan))           == False
    assert ask(Q.bounded(nan))       == False
    assert ask(Q.infinitesimal(nan)) == False
    assert ask(Q.prime(nan))         == False
    assert ask(Q.composite(nan))     == False
示例#23
0
def test_neg_infinity():
    mm = S.NegativeInfinity
    assert ask(Q.commutative(mm))    == True
    assert ask(Q.integer(mm))        == False
    assert ask(Q.rational(mm))       == False
    assert ask(Q.real(mm))           == False
    assert ask(Q.extended_real(mm))  == True
    assert ask(Q.complex(mm))        == False
    assert ask(Q.irrational(mm))     == False
    assert ask(Q.imaginary(mm))      == False
    assert ask(Q.positive(mm))       == False
    assert ask(Q.negative(mm))       == True
    assert ask(Q.even(mm))           == False
    assert ask(Q.odd(mm))            == False
    assert ask(Q.bounded(mm))        == False
    assert ask(Q.infinitesimal(mm))  == False
    assert ask(Q.prime(mm))          == False
    assert ask(Q.composite(mm))      == False
示例#24
0
def test_nan():
    nan = S.NaN
    assert ask(Q.commutative(nan)) == True
    assert ask(Q.integer(nan)) == False
    assert ask(Q.rational(nan)) == False
    assert ask(Q.real(nan)) == False
    assert ask(Q.extended_real(nan)) == False
    assert ask(Q.complex(nan)) == False
    assert ask(Q.irrational(nan)) == False
    assert ask(Q.imaginary(nan)) == False
    assert ask(Q.positive(nan)) == False
    assert ask(Q.nonzero(nan)) == True
    assert ask(Q.even(nan)) == False
    assert ask(Q.odd(nan)) == False
    assert ask(Q.bounded(nan)) == False
    assert ask(Q.infinitesimal(nan)) == False
    assert ask(Q.prime(nan)) == False
    assert ask(Q.composite(nan)) == False
示例#25
0
def test_neg_infinity():
    mm = S.NegativeInfinity
    assert ask(Q.commutative(mm)) == True
    assert ask(Q.integer(mm)) == False
    assert ask(Q.rational(mm)) == False
    assert ask(Q.real(mm)) == False
    assert ask(Q.extended_real(mm)) == True
    assert ask(Q.complex(mm)) == False
    assert ask(Q.irrational(mm)) == False
    assert ask(Q.imaginary(mm)) == False
    assert ask(Q.positive(mm)) == False
    assert ask(Q.negative(mm)) == True
    assert ask(Q.even(mm)) == False
    assert ask(Q.odd(mm)) == False
    assert ask(Q.bounded(mm)) == False
    assert ask(Q.infinitesimal(mm)) == False
    assert ask(Q.prime(mm)) == False
    assert ask(Q.composite(mm)) == False
示例#26
0
def test_infinity():
    oo = S.Infinity
    assert ask(Q.commutative(oo)) == True
    assert ask(Q.integer(oo)) == False
    assert ask(Q.rational(oo)) == False
    assert ask(Q.real(oo)) == False
    assert ask(Q.extended_real(oo)) == True
    assert ask(Q.complex(oo)) == False
    assert ask(Q.irrational(oo)) == False
    assert ask(Q.imaginary(oo)) == False
    assert ask(Q.positive(oo)) == True
    assert ask(Q.negative(oo)) == False
    assert ask(Q.even(oo)) == False
    assert ask(Q.odd(oo)) == False
    assert ask(Q.bounded(oo)) == False
    assert ask(Q.infinitesimal(oo)) == False
    assert ask(Q.prime(oo)) == False
    assert ask(Q.composite(oo)) == False
示例#27
0
def test_infinity():
    oo = S.Infinity
    assert ask(Q.commutative(oo))     == True
    assert ask(Q.integer(oo))         == False
    assert ask(Q.rational(oo))        == False
    assert ask(Q.real(oo))            == False
    assert ask(Q.extended_real(oo))   == True
    assert ask(Q.complex(oo))         == False
    assert ask(Q.irrational(oo))      == False
    assert ask(Q.imaginary(oo))       == False
    assert ask(Q.positive(oo))        == True
    assert ask(Q.negative(oo))        == False
    assert ask(Q.even(oo))            == False
    assert ask(Q.odd(oo))             == False
    assert ask(Q.bounded(oo))         == False
    assert ask(Q.infinitesimal(oo))   == False
    assert ask(Q.prime(oo))           == False
    assert ask(Q.composite(oo))       == False
示例#28
0
def test_real():
    x, y = symbols('x,y')
    assert ask(Q.real(x)) == None
    assert ask(Q.real(x), Q.real(x)) == True
    assert ask(Q.real(x), Q.nonzero(x)) == True
    assert ask(Q.real(x), Q.positive(x)) == True
    assert ask(Q.real(x), Q.negative(x)) == True
    assert ask(Q.real(x), Q.integer(x)) == True
    assert ask(Q.real(x), Q.even(x)) == True
    assert ask(Q.real(x), Q.prime(x)) == True

    assert ask(Q.real(x / sqrt(2)), Q.real(x)) == True
    assert ask(Q.real(x / sqrt(-2)), Q.real(x)) == False

    I = S.ImaginaryUnit
    assert ask(Q.real(x + 1), Q.real(x)) == True
    assert ask(Q.real(x + I), Q.real(x)) == False
    assert ask(Q.real(x + I), Q.complex(x)) == None

    assert ask(Q.real(2 * x), Q.real(x)) == True
    assert ask(Q.real(I * x), Q.real(x)) == False
    assert ask(Q.real(I * x), Q.imaginary(x)) == True
    assert ask(Q.real(I * x), Q.complex(x)) == None

    assert ask(Q.real(x**2), Q.real(x)) == True
    assert ask(Q.real(sqrt(x)), Q.negative(x)) == False
    assert ask(Q.real(x**y), Q.real(x) & Q.integer(y)) == True
    assert ask(Q.real(x**y), Q.real(x) & Q.real(y)) == None
    assert ask(Q.real(x**y), Q.positive(x) & Q.real(y)) == True

    # trigonometric functions
    assert ask(Q.real(sin(x))) == None
    assert ask(Q.real(cos(x))) == None
    assert ask(Q.real(sin(x)), Q.real(x)) == True
    assert ask(Q.real(cos(x)), Q.real(x)) == True

    # exponential function
    assert ask(Q.real(exp(x))) == None
    assert ask(Q.real(exp(x)), Q.real(x)) == True
    assert ask(Q.real(x + exp(x)), Q.real(x)) == True

    # Q.complexes
    assert ask(Q.real(re(x))) == True
    assert ask(Q.real(im(x))) == True
示例#29
0
def test_real():
    x, y = symbols('x,y')
    assert ask(Q.real(x)) == None
    assert ask(Q.real(x), Q.real(x)) == True
    assert ask(Q.real(x), Q.nonzero(x)) == True
    assert ask(Q.real(x), Q.positive(x)) == True
    assert ask(Q.real(x), Q.negative(x)) == True
    assert ask(Q.real(x), Q.integer(x)) == True
    assert ask(Q.real(x), Q.even(x)) == True
    assert ask(Q.real(x), Q.prime(x)) == True

    assert ask(Q.real(x/sqrt(2)), Q.real(x)) == True
    assert ask(Q.real(x/sqrt(-2)), Q.real(x)) == False

    I = S.ImaginaryUnit
    assert ask(Q.real(x+1), Q.real(x)) == True
    assert ask(Q.real(x+I), Q.real(x)) == False
    assert ask(Q.real(x+I), Q.complex(x)) == None

    assert ask(Q.real(2*x), Q.real(x)) == True
    assert ask(Q.real(I*x), Q.real(x)) == False
    assert ask(Q.real(I*x), Q.imaginary(x)) == True
    assert ask(Q.real(I*x), Q.complex(x)) == None

    assert ask(Q.real(x**2), Q.real(x)) == True
    assert ask(Q.real(sqrt(x)), Q.negative(x)) == False
    assert ask(Q.real(x**y), Q.real(x) & Q.integer(y)) == True
    assert ask(Q.real(x**y), Q.real(x) & Q.real(y)) == None
    assert ask(Q.real(x**y), Q.positive(x) & Q.real(y)) == True

    # trigonometric functions
    assert ask(Q.real(sin(x))) == None
    assert ask(Q.real(cos(x))) == None
    assert ask(Q.real(sin(x)), Q.real(x)) == True
    assert ask(Q.real(cos(x)), Q.real(x)) == True

    # exponential function
    assert ask(Q.real(exp(x))) == None
    assert ask(Q.real(exp(x)), Q.real(x)) == True
    assert ask(Q.real(x + exp(x)), Q.real(x)) == True

    # Q.complexes
    assert ask(Q.real(re(x))) == True
    assert ask(Q.real(im(x))) == True
示例#30
0
def test_type_extensibility():
    """test that new types can be added to the ask system at runtime
    We create a custom type MyType, and override ask Q.prime=True with handler
    MyAskHandler for this type

    TODO: test incompatible resolutors
    """
    from sympy.core import Basic

    class MyType(Basic):
        pass

    class MyAskHandler(AskHandler):
        @staticmethod
        def MyType(expr, assumptions):
            return True

    a = MyType()
    register_handler(Q.prime, MyAskHandler)
    assert ask(Q.prime(a)) == True
示例#31
0
def test_type_extensibility():
    """test that new types can be added to the ask system at runtime
    We create a custom type MyType, and override ask Q.prime=True with handler
    MyAskHandler for this type

    TODO: test incompatible resolutors
    """
    from sympy.core import Basic

    class MyType(Basic):
        pass

    class MyAskHandler(AskHandler):
        @staticmethod
        def MyType(expr, assumptions):
            return True

    a = MyType()
    register_handler(Q.prime, MyAskHandler)
    assert ask(Q.prime(a)) == True
示例#32
0
def test_integer():
    x = symbols('x')
    assert ask(Q.integer(x)) == None
    assert ask(Q.integer(x), Q.integer(x)) == True
    assert ask(Q.integer(x), ~Q.integer(x)) == False
    assert ask(Q.integer(x), ~Q.real(x)) == False
    assert ask(Q.integer(x), ~Q.positive(x)) == None
    assert ask(Q.integer(x), Q.even(x) | Q.odd(x)) == True

    assert ask(Q.integer(2*x), Q.integer(x)) == True
    assert ask(Q.integer(2*x), Q.even(x)) == True
    assert ask(Q.integer(2*x), Q.prime(x)) == True
    assert ask(Q.integer(2*x), Q.rational(x)) == None
    assert ask(Q.integer(2*x), Q.real(x)) == None
    assert ask(Q.integer(sqrt(2)*x), Q.integer(x)) == False

    assert ask(Q.integer(x/2), Q.odd(x)) == False
    assert ask(Q.integer(x/2), Q.even(x)) == True
    assert ask(Q.integer(x/3), Q.odd(x)) == None
    assert ask(Q.integer(x/3), Q.even(x)) == None
示例#33
0
def test_integer():
    x = symbols('x')
    assert ask(Q.integer(x)) == None
    assert ask(Q.integer(x), Q.integer(x)) == True
    assert ask(Q.integer(x), ~Q.integer(x)) == False
    assert ask(Q.integer(x), ~Q.real(x)) == False
    assert ask(Q.integer(x), ~Q.positive(x)) == None
    assert ask(Q.integer(x), Q.even(x) | Q.odd(x)) == True

    assert ask(Q.integer(2 * x), Q.integer(x)) == True
    assert ask(Q.integer(2 * x), Q.even(x)) == True
    assert ask(Q.integer(2 * x), Q.prime(x)) == True
    assert ask(Q.integer(2 * x), Q.rational(x)) == None
    assert ask(Q.integer(2 * x), Q.real(x)) == None
    assert ask(Q.integer(sqrt(2) * x), Q.integer(x)) == False

    assert ask(Q.integer(x / 2), Q.odd(x)) == False
    assert ask(Q.integer(x / 2), Q.even(x)) == True
    assert ask(Q.integer(x / 3), Q.odd(x)) == None
    assert ask(Q.integer(x / 3), Q.even(x)) == None
示例#34
0
def test_imaginary():
    x, y, z = symbols('x,y,z')
    I = S.ImaginaryUnit
    assert ask(Q.imaginary(x)) == None
    assert ask(Q.imaginary(x), Q.real(x)) == False
    assert ask(Q.imaginary(x), Q.prime(x)) == False

    assert ask(Q.imaginary(x+1), Q.real(x)) == False
    assert ask(Q.imaginary(x+1), Q.imaginary(x)) == False
    assert ask(Q.imaginary(x+I), Q.real(x)) == False
    assert ask(Q.imaginary(x+I), Q.imaginary(x)) == True
    assert ask(Q.imaginary(x+y), Q.imaginary(x) & Q.imaginary(y)) == True
    assert ask(Q.imaginary(x+y), Q.real(x) & Q.real(y)) == False
    assert ask(Q.imaginary(x+y), Q.imaginary(x) & Q.real(y)) == False
    assert ask(Q.imaginary(x+y), Q.complex(x) & Q.real(y)) == None

    assert ask(Q.imaginary(I*x), Q.real(x)) == True
    assert ask(Q.imaginary(I*x), Q.imaginary(x)) == False
    assert ask(Q.imaginary(I*x), Q.complex(x)) == None
    assert ask(Q.imaginary(x*y), Q.imaginary(x) & Q.real(y)) == True

    assert ask(Q.imaginary(x+y+z), Q.real(x) & Q.real(y) & Q.real(z)) == False
    assert ask(Q.imaginary(x+y+z), Q.real(x) & Q.real(y) & Q.imaginary(z)) == None
    assert ask(Q.imaginary(x+y+z), Q.real(x) & Q.imaginary(y) & Q.imaginary(z)) == False
示例#35
0
def test_pi():
    z = S.Pi
    assert ask(Q.commutative(z))      == True
    assert ask(Q.integer(z))          == False
    assert ask(Q.rational(z))         == False
    assert ask(Q.real(z))             == True
    assert ask(Q.complex(z))          == True
    assert ask(Q.irrational(z))       == True
    assert ask(Q.imaginary(z))        == False
    assert ask(Q.positive(z))         == True
    assert ask(Q.negative(z))         == False
    assert ask(Q.even(z))             == False
    assert ask(Q.odd(z))              == False
    assert ask(Q.bounded(z))          == True
    assert ask(Q.infinitesimal(z))    == False
    assert ask(Q.prime(z))            == False
    assert ask(Q.composite(z))        == False

    z = S.Pi + 1
    assert ask(Q.commutative(z))      == True
    assert ask(Q.integer(z))          == False
    assert ask(Q.rational(z))         == False
    assert ask(Q.real(z))             == True
    assert ask(Q.complex(z))          == True
    assert ask(Q.irrational(z))       == True
    assert ask(Q.imaginary(z))        == False
    assert ask(Q.positive(z))         == True
    assert ask(Q.negative(z))         == False
    assert ask(Q.even(z))             == False
    assert ask(Q.odd(z))              == False
    assert ask(Q.bounded(z))          == True
    assert ask(Q.infinitesimal(z))    == False
    assert ask(Q.prime(z))            == False
    assert ask(Q.composite(z))        == False

    z = 2*S.Pi
    assert ask(Q.commutative(z))      == True
    assert ask(Q.integer(z))          == False
    assert ask(Q.rational(z))         == False
    assert ask(Q.real(z))             == True
    assert ask(Q.complex(z))          == True
    assert ask(Q.irrational(z))       == True
    assert ask(Q.imaginary(z))        == False
    assert ask(Q.positive(z))         == True
    assert ask(Q.negative(z))         == False
    assert ask(Q.even(z))             == False
    assert ask(Q.odd(z))              == False
    assert ask(Q.bounded(z))          == True
    assert ask(Q.infinitesimal(z))    == False
    assert ask(Q.prime(z))            == False
    assert ask(Q.composite(z))        == False

    z = S.Pi ** 2
    assert ask(Q.commutative(z))      == True
    assert ask(Q.integer(z))          == False
    assert ask(Q.rational(z))         == False
    assert ask(Q.real(z))             == True
    assert ask(Q.complex(z))          == True
    assert ask(Q.irrational(z))       == True
    assert ask(Q.imaginary(z))        == False
    assert ask(Q.positive(z))         == True
    assert ask(Q.negative(z))         == False
    assert ask(Q.even(z))             == False
    assert ask(Q.odd(z))              == False
    assert ask(Q.bounded(z))          == True
    assert ask(Q.infinitesimal(z))    == False
    assert ask(Q.prime(z))            == False
    assert ask(Q.composite(z))        == False

    z = (1+S.Pi) ** 2
    assert ask(Q.commutative(z))      == True
    assert ask(Q.integer(z))          == False
    assert ask(Q.rational(z))         == False
    assert ask(Q.real(z))             == True
    assert ask(Q.complex(z))          == True
    assert ask(Q.irrational(z))       == True
    assert ask(Q.imaginary(z))        == False
    assert ask(Q.positive(z))         == True
    assert ask(Q.negative(z))         == False
    assert ask(Q.even(z))             == False
    assert ask(Q.odd(z))              == False
    assert ask(Q.bounded(z))          == True
    assert ask(Q.infinitesimal(z))    == False
    assert ask(Q.prime(z))            == False
    assert ask(Q.composite(z))        == False
示例#36
0
def test_pi():
    z = S.Pi
    assert ask(Q.commutative(z)) == True
    assert ask(Q.integer(z)) == False
    assert ask(Q.rational(z)) == False
    assert ask(Q.real(z)) == True
    assert ask(Q.complex(z)) == True
    assert ask(Q.irrational(z)) == True
    assert ask(Q.imaginary(z)) == False
    assert ask(Q.positive(z)) == True
    assert ask(Q.negative(z)) == False
    assert ask(Q.even(z)) == False
    assert ask(Q.odd(z)) == False
    assert ask(Q.bounded(z)) == True
    assert ask(Q.infinitesimal(z)) == False
    assert ask(Q.prime(z)) == False
    assert ask(Q.composite(z)) == False

    z = S.Pi + 1
    assert ask(Q.commutative(z)) == True
    assert ask(Q.integer(z)) == False
    assert ask(Q.rational(z)) == False
    assert ask(Q.real(z)) == True
    assert ask(Q.complex(z)) == True
    assert ask(Q.irrational(z)) == True
    assert ask(Q.imaginary(z)) == False
    assert ask(Q.positive(z)) == True
    assert ask(Q.negative(z)) == False
    assert ask(Q.even(z)) == False
    assert ask(Q.odd(z)) == False
    assert ask(Q.bounded(z)) == True
    assert ask(Q.infinitesimal(z)) == False
    assert ask(Q.prime(z)) == False
    assert ask(Q.composite(z)) == False

    z = 2 * S.Pi
    assert ask(Q.commutative(z)) == True
    assert ask(Q.integer(z)) == False
    assert ask(Q.rational(z)) == False
    assert ask(Q.real(z)) == True
    assert ask(Q.complex(z)) == True
    assert ask(Q.irrational(z)) == True
    assert ask(Q.imaginary(z)) == False
    assert ask(Q.positive(z)) == True
    assert ask(Q.negative(z)) == False
    assert ask(Q.even(z)) == False
    assert ask(Q.odd(z)) == False
    assert ask(Q.bounded(z)) == True
    assert ask(Q.infinitesimal(z)) == False
    assert ask(Q.prime(z)) == False
    assert ask(Q.composite(z)) == False

    z = S.Pi**2
    assert ask(Q.commutative(z)) == True
    assert ask(Q.integer(z)) == False
    assert ask(Q.rational(z)) == False
    assert ask(Q.real(z)) == True
    assert ask(Q.complex(z)) == True
    assert ask(Q.irrational(z)) == True
    assert ask(Q.imaginary(z)) == False
    assert ask(Q.positive(z)) == True
    assert ask(Q.negative(z)) == False
    assert ask(Q.even(z)) == False
    assert ask(Q.odd(z)) == False
    assert ask(Q.bounded(z)) == True
    assert ask(Q.infinitesimal(z)) == False
    assert ask(Q.prime(z)) == False
    assert ask(Q.composite(z)) == False

    z = (1 + S.Pi)**2
    assert ask(Q.commutative(z)) == True
    assert ask(Q.integer(z)) == False
    assert ask(Q.rational(z)) == False
    assert ask(Q.real(z)) == True
    assert ask(Q.complex(z)) == True
    assert ask(Q.irrational(z)) == True
    assert ask(Q.imaginary(z)) == False
    assert ask(Q.positive(z)) == True
    assert ask(Q.negative(z)) == False
    assert ask(Q.even(z)) == False
    assert ask(Q.odd(z)) == False
    assert ask(Q.bounded(z)) == True
    assert ask(Q.infinitesimal(z)) == False
    assert ask(Q.prime(z)) == False
    assert ask(Q.composite(z)) == False
示例#37
0
def get_known_facts(x=None):
    """
    Facts between unary predicates.

    Parameters
    ==========

    x : Symbol, optional
        Placeholder symbol for unary facts. Default is ``Symbol('x')``.

    Returns
    =======

    fact : Known facts in conjugated normal form.

    """
    if x is None:
        x = Symbol('x')

    fact = And(
        # primitive predicates for extended real exclude each other.
        Exclusive(Q.negative_infinite(x), Q.negative(x), Q.zero(x),
                  Q.positive(x), Q.positive_infinite(x)),

        # build complex plane
        Exclusive(Q.real(x), Q.imaginary(x)),
        Implies(Q.real(x) | Q.imaginary(x), Q.complex(x)),

        # other subsets of complex
        Exclusive(Q.transcendental(x), Q.algebraic(x)),
        Equivalent(Q.real(x),
                   Q.rational(x) | Q.irrational(x)),
        Exclusive(Q.irrational(x), Q.rational(x)),
        Implies(Q.rational(x), Q.algebraic(x)),

        # integers
        Exclusive(Q.even(x), Q.odd(x)),
        Implies(Q.integer(x), Q.rational(x)),
        Implies(Q.zero(x), Q.even(x)),
        Exclusive(Q.composite(x), Q.prime(x)),
        Implies(Q.composite(x) | Q.prime(x),
                Q.integer(x) & Q.positive(x)),
        Implies(Q.even(x) & Q.positive(x) & ~Q.prime(x), Q.composite(x)),

        # hermitian and antihermitian
        Implies(Q.real(x), Q.hermitian(x)),
        Implies(Q.imaginary(x), Q.antihermitian(x)),
        Implies(Q.zero(x),
                Q.hermitian(x) | Q.antihermitian(x)),

        # define finity and infinity, and build extended real line
        Exclusive(Q.infinite(x), Q.finite(x)),
        Implies(Q.complex(x), Q.finite(x)),
        Implies(
            Q.negative_infinite(x) | Q.positive_infinite(x), Q.infinite(x)),

        # commutativity
        Implies(Q.finite(x) | Q.infinite(x), Q.commutative(x)),

        # matrices
        Implies(Q.orthogonal(x), Q.positive_definite(x)),
        Implies(Q.orthogonal(x), Q.unitary(x)),
        Implies(Q.unitary(x) & Q.real_elements(x), Q.orthogonal(x)),
        Implies(Q.unitary(x), Q.normal(x)),
        Implies(Q.unitary(x), Q.invertible(x)),
        Implies(Q.normal(x), Q.square(x)),
        Implies(Q.diagonal(x), Q.normal(x)),
        Implies(Q.positive_definite(x), Q.invertible(x)),
        Implies(Q.diagonal(x), Q.upper_triangular(x)),
        Implies(Q.diagonal(x), Q.lower_triangular(x)),
        Implies(Q.lower_triangular(x), Q.triangular(x)),
        Implies(Q.upper_triangular(x), Q.triangular(x)),
        Implies(Q.triangular(x),
                Q.upper_triangular(x) | Q.lower_triangular(x)),
        Implies(Q.upper_triangular(x) & Q.lower_triangular(x), Q.diagonal(x)),
        Implies(Q.diagonal(x), Q.symmetric(x)),
        Implies(Q.unit_triangular(x), Q.triangular(x)),
        Implies(Q.invertible(x), Q.fullrank(x)),
        Implies(Q.invertible(x), Q.square(x)),
        Implies(Q.symmetric(x), Q.square(x)),
        Implies(Q.fullrank(x) & Q.square(x), Q.invertible(x)),
        Equivalent(Q.invertible(x), ~Q.singular(x)),
        Implies(Q.integer_elements(x), Q.real_elements(x)),
        Implies(Q.real_elements(x), Q.complex_elements(x)),
    )
    return fact
示例#38
0
def test_prime():
    x, y = symbols('x,y')
    assert ask(Q.prime(x), Q.prime(x)) == True
    assert ask(Q.prime(x), ~Q.prime(x)) == False
    assert ask(Q.prime(x), Q.integer(x)) == None
    assert ask(Q.prime(x), ~Q.integer(x)) == False

    assert ask(Q.prime(2 * x), Q.integer(x)) == False
    assert ask(Q.prime(x * y)) == None
    assert ask(Q.prime(x * y), Q.prime(x)) == None
    assert ask(Q.prime(x * y), Q.integer(x) & Q.integer(y)) == False

    assert ask(Q.prime(x**2), Q.integer(x)) == False
    assert ask(Q.prime(x**2), Q.prime(x)) == False
    assert ask(Q.prime(x**y), Q.integer(x) & Q.integer(y)) == False
示例#39
0
def test_prime():
    x, y = symbols('x,y')
    assert ask(Q.prime(x), Q.prime(x)) == True
    assert ask(Q.prime(x), ~Q.prime(x)) == False
    assert ask(Q.prime(x), Q.integer(x)) == None
    assert ask(Q.prime(x), ~Q.integer(x)) == False

    assert ask(Q.prime(2*x), Q.integer(x)) == False
    assert ask(Q.prime(x*y)) == None
    assert ask(Q.prime(x*y), Q.prime(x)) == None
    assert ask(Q.prime(x*y), Q.integer(x) & Q.integer(y)) == False

    assert ask(Q.prime(x**2), Q.integer(x)) == False
    assert ask(Q.prime(x**2), Q.prime(x)) == False
    assert ask(Q.prime(x**y), Q.integer(x) & Q.integer(y)) == False