Cubic Splines

Cubic splines are piecewise polynomials of order three. They are often used to interpolate a data series. Cubic splines come in many shapes and are implemented by the CubicSpline class.

Cubic splines are interpolating curves and so they are defined in part by a set of data points. In addition, the first derivative (slope) of the curve is required to be continuous. This still does not fully define the conditions on all the coefficients of the piecewise polynomials, so additional conditions are usually applied. Choosing different conditions leads to different types of cubic splines. The kinds supported by the Extreme Optimization Numerical Libraries for .NET are defined by the CubicSplineKind enumeration type, whose members are listed below:

Constructing cubic splines

The CubicSpline class has four sets of constructors, one set each for each kind of spline. In addition, the CubicSpline class has a number of static methods that construct splines of a specific kind.

There are three constructors that create a natural spline. The first constructor takes two Double arrays as arguments. The first array contains the x-values of the data points. The second array contains the y-values. As mentioned before, the x values must be provided in ascending order. The second constructor takes two Vector<T> objects, with the same meaning as before. The third constructor has only one argument: an array of Point structures. The following example illustrates the use of these constructors:

Vector<double> xValues = Vector.Create(1.0, 2.0, 3.0, 4.0, 5.0, 6.0);
Vector<double> yValues = Vector.Create(1.0, 3.0, 4.0, 3.0, 4.0, 2.0);
CubicSpline naturalSpline1 = new CubicSpline(xValues, yValues);
Point[] dataPoints = new Point[]
    {new Point(1, 1), new Point(2, 3), new Point(3, 4),
     new Point(4, 3), new Point(5, 4), new Point(6, 2)};
CubicSpline naturalSpline2 = new CubicSpline(dataPoints);
CubicSpline naturalSpline3 = CubicSpline.CreateNatural(xValues, yValues);
CubicSpline naturalSpline4 = CubicSpline.CreateNatural(dataPoints);

Dim xValues = Vector.Create(1.0, 2.0, 3.0, 4.0, 5.0, 6.0)
Dim yValues = Vector.Create(1.0, 3.0, 4.0, 3.0, 4.0, 2.0)
Dim naturalSpline1 As CubicSpline = New CubicSpline(xValues, yValues)
Dim dataPoints = New Point() _
    { New Point(1, 1), New Point(2, 3), New Point(3, 4),
     New Point(4, 3), New Point(5, 4), New Point(6, 2) }
Dim naturalSpline2 As CubicSpline = New CubicSpline(dataPoints)
Dim naturalSpline3 As CubicSpline = CubicSpline.CreateNatural(xValues, yValues)
Dim naturalSpline4 As CubicSpline = CubicSpline.CreateNatural(dataPoints)

No code example is currently available or this language may not be supported.

let xValues = Vector.Create(1.0, 2.0, 3.0, 4.0, 5.0, 6.0)
let yValues = Vector.Create(1.0, 3.0, 4.0, 3.0, 4.0, 2.0)
let naturalSpline1 = CubicSpline(xValues, yValues)
let dataPoints = [|
    Point(1.0, 1.0); Point(2.0, 3.0); Point(3.0, 4.0);
    Point(4.0, 3.0); Point(5.0, 4.0); Point(6.0, 2.0) |]
let naturalSpline2 = CubicSpline(dataPoints)
let naturalSpline3 = CubicSpline.CreateNatural(xValues, yValues)
let naturalSpline4 = CubicSpline.CreateNatural(dataPoints)
//

Natural splines can also be created with the static CreateNatural method, which accepts the same arguments.

To construct a clamped spline, the same three options are available, but two additional parameters are required: the slopes at the left and right end point. The following example constructs a clamped cubic spline through the same data points as above, and forces the slope at the lower bound to be -1, and the slope at the upper bound to be 1:

CubicSpline clampedSpline1 = new CubicSpline(xValues, yValues, -1.0, 1.0);
CubicSpline clampedSpline2 = new CubicSpline(dataPoints, -1.0, 1.0);
CubicSpline clampedSpline3 = CubicSpline.CreateClamped(xValues, yValues, -1.0, 1.0);
CubicSpline clampedSpline4 = CubicSpline.CreateClamped(dataPoints, -1.0, 1.0);

Dim clampedSpline1 As CubicSpline = New CubicSpline(xValues, yValues, -1.0, 1.0)
Dim clampedSpline2 As CubicSpline = New CubicSpline(dataPoints, -1.0, 1.0)
Dim clampedSpline3 As CubicSpline = CubicSpline.CreateClamped(xValues, yValues, -1.0, 1.0)
Dim clampedSpline4 As CubicSpline = CubicSpline.CreateClamped(dataPoints, -1.0, 1.0)

No code example is currently available or this language may not be supported.

let clampedSpline1 = CubicSpline(xValues, yValues, -1.0, 1.0)
let clampedSpline2 = CubicSpline(dataPoints, -1.0, 1.0)
let clampedSpline3 = CubicSpline.CreateClamped(xValues, yValues, -1.0, 1.0)
let clampedSpline4 = CubicSpline.CreateClamped(dataPoints, -1.0, 1.0)
//

As the above code shows, clamped splines can also be created with the static CreateClamped method, which accepts the same arguments.

To construct an Akima spline, the same options are once again available, but an additional argument should be supplied: a CubicSplineKind value with a value of Akima. Akima splines can also be created with the static CreateAkima method, which accepts the same arguments while omitting the extra argument.

CubicSpline akimaSpline1 = new CubicSpline(xValues, yValues, CubicSplineKind.Akima);
CubicSpline akimaSpline2 = new CubicSpline(dataPoints, CubicSplineKind.Akima);
CubicSpline akimaSpline3 = CubicSpline.CreateAkima(xValues, yValues);
CubicSpline akimaSpline4 = CubicSpline.CreateAkima(dataPoints);

Dim akimaSpline1 As CubicSpline = New CubicSpline(xValues, yValues, CubicSplineKind.Akima)
Dim akimaSpline2 As CubicSpline = New CubicSpline(dataPoints, CubicSplineKind.Akima)
Dim akimaSpline3 As CubicSpline = CubicSpline.CreateAkima(xValues, yValues)
Dim akimaSpline4 As CubicSpline = CubicSpline.CreateAkima(dataPoints)

No code example is currently available or this language may not be supported.

let akimaSpline1 = CubicSpline(xValues, yValues, CubicSplineKind.Akima)
let akimaSpline2 = CubicSpline(dataPoints, CubicSplineKind.Akima)
let akimaSpline3 = CubicSpline.CreateAkima(xValues, yValues)
let akimaSpline4 = CubicSpline.CreateAkima(dataPoints)
//

To construct a smoothing spline, the same options are again available as for natural splines, but one or two additional arguments should be supplied. The first is the smoothing parameter. This is a value, usually between 0 and 1, that specifies the relative weight of the smoothness and interpolation error. A value of 0 corresponds to a least squares fit of a horizontal line. A value of 1 corresponds to a natural spline. The second additional argument is an array or vector that contains the weights of each data point. If no weights are supplied, they are assumed to all be equal to 1.

Smoothing splines can also be created with the static CreateSmooth method, which accepts the same arguments as the constructors. It also has overloads that omit the weights. In this case, the weights are assumed to be all equal to 1.

Vector<double> weights = Vector.Create(xValues.Length, i => 1 / yValues[i]);
CubicSpline smoothingSpline1 = new CubicSpline(xValues, yValues, 0.5, weights);
CubicSpline smoothingSpline2 = new CubicSpline(dataPoints, 0.5, weights);
CubicSpline smoothingSpline3 = CubicSpline.CreateSmooth(xValues, yValues, 0.5);
CubicSpline smoothingSpline4 = CubicSpline.CreateSmooth(dataPoints, 0.5);

Dim weights = Vector.Reciprocal(yValues)
Dim smoothingSpline1 As CubicSpline = New CubicSpline(xValues, yValues, 0.5, weights)
Dim smoothingSpline2 As CubicSpline = New CubicSpline(dataPoints, 0.5, weights)
Dim smoothingSpline3 As CubicSpline = CubicSpline.CreateSmooth(xValues, yValues, 0.5)
Dim smoothingSpline4 As CubicSpline = CubicSpline.CreateSmooth(dataPoints, 0.5)

No code example is currently available or this language may not be supported.

let weights = Vector.Reciprocal(yValues)
let smoothingSpline1 = CubicSpline(xValues, yValues, 0.5, weights)
let smoothingSpline2 = CubicSpline(dataPoints, 0.5, weights)
let smoothingSpline3 = CubicSpline.CreateSmooth(xValues, yValues, 0.5)
let smoothingSpline4 = CubicSpline.CreateSmooth(dataPoints, 0.5)
//

To construct a monotonic cubic spline, the same options are once again available. They do not require any additional parameters. Cubic Hermite splines can also be created with the static CreateMonotonic method, which accepts the same arguments as the constructors.

CubicSpline monotonicSpline1 = new CubicSpline(xValues, yValues, CubicSplineKind.Monotonic);
CubicSpline monotonicSpline2 = new CubicSpline(dataPoints, CubicSplineKind.Monotonic);
CubicSpline monotonicSpline3 = CubicSpline.CreateMonotonic(xValues, yValues);
CubicSpline monotonicSpline4 = CubicSpline.CreateMonotonic(dataPoints);

Dim monotonicSpline1 As CubicSpline = New CubicSpline(xValues, yValues, CubicSplineKind.Monotonic)
Dim monotonicSpline2 As CubicSpline = New CubicSpline(dataPoints, CubicSplineKind.Monotonic)
Dim monotonicSpline3 As CubicSpline = CubicSpline.CreateMonotonic(xValues, yValues)
Dim monotonicSpline4 As CubicSpline = CubicSpline.CreateMonotonic(dataPoints)

No code example is currently available or this language may not be supported.

let monotonicSpline1 = CubicSpline(xValues, yValues, CubicSplineKind.Monotonic)
let monotonicSpline2 = CubicSpline(dataPoints, CubicSplineKind.Monotonic)
let monotonicSpline3 = CubicSpline.CreateMonotonic(xValues, yValues)
let monotonicSpline4 = CubicSpline.CreateMonotonic(dataPoints)
//

To construct a cubic Hermite interpolating spline, the same options are once again available, but an additional array or vector should be supplied that contains the first derivatives at each of the data points. Cubic Hermite splines can also be created with the static CreateHermiteInterpolant method, which accepts the same arguments as the constructors.

Vector<double> derivatives = Vector.Create(0.5, 0.0, -0.5, 0.0, 0.5, 1.0);
CubicSpline hermiteSpline1 = new CubicSpline(xValues, yValues, derivatives);
CubicSpline hermiteSpline2 = new CubicSpline(dataPoints, derivatives);
CubicSpline hermiteSpline3 = CubicSpline.CreateHermiteInterpolant(xValues, yValues, derivatives);
CubicSpline hermiteSpline4 = CubicSpline.CreateHermiteInterpolant(dataPoints, derivatives);

Dim derivatives = Vector.Create(0.5, 0.0, -0.5, 0.0, 0.5, 1.0)
Dim hermiteSpline1 As CubicSpline = New CubicSpline(xValues, yValues, derivatives)
Dim hermiteSpline2 As CubicSpline = New CubicSpline(dataPoints, derivatives)
Dim hermiteSpline3 As CubicSpline = CubicSpline.CreateHermiteInterpolant(xValues, yValues, derivatives)
Dim hermiteSpline4 As CubicSpline = CubicSpline.CreateHermiteInterpolant(dataPoints, derivatives)

No code example is currently available or this language may not be supported.

let derivatives = Vector.Create(0.5, 0.0, -0.5, 0.0, 0.5, 1.0)
let hermiteSpline1 = CubicSpline(xValues, yValues, derivatives)
let hermiteSpline2 = CubicSpline(dataPoints, derivatives)
let hermiteSpline3 = CubicSpline.CreateHermiteInterpolant(xValues, yValues, derivatives)
let hermiteSpline4 = CubicSpline.CreateHermiteInterpolant(dataPoints, derivatives)
//

Working with cubic splines

Once created, there is no real difference between any of the types of cubic splines.

CubicSpline implements most methods and properties of the Curve class.

The ValueAt method returns the value of the spline at a specified point. If the x value is less than the lower bound of the first interval, the value is that of the cubic polynomial on the first interval extended to the left. If the x value is greater than the upper bound of the last interval, the value is that of the cubic polynomial on the last interval extended to the right.

The SlopeAt method returns the derivative. It is defined everywhere. The GetDerivative method is not available.

Console.WriteLine("naturalSpine1.ValueAt(2) = {0}", naturalSpline1.ValueAt(2));
Console.WriteLine("naturalSpine1.SlopeAt(2) = {0}", naturalSpline1.SlopeAt(2));

Console.WriteLine("naturalSpine1.ValueAt(2) = { 0 }", naturalSpline1.ValueAt(2))
Console.WriteLine("naturalSpine1.SlopeAt(2) = { 0 }", naturalSpline1.SlopeAt(2))

No code example is currently available or this language may not be supported.

Console.WriteLine("naturalSpine1.ValueAt(2) = {0}", naturalSpline1.ValueAt(2.0))
Console.WriteLine("naturalSpine1.SlopeAt(2) = {0}", naturalSpline1.SlopeAt(2.0))
//

Integral evaluates the definite integral over a specified interval. The integral is calculated exactly and efficiently. In fact, a common application of cubic splines is the approximation of the integral of a tabulated function. The example below illustrates this procedure:

double integral = naturalSpline1.Integral(2.2, 5.4);

Dim integral As Double = naturalSpline1.Integral(2.2, 5.4)

No code example is currently available or this language may not be supported.

let integral = naturalSpline1.Integral(2.2, 5.4)
//

This type of approximation turns out to be of good quality in most cases.

The FindRoots method is specialized to return all zeros of the cubic spline function.