1

CHAPTER 2

Data Representation

in Computer Systems

2
 Chapter 2 Objectives

• 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.
3
 Chapter 2 Objectives

• 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.
4
2.1 Introduction

• A bit is the most basic unit of information in a

computer.
– It is a state of “on” or “off” in a digital circuit.
– Sometimes these states are “high” or “low” voltage
instead of “on” or “off..”
• A byte is a group of eight bits.
– A byte is the smallest possible addressable unit of
computer storage.
– The term, “addressable,” means that a particular byte can
be retrieved according to its location in memory.
5
2.1 Introduction

• 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 “high-order
nibble,” and a “low-order” nibble.
6
2.2 Positional Numbering Systems

• 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).
7
2.2 Positional Numbering Systems

• The decimal number 947 in powers of 10 is:

9  10 2 + 4  10 1 + 7  10 0

• The decimal number 5836.47 in powers of 10 is:

5  10 3 + 8  10 2 + 3  10 1 + 6  10
0

+ 4  10 -1 + 7  10 -2

8
2.2 Positional Numbering Systems

• 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
9
2.3 Binary to Hex Conversions

• 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.
10
2.3 Binary to Hex Conversions

• 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.
11
2.3 Binary to Hex Conversions

• The binary number 110101000110112 (= 1359510) in

hexadecimal is:

• Octal (base 8) values are derived from binary by

using groups of three bits (8 = 23):

12
2.4 Signed Integer Representation

• The conversions we have so far presented have

involved only positive numbers.
• To represent negative values, computer systems
allocate the high-order bit to indicate the sign of a
value.
– The high-order bit is the leftmost bit in a byte. It is also
called the most significant bit.
• The remaining bits contain the value of the
number.
13
2.4 Signed Integer Representation

• There are three ways in which signed binary

numbers may be expressed:
– Signed magnitude,
– One’s complement, and
– Two’s complement.

• 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.
14
2.4 Signed Integer Representation

• For example, in 8-bit signed magnitude, positive

3 is: 00000011
negative 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.
15
2.4 Signed Integer Representation

• 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.

16
2.4 Signed Integer Representation

• Example 1:
– 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.
17
2.4 Signed Integer Representation

• Example 1:
– 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.
18
2.4 Signed Integer Representation

• Example 1:
– 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.

19
2.4 Signed Integer Representation

• Example 1:
– Using signed magnitude
binary arithmetic, find the
sum of 75 and 46.
• The third and fourth bits also
give us carries.

20
2.4 Signed Integer Representation

• Example 1:
– Using signed magnitude binary
arithmetic, find the sum of 75
and 46.
• Once we have worked our way
through all eight bits, we are
done.
21
2.4 Signed Integer Representation

• 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.
22
2.4 Signed Integer Representation

• 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.
23
2.4 Signed Integer Representation

• 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.
– Note the “borrows” from the second and sixth bits.

24
2.4 Signed Integer Representation

• 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 computer systems employ
complement systems for numeric value
representation.
25
2.4 Signed Integer Representation

• In complement systems, negative values are

represented by some difference between a
number and its base.
• In diminished radix complement systems, a
negative value is given by the difference between
the absolute value of a number and one less than
its base.
• In the binary system, this gives us one’s
complement.
26
2.4 Signed Integer Representation

• For example, in 8-bit one’s complement,

positive 3 is: 00000011
negative 3 is: 11111100

• In one’s complement, as with signed

magnitude, negative values are indicated by a
1 in the high order bit.

• Complement systems are useful because they

eliminate the need for subtraction.
27
2.4 Signed Integer Representation

• With one’s complement

addition, the carry bit is
“carried around” and added
to the sum.
– Example: Using one’s
complement binary arithmetic,
find the sum of 48 and - 19

We note that 19 in one’s complement is 00010011,

so -19 in one’s complement is: 11101100.
28
2.4 Signed Integer Representation

• Although the “end carry around” adds some

complexity, one’s complement is simpler to
implement than signed magnitude.
• But it still has the disadvantage of having two
different representations for zero: positive zero
and negative zero.
• Two’s complement solves this problem.
• Two’s complement is the radix complement of
the binary numbering system.
29
2.4 Signed Integer Representation

• To express a value in two’s complement:

– If the number is positive, just convert it to binary and
you’re done.
– If the number is negative, find the one’s complement of
the number and then add 1.
• Example:
– In 8-bit one’s complement, positive 3 is: 00000011
– Negative 3 in one’s complement is: 11111100
– Adding 1 gives us -3 in two’s complement form: 11111101.

30
2.4 Signed Integer Representation

• With two’s complement arithmetic, all we do is add

our two binary numbers. Just discard any carries
emitting from the high order bit.
– Example: Using one’s
complement binary
arithmetic, find the sum of
48 and - 19.

We note that 19 in one’s complement is: 00010011,

so -19 in one’s complement is: 11101100,
and -19 in two’s complement is: 11101101.
31
2.4 Signed Integer Representation

• 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
to be stored in the computer.

• While we can’t always prevent overflow, we

can always detect overflow.

• In complement arithmetic, an overflow condition

is easy to detect.
32
2.4 Signed Integer Representation

• Example:
– Using two’s complement binary
arithmetic, find the sum of 107
and 46.
• We see that the nonzero carry
from the seventh bit overflows
into the sign bit, giving us the
erroneous result: 107 + 46 = -103.

Rule for detecting signed two’s complement overflow: When

the “carry in” and the “carry out” of the sign bit differ,
overflow has occurred.
33
2.4 Signed Integer Representation

• 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.
34
2.4 Signed Integer Representation

35
2.5 Floating-Point Representation

• The signed magnitude, one’s complement, and

two’s complement representation that we have
just presented deal with integer values only.
• Without modification, these formats are not
useful in scientific or business applications that
deal with real number values.
• Floating-point representation solves this
problem.
36
2.5 Floating-Point Representation

• If we are clever programmers, we can perform

floating-point calculations using any integer format.
• This is called floating-point emulation, because
floating point values aren’t stored as such, we just
create programs that make it seem as if floating-
point values are being used.
• Most of today’s computers are equipped with
specialized hardware that performs floating-point
arithmetic with no special programming required.
37
2.5 Floating-Point Representation

• Floating-point numbers allow an arbitrary

number of decimal places to the right of the
decimal point.
– For example: 0.5  0.25 = 0.125
• They are often expressed in scientific notation.
– For example:
0.125 = 1.25  10-1
5,000,000 = 5.0  106
38
2.5 Floating-Point Representation

• Computers use a form of scientific notation for

floating-point representation

• Numbers written in scientific notation have three

components:

39
2.5 Floating-Point Representation

• Computer representation of a floating-point

number consists of three fixed-size fields:

• This is the standard arrangement of these fields.

40
2.5 Floating-Point Representation

• The one-bit sign field is the sign of the stored value.

• The size of the exponent field, determines the

range of values that can be represented.

• The size of the significand (mantissa) determines

the precision of the representation.
41
 2.5 Floating-Point Representation

• The IEEE-754 single precision floating point standard

uses an 8-bit exponent and a 23-bit significand.
• The IEEE-754 double precision standard uses an 11-bit
exponent and a 52-bit significand.

For illustrative purposes, we will use a 14-bit model

with a 5-bit exponent and an 8-bit significand. 42
2.5 Floating-Point Representation

• The significand of a floating-point number is

always preceded by an implied binary point.
• Thus, the significand always contains a fractional
binary value.
• The exponent indicates the power of 2 to which
the significand is raised.
43
2.5 Floating-Point Representation

• Example:
– Express 3210 in the simplified 14-bit floating-point
model.
• We know that 32 is 25. So in (binary) scientific
notation 32 = 1.0 x 25 = 0.1 x 26.
• Using this information, we put 110 (= 610) in the
exponent field and 1 in the significand as shown.

44
 2.5 Floating-Point Representation

• The illustrations shown at

the right are all equivalent
representations for 32
using our simplified model.

• Not only do these

synonymous
representations waste
space, but they can also
cause confusion.
45
2.5 Floating-Point Representation

• Another problem with our system is that we have

made no allowances for negative exponents. We
have no way to express 0.5 (=2 -1)! (Notice that
there is no sign in the exponent field!)

All of these problems can be fixed with no

changes to our basic model.

46
 2.5 Floating-Point Representation

• To resolve the problem of synonymous forms,

we will establish a rule that the first digit of the
significand must be 1. This results in a unique
pattern for each floating-point number.
– In the IEEE-754 standard, this 1 is implied meaning
that a 1 is assumed after the binary point.
– By using an implied 1, we increase the precision of the
representation by a power of two. (Why?)

In our simple instructional model,

we will use no implied bits.

47
 2.5 Floating-Point Representation

• To provide for negative exponents, we will use a

biased exponent.
• A bias is a number that is approximately midway
in the range of values expressible by the
exponent. We subtract the bias from the value
in the exponent to determine its true value.
– In our case, we have a 5-bit exponent. We will use 16
for our bias. This is called excess-16 representation.
• In our model, exponent values less than 16 are
negative, representing fractional numbers.

48
2.5 Floating-Point Representation

• Example:
– Express 3210 in the revised 14-bit floating-point model.
• We know that 32 = 1.0 x 25 = 0.1 x 26.
• To use our excess 16 biased exponent, we add 16 to
6, giving 2210 (=101102).
• Graphically:

49
2.5 Floating-Point Representation

• Example:
– Express 0.062510 in the revised 14-bit floating-point
model.
• We know that 0.0625 is 2-4. So in (binary) scientific
notation 0.0625 = 1.0 x 2-4 = 0.1 x 2 -3.
• To use our excess 16 biased exponent, we add 16 to
-3, giving 1310 (=011012).

50
2.5 Floating-Point Representation

• Example:
– Express -26.62510 in the revised 14-bit floating-point
model.
• We find 26.62510 = 11010.1012. Normalizing, we have:
26.62510 = 0.11010101 x 2 5.
• To use our excess 16 biased exponent, we add 16 to 5,
giving 2110 (=101012). We also need a 1 in the sign bit.

51
 2.5 Floating-Point Representation

• The IEEE-754 single precision floating point

standard uses bias of 127 over its 8-bit exponent.
– An exponent of 255 indicates a special value.
• If the significand is zero, the value is  infinity.
• If the significand is nonzero, the value is NaN, “not a
number,” often used to flag an error condition.
• The double precision standard has a bias of 1023
over its 11-bit exponent.
– The “special” exponent value for a double precision number
is 2047, instead of the 255 used by the single precision
standard.
52
 2.5 Floating-Point Representation

• Both the 14-bit model that we have presented and

the IEEE-754 floating point standard allow two
representations for zero.
– Zero is indicated by all zeros in the exponent and the
significand, but the sign bit can be either 0 or 1.
• This is why programmers should avoid testing a
floating-point value for equality to zero.
– Negative zero does not equal positive zero.

53
 2.5 Floating-Point Representation

• Floating-point addition and subtraction are done

using methods analogous to how we perform
calculations using pencil and paper.
• The first thing that we do is express both
operands in the same exponential power, then
add the numbers, preserving the exponent in the
sum.
• If the exponent requires adjustment, we do so at
the end of the calculation.

54
2.5 Floating-Point Representation

• Example:

– Find the sum of 1210 and 1.2510 using the 14-bit floating-point model.

• We find 1210 = 0.1100 x 2 4. And 1.2510 = 0.101 x 2 1 = 0.000101 x 2

4
.

• Thus, our sum is

0.110101 x 2 4.

55
2.5 Floating-Point Representation

• Floating-point multiplication is also carried out in

a manner akin to how we perform multiplication
using pencil and paper.

• We multiply the two operands and add their

exponents.

• If the exponent requires adjustment, we do so at

the end of the calculation.
56
2.5 Floating-Point Representation

• Example:
– Find the product of 1210 and 1.2510 using the 14-bit
floating-point model.
• We find 1210 = 0.1100 x 2 4. And 1.2510 = 0.101 x 2 1.
• Thus, our product is
0.0111100 x 2 5 =
0.1111 x 2 4.
• The normalized
product requires an
exponent of 2210 =
101102.
57
 2.5 Floating-Point Representation

• No matter how many bits we use in a floating-point

representation, our model must be finite.
• The real number system is, of course, infinite, so
our models can give nothing more than an
approximation of a real value.
• At some point, every model breaks down,
introducing errors into our calculations.
• By using a greater number of bits in our model, we
can reduce these errors, but we can never totally
eliminate them.
58
 2.5 Floating-Point Representation

• Our job becomes one of reducing error, or at least

being aware of the possible magnitude of error in
our calculations.
• We must also be aware that errors can compound
through repetitive arithmetic operations.
• For example, our 14-bit model cannot exactly
represent the decimal value 128.5. In binary, it is
9 bits wide:
10000000.12 = 128.510
59
 2.5 Floating-Point Representation

• When we try to express 128.510 in our 14-bit model,

we lose the low-order bit, giving a relative error of:
128.5 - 128
 0.39%
128.5

• If we had a procedure that repetitively added 0.5 to

128.5, we would have an error of nearly 2% after
only four iterations.
60
2.5 Floating-Point Representation

• When discussing floating-point numbers, it is

important to understand the terms range and
accuracy.

• The range of a numeric integer format is the

difference between the largest and smallest
values that is can express.

• Accuracy refers to how closely a numeric

representation approximates a true value.
61
 2.6 Character Codes

• Calculations aren’t useful until their results can

be displayed in a manner that is meaningful to
people.

• We also need to store the results of calculations,

and provide a means for data input.

• Thus, human-understandable characters must be

converted to computer-understandable bit
patterns using some sort of character encoding
scheme.
62
 2.6 Character Codes

• As computers have evolved, character codes

have evolved.

• Larger computer memories and storage devices

permit richer character codes.

• The earliest computer coding systems used six

bits.

• Binary-coded decimal (BCD) was one of these

early codes. It was used by IBM mainframes in
the 1950s and 1960s.
63
 2.6 Character Codes

• In 1964, BCD was extended to an 8-bit code,

Extended Binary-Coded Decimal Interchange
Code (EBCDIC).

• EBCDIC was one of the first widely-used

computer codes that supported upper and
lowercase alphabetic characters, in addition to
special characters, such as punctuation and
control characters.
64
 2.6 Character Codes

• EBCDIC and BCD are still in use by IBM

mainframes today.

• Other computer manufacturers chose the 7-bit

ASCII (American Standard Code for Information
Interchange).

• Until recently, ASCII was the dominant character

code outside the IBM mainframe world. 65
 2.6 Character Codes

• Many of today’s systems embrace Unicode, a 16-

bit system that can encode the characters of
every language in the world.

• The Unicode code space is divided into six parts.

• The first part is for Western alphabet codes,

including English, Greek, and Russian.
66
 2.6 Character Codes

• The Unicode codes-

pace allocation is
shown at the right.

• The lowest-numbered
Unicode characters
comprise the ASCII
code.

• The highest provide for

user-defined codes. 67
 2.8 Error Detection and Correction

• It is physically impossible for any data recording or

transmission medium to be 100% perfect 100% of
the time over its entire expected useful life.

• As more bits are packed onto a square centimeter

of disk storage, as communications transmission
speeds increase, the likelihood of error increases.

• Thus, error detection and correction is critical to

accurate data transmission, storage and retrieval.
68
 2.8 Error Detection and Correction

• Check digits, appended to the end of a long

number can provide some protection against data
input errors.

• Longer data streams require more economical and

sophisticated error detection mechanisms.

• Cyclic redundancy checking (CRC) codes provide

error detection for large blocks of data.
69
2.8 Error Detection and Correction

• CRC codes are examples of systematic error

detection.

• In systematic error detection a group of error

control bits is appended to the end of the block
of transmitted data.

• This group of bits is called a syndrome.

70