相互依赖阵列的numpy矢量化

我需要同时填充两个相互依赖的数组，基于它们以前的元素，如下所示：

import numpy as np
a = np.zeros(100)
b = np.zeros(100)
c = np.random.random(100)

for num in range(1, len(a)):
    a[num] = b[num-1] + c[num]
    b[num] = b[num-1] + a[num]

有没有一种方法可以真正使用numpy将其矢量化（即不使用numpy.vectorize）？请注意，这些是任意数组，不是为这些特定值寻找解决方案。

是的，有：

c = np.arange(100)
a = 2 ** c - 1
b = numpy.cumsum(a)

---

显然，这些更新是：

a_i = b_i-1 + c_i
b_i = 2*b_i-1 + c_i

写出递归

b_0 = c_0              # I'm not sure if c_0 is to be used
b_1 = 2*b_0 + c_1
    = 2*c_0 + c_1
b_2 = 2*b_1 + c_2
    = 2*(2*c_0 + c_1) + c_2
    = 4*c_0 + 2*c_1 + c_2
b_3 = 2*b_2 + c_3
    = 2*(4*c_0 + 2*c_1 + c_2) + c_3
    = 8*c_0 + 4*c_1 + 2*c_2 + c_3

看来

b_i = np.sum((2**np.arange(i+1))[::-1] * c[:i])
a_i = b_i-1 + c_i

这里不可能进行累积求和，因为

ci

的系数一直在变化

完全矢量化的最简单方法可能就是使用一个巨大的矩阵。如果

c

具有大小

N

：

t = np.zeros((N, N))
x, y = np.tril_indices(N)
t[x, y] = 2 ** (x - y)

这给了我们：

>>> t
array([[ 1.,  0.,  0.,  0.],
       [ 2.,  1.,  0.,  0.],
       [ 4.,  2.,  1.,  0.],
       [ 8.,  4.,  2.,  1.]])

现在你可以做：

b = np.sum(t * c, axis=1)
a = np.zeros(N)
a[1:] = b[:-1] + c[1:]

---

我可能不会推荐这种解决方案。从我对计算方法所知的一点来看，对于大型

N

，这在数值上似乎并不稳定。但我有一种感觉，这对于任何在最后执行求和的向量化解都是正确的。也许你应该尝试一下for循环和这段代码，看看你的错误是否会随着矢量化的解决方案而不断爆发。

正如@Praveen的文章中提到的，我们可以在几次迭代中编写这些表达式，试图找到闭式，当然对于

c

，这将是一个三角形矩阵。然后，我们只需添加迭代缩放的

b[0]

即可获得完整的

b

。为了得到

a

，我们只需添加

b

和

c

的移位版本

因此，从实现角度来看，为了提高效率，这里有一个不同的观点-

p = 2**np.arange(a.size-1)
scale1 = p[:,None]//p
b_out = np.append(b[0],scale1.dot(c[1:]) + 2*p*b[0])
a_out = np.append(a[0],b_out[:-1] + c[1:])

如果

a

和

b

总是以

0

开头，那么最后两个步骤的代码将简化为-

b_out = np.append(0,scale1.dot(c[1:]))
a_out = np.append(0,b_out[:-1] + c[1:])

---

您是在寻找一种方法来处理

a

、

b

和

c

的特定值，还是针对

c

的任意值？@Praveen，所有提到的数组的任意值，我只是在寻找这个问题的通用解决方案。谢谢@Nils，我正在寻找问题的通用解决方案，而不是

c

的特定值，我更新了我的问题。您的问题的解决方案应该可以按照Nils在此处发布的内容进行；虽然我还没有检查这是否准确。谢谢@Eelco，我很难理解如何将其应用于非分析性案例。如果

c

中填充了随机数（请参见我更新的问题），则@Nils解决方案中的第二行不能替换为类似的矢量化，对吗？谢谢@Praveen！试图复制结果，但

a

和

b

与循环给出的结果不同。不过，关于如何到达那里的解释还是很好的。谢谢@Divakar！