Predicates

普通

class sympy.assumptions.predicates.common.IsTruePredicate(*args, **kwargs)

泛型谓词。

解释

ask(Q.is_true(x)) is true iff x is true. This only makes sense if x is a boolean object.

实例

>>> from sympy import ask, Q
>>> from sympy.abc import x, y
>>> ask(Q.is_true(True))
True

Wrapping another applied predicate just returns the applied predicate.

>>> Q.is_true(Q.even(x))
Q.even(x)

Wrapping binary relation classes in SymPy core returns applied binary relational predicates.

>>> from sympy import Eq, Gt
>>> Q.is_true(Eq(x, y))
Q.eq(x, y)
>>> Q.is_true(Gt(x, y))
Q.gt(x, y)

笔记

This class is designed to wrap the boolean objects so that they can behave as if they are applied predicates. Consequently, wrapping another applied predicate is unnecessary and thus it just returns the argument. Also, binary relation classes in SymPy core have binary predicates to represent themselves and thus wrapping them with Q.is_true converts them to these applied predicates.

Handler

Multiply dispatched method: IsTrueHandler

允许查询布尔表达式的真值的包装器。

handler = <dispatched IsTrueHandler>

class sympy.assumptions.predicates.common.CommutativePredicate(*args, **kwargs)

交换谓词。

解释

ask(Q.commutative(x)) 是真的吗 x 与乘法运算有关的任何其他对象通勤。

Handler

Multiply dispatched method: CommutativeHandler

Handler for key 'commutative'.

handler = <dispatched CommutativeHandler>

微积分

class sympy.assumptions.predicates.calculus.FinitePredicate(*args, **kwargs)

Finite number predicate.

解释

Q.finite(x) is true if x is a number but neither an infinity nor a NaN. In other words, ask(Q.finite(x)) is true for all numerical x having a bounded absolute value.

实例

>>> from sympy import Q, ask, S, oo, I, zoo
>>> from sympy.abc import x
>>> ask(Q.finite(oo))
False
>>> ask(Q.finite(-oo))
False
>>> ask(Q.finite(zoo))
False
>>> ask(Q.finite(1))
True
>>> ask(Q.finite(2 + 3*I))
True
>>> ask(Q.finite(x), Q.positive(x))
True
>>> print(ask(Q.finite(S.NaN)))
None

Handler

Multiply dispatched method: FiniteHandler

Handler for Q.finite. Test that an expression is bounded respect to all its variables.

工具书类

[R9]

https://en.wikipedia.org/wiki/Finite

handler = <dispatched FiniteHandler>

class sympy.assumptions.predicates.calculus.InfinitePredicate(*args, **kwargs)

无限数谓词。

Q.infinite(x) 如果绝对值为 x 是无限的。

Handler

Multiply dispatched method: InfiniteHandler

Handler for Q.infinite key.

handler = <dispatched InfiniteHandler>

矩阵

class sympy.assumptions.predicates.matrices.SymmetricPredicate(*args, **kwargs)

对称矩阵谓词。

解释

Q.symmetric(x) 是真的吗 x 是一个方阵，等于它的转置。每一个正方形对角矩阵都是一个对称矩阵。

实例

>>> from sympy import Q, ask, MatrixSymbol
>>> X = MatrixSymbol('X', 2, 2)
>>> Y = MatrixSymbol('Y', 2, 3)
>>> Z = MatrixSymbol('Z', 2, 2)
>>> ask(Q.symmetric(X*Z), Q.symmetric(X) & Q.symmetric(Z))
True
>>> ask(Q.symmetric(X + Z), Q.symmetric(X) & Q.symmetric(Z))
True
>>> ask(Q.symmetric(Y))
False

Handler

Multiply dispatched method: SymmetricHandler

Handler for Q.symmetric.

工具书类

[R10]

https://en.wikipedia.org/wiki/Symmetric_matrix

handler = <dispatched SymmetricHandler>

class sympy.assumptions.predicates.matrices.InvertiblePredicate(*args, **kwargs)

可逆矩阵谓词。

解释

Q.invertible(x) 是真的吗 x 是可逆矩阵。方阵只有行列式为0时才称为可逆矩阵。

实例

>>> from sympy import Q, ask, MatrixSymbol
>>> X = MatrixSymbol('X', 2, 2)
>>> Y = MatrixSymbol('Y', 2, 3)
>>> Z = MatrixSymbol('Z', 2, 2)
>>> ask(Q.invertible(X*Y), Q.invertible(X))
False
>>> ask(Q.invertible(X*Z), Q.invertible(X) & Q.invertible(Z))
True
>>> ask(Q.invertible(X), Q.fullrank(X) & Q.square(X))
True

Handler

Multiply dispatched method: InvertibleHandler

Handler for Q.invertible.

工具书类

[R11]

https://en.wikipedia.org/wiki/Invertible_matrix

handler = <dispatched InvertibleHandler>

class sympy.assumptions.predicates.matrices.OrthogonalPredicate(*args, **kwargs)

正交矩阵谓词。

解释

Q.orthogonal(x) 是真的吗 x 是一个正交矩阵。方阵 M 是一个正交矩阵，如果它满足 M^TM = MM^T = I 在哪里？ M^T 是的转置矩阵 M 和 I 是一个单位矩阵。注意一个正交矩阵必然是可逆的。

实例

>>> from sympy import Q, ask, MatrixSymbol, Identity
>>> X = MatrixSymbol('X', 2, 2)
>>> Y = MatrixSymbol('Y', 2, 3)
>>> Z = MatrixSymbol('Z', 2, 2)
>>> ask(Q.orthogonal(Y))
False
>>> ask(Q.orthogonal(X*Z*X), Q.orthogonal(X) & Q.orthogonal(Z))
True
>>> ask(Q.orthogonal(Identity(3)))
True
>>> ask(Q.invertible(X), Q.orthogonal(X))
True

Handler

Multiply dispatched method: OrthogonalHandler

Handler for key 'orthogonal'.

工具书类

[R12]

https://en.wikipedia.org/wiki/Orthogonal_matrix

handler = <dispatched OrthogonalHandler>

class sympy.assumptions.predicates.matrices.UnitaryPredicate(*args, **kwargs)

酉矩阵谓词。

解释

Q.unitary(x) 是真的吗 x 是酉矩阵。酉矩阵是正交矩阵的一个类似物。方阵 M 复元素是酉的如果 :math:M^TM = MM^T= I` `在哪里 :math:``M^T` `是的共轭转置矩阵 ``M .

实例

>>> from sympy import Q, ask, MatrixSymbol, Identity
>>> X = MatrixSymbol('X', 2, 2)
>>> Y = MatrixSymbol('Y', 2, 3)
>>> Z = MatrixSymbol('Z', 2, 2)
>>> ask(Q.unitary(Y))
False
>>> ask(Q.unitary(X*Z*X), Q.unitary(X) & Q.unitary(Z))
True
>>> ask(Q.unitary(Identity(3)))
True

Handler

Multiply dispatched method: UnitaryHandler

Handler for key 'unitary'.

工具书类

[R13]

https://en.wikipedia.org/wiki/Unitary_matrix

handler = <dispatched UnitaryHandler>

class sympy.assumptions.predicates.matrices.PositiveDefinitePredicate(*args, **kwargs)

正定矩阵谓词。

解释

If \(M\) is a \(n \times n\) symmetric real matrix, it is said to be positive definite if \(Z^TMZ\) is positive for every non-zero column vector \(Z\) of \(n\) real numbers.

实例

>>> from sympy import Q, ask, MatrixSymbol, Identity
>>> X = MatrixSymbol('X', 2, 2)
>>> Y = MatrixSymbol('Y', 2, 3)
>>> Z = MatrixSymbol('Z', 2, 2)
>>> ask(Q.positive_definite(Y))
False
>>> ask(Q.positive_definite(Identity(3)))
True
>>> ask(Q.positive_definite(X + Z), Q.positive_definite(X) &
...     Q.positive_definite(Z))
True

Handler

Multiply dispatched method: PositiveDefiniteHandler

Handler for key 'positive_definite'.

工具书类

[R14]

https://en.wikipedia.org/wiki/Positive-definite_matrix

handler = <dispatched PositiveDefiniteHandler>

class sympy.assumptions.predicates.matrices.UpperTriangularPredicate(*args, **kwargs)

上三角矩阵谓词。

解释

A matrix \(M\) is called upper triangular matrix if \(M_{ij}=0\) for \(i<j\).

实例

>>> from sympy import Q, ask, ZeroMatrix, Identity
>>> ask(Q.upper_triangular(Identity(3)))
True
>>> ask(Q.upper_triangular(ZeroMatrix(3, 3)))
True

Handler

Multiply dispatched method: UpperTriangularHandler

Handler for key 'upper_triangular'.

工具书类

[R15]

https://mathworld.wolfram.com/UpperTriangularMatrix.html

handler = <dispatched UpperTriangularHandler>

class sympy.assumptions.predicates.matrices.LowerTriangularPredicate(*args, **kwargs)

下三角矩阵谓词。

解释

A matrix \(M\) is called lower triangular matrix if \(M_{ij}=0\) for \(i>j\).

实例

>>> from sympy import Q, ask, ZeroMatrix, Identity
>>> ask(Q.lower_triangular(Identity(3)))
True
>>> ask(Q.lower_triangular(ZeroMatrix(3, 3)))
True

Handler

Multiply dispatched method: LowerTriangularHandler

Handler for key 'lower_triangular'.

工具书类

[R16]

https://mathworld.wolfram.com/LowerTriangularMatrix.html

handler = <dispatched LowerTriangularHandler>

class sympy.assumptions.predicates.matrices.DiagonalPredicate(*args, **kwargs)

对角矩阵谓词。

解释

Q.diagonal(x) 是真的吗 x 是一个对角矩阵。对角线矩阵是主对角线之外的项都为零的矩阵。

实例

>>> from sympy import Q, ask, MatrixSymbol, ZeroMatrix
>>> X = MatrixSymbol('X', 2, 2)
>>> ask(Q.diagonal(ZeroMatrix(3, 3)))
True
>>> ask(Q.diagonal(X), Q.lower_triangular(X) &
...     Q.upper_triangular(X))
True

Handler

Multiply dispatched method: DiagonalHandler

Handler for key 'diagonal'.

工具书类

[R17]

https://en.wikipedia.org/wiki/Diagonal_matrix

handler = <dispatched DiagonalHandler>

class sympy.assumptions.predicates.matrices.FullRankPredicate(*args, **kwargs)

全秩矩阵谓词。

解释

Q.fullrank(x) 是真的吗 x 是一个满秩矩阵。如果矩阵的所有行都是线性的且秩是独立的。方阵的行列式非零时为满秩矩阵。

实例

>>> from sympy import Q, ask, MatrixSymbol, ZeroMatrix, Identity
>>> X = MatrixSymbol('X', 2, 2)
>>> ask(Q.fullrank(X.T), Q.fullrank(X))
True
>>> ask(Q.fullrank(ZeroMatrix(3, 3)))
False
>>> ask(Q.fullrank(Identity(3)))
True

Handler

Multiply dispatched method: FullRankHandler

Handler for key 'fullrank'.

handler = <dispatched FullRankHandler>

class sympy.assumptions.predicates.matrices.SquarePredicate(*args, **kwargs)

方阵谓词。

解释

Q.square(x) 是真的吗 x 是一个方阵。方阵是具有相同行数和列数的矩阵。

实例

>>> from sympy import Q, ask, MatrixSymbol, ZeroMatrix, Identity
>>> X = MatrixSymbol('X', 2, 2)
>>> Y = MatrixSymbol('X', 2, 3)
>>> ask(Q.square(X))
True
>>> ask(Q.square(Y))
False
>>> ask(Q.square(ZeroMatrix(3, 3)))
True
>>> ask(Q.square(Identity(3)))
True

Handler

Multiply dispatched method: SquareHandler

Handler for Q.square.

工具书类

[R18]

https://en.wikipedia.org/wiki/Square_matrix

handler = <dispatched SquareHandler>

class sympy.assumptions.predicates.matrices.IntegerElementsPredicate(*args, **kwargs)

整数元素矩阵谓词。

解释

Q.integer_elements(x) 如果所有的元素 x 是整数。

实例

>>> from sympy import Q, ask, MatrixSymbol
>>> X = MatrixSymbol('X', 4, 4)
>>> ask(Q.integer(X[1, 2]), Q.integer_elements(X))
True

Handler

Multiply dispatched method: IntegerElementsHandler

Handler for key 'integer_elements'.

handler = <dispatched IntegerElementsHandler>

class sympy.assumptions.predicates.matrices.RealElementsPredicate(*args, **kwargs)

实元素矩阵谓词。

解释

Q.real_elements(x) 如果所有的元素 x 都是实数。

实例

>>> from sympy import Q, ask, MatrixSymbol
>>> X = MatrixSymbol('X', 4, 4)
>>> ask(Q.real(X[1, 2]), Q.real_elements(X))
True

Handler

Multiply dispatched method: RealElementsHandler

Handler for key 'real_elements'.

handler = <dispatched RealElementsHandler>

class sympy.assumptions.predicates.matrices.ComplexElementsPredicate(*args, **kwargs)

复数元素矩阵谓词。

解释

Q.complex_elements(x) 如果所有的元素 x 是复数。

实例

>>> from sympy import Q, ask, MatrixSymbol
>>> X = MatrixSymbol('X', 4, 4)
>>> ask(Q.complex(X[1, 2]), Q.complex_elements(X))
True
>>> ask(Q.complex_elements(X), Q.integer_elements(X))
True

Handler

Multiply dispatched method: ComplexElementsHandler

Handler for key 'complex_elements'.

handler = <dispatched ComplexElementsHandler>

class sympy.assumptions.predicates.matrices.SingularPredicate(*args, **kwargs)

单数矩阵谓词。

当行列式的值为0时，矩阵是奇异的。

实例

>>> from sympy import Q, ask, MatrixSymbol
>>> X = MatrixSymbol('X', 4, 4)
>>> ask(Q.singular(X), Q.invertible(X))
False
>>> ask(Q.singular(X), ~Q.invertible(X))
True

Handler

Multiply dispatched method: SingularHandler

Predicate fore key 'singular'.

工具书类

[R19]

https://mathworld.wolfram.com/SingularMatrix.html

handler = <dispatched SingularHandler>

class sympy.assumptions.predicates.matrices.NormalPredicate(*args, **kwargs)

正规矩阵谓词。

如果它是一个正规的转置矩阵。

实例

>>> from sympy import Q, ask, MatrixSymbol
>>> X = MatrixSymbol('X', 4, 4)
>>> ask(Q.normal(X), Q.unitary(X))
True

Handler

Multiply dispatched method: NormalHandler

Predicate fore key 'normal'.

工具书类

[R20]

https://en.wikipedia.org/wiki/Normal_matrix

handler = <dispatched NormalHandler>

class sympy.assumptions.predicates.matrices.TriangularPredicate(*args, **kwargs)

三角矩阵谓词。

解释

Q.triangular(X) 如果是真的 X 是下三角或上三角的。

实例

>>> from sympy import Q, ask, MatrixSymbol
>>> X = MatrixSymbol('X', 4, 4)
>>> ask(Q.triangular(X), Q.upper_triangular(X))
True
>>> ask(Q.triangular(X), Q.lower_triangular(X))
True

Handler

Multiply dispatched method: TriangularHandler

Predicate fore key 'triangular'.

工具书类

[R21]

https://en.wikipedia.org/wiki/Triangular_matrix

handler = <dispatched TriangularHandler>

class sympy.assumptions.predicates.matrices.UnitTriangularPredicate(*args, **kwargs)

单位三角矩阵谓词。

解释

单位三角形矩阵是对角线上有1的三角形矩阵。

实例

>>> from sympy import Q, ask, MatrixSymbol
>>> X = MatrixSymbol('X', 4, 4)
>>> ask(Q.triangular(X), Q.unit_triangular(X))
True

Handler

Multiply dispatched method: UnitTriangularHandler

Predicate fore key 'unit_triangular'.

handler = <dispatched UnitTriangularHandler>

数论

class sympy.assumptions.predicates.ntheory.EvenPredicate(*args, **kwargs)

偶数谓词。

解释

ask(Q.even(x)) 是真的吗 x 属于偶数整数集。

实例

>>> from sympy import Q, ask, pi
>>> ask(Q.even(0))
True
>>> ask(Q.even(2))
True
>>> ask(Q.even(3))
False
>>> ask(Q.even(pi))
False

Handler

Multiply dispatched method: EvenHandler

Handler for key 'even'.

handler = <dispatched EvenHandler>

class sympy.assumptions.predicates.ntheory.OddPredicate(*args, **kwargs)

奇数谓词。

解释

ask(Q.odd(x)) 是真的吗 x 属于奇数集合。

实例

>>> from sympy import Q, ask, pi
>>> ask(Q.odd(0))
False
>>> ask(Q.odd(2))
False
>>> ask(Q.odd(3))
True
>>> ask(Q.odd(pi))
False

Handler

Multiply dispatched method: OddHandler

Handler for key 'odd'. Test that an expression represents an odd number.

handler = <dispatched OddHandler>

class sympy.assumptions.predicates.ntheory.PrimePredicate(*args, **kwargs)

质数谓词。

解释

ask(Q.prime(x)) 是真的吗 x 是一个大于1的自然数，它除了 1 以及数字本身。

实例

>>> from sympy import Q, ask
>>> ask(Q.prime(0))
False
>>> ask(Q.prime(1))
False
>>> ask(Q.prime(2))
True
>>> ask(Q.prime(20))
False
>>> ask(Q.prime(-3))
False

Handler

Multiply dispatched method: PrimeHandler

Handler for key 'prime'. Test that an expression represents a prime number. When the expression is an exact number, the result (when True) is subject to the limitations of isprime() which is used to return the result.

handler = <dispatched PrimeHandler>

class sympy.assumptions.predicates.ntheory.CompositePredicate(*args, **kwargs)

复合数字谓词。

解释

ask(Q.composite(x)) 是真的吗 x 是一个正整数，并且至少有一个除 1 以及数字本身。

实例

>>> from sympy import Q, ask
>>> ask(Q.composite(0))
False
>>> ask(Q.composite(1))
False
>>> ask(Q.composite(2))
False
>>> ask(Q.composite(20))
True

Handler

Multiply dispatched method: CompositeHandler

Handler for key 'composite'.

handler = <dispatched CompositeHandler>

秩序

class sympy.assumptions.predicates.order.PositivePredicate(*args, **kwargs)

正实数谓词。

解释

Q.positive(x) 是真的吗 x 是真实的而且 \(x > 0\) ，如果 x 在间隔时间内 \((0, \infty)\) . 特别是，无限不是正的。

关于正数的几个重要事实：

• Note that Q.nonpositive and ~Q.positive are not the same

  thing. ~Q.positive(x) simply means that x is not positive, whereas Q.nonpositive(x) means that x is real and not positive, i.e., Q.nonpositive(x) is logically equivalent to \(Q.negative(x) | Q.zero(x)`\). So for example, ~Q.positive(I) is true, whereas Q.nonpositive(I) is false.

• See the documentation of Q.real for more information about

  related facts.

实例

>>> from sympy import Q, ask, symbols, I
>>> x = symbols('x')
>>> ask(Q.positive(x), Q.real(x) & ~Q.negative(x) & ~Q.zero(x))
True
>>> ask(Q.positive(1))
True
>>> ask(Q.nonpositive(I))
False
>>> ask(~Q.positive(I))
True

Handler

Multiply dispatched method: PositiveHandler

Handler for key 'positive'. Test that an expression is strictly greater than zero.

handler = <dispatched PositiveHandler>

class sympy.assumptions.predicates.order.NegativePredicate(*args, **kwargs)

负数谓词。

解释

Q.negative(x) 是真的吗 x 是一个实数 \(x < 0\) ，也就是说，它在间隔时间内 \((-\infty, 0)\) . 特别要注意的是，负无穷不是负的。

关于负数的几个重要事实：

• Note that Q.nonnegative and ~Q.negative are not the same

  thing. ~Q.negative(x) simply means that x is not negative, whereas Q.nonnegative(x) means that x is real and not negative, i.e., Q.nonnegative(x) is logically equivalent to Q.zero(x) | Q.positive(x). So for example, ~Q.negative(I) is true, whereas Q.nonnegative(I) is false.

• See the documentation of Q.real for more information about

  related facts.

实例

>>> from sympy import Q, ask, symbols, I
>>> x = symbols('x')
>>> ask(Q.negative(x), Q.real(x) & ~Q.positive(x) & ~Q.zero(x))
True
>>> ask(Q.negative(-1))
True
>>> ask(Q.nonnegative(I))
False
>>> ask(~Q.negative(I))
True

Handler

Multiply dispatched method: NegativeHandler

Handler for Q.negative. Test that an expression is strictly less than zero.

handler = <dispatched NegativeHandler>

class sympy.assumptions.predicates.order.ZeroPredicate(*args, **kwargs)

零数谓词。

解释

ask(Q.zero(x)) 如果 x 是零。

实例

>>> from sympy import ask, Q, oo, symbols
>>> x, y = symbols('x, y')
>>> ask(Q.zero(0))
True
>>> ask(Q.zero(1/oo))
True
>>> print(ask(Q.zero(0*oo)))
None
>>> ask(Q.zero(1))
False
>>> ask(Q.zero(x*y), Q.zero(x) | Q.zero(y))
True

Handler

Multiply dispatched method: ZeroHandler

Handler for key 'zero'.

handler = <dispatched ZeroHandler>

class sympy.assumptions.predicates.order.NonZeroPredicate(*args, **kwargs)

非零实数谓词。

解释

ask(Q.nonzero(x)) 是真的吗 x 是真实的而且 x 不是零。请特别注意 Q.nonzero(x) 如果 x 不是真的。使用 ~Q.zero(x) 如果你想在没有任何实际假设的情况下否定为零。

关于非零数的几个重要事实：

• Q.nonzero 逻辑上等价于 Q.positive | Q.negative .

• See the documentation of Q.real for more information about

  related facts.

实例

>>> from sympy import Q, ask, symbols, I, oo
>>> x = symbols('x')
>>> print(ask(Q.nonzero(x), ~Q.zero(x)))
None
>>> ask(Q.nonzero(x), Q.positive(x))
True
>>> ask(Q.nonzero(x), Q.zero(x))
False
>>> ask(Q.nonzero(0))
False
>>> ask(Q.nonzero(I))
False
>>> ask(~Q.zero(I))
True
>>> ask(Q.nonzero(oo))
False

Handler

Multiply dispatched method: NonZeroHandler

Handler for key 'nonzero'. Test that an expression is not identically zero.

handler = <dispatched NonZeroHandler>

class sympy.assumptions.predicates.order.NonPositivePredicate(*args, **kwargs)

非正实数谓词。

解释

ask(Q.nonpositive(x)) 是真的吗 x 属于包含零的负数集合。

• Note that Q.nonpositive and ~Q.positive are not the same

  thing. ~Q.positive(x) simply means that x is not positive, whereas Q.nonpositive(x) means that x is real and not positive, i.e., Q.nonpositive(x) is logically equivalent to \(Q.negative(x) | Q.zero(x)`\). So for example, ~Q.positive(I) is true, whereas Q.nonpositive(I) is false.

实例

>>> from sympy import Q, ask, I

>>> ask(Q.nonpositive(-1))
True
>>> ask(Q.nonpositive(0))
True
>>> ask(Q.nonpositive(1))
False
>>> ask(Q.nonpositive(I))
False
>>> ask(Q.nonpositive(-I))
False

Handler

Multiply dispatched method: NonPositiveHandler

Handler for key 'nonpositive'.

handler = <dispatched NonPositiveHandler>

class sympy.assumptions.predicates.order.NonNegativePredicate(*args, **kwargs)

非负实数谓词。

解释

ask(Q.nonnegative(x)) 是真的吗 x 属于包含零的正数集合。

• Note that Q.nonnegative and ~Q.negative are not the same

  thing. ~Q.negative(x) simply means that x is not negative, whereas Q.nonnegative(x) means that x is real and not negative, i.e., Q.nonnegative(x) is logically equivalent to Q.zero(x) | Q.positive(x). So for example, ~Q.negative(I) is true, whereas Q.nonnegative(I) is false.

实例

>>> from sympy import Q, ask, I
>>> ask(Q.nonnegative(1))
True
>>> ask(Q.nonnegative(0))
True
>>> ask(Q.nonnegative(-1))
False
>>> ask(Q.nonnegative(I))
False
>>> ask(Q.nonnegative(-I))
False

Handler

Multiply dispatched method: NonNegativeHandler

Handler for Q.nonnegative.

handler = <dispatched NonNegativeHandler>

集合

class sympy.assumptions.predicates.sets.IntegerPredicate(*args, **kwargs)

整数谓词。

解释

Q.integer(x) 是真的吗 x 属于整数集。

实例

>>> from sympy import Q, ask, S
>>> ask(Q.integer(5))
True
>>> ask(Q.integer(S(1)/2))
False

Handler

Multiply dispatched method: IntegerHandler

Handler for Q.integer.

Test that an expression belongs to the field of integer numbers.

工具书类

[R22]

https://en.wikipedia.org/wiki/Integer

handler = <dispatched IntegerHandler>

class sympy.assumptions.predicates.sets.RationalPredicate(*args, **kwargs)

有理数谓词。

解释

Q.rational(x) 是真的吗 x 属于有理数集合。

实例

>>> from sympy import ask, Q, pi, S
>>> ask(Q.rational(0))
True
>>> ask(Q.rational(S(1)/2))
True
>>> ask(Q.rational(pi))
False

Handler

Multiply dispatched method: RationalHandler

Handler for Q.rational.

Test that an expression belongs to the field of rational numbers.

工具书类

[R23]

https://en.wikipedia.org/wiki/Rational_number

handler = <dispatched RationalHandler>

class sympy.assumptions.predicates.sets.IrrationalPredicate(*args, **kwargs)

无理数谓词。

解释

Q.irrational(x) 是真的吗 x 不能用整数比率表示的任何实数。

实例

>>> from sympy import ask, Q, pi, S, I
>>> ask(Q.irrational(0))
False
>>> ask(Q.irrational(S(1)/2))
False
>>> ask(Q.irrational(pi))
True
>>> ask(Q.irrational(I))
False

Handler

Multiply dispatched method: IrrationalHandler

Handler for Q.irrational.

Test that an expression is irrational numbers.

工具书类

[R24]

https://en.wikipedia.org/wiki/Irrational_number

handler = <dispatched IrrationalHandler>

class sympy.assumptions.predicates.sets.RealPredicate(*args, **kwargs)

实数谓词。

解释

Q.real(x) 是真的吗 x 是一个实数，也就是说，它在区间内 \((-\infty, \infty)\) . 请注意，尤其是无穷大不是真的。使用 Q.extended_real 如果你还想考虑这些。

关于reals的几个重要事实：

• Every real number is positive, negative, or zero. Furthermore,

  because these sets are pairwise disjoint, each real number is exactly one of those three.

• 每个实数也是复杂的。

• 每个实数都是有限的。

• 每个实数要么有理，要么无理。

• 每个实数要么是代数的，要么是超越的。

• The facts Q.negative, Q.zero, Q.positive,

  Q.nonnegative, Q.nonpositive, Q.nonzero, Q.integer, Q.rational, and Q.irrational all imply Q.real, as do all facts that imply those facts.

• The facts Q.algebraic, and Q.transcendental do not imply

  Q.real; they imply Q.complex. An algebraic or transcendental number may or may not be real.

• The "non" facts (i.e., Q.nonnegative, Q.nonzero,

  Q.nonpositive and Q.noninteger) are not equivalent to not the fact, but rather, not the fact and Q.real. For example, Q.nonnegative means ~Q.negative & Q.real. So for example, I is not nonnegative, nonzero, or nonpositive.

实例

>>> from sympy import Q, ask, symbols
>>> x = symbols('x')
>>> ask(Q.real(x), Q.positive(x))
True
>>> ask(Q.real(0))
True

Handler

Multiply dispatched method: RealHandler

Handler for Q.real.

Test that an expression belongs to the field of real numbers.

工具书类

[R25]

https://en.wikipedia.org/wiki/Real_number

handler = <dispatched RealHandler>

class sympy.assumptions.predicates.sets.ExtendedRealPredicate(*args, **kwargs)

扩展实谓词。

解释

Q.extended_real(x) 是真的吗 x 是实数还是 \(\{{-\infty, \infty\}}\) .

参见文档 Q.real 有关相关事实的更多信息。

实例

>>> from sympy import ask, Q, oo, I
>>> ask(Q.extended_real(1))
True
>>> ask(Q.extended_real(I))
False
>>> ask(Q.extended_real(oo))
True

Handler

Multiply dispatched method: ExtendedRealHandler

Handler for Q.extended_real.

Test that an expression belongs to the field of extended real

numbers, that is real numbers union {Infinity, -Infinity}.

handler = <dispatched ExtendedRealHandler>

class sympy.assumptions.predicates.sets.HermitianPredicate(*args, **kwargs)

厄米谓词。

解释

ask(Q.hermitian(x)) 是真的吗 x 属于Hermitian运算符集。

Handler

Multiply dispatched method: HermitianHandler

Handler for Q.hermitian.

Test that an expression belongs to the field of Hermitian operators.

工具书类

[R26]

https://mathworld.wolfram.com/HermitianOperator.html

handler = <dispatched HermitianHandler>

class sympy.assumptions.predicates.sets.ComplexPredicate(*args, **kwargs)

复数谓词。

解释

Q.complex(x) 是真的吗 x 属于复数集合。注意每个复数都是有限的。

实例

>>> from sympy import Q, Symbol, ask, I, oo
>>> x = Symbol('x')
>>> ask(Q.complex(0))
True
>>> ask(Q.complex(2 + 3*I))
True
>>> ask(Q.complex(oo))
False

Handler

Multiply dispatched method: ComplexHandler

Handler for Q.complex.

Test that an expression belongs to the field of complex numbers.

工具书类

[R27]

https://en.wikipedia.org/wiki/Complex_number

handler = <dispatched ComplexHandler>

class sympy.assumptions.predicates.sets.ImaginaryPredicate(*args, **kwargs)

虚数谓词。

解释

Q.imaginary(x) 是真的吗 x 可以写成实数乘以虚数单位 I . 请注意 0 不被认为是虚数。

实例

>>> from sympy import Q, ask, I
>>> ask(Q.imaginary(3*I))
True
>>> ask(Q.imaginary(2 + 3*I))
False
>>> ask(Q.imaginary(0))
False

Handler

Multiply dispatched method: ImaginaryHandler

Handler for Q.imaginary.

Test that an expression belongs to the field of imaginary numbers,

that is, numbers in the form x*I, where x is real.

工具书类

[R28]

https://en.wikipedia.org/wiki/Imaginary_number

handler = <dispatched ImaginaryHandler>

class sympy.assumptions.predicates.sets.AntihermitianPredicate(*args, **kwargs)

反热谓词。

解释

Q.antihermitian(x) 是真的吗 x 属于反热算符领域，即形式上的算符 x*I 在哪里 x 是赫米特人。

Handler

Multiply dispatched method: AntiHermitianHandler

Handler for Q.antihermitian.

Test that an expression belongs to the field of anti-Hermitian

operators, that is, operators in the form x*I, where x is Hermitian.

工具书类

[R29]

https://mathworld.wolfram.com/HermitianOperator.html

handler = <dispatched AntiHermitianHandler>

class sympy.assumptions.predicates.sets.AlgebraicPredicate(*args, **kwargs)

代数数谓词。

解释

Q.algebraic(x) 是真的吗 x 属于代数数的集合。 x 是代数的如果在 p(x)\in \mathbb\{{Q\}}[x] 这样的话 p(x) = 0 .

实例

>>> from sympy import ask, Q, sqrt, I, pi
>>> ask(Q.algebraic(sqrt(2)))
True
>>> ask(Q.algebraic(I))
True
>>> ask(Q.algebraic(pi))
False

Handler

Multiply dispatched method: AskAlgebraicpredicateHandler

Handler for key AskAlgebraicpredicateHandler

工具书类

[R30]

https://en.wikipedia.org/wiki/Algebraic_number

AlgebraicHandler = <dispatched AlgebraicHandler>

handler = <dispatched AskAlgebraicpredicateHandler>

class sympy.assumptions.predicates.sets.TranscendentalPredicate(*args, **kwargs)

经文数谓词。

解释

Q.transcendental(x) 是真的吗 x 属于超越数的集合。超越数是不是代数的实数或复数。

Handler

Multiply dispatched method: Transcendental

Handler for Q.transcendental key.

handler = <dispatched Transcendental>