Chapter 2

Data
Representation
in Computer
Systems
 Objectives (1 of 2)

Understand the fundamentals of numerical

data representation and manipulation in
digital computers.
Master the skill of converting between
various radix systems.
Understand how errors can occur in
computations because of overflow and
truncation.
 Objectives (2 of 2)

Understand the fundamental concepts of

floating-point representation.
Gain familiarity with the most popular
character codes.
Understand the concepts of error detecting
and correcting codes.
 2.1 Introduction (1 of 2)

A bit is the most basic unit of information in a

computer.

A byte is a group of eight bits.

A byte is the smallest possible addressable unit of
computer storage.

can be retrieved according to its location in memory.

 2.1 Introduction (2 of 2)

A word is a contiguous group of bytes.

Words can be any number of bits or bytes.
Word sizes of 16, 32, or 64 bits are most
common.
In a word-addressable system, a word is the
smallest addressable unit of storage.
A group of four bits is called a nibble.
Bytes, therefore, consist of two nibbles: a
- -
 2.2 Positional Numbering Systems
(1 of 3)
Bytes store numbers using the position of
each bit to represent a power of 2.
The binary system is also called the base-2
system.
Our decimal system is the base-10 system. It
uses powers of 10 for each position in a
number.
Any integer quantity can be represented
exactly using any base (or radix).
 2.2 Positional Numbering Systems
(2 of 3)
The decimal number 947 in powers of 10 is:
9 102 + 4 101 + 7 100

The decimal number 5836.47 in powers of 10 is:

5 103 + 8 102 + 3 101 + 6 100

+ 4 10-1 + 7 10-2
 2.2 Positional Numbering Systems
(3 of 3)
The binary number 11001 in powers of 2 is:
1 24 + 1 23 + 0 22 + 0 21 + 1 20
= 16 + 8 + 0 + 0 + 1 = 25
When the radix of a number is something other
than 10, the base is denoted by a subscript.
Sometimes, the subscript 10 is added for emphasis:
110012 = 2510
2.3 Converting Between Bases (1 of 19)

Because binary numbers are the basis for all

data representation in digital computer
systems, it is important that you become
proficient with this radix system.
Your knowledge of the binary numbering
system will enable you to understand the
operation of all computer components as well
as the design of instruction set architectures.
2.3 Converting Between Bases (2 of 19)

In an earlier slide, we said that every integer

value can be represented exactly using any
radix system.
There are two methods for radix conversion:
the subtraction method and the division
remainder method.
The subtraction method is more intuitive, but
cumbersome. It does, however reinforce the
ideas behind radix mathematics.
2.3 Converting Between Bases (3 of 19)

Suppose we want to
convert the decimal
number 190 to base 3.
We know that 35 = 243 so
our result will be less than
six digits wide. The largest
power of 3 that we need is
therefore 34 = 81, and 81
2 = 162.
Write down the 2 and
subtract 162 from 190,
giving 28.
2.3 Converting Between Bases (4 of 19)

Converting 190 to base 3

The next power of 3 is
33
these, so we subtract 27
and write down the
numeral 1 in our result.
The next power of 3, 32 =
9, is too large, but we
have to assign a
placeholder of zero and
carry down the 1.
2.3 Converting Between Bases (5 of 19)

Converting 190 to base 3

31 = 3 is again too large, so
we assign a zero
placeholder.
The last power of 3, 30 = 1,
is our last choice, and it
gives us a difference of
zero.
Our result, reading from
top to bottom is:
19010 = 210013
2.3 Converting Between Bases (6 of 19)

Another method of converting integers from

decimal to some other radix uses division.
This method is mechanical and easy.
It employs the idea that successive division by
a base is equivalent to successive subtraction
by powers of the base.

again convert 190 in decimal to base 3.

2.3 Converting Between Bases (7 of 19)

Converting 190 to base 3

First we take the number
that we wish to convert
and divide it by the radix in
which we want to express
our result.
In this case, 3 divides 190
63 times, with a remainder
of 1.
Record the quotient and
the remainder.
2.3 Converting Between Bases (8 of 19)

Converting 190 to base 3

63 is evenly divisible
by 3.
Our remainder is
zero, and the quotient
is 21.
2.3 Converting Between Bases (9 of 19)

Converting 190 to base 3

Continue in this way until
the quotient is zero.
In the final calculation,
we note that 3 divides 2
zero times with a
remainder of 2.
Our result, reading from
bottom to top is:
19010 = 210013
2.3 Converting Between Bases (10 of 19)

Fractional values can be approximated in

all base systems.
Unlike integer values, fractions do not
necessarily have exact representations
under all radices.
The quantity ½ is exactly representable in
the binary and decimal systems, but is not
in the ternary (base 3) numbering system.
2.3 Converting Between Bases (11 of 19)

Fractional decimal values have nonzero digits

to the right of the decimal point.
Fractional values of other radix systems have
nonzero digits to the right of the radix point.
Numerals to the right of a radix point
represent negative powers of the radix:
0.4710 = 4 10-1 + 7 10-2
0.112 = 1 2-1 + 1 2-2
= ½ + ¼
= 0.5 + 0.25 = 0.75
2.3 Converting Between Bases (12 of 19)

As with whole-number conversions, you can use

either of two methods: a subtraction method or an
easy multiplication method.
The subtraction method for fractions is identical to
the subtraction method for whole numbers. Instead
of subtracting positive powers of the target radix,
we subtract negative powers of the radix.
We always start with the largest value first, n-1,
where n is our radix, and work our way along using
larger negative exponents.
2.3 Converting Between Bases (13 of 19)

The calculation to the

right is an example of
using the subtraction
method to convert the
decimal 0.8125 to binary.
Our result, reading from
top to bottom is:
0.812510 = 0.11012
Of course, this method
works with any base, not
just binary.
2.3 Converting Between Bases (14 of 19)

Using the
multiplication method
to convert the decimal
0.8125 to binary, we
multiply by the radix 2.
The first product carries
into the units place.
 2.3 Converting Between
Bases (15 of 19)
Converting 0.8125 to
binary
Ignoring the value in
the units place at each
step, continue
multiplying each
fractional part by the
radix.
2.3 Converting Between Bases (16 of 19)

Converting 0.8125 to binary

You are finished when the
product is zero, or until you
have reached the desired
number of binary places.
Our result, reading from top
to bottom is:
0.812510 = 0.11012
This method also works with
any base. Just use the target
radix as the multiplier.
2.3 Converting Between Bases (17 of 19)

The binary numbering system is the most important

radix system for digital computers.
However, it is difficult to read long strings of binary
numbers and even a modestly-sized decimal
number becomes a very long binary number.
For example: 110101000110112 = 1359510
For compactness and ease of reading, binary values
are usually expressed using the hexadecimal, or base-
16, numbering system.
2.3 Converting Between Bases (18 of 19)

The hexadecimal numbering system uses the

numerals 0 through 9 and the letters A through F.
The decimal number 12 is C16.
The decimal number 26 is 1A16.
It is easy to convert between base 16 and base 2,
because 16 = 24.
Thus, to convert from binary to hexadecimal, all we
need to do is group the binary digits into groups of
four.
A group of four binary digits is called a hextet.
 2.3 Converting Between Bases (19 of 19)

Using groups of hextets, the binary number

110101000110112 (= 1359510) in hexadecimal is:
If the number of bits is
not a multiple of 4, pad
on the left with zeros.

Octal (base 8) values are derived from binary by

using groups of three bits (8 = 23):

Octal was very useful when computers used six-bit words.

 2.4 Signed Integer Representation
(1 of 35)
The conversions we have so far presented have
involved only unsigned numbers.
To represent signed integers, computer systems
allocate the high-order bit to indicate the sign of a
number.
The high-order bit is the leftmost bit. It is also called
the most significant bit.
0 is used to indicate a positive number; 1 indicates a
negative number.
The remaining bits contain the value of the number
(but this can be interpreted different ways).
 2.4 Signed Integer Representation
(2 of 35)
There are three ways in which signed binary
integers may be expressed:
Signed magnitude

In an 8-bit word, signed magnitude

representation places the absolute value of
the number in the 7 bits to the right of the
sign bit.
 2.4 Signed Integer Representation
(3 of 35)
For example, in 8-bit signed magnitude
representation:
+3 is: 00000011
3 is: 10000011
Computers perform arithmetic operations on
signed magnitude numbers in much the same way
as humans carry out pencil and paper arithmetic.
Humans often ignore the signs of the operands while
performing a calculation, applying the appropriate sign
after the calculation is complete.
2.4 Signed Integer Representation (4 of
35)
Binary addition is as easy as it gets. You
need to know only four rules:
0 + 0 = 0 0 + 1 = 1
1 + 0 = 1 1 + 1 = 10
The simplicity of this system makes it
possible for digital circuits to carry out
arithmetic operations.
We will describe these circuits in Chapter 3.
magnitude numbers . . .
 2.4 Signed Integer Representation
(5 of 35)
Example:
Using signed
magnitude binary
arithmetic, find the
sum of 75 and 46.
First, convert 75 and 46
to binary, and arrange
as a sum, but separate
the (positive) sign bits
from the magnitude
bits.
 2.4 Signed Integer Representation
(6 of 35)
Example:
Using signed
magnitude binary
arithmetic, find the
sum of 75 and 46.
Just as in decimal
arithmetic, we find the
sum starting with the
rightmost bit and work
left.
 2.4 Signed Integer Representation
(7 of 35)
Example:
Using signed
magnitude binary
arithmetic, find the
sum of 75 and 46.
In the second bit, we
have a carry, so we
note it above the third
bit.
 2.4 Signed Integer Representation
(8 of 35)
Example:
Using signed
magnitude binary
arithmetic, find
the sum of 75 and
46.
The third and
fourth bits also
give us carries.
 2.4 Signed Integer Representation
(9 of 35)
Example:
Using signed
magnitude binary
arithmetic, find
the sum of 75 and
46.
Once we have In this example, we were
careful to pick two values
worked our way whose sum would fit into seven
through all eight bits. If that is not the case, we
bits, we are done. have a problem.
 2.4 Signed Integer Representation
(10 of 35)
Example:
Using signed
magnitude
binary
arithmetic, find
the sum of 107
and 46.
We see that the
carry from the
seventh bit
overflows and is
discarded, giving
us the erroneous
result: 107 + 46
= 25.
 2.4 Signed Integer Representation
(11 of 35)
The signs in signed
magnitude representation
work just like the signs in
pencil and paper arithmetic.
Example: Using signed
magnitude binary arithmetic,
find the sum of 46 and 25.
Because the signs are the
same, all we do is add the
numbers and supply the
negative sign when we
are done.
 2.4 Signed Integer Representation
(12 of 35)
Mixed sign addition (or
subtraction) is done the
same way.
Example: Using signed
magnitude binary
arithmetic, find the
sum of 46 and 25.
The sign of the result gets
the sign of the number that
is larger.
the second and sixth bits.
 2.4 Signed Integer Representation
(13 of 35)
Signed magnitude representation is easy for
people to understand, but it requires
complicated computer hardware.
Another disadvantage of signed magnitude is
that it allows two different representations for
zero: positive zero and negative zero.
For these reasons (among others) computers
systems employ complement systems for
numeric value representation.
 2.4 Signed Integer Representation
(14 of 35)
In complement systems, negative values are
represented by some difference between a number
and its base.
The diminished radix complement of a non-zero
number N in base r with d digits is (rd 1) N
In the binary system, this gives us .
It amounts to little more than flipping the bits of a
binary number.
 2.4 Signed Integer Representation
(15 of 35)
For example, using 8-
representation:
+3 is: 00000011
3 is: 11111100

magnitude, negative values are indicated by a 1 in

the high order bit.
Complement systems are useful because they
eliminate the need for subtraction. The difference
of two values is found by adding the minuend to
the complement of the subtrahend.
 2.4 Signed Integer Representation
(16 of 35)

addition, the carry bit is

to the sum.
complement binary
arithmetic, find the sum of 48
and 19.
We note that 19 in binary is
00010011,
so
is: 11101100.
 2.4 Signed Integer Representation
(17 of 35)

than signed magnitude.

But it still has the disadvantage of having two different
representations for zero: positive zero and negative
zero.

binary numbering system; the radix complement of a

non-zero number N in base r with d digits is rd N.
 2.4 Signed Integer Representation
(18 of 35)

representation:
If the number is positive, just convert it to binary and

of the number and then add 1.

Example:
In 8-bit binary, 3 is: 00000011

11111100
Adding 1 gives us
11111101.
 2.4 Signed Integer Representation
(19 of 35)

arithmetic, all we do is add

our two binary numbers. Just
discard any carries emitting
from the high order bit
Example:
complement binary arithmetic,
find the sum of 48 and 19.
We note that 19 in binary is:
00010011,
so
11101100,
and
11101101.
 2.4 Signed Integer Representation
(20 of 35)
Excess-M representation (also called offset binary
representation) is another way for unsigned binary
values to represent signed integers.
Excess-M representation is intuitive because the binary
string with all 0s represents the smallest number, whereas
the binary string with all 1s represents the largest value.
An unsigned binary integer M (called the bias)
represents the value 0, whereas all zeroes in the bit
pattern represents the integer -M.
The integer is interpreted as positive or negative
depending on where it falls in the range.
 2.4 Signed Integer Representation
(21 of 35)
If n bits are used for the binary representation, we
select the bias in such a manner that we split the
range equally.
Typically we choose a bias of 2n-1 1.
For example, if we were using 4-bit representation, the
bias should be 24 -1 1 = 7.

values that can be expressed in n bits.

 2.4 Signed Integer Representation
(22 of 35)
The unsigned binary value for a signed integer using
excess-M representation is determined simply by adding
M to that integer.
For example, assuming that we are using excess-7
representation, the integer 010 is represented as 0 + 7 = 710
= 01112.
The integer 310 is represented as 3 + 7 = 1010 = 10102.
The integer 7 is represented as 7 + 7 = 010 = 00002.
To find the decimal value of the excess-7 binary number
11112 subtract 7: 11112 = 1510 and 15 7 = 8; thus 11112, in
excess-7 is + 810.
 2.4 Signed Integer Representation
(23 of 35)
Lets compare our representations:
 2.4 Signed Integer Representation
(24 of 35)
When we use any finite number of bits to represent a
number, we always run the risk of the result of our
calculations becoming too large or too small to be
stored in the computer.

always detect overflow.

In complement arithmetic, an overflow condition is
easy to detect.
 2.4 Signed Integer Representation
(25 of 35)
Example:
arithmetic, find the sum of 107
and 46.
We see that the nonzero carry
from the seventh bit out into the
sign bit, giving us the erroneous
result: 107 + 46 = 103.
But carry out into the sign bit
does not always mean that we
have an error.
 2.4 Signed Integer Representation
(26 of 35)
Example:
binary arithmetic, find the
sum of 23 and 9.
We see that there is carry
into the sign bit and carry
out. The final result is
correct: 23 + ( 9) = 14.

When

overflow has occurred. If the carry into the sign bit equals
the carry out of the sign bit, no overflow has occurred.
 2.4 Signed Integer Representation
(27 of 35)
Signed and unsigned numbers are both useful.
For example, memory addresses are always unsigned.
Using the same number of bits, unsigned integers

signed numbers.

In four bits: 1111 + 1 = 0000.

Good programmers stay alert for this kind of
problem.
 2.4 Signed Integer Representation
(28 of 35)
Research into finding better arithmetic
algorithms has continued for over 50 years.
One of the many interesting products of this

multiplication faster and more accurately than

pencil-and-paper methods.
The general idea is to replace arithmetic
operations with bit shifting to the extent
possible.
 2.4 Signed Integer Representation
(29 of 35)
0011
If the current multiplier bit is 1 x 0110
and the preceding bit was 0,
subtract the multiplicand from
the product + 0000 (shift)
If the current multiplier bit is 0
and the preceding bit was 1, - 0011 (subtract)
we add the multiplicand to the
product
If we have a 00 or 11 pair, we + 0000 (shift)
simply shift.
+ 0011 (add) .
bit
Shift after each step 00010010
We see that 3 6 = 18!
 2.4 Signed Integer Representation
(30 of 35) 00110101
x 01111110
Here is a larger + 0000000000000000
example. + 111111111001011
+ 00000000000000
+ 0000000000000
+ 000000000000
Ignore all bits over 2n.
+ 00000000000
+ 0000000000
+ 000110101_______
10001101000010110
53 126 =
6678!
 2.4 Signed Integer Representation
(31 of 35)
Overflow and carry are tricky ideas.
Signed number overflow means nothing in the
context of unsigned numbers, which set a
carry flag instead of an overflow flag.
If a carry out of the leftmost bit occurs with an
unsigned number, overflow has occurred.
Carry and overflow occur independently of
each other.
The table on the next slide summarizes these ideas.
2.4 Signed Integer Representation
(32 of 35)
 2.4 Signed Integer Representation
(33 of 35)
We can do binary multiplication and division by 2
very easily using an arithmetic shift operation.
A left arithmetic shift inserts a 0 in for the rightmost
bit and shifts everything else left one bit; in effect, it
multiplies by 2.
A right arithmetic shift shifts everything one bit to the
right, but copies the sign bit; it divides by 2.
 2.4 Signed Integer Representation
(34 of 35)
Example:
Multiply the value 11 (expressed using 8-bit signed

We start with the binary value for 11:

00001011 (+11)
We shift left one place, resulting in:
00010110 (+22)
The sign bit has not changed, so the value is valid.
To multiply 11 by 4, we simply perform a left shift twice.
 2.4 Signed Integer Representation
(35 of 35)
Example:
Divide the value 12 (expressed using 8-bit signed

We start with the binary value for 12:

00001100 (+12)
We shift left one place, resulting in:
00000110 (+6)
(Remember, we carry the sign bit to the left as we
shift.)
To divide 12 by 4, we right shift twice.