CSC 2400
Computer Systems I
Lecture 2
Representations
The Machine
Why Don’t Computers Use Base 10?

Base 10 Number Representation
–
–
That’s why fingers are known as “digits”
Natural representation for financial transactions

–
Even carries through in scientific notation


Floating point number cannot exactly represent $1.20
1.5213 X 104
Implementing Electronically
–
Hard to store

–
Hard to transmit

–
ENIAC (First electronic computer) used 10 vacuum tubes / digit
Need high precision to encode 10 signal levels on single wire
Messy to implement digital logic functions

Addition, multiplication, etc.
3
How do we represent data in a computer?
At
–
the lowest level, a computer is an electronic machine.
works by controlling the flow of electrons
Easy
1.
2.
to recognize two conditions:
presence of a voltage – we’ll call this state “1”
absence of a voltage – we’ll call this state “0”
Could base state on value of voltage, but control
and detection circuits more complex.
–
compare turning on a light switch to
measuring or regulating voltage
4
Computer is a binary digital system.
Digital system:
• finite number of symbols


Binary (base two) system:
• has two states: 0 and 1
Basic unit of information is the binary digit, or bit.
Values with more than two states require multiple bits.
–
A collection of two bits has four possible states:
00, 01, 10, 11
–
A collection of three bits has eight possible states:
000, 001, 010, 011, 100, 101, 110, 111
–
A collection of n bits has 2n possible states.
5
What kinds of data do we need to represent?
–
–
–
–
–
–
–

Numbers – signed, unsigned, integers, floating point,
complex, rational, irrational, …
Text – characters, strings, …
Images – pixels, colors, shapes, …
Sound
Logical – true, false
Instructions
…
Data type:
–
representation and operations within the computer
6
Machine Words

Machine Has “Word Size”
–
Nominal size of integer-valued data

–
Most current machines are 32 bits (4 bytes)


–
Limits addresses to 4GB
Becoming too small for memory-intensive applications
High-end systems are 64 bits (8 bytes)

–
Including addresses
Potentially address  1.8 X 1019 bytes
Machines support multiple data formats


Fractions or multiples of word size
Always integral number of bytes
7
Word-Oriented Memory Organization
32-bit 64-bit
Words Words

Addresses Specify Byte
Locations
–
–
Address of first byte in word
Addresses of successive words
differ by 4 (32-bit) or 8 (64-bit)
Addr
=
0000
??
Addr
=
0000
??
Addr
=
0004
??
Addr
=
0008
??
Addr
=
0012
??
Addr
=
0008
??
Bytes Addr.
0000
0001
0002
0003
0004
0005
0006
0007
0008
0009
0010
0011
0012
0013
0014
0015
8
Data Representations

Sizes of C Objects (in Bytes)
–
C Data Type








Sparc/Unix
Typical 32-bit
Intel IA32
4
8
1
2
4
8
8
8
4
4
1
2
4
8
8
4
4
4
1
2
4
8
10/12
4
int
long int
char
short
float
double
long double
char *
–
Or any other “pointer”
9
Pointers and Arrays

Pointer
–
–
Address of a variable in memory
Allows us to indirectly access variables


in other words, we can talk about its address
rather than its value
Array
–
A list of values arranged sequentially in memory
Example: a list of telephone numbers
–
Expression a[4] refers to the 5th element of the array a
–
10
Address vs. Value
 Sometimes
we want to deal with the address
of a memory location,
rather than the value it contains.
address
value
 Adding
–
–
a column of numbers.
R2 contains address of first location.
Read value, add to sum, and
increment R2 until all numbers
have been processed.
 R2
R2
is a pointer -- it contains the
address of data we’re interested in.
x3100
x3107
x2819
x0110
x0310
x0100
x1110
x11B1
x0019
x3100
x3101
x3102
x3103
x3104
x3105
x3106
x3107
11
Byte Ordering


How should bytes within multi-byte word be ordered in
memory?
Conventions
–
Sun’s, Mac’s are “Big Endian” machines

–
Least significant byte has highest address
Alphas, PC’s are “Little Endian” machines

Least significant byte has lowest address
12
Byte Ordering Example

Big Endian
–

Little Endian
–

Least significant byte has highest address
Least significant byte has lowest address
Example
–
–
Variable x has 4-byte representation 0x01234567
Address given by &x is 0x100
Big Endian
0x100 0x101 0x102 0x103
01
Little Endian
23
45
67
0x100 0x101 0x102 0x103
67
45
23
01
13
Machine-Level Code Representation

Encode Program as Sequence of Instructions
–
Each simple operation



–
Arithmetic operation
Read or write memory
Conditional branch
Instructions encoded as bytes

Alpha’s, Sun’s, Mac’s use 4 byte instructions
–

PC’s use variable length instructions
–
–
Complex Instruction Set Computer (CISC)
Different instruction types and encodings for different machines


Reduced Instruction Set Computer (RISC)
Most code not binary compatible
Programs are Byte Sequences Too!
14
Big Idea: Information is Bits + Context


Computer stores the bits
You decide how to interpret them

Example (binary)
00000000 00000000 00000000 00001101

Decimal = 13
Float = 1.82169E-44

Chapter 1
15
Integers
Unsigned Integers

Non-positional notation
–
–

could represent a number (“5”) with a string of ones (“11111”)
problems?
Weighted positional notation
–
–
like decimal numbers: “329”
“3” is worth 300, because of its position, while “9” is only worth 9
329
102 101 100
3x100 + 2x10 + 9x1 = 329
most
significant
22
101
21
least
significant
20
1x4 + 0x2 + 1x1 = 5
17
Unsigned Integers (cont.)

An n-bit unsigned integer represents 2n values:
from 0 to 2n-1.
22
21
20
0
0
0
0
0
0
1
1
0
1
0
2
0
1
1
3
1
0
0
4
1
0
1
5
1
1
0
6
1
1
1
7
18
Unsigned Binary Arithmetic

Base-2 addition – just like base-10!
–
add from right to left, propagating carry
carry
10010
+ 1001
11011
10010
+ 1011
11101
1111
+
1
10000
10111
+ 111
19
Signed Integers

With n bits, we have 2n distinct values.
–
–

Positive integers
–

assign about half to positive integers (1 through 2n-1)
and about half to negative (- 2n-1 through -1)
that leaves two values: one for 0, and one extra
just like unsigned – zero in most significant bit
00101 = 5
Negative integers
–
–
–
sign-magnitude – set top bit to show negative,
other bits are the same as unsigned
10101 = -5
one’s complement – flip every bit to represent negative
11010 = -5
in either case, MS bit indicates sign: 0=positive, 1=negative
20
Two’s Complement

Problems with sign-magnitude and 1’s complement
–
–
two representations of zero (+0 and –0)
arithmetic circuits are complex

How to add two sign-magnitude numbers?
–

How to add to one’s complement numbers?
–

e.g., try 2 + (-3)
e.g., try 4 + (-3)
Two’s complement representation developed to make
circuits easy for arithmetic.
–
for each positive number (X), assign value to its negative (-X),
such that X + (-X) = 0 with “normal” addition, ignoring carry out
00101 (5)
+ 11011 (-5)
00000 (0)
01001 (9)
+
(-9)
00000 (0)
21
Two’s Complement Representation

If number is positive or zero,
–

normal binary representation, zeroes in upper bit(s)
If number is negative,
–
–
–
start with positive number
flip every bit (i.e., take the one’s complement)
then add one
00101 (5)
11010 (1’s comp)
+
1
11011 (-5)
01001 (9)
(1’s comp)
+
1
(-9)
22
Two’s Complement Signed Integers


MS bit is sign bit – it has weight –2n-1.
Range of an n-bit number: -2n-1 through 2n-1 – 1.
–
The most negative number (-2n-1) has no positive counterpart.
-23
22
21
20
-23
22
21
20
0
0
0
0
0
1
0
0
0
-8
0
0
0
1
1
1
0
0
1
-7
0
0
1
0
2
1
0
1
0
-6
0
0
1
1
3
1
0
1
1
-5
0
1
0
0
4
1
1
0
0
-4
0
1
0
1
5
1
1
0
1
-3
0
1
1
0
6
1
1
1
0
-2
0
1
1
1
7
1
1
1
1
-1
23
ASCII, etc.
Text: ASCII Characters

ASCII: Maps 128 characters to 7-bit code. (type man ascii)
–
both printable and non-printable (ESC, DEL, …) characters
00
01
02
03
04
05
06
07
08
09
0a
0b
0c
0d
0e
0f
nul
soh
stx
etx
eot
enq
ack
bel
bs
ht
nl
vt
np
cr
so
si
10
11
12
13
14
15
16
17
18
19
1a
1b
1c
1d
1e
1f
dle
dc1
dc2
dc3
dc4
nak
syn
etb
can
em
sub
esc
fs
gs
rs
us
20
21
22
23
24
25
26
27
28
29
2a
2b
2c
2d
2e
2f
sp
!
"
#
$
%
&
'
(
)
*
+
,
.
/
30
31
32
33
34
35
36
37
38
39
3a
3b
3c
3d
3e
3f
0
1
2
3
4
5
6
7
8
9
:
;
<
=
>
?
40
41
42
43
44
45
46
47
48
49
4a
4b
4c
4d
4e
4f
@
A
B
C
D
E
F
G
H
I
J
K
L
M
N
O
50
51
52
53
54
55
56
57
58
59
5a
5b
5c
5d
5e
5f
P
Q
R
S
T
U
V
W
X
Y
Z
[
\
]
^
_
60
61
62
63
64
65
66
67
68
69
6a
6b
6c
6d
6e
6f
`
a
b
c
d
e
f
g
h
i
j
k
l
m
n
o
70
71
72
73
74
75
76
77
78
79
7a
7b
7c
7d
7e
7f
p
q
r
s
t
u
v
w
x
y
z
{
|
}
~
del
25
Interesting Properties of ASCII Code

What is relationship between a decimal digit ('0', '1', …)
and its ASCII code?

What is the difference between an upper-case letter
('A', 'B', …) and its lower-case equivalent ('a', 'b', …)?

Given two ASCII characters, how do we tell which comes
first in alphabetical order?

Are 128 characters enough?
(http://www.unicode.org/)
26
Other Data Types

Text strings
–
–

sequence of characters, terminated with NULL (0)
typically, no special hardware support
Image
–
array of pixels



–
hardware support:



monochrome: one bit (1/0 = black/white)
color: red, green, blue (RGB) components (e.g., 8 bits each)
other properties: transparency
typically none, in general-purpose processors
MMX -- multiple 8-bit operations on 32-bit word
Sound
–
sequence of fixed-point numbers
27
Pointers in C

C lets us talk about and manipulate “pointers”
(addresses) as variables and in expressions.

Declaration
int *p;

/* p is a pointer to an int */

A pointer in C is always a pointer to a particular data type:
int*, double*, char*, etc.

Operators
*p -- returns the value pointed to by p (“dereference”)
&z -- returns the address of variable z (“address of”)


28
Example





int i;
int *ptr;
store the value 4 into the memory location
associated with i
store the address of i into the
i = 4;
memory location associated with ptr
ptr = &i;
*ptr = *ptr + 1;
read the contents of memory
at the address stored in ptr
store the result into memory
at the address stored in ptr
29
Converting Integer
Representations
Converting Binary (2’s C) to Decimal
1.
2.
3.
If leading bit is one, take two’s
complement to get a positive number.
Add powers of 2 that have “1” in the
corresponding bit positions.
If original number was negative,
add a minus sign.
X = 01101000two
= 26+25+23 = 64+32+8
= 104ten
n 2n
0
1
2
3
4
5
6
7
8
9
10
1
2
4
8
16
32
64
128
256
512
1024
Assuming 8-bit 2’s complement numbers.
31
More Examples
X = 00100111two
= 25+22+21+20 = 32+4+2+1
= 39ten
X =
-X =
=
=
X=
11100110two
00011010
24+23+21 = 16+8+2
26ten
-26ten
n 2n
0
1
2
3
4
5
6
7
8
9
10
1
2
4
8
16
32
64
128
256
512
1024
Assuming 8-bit 2’s complement numbers.
32
Converting Decimal to Binary (2’s C)

1.
2.
3.
First Method: Division
Divide by two – remainder is least significant bit.
Keep dividing by two until answer is zero,
writing remainders from right to left.
Append a zero as the MS bit;
if original number negative, take two’s complement.
X = 104ten
X = 01101000two
104/2
52/2
26/2
13/2
6/2
3/2
=
=
=
=
=
=
52 r0
26 r0
13 r0
6 r1
3 r0
1 r1
1/2 = 0 r1
bit 0
bit 1
bit 2
bit 3
bit 4
bit 5
bit 6
33
Converting Decimal to Binary (2’s C)

1.
2.
3.
4.
5.
Second Method: Subtract Powers of Two
Change to positive decimal number.
Subtract largest power of two
less than or equal to number.
Put a one in the corresponding bit position.
Keep subtracting until result is zero.
Append a zero as MS bit;
if original was negative, take two’s complement.
X = 104ten
104 - 64 = 40
40 - 32 = 8
8-8 = 0
n 2n
0
1
2
3
4
5
6
7
8
9
10
1
2
4
8
16
32
64
128
256
512
1024
bit 6
bit 5
bit 3
X = 01101000two
34
Hexadecimal Notation

It is often convenient to write binary (base-2) numbers
as hexadecimal (base-16) numbers instead.
–
–
fewer digits -- four bits per hex digit
less error prone -- easy to corrupt long string of 1’s and 0’s
Binary
Hex
Decimal
Binary
Hex
Decimal
0000
0001
0010
0011
0100
0101
0110
0111
0
1
2
3
4
5
6
7
0
1
2
3
4
5
6
7
1000
1001
1010
1011
1100
1101
1110
1111
8
9
A
B
C
D
E
F
8
9
10
11
12
13
14
15
35
Converting from Binary to Hexadecimal

Every four bits is a hex digit.
–
start grouping from right-hand side
011101010001111010011010111
3
A
8
F
4
D
7
This is not a new machine representation,
just a convenient way to write the number.
36
Operations in C
Overview of some C operators
!
Logical NOT or “bang”
~
Bitwise NOT (“flips” bits)
&
Bitwise AND
^
Bitwise XOR
|
Bitwise OR
+
Addition
<<
Bitwise left shift (shifts bits to left)
>>
Bitwise right shift (shifts bits to right)
38
Addition

2’s comp. addition is just binary addition.
–
–
–
assume all integers have the same number of bits
ignore carry out
for now, assume that sum fits in n-bit 2’s comp. representation
01101000 (104)
11110110 (-10)
+ 11110000 (-16) +
(-9)
01011000 (88)
(-19)
Assuming 8-bit 2’s complement numbers.
39
Subtraction

Negate subtrahend (2nd no.) and add.
–
–
–
assume all integers have the same number of bits
ignore carry out
for now, assume that difference fits in n-bit 2’s comp. representation
01101000 (104)
11110110 (-10)
- 00010000 (16) +
(-9)
01011000 (88)
(-19)
01101000 (104)
11110110 (-10)
+ 11110000 (-16) +
(9)
01011000 (88)
(-1)
Assuming 8-bit 2’s complement numbers.
40
Sign Extension



To add two numbers, we must represent them
with the same number of bits.
If we just pad with zeroes on the left:
4-bit
8-bit
0100 (4)
00000100 (still 4)
1100 (-4)
00001100 (12, not -4)
Instead, replicate the MS bit -- the sign bit:
4-bit
8-bit
0100 (4)
00000100 (still 4)
1100 (-4)
11111100 (still -4)
41
Overflow

If operands are too big, then sum cannot be represented
as an n-bit 2’s comp number.
01000 (8)
+ 01001 (9)
10001 (-15)

We have overflow if:
–
–

11000 (-8)
+ 10111 (-9)
01111 (+15)
signs of both operands are the same, and
sign of sum is different.
Another test -- easy for hardware:
–
carry into MS bit does not equal carry out
42
Logical Operations

Operations on logical TRUE or FALSE
–

two states -- takes one bit to represent: TRUE=1, FALSE=0
View n-bit number as a collection of n logical values
–
A
0
0
1
1
operation applied to each bit independently
B
0
1
0
1
A AND B
0
0
0
1
A
0
0
1
1
B
0
1
0
1
A OR B
0
1
1
1
A
0
1
NOT A
1
0
43
Examples of Logical Operations

AND
–
useful for clearing bits



OR
–
useful for setting bits



AND with zero = 0
AND with one = no change
11000101
AND 00001111
00000101
OR with zero = no change
OR with one = 1
OR
11000101
00001111
11001111
NOT
–
–
unary operation -- one argument
flips every bit
NOT
11000101
00111010
44
Bit-Level Operations in C

Operations &, |, ~, ^ Available in C
–
Apply to any “integral” data type

–
–

long, int, short, char
View arguments as bit vectors
Arguments applied bit-wise
Examples (Char data type)
–
~0x41 -->
0xBE
~010000012
–
–
~0x00 -->
-->
101111102
0xFF
~000000002
-->
111111112
0x69 & 0x55
-->
0x41
011010012 & 010101012 --> 010000012
–
0x69 | 0x55
-->
0x7D
011010012 | 010101012 --> 011111012
45
Relations Between Operations

DeMorgan’s Laws
–
Express & in terms of |, and vice-versa

A & B = ~(~A | ~B)
–

A | B = ~(~A & ~B)
–

A and B are true if and only if neither A nor B is false
A or B are true if and only if A and B are not both false
Exclusive-Or using Inclusive Or

A ^ B = (~A & B) | (A & ~B)
–

Exactly one of A and B is true
A ^ B = (A | B) & ~(A & B)
–
Either A is true, or B is true, but not both
46
General Boolean Algebras

Operate on Bit Vectors
–
Operations applied bitwise
01101001
& 01010101
01000001
01000001

01101001
| 01010101
01111101
01111101
01101001
^ 01010101
00111100
00111100
~ 01010101
10101010
10101010
All of the Properties of Boolean Algebra Apply
47
Contrast: Logic Operations in C

Contrast to Logical Operators
–
&&, ||, !





View 0 as “False”
Anything nonzero as “True”
Always return 0 or 1
Early termination
Examples (char data type)
–
–
–
–
–
–
!0x41 -->
!0x00 -->
!!0x41 -->
0x00
0x01
0x01
0x69 && 0x55 --> 0x01
0x69 || 0x55 --> 0x01
p && *p (avoids null pointer access)
48
Shift Operations

Left Shift:
–
Shift bit-vector x left y positions



x << y
Throw away extra bits on left
Fill with 0’s on right
Right Shift: x >> y
–
Shift bit-vector x right y positions

–
–
Fill with 0’s on left
Arithmetic shift


<< 3
00010000
Log. >> 2
00011000
Arith. >> 2 00011000
Throw away extra bits on right
Logical shift

Argument x 01100010
Replicate most significant bit on right
Useful with two’s complement integer
representation
Argument x 10100010
<< 3
00010000
Log. >> 2
00101000
Arith. >> 2 11101000
49
Limits of the Machine
Numeric Ranges
Unsigned
–
Two’s
Values
UMin
=
0
–
TMin
000…0
–
UMax
Complement Values
=
–2w–1
=
2w–1 – 1
100…0
=
2w – 1
–
TMax
111…1
011…1
Other
–
Values
Minus 1
111…1
Values for W = 16
UMax
TMax
TMin
-1
0
Decimal
65535
32767
-32768
-1
0
Hex
FF FF
7F FF
80 00
FF FF
00 00
Binary
11111111 11111111
01111111 11111111
10000000 00000000
11111111 11111111
00000000 00000000
51
Values for Different Word Sizes
W
8
255
127
-128
UMax
TMax
TMin

16
65,535
32,767
-32,768
32
4,294,967,295
2,147,483,647
-2,147,483,648
Observations
–
|TMin |

–
=
TMax + 1

C Programming
–
Asymmetric range
UMax
=
2 * TMax + 1
64
18,446,744,073,709,551,615
9,223,372,036,854,775,807
-9,223,372,036,854,775,808
#include <limits.h>

–
Declares constants, e.g.,



–
K&R App. B11
ULONG_MAX
LONG_MAX
LONG_MIN
Values platform-specific
52
Casting Signed to Unsigned

C Allows Conversions from Signed to Unsigned
short int
x = 15213;
unsigned short int ux = (unsigned short) x;
short int
y = -15213;
unsigned short int uy = (unsigned short) y;

Resulting Value
–
–
No change in bit representation
Nonnegative values unchanged

–
ux = 15213
Negative values change into (large) positive values

uy = 50323
53
Signed vs. Unsigned in C

Constants
–
–
By default are considered to be signed integers
Unsigned if have “U” as suffix
0U, 4294967259U

Casting
–
Explicit casting between signed & unsigned same as U2T and T2U
int tx, ty;
unsigned ux, uy;
tx = (int) ux;
uy = (unsigned) ty;
–
Implicit casting also occurs via assignments and procedure calls
tx = ux;
uy = ty;
54
Why Should I Use Unsigned?

Don’t Use Just Because Number Nonzero
–
C compilers on some machines generate less efficient code
unsigned i;
for (i = 1; i < cnt; i++)
a[i] += a[i-1];
–
Easy to make mistakes
for (i = cnt-2; i >= 0; i--)
a[i] += a[i+1];

Do Use When Performing Modular Arithmetic
–
–

Multiprecision arithmetic
Other esoteric stuff
Do Use When Need Extra Bit’s Worth of Range
–
Working right up to limit of word size
55
Multiplication

Computing Exact Product of w-bit numbers x, y
–

Either signed or unsigned
Ranges
–
Unsigned:

–
Two’s complement:


Result requires up to 2w bits
Result requires to 2w–1 bits
Maintaining Exact Results
–
–
Would need to keep expanding word size with each product computed
Done in software by “arbitrary precision” arithmetic packages
56
Unsigned Multiplication in C
Operands: w bits
*
True Product: 2*w bits u · v
v
• • •
UMultw(u , v)
• • •
• • •
Standard Multiplication Function
–

• • •
• • •
Discard w bits: w bits

u
Ignores high order w bits
Implements Modular Arithmetic
UMultw(u , v)
=
u · v mod 2w
57
Unsigned vs. Signed Multiplication

Unsigned Multiplication
unsigned ux = (unsigned) x;
unsigned uy = (unsigned) y;
unsigned up = ux * uy
–
–

Truncates product to w-bit number up = UMultw(ux, uy)
Modular arithmetic: up = ux  uy mod 2w
Two’s Complement Multiplication
int x, y;
int p = x * y;
–
–
Compute exact product of two w-bit numbers x, y
Truncate result to w-bit number p = TMultw(x, y)
58
Power-of-2 Multiply with Shift

Operation
–
–
u << k gives u * 2k
Both signed and unsigned
Operands: w bits
True Product: w+k bits
Discard k bits: w bits
*
u · 2k
u
k
• • •
2k
0 ••• 0 1 0 ••• 0 0
• • •
UMultw(u , 2k)
•••
0 ••• 0 0
0 ••• 0 0
TMultw(u , 2k)

Examples
–
–
–
u << 3
==
u * 8
u << 5 - u << 3 ==
u * 24
Most machines shift and add much faster than multiply

Compiler generates this code automatically
59
Unsigned Power-of-2 Divide with Shift

Quotient of Unsigned by Power of 2
–
u >> k gives  u / 2k 
–
Uses logical shift
k
u
Operands:
Division:
Result:
x
x >> 1
x >> 4
x >> 8
/
2k
•••
•••
0 ••• 0 1 0 ••• 0 0
u / 2k
0 •••
•••
 u / 2k 
0 •••
•••
Division
15213
7606.5
950.8125
59.4257813
Binary Point
Computed
15213
7606
950
59
Hex
3B 6D
1D B6
03 B6
00 3B
.
•••
Binary
00111011 01101101
00011101 10110110
00000011 10110110
00000000 00111011
60
Signed Power-of-2 Divide with Shift

Quotient of Signed by Power of 2
–
–
–
x >> k gives  x / 2k 
Uses arithmetic shift
Rounds wrong direction when u < 0
k
x
Operands:
/
x / 2k
Division:
Result:
y
y >> 1
y >> 4
y >> 8
2k
RoundDown(x / 2k)
Division
-15213
-7606.5
-950.8125
-59.4257813
•••
•••
Binary Point
0 ••• 0 1 0 ••• 0 0
0 •••
•••
0 •••
•••
Computed
-15213
-7607
-951
-60
Hex
C4 93
E2 49
FC 49
FF C4
.
•••
Binary
11000100 10010011
11100010 01001001
11111100 01001001
11111111 11000100
61
Correct Power-of-2 Divide

Quotient of Negative Number by Power of 2
–
–
•
Want  x / 2k  (Round Toward 0)
Compute as  (x+2k-1)/ 2k 

In C: (x + (1<<k)-1) >> k

Biases dividend toward 0
Case 1: No rounding
k
u
Dividend:
+2k +–1
1
/
2k
 u / 2k 
0 ••• 0 0
0 ••• 0 0 1 ••• 1 1
1
Divisor:
•••
•••
1 ••• 1 1
Binary Point
0 ••• 0 1 0 ••• 0 0
0 ••• 1 1 1
1
•••
. 1 ••• 1 1
Biasing has no effect
62
Correct Power-of-2 Divide (Cont.)
Case 2: Rounding
k
x
Dividend:
+2k +–1
1
•••
•••
0 ••• 0 0 1 ••• 1 1
1
•••
•••
Incremented by 1
Divisor:
/
2k
 x / 2k 
Binary Point
0 ••• 0 1 0 ••• 0 0
0 ••• 1 1 1
1
Biasing adds 1 to final result
•••
.
•••
Incremented by 1
63
Floating Point
Fractions: Fixed-Point

How can we represent fractions?
–
–
Use a “binary point” to separate positive
from negative powers of two -- just like “decimal point.”
2’s comp addition and subtraction still work.

if binary points are aligned
2-1 = 0.5
2-2 = 0.25
2-3 = 0.125
00101000.101 (40.625)
+ 11111110.110 ( -1.25) [note, it is in 2s compl.]
00100111.011 (39.375)
No new operations -- same as integer arithmetic.
65
Very Large and Very Small: Floating-Point





Large values: 6.023 x 1023 -- requires 79 bits
Small values: 6.626 x 10-34 -- requires >110 bits
Use equivalent of “scientific notation”: F x 2E
Need to represent F (fraction), E (exponent), and sign.
IEEE 754 Floating-Point Standard (32-bits):
1b
8b
S Exponent
23b
Fraction
N  1S  1.fraction  2exponent 127 , 1  exponent  254
N  1S  0.fraction  2 126 , exponent  0
66
Floating Point Example


Single-precision IEEE floating point number:
10111111010000000000000000000000
sign exponent
–
–
–

fraction
Sign is 1 – number is negative.
Exponent field is 01111110 = 126 (decimal).
Fraction is 0.100000000000… = 0.5 (decimal).
Value = -1.5 x 2(126-127) = -1.5 x 2-1 = -0.75.
67
Floating Point in C

C Guarantees Two Levels
float
double

single precision
double precision
Conversions
–
–
Casting between int, float, and double changes numeric values
Double or float to int



Truncates fractional part
Like rounding toward zero
Not defined when out of range
–
–
int to double

–
Generally saturates to TMin or TMax
Exact conversion, as long as int has ≤ 53 bit word size
int to float

Will round according to rounding mode
68