# Signed zeros: is this a bug?

Paul Rubin http
Mon Mar 12 00:21:38 CET 2007

```"Paddy" <paddy3118 at googlemail.com> writes:
> > Most machines these days use IEEE 754 which supports negative zero.
> > http://en.wikipedia.org/wiki/Negative_zero
>
> Isn't negative zero mathematically the same as zero? Isn't -0 just an
> artefact of the representation of floating point numbers? Shouldn't
> f(0) == f(-0) for all functions f?

Not sure what you mean.  "Floating point numbers" and in particular
"IEEE 754 floating point numbers" are a set of values and operations
with particular characteristics, that computers happen to implement.
They are not the same thing as the mathematical real numbers.  For
example, there are infinitely many real numbers, but there are only
finitely many 64-bit IEEE floating point numbers (at most 2**64 of
them).  They don't satisfy the same algebraic laws as real numbers.
For example, (1e100 + 1) == 1e100, and as a consequence, (1e100 + 1) -
1e100 == 0, but (1e100 - 1e100) + 1 == 1, so the commutative addition
law doesn't hold.  These are all part of a mesh of interlocking
compromises made in floating point computer arithmetic to approximate
real-number arithmetic with finite-precision values.  At first (i.e.
from the early computer era through the 1970's or so) this stuff was
designed somewhat ad hoc by computer architects, but eventually
serious numerical mathemticians got into the act, figuring out how to
make the best possible choices of these compromises for numerical
computation.  The result was IEEE 754, which resulted in Prof. Kahan
winning the Turing award in 1989.

IEEE 754 specifies that -0 and +0 are separate numbers.  Yes it is an
artifact in the sense of being one of the compromises.  But these
compromises all interact with each other to make the errors cancel in
various numerical algorithms.  The existence of -0 in IEEE 754 is part
of an intricate framework designed very carefully over a long period
by extremely experienced and knowledgeable people who knew what they
were doing.  It's not really wise to mess with it unless you're
planning to undertake a project to redesign computer arithmetic of
similar scope to the IEEE 754 effort.

> Getting back to Python, shouldn't we strive to remove any distinction?
> a zero is a zero regardless of sign and a function like atan returning
> one of two different vaues for an argument of zero is actually
> mathematically not a bad thing to do?

No.  Floating point numbers are not the same as real numbers and they
don't satisfy the same laws.  There have been some proposals
(rejected) for Python to support exact rational arithmetic in addition
to floating point and exact integer arithmetic.  Exact rationals in
Python (if implemented) should behave like mathematical rationals.
But Python floating point arithmetic should follow IEEE 754, at least
when the hardware supports it, which these days is almost always.

```