Introduction to computer science ch3. number representation

(1)

Chapter 3

Number

(2)

Convert a number from decimal to binary notation and

vice versa.

Understand the different representations of an integer inside

a computer: unsigned, sign-and-magnitude, one’s complement,

and two’s complement.

Understand the Excess system that is used to store the

exponential part of a floating-point number.

After reading this chapter, the reader should

be able to :

O

BJECTIVES

Understand how floating numbers are stored inside a computer

using the exponent and the mantissa.

(3)

DECIMAL

AND

BINARY

DECIMAL

AND

BINARY

3.1

(4)

Figure 3-1

(5)

Figure 3-2

(6)

CONVERSION

3.2

(7)

Figure 3-3

(8)

Example 1

Convert the binary number 10011 to decimal.

Solution

Write out the bits and their weights. Multiply the bit by its corresponding weight and record the result. At the end, add the results to get the decimal number.

Binary 1 0 0 1 1

Weights 16 8 4 2 1 16 + 0 + 0 + 2 + 1

(9)

Example 2

Convert the decimal number 35 to binary.

Solution

Write out the number at the right corner. Divide the number continuously by 2 and write the quotient and the remainder. The quotients move to the left, and the remainder is recorded under each quotient. Stop when the quotient is zero.

0  1  2  4  8  17  35 Dec.

(10)

Figure 3-4

(11)

Figure 3-7

(12)

Example 17

Transform the fraction 0.875 to binary

Solution

Write the fraction at the left corner. Multiply the

number continuously by 2 and extract the

integer part as the binary digit. Stop when the

number is 0.0.

0.875  1.750  1.5  1.0  0.0 0

.

1 1 1

(13)

Example 18

Transform the fraction 0.4 to a binary of 6 bits.

Solution

Write the fraction at the left cornet. Multiply the

number continuously by 2 and extract the

integer part as the binary digit. You can never

get the exact binary representation. Stop when

you have 6 bits.

0.4  0.8  1.6  1.2  0.4  0.8  1.6 0

.

0 1 1 0 0 1

(14)

INTEGER

REPRESENTATION

INTEGER

REPRESENTATION

3.4

(15)

Figure 3-5

(16)

Figure 3-6

(17)

Table 3.1 Range of unsigned integers

# of Bits # of Bits ---8 16 RangeRange ---0 255 0 65,535

(18)

Example 3

Store 7 in an 8-bit memory location.

Solution

First change the number to binary 111. Add five

0s to make a total of N (8) bits,

0s to make a total of N (8) bits, 0000011100000111. The . The number is stored in the memory location.

(19)

Example 4

Store 258 in a 16-bit memory location.

Solution

First change the number to binary 100000010.

Add seven 0s to make a total of N (16) bits,

Add seven 0s to make a total of N (16) bits, 0000000100000010

0000000100000010. The number is stored in the . The number is stored in the memory location.

(20)

Table 3.2 Example of storing unsigned integers in

two different computers

(

( 一個為一個為 _8-bit;_8-bit; 另一個為另一個為 _16-bit)_16-bit)

Decimal Decimal ---7 234 258 24,760 1,245,678 8-bit allocation 8-bit allocation ---00000111 11101010 overflow overflow overflow 16-bit allocation 16-bit allocation ---0000000000000111 0000000011101010 0000000100000010 0110000010111000 overflow

(21)

Example 5

Interpret 00101011 in decimal if the number

was stored as an unsigned integer.

Solution

Using the procedure shown in Figure

3.3 , the number in decimal is

(22)

Table 3.3 Range of sign-and-magnitude integers

# of Bits # of Bits ---8 16 32 127 0 32767 0  0 +0 +127 +0 +32767 +0 +2,147,483,647 Range Range

(23)

---In sign-and-magnitude representation,

In sign-and-magnitude representation,

the leftmost bit defines the sign of the

number. If it is 0, the number is

positive.If it is 1, the number is negative.

Note:

(24)

There are two 0s in

sign-and-magnitude

magnitude

representation: positive and

negative.

In an 8-bit allocation:

+0



00000000

-0



10000000

_10000000

Note:

(25)

Example 6

Store +7 in an 8-bit memory location using

sign-and-magnitude representation.

Solution

First change the number to binary 111. Add

four 0s to make a total of N-1 (7) bits,

four 0s to make a total of N-1 (7) bits, 00001110000111. . Add an extra zero because the number is

Add an extra zero because the number is

positive. The result is:

(26)

Example 7

Store –258 in a 16-bit memory location

using sign-and-magnitude representation.

Solution

Add six 0s to make a total of N-1 (15) bits,

Add six 0s to make a total of N-1 (15) bits, 000000100000010

000000100000010. Add an extra 1 because the . Add an extra 1 because the number is negative. The result is:

number is negative. The result is:

(27)

Table 3.4 Example of storing sign-and-magnitude integers

in two computers in two computers Decimal Decimal ---+7 -124 +258 -24,760 8-bit allocation 8-bit allocation ---00000111 11111100 overflow overflow 16-bit allocation 16-bit allocation ---0000000000000111 1000000001111100 0000000100000010 1110000010111000

(28)

Example 8

Interpret 10111011 in decimal if the number

was stored as a sign-and-magnitude integer.

Solution

Ignoring the leftmost bit, the remaining bits are

0111011. This number in decimal is 59. The

leftmost bit is 1, so the number is

(29)

There are two 0s in one’s

complement

representation: positive and

negative.

In an 8-bit allocation:

+0



00000000

-0



11111111

_11111111

Note:

(30)

One’s complement

( 一位補數法 )

• If the sign is positive (0), no more action is needed;

• If the sign is negative, every bit is complemented.

(31)

Table 3.5 Range of one’s complement integers

# of Bits # of Bits ---8 16 32 127 0 32767 0  0 +0 +127 +0 +32767 +0 +2,147,483,647 Range Range

(32)

---In one’s complement representation,

In one’s complement representation,

the leftmost bit defines the sign of the

number. If it is 0, the number is

positive.If it is 1, the number is negative.

Note:

(33)

Example 9

Store +7 in an 8-bit memory location using

one’s complement representation.

Solution

0s to make a total of N (8) bits, 0000011100000111. The . The sign is positive, so no more action is needed. The

sign is positive, so no more action is needed. The

result is:

(34)

Example 10

Store –258 in a 16-bit memory location

using one’s complement representation.

Solution

Add seven 0s to make a total of N (16) bits,

Add seven 0s to make a total of N (16) bits, 0000000100000010

0000000100000010. The sign is negative, so . The sign is negative, so each bit is complemented. The result is:

each bit is complemented. The result is:

(35)

Table 3.6 Example of storing one’s complement integers in

Decimal Decimal ---      8-bit allocation 8-bit allocation ---00000111 11111000 01111100 10000011 overflow overflow 16-bit allocation 16-bit allocation ---0000000000000111 1111111111111000 0000000001111100 1111111110000011 0110000010111000 1001111101000111

(36)

Example 11

Interpret 11110110 in decimal if the number

was stored as a one’s complement integer.

Solution

The leftmost bit is 1, so the number is negative.

First complement it . The result is 00001001.

The complement in decimal is 9. So the original

number was

number was –9–9. Note that complement of a _{. Note that complement of a}

complement is the original number.

(37)

One’s complement means reversing all

bits. If you one’s complement a positive

number, you get the corresponding

negative number. If you one’s

complement a negative number, you get

the corresponding positive number. If

you one’s complement a number twice,

you get the original number.

Note:

(38)

Two’s complement is the most common,

the most important, and the most widely

used representation of integers today.

Note:

(39)

Two’s complement

• If the sign is positive, no further action is needed;

• If the sign is negative, leave all the rightmost 0s and the first 1 unchanged. Complement the rest of the bits

e.g. 00000000001010000000000000101000

1111111111011000_1111111111011000

(40)

Two’s complement 的另類看法

00000000001010000000000000101000 111111111101 11111111110110001000 1. 1. 00000000001010000000000000101000 1111111111010111 1111111111010111 11111111110110001111111111011000 One’s complement +1 2. 216-0000000000101000_{0000000000101000} 1000000000000000010000000000000000 -) 0000000000101000 -) 0000000000101000 11111111110110001111111111011000

(41)

Table 3.7 Range of two’s complement integers

# of Bits # of Bits ---8 16 32 128  32,768  0 +127 0 +32,767 0 +2,147,483,647 Range Range

(42)

---In two’s complement representation,

In two’s complement representation,

the leftmost bit defines the sign of the

number. If it is 0, the number is positive.

If it is 1, the number is negative.

Note:

(43)

Example 12

Store +7 in an 8-bit memory location using

two’s complement representation.

Solution

0s to make a total of N (8) bits, 0000011100000111.The .The

sign is positive, so no more action is needed. The

result is:

(44)

Example 13

Store –40 in a 16-bit memory location using two’s complement representation.

Solution

First change the number to binary 101000. Add

ten 0s to make a total of N (16) bits,

ten 0s to make a total of N (16) bits, 0000000000101000

0000000000101000. The sign is negative, so . The sign is negative, so

leave the rightmost 0s up to the first 1 (including

the 1) unchanged and complement the rest. The

result is:

(45)

Table 3.8 Example of storing two’s complement integers in

Decimal Decimal ---      8-bit allocation 8-bit allocation ---00000111 11111001 01111100 10000100 overflow overflow 16-bit allocation 16-bit allocation ---0000000000000111 1111111111111001 0000000001111100 1111111110000100 0110000010111000 1001111101001000

(46)

There is only one 0 in two’s

complement:

In an 8-bit allocation:

0

0 



00000000

Note:

(47)

Example 14

Interpret 11110110 in decimal if the number

was stored as a two’s complement integer.

Solution

The leftmost bit is 1. The number is negative.

Leave 10 at the right alone and complement the

rest. The result is 00001010. The two’s

complement number is 10. So the original

number was

(48)

Two’s complement can be achieved by

reversing all bits except the rightmost bits up to

the first 1 (inclusive). If you two’s complement

a positive number, you get the corresponding

negative number. If you two’s complement a

negative number, you get the corresponding

positive number. If you two’s complement a

number twice, you get the original number.

Note:

(49)

Table 3.9 Summary of integer representation

Contents of Contents of Memory Memory ---0000 0001 0010 0011 0100 0101 0110 0111 1000 1001 1010 1011 1100 1101 1110 1111 Unsigned Unsigned ---0 0 1 1 2 2 3 3 4 4 5 5 6 6 7 7 8 8 9 9 10 10 11 11 12 12 13 13 14 14 15 15 Sign-and-Magnitude Magnitude                                   One’s One’s Complement Complement                                   Two’s Two’s Complement Complement                                  

(50)

EXCESS

SYSTEM

EXCESS

SYSTEM

3.5

(51)

Example 15

Represent –25 in Excess_127 using an 8-bit

allocation.

Solution

First add 127 to get 102. This number in

binary is 1100110. Add one bit to make it 8

bits in length. The representation is

01100110

(52)

Example 16

Interpret 11111110 if the representation is

Excess_127.

Solution

First change the number to decimal. It

is 254. Then subtract 127 from the

number. The result is decimal

(53)

FLOATING-POINT

REPRESENTATION

FLOATING-POINT

REPRESENTATION

3.5

(54)

Table 3.10 Example of normalization

Original Number Original Number ---+1010001.1101 -111.000011 +0.00000111001 -001110011 Move Move --- 6  2 6  3  Original Number Original Number ---    Normalized x x x x

(55)

Figure 3-8

(56)

Example 19

Show the representation of the normalized

number

+ 2

6

x 1.01000111001

Solution

The sign is positive. The Excess_127 representation of

the exponent is 133. You add extra 0s on the right to

make it 23 bits. The number in memory is stored as:

(57)

Table 3.11 Example of floating-point representation

Sign Sign ----1 0 1 Mantissa ---11000011000000000000000 11001000000000000000000 11001100000000000000000 Number -22_{x 1.11000011} +2-6_{x 1.11001} -2-3_{x 1.110011} Exponent Exponent ---10000001 01111001 01111100

(58)

Example 20