Let's continue where we left off. In the last article I covered what are binary numbers and how to convert from binary to decimal. If you had a chance to read it, you're now probably wondering how positive and negative numbers are represented in a computer. This article will cover this.

Adding binary numbers

Before I cover positive and negative numbers, I must first touch on a few things that will make some of the concepts I will bring up later easier to follow. The first thing I will touch on is how addition works in binary.

Binary addition follows the same rules as addition in the decimal system.

In the decimal system, when the result of an addition equals 10, we carry 1 over to the next digit on the left.

For example:

12 + 9 = 21

In binary addition, we carry 1 over when the sum of the values equal 2:

0 + 0 = 0

0 + 1 = 1

1 + 0 = 1

1 + 1 = 10, carry over 1, i.e. 10

Example:

      1  0  ¹0  1  ¹0  1

  +      1    0  1   0  1

  =  1  1    1  0   1  0

The value 2 in the binary system is equivalent to 10 in the decimal system.

Bits, bits, and more bits

The next topic I will touch on is how numbers are  stored and organized in a computer system. A single binary digit is called a bit. Bits are the most basic units of information in a computer system. A bit by itself can only provide two values: 0 and 1. But as you seen in the last article, a computer can represent larger numeric values with more bits.

Programming languages typically provide a variety of numeric data types, each of which allow for a different range of numbers to be stored. Here are the types you will come across:

Data Type	# Bits	Number Range
Byte	8	0 - 256 (2^8)
Short/Word	16 (2 Bytes)	0 - 65536 (2^16)
Double Word	32 (4 Bytes)	0 - 4,294,967,296 (2^32)
Long	64 (8 Bytes)	0 - 18,446,744,073,709,551,616

Positive and Negative Integers

To represent negative numbers, one bit in the number is used to indicate whether or not the number is positive or negative. If this bit is 0 than the number is positive. If the bit is 1 than the number is negative. This bit is called the sign bit and is the leftmost bit in the binary number

Let's say that we using 8 bits to represent positive and negative numbers. This is what the number 105 will look like:

Sign (High order bit)							Low Order Bit
0	1	1	0	1	0	0	1

And this what -105 looks like:

Sign (High order bit)							Low Order Bit
1	0	0	1	0	1	1	1

If you compare the two binary numbers you will notice that for every bit in the number 105 except for the right most bit, the 1s was exchanged for 0s and the 0s were exchanged for 1s. We have a special name for these type of numbers. It's called two's complement.

The two's complement for any binary number can be computed by simply inverting the each bit (turning 0s into 1s and 1s into 0s) and adding 1 to the result.

As another example here's the number 78 and its two's complement:

78

Sign (High order bit)							Low Order Bit
0	1	0	0	1	1	1	0

And -78

Sign (High order bit)							Low Order Bit
1	0	1	1	0	0	1	0

As mentioned before most programming languages provide a number of numeric data types that allow the user to store numbers of varying ranges. Since 1 bit is used to represent negative numbers, the range of numbers that can be represented will be different

Data Type	# Bits	Number Range
Byte	8	-127 to 127
Short/Word	16 (2 Bytes)	-32767 to 32767
Double Word	32 (4 Bytes)	-2,147,483,648 - 2,147,483,647
Long	64 (8 Bytes)	(-2^63)+1 - (2^63)-1

Some languages like C/C++ provide signed and unsigned integers. Signed integers which use one bit to represent negative numbers and unsigned integers which do not.

So now that you know about signed and unsigned integers, what do you think will happen if you perform a calculation like 2,147,483,647 + 1 and store the result in a signed integer? What do you think will happen if you store the result of 4,294,967,296 + 1 in an unsigned integer?

In the case of unsigned integers, what happens depends on the programming language and the compiler. Some languages will raise an error when this happens. Most however will either perform a modulo/wrap around operation or have some undefined behavior.

In the example above the let's let UINT = 4,294,967,296 + 1. Then

UINT + 1 = 0

UINT + 2 = 1

UINT + 3 = 2

And so on..

In the  case of signed integers the result might be even more surprising. Let's let SINT = 2,147,483,647. Here's what you can mostly expect:

SINT + 1 = -2,147,483,648

SINT + 2 = -2,147,483,647

SINT + 3 = -2,147,483,646

And so on..

The result becomes a negative number.

These cases, where the result of an integer operation does not fit within the allocated memory space, are called integer overflow errors. As you can imagine these errors are very dangerous because they often lead to unexpected behaviors.

Avoiding integer overflow errors usually comes down to checking the result of the addition. If the sum of two numbers is less than either of the operands, then you know for sure an integer overflow occurred.

What's next…

In this article, you learned how positive and negative integers are represented in binary and special cases you should be aware of when adding integers. Next article we will discuss floating point numbers.