1×0 empty double row vector using find

Hi, I have problem with this code:

clc; clear; close all
x=[0 0.1 0.2 0.3 0.4 0.5];
y=[1 7 4 3 5 2];
h=0.1;

n=(max(x)-min(x))/h

suma=0;

for i=2:n
    aux=h*(i-1)
    [row,col] = find(x==aux)
    suma=suma+y(col);
end

when I run the for cicle and aux is equal to 0.3, the result of find is "1×0 empty double row vector", but there is a 0.3 in x. I'm really confused about this, someone can help me, please?

Thanks in advance.

[Stephen23]

"I'm really confused about this, someone can help me, please?"

This is a completely expected result with binary floating point numbers:

https://www.mathworks.com/matlabcentral/answers/57444-faq-why-is-0-3-0-2-0-1-not-equal-to-zero

https://www.mathworks.com/matlabcentral/answers/316889-why-two-equal-numbers-are-not-equal

http://www.mathworks.com/matlabcentral/answers/102419-how-do-i-determine-if-the-error-in-my-answer-is-the-result-of-round-off-error-or-a-bug

http://www.mathworks.com/matlabcentral/answers/140656-about-numerical-difficulty-of-equality-comparison-operation-between-two-double-real-numbers-in-matlab

This is worth reading as well:

https://docs.oracle.com/cd/E19957-01/806-3568/ncg_goldberg.html

http://faculty.tarleton.edu/agapie/documents/cs_343_arch/papers/1991_Goldberg_FloatingPoint.pdf

[Adam Danz]

Nice list of references @Stephen23. The last link is broke but I think it points to this paper

https://pages.cs.wisc.edu/~david/courses/cs552/S12/handouts/goldberg-floating-point.pdf

I'll add this one

https://0.30000000000000004.com/

Answer 1

[James Tursa]

Welcome to the world of floating point arithmetic. For your specific example, they are not equal. E.g.,

x=[0 0.1 0.2 0.3 0.4 0.5];
h=0.1;
i = 4;
aux=h*(i-1);
[row,col] = find(x==aux)

row =

  1×0 empty double row vector


col =

  1×0 empty double row vector

fprintf('%20.18f\n',x(4))

0.299999999999999989

fprintf('%20.18f\n',aux)

0.300000000000000044

isequal(0.3,3*0.1)

ans = logical
   0

You can see that these numbers are close but not exactly equal. They differ by one least significant bit in the floating point bit pattern:

num2hex(0.3)

ans = '3fd3333333333333'

num2hex(3*0.1)

ans = '3fd3333333333334'

To understand why you get this difference between 0.3 and 3*0.1, see this link:

https://www.mathworks.com/matlabcentral/answers/703427-why-is-0-3-0-1-0-2-0-1-0-2-0-3?s_tid=srchtitle

It is usually bad practice to test for exact equality when floating point arithmetic is involved. Your code needs to be written to account for these small differences.

Answer 2

[VBBV]

clc; clear; close all
x=[0 0.1 0.2 0.3 0.4 0.5];
y=[1 7 4 3 5 2];
h=0.1;
n=(max(x)-min(x))/h

n = 5

suma=0;
for i=2:n
    aux=h*(i-1)
    [row,col] = find((x==round(aux,1)))
    suma=suma+y(col);
end

aux = 0.1000

row = 1

col = 2

aux = 0.2000

row = 1

col = 3

aux = 0.3000

row = 1

col = 4

aux = 0.4000

row = 1

col = 5

[VBBV]

Its due to double precision floatpoint operation on vectors, You can use round function to compare the values upto single digit only, In double precision float operations, the values are computed for large number of decimal places which when compared do not become equal sometimes. Hence it returns the empty row vector in such cases.

[John D'Errico]

Be careful with rounding decimals. Even then, you do not get exactly what you think you get. For example,

x = 0.3;
sprintf('%0.55f',x)

ans = '0.2999999999999999888977697537484345957636833190917968750'

y = round(x,1);
sprintf('%0.55f',y)

ans = '0.2999999999999999888977697537484345957636833190917968750'

0.3 is not exactly representable in floating point arithmetic, and rounding will not change that fact.

[VBBV]

round function will output the same what we expect based on the number of input decimal precision given to the function. However, sprintf is different thing, which again displays outputs based on the input precision specified in the function

x = 0.3;
sprintf('%0.55f',x)

ans = '0.2999999999999999888977697537484345957636833190917968750'

y = round(x,1)

y = 0.3000

% round while displaying 
sprintf('%0.9f',y)

ans = '0.300000000'

0.3 is not exactly representable in floating point arithmetic, and rounding will not change that fact.

Then what is the purpose of round function ?