我应该如何对执行数组数值插值的类进行单元测试？

Question

I work with a project where some classes perform numerical interpolation, that is, given a set of points at known locations, I can ask for the position of points between the nodes of the grid, so to say.

Since these methods do not return exact values by definition, I wonder how am I supposed to unit-test them.

For example, the code below tests that the interpolant returns an array of zeros if I give a similar array of zeros to it, and it works, but I suspect it's working because I am not actually resampling here, just asking the same positions again.

[TestMethod]
public void Interpolate_ZeroIn_ZeroOut()
{
    var Xvalues = new double[] {1,2,3,4,5,6,7,8,9,10};
    var Yvalues = new double[] {0,0,0,0,0,0,0,0,0,0};

    List<Point> points = 
        Enumerable.Zip(Xvalues, Yvalues, (x,y) => new Point(x,y)).ToList();

    int interpolation_order = 5;

    FourierIterpolator target = new FourierInterpolator(points, interpolation_order);

    var output = Xvalues.Select(p => target.Interpolate(p)).ToList();

    CollectionAssert.AreEqual(output, Yvalues);
}

Problem is: with actual resampling, the new points will be "between" input points, so I cannot use CollectionAssert.AreEqual . Also, with some interpolation methods with smoothing, the arrays will not be equal, only approximate.

So, my question is:

What are recommended assertions to use when testing numeric methods involving aproximation / interpolation?

Answer 1

Is your interpolation technique deterministic ? ( Deterministic means: If your method is called twice with the same parameters , will it return the exact same result in both cases?)

If yes,

• run a few values through your function,
• use an external method to verify that the result is correct (pen and paper, or some math tool),
• add those values as test cases.

This will ensure that any breaking changes to your method are detected by the test cases. One drawback is that your cases will fail if you improve your interpolation technique, yielding different results. This is not necessarily a bad thing, since it alerts you that your method now returns different results.

If your interpolation technique is not deterministic, ie, if it uses some source of randomness, you might be able to assert that the values are within some reasonable error margin.

Answer 2

Currently its hard to see what is input data for your test. I would recommend you to make tests data explicit and easy to see. Also I don't think you need 10 or 100 points to verify whether your method works. Probably 2-3 points would be enough:

var points = new []{ new Point(0,0), new Point(1,0), new Point(2,0) });

Next you should provide expected values:

double[] expected = { 0.33, 0.66, 1.66 };

And last - check if actual values are equal or near expected values:

[TestMethod]
public void Interpolar_ZeroIn_ZeroOut()
{
    var points = new []{ new Point(0,0), new Point(1,0), new Point(2,0) });
    // calculate expected values manually
    double[] expected = { 0.33, 0.66, 1.66 };    
    int ordem = 5;

    var interpolator = new InterpoladorFourier(points, ordem);

    for(int i = 0; i < points.Length; i++)        
       Assert.AreEqual(expected[i], interpolator.Interpolar(points[i].X));
}

If expected data are not accurate then you can provide delta for assertion:

Assert.AreEqual(expected[i], interpolator.Interpolar(points[i].X), 0.01);

---

Or even better - you can create method which creates points in very readable way:

var points = CreatePoints("0,0", "1,0", "2,0"); 

With this helper method:

private Point[] CreatePoints(params string[] points)
{
    List<Point> result = new List<Point>();

    foreach(var s in points)
    {
        var parts = s.Split(',');
        var x = Double.Parse(parts[0]);
        var y = Double.Parse(parts[1]);            
        var point = new Point(x,y);
        result.Add(point);
    }

    return result.ToArray();
}

Answer 3

I came here via google because I was looking for some answers myself, but my current approach might be better than those provided here, so I will share for future reference.

Most (if not all) interpolation methods have a decent number of functions that they interpolate perfectly or at least up to machine precision. For example a cubic spline it's polynomials up do degree 3. I just test for a reasonable number of those polynomials with varying coefficients, varying intervals, varying number of points... Calculate the RMS error and "assert" if it's close to machine precision (say rms_err < 10*eps). Choosing exactly which polynomials/functions/parameters are suitable here requires a bit of knowledge about the specific interpolation method and maybe floating point errors, but it's doable.

Another way is just to compare with available libraries with the same or similar implementation, either by just exporting values of just using the library directly. For example I tested my 2D interpolation implementation with available 1D implementations which use the same method, along one dimension at a time of course.