Can anyone help for a valid interpolation of an angle from -0.2 to 0.2 to give 1001 points in between? SLERP is not doing this range for me ?
Thank you
MATLAB: Interpolating angle between -0.2 to 0.2 rad
angleinterpolation
Related Solutions
The answer arises by understanding how floating point numbers are stored in MATLAB.
Here are 0.3, 0.1, 0.2, expressed each as what I might call binary fractional numbers. I've written the bit sequences for the numbers as strings of 0 and 1 bits.
0.3: '0.010011001100110011001100110011001100110011001100110011'
0.1: '0.00011001100110011001100110011001100110011001100110011010'
0.2: '0.0011001100110011001100110011001100110011001100110011010'
In all cases, these numbers are truly repeating binary sequences. The binary form for these fractions extends to infinitely many bits, just as we cannot represent the fraction 2/3 exactly as a decimal number. But remember that a double can store only 52 bits of information.
(Those results were produced by a little toy I wrote some years ago, num2bin. I've attached num2bin to this answer for those who are interested.)
num2bin(0.3)ans = struct with fields: Class: 'double' Sign: 1 Exponent: -2 Mantissa: '10011001100110011001100110011001100110011001100110011' BinaryExpansion: [1×27 double] BiSci: '1.0011001100110011001100110011001100110011001100110011 B-2' BiCimal: '0.010011001100110011001100110011001100110011001100110011'We can write any floating point number in MATLAB as a sum of positive and negative powers of 2. Thus here, we see
BE = num2bin(0.3).BinaryExpansionBE = Columns 1 through 21 -2 -5 -6 -9 -10 -13 -14 -17 -18 -21 -22 -25 -26 -29 -30 -33 -34 -37 -38 -41 -42 Columns 22 through 27 -45 -46 -49 -50 -53 -54Those are the powers of 2 that we use to represent the decimal fraction 3/10 = 0.3. We can even reconstruct the original number from those powers of 2.
sum(2.^BE)ans = 0.3 sum(2.^BE) == 0.3ans = logical 1I'll use num2bin to see what happens in depth to the numbers in these similar computations? Why do they produce different results?
[0.3 - 0.1 - 0.2, -0.1 - 0.2 + 0.3]ans = -2.77555756156289e-17 -5.55111512312578e-17Look carefully at what happens. In the former case, we can write it as
(0.3 - 0.1) - 0.2
So we first compute 0.3 - 0.1. That result is stored temporarily, as a
double in some temporary register by MATLAB. And THEN we subtract 0.2. The intermediate result, 0.3 - 0.1 is stored internally as the binary number:
'0.0011001100110011001100110011001100110011001100110011001'
Compare that result to 0.2 alone, which is stored as
'0.0011001100110011001100110011001100110011001100110011010'
Can you see the bit sequences are subtly different at the end, in the least significant bits? The difference arises because we can store only 52 binary bits in the result. When we now subtract 0.2 from the intermediate result, thus forming
(0.3 - 0.1) - 0.2
the result ends up as effectively
2^-55 - 2^-54 = -2^-55
And what is 2^-55? (2^-55 is actually stored properly as a double, since it is an exact power of 2.)
-2^-55ans = -2.77555756156289e-17 0.3 - 0.1 - 0.2ans = -2.77555756156289e-17Of course we know that real mathematics would produce a true zero, but numbers stored in floating point form are often not the numbers we think are stored. They are only approximations thereof.
What changes when we change the sequence of the elements in that computation? Now consider the expression:
-0.1 -0.2 + 0.3ans = -5.55111512312578e-17Again, the result should mathematically be zero, but just as alarmingly to new users, the result is different from the previous one. Again, we can break this down into two subproblems. We perform the first computation as (-0.1 - 0.2), and THEN we will add 0.3.
-0.1 -0.2 + 0.3ans = -5.55111512312578e-17 num2bin(-0.1 - 0.2 + 0.3).BinaryExpansionans = -54 -2^-54ans = -5.55111512312578e-17So we see the two computations, performed in a subtly different sequence, result in different answers. It is not always true that we have a difference. For example, we find that
(0.2 + 0.3 - 0.4) == (-0.4 + 0.2 + 0.3)ans = logical 1and
-4/7 + 1/7 + 3/7 == 1/7 - 4/7 + 3/7ans = logical 1So two results that did produce the expected answer. And then, we find this:
12/13 - 3/13 - 9/13 == 12/13 - 9/13 - 3/13ans = logical 0The point is to never trust the least significant bits of a computation. At least, not until you understand those computations well enough to know when not to trust them. And even then? Be careful, be very careful.
One approach:
x0=0; x1=5; g0=0; g1=0;y0= 0; y1= 150;A1 = [x0^3,x0^2,x0,1; 3*x0^2,2*x0,1,0; x1^3,x1^2,x1,1; 3*x1^2,2*x1,1,0]; C1 = A1\[y0,g0,y1,g1]'; % Solve for the four cubic Hermite coefficients
n = 1000;X1 = linspace(x0,x1,n);Y1 = C1'*[X1.^3;X1.^2;X1;ones(1,n)];% second segment
x2=10; y2= 0; g1= 0; g2=0;A2 = [x1^3,x1^2,x1,1; 3*x1^2,2*x1,1,0; x2^3,x2^2,x2,1; 3*x2^2,2*x2,1,0]; C2 = A2\[y1,g1,y2,g2]';X2 = linspace(x1,x2,n);Y2 = C2'*[X2.^3;X2.^2;X2;ones(1,n)];dY1 = gradient(Y1, X1(2)-X1(1)); % Calculate Gradient
[Y1max,idxY1(1)] = max(dY1);[Y1min,idxY1(2)] = min(dY1);dY2 = gradient(Y2, X2(2)-X2(1)); % Calculate Gradient[Y2max,idxY2(1)] = max(dY2);[Y2min,idxY2(2)] = min(dY2);plot(X1,Y1)hold onplot(X2,Y2)plot(X1(idxY1(1)), Y1(idxY1(1)), '^')plot(X1(idxY1(2)), Y1(idxY1(2)), 'v')plot(X2(idxY2(1)), Y2(idxY2(1)), '^')plot(X2(idxY2(2)), Y2(idxY2(2)), 'v')hold offtitle('cubic hermite')xlabel('x')ylabel('y');This uses the gradient (link) function to calculate the numerical derivative of the vectors, then finds the maxima and minima.
Experiment to get the result you want.
Best Answer