C＃中的插值-性能问题

Question

我需要使用简单的线性插值对大数据集（几百个光谱，每个光谱包含数千个点）进行重采样。

我已经在C＃中创建了插值方法，但是对于庞大的数据集来说，它似乎真的很慢。

如何提高此代码的性能？

public static List<double> interpolate(IList<double> xItems, IList<double> yItems, IList<double> breaks)
        {
                double[] interpolated = new double[breaks.Count];
                int id = 1;
                int x = 0;
                while(breaks[x] < xItems[0])
                {
                    interpolated[x] = yItems[0];
                    x++;
                }

                double p, w;
                // left border case - uphold the value
                for (int i = x; i < breaks.Count; i++) 
                {
                    while (breaks[i] > xItems[id])
                    {
                        id++;
                        if (id > xItems.Count - 1)
                        {
                            id = xItems.Count - 1;
                            break;
                        }
                    }

                    System.Diagnostics.Debug.WriteLine(string.Format("i: {0}, id {1}", i, id));

                    if (id <= xItems.Count - 1)
                    {
                        if (id == xItems.Count - 1 && breaks[i] > xItems[id])
                        {

                            interpolated[i] = yItems[yItems.Count - 1];
                        }
                        else
                        {
                            w = xItems[id] - xItems[id - 1];
                            p = (breaks[i] - xItems[id - 1]) / w;
                            interpolated[i] = yItems[id - 1] + p * (yItems[id] - yItems[id - 1]);
                        }
                    }
                    else // right border case - uphold the value
                    {
                        interpolated[i] = yItems[yItems.Count - 1];
                    }

                }
                return interpolated.ToList();

        }

编辑
谢谢大家的答复。 当我写这个问题时，我想要实现的是一些总体思路，可以在其中找到一些领域来提高性能。 我没想到任何现成的解决方案，只有一些想法。 你给了我我想要的东西，谢谢！

在编写此问题之前，我曾考虑过用C ++重写此代码，但是在阅读了Will的回答后，看来收益可能会比我预期的要少。

而且，代码是如此简单，以至于这里没有强大的代码技巧。 感谢Petar 尝试优化代码

似乎所有这些都可以减少问题， 找到合适的探查器并检查每条线和故障排除程序并尝试对其进行优化。

再次感谢您的所有回复，并参与本次讨论！

Answer 1

public static List<double> Interpolate(IList<double> xItems, IList<double> yItems, IList<double> breaks)
{
    var a = xItems.ToArray();
    var b = yItems.ToArray();

    var aLimit = a.Length - 1;
    var bLimit = b.Length - 1;

    var interpolated = new double[breaks.Count];

    var total = 0;
    var initialValue = a[0];
    while (breaks[total] < initialValue)
    {
        total++;
    }
    Array.Copy(b, 0, interpolated, 0, total);

    int id = 1;
    for (int i = total; i < breaks.Count; i++)
    {
        var breakValue = breaks[i];

        while (breakValue > a[id])
        {
            id++;
            if (id > aLimit)
            {
                id = aLimit;
                break;
            }
        }

        double value = b[bLimit];

        if (id <= aLimit)
        {
            var currentValue = a[id];
            var previousValue = a[id - 1];
            if (id != aLimit || breakValue <= currentValue)
            {
                var w = currentValue - previousValue;
                var p = (breakValue - previousValue) / w;
                value = b[id - 1] + p * (b[id] - b[id - 1]);
            }
        }

        interpolated[i] = value;
    }
    return interpolated.ToList();
}

我已经缓存了一些（常量）值并使用了Array.Copy，但是我认为这些是微处理优化，编译器已经在Release模式下进行了微优化。 但是，您可以尝试使用此版本，并查看它是否会超过代码的原始版本。

Answer 2

代替

interpolated.ToList()

复制整个数组，您可以直接在最终列表中计算插值（或返回该数组）。 尤其是如果数组/列表足够大，可以容纳大对象堆 。

与普通堆不同，LOH不会由GC压缩，这意味着短暂的大对象比小对象有害得多。

再说一遍：大约7000双。 56'000字节，低于大对象阈值85'000字节（ 1 ）。

Answer 3

在我看来，您已经创建了O（n ^ 2）算法。 您正在搜索时间间隔，即O（n），然后可能将其应用n次。 通过利用列表中已订购商品的事实，您将获得快速而廉价的加速。 使用BinarySearch（），即O（log（n））。

如果仍然有必要，您应该能够使用外循环更快地执行某些操作，无论您以前发现什么间隔，都应该可以更轻松地找到下一个循环。 但是该代码不在您的代码段中。

Answer 4

我想说一下代码，看看它在哪里花费时间，然后您就可以集中精力了。

ANTS很流行，但我认为Equatec是免费的。

Answer 5

一些建议，

• 正如其他人建议的那样，请使用事件探查器更好地了解在哪里使用时间。

• 循环

while (breaks[x] < xItems[0])

如果x的大小大于“中断”列表中的项目数，则可能导致异常。 您应该使用类似

while ( x < breaks.Count && breaks[x] < xItems[0])

但是您可能根本不需要该循环。 为什么将第一项视为特殊情况，仅从id = 0开始并处理for（i）循环中的第一点。 我知道在这种情况下id可能从0开始，并且[id-1]将为负索引，但是请看是否可以在其中做些什么。

• 如果要优化速度，则会牺牲内存大小，反之亦然。 通常，您不能同时拥有这两种方法，除非您制定了非常聪明的算法。 在这种情况下，这意味着要在循环外进行尽可能多的计算，然后将这些值存储在变量中（额外的内存）并在以后使用它们。 例如，与其总是说：

id = xItems.Count - 1;

你可以说：

int lastXItemsIndex = xItems.Count-1;
...
id = lastXItemsIndex;

这与Petar Petrov对aLimit，bLimit所做的建议相同。

• 下一点，即循环（或建议的一个Petar Petrov）：

 while (breaks[i] > xItems[id]) { id++; if (id > xItems.Count - 1) { id = xItems.Count - 1; break; } } 

可能会减少为：

double currentBreak = breaks [i];

while（id <= lastXIndex && currentBreak> xItems [id]）id ++;

• 我要补充的最后一点是检查样本中是否有一些特定于您的问题的属性。 例如，如果xItems表示时间，并且您要定期采样，则

w = xItems[id] - xItems[id - 1];

是常量 ，您不必每次都在循环中进行计算。

可能通常不是这种情况，但是可能您的问题具有其他一些属性，可以用来提高性能。

另一个想法是：也许您不需要双精度，“ float ”可能会更快，因为它更小。

祝好运

Answer 6

System.Diagnostics.Debug.WriteLine(string.Format("i: {0}, id {1}", i, id));

我希望它是未定义DEBUG的发布版本？

否则，这可能取决于那些IList参数的确切含义。 存储计数值而不是每次访问属性都可能有用。

Answer 7

这是您需要转移到本机代码的问题。