Unsigned Integer Ranges and Overflow Detection

Hello! Last time, you converted non-negative integers among decimal, binary, and hexadecimal. Now we’ll put a limit on the number of binary positions available. That limit matters whenever a counter, file size, or arithmetic result must fit in a fixed-width integer: the mathematical answer and the value that can be stored may differ.

In this lesson, you’ll calculate the range of an unsigned integer, decide whether an operation fits, and explain what remains in the available bits when it does not.

How width determines the range

An unsigned integer uses every bit to represent a non-negative value. With $n$ bits, there are $2^n$ possible bit patterns. The smallest is all zeros. The largest is all ones: adding the place values of those ones gives

Thus, for a positive width $n$, the representable range is

The upper limit is one less than $2^n$ because zero occupies one of the $2^n$ patterns.

Last lesson, you saw that leading zeros leave a number’s value unchanged. Here they can communicate its width: 00000101 shows how decimal 5 fits in eight bits, while 0101 shows it in four. Both contain the same value, but their possible maximum values differ.

Addition and the carry beyond the available bits

Binary addition follows the same place-value rule as decimal addition. When a column totals two, write a zero in that column and carry one into the next. A carry within the available bits is ordinary addition; a carry out of the leftmost bit means the sum needs another position.

Watch Binary Addition & Overflow from Computerphile. The first segment develops binary carrying using a sum that fits; the second crosses a four-bit boundary.

For example, four-bit $11+3=14$ fits, even though carrying occurs during the calculation. But $15+1=16$ does not fit: four bits end at 15. The complete binary sum needs a fifth bit, while its four rightmost bits are 0000.

The same boundary appears at larger widths. Consider this eight-bit addition:

Checking the image against your conversion skills catches an instructive error: the drawn bits represent $248+12$, not $242+18$. Either pair totals 260, but an unsigned eight-bit value can reach only 255. The complete sum is 1 00000100; the eight-bit result retains 00000100, which represents 4. When interpreting a diagram like this, check the operands as well as the final sum.

Decide whether an operation fits

The most reliable overflow test is to calculate the exact mathematical result first, then compare it with the width’s range. For an eight-bit unsigned result, the test is whether the answer lies between 0 and 255, inclusive.

For addition, $200+55=255$ fits exactly at the boundary; $200+56=256$ exceeds it. Both operands fit individually, but that does not guarantee their sum fits. The same issue arises with multiplication: $20\times 13=260$ exceeds the eight-bit maximum, despite both inputs fitting.

Subtraction can cross the other boundary. The exact result of $3-5$ is $-2$, which is below the unsigned minimum of zero. This is often called unsigned underflow, rather than overflow above the maximum. In either case, the exact answer is outside the representable range.

For two unsigned inputs $a$ and $b$ that already fit, these checks can help when you cannot safely calculate a potentially oversized result in the same fixed-width type:

• Addition exceeds the maximum when $a>(2^n-1)-b$.
• Multiplication exceeds the maximum when $a>\lfloor (2^n-1)/b\rfloor$, provided $b>0$.
• Subtraction goes below zero when $a<b$.

These are just range comparisons written so that you can make the decision before storing the result. Multiplication by zero always produces zero.

What unsigned wraparound stores

When an unsigned result does not fit, its stored $n$-bit value consists of the $n$ rightmost bits of the exact result. Numerically, that value is the remainder after division by $2^n$:

For eight bits, the modulus is 256. The earlier addition stores $260\mathrm{mod}256=4$. A result may even pass the boundary more than once: $200\times 3=600$, and $600\mathrm{mod}256=88$. For subtraction, the unsigned eight-bit value corresponding to the exact result $-2$ is 254, because $-2$ and 254 differ by 256.

The Overflow section of Cornell’s Introduction & C notes connects this bit-level account to an eight-bit unsigned variable. Read the indicated passage for the distinction it makes between unsigned and signed arithmetic; you do not need to learn the surrounding C syntax yet.

You can inspect the distinction between exact answer and stored answer with Python. Python integers do not normally wrap at eight bits, so the remainder operation below models an eight-bit unsigned result rather than demonstrating Python’s default integer behavior:

width = 8
modulus = 1 << width
maximum = modulus - 1

calculations = [
    ("addition", 248 + 12),
    ("multiplication", 200 * 3),
    ("subtraction", 3 - 5),
]

for name, exact in calculations:
    if exact < 0:
        status = "underflow"
    elif exact > maximum:
        status = "overflow"
    else:
        status = "fits"

    stored = exact % modulus
    print(f"{name}: exact={exact}, {status}, stored={stored:08b}")

Here, 1 << width calculates $2^{\text{width}}$. The first output ends in 00000100; the multiplication ends in 01011000 (88); and the subtraction ends in 11111110 (254). Changing width changes the boundaries, though the 08b display format would also need adjusting if you wanted the printed bits padded to a different width.

Key takeaways

An $n$-bit unsigned integer represents 0 through $2^n-1$. To detect overflow or underflow, compare the exact arithmetic result with both endpoints—not merely with the operands. If the result is stored in $n$ unsigned bits, the stored value is its remainder modulo $2^n$; that value need not equal the mathematical answer.

Next, we’ll use fixed-width bits to represent signed integers. The bit patterns will be familiar, but their interpretation and range will change.