Exemplo n.º 1
0
def test_finally():
    try:
        with assuming(Q.integer(x)):
            1/0
    except ZeroDivisionError:
        pass
    assert not ask(Q.integer(x))
Exemplo n.º 2
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
Exemplo n.º 3
0
 def Pow(expr, assumptions):
     """
     Integer**Integer     -> !Prime
     """
     if expr.is_number:
         return AskPrimeHandler._number(expr, assumptions)
     if ask(Q.integer(expr.exp), assumptions) and ask(Q.integer(expr.base), assumptions):
         return False
Exemplo n.º 4
0
def test_custom_context():
    """Test ask with custom assumptions context"""
    x = symbols('x')
    assert ask(Q.integer(x)) == None
    local_context = AssumptionsContext()
    local_context.add(Q.integer(x))
    assert ask(Q.integer(x), context = local_context) == True
    assert ask(Q.integer(x)) == None
Exemplo n.º 5
0
def test_remove_safe():
    global_assumptions.add(Q.integer(x))
    with assuming():
        assert ask(Q.integer(x))
        global_assumptions.remove(Q.integer(x))
        assert not ask(Q.integer(x))
    assert ask(Q.integer(x))
    global_assumptions.clear() # for the benefit of other tests
Exemplo n.º 6
0
def test_global():
    """Test ask with global assumptions"""
    x = symbols('x')
    assert ask(Q.integer(x)) == None
    global_assumptions.add(Q.integer(x))
    assert ask(Q.integer(x)) == True
    global_assumptions.clear()
    assert ask(Q.integer(x)) == None
Exemplo n.º 7
0
    def Pow(expr, assumptions):
        """
        Real**Integer              -> Real
        Positive**Real             -> Real
        Real**(Integer/Even)       -> Real if base is nonnegative
        Real**(Integer/Odd)        -> Real
        Imaginary**(Integer/Even)  -> Real
        Imaginary**(Integer/Odd)   -> not Real
        Imaginary**Real            -> ? since Real could be 0 (giving real) or 1 (giving imaginary)
        b**Imaginary               -> Real if log(b) is imaginary and b != 0 and exponent != integer multiple of I*pi/log(b)
        Real**Real                 -> ? e.g. sqrt(-1) is imaginary and sqrt(2) is not
        """
        if expr.is_number:
            return AskRealHandler._number(expr, assumptions)

        if expr.base.func == exp:
            if ask(Q.imaginary(expr.base.args[0]), assumptions):
                if ask(Q.imaginary(expr.exp), assumptions):
                    return True
            # If the i = (exp's arg)/(I*pi) is an integer or half-integer
            # multiple of I*pi then 2*i will be an integer. In addition,
            # exp(i*I*pi) = (-1)**i so the overall realness of the expr
            # can be determined by replacing exp(i*I*pi) with (-1)**i.
            i = expr.base.args[0]/I/pi
            if ask(Q.integer(2*i), assumptions):
                return ask(Q.real(((-1)**i)**expr.exp), assumptions)
            return

        if ask(Q.imaginary(expr.base), assumptions):
            if ask(Q.integer(expr.exp), assumptions):
                odd = ask(Q.odd(expr.exp), assumptions)
                if odd is not None:
                    return not odd
                return

        if ask(Q.imaginary(expr.exp), assumptions):
            imlog = ask(Q.imaginary(log(expr.base)), assumptions)
            if imlog is not None:
                # I**i -> real, log(I) is imag;
                # (2*I)**i -> complex, log(2*I) is not imag
                return imlog

        if ask(Q.real(expr.base), assumptions):
            if ask(Q.real(expr.exp), assumptions):
                if expr.exp.is_Rational and \
                        ask(Q.even(expr.exp.q), assumptions):
                    return ask(Q.positive(expr.base), assumptions)
                elif ask(Q.integer(expr.exp), assumptions):
                    return True
                elif ask(Q.positive(expr.base), assumptions):
                    return True
                elif ask(Q.negative(expr.base), assumptions):
                    return False
Exemplo n.º 8
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
Exemplo n.º 9
0
    def Pow(expr, assumptions):
        """
        Imaginary**Odd        -> Imaginary
        Imaginary**Even       -> Real
        b**Imaginary          -> !Imaginary if exponent is an integer multiple of I*pi/log(b)
        Imaginary**Real       -> ?
        Positive**Real        -> Real
        Negative**Integer     -> Real
        Negative**(Integer/2) -> Imaginary
        Negative**Real        -> not Imaginary if exponent is not Rational
        """
        if expr.is_number:
            return AskImaginaryHandler._number(expr, assumptions)

        if expr.base.func == exp:
            if ask(Q.imaginary(expr.base.args[0]), assumptions):
                if ask(Q.imaginary(expr.exp), assumptions):
                    return False
                i = expr.base.args[0]/I/pi
                if ask(Q.integer(2*i), assumptions):
                    return ask(Q.imaginary(((-1)**i)**expr.exp), assumptions)

        if ask(Q.imaginary(expr.base), assumptions):
            if ask(Q.integer(expr.exp), assumptions):
                odd = ask(Q.odd(expr.exp), assumptions)
                if odd is not None:
                    return odd
                return

        if ask(Q.imaginary(expr.exp), assumptions):
            imlog = ask(Q.imaginary(log(expr.base)), assumptions)
            if imlog is not None:
                return False  # I**i -> real; (2*I)**i -> complex ==> not imaginary

        if ask(Q.real(expr.base) & Q.real(expr.exp), assumptions):
            if ask(Q.positive(expr.base), assumptions):
                return False
            else:
                rat = ask(Q.rational(expr.exp), assumptions)
                if not rat:
                    return rat
                if ask(Q.integer(expr.exp), assumptions):
                    return False
                else:
                    half = ask(Q.integer(2*expr.exp), assumptions)
                    if half:
                        return ask(Q.negative(expr.base), assumptions)
                    return half
Exemplo n.º 10
0
 def MatPow(expr, assumptions):
     # only for integer powers
     base, exp = expr.args
     int_exp = ask(Q.integer(exp), assumptions)
     if int_exp:
         return ask(Q.unitary(base), assumptions)
     return None
Exemplo n.º 11
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
Exemplo n.º 12
0
 def Pow(expr, assumptions):
     """
     Imaginary**integer -> Imaginary if integer % 2 == 1
     Imaginary**integer -> real if integer % 2 == 0
     Imaginary**Imaginary    -> ?
     Imaginary**Real         -> ?
     """
     if expr.is_number:
         return AskImaginaryHandler._number(expr, assumptions)
     if ask(Q.imaginary(expr.base), assumptions):
         if ask(Q.real(expr.exp), assumptions):
             if ask(Q.odd(expr.exp), assumptions):
                 return True
             elif ask(Q.even(expr.exp), assumptions):
                 return False
     elif ask(Q.real(expr.base), assumptions):
         if ask(Q.real(expr.exp), assumptions):
             if expr.exp.is_Rational and \
                ask(Q.even(expr.exp.q), assumptions):
                 return ask(Q.negative(expr.base),assumptions)
             elif ask(Q.integer(expr.exp), assumptions):
                 return False
             elif ask(Q.positive(expr.base), assumptions):
                 return False
             elif ask(Q.negative(expr.base), assumptions):
                 return True
Exemplo n.º 13
0
 def MatPow(expr, assumptions):
     # only for integer powers
     base, exp = expr.args
     int_exp = ask(Q.integer(exp), assumptions)
     if int_exp and ask(~Q.negative(exp), assumptions):
         return ask(Q.fullrank(base), assumptions)
     return None
Exemplo n.º 14
0
 def Mul(expr, assumptions):
     """
     Integer*Integer      -> Integer
     Integer*Irrational   -> !Integer
     Odd/Even             -> !Integer
     Integer*Rational     -> ?
     """
     if expr.is_number:
         return AskIntegerHandler._number(expr, assumptions)
     _output = True
     for arg in expr.args:
         if not ask(Q.integer(arg), assumptions):
             if arg.is_Rational:
                 if arg.q == 2:
                     return ask(Q.even(2*expr), assumptions)
                 if ~(arg.q & 1):
                     return None
             elif ask(Q.irrational(arg), assumptions):
                 if _output:
                     _output = False
                 else:
                     return
             else:
                 return
     else:
         return _output
Exemplo n.º 15
0
 def Basic(expr, assumptions):
     _integer = ask(Q.integer(expr), assumptions)
     if _integer:
         _even = ask(Q.even(expr), assumptions)
         if _even is None: return None
         return not _even
     return _integer
Exemplo n.º 16
0
 def Mul(expr, assumptions):
     """
     Even * Integer -> Even
     Even * Odd     -> Even
     Integer * Odd  -> ?
     Odd * Odd      -> Odd
     """
     if expr.is_number:
         return AskEvenHandler._number(expr, assumptions)
     even, odd, irrational = False, 0, False
     for arg in expr.args:
         # check for all integers and at least one even
         if ask(Q.integer(arg), assumptions):
             if ask(Q.even(arg), assumptions):
                 even = True
             elif ask(Q.odd(arg), assumptions):
                 odd += 1
         elif ask(Q.irrational(arg), assumptions):
             # one irrational makes the result False
             # two makes it undefined
             if irrational:
                 break
             irrational = True
         else:
             break
     else:
         if irrational:
             return False
         if even:
             return True
         if odd == len(expr.args):
             return False
Exemplo n.º 17
0
def refine_exp(expr, assumptions):
    """
    Handler for exponential function.

    >>> from sympy import Symbol, Q, exp, I, pi
    >>> from sympy.assumptions.refine import refine_exp
    >>> from sympy.abc import x
    >>> refine_exp(exp(pi*I*2*x), Q.real(x))
    >>> refine_exp(exp(pi*I*2*x), Q.integer(x))
    1

    """
    arg = expr.args[0]
    if arg.is_Mul:
        coeff = arg.as_coefficient(S.Pi*S.ImaginaryUnit)
        if coeff:
            if ask(Q.integer(2*coeff), assumptions):
                if ask(Q.even(coeff), assumptions):
                    return S.One
                elif ask(Q.odd(coeff), assumptions):
                    return S.NegativeOne
                elif ask(Q.even(coeff + S.Half), assumptions):
                    return -S.ImaginaryUnit
                elif ask(Q.odd(coeff + S.Half), assumptions):
                    return S.ImaginaryUnit
Exemplo n.º 18
0
 def Pow(expr, assumptions):
     """
     Real**Integer         -> Real
     Positive**Real        -> Real
     Real**(Integer/Even)  -> Real if base is nonnegative
     Real**(Integer/Odd)   -> Real
     Real**Imaginary       -> ?
     Imaginary**Real       -> ?
     Real**Real            -> ?
     """
     if expr.is_number:
         return AskRealHandler._number(expr, assumptions)
     if ask(Q.imaginary(expr.base), assumptions):
         if ask(Q.real(expr.exp), assumptions):
             if ask(Q.odd(expr.exp), assumptions):
                 return False
             elif ask(Q.even(expr.exp), assumptions):
                 return True
     elif ask(Q.real(expr.base), assumptions):
         if ask(Q.real(expr.exp), assumptions):
             if expr.exp.is_Rational and \
                ask(Q.even(expr.exp.q), assumptions):
                 return ask(Q.positive(expr.base), assumptions)
             elif ask(Q.integer(expr.exp), assumptions):
                 return True
             elif ask(Q.positive(expr.base), assumptions):
                 return True
             elif ask(Q.negative(expr.base), assumptions):
                 return False
Exemplo n.º 19
0
Arquivo: sets.py Projeto: B-Rich/sympy
    def Pow(expr, assumptions):
        """
        Imaginary**integer/odd  -> Imaginary
        Imaginary**integer/even -> Real if integer % 2 == 0
        b**Imaginary            -> !Imaginary if exponent is an integer multiple of I*pi/log(b)
        Imaginary**Real         -> ?
        Negative**even root     -> Imaginary
        Negative**odd root      -> Real
        Negative**Real          -> Imaginary
        Real**Integer           -> Real
        Real**Positive          -> Real
        """
        if expr.is_number:
            return AskImaginaryHandler._number(expr, assumptions)

        if expr.base.func == C.exp:
            if ask(Q.imaginary(expr.base.args[0]), assumptions):
                if ask(Q.imaginary(expr.exp), assumptions):
                    return False
                i = expr.base.args[0]/I/pi
                if ask(Q.integer(2*i), assumptions):
                    return ask(Q.imaginary(((-1)**i)**expr.exp), assumptions)

        if ask(Q.imaginary(expr.base), assumptions):
            if ask(Q.integer(expr.exp), assumptions):
                odd = ask(Q.odd(expr.exp), assumptions)
                if odd is not None:
                    return odd
                return

        if ask(Q.imaginary(expr.exp), assumptions):
            imlog = ask(Q.imaginary(C.log(expr.base)), assumptions)
            if imlog is not None:
                return False  # I**i -> real; (2*I)**i -> complex ==> not imaginary

        if ask(Q.real(expr.base), assumptions):
            if ask(Q.real(expr.exp), assumptions):
                if ask(Q.rational(expr.exp) & Q.even(denom(expr.exp)), assumptions):
                    return ask(Q.negative(expr.base), assumptions)
                elif ask(Q.integer(expr.exp), assumptions):
                    return False
                elif ask(Q.positive(expr.base), assumptions):
                    return False
                elif ask(Q.negative(expr.base), assumptions):
                    return True
Exemplo n.º 20
0
 def Mul(expr, assumptions):
     if expr.is_number:
         return AskPrimeHandler._number(expr, assumptions)
     for arg in expr.args:
         if not ask(Q.integer(arg), assumptions):
             return None
     for arg in expr.args:
         if arg.is_number and arg.is_composite:
             return False
Exemplo n.º 21
0
 def MatPow(expr, assumptions):
     # only for integer powers
     base, exp = expr.args
     int_exp = ask(Q.integer(exp), assumptions)
     if not int_exp:
         return None
     if exp.is_negative == False:
         return ask(Q.integer_elements(base), assumptions)
     return None
Exemplo n.º 22
0
 def Pow(expr, assumptions):
     """
     Hermitian**Integer -> Hermitian
     """
     if expr.is_number:
         return AskRealHandler._number(expr, assumptions)
     if ask(Q.hermitian(expr.base), assumptions):
         if ask(Q.integer(expr.exp), assumptions):
             return True
Exemplo n.º 23
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
Exemplo n.º 24
0
 def Mul(expr, assumptions):
     if expr.is_number:
         return AskPrimeHandler._number(expr, assumptions)
     for arg in expr.args:
         if ask(Q.integer(arg), assumptions):
             pass
         else: break
     else:
         # a product of integers can't be a prime
         return False
Exemplo n.º 25
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
Exemplo n.º 26
0
 def Pow(expr, assumptions):
     if expr.is_number:
         return AskEvenHandler._number(expr, assumptions)
     if ask(Q.integer(expr.exp), assumptions):
         if ask(Q.positive(expr.exp), assumptions):
             return ask(Q.even(expr.base), assumptions)
         elif ask(~Q.negative(expr.exp) & Q.odd(expr.base), assumptions):
             return False
         elif expr.base is S.NegativeOne:
             return False
Exemplo n.º 27
0
 def MatPow(expr, assumptions):
     # only for integer powers
     base, exp = expr.args
     int_exp = ask(Q.integer(exp), assumptions)
     if not int_exp:
         return None
     non_negative = ask(~Q.negative(exp), assumptions)
     if (non_negative or non_negative == False
             and ask(Q.invertible(base), assumptions)):
         return ask(Q.complex_elements(base), assumptions)
     return None
Exemplo n.º 28
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
Exemplo n.º 29
0
 def Mul(expr, assumptions):
     if expr.is_number:
         return AskPrimeHandler._number(expr, assumptions)
     for arg in expr.args:
         if ask(Q.integer(arg), assumptions):
             pass
         else:
             break
     else:
         # a product of integers can't be a prime
         return False
Exemplo n.º 30
0
def _(expr, assumptions):
    # only for integer powers
    base, exp = expr.args
    int_exp = ask(Q.integer(exp), assumptions)
    if not int_exp:
        return None
    non_negative = ask(~Q.negative(exp), assumptions)
    if (non_negative
            or non_negative == False and ask(Q.invertible(base), assumptions)):
        return ask(Q.diagonal(base), assumptions)
    return None
Exemplo n.º 31
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
Exemplo n.º 32
0
 def MatPow(expr, assumptions):
     # only for integer powers
     base, exp = expr.args
     int_exp = ask(Q.integer(exp), assumptions)
     if not int_exp:
         return None
     non_negative = ask(~Q.negative(exp), assumptions)
     if (non_negative or non_negative == False
                         and ask(Q.invertible(base), assumptions)):
         return ask(Q.complex_elements(base), assumptions)
     return None
Exemplo n.º 33
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
Exemplo n.º 34
0
def _(expr, assumptions):
    """
    * Hermitian**Integer -> Hermitian
    """
    if expr.is_number:
        return None
    if expr.base == E:
        if ask(Q.hermitian(expr.exp), assumptions):
            return True
        return
    if ask(Q.hermitian(expr.base), assumptions):
        if ask(Q.integer(expr.exp), assumptions):
            return True
Exemplo n.º 35
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
Exemplo n.º 36
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
Exemplo n.º 37
0
def test_composite_proposition():
    from sympy.logic.boolalg import Equivalent, Implies
    x = symbols('x')
    assert ask(True) is True
    assert ask(~Q.negative(x), Q.positive(x)) is True
    assert ask(~Q.real(x), Q.commutative(x)) is None
    assert ask(Q.negative(x) & Q.integer(x), Q.positive(x)) is False
    assert ask(Q.negative(x) & Q.integer(x)) is None
    assert ask(Q.real(x) | Q.integer(x), Q.positive(x)) is True
    assert ask(Q.real(x) | Q.integer(x)) is None
    assert ask(Q.real(x) >> Q.positive(x), Q.negative(x)) is False
    assert ask(Implies(Q.real(x), Q.positive(x), evaluate=False), Q.negative(x)) is False
    assert ask(Implies(Q.real(x), Q.positive(x), evaluate=False)) is None
    assert ask(Equivalent(Q.integer(x), Q.even(x)), Q.even(x)) is True
    assert ask(Equivalent(Q.integer(x), Q.even(x))) is None
    assert ask(Equivalent(Q.positive(x), Q.integer(x)), Q.integer(x)) is None
Exemplo n.º 38
0
def test_composite_proposition():
    from sympy.logic.boolalg import Equivalent, Implies
    x = symbols('x')
    assert ask(True) is True
    assert ask(~Q.negative(x), Q.positive(x)) is True
    assert ask(~Q.real(x), Q.commutative(x)) is None
    assert ask(Q.negative(x) & Q.integer(x), Q.positive(x)) is False
    assert ask(Q.negative(x) & Q.integer(x)) is None
    assert ask(Q.real(x) | Q.integer(x), Q.positive(x)) is True
    assert ask(Q.real(x) | Q.integer(x)) is None
    assert ask(Q.real(x) >> Q.positive(x), Q.negative(x)) is False
    assert ask(Implies(Q.real(x), Q.positive(x), evaluate=False), Q.negative(x)) is False
    assert ask(Implies(Q.real(x), Q.positive(x), evaluate=False)) is None
    assert ask(Equivalent(Q.integer(x), Q.even(x)), Q.even(x)) is True
    assert ask(Equivalent(Q.integer(x), Q.even(x))) is None
    assert ask(Equivalent(Q.positive(x), Q.integer(x)), Q.integer(x)) is None
Exemplo n.º 39
0
def _(expr, assumptions):
    """
    * Hermitian**Integer -> Hermitian
    """
    if expr.is_number:
        raise MDNotImplementedError
    if expr.base == E:
        if ask(Q.hermitian(expr.exp), assumptions):
            return True
        raise MDNotImplementedError
    if ask(Q.hermitian(expr.base), assumptions):
        if ask(Q.integer(expr.exp), assumptions):
            return True
    raise MDNotImplementedError
Exemplo n.º 40
0
 def Pow(expr, assumptions):
     """
     Hermitian**Integer  -> !Antihermitian
     Antihermitian**Even -> !Antihermitian
     Antihermitian**Odd  -> Antihermitian
     """
     if expr.is_number:
         return AskImaginaryHandler._number(expr, assumptions)
     if ask(Q.hermitian(expr.base), assumptions):
         if ask(Q.integer(expr.exp), assumptions):
             return False
     elif ask(Q.antihermitian(expr.base), assumptions):
         if ask(Q.even(expr.exp), assumptions):
             return False
         elif ask(Q.odd(expr.exp), assumptions):
             return True
Exemplo n.º 41
0
Arquivo: sets.py Projeto: siv2r/sympy
def _(expr, assumptions):
    """
    * Hermitian**Integer  -> !Antihermitian
    * Antihermitian**Even -> !Antihermitian
    * Antihermitian**Odd  -> Antihermitian
    """
    if expr.is_number:
        return None
    if ask(Q.hermitian(expr.base), assumptions):
        if ask(Q.integer(expr.exp), assumptions):
            return False
    elif ask(Q.antihermitian(expr.base), assumptions):
        if ask(Q.even(expr.exp), assumptions):
            return False
        elif ask(Q.odd(expr.exp), assumptions):
            return True
Exemplo n.º 42
0
def _(expr, assumptions):
    """
    * Imaginary**Odd        -> Imaginary
    * Imaginary**Even       -> Real
    * b**Imaginary          -> !Imaginary if exponent is an integer
                               multiple of I*pi/log(b)
    * Imaginary**Real       -> ?
    * Positive**Real        -> Real
    * Negative**Integer     -> Real
    * Negative**(Integer/2) -> Imaginary
    * Negative**Real        -> not Imaginary if exponent is not Rational
    """
    if expr.is_number:
        return _Imaginary_number(expr, assumptions)

    if expr.base == E:
        a = expr.exp / I / pi
        return ask(Q.integer(2 * a) & ~Q.integer(a), assumptions)

    if expr.base.func == exp or (expr.base.is_Pow and expr.base.base == E):
        if ask(Q.imaginary(expr.base.exp), assumptions):
            if ask(Q.imaginary(expr.exp), assumptions):
                return False
            i = expr.base.exp / I / pi
            if ask(Q.integer(2 * i), assumptions):
                return ask(Q.imaginary((S.NegativeOne**i)**expr.exp),
                           assumptions)

    if ask(Q.imaginary(expr.base), assumptions):
        if ask(Q.integer(expr.exp), assumptions):
            odd = ask(Q.odd(expr.exp), assumptions)
            if odd is not None:
                return odd
            return

    if ask(Q.imaginary(expr.exp), assumptions):
        imlog = ask(Q.imaginary(log(expr.base)), assumptions)
        if imlog is not None:
            # I**i -> real; (2*I)**i -> complex ==> not imaginary
            return False

    if ask(Q.real(expr.base) & Q.real(expr.exp), assumptions):
        if ask(Q.positive(expr.base), assumptions):
            return False
        else:
            rat = ask(Q.rational(expr.exp), assumptions)
            if not rat:
                return rat
            if ask(Q.integer(expr.exp), assumptions):
                return False
            else:
                half = ask(Q.integer(2 * expr.exp), assumptions)
                if half:
                    return ask(Q.negative(expr.base), assumptions)
                return half
Exemplo n.º 43
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
Exemplo n.º 44
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
Exemplo n.º 45
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
Exemplo n.º 46
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
Exemplo n.º 47
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
Exemplo n.º 48
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
Exemplo n.º 49
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
Exemplo n.º 50
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
Exemplo n.º 51
0
    def _eval_refine(self, assumptions):
        from sympy.assumptions import ask, Q
        arg = self.args[0]
        if arg.is_Mul:
            Ioo = S.ImaginaryUnit * S.Infinity
            if arg in [Ioo, -Ioo]:
                return S.NaN

            coeff = arg.as_coefficient(S.Pi * S.ImaginaryUnit)
            if coeff:
                if ask(Q.integer(2 * coeff)):
                    if ask(Q.even(coeff)):
                        return S.One
                    elif ask(Q.odd(coeff)):
                        return S.NegativeOne
                    elif ask(Q.even(coeff + S.Half)):
                        return -S.ImaginaryUnit
                    elif ask(Q.odd(coeff + S.Half)):
                        return S.ImaginaryUnit
Exemplo n.º 52
0
 def Pow(expr, assumptions):
     """
     Real**Integer         -> Real
     Positive**Real        -> Real
     Real**(Integer/Even)  -> Real if base is nonnegative
     Real**(Integer/Odd)   -> Real
     """
     if expr.is_number:
         return AskRealHandler._number(expr, assumptions)
     if ask(Q.real(expr.base), assumptions):
         if ask(Q.integer(expr.exp), assumptions):
             return True
         elif expr.exp.is_Rational:
             if (expr.exp.q % 2 == 0):
                 return ask(Q.real(expr.base), assumptions) and \
                    not ask(Q.negative(expr.base), assumptions)
             else: return True
         elif ask(Q.real(expr.exp), assumptions):
             if ask(Q.positive(expr.base), assumptions):
                 return True
Exemplo n.º 53
0
def test_even():
    x, y, z, t = symbols('x,y,z,t')
    assert ask(Q.even(x)) == None
    assert ask(Q.even(x), Q.integer(x)) == None
    assert ask(Q.even(x), ~Q.integer(x)) == False
    assert ask(Q.even(x), Q.rational(x)) == None
    assert ask(Q.even(x), Q.positive(x)) == None

    assert ask(Q.even(2 * x)) == None
    assert ask(Q.even(2 * x), Q.integer(x)) == True
    assert ask(Q.even(2 * x), Q.even(x)) == True
    assert ask(Q.even(2 * x), Q.irrational(x)) == False
    assert ask(Q.even(2 * x), Q.odd(x)) == True
    assert ask(Q.even(2 * x), ~Q.integer(x)) == None
    assert ask(Q.even(3 * x), Q.integer(x)) == None
    assert ask(Q.even(3 * x), Q.even(x)) == True
    assert ask(Q.even(3 * x), Q.odd(x)) == False

    assert ask(Q.even(x + 1), Q.odd(x)) == True
    assert ask(Q.even(x + 1), Q.even(x)) == False
    assert ask(Q.even(x + 2), Q.odd(x)) == False
    assert ask(Q.even(x + 2), Q.even(x)) == True
    assert ask(Q.even(7 - x), Q.odd(x)) == True
    assert ask(Q.even(7 + x), Q.odd(x)) == True
    assert ask(Q.even(x + y), Q.odd(x) & Q.odd(y)) == True
    assert ask(Q.even(x + y), Q.odd(x) & Q.even(y)) == False
    assert ask(Q.even(x + y), Q.even(x) & Q.even(y)) == True

    assert ask(Q.even(2 * x + 1), Q.integer(x)) == False
    assert ask(Q.even(2 * x * y), Q.rational(x) & Q.rational(x)) == None
    assert ask(Q.even(2 * x * y), Q.irrational(x) & Q.irrational(x)) == None

    assert ask(Q.even(x + y + z), Q.odd(x) & Q.odd(y) & Q.even(z)) == True
    assert ask(Q.even(x + y + z + t),
               Q.odd(x) & Q.odd(y) & Q.even(z) & Q.integer(t)) == None

    assert ask(Q.even(Abs(x)), Q.even(x)) == True
    assert ask(Q.even(Abs(x)), ~Q.even(x)) == None
    assert ask(Q.even(re(x)), Q.even(x)) == True
    assert ask(Q.even(re(x)), ~Q.even(x)) == None
    assert ask(Q.even(im(x)), Q.even(x)) == True
    assert ask(Q.even(im(x)), Q.real(x)) == True
Exemplo n.º 54
0
def _(expr, assumptions):
    """
    Even * Integer    -> Even
    Even * Odd        -> Even
    Integer * Odd     -> ?
    Odd * Odd         -> Odd
    Even * Even       -> Even
    Integer * Integer -> Even if Integer + Integer = Odd
    otherwise         -> ?
    """
    if expr.is_number:
        return _EvenPredicate_number(expr, assumptions)
    even, odd, irrational, acc = False, 0, False, 1
    for arg in expr.args:
        # check for all integers and at least one even
        if ask(Q.integer(arg), assumptions):
            if ask(Q.even(arg), assumptions):
                even = True
            elif ask(Q.odd(arg), assumptions):
                odd += 1
            elif not even and acc != 1:
                if ask(Q.odd(acc + arg), assumptions):
                    even = True
        elif ask(Q.irrational(arg), assumptions):
            # one irrational makes the result False
            # two makes it undefined
            if irrational:
                break
            irrational = True
        else:
            break
        acc = arg
    else:
        if irrational:
            return False
        if even:
            return True
        if odd == len(expr.args):
            return False
Exemplo n.º 55
0
def test_rational():
    x, y = symbols('x,y')
    assert ask(Q.rational(x), Q.integer(x)) == True
    assert ask(Q.rational(x), Q.irrational(x)) == False
    assert ask(Q.rational(x), Q.real(x)) == None
    assert ask(Q.rational(x), Q.positive(x)) == None
    assert ask(Q.rational(x), Q.negative(x)) == None
    assert ask(Q.rational(x), Q.nonzero(x)) == None

    assert ask(Q.rational(2 * x), Q.rational(x)) == True
    assert ask(Q.rational(2 * x), Q.integer(x)) == True
    assert ask(Q.rational(2 * x), Q.even(x)) == True
    assert ask(Q.rational(2 * x), Q.odd(x)) == True
    assert ask(Q.rational(2 * x), Q.irrational(x)) == False

    assert ask(Q.rational(x / 2), Q.rational(x)) == True
    assert ask(Q.rational(x / 2), Q.integer(x)) == True
    assert ask(Q.rational(x / 2), Q.even(x)) == True
    assert ask(Q.rational(x / 2), Q.odd(x)) == True
    assert ask(Q.rational(x / 2), Q.irrational(x)) == False

    assert ask(Q.rational(1 / x), Q.rational(x)) == True
    assert ask(Q.rational(1 / x), Q.integer(x)) == True
    assert ask(Q.rational(1 / x), Q.even(x)) == True
    assert ask(Q.rational(1 / x), Q.odd(x)) == True
    assert ask(Q.rational(1 / x), Q.irrational(x)) == False

    assert ask(Q.rational(2 / x), Q.rational(x)) == True
    assert ask(Q.rational(2 / x), Q.integer(x)) == True
    assert ask(Q.rational(2 / x), Q.even(x)) == True
    assert ask(Q.rational(2 / x), Q.odd(x)) == True
    assert ask(Q.rational(2 / x), Q.irrational(x)) == False

    # with multiple symbols
    assert ask(Q.rational(x * y), Q.irrational(x) & Q.irrational(y)) == None
    assert ask(Q.rational(y / x), Q.rational(x) & Q.rational(y)) == True
    assert ask(Q.rational(y / x), Q.integer(x) & Q.rational(y)) == True
    assert ask(Q.rational(y / x), Q.even(x) & Q.rational(y)) == True
    assert ask(Q.rational(y / x), Q.odd(x) & Q.rational(y)) == True
    assert ask(Q.rational(y / x), Q.irrational(x) & Q.rational(y)) == False
Exemplo n.º 56
0
 def Abs(expr, assumptions):
     return ask(Q.integer(expr.args[0]), assumptions)
Exemplo n.º 57
0
def refine_Pow(expr, assumptions):
    """
    Handler for instances of Pow.

    >>> from sympy import Symbol, Q
    >>> from sympy.assumptions.refine import refine_Pow
    >>> from sympy.abc import x,y,z
    >>> refine_Pow((-1)**x, Q.real(x))
    >>> refine_Pow((-1)**x, Q.even(x))
    1
    >>> refine_Pow((-1)**x, Q.odd(x))
    -1

    For powers of -1, even parts of the exponent can be simplified:

    >>> refine_Pow((-1)**(x+y), Q.even(x))
    (-1)**y
    >>> refine_Pow((-1)**(x+y+z), Q.odd(x) & Q.odd(z))
    (-1)**y
    >>> refine_Pow((-1)**(x+y+2), Q.odd(x))
    (-1)**(y + 1)
    >>> refine_Pow((-1)**(x+3), True)
    (-1)**(x + 1)

    """
    from sympy.core import Pow, Rational
    from sympy.functions.elementary.complexes import Abs
    from sympy.functions import sign
    if isinstance(expr.base, Abs):
        if ask(Q.real(expr.base.args[0]), assumptions) and \
                ask(Q.even(expr.exp), assumptions):
            return expr.base.args[0]**expr.exp
    if ask(Q.real(expr.base), assumptions):
        if expr.base.is_number:
            if ask(Q.even(expr.exp), assumptions):
                return abs(expr.base)**expr.exp
            if ask(Q.odd(expr.exp), assumptions):
                return sign(expr.base) * abs(expr.base)**expr.exp
        if isinstance(expr.exp, Rational):
            if type(expr.base) is Pow:
                return abs(expr.base.base)**(expr.base.exp * expr.exp)

        if expr.base is S.NegativeOne:
            if expr.exp.is_Add:

                old = expr

                # For powers of (-1) we can remove
                #  - even terms
                #  - pairs of odd terms
                #  - a single odd term + 1
                #  - A numerical constant N can be replaced with mod(N,2)

                coeff, terms = expr.exp.as_coeff_add()
                terms = set(terms)
                even_terms = set([])
                odd_terms = set([])
                initial_number_of_terms = len(terms)

                for t in terms:
                    if ask(Q.even(t), assumptions):
                        even_terms.add(t)
                    elif ask(Q.odd(t), assumptions):
                        odd_terms.add(t)

                terms -= even_terms
                if len(odd_terms) % 2:
                    terms -= odd_terms
                    new_coeff = (coeff + S.One) % 2
                else:
                    terms -= odd_terms
                    new_coeff = coeff % 2

                if new_coeff != coeff or len(terms) < initial_number_of_terms:
                    terms.add(new_coeff)
                    expr = expr.base**(Add(*terms))

                # Handle (-1)**((-1)**n/2 + m/2)
                e2 = 2 * expr.exp
                if ask(Q.even(e2), assumptions):
                    if e2.could_extract_minus_sign():
                        e2 *= expr.base
                if e2.is_Add:
                    i, p = e2.as_two_terms()
                    if p.is_Pow and p.base is S.NegativeOne:
                        if ask(Q.integer(p.exp), assumptions):
                            i = (i + 1) / 2
                            if ask(Q.even(i), assumptions):
                                return expr.base**p.exp
                            elif ask(Q.odd(i), assumptions):
                                return expr.base**(p.exp + 1)
                            else:
                                return expr.base**(p.exp + i)

                if old != expr:
                    return expr
Exemplo n.º 58
0
def _(expr, assumptions):
    a = expr.exp / I / pi
    return ask(Q.integer(2 * a) & ~Q.integer(a), assumptions)
Exemplo n.º 59
0
def _(expr, assumptions):
    return ask(Q.integer(expr.exp / I / pi) | Q.real(expr.exp), assumptions)
Exemplo n.º 60
0
def _(expr, assumptions):
    """
    * Real**Integer              -> Real
    * Positive**Real             -> Real
    * Real**(Integer/Even)       -> Real if base is nonnegative
    * Real**(Integer/Odd)        -> Real
    * Imaginary**(Integer/Even)  -> Real
    * Imaginary**(Integer/Odd)   -> not Real
    * Imaginary**Real            -> ? since Real could be 0 (giving real)
                                    or 1 (giving imaginary)
    * b**Imaginary               -> Real if log(b) is imaginary and b != 0
                                    and exponent != integer multiple of
                                    I*pi/log(b)
    * Real**Real                 -> ? e.g. sqrt(-1) is imaginary and
                                    sqrt(2) is not
    """
    if expr.is_number:
        return _RealPredicate_number(expr, assumptions)

    if expr.base == E:
        return ask(
            Q.integer(expr.exp / I / pi) | Q.real(expr.exp), assumptions)

    if expr.base.func == exp or (expr.base.is_Pow and expr.base.base == E):
        if ask(Q.imaginary(expr.base.exp), assumptions):
            if ask(Q.imaginary(expr.exp), assumptions):
                return True
        # If the i = (exp's arg)/(I*pi) is an integer or half-integer
        # multiple of I*pi then 2*i will be an integer. In addition,
        # exp(i*I*pi) = (-1)**i so the overall realness of the expr
        # can be determined by replacing exp(i*I*pi) with (-1)**i.
        i = expr.base.exp / I / pi
        if ask(Q.integer(2 * i), assumptions):
            return ask(Q.real(((-1)**i)**expr.exp), assumptions)
        return

    if ask(Q.imaginary(expr.base), assumptions):
        if ask(Q.integer(expr.exp), assumptions):
            odd = ask(Q.odd(expr.exp), assumptions)
            if odd is not None:
                return not odd
            return

    if ask(Q.imaginary(expr.exp), assumptions):
        imlog = ask(Q.imaginary(log(expr.base)), assumptions)
        if imlog is not None:
            # I**i -> real, log(I) is imag;
            # (2*I)**i -> complex, log(2*I) is not imag
            return imlog

    if ask(Q.real(expr.base), assumptions):
        if ask(Q.real(expr.exp), assumptions):
            if expr.exp.is_Rational and \
                    ask(Q.even(expr.exp.q), assumptions):
                return ask(Q.positive(expr.base), assumptions)
            elif ask(Q.integer(expr.exp), assumptions):
                return True
            elif ask(Q.positive(expr.base), assumptions):
                return True
            elif ask(Q.negative(expr.base), assumptions):
                return False