Question

I need to resample big sets of data (few hundred spectra, each containing few thousand points) using simple linear interpolation.

I have created interpolation method in C# but it seems to be really slow for huge datasets.

How can I improve the performance of this code?

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();

        }

Edit
Thanks, guys, for all your responses. What I wanted to achieve, when I wrote this questions, were some general ideas where I could find some areas to improve the performance. I haven’t expected any ready solutions, only some ideas. And you gave me what I wanted, thanks!

Before writing this question I thought about rewriting this code in C++ but after reading comments to Will’s asnwer it seems that the gain can be less than I expected.

Also, the code is so simple, that there are no mighty code-tricks to use here. Thanks to Petar for his attempt to optimize the code

It seems that all reduces the problem to finding good profiler and checking every line and soubroutine and trying to optimize that.

Thank you again for all responses and taking your part in this discussion!

Answer 1

I’d say profile the code and see where it spends its time, then you have somewhere to focus on.

ANTS is popular, but Equatec is free I think.