CODEWITHSUNDEEP
c
james
james

Reputation: 221

Double value as a negative zero

I have a program example:

int main()
{
    double x;
    x=-0.000000;
    if(x<0)
    {
        printf("x is less");
    }
    else 
    {
        printf("x is greater");
    }
}

Why does the control goes in the first statement - x is less . What is -0.000000?

Upvotes: 2

Views: 1946

Answers (3)

Artur
Artur

Reputation: 7267

Nathan is right but there is one issue though. Usually most of float/double operations are performed by coprocessor. However some compilers try to be clever and instead of letting coprocessor do the comparison (it treats -0.0 and +0.0 the same as 0.0) just assume that since your x variable has minus sign it means that it should be treated as negative and optimize your code.

If you would be able to see how assembly output looks like - I bet you'll only see call to:

printf("x is less");

So it is optimization stuff (bad optimization).

BTW - VC 2008 produces correct output here regardless of optimization level set.

For example - VC optimizes (at full/max optimization level) the code leaving this only:

printf("x is grater");

I like my compiler more every day ;-)

Upvotes: 2

Nathan Fellman
Nathan Fellman

Reputation: 127538

IEEE 754 defines a standard floating point numbers, which is very commonly used. You can see its structure here:

Finite numbers, which may be either base 2 (binary) or base 10 (decimal). Each finite number is described by three integers: s = a sign (zero or one), c = a significand (or 'coefficient'), q = an exponent. The numerical value of a finite number is

  (−1)^s × c × bq

where b is the base (2 or 10). For example, if the sign is 1 (indicating negative), the significand is 12345, the exponent is −3, and the base is 10, then the value of the number is −12.345.

Double FP number

So if the fraction is 0, and the sign is 0, you have +0.0.
And if the fraction is 0, and the sign is 1, you have -0.0.

The numbers have the same value, but they differ in the positive/negative check. This means, for instance, that if:

x = +0.0;
y = -0.0;

Then you should see:

(x -y) == 0

However, for x, the OP's code would go with "x is greater", while for y, it would go with "x is less".

Edit: Artur's answer and Jeffrey Sax's comment to this answer clarify that the difference in the test for x < 0 in the OP's question is actually a compiler optimization, and that actually the test for x < 0 for both positive and negative 0 should always be false.

Upvotes: 9

Jeffrey Sax
Jeffrey Sax

Reputation: 10323

Negative zero is still zero, so +0 == -0 and -0 < +0 is false. They are two representations of the same value. There are only a few operations for which it makes a difference:

  1. 1 / -0 = -infinity, while 1 / +0 = +infinity.
  2. sqrt(-0) = -0, while sqrt(+0) = +0

Negative zero can be created in a few different ways:

  1. Dividing a positive number by -infinity, or a negative number by +infinity.
  2. An operation that produces an underflow on a negative number.

This may seem rather obscure, but there is a good reason for this, mainly to do with making mathematical expressions involving complex numbers consistent. For example, note that the identity 1/√(-z)==-1/√z is not correct unless you define the square root as I did above.

If you want to know more details, try and find William Kahan's Branch Cuts for Complex Elementary Functions, or Much Ado About Nothing's Sign Bit in The State of the Art in Numerical Analysis (1987).

Upvotes: 2

Related Questions