Signed Integer Representation

This page is the second installment of a two-part reading on the binary representation of integers. The first installment discussed bits, bytes, and the representation of non-negative integers. This installment focuses upon signed integers.

Fixed and Variable Size Approaches

In principle, two approaches might be considered in the storage of integers (or other numbers): fixed size and variable size.

Variable size storage allocates as many bits as needed to represent an integer value. The approach is analogous to our common experience writing decimal integers. We use a single decimal digit (e.g., 1 or 7) to write small integers, two digits (e.g., 12 or 65) for integers between 10 and 99, three digits (e.g., 123 or 948) for integers between 100 and 999, etc. Such an approach allows an unlimited range of integers — as long as we have sufficient space to write the digits.
Fixed size storage works within the constraint that only a specified number of digits (or binary bits) are available for use. For example, if 8 bits (one byte) are available, the number zero would be represented 00000000, the number one as 00000001, the number two as 00000010, ..., and the number 255 as 11111111. With this approach, numbers 256 or larger cannot be represented within the 8-bit constraint.

In practice, although a few programming languages, such as Scheme, use variable size storage for integers, most programming languages, including C, use fixed size storage for integers. In the next section(s), we explore several fixed-size options for integers available within C.

Basic [unsigned] C Integer Types

The most recent C Standard, approved in 2011, includes several required integer types and also allows a C implementation to define additional, extended types. Historically, the size of integer types has represented a compromise. Large integers require more bits than small integers. If an application can expect all integers to be small, then a small storage size (low number of bits) can save space. Of course, savings for just one number may be small. However, when using large arrays of numbers, the savings can be substantial.

As an example, MyroC stores images (e.g., from a camera) pixel by pixel. Each pixel contains red, green, and blue values, and a char variable (i.e., 1 byte) is used to store each color intensity. That is, the current storage mechanism requires 3 bytes for each pixel.

A medium-resolution image (800 by 1280 pixels) requires about 3,072,000 bytes (3 MB) when color data are stored with 1 byte per color per pixel. Experiments indicate that transmission of these data over Bluetooth requires 25-30 seconds per image.
If 8 bytes were used for each color (C's long int or long long int type, depending upon the machine), one image would require about 24MB of storage, and transmission of a picture over Bluetooth would require over 7 minutes.

Overall, storage and transmission factors can have a substantial effect on what can be stored and how long processing takes. C's different storage types allow programmers to choose a size that supports an application adequately without wasting resources and without yielding unnecessary communication delays.

Altogether, the 2011 C Standard defines five different basic types for storing [unsigned] integers. Also, the Standard indicates the minimum number of bits required for each integer type. However, with computer memories becoming larger and less expensive over time, the 2011 C Standard allows the use of larger bit allocations than the minimum. Run program integer-sizes.c on your local machine to determine how many bits are allocated for varying types on your own computer. Some additional notes follow:

Historically, the char type or unsigned char type (1 byte) has been used for character data, although char is considered a type for small integers. The char will be discussed in more detail in the course segments, sessions, readings, and labs related to character data.
- Traditionally, characters have focused upon a Western alphabet although other options are available, and historically storage of these characters has required just one byte.
- New character options allow multiple bytes, and new capabilities are identified in the wchar.h header and library.
In the progression of types, [unsigned] char, [unsigned] short int, [unsigned] int, [unsigned] long int, [unsigned] long long int, each type conceptually utilizes about twice the number of bits as the previous type — although bit allocations for specific implementations vary. For example, a long int contains twice the number of bits as an int. Details may be found in the table at the right.

Unsigned C Types

The C Standard specifies minimal sizes for several unsigned integer types, but larger sizes are possible on a macine-by-machine basis.

Unsigned Integer Type	Number of Bits
Unsigned Integer Type	Standard Minimum	Common Size
`unsigned char`	8	8
`unsigned short int`	16	16
`unsigned int`	16	32
`unsigned long int`	32	64
`unsigned long long int`	64	64

Excursion: Basic Addition

Addition of binary numbers follows much the same rules as with the addition of decimal numbers:

  0 + 0 =  0
  1 + 0 =  1
  0 + 1 =  1
  1 + 1 = 10   //in decimal 1+1 is 2,
               //but 2 in binary is 10

In adding 1 + 1, think of the 1 as being a carry into the next place.

When adding multi-digit binary numbers, we proceed right-to-left, digit by digit in much the same way as with decimal addition. First, we add the right most digits. For 0+0, 1+0, 0+1, the result is a single digit which we can write down directly. However, for 1+1, we write down 0 as the result for that column, but then the 1 needs to be added when we perform the addition for the next column of numbers to be added.

To illustrate, we add 1 to 0 six times:

  0    1    10     11      100     101
 +1   +1    +1     +1       +1      +1
 __   __    __    ___      ___     ___
  1   10    11    100      101     110
      ↑           ↑↑                ↑ 
    carry  no     two       no     carry
          carry   carries  carry   from
                  working          right
                  right            digit
                  to left

Addition Practice

Find the [binary] sum of the following 8-bit binary numbers. (Each initial binary number has an initial 0, so the resulting sum will fit within 8 binary bits.)
Be sure to type 8 bits in your answer.

First number:
Second number:
Enter sum (8 bits):

Signed Integers

Throughout the discussion of integers so far, we have focused on non-negative integers, sometimes called unsigned integers.

If 16 bits are allocated to an integer, then the integer could store 2¹⁶ bit patterns, and a variable could hold values between 0 and 2¹⁶-1=65535.
If 32 bits are allocated, then an integer could store 2³² bit patterns, and a variable could hold values between 0 and 2³²-1=4294967295.

However, if we want to allow both negative and non-negative values, then about half of the numbers will be negative and about half positive.

If 16 bits are allocated for both negative and non-negative integers, then the range of numbers would be approximately -32767 to 32767.
If 32 bits are allocated, then the range could be -2147483647 to 2147483647.

With this in mind, C defines two versions of standard integers:

The basic integer types (char, short int, int, long int, long long int) allow negatives, zero, and positives.
Adding "unsigned" to the type (unsigned char, unsigned short int, unsigned int, unsigned long int, unsigned long long int) prescribes all bits will be used to represent non-negative integers.

Once both negative and non-negative integers are allowed, the natural next step is to determine how to represent these numbers within a specified number of bits.

Interestingly, the 2011 C Standard allows three alternatives for representing negative numbers.

Sign-magnitude Notation
Ones-complement Notation
Twos-complement Notation

Range of Integer Types Varies

As noted earlier, the actual range of values for each integer data type varies according to the actual computer and compiler. The <limits.h> header file provides constants that present the actual range of integer values for each type.

Integer Type	Constants from `<limits.h>`
Integer Type	Minimum in range	Maximum in range
`unsigned char`	`0`	`UCHAR_MAX`
`char`	`CHAR_MIN`	`CHAR_MAX`
`unsigned short int`	`0`	`USHRT_MAX`
`short int`	`SHRT_MIN`	`SHRT_MAX`
`unsigned int`	`0`	`UINT_MAX`
`int`	`INT_MIN`	`INT_MAX`
`unsigned long int`	`0`	`ULONG_MAX`
`long int`	`LONG_MIN`	`LONG_MAX`
`unsigned long long int`	`0`	`ULLONG_MAX`
`long long int`	`LLONG_MIN`	`LLONG_MAX`

Run program integer-ranges.c on your local machine to determine the ranges of the various types on your computer.

Sign-magnitude Notation

In all three notations for signed integers, the first (leftmost) bit designates whether the number is negative or non-negative.

If the leftmost bit is 0, the number is non-negative.
If the leftmost bit is 1, the number is non-positive.

As we shall discuss, the mechanism to determine the representation of a negative number varies according to the three notations, but in each case, the leftmost bit effectively indicates the sign of the number (- or +).

With the first bit devoted to the number's sign (- or +), the largest positive number that can be represented will be 0111...111. That is, the first bit is 0 (the + sign), and the remaining bits are 1. Numbers larger than this cannot be stored properly — a situation called overflow.

In sign-magnitude notation, the first bit is 0 or 1 (for + or -, respectively), and the remaining bits give the binary bits of the non-negative number.

Examples using a 16-bit signed integer:

Decimal	16-bit representation sign-magnitude notation
127	0000000001111111
-127	1000000001111111
0	0000000000000000
-0	1000000000000000
87	0000000001010111
-87	1000000001010111

Notes:

As shown in the table, the number zero has two representations (+0 and -0).
With this notation, addition is somewhat complicated, as one must consider the addition of two positive numbers, one positive and one negative, one negative and one positive, and two negatives.

Both of these circumstances (zero, addition) yield some complexity for circuitry.

Practice

Fill in the table for the 16-bit, sign-magnitude representation of the given decimal integer

Decimal Number	Fill in 16-bit sign-magnitude representation

Ones-complement Notation

As with sign-magnitude notation using n bits, all non-negative numbers must utilize the right n-1 bits and be written with a leading zero. Non-negative numbers are exactly the same with sign-magnitude and ones-complement notation (and also with two-complement, to be discussed later).

Given a non-negative number, the corresponding negative number is determined by changing all 0's to 1's and all 1's to 0's. Several examples follow:

Decimal	16-bit representation ones-complement notation
27	`0000000000011011`
-27	`1111111111100100`
0	`0000000000000000`
-0	`1111111111111111`
87	`0000000001010111`
-87	`1111111110101000`
114	`0000000001110010`
-114	`1111111110001101`
60	`0000000000011100`
-60	`1111111111000011`

Practice

Fill in the table for the 16-bit, ones-complement representation of the given decimal integer

Decimal Number	Fill in 16-bit ones-complement representation

Addition in Ones-Complement

Although ones complement notation is clear and unambiguous, the following example illustrates that addition may seem a little quirky.

Consider binary addition for ±87 and ±27. (Refer to the example above for relevant values.)

	decimal	ones complement	Notes
	27	`0000000000011011`
	87	`0000000001010111`
binary sum	114	`0000000001110010`	correct — matches previously-computed value for 114!

	27	`0000000000011011`
	-87	`1111111110101000`
binary sum	-60	`1111111111000011`	correct — matches previously-computed value for -60!

	-27	`1111111111100100`
	-87	`1111111110101000`
binary sum	-114	`11111111110001100`	carry to seventeenth bit — right 16 bits off; need to add 1

	-27	`1111111111100100`
	87	`0000000001010111`
binary sum	60	`10000000000111011`	carry to seventeenth bit — right 16 bits off; need to add 1

Notes: As with sign-magnitude notation, two circumstances arise with ones-complement notation

The number zero has two representations (all zeros and all ones).
The example with addition suggests that sometimes addition works fine with ones-complement notation, However, sometimes there is a carry into a seventeenth digit, and when the seventeenth bit is removed, a 1 must be added to the computed sum to obtain the correct answer.

Again, both the two forms of zero and the multiple cases for addition yield some complexity for circuitry.

Optional: For the Mathematically Inclined and/or Curious

The addition example for ones-complement arithmetic suggests an issue for n-bit signed numbers: sometimes addition of two ones-complements numbers seems to generate an extra bit, and in those cases, one must be added to the remaining n bits to obtain the proper answer. The following notes explain why this pattern occurs generally.

Suppose n bits are allocated for ones-complement numbers. Since n bits allow 2ⁿ different patterns — about half for positives and about half for negatives (and 1 or 2 for zero), positive numbers will be between 0 and 2^n-1-1.

In addition, since we only store n bits, we can add or subtract multiples of 2ⁿ as we wish — such values are not stored in n-bit numbers.

Now suppose a and b are positive integers, 0 ≤ a, b ≤ 2^n-1-1. The negative numbers -a and -b will be represented by binary values with a leading 1 — numbers between 2^n-1-1 and 2ⁿ.

Next consider the process of switching bits from 0 to 1 and from 1 to 0. One way to accomplish this switch is subtracting the original bit from 1:

  1 - 0 = 1     1 - 1 = 0

The positive number representing all n 1's is 2ⁿ-1, so switching all bits of a can be achieved by subtracting the binary representation of a from 2ⁿ-1, bit-by-bit. That is, the ones-complement representation of the number -a is given by the number 2ⁿ-1 - a — a number with a leading 1 that is larger than 2^n-1-1. Similarly, -b is represented by 2ⁿ-1 - b.

Now, let's consider cases of arithmetic; for simplicity, we assume b > a.

a + b will be positive. As long as this number can be represented with n-1 bits, addition will work without trouble.
Consider a - b. Since we are assuming b > a, (b -a) is positive, and (a - b) would be negative. We have observed that -b would be represented by 2ⁿ-1 - b, so a - b = a - (2ⁿ-1 - b) = (2ⁿ-1 - (b - a)). With ones-complement notation, this value exactly corresponds to -(b-a), as desired.
Consider -a - b. Since -a is represented by 2ⁿ-1 - a and -b is represented by 2ⁿ-1 - b, -a -b is represented by 2ⁿ-1 - a + 2ⁿ-1 - b = 2*2ⁿ-2 - (a + b).

Here, the factor 2*2ⁿ indicates a carry into the extra digit. Also, the -2 term is off by one for ones-complement. Altogether, we can obtain the correct result by ignoring the carry into the extra digit and adding 1.
Consider b - a. Since -a is represented by 2ⁿ-1 - a, b - a is represented by 2ⁿ-1 - a + b. Since we are assuming b > a, b-a is positive, the answer to the addition should be b-a. In interpreting this number, and we can ignore 2ⁿ (the carry into an n^th bit), because this number is not stored in n bits. This leaves the number -1 - a - b, which is off by 1. Again, adding 1 to the result of the b-a computation yields the correct answer.

Altogether, the representation of -a by 2ⁿ-1 - a sometimes works fine, but sometimes the representation is off by 1 and we need an extra term 2ⁿ (not recorded) for the result to work right.

Twos-complement Notation

As with the other n-bit notations for negative and non-negative integers, the left-most bit for non-negative integers is 0, the integers utilize the remaining n-1 bits, and non-negative integers must be in the range 0 through 2^n-1-1.

Also given a non-negative number a, the twos-complement notation for -a is obtained in two basic steps:

Write -a in ones-complement notation.
Add 1

Several examples follow:

decimal	ones-complement	twos-complement
27	`0000000000011011`	`0000000000011011`
-27	`1111111111100100`	`1111111111100101`
87	`0000000001010111`	`0000000001010111`
-87	`1111111110101000`	`1111111110101001`
60	`0000000000111100`	`0000000000111100`
-60	`1111111111000011`	`1111111111000100`
114	`0000000001110010`	`0000000001110010`
-114	`1111111110001101`	`1111111110001110`

Practice

Fill in the table for the 16-bit, twos-complement representation of the given decimal integer

Dec. Num.	Fill in 16-bit representations
	16-bit-pos.
	1's-comp.
	2's-comp.

Optional: For the Mathematically Inclined and/or Curious

In the discussion of ones-complement notation, we noted that non-negative numbers a are represented by their unsigned binary representation, but negative numbers a are represented by 2ⁿ-1 - a.

Since the twos-complement representation for -a starts with ones-complement notation and adds one, the two's complement representation for -a is 2ⁿ- a. With this notation, the issues for addition for ones-complement numbers (involving sometimes being off by one) are completely resolved).

Concluding Observations

In practice, twos-complement notation has two advantages over other approaches for representing negative integers.

In examining twos-complement notation, note that adding 1 to -0 in ones-complement notation yields 00000...000, the same value as +0. Thus, twos-complement notation has only one bit pattern for the number zero.
The notes For the Mathematically Inclined or Curious explain why twos-complement addition resolves difficulties encountered with sign-magnitude notation (complexity) and with ones-complement notation (extra carry and sometimes off by one).

Altogether, although the 2011 C Standard allows the use of sign-magnitude notation, ones-complement notation, and twos-complement notation, [almost] all modern computers utilize twos-complement notation due to its simple representation of zero and its efficiency with addition of integers.

CS 415, Section 001	Sonoma State University	Spring, 2024

Algorithm Analysis
Instructor: Henry M. Walker Lecturer, Sonoma State University Professor Emeritus of Computer Science and Mathematics, Grinnell College

Contract Negotiations Have Yielded a Tentative Agreement

Representation of Signed Integers

Reading outline

Fixed and Variable Size Approaches

Basic [unsigned] C Integer Types

Unsigned C Types

Excursion: Basic Addition

Addition Practice

Signed Integers

Range of Integer Types Varies

Sign-magnitude Notation

Practice

Ones-complement Notation

Practice

Addition in Ones-Complement

Optional: For the Mathematically Inclined and/or Curious

Twos-complement Notation

Practice

Optional: For the Mathematically Inclined and/or Curious

Concluding Observations

created August 7, 2022 revised December 29, 2022
For more information, please contact Henry M. Walker at walker@cs.grinnell.edu.