Why 2 vectors are not the same in matlab?

Click For Summary

Discussion Overview

The discussion revolves around the issue of comparing two vectors in MATLAB that appear similar but yield different results when checked for equality. Participants explore the implications of floating-point arithmetic and rounding errors in numerical computations.

Discussion Character

  • Technical explanation
  • Debate/contested
  • Mathematical reasoning

Main Points Raised

  • Some participants note that the vectors a and b seem similar visually but return different logical arrays when compared using the equality operator.
  • One participant suggests that rounding errors may be the cause of the discrepancy and proposes checking the actual values of vector a after multiplication.
  • Another participant mentions that floating-point arithmetic can lead to slight differences in stored values, which could explain why a might not equal b.
  • There is a suggestion to shift the values instead of multiplying to achieve the expected result, with one participant confirming that this method yields the desired output.
  • Some participants express confusion regarding the representation of very small numbers in MATLAB and question the existence of even smaller values (in pico or nano ranges).
  • A suggestion is made to use a tolerance when comparing floating-point numbers to avoid issues with direct equality checks.

Areas of Agreement / Disagreement

Participants generally agree that floating-point arithmetic can lead to unexpected results in comparisons, but there is no consensus on the best method to address the issue or the implications of very small numbers in MATLAB.

Contextual Notes

Participants mention limitations related to the representation of floating-point numbers and the potential for rounding errors, but do not resolve these issues or provide definitive solutions.

Nate Duong
Messages
125
Reaction score
4
I have 2 vectors:

a = 1.0e-04*[0.110000000000000 0.140000000000000 0.140000000000000 0.140000000000000];
b = [0.000011000000000 0.000014000000000 0.000014000000000 0.000014000000000];


by look at by eyes, it seems similar; but when I use this command:

a == b

then I got:

ans =
1×4 logical array
0 0 0 0


The expectation is:

ans =
1×4 logical array
1 1 1 1


Does anyone knows what wrong with this command in the matlab?

Thank you.
 
Physics news on Phys.org
Nate Duong said:
I have 2 vectors:

a = 1.0e-04*[0.110000000000000 0.140000000000000 0.140000000000000 0.140000000000000];
b = [0.000011000000000 0.000014000000000 0.000014000000000 0.000014000000000];


by look at by eyes, it seems similar; but when I use this command:

a == b

then I got:

ans =
1×4 logical array
0 0 0 0


The expectation is:

ans =
1×4 logical array
1 1 1 1


Does anyone knows what wrong with this command in the matlab?

Thank you.
Rounding error? What happens if you show the values of the a vector after the multiplication is done? Can you try a shift right by 4 places instead of using the multiplication?
 
  • Like
Likes   Reactions: Mark44
Nate Duong said:
I have 2 vectors:

a = 1.0e-04*[0.110000000000000 0.140000000000000 0.140000000000000 0.140000000000000];
b = [0.000011000000000 0.000014000000000 0.000014000000000 0.000014000000000];


by look at by eyes, it seems similar; but when I use this command:

a == b

then I got:

ans =
1×4 logical array
0 0 0 0


The expectation is:

ans =
1×4 logical array
1 1 1 1


Does anyone knows what wrong with this command in the matlab?

Thank you.
It's possible that after multiplying each element of a by 10^(-4), what is actually stored in a is slightly different from the numbers stored in b. For example, the first element of a might be something like 0.000011000000002 .
Floating point arithmetic is notorious in this way. Some decimal value are stored exactly, such as 2.5, .75, but others, such as 0.1 are stored in only an approximate form.
 
  • Like
Likes   Reactions: Nate Duong and berkeman
berkeman said:
Rounding error? What happens if you show the values of the a vector after the multiplication is done? Can you try a shift right by 4 places instead of using the multiplication?
@berkeman: if I shift right by 4 places instead of using the multiplication, I will have what I want, that is vector [1 1 1 1], that is no surprise, but the thing I am working on is very small number (in nano values 1e-9) and sometime MATLAB gives me a vector, example: a = 1.0e-04*[ 1 1 1 1] and sometimes a = [0.0001000000 , 0.0001000000, 0.0001000000, 0.0001000000] , that make me confuse and also think about very small numbers are exist (maybe in pico)
 
Mark44 said:
It's possible that after multiplying each element of a by 10^(-4), what is actually stored in a is slightly different from the numbers stored in b. For example, the first element of a might be something like 0.000011000000002 .
Floating point arithmetic is notorious in this way. Some decimal value are stored exactly, such as 2.5, .75, but others, such as 0.1 are stored in only an approximate form.
@Mark44: that could be, i am happy if some very small decimal number exist (my expectation in nano or pico values) but is there any way to detect them (if they are exist), even I used command format long and still do not see any change.
 
try:
Code:
>> a - b

Also, the MATLAB documentation suggests (under 'eq, ==') a way that avoids the problem when trying to compare floating point numbers:
Compare floating-point numbers using a tolerance, tol , instead of using ==.
Code:
tol = eps(0.5)
abs(C-0) < tol
 
  • Like
Likes   Reactions: berkeman

Similar threads

  • · Replies 4 ·
Replies
4
Views
2K
  • · Replies 4 ·
Replies
4
Views
4K
  • · Replies 4 ·
Replies
4
Views
6K
  • · Replies 5 ·
Replies
5
Views
4K
  • · Replies 4 ·
Replies
4
Views
3K
  • · Replies 2 ·
Replies
2
Views
3K
  • · Replies 1 ·
Replies
1
Views
3K
  • · Replies 5 ·
Replies
5
Views
3K
  • · Replies 10 ·
Replies
10
Views
3K
  • · Replies 2 ·
Replies
2
Views
2K