深入理解计算机系统(第三版)作业题答案(第二章)-白红宇

深入理解计算机系统(第三版)作业题答案(第二章)

阅读量：5915 次

发布时间：2019-06-19

本文共 27040 字，大约阅读时间需要 90 分钟。

说明

我发现，当把这些题做完之后对本章知识的理解才算有点小进步。下边的答案主要参考了这两个网站：

2.58

原理是把指向一个int类型的指针强行改为指向char类型，一般来说一个char占8位，这就能判断出来取出的值是否大于1

int is_little_endian(){    int a = 1;    return *((char*)&a);}

2.59

这个比较简单，主要考察如何获取某些位。

(x&0xFF) | (y&~0xFF)

2.60

i << 3表示i * 2^3, 其原理是找出需要替换的那些位，然后将其替换掉就行了。

unsigned replace_byte(unsigned x, unsigned char b, int i){    return (x & ~(0xFF<<(i<<3))) | (b << (i<<3));}

位级整数编码规则

2.61

下边的内容跟书的题目有关系，需要根据实际情况。

A(!~x) // 比较简单，不解释B(!x) // 同上C(!~(x | (~0xFF))) // x的最低有效字节中的位都等于1D(!(x >> ((sizeof(int) - 1) << 3))) // x的最高有效字节中的位都等于0

2.62

这个题我觉得在使用补码表示整数的机器上是没啥问题的

#include 
    
     int int_shifts_are_arithmetic() {    int i = -1;    return (i >> 1) == -1;}int main(void) {    printf("%d", int_shifts_are_arithmetic());}

2.63

#include 
    
     unsigned srl(unsigned x, int k) {    int xsrl = (int)x >> k;    int w = 8 * sizeof(int);    unsigned z = 2 << (w - k -1);    return (z - 1) & xsrl;}int sra(int x, int k) {    int xsra = (unsigned)x >> k;    int w = sizeof(int) << 3;    unsigned z = 1 << (w - k - 1);    unsigned mask = z - 1;    unsigned right = xsra & mask;    unsigned left = ~mask & (~(z & xsra) + z);    return left | right;}int main(void) {    unsigned t1 = srl(100, 2);    unsigned t2 = (unsigned)100 >> 2;    printf("%d----%d \n", t1, t2);    int t3 = sra(100, 2);    int t4 = 100 >> 2;    printf("%d----%d \n", t3, t4);    int t5 = sra(-100, 2);    int t6 = -100 >> 2;    printf("%d----%d \n", t5, t6);}

2.64

// 该题目要求，只要奇数位有1，就返回1，否则返回0#include 
    
     /* Return 1 when any odd bit of x equals 1, 0 otherwise.   Assume w = 32.*/int any_odd_one(unsigned x) {    return !!(x & 0x55555555);}int main(void) {    int result = any_odd_one((unsigned)5);    printf("The result of 5: %d \n", result);    int result1 = any_odd_one((unsigned)2);    printf("The result of 2: %d \n", result1);}

2.65

// 该题目要求，只要二进制书中1的个数为奇数，就返回1，否则返回0#include 
    
     /* Return 1 when x contains an odd nuimber of 1s, 0 otherwise.   Assume w = 32.*/int odd_ones(unsigned x) {    // 这是第一层的处理，对某一位i而言，通过右移了一位，我们就获取到了i前边的那一位，把他们异或后，    // 得到的位的值为0或者1，1就表示和前边的一位中有奇数个1，0表示有偶数个1.    x ^= (x >> 1);    // 经过上边的处理后呢，x中每一位的值的意义就不同了，他表示该位和它前边的位1的个数是奇数还是偶数    //  此时我们再右移2位，就获得了i前边的前边的值j，这个值j表示j和前边一位1的个数是奇数还是偶数    //  异或后，的值就便是到j前边，一共四位1的个数是奇数还是偶数    x ^= (x >> 2);    // 后面的都是按照上边的原理依次类推的    x ^= (x >> 4);    x ^= (x >> 8);    x ^= (x >> 16);    return x & 1;}int main(void) {    int result = odd_ones((unsigned)5);    printf("The result of 5: %d \n", result);    int result1 = odd_ones((unsigned)7);    printf("The result of 3: %d \n", result1);}

2.66

#include 
    
     #include 
     
      // 1. 先使用或加位移让第一个1的后边都是1// 2. 然后取非后右移一位后，最右边的1就是我们想要的掩码// 3. 由于上边得到的那个1就是原值中的第一个1的位置，因此&上原值就清空了1前边的位int leftmost_one(unsigned x) {    x |= x >> 1;    x |= x >> 2;    x |= x >> 4;    x |= x >> 8;    x |= x >> 16;    return x & (~x >> 1);}int main(void) {    assert(leftmost_one(0xff00) == 0x8000);    assert(leftmost_one(0x6600) == 0x4000);    return 0;}

2.67

#include 
    
     #include 
     
      int int_size_is_32() {    int set_msb = 1 << 31;    int beyond_msb = set_msb << 1;    return set_msb && !beyond_msb;}int int_size_is_32_for_16bit() {    int set_msb = 1 << 15 << 15 << 1;    int beyond_msb = set_msb << 1;    return set_msb && !beyond_msb;}int main(void) {    printf("1: %lu \n", sizeof(1));    printf("32: %d \n", int_size_is_32());    printf("16: %d \n", int_size_is_32_for_16bit());}

2.68

#include 
    
     #include 
     
      int lower_one_mask(int n) {    int w = sizeof(int) << 3;    return (unsigned)-1 >> (w - n);}int main(void) {    assert(lower_one_mask(6) == 0x3F);    assert(lower_one_mask(17) == 0x1FFFF);    assert(lower_one_mask(32) == 0xFFFFFFFF);    return 0;}

2.69

#include 
    
     #include 
     
      unsigned rotate_left(unsigned x, int n) {    int w = sizeof(int) << 3;    unsigned t = x << n;    unsigned t1 = x >> (w - n - 1) >> 1;    return t | t1;}int main(void) {    assert(rotate_left(0x12345678, 4) == 0x23456781);    assert(rotate_left(0x12345678, 20) == 0x67812345);    assert(rotate_left(0x12345678, 0) == 0x12345678);    return 0;}

2.70

#include 
    
     #include 
     
      // 如果x的二进制可以用n位表示就返回1，/*   * Assume w = 8, n = 3   * if x > 0   *   0b00000110 is ok, 0b00001010 is not   *   first w-n bits must be 0   * if x < 0   *   0b11111100 is ok, 0b10111100 is not, and 0b11111000 is not yet   *   first w-n+1 bits must be 1   */int fits_bits(int x, int n) {    int w = sizeof(int) << 3;    x >>= n - 1;    /*     * !(x >> 1) 用于判断x大于0的情况     * !~x 用于判断x小于0的情况     */    return !(x >> 1) || !~x;}int main(void) {    assert(fits_bits(0xFF, 8));    assert(!fits_bits(0xFFFFFF00, 8));    return 0;}

2.71

#include 
    
     #include 
     
      typedef unsigned packet_t;// 该函数的作用是取出一个字中的某个字节，然后把该字节扩展为有符号整数// 难点在于如何利用算数右移填充前边的位// 核心思想就是先把目前字节左移到最高位，然后再利用算数右移int xbyte(packet_t word, int bytenum) {    int size = sizeof(unsigned);    int shift_left_val = (size - 1 - bytenum) << 3;    int shift_right_val = (size - 1) << 3;    return (int)word << shift_left_val >> shift_right_val;}int main(void) {    assert(xbyte(0xAABBCCDD, 1) == 0xFFFFFFCC);    assert(xbyte(0x00112233, 2) == 0x11);    return 0;}

2.72

#include 
    
     #include 
     
      #include 
      
       #include 
       
        void copy_int(int val, void *buf, int maxbytes) {    if (maxbytes >= (int)sizeof(val)) {        memcpy(buf, (void *)&val, sizeof(val));    }}int main() {    int maxbytes = sizeof(int) * 10;    void *buf = malloc(maxbytes);    int val;    val = 0x12345678;    copy_int(val, buf, maxbytes);    assert(*(int *)buf == val);        val = 0x11111111;    val = 0xAABBCCDD;    copy_int(val, buf, 0);    assert(*(int *)buf != val);    return 0;}

2.73

#include 
    
     #include 
     
      #include 
      
       // 该函数是饱和加法，当正溢出，取最大整数，负溢出，取最小整数int saturationg_add(int x, int y) {    int sum = x + y;    int sig_mask = INT_MIN;    // 如果x > 0 y > 0 sum < 0 正溢出    // 如果x < 0 y < 0 sum > 0 负溢出    int pos_over = !(x & sig_mask) && !(y & sig_mask) && (sum & sig_mask);    int neg_over = (x & sig_mask) && (y & sig_mask) && !(sum & sig_mask);    (pos_over && (sum = INT_MAX)) || (neg_over && (sum = INT_MIN));    return sum;}int main() {    assert(INT_MAX == saturationg_add(INT_MAX, 0x1234));    assert(INT_MIN == saturationg_add(INT_MIN, -0x1234));    assert(0x12 + 0x34 == saturationg_add(0x12, 0x34));    return 0;}

2.74

#include 
    
     #include 
     
      #include 
      
       // 该函数用于检查两个整数相减会不会产生溢出// 这个和上边的题目很相似，可以把x-y看做x+（-y）int tsub_ok(int x, int y) {    // 当y为最小整数的时候，就产生了溢出，因为任何数减最小数都会溢出    if (y == INT_MIN) {        return 0;    }    int neg_y = -y;    int sum = x + neg_y;    int pos_over = x > 0 && neg_y > 0 && sum < 0;    int neg_over = x < 0 && neg_y < 0 && sum >= 0;    return !(pos_over || neg_over);}int main(int argc, char* argv[]) {  assert(!tsub_ok(0x00, INT_MIN));  assert(tsub_ok(0x00, 0x00));  return 0;}

2.75

/*    这个问题需要一步一步的进行推导    T2Uw(x)我们把这种写法称为补码转无符号数，那么很容易得出：    (2^w表示2的w次方，为什么当x<0时是这个结果呢，    其实，补码的负数就是把原来w-1之后的位的结果减去了最高一位的值，最高位的值就是2^w)    if x < 0  => x + 2^w    if x > 0  => x    上边的公式很简单，但在使用的时候还要做判断，显然很不科学，我们可以认为T2Uw(x)是一个函数    接下来就想办法推导出一个表达式来    这里省略了一系列的推导过程，得出了这样一个结果"    T2Uw(X)= X + X(w-1)2^w    大家看看这个式子跟上边的那个作用一样，x的w-1位就是他的最高位，如果该位的值是1，那么就相当于    x<0的情况，否则就是另一种情况    我们假设x`表示x的无符号值    X` = X + X(w-1)2^w    我们假设y`表示x的无符号值    Y` = Y + Y(w-1)2^w    那么X` * Y` = (X + X(w-1)2^w) * (Y + Y(w-1)2^w)    如果要把这个计算式展开会很麻烦，我们可以进一步抽象    设a = X(w-1)2^w, b= Y(w-1)2^w    则： X` * Y` = X*Y + X*b + Y*a + a*b    我们假定有这样一个函数，他的功能是取出无符号数的最高位uh(),因此上边的式子变形为：    uh(X` * Y`) = uh(X*Y + X*b + Y*a + a*b)                = uh(X*Y) + uh(X*b) + uh(Y*a) + uh(a*b)    那么X * b 也就是X*b= X*Y(w-1)2^w 他的最高位的值就是X*Y(w-1)2^w / 2^w => X*Y(w-1)    那么Y * a 也就是Y*a= Y*X(w-1)2^w 他的最高位的值就是Y*X(w-1)2^w / 2^w => Y*X(w-1)    那么a * b 也就是a*b= X(w-1)2^w * Y(w-1)2^w 他 / 2^w => 0    ===> uh(X` * Y`) = uh(X*Y) + X*Y(w-1) + Y*X(w-1)    上边推理的核心思想就是 无符号X`的补码表示：X + X(w-1)2^w 求高位的/ 2^w 操作*//* * unsigned-high-prod.c */#include 
    
     #include 
     
      #include 
      
       int signed_high_prod(int x, int y) {  int64_t mul = (int64_t) x * y;  return mul >> 32;}unsigned unsigned_high_prod(unsigned x, unsigned y) {  /* TODO calculations */  int sig_x = x >> 31;  int sig_y = y >> 31;  int signed_prod = signed_high_prod(x, y);  return signed_prod + x * sig_y + y * sig_x;}/* a theorically correct version to test unsigned_high_prod func */unsigned another_unsigned_high_prod(unsigned x, unsigned y) {  uint64_t mul = (uint64_t) x * y;  return mul >> 32;}int main(int argc, char* argv[]) {  unsigned x = 0x12345678;  unsigned y = 0xFFFFFFFF;  assert(another_unsigned_high_prod(x, y) == unsigned_high_prod(x, y));  return 0;}

2.76

#include 
    
     #include 
     
      #include 
      
       #include 
       
        #include 
        
         void *another_calloc(size_t nmemb, size_t size) {    if (nmemb == 0 || size == 0) {        return NULL;    }    size_t buff_size = nmemb * size;    if (nmemb == buff_size / size) {        void *ptr = malloc(buff_size);        memset(ptr, 0, buff_size);        return ptr;    }    return NULL;}int main() {    void *p;    p = another_calloc(0x1234, 1);    assert(p != NULL);    free(p);    p = another_calloc(SIZE_MAX, 2);    assert(p == NULL);    free(p);    return 0;}

2.77

#include 
    
     #include 
     
      // K = 17int A(int x) {    return (x << 4) + x;}// K = -7int B(int x) {    return x - (x << 3);}// K = 60int C(int x) {    return (x << 6) - (x << 2);}// K = -112int D(int x) {    return (x << 4) - (x << 7);}int main() {    int x = 0x12345678;    assert(A(x) == x * 17);    assert(B(x) == x * -7);    assert(C(x) == x * 60);    assert(D(x) == x * -112);    printf("Passed.\n");    return 0;}

2.78

#include 
    
     #include 
     
      #include 
      
       // c语言的除法要求向0取整，除法本质上就是右移操作int divide_power2(int x, int k) {    int is_neg = x & INT_MIN;    (is_neg && (x = x + (1 << k) - 1));    return x >> k;}int main(int argc, char* argv[]) {  int x = 0x80000007;  assert(divide_power2(x, 1) == x / 2);  assert(divide_power2(x, 2) == x / 4);  printf("%d", x);  return 0;}

2.79

#include 
    
     #include 
     
      #include 
      
       /* * 在这个题目中的除以4中我们需要注意的是取整问题，因此需要用到题目2.78的函数 */int divide_power2(int x, int k) {    int is_neg = x & INT_MIN;    (is_neg && (x = x + (1 << k) -1));    return x >> k;}int mul3div4(int x) {    int mul3 = (x << 1) + x;    return divide_power2(mul3, 2);}int main() {    int t = 0x12345678;    assert(mul3div4(t) == (t * 3 / 4));    return 0;}

2.80

#include 
    
     #include 
     
      #include 
      
       /* * 这个题目非常有意思，要保证不溢出，就要先做除法，也就是先除以4再乘以3 * 在下边中用到了一个非常巧妙的地方，把一个整数进行拆分 *//* * calculate 3/4x, no overflow, round to zero * * no overflow means divide 4 first, then multiple 3, diffrent from 2.79 here * * rounding to zero is a little complicated. * every int x, equals f(first 30 bit number) plus l(last 2 bit number) * *   f = x & ~0x3 *   l = x & 0x3 *   x = f + l *   threeforths(x) = f/4*3 + l*3/4 * * f doesn't care about round at all, we just care about rounding from l*3/4 * *   lm3 = (l << 1) + l * * when x > 0, rounding to zero is easy * *   lm3d4 = lm3 >> 2 * * when x < 0, rounding to zero acts like divide_power2 in 2.78 * *   bias = 0x3    // (1 << 2) - 1 *   lm3d4 = (lm3 + bias) >> 2 */int threeforths(int x) {  int is_neg = x & INT_MIN;  int f = x & ~0x3;  int l = x & 0x3;  int fd4 = f >> 2;  int fd4m3 = (fd4 << 1) + fd4;  int lm3 = (l << 1) + l;  int bias = (1 << 1) + 1;  (is_neg && (lm3 += bias));  int lm3d4 = lm3 >> 2;  return fd4m3 + lm3d4;}int main(int argc, char* argv[]) {  assert(threeforths(8) == 6);  assert(threeforths(9) == 6);  assert(threeforths(10) == 7);  assert(threeforths(11) == 8);  assert(threeforths(12) == 9);  assert(threeforths(-8) == -6);  assert(threeforths(-9) == -6);  assert(threeforths(-10) == -7);  assert(threeforths(-11) == -8);  assert(threeforths(-12) == -9);  return 0;}

2.81

#include 
    
     #include 
     
      #include 
      
       int A(int k) {    return -1 << k;}int B(int k, int j) {    return ~A(k) << j;}int main(int argc, char* argv[]) {  assert(A(8) == 0xFFFFFF00);  assert(B(16, 8) == 0x00FFFF00);  printf("%d", -INT_MIN);  return 0;}

2.82

/* * 2.82.c */#include 
    
     #include 
     
      #include 
      
       #include "lib/random.h"// 强调的是这个推导的过程/* broken when x is INT_MIN */int A(int x, int y) {  return (x < y) == (-x > -y);}/* * right * * ((x + y) << 4) + y - x *   => * x << 4 - x + y << 4 + y *   => * x*16 - x + y*16 + y *   whether overflow or not, => * x*15 + y*17 */int B(int x, int y) {  return ((x + y) << 4) + y - x == 17 * y + 15 * x;}/* * right * * ~x + ~y + 1 *   => * ~x + 1 + ~y + 1 - 1 *   => * -x + -y - 1 *   => * -(x + y) - 1 *   => * ~(x + y) + 1 - 1 *   => * ~(x + y) */int C(int x, int y) {  return ~x + ~y + 1 == ~(x + y);}/* * right * * (ux - uy) == -(unsigned) (y - x) *   => * -(ux - uy) == (unsigned) (y - x) *   => * (ux - uy) == (unsigned) (x - y) */int D(int x, int y) {  unsigned ux = (unsigned) x;  unsigned uy = (unsigned) y;  return (ux - uy) == -(unsigned) (y - x);}/* * right * * x >> 2 << 2 *   => * x & ~0x3 *   => * x - num(00/01/10/11) *   => * ((x >> 2) << 2) <= x */int E(int x, int y) {  return ((x >> 2) << 2) <= x;}int main(int argc, char* argv[]) {  init_seed();  int x = random_int();  int y = random_int();  assert(!A(INT_MIN, 0));  assert(B(x, y));  assert(C(x, y));  assert(D(x, y));  assert(E(x, y));  return 0;}

2.83

/* * A: * 这个问题的关键是找到y，k 和整数x的关系 * 我们假设这个整数是x * 那么x = 0.yyyyyyyy... 这个时候是无法得出结果的，并没有用到k * 那么要想用到k，我们把x左移k为 x << k = y.yyyyyyyy... * 上边的那个表达式中y.yyyyyyyyy... = Y + x * 因此得出 x << k = Y + x === > x << k - x = Y == > x = Y/(2^k - 1) * B: * y = 101  == > k=3 Y=5 x=5/7 * y = 0110  == > k=4 Y=6 x=6/15 * y = 010011  == > k=6 Y=19 x=19/63 */

2.84

#include 
    
     #include 
     
      unsigned f2u(float x) {    return *(unsigned *)&x;}int float_le(float x, float y) {    unsigned ux = f2u(x);    unsigned uy = f2u(y);    unsigned sx = ux >> 31;    unsigned sy = uy >> 31;    return sx == sy ? (sx == 0 ? ux <= uy : ux >= uy) : sx > sy;}int main() {    assert(float_le(+0, -0));    assert(float_le(0, 3));    assert(float_le(-4.12, -0));    assert(float_le(-4, 4));    return 0;}

2.85

A:bias = 2^(k-1) - 1 =v = 2^E + M7.0 = 111.000 = 1.11000x2^2E = 2 = e - bias ==>  e = E + bias = 2 + bias = 1 + 2^(k-1) ==> 0 1000...001 1100...B:能够描述的最大的奇整数的位应该是111111......而浮点数表示为1.111111...*2^n的样式，小数点后边应该有n个1 得到这些，我们就能计算出该浮点数的二进制表示因此最大的奇整数位11111... 有n+1个1 也就是2^(n+1) - 1E = n  ==> e = E + bias = n + bias==> 0 n + bias 11111...C:要想得到最小的规格数，M必须是1.00...的样式 E = 1 - biasV = 2^(1-bias) 取倒数 ==> V = 2^(bias-1) ==> E = bias - 1e = bias + E ==> e = 2bias -1 = 2(2^(k-1) - 1) - 1 = 2^k -3==> 0 1111...101 000000

2.86

第一行答案：最小的正非规格化数，要满足一下几个条件1. 符号位为12. 阶码位全部为03. 单独的整数位为04. 小数位最后一位为1，其他都为0得出的结论是： 0 000..00(15位) 0 000..01(63位)偏量bias = 2^(k-1) - 1 = 2^(15-1) - 1 = 2^14 - 1E = 1 - bias = 1 - 2^14 + 1 = 2 - 2^14V = M * 2^E = 2^(-63) * 2^(2 - 2^14) = 2^(-63 + 2 - 2^14) = 2^(-61-2^14)第二行答案：最小的正规格数，满足下边几个条件1. 符号位为02. 阶码位为13. 按照该题目要求，单独的整数位为14. 小数位全是0得出的结论是： 0 000..01(15位) 1 000..00(63位)偏量bias = 2^(k-1) - 1 = 2^(15-1) - 1 = 2^14 - 1E = e - bias = 1 - 2^14 + 1 = 2 - 2^14V = M * 2^E = 1 * 2^(2 - 2^14)第三行答案：最大的规格数，满足下边几个条件1. 符号位为02. 阶码位全为13. 按照该题目要求，单独的整数位为14. 小数位全是1得出的结论是： 0 111..10(15位) 1 111..11(63位)偏量bias = 2^(k-1) - 1E = e - bias = 2^15 - 2 - biasV = M * 2^E = M * 2^(2^15 - 2 - bias) = M * 2^(2^14 * 2 - 2 - bias)= M * 2^(2bias - bias) = M * 2^bias此时M = 1 + (1 - 2^-63) = 2 - 2^-63得出最终的结果是：2^bias * (2 - 2^-63)

2.87

-0:首先尾数M必须为0阶码可以设置成00000 因此E = 1 - bias = 1 - 15 = -14得到的位模式为：1 00000 0000000000 ==> 0x8000最小的>2的值：由M * 2^E ==> E = 1 M = 1.0000000001E = e - bias ==> e = E + bias = 16 ==> e = 100000M的值为2^-10 + 1 = 1025/1024得到的位模式为：0 10000 0000000001 ==> 0x4001V = 1025/1024 * 2 = 1025/512512:M = 1 E = 9 = e - bias ==> e = 9 + 15 = 24 ==> 11000得到的位模式为：0 11000 0000000000 ==> 0x6000最大的非规格化数：非规格化数表示阶码位都是0 E= 1 - bias = -14M 1023/1024得到的位模式为：0 00000 1111111111 ==> 0x03FF-oo:1 11111 0000000000 ==> 0xFC00十六进制表示为3BB0:先把这个数展开：0011 1011 1011 0000 ==> 0 01110 1110110000e = 14 E = e - bias = 14 - 15 = -1M = 2^-1 + 2^-2 + 2^-3 + 2^-5 + 2^-6 = 59/64V = M * 2^E = 59/64 * 2^-1 = 59/128

2.88

注意：如果是规格化的M = 1 + f 非规格化M = f0 10110 101 :A:E = 22 - 15 = 7 V = (2^-1 + 2^-3 + 1) * 2^7 = 13 * 2^4B:通过观察，我们发现，先保持小数位不变，求阶码，如果不行，在改变小数位因此B的 0 1110 1010 V = 13 * 2^41 00111 110：A:E = 7 - 15 = -8 (2^-1 + 2^-2 + 1) * 2^-8 = 7/4 * 2^-8 = -7/2^10B:1 0011 1110 ==> M = 1 + 2^-1 + 2^-2 + 2^-3 = 15/8==> 2^E = (7/2^10) / (15/8)  = 7/15 / 2^7 约等于2^-1*2^-7 = 2^-8我们看看2^E的范围 2^-6 ~ 2^14由于上边计算的2^-8不在这个范围中，因此需要调整阶码的值先从最小的开始，设阶码为2^-6 那么 7/2^10 / 2^-6 = 7 / 16==> (1/16 + 2/16 + 4/16) ==> (1/16 + 1/8 + 1/4)  ==> (2^-4 + 2^-3 + 2^-2)因此B的 0 0000 01110 00000 101:A:E = 1 - 15 = -14  V = (2^-1 + 2^-3) * 2^-14 = 5 * 2^-3 * 2^-14 = 5 * 2^-17 = 5/2^17假设使用101作为尾数，那么M = (2^-1 + 2^-3 + 1) = 13 * 2^-32^E = V/M = 5/2^17 / (13 * 2^-3) = 5/17 * 2^-17 * 2^3 = 5/17 * 2^-14 显然你在范围之内先从最小的开始，设阶码为2^-6 那么 5/2^17 / 2^-6 = 5 * 2^-11 显然B无法表示这个小数值取一个最近似的 0 0000 00001 11011 000：A:E = 27 - 15 = 12 V = 2^12 取-  得-2^12B:由于这个值比较大，因此阶码取最大值1110 e = 14 E = e - 7 = 14 - 7 = 7 这样才能计算M的最小值M = 2^12 / 2^7 = 2^5显然M的值无法表示，因此阶码我们这次使用 1111 -oo1 1111 0000

2.89

/* * 2.89.c */#include 
    
     #include 
     
      #include 
      
       #include "lib/random.h"/* * most important thing is that all double number come from ints *//* right */int A(int x, double dx) {  return (float)x == (float)dx;}/* wrong when y is INT_MIN */int B(int x, double dx, int y, double dy) {  return dx-dy == (double)(x-y);}/* right */int C(double dx, double dy, double dz) {  return (dx+dy)+dz == dx+(dy+dz);}/* * wrong * * FIXME I don't know what conditions cause false */int D(double dx, double dy, double dz) {  return (dx*dy)*dz == dx*(dy*dz);}/* wrong when dx != 0 and dz == 0 */int E(double dx, double dz) {  return dx/dx == dz/dz;}int main(int argc, char* argv[]) {  init_seed();  int x = random_int();  int y = random_int();  int z = random_int();  double dx = (double)x;  double dy = (double)y;  double dz = (double)z;  printf("%x %x %x\n", x, y, z);  assert(A(x, dx));  assert(!B(0, (double)(int)0, INT_MIN, (double)(int)INT_MIN));  assert(C(dx, dy, dz));  /* magic number, brute force attack */  assert(!D((double)(int)0x64e73387, (double)(int)0xd31cb264, (double)(int)0xd22f1fcd));  assert(!E(dx, (double)(int)0));  return 0;}

2.90

/* * fpwr2.c */#include 
    
     #include 
     
      #include 
      
       float u2f(unsigned x) {  return *(float*) &x;}/* 2^x */float fpwr2(int x) {  /* Result exponent and fraction */  unsigned exp, frac;  unsigned u;/* 因为2^x 是大于0的，因此我们首先要确定浮点数能够表示的正非规格化数的最小值是0 00000000 00000...001  ==> 2^-23 * 2^(1-bias) = 2^-23 * 2^(1-(2^7 - 1))= 2^-23 * 2^(2-2^7)) = 2^(2 - 2^7 -23) = 2 - 128 - 23 = -149*/  if (x < 2-pow(2,7)-23) {    /* too small. return 0.0 */    exp = 0;    frac = 0;  } else if (x < 2-pow(2,7)) {    /* Denormalized result */    /* 求出最小的规格化数0 00000001 00000...000E = 1 - 2^7 + 1 = 2 - 2^7 = -126 */    exp = 0;    /* 这段代码块求的值应该是非规格化数范围内的值       根据 V = M * 2^E V = 2^x  ==> 2^x = M * 2^E       frac = M = 2^x / 2^E       E = 1 - bias = 2-2^7       frac = 2^(x - (2 - 2^7)) 这个是frac的值，但是我们如何获得它的位模式呢？       我们知道0 00000000 00000...001 最后边这个1对应的值是2^-23 也就是说       小数位的值和他的位模式有一个对应关系，我们只要求出frac是最后这个1（2^-23）的多少       倍，然后1 << 这个倍数就可以了，这样就得到了frac的位模式     */    frac = 1 << (unsigned)(x - (2-pow(2,7)-23));  } else if (x < pow(2,7)-1+1) {    /* Normalized result */    /* 11111111 2^8 -1 - (2^7 - 1) ==> 2^8 - 2^7 -1 + 1 ==> 2^7       因此求exp 就等于求e e = E + bias = x + (2^7 - 1)     */    exp = pow(2,7)-1+x;    frac = 0;  } else {    /* Too big, return +oo */    exp = 0xFF;    frac = 0;  }  /* pack exp and frac into 32 bits */  u = exp << 23 | frac;  /* Result as float */  return u2f(u);}int main(int argc, char* argv[]) {  assert(fpwr2(0) == powf(2,0));  assert(fpwr2(100) == powf(2,100));  assert(fpwr2(-100) == powf(2,-100));  assert(fpwr2(10000) == powf(2,10000));  assert(fpwr2(-10000) == powf(2,-10000));  return 0;}

2.91

A:0x40490FDB 展开后 0100 0000 0100 1001 0000 1111 1101 1011换成小数的位模式： 0 10000000 10010010000111111011011由于2^E = 2 V = 2M  我们知道M = 1.10010010000111111011011 那么2m就相当于 << 1 得到：11.0010010000111111011011B:在问题2.83中我们得出这么一个公式：x = Y/(2^k - 1)在本题中 x = 1/7 也就是说Y = 1 k = 3 说明Y是3位且值为1 因此就是001所以最终的答案是11.001001001...(001)C:十进制小数转二进制数：“乘以2取整，顺序排列”（乘2取整法）223/71 = 3.140845070422535 小数部分：0.1408450704225350.140845070422535 * 2 = 0.28169014084507  ----- 取整 ----- 00.28169014084507 * 2 = 0.563380281690141  ----- 取整 ----- 00.563380281690141 * 2 = 1.126760563380282  ----- 取整 ----- 10.126760563380282 * 2 = 0.253521126760563  ----- 取整 ----- 00.253521 * 2 = 0.507042  ----- 取整 ----- 00.507042 * 2 = 1.014084  ----- 取整 ----- 10.014084 * 2 = 0.028168  ----- 取整 ----- 00.028168 * 2 = 0.056336  ----- 取整 ----- 00.056336 * 2 = 0.112672  ----- 取整 ----- 00.112672 * 2 = 0.225344  ----- 取整 ----- 0因此在第9位就不同了

2.92

#include 
    
     #include 
     
      typedef unsigned float_bits;float_bits float_negate(float_bits f) {    unsigned sig = f >> 31;    unsigned exp = f >> 23 & 0xFF;    unsigned frac = f & 0x7FFFFF;    int is_nan = (exp == 0xFF && frac != 0);    if (is_nan) {        return f;    }    return ~sig << 31 | exp << 23 | frac;}int main() {    printf("%u", float_negate(32.0));    assert(float_negate(32.0) == -32.0);    return 0;}

2.93

#include 
    
     #include 
     
      typedef unsigned float_bits;float_bits float_absval(float_bits f) {    unsigned exp = f >> 23 & 0xFF;    unsigned frac = f & 0x7FFFFF;    int is_nan = (exp == 0xFF && frac != 0);    if (is_nan) {        return f;    }    return 0 << 31 | exp << 23 | frac;}int main() {    printf("%u\n", float_absval(32.0));    return 0;}

2.94

#include 
    
     #include 
     
      typedef unsigned float_bits;/* * 要想实现浮点数*2，可以这么考虑 V = M * 2^E * 当浮点数是规格数的时候，我们只需要改变E就行了，E = e - bias ==> 相当于给e的值+1 * 但是+1有个特殊情况，要是e的位模式为11111110 +1 就需要特殊处理 * 如果是非规格数， 那么 2^E就是固定的值，我们只能改变M的大小，*2就相当于把小数位左移一位 */float_bits float_twice(float_bits f) {    unsigned sig = f >> 31;    unsigned exp = f >> 23 & 0xFF;    unsigned frac = f & 0x7FFFFF;    int is_nan_or_oo = (exp == 0xFF);    if (is_nan_or_oo) {        return f;    }    if (exp == 0) {        frac <<= 1;    } else if (exp == 0xFE) {        exp = 0xFF;        frac = 0;    } else {        exp += 1;    }    return sig << 31 | exp << 23 | frac;}int main() {    printf("%u\n", float_twice(32.22));    return 0;}

2.95

/* * float-half.c */#include 
    
     #include 
     
      typedef unsigned float_bits;float_bits float_half(float_bits f) {  unsigned sig = f >> 31;  unsigned rest = f & 0x7FFFFFFF;  unsigned exp = f >> 23 & 0xFF;  unsigned frac = f & 0x7FFFFF;  int is_NAN_or_oo = (exp == 0xFF);  if (is_NAN_or_oo) {    return f;  }  /*   * 这里就用到了向偶数取整的知识，在下边的注释中描述的很详细   * 那么如何理解取整呢，我们假设这个被右移出去的位为a，那么a就有可能是1或者0，如果是0，那么我们     就不需要取整，如果是1，我们可以这么想：1111.a 这个a如果是1，折算成小数就是0.5 因此是需要     取整的，它前边的那一位如果是0，表示已经是偶数了，就舍弃a 如果是1，要向上取整，在未右移之前+1就可以了   */  /*   * round to even, we care about last 2 bits of frac   *   * 00 => 0 just >>1   * 01 => 0 (round to even) just >>1   * 10 => 1 just >>1   * 11 => 1 + 1 (round to even) just >>1 and plus 1   */  int addition = (frac & 0x3) == 0x3;  if (exp == 0) {    /* Denormalized */    frac >>= 1;    frac += addition;  } else if (exp == 1) {    /* Normalized to denormalized */    rest >>= 1;    rest += addition;    exp = rest >> 23 & 0xFF;    frac = rest & 0x7FFFFF;  } else {    /* Normalized */    exp -= 1;  }  return sig << 31 | exp << 23 | frac;}

2.96

#include 
    
     #include 
     
      /*    我们首先考虑作为浮点数f能表示的最大的合法的整数是多少？    V = M * 2^E E = e - bias 由这两个公式可知E越大越好也就是e越大越好    e ==> 11111110 不能是11111111，    我们再考虑一个范围 0 <= f < 1 如果f在这个范围中，那么它的值就直接取0    我们要找出这个范围的浮点位模式，0：0 00000000 00000000000000000000000                              1：0 01111111 00000000000000000000000    在上边的这个空间的值直接取0就行    那么f能表示的最大的合法的规格数是 0 11111110 111111111111111111111111    超过这个数的就成为越界了    如果在这个范围内：    E = exp - bias;    我们知道M的值的二进制小数是1.xxxxx... 但是下边M的值明显是做了<<23操作的，因此后边就要用E- 23    M = frac | 0x800000;    f = M * 2^E 根据这个公式，向0取整    if (E > 23) {      num = M << (E - 23);    } else {      num = M >> (23 - E);    } */ /* * Compute (float) f * If conversion cause overflow or f is NaN, return 0x80000000 */int float_f2i(float_bits f) {  unsigned sig = f >> 31;  unsigned exp = f >> 23 & 0xFF;  unsigned frac = f & 0x7FFFFF;  unsigned bias = 0x7F;  int num;  unsigned E;  unsigned M;  /*   * consider positive numbers   *   * 0 00000000 00000000000000000000000   *   ===>   * 0 01111111 00000000000000000000000   *   0 <= f < 1   * get integer 0   *   * 0 01111111 00000000000000000000000   *   ===>   * 0 (01111111+31) 00000000000000000000000   *   1 <= f < 2^31   * integer round to 0   *   * 0 (01111111+31) 00000000000000000000000   *   ===>   * greater   *   2^31 <= f < oo   * return 0x80000000   */  if (exp >= 0 && exp < 0 + bias) {    /* number less than 1 */    num = 0;  } else if (exp >= 31 + bias) {    /* number overflow */    /* or f < 0 and (int)f == INT_MIN */    num = 0x80000000;  } else {    E = exp - bias;    M = frac | 0x800000;    if (E > 23) {      num = M << (E - 23);    } else {      /* whether sig is 1 or 0, round to zero */      num = M >> (23 - E);    }  }  return sig ? -num : num;}

2.97

/* * float-i2f.c */#include 
    
     #include 
     
      #include 
      
       #include "float-i2f.h"/* * Assume i > 0 * calculate i's bit length * * e.g. * 0x3 => 2 * 0xFF => 8 * 0x80 => 8 */int bits_length(int i) {  if ((i & INT_MIN) != 0) {    return 32;  }  unsigned u = (unsigned)i;  int length = 0;  while (u >= (1<
       
         0x00000007 * 16 => 0x0000FFFF */unsigned bits_mask(int l) {  return (unsigned) -1 >> (32-l);}/* * Compute (float) i */float_bits float_i2f(int i) {  unsigned sig, exp, frac, rest, exp_sig /* except sig */, round_part;  unsigned bits, fbits;  unsigned bias = 0x7F;  if (i == 0) {    sig = 0;    exp = 0;    frac = 0;    return sig << 31 | exp << 23 | frac;  }  if (i == INT_MIN) {    sig = 1;    exp = bias + 31;    frac = 0;    return sig << 31 | exp << 23 | frac;  }  sig = 0;  /* 2's complatation */  if (i < 0) {    sig = 1;    i = -i;  }  bits = bits_length(i);  fbits = bits - 1;  exp = bias + fbits;  rest = i & bits_mask(fbits);  if (fbits <= 23) {    frac = rest << (23 - fbits);    exp_sig = exp << 23 | frac;  } else {    int offset = fbits - 23;    int round_mid = 1 << (offset - 1);    round_part = rest & bits_mask(offset);    frac = rest >> offset;    exp_sig = exp << 23 | frac;    /* round to even */    if (round_part < round_mid) {      /* nothing */    } else if (round_part > round_mid) {      exp_sig += 1;    } else {      /* round_part == round_mid */      if ((frac & 0x1) == 1) {        /* round to even */        exp_sig += 1;      }    }  }  return sig << 31 | exp_sig;}