深入理解计算机原理（csapp第三版）——datalab

1. bitXor

bitXor - x^y using only ~ and &

Example: bitXor(4, 5) = 1

Legal ops: ~ &

Max ops: 14

Rating: 1

异或，只能用~和&，操作数最大14个

int bitXor(int x, int y) {
    int res = ~(~(x & ~y) & ~(~x & y));
    return res;
}

思路
- 异或，就是不同时才为1，相同时为0。那么，使用非~就可以找出，x & _{y为1的位就是x为1但是y为0的位，}x & y为1的位就是x为0但是y为1的位。
- 找出异或为1的位后，需要做一个或运算，但是本题中不能用|。用~(a | b)==~a & ~b来代替。
其他答案

int bitXor(int x, int y) {
  return ~(~x&~y)&~(x&y);
}

这个利用的是，_x&y为1的位是同时为0的，x&y为1的位是同时为1的，那么其按位非就是不同时为1且不同时为0的。

2. tmin

tmin - return minimum two's complement integer

Legal ops: ! ~ & ^ | + << >>

Max ops: 4

Rating: 1

2的补码的最小值

int tmin(void) {
    int res = 1 << 31;
    return res;
}

只把符号位置为1就行了

3. isTmax

isTmax - returns 1 if x is the maximum, two's complement number, and 0 otherwise

Legal ops: ! ~ & ^ | +

Max ops: 10

Rating: 1

如果返回的是补码的最大值，就返回1

int isTmax(int x) {
    int addOne = x + 1;
    int res = addOne ^ ~x;
    return !(res + !addOne);
}

一个数的相反数的表示和这个数加一一样，这种情况只存在于符号转变的从-1到0和从TMax到TMin之间。排除0的情况就是TMax了

4. allOddBits

allOddBits - return 1 if all odd-numbered bits in word set to 1 where bits are numbered from 0 (least significant) to 31 (most significant)

Examples allOddBits(0xFFFFFFFD) = 0, allOddBits(0xAAAAAAAA) = 1

Legal ops: ! ~ & ^ | + << >>

Max ops: 12

Rating: 2

如果所有的奇数位都为1就返回1，位数是从零开始数的。

int allOddBits(int x) {
    int mask = 0xAA;
    mask |= mask << 8;
    mask |= mask << 16;
    int res = (x & mask) ^ mask;
    return !res;
}

5. negate

negate - return -x

Example: negate(1) = -1.

Legal ops: ! ~ & ^ | + << >>

Max ops: 5

Rating: 2

返回负数

int negate(int x) {
    int res = ~x + 1;
  return res;
}

相反数就是补码加一

6. isAsciiDigit

isAsciiDigit - return 1 if 0x30 <= x <= 0x39 (ASCII codes for characters '0' to '9')

Example: isAsciiDigit(0x35) = 1.

isAsciiDigit(0x3a) = 0.

isAsciiDigit(0x05) = 0.

Legal ops: ! ~ & ^ | + << >>

Max ops: 15

Rating: 3

返回数值在0x30和0x39之间的数

int isAsciiDigit(int x) {
    int highBit = !((x >> 4) ^ 0x3);
    int bitOne = (x>>3) & 0x1;
    int bit23 = (x>>1) & 0x3;
    return highBit & (!bitOne | !bit23);
}

0x30 → 0011 0000 0x39 → 0011 1001
在这个范围内的，首先第一位必须是0011
其次第二位有两种情况，最高位为0时，总是符合（0000~0111）；最高位为1时，必须有中间两位为0（1000,1001）
其他答案
- 可以使用两个数，一个数是加上比0x39大的数后符号由正变负，另一个数是加上比0x30小的值时是负数。这两个数是代码中初始化的 upperBound 和 lowerBound，然后加法之后获取其符号位判断即可

int isAsciiDigit(int x) {
  int sign = 0x1<<31;
  int upperBound = ~(sign|0x39);
  int lowerBound = ~0x30;
  upperBound = sign&(upperBound+x)>>31;
  lowerBound = sign&(lowerBound+1+x)>>31;
  return !(upperBound|lowerBound);
}

7. conditional

conditional - same as x ? y : z

Example: conditional(2,4,5) = 4

Legal ops: ! ~ & ^ | + << >>

Max ops: 16

Rating: 3

实现一个三元表达式

int conditional(int x, int y, int z) {
    int flag = ~!!x + 1;
    return (flag & y) | (~flag & z);
}

把flag构造为全0或者全1的来与y和z进行与。
如果x非0，那么~!!x + 1就是全1；如果x是0，那么~!!x + 1就是全0

8. isLessOrEqual

isLessOrEqual - if x <= y then return 1, else return 0

Example: isLessOrEqual(4,5) = 1.

Legal ops: ! ~ & ^ | + << >>

Max ops: 24

Rating: 3

实现一个小于等于

int isLessOrEqual(int x, int y) {
    int diff = ~x + y + 1;
    int signX = (x>>31) & 0x1;
    int signY = (y>>31) & 0x1;
    int signD = (diff>>31) & 0x1;
    int sameSign = !(signX ^ signY);
    return (sameSign & !signD) | (!sameSign & signX);
}

虽然不能用减法，但是比较大小就是做差的过程。转换目标为y-x≥0，因为大于等于0的符号位都是0.
首先用y-x=~x+y+1算出差的位级表示，但是这个结果是可能溢出的，需要判断是否溢出。
如果x和y的符号一致，肯定是不会溢出的；如果溢出的话，那么y-x≥0就取决于x和y的符号了（他俩一定是相反的）

9. logicalNeg

logicalNeg - implement the ! operator, using all of the legal operators except !

Examples: logicalNeg(3) = 0, logicalNeg(0) = 1

Legal ops: ~ & ^ | + << >>

Max ops: 12

Rating: 4

实现逻辑非的表示。

int logicalNeg(int x) {
    int com = ~x + 1;
    int signOrigin = (x>>31) & 0x1;
    int signCom = (com>>31) & 0x1;
    int sameSign = signOrigin ^ signCom ^ 0x1;
    return sameSign & (((x>>31) & 0x1) ^ 0x1);
}

基本思路就是，既然只有一个输入x，那么要么是对x进行变换后比较，要么是和固定值比较。
把x和-x的符号进行比较，如果不同那么就输出0；如果相同且不是0x80000000就返回1。
主要是要用异或实现对指定位的非操作
其他答案
- 还是利用符号位，只不过要简单一些。直接把x和-x的符号做或，如果为1就返回1，如果为0就返回0。使用右移31位，符号位为0就是0，符号位为1就是-1，加1即可

int logicalNeg(int x) {
  return ((x|(~x+1))>>31)+1;
}

10. howManyBits

howManyBits - return the minimum number of bits required to represent x in two's complement *

Examples:

howManyBits(12) = 5

howManyBits(298) = 10

howManyBits(-5) = 4

howManyBits(0) = 1

howManyBits(-1) = 1

howManyBits(0x80000000) = 32

Legal ops: ! ~ & ^ | + << >>

Max ops: 90

Rating: 4

一个数用补码表示最少需要几位？

int howManyBits(int x) {
    int sign = x>>31;
    int y = (sign & ~x) | (~sign & x);
    int b16 = (!!(y>>16))<<4;     //高十六位是否有1
    y = y>>b16;                   //如果有（至少需要16位），则将原数右移16位
    int b8 = (!!(y>>8))<<3;       //剩余位高8位是否有1
    y = y>>b8;                    //如果有，则右移8位
    int b4 = (!!(y>>4))<<2;
    y = y>>b4;
    int b2 = (!!(y>>2))<<1;
    y = y>>b2;
    int b1 = !!(y>>1);
    y = y>>b1;
    int b0 = y;
    return b16 + b8 + b4 + b2 + b1 + b0 + 1;
}

位运算也不定不能用二分，这道题就相当于层层二分了。
对于正数，最少位数为最高位的1加一个符号位；对于负数，最少位数为最高位的0加一个符号位。所以可以直接把负数转成补码处理。
用两个非!!来测试范围内有没有1，层层二分，如果范围内有就位移并加上这个范围。

11. floatScale2

floatScale2 - Return bit-level equivalent of expression 2*f for floating point argument f.

Both the argument and result are passed as unsigned int's, but they are to be interpreted as the bit-level representation of single-precision floating point values.

When argument is NaN, return argument

Legal ops: Any integer/unsigned operations incl. ||, &&. also if, while

Max ops: 30

Rating: 4

求2乘以一个浮点数

unsigned floatScale2(unsigned uf) {
    unsigned sign = uf >> 31;
    unsigned exp = (uf >> 23) & 0xFF;
    unsigned frac = uf & 0x7FFFFF;
    if(exp==0xFF) {
        return uf;
    } else if(exp!=0) {
        exp += 1;
    } else {
        if((frac>>22)&0x1) {
            frac = frac & ~0x800000;
            exp = 1;
        }
        frac = frac<<1;
    }

    return (sign<<31) | (exp<<23) | frac;
}

区分无穷/NaN，返回其本身。问题是其实无穷也应该返回NaN，但是直接返回无穷不会报错。
规格化数直接exp加一；非规格化数如果最高位是1就要规格化。

12. floatFloat2Int

floatFloat2Int - Return bit-level equivalent of expression (int) f for floating point argument f.

Argument is passed as unsigned int, but it is to be interpreted as the bit-level representation of a single-precision floating point value.

Anything out of range (including NaN and infinity) should return 0x80000000u.

Legal ops: Any integer/unsigned operations incl. ||, &&. also if, while

Max ops: 30

Rating: 4

把浮点数转换为整数

int floatFloat2Int(unsigned f) {
    unsigned sign = f >> 31;
    unsigned exp = (f >> 23) & 0xFF;
    unsigned frac = f & 0x7FFFFF;
    unsigned e, half, round, rest;
    int k = 23;
    int bias = 127;
    if(exp==0xFF) {
        return 0x80000000;
    }
    if(exp < bias) {   //(1<<(8-1))-1
        return 0;
    } else {
        frac |= 0x800000;
        e = exp - bias;
        if(e<k) {
            half = 1<<(k - e - 1);
            round = frac & ((1<<(k - e)) - 1);
            rest = frac >> (k - e);
            if(round>half) {
                rest += 1;
            } else {
                if(round==half && (rest & 0x1)) {
                    rest += 1;
                }
            }
        } else if(e<31) {
            rest = frac << (e - k);
        } else {
            return 0x80000000;
        }
    }
    if(sign) {
        rest = ~rest + 1;
    }
    return rest;
}

比较麻烦的是处理向偶数舍入

13. floatPower2

floatPower2 - Return bit-level equivalent of the expression 2.0^x (2.0 raised to the power x) for any 32-bit integer x.

The unsigned value that is returned should have the identical bit representation as the single-precision floating-point number 2.0^x.

If the result is too small to be represented as a denorm, return 0. If too large, return +INF.

Legal ops: Any integer/unsigned operations incl. ||, &&. Also if, while

Max ops: 30

Rating: 4

输入一个整数x，返回他的2x2^x2x

unsigned floatPower2(int x) {
    int k = 23;
    int bias = 127;
    unsigned frac;
    unsigned exp;
    if(x>bias) {
        return 0x7F800000;
    } else if(x>=-bias) {
        exp = x + bias;
        frac = 0;
    } else if(x>=-bias-k+2) {
        exp = 0;
        frac = 1<<(bias+k-2+x);
    } else {
        return 0x0;
    }
    return (exp<<k) | frac;
}

比较麻烦的是要处理非规格数。此外需要把超时时间调大一点，不然会运行不完。

posted @ 2021-12-12 17:29 iwehdio 阅读(962) 评论(0) 编辑收藏举报

刷新页面返回顶部

iwehdio

——来源与结束于否定之否定

深入理解计算机原理（csapp第三版）——datalab

1. bitXor

2. tmin

3. isTmax

4. allOddBits

5. negate

6. isAsciiDigit

7. conditional

8. isLessOrEqual

9. logicalNeg

10. howManyBits

11. floatScale2

12. floatFloat2Int

13. floatPower2

公告