混凝土#
超几何项#
在递归求解和求和的中心阶段，使用超几何项。在形式上，这些序列被一阶线性递归算子湮没。简单地说，如果给我们一个条件 \(a(n)\) 如果它的连续项比率是有理函数，则它是超几何的 \(n\) .
若要检查序列是否属于此类型，可以使用 is_hypergeometric 方法，该方法在基类中可用。下面是一个涉及多项式的简单例子：
>>> 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。总数：
\[\和{m\leq i<n}f（i）\]有 显而易见的意义 对于 \(m < n\) ，即：
\[\和{m\leq i<n}f（i）=f（m）+f（m+1）+\ldots+f（n-2）+f（n-1）\]具有上限值 \(f(n)\) 排除。空集上的和是零当且仅当 \(m = n\) ：
\[\和{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)
下面是用符号索引进行求和的示例。可以使用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
工具书类
[R98]Michael Karr, "Summation in Finite Terms", Journal of the ACM, Volume 28 Issue 2, April 1981, Pages 305-350 https://dl.acm.org/doi/10.1145/322248.322255
- euler_maclaurin(m=0, n=0, eps=0, eval_integral=True)[源代码]#
返回self的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)[源代码]#
Check whether the function matches with the zeta function.
If it matches, then return a \(Piecewise\) expression because zeta function does not converge unless \(s > 1\) and \(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
工具书类
- is_convergent()[源代码]#
检查和的收敛性。
解释
我们将无穷和与乘积的收敛性研究分为两部分。
第一部分：第一部分是所有术语是否定义良好的问题，即它们在和中是有限的，在乘积中也是非零的。零是乘积中（负）无穷大的类比 \(e^{{-\infty}} = 0\) .
第二部分：第二部分是无穷大后的收敛性问题，假设乘积的个数是有限的，省略了乘积中的零点。这意味着我们只考虑求和或积的尾，从某个点开始，然后所有的项都定义得很好。
例如，在以下形式的总和中：
\[\求和{1\leq i<\infty}\frac{1}{n^2+an+b}\]其中a和b是数字。例程将返回true，即使项序列中存在无穷大（最多两个）。类似的产品是：
\[\生产{1\leq i<\infty}e^{\frac{1}{n^2+an+b}}\]这就是对趋同的解释。它关注的是极限时发生的事情。找到不好的条件是另一个独立的问题。
请注意，用户的责任是定义好的。
There are various tests employed to check the convergence like divergence test, root test, integral test, alternating series test, comparison tests, Dirichlet tests. It returns true if Sum is convergent and false if divergent and NotImplementedError if it cannot be checked.
实例
>>> 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
工具书类
- reverse_order(*indices)[源代码]#
将一个极限的顺序颠倒。
解释
reverse_order(self, *indices)反转表达式中的某些限制self可以是Sum或AProduct. 参数中的选择器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, "Summation in Finite Terms", Journal of the ACM, Volume 28 Issue 2, April 1981, Pages 305-350 https://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. 根据长期存在的数学惯例，最终项包含在产品中。有限积
对于有限乘积（以及假定符号极限为有限的乘积），我们遵循Karr描述的求和约定的类似方法 [1] 尤其是第1.4节的定义3。产品：
\[\prod{m\leq i<n}f（i）\]有 显而易见的意义 对于 \(m < n\) ，即：
\[\生产{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
沃利斯的pi产品：
>>> 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
一个例子表明，乘积的符号结果对看似无意义的极限值仍然有效。然后，Karr公约允许我们根据上述规则交换限制，对这些产品进行完全有效的解释：
>>> 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
适用于产品的Karr求和约定的一个明确示例：
>>> 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
工具书类
[R104]Michael Karr, "Summation in Finite Terms", Journal of the ACM, Volume 28 Issue 2, April 1981, Pages 305-350 https://dl.acm.org/doi/10.1145/322248.322255
[R105]https://en.wikipedia.org/wiki/Multiplication大写字母
- is_convergent()[源代码]#
参见文档
Sum.is_convergent()解释同调收敛的原因。解释
无限乘积：
\[\生产{1\leq i<\infty}f（i）\]由部分乘积的序列定义：
\[\prod{i=1}^{n}f（i）=f（1）f（2）\cdots f（n）\]当氮无限制地增加时。只有当且仅当和仅当以下总和时，乘积收敛到非零值：
\[\和{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
工具书类
- reverse_order(*indices)[源代码]#
颠倒产品中某个极限的顺序。
解释
reverse_order(expr, *indices)反转表达式中的某些限制expr可以是Sum或AProduct. 参数中的选择器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 https://dl.acm.org/doi/10.1145/322248.322255
- class sympy.concrete.expr_with_intlimits.ExprWithIntLimits(function, *symbols, **assumptions)[源代码]#
Superclass for Product and Sum.
参见
sympy.concrete.expr_with_limits.ExprWithLimits,sympy.concrete.products.Product,sympy.concrete.summations.Sum- change_index(var, trafo, newvar=None)[源代码]#
改变一个和或乘积的指数。
执行线性变换 \(x \mapsto a x + b\) 关于索引变量 \(x\) . 为了 \(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。
- 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
- index(x)[源代码]#
返回限制列表中伪变量的索引。
解释
index(expr, x)返回虚拟变量的索引x在expr. 请注意，我们从最内部的极限元组开始计数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(*arg)[源代码]#
在包含和或积的表达式中重新排序限制。
解释
expr.reorder(*arg)重新排列表达式中的限制expr根据arg. 这些元组可以包含数值索引或索引变量名，或者两者都包含。实例
>>> 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(x, y)[源代码]#
交换和或乘积表达式的两个极限元组。
解释
expr.reorder_limit(x, y)交换两个极限元组。争论x和y是与要互换的两个极限的索引变量相对应的整数。表达式expr必须是一笔钱，要么是一个产品。实例
>>> 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))
具体功能参考#
- sympy.concrete.summations.summation(f, *symbols, **kwargs)[源代码]#
计算f相对于符号的和。
解释
符号的表示法与积分中使用的符号类似。求和（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)
- sympy.concrete.products.product(*args, **kwargs)[源代码]#
计算乘积。
解释
符号的符号表示法与求和或积分中使用的符号类似。乘积（f，（i，a，b））计算f相对于i从a到b的乘积，即：。，
b _____ product(f(n), (i, a, b)) = | | f(n) | | i = a
如果无法计算产品，则返回未评估的产品对象。重复乘积可以通过引入额外的符号元组来计算：
.. 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)[源代码]#
计算Gosper的正规形式
f和g.解释
给定相对素的一元多项式
f和g，将它们的商重写为正常形式，定义如下：\[\分形{f（n）}{g（n）}=Z\cdot\frac{A（n）C（n+1）}{B（n）C（n）}\]在哪里？
Z是任意常数，并且A，B，C一元多项式在吗n具有以下属性：\(\gcd(A(n), B(n+h)) = 1 \forall h \in \mathbb{N}\)
\(\gcd(B(n), C(n+1)) = 1\)
\(\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)[源代码]#
计算Gosper的超几何项
f.解释
假设
f是一个超几何术语，因此：\[s\u n=\sum{k=0}^{n-1}f_k\]and \(f_k\) does not depend on \(n\). Returns a hypergeometric term \(g_n\) such that \(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\u n=\sum{k=0}^{n-1}f_k\]and \(f(n)\) does not depend on \(n\), returns \(g_{n} - g(0)\) where \(g_{n+1} - g_n = f_n\), or
Noneif \(s_n\) cannot be expressed in closed form as a sum of hypergeometric terms.实例
>>> 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有限公司，马萨诸塞州韦尔斯利，美国，1997年，第73-100页