牛顿'的正确递归python实现；s差分插值方法，获取递归内部的一些返回值

我用python编写了一个递归函数来计算

图中以图形方式解释了这一点：

f[x]=f（x）

和

f[x0，x1]=f[x1]-f[x0]）/（x1-x0）

当

f[x0，x1，…xn]=f[all_leastFirst，allbutLast]/xlast xfirst

时也是如此

这就是它，递归地

我得到了以下代码：

xxs=[]
yys=[]
coeficientes = []
h = {}
r = 0.0

def a_j(xx,yy):
    global r
    if len(yy) == 1:
        h[xx[0]] = yy[0]
        return yy[0]
    else:
        r = (a_j(xx[1:],yy[1:])  - a_j(xx[:-1],yy[:-1])) / (xx-1]-xx[0])
        h[''.join(str(i) for i in xx[::-1])]=r
        coeficientes.append(r)
        return ( r )

但是需要获得一个数组作为输出，该数组只包含绿色圆圈中标记的数字。我不知道如何在递归实现中只获取这些。 关于它们的一个常见模式是它们总是从

x0

开始，所以我选择标记它们或使用字典可能会有所帮助

预期结果将是：

[1,1.71828,1.47625,.84553]

我正在获得：

[1, 2.71828, 7.3890599999999997, 20.085540000000002, 1.71828, 4.6707799999999997, 12.696480000000001, 1.4762499999999998, 4.0128500000000003, 0.84553333333333347]

[4, 3.5, 4, 5.6, -0.5, 0.5, 0.5, 0.7999999999999998, 0.09999999999999994, -0.10000000000000002]

对于另一次运行使用不同的参数，如果调用：

a_j([1,2,3,5][4,3.5,4,5.6])

应输出：

[4,-0.5,0.5,-0.1]

我正在获得：

[1, 2.71828, 7.3890599999999997, 20.085540000000002, 1.71828, 4.6707799999999997, 12.696480000000001, 1.4762499999999998, 4.0128500000000003, 0.84553333333333347]

[4, 3.5, 4, 5.6, -0.5, 0.5, 0.5, 0.7999999999999998, 0.09999999999999994, -0.10000000000000002]

另一个例子：

a_j([-2,-1,0,1,2], [13,24,39,65,106])

将输出：

[13, 24, 39, 65, 106, 11, 15, 2, 26, 5, 1, 41, 7, 0, -1]

但结果应该是：

[13,11,2,1.167,-0.125]

我还成功地编写了这个迭代实现，它已经是正确的了：

diferencias = {}
coeficientes = []

def sublists_n(l, n):
    subs = []
    for i in range(len(l)-n+1):
        subs.extend([l[i:i+n]])
    return subs

def sublists(l):
    subs = []
    for i in range(len(l)-1,0,-1):
        subs.extend(sublists_n(l,i))
    subs.insert(0,l)
    return subs[::-1]


def diferenciasDivididas(xx,yy,x):

    combinaciones = sublists([i for i in range(len(xx))])

    for c in combinaciones:

        if len(c) == 1:
            diferencias[str(c[0])]= float(yy[c[0]])
            if c[0] == 0:
                coeficientes.append(float(yy[c[0]]))

        else:
            c1 = diferencias.get(''.join(str(i) for i in c[1:]))
            c2 = diferencias.get(''.join(str(i) for i in c[:-1]))

            d = float(( c1 - c2 ) / ( xx[c[len(c)-1]] - xx[c[0]] ))

            diferencias[''.join(str(i) for i in c)] = d

            if c[0] == 0:
                coeficientes.append(float(d))

---

我只是想知道我遗漏了什么？

因为你在做递归，你会在每个值退出函数时追加它，你会以相反的方式完成追加，x3，x2，x1

---

一旦您完成了整个递归并最后一次退出，只需反转列表即可，这对于几种方法来说都相对简单，而且以前也有人问过。我将您想要使用的方法留给您（或者记住“Google是您的朋友”）

您在这里得到的是负值，因为您没有将减法括在括号中。否则代码看起来不错

   r = ( a_j(xx1,yy1)  - a_j(xx0,yy0)  ) / (xx[len(xx)-1]-xx[0])

试试这个：

    array=[]
    h={}
    r=0

    def a_j(xx,yy):
        global r
        if len(yy) == 1:
            h[int(xx[0])]=yy[0]
            return yy[0]

        else:
            r=( a_j(xx[1:],yy[1:])  - a_j(xx[:-1],yy[:-1])) / (xx[-1]-xx[0])
            h[int(''.join(str(i) for i in xx[::-1]))]=r
            return r

    a_j([0,1,2,3], [1,2.71828,7.38906,20.08554])
    array=[h[key] for key in  sorted(h.keys())]
    print array

输出： [1,2.71828,7.38905999999997,20.085540000000002,1.71828,4.67077999999997,12.6964800000001,1.47624999999998,4.0128500000003,0.84553333347]

---

在这段代码中，值首先被分配给一个dict，其中键作为xx的元素被反转并转换成整数。

我对脚本做了一些修改

    array=[]
    r='s'
    s=0
    def a_j(xx,yy):
        global r,s
        if r == 's':
            s=xx[0]
            r=0.0
        if len(yy) == 1:
            if xx[0]==s: array.append(yy[0])
            return float(yy[0])

        else:
            r=( a_j(xx[1:],yy[1:])  - a_j(xx[:-1],yy[:-1])) / (xx[-1]-xx[0])
            if xx[0]==s: array.append(r)
            return float(r)

    a_j([1,2,3,5],[4,3.5,4,5.6])
    print array

输出： [4，-0.5,0.5，-0.100000000000002]

另外，你给出的第二个例子看起来并不正确。 a_j（[-2，-1,0,1,2]，[13,24,39,65106]）-->[13,11,4,7，-3]

上面的答案是第三个元素是4

    3rd element means --> x(-2,-1,0) -> x(-1,0)  -  x(-2,-1)/(2)
                                     -> x(0)-x(-1)/1  -  x(-1)-x(-2)/(1) /(2)
                                     ->(39-24) - (24-13)   /(2)
                                     ->15-11/(2)
                                     ->4/2 =2

---

如果我错了，请纠正我

预期的结果是什么？您能否解释一下

f[x0，x1]=1.71828

？根据你的公式，它的值应该小得多。@thefourtheye因为那是

f（x1）-f（x0）/（x1-x0）

那是

2.71828-1/（1-0）

我设法把第二列弄对了，而我现在不明白第三列：（我得到了

[1.71828,4.67078,12.6964800000001]

，但我得到的下一列是

[2.9524999999999997, 8.0257]

这有一点帮助，但这并不完全是我的错误。非常感谢，你的回答真的帮助了我。我刚刚意识到我实际上只需要计算一些值，我编辑了我的问题，我的道歉。是的，第三个示例是错误的，我的道歉。我只会添加到cast以浮动返回值以获得正确的结果。我实际上，我不知道为什么它们不能像它那样工作，因为它们首先碰巧是整数？你非常渴望这样的需求，谢谢！还有，为什么确切地说应该

r

和

s

global

？你能看看我的编辑并对我的迭代实现给出意见吗？最后，我在递归实现中遗漏了什么？（我认为那个错误的例子愚弄了我，把我弄糊涂了）谢谢你的编辑。你是对的。r和s是全局的，因为我们需要在第一次迭代中检查这些变量的值。找不到更好的解决方案。你的代码看起来不错。我认为这个例子让你困惑了。我把它设为全局的，因为我们只需要函数中的初始值一次。如果它是局部变量able，它将在每次调用函数时为变量赋值。这将始终满足第一个条件语句。我们需要获取传递给函数的原始元素的第一个元素。这只能在函数的第一次迭代期间完成。