How is linear interpolation of data sets usually implemented?

问题

Suppose if you are given a bunch of points in (x,y) values and you need to generate points by linearly interpolate between the 2 nearest values in the x axis, what is the fastest implementation to do so?

I searched around but I was unable to find a satisfactory answer, I feel its because I wasnt searching for the right words.

For example, if I was given (0,0) (0.5 , 1) (1, 0.5), then I want to get a value at 0.7; it would be (0.7-0.5)/(1-0.5) * (0.5-1) + 1; but what data structure would allow me to find the 2 nearest key values to interpolate in between? Is a simple linear search/ binary search if I have many key values the best I could do?

回答1:

The way I usually implement O(1) interpolation is by means of an additional data structure, which I call IntervalSelector that in time O(1) will give the two surrounding values of the sequence that have to be interpolated.

An IntervalSelector is a class that, when given a sequence of n abscissas builds and remembers a table that will map any given value of x to the index i such that sequence[i] <= x < sequence[i+1] in time O(1).

Note: In what follows arrays are 1 based.

The algorithm that builds the table proceeds as follow:

1. Find delta to be the minimum distance between two consecutive elements in the input sequence of abscissas.
2. Set count := (b-a)/delta + 1, where a and b are respectively the first and last of the (ascending) sequence and / stands for the integer quotient of the division.
3. Define table to be an Array of count elements.
4. For i between 1 and n set table[(sequence[j]-a)/delta + 1] := j.
5. Repeat every entry of table visited in 4 to the unvisited positions that come right after it.

On output, table maps j to i if (j-1)*d <= sequence[i] - a < j*d.

Here is an example:

Since elements 3^rd and 4^th are the closest ones, we divide the interval in subintervals of this smallest length. Now, we remember in the table the positions of the left end of each of these deta-intervals. Later on, when an input x is given, we compute the delta-interval of such x as (x-a)/delta + 1 and use the table to deduce the corresponding interval in the sequence. If x falls to the left of the ith sequence element, we choose the (i-1)th.

More precisely:

Given any input x between a and b calculate j := (x-a)/delta + 1 and i := table[j]. If x < sequence[i] put i := i - 1. Then, the index i satisfies sequence[i] <= x < sequence[i+1]; otherwise the distance between these two consecutive elements would be smaller than delta, which is not.

Remark: Be aware that if the minimum distance delta between consecutive elements in sequence is too small the table will have too many entries. The simple description I've presented here ignores these pathological cases, which require additional work.

回答2:

Yes, a simple binary search should do well and will typically suffice.

If you need to get better, you might try interpolation search (has nothing to do with your value interpolation).

If your points are distributed at fixed intervals (like in your example, 0 0.5 1), you can also simply store the values in an array and access them in constant time via their index.

来源：https://stackoverflow.com/questions/29222858/how-is-linear-interpolation-of-data-sets-usually-implemented