Digital Representations

Data Representation in Computer Systems

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 they represent high or low voltage

A byte is a group of eight bits.. It is the smallest

possible addressable unit of computer storage.

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

1
 Digital Representations

Binary Representation
• Only two states (0 and 1)
• The binary system is also called the base-2
system MSB LSB

• Easy to implement electronically

0= (0)10 110= (6)10 1100 = (12)10 10010 = (18)10
1= (1)10 111= (7)10 1101 = (13)10 10011 = (19)10
10= (2)10 1000= (8)10 1110 = (14)10 10100 = (20)10
Nibble
% 11 = (3)10 1001= (9)10 1111 = (15)10 :
% 100 = (4)10 1010= (10)10 10000 = (16)10 10011001= (153)10
% 101 = (5)10 1011= (11)10 10001 = (17)10 :
Byte :

word = 16 bits (2 bytes)

long word = 32 bits (4 bytes)
(double)

2
 Digital Representations

Binary Representation

MSB

Nibble

3
 Digital Representations

Decimal to binary
Example : 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.
Note : It is difficult to read long strings of
binary numbers-- and even a modestly-
sized decimal number becomes a very
long binary number.(hence Hex)

4
 Digital Representations

Hexidecimal (HEX) Representation

• Easier to work with than long strings of 1s and 0s
• 16 “digits” each representing 4 bits
• The hexadecimal numbering system uses the
numerals 0 through 9 and the letters A through
F.
8 =1000 = (8)10
0 =0000 = (0)10
9 = 1001 = (9)10
1 = 0001 = (1)10
A = 1010 = (10)10
2 = 0010 = (2)10
B = 1011 = (11)10
3 = 0011 = (3)10
C = 1100 = (12)10
4 = 0100 = (4)10
D = 1101 = (13)10
5 = 0101 = (5)10
E = 1110 = (14)10
6 = 0110 = (6)10
F = 1111 = (15)10
7 = 0111 = (7)10

5
 Digital Representations

Hex to Binary Conversion

• Each Hex digit represents 4 bits
• Simply convert each digit to its 4-bit value

Example: Convert DF3 to binary

(DF3)16 = 1101 1111 0011

6
 Digital Representations

Binary to Hex Conversion

• Create groups of 4 bits (starting with LSB)
• Pad last group with zeros if needed
• Convert each group to corresponding Hex digit

Example: Convert 1101000101 to Hex

1101000101 = 0011 0100 0101
3 4 5

1101000101 = (345)16

7
 Digital Representations
Example for n = 4.47

8
Digital Representations

9
 Digital Representations

Convert 110102 to decimal

110102 = (1  24) + (1  23) + (0  22) + (1  21) + (0  20)
= 16 + 8 + 0 + 2 + 0
= (26)10

10
 Digital Representations

Fixed Precision
• Beware of overflow problems!
• Microprocessors limit numbers to a fixed number of bits:

For example: What is the result of 255 + 1 (assuming 8 bit precision)?

255 = 11111111 = FF
+ 1 = 00000001 = 01
-------------------
256  00000000 = 00

F + 1 = 0, carry
F + 1 (carry) + 0 = 0, carry
Carry out of MSB falls off the end because there is no place to put it!

Final answer is WRONG because could not store carry bit.

11
 Digital Representations
Signed and Unsigned numbers
• Unsigned binary numbers are positive numbers and thus
do not require an arithmetic sign
• An m-bit unsigned number represents all numbers in the
range 0 to 2m − 1.
• For example, the range of 8-bit unsigned binary numbers
is from 0 to 25510 in decimal and from 00 to FF16 in
hexadecimal. Similarly, the range of 16-bit unsigned
binary numbers is from 0 to 65,53510 in decimal and from
0000 to FFFF16 in hexadecimal

12
 Digital Representations
Signed numbers
• Signed numbers, require an arithmetic sign. The
most significant bit of a binary number is used to
represent the sign bit. If the sign bit is equal to
zero, the signed binary number is positive;
otherwise, it is negative.
• The remaining bits represent the actual number.
There are three ways to represent negative
numbers.
1. Sign-Magnitude Representation
2. One's-Complement Representation
3. Two’s complement.

13
 Digital Representations
Signed Magnitude Representation
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

For example, in 8-bit signed magnitude,

Positive 3 is: 00000011
Negative 3 is: 10000011

14
 Digital Representations

• Example:
• Using signed magnitude
binary arithmetic, find the
sum of 75 and 46.
• First, convert 75 and 46 to
binary, andinarrange
For example, asmagnitude,
8-bit signed a sum,
Positive
but 3 is:
separate 00000011
the (positive) sign
Negative 3 is: 10000011
bits from the magnitude bits.

In this example, we were careful careful to pick two

values whose sum would fit into seven bits. If that
is not the case, we have a problem.

15
 Digital Representations

• 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
For example, giving
discarded, in 8-bit signed
us themagnitude,
Positive 3 is: 00000011
erroneous
Negative 3 is:result: 107 + 46 = 25.
10000011

16
 Digital Representations

• Signed magnitude representation is easy for

people to understand, but it requires complicated
computer hardware.
• In the binary system, this gives us one’s
complement.
• It amounts to little more than flipping the bits of a
binary number.

17
 Digital Representations

• 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. The difference of
two values is found by adding the minuend to the
complement of the subtrahend.

18
 Digital Representations

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

19
 Digital Representations

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

20
 Digital Representations
• 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 two’s

complement binary
arithmetic, find the sum of
48 and - 19.
We note that 19 is: 00010011,
so -19 in one’s complement is: 11101100,
and -19 in two’s complement is: 11101101.

21
 Digital Representations

Signed Integers
• Does arithmetic still work?
Example: What is the sum of (-128)10 + (127)10 in binary representation?
(Verify by converting the result to decimal representation.)

Solution: (-128)10 = 10000000

+(127)10 = 01111111
11111111 (in two’s complement)

MSB =1 tells you this

is a negative number Complement and add 1 to get magnitude
%00000000 + %00000001 = %0000001 = (1)10

Final result is (-1)10

22
 Digital Representations

Two’s Complement Overflow

• What happens if we do (1)10 + (127)10 using
two’s complement representation?
(1)10 = 00000001
+(127)10 = 01111111
10000000 (in two’s complement)

MSB =1 tells you this

is a negative number Complement and add 1 to get magnitude
01111111 + 00000001 = 10000000 = (128)10

Final result is (128)10

23
 Digital Representations

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

24
 Digital Representations
• 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.

25
 Digital Representations

• Signed and unsigned numbers are both useful.

• For example, memory addresses are always unsigned.
• Using the same number of bits, unsigned integers
can express twice as many values as signed
numbers.
• Trouble arises if an unsigned value “wraps around.”
• In four bits: 1111 + 1 = 0000.
• Good programmers stay alert for this kind of problem.

26
 Digital Representations

Signed integer Multiplication

• Research into finding better arithmetic algorithms has
continued apace for over 50 years.
• One of the many interesting products of this work is
Booth’s algorithm.
• In most cases, Booth’s algorithm carries out
multiplication faster and more accurately than naïve
pencil-and-paper methods.
• The general idea is to replace arithmetic operations
with bit shifting to the extent possible.

27
 Digital Representations

Floating-Point Representation
• The signed magnitude, 1’s complement, and
2’s complement representations as such are
not useful in scientific or business applications
that deal with real number values over a wide
range.
• Floating-point representation solves this
problem.

28
 Digital Representations

• Computers use a form of scientific notation for

floating-point representation
• Numbers written in scientific notation have three
components:

29
 Digital Representations

• Computer representation of a floating-point number

consists of three fixed-size fields:

• This is the standard arrangement of these fields.

30
 Digital Representations

• 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 determines the precision
of the representation.

31
 Digital Representations

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

32
 Digital Representations

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

33
 Digital Representations

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

34
 Digital Representations
• 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.

35
 Digital Representations

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

36
 Digital Representations

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

In our simple instructional model,

we will use no implied bits.

37
 Digital Representations

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

38
 Digital Representations

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

39
 Digital Representations

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

40
 Digital Representations
• 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.

41
 Digital Representations

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

42
 Digital Representations

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

43
 Digital Representations

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

44
 Digital Representations

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

45
 Digital Representations
• 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.

46
 Digital Representations

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

47
 Digital Representations
• 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.

48