Curve Fitting Toolbox 

This example shows how to use the spline commands in Curve Fitting Toolbox™ to fit tensor product splines to bivariate gridded data.
Since Curve Fitting Toolbox can handle splines with vector coefficients, it is easy to implement interpolation or approximation to gridded data by tensor product splines. Most spline construction commands in the toolbox take advantage of this.
However, you might be interested in seeing a detailed description of how approximation to gridded data by tensor products is actually done for bivariate data. This will also come in handy when you need some tensor product construction not provided by the commands in the toolbox.
Example: LeastSquares Approximation to Gridded Data
Consider, for example, leastsquares approximation to given data
z(i,j) = f(x(i),y(j)) for i = 1:I, j = 1:J.
Here are some gridded data, taken from Franke's sample function. Note that the grid is somewhat denser near the boundary, to help pin down the approximation there.
x = sort([(0:10)/10,.03 .07, .93 .97]); y = sort([(0:6)/6,.03 .07, .93 .97]); [xx,yy] = ndgrid(x,y); % note: ndgrid rather than meshgrid z = franke(xx,yy); mesh(x,y,z.'); xlabel('x'); ylabel('y'); view(150,50); title('Data from the Franke Function');
A note about NDGRID vs. MESHGRID
Note that the statements
[xx,yy] = ndgrid(x,y); z = franke(xx,yy);
used above make certain that z(i,j) is the value of the function being approximated at the grid point (x(i),y(j)).
However, the MATLAB® command mesh(x,y,z) expects z(j,i) (note the reversed order of i and j) as the value at the grid point (x(i),y(j)). For that reason, the above plot was generated by the statement
mesh(x,y,z.');
i.e., using the transpose of the matrix z.
Such transposing would not have been necessary had we used meshgrid instead of ndgrid. But the resulting z would not have followed approximation theory standards.
Choice of Spline Space in the YDirection
Next, we choose a spline order ky and a knot sequence knotsy for the ydirection
ky = 3; knotsy = augknt([0,.25,.5,.75,1],ky);
and then obtain
sp = spap2(knotsy,ky,y,z);
a spline curve whose ith component is an approximation to the curve (y,z(i,:)) for i=1:I.
In particular,
yy = .1:.05:1.1; vals = fnval(sp,yy);
creates the matrix vals whose (i,j)th element can be taken as an approximation to the value f(x(i),yy(j)) of the underlying function f at the grid point (x(i),yy(j)). This is evident when we plot vals.
mesh(x,yy,vals.'); xlabel('x'); ylabel('y'); view(150,50); title('Simultaneous Approximation to All Curves in the YDirection');
Note that, for each x(i), both the first two and the last two values are zero since both the first two and the last two sites in yy are outside the basic interval for the spline sp.
Also note the "ridges" that run along the ydirection, most noticeable near the peaks of the surface. They confirm that we are plotting smooth curves in one direction only.
From Curves to a Surface; Choosing a Spline Space in the XDirection
To get an actual surface, we now have to go one step further. Consider the coefficients coefsy of the spline sp, as obtained by
coefsy = fnbrk(sp,'c');
Abstractly, you can think of the spline sp as the vectorvalued function
y > sum coefsy(:,r) B_{r,ky}(y) r
with the ith element, coefsy(i,r), of the vector coefficient coefsy(:,r) corresponding to x(i) for i=1:I. This suggests approximating each curve (x,coefsy(:,r)) by a spline, using the same order kx and the same appropriate knot sequence knotsx for every r.
kx = 4; knotsx = augknt(0:.2:1,kx); sp2 = spap2(knotsx,kx,x,coefsy.');
The use of the spap2 command here needs, perhaps, an explanation.
Recall that spap2(knots,k,x,fx) treats fx(:,j) as the value at x(j), i.e., takes each column of fx as a data value. Since we wanted to fit the value coefsy(i,:) at x(i), for all i, we have to provide spap2 with the transpose of coefsy.
Now consider the transpose of the coefficient matrix of the resulting spline "curve" sp2, obtained as
coefs = fnbrk(sp2,'c').';
coefs provides the bivariate spline approximation
(x,y) > sum sum coefs(q,r) B_{q,kx}(x) B_{r,ky}(y) q r
to the original data
(x(i),y(j)) > f(x(i),y(j)) = z(i,j).
We use spcol to provide the values B_{q,kx}(xv(i)) and B_{r,ky}(yv(j)) needed to evaluate this spline surface at some grid points (xv(i),yv(j)) and then plot the values.
xv = 0:.025:1; yv = 0:.025:1; values = spcol(knotsx,kx,xv)*coefs*spcol(knotsy,ky,yv).'; mesh(xv,yv,values.'); xlabel('x'); ylabel('y'); view(150,50); title('The Spline Approximant');
Why Does This Evaluation Work?
The statement
values = spcol(knotsx,kx,xv) * coefs * spcol(knotsy,ky,yv).'
used above makes good sense since, for example, spcol(knotsx,kx,xv) is the matrix whose (i,q)th entry equals the value B_{q,kx}(xv(i)) at xv(i) of the qth Bspline of order kx for the knot sequence knotsx, while we want to evaluate the expression
sum sum coefs(q,r) B_{q,kx}(x) B_{r,ky}(y) q r = sum sum B_{q,kx}(x) coefs(q,r) B_{r,ky}(y) q r
at (x,y) = (xv(i),yv(j)).
Since the matrices spcol(knotsx,kx,xv) and spcol(knotsy,ky,yv) are banded, it may be more efficient for "large" xv and yv (though perhaps more memoryconsuming) to make use of fnval.
value2 = fnval(spmak(knotsx,fnval(spmak(knotsy,coefs),yv).'),xv).';
In fact, fnval and spmak can deal directly with multivariate splines, hence the above statement can be replaced by
value3 = fnval( spmak({knotsx,knotsy},coefs), {xv,yv} );
Better yet, the construction of the approximation can be done by one call to spap2, therefore we can obtain these values directly from the given data by the statement
value4 = fnval( spap2({knotsx,knotsy},[kx ky],{x,y},z), {xv,yv} );
Here is a check, specifically, the relative difference between the values computed in these four different ways.
diffs = abs(valuesvalue2) + abs(valuesvalue3) + abs(valuesvalue4); max(max(diffs)) / max(max(abs(values)))
ans = 1.6809e15
The four methods return the same values, up to roundoff error.
Here is a plot of the error, i.e., the difference between the given data value and the value of the spline approximation at those data sites.
errors = z  spcol(knotsx,kx,x)*coefs*spcol(knotsy,ky,y).'; mesh(x,y,errors.'); xlabel('x'); ylabel('y'); view(150,50); title('Error at the Given Data Sites');
The relative error is
max(max(abs(errors))) / max(max(abs(z)))
ans = 0.0539
This is perhaps not too impressive. On the other hand, the ratio
(degrees of freedom used) / (number of data points)
is only
numel(coefs)/numel(z)
ans = 0.2909
Apparent Bias of This Approach
The approach followed here seems biased: We first think of the given data values z as describing a vectorvalued function of y, and then we treat the matrix formed by the vector coefficients of the approximating curve as describing a vectorvalued function of x.
What happens when we take things in the opposite order, i.e., think of z as describing a vectorvalued function of x, and then treat the matrix made up from the vector coefficients of the approximating curve as describing a vectorvalued function of y?
Perhaps surprisingly, the final approximation is the same, up to roundoff. The next section contains the numerical experiment confirming that.
Doing It the Other Way Around: Start With a Spline Space in X
First, we fit a spline curve to the data, but this time with x as the independent variable, hence it is the rows of z which now become the data values. Correspondingly, we must supply z.' (rather than z) to spap2, and obtain
spb = spap2(knotsx,kx,x,z.');
a spline approximation to all the curves (x,z(:,j)) for j=1:J. In particular,
valsb = fnval(spb,xv).';
creates a matrix whose (i,j)th element can be taken as an approximation to the value f(xv(i),y(j)) of the underlying function f at the grid point (xv(i),y(j)). This is evident when we plot valsb.
mesh(xv,y,valsb.'); xlabel('x'); ylabel('y'); view(150,50); title('Simultaneous Approximation to All Curves in the XDirection');
Again note the ridges, this time running along the xdirection. They confirm that, once again, we are plotting smooth curves in one direction only.
From Curves to a Surface: Using a Spline Space in the YDirection
Now comes the second step, to get the actual surface.
Let coefsx be the coefficients for spb, i.e.,
coefsx = fnbrk(spb,'c');
Abstractly, you can think of the spline spb as the vectorvalued function
x > sum coefsx(r,:) B_{r,kx}(x) r
with the jth entry coefsx(r,j) of the vector coefficient coefsx(r,:) corresponding to y(j), for all j. Thus, we now fit each curve (y,coefsx(r,:)) by a spline, using the same order ky and the same appropriate knot sequence knotsy for each r.
spb2 = spap2(knotsy,ky,y,coefsx.');
In the construction of spb2, we again need to transpose the coefficient matrix from spb, since spap2 takes the columns of its last input argument as the data values.
For this reason, there is now no need to transpose the coefficient matrix coefsb of the resulting "curve".
coefsb = fnbrk(spb2,'c');
Claim: coefsb equals the earlier coefficient array coefs, up to roundoff. For a proof of this, see the discussion of the tensor product construct in Curve Fitting Toolbox documentation. Here, we simply make the following check.
max(max(abs(coefs  coefsb)))
ans = 8.8818e16
Thus, the bivariate spline approximation
(x,y) > sum sum coefsb(q,r) B_{q,kx}(x) B_{r,ky}(y) q r
to the original data
(x(i),y(j)) > f(x(i),y(j)) = z(i,j)
obtained coincides with the earlier one, which generated coefs rather than coefsb.
As observed earlier, you can carry out the entire construction we just went through (in two ways), using just two statements, one for the construction of the leastsquares approximant, the other for its evaluation at a rectangular mesh.
tsp = spap2({knotsx,knotsy},[kx,ky],{x,y},z); valuet = fnval(tsp,{xv,yv});
Here, as another check, is the relative difference between the values computed earlier and those computed now:
max(max(abs(valuesvaluet))) / max(max(abs(values)))
ans = 5.6029e16
Another Example: Interpolation
Since the data come from a smooth function, we should be interpolating it, i.e., using spapi instead of spap2, or, equivalently, use spap2 with the appropriate knot sequences. For illustration, here is the same process done with spapi.
To recall, the (univariate) data sites were
x
x = Columns 1 through 7 0 0.0300 0.0700 0.1000 0.2000 0.3000 0.4000 Columns 8 through 14 0.5000 0.6000 0.7000 0.8000 0.9000 0.9300 0.9700 Column 15 1.0000
y
y = Columns 1 through 7 0 0.0300 0.0700 0.1667 0.3333 0.5000 0.6667 Columns 8 through 11 0.8333 0.9300 0.9700 1.0000
We use again quadratic splines in y, hence use knots midway between data sites.
knotsy = augknt( [0 1 (y(2:(end2))+y(3:(end1)))/2 ], ky);
spi = spapi(knotsy,y,z);
coefsy = fnbrk(spi,'c');
Interpolation of Resulting Coefficients
We use again cubic splines in x, and use the notaknot condition. We therefore use all but the second and the secondtolast data points as knots.
knotsx = augknt(x([1,3:(end2),end]), kx);
spi2 = spapi(knotsx,x,coefsy.');
icoefs = fnbrk(spi2,'c').';
We are now ready to evaluate the interpolant
ivalues = spcol(knotsx,kx,xv)*icoefs*spcol(knotsy,ky,yv).';
and plot the interpolant at a fine mesh.
mesh(xv,yv,ivalues.'); xlabel('x'); ylabel('y'); view(150,50); title('The Spline Interpolant');
Again, the steps above can be carried out using just two statements, one for the construction of the interpolant, the other for its evaluation at a rectangular mesh.
tsp = spapi({knotsx,knotsy},{x,y},z); valuet = fnval(tsp,{xv,yv});
For a check, we also compute the relative difference between the values computed earlier and those computed now.
max(max(abs(ivaluesvaluet))) / max(max(abs(ivalues)))
ans = 5.5068e16
Next, we compute the error of the interpolant as an approximation to the Franke function.
fvalues = franke(repmat(xv.',1,length(yv)),repmat(yv,length(xv),1)); error = fvalues  ivalues; mesh(xv,yv,error.'); xlabel('x'); ylabel('y'); view(150,50); title('Interpolation error');
The relative approximation error is
max(max(abs(error))) / max(max(abs(fvalues)))
ans = 0.0409