1、bitXor
异或：不是同时为0和不是同时为1的情况进行按位与
/*
* 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、tmin
int最小值就是符号位为1，其他为0
/*
* tmin - return minimum two's complement integer
* Legal ops: ! ~ & ^ | + << >>
* Max ops: 4
* Rating: 1
*/
int tmin(void)
{
return 0x01 << 31;
}3、isTmax
我们考虑四位的最大值x=0111 然后x+1之后就会变成1000，我们对1000取非0111就会重新变回x值，已知自己与自己异或会得到0，也就是说我们可以用异或来判断等于!((~(x+1)^x)) 是否为1即可判断是否为最大值。这里有一个例外就是x=-1，由于-1=1111 他利用上面的式子判断也符合，故要特判-1，利用!!(x+1) 这个操作-1和最大值并不相同
/*
* isTmax - returns 1 if x is the maximum, two's complement number,
* and 0 otherwise
* Legal ops: ! ~ & ^ | +
* Max ops: 10
* Rating: 1
*/
int isTmax(int x)
{
return !(~(x + 1) ^ x) & !!(x + 1);
}4、allOddBits
A=1010， A是一个典型的奇数位都是1的数(起始位为第0位)，那只要一个四位的二进制数X & A = A就说明这个二进制符合条件，即只要判断x & 0xAAAAAAAA == 0xAAAAAAAA 就可以了。
由于不能直接定义0xAAAAAAAA ，我们需要一些位运算的小技巧
/*
* 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
*/
int allOddBits(int x)
{
int mask = 0xAA; // 0xAA
mask = (mask << 8) + mask; // 0xAAAA
mask = (mask << 16) + mask; // 0xAAAAAAAA
return !((x & mask) ^ mask);
}5、negate
A + ~A = -1 和 A + (-A) =0 利用这两个式子我们可以得到 (-A) = ~A + 1
int值机器数为补码，补码取负为: 所有位取反然后加1即可
/*
* negate - return -x
* Example: negate(1) = -1.
* Legal ops: ! ~ & ^ | + << >>
* Max ops: 5
* Rating: 2
*/
int negate(int x)
{
return ~x + 1;
}6、isAsciiDigit
我们可以看到“十”位必须是3， 并且只需要“个”位小于A即可，这里的小于运算 ，用了 a < b = a + (-b) < 0的性质，x & 0xF保存了x的后四位, 加上(-A)是否为负数来判断后四位的范围，判断负数是与0x1 << 31进行按位与运算，如果结果最高位为1则为负数
/*
* 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 ah = !(x >> 4 ^ 0x3);
int al = x & 0xF;
int minus_a = ~0xA + 1;
int flag = 0x1 << 31;
return ah & !!((al + minus_a) & flag);
}7、conditional
当x非0, 则!x为0, !!x为1, 令x = !!x，则此时~x+1为全1
若x为0, 则!!x为0, ~x+1还是为0
/*
* conditional - same as x ? y : z
* Example: conditional(2,4,5) = 4
* Legal ops: ! ~ & ^ | + << >>
* Max ops: 16
* Rating: 3
*/
// x > 0 return y else return z
int conditional(int x, int y, int z)
{
x = !!(x);
x = ~x + 1;
return (x & y) | ((~x) & z);
}8、isLessOrEqual
注意：直接用x-y可能会爆int故不能通过这样简单的判断, 故进行分类讨论
- case 1代表x < 0, y > 0，
- case 2代表x > 0, y < 0。
- 在x y同号时(同大于0或同小于0时)，我们可以放心的进行x-y操作，这样确保不会因为溢出而导致结果的符号错误，因此这两种情况可以合并为一种情况, 即case 3。
显然case 1是符合条件的，case 2不符合条件但它却是统一讨论情况3的障碍，所以最终在返回条件中一定要有!case 2来将情况2排除掉，再与两种同号条件相与。
/*
* isLessOrEqual - if x <= y then return 1, else return 0
* Example: isLessOrEqual(4,5) = 1.
* Legal ops: ! ~ & ^ | + << >>
* Max ops: 24
* Rating: 3
*/
// 若x<=y则返回1, 否则返回0
int isLessOrEqual(int x, int y)
{
int sign_x = (x >> 31) & 0x1;
int sign_y = (y >> 31) & 0x1;
// case 1: x为-，y为+
int case_1 = sign_x & (!sign_y);
// case 2: x为+，y为-
int case_2 = (!sign_x) & sign_y;
// case 3: x与y同号
int minus_y = (~y) + 1; // -y
int sum = x + minus_y; // x + (-y) = x - y
// 判断sum是否 <= 0
// 判断 = 0，若sum == 0, eq一定为1
int eq = !sum;
// 判断 < 0，若sum < 0，less一定为1
int less = (sum >> 31) & 0x1;
return case_1 | (!case_2 & (eq | less));
}9、logicalNeg
非零数x，-x | x一定可以保证符号位为1。而对于0，这样的结论是不成立的，这就找到了能够完全区分0值和非0值的一个清晰的边界。
/*
* 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 res = ((x | (~x + 1)) >> 31); // //除了0以外，其他的数都可以让res取到全1
return res + 1; // res=0xffffffff, 因为int右移符号扩展 x|（～x+1）在x非0情况下必定是负数
}10、howManyBits
为了便于处理，将负数转换成对应的反码，再求解最高位1所在的位置
正数的话直接求解最高位1所在的位置即可。最终结果为，最高位1所在的位置 + 1(符号位)，比如，0111 -> 3 + 1(符号位)
注：这里最高位所在的位置表示该位置是第几位(从1开始计算), 第一位、第二位、......
求解最高位1所在位置使用二分法：
如果x的高16位不为0，将x右移16位，然后用b16记录一下最高位1后面至少有16个数，
x右移16位之后，再接着二分，右移8位，
如果x的高8位不为0，将x右移8位，然后用b8记录一下最高位1后面至少有8个数
以此类推，最后将最高位1后面的数(包括自己)都加起来，即b16 + b8 + b4 + b2 + b1 + b0，再加一个符号位，即为最终答案b16 + b8 + b4 + b2 + b1 + b0 + 1
/* 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 b16, b8, b4, b2, b1, b0;
int sign = x >> 31;
x = (sign & ~x) | (~sign & x);
b16 = !!(x >> 16) << 4; // 10000, 16
x = x >> b16;
b8 = !!(x >> 8) << 3; // 1000, 8
x = x >> b8;
b4 = !!(x >> 4) << 2; // 100, 4
x = x >> b4;
b2 = !!(x >> 2) << 1; // 10, 2
x = x >> b2;
b1 = !!(x >> 1); // 1, 1
x = x >> b1;
b0 = x;
return b16 + b8 + b4 + b2 + b1 + b0 + 1;
}浮点数部分最重要的是理解下面这张图（太重要了！！！，不然根本没思路解题）
11、floatScale2
// float
/*
* 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
*/
unsigned floatScale2(unsigned uf)
{
unsigned s = (uf >> 31) & (0x1);
unsigned exp = (uf >> 23) & (0xff);
unsigned frac = (uf & 0x7fffff);
// 0
if (exp == 0 && frac == 0)
return uf;
// 无穷大/NAN
if (exp == 0xff)
return uf;
// 非规格化
if (exp == 0)
{
// E = exp - 127 = -127
// frac
frac <<= 1; // *2
return (s << 31) | frac;
}
// 规格化
exp++; // E = exp - 127
return (s << 31) | (exp << 23) | (frac);
}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 uf)
{
unsigned s = (uf >> 31) & (0x1);
unsigned exp = (uf >> 23) & (0xff);
unsigned frac = (uf & 0x7fffff);
// 0
if (exp == 0 && frac == 0)
return 0;
// 无限大/NAN
if (exp == 0xff)
return 0x80000000u;
// 非规格化
if (exp == 0)
{
// M 0.1111... < 1
// E = 1 - 127 = -126
return 0;
}
// 规格化
// M 1.xXXXX
int E = exp - 127;
frac = frac | (1 << 23);
if (E > 31) // 爆int
return 0x80000000u;
else if (E < 0)
{
return 0;
}
// M * 2^E
if (E > 23)
{
frac <<= (E - 23);
}
else
{
frac >>= (23 - E);
}
if (s)
return ~frac + 1;
return frac;
}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
*/
/*
非规格化浮点数的范围：2^-149 - 2^-126
规格化浮点数的范围： 2^-126 - 2^127
*/
unsigned floatPower2(int x)
{
if (x < -149)
return 0;
else if (x < -126)
{
// E = x
// E = 1 - 127 = -126
int shift = 23 + (x + 126);
return 1 << shift;
}
else if (x <= 127)
{
// x = exp - bias
int exp = x + 127;
return exp << 23;
}
else
{
return (0xff) << 23;
}
}测试结果
写在最后：笔者仰慕CSAAPLab已久，今日终于可以动手做做了，不得不说，Lab的质量确实高，做完本次实验，感觉自己对计算机中信息位的表示与处理的理解更深了一步，由于写博客的时间比较仓促，博客中出现的问题还请各位大神在评论区批评指正，谢谢大家！
