How Numbers Live in Memory

Two’s complement at a fixed width

To form -42 in eight bits:

The subtraction rule is often faster than inverting:

if the top bit is 0: signed value = unsigned value
if the top bit is 1: signed value = unsigned value - 2^width

For 1111_0011, the unsigned value is 243. At eight bits, 243 - 256 = -13.

Why addition works without a separate negative-number circuit

Add 42 and -42 while keeping eight bits:

  0010_1010
+ 1101_0110
-----------
1_0000_0000

The ninth carry bit falls outside the width. The stored eight bits are 0000_0000, which is zero.

This is the central advantage of two’s complement. One fixed-width addition rule works for positive and negative operands. There is one zero pattern. Subtraction can use addition of the two’s complement.

The asymmetric minimum

An eight-bit signed range is -128 through 127.

0111_1111 = 127
1000_0000 = -128

There is no eight-bit +128. Negating the minimum within the same width returns the same pattern. This behavior generalizes to Short.MIN_VALUE, Integer.MIN_VALUE, and Long.MIN_VALUE.

Overflow is fixed-width wraparound

The maximum byte pattern plus one gives the minimum byte pattern:

0111_1111  127
+       1
----------
1000_0000 -128

Java promotes byte arithmetic to int, so this program uses a cast to return to eight bits:

byte maximum = Byte.MAX_VALUE;
byte wrapped = (byte) (maximum + 1);
System.out.println(wrapped); // -128

Ordinary int and long arithmetic also wraps at their own widths. Math.addExact, Math.subtractExact, and Math.multiplyExact provide checked alternatives.

IEEE 754 binary32

A normal finite float uses three fields:

For normal finite values, the interpretation is:

(-1)^sign * 1.fraction * 2^(storedExponent - 127)

The implied leading 1 gives 24 bits of precision even though only 23 fraction bits are stored.

Build 8.125

8.125 is 1000.001 in binary. Normalize it:

1000.001 = 1.000001 * 2^3

The sign is 0. The stored exponent is 3 + 127 = 130, or 1000_0010. The fraction field holds the digits after the leading 1.: 000001, followed by zeros. Every required binary digit fits, so the result is exact.

Why 0.7 is rounded

Convert the fractional part by repeatedly multiplying by two:

The remainder 0.4 has returned, so the sequence repeats:

0.7 decimal = 0.10110011001100110011... binary

A float cannot store infinitely many fraction bits. IEEE 754 rounds to a nearby representable value. The exact decimal value of the resulting float is:

0.699999988079071044921875

printf("%.20f", value) rounds that stored value to twenty digits after the point. Float.toString(value) uses the shortest decimal text that parses back to the same float, which is why println displays 0.7.

Exponent patterns also encode special values

The normal-value formula does not cover every exponent pattern.

This program exposes the arithmetic behavior:

public class SpecialFloats {
    public static void main(String[] args) {
        double positiveInfinity = 1.0 / 0.0;
        double notANumber = 0.0 / 0.0;

        System.out.println(positiveInfinity);
        System.out.println(notANumber);
        System.out.println(notANumber == notANumber);
        System.out.println(+0.0 == -0.0);
    }
}

Output:

Infinity
NaN
false
true

Integer division by zero is different: 1 / 0 throws ArithmeticException.

Equality needs a contract

0.1 + 0.2 == 0.3 is false because the two computations land on different representable doubles.

double sum = 0.1 + 0.2;
System.out.printf("%.17f%n", sum); // 0.30000000000000004

For measured or calculated quantities, compare against a tolerance chosen for the domain:

static boolean closeEnough(double a, double b, double tolerance) {
    return Math.abs(a - b) <= tolerance;
}

An absolute tolerance alone is not suitable across every magnitude. Production numeric code often combines absolute and relative tolerances and defines behavior for NaN and infinity.

Use BigDecimal when the domain requires exact decimal arithmetic, such as a currency amount with defined decimal rounding. Construct it from decimal text or BigDecimal.valueOf, not from an already rounded binary floating-point value.