SymPy-1-13-中文文档-四-

SymPy 1.13 中文文档（四）

原文：docs.sympy.org/latest/index.html

精炼

原文：docs.sympy.org/latest/modules/assumptions/refine.html

sympy.assumptions.refine.refine(expr, assumptions=True)

使用假设简化表达式。

解释

与 simplify() 不同，后者在没有任何假设的情况下执行结构化简化，而此函数将表达式转换为仅在特定假设下有效的形式。请注意，在精炼过程中通常不执行 simplify()。

优化布尔表达式涉及将其简化为 S.true 或 S.false。与 ask() 不同，如果无法确定真值，表达式将不会被简化。

示例

>>> from sympy import refine, sqrt, Q
>>> from sympy.abc import x
>>> refine(sqrt(x**2), Q.real(x))
Abs(x)
>>> refine(sqrt(x**2), Q.positive(x))
x

>>> refine(Q.real(x), Q.positive(x))
True
>>> refine(Q.positive(x), Q.real(x))
Q.positive(x)

另见

sympy.simplify.simplify.simplify 的处理程序。

没有假设的结构化简化。

sympy.assumptions.ask.ask 的处理程序。

使用假设查询布尔表达式。

sympy.assumptions.refine.refine_Pow(expr, assumptions)

Pow 实例的处理程序。

示例

>>> from sympy import 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

对于 -1 的幂，指数的偶数部分可以简化：

>>> 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)

sympy.assumptions.refine.refine_abs(expr, assumptions)

绝对值的处理程序。

示例

>>> from sympy import Q, Abs
>>> from sympy.assumptions.refine import refine_abs
>>> from sympy.abc import x
>>> refine_abs(Abs(x), Q.real(x))
>>> refine_abs(Abs(x), Q.positive(x))
x
>>> refine_abs(Abs(x), Q.negative(x))
-x

sympy.assumptions.refine.refine_arg(expr, assumptions)

复数参数的处理程序。

解释

>>> from sympy.assumptions.refine import refine_arg
>>> from sympy import Q, arg
>>> from sympy.abc import x
>>> refine_arg(arg(x), Q.positive(x))
0
>>> refine_arg(arg(x), Q.negative(x))
pi

sympy.assumptions.refine.refine_atan2(expr, assumptions)

atan2 函数的处理程序。

示例

>>> from sympy import Q, atan2
>>> from sympy.assumptions.refine import refine_atan2
>>> from sympy.abc import x, y
>>> refine_atan2(atan2(y,x), Q.real(y) & Q.positive(x))
atan(y/x)
>>> refine_atan2(atan2(y,x), Q.negative(y) & Q.negative(x))
atan(y/x) - pi
>>> refine_atan2(atan2(y,x), Q.positive(y) & Q.negative(x))
atan(y/x) + pi
>>> refine_atan2(atan2(y,x), Q.zero(y) & Q.negative(x))
pi
>>> refine_atan2(atan2(y,x), Q.positive(y) & Q.zero(x))
pi/2
>>> refine_atan2(atan2(y,x), Q.negative(y) & Q.zero(x))
-pi/2
>>> refine_atan2(atan2(y,x), Q.zero(y) & Q.zero(x))
nan

sympy.assumptions.refine.refine_im(expr, assumptions)

虚部的处理程序。

解释

>>> from sympy.assumptions.refine import refine_im
>>> from sympy import Q, im
>>> from sympy.abc import x
>>> refine_im(im(x), Q.real(x))
0
>>> refine_im(im(x), Q.imaginary(x))
-I*x

sympy.assumptions.refine.refine_matrixelement(expr, assumptions)

对称部分的处理程序。

示例

>>> from sympy.assumptions.refine import refine_matrixelement
>>> from sympy import MatrixSymbol, Q
>>> X = MatrixSymbol('X', 3, 3)
>>> refine_matrixelement(X[0, 1], Q.symmetric(X))
X[0, 1]
>>> refine_matrixelement(X[1, 0], Q.symmetric(X))
X[0, 1]

sympy.assumptions.refine.refine_re(expr, assumptions)

实部的处理程序。

示例

>>> from sympy.assumptions.refine import refine_re
>>> from sympy import Q, re
>>> from sympy.abc import x
>>> refine_re(re(x), Q.real(x))
x
>>> refine_re(re(x), Q.imaginary(x))
0

sympy.assumptions.refine.refine_sign(expr, assumptions)

符号的处理程序。

示例

>>> from sympy.assumptions.refine import refine_sign
>>> from sympy import Symbol, Q, sign, im
>>> x = Symbol('x', real = True)
>>> expr = sign(x)
>>> refine_sign(expr, Q.positive(x) & Q.nonzero(x))
1
>>> refine_sign(expr, Q.negative(x) & Q.nonzero(x))
-1
>>> refine_sign(expr, Q.zero(x))
0
>>> y = Symbol('y', imaginary = True)
>>> expr = sign(y)
>>> refine_sign(expr, Q.positive(im(y)))
I
>>> refine_sign(expr, Q.negative(im(y)))
-I

谓词

原文：docs.sympy.org/latest/modules/assumptions/predicates.html

Common

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

通用谓词。

解释

ask(Q.is_true(x)) 是当且仅当 x 为真时为真。这只有当 x 是布尔对象时才有意义。

示例

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

多余地再次包装另一个应用的谓词只会返回应用的谓词。

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

在 SymPy 核心中将二元关系类包装为应用的二元关系谓词。

>>> 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)

注释

这个类被设计成包装布尔对象，使它们能够表现得像应用的谓词一样。因此，多余地再次包装另一个应用的谓词是不必要的，因此它只返回参数。此外，SymPy 核心中的二元关系类具有用于表示自身的二元谓词，因此用 Q.is_true 包装它们会将它们转换为这些应用的谓词。

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)

有限数谓词。

解释

Q.finite(x) 是当且仅当 x 是一个数但既不是无穷也不是 NaN 时为真。换句话说，对于所有有界绝对值的数值 x，ask(Q.finite(x)) 都为真。

示例

>>> 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]

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]

en.wikipedia.org/wiki/Symmetric_matrix

handler = <dispatched SymmetricHandler>

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

可逆矩阵谓词。

解释

Q.invertible(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.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]

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

处理键为‘orthogonal’的处理器。

参考文献

[R12]

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

处理器

多重分派方法：UnitaryHandler

处理键为‘unitary’的处理器。

参考文献

[R13]

en.wikipedia.org/wiki/Unitary_matrix

handler = <dispatched UnitaryHandler>

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

正定矩阵断言。

解释

如果 (M) 是一个 (n \times n) 的对称实矩阵，当对于每个非零的 (n) 维实数列向量 (Z)，(Z^TMZ) 都是正数时，称其为正定矩阵。

例子

>>> 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

处理器

多重分派方法：PositiveDefiniteHandler

处理键为‘positive_definite’的处理器。

参考文献

[R14]

en.wikipedia.org/wiki/Positive-definite_matrix

handler = <dispatched PositiveDefiniteHandler>

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

上三角矩阵断言。

解释

如果矩阵 (M) 满足 (M_{ij}=0) 对于 (i<j)，则称其为上三角矩阵。

例子

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

处理器

多重分派方法：UpperTriangularHandler

处理键为‘upper_triangular’的处理器。

参考文献

[R15]

mathworld.wolfram.com/UpperTriangularMatrix.html

handler = <dispatched UpperTriangularHandler>

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

下三角矩阵断言。

解释

如果矩阵 (M) 满足 (M_{ij}=0) 对于 (i>j)，则称其为下三角矩阵。

例子

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

处理器

多重分派方法：LowerTriangularHandler

处理键为‘lower_triangular’的处理器。

参考文献

[R16]

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

处理器

多重分派方法：DiagonalHandler

处理键为‘diagonal’的处理器。

参考文献

[R17]

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

处理器

多重分派方法：FullRankHandler

处理键为‘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

处理器

多重分派方法：SquareHandler

处理键为 Q.square 的处理器。

参考文献

[R18]

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

处理器

多重分发方法：IntegerElementsHandler

处理器用于关键字‘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

处理器

多重分发方法：RealElementsHandler

处理器用于关键字‘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

处理器

多重分发方法：ComplexElementsHandler

处理器用于关键字‘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

处理器

多重分发方法：SingularHandler

关键字‘singular’的谓词。

参考文献

[R19]

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

处理器

多重分发方法：NormalHandler

关键字‘normal’的谓词。

参考文献

[R20]

zh.wikipedia.org/wiki/正规矩阵

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

处理器

多重分发方法：TriangularHandler

关键字‘triangular’的谓词。

参考文献

[R21]

zh.wikipedia.org/wiki/三角矩阵

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

处理器

多重分发方法：UnitTriangularHandler

关键字‘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

处理器

多重分发方法：EvenHandler

处理器用于关键字‘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

处理器

多重分发方法：OddHandler

处理器用于关键字‘odd’。测试一个表达式是否表示一个奇数。

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

处理器

多重分发方法：PrimeHandler

处理器用于关键字‘prime’。测试一个表达式是否表示一个质数。当表达式是一个确切的数时，结果（为真时）受 isprime()的限制，该函数用于返回结果。

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

处理器

多重分发方法：CompositeHandler

处理器用于关键字‘composite’。

handler = <dispatched CompositeHandler>

顺序

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

正实数谓词。

解释

Q.positive(x) 当且仅当 x 是实数且 ( x > 0 ) 时为真，即 x 在区间 ((0, \infty)) 内。特别地，无穷不是正数。

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

注意 Q.nonpositive 和 ~Q.positive 不是相同的。

事物。 ~Q.positive(x) 简单地表示 x 不是正数，而 Q.nonpositive(x) 表示 x 是实数且不是正数，即 Q.nonpositive(x) 在逻辑上等价于 (Q.negative(x) | Q.zero(x))。例如，~Q.positive(I) 为真，而 Q.nonpositive(I) 为假。
查看有关 Q.real 的文档以获取更多信息

相关事实。

示例

>>> 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 = <dispatched PositiveHandler>

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

负数谓词。

解释

Q.negative(x) 当且仅当 x 是实数且 ( x < 0 ) 时为真，即 x 在区间 ((-\infty, 0)) 内。特别注意负无穷不是负数。

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

注意 Q.nonnegative 和 ~Q.negative 不是相同的。

事物。 ~Q.negative(x) 简单地表示 x 不是负数，而 Q.nonnegative(x) 表示 x 是实数且不是负数，即 Q.nonnegative(x) 在逻辑上等价于 Q.zero(x) | Q.positive(x)。例如，~Q.negative(I) 为真，而 Q.nonnegative(I) 为假。
查看有关 Q.real 的文档以获取更多信息。

相关事实。

示例

>>> 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 = <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

处理程序

多重分派方法：零处理程序

键为‘zero’的处理程序。

handler = <dispatched ZeroHandler>

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

非零实数谓词。

解释

ask(Q.nonzero(x)) 当且仅当 x 是实数且 x 不为零时为真。特别注意，如果 x 不是实数，则 Q.nonzero(x) 为假。如果要求不带任何实数假设的非零否定，请使用 ~Q.zero(x)。

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

Q.nonzero 在逻辑上等价于 Q.positive | Q.negative。
查看有关 Q.real 的文档以获取更多信息

相关事实。

示例

>>> 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 = <dispatched NonZeroHandler>

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

非正实数谓词。

解释

ask(Q.nonpositive(x)) 当且仅当 x 属于包括零的负数集时为真。

注意 Q.nonpositive 和 ~Q.positive 不是相同的。

事物。 ~Q.positive(x) 简单地表示 x 不是正数，而 Q.nonpositive(x) 表示 x 是实数且不是正数，即 Q.nonpositive(x) 在逻辑上等价于 (Q.negative(x) | Q.zero(x))。例如，~Q.positive(I) 为真，而 Q.nonpositive(I) 为假。

示例

>>> 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 = <dispatched NonPositiveHandler>

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

非负实数谓词。

解释

ask(Q.nonnegative(x)) 当且仅当 x 属于包括零在内的正数集时为真。

请注意，Q.nonnegative 和 ~Q.negative 不是相同的

事情。~Q.negative(x) 简单地意味着 x 不是负数，而 Q.nonnegative(x) 意味着 x 是实数且不为负数，即 Q.nonnegative(x) 在逻辑上等价于 Q.zero(x) | Q.positive(x)。因此，例如，~Q.negative(I) 为真，而 Q.nonnegative(I) 为假。

例子

>>> 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

处理

多重调度方法：非负数处理器

处理 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

处理

多重调度方法：整数处理器

处理 Q.integer。

测试表达式是否属于整数域。

参考资料

[R22]

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

处理

多重调度方法：有理数处理器

处理 Q.rational。

测试表达式是否属于有理数域。

参考资料

[R23]

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

处理

多重调度方法：无理数处理器

处理 Q.irrational。

测试表达式是否是无理数。

参考资料

[R24]

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。

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

每个实数要么是正数、负数或零。此外，

因为这些集合两两不交，每个实数恰好是这三个集合中的一个。
每个实数也是复数。
每个实数都是有限的。
每个实数要么是有理数要么是无理数。
每个实数要么是代数的要么是超越的。
事实 Q.negative、Q.zero、Q.positive，

Q.nonnegative、Q.nonpositive、Q.nonzero、Q.integer、Q.rational 和 Q.irrational 都意味着 Q.real，就像暗示这些事实的所有事实一样。
事实 Q.algebraic 和 Q.transcendental 不意味着

Q.real；它们暗示 Q.complex。代数或超越数可能是实数也可能不是。
“非”事实（即 Q.nonnegative、Q.nonzero，

Q.nonpositive 和 Q.noninteger）与事实不等同，而是事实和Q.real。例如，Q.nonnegative 意味着 ~Q.negative & Q.real。因此，例如，I 不是非负、非零或非正。

例子

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

处理

多重分派方法：RealHandler

Q.real 的处理器。

测试一个表达式是否属于实数域。

参考文献

[R25]

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

处理器

多重分派方法：ExtendedRealHandler

Q.extended_real 的处理器。

测试一个表达式是否属于扩展实数域

数字，即实数并集 {Infinity, -Infinity}。

handler = <dispatched ExtendedRealHandler>

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

厄尔米特数判断。

解释

ask(Q.hermitian(x)) 当且仅当 x 属于厄尔米特操作符集合时为真。

处理器

多重分派方法：HermitianHandler

Q.hermitian 的处理器。

测试一个表达式是否属于厄尔米特操作符域。

参考文献

[R26]

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

处理器

多重分派方法：ComplexHandler

Q.complex 的处理器。

测试一个表达式是否属于复数域。

参考文献

[R27]

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

处理器

多重分派方法：ImaginaryHandler

Q.imaginary 的处理器。

测试一个表达式是否属于虚数域，

即形如 x*I 的数，其中 x 是实数。

参考文献

[R28]

en.wikipedia.org/wiki/Imaginary_number

handler = <dispatched ImaginaryHandler>

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

反埃尔米特数判断。

解释

Q.antihermitian(x) 当且仅当 x 属于反阿尔米特操作符域时为真，即形如 x*I 的操作符，其中 x 是厄尔米特的。

处理器

多重分派方法：AntiHermitianHandler

Q.antihermitian 的处理器。

测试一个表达式是否属于反厄尔米特操作符域

操作符，即形如 x*I 的操作符，其中 x 是厄尔米特的。

参考文献

[R29]

mathworld.wolfram.com/HermitianOperator.html

handler = <dispatched AntiHermitianHandler>

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

代数数判断。

解释

Q.algebraic(x) 当且仅当 x 属于代数数集合时为真。如果存在多项式 p(x)\in \mathbb{Q}[x] 使得 p(x) = 0，则 x 是代数的。

例子

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

处理器

多重分派方法：AskAlgebraicpredicateHandler

AskAlgebraicpredicateHandler 的关键处理器

参考文献

[R30]

en.wikipedia.org/wiki/Algebraic_number

AlgebraicHandler = <dispatched AlgebraicHandler>

handler = <dispatched AskAlgebraicpredicateHandler>

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

超越数述词。

解释

Q.transcendental(x) 当且仅当 x 属于超越数集时为真。超越数是一个既非代数的实数也非复数。

处理程序

多重派发方法：超越数

Q.transcendental 键的处理程序。

handler = <dispatched Transcendental>

微积分

原文：docs.sympy.org/latest/modules/calculus/index.html

与微积分相关的方法。

此模块实现了一种查找给定拉格朗日量的欧拉-拉格朗日方程的方法。

sympy.calculus.euler.euler_equations(L, funcs=(), vars=())

查找给定拉格朗日量的欧拉-拉格朗日方程[R31]。

参数：

L：Expr

拉格朗日量应该是列在第二个参数中的函数及其导数的函数。

例如，在两个函数 (f(x,y))，(g(x,y)) 和两个自变量 (x)，(y) 的情况下，拉格朗日量的形式为：

[L\left(f(x,y),g(x,y),\frac{\partial f(x,y)}{\partial x}, \frac{\partial f(x,y)}{\partial y}, \frac{\partial g(x,y)}{\partial x}, \frac{\partial g(x,y)}{\partial y},x,y\right)]

在许多情况下，除了拉格朗日量之外，通常不需要提供任何内容，它将会自动检测到（如果不能完成这个操作，那么将会产生一个错误）。

函数：Function 或者函数的可迭代对象

拉格朗日量所依赖的函数。欧拉方程是每个这些函数的微分方程。

变量：Symbol 或者符号的可迭代对象

是这些函数的自变量的符号。

方程：Eq 列表

差分方程的列表，每个函数一个。

示例

>>> from sympy import euler_equations, Symbol, Function
>>> x = Function('x')
>>> t = Symbol('t')
>>> L = (x(t).diff(t))**2/2 - x(t)**2/2
>>> euler_equations(L, x(t), t)
[Eq(-x(t) - Derivative(x(t), (t, 2)), 0)]
>>> u = Function('u')
>>> x = Symbol('x')
>>> L = (u(t, x).diff(t))**2/2 - (u(t, x).diff(x))**2/2
>>> euler_equations(L, u(t, x), [t, x])
[Eq(-Derivative(u(t, x), (t, 2)) + Derivative(u(t, x), (x, 2)), 0)]

参考

[R31] (1,2)

en.wikipedia.org/wiki/Euler%E2%80%93Lagrange_equation

奇点

此模块实现了查找函数的奇点以及识别函数类型的算法。

本模块中的微分计算方法包括以下方法来识别给定Interval中的以下函数类型： - 增加 - 严格增加 - 减少 - 严格减少 - 单调

sympy.calculus.singularities.is_decreasing(expression, interval=Reals, symbol=None)

返回函数在给定区间内是否减少。

参数：

表达式：Expr

正在检查的目标函数。

区间：Set，可选

测试范围中的值的范围（默认为所有实数的集合）。

符号：Symbol，可选

表达式中存在的符号在给定范围内变化。

布尔值

如果expression在给定的interval中减少（严格减少或常数），则为 True。

示例

>>> from sympy import is_decreasing
>>> from sympy.abc import x, y
>>> from sympy import S, Interval, oo
>>> is_decreasing(1/(x**2 - 3*x), Interval.open(S(3)/2, 3))
True
>>> is_decreasing(1/(x**2 - 3*x), Interval.open(1.5, 3))
True
>>> is_decreasing(1/(x**2 - 3*x), Interval.Lopen(3, oo))
True
>>> is_decreasing(1/(x**2 - 3*x), Interval.Ropen(-oo, S(3)/2))
False
>>> is_decreasing(1/(x**2 - 3*x), Interval.Ropen(-oo, 1.5))
False
>>> is_decreasing(-x**2, Interval(-oo, 0))
False
>>> is_decreasing(-x**2 + y, Interval(-oo, 0), x)
False

sympy.calculus.singularities.is_increasing(expression, interval=Reals, symbol=None)

返回函数在给定区间内是否增加。

参数：

表达式：Expr

正在检查的目标函数。

区间：Set，可选

测试范围中的值的范围（默认为所有实数的集合）。

符号：Symbol，可选

表达式中存在的符号在给定范围内变化。

布尔值

如果expression在给定的interval中增加（严格增加或常数），则为 True。

示例

>>> from sympy import is_increasing
>>> from sympy.abc import x, y
>>> from sympy import S, Interval, oo
>>> is_increasing(x**3 - 3*x**2 + 4*x, S.Reals)
True
>>> is_increasing(-x**2, Interval(-oo, 0))
True
>>> is_increasing(-x**2, Interval(0, oo))
False
>>> is_increasing(4*x**3 - 6*x**2 - 72*x + 30, Interval(-2, 3))
False
>>> is_increasing(x**2 + y, Interval(1, 2), x)
True

sympy.calculus.singularities.is_monotonic(expression, interval=Reals, symbol=None)

返回函数在给定区间内是否单调。

参数：

表达式：Expr

正在检查的目标函数。

区间：Set，可选

我们正在测试的值的范围（默认为所有实数的集合）。

符号：符号，可选

在给定范围内变化的表达式中出现的符号。

布尔值

如果expression在给定的interval中是单调的，则为真，否则为假。

引发：

未实现错误

未对查询函数实施单调性检查。

示例

>>> from sympy import is_monotonic
>>> from sympy.abc import x, y
>>> from sympy import S, Interval, oo
>>> is_monotonic(1/(x**2 - 3*x), Interval.open(S(3)/2, 3))
True
>>> is_monotonic(1/(x**2 - 3*x), Interval.open(1.5, 3))
True
>>> is_monotonic(1/(x**2 - 3*x), Interval.Lopen(3, oo))
True
>>> is_monotonic(x**3 - 3*x**2 + 4*x, S.Reals)
True
>>> is_monotonic(-x**2, S.Reals)
False
>>> is_monotonic(x**2 + y + 1, Interval(1, 2), x)
True

sympy.calculus.singularities.is_strictly_decreasing(expression, interval=Reals, symbol=None)

返回函数在给定区间内是否严格递减。

参数：

expression：表达式

正在检查的目标函数。

interval：集合，可选

我们正在测试的值的范围（默认为所有实数的集合）。

符号：符号，可选

在给定范围内变化的表达式中出现的符号。

布尔值

如果expression在给定的interval中严格递减，则为 True，否则为 False。

示例

>>> from sympy import is_strictly_decreasing
>>> from sympy.abc import x, y
>>> from sympy import S, Interval, oo
>>> is_strictly_decreasing(1/(x**2 - 3*x), Interval.Lopen(3, oo))
True
>>> is_strictly_decreasing(1/(x**2 - 3*x), Interval.Ropen(-oo, S(3)/2))
False
>>> is_strictly_decreasing(1/(x**2 - 3*x), Interval.Ropen(-oo, 1.5))
False
>>> is_strictly_decreasing(-x**2, Interval(-oo, 0))
False
>>> is_strictly_decreasing(-x**2 + y, Interval(-oo, 0), x)
False

sympy.calculus.singularities.is_strictly_increasing(expression, interval=Reals, symbol=None)

返回函数在给定区间内是否严格递增。

参数：

expression：表达式

正在检查的目标函数。

interval：集合，可选

我们正在测试的值的范围（默认为所有实数的集合）。

符号：符号，可选

在给定范围内变化的表达式中出现的符号。

布尔值

如果expression在给定的interval中严格递增，则为 True，否则为 False。

示例

>>> from sympy import is_strictly_increasing
>>> from sympy.abc import x, y
>>> from sympy import Interval, oo
>>> is_strictly_increasing(4*x**3 - 6*x**2 - 72*x + 30, Interval.Ropen(-oo, -2))
True
>>> is_strictly_increasing(4*x**3 - 6*x**2 - 72*x + 30, Interval.Lopen(3, oo))
True
>>> is_strictly_increasing(4*x**3 - 6*x**2 - 72*x + 30, Interval.open(-2, 3))
False
>>> is_strictly_increasing(-x**2, Interval(0, oo))
False
>>> is_strictly_increasing(-x**2 + y, Interval(-oo, 0), x)
False

sympy.calculus.singularities.monotonicity_helper(expression, predicate, interval=Reals, symbol=None)

函数助手，用于检查函数单调性的函数。

参数：

expression：表达式

正在检查的目标函数

谓词：函数

正在测试的属性。该函数接受一个整数并返回一个布尔值。如果属性被满足，则整数输入是导数，布尔结果应为真，否则为假。

interval：集合，可选

我们正在测试的值的范围，默认为所有实数。

符号：符号，可选

在给定范围内变化的表达式中出现的符号。

它返回一个布尔值，指示区间是否

函数的导数满足给定谓词是一个超集

给定区间的。

布尔值

当在range中变化symbol时，如果所有导数都为真，则为predicate，否则为假。

sympy.calculus.singularities.singularities(expression, symbol, domain=None)

查找给定函数的奇点。

参数：

expression：表达式

需要找到奇点的目标函数。

符号：符号

表达式中正在搜索的奇点的符号变化的值。

集合

为symbol的一组值，对于这些值的任何给定值，expression都具有奇点。如果expression没有任何奇点，则返回EmptySet。

引发：

未实现错误

尚未开发此函数的奇点确定方法。

注：

此函数不查找非孤立的奇点，也不查找表达式的分支点。

目前支持的函数有：

单变量连续（实数或复数）函数

示例

>>> from sympy import singularities, Symbol, log
>>> x = Symbol('x', real=True)
>>> y = Symbol('y', real=False)
>>> singularities(x**2 + x + 1, x)
EmptySet
>>> singularities(1/(x + 1), x)
{-1}
>>> singularities(1/(y**2 + 1), y)
{-I, I}
>>> singularities(1/(y**3 + 1), y)
{-1, 1/2 - sqrt(3)*I/2, 1/2 + sqrt(3)*I/2}
>>> singularities(log(x), x)
{0}

参考资料

[R32]

en.wikipedia.org/wiki/Mathematical_singularity

有限差分权重

参数：

核心算法提供了用于生成有限差分权重的函数 (finite_diff_weights)，并提供了两个便利函数用于：

示例

也提供了 (apply_finite_diff)。
使用有限差分近似进行微分

本模块实现了一个用于常微分方程中的函数导数的有效生成有限差分权重的算法，从 0 阶（插值）到任意阶数。（differentiate_finite）。

sympy.calculus.finite_diff.apply_finite_diff(order, x_list, y_list, x0=0)

直接从一系列点中估算导数（或插值）

order: int

y_list: sequence

待翻译的文本有很多行，请稍等，正在处理中。```markdown

参见

独立变量的（唯一）值序列。

待翻译的文本有很多行，请稍等，正在处理中。

示例

x0: Number or Symbol

在哪个独立变量的值上应该评估导数。默认为 0。

sympy.core.add.Add or sympy.core.numbers.Number

在 x0 处近似请求的导数阶数的有限差分表达式。

x_list: sequence

>>> from sympy import apply_finite_diff
>>> cube = lambda arg: (1.0*arg)**3
>>> xlist = range(-3,3+1)
>>> apply_finite_diff(2, xlist, map(cube, xlist), 2) - 12 
-3.55271367880050e-15

我们看到上面的示例仅包含舍入误差。apply_finite_diff 也可用于更抽象的对象：

>>> from sympy import IndexedBase, Idx
>>> x, y = map(IndexedBase, 'xy')
>>> i = Idx('i')
>>> x_list, y_list = zip(*[(x[i+j], y[i+j]) for j in range(-1,2)])
>>> apply_finite_diff(1, x_list, y_list, x[i])
((x[i + 1] - x[i])/(-x[i - 1] + x[i]) - 1)*y[i]/(x[i + 1] - x[i]) -
(x[i + 1] - x[i])*y[i - 1]/((x[i + 1] - x[i - 1])*(-x[i - 1] + x[i])) +
(-x[i - 1] + x[i])*y[i + 1]/((x[i + 1] - x[i - 1])*(x[i + 1] - x[i]))

注释

阶数 = 0 对应插值。仅在提取导数时提供足够多的点是有意义的（函数在该区域内表现良好）。也注意 Runge 现象。

*symbols : 对符号进行微分

sympy.calculus.finite_diff.finite_diff_weights

参考文献

用于数值计算的 Python 接口的 Fortran 90 实现：finitediff

sympy.calculus.finite_diff.differentiate_finite(expr, *symbols, points=1, x0=None, wrt=None, evaluate=False)

对表达式进行微分，并用有限差分替换导数。

参数：

expr : 表达式

计算在提供的 x_list 和 y_list 中，在 x0 处请求的阶数的有限差分近似的导数。

points: sequence, coefficient or undefined function, optional

参数：

x0: number or Symbol, optional

参见 Derivative.as_finite_difference

wrt: Symbol, optional

参见 Derivative.as_finite_difference

参见 Derivative.as_finite_difference

>>> from sympy import sin, Function, differentiate_finite
>>> from sympy.abc import x, y, h
>>> f, g = Function('f'), Function('g')
>>> differentiate_finite(f(x)*g(x), x, points=[x-h, x+h])
-f(-h + x)*g(-h + x)/(2*h) + f(h + x)*g(h + x)/(2*h)

differentiate_finite 适用于任何表达式，包括带有嵌入导数的表达式：

>>> differentiate_finite(f(x) + sin(x), x, 2)
-2*f(x) + f(x - 1) + f(x + 1) - 2*sin(x) + sin(x - 1) + sin(x + 1)
>>> differentiate_finite(f(x, y), x, y)
f(x - 1/2, y - 1/2) - f(x - 1/2, y + 1/2) - f(x + 1/2, y - 1/2) + f(x + 1/2, y + 1/2)
>>> differentiate_finite(f(x)*g(x).diff(x), x)
(-g(x) + g(x + 1))*f(x + 1/2) - (g(x) - g(x - 1))*f(x - 1/2)

若要使用非恒定离散化步长进行有限差分，请使用未定义的函数：

>>> dx = Function('dx')
>>> differentiate_finite(f(x)*g(x).diff(x), points=dx(x))
-(-g(x - dx(x)/2 - dx(x - dx(x)/2)/2)/dx(x - dx(x)/2) +
g(x - dx(x)/2 + dx(x - dx(x)/2)/2)/dx(x - dx(x)/2))*f(x - dx(x)/2)/dx(x) +
(-g(x + dx(x)/2 - dx(x + dx(x)/2)/2)/dx(x + dx(x)/2) +
g(x + dx(x)/2 + dx(x + dx(x)/2)/2)/dx(x + dx(x)/2))*f(x + dx(x)/2)/dx(x)

sympy.calculus.finite_diff.finite_diff_weights(order, x_list, x0=1)

使用递归公式计算 x_list 上任意间隔的一维网格的 x0 处的阶数 0、1、…、order 的有限差分权重。如果 x_list 正确定义，则精度顺序至少为 len(x_list) - order。

独立变量在 x_list 中相应值处的函数值。

order: int

权重应计算到哪个导数阶数。0 对应插值。

x_list: sequence

独立变量的（唯一）值序列。有用（但不必要）将x_list从离x0最近到最远进行排序；请参见下面的示例。

x0: Number or Symbol

应生成有限差分权重的根或独立变量的值。默认为S.One。

列表

一个子列表的列表，每个子列表对应于增加的导数阶数的系数，并且每个子列表包含增加的x_list子集的系数列表。

例子

>>> from sympy import finite_diff_weights, S
>>> res = finite_diff_weights(1, [-S(1)/2, S(1)/2, S(3)/2, S(5)/2], 0)
>>> res
[[[1, 0, 0, 0],
 [1/2, 1/2, 0, 0],
 [3/8, 3/4, -1/8, 0],
 [5/16, 15/16, -5/16, 1/16]],
 [[0, 0, 0, 0],
 [-1, 1, 0, 0],
 [-1, 1, 0, 0],
 [-23/24, 7/8, 1/8, -1/24]]]
>>> res[0][-1]  # FD weights for 0th derivative, using full x_list
[5/16, 15/16, -5/16, 1/16]
>>> res[1][-1]  # FD weights for 1st derivative
[-23/24, 7/8, 1/8, -1/24]
>>> res[1][-2]  # FD weights for 1st derivative, using x_list[:-1]
[-1, 1, 0, 0]
>>> res[1][-1][0]  # FD weight for 1st deriv. for x_list[0]
-23/24
>>> res[1][-1][1]  # FD weight for 1st deriv. for x_list[1], etc.
7/8

每个子列表包含最精确的公式在最后。请注意，在上面的示例中，res[1][1]与res[1][2]相同。由于res[1][2]的精度顺序为len(x_list[:3]) - order = 3 - 1 = 2，对于res[1][1]也是如此！

>>> res = finite_diff_weights(1, [S(0), S(1), -S(1), S(2), -S(2)], 0)[1]
>>> res
[[0, 0, 0, 0, 0],
 [-1, 1, 0, 0, 0],
 [0, 1/2, -1/2, 0, 0],
 [-1/2, 1, -1/3, -1/6, 0],
 [0, 2/3, -2/3, -1/12, 1/12]]
>>> res[0]  # no approximation possible, using x_list[0] only
[0, 0, 0, 0, 0]
>>> res[1]  # classic forward step approximation
[-1, 1, 0, 0, 0]
>>> res[2]  # classic centered approximation
[0, 1/2, -1/2, 0, 0]
>>> res[3:]  # higher order approximations
[[-1/2, 1, -1/3, -1/6, 0], [0, 2/3, -2/3, -1/12, 1/12]]

让我们将其与另外定义的x_list进行比较。注意foo[i][k]对应于由x_list[k]定义的网格点。

>>> foo = finite_diff_weights(1, [-S(2), -S(1), S(0), S(1), S(2)], 0)[1]
>>> foo
[[0, 0, 0, 0, 0],
 [-1, 1, 0, 0, 0],
 [1/2, -2, 3/2, 0, 0],
 [1/6, -1, 1/2, 1/3, 0],
 [1/12, -2/3, 0, 2/3, -1/12]]
>>> foo[1]  # not the same and of lower accuracy as res[1]!
[-1, 1, 0, 0, 0]
>>> foo[2]  # classic double backward step approximation
[1/2, -2, 3/2, 0, 0]
>>> foo[4]  # the same as res[4]
[1/12, -2/3, 0, 2/3, -1/12]

请注意，除非您计划使用基于x_list子集的逼近，否则网格点的顺序不重要。

可以在任意点生成权重的能力，例如可以通过使用切比雪夫节点来最小化朗格现象：

>>> from sympy import cos, symbols, pi, simplify
>>> N, (h, x) = 4, symbols('h x')
>>> x_list = [x+h*cos(i*pi/(N)) for i in range(N,-1,-1)] # chebyshev nodes
>>> print(x_list)
[-h + x, -sqrt(2)*h/2 + x, x, sqrt(2)*h/2 + x, h + x]
>>> mycoeffs = finite_diff_weights(1, x_list, 0)[1][4]
>>> [simplify(c) for c in  mycoeffs] 
[(h**3/2 + h**2*x - 3*h*x**2 - 4*x**3)/h**4,
(-sqrt(2)*h**3 - 4*h**2*x + 3*sqrt(2)*h*x**2 + 8*x**3)/h**4,
(6*h**2*x - 8*x**3)/h**4,
(sqrt(2)*h**3 - 4*h**2*x - 3*sqrt(2)*h*x**2 + 8*x**3)/h**4,
(-h**3/2 + h**2*x + 3*h*x**2 - 4*x**3)/h**4]

注意事项

如果想要用于有限差分逼近的三阶导数的权重，则可以免费计算零阶、一阶和二阶的权重，以及使用x_list子集的公式。这是可以利用以节省计算成本的东西。请注意，应该将x_list从离x0最近到最远进行定义。如果不是这样，x_list的子集将产生较差的逼近，可能无法获得len(x_list) - order的精度顺序。

另请参阅

sympy.calculus.finite_diff.apply_finite_diff

参考文献

[R33]

在任意间隔网格上生成有限差分公式，Bengt Fornberg；计算数学；51；184；（1988）；699-706；doi:10.1090/S0025-5718-1988-0935077-0

sympy.calculus.util.continuous_domain(f, symbol, domain)

返回函数表达式f连续的定义域。

此函数受限于确定给定函数的各种奇点和不连续性的能力。结果要么作为间隔的并集给出，要么使用其他集合运算构造。

参数：

f : Expr

相关的函数。

symbol : Symbol

要确定间隔的变量。

domain : Interval

必须检查符号连续性的定义域。

Interval

函数连续的所有间隔的并集。

异常：

NotImplementedError

如果尚未开发出确定此类函数连续性的方法。

例子

>>> from sympy import Interval, Symbol, S, tan, log, pi, sqrt
>>> from sympy.calculus.util import continuous_domain
>>> x = Symbol('x')
>>> continuous_domain(1/x, x, S.Reals)
Union(Interval.open(-oo, 0), Interval.open(0, oo))
>>> continuous_domain(tan(x), x, Interval(0, pi))
Union(Interval.Ropen(0, pi/2), Interval.Lopen(pi/2, pi))
>>> continuous_domain(sqrt(x - 2), x, Interval(-5, 5))
Interval(2, 5)
>>> continuous_domain(log(2*x - 1), x, S.Reals)
Interval.open(1/2, oo)

sympy.calculus.util.function_range(f, symbol, domain)

在给定域中找到函数的范围。该方法受限于确定奇点和确定极限的能力。

参数：

f：Expr

相关函数。

符号：Symbol

要确定函数范围的变量。

域：Interval

函数的范围必须找到的域。

Interval

所有区间下函数连续的域的所有范围的并集。

异常：

未实现错误

如果给定域中任何一个区间中的函数连续不是有限的或实数的，或者无法找到域上函数的临界点。

示例

>>> from sympy import Interval, Symbol, S, exp, log, pi, sqrt, sin, tan
>>> from sympy.calculus.util import function_range
>>> x = Symbol('x')
>>> function_range(sin(x), x, Interval(0, 2*pi))
Interval(-1, 1)
>>> function_range(tan(x), x, Interval(-pi/2, pi/2))
Interval(-oo, oo)
>>> function_range(1/x, x, S.Reals)
Union(Interval.open(-oo, 0), Interval.open(0, oo))
>>> function_range(exp(x), x, S.Reals)
Interval.open(0, oo)
>>> function_range(log(x), x, S.Reals)
Interval(-oo, oo)
>>> function_range(sqrt(x), x, Interval(-5, 9))
Interval(0, 3)

sympy.calculus.util.is_convex(f, *syms, domain=Reals)

确定传入参数中函数的凸性。

参数：

f：Expr

相关函数。

符号：Symbol的元组

要确定凸性的变量。

域：Interval，可选

要检查函数凸性的域。如果未指定，S.Reals 将是默认域。

布尔

如果函数是凸的，则方法返回True，否则返回False。

异常：

未实现错误

尚未实现多变量函数的凸性检查。

注意

要确定函数的凹性，请将(-f)传递为相关函数。要确定函数的对数凸性，请将(\log(f))作为相关函数。要确定函数的对数凹性，请将(-\log(f))作为相关函数。

目前，不处理多变量函数的凸性检查。

示例

>>> from sympy import is_convex, symbols, exp, oo, Interval
>>> x = symbols('x')
>>> is_convex(exp(x), x)
True
>>> is_convex(x**3, x, domain = Interval(-1, oo))
False
>>> is_convex(1/x**2, x, domain=Interval.open(0, oo))
True

参考资料

[R34]

zh.wikipedia.org/wiki/凸函数

[R35]

www.ifp.illinois.edu/~angelia/L3_convfunc.pdf

[R36]

zh.wikipedia.org/wiki/对数凸函数

[R37]

zh.wikipedia.org/wiki/对数凹函数

[R38]

zh.wikipedia.org/wiki/凹函数

sympy.calculus.util.lcim(numbers)

返回数字列表的最小公倍数。

数字可以是有理数或无理数或两者混合。对于不可共同测量的数字，返回(None)。

参数：

数字：列表

要找到 lcim 的有理和/或无理数。

数字

如果存在，则返回 lcim，否则对于不可比较的数字返回None。

示例

>>> from sympy.calculus.util import lcim
>>> from sympy import S, pi
>>> lcim([S(1)/2, S(3)/4, S(5)/6])
15/2
>>> lcim([2*pi, 3*pi, pi, pi/2])
6*pi
>>> lcim([S(1), 2*pi])

sympy.calculus.util.maximum(f, symbol, domain=Reals)

返回给定定义域内函数的最大值。

参数：

f : Expr

相关函数。

symbol : Symbol

需要确定最大值变量。

domain : Interval

需要确定最大值的定义域。如果未指定，则返回全局最大值。

数字

给定定义域内函数的最大值。

示例

>>> from sympy import Interval, Symbol, S, sin, cos, pi, maximum
>>> x = Symbol('x')

>>> f = -x**2 + 2*x + 5
>>> maximum(f, x, S.Reals)
6

>>> maximum(sin(x), x, Interval(-pi, pi/4))
sqrt(2)/2

>>> maximum(sin(x)*cos(x), x)
1/2

sympy.calculus.util.minimum(f, symbol, domain=Reals)

返回给定定义域内函数的最小值。

参数：

f : Expr

相关函数。

symbol : Symbol

需要确定最小值变量。

domain : Interval

需要确定最小值的定义域。如果未指定，则返回全局最小值。

数字

给定定义域内函数的最小值。

示例

>>> from sympy import Interval, Symbol, S, sin, cos, minimum
>>> x = Symbol('x')

>>> f = x**2 + 2*x + 5
>>> minimum(f, x, S.Reals)
4

>>> minimum(sin(x), x, Interval(2, 3))
sin(3)

>>> minimum(sin(x)*cos(x), x)
-1/2

sympy.calculus.util.not_empty_in(finset_intersection, *syms)

在finset_intersection中找到函数的定义域，其中finite_set非空。

参数：

finset_intersection : 有限集的交集

未计算的交集，包含具有联合集的实值函数的有限集

syms : 符号元组

寻找要找到其定义域的符号

引发：

NotImplementedError

尚未实现用于查找给定有限集非空性的算法。

ValueError

输入无效。

RuntimeError

这是一个 bug，请报告给 github 问题跟踪器（github.com/sympy/sympy/issues）。

示例

>>> from sympy import FiniteSet, Interval, not_empty_in, oo
>>> from sympy.abc import x
>>> not_empty_in(FiniteSet(x/2).intersect(Interval(0, 1)), x)
Interval(0, 2)
>>> not_empty_in(FiniteSet(x, x**2).intersect(Interval(1, 2)), x)
Union(Interval(1, 2), Interval(-sqrt(2), -1))
>>> not_empty_in(FiniteSet(x**2/(x + 2)).intersect(Interval(1, oo)), x)
Union(Interval.Lopen(-2, -1), Interval(2, oo))

sympy.calculus.util.periodicity(f, symbol, check=False)

测试给定符号中函数的周期性。

参数：

f : Expr

相关函数。

symbol : Symbol

需要确定周期的变量。

check : bool, 可选

用于验证返回值是否为周期的标志。

周期

返回函数的周期。当函数是非周期的或具有复杂周期时，返回None。常数函数的周期值为(0)。

引发：

NotImplementedError

无法验证计算出的周期值。

注释

目前，我们不支持具有复杂周期的函数。评估具有复杂周期值（例如exp、sinh）的函数周期为None。

返回的值可能不是给定函数的“基本”周期，即它可能不是函数的最小周期值。

由于给定表达式的内部简化，通过check标志验证周期不可靠。因此，默认情况下将其设置为False。

示例

>>> from sympy import periodicity, Symbol, sin, cos, tan, exp
>>> x = Symbol('x')
>>> f = sin(x) + sin(2*x) + sin(3*x)
>>> periodicity(f, x)
2*pi
>>> periodicity(sin(x)*cos(x), x)
pi
>>> periodicity(exp(tan(2*x) - 1), x)
pi/2
>>> periodicity(sin(4*x)**cos(2*x), x)
pi
>>> periodicity(exp(x), x)

sympy.calculus.util.stationary_points(f, symbol, domain=Reals)

返回给定域内函数的静止点（函数的导数为 0 的地方）。

参数：

f：Expr

相关的函数。

symbol：Symbol

要确定静止点的变量。

domain：Interval

要检查静止点的定义域。如果未指定，默认情况下为S.Reals。

集合

函数的一组静止点。如果没有静止点，则返回一个EmptySet。

示例

>>> from sympy import Interval, Symbol, S, sin, pi, pprint, stationary_points
>>> x = Symbol('x')

>>> stationary_points(1/x, x, S.Reals)
EmptySet

>>> pprint(stationary_points(sin(x), x), use_unicode=False)
 pi                              3*pi
{2*n*pi + -- | n in Integers} U {2*n*pi + ---- | n in Integers}
 2                                2

>>> stationary_points(sin(x),x, Interval(0, 4*pi))
{pi/2, 3*pi/2, 5*pi/2, 7*pi/2}

组合数学

原文：docs.sympy.org/latest/modules/combinatorics/index.html

分区

原文：docs.sympy.org/latest/modules/combinatorics/partitions.html

class sympy.combinatorics.partitions.Partition(*partition)

此类表示一个抽象分区。

分区是一组其联合等于给定集合的不相交集合。

参见

sympy.utilities.iterables.partitions，sympy.utilities.iterables.multiset_partitions

property RGS

返回分区的“受限增长字符串”。

解释

返回 RGS 作为索引列表 L，其中 L[i] 表示元素 i 出现在哪个块中。例如，在将 3 个元素（a、b、c）分成 2 个块（[c]、[a, b]）的分区中，RGS 是 [1, 1, 0]：“a” 在块 1 中，“b” 在块 1 中，“c” 在块 0 中。

例子

>>> from sympy.combinatorics import Partition
>>> a = Partition([1, 2], [3], [4, 5])
>>> a.members
(1, 2, 3, 4, 5)
>>> a.RGS
(0, 0, 1, 2, 2)
>>> a + 1
Partition({3}, {4}, {5}, {1, 2})
>>> _.RGS
(0, 0, 1, 2, 3)

classmethod from_rgs(rgs, elements)

从受限增长字符串创建一个集合分区。

解释

假设 rgs 中给定的索引是元素在提供的 elements 中的索引（此例程不对元素进行排序）。块编号从 0 开始。如果在 rgs 中没有引用任何块，则会引发错误。

例子

>>> from sympy.combinatorics import Partition
>>> Partition.from_rgs([0, 1, 2, 0, 1], list('abcde'))
Partition({c}, {a, d}, {b, e})
>>> Partition.from_rgs([0, 1, 2, 0, 1], list('cbead'))
Partition({e}, {a, c}, {b, d})
>>> a = Partition([1, 4], [2], [3, 5])
>>> Partition.from_rgs(a.RGS, a.members)
Partition({2}, {1, 4}, {3, 5})

property partition

返回分区作为排序后的列表列表。

例子

>>> from sympy.combinatorics import Partition
>>> Partition([1], [2, 3]).partition
[[1], [2, 3]]

property rank

获取分区的等级。

例子

>>> from sympy.combinatorics import Partition
>>> a = Partition([1, 2], [3], [4, 5])
>>> a.rank
13

sort_key(order=None)

返回一个可用于排序的规范键。

排序基于分区的大小和排序后的元素，并使用排名来解决冲突。

例子

>>> from sympy import default_sort_key
>>> from sympy.combinatorics import Partition
>>> from sympy.abc import x
>>> a = Partition([1, 2])
>>> b = Partition([3, 4])
>>> c = Partition([1, x])
>>> d = Partition(list(range(4)))
>>> l = [d, b, a + 1, a, c]
>>> l.sort(key=default_sort_key); l
[Partition({1, 2}), Partition({1}, {2}), Partition({1, x}), Partition({3, 4}), Partition({0, 1, 2, 3})]

class sympy.combinatorics.partitions.IntegerPartition(partition, integer=None)

此类表示一个整数分区。

解释

在数论和组合数学中，正整数 n 的一个分区，也称为整数分区，是将 n 写成一组总和为 n 的正整数列表的一种方式。只有在加法因子的顺序不同的两个分区被视为相同的分区；如果顺序有影响，则称为组合。例如，4 有五个分区：[4]、[3, 1]、[2, 2]、[2, 1, 1] 和 [1, 1, 1, 1]；组合 [1, 2, 1] 和 [1, 1, 2] 与分区 [2, 1, 1] 是相同的。

参见

sympy.utilities.iterables.partitions，sympy.utilities.iterables.multiset_partitions

参考

[R61]

en.wikipedia.org/wiki/Partition_%28number_theory%29

as_dict()

返回分区作为一个字典，其键是分区整数，值是该整数的重复次数。

例子

>>> from sympy.combinatorics.partitions import IntegerPartition
>>> IntegerPartition([1]*3 + [2] + [3]*4).as_dict()
{1: 3, 2: 1, 3: 4}

as_ferrers(char='#')

打印分区的费雷尔图。

例子

>>> from sympy.combinatorics.partitions import IntegerPartition
>>> print(IntegerPartition([1, 1, 5]).as_ferrers())
#####
#
#

property conjugate

计算其自身的共轭分区。

例子

>>> from sympy.combinatorics.partitions import IntegerPartition
>>> a = IntegerPartition([6, 3, 3, 2, 1])
>>> a.conjugate
[5, 4, 3, 1, 1, 1]

next_lex()

返回整数 n 的下一个分区的字典顺序，如果分区是 [1, …, 1]，则环绕到 [n]。

例子

>>> from sympy.combinatorics.partitions import IntegerPartition
>>> p = IntegerPartition([3, 1])
>>> print(p.next_lex())
[4]
>>> p.partition < p.next_lex().partition
True

prev_lex()

返回整数 n 的前一个分割，按字典顺序排列，如果分割是 [n]，则返回 [1, …, 1]。

示例

>>> from sympy.combinatorics.partitions import IntegerPartition
>>> p = IntegerPartition([4])
>>> print(p.prev_lex())
[3, 1]
>>> p.partition > p.prev_lex().partition
True

sympy.combinatorics.partitions.random_integer_partition(n, seed=None)

生成一个随机整数分割，其和为n，作为逆排序整数列表。

示例

>>> from sympy.combinatorics.partitions import random_integer_partition

对于以下情况，给出了一个种子，以便展示已知值；在实践中，不会给出种子。

>>> random_integer_partition(100, seed=[1, 1, 12, 1, 2, 1, 85, 1])
[85, 12, 2, 1]
>>> random_integer_partition(10, seed=[1, 2, 3, 1, 5, 1])
[5, 3, 1, 1]
>>> random_integer_partition(1)
[1]

sympy.combinatorics.partitions.RGS_generalized(m)

计算 m + 1 广义无限增长字符串，并将它们作为矩阵中的行返回。

示例

>>> from sympy.combinatorics.partitions import RGS_generalized
>>> RGS_generalized(6)
Matrix([
[  1,   1,   1,  1,  1, 1, 1],
[  1,   2,   3,  4,  5, 6, 0],
[  2,   5,  10, 17, 26, 0, 0],
[  5,  15,  37, 77,  0, 0, 0],
[ 15,  52, 151,  0,  0, 0, 0],
[ 52, 203,   0,  0,  0, 0, 0],
[203,   0,   0,  0,  0, 0, 0]])

sympy.combinatorics.partitions.RGS_enum(m)

RGS_enum 计算大小为 m 的超集可能的受限增长字符串的总数。

示例

>>> from sympy.combinatorics.partitions import RGS_enum
>>> from sympy.combinatorics import Partition
>>> RGS_enum(4)
15
>>> RGS_enum(5)
52
>>> RGS_enum(6)
203

我们可以通过实际生成分割来检查枚举是否正确。这里，生成了 4 个项的 15 个分割：

>>> a = Partition(list(range(4)))
>>> s = set()
>>> for i in range(20):
...     s.add(a)
...     a += 1
...
>>> assert len(s) == 15

sympy.combinatorics.partitions.RGS_unrank(rank, m)

给定超集大小，返回未排序的受限增长字符串。

示例

>>> from sympy.combinatorics.partitions import RGS_unrank
>>> RGS_unrank(14, 4)
[0, 1, 2, 3]
>>> RGS_unrank(0, 4)
[0, 0, 0, 0]

sympy.combinatorics.partitions.RGS_rank(rgs)

计算受限增长字符串的秩。

示例

>>> from sympy.combinatorics.partitions import RGS_rank, RGS_unrank
>>> RGS_rank([0, 1, 2, 1, 3])
42
>>> RGS_rank(RGS_unrank(4, 7))
4

排列

原文：docs.sympy.org/latest/modules/combinatorics/permutations.html

class sympy.combinatorics.permutations.Permutation(*args, size=None, **kwargs)

一个排列，又称为“排列数”或“顺序”，是将有序列表的元素重新排列成与自身的一一映射。给定一个排列的安排是指在重新排列后元素的位置：[R80]。例如，如果开始时元素为 [x, y, a, b]（按照这个顺序），并且将它们重新排序为 [x, y, b, a]，那么排列就是 [0, 1, 3, 2]。请注意（在 SymPy 中），第一个元素总是被称为 0，排列使用原始排序中元素的索引，而不是元素本身 (a, b, ...)。

>>> from sympy.combinatorics import Permutation
>>> from sympy import init_printing
>>> init_printing(perm_cyclic=False, pretty_print=False)

排列表示法

排列通常用不相交循环或数组形式表示。

数组表示法和二行形式

在二行形式中，元素及其最终位置被显示为一个具有 2 行的矩阵：

[0 1 2 … n-1] [p(0) p(1) p(2) … p(n-1)]

由于第一行总是 range(n)，其中 n 是 p 的大小，仅用第二行表示排列已足以，称为排列的“数组形式”，用方括号作为 Permutation 类的参数输入：

>>> p = Permutation([0, 2, 1]); p
Permutation([0, 2, 1])

给定 i 在范围(p.size)内，排列将 i 映射到 i^p

>>> [i^p for i in range(p.size)]
[0, 2, 1]

两个排列 pq 的复合意味着首先应用 p，然后 q，因此 i^(pq) = (i^p)q，根据 Python 的优先规则是 i^pq：

>>> q = Permutation([2, 1, 0])
>>> [i^p^q for i in range(3)]
[2, 0, 1]
>>> [i^(p*q) for i in range(3)]
[2, 0, 1]

也可以使用 p(i) = i^p 的表示法，但是复合规则是 (p*q)(i) = q(p(i))，而不是 p(q(i))：

>>> [(p*q)(i) for i in range(p.size)]
[2, 0, 1]
>>> [q(p(i)) for i in range(p.size)]
[2, 0, 1]
>>> [p(q(i)) for i in range(p.size)]
[1, 2, 0]

不相交循环表示法

在不相交循环表示法中，只指示了已移动的元素。

例如，[1, 3, 2, 0] 可以表示为 (0, 1, 3)(2)。这可以从给定排列的二行格式理解。在二行形式中，[0 1 2 3] [1 3 2 0]

第 0 位置的元素是 1，所以 0 -> 1. 第 1 位置的元素是三，所以 1 -> 3. 而第三位置的元素再次是 0，所以 3 -> 0. 因此，0 -> 1 -> 3 -> 0，而 2 -> 2. 因此，这可以表示为 2 个循环：(0, 1, 3)(2)。通常的表示法中，单个循环不会显式写出，因为可以隐含推断。

只有循环中元素的相对顺序才有意义：

>>> Permutation(1,2,3) == Permutation(2,3,1) == Permutation(3,1,2)
True

不相交循环表示法在表示具有多个循环的排列时很方便：

>>> Permutation(1, 2)(3, 5) == Permutation([[1, 2], [3, 5]])
True

在计算以不相交循环表示法书写的排列乘积时，这也提供了一些输入的经济性：

>>> Permutation(1, 2)(1, 3)(2, 3)
Permutation([0, 3, 2, 1])
>>> _ == Permutation([[1, 2]])*Permutation([[1, 3]])*Permutation([[2, 3]])
True

Caution: 当循环之间存在共同元素时，排列的应用顺序至关重要。此模块按照从左到右的顺序应用排列。
>>> Permutation(1, 2)(2, 3) == Permutation([(1, 2), (2, 3)])

True

>>> Permutation(1, 2)(2, 3).list()

[0, 3, 1, 2] 
在上述情况中，(1,2) 在 (2,3) 之前计算。由于 0 -> 0，0 -> 0，第 0 位置的元素是 0。由于 1 -> 2，2 -> 3，第 1 位置的元素是 3。由于 2 -> 1，1 -> 1，第 2 位置的元素是 1。由于 3 -> 3，3 -> 2，第 3 位置的元素是 2。

如果首先交换第一个和第二个元素，然后交换第二个和第三个元素，结果将会是[0, 2, 3, 1]。如果你想按照传统的从右到左顺序应用循环，可以如下所示反向传递参数调用函数：
>>> Permutation([(1, 2), (2, 3)][::-1]).list()

[0, 2, 3, 1] 

在排列中输入一个单例是指示排列大小的一种方法。也可以使用size关键字。

数组形式输入：

>>> Permutation([[1, 2], [9]])
Permutation([0, 2, 1], size=10)
>>> Permutation([[1, 2]], size=10)
Permutation([0, 2, 1], size=10)

循环形式输入：

>>> Permutation(1, 2, size=10)
Permutation([0, 2, 1], size=10)
>>> Permutation(9)(1, 2)
Permutation([0, 2, 1], size=10)

注意：不能输入包含比先前任何循环中最大元素还大的元素的单例。这是在 Permutation 和 Cycle 处理__call__语法时的一个重要区别。在 Permutation 中，作为排列开始的单例参数执行实例化操作是允许的：

>>> Permutation(5)
Permutation([], size=6)

在实例化后输入单例是对排列的调用 - 一个函数调用 - 如果参数超出范围，将触发错误。因此，最好从单例开始循环：

以下失败，因为不存在元素 3：

>>> Permutation(1, 2)(3)
Traceback (most recent call last):
...
IndexError: list index out of range

这是可以的：只有调用超出范围的单例是被禁止的；否则排列会自动调整大小：

>>> Permutation(3)(1, 2)
Permutation([0, 2, 1, 3])
>>> Permutation(1, 2)(3, 4) == Permutation(3, 4)(1, 2)
True

相等性测试

所有排列形式必须相同才能使排列相等：

>>> Permutation([1, 0, 2, 3]) == Permutation([1, 0])
False

单位置换

单位置换是没有元素放错位置的置换。它可以用多种方式输入。以下所有的方式都会创建一个大小为 4 的单位置换：

>>> I = Permutation([0, 1, 2, 3])
>>> all(p == I for p in [
... Permutation(3),
... Permutation(range(4)),
... Permutation([], size=4),
... Permutation(size=4)])
True

注意在集合的括号内部输入范围：

>>> I == Permutation([range(4)])
False

排列打印

有几点需要注意关于如何打印排列。

自版本 1.6 起不推荐使用：通过设置Permutation.print_cyclic配置排列打印是不推荐的。用户应该使用打印机的perm_cyclic标志，如下所述。

如果你更喜欢一种形式（数组或循环）胜过另一种，你可以通过perm_cyclic标志来设置init_printing。

>>> from sympy import init_printing
>>> p = Permutation(1, 2)(4, 5)(3, 4)
>>> p
Permutation([0, 2, 1, 4, 5, 3])

>>> init_printing(perm_cyclic=True, pretty_print=False)
>>> p
(1 2)(3 4 5)

不管设置如何，都可以获得循环形式中数组元素的列表，并且可以复制其中任何一个并作为参数提供给 Permutation：

>>> p.array_form
[0, 2, 1, 4, 5, 3]
>>> p.cyclic_form
[[1, 2], [3, 4, 5]]
>>> Permutation(_) == p
True

打印是经济的，因为尽可能少地打印，同时保留排列大小的所有信息：

>>> init_printing(perm_cyclic=False, pretty_print=False)
>>> Permutation([1, 0, 2, 3])
Permutation([1, 0, 2, 3])
>>> Permutation([1, 0, 2, 3], size=20)
Permutation([1, 0], size=20)
>>> Permutation([1, 0, 2, 4, 3, 5, 6], size=20)
Permutation([1, 0, 2, 4, 3], size=20)

>>> p = Permutation([1, 0, 2, 3])
>>> init_printing(perm_cyclic=True, pretty_print=False)
>>> p
(3)(0 1)
>>> init_printing(perm_cyclic=False, pretty_print=False)

数字 2 未打印出来，但仍然存在，可以通过 array_form 和 size 方法看到：

>>> p.array_form
[1, 0, 2, 3]
>>> p.size
4

对其他方法的简短介绍

排列可以作为双射函数，告诉给定位置上位于哪个元素

>>> q = Permutation([5, 2, 3, 4, 1, 0])
>>> q.array_form[1] # the hard way
2
>>> q(1) # the easy way
2
>>> {i: q(i) for i in range(q.size)} # showing the bijection
{0: 5, 1: 2, 2: 3, 3: 4, 4: 1, 5: 0}

可以获得完整的循环形式（包括单例）：

>>> p.full_cyclic_form
[[0, 1], [2], [3]]

任何排列都可以分解为元素对的换位：

>>> Permutation([[1, 2], [3, 4, 5]]).transpositions()
[(1, 2), (3, 5), (3, 4)]
>>> Permutation.rmul(*[Permutation([ti], size=6) for ti in _]).cyclic_form
[[1, 2], [3, 4, 5]]

集合 n 元素的排列数由 n!给出，称为基数。

>>> p.size
4
>>> p.cardinality
24

给定的排列在相同元素的所有可能排列中有一个秩，但这个秩取决于排列是如何枚举的。 (有许多不同的方法可以做到这一点。) 字典排序秩由 rank 方法给出，这个秩用于通过加法/减法增加排列：

>>> p.rank()
6
>>> p + 1
Permutation([1, 0, 3, 2])
>>> p.next_lex()
Permutation([1, 0, 3, 2])
>>> _.rank()
7
>>> p.unrank_lex(p.size, rank=7)
Permutation([1, 0, 3, 2])

两个排列 p 和 q 的乘积定义为它们作为函数的组合，(p*q)(i) = q(p(i)) [R84]。

>>> p = Permutation([1, 0, 2, 3])
>>> q = Permutation([2, 3, 1, 0])
>>> list(q*p)
[2, 3, 0, 1]
>>> list(p*q)
[3, 2, 1, 0]
>>> [q(p(i)) for i in range(p.size)]
[3, 2, 1, 0]

排列可以“应用”于任何类似列表的对象，不仅限于排列：

>>> p(['zero', 'one', 'four', 'two'])
['one', 'zero', 'four', 'two']
>>> p('zo42')
['o', 'z', '4', '2']

如果你有一个任意元素的列表，可以使用 from_sequence 方法找到相应的排列：

>>> Permutation.from_sequence('SymPy')
Permutation([1, 3, 2, 0, 4])

检查排列是否包含在群组中

通常，如果你有一个包含 n 个符号的排列群组 G，并且你要检查小于 n 个符号的排列是否属于该群组，则检查将失败。

这里有一个 n=5 的例子，我们检查循环 (1,2,3) 是否在 G 中：

>>> from sympy import init_printing
>>> init_printing(perm_cyclic=True, pretty_print=False)
>>> from sympy.combinatorics import Cycle, Permutation
>>> from sympy.combinatorics.perm_groups import PermutationGroup
>>> G = PermutationGroup(Cycle(2, 3)(4, 5), Cycle(1, 2, 3, 4, 5))
>>> p1 = Permutation(Cycle(2, 5, 3))
>>> p2 = Permutation(Cycle(1, 2, 3))
>>> a1 = Permutation(Cycle(1, 2, 3).list(6))
>>> a2 = Permutation(Cycle(1, 2, 3)(5))
>>> a3 = Permutation(Cycle(1, 2, 3),size=6)
>>> for p in [p1,p2,a1,a2,a3]: p, G.contains(p)
((2 5 3), True)
((1 2 3), False)
((5)(1 2 3), True)
((5)(1 2 3), True)
((5)(1 2 3), True)

对于上面的 p2 检查将失败。

检查 p1 是否在 G 中有效，因为 SymPy 知道 G 是一个包含 5 个符号的群组，而 p1 也是在 5 个符号上（其最大元素是 5）。

对于 a1，.list(6) 调用将排列扩展到 5 个符号，因此测试也将成功。在 a2 的情况下，通过使用单例将排列扩展到 5 个符号，而在 a3 的情况下，通过构造函数参数 size=6 进行扩展。

还有另一种方法，即告诉 contains 方法，群组的符号数不需要完全匹配排列的符号数：

>>> G.contains(p2,strict=False)
True

可以通过strict参数传递给contains方法，SymPy 将尝试自行扩展排列，然后执行包含性检查。

参见

Cycle

参考文献

[R79]

Skiena, S. 在 Implementing Discrete Mathematics Combinatorics and Graph Theory with Mathematica 一书中的 1.1 章节。Reading, MA: Addison-Wesley, pp. 3-16, 1990。

[R80] (1,2)

Knuth, D. E. 在 The Art of Computer Programming, Vol. 4: Combinatorial Algorithms 一书中，第一版。Reading, MA: Addison-Wesley, 2011.

[R81]

Wendy Myrvold 和 Frank Ruskey. 2001. 在 Inf. Process. Lett. 中的 79 卷，6 期 (2001 年 9 月)，281-284. DOI=10.1016/S0020-0190(01)00141-7

[R82]

D. L. Kreher, D. R. Stinson 在 CRC Press 出版的 Combinatorial Algorithms，1999 年

[R83]

Graham, R. L.; Knuth, D. E.; and Patashnik, O. 在 Concrete Mathematics: A Foundation for Computer Science，第二版。Reading, MA: Addison-Wesley, 1994.

[R84] (1,2)

en.wikipedia.org/w/index.php?oldid=499948155#Product_and_inverse

[R85]

en.wikipedia.org/wiki/Lehmer_code

apply(i)

将排列应用于表达式。

参数：

i : Expr

它应该是一个介于(0)和(n-1)之间的整数，其中(n)是排列的大小。

如果它是一个可以取整数值的符号或符号表达式，将返回一个AppliedPermutation对象，该对象可以表示一个未评估的函数。

注意

任何排列可以定义为一个双射函数(\sigma : { 0, 1, \dots, n-1 } \rightarrow { 0, 1, \dots, n-1 })，其中(n)表示排列的大小。

甚至可以将定义扩展到具有不同元素的任何集合，以便排列可以应用于实数或类似的情况，但是出于计算原因和与群论模块的完整性考虑，目前未实施。

此函数类似于__call__魔术方法，但__call__魔术方法已经具有某些其他应用，如排列数组或附加新循环，这并不总是数学上一致的。

这也确保了返回类型是 SymPy 整数，这保证了使用假设的安全性。

property array_form

返回属性 _array_form 的副本示例 ========

>>> from sympy.combinatorics import Permutation
>>> p = Permutation([[2, 0], [3, 1]])
>>> p.array_form
[2, 3, 0, 1]
>>> Permutation([[2, 0, 3, 1]]).array_form
[3, 2, 0, 1]
>>> Permutation([2, 0, 3, 1]).array_form
[2, 0, 3, 1]
>>> Permutation([[1, 2], [4, 5]]).array_form
[0, 2, 1, 3, 5, 4]

ascents()

返回排列中上升的位置，即满足 p[i] < p[i+1]的位置。

示例

>>> from sympy.combinatorics import Permutation
>>> p = Permutation([4, 0, 1, 3, 2])
>>> p.ascents()
[1, 2]

参见

descents, inversions, min, max

atoms()

返回排列的所有元素

示例

>>> from sympy.combinatorics import Permutation
>>> Permutation([0, 1, 2, 3, 4, 5]).atoms()
{0, 1, 2, 3, 4, 5}
>>> Permutation([[0, 1], [2, 3], [4, 5]]).atoms()
{0, 1, 2, 3, 4, 5}

property cardinality

返回所有可能排列的数量。

示例

>>> from sympy.combinatorics import Permutation
>>> p = Permutation([0, 1, 2, 3])
>>> p.cardinality
24

参见

length, order, rank, size

commutator(x)

返回self和x的交换子：~x*~self*x*self

如果 f 和 g 是群 G 的一部分，则 f 和 g 的对易子是群恒等式当且仅当 f 和 g 交换，即 fg == gf。

示例

>>> from sympy.combinatorics import Permutation
>>> from sympy import init_printing
>>> init_printing(perm_cyclic=False, pretty_print=False)
>>> p = Permutation([0, 2, 3, 1])
>>> x = Permutation([2, 0, 3, 1])
>>> c = p.commutator(x); c
Permutation([2, 1, 3, 0])
>>> c == ~x*~p*x*p
True

>>> I = Permutation(3)
>>> p = [I + i for i in range(6)]
>>> for i in range(len(p)):
...     for j in range(len(p)):
...         c = p[i].commutator(p[j])
...         if p[i]*p[j] == p[j]*p[i]:
...             assert c == I
...         else:
...             assert c != I
...

参考

[R86]

zh.wikipedia.org/wiki/对易子

commutes_with(other)

检查元素是否对易。

示例

>>> from sympy.combinatorics import Permutation
>>> a = Permutation([1, 4, 3, 0, 2, 5])
>>> b = Permutation([0, 1, 2, 3, 4, 5])
>>> a.commutes_with(b)
True
>>> b = Permutation([2, 3, 5, 4, 1, 0])
>>> a.commutes_with(b)
False

property cycle_structure

返回排列的循环结构，作为指示每个循环长度的多重性的字典。

示例

>>> from sympy.combinatorics import Permutation
>>> Permutation(3).cycle_structure
{1: 4}
>>> Permutation(0, 4, 3)(1, 2)(5, 6).cycle_structure
{2: 2, 3: 1}

property cycles

返回排列中包含的循环数（包括单例）。

示例

>>> from sympy.combinatorics import Permutation
>>> Permutation([0, 1, 2]).cycles
3
>>> Permutation([0, 1, 2]).full_cyclic_form
[[0], [1], [2]]
>>> Permutation(0, 1)(2, 3).cycles
2

参见

sympy.functions.combinatorial.numbers.stirling

property cyclic_form

用于从规范表示转换为循环表示。单例将被省略。

示例

>>> from sympy.combinatorics import Permutation
>>> p = Permutation([0, 3, 1, 2])
>>> p.cyclic_form
[[1, 3, 2]]
>>> Permutation([1, 0, 2, 4, 3, 5]).cyclic_form
[[0, 1], [3, 4]]

另见

array_form, full_cyclic_form

descents()

返回排列中下降位置，即满足 p[i] > p[i+1]的位置。

示例

>>> from sympy.combinatorics import Permutation
>>> p = Permutation([4, 0, 1, 3, 2])
>>> p.descents()
[0, 3]

另见

ascents, inversions, min, max

classmethod from_inversion_vector(inversion)

从反转向量计算排列。

示例

>>> from sympy.combinatorics import Permutation
>>> from sympy import init_printing
>>> init_printing(perm_cyclic=False, pretty_print=False)
>>> Permutation.from_inversion_vector([3, 2, 1, 0, 0])
Permutation([3, 2, 1, 0, 4, 5])

classmethod from_sequence(i, key=None)

返回使i从排序元素i中获取所需排列。如果需要自定义排序，则可以提供一个键。

示例

>>> from sympy.combinatorics import Permutation

>>> Permutation.from_sequence('SymPy')
(4)(0 1 3)
>>> _(sorted("SymPy"))
['S', 'y', 'm', 'P', 'y']
>>> Permutation.from_sequence('SymPy', key=lambda x: x.lower())
(4)(0 2)(1 3)

property full_cyclic_form

返回包含单例的循环形式排列。

示例

>>> from sympy.combinatorics import Permutation
>>> Permutation([0, 2, 1]).full_cyclic_form
[[0], [1, 2]]

get_adjacency_distance(other)

计算两个排列之间的邻接距离。

解释

此度量衡计算作业对i,j在 p 和 p'中邻接的次数。如果 n_adj 为此数量，则邻接距离为 n - n_adj - 1 [1]

[1] 里夫斯（Reeves, Colin R.）, Landscaes, Operators and Heuristic search, Annals of Operational Research, 86, pp 473-490. (1999)

示例

>>> from sympy.combinatorics import Permutation
>>> p = Permutation([0, 3, 1, 2, 4])
>>> q = Permutation.josephus(4, 5, 2)
>>> p.get_adjacency_distance(q)
3
>>> r = Permutation([0, 2, 1, 4, 3])
>>> p.get_adjacency_distance(r)
4

另见

get_precedence_matrix, get_precedence_distance, get_adjacency_matrix

get_adjacency_matrix()

计算排列的邻接矩阵。

解释

如果作业i在排列p中邻接到作业j，则我们将 m[i, j] = 1，其中 m 是 p 的邻接矩阵。

示例

>>> from sympy.combinatorics import Permutation
>>> p = Permutation.josephus(3, 6, 1)
>>> p.get_adjacency_matrix()
Matrix([
[0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 1, 0],
[0, 0, 0, 0, 0, 1],
[0, 1, 0, 0, 0, 0],
[1, 0, 0, 0, 0, 0],
[0, 0, 0, 1, 0, 0]])
>>> q = Permutation([0, 1, 2, 3])
>>> q.get_adjacency_matrix()
Matrix([
[0, 1, 0, 0],
[0, 0, 1, 0],
[0, 0, 0, 1],
[0, 0, 0, 0]])

另见

get_precedence_matrix, get_precedence_distance, get_adjacency_distance

get_positional_distance(other)

计算两个排列之间的位置距离。

例子

>>> from sympy.combinatorics import Permutation
>>> p = Permutation([0, 3, 1, 2, 4])
>>> q = Permutation.josephus(4, 5, 2)
>>> r = Permutation([3, 1, 4, 0, 2])
>>> p.get_positional_distance(q)
12
>>> p.get_positional_distance(r)
12

另见

get_precedence_distance, get_adjacency_distance

get_precedence_distance(other)

计算两个排列之间的优先度距离。

解释

假设 p 和 p' 代表 n 个作业。优先度度量统计作业 j 在 p 和 p' 中被作业 i 先于的次数。此度量是可交换的。

例子

>>> from sympy.combinatorics import Permutation
>>> p = Permutation([2, 0, 4, 3, 1])
>>> q = Permutation([3, 1, 2, 4, 0])
>>> p.get_precedence_distance(q)
7
>>> q.get_precedence_distance(p)
7

另见

get_precedence_matrix, get_adjacency_matrix, get_adjacency_distance

get_precedence_matrix()

获取优先度矩阵。这用于计算两个排列之间的距离。

例子

>>> from sympy.combinatorics import Permutation
>>> from sympy import init_printing
>>> init_printing(perm_cyclic=False, pretty_print=False)
>>> p = Permutation.josephus(3, 6, 1)
>>> p
Permutation([2, 5, 3, 1, 4, 0])
>>> p.get_precedence_matrix()
Matrix([
[0, 0, 0, 0, 0, 0],
[1, 0, 0, 0, 1, 0],
[1, 1, 0, 1, 1, 1],
[1, 1, 0, 0, 1, 0],
[1, 0, 0, 0, 0, 0],
[1, 1, 0, 1, 1, 0]])

另见

get_precedence_distance, get_adjacency_matrix, get_adjacency_distance

index()

返回排列的索引。

排列的索引是所有下标 j 的和，使得 p[j] 大于 p[j+1]。

例子

>>> from sympy.combinatorics import Permutation
>>> p = Permutation([3, 0, 2, 1, 4])
>>> p.index()
2

inversion_vector()

返回排列的逆序向量。

逆序向量包含元素，其值表示排列中小于它并位于其右侧的元素数。

逆序向量与排列的 Lehmer 编码相同。

例子

>>> from sympy.combinatorics import Permutation
>>> p = Permutation([4, 8, 0, 7, 1, 5, 3, 6, 2])
>>> p.inversion_vector()
[4, 7, 0, 5, 0, 2, 1, 1]
>>> p = Permutation([3, 2, 1, 0])
>>> p.inversion_vector()
[3, 2, 1]

逆序向量随排列的秩递增词典顺序遍历，第 i 个元素循环 0..i。

>>> p = Permutation(2)
>>> while p:
...     print('%s  %s  %s' % (p, p.inversion_vector(), p.rank()))
...     p = p.next_lex()
(2) [0, 0] 0
(1 2) [0, 1] 1
(2)(0 1) [1, 0] 2
(0 1 2) [1, 1] 3
(0 2 1) [2, 0] 4
(0 2) [2, 1] 5

另见

from_inversion_vector

inversions()

计算排列的逆序数。

解释

逆序是指 i > j 但是 p[i] < p[j]。

对于 p 的长度较小，它遍历所有的 i 和 j 值并计算逆序数。对于 p 的长度较大，它使用归并排序的变体来计算逆序数。

例子

>>> from sympy.combinatorics import Permutation
>>> p = Permutation([0, 1, 2, 3, 4, 5])
>>> p.inversions()
0
>>> Permutation([3, 2, 1, 0]).inversions()
6

另见

descents, ascents, min, max

参考

[R87]

www.cp.eng.chula.ac.th/~prabhas//teaching/algo/algo2008/count-inv.htm

property is_Empty

检查置换是否为包含零元素的集合

示例

>>> from sympy.combinatorics import Permutation
>>> Permutation([]).is_Empty
True
>>> Permutation([0]).is_Empty
False

另见

is_Singleton

property is_Identity

如果置换是单位置换，则返回 True。

示例

>>> from sympy.combinatorics import Permutation
>>> p = Permutation([])
>>> p.is_Identity
True
>>> p = Permutation([[0], [1], [2]])
>>> p.is_Identity
True
>>> p = Permutation([0, 1, 2])
>>> p.is_Identity
True
>>> p = Permutation([0, 2, 1])
>>> p.is_Identity
False

另见

order

property is_Singleton

检查置换是否仅包含一个数字，因此是该数字集的唯一可能置换。

示例

>>> from sympy.combinatorics import Permutation
>>> Permutation([0]).is_Singleton
True
>>> Permutation([0, 1]).is_Singleton
False

另见

is_Empty

property is_even

检查置换是否为偶置换。

示例

>>> from sympy.combinatorics import Permutation
>>> p = Permutation([0, 1, 2, 3])
>>> p.is_even
True
>>> p = Permutation([3, 2, 1, 0])
>>> p.is_even
True

另见

is_odd

property is_odd

检查置换是否为奇置换。

示例

>>> from sympy.combinatorics import Permutation
>>> p = Permutation([0, 1, 2, 3])
>>> p.is_odd
False
>>> p = Permutation([3, 2, 0, 1])
>>> p.is_odd
True

另见

is_even

classmethod josephus(m, n, s=1)

使用 Josephus 方案对范围(n)进行置换，并返回置换为每个 m-th 项选取直到所有项都被选择的顺序列出的元素的置换。

参数 s 在剩下 s 个项目并继续选择时停止选择过程，而不是按 m 计数。

考虑从 6 中每 3 个选一个，直到剩下 2 个：

choices    chosen
========   ======
  012345
  01 345   2
  01 34    25
  01  4    253
  0   4    2531
  0        25314
           253140

示例

>>> from sympy.combinatorics import Permutation
>>> Permutation.josephus(3, 6, 2).array_form
[2, 5, 3, 1, 4, 0]

参考

[R88]

en.wikipedia.org/wiki/Flavius_Josephus

[R89]

en.wikipedia.org/wiki/Josephus_problem

[R90]

web.archive.org/web/20171008094331/http://www.wou.edu/~burtonl/josephus.html

length()

返回置换移动的整数数量。

示例

>>> from sympy.combinatorics import Permutation
>>> Permutation([0, 3, 2, 1]).length()
2
>>> Permutation([[0, 1], [2, 3]]).length()
4

另见

min, max, support, cardinality, order, rank, size

list(size=None)

将置换作为显式列表返回，如果 size 小于置换中的最大元素，则可能会截断未移动的元素；如果需要此功能，设置 size=-1 将保证这样的截断。

示例

>>> from sympy.combinatorics import Permutation
>>> p = Permutation(2, 3)(4, 5)
>>> p.list()
[0, 1, 3, 2, 5, 4]
>>> p.list(10)
[0, 1, 3, 2, 5, 4, 6, 7, 8, 9]

传递一个太小的长度将截断置换中未更改的尾部元素：

>>> Permutation(2, 4)(1, 2, 4).list(-1)
[0, 2, 1]
>>> Permutation(3).list(-1)
[]

max() → int

置换移动的最大元素。

示例

>>> from sympy.combinatorics import Permutation
>>> p = Permutation([1, 0, 2, 3, 4])
>>> p.max()
1

另请参阅

min, descents, ascents, inversions

min() → int

置换移动的最小元素。

示例

>>> from sympy.combinatorics import Permutation
>>> p = Permutation([0, 1, 4, 3, 2])
>>> p.min()
2

另请参阅

max, descents, ascents, inversions

mul_inv(other)

other*~self，self 和 other 有 _array_form

next_lex()

返回字典顺序中的下一个置换。如果 self 是字典顺序中的最后一个置换，则返回 None。见 [4] 第 2.4 节。

示例

>>> from sympy.combinatorics import Permutation
>>> p = Permutation([2, 3, 1, 0])
>>> p = Permutation([2, 3, 1, 0]); p.rank()
17
>>> p = p.next_lex(); p.rank()
18

另请参阅

rank, unrank_lex

next_nonlex()

返回非字典顺序中的下一个置换 [3]。如果 self 是该顺序中的最后一个置换，则返回 None。

示例

>>> from sympy.combinatorics import Permutation
>>> from sympy import init_printing
>>> init_printing(perm_cyclic=False, pretty_print=False)
>>> p = Permutation([2, 0, 3, 1]); p.rank_nonlex()
5
>>> p = p.next_nonlex(); p
Permutation([3, 0, 1, 2])
>>> p.rank_nonlex()
6

另请参阅

rank_nonlex, unrank_nonlex

next_trotterjohnson()

返回 Trotter-Johnson 顺序中的下一个排列。如果 self 是最后一个排列，则返回 None。参见[4]第 2.4 节。如果希望生成所有这样的排列，则可以使用generate_bell函数更快地按顺序生成。

示例

>>> from sympy.combinatorics import Permutation
>>> from sympy import init_printing
>>> init_printing(perm_cyclic=False, pretty_print=False)
>>> p = Permutation([3, 0, 2, 1])
>>> p.rank_trotterjohnson()
4
>>> p = p.next_trotterjohnson(); p
Permutation([0, 3, 2, 1])
>>> p.rank_trotterjohnson()
5

参见

rank_trotterjohnson, unrank_trotterjohnson, sympy.utilities.iterables.generate_bell

order()

计算排列的阶。

当排列数被其阶数的幂次时，它等于单位排列。

示例

>>> from sympy.combinatorics import Permutation
>>> from sympy import init_printing
>>> init_printing(perm_cyclic=False, pretty_print=False)
>>> p = Permutation([3, 1, 5, 2, 4, 0])
>>> p.order()
4
>>> (p**(p.order()))
Permutation([], size=6)

参见

identity, cardinality, length, rank, size

parity()

计算排列的奇偶性。

解释

排列的奇偶性反映了排列中逆序对的奇偶性，即满足x > y但p[x] < p[y]的 x 和 y 对的数量。

示例

>>> from sympy.combinatorics import Permutation
>>> p = Permutation([0, 1, 2, 3])
>>> p.parity()
0
>>> p = Permutation([3, 2, 0, 1])
>>> p.parity()
1

参见

_af_parity

classmethod random(n)

生成长度为n的随机排列。

使用基础 Python 伪随机数生成器。

示例

>>> from sympy.combinatorics import Permutation
>>> Permutation.random(2) in (Permutation([1, 0]), Permutation([0, 1]))
True

rank()

返回排列的字典序排名。

示例

>>> from sympy.combinatorics import Permutation
>>> p = Permutation([0, 1, 2, 3])
>>> p.rank()
0
>>> p = Permutation([3, 2, 1, 0])
>>> p.rank()
23

参见

next_lex, unrank_lex, cardinality, length, order, size

rank_nonlex(inv_perm=None)

这是一种线性时间的排名算法，不强制使用字典顺序 [3]。

示例

>>> from sympy.combinatorics import Permutation
>>> p = Permutation([0, 1, 2, 3])
>>> p.rank_nonlex()
23

参见

next_nonlex, unrank_nonlex

rank_trotterjohnson()

返回特罗特-约翰逊排名，该排名来自最小变更算法。请参见 [4] 第 2.4 节。

示例

>>> from sympy.combinatorics import Permutation
>>> p = Permutation([0, 1, 2, 3])
>>> p.rank_trotterjohnson()
0
>>> p = Permutation([0, 2, 1, 3])
>>> p.rank_trotterjohnson()
7

参见

unrank_trotterjohnson, next_trotterjohnson

resize(n)

调整排列大小为新的大小 n。

参数：

n : 整数

排列的新大小。

异常：

数值错误

如果无法将排列调整到给定的大小。这只会在调整为比原始大小更小的大小时发生。

示例

>>> from sympy.combinatorics import Permutation

增加排列的大小：

>>> p = Permutation(0, 1, 2)
>>> p = p.resize(5)
>>> p
(4)(0 1 2)

减小排列的大小：

>>> p = p.resize(4)
>>> p
(3)(0 1 2)

如果调整到特定大小会破坏循环：

>>> p.resize(2)
Traceback (most recent call last):
...
ValueError: The permutation cannot be resized to 2 because the
cycle (0, 1, 2) may break.

static rmul(*args)

返回排列 [a, b, c, …] 的乘积，其第 i 个值为 a(b(c(i)))。

a, b, c, … 可以是 Permutation 对象或元组。

示例

>>> from sympy.combinatorics import Permutation

>>> a, b = [1, 0, 2], [0, 2, 1]
>>> a = Permutation(a); b = Permutation(b)
>>> list(Permutation.rmul(a, b))
[1, 2, 0]
>>> [a(b(i)) for i in range(3)]
[1, 2, 0]

与*操作符相比，以相反的顺序处理操作数：

>>> a = Permutation(a); b = Permutation(b)
>>> list(a*b)
[2, 0, 1]
>>> [b(a(i)) for i in range(3)]
[2, 0, 1]

注释

只要第一个项目是一个排列，序列中的所有项目将由 Permutation 解析为必需的。

>>> Permutation.rmul(a, [0, 2, 1]) == Permutation.rmul(a, b)
True

参数的反向顺序将引发类型错误。

classmethod rmul_with_af(*args)

与 rmul 相同，但 args 的元素是具有 _array_form 的 Permutation 对象。

runs()

返回排列的运行。

排列中的升序序列称为一个运行 [5]。

示例

>>> from sympy.combinatorics import Permutation
>>> p = Permutation([2, 5, 7, 3, 6, 0, 1, 4, 8])
>>> p.runs()
[[2, 5, 7], [3, 6], [0, 1, 4, 8]]
>>> q = Permutation([1,3,2,0])
>>> q.runs()
[[1, 3], [2], [0]]

signature()

给出将排列元素按照规范顺序排列所需的排列特征。

签名计算为(-1)^<逆序数>。

示例

>>> from sympy.combinatorics import Permutation
>>> p = Permutation([0, 1, 2])
>>> p.inversions()
0
>>> p.signature()
1
>>> q = Permutation([0,2,1])
>>> q.inversions()
1
>>> q.signature()
-1

参见

inversions

property size

返回排列中元素的数量。

示例

>>> from sympy.combinatorics import Permutation
>>> Permutation([[3, 2], [0, 1]]).size
4

参见

cardinality, length, order, rank

support()

返回置换 P 中使得 P[i] != i 的元素。

示例

>>> from sympy.combinatorics import Permutation
>>> p = Permutation([[3, 2], [0, 1], [4]])
>>> p.array_form
[1, 0, 3, 2, 4]
>>> p.support()
[0, 1, 2, 3]

transpositions()

返回分解为换位列表的置换。

解释

可以始终将置换表示为换位的乘积，参见 [1]

示例

>>> from sympy.combinatorics import Permutation
>>> p = Permutation([[1, 2, 3], [0, 4, 5, 6, 7]])
>>> t = p.transpositions()
>>> t
[(0, 7), (0, 6), (0, 5), (0, 4), (1, 3), (1, 2)]
>>> print(''.join(str(c) for c in t))
(0, 7)(0, 6)(0, 5)(0, 4)(1, 3)(1, 2)
>>> Permutation.rmul(*[Permutation([ti], size=p.size) for ti in t]) == p
True

参考

[R91]

en.wikipedia.org/wiki/Transposition_%28mathematics%29#Properties

classmethod unrank_lex(size, rank)

字典顺序排列的置换不排序。

示例

>>> from sympy.combinatorics import Permutation
>>> from sympy import init_printing
>>> init_printing(perm_cyclic=False, pretty_print=False)
>>> a = Permutation.unrank_lex(5, 10)
>>> a.rank()
10
>>> a
Permutation([0, 2, 4, 1, 3])

另请参阅

rank, next_lex

classmethod unrank_nonlex(n, r)

这是一个不遵守词典顺序的线性时间不排序算法 [3]。

示例

>>> from sympy.combinatorics import Permutation
>>> from sympy import init_printing
>>> init_printing(perm_cyclic=False, pretty_print=False)
>>> Permutation.unrank_nonlex(4, 5)
Permutation([2, 0, 3, 1])
>>> Permutation.unrank_nonlex(4, -1)
Permutation([0, 1, 2, 3])

另请参阅

next_nonlex, rank_nonlex

classmethod unrank_trotterjohnson(size, rank)

Trotter Johnson 置换不排序。参见 [4] 第 2.4 节。

示例

>>> from sympy.combinatorics import Permutation
>>> from sympy import init_printing
>>> init_printing(perm_cyclic=False, pretty_print=False)
>>> Permutation.unrank_trotterjohnson(5, 10)
Permutation([0, 3, 1, 2, 4])

另请参阅

rank_trotterjohnson, next_trotterjohnson

class sympy.combinatorics.permutations.Cycle(*args)

封装了提供不相交循环功能的 dict。

解释

一个循环显示了用于移动元素子集以获得置换的规则。Cycle 类比 Permutation 更灵活，因为 1) 不需要所有元素都出现以调查多个循环如何按顺序操作，2) 它可以包含单例：

>>> from sympy.combinatorics.permutations import Perm, Cycle

一个 Cycle 将自动解析作为 rhs 上给定元组的周期：

>>> Cycle(1, 2)(2, 3)
(1 3 2)

单位循环，Cycle()，可用于启动产品：

>>> Cycle()(1, 2)(2, 3)
(1 3 2)

通过调用列表方法（或将其传递给列表函数），可以获得 Cycle 的数组形式，并显示所有从 0 开始的元素：

>>> a = Cycle(1, 2)
>>> a.list()
[0, 2, 1]
>>> list(a)
[0, 2, 1]

如果需要更大（或更小）的范围，请使用列表方法并提供所需的大小 - 但是 Cycle 不能被截断为比顺序错位的最大元素更小的大小：

>>> b = Cycle(2, 4)(1, 2)(3, 1, 4)(1, 3)
>>> b.list()
[0, 2, 1, 3, 4]
>>> b.list(b.size + 1)
[0, 2, 1, 3, 4, 5]
>>> b.list(-1)
[0, 2, 1]

除了最大元素始终显示为单个元素外，在打印时不显示单例：

>>> Cycle(1, 4, 10)(4, 5)
(1 5 4 10)
>>> Cycle(1, 2)(4)(5)(10)
(1 2)(10)

可以使用数组形式来实例化一个置换，以便研究置换的其他属性：

>>> Perm(Cycle(1, 2)(3, 4).list()).transpositions()
[(1, 2), (3, 4)]

注意

Cycle 的基本结构是一个字典，尽管 iter 方法已被重新定义为给出循环的数组形式，但底层字典项目仍然可通过 items()等方法使用：

>>> list(Cycle(1, 2).items())
[(1, 2), (2, 1)]

参见

Permutation

list(size=None)

返回循环作为从 0 开始直到循环中最大值和大小中较大者的显式列表。

当大小小于循环中的最大元素时，将截断尾部未移动的项目；如果需要此操作，请设置size=-1来保证这样的修剪。

示例

>>> from sympy.combinatorics import Cycle
>>> p = Cycle(2, 3)(4, 5)
>>> p.list()
[0, 1, 3, 2, 5, 4]
>>> p.list(10)
[0, 1, 3, 2, 5, 4, 6, 7, 8, 9]

如果传递的长度太小，则会修剪置换中未改变的尾部元素：

>>> Cycle(2, 4)(1, 2, 4).list(-1)
[0, 2, 1]

sympy.combinatorics.permutations._af_parity(pi)

计算数组形式置换的奇偶性。

解释

置换的奇偶性反映了置换中倒置对的奇偶性，即 x > y 但 p[x] < p[y]的对数。

示例

>>> from sympy.combinatorics.permutations import _af_parity
>>> _af_parity([0, 1, 2, 3])
0
>>> _af_parity([3, 2, 0, 1])
1

参见

Permutation

生成器

generators.symmetric()

生成阶为 n 的对称群 Sn。

示例

>>> from sympy.combinatorics.generators import symmetric
>>> list(symmetric(3))
[(2), (1 2), (2)(0 1), (0 1 2), (0 2 1), (0 2)]

generators.cyclic()

生成阶为 n 的循环群 Cn。

示例

>>> from sympy.combinatorics.generators import cyclic
>>> list(cyclic(5))
[(4), (0 1 2 3 4), (0 2 4 1 3),
 (0 3 1 4 2), (0 4 3 2 1)]

参见

dihedral

generators.alternating()

生成阶为 n 的交替群 An。

示例

>>> from sympy.combinatorics.generators import alternating
>>> list(alternating(3))
[(2), (0 1 2), (0 2 1)]

generators.dihedral()

生成阶为 2n 的二面角群 Dn。

结果作为 Sn 的一个子群给出，除了特殊情况 n=1（群 S2）和 n=2（Klein 4-群）不可能和在 S2 和 S4 中的嵌入外。

示例

>>> from sympy.combinatorics.generators import dihedral
>>> list(dihedral(3))
[(2), (0 2), (0 1 2), (1 2), (0 2 1), (2)(0 1)]

参见

cyclic

posted @ 2024-06-27 17:24 绝不原创的飞龙阅读(90) 评论(0) 收藏举报

刷新页面返回顶部

龙哥盟

掠夺·扩张·投机·博弈

SymPy-1-13-中文文档-四-

SymPy 1.13 中文文档（四）

精炼

谓词

Common

微积分

矩阵

数论

顺序

集合

微积分

奇点

有限差分权重

组合数学

目录

分区

排列

生成器

公告