資訊的表示和處理 及 CS:APP 15213 datalab
資訊的表示和處理
在通用計算機中中,位元組
作為最為最小 的可定址的記憶體單元,而不是訪問記憶體中單獨的位。
定址和位元組順序
big endian
(大端法),資料最高位元組部分地址在地址處,和人的感覺邏輯相似little endian
(小端法),低位元組部分在低地址處
布林代數
1
TRUE2
FALSE~
NOT&
AND|
OR^
EXCLUSIVE-OR(異或)- 1 ^ 0 = 1
- 1 ^ 1 = 0
- 0 ^ 0 = 0
- 0 ^ 1 = 1
IEEE 754 浮點數
$ V = (-1)^s \times M \times 2^E$
- 符號(sign) s(1)為負數, s
- 尾數(significand) M 是一個二進位制小數, 範圍為 $1 \sim 2 - \varepsilon $ 或者 \(0 \sim 1 - \varepsilon\)
- 階碼(exponent) E的作用是對浮點數加權, 權重的範圍為2的 E 次方冪
將浮點數的位劃分位三個欄位,分別對這些值賦值:
- 一個單獨的符號位 s 直接編碼符號位 s, 1-bit
- k 位的階碼欄位 \(exp = e_{k-1} \cdots e_1 e_0\) 編碼階碼 E,
k=7
(單精度),k=11
(雙精度) - n 位小數字段 \(frac = f_{n-1} \cdots f_1 f_0\) 編碼尾數 M
n=23
(單精度),n=52
(雙精度)
浮點數的值:
- e 為無符號整數,其位表示 \(e_{k-1} \cdots e_1 e_0\)
- 小數字段 frac 被解釋為描述小數值 \(f\), 其中 \(0 \le f \le 1\), 其二進位制表示\(0.f_{n-1} \cdots f_1 f_0\)
- Bias 是一個等於 $2^{k-1} -1 $ 的偏置值
- 規格化\((exp !=0, exp != 2^{k}-1)\), 最常遇到的值
- 階碼的值 \(E = exp - Bias\)
- 尾數定義 \(M = 1 + f\)
- 非規格化\((exp == 0)\), 提供表示數值 0 及逐漸接近 0 的方法
- 階碼的值 $E = 1 - Bias $
- 尾數定義 \(M = f\)
- 非規格化\((exp == 2^{k}-1)\), 特殊值
NaN
舍入
表示方法限制了浮點數的範圍和精度
偶數舍入(round-to-even)
為預設的舍入方式, 其將數字向上或向下舍入,使得結果的最低有效數字(保留位)是偶數(0)
只有是在兩個可能的結果的中間值才考慮向偶數舍入, 大於 0.5 是直接進位的
向上舍入的情況,向下舍入可以不管(反正要丟棄了,不影響結果)
尾數 \(1.BBGRXXX\), 保留位(Guard bit)、近似位(Round bit) 和 粘滯位(Sticky bit)
- Round = 1, Sticky = 1 > 0.5 進位
- Guard = 1, Round = 1, Sticky = 0 -> 偶數向上舍入
實驗部分
1. 只用 ~
和 &
操作符求兩個數的或
摩根定律: $ \neg(p \lor q) = \neg p \land \neg q $
異或:$ p \oplus q = (\neg p \land q) \lor (p \land \neg q)$
所以展開即可
/*
* bitXor - x^y using only ~ and &
* Example: bitXor(4, 5) = 1
* Legal ops: ~ &
* Max ops: 14
* Rating: 1
*/
int bitXor(int x, int y) {
return ~(~(~x & y) & ~(x & ~y));
}
2. 最小的整形補碼, 可用符號 ! ~ & ^ | + << >>
$ -2^{31} $ (0xF0000000)
/*
* tmin - return minimum two's complement integer
* Legal ops: ! ~ & ^ | + << >>
* Max ops: 4
* Rating: 1
*/
int tmin(void) {
return 1 << 31;
}
3. 判斷是否是最大的整形數,可用符號 ! ~ & ^ | +*
直接利用 INT_MAX + INT_MAX + 2 = 0 的結果並且排除0xFFFFFFFF,還要注意一個不能直接相加,只能 x+1+x+1
/*
* isTmax - returns 1 if x is the maximum, two's complement number,
* and 0 otherwise
* Legal ops: ! ~ & ^ | +
* Max ops: 10
* Rating: 2
*/
int isTmax(int x) {
return !(x + 1 + x + 1) & !!(x + 1);
}
4. 判斷所有的奇數位為1,可用符號 ! ~ & ^ | + << >>
排除偶數位的干擾得到奇數位的值,再與奇數位的 0xaaaaaaaa 做亦或運算,如果正確結果必為 0,這時做 非運算 就可以了
所有先得到 0xaaaaaaa
/*
* allOddBits - return 1 if all odd-numbered bits in word set to 1
* Examples allOddBits(0xFFFFFFFD) = 0, allOddBits(0xAAAAAAAA) = 1
* Legal ops: ! ~ & ^ | + << >>
* Max ops: 12
* Rating: 2
*/
int allOddBits(int x) {
int bits0_15 = (0xAA << 8) + 0xAA;
int bits0_23 = (bits0_15 << 8) + 0xAA;
int bits0_31 = (bits0_23 << 8) + 0xAA;
return !((bits0_31 & x) ^ bits0_31);
}
5.取負,可用符號 ! ~ & ^ | + << >>
/*
* negate - return -x
* Example: negate(1) = -1.
* Legal ops: ! ~ & ^ | + << >>
* Max ops: 5
* Rating: 2
*/
int negate(int x) { return ~x + 1; }
6. 判斷是否是 ASCII 數字,可用符號 ! ~ & ^ | + << >>
- 判斷高 6_31 位,必須是 0
- 判斷 4 5 位,必須為 1
- 判斷第四位,通過相加6判斷是否有進位
/*
* 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
*/
int isAsciiDigit(int x) {
int bit6_31 = !((x >> 6) & (~0));
int bit_5 = (x & 0x20) >> 5;
int bit_4 = (x & 0x10) >> 4;
int bits0_3 = !(((x & 0xF) + 6) & 0x10);
return bits0_3 & bit_4 & bit_5 & bit6_31;
}
7. 條件判斷,三目運算子, 可用字元 ! ~ & ^ | + << >>
思路:由於 X & 0xFFFFFFFF = X, X & 0x0 = 0
, 將兩個數和 0xFFFFFFFF, 0x0 做與操作,再相加
- 只需要找到什麼時候為 0xFFFFFFFF 和 0x0, 注意這兩者可通過
~
得到
/*
* 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 + ~0);
return (z & flag) + (y & ~flag);
}
8. 小於等於 可用字元 ! ~ & ^ | + << >>
思路:判斷相等,同符號相減判斷是否有進位,不同符號直接判斷第一個數的符號是否為 正
/*
* 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 equal = !(x ^ y); // x == y
int same_sign = !((x ^ y) >> 31); // sign
int x_reduce_y = ~y + 1 + x;
return equal | (same_sign & (x_reduce_y >> 31)) | ((!same_sign) & (x >> 31) & 1);
}
9. 非運算子 可用字元 ! ~ & ^ | + << >>
思路:核心就是抓住 符號位判斷
- 考慮取反還是取負,取反所有數字的符號位都改變,取負只有 0 和 0x80000000 符號位不變,且這兩個符號位相反,所以用取負的方式
- 將數與其負數
直接
做與操作,只有 0x80000000,符號為 1 不變,不能篩選出 0 的情況 - 考慮別的情況,將數
取反
做與操作,符號相反的數與操作後仍然為 0, 0x800000000 取反(符號為0)與其負數(符號為0)相與也還為 0,只有0取反後符號為1,與操作後仍為1
/*
* 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) {
return ((~x & ~(~x + 1)) >> 31) & 0x1;
}
10. 計算一個最少的補碼位可以表達的位數 可用字元 ! ~ & ^ | + << >>
思路:將相鄰位做亦或操作,找到最高的位為 1 所在的位
~(bits16 << 3) + 1) + (((bits16 ^ 1) & 0x1) << 3
, bits* 為上一個移位的結果,利用這個結果判斷是增加位移的大小
/* 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) {
// all assignment must be followed by a declaration.
int bits16, bits8, bits4, bits2, bits1;
int shift16, shift8, shift4, shift2, shift1;
int shift_off = 16; // first shift offset
x ^= x << 1; // find the highest 1-bit after XOR adjacent bits
bits16 = !(x >> shift_off);
shift16 = bits16 << 4;
// binary search.
// if result of prev offset != 0, shift_off should be increasing half prev
// offset , else should be decreasing half.
shift_off = shift_off + (~(bits16 << 3) + 1) + (((bits16 ^ 1) & 0x1) << 3);
bits8 = (!(x >> shift_off));
shift8 = bits8 << 3;
shift_off = shift_off + (~(bits8 << 2) + 1) + (((bits8 ^ 1) & 0x1) << 2);
bits4 = (!(x >> shift_off));
shift4 = bits4 << 2;
shift_off = shift_off + (~(bits4 << 1) + 1) + (((bits4 ^ 1) & 0x1) << 1);
bits2 = (!(x >> shift_off));
shift2 = bits2 << 1;
shift_off = shift_off + (~(bits2) + 1) + ((bits2 ^ 1) & 0x1);
bits1 = (!(x >> shift_off));
shift1 = bits1;
}
11. 計算浮點數 f 2, 返回浮點數的二進位制位表示, 可用符號不受限制*
思路:由於尾數的值取決於 frac 和 exp,所以要對其分開處理
- 對於規格數,exp + 1, 但要考慮 +1 後不能為 255
- 對於非規格數
- exp = 255, 直接返回引數
- exp = 0, frac = 0 返回 0, 因為這就是個 0
- exp = 0, frac != 0, frac 左移一位(尾數取值的問題),又要判斷左移後是否溢位(0-22bit)
/*
* float_twice - 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
*/
unsigned float_twice(unsigned uf) {
int exp = 0x7f800000 & uf;
int frac = 0x007FFFFF & uf;
int sign = 0x80000000 & uf;
int bias = (exp >> 23) - 127;
if (uf == 0x0)
return 0;
if (bias == 128) // NaN return NaN, inf can't *2
return uf;
// frac depends on exp, so exp could not add 1 alone.
if (exp == 0) { // (exp + frac) << 1
frac = (frac << 1) & 0x007FFFFF;
if (uf & 0x00400000)
exp = 0x00800000;
} else {
exp = (exp + 0x00800000) & 0x7F800000;
if (exp == 0x7F800000)
frac = 0;
}
uf = sign | exp | frac;
return sign | exp | frac;
}
12. 整數轉浮點數,返回浮點數的二進位制位表示, 可用符號不受限制
思路:核心在於發現該數的絕對值的最高位 1 對應浮點數隱式精度的 1, 然後最高位1後的23位排列在 frac 位置
- 取數的絕對值,後面對非負數數進行操作
- 取最少可以表達整數(最高位 1)的 k 位 inum,
- 所在的位數 n 整數i轉浮點數f 在位模式上為 將 k-1 .. k-2 .. 0 放置在浮點數的 frac 部分,非規格數有一個隱式 1, 代替數字有效最高位 1
- 由上精度有限制,有效位的前23位充當尾數部分,要對後9位進行判斷是否需要舍入
- 將 exp = 127 + n
- 符號位不變
- 其他 0 等情況考慮
/*
* float_i2f - Return bit-level equivalent of expression (float) x
* Result is returned as unsigned int, but
* it is to be interpreted as the bit-level representation of a
* single-precision floating point values.
* Legal ops: Any integer/unsigned operations incl. ||, &&. also if, while
* Max ops: 30
* Rating: 4
*/
unsigned float_i2f(int x) {
unsigned abs_x = x;
unsigned sign = x & 0x80000000;
int flag = 0;
int n = 30;
if (x == 0)
return x;
else if (x == 0x80000000)
return 0xcf000000;
if (sign)
abs_x = -x;
while (!(abs_x & (1 << n)))
n--;
abs_x <<= 32 - n;
if ((abs_x & 0x01ff) > 0x0100)
flag = 1;
else if ((abs_x & 0x03ff) == 0x0300)
flag = 1;
else
flag = 0;
return sign + ((n << 23) + 0x3F800000) + (abs_x >> 9) + flag;
}
13. 浮點數轉整數,返回整數的二進位制位表示, 可用符號不受限制
思路:有上面的 float_i2f()
做鋪墊,
- 集中在對精度的處理, 對於 exp
- 大於 31,超過整形的表達範圍
- 小於 23,值不發生改變,右移 23 - exp
- 大於 23 小於等於 31,值發生改變 左移 exp -23
- 由於浮點數的正負只由符號位影響,所以可以最後做取負操作。
/*
* float_f2i - 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 float_f2i(unsigned uf) {
unsigned sign = uf & 0x80000000;
unsigned exp = uf & 0x7F800000;
unsigned frac = uf & 0x007FFFFF;
if (uf == 0x7F800000)
return 0x80000000;
else if (uf == 0)
return 0;
if (exp == 0)
return 0;
int m = 0x00800000 + frac;
int e = (exp >> 23) - 127;
if (e < 0)
return 0;
else if (e > 31)
return 0x80000000;
else if (e < 23)
m >>= (23 - e);
else
m <<= (e - 23);
if (sign)
m = -m;
return sign | m;
}