Scribd
Upload
222 views3 pages

Unsigned SX Ux 31 Unsigned Sy Uy 31 : / Get The Sign Bits

This document discusses representing and manipulating numeric information in computing systems. It covers topics like: - Floating point number formats including sign bits, exponents, significands, and biases - Converting between different floating point formats - Potential rounding issues when converting between integer and floating point types - Constructing the IEEE single-precision floating point representation of 2^x

Uploaded by

Dup Vlerd
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
222 views3 pages

Unsigned SX Ux 31 Unsigned Sy Uy 31 : / Get The Sign Bits

This document discusses representing and manipulating numeric information in computing systems. It covers topics like: - Floating point number formats including sign bits, exponents, significands, and biases - Converting between different floating point formats - Potential rounding issues when converting between integer and floating point types - Constructing the IEEE single-precision floating point representation of 2^x

Uploaded by

Dup Vlerd
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 3

128 Chapter 2 Representing and Manipulating Information

/* Get the sign bits */


unsigned sx = ux >> 31;
unsigned sy = uy >> 31;

/* Give an expression using only ux, uy, sx, and sy */


return ;
}

2.84 ◆
Given a floating-point format with a k-bit exponent and an n-bit fraction, write
formulas for the exponent E, significand M, the fraction f , and the value V for
the quantities that follow. In addition, describe the bit representation.
A. The number 7.0
B. The largest odd integer that can be represented exactly
C. The reciprocal of the smallest positive normalized value

2.85 ◆
Intel-compatible processors also support an “extended precision” floating-point
format with an 80-bit word divided into a sign bit, k = 15 exponent bits, a single
integer bit, and n = 63 fraction bits. The integer bit is an explicit copy of the
implied bit in the IEEE floating-point representation. That is, it equals 1 for
normalized values and 0 for denormalized values. Fill in the following table giving
the approximate values of some “interesting” numbers in this format:

Extended precision
Description Value Decimal
Smallest positive denormalized
Smallest positive normalized
Largest normalized

2.86 ◆
Consider a 16-bit floating-point representation based on the IEEE floating-point
format, with one sign bit, seven exponent bits (k = 7), and eight fraction bits
(n = 8). The exponent bias is 27−1 − 1 = 63.
Fill in the table that follows for each of the numbers given, with the following
instructions for each column:

Hex: The four hexadecimal digits describing the encoded form.


M: The value of the significand. This should be a number of the
form x or xy , where x is an integer, and y is an integral
67 1
power of 2. Examples include: 0, 64 , and 256 .
E: The integer value of the exponent.
V: The numeric value represented. Use the notation x or
x × 2z , where x and z are integers.
Homework Problems 129

As an example, to represent the number 87 , we would have s = 0, M = 47 , and


E = −1. Our number would therefore have an exponent field of 0x3E (decimal
value 63 − 1 = 62) and a significand field 0xC0 (binary 110000002 ), giving a hex
representation 3EC0.
You need not fill in entries marked “—”.
Description Hex M E V
−0 —
Smallest value > 2
512 —
Largest denormalized
−∞ — — —
Number with hex representation 3BB0 —

2.87 ◆◆
Consider the following two 9-bit floating-point representations based on the IEEE
floating-point format.
1. Format A
There is one sign bit.
There are k = 5 exponent bits. The exponent bias is 15.
There are n = 3 fraction bits.
2. Format B
There is one sign bit.
There are k = 4 exponent bits. The exponent bias is 7.
There are n = 4 fraction bits.
Below, you are given some bit patterns in Format A, and your task is to convert
them to the closest value in Format B. If rounding is necessary, you should round
toward +∞. In addition, give the values of numbers given by the Format A and
Format B bit patterns. Give these as whole numbers (e.g., 17) or as fractions (e.g.,
17/64 or 17/26).
Format A Format B
Bits Value Bits Value
−9 −9
1 01111 001 8 1 0111 0010 8
0 10110 011
1 00111 010
0 00000 111
1 11100 000
0 10111 100

2.88 ◆
We are running programs on a machine where values of type int have a 32-
bit two’s-complement representation. Values of type float use the 32-bit IEEE
format, and values of type double use the 64-bit IEEE format.
130 Chapter 2 Representing and Manipulating Information

We generate arbitrary integer values x, y, and z, and convert them to values


of type double as follows:

/* Create some arbitrary values */


int x = random();
int y = random();
int z = random();
/* Convert to double */
double dx = (double) x;
double dy = (double) y;
double dz = (double) z;

For each of the following C expressions, you are to indicate whether or


not the expression always yields 1. If it always yields 1, describe the underlying
mathematical principles. Otherwise, give an example of arguments that make
it yield 0. Note that you cannot use an IA32 machine running gcc to test your
answers, since it would use the 80-bit extended-precision representation for both
float and double.
A. (float) x == (float) dx
B. dx - dy == (double) (x-y)
C. (dx + dy) + dz == dx + (dy + dz)
D. (dx * dy) * dz == dx * (dy * dz)
E. dx / dx == dz / dz

2.89 ◆
You have been assigned the task of writing a C function to compute a floating-
point representation of 2x . You decide that the best way to do this is to directly
construct the IEEE single-precision representation of the result. When x is too
small, your routine will return 0.0. When x is too large, it will return +∞. Fill in the
blank portions of the code that follows to compute the correct result. Assume the
function u2f returns a floating-point value having an identical bit representation
as its unsigned argument.

float fpwr2(int x)
{

/* Result exponent and fraction */


unsigned exp, frac;
unsigned u;

if (x < ) {
/* Too small. Return 0.0 */
exp = ;
frac = ;
} else if (x < ) {

You might also like