Vorzeichenbehaftete Null

−0 is the representation of negative zero or minus zero, a number that, in computing, exists in some signed number representations for integers, and in most floating point number representations. Use of a floating-point representation that contains negative zero may be necessary to achieve numerical accuracy in some critical problems,^[1] and to avoid anomalies in the definitions of elementary functions.^[2]

In mathematical terms there is no concept of a negative (or positive) zero, and −0 is equal to, and represented as, zero; however a similar concept of the one-sided limit of 0 approached from below is normally denoted by 0⁻ or ↑0.

In common usage, −0 may be used to denote a negative number rounded to zero, or a number approaching zero from the negative direction. In statistical mechanics, certain systems in a state of population inversion may be considered to have an absolute temperature of −0, the hottest possible absolute temperature (see negative temperature).

Representations

In a 1+7-bit sign-and-magnitude representation for integers, negative zero is represented by the binary value 10000000. In an 8-bit one's complement representation, negative zero is represented by the binary value 11111111. In IEEE 754 floating point numbers, negative zero is represented by the exponent and significand being zero and the sign bit being one.

In IEEE 754 and in IBM's General Decimal Arithmetic encoding specification, a floating-point representation that uses decimal arithmetic, negative zero is represented by an exponent being any valid exponent in the range for the encoding, the coefficient being (densely packed encoded) all zeros, and the sign bit being one.

Negative zero cannot be distinguished from positive zero with conventional two's complement encoding, which is the most common representation of signed binary integers.

Properties and handling

In programming languages such as C, C#, C++, Java, and Javascript, whilst it is possible to obtain negative zero as the result of an expression (for instance as the result of arithmetic underflow on a negative number), negative zero and positive zero compare equal under default (numerical) comparison. Thus a simple comparison is not sufficient to test whether a number is negative zero.

Ways of testing include

using the copysign() function, which is defined by IEEE 754 and C to copy the sign of the zero, to some non-zero number,
dividing the number into a positive number—the resulting Infinity will reflect the sign of the zero.

${\frac {k}{+0}}=+\infty$ (for positive k)

${\frac {k}{-0}}=-\infty$ (for positive k)

For example, in Javascript:

function isNegativeZero(x) { return x === 0 && 1/x < 0; }
isNegativeZero(-0.0); // Result: true
isNegativeZero( 0.0); // Result: false

Note that in other languages, this may require disabling any trap that might occur on division by zero.

in Java, using the equals method in the Double class, which treats negative zero as distinct from positive zero; for example:

Double negativeZero = new Double(-0.0);
negativeZero.equals(-0.0); // Result: true
negativeZero.equals( 0.0); // Result: false

in C, using a non-portable technique that relies on the local hardware representation, e.g., *(int *)&var == 0x80000000 (where var is encoded in IEEE 754 single precision).

Multiplication and division follow their usual rules for combining signs:

${\frac {-0}{x}}=-0\,\!$ (for positive x)

$(-0)\cdot (-0)=+0\,\!$

$\left|x\right|\cdot (-0)=-0\,\!$

Addition and subtraction are handled specially if the values could cancel:

$(-0)-(+0)=-0\,\!$

$(-0)-(-0)=+0\,\!$ (−0 in rounding toward negative)

$(+0)+(-0)=+0\,\!$ (−0 in rounding toward negative)

$(-0)+(-0)=-0\,\!$

$x+(-0)=x\,\!$ (for x different from 0)

Special rules

${\sqrt {-0}}=-0\,\!$

${\frac {-0}{-\infty }}=+0\,\!$ (follows the sign rule for division)

${\frac {\infty }{-0}}=-\infty \,\!$ (follows the sign rule for division)

${\pm 0}\times {\pm \infty }={\mbox{NaN}}\,\!$ (Not a Number or interrupt for indeterminate form)

${\frac {\pm 0}{\pm 0}}={\mbox{NaN}}\,\!$

Use of an integer representation that contains negative zero can be a source of errors in programs when software developers do not realize that, while the two zero representations compare equal, they are treated differently by some operations.

Scientific uses

In meteorology, −0 can be used to indicate a temperature which is below zero, especially for the Celsius scale where below zero indicates freezing. It is often important for statistical reasons, when it is not low enough to be rounded to −1. An example of such a temperature is −0.2 degrees; this cannot be listed as zero degrees, because temperatures of zero degrees are obviously not considered below zero. However, a tally of below-zero days is often a rudimentary statistic in comparing the coldness of winter seasons, so it cannot be ignored. It is not low enough to be rounded to −1, so it is recorded as −0.

In some contexts related to statistical mechanics, it is possible for systems to have a negative absolute temperature, but counterintuitively, these are not extremely cold, but rather extremely hot, hotter than any positive temperature. In this context, −0 is the hottest temperature there is.

References

↑ William Kahan, "Branch Cuts for Complex Elementary Functions, or Much Ado About Nothing's Sign Bit", in The State of the Art in Numerical Analysis (eds. Iserles and Powell), Clarendon Press, Oxford, 1987.
↑ William Kahan, Derivatives in the Complex z-plane, p10.

Other references

Floating point types. In: MSDN C# Language Specification. Abgerufen im 1. Januar 1 Vorlage:Deadlink
Division operator. In: MSDN C# Language Specification. Abgerufen im 1. Januar 1 Vorlage:Deadlink
Vorlage:Cite paper
Mike Colishaw: Decimal Arithmetic Specification, version 1.68. 28. Juli 2008, abgerufen am 14. August 2008. — a decimal floating point specification that includes negative zero
Charles Kittel, and Herbert Kroemer: Thermal Physics. W. H. Freeman & Company, 1980, ISBN 0-7167-1088-9.

Representations

Properties and handling

Scientific uses

References

Other references

Further reading