Signed zero

Binary integer formats can use various encodings. In the widely used two's complement encoding, zero is unsigned. In a 1+7-bit sign-and-magnitude representation for integers, negative zero is represented by the bit string 10000000. In an 8-bit ones' complement representation, negative zero is represented by the bit string 11111111. In all these three encodings, positive or unsigned zero is represented by 00000000. However, the latter two encodings (with a signed zero) are uncommon for integer formats. The most common formats with a signed zero are floating-point formats (IEEE 754 formats or similar), described below.

 

In IEEE 754 binary floating-point formats, zero values are represented by the biased exponent and significand both being zero. Negative zero has the sign bit set to one. One may obtain negative zero as the result of certain computations, for instance as the result of arithmetic underflow on a negative number (other results may also be possible), or −1.0×0.0, or simply as −0.0.

In IEEE 754 decimal floating-point formats, a negative zero is represented by an exponent being any valid exponent in the range for the format, the true significand being zero, and the sign bit being one.

The IEEE 754 floating-point standard specifies the behavior of positive zero and negative zero under various operations. The outcome may depend on the current IEEE rounding mode settings.

In systems that include both signed and unsigned zeros, the notation ${\displaystyle 0^{+}}$  and ${\displaystyle 0^{-}}$  is sometimes used for signed zeros.

Addition and multiplication are commutative, but there are some special rules that have to be followed, which mean the usual mathematical rules for algebraic simplification may not apply. The ${\displaystyle =}$  sign below shows the obtained floating-point results (it is not the usual equality operator).

The usual rule for signs is always followed when multiplying or dividing:

• ${\displaystyle (-0)\cdot \left|x\right|=-0\,\!}$  (for ${\displaystyle x}$  different from ±∞)
• ${\displaystyle {\frac {-0}{\left|x\right|}}=-0\,\!}$  (for ${\displaystyle x}$  different from 0)
• ${\displaystyle (-0)\cdot (-0)=+0\,\!}$ 

There are special rules for adding or subtracting signed zero:

• ${\displaystyle x+(\pm 0)=x\,\!}$  (for ${\displaystyle x}$  different from 0)
• ${\displaystyle (-0)+(-0)=(-0)-(+0)=-0\,\!}$ 
• ${\displaystyle (+0)+(+0)=(+0)-(-0)=+0\,\!}$ 
• ${\displaystyle x-x=x+(-x)=+0\,\!}$  (for any finite ${\displaystyle x}$ , −0 when rounding toward negative)

Because of negative zero (and also when the rounding mode is upward or downward), the expressions −(x − y) and (−x) − (−y), for floating-point variables x and y, cannot be replaced by y − x. However (−0) + x can be replaced by x with rounding to nearest (except when x can be a signaling NaN).

Some other special rules:

• ${\displaystyle \left|-0\right|=+0\,\!}$ 
• ${\displaystyle {\sqrt {-0}}=-0\,\!}$ ^[3]
• ${\displaystyle {\frac {-0}{-\infty }}=+0\,\!}$  (follows the sign rule for division)
• ${\displaystyle {\frac {\left|x\right|}{-0}}=-\infty \,\!}$  (for non-zero ${\displaystyle x}$ , follows the sign rule for division)
• ${\displaystyle {\pm 0}\times {\pm \infty }={\mbox{NaN}}\,\!}$  (Not a Number or interrupt for indeterminate form)
• ${\displaystyle {\frac {\pm 0}{\pm 0}}={\mbox{NaN}}\,\!}$ 

Division of a non-zero number by zero sets the divide by zero flag, and an operation producing a NaN sets the invalid operation flag. An exception handler is called if enabled for the corresponding flag.

According to the IEEE 754 standard, negative zero and positive zero should compare as equal with the usual (numerical) comparison operators, like the == operators of C and Java. In those languages, special programming tricks may be needed to distinguish the two values:

• Type punning the number to an integer type, so as to look at the sign bit in the bit pattern;
• using the ISO C copysign() function (IEEE 754 copySign operation) to copy the sign of the zero to some non-zero number;
• using the ISO C signbit() macro (IEEE 754 isSignMinus operation) that returns whether the sign bit of a number is set;
• taking the reciprocal of the zero to obtain either 1/(+0) = +∞ or 1/(−0) = −∞ (if the division by zero exception is not trapped).

Note: Casting to integral type will not always work, especially on two's complement systems.

However, some programming languages may provide alternative comparison operators that do distinguish the two zeros. This is the case, for example, of the equals method in Java's Double wrapper class.^[4]

Informally, one may use the notation "−0" for a negative value that was rounded to zero. This notation may be useful when a negative sign is significant; for example, when tabulating Celsius temperatures, where a negative sign means below freezing.

In statistical mechanics, one sometimes uses negative temperatures to describe systems with population inversion, which can be considered to have a temperature greater than positive infinity, because the coefficient of energy in the population distribution function is −1/Temperature. In this context, a temperature of −0 is a (theoretical) temperature larger than any other negative temperature, corresponding to the (theoretical) maximum conceivable extent of population inversion, the opposite extreme to +0.^[5]

• Line with two origins
• Extended real number line