SymPy 1.13 中文文档（二十）

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

abc

原文：docs.sympy.org/latest/modules/abc.html

此模块将所有拉丁字母和希腊字母作为符号导出，因此您可以方便地进行以下操作

>>> from sympy.abc import x, y 

而不是看起来稍微笨拙的

>>> from sympy import symbols
>>> x, y = symbols('x y') 

注意事项

1. 在撰写本文时，名称 O、S、I、N、E 和 Q 与 SymPy 中定义的名称发生冲突。如果您同时从 sympy.abc 和 sympy 导入它们，第二个导入将“获胜”。这仅适用于 * 导入，应仅用于短暂的代码，例如交互会话和不会存活到下一个 SymPy 升级的临时脚本，其中 sympy 可能包含不同的名称。

2. 此模块不会按需定义符号名称，即 from sympy.abc import foo 将报告错误，因为 sympy.abc 中不包含名称 foo。要获取名为 foo 的符号，仍然需要使用 Symbol('foo') 或 symbols('foo')。您可以自由混合使用 sympy.abc 和 Symbol/symbols，尽管仅使用一种方法获取符号往往会使代码更易读。

该模块还定义了一些特殊名称，以帮助检测哪些名称与默认的 SymPy 命名空间冲突。

_clash1 定义所有与 SymPy 对象冲突的单字母变量；_clash2 定义冲突的多字母符号；_clash 是两者的并集。如果希望在 sympification 期间传递 locals 而不是这些名称的非符号对象，则可以使用它们。

示例

>>> from sympy import S
>>> from sympy.abc import _clash1, _clash2, _clash
>>> S("Q & C", locals=_clash1)
C & Q
>>> S('pi(x)', locals=_clash2)
pi(x)
>>> S('pi(C, Q)', locals=_clash)
pi(C, Q) 

代数

原文链接：docs.sympy.org/latest/modules/algebras.html

介绍

SymPy 的 Algebras 模块提供了对四元数的基本代数操作的支持。

四元数参考

此部分列出了由 Algebras 模块实现的类。

class sympy.algebras.Quaternion(a=0, b=0, c=0, d=0, real_field=True, norm=None)

提供基本的四元数操作。四元数对象可以实例化为 Quaternion(a, b, c, d)，如 (q = a + bi + cj + dk)。

参数：

norm：None 或 数字

预定义四元数范数。如果给定一个值，Quaternion.norm 返回这个预定义的值，而不是计算范数。

示例

>>> from sympy import Quaternion
>>> q = Quaternion(1, 2, 3, 4)
>>> q
1 + 2*i + 3*j + 4*k 

复数域上的四元数可以定义为：

>>> from sympy import Quaternion
>>> from sympy import symbols, I
>>> x = symbols('x')
>>> q1 = Quaternion(x, x**3, x, x**2, real_field = False)
>>> q2 = Quaternion(3 + 4*I, 2 + 5*I, 0, 7 + 8*I, real_field = False)
>>> q1
x + x**3*i + x*j + x**2*k
>>> q2
(3 + 4*I) + (2 + 5*I)*i + 0*j + (7 + 8*I)*k 

定义符号单位四元数：

>>> from sympy import Quaternion
>>> from sympy.abc import w, x, y, z
>>> q = Quaternion(w, x, y, z, norm=1)
>>> q
w + x*i + y*j + z*k
>>> q.norm()
1 

参考文献

[R1]

www.euclideanspace.com/maths/algebra/realNormedAlgebra/quaternions/

[R2]

en.wikipedia.org/wiki/Quaternion

add(other)

添加四元数。

参数：

other：四元数

要添加到当前（self）四元数的四元数。

返回：

四元数

将当前（self）添加到其他四元数后的结果四元数

示例

>>> from sympy import Quaternion
>>> from sympy import symbols
>>> q1 = Quaternion(1, 2, 3, 4)
>>> q2 = Quaternion(5, 6, 7, 8)
>>> q1.add(q2)
6 + 8*i + 10*j + 12*k
>>> q1 + 5
6 + 2*i + 3*j + 4*k
>>> x = symbols('x', real = True)
>>> q1.add(x)
(x + 1) + 2*i + 3*j + 4*k 

复数域上的四元数：

>>> from sympy import Quaternion
>>> from sympy import I
>>> q3 = Quaternion(3 + 4*I, 2 + 5*I, 0, 7 + 8*I, real_field = False)
>>> q3.add(2 + 3*I)
(5 + 7*I) + (2 + 5*I)*i + 0*j + (7 + 8*I)*k 

angle()

返回以实轴平面为单位测量的四元数的角度。

解释

给定四元数 (q = a + bi + cj + dk)，其中 (a)，(b)，(c) 和 (d) 是实数，返回由四元数给定的角度

[\theta := 2 \operatorname{atan_2}\left(\sqrt{b² + c² + d²}, {a}\right)]

示例

>>> from sympy.algebras.quaternion import Quaternion
>>> q = Quaternion(1, 4, 4, 4)
>>> q.angle()
2*atan(4*sqrt(3)) 

arc_coplanar(other)

如果输入四元数表示的变换弧发生在同一平面上，则返回 True。

参数：

other：一个四元数

返回：

True：如果两个四元数的平面相同，除了方向/符号。

False：如果两个四元数的平面不相同，除了方向/符号。

None：如果其中任何一个四元数的平面是未知的。

解释

当它们的轴平行时，两个四元数在这个弧的意义上被称为共面。一个四元数的平面是其法向量。

示例

>>> from sympy.algebras.quaternion import Quaternion
>>> q1 = Quaternion(1, 4, 4, 4)
>>> q2 = Quaternion(3, 8, 8, 8)
>>> Quaternion.arc_coplanar(q1, q2)
True 

>>> q1 = Quaternion(2, 8, 13, 12)
>>> Quaternion.arc_coplanar(q1, q2)
False 

参见

vector_coplanar, is_pure

axis()

返回 (\mathbf{Ax}(q))，即四元数 (q) 的轴。

解释

给定四元数 (q = a + bi + cj + dk)，返回 (\mathbf{Ax}(q))，即该四元数的向量部分的单位向量等于 (\mathbf{U}[\mathbf{V}(q)])。轴始终是一个虚数单位，其平方等于 (-1 + 0i + 0j + 0k)。

示例

>>> from sympy.algebras.quaternion import Quaternion
>>> q = Quaternion(1, 1, 1, 1)
>>> q.axis()
0 + sqrt(3)/3*i + sqrt(3)/3*j + sqrt(3)/3*k 

参见

vector_part

exp()

返回 (q) 的指数，由 (e^q) 给出。

返回：

四元数

四元数的指数。

示例

>>> from sympy import Quaternion
>>> q = Quaternion(1, 2, 3, 4)
>>> q.exp()
E*cos(sqrt(29))
+ 2*sqrt(29)*E*sin(sqrt(29))/29*i
+ 3*sqrt(29)*E*sin(sqrt(29))/29*j
+ 4*sqrt(29)*E*sin(sqrt(29))/29*k 

classmethod from_Matrix(elements)

返回从列向量的元素生成的四元数。如果 vector_only 是 True，则仅返回长度为 3 的矩阵的虚部。

参数：

元素：长度为 3 或 4 的矩阵、列表或元组。如果长度为 3，则

假设实部为零。默认值：False

返回：

四元数

由输入元素创建的四元数。

示例

>>> from sympy import Quaternion
>>> from sympy.abc import a, b, c, d
>>> q = Quaternion.from_Matrix([a, b, c, d])
>>> q
a + b*i + c*j + d*k 

>>> q = Quaternion.from_Matrix([b, c, d])
>>> q
0 + b*i + c*j + d*k 

classmethod from_axis_angle(vector, angle)

给定轴和旋转角度后返回旋转四元数。

参数：

向量：包含三个数字的元组

给定轴的向量表示。

角度：数字

轴旋转的角度（以弧度表示）。

返回：

四元数

从给定轴和旋转角度计算的归一化旋转四元数。

示例

>>> from sympy import Quaternion
>>> from sympy import pi, sqrt
>>> q = Quaternion.from_axis_angle((sqrt(3)/3, sqrt(3)/3, sqrt(3)/3), 2*pi/3)
>>> q
1/2 + 1/2*i + 1/2*j + 1/2*k 

classmethod from_euler(angles, seq)

返回由欧拉角表示的旋转的四元数等效物，其序列由seq定义。

参数：

角度：包含 3 个数字的列表、元组或矩阵

欧拉角（以弧度表示）。

seq：长度为 3 的字符串

表示旋转序列。对于外部旋转，seq 必须全部小写，并且其元素必须来自集合{'x', 'y', 'z'}。对于内部旋转，seq 必须全部大写，并且其元素必须来自集合{'X', 'Y', 'Z'}

返回：

四元数

从给定序列中的欧拉角计算的归一化旋转四元数。

示例

>>> from sympy import Quaternion
>>> from sympy import pi
>>> q = Quaternion.from_euler([pi/2, 0, 0], 'xyz')
>>> q
sqrt(2)/2 + sqrt(2)/2*i + 0*j + 0*k 

>>> q = Quaternion.from_euler([0, pi/2, pi] , 'zyz')
>>> q
0 + (-sqrt(2)/2)*i + 0*j + sqrt(2)/2*k 

>>> q = Quaternion.from_euler([0, pi/2, pi] , 'ZYZ')
>>> q
0 + sqrt(2)/2*i + 0*j + sqrt(2)/2*k 

classmethod from_rotation_matrix(M)

返回等效于矩阵的四元数。仅当矩阵是特殊正交矩阵（正交且 det(M) = 1）时，四元数才会被归一化。

参数：

M：矩阵

要转换为等效四元数的输入矩阵。M 必须是特殊正交矩阵（正交且 det(M) = 1），以使四元数被归一化。

返回：

四元数

等效于给定矩阵的四元数。

示例

>>> from sympy import Quaternion
>>> from sympy import Matrix, symbols, cos, sin, trigsimp
>>> x = symbols('x')
>>> M = Matrix([[cos(x), -sin(x), 0], [sin(x), cos(x), 0], [0, 0, 1]])
>>> q = trigsimp(Quaternion.from_rotation_matrix(M))
>>> q
sqrt(2)*sqrt(cos(x) + 1)/2 + 0*i + 0*j + sqrt(2 - 2*cos(x))*sign(sin(x))/2*k 

index_vector()

返回四元数的索引向量。

返回：

四元数：表示提供的四元数的索引向量。

说明

索引向量由(\mathbf{T}(q))给出，四元数(q)的模（或大小）乘以(\mathbf{Ax}(q))，即(q)的轴。

示例

>>> from sympy.algebras.quaternion import Quaternion
>>> q = Quaternion(2, 4, 2, 4)
>>> q.index_vector()
0 + 4*sqrt(10)/3*i + 2*sqrt(10)/3*j + 4*sqrt(10)/3*k 

另请参阅

axis，norm

integrate(*args)

计算四元数的积分。

返回：

四元数

与给定变量一起进行四元数积分。

示例

四元数的不定积分：

>>> from sympy import Quaternion
>>> from sympy.abc import x
>>> q = Quaternion(1, 2, 3, 4)
>>> q.integrate(x)
x + 2*x*i + 3*x*j + 4*x*k 

四元数的定积分：

>>> from sympy import Quaternion
>>> from sympy.abc import x
>>> q = Quaternion(1, 2, 3, 4)
>>> q.integrate((x, 1, 5))
4 + 8*i + 12*j + 16*k 

inverse()

返回四元数的逆。

is_pure()

如果四元数是纯的，则返回 true；如果四元数不是纯的，则返回 false；如果未知，则返回 none。

说明

纯四元数（也称为向量四元数）是具有标量部分等于 0 的四元数。

示例

>>> from sympy.algebras.quaternion import Quaternion
>>> q = Quaternion(0, 8, 13, 12)
>>> q.is_pure()
True 

另请参阅

scalar_part

is_zero_quaternion()

如果四元数是零四元数，则返回 true；如果不是零四元数，则返回 false；如果值未知，则返回 None。

说明

零四元数是标量部分和向量部分均为 0 的四元数。

示例

>>> from sympy.algebras.quaternion import Quaternion
>>> q = Quaternion(1, 0, 0, 0)
>>> q.is_zero_quaternion()
False 

>>> q = Quaternion(0, 0, 0, 0)
>>> q.is_zero_quaternion()
True 

另请参阅

scalar_part, vector_part

log()

返回四元数的对数，即 (\log q)。

示例

>>> from sympy import Quaternion
>>> q = Quaternion(1, 2, 3, 4)
>>> q.log()
log(sqrt(30))
+ 2*sqrt(29)*acos(sqrt(30)/30)/29*i
+ 3*sqrt(29)*acos(sqrt(30)/30)/29*j
+ 4*sqrt(29)*acos(sqrt(30)/30)/29*k 

mensor()

返回四元数模（大小）的自然对数。

示例

>>> from sympy.algebras.quaternion import Quaternion
>>> q = Quaternion(2, 4, 2, 4)
>>> q.mensor()
log(2*sqrt(10))
>>> q.norm()
2*sqrt(10) 

参见

norm

mul(other)

乘积四元数。

参数：

other : 四元数或符号

与当前（self）四元数相乘的四元数。

返回：

四元数

与另一个四元数相乘后的结果四元数。

示例

>>> from sympy import Quaternion
>>> from sympy import symbols
>>> q1 = Quaternion(1, 2, 3, 4)
>>> q2 = Quaternion(5, 6, 7, 8)
>>> q1.mul(q2)
(-60) + 12*i + 30*j + 24*k
>>> q1.mul(2)
2 + 4*i + 6*j + 8*k
>>> x = symbols('x', real = True)
>>> q1.mul(x)
x + 2*x*i + 3*x*j + 4*x*k 

复数域上的四元数：

>>> from sympy import Quaternion
>>> from sympy import I
>>> q3 = Quaternion(3 + 4*I, 2 + 5*I, 0, 7 + 8*I, real_field = False)
>>> q3.mul(2 + 3*I)
(2 + 3*I)*(3 + 4*I) + (2 + 3*I)*(2 + 5*I)*i + 0*j + (2 + 3*I)*(7 + 8*I)*k 

norm()

返回四元数的模。

normalize()

返回四元数的标准形式。

orthogonal(other)

返回两个四元数的正交性。

参数：

other : 一个四元数

返回：

True : 如果两个作为 3D 向量的纯四元数是正交的。

False : 如果两个作为 3D 向量的纯四元数不正交。

None : 如果两个作为 3D 向量的纯四元数是正交的情况未知。

解释

当两个纯四元数的乘积是反交换时称为正交。

示例

>>> from sympy.algebras.quaternion import Quaternion
>>> q = Quaternion(0, 4, 4, 4)
>>> q1 = Quaternion(0, 8, 8, 8)
>>> q.orthogonal(q1)
False 

>>> q1 = Quaternion(0, 2, 2, 0)
>>> q = Quaternion(0, 2, -2, 0)
>>> q.orthogonal(q1)
True 

parallel(other)

如果两个作为 3D 向量的纯四元数是平行的，则返回 True。

参数：

other : 一个四元数

返回：

True : 如果两个作为 3D 向量的纯四元数是平行的。

False : 如果两个作为 3D 向量的纯四元数不平行。

None : 如果两个作为 3D 向量的纯四元数是平行的情况未知。

解释

当两个向量积可交换时，两个纯四元数称为平行。

示例

>>> from sympy.algebras.quaternion import Quaternion
>>> q = Quaternion(0, 4, 4, 4)
>>> q1 = Quaternion(0, 8, 8, 8)
>>> q.parallel(q1)
True 

>>> q1 = Quaternion(0, 8, 13, 12)
>>> q.parallel(q1)
False 

pow(p)

计算四元数的 p 次幂。

参数：

p : 整数

应用于四元数的幂。

返回：

四元数

返回当前四元数的 p 次幂。如果 p = -1，则返回其逆。

示例

>>> from sympy import Quaternion
>>> q = Quaternion(1, 2, 3, 4)
>>> q.pow(4)
668 + (-224)*i + (-336)*j + (-448)*k 

pow_cos_sin(p)

计算以余弦-正弦形式的 p 次幂。

参数：

p : 整数

应用于四元数的幂。

返回：

四元数

以余弦-正弦形式给出的 p 次幂。

示例

>>> from sympy import Quaternion
>>> q = Quaternion(1, 2, 3, 4)
>>> q.pow_cos_sin(4)
900*cos(4*acos(sqrt(30)/30))
+ 1800*sqrt(29)*sin(4*acos(sqrt(30)/30))/29*i
+ 2700*sqrt(29)*sin(4*acos(sqrt(30)/30))/29*j
+ 3600*sqrt(29)*sin(4*acos(sqrt(30)/30))/29*k 

property product_matrix_left

返回与哈密顿乘积等效的 4 x 4 矩阵，从左边计算。当将四元数元素视为列向量时，这可能很有用。给定四元数 (q = a + bi + cj + dk) 其中 a, b, c 和 d 是实数，从左侧的乘积矩阵是：

[\begin{split}M = \begin{bmatrix} a &-b &-c &-d \ b & a &-d & c \ c & d & a &-b \ d &-c & b & a \end{bmatrix}\end{split}]

示例

>>> from sympy import Quaternion
>>> from sympy.abc import a, b, c, d
>>> q1 = Quaternion(1, 0, 0, 1)
>>> q2 = Quaternion(a, b, c, d)
>>> q1.product_matrix_left
Matrix([
[1, 0,  0, -1],
[0, 1, -1,  0],
[0, 1,  1,  0],
[1, 0,  0,  1]]) 

>>> q1.product_matrix_left * q2.to_Matrix()
Matrix([
[a - d],
[b - c],
[b + c],
[a + d]]) 

这等同于：

>>> (q1 * q2).to_Matrix()
Matrix([
[a - d],
[b - c],
[b + c],
[a + d]]) 

property product_matrix_right

返回与哈密顿乘积等效的 4 x 4 矩阵，从右边计算。当将四元数元素视为列向量时，这可能很有用。给定四元数 (q = a + bi + cj + dk) 其中 a, b, c 和 d 是实数，从左侧的乘积矩阵是：

[\begin{split}M = \begin{bmatrix} a &-b &-c &-d \ b & a & d &-c \ c &-d & a & b \ d & c &-b & a \end{bmatrix}\end{split}]

示例

>>> from sympy import Quaternion
>>> from sympy.abc import a, b, c, d
>>> q1 = Quaternion(a, b, c, d)
>>> q2 = Quaternion(1, 0, 0, 1)
>>> q2.product_matrix_right
Matrix([
[1, 0, 0, -1],
[0, 1, 1, 0],
[0, -1, 1, 0],
[1, 0, 0, 1]]) 

注意参数已交换：矩阵表示右侧的四元数，但仍然被视为从左侧进行矩阵乘法。

>>> q2.product_matrix_right * q1.to_Matrix()
Matrix([
[ a - d],
[ b + c],
[-b + c],
[ a + d]]) 

这等价于：

>>> (q1 * q2).to_Matrix()
Matrix([
[ a - d],
[ b + c],
[-b + c],
[ a + d]]) 

static rotate_point(pin, r)

返回旋转后点 pin 的坐标（一个 3 元组）。

参数：

pin : 元组

一个需要旋转的点的 3 元素元组。

r : 四元数或元组

旋转的轴和角度。

需要注意的是，当 r 是一个元组时，它必须是 (轴, 角度) 的形式

返回：

元组

旋转后点的坐标。

示例

>>> from sympy import Quaternion
>>> from sympy import symbols, trigsimp, cos, sin
>>> x = symbols('x')
>>> q = Quaternion(cos(x/2), 0, 0, sin(x/2))
>>> trigsimp(Quaternion.rotate_point((1, 1, 1), q))
(sqrt(2)*cos(x + pi/4), sqrt(2)*sin(x + pi/4), 1)
>>> (axis, angle) = q.to_axis_angle()
>>> trigsimp(Quaternion.rotate_point((1, 1, 1), (axis, angle)))
(sqrt(2)*cos(x + pi/4), sqrt(2)*sin(x + pi/4), 1) 

scalar_part()

返回四元数 q 的标量部分((\mathbf{S}(q)))。

解释

给定四元数 (q = a + bi + cj + dk)，返回 (\mathbf{S}(q) = a)。

示例

>>> from sympy.algebras.quaternion import Quaternion
>>> q = Quaternion(4, 8, 13, 12)
>>> q.scalar_part()
4 

set_norm(norm)

设置已实例化四元数的范数。

参数：

norm : None 或 数字

预定义四元数的范数。如果给定值，则Quaternion.norm返回此预定义值而不是计算范数

示例

>>> from sympy import Quaternion
>>> from sympy.abc import a, b, c, d
>>> q = Quaternion(a, b, c, d)
>>> q.norm()
sqrt(a**2 + b**2 + c**2 + d**2) 

设置范数：

>>> q.set_norm(1)
>>> q.norm()
1 

移除设置的范数：

>>> q.set_norm(None)
>>> q.norm()
sqrt(a**2 + b**2 + c**2 + d**2) 

to_Matrix(vector_only=False)

将四元数的元素作为列向量返回。默认情况下，返回长度为 4 的Matrix，其中实部为第一个元素。如果vector_only为True，则仅返回长度为 3 的虚部作为Matrix。

参数：

vector_only : 布尔值

如果为 True，则仅返回虚部。默认值：False

返回：

矩阵

由四元数的元素构造的列向量。

示例

>>> from sympy import Quaternion
>>> from sympy.abc import a, b, c, d
>>> q = Quaternion(a, b, c, d)
>>> q
a + b*i + c*j + d*k 

>>> q.to_Matrix()
Matrix([
[a],
[b],
[c],
[d]]) 

>>> q.to_Matrix(vector_only=True)
Matrix([
[b],
[c],
[d]]) 

to_axis_angle()

返回四元数的旋转轴和角度。

返回：

元组

(轴, 角度) 元组

示例

>>> from sympy import Quaternion
>>> q = Quaternion(1, 1, 1, 1)
>>> (axis, angle) = q.to_axis_angle()
>>> axis
(sqrt(3)/3, sqrt(3)/3, sqrt(3)/3)
>>> angle
2*pi/3 

to_euler(seq, angle_addition=True, avoid_square_root=False)

返回表示与四元数相同旋转的欧拉角，按给定的seq顺序。这实现了[R3]中描述的方法。

对于退化情况（万向锁情况），第三个角度设置为零。

参数：

seq : 长度为 3 的字符串

表示旋转顺序。对于外部旋转，seq 必须全小写，并且其元素必须来自集合 {'x', 'y', 'z'}。对于内部旋转，seq 必须全大写，并且其元素必须来自集合 {'X', 'Y', 'Z'}

angle_addition : 布尔值

当为 True 时，第一个和第三个角度由两个简单的atan2表达式的加减给出。当为 False 时，第一个和第三个角度分别由一个更复杂的atan2表达式给出。该等价表达式如下：

[\operatorname{atan_2} (b,a) \pm \operatorname{atan_2} (d,c) = \operatorname{atan_2} (bc\pm ad, ac\mp bd)]

默认值：True

avoid_square_root : 布尔值

当为 True 时，第二个角度计算使用基于acos的表达式，稍微复杂一些但避免了平方根。当为 False 时，第二个角度使用atan2计算，这更简单并且在数值上更好（某些acos的数值实现在接近零时存在问题）。默认值：False

返回：

元组

由四元数计算得到的欧拉角

示例

>>> from sympy import Quaternion
>>> from sympy.abc import a, b, c, d
>>> euler = Quaternion(a, b, c, d).to_euler('zyz')
>>> euler
(-atan2(-b, c) + atan2(d, a),
 2*atan2(sqrt(b**2 + c**2), sqrt(a**2 + d**2)),
 atan2(-b, c) + atan2(d, a)) 

参考文献

[R3] (1,2)

doi.org/10.1371/journal.pone.0276302

to_rotation_matrix(v=None, homogeneous=True)

返回等效的旋转变换矩阵，表示围绕原点的四元数旋转，如果未传递 v。

参数：

v：元组或无

默认值：无

homogeneous：布尔值

当为真时，提供一个可能对符号计算更有效但对直接评估不那么有效的表达式。这两个公式在数学上是等效的。默认值：真

返回：

元组

返回等效的旋转变换矩阵，表示围绕原点的四元数旋转，如果未传递 v。

示例

>>> from sympy import Quaternion
>>> from sympy import symbols, trigsimp, cos, sin
>>> x = symbols('x')
>>> q = Quaternion(cos(x/2), 0, 0, sin(x/2))
>>> trigsimp(q.to_rotation_matrix())
Matrix([
[cos(x), -sin(x), 0],
[sin(x),  cos(x), 0],
[     0,       0, 1]]) 

生成一个 4x4 变换矩阵（用于绕非原点旋转）如果点（v）作为参数传递。

classmethod vector_coplanar(q1, q2, q3)

如果将纯四元数的轴视为 3D 向量 q1、q2 和 q3 共面，则返回真。

参数：

q1

一个纯四元数。

q2

一个纯四元数。

q3

一个纯四元数。

返回：

True：如果纯四元数的轴被视为 3D 向量

q1、q2 和 q3 共面。

False：如果将纯四元数的轴视为 3D 向量

q1、q2 和 q3 不共面。

None：如果将纯四元数的轴视为 3D 向量

q1、q2 和 q3 是否共面是未知的。

说明

如果将四元数视为 3D 向量，则三个纯四元数是向量共面的。

示例

>>> from sympy.algebras.quaternion import Quaternion
>>> q1 = Quaternion(0, 4, 4, 4)
>>> q2 = Quaternion(0, 8, 8, 8)
>>> q3 = Quaternion(0, 24, 24, 24)
>>> Quaternion.vector_coplanar(q1, q2, q3)
True 

>>> q1 = Quaternion(0, 8, 16, 8)
>>> q2 = Quaternion(0, 8, 3, 12)
>>> Quaternion.vector_coplanar(q1, q2, q3)
False 

另请参阅

axis, is_pure

vector_part()

返回 (\mathbf{V}(q))，四元数 (q) 的向量部分。

说明

给定四元数 (q = a + bi + cj + dk)，返回 (\mathbf{V}(q) = bi + cj + dk)。

示例

>>> from sympy.algebras.quaternion import Quaternion
>>> q = Quaternion(1, 1, 1, 1)
>>> q.vector_part()
0 + 1*i + 1*j + 1*k 

>>> q = Quaternion(4, 8, 13, 12)
>>> q.vector_part()
0 + 8*i + 13*j + 12*k 

具体

原文：docs.sympy.org/latest/modules/concrete.html

超几何项

在递归求解和求和中，超几何项占据了中心舞台。正式地说，这些是被一阶线性递推算子消灭的序列。简单地说，如果给定项 (a(n))，则如果其连续项比是 (n) 的有理函数，则它是超几何的。

要检查一个序列是否是这种类型，可以使用 is_hypergeometric 方法，该方法在 Basic 类中可用。以下是涉及多项式的简单示例：

>>> from sympy import *
>>> n, k = symbols('n,k')
>>> (n**2 + 1).is_hypergeometric(n)
True 

当然，多项式是超几何的，但还有更复杂的这种类型的序列吗？以下是一些简单的例子：

>>> factorial(n).is_hypergeometric(n)
True
>>> binomial(n, k).is_hypergeometric(n)
True
>>> rf(n, k).is_hypergeometric(n)
True
>>> ff(n, k).is_hypergeometric(n)
True
>>> gamma(n).is_hypergeometric(n)
True
>>> (2**n).is_hypergeometric(n)
True 

我们看到在具体数学的求和和其他部分中使用的所有特殊物种都是超几何的。还要注意，二项式系数以及升序和降序阶乘在它们的参数中都是超几何的：

>>> binomial(n, k).is_hypergeometric(k)
True
>>> rf(n, k).is_hypergeometric(k)
True
>>> ff(n, k).is_hypergeometric(k)
True 

进一步说，所有先前显示的例子都适用于整数线性参数：

>>> factorial(2*n).is_hypergeometric(n)
True
>>> binomial(3*n+1, k).is_hypergeometric(n)
True
>>> rf(n+1, k-1).is_hypergeometric(n)
True
>>> ff(n-1, k+1).is_hypergeometric(n)
True
>>> gamma(5*n).is_hypergeometric(n)
True
>>> (2**(n-7)).is_hypergeometric(n)
True 

然而，非线性参数使得这些序列无法成为超几何序列：

>>> factorial(n**2).is_hypergeometric(n)
False
>>> (2**(n**3 + 1)).is_hypergeometric(n)
False 

如果需要的不仅仅是判断是否为超几何序列的知识，可以使用 hypersimp() 函数。它将尝试简化组合表达式，并且如果给定的项是超几何的，则返回最小度数多项式的商。否则，将返回 (None) 表示序列不是超几何的：

>>> hypersimp(factorial(2*n), n)
2*(n + 1)*(2*n + 1)
>>> hypersimp(factorial(n**2), n) 

具体类参考

class sympy.concrete.summations.Sum(function, *symbols, **assumptions)

表示未计算的求和。

说明

Sum 表示一个有限或无限级数，第一个参数是级数项的一般形式，第二个参数是 (dummy_variable, start, end)，其中 dummy_variable 取从 start 到 end 的所有整数值。根据长期以来的数学约定，包含结束项在内的求和。

有限和

对于有限和（和假定有限的符号限制），我们遵循 Karr [1] 描述的求和惯例，特别是第 1.4 节的定义 3。这个和:

[\sum_{m \leq i < n} f(i)]

对于 (m < n)，具有显而易见的含义，即:

[\sum_{m \leq i < n} f(i) = f(m) + f(m+1) + \ldots + f(n-2) + f(n-1)]

上限值 (f(n)) 排除。如果 (m = n)，则空集的和为零：

[\sum_{m \leq i < n} f(i) = 0 \quad \mathrm{for} \quad m = n]

最后，对于所有其他空集的求和，我们假设以下定义：

[\sum_{m \leq i < n} f(i) = - \sum_{n \leq i < m} f(i) \quad \mathrm{for} \quad m > n]

需要注意的是，Karr 定义了所有上限为排除的求和。这与通常的数学符号形成对比，但不影响求和约定。确实，我们有:

[\sum_{m \leq i < n} f(i) = \sum_{i = m}^{n - 1} f(i)]

符号差异是故意的，以强调其含义，顶部的限制被设置为包含。

例子

>>> from sympy.abc import i, k, m, n, x
>>> from sympy import Sum, factorial, oo, IndexedBase, Function
>>> Sum(k, (k, 1, m))
Sum(k, (k, 1, m))
>>> Sum(k, (k, 1, m)).doit()
m**2/2 + m/2
>>> Sum(k**2, (k, 1, m))
Sum(k**2, (k, 1, m))
>>> Sum(k**2, (k, 1, m)).doit()
m**3/3 + m**2/2 + m/6
>>> Sum(x**k, (k, 0, oo))
Sum(x**k, (k, 0, oo))
>>> Sum(x**k, (k, 0, oo)).doit()
Piecewise((1/(1 - x), Abs(x) < 1), (Sum(x**k, (k, 0, oo)), True))
>>> Sum(x**k/factorial(k), (k, 0, oo)).doit()
exp(x) 

这里有用符号索引进行求和的示例。您可以使用 Function 或 IndexedBase 类：

>>> f = Function('f')
>>> Sum(f(n), (n, 0, 3)).doit()
f(0) + f(1) + f(2) + f(3)
>>> Sum(f(n), (n, 0, oo)).doit()
Sum(f(n), (n, 0, oo))
>>> f = IndexedBase('f')
>>> Sum(f[n]**2, (n, 0, 3)).doit()
f[0]**2 + f[1]**2 + f[2]**2 + f[3]**2 

一个例子显示求和的符号结果对于看似荒谬的极限值仍然有效。然后 Karr 约定允许我们根据上述规则交换极限，从而为这些求和给出完全有效的解释：

>>> S = Sum(i, (i, 1, n)).doit()
>>> S
n**2/2 + n/2
>>> S.subs(n, -4)
6
>>> Sum(i, (i, 1, -4)).doit()
6
>>> Sum(-i, (i, -3, 0)).doit()
6 

Karr 求和约定的显式示例：

>>> S1 = Sum(i**2, (i, m, m+n-1)).doit()
>>> S1
m**2*n + m*n**2 - m*n + n**3/3 - n**2/2 + n/6
>>> S2 = Sum(i**2, (i, m+n, m-1)).doit()
>>> S2
-m**2*n - m*n**2 + m*n - n**3/3 + n**2/2 - n/6
>>> S1 + S2
0
>>> S3 = Sum(i, (i, m, m-1)).doit()
>>> S3
0 

另见

summation, Product, sympy.concrete.products.product

参考文献

[R98]

Michael Karr，“Summation in Finite Terms”，Journal of the ACM，Volume 28 Issue 2，April 1981，Pages 305-350 dl.acm.org/doi/10.1145/322248.322255

[R99]

en.wikipedia.org/wiki/Summation#Capital-sigma_notation

[R100]

en.wikipedia.org/wiki/Empty_sum

euler_maclaurin(m=0, n=0, eps=0, eval_integral=True)

返回自身的 Euler-Maclaurin 近似，其中 m 是直接求和的前导项数，n 是尾部项数。

当 m = n = 0 时，这只是对应积分加上一阶端点修正。

返回 (s, e)，其中 s 是 Euler-Maclaurin 近似，e 是估计的误差（取尾部省略项的大小）：

>>> from sympy.abc import k, a, b
>>> from sympy import Sum
>>> Sum(1/k, (k, 2, 5)).doit().evalf()
1.28333333333333
>>> s, e = Sum(1/k, (k, 2, 5)).euler_maclaurin()
>>> s
-log(2) + 7/20 + log(5)
>>> from sympy import sstr
>>> print(sstr((s.evalf(), e.evalf()), full_prec=True))
(1.26629073187415, 0.0175000000000000) 

端点可以是符号的：

>>> s, e = Sum(1/k, (k, a, b)).euler_maclaurin()
>>> s
-log(a) + log(b) + 1/(2*b) + 1/(2*a)
>>> e
Abs(1/(12*b**2) - 1/(12*a**2)) 

如果函数是至多 2n+1 次的多项式，则 Euler-Maclaurin 公式变得精确（并返回 e = 0）：

>>> Sum(k, (k, 2, b)).euler_maclaurin()
(b**2/2 + b/2 - 1, 0)
>>> Sum(k, (k, 2, b)).doit()
b**2/2 + b/2 - 1 

当指定非零 eps 时，只要剩余项小于 epsilon，就结束求和。

eval_zeta_function(f, limits)

检查函数是否与 zeta 函数匹配。

如果匹配，则返回 (Piecewise) 表达式，因为 zeta 函数只有在 (s > 1) 和 (q > 0) 时收敛。

is_absolutely_convergent()

检查无穷级数的绝对收敛性。

检查无穷级数的绝对收敛性。

例子

>>> from sympy import Sum, Symbol, oo
>>> n = Symbol('n', integer=True)
>>> Sum((-1)**n, (n, 1, oo)).is_absolutely_convergent()
False
>>> Sum((-1)**n/n**2, (n, 1, oo)).is_absolutely_convergent()
True 

另见

Sum.is_convergent

参考文献

[R101]

en.wikipedia.org/wiki/Absolute_convergence

is_convergent()

检查 Sum 的收敛性。

解释

我们将无穷级数和乘积的收敛性研究分为两部分。

第一部分：一个问题是所有项是否良好定义，即它们在求和中是有限的，在乘积中也是非零的。零在乘积中类似于（负）无穷大，即 (e^{-\infty} = 0)。

第二部分：第二部分是在忽略了无穷大和乘积中的零后的收敛性问题，假设它们的数量是有限的。这意味着我们只考虑求和或乘积的尾部，从某个点开始，所有项都是良定义的。

例如，在形如：

[\sum_{1 \leq i < \infty} \frac{1}{n² + an + b}]

其中 a 和 b 是数字的求和中，例程将返回 true，即使在项序列中存在无穷大（至多两个）。类似的乘积会是：

[\prod_{1 \leq i < \infty} e^{\frac{1}{n² + an + b}}]

这是收敛性的解释方式。它关注于极限时发生的情况。寻找不良项是另一个独立的问题。

注意：确保用户自行负责确保求和或乘积的定义良好。

有多种测试用于检查收敛性，如发散测试，根测试，积分测试，交替级数测试，比较测试，狄利克雷测试。如果求和收敛则返回 true，发散则返回 false，如果无法检查则返回 NotImplementedError。

示例

>>> from sympy import factorial, S, Sum, Symbol, oo
>>> n = Symbol('n', integer=True)
>>> Sum(n/(n - 1), (n, 4, 7)).is_convergent()
True
>>> Sum(n/(2*n + 1), (n, 1, oo)).is_convergent()
False
>>> Sum(factorial(n)/5**n, (n, 1, oo)).is_convergent()
False
>>> Sum(1/n**(S(6)/5), (n, 1, oo)).is_convergent()
True 

参见

Sum.is_absolutely_convergent, sympy.concrete.products.Product.is_convergent

参考

[R102]

en.wikipedia.org/wiki/Convergence_tests

reverse_order(*indices)

反转求和中的极限顺序。

解释

reverse_order(self, *indices) 反转表达式self中的一些限制，它可以是Sum或Product。参数indices中的选择器指定了要反转限制的索引。这些选择器可以是变量名或从最内层限制元组开始计数的数值索引。

示例

>>> from sympy import Sum
>>> from sympy.abc import x, y, a, b, c, d 

>>> Sum(x, (x, 0, 3)).reverse_order(x)
Sum(-x, (x, 4, -1))
>>> Sum(x*y, (x, 1, 5), (y, 0, 6)).reverse_order(x, y)
Sum(x*y, (x, 6, 0), (y, 7, -1))
>>> Sum(x, (x, a, b)).reverse_order(x)
Sum(-x, (x, b + 1, a - 1))
>>> Sum(x, (x, a, b)).reverse_order(0)
Sum(-x, (x, b + 1, a - 1)) 

在指定反转哪些限制时应优先使用变量名，但是如果有几个符号具有相同名称，则索引计数符号非常方便。

>>> S = Sum(x**2, (x, a, b), (x, c, d))
>>> S
Sum(x**2, (x, a, b), (x, c, d))
>>> S0 = S.reverse_order(0)
>>> S0
Sum(-x**2, (x, b + 1, a - 1), (x, c, d))
>>> S1 = S0.reverse_order(1)
>>> S1
Sum(x**2, (x, b + 1, a - 1), (x, d + 1, c - 1)) 

当然，我们可以混合两种表示法：

>>> Sum(x*y, (x, a, b), (y, 2, 5)).reverse_order(x, 1)
Sum(x*y, (x, b + 1, a - 1), (y, 6, 1))
>>> Sum(x*y, (x, a, b), (y, 2, 5)).reverse_order(y, x)
Sum(x*y, (x, b + 1, a - 1), (y, 6, 1)) 

参见

sympy.concrete.expr_with_intlimits.ExprWithIntLimits.index, reorder_limit, sympy.concrete.expr_with_intlimits.ExprWithIntLimits.reorder

参考

[R103]

Michael Karr，《有限项求和》，ACM 期刊，第 28 卷第 2 期，1981 年 4 月，305-350 页 dl.acm.org/doi/10.1145/322248.322255

class sympy.concrete.products.Product(function, *symbols, **assumptions)

表示未评估的乘积。

解释

Product 表示一个有限或无限的乘积，第一个参数是序列中项的一般形式，第二个参数是 (dummy_variable, start, end)，其中 dummy_variable 取从 start 到 end 的所有整数值。根据长期以来的数学惯例，最后一项包括在乘积中。

有限乘积

对于有限乘积（以及假设为有限的符号极限乘积），我们遵循卡尔描述的和约定的类似方式 [1]，特别是第 1.4 节的定义 3。乘积：

[\prod_{m \leq i < n} f(i)]

对于 (m < n)，具有 明显的含义，即：

[\prod_{m \leq i < n} f(i) = f(m) f(m+1) \cdot \ldots \cdot f(n-2) f(n-1)]

具有排除上限值 (f(n))。如果且仅如果 (m = n)，则空集的乘积为一：

[\prod_{m \leq i < n} f(i) = 1 \quad \mathrm{for} \quad m = n]

最后，对于所有空集合上的其他乘积，我们假设以下定义：

[\prod_{m \leq i < n} f(i) = \frac{1}{\prod_{n \leq i < m} f(i)} \quad \mathrm{for} \quad m > n]

需要注意的是，在上文中我们定义所有带有排除上限的乘积。这与通常的数学表示形式相反，但不影响乘积约定。确实，我们有：

[\prod_{m \leq i < n} f(i) = \prod_{i = m}^{n - 1} f(i)]

其中符号上的差异是故意的，以强调含义，极限的排版在顶部是包含的。

示例

>>> from sympy.abc import a, b, i, k, m, n, x
>>> from sympy import Product, oo
>>> Product(k, (k, 1, m))
Product(k, (k, 1, m))
>>> Product(k, (k, 1, m)).doit()
factorial(m)
>>> Product(k**2,(k, 1, m))
Product(k**2, (k, 1, m))
>>> Product(k**2,(k, 1, m)).doit()
factorial(m)**2 

瓦利斯的π乘积：

>>> W = Product(2*i/(2*i-1) * 2*i/(2*i+1), (i, 1, oo))
>>> W
Product(4*i**2/((2*i - 1)*(2*i + 1)), (i, 1, oo)) 

当前的直接计算失败：

>>> W.doit()
Product(4*i**2/((2*i - 1)*(2*i + 1)), (i, 1, oo)) 

但是我们可以通过有限乘积的极限逼近无限乘积：

>>> from sympy import limit
>>> W2 = Product(2*i/(2*i-1)*2*i/(2*i+1), (i, 1, n))
>>> W2
Product(4*i**2/((2*i - 1)*(2*i + 1)), (i, 1, n))
>>> W2e = W2.doit()
>>> W2e
4**n*factorial(n)**2/(2**(2*n)*RisingFactorial(1/2, n)*RisingFactorial(3/2, n))
>>> limit(W2e, n, oo)
pi/2 

同样的公式也可以计算 sin(pi/2)：

>>> from sympy import combsimp, pi, gamma, simplify
>>> P = pi * x * Product(1 - x**2/k**2, (k, 1, n))
>>> P = P.subs(x, pi/2)
>>> P
pi**2*Product(1 - pi**2/(4*k**2), (k, 1, n))/2
>>> Pe = P.doit()
>>> Pe
pi**2*RisingFactorial(1 - pi/2, n)*RisingFactorial(1 + pi/2, n)/(2*factorial(n)**2)
>>> limit(Pe, n, oo).gammasimp()
sin(pi**2/2)
>>> Pe.rewrite(gamma)
(-1)**n*pi**2*gamma(pi/2)*gamma(n + 1 + pi/2)/(2*gamma(1 + pi/2)*gamma(-n + pi/2)*gamma(n + 1)**2) 

具有下限大于上限的产品：

>>> Product(1/i, (i, 6, 1)).doit()
120
>>> Product(i, (i, 2, 5)).doit()
120 

空产品：

>>> Product(i, (i, n, n-1)).doit()
1 

显示了一个示例，即使在极限看似荒谬的情况下，产品的符号结果仍然有效。然后，根据上述规则，卡尔约定允许我们对这些产品进行完全有效的解释：

>>> P = Product(2, (i, 10, n)).doit()
>>> P
2**(n - 9)
>>> P.subs(n, 5)
1/16
>>> Product(2, (i, 10, 5)).doit()
1/16
>>> 1/Product(2, (i, 6, 9)).doit()
1/16 

卡尔总和约定应用于乘积的明确示例：

>>> P1 = Product(x, (i, a, b)).doit()
>>> P1
x**(-a + b + 1)
>>> P2 = Product(x, (i, b+1, a-1)).doit()
>>> P2
x**(a - b - 1)
>>> simplify(P1 * P2)
1 

和另一个：

>>> P1 = Product(i, (i, b, a)).doit()
>>> P1
RisingFactorial(b, a - b + 1)
>>> P2 = Product(i, (i, a+1, b-1)).doit()
>>> P2
RisingFactorial(a + 1, -a + b - 1)
>>> P1 * P2
RisingFactorial(b, a - b + 1)*RisingFactorial(a + 1, -a + b - 1)
>>> combsimp(P1 * P2)
1 

另请参见

Sum，summation，product

参考文献

[R104]

迈克尔·卡尔，“有限术语的总和”，ACM 期刊，第 28 卷第 2 期，1981 年 4 月，305-350 页 dl.acm.org/doi/10.1145/322248.322255

[R105]

zh.wikipedia.org/wiki/%E4%B9%98%E6%B3%95

[R106]

zh.wikipedia.org/wiki/%E7%A9%BA%E4%BA%A7%E4%B9%98%E7%A7%AF

is_convergent()

请参阅 Sum.is_convergent() 的文档，了解 SymPy 中收敛的解释。

解释

无限乘积：

[\prod_{1 \leq i < \infty} f(i)]

由部分乘积序列定义：

[\prod_{i=1}^{n} f(i) = f(1) f(2) \cdots f(n)]

当 ( n ) 无限增大时。该乘积在且仅在和式收敛到非零值时收敛：

[\sum_{1 \leq i < \infty} \log{f(n)}]

收敛。

示例

>>> from sympy import Product, Symbol, cos, pi, exp, oo
>>> n = Symbol('n', integer=True)
>>> Product(n/(n + 1), (n, 1, oo)).is_convergent()
False
>>> Product(1/n**2, (n, 1, oo)).is_convergent()
False
>>> Product(cos(pi/n), (n, 1, oo)).is_convergent()
True
>>> Product(exp(-n**2), (n, 1, oo)).is_convergent()
False 

参考文献

[R107]

en.wikipedia.org/wiki/Infinite_product

reverse_order(*indices)

反转产品中限制的顺序。

解释

reverse_order(expr, *indices) 反转表达式 expr 中的一些限制条件，可以是 Sum 或 Product。参数 indices 中的选择器指定要反转限制条件的索引。这些选择器可以是变量名或从内部限制元组开始计数的数值索引。

示例

>>> from sympy import gamma, Product, simplify, Sum
>>> from sympy.abc import x, y, a, b, c, d
>>> P = Product(x, (x, a, b))
>>> Pr = P.reverse_order(x)
>>> Pr
Product(1/x, (x, b + 1, a - 1))
>>> Pr = Pr.doit()
>>> Pr
1/RisingFactorial(b + 1, a - b - 1)
>>> simplify(Pr.rewrite(gamma))
Piecewise((gamma(b + 1)/gamma(a), b > -1), ((-1)**(-a + b + 1)*gamma(1 - a)/gamma(-b), True))
>>> P = P.doit()
>>> P
RisingFactorial(a, -a + b + 1)
>>> simplify(P.rewrite(gamma))
Piecewise((gamma(b + 1)/gamma(a), a > 0), ((-1)**(-a + b + 1)*gamma(1 - a)/gamma(-b), True)) 

当指定要反转的限制条件时，应优先使用变量名，但索引计数符号在多个同名符号的情况下非常有用。

>>> S = Sum(x*y, (x, a, b), (y, c, d))
>>> S
Sum(x*y, (x, a, b), (y, c, d))
>>> S0 = S.reverse_order(0)
>>> S0
Sum(-x*y, (x, b + 1, a - 1), (y, c, d))
>>> S1 = S0.reverse_order(1)
>>> S1
Sum(x*y, (x, b + 1, a - 1), (y, d + 1, c - 1)) 

当然，我们可以混合使用这两种符号：

>>> Sum(x*y, (x, a, b), (y, 2, 5)).reverse_order(x, 1)
Sum(x*y, (x, b + 1, a - 1), (y, 6, 1))
>>> Sum(x*y, (x, a, b), (y, 2, 5)).reverse_order(y, x)
Sum(x*y, (x, b + 1, a - 1), (y, 6, 1)) 

另见

sympy.concrete.expr_with_intlimits.ExprWithIntLimits.index, reorder_limit, sympy.concrete.expr_with_intlimits.ExprWithIntLimits.reorder

参考文献

[R108]

Michael Karr，“Summation in Finite Terms”，Journal of the ACM，Volume 28 Issue 2，April 1981，Pages 305-350 dl.acm.org/doi/10.1145/322248.322255

class sympy.concrete.expr_with_intlimits.ExprWithIntLimits(function, *symbols, **assumptions)

产品和和的超类。

另见

sympy.concrete.expr_with_limits.ExprWithLimits, sympy.concrete.products.Product, sympy.concrete.summations.Sum

change_index(var, trafo, newvar=None)

更改和积的索引。

对索引变量 ( x ) 执行线性变换 ( x \mapsto a x + b )。允许的 ( a ) 值仅限于 ( \pm 1 )。在索引变更后也可以指定一个新变量。

解释

change_index(expr, var, trafo, newvar=None) 其中 var 指定要变换的索引变量 ( x )。变换 trafo 必须是线性的，并且以 var 的形式给出。如果提供了可选参数 newvar，则最终表达式中的 var 将被替换为 newvar。

示例

>>> from sympy import Sum, Product, simplify
>>> from sympy.abc import x, y, a, b, c, d, u, v, i, j, k, l 

>>> S = Sum(x, (x, a, b))
>>> S.doit()
-a**2/2 + a/2 + b**2/2 + b/2 

>>> Sn = S.change_index(x, x + 1, y)
>>> Sn
Sum(y - 1, (y, a + 1, b + 1))
>>> Sn.doit()
-a**2/2 + a/2 + b**2/2 + b/2 

>>> Sn = S.change_index(x, -x, y)
>>> Sn
Sum(-y, (y, -b, -a))
>>> Sn.doit()
-a**2/2 + a/2 + b**2/2 + b/2 

>>> Sn = S.change_index(x, x+u)
>>> Sn
Sum(-u + x, (x, a + u, b + u))
>>> Sn.doit()
-a**2/2 - a*u + a/2 + b**2/2 + b*u + b/2 - u*(-a + b + 1) + u
>>> simplify(Sn.doit())
-a**2/2 + a/2 + b**2/2 + b/2 

>>> Sn = S.change_index(x, -x - u, y)
>>> Sn
Sum(-u - y, (y, -b - u, -a - u))
>>> Sn.doit()
-a**2/2 - a*u + a/2 + b**2/2 + b*u + b/2 - u*(-a + b + 1) + u
>>> simplify(Sn.doit())
-a**2/2 + a/2 + b**2/2 + b/2 

>>> P = Product(i*j**2, (i, a, b), (j, c, d))
>>> P
Product(i*j**2, (i, a, b), (j, c, d))
>>> P2 = P.change_index(i, i+3, k)
>>> P2
Product(j**2*(k - 3), (k, a + 3, b + 3), (j, c, d))
>>> P3 = P2.change_index(j, -j, l)
>>> P3
Product(l**2*(k - 3), (k, a + 3, b + 3), (l, -d, -c)) 

当仅处理符号时，我们可以进行一般的线性转换：

>>> Sn = S.change_index(x, u*x+v, y)
>>> Sn
Sum((-v + y)/u, (y, b*u + v, a*u + v))
>>> Sn.doit()
-v*(a*u - b*u + 1)/u + (a**2*u**2/2 + a*u*v + a*u/2 - b**2*u**2/2 - b*u*v + b*u/2 + v)/u
>>> simplify(Sn.doit())
a**2*u/2 + a/2 - b**2*u/2 + b/2 

然而，最后的结果可能与通常的求和不一致，其中索引增量始终为 1。这很明显，因为我们仅在 u 等于 +1 或 -1 时才返回原始值。

见也

sympy.concrete.expr_with_intlimits.ExprWithIntLimits.index, reorder_limit, sympy.concrete.expr_with_intlimits.ExprWithIntLimits.reorder, sympy.concrete.summations.Sum.reverse_order, sympy.concrete.products.Product.reverse_order

property has_empty_sequence

如果对空序列计算求和或乘积，则返回 True。

示例

>>> from sympy import Sum, Product, Symbol
>>> m = Symbol('m')
>>> Sum(m, (m, 1, 0)).has_empty_sequence
True 

>>> Sum(m, (m, 1, 1)).has_empty_sequence
False 

>>> M = Symbol('M', integer=True, positive=True)
>>> Product(m, (m, 1, M)).has_empty_sequence
False 

>>> Product(m, (m, 2, M)).has_empty_sequence 

>>> Product(m, (m, M + 1, M)).has_empty_sequence
True 

>>> N = Symbol('N', integer=True, positive=True)
>>> Sum(m, (m, N, M)).has_empty_sequence 

>>> N = Symbol('N', integer=True, negative=True)
>>> Sum(m, (m, N, M)).has_empty_sequence
False 

见也

has_reversed_limits, has_finite_limits

index(x)

返回在极限列表中的虚拟变量的索引。

解释

index(expr, x) 返回表达式 expr 中变量 x 在极限中的索引。注意，我们从最内层的极限元组开始以 0 开始计数。

示例

>>> from sympy.abc import x, y, a, b, c, d
>>> from sympy import Sum, Product
>>> Sum(x*y, (x, a, b), (y, c, d)).index(x)
0
>>> Sum(x*y, (x, a, b), (y, c, d)).index(y)
1
>>> Product(x*y, (x, a, b), (y, c, d)).index(x)
0
>>> Product(x*y, (x, a, b), (y, c, d)).index(y)
1 

见也

reorder_limit, reorder, sympy.concrete.summations.Sum.reverse_order, sympy.concrete.products.Product.reverse_order

reorder(*arg)

在包含求和或乘积的表达式中重新排序极限。

解释

expr.reorder(*arg) 根据给定的元组列表 arg 重新排序表达式 expr 中的极限。这些元组可以包含数值索引、索引变量名称或二者的组合。

示例

>>> from sympy import Sum, Product
>>> from sympy.abc import x, y, z, a, b, c, d, e, f 

>>> Sum(x*y, (x, a, b), (y, c, d)).reorder((x, y))
Sum(x*y, (y, c, d), (x, a, b)) 

>>> Sum(x*y*z, (x, a, b), (y, c, d), (z, e, f)).reorder((x, y), (x, z), (y, z))
Sum(x*y*z, (z, e, f), (y, c, d), (x, a, b)) 

>>> P = Product(x*y*z, (x, a, b), (y, c, d), (z, e, f))
>>> P.reorder((x, y), (x, z), (y, z))
Product(x*y*z, (z, e, f), (y, c, d), (x, a, b)) 

我们还可以通过计数选择索引变量，从最内层开始：

>>> Sum(x**2, (x, a, b), (x, c, d)).reorder((0, 1))
Sum(x**2, (x, c, d), (x, a, b)) 

当然，我们也可以混合使用这两种方案：

>>> Sum(x*y, (x, a, b), (y, c, d)).reorder((y, x))
Sum(x*y, (y, c, d), (x, a, b))
>>> Sum(x*y, (x, a, b), (y, c, d)).reorder((y, 0))
Sum(x*y, (y, c, d), (x, a, b)) 

见也

reorder_limit, index, sympy.concrete.summations.Sum.reverse_order, sympy.concrete.products.Product.reverse_order

reorder_limit(x, y)

交换 Sum 或 Product 表达式的两个限制元组。

说明

expr.reorder_limit(x, y) 交换两个限制元组。参数 x 和 y 是对应于要交换的两个限制的索引变量的整数。表达式 expr 必须是 Sum 或 Product。

示例

>>> from sympy.abc import x, y, z, a, b, c, d, e, f
>>> from sympy import Sum, Product 

>>> Sum(x*y*z, (x, a, b), (y, c, d), (z, e, f)).reorder_limit(0, 2)
Sum(x*y*z, (z, e, f), (y, c, d), (x, a, b))
>>> Sum(x**2, (x, a, b), (x, c, d)).reorder_limit(1, 0)
Sum(x**2, (x, c, d), (x, a, b)) 

>>> Product(x*y*z, (x, a, b), (y, c, d), (z, e, f)).reorder_limit(0, 2)
Product(x*y*z, (z, e, f), (y, c, d), (x, a, b)) 

另请参阅

index, reorder, sympy.concrete.summations.Sum.reverse_order, sympy.concrete.products.Product.reverse_order

具体函数参考

sympy.concrete.summations.summation(f, *symbols, **kwargs)

计算符号与符号的和。

说明

符号的表示法类似于积分中使用的符号。summation(f, (i, a, b)) 计算 f 对于 i 从 a 到 b 的求和，即，

 b
                          ____
                          \   `
summation(f, (i, a, b)) =  )    f
                          /___,
                          i = a 

如果无法计算和，则返回一个未计算的 Sum 对象。通过引入额外的符号元组可以计算重复的和：

.. rubric:: Examples 

>>> from sympy import summation, oo, symbols, log
>>> i, n, m = symbols('i n m', integer=True) 

>>> summation(2*i - 1, (i, 1, n))
n**2
>>> summation(1/2**i, (i, 0, oo))
2
>>> summation(1/log(n)**n, (n, 2, oo))
Sum(log(n)**(-n), (n, 2, oo))
>>> summation(i, (i, 0, n), (n, 0, m))
m**3/6 + m**2/2 + m/3 

>>> from sympy.abc import x
>>> from sympy import factorial
>>> summation(x**n/factorial(n), (n, 0, oo))
exp(x) 

另请参阅

Sum, Product, sympy.concrete.products.product

sympy.concrete.products.product(*args, **kwargs)

计算乘积。

说明

符号的表示法类似于求和或积分中使用的符号。product(f, (i, a, b)) 计算 f 对于 i 从 a 到 b 的乘积，即，

 b
                           _____
product(f(n), (i, a, b)) = |   | f(n)
                           |   |
                           i = a 

如果无法计算乘积，则返回一个未计算的 Product 对象。通过引入额外的符号元组可以计算重复的乘积：

.. rubric:: Examples 

>>> from sympy import product, symbols
>>> i, n, m, k = symbols('i n m k', integer=True) 

>>> product(i, (i, 1, k))
factorial(k)
>>> product(m, (i, 1, k))
m**k
>>> product(i, (i, 1, k), (k, 1, n))
Product(factorial(k), (k, 1, n)) 

sympy.concrete.gosper.gosper_normal(f, g, n, polys=True)

计算 f 和 g 的 Gosper 正常形式。

说明

给定相对质的一元多项式 f 和 g，将它们的商重写为以下定义的正常形式：

[\frac{f(n)}{g(n)} = Z \cdot \frac{A(n) C(n+1)}{B(n) C(n)}]

其中 Z 是任意常数，A, B, C 是关于 n 的首一多项式，并具有以下性质：

1. (\gcd(A(n), B(n+h)) = 1 \forall h \in \mathbb{N})

2. (\gcd(B(n), C(n+1)) = 1)

3. (\gcd(A(n), C(n)) = 1)

此正常形式，或者说是有理分解，是 Gosper 算法和求解差分方程的关键步骤。它还可以用来判断两个超几何项是否相似。

此过程将返回一个包含分解元素的元组，形式为(Z*A, B, C)。

示例

>>> from sympy.concrete.gosper import gosper_normal
>>> from sympy.abc import n 

>>> gosper_normal(4*n+5, 2*(4*n+1)*(2*n+3), n, polys=False)
(1/4, n + 3/2, n + 1/4) 

sympy.concrete.gosper.gosper_term(f, n)

计算 f 的 Gosper 超几何项。

解释

假设 f 是一个超几何项，使得：

[s_n = \sum_{k=0}^{n-1} f_k]

并且 (f_k) 不依赖于 (n)。返回一个超几何项 (g_n)，使得 (g_{n+1} - g_n = f_n)。

示例

>>> from sympy.concrete.gosper import gosper_term
>>> from sympy import factorial
>>> from sympy.abc import n 

>>> gosper_term((4*n + 1)*factorial(n)/factorial(2*n + 1), n)
(-n - 1/2)/(n + 1/4) 

sympy.concrete.gosper.gosper_sum(f, k)

Gosper 的超几何求和算法。

解释

给定一个超几何项 f，使得：

[s_n = \sum_{k=0}^{n-1} f_k]

并且 (f(n)) 不依赖于 (n)，返回 (g_{n} - g(0))，其中 (g_{n+1} - g_n = f_n)，或者如果 (s_n) 无法作为超几何项和的封闭形式表示，则返回 None。

示例

>>> from sympy.concrete.gosper import gosper_sum
>>> from sympy import factorial
>>> from sympy.abc import n, k 

>>> f = (4*k + 1)*factorial(k)/factorial(2*k + 1)
>>> gosper_sum(f, (k, 0, n))
(-factorial(n) + 2*factorial(2*n + 1))/factorial(2*n + 1)
>>> _.subs(n, 2) == sum(f.subs(k, i) for i in [0, 1, 2])
True
>>> gosper_sum(f, (k, 3, n))
(-60*factorial(n) + factorial(2*n + 1))/(60*factorial(2*n + 1))
>>> _.subs(n, 5) == sum(f.subs(k, i) for i in [3, 4, 5])
True 

参考资料

[R109]

Marko Petkovsek, Herbert S. Wilf, Doron Zeilberger, A = B, AK Peters, Ltd., Wellesley, MA, USA, 1997, pp. 73–100