处理Python中大二项式的总和

Question

我需要计算这个公式：

这是此积分

的近似值

但这并不重要，实际上我只想用 PYTHON 来计算图1的值，这是主题所关注的内容。

K，alpha和sigma是单个计算中的固定值，通常为：

• 0＆lt; = k＆lt; = 99;
• alpha = 3;
• sigma = 2。

以下是我在python中尝试计算这样求和的方法：

import decimal
from scipy.special import binom

def residual_time_mean(alpha, sigma=2, k=1):
    prev_prec = decimal.getcontext().prec
    D = decimal.Decimal
    decimal.getcontext().prec = 128

    a = float(alpha)
    s = float(sigma)
    sum1 = 0.0
    sum2 = 0.0
    sumD1 = D(0.0)
    sumD2 = D(0.0)

    for i in range(1, k + 1):
        sum1 += binom(k, i) * ((-1) ** (i + 1)) * (s / ((a - 1) * i - 1.0))
        sum2 += binom(k, i) * ((-1) ** (i + 1)) * s / ((a - 1) * i - 1.0)
        sumD1 += D(binom(k, i)) * (D(-1.0) ** (D(i) + D(1.0))) * (D(s) / ((D(a) - D(1.0)) * D(i) - D(1.0)))
        sumD2 += D(binom(k, i)) * (D(-1.0) ** (D(i) + D(1.0))) * D(s) / ((D(a) - D(1.0)) * D(i) - D(1.0))

    decimal.getcontext().prec = prev_prec

    return sum1, sum2, float(sumD1), float(sumD2)

运行

for k in [0, 1, 2, 4, 8, 20, 50, 99]:
    print("k={} -> {}".format(k, residual_time_mean(3, 2, k)))

结果是：

k=0 -> (0.0, 0.0, 0.0, 0.0)
k=1 -> (2.0, 2.0, 2.0, 2.0)
k=2 -> (3.3333333333333335, 3.3333333333333335, 3.3333333333333335, 3.3333333333333335)
k=4 -> (5.314285714285714, 5.314285714285714, 5.314285714285714, 5.314285714285714)
k=8 -> (8.184304584304588, 8.184304584304583, 8.184304584304584, 8.184304584304584)
k=20 -> (13.952692275798238, 13.952692275795965, 13.95269227579524, 13.95269227579524)
k=50 -> (23.134878809207617, 23.13390225415814, 23.134078892910786, 23.134078892910786)
k=99 -> (265412075330.96634, 179529505602.9507, 17667813427.20196, 17667813427.20196)

您可以看到从k=8开始，结果不同。

在除法之前进行乘法会导致sum1和sum2的结果分散很多，例如k = 99。

sum1 += binom(k, i) * ((-1) ** (i + 1)) * (s / ((a - 1) * i - 1.0))
sum2 += binom(k, i) * ((-1) ** (i + 1)) * s / ((a - 1) * i - 1.0)

使用小数时，这个问题不会发生，但结果根本不正确。

计算WolframAlpha

的总和

表示k = 99

（Here is the link for the computation on WolframAlpha）。它给出 33.3159488 （...）而我的python函数是17667813427.20196。我相信WolframAlpha，因为它会产生类似符号计算的东西，实际上它也会以分数的形式返回真正的价值。

为其他k

近似问题（例如，Wolfram计算的值与python中计算的值不同，数量级为10 ^ 0或更大）从k~ = 60开始。

此外，使用scipy.integrate计算积分（图2）会导致类似的近似误差。

问题：

你有什么建议来处理这个计算吗？增加小数精度似乎没有帮助。

Answer 1

我自己发现了这个问题：

执行scipy.special.binom(99,50)给出

5.044567227278209e+28

在WolframAlpha上计算二项式（99,50）时给出

5.0445672272782096667406248628e+28

存在绝对差异，其数量级为10 ^ 12。

这就是为什么，对于k的高值，python函数的结果肯定是不可靠的。所以我需要改变计算二项式的方式。

Answer 2

我不明白为什么你在这里涉及numpy函数，以及为什么要转换为float个对象。实际上，对于这个公式，如果您的输入始终是整数，那么只需坚持int和fractions.Fraction，您的答案将始终完全。实现自己的binom函数很简单：

In [8]: def binom(n, k):
    ...:     return (
    ...:         factorial(n)
    ...:         // (factorial(k)*factorial(n-k))
    ...:     )
    ...:

注意，我使用了整数除法：//。最后，你的总结：

In [9]: from fractions import Fraction
    ...: def F(k, a, s):
    ...:     result = Fraction(0, 1)
    ...:     for i in range(1, k+1):
    ...:         b = binom(k, i)*pow(-1, i+1)
    ...:         x = Fraction(s, (a-1)*i - 1)
    ...:         result += b*x
    ...:     return result
    ...:

结果：

In [10]: F(99, 3, 2)
Out[10]: Fraction(47372953498165579239913571130715220654368322523193013011418, 1421930192463933435386372127473055337225260516259631545875)

基于wolfram-alpha看似正确......

注意，如果说alpha可以是非整数，则可以使用decimal.Decimal进行仲裁精度浮点运算：

In [17]: from decimal import Decimal
     ...: def F(k, a, s):
     ...:     result = Decimal('0')
     ...:     for i in range(1, k+1):
     ...:         b = binom(k, i)*pow(-1, i+1)
     ...:         x = Decimal(s) / Decimal((a-1)*i - 1)
     ...:         result += b*x
     ...:     return result
     ...:

In [18]: F(99, 3, 2)
Out[18]: Decimal('33.72169506311642881389682714')

让我们提高精度：

In [20]: import decimal

In [21]: decimal.getcontext().prec
Out[21]: 28

In [22]: decimal.getcontext().prec = 100

In [23]: F(99, 3, 2)
Out[23]: Decimal('33.31594880623309576443774363783112352607484321721989160481537847749994248174570647797323789728798446')