如何通过 LINQ 将一个列表转换为另一个半聚合列表？

Question

我是 Linq 初学者，所以只是想找人告诉我是否可以使用 Linq 实现以下内容，如果可以的话，请提供一些如何实现它的指示。

我想将一个金融时间序列列表转换为另一个列表，其中第二个系列列表的长度将与第一个列表相同或更短（通常它会更短，即，它成为一个新列表，其中元素本身代表一个列表的信息聚合）或第一个列表中的更多元素）。如何将列表从一个列表折叠到另一个列表取决于第一个列表中的数据。该算法需要跟踪在将新元素添加到第二个列表时重置的计算。举个例子可能更容易描述：

表1（收盘价和成交量从开始到结束的时间序列）：

{P=7,V=1}, {P=10,V=2}, {P= 10,V=1}, {P=10,V=3}, {P=11,V=5}, {P=12,V=1}, {P=13,V=2}, {P= 17,V=1}, {P=15,V=4}, {P=14,V=10}, {P=14,V=8}, {P=10,V=2}, {P= 9,V=3}, {P=8,V=1}

列表 2（一系列开盘/收盘价格范围以及该范围期间的交易量总和，使用这 2 个参数设置将列表 1 转换为列表 2：参数 1：价格范围步长 = 3，参数 2：价格范围反转步长 = 6)：

{O=7,C=10,V=1+2+1}, {O=10,C=13,V=3+ 5+1+2}, {O=13,C=16,V=0}, {O=16,C=10,V=1+4+10+8+2}, {O=10,C= 8,V=3+1}

在列表 2 中，我明确地显示了列表 2 中列表 1 中 V 属性的总和。但 V 只是一个 long，所以实际上它只是一个数字。所以它的工作原理是开盘时间序列价格为 7。然后我们从这个初始起始价格中寻找第一个价格，其中 delta 距离 7 为 3（通过参数 1 设置）。在列表 1 中，当我们浏览列表时，下一步是向上移动到 10，因此我们已经建立了“上升趋势”。因此，现在我们在列表 2 中构建第一个元素，开盘价=7，收盘价=10，并对第一个列表中使用的所有柱的交易量求和，以达到列表 2 中的第一步。现在，下一个元素的起点是 10。建立另一个向上台阶，我们需要再向上推进 3 个以创建另一个向上台阶，或者我们可以反向并向下前进 6 个（参数 2）。使用列表 1 中的数据，我们首先达到 13，这样就构建了列表 2 中的第二个元素，并对用于到达此步骤的所有 V 属性求和。我们继续这个过程直到列表 1 处理结束。

请注意列表 1 中发生的间隙跳跃。我们仍然想要创建一个 {O=13,C=16,V=0} 的步骤元素。 V 为 0 只是说明我们有一个经过此步骤的范围移动，但成交量为 0（此处没有出现列表 1 中的实际价格 - 它位于其上方，但我们想要构建导致价格的一组步骤那是在它上面）。

列表 2 中倒数第二个条目表示从上到下的反转。

列表 2 中的最后一个条目仅使用列表 1 中的最终关闭，即使它实际上尚未完成建立全范围步骤。

感谢您提供有关如何通过 Linq 完成此操作（如果有的话）的任何指示。

Answer 1

我的第一个想法是，为什么要尝试使用 LINQ 来解决这个问题？使用 yield 关键字来部分处理然后吐出答案来创建新的 Enumerable 似乎是一个更好的情况。

大概是这样的：

public struct PricePoint
{
    ulong price;
    ulong volume;
}

public struct RangePoint
{
    ulong open;
    ulong close;
    ulong volume;
}

public static IEnumerable<RangePoint> calculateRanges(IEnumerable<PricePoint> pricePoints)
{
    if (pricePoints.Count() > 0)
    {
        ulong open = pricePoints.First().price;
        ulong volume = pricePoints.First().volume;

        foreach(PricePoint pricePoint in pricePoints.Skip(1))
        {
            volume += pricePoint.volume;
            if (pricePoint.price > open)
            {
                if ((pricePoint.price - open) >= STEP)
                {
                    // We have established a up-trend.
                    RangePoint rangePoint;
                    rangePoint.open = open;
                    rangePoint.close = close;
                    rangePoint.volume = volume;

                    open = pricePoint.price;
                    volume = 0;

                    yield return rangePoint;
                }
            }
            else
            {
                if ((open - pricePoint.price) >= REVERSAL_STEP)
                {
                    // We have established a reversal.
                    RangePoint rangePoint;
                    rangePoint.open = open;
                    rangePoint.close = pricePoint.price;
                    rangePoint.volume = volume;

                    open = pricePoint.price;
                    volume = 0;

                    yield return rangePoint;
                }
            }
        }

        RangePoint lastPoint;
        lastPoint.open = open;
        lastPoint.close = pricePoints.Last().price;
        lastPoint.volume = volume;
        yield return lastPoint;
    }
}

这还没有完成。例如，它不处理间隙，并且存在未处理的边缘情况，其中最后一个数据点可能会被消耗，但它仍然会处理“lastPoint”。但这应该足以开始。