示例#1
0
def _construct_simple(coeffs, opt):
    """Handle simple domains, e.g.: ZZ, QQ, RR and algebraic domains. """
    result, rationals, reals, algebraics = {}, False, False, False

    if opt.extension is True:
        is_algebraic = lambda coeff: ask(Q.algebraic(coeff))
    else:
        is_algebraic = lambda coeff: False

    # XXX: add support for a + b*I coefficients
    for coeff in coeffs:
        if coeff.is_Rational:
            if not coeff.is_Integer:
                rationals = True
        elif coeff.is_Float:
            if not algebraics:
                reals = True
            else:
                # there are both reals and algebraics -> EX
                return False
        elif is_algebraic(coeff):
            if not reals:
                algebraics = True
            else:
                # there are both algebraics and reals -> EX
                return False
        else:
            # this is a composite domain, e.g. ZZ[X], EX
            return None

    if algebraics:
        domain, result = _construct_algebraic(coeffs, opt)
    else:
        if reals:
            domain = RR
        else:
            if opt.field or rationals:
                domain = QQ
            else:
                domain = ZZ

        result = []

        for coeff in coeffs:
            result.append(domain.from_sympy(coeff))

    return domain, result
示例#2
0
 def log(expr, assumptions):
     x = expr.args[0]
     if ask(Q.algebraic(x), assumptions):
         return ask(~Q.nonzero(x - 1), assumptions)
示例#3
0
文件: sets.py 项目: Tarang1993/sympy
 def Pow(expr, assumptions):
     return expr.exp.is_Rational and ask(
         Q.algebraic(expr.base), assumptions)
示例#4
0
def _(expr, assumptions):
    if expr.base == E:
        if ask(Q.algebraic(expr.exp), assumptions):
            return ask(~Q.nonzero(expr.exp), assumptions)
        return
    return expr.exp.is_Rational and ask(Q.algebraic(expr.base), assumptions)
示例#5
0
 def cot(expr, assumptions):
     x = expr.args[0]
     if ask(Q.algebraic(x), assumptions):
         return False
示例#6
0
文件: sets.py 项目: wuxi20/Pythonista
 def cot(expr, assumptions):
     x = expr.args[0]
     if ask(Q.algebraic(x), assumptions):
         return False
示例#7
0
文件: sets.py 项目: wuxi20/Pythonista
 def log(expr, assumptions):
     x = expr.args[0]
     if ask(Q.algebraic(x), assumptions):
         return ask(~Q.nonzero(x - 1), assumptions)
示例#8
0
 def _is_coeff(factor):
     return ask(Q.algebraic(factor))
示例#9
0
文件: sets.py 项目: wuxi20/Pythonista
 def Pow(expr, assumptions):
     return expr.exp.is_Rational and ask(
         Q.algebraic(expr.base), assumptions)
示例#10
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
示例#11
0
def test_algebraic():
    x, y = symbols('x,y')

    assert ask(Q.algebraic(x)) == None

    assert ask(Q.algebraic(I)) == True
    assert ask(Q.algebraic(2*I)) == True
    assert ask(Q.algebraic(I/3)) == True

    assert ask(Q.algebraic(sqrt(7))) == True
    assert ask(Q.algebraic(2*sqrt(7))) == True
    assert ask(Q.algebraic(sqrt(7)/3)) == True

    assert ask(Q.algebraic(I*sqrt(3))) == True
    assert ask(Q.algebraic(sqrt(1+I*sqrt(3)))) == True

    assert ask(Q.algebraic((1+I*sqrt(3)**(S(17)/31)))) == True
    assert ask(Q.algebraic((1+I*sqrt(3)**(S(17)/pi)))) == False

    assert ask(Q.algebraic(sin(7))) == None
    assert ask(Q.algebraic(sqrt(sin(7)))) == None
    assert ask(Q.algebraic(sqrt(y+I*sqrt(7)))) == None

    assert ask(Q.algebraic(oo)) == False
    assert ask(Q.algebraic(-oo)) == False

    assert ask(Q.algebraic(2.47)) == False
示例#12
0
文件: sets.py 项目: sidhu1012/sympy
def _(expr, assumptions):
    x = expr.exp
    if ask(Q.algebraic(x), assumptions):
        return ask(~Q.nonzero(x), assumptions)
示例#13
0
文件: polyutils.py 项目: Jerryy/sympy
 def _is_coeff(factor):
     return ask(Q.algebraic(factor))
示例#14
0
def test_algebraic():
    x, y = symbols('x,y')

    assert ask(Q.algebraic(x)) == None

    assert ask(Q.algebraic(I)) == True
    assert ask(Q.algebraic(2 * I)) == True
    assert ask(Q.algebraic(I / 3)) == True

    assert ask(Q.algebraic(sqrt(7))) == True
    assert ask(Q.algebraic(2 * sqrt(7))) == True
    assert ask(Q.algebraic(sqrt(7) / 3)) == True

    assert ask(Q.algebraic(I * sqrt(3))) == True
    assert ask(Q.algebraic(sqrt(1 + I * sqrt(3)))) == True

    assert ask(Q.algebraic((1 + I * sqrt(3)**(S(17) / 31)))) == True
    assert ask(Q.algebraic((1 + I * sqrt(3)**(S(17) / pi)))) == False

    assert ask(Q.algebraic(sin(7))) == None
    assert ask(Q.algebraic(sqrt(sin(7)))) == None
    assert ask(Q.algebraic(sqrt(y + I * sqrt(7)))) == None

    assert ask(Q.algebraic(oo)) == False
    assert ask(Q.algebraic(-oo)) == False

    assert ask(Q.algebraic(2.47)) == False