Matlab round the values and find function can not give the exact result(index)?!

I have a 2D array of size 10767*10136 from lat/long which means the values are unique. One pixel value of this array is -69.723897531281570 if I look for -69.723897 the result would more than one value. I used this expression format longE to consider the actual values, the outcome would be the same as before.

Also, I tried some inventory techniques to multiply 2D array and x value by 1000000 to eliminate the incapability of Matlab in processing a large array with high accuracy, but not reliable results?! Is there a solution to this problem?!

format longE
field2 = ncread(filenames,'lat') ;  % to read 2D array data 
x = -69.723897; % value that I am searching for
round_field2 = round(field2,6 );    % I am rounding to find the exact value and eliminationg the long deciaml value -69.723897531281570
use_minus_method = round_field2 - x;  % to find the 0 value that sould be one just one 0
[ idx , idm] = find(use_minus_method == 0 );

% % % the other technique 
x = -69.723897; % value that I am searching for
round_field2 = round(field2,6 );    % I am rounding to find the exact value and eliminationg the long deciaml value -69.723897531281570
format longE   % also I tried in this place
[ idx , idm] = find(round_field2 == x ); % directly finding x

% % % the other technique 
x = -69.723897; % value that I am searching for
x = string(x);  % create string
round_field2 = round(field2,6 );    % I am rounding to find the exact value and eliminationg the long deciaml value -69.723897531281570
round_field_string = string(round_field2); % create string
[ idx , idm] = find(contains(round_field_string,x)); %find x using the contain method

[Stephen23]

"...to eliminate the incapability of Matlab in processing a large array with high accuracy..."

MATLAB uses exactly the same binary floating point numbers that almost every other numeric application uses, because they are supported by all modern computer HW and important linear algebra libraries, enabling fast and efficient numeric operations. Their accuracy is around 15-17 decimal digits, which is on par with the most precisely measured quantities in all of physics, e.g.:

https://en.wikipedia.org/wiki/G-factor_(physics)#Measured_g-factor_values

Apparently this precision is inadequate for your data, for which I am deeply impressed, as this means that your experimental data are more accurately measured than every other measurement in all of human history. How did you achieve this remarkable feat?

Answer 1

[Stephen23]

"I used this expression format longE to consider the actual values"

format longE does not show the "actual values", it just shows the values with fifteen digits after the decimal place (for doubles). If you really want to see the "actual values" then download this:

https://www.mathworks.com/matlabcentral/fileexchange/22239-num2strexact-exact-version-of-num2str

Neither rounding nor converting to string will resolve the cause of your difficulties. The actual solution is to not to measure for exact equivalence, but instead compare the absolute difference against a tolerance:

abs(A-B)<tol

For example:

V = [-69.72389752,-69.723897531281570,-69.72389754];
x = -69.72389753;
tol = 5e-9;
idx = abs(V-x)<tol

idx = 1x3 logical array
   0   1   0

Read more about 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

[FSh]

Thank you for your response, it works well for such a small dataset. The fact is that all of the pixels in the 2D array consist of 15 digits after the decimal place. So modifying your suggested code as below, still results in fifty 1s as matched values. Is it possible to effectively assign a tolerance for that?! Or I misunderstood some part of your code?

V = [-69.722709655761720,-69.723021184353730,-69.723332712945730;
    -69.722524784485300,-69.722836310588580,-69.723147836691850];
x = -69.723021;
tol = 1e-6;
idx = abs(V-x)<tol
[xn,xm]= find(idx==1);

[Stephen23]

Your tolerance is too large. A good starting tolerance is half of the last digit that you want to match:

V = [-69.722709655761720,-69.723021184353730,-69.723332712945730;
    -69.722524784485300,-69.722836310588580,-69.723147836691850];
x = -69.723021;
tol = 5e-7;
idx = abs(V-x)<tol

idx = 2x3 logical array
   0   1   0
   0   0   0

"The fact is that all of the pixels in the 2D array consist of 15 digits after the decimal place"

This does not mean that those digits contain meaningful information.

[FSh]

So many thanks I learned from you.

However, I could not solve the problem as the problem might be in (V-x) that results in several possible options.

[Stephen23]

@FSh: if you want further assistance please upload the variables V and x in a mat file by clicking the paperclip button.

[FSh]

Unfortunately, my file is so bulky that I can not attach it here. However, in case you think you can help me the link to the folder is https://www.amazon.de/clouddrive/share/tp4XUVBYR1pjNOyvGEVbqAJgPzIdOLmRCXlzqGqP5hs

So many thanks in any way

[Stephen23]

Most likely you will have to experiment with the required tolerance. To start it might help to get a sorted list of the differences using that data set, from which you can decide what it means for those values to be considered different (or not).

[FSh]

Thank you