MATLAB: Atan2 not consisent

atan2binary floating pointieee-754mathMATLABnegative zeropositive zerosigned zerotangent

I have the following values that I run through the atan2 function:

a(77:78,:)
ans =
  -0.250000000000000                   0  -0.950000000000000
  -0.260000000000000                   0  -0.950000000000000

when I put the above array through the atan2 function, the first value is positive and the second is negative,

  atan2(a(77:78,2),a(77:78,3))
ans =
   3.141592653589793
  -3.141592653589793

If I type in each value of the second row of data by hand, the result is differnt for the atan2 function (it is positive):

  atan2(0,-0.95)
ans =
   3.141592653589793

If I build a test matrix, manually inputing the values, the atan2 results are both positive.

   test = [-0.25, 0 , -0.95; -0.26, 0 , -0.95]
test =
  -0.250000000000000                   0  -0.950000000000000
  -0.260000000000000                   0  -0.950000000000000
>> atan2(test(1,2),test(1,3))
ans =
   3.141592653589793
>> atan2(test(2,2),test(2,3))
ans =
   3.141592653589793

Question: Why are the values of atan2 function positive and negative in the first case but then both positive when I type out the values?

Aside: If done separately:

   atan2(a(77,2),a(77,3))
ans =
   3.141592653589793
>> atan2(a(78,2),a(78,3))
ans =
  -3.141592653589793

Thank you

Best Answer

The reason is a little arcane: negative zero:

https://en.wikipedia.org/wiki/Signed_zero

The other answers and comments are wrong: this has nothing to do with floating point error or "almost zero" values.

The second column values are exactly zero, and we know that the value is exactly zero because in both long and short format only the exact value zero is displayed as one single digit "0", just as all of your examples show.

So what is the catch?

The catch is simply the IEEE 754 defines two zeros, a positive zero and a negative zero. Same value, different signs. Some (but not all) operations retain the sign when operating on them.

One of your zeros is negative and one is positive, but unfortunately MATLAB** displays them without the sign:

Y = [0;-0] % positive and negative zero!
Y = 2×1
     0
     0
X = [-0.95;-0.95]; % these values are not really relevant
atan2(Y,X)
ans = 2×1
    3.1416
   -3.1416

Here is a useful trick to detect if a zero is positive or negative (simply displaying it doesn't work):

Y % they look the same ... but are they?
Y = 2×1
     0
     0
sign(1./Y) % no!
ans = 2×1
     1
    -1

Negative zeros can be generated by some arithmetic operations, or perhaps by converting data from text. If you want to remove negative zeros from an array without changing the sign of the other data, just add zero:

Z = [-0,-2,+0,3]
Z = 1×4
     0    -2     0     3
sign(1./Z)
ans = 1×4
    -1    -1     1     1
Z = 0+Z % remove negative zeros
Z = 1×4
     0    -2     0     3
sign(1./Z)
ans = 1×4
     1    -1     1     1

** for what it's worth, Octave does display the sign.

Related Solutions

MATLAB: 0.35 divide 0.001 return double, and 0.34 divide 0.001 return int.

MATLAB does not represent numbers with fractions in decimal (not even in the Symbolic toolbox, but you have to push hard to prove that for the Symbolic toolbox).

MATLAB itself represents most numbers in IEEE 754 Double Precision, which is a representation that uses one sign bit, 11 bits of binary exponent, and 52 bits of binary fraction. For technical reasons, this gives 53 bits of precision: numbers are effectively represented as a 53 bit integer times a power of 2 (that might be negative). The only fractions that can be exactly represented are those involving powers of 2. It is like having an unreduced fraction in which the denominator is always 2^53. Other denominators such as 10 are only possible if they are powers of 2: for example the system can exactly represent 16ths, but never 3rds or 10ths, not exactly.

This system has exactly the same variety of limitations that sticking strictly to a fixed number of decimal places would have. For example if you pick any fixed number of decimal places, you can never exactly represent 1/3 or 1/7, and instead those end up in decimal being infinite repeating decimals, just like how 1/3 in decimal starts 0.333333333333333 but continues on infinitely. Now in decimal, take that number and multiply it by 3 again, and what you get is 0.999999999999999 rather than exactly 1.

Just so, in binary, 1/10 is an infinite repeating number, and if you truncate it to any finite number of decimal places, and multiply by 10 you do not get exactly 1 back.

Now, with some multiples of 1/10 in binary, when you multiply by 10, the result rounds to the representation of an integer, but that is not the case for all multiples of 1/10 in finite binary: for some of them, after multiplication you get a number that is 1 bit different than an exact integer, just like the 0.99999999999999 is 1 trailing decimal place different from an exact decimal integer.

So 0.34/0.001 with both numbers expressed in finite binary approximation ends up rounding to an exact integer but 0.35/0.001 with both numbers expressed in finite binary approximation ends up rounding to one bit different from an exact integer.

The moral of the story is: Don't Do That!! Avoid using fractions to calculate integer indices, because fractions are only approximations.

Example: instead of

for f=0.01:0.01:1
  G(100*f)=f.^2;
end

You can use

for fi = 1:100
  f=fi/100;
  G(fi) = f.^2;
 end

MATLAB: Fprintf(‘%3.1f’,round(-eps)) prints -0.0

You are missing the fact that MATLAB has two zeros: positive zero and negative zero, which have different HEX values. This is a result of the IEEE 754 floating point standard that MATLAB implements, which uses one bit to indicate the number sign: a corollary of this is that even a zero can be positive or negative.

It is not possible to use < to directly test if zero is negative (by definition negative zero is equal to positive zero, so this makes sense):

 >> (-0)<0
 ans =
     0

but here is one simple trick that will test for negative zero:

 >> (1/-0)<0
 ans =
     1

Which relies on this behavior:

 >> 1/-0
 ans =
   -Inf
 >> 1/round(-eps) % your question
 ans =
   -Inf

Neat huh!

You can find more interesting information on negative zeros here:

https://en.wikipedia.org/wiki/Signed_zero

Best Answer

Related Solutions

MATLAB: 0.35 divide 0.001 return double, and 0.34 divide 0.001 return int.

MATLAB: Fprintf(‘%​3.1f’,roun​d(-eps)) prints -0.0

Related Question

MATLAB: Fprintf(‘%3.1f’,round(-eps)) prints -0.0