Incorrect linear interpolation with large x values using Math.Net Numerics

Question

I'm trying to use Math.NET Numerics to do interpolation of a DateTime - Value series. I started off with linear interpolation, but am getting some very off looking results.

Running this test:

public class script{

public void check_numerics()
  {
    var ticks = DateTime.Now.Ticks;
    Console.WriteLine("Ticks: " + ticks);
    var xValues = new double[] { ticks, ticks + 1000, ticks + 2000, ticks + 3000, ticks + 4000, ticks + 5000 };
    var yValues = new double[] {0, 1, 2, 3, 4, 5};
    var spline = Interpolate.LinearBetweenPoints(xValues, yValues);
    var ticks2 = ticks;
    for (int i = 0; i < 10; i++)
    {
      ticks2 += 500;
      Console.WriteLine(spline.Interpolate(ticks2));
    }
  }
}

This gives:

Ticks: 635385235576843379
0.5
1
1.5
2
2.42857142857143 // this should be 2.5
3
3.5
4
4.5
5

Notice that 2.4285 is fairly wrong. At a different time (different ticks value) a different value will be "wrong". Is there a "bug" with large x values in Math.NET or am I expecting too much?

It won't be totally accurate given that double only has 15 - 17 s.f. and you are exceeding that so double can't represent the values your giving it accurately but I would have thought it'd be closer than that — James, Jun 16 '14 at 13:49
Thanks @JamesBarrass, so you can't represent the current time in a double -- good to know! — jdpilgrim, Jun 16 '14 at 16:23
Not at that accuracy, milliseconds, maybe 10's of microseconds. Not much smaller. IIRC ticks are around 100 nanoseconds — James, Jun 16 '14 at 16:25

Christoph Rüegg · Accepted Answer · 2014-06-16T22:26:44.650

Just confirming the comments above as the maintainer of Math.NET Numerics:

The distance (epsilon) between the closest numbers of this magnitude that can be represented at double precision is 128:

Precision.EpsilonOf(ticks); // 128

This means that if you add or substract 128/2-1 = 63 from this number, you get back exactly the same number:

long ticks = DateTime.Now.Ticks // 635385606515570758
((long)(double)ticks)           // 635385606515570816
((long)(63+(double)ticks))      // 635385606515570816
((long)(-63+(double)ticks))     // 635385606515570816
((long)(65+(double)ticks))      // 635385606515570944
((long)(-65+(double)ticks))     // 635385606515570688

The incremental steps of 500 are very close to these 128 and effectively get rounded to multiples of 128 (e.g. 512), so it's not surprising that there will be some artifacts like this.

If you reduce the time precision to milliseconds by dividing the ticks by 10000, as suggested by James, you get an epsilon of 0.0078125, and accurate results even for steps of 1 instead of 500.

Precision.EpsilonOf(ticks/10000); // 0.0078125

Incorrect linear interpolation with large x values using Math.Net Numerics

1 Answers1