CSc 252 Computer Organization 2 Binary Numbers 1

Storing Information Digitally

Read: Sections 3.1 - 3.2
Binary Basics:

Why binary numbers?

In a digital computer, all information is represented using the binary number system.

It is easy to build fast electronic circuits that operate on the basis of two states: on and off.

Number systems:

Labeling the columns, representing nine hundred forty-two in base 10 (decimal):

Hundreds Tens Units
9
10
2
9 * 10
2
4
10
1
4 * 10
1
2
10
0
2 * 10
0
CSc 252 Computer Organization 2 Binary Numbers
Binary Basics (continued):

Range of possible values:

For a three-digit number, the maximum is:

One less than one thousand (10

3
).

In general, for an N-digit number, the range is 0 to 10

N
- 1.

Addition:
9
9
4
4
2
2 +
1 9 1 1
1 1
2 + 9 = 1 * 10
1
+ 1 * 10
0
Carry
thousand
Carry
ten
2
Hundreds Tens Units
9
10
2
9 * 10
2
9
10
1
9 * 10
1
9
10
0
9 * 10
0
CSc 252 Computer Organization 2 Binary Numbers
Binary Basics (continued):

Lets consider an 8 digit binary number: 1010 1011

Label the columns starting at the right in increasing powers of 2:

To convert to decimal, add the decimal values for each place that has a 1:
= 128 + 32 + 8 + 2 + 1 = 171ten.

Range of an N-digit, binary number: 0 .. 2

N
- 1

For an 8-digit number, this would be 0000 0000two to 1111 1111two, or 0 .. 2

8
-1, or 0ten to 255ten.
3
1 0 1 0 1 0 1 1
2
7
2
6
2
5
2
4
2
3
2
2
2
1
2
0
128s 64s 32s 16s 8s 4s 2s 1s

Terminology:

Each binary digit is called a bit.

Eight binary digits make up a byte.

Four binary digits thus make a nibble (really! :-)

The left most bit is called the most signicant bit, or MSB.

The right most bit is called the least signicant bit, or LSB.
CSc 252 Computer Organization 2 Binary Numbers
= 42
ten
= 31
ten
= 73
ten
0 0 1
1 1 1 1 1
0 1 0 1 0
0 0 1 0 1 1 1 1
0 1 0 0 1 0 0 1
+
= 1*2
5
+ 1*2
3
+ 1*2
1
= 1*2
4
+ 1*2
3
+ 1*2
2
+ 1*2
1
+ 1*2
0
= 1*2
6
+ 1*2
3
+ 1*2
0
1+1+1 = 1*2
1
+ 1*2
0
Binary Addition:

Binary Addition, again:

0 0 0
1 1 1 1 1
0 1 0 1 1
0
0 0 1 0 0 0 0 0
0 0 1 0 1 0 1 +
= 1*2
3
+ 1*2
1
+ 1*2
0
= 1*2
4
+ 1*2
2
+ 1*2
0
= 1*2
5
= 11
ten
= 21
ten
= 32
ten
4
CSc 252 Computer Organization 2 Binary Numbers
Overow:

Computing devices can only represent binary numbers up to a xed number of bits.

Machines are nite.

This introduces the problem of overow.

Binary Addition if we only have 8 bits (1 byte) to hold each number:

1 0 0 0 1
1 1 1 1
1 1 0
1 0 0 0 1 1 0 0
0 0 0 0 1 1 0 0
+
= 1*2
7
+ 1*2
3
+ 1*2
2
+ 1*2
1
= 1*2
7
+ 1*2
1
+ 1*2
0
= 1*2
4
+ 1*2
0
= 142
ten
= 131
ten
= 17
ten
5

We can solve the problem by using more than 8 bits.

Most systems use (at least) 32 bits, 4 bytes, to represent an integer.

The MIPS architecture that we will be using does this.

Can still have an overow problem:

1 1
10000000 10000000 00000000 00000010 = 1*2
31
+ 1*2
23
+ 1*2
1
= 2,155,872,258
+ 10000000 00000000 10000000 00000011 = 1*2
31
+ 1*2
15
+ 1*2
1
+ 1*2
0
= 2,147,516,419
00000000 10000000 10000000 00000101 = 1*2
23
+ 1*2
15
+ 1*2
2
+ 1*2
0
= 8,421,381
CSc 252 Computer Organization 2 Binary Numbers
Signed and Unsigned Numbers:

Sometimes we only want to represent positive numbers and zero.

Best example: Addresses located in the computers memory.

Other times, we need to represent both positive and negative numbers.

The basic idea: Use one bit to represent the sign.

Want to represent a range of positive numbers, and a range of negative numbers, and zero.

Three methods have been used for representing negative numbers:

Sign and Magnitude.

Ones Complement.

Twos Complement.

None of these is perfect.

6
CSc 252 Computer Organization 2 Binary Numbers
Signed and Unsigned Numbers (continued):

Sign and Magnitude:

Use the left most bit to signal whether the

number is positive or negative.

Left most bit is then the sign bit.

Range: -(2
N-1
- 1) .. +(2
N-1
- 1)

Problems:

Need separate electronic circuits for

manipulating the sign bits.

Two distinct representations of zero.

Causes problems with comparing a

number to zero.

Results in two comparisons.

Comparison to zero happens a lot!!

7
8-bit, Sign and Magnitude Values 8-bit, Sign and Magnitude Values
Positive Numbers Negative numbers
0000 0000 = 0ten
0000 0001 = 1ten
0000 0010 = 2ten
0000 0011 = 3ten
0000 0100 = 4ten
0000 0101 = 5ten
0000 0110 = 6ten
0000 0111 = 7ten
0000 1000 = 8ten
0000 1001 = 9ten
...
0111 1111 = ?ten
1000 0000 = -0ten
1000 0001 = -1ten
1000 0010 = -2ten
1000 0011 = -3ten
1000 0100 = -4ten
1000 0101 = -5ten
1000 0110 = -6ten
1000 0111 = -7ten
1000 1000 = -8ten
1000 1001 = -9ten
...
1111 1111 = -?ten
CSc 252 Computer Organization 2 Binary Numbers
8-bit, Ones Complement Values 8-bit, Ones Complement Values
Positive Numbers Negative numbers
00000000 = 0ten
00000001 = 1ten
00000010 = 2ten
00000011 = 3ten
00000100 = 4ten
00000101 = 5ten
00000110 = 6ten
00000111 = 7ten
00001000 = 8ten
00001001 = 9ten
...
01111111 = ?ten
11111111 = -0ten
11111110 = -1ten
11111101 = -2ten
11111100 = -3ten
11111011 = -4ten
11111010 = -5ten
11111001 = -6ten
11111000 = -7ten
11110111 = -8ten
11110110 = -9ten
...
10000000 = -?ten
Signed and Unsigned Numbers (continued):

Ones Complement:

Any pattern whose sign bit is 1 represents a

negative value.

Change (complement) every 1 to 0 and every 0

to 1.

Range: -(2
N-1
- 1) .. +(2
N-1
- 1)

Same as Sign and Magnitude.

Advantage over Sign and Magnitude:

Easier to design circuits which perform

arithmetic on numbers represented in this
form.

Especially: easy to convert a positive number

to a negative number (and vice versa).

Problem:

Two distinct representations of zero (still!).

8
CSc 252 Computer Organization 2 Binary Numbers
Signed and Unsigned Numbers (continued):

Twos Complement:

To switch between the positive and negative,

there are two steps:

Invert: each 1 to a 0 and each 0 to a 1,

Then, add 1 to get the nal value.

E.g.,
1 1 1 1 1 0 1 1 = -5ten
0 0 0 0 0 1 0 0 Invert step
+ 1 Add 1 step
0 0 0 0 0 1 0 1 = 5ten

E.g.,
0 0 0 0 1 0 0 0 = 8ten
1 1 1 1 0 1 1 1 Invert step
+ 1 Add 1 step
1 1 1 1 1 0 0 0 = -8ten
9
8-bit, Twos Complement Values 8-bit, Twos Complement Values
Positive Numbers Negative numbers
00000000 = 0ten
00000001 = 1ten
00000010 = 2ten
00000011 = 3ten
00000100 = 4ten
00000101 = 5ten
00000110 = 6ten
00000111 = 7ten
00001000 = 8ten
00001001 = 9ten
...
01111111 = ?ten
00000000 = -0ten
11111111 = -1ten
11111110 = -2ten
11111101 = -3ten
11111100 = -4ten
11111011 = -5ten
11111010 = -6ten
11111001 = -7ten
11111000 = -8ten
11110111 = -9ten
...
10000000 = -?ten

Same as Ones Complement, but you add an extra

one (hence, Twos Complement).
CSc 252 Computer Organization 2 Binary Numbers
Signed and Unsigned Numbers (continued):

Only one zero. Apply Twos Complement to zero (16-bit version shown):
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 Invert step
+ 1 Add 1 step
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

We lost the 1 that carried out past the left side in that addition (did you notice?).

Solves the problem of two representations of zero.

However, the negative value 10000000 00000000 does not have an equivalent positive representation:
1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 Invert step
+ 1 Add 1 step
1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

Range is therefore: -(2

N-1
) .. +(2
N-1
- 1)

For 8-bit values: -128ten .. +127ten

For 16-bit values: -32,768ten .. +32,767ten

For 32-bit values: -2,147,483,648ten .. +2,147,483,647ten

10
CSc 252 Computer Organization 2 Binary Numbers
Sign Extension:

Often you will have a number that needs to be padded out to a larger number of bits. For example, an 8-bit value
to place in a 16-bit storage location; or, a 16-bit value in a 32-bit location; etc.

Put the number in the least signicant bits of the location and pad to the left by replicating the sign bit.

For example, starting with an 8-bit representation of -6ten:

8-bits: 1 1 1 1 1 0 1 0
16-bits: 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 0
32-bits: 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 0

Analogously for positive numbers: extend the zero on the left.

For example, starting with a 16-bit representation of 312ten:

16-bits: 0 0 0 0 0 0 0 1 0 0 1 1 1 0 0 0
32-bits: 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 1 1 0 0 0
11
CSc 252 Computer Organization 2 Binary Numbers
Binary Arithmetic:

Addition:
1 1 1 1 1
0 0 0 1 1 1 1 1 = 31ten
+ 1 1 0 1 0 1 1 1 = + -41ten
1 1 1 1 0 1 1 0 = -10ten

Subtraction:


1 0 0 0 1 1 1 0 = -114ten
- 1 0 0 0 0 0 1 1 = - -125ten
= 11ten
10
0
1 0 0 0 0 1 1 = 11ten 0
0 10
1
12
CSc 252 Computer Organization 2 Binary Numbers
Binary Arithmetic (continued):

Easier approach: Change the subtrahend by nding its Twos Complement, then Add the two values:
1 0 0 0 1 1 1 0 = -114ten
- 1 0 0 0 0 0 1 1 = - -125ten
13
Find the twos complement of the subtrahend:
1 0 0 0 0 0 1 1
0 1 1 1 1 1 0 0 Invert step
+ 1 Add 1 step
0 1 1 1 1 1 0 1 Twos complement of subtrahend
Now, add the two numbers:
1 1 1 1 1 1
1 0 0 0 1 1 1 0
+ 0 1 1 1 1 1 0 1
0 0 0 0 1 0 1 1 Ignore the carry out
CSc 252 Computer Organization 2 Binary Numbers
Step 3:
pad with 0s to 16-bits
sign-bit for positive number:
0 0 0 0 0 0 0 0 1 0 0 0 0 1 1 1
Step 4:
Twos complement to get
negative number:
1 1 1 1 1 1 1 1 1 0 1 1 0 1 0 0
+ 1
1 1 1 1 1 1 1 1 1 0 1 1 0 1 0 1
Step 2:
= 1 0 0 1 0 1 1
75 2
37 2
18 2
9 2
4 2
2 2
1
1
1
0
1
0
0
1
2
0
Step 1:
Step 2:
= 1 0 0 0 0 1 1 1
135 2
67 2
33 2
16 2
8 2
4 2
2 2
1 2
0 1
0
0
0
0
1
1
1
Step 1:
14

For a negative number, nd its positive

representation, then nd its Twos
Complement:
Converting Decimal to Binary:

Successive Division:

Keep dividing by two.

The remainders form the binary result.

Note the order in which the remainders are

collected!

(16-bit example, since 135ten will not t in a

signed 8-bit number):
Step 3:
pad to 16-bits with zero
sign-bit for positive number:
0 0 0 0 0 0 0 0 0 1 0 0 1 0 1 1
CSc 252 Computer Organization 2 Binary Numbers
135 we cant 0 subtract 16,384
135 we cant 0 subtract 8,192
135 we cant 0 subtract 4,096
135 we cant 0 subtract 2,048
135 we cant 0 subtract 1,024
135 we cant 0 subtract 512
135 we cant 0 subtract 256
135 we can 1 subtract 128 ( remainder 7 )
7 we cant 0 subtract 64
7 we cant 0 subtract 32
7 we cant 0 subtract 16 = 0 0 0 0 0 0 0 0 1 0 0 0 0 1 1 1
7 we cant 0 subtract 8
7 we can 1 subtract 4 ( remainder 3 )
3 we can 1 subtract 2 ( remainder 1 )
1 we can 1 subtract 1 ( remainder 0 )
Converting Decimal to Binary (continued):

Successive Subtraction: Subtract powers of two (16-bit example):

Convert 135ten to binary:

For 16-bit, signed value, we start with 2

14
= 16,384:
15
CSc 252 Computer Organization 2 Binary Numbers
Multiplication in Binary:

4-bit example:
1 0 0 0
* 0 1 1 0
0 0 0 0
1 0 0 0
1 0 0 0
0 0 0 0
0 1 1 0 0 0 0

Note: we ended up with more than a 4-bit answer.

In general, to multiply two N-bit binary numbers, you need to allow for up to 2 * N bits in the answer. For
example:
1 1 0 0
* 1 1 0 1
1 1 0 0
0 0 0 0
1 1 0 0
1 1 0 0
1 0 0 1 1 1 0 0
16
CSc 252 Computer Organization 2 Binary Numbers
Multiplication in Binary (continued):

Multiplying by two is a shift left operation:

0 0 1 1 0 0 1 1
* 1 0
0 0 0 0 0 0 0 0
0 0 1 1 0 0 1 1
0 0 1 1 0 0 1 1 0

Works with both signed and unsigned integers.

Unsigned:
0 0 1 0 1 1 0 1 = 2
5
+ 2
3
+ 2
2
+ 2
0
= 32 + 8 + 4 + 1 = 45ten
0 1 0 1 1 0 1 0 = 2
6
+ 2
4
+ 2
3
+ 2
1
= 64 + 16 + 8 + 2 = 90ten
1 0 1 1 0 1 0 0 = 2
7
+ 2
5
+ 2
4
+ 2
2
= 128 + 32 + 16 + 4 = 180ten

What happens when we shift left again?

Signed:
1 1 1 0 0 0 0 0 = -32ten
1 1 0 0 0 0 0 0 = -64ten
1 0 0 0 0 0 0 0 = ??

If we shift left again?

17
CSc 252 Computer Organization 2 Binary Numbers
Division in Binary:

85ten / 6ten = 14 !

Dividing by two is a shift right operation:

18
1 0 1 0 1 0 1 1 1 0
1 1 1 0 quotient
1 1 0
1 0 0 1
1 1 0
1 1 0
1 1 0
1 remainder
1110 = 2
3
+ 2
2
+ 2
1

= 8 + 4 + 2
= 14ten
0 0 1 1 0 0 1 1 1 0
1 1 0 0 1 quotient
1 0
1 0
0 0 1 1
1 0
1
1 0
CSc 252 Computer Organization 2 Binary Numbers
Division in Binary (continued):

Signed number:

How does shift right maintain the correct result for dividing by 2?

Arithmetic shift right: replicate the sign bit when shifting:

-31ten = 1110 0001two

Shift right: 1111 0000two

0000 1111 Invert step
+ 1 Add one
0001 0000 = 2
4
= 16ten

-16ten is the correct result.

19
CSc 252 Computer Organization 2 Binary Numbers
Signed Numbers Detecting Overow:

No overow possible when adding a positive and a negative number: positive + negative negative + positive

No overow possible when the signs are the same for subtraction: positive - positive negative - negative

Overow occurs when the answer makes the sign wrong:

Examples using 8-bit, Twos Complement integers:

Overow: adding two positives yields a negative (answer should be positive)

1 1 1
0 1 1 0 1 1 1 0 110ten
+ 0 1 0 0 0 1 0 0 + 68ten
1 0 1 1 0 0 1 0 -78ten

Overow: adding two negatives gives a positive (answer should be negative)

1
1 0 0 1 0 0 1 1 -109ten
+ 1 1 0 0 1 1 0 0 + - 52ten
0 1 0 1 1 1 1 1 95ten
Note: With signed numbers, whether there is, or is not, a carry-out on the left tells you nothing about
whether overow did or did not occur!
20
CSc 252 Computer Organization 2 Binary Numbers
Signed Numbers Detecting Overow (continued):

Overow: subtract a negative from a positive and get a negative (should be positive).
0 1 1 1 1 1 1 1 127ten
- 1 1 1 1 1 1 1 1 - -1ten
1 0 0 0 0 0 0 0 -> Twos complement for -128, but answer should be +128.

Overow: subtract a positive from a negative and get a positive (should be negative).
1 0 0 0 0 0 0 1 -127ten
- 0 0 0 0 0 1 0 1 - +5ten
0 1 1 1 1 1 0 0 -> Twos complement for +124ten, but answer should be -132ten

Figure 3.2, page 226:

21
Operation Operand A Operand B
Result indicating
overow
A + B ! 0 ! 0 < 0
A + B < 0 < 0 ! 0
A - B ! 0 < 0 < 0
A - B < 0 ! 0 ! 0
CSc 252 Computer Organization 2 Binary Numbers
Signed Numbers Detecting Overow (continued):

Okay, so do we really care?

Sometimes, we do not!

Ignore any overows that occur.

Java example:
import java.io.*;
public class Zap {
public static void main (String args[]) {
int i, j;
for (i = 2147483640, j = 0; j < 15; i++, j++)
System.out.println("i = " + i + " j = " + j);
} // main
} // class Zap

Sometimes, we do

Duplicate versions of assembly language instructions that cause an exception when overow occurs.

MIPS uses this approach:

add, addi, sub cause exceptions on overow.

addu, addiu, subu do not cause exceptions on overow.

22
CSc 252 Computer Organization 2 Binary Numbers
Hexadecimal and Octal:

Binary can be difcult to read and write (for us humans :-).

An alternative is to use octal notation.

Octal = base 8.

3 binary digits = 1 octal digit.

Counting exercise: What ten numbers follow:

75,

377,
23
Binary Octal
000
001
010
011
100
101
110
111
0
1
2
3
4
5
6
7
CSc 252 Computer Organization 2 Binary Numbers
Hexadecimal and Octal (continued):

Converting octal to/from binary:

Group the binary number into groups of three digits, starting from the right.

Examples:
00 110 111two = 067octal
10 101 001two = 251octal
11 111 111two = 377octal
01 110 100 010 101 011 111 010 010 101 100two = ??

Converting octal to/from decimal:

My preference: convert to binary rst:

117octal = 001 001 111two = 2
6
+ 2
3
+ 2
2
+ 2
1
+ 2
0
= 64 + 8 + 4 + 2 + 1 = 79ten

But, you can do it directly:

2,143octal = 2 * 8
3
+ 1 * 8
2
+ 4 * 8
1
+ 3 * 8
0
= 2 * 512 + 64 + 32 + 3 = 1,123ten

8
3
= (2
3
)
3
= 2
9
= 512 8
4
= 2
12
= 2
2
* 2
10
= 4 * 1,024 = 4,096 8
5
= 2
15
= ???
24
CSc 252 Computer Organization 2 Binary Numbers
Hexadecimal and Octal (continued):

Converting octal to/from decimal (continued):

Convert 1,293ten to octal

25
1293
2
646
2
323
2
161
2
80
2
40
2
20
2
10
2
5
2
2
2
1
2
0
1
0
1
1
0
0
0
0
1
0
1
= 10100001101two
= 10 100 001 101two
= 2 4 1 5octal
My preference:
Convert to binary, then to octal:
1293
8
8
8
161
20
2
0
5
1
4
2
= 2,415octal
8
Can be done directly
using successive division:
Conversion Exercises:
1. Convert 3,724octal to decimal.
2. Convert 1,562ten to octal.
CSc 252 Computer Organization 2 Binary Numbers
Hexadecimal and Octal (continued):

More common today: base 16 (hexadecimal):

Counting exercise: What ten hexadecimal numbers follow:

97,

2F9,
26
Binary Hexadecimal Binary Hexadecimal
0000
0001
0010
0011
0100
0101
0110
0111
0
1
2
3
4
5
6
7
1000
1001
1010
1011
1100
1101
1110
1111
8
9
A
B
C
D
E
F
CSc 252 Computer Organization 2 Binary Numbers
Hexadecimal and Octal (continued):

Convert hexadecimal to/from binary:

Group the binary number in groups of four digits, starting from the right.

Examples:
0100 1001two = 49hex
1111 1111two = FFhex
0110 1100two = 6Chex
1001 1000 1101 1011 1100 0100 0101 0011two =
9 8 D B C 4 5 3hex
0110 1101 1011 0110 1100 0100 1011 1110two = ??
2F 37 A0 C6hex = ??
27
CSc 252 Computer Organization 2 Binary Numbers
Hexadecimal and Octal (continued):

Converting hexadecimal to/from decimal:

My preference: convert to binary rst:

AC8Ehex = 1010 1100 1000 1110two = 2
15
+ 2
13
+ 2
11
+ 2
10
+ 2
7
+ 2
3
+ 2
2
+ 2
1
=

32,768 2
15

8,192 2
13

2,048 2
11

1,024 2
10

128 2
7

8 2
3

4 2
2

+ 2 2
1

44,174ten

But, you can do it directly:

AC8Ehex = 10 * 16
3
+ 12 * 16
2
+ 8 * 16
1
+ 14 * 16
0
=

40,960 10 * 4,096

3,072 12 * 256

128 8 * 16

+ 14 14 * 1

44,174ten
28
CSc 252 Computer Organization 2 Binary Numbers
Hexadecimal and Octal (continued):

Converting hexadecimal to/from decimal (continued):

Convert 3,164ten to hexadecimal.

29
3164
16
16
197
12
0
12
5
12
= C5Chex
16
Can be done directly
using successive division:
Conversion Exercises:
1. Convert 5B C7hex to decimal.
2. Convert 9,127ten to hexadecimal.
3164
2
1582
2
791
2
395
2
197
2
98
2
49
2
24
2
12
2
6
2
3
2
1
0
0
1
1
1
0
1
0
0
0
1
1
= 110001011100two
= 1100 0101 1100two
= C 5 Chex
My preference:
Convert to binary, then to hexadecimal:
2
0
CSc 252 Computer Organization 2 Binary Numbers
Hexadecimal and Octal (continued):

Multiplication table for hexadecimal:

Complete the rows for 4 and 8 (they are useful) and F (for fun :-)
30
0 1 2 3 4 5 6 7 8 9 A B C D E F
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
1 0 1 2 3 4 5 6 7 8 9 A B C D E F
2 0 2 4 6 8 A C E 10 12 14 16 18 1A 1C 1E
3 0 3
4 0 4
5 0 5
6 0 6
7 0 7
8 0 8
9 0 9
A 0 A
B 0 B
C 0 C
D 0 D
E 0 E
F 0 F
CSc 252 Computer Organization 2 Binary Numbers
Floating Point (a brief look).

Read: Section 3.5 pages 242-254.

Need a way to represent:

Numbers with fractions: 3.1415926536

Very small numbers: 0.000000000000132 = 1.32 * 10

-13

Very large numbers: 6.023 * 10

23

Negative versions of these as well.

Review:

6.023 * 10
23

6.023 is the mantissa.

10 is the base (or radix).

23 is the exponent.

In binary, it is exactly the same, except the base is 2.

Computer arithmetic that supports this form is called oating point arithmetic.
31
CSc 252 Computer Organization 2 Binary Numbers
Floating Point Representation:

Floating point numbers are stored in binary, not decimal!

Example: 176,128.75ten

176,128ten = 131,072 + 32,768 + 8,192 + 4,096 = 2

17
+ 2
15
+ 2
13
+ 2
12
= 10 1011 0000 0000 0000two

0.75ten = " + # = 2
-1
+ 2
-2
= 0.11two

176,128.75ten = 10 1011 0000 0000 0000.11two

Normal format is 1.m * 2

e

176,128.75ten = 10 1011 0000 0000 0000.11two = 1.0 1011 0000 0000 0000 11 * 2
17

= 1.0 1011 0000 0000 0000 11 * 2

10001

If we have a xed amount of space (and we always do!), we have to trade off the number of bits among m and e:

More bits for m = greater accuracy.

More bits for e = greater range.

Historically, there have been many different representations

They differ (mainly) in the values of m and e.

32
CSc 252 Computer Organization 2 Binary Numbers
Floating Point Representation (continued):

IEEE 754 A Standard for Floating Point Numbers.

Bits for m = 23. Bits for e = 8.

Plus one bit for the Sign.

Exponent.

With 8 bits for the exponent we can represent numbers from approximately 2
-127
.. 2
127

2
-127
$ 10
-38
; 2
127
$ 10
38
.

Mantissa.

Since the rst digit of the Mantissa is always 1 in binary (what is it in decimal?), we can optimize (save
space) by not storing it (but remembering it is there).
33
CSc 252 Computer Organization 2 Binary Numbers
S Ex p o n e n t S i g n i f i c a n d
Floating Point Representation (continued):

Laying out Floating Point Numbers.

Basic layout:

S = 1 bit, Exponent = 8 bits, Signicand = 23 bits.

There is a strong motivation to enable comparisons to be made using integer compares:

Compare the signs.

Compare the exponents.

Compare the signicands.

Problem with comparing exponents: -127 appears to be larger than +127 (when both are written as Two's
Complement binary numbers).

Solution: bias the exponent so positive exponents occupy the upper-half of the exponent range.

In IEEE 754, 127ten is used to bias the exponent.

For an exponent of +1ten use 1 + 127 = 128ten = 1000 0000two

For an exponent of +12ten use 12 + 127 = 139ten = 1000 1011two

34

For -4ten: -4 + 127 = 123ten = 0111 1011two

For -33ten: -33 + 127 = 94ten = 0101 1110two

CSc 252 Computer Organization 2 Binary Numbers
Floating Point Representation (continued):

Completing the example:

176,128.75ten = 1.0 1011 0000 0000 0000 11 * 2

17

Sign: 0 (positive)

Exponent:

17

Add the bias: 17 + 127 = 144 = 128 + 16 = 1001 0000two

Signicand (without the 1 to the left of the decimal): 010 1100 0000 0000 0011 0000

Result:

S Expo nent Sig nifi cand

0 1001 0000 010 1100 0000 0000 0011 0000
35
When converting from decimal to binary:
Add the bias (always).
Does not matter whether the exponent in
decimal is positive or negative, always add.
CSc 252 Computer Organization 2 Binary Numbers
Floating Point Representation (continued):

Example of a Floating Point number:

0 01101000 101 0000 0000 0000 0000 0000
S Exponent Sig nifi cand

Sign bit is 0, so the number is positive.

Exponent: 8 digits

0110 1000two = 104ten

Biased: 104ten - 127ten = -23ten

Signicand: 23 digits

101 0000 0000 0000 0000 0000

1.101two * 2
-23

1.101two = 1 + (1*2
-1
+ 0*2
-2
+ 1*2
-3
) = 1 + " + " = 1 + # = 1.625ten

Number: 1.625 * 2
-23
, which is approximately 1.937 * 10
-7
.
36
When converting from binary to decimal:
Subtract the bias (always).
Does not matter whether the exponent in
binary starts with 1 or 0, always subtract.
CSc 252 Computer Organization 2 Binary Numbers
Floating Point Representation (continued):

There are three problems to handle:

Zero: The standard uses all 0s for the exponent and all 0s for the signicand:
0 0000 0000 000 0000 0000 0000 0000 0000
S Expo nent Sig nifi cand

The sign bit can be 0 or 1.

Innity: The standard uses all 1s for the exponent and all 0s for the signicand:
0 1111 1111 000 0000 0000 0000 0000 0000
S Expo nent Sig nifi cand

The sign bit can be 0 or 1.

NaN: Not a Number. For operations such as 0 / 0 or subtracting innity - innity.

The standard uses all 1s for the exponent and some (any) nonzero value for the signicand.
0 1111 1111 101 0000 0000 0000 0000 0000 (as one example).
S Expo nent Sig nifi cand

The sign bit can be 0 or 1.

37
CSc 252 Computer Organization 2 Binary Numbers
Floating Point Representation (continued):

Exponent:

-126ten to +127ten can be represented.

-126 + 127 = 1ten = 0000 0001two

+127 + 127 = 254ten = 1111 1110two

When the exponent is all 0s:

If the signicand is all 0s, the bit pattern represents 0ten.

If the signicand is nonzero, the signicand does not have an implied leading 1.

Called denormalized values.

Allows representation of values closer to zero.

Figure 3.14, page 246 (partial), Single Precision:

38
Exponent Fraction Object represented
0 0 0
0 nonzero +/- denormalized number
1 - 254 anything +/- oating-point number
255 0 +/- innity
255 nonzero NaN (Not a Number)
CSc 252 Computer Organization 2 Binary Numbers
Floating Point Representation (continued):

Example:

Decimal: -0.75 = - 3/4 = - (1/2 + 1/4) = - (1*2

-1
+ 1*2
-2
)

Binary: -0.11 = -1.1 * 2

-1

Floating point:

Sign bit for negative value: 1

Exponent:

-1ten + bias = -1ten + 127ten = 126ten = 0111 1110two

Signicand: 1.1

1.100 0000 0000 0000 0000 0000

Implicit 1 at the start not part of the stored number.

Signicand is thus: 100 0000 0000 0000 0000 0000

IEEE single precision result: 1 0111 1110 100 0000 0000 0000 0000 0000
1 01111110 10000000000000000000000
S Exponent Significand
39
CSc 252 Computer Organization 2 Binary Numbers
Floating Point Representation (continued):

Example:

4.2 * 10
3
into binary (IEEE format).

4.2 * 10
3
= 4200ten

4200ten = 1 0000 0110 1000two

Normalize it

Need to move the binary decimal point 12 places:

1.000 0011 0100 0 * 2

12

Result:

Sign bit for positive number: 0

Exponent:

12ten + 127ten = 139ten = 128ten + 8ten + 2ten + 1ten = 1000 1011two

Signicand: 1.000001101000, we drop the implicit 1, to get:

000 0011 0100 0000 0000 0000, extra zeros needed on the right to ll out the 23 digits
0 1000 1011 000 0011 0100 0000 0000 0000
S Expo nent Sig nifi cand
40
CSc 252 Computer Organization 2 Binary Numbers
Floating Point Addition:

Have to make the exponents the same (align the oating decimal point).

Base 10 example:

4.2*10
3
+ 4.2*10
5
= 0.042*10
5
+ 4.2*10
5
= 4.242*10
5

Binary example:

We converted 4.2 * 10
3
earlier (see previous slide): 0 1000 1011 000 0011 0100 0000 0000 0000

4.2 * 10
5
= 420,000ten = 110 0110 1000 1010 0000two = 1.1001101000101*2
18

Sign, number is positive: 0

Exponent: 18ten + 127ten = 145ten = 1001 0001two

Signicand: 100 1101 0001 0100 0000 0000

Result:
0 1001 0001 100 1101 0001 0100 0000 0000
S Expo nent Sig nifi cand
41
CSc 252 Computer Organization 2 Binary Numbers
Floating Point Addition (continued):

Adding:
0 1001 0001 100 1101 0001 0100 0000 0000 2
18
4.2 * 10
5
+ 0 1000 1011 000 0011 0100 0000 0000 0000 2
12
+ 4.2 * 10
3

Shift the second number six places to the right to align the exponents:
0 1001 0001 100 1101 0001 0100 0000 0000 2
18
4.2 * 10
5
+ 0 1001 0001 000 0010 0000 1101 0000 0000 2
18
+ 0.042 * 10
5

Have to put the implicit one into the second number when we shift it right!

Result:
0 1001 0001 100 1101 0001 0100 0000 0000 2
18
4.2 * 10
5
+ 0 1001 0001 000 0010 0000 1101 0000 0000 2
18
+ 0.042 * 10
5
0 1001 0001 100 1111 0010 0001 0000 0000
S Exponent Significand
Checking the result to see if it matches (approximates) the decimal result:
Exponent: 1001 0001 = 128 + 16 + 1 = 145ten - 127ten = 18ten
1.100 1111 0010 0001 * 2
18
= 110 0111 1001 0000 1000two = 67,908hex =
6*16
4
+ 7*16
3
+ 9*16
2
+ 8*16
0
= 6*65,536 + 7*4,096 + 9*256 + 8 =
393,216 + 28,672 + 2,304 + 8 = 424,200
42
CSc 252 Computer Organization 2 Binary Numbers
Floating Point (continued):

IEEE 754 Floating Point standard:

Single precision:

Sign bit.

Exponent: 8 bits, bias 127.

Signicand: 23 bits.

Double precision:

Sign bit.

Exponent: 11 bits, bias 1023.

Signicand: 52 bits.
43
CSc 252 Computer Organization 2 Binary Numbers
Floating Point Complexities:

Operations are somewhat more complicated than integer operations (see text).

In addition to overow, we can have underow:

Value too close to zero to be represented.

Accuracy can be a big problem.

IEEE 754 uses two extra bits during operations: guard and round to round intermediate answers.

Four rounding modes.

Positive divided by zero yields innity.

Zero divided by zero yields Not a Number.

Other complexities

Implementing the standard can be tricky.

MIPS uses separate oating-point registers (not part of the 32 general-purpose registers that are used for integer
operations) see discussion in the text.

We will come back to this point later.

Not using the standard can be even worse.

See the text (4th edition: pages 272-279) for description of the 80x86 oating-pt operations and the Pentium
divide bug!
44
CSc 252 Computer Organization 2 Binary Numbers
Representation of Characters:

Characters such as A ? p u 5 (and the characters in this document :-) must also be represented.

Standard representation (ASCII code) 4th edition: Figure 2.15, page 122.
0 1 0 0 0 0 0 1 = A
0 1 0 0 0 0 1 0 = B
0 1 1 0 0 0 0 1 = a
0 1 1 0 0 0 1 0 = b

Also have to represent numbers as characters; e.g. 5, but note these are not the same as 5.

5 (the number, as an 8-bit, signed integer) = 0 0 0 0 0 1 0 1

5 (the character) = 0 0 1 1 0 1 0 1

55 (the number, as an 8-bit, signed integer) = 0 0 1 1 0 1 1 1

5 5 (two characters, need 16-bits, 8 bits for each 5) = 0 0 1 1 0 1 0 1 0 0 1 1 0 1 0 1

How many bits would it take to represent 1,000,000ten in ASCII?

How many bits would it take to represent 1,000,000ten as an unsigned integer?

45
CSc 252 Computer Organization 2 Binary Numbers
Representation of Characters (continued):

ASCII in various bases (taken from man ascii in OS X):

The decimal set:
0 nul 1 soh 2 stx 3 etx 4 eot 5 enq 6 ack 7 bel
8 bs 9 ht 10 nl 11 vt 12 np 13 cr 14 so 15 si
16 dle 17 dc1 18 dc2 19 dc3 20 dc4 21 nak 22 syn 23 etb
24 can 25 em 26 sub 27 esc 28 fs 29 gs 30 rs 31 us
32 sp 33 ! 34 " 35 # 36 $ 37 % 38 & 39 '
40 ( 41 ) 42 * 43 + 44 , 45 - 46 . 47 /
48 0 49 1 50 2 51 3 52 4 53 5 54 6 55 7
56 8 57 9 58 : 59 ; 60 < 61 = 62 > 63 ?
64 @ 65 A 66 B 67 C 68 D 69 E 70 F 71 G
72 H 73 I 74 J 75 K 76 L 77 M 78 N 79 O
80 P 81 Q 82 R 83 S 84 T 85 U 86 V 87 W
88 X 89 Y 90 Z 91 [ 92 \ 93 ] 94 ^ 95 _
96 ` 97 a 98 b 99 c 100 d 101 e 102 f 103 g
104 h 105 i 106 j 107 k 108 l 109 m 110 n 111 o
112 p 113 q 114 r 115 s 116 t 117 u 118 v 119 w
120 x 121 y 122 z 123 { 124 | 125 } 126 ~ 127 del
46
CSc 252 Computer Organization 2 Binary Numbers
Representation of Characters (continued):

ASCII in various bases (continued):

The hexadecimal set:
00 nul 01 soh 02 stx 03 etx 04 eot 05 enq 06 ack 07 bel
08 bs 09 ht 0a nl 0b vt 0c np 0d cr 0e so 0f si
10 dle 11 dc1 12 dc2 13 dc3 14 dc4 15 nak 16 syn 17 etb
18 can 19 em 1a sub 1b esc 1c fs 1d gs 1e rs 1f us
20 sp 21 ! 22 " 23 # 24 $ 25 % 26 & 27 '
28 ( 29 ) 2a * 2b + 2c , 2d - 2e . 2f /
30 0 31 1 32 2 33 3 34 4 35 5 36 6 37 7
38 8 39 9 3a : 3b ; 3c < 3d = 3e > 3f ?
40 @ 41 A 42 B 43 C 44 D 45 E 46 F 47 G
48 H 49 I 4a J 4b K 4c L 4d M 4e N 4f O
50 P 51 Q 52 R 53 S 54 T 55 U 56 V 57 W
58 X 59 Y 5a Z 5b [ 5c \ 5d ] 5e ^ 5f _
60 ` 61 a 62 b 63 c 64 d 65 e 66 f 67 g
68 h 69 i 6a j 6b k 6c l 6d m 6e n 6f o
70 p 71 q 72 r 73 s 74 t 75 u 76 v 77 w
78 x 79 y 7a z 7b { 7c | 7d } 7e ~ 7f del
47
CSc 252 Computer Organization 2 Binary Numbers
Representation of Characters (continued):

ASCII in various bases (continued):

The octal set:
000 nul 001 soh 002 stx 003 etx 004 eot 005 enq 006 ack 007 bel
010 bs 011 ht 012 nl 013 vt 014 np 015 cr 016 so 017 si
020 dle 021 dc1 022 dc2 023 dc3 024 dc4 025 nak 026 syn 027 etb
030 can 031 em 032 sub 033 esc 034 fs 035 gs 036 rs 037 us
040 sp 041 ! 042 " 043 # 044 $ 045 % 046 & 047 '
050 ( 051 ) 052 * 053 + 054 , 055 - 056 . 057 /
060 0 061 1 062 2 063 3 064 4 065 5 066 6 067 7
070 8 071 9 072 : 073 ; 074 < 075 = 076 > 077 ?
100 @ 101 A 102 B 103 C 104 D 105 E 106 F 107 G
110 H 111 I 112 J 113 K 114 L 115 M 116 N 117 O
120 P 121 Q 122 R 123 S 124 T 125 U 126 V 127 W
130 X 131 Y 132 Z 133 [ 134 \ 135 ] 136 ^ 137 _
140 ` 141 a 142 b 143 c 144 d 145 e 146 f 147 g
150 h 151 i 152 j 153 k 154 l 155 m 156 n 157 o
160 p 161 q 162 r 163 s 164 t 165 u 166 v 167 w
170 x 171 y 172 z 173 { 174 | 175 } 176 ~ 177 del
48
CSc 252 Computer Organization 2 Binary Numbers
Representation of Characters (continued):

ASCII printable and non-printable characters:

Printable:

Characters from the blank space to the tilde character.

Decimal: values between 32 and 126, inclusive.

Non-Printable:

Characters from the nul character (ascii value 0) to the us character (us = unit separator, ascii value 31).

And, the del character: (ascii value 127).

Interesting non-printable characters:

Ascii values 1 to 26 are the control characters: control-A through control-Z.

Some are tied to keys:

Control-I, ascii 9, ht, horizontal tab, is the tab key.

Control-H, ascii 8, bs, backspace, is the backspace key.

Ascii 27, escape, is the ESC key.

Networking use, in low-level message protocols:

soh, start of heading, stx, start of text, etx, end of text.

49
CSc 252 Computer Organization 2 Binary Numbers
Representation of Characters (continued):

Interesting non-printable characters (continued):

There are two ascii characters that can control advancing to the next line:

Control-J, ascii 10, lf, line feed.

Control-M, ascii 13, cr, carriage return.

Windows puts both characters at the end of a line. In Java, when you use \n, you get both cr and lf.

Unix puts only the lf character at the end of a line. In Java, when you use \n, you get only lf.

Linux and Mac OS X follow the Unix convention.

50
CSc 252 Computer Organization 2 Binary Numbers
Representation of Characters (continued):

Unicode.

Of course, 128 is not very many possibilities when you have to represent all the characters in the world.

Think different alphabets here.

East Asian, Cyrillic, Arabic, Greek, Tibetan, Cherokee,

Many systems use Unicode. 16 bits for each character.

Java species the use of Unicode.

2
16
allows for 65,536 characters.

The rst 128 characters in Unicode are the ASCII characters, of course. (Why of course?)
51
CSc 252 Computer Organization 2 Binary Numbers
Summary:

Numbers and characters may be represented using binary.

And other items as well (assembly language instructions, for example).

We always have to know how to interpret a bit pattern -- the pattern alone is not sufcient!

Variety of techniques for representing negative numbers, oating point numbers, etc.

Can perform arithmetic on binary numbers.

Can (easily?) convert between more readable hexadecimal (or octal) and binary notation.

How do we tell from looking at a bit pattern what it represents?

Often cannot tell from the pattern alone (see the homework).

Can sometimes eliminate some possibilities.

Need context to determine what the bit pattern means

52