在我的情况下,我可以计算一个元素而不循环遍历所有前面的元素(参见问题正文)吗？

Question

我有2个相同长度的双打阵列.数组a中填充了一些数据,数组b将被计算出来.

数组b的每个元素等于数组a中的对应值加上数组b中所有先前元素的加权和.

通过将所有这些元素相乘,每个元素乘以系数来计算加权和,该系数等于它与我们计算的当前元素的距离除以前一子集中的元素数.

为了实现这一点,我为我计算的每个元素循环遍历整个前面的子集.

这可以优化吗？我没有足够的数学技能,但我怀疑我只能使用前面的第一个元素来计算每一个元素,因为每个元素都已经从前面的集合中派生出来并且包含了已经加权的所有信息.也许我可以调整重量公式并获得相同的结果而无需第二级循环？

这似乎是Scala的一个例子(我不确定它是否正确: - ]).由于实际项目使用负指数,因此在上面写的任务方面将(1)和a(2)视为(0)之前.

import scala.Double.NaN
val a = Array[Double] (8.5, 3.4, 7.1, 5.12, 0.14, 5)
val b = Array[Double] (NaN, NaN, NaN, NaN, NaN, 5)
var i = b.length - 2
while (i >= 0) {
  b(i) = a(i) + {
    var succession = 0.0
    var j = 1
    while (i + j < b.length) {
      succession += b (i+j) * (1.0-j.toDouble/(b.length - i))
      j += 1
    }
    succession
  }
  i -= 1
}
b.foreach((n : Double) => println(n))

Answer 1

这就是你想做的事？

f(x_n) := g(x_0,..,x_(n-1)) + h(x_n)

只有找到等效函数来替换，才能优化嵌套循环g。实际上，我不知道加权和的确切含义。我猜，是

g(x_0,..,x_(n-1)) = (x_0 + ... + x_(n-1)) / (n-1)

（将所有值相加并除以值的数量）

在这种情况下，您可以存储总和并重复使用它：

a := (x_0 + ... + x_(n-2))
g(x_0,..,x_(n-1)) = (a + x_(n-1)) / (n-1)

这将消除嵌套循环。

就Java而言（实现了我的加权总和的想法）：

double[] x = initX();
double[] y = new double[x.length];
double sum = 0;
y[0] = h(x[0]);
for (int i = 1; i < x.length; i++) {
  sum = sum + x[i-1];    
  y[i] = sum / (i-1) + h(x[i]);
}