An unsigned binary integer is simply a binary fixed-point system with no fractional digits.

Unsigned binary integers are modular number systems, where the modulus is usually a power of 2.

We identify bits in a binary integer by the power of 2 at that position. Hence, the rightmost bit is called "bit 0", the next one to the left is "bit 1", and so on. The leftmost bit will have a power of N-1, where N is the number of bits, since we start at 0. In 1011, bit 0 is 1, bit 2 is 0, and bit 3 is 1. there is no bit 4.

Modern computers typically support binary integers of 8, 16, 32, and 64 bits. A 64-bit computer supports all of these integer sizes, a 32-bit computer supports all but 64-bit, etc.

The largest value in any unsigned binary integer system is the one containing all 1s, just as the largest decimal number is the one containing all 9s.

Largest modulo-1000₁₀ = 999₁₀.

Largest modulo-1000₂ = 111₂.

If we add 1 to a 4-bit binary value of all 1s, note what happens:

        111
        1111_2
    +      1
    --------
       10000_2 = 2^4
            

This is the same thing that happens when we add 1 to 9999₁₀.

        111
        9999_10
    +      1
    --------
       10000_10 = 10^4
            

If we add one to the largest value possible in 4 bits, we get 2⁴ (which requires 5 bits). If we add 1 to the largest value possible in N bits, we will get 2^N. Hence, the largest value possible in N bits, is 2^N - 1, just as the largest possible value with N decimal digits is 10^N - 1. Table 15.7, “Unsigned Binary Integer Ranges” shows the ranges of common unsigned integer sizes.

Note that even a 64-bit integer cannot hold Avogadro's constant, 6 * 10²³. In order to represent very large numbers with only 32 or 64 bits, we must use a system other than fixed-point. This is discussed in the section called “Floating Point”.

Note also that we cannot express fractional or irrational numbers or negative numbers, but only non-negative integers. Systems for representing signed integers and non-integers are covered in later sections.

How many bits are needed to represent a number? For this we use high-school algebra. If y = b^x, then x = log_b(y). If the result is not an integer, we need the next higher integer since we obviously cannot have portions of bits in digital hardware. Mathematically, we use the "ceiling" function, which rounds up to the nearest integer >= N. For an N-bit number:

    maximum-value = 2^N - 1
    maximum-value + 1 = 2^N
    N = ceiling(log_2(maximum-value + 1))
      = ceiling(ln(maximum-value + 1) / ln(2))
            

How many bits needed for 60,000?

    N = ceiling(log_2(60,000 + 1))
      = ceiling(ln(65,536) / ln(2))
      = ceiling(15.87)
      = 16
            

For convenience, you can also use Table 15.8, “Powers of 2” and Table 15.9, “Powers of 2”. Just find the lowest power of 2 greater than the number you want to represent, and you'll immediately know how many bits it requires. The lowest power of 2 greater than 60,000 is 65,536, which is 2^16, so we need 16 bits.

Addition in binary works the same way as in decimal. We need only remember that our largest possible digit is 1, so when adding 1 + 1, the result is not 2, but 10, and we carry the 1. 1 + 1 + 1 is 11, so the result is 1, carry a 1.

     11     111     Carry
    1001    0011
+   0011 +  0111
    ----    ----
    1100    1010
            

In fact, the process is the same for any base. We simply need to remember what our largest digit is and hence when to carry a 1.

    1
    27_8        19_16
+   21_8    +   21_16
--------    ---------
    50_8        3A_16
            

Subtraction, multiplication, and division are all basically the same as in decimal as well.