If I understand your question correctly, you are trying to solve an interpolation problem where the two dependent variables are given, and you wish to recover the values of three independent variables. If a solution exists, then it will generally be infinitely many solutions, i.e., a 1-manifold of solutions that lie in the R^3 domain space of this problem. Think of this as an iso-line. Is any point on this locus of solutions a valid solution?

As is often the case, my approach would depend on my goals. If a piecewise linear approximation to the 1-manifold was acceptable, then I might start with a triangulation of the R^3 domain set. Then slice through this twice to reduce that triangulation to a piecewise linear 1-manifold. Now I can do anything I want with that curve. It is quite nice for visualization purposes, and sometimes for other end uses. I would use a set of custom made tools for these slices that I have never gotten around to putting on the File Exchange.

If my goal is otherwise, I might apply fmincon (rather than Newton-Raphson, which cannot employ constraints) to solve for the closest point to my starting point, such that the dependent variables are properly interpolated (as a pair of nonlinear equality constraints.) Here my interpolation might use griddata or interp2, with a smooth method employed.

Let me know if I can be of further help, or if my understanding of your question was incorrect.

John

Is this a Simulink question I think? Your question is very confusing, so I am not sure how to respond. You need to work out what is your question. What are you trying to do here? I have said this many times before, but the most important part of solving a difficult problem is in simply stating the problem accurately.

Regardless of the environment you will use it in, let me talk briefly about lookup tables. A lookup table generally is defined by a list of points, an input and an output for each input. I’ll call the input x (the independent variable) and the output variable y. y is dependent upon x. Now, suppose we will use the lookup table. For a new value, call it X, we wish to determine an appropriate output value Y.

With one dimensional input, we must identify the pair of points in x that bound the new value X. Then use some scheme to predict a value for Y at that location. Some lookup tables will merely use nearest neighbor interpolation or a variant of it, or linear interpolation, or perhaps a cubic spline interplant. The choice of method would be up to you. But regardless, the table itself is fixed, dependent upon what data you supply. So if your data points represent a decreasing relationship, then so would your lookup table. (Note that some choice of interpolants will not always produce a monotone interpolant even for monotone data. This is why PCHIP was invented, and provided as part of interp1.)

So please try restating your problem.

Regards,
John

My concern was not entirely about the NaN on the inverse function, but also that the result of the forward transform did not guarantee that the output would be bounded by the limits of the reference points. Extrapolation only help to avoid the NaN in the inverse transformation.

I will give the code for a simple two multiplier interpolation (as in the main part of your blog).

function yi = IntLin (x, y, xi)
% Linear interpolation with a guarantee that if xi=x, then yi=y

[Nc, k] = histc (xi, x);
Nx = length (x);
k(k==Nx) = Nx - 1;

t = (xi - x(k)) ./ (x(k+1) - x(k));
yi = (1-t) .* y(k) + t .* y(k+1);

For the following, let us assume xi is scalar
1. The histc function and the subsequent fix-up below it will guarantee that xi lies between x(k) and x(k+1) (inclusive).
2. This guarantees that xi-x(k) is zero or greater. Further any reasonable floating point implementation will give xi-x(k) as a non-decreasing function of xi.
3. The largest value of the numerator in the calculation of t is x(k+1)-x(k).
4. Any reasonable implementation of floating point operations will guarantee that t = (xi-x(k)) / (x(k+1)-x(k)) will lie between 0 and 1 (inclusive) and that t will be a non-decreasing function of xi.
5. Floating point systems (IEEE 754 in particular) can represent integers exactly. Then when t=0 or t=1, (1-t) will be exactly 1 or zero.
6. Certainly when xi hits the limits we will have 0 times one value + 1 times another value, giving the correct results at the end points.

The two multiplier version will handle the end points correctly. I cannot at the moment see a way to argue that yi using the two multiplier version changes monotonically as xi goes from x(k) to x(k+1). The one multiplier version (yi = y(k) + (y(k+1)-y(k))*t) is a monotonic function of t, but has the possibility of going beyond the upper bound.

As a side note: one can see that the authors of linspace realized there was a problem with the boundary value. The routine generates the first N-1 points using a formula similar to the one multiplier version of the interpolation formula. The last point boundary point is appended separately.

No. Sorry, but no. There is no assurance that simply rewriting the equation for yi in this form will solve your problem. In fact, the problem will surely arise again if you do. The problem is that MATLAB does its arithmetic in a binary floating point arithmetic (true for almost all computational platforms.) Most decimal numbers cannot be exactly represented in floating point arithmetic. One way to convince yourself of that is to look at the hex representation of some simple numbers.

format hex
0.1
ans =
   3fb999999999999a

0.2
ans =
   3fc999999999999a

0.3
ans =
   3fd3333333333333

0.4
ans =
   3fd999999999999a

0.5
ans =
   3fe0000000000000

0.6
ans =
   3fe3333333333333

0.7
ans =
   3fe6666666666666

0.8
ans =
   3fe999999999999a

0.9
ans =
   3feccccccccccccd

As it turns out, only 0.5 was exactly represented as a binary floating point number. All of the other members of this sequence were off by a bit or so in the least significant bit. This happens because a number like 0.1 has no representation in a finite number of bits in a binary form.

So you should NEVER test floating point numbers that are the result of any numerical computation like this for exact equality. Never assume the least significant bit of your result is known exactly.

That the point is returned as a NaN happens because of these errors in the LSB. Make this comparison instead:

xi = interp1(y, x, yi)
xi =
                         0                    0.0275                       NaN

xi = interp1(y, x, yi,[],'extrap')
xi =
                         0                    0.0275                      0.08

See that when I allow interp1 to extrapolate outside the interval, there is no longer a problem. It only had to extrapolate by a bit or so in the LSB, but that was enough.

See topic 6.1 in the MATLAB FAQ for more discussion of this, or the newsgroup for infinitely many discussions on this and similar topics.

http://matlabwiki.mathworks.com/MATLAB_FAQ

This behaviour breaks some code of mine. I have a simple piecewise linear mapping. Some processing occurs on the mapped data, and then the inverse mapping is done. The inverse mapping is easily implemented by swapping x and y.
Consider the following code where the forward mapping values are passed back into the inverse mapping (i.e. no modification happens). The value of y2 is a “magic” value which causes problems.

x = [0 0.0275 0.08];
y2 = 0.016603773584906 - 3.400058012914542e-016;
y = [0 y2 0.08];

xi = x;

% Forward mapping
yi = interp1(x, y, xi)
yi - y   % not zero for the last point

% Inverse mapping, returns an NaN for the last point
xi = interp1(y, x, yi)

Running this snippet of code will show that xi contains an NaN. Tracking down the problem shows that interp1q uses a one multiplier version of linear interpolation. In summary form for a scalar xi,

  yi = yleft + (yright-yleft)*u

For the case of the values in the earlier example, u=1 for the last value of xi, but numerical errors cause the result not to be equal to yright. A two multiplier version of linear interpolation would solve the problem.

  yi = (1-u)*yleft + u*yright

Looks like I will have to implement a two multipler version of linear interpolation to avoid the problem!

I would like to use simplicial and multilinear interpolation schemes for multivariate interpolation of general functions with complex values depending from more real variables.

Thanks

Best regards,

Alex

It might be easier to just pump me for knowledge, having already done everything possible with each of these methods.

I assume that you wish to use these methods for color lookup table interpolation? In how many dimensions? What size tables? What types of tables?

Yes, interpn is the only tool in matlab. It will do n-d linear, or if you prefer, tensor product linear interpolation.

A simplicial interpolant is easy enough to write. Almost trivial. (John says this with a mischievous grin on his face.) There are a few tricks to make it easier. So what is your goal in this investigation of yours?

John

I am really interested in simplicial and multilinear interpolation (so N-dimensional interpolation by these two schemes), I would like to use and compare them in Matlab. Is there a built-in function in Matlab for simplicial interpolation in N-dimension?If not, how can I implement it in Matlab?Interpn in Matlab I guess is only for multilinear interpolation.

Thanks

Best regards,

Alex