在JavaScript中实现任意长度数组的算术-几何均值迭代计算

两个数的算术-几何均值定义为算术均值与几何均值序列的极限。以下是针对不同变量数量实现的单次迭代函数：

双变量实现 #

function agm2(n)
{
    /**
     * @param {Float64Array(2)} n
     */
    var x0 = n[0], x1 = n[1];

    var a0 = (x0 + x1) / 2;
    var a1 = Math.sqrt(x0 * x1);

    return new Float64Array([a0, a1]);
}

三变量实现 #

function agm3(n)
{
    /**
     * @param {Float64Array(3)} n
     */
    var x0 = n[0], x1 = n[1], x2 = n[2];

    var a0 = (x0 + x1 + x2) / 3;
    var a1 = Math.sqrt((x0 * x1 + x1 * x2 + x0 * x2) / 3);
    var a2 = Math.pow(x0 * x1 * x2, 1 / 3);

    return new Float64Array([a0, a1, a2]);
}

四变量实现 #

function agm4(n)
{
    /**
     * @param {Float64Array(4)} n
     */
    var x0 = n[0], x1 = n[1], x2 = n[2], x3 = n[3];

    var a0 = (x0 + x1 + x2 + x3) / 4;
    var a1 = Math.sqrt((
                      x0 * x1
                    + x0 * x2
                    + x0 * x3
                    + x1 * x2
                    + x1 * x3
                    + x2 * x3
        ) / 6);
    var a2 = Math.pow((
                      x0 * x1 * x2
                    + x0 * x1 * x3
                    + x0 * x2 * x3
                    + x1 * x2 * x3
        ) / 4, 1 / 3);
    var a3 = Math.pow(x0 * x1 * x2 * x3, 1 / 4);

    return new Float64Array([a0, a1, a2, a3]);
}

五变量实现 #

function agm5(n)
{
    /**
     * @param {Float64Array(5)} n
     */
    var x0 = n[0], x1 = n[1], x2 = n[2], x3 = n[3], x4 = n[4];

    var a0 = (x0 + x1 + x2 + x3 + x4) / 5;
    var a1 = Math.sqrt((
                      x0 * x1
                    + x0 * x2
                    + x0 * x3
                    + x0 * x4
                    + x1 * x2
                    + x1 * x3
                    + x1 * x4
                    + x2 * x3
                    + x2 * x4
                    + x3 * x4
        ) / 10);
    var a2 = Math.pow((
                      x0 * x1 * x2
                    + x0 * x1 * x3
                    + x0 * x1 * x4
                    + x0 * x2 * x3
                    + x0 * x2 * x4
                    + x0 * x3 * x4
                    + x1 * x2 * x3
                    + x1 * x2 * x4
                    + x1 * x3 * x4
                    + x2 * x3 * x4
        ) / 10, 1 / 3);
    var a3 = Math.pow((
                      x0 * x1 * x2 * x3
                    + x0 * x1 * x2 * x4
                    + x0 * x1 * x3 * x4
                    + x0 * x2 * x3 * x4
                    + x1 * x2 * x3 * x4
        ) / 5, 1 / 4);
    var a4 = Math.pow(x0 * x1 * x2 * x3 * x4, 1 / 5);

    return new Float64Array([a0, a1, a2, a3, a4]);
}

六变量实现 #

function agm6(n)
{
    /**
     * @param {Float64Array(5)} n
     */
    var x0 = n[0], x1 = n[1], x2 = n[2], x3 = n[3], x4 = n[4], x5 = n[5];

    var a0 = (x0 + x1 + x2 + x3 + x4 + x5) / 6;
    var a1 = Math.sqrt((
                      x0 * x1
                    + x0 * x2
                    + x0 * x3
                    + x0 * x4
                    + x0 * x5
                    + x1 * x2
                    + x1 * x3
                    + x1 * x4
                    + x1 * x5
                    + x2 * x3
                    + x2 * x4
                    + x2 * x5
                    + x3 * x4
                    + x3 * x5
                    + x4 * x5
        ) / 15);
    var a2 = Math.pow((
                      x0 * x1 * x2
                    + x0 * x1 * x3
                    + x0 * x1 * x4
                    + x0 * x1 * x5
                    + x0 * x2 * x3
                    + x0 * x2 * x4
                    + x0 * x2 * x5
                    + x0 * x3 * x4
                    + x0 * x3 * x5
                    + x0 * x4 * x5
                    + x1 * x2 * x3
                    + x1 * x2 * x4
                    + x1 * x2 * x5
                    + x1 * x3 * x4
                    + x1 * x3 * x5
                    + x1 * x4 * x5
                    + x2 * x3 * x4
                    + x2 * x3 * x5
                    + x2 * x4 * x5
                    + x3 * x4 * x5
        ) / 20, 1 / 3);
    var a3 = Math.pow((
                      x0 * x1 * x2 * x3
                    + x0 * x1 * x2 * x4
                    + x0 * x1 * x2 * x5
                    + x0 * x1 * x3 * x4
                    + x0 * x1 * x3 * x5
                    + x0 * x1 * x4 * x5
                    + x0 * x2 * x3 * x4
                    + x0 * x2 * x3 * x5
                    + x0 * x2 * x4 * x5
                    + x0 * x3 * x4 * x5
                    + x1 * x2 * x3 * x4
                    + x1 * x2 * x3 * x5
                    + x1 * x2 * x4 * x5
                    + x1 * x3 * x4 * x5
                    + x2 * x3 * x4 * x5
        ) / 15, 1 / 4);
    var a4 = Math.pow((
                      x0 * x1 * x2 * x3 * x4
                    + x0 * x1 * x2 * x3 * x5
                    + x0 * x1 * x2 * x4 * x5
                    + x0 * x1 * x3 * x4 * x5
                    + x0 * x2 * x3 * x4 * x5
                    + x1 * x2 * x3 * x4 * x5
        ) / 6, 1 / 5);
    var a5 = Math.pow(x0 * x1 * x2 * x3 * x4 * x5, 1 / 6);

    return new Float64Array([a0, a1, a2, a3, a4, a5]);
}

对任意严格正实数数组反复执行上述迭代，最终所有系数会收敛到单一值。

需求与问题 #

如何将上述实现泛化为无需为每个数组长度定义单独函数的通用版本？该通用agm函数需接收任意长度的Float64Array，并输出单次迭代后的Float64Array。已知可实现二项式系数，请问如何正确实现任意长度数组的初等对称多项式（除首尾项外）？

内容的提问来源于stack exchange，提问作者user4819461