Python Q.imaginary方法代码示例

# 需要导入模块: from sympy.assumptions import Q [as 别名]
# 或者: from sympy.assumptions.Q import imaginary [as 别名]
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

# 需要导入模块: from sympy.assumptions import Q [as 别名]
# 或者: from sympy.assumptions.Q import imaginary [as 别名]
    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

# 需要导入模块: from sympy.assumptions import Q [as 别名]
# 或者: from sympy.assumptions.Q import imaginary [as 别名]
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

# 需要导入模块: from sympy.assumptions import Q [as 别名]
# 或者: from sympy.assumptions.Q import imaginary [as 别名]
 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

# 需要导入模块: from sympy.assumptions import Q [as 别名]
# 或者: from sympy.assumptions.Q import imaginary [as 别名]
 def log(expr, assumptions):
     if ask(Q.real(expr.args[0]), assumptions):
         if ask(Q.positive(expr.args[0]), assumptions):
             return False
         return
     # XXX it should be enough to do
     # return ask(Q.nonpositive(expr.args[0]), assumptions)
     # but ask(Q.nonpositive(exp(x)), Q.imaginary(x)) -> None;
     # it should return True since exp(x) will be either 0 or complex
     if expr.args[0].func == exp:
         if expr.args[0].args[0] in [I, -I]:
             return True
     im = ask(Q.imaginary(expr.args[0]), assumptions)
     if im is False:
         return False

# 需要导入模块: from sympy.assumptions import Q [as 别名]
# 或者: from sympy.assumptions.Q import imaginary [as 别名]
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

# 需要导入模块: from sympy.assumptions import Q [as 别名]
# 或者: from sympy.assumptions.Q import imaginary [as 别名]
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

# 需要导入模块: from sympy.assumptions import Q [as 别名]
# 或者: from sympy.assumptions.Q import imaginary [as 别名]
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

# 需要导入模块: from sympy.assumptions import Q [as 别名]
# 或者: from sympy.assumptions.Q import imaginary [as 别名]
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

# 需要导入模块: from sympy.assumptions import Q [as 别名]
# 或者: from sympy.assumptions.Q import imaginary [as 别名]
 def Mul(expr, assumptions):
     """
     Real*Real               -> Real
     Real*Imaginary          -> !Real
     Imaginary*Imaginary     -> Real
     """
     if expr.is_number:
         return AskRealHandler._number(expr, assumptions)
     result = True
     for arg in expr.args:
         if ask(Q.real(arg), assumptions):
             pass
         elif ask(Q.imaginary(arg), assumptions):
             result = result ^ True
         else:
             break
     else:
         return result

# 需要导入模块: from sympy.assumptions import Q [as 别名]
# 或者: from sympy.assumptions.Q import imaginary [as 别名]
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

# 需要导入模块: from sympy.assumptions import Q [as 别名]
# 或者: from sympy.assumptions.Q import imaginary [as 别名]
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

# 需要导入模块: from sympy.assumptions import Q [as 别名]
# 或者: from sympy.assumptions.Q import imaginary [as 别名]
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

# 需要导入模块: from sympy.assumptions import Q [as 别名]
# 或者: from sympy.assumptions.Q import imaginary [as 别名]
 def Add(expr, assumptions):
     """
     Imaginary + Imaginary -> Imaginary
     Imaginary + Complex   -> ?
     Imaginary + Real      -> !Imaginary
     """
     if expr.is_number:
         return AskImaginaryHandler._number(expr, assumptions)
     reals = 0
     for arg in expr.args:
         if ask(Q.imaginary(arg), assumptions):
             pass
         elif ask(Q.real(arg), assumptions):
             reals += 1
         else:
             break
     else:
         if reals == 0:
             return True
         if reals == 1 or (len(expr.args) == reals):
             # two reals could sum 0 thus giving an imaginary
             return False

# 需要导入模块: from sympy.assumptions import Q [as 别名]
# 或者: from sympy.assumptions.Q import imaginary [as 别名]
def test_commutative():
    """By default objects are Q.commutative that is why it returns True
    for both key=True and key=False"""
    x, y = symbols('x,y')
    assert ask(Q.commutative(x)) == True
    assert ask(Q.commutative(x), ~Q.commutative(x)) == False
    assert ask(Q.commutative(x), Q.complex(x)) == True
    assert ask(Q.commutative(x), Q.imaginary(x)) == True
    assert ask(Q.commutative(x), Q.real(x)) == True
    assert ask(Q.commutative(x), Q.positive(x)) == True
    assert ask(Q.commutative(x), ~Q.commutative(y))  == True

    assert ask(Q.commutative(2*x)) == True
    assert ask(Q.commutative(2*x), ~Q.commutative(x)) == False

    assert ask(Q.commutative(x + 1)) == True
    assert ask(Q.commutative(x + 1), ~Q.commutative(x)) == False

    assert ask(Q.commutative(x**2)) == True
    assert ask(Q.commutative(x**2), ~Q.commutative(x)) == False

    assert ask(Q.commutative(log(x))) == True