Python 积分逼近的自定函数未知误差

我将以下函数定义为使用布尔法则近似积分的方法：

def integrate_boole(f,l,r,N):
    h=((r-l)/N)
    xN = np.linspace(l,r,N+1)
    fN = f(xN)
    return ((2*h)/45)*(7*fN[0]+32*(np.sum(fN[1:-2:2]))+12*(np.sum(fN[2:-3:4]))+14*(np.sum(fN[4:-5]))+7*fN[-1])

我使用该函数获取0和pi（其中N=8）之间的

sin（x）dx

的积分值，并将其分配给变量

sine_int

答案是1.3938101893248442

在手工计算出原始方程式（见）后，我意识到这个答案相当不准确

fN的和给出了不正确的值，但我不知道为什么。例如，

np.sum（fN[4:-5]）

将变为0

是否有更好的方法对所涉及的和进行编码，或者我的参数中是否存在导致计算不准确的错误

提前谢谢

编辑

---

我应该说得更清楚一点，这应该是该规则的一个复合版本，即，在N可被4整除的N个点上近似。因此，不幸的是，典型的5分加4个间隔并不能在这里解决这个问题。我想把我用的方程复制到这里，但我没有它的图像，乳胶也不是一个选项。从我的代码中应该/可能可以清楚地看出，在快速检查返回后，术语乘以f（x_4）应该是32，而不是14：

def integrate_boole(f,l,r,N):
    h=((r-l)/N)
    xN = np.linspace(l,r,N+1)
    fN = f(xN)
    return ((2*h)/45)*(7*fN[0]+32*(np.sum(fN[1:-2:2]))+
                       12*(np.sum(fN[2:-3:4]))+32*(np.sum(fN[4:-5]))+7*fN[-1])

---

首先，正如@nixon所指出的，你的一个系数是错误的。然后，我认为你并不真正理解布尔法则是如何工作的——它只使用函数的5个点来近似函数的积分。因此，像

np.sum（fN[1:-2:2]）

这样的术语毫无意义。您只需要五个点，可以通过

xN=np.linspace（l，r，5）

获得。您的

h

只是两个相邻点之间的距离

h=xN[1]-xN[0]

。然后，简单的豌豆：

import numpy as np 

def integrate_boole(f,l,r):
    xN = np.linspace(l,r,5)
    h = xN[1] - xN[0]
    fN = f(xN)
    return ((2*h)/45)*(7*fN[0]+32*fN[1]+12*fN[2]+32*fN[3]+7*fN[4])

def f(x):
  return np.sin(x)

I = integrate_boole(f, 0, np.pi)
print(I) # Outputs 1.99857...

---

我不知道你希望你的代码符合w.r.t.布尔的规则。为什么要对函数的样本求和（即

np.sum（fN[2:-3:4]）

？我认为你的

N

参数也没有很好的定义，我不确定它应该代表什么。也许你在使用另一条我不熟悉的规则：我让你决定

不管怎样，下面是一个布勒规则的实现，正如维基百科所定义的。变量映射到您链接的Wikipedia版本：

def integ_boole(func, left, right):
    h = (right - left) / 4
    x1 = left
    x2 = left + h
    x3 = left + 2*h
    x4 = left + 3*h
    x5 = right # or left + 4h

    result = (2*h / 45) * (7*func(x1) + 32*func(x2) + 12*func(x3) + 32*func(x4) + 7*func(x5))
    return result

然后，要测试：

import numpy as np
print(integ_boole(np.sin, 0, np.pi))

输出

1.9985707318238357

，与

2

的正确答案非常接近

---

嗯。

那是很多括号<代码>返回14*h/45*fN[0]+32*np.sum（fN[1:-2:2]）+12*np.sum（fN[2:-3:4]）+14*np.sum（fN[4:-5]）+7*fN[-1]感觉更好不？不确定是不是这样，但我认为

32*（np.sum（fN[1:-2:2]）

应该是

32*（np sum（fN[1:-1:2]）/code>（最后一个索引不包括在内，所以我认为你遗漏了几个数字）…当然，我假设
N
是4的倍数。我仍然不明白为什么
np.sum（fN[4:-5]）当N=8时，
变为0。当您尝试将相同的值与其自身求和时，是否总是这样的结果？@rory_c是的，因为在这种情况下，
4
和
-5
表示相同的索引，切片是空的（这与
fn[4:4]
的情况相同），所以总和是0。如果你真的想包含那个元素，你需要再增加一个索引。是的，我想我也错过了那个索引，它应该是
fn[4:-4]
，所以最后一个开始/结束也包括在内。是的，它只适用于[4:-4]，thanksIt是一个复合布尔规则，因此它使用
N+1
点进行积分，其中
N
是4的倍数。不幸的是，这不是我想要的。正如@jdehesa所说，这是典型布尔规则的一个变体。因此，是的，我确实了解它是如何工作的，只是不知道如何在这个特定的上下文中编写代码。我的main问题似乎是括号内的和，因为它们与提供的参数不准确。我不确定原因。哦，对不起，误解了您的意思。这是一个复合布尔法则，它将所有值乘以32、12和14（加上第一个和最后一个值乘以7）。
fN[4:-5]
是每个积分段的起点和终点，它们乘以14，因为每个段的第一个点和最后一个点被7积分（因此7表示一个段的终点，7表示下一个段的起点）.改变系数没有任何区别，因为括号内的和为零。我正在试图找出原因。（就我所知，对于布尔法则的这个版本，14实际上是正确的）