CSAPP lab1——位运算
本次为一次计算机系统实验，就是使用一些基本的运算符来实现函数功能。
ps做这些题让我想起大一上学期刚学二进制时被鹏哥支配的痛苦。
知识准备：
1.负数等于正数取反加一。
2.左移一位相当于将这个数扩大两倍，右移两位相当于将这个数缩小两倍
3.符号位向右移动后,正数补0,负数补1。
4.负数补码最高位是1，正数补码最高位是0
5. 32位正数取值为
最大：01111111 11111111 11111111 11111111
最小：10000000 00000000 00000000 00000000
min:-2147483648 max:2147483647
1.
/*
* bitXor - 仅允许使用~和&来实现异或
* 例子: bitXor(4, 5) = 1
* 允许的操作符: ~ &
* 最多操作符数目: 14
* 分值: 1
*/
解题思路：简单的异或，a⊕b = (¬a ∧ b) ∨ (a ∧¬b)但要求使用&，所以需要德摩根律
int bitXor(int x,int y)
{
return ~(~(~x&y)&~(x&~y));
}
但这样还不是最简单的，如果使用同或的非来表示异或，a⊕b = ¬（(a ∧ b) ∨ (¬a ∧¬b)）还能再少用一个字符。
int bitXor(int x, int y)
{
return ~(x&y)&~(~x&~y);//同或的非
}
2.
/*
* tmin - 返回最小的二进制补码
* 允许的操作符: ! ~ & ^ | + << >>
* 最多操作符数目: 4
* 分值: 1
*/
解题思路：最小值为0x8000 0000，我们可以将1左移31位得到最小值。
int tmin(void)
{
return 1<<31;
}
3.
/*
* isTmax - 如果x是最大的二进制补码，返回1；否则，返回0
* 允许的操作符: ! ~ & ^ | +
* 最多操作符数目: 10
* 分值: 2
*/
解题思路：最大的二进制补码为0x7FFFFFFF，为判断输入是否为这一个数，我们只需要将其与最小的二进制补码与或一下判断是否为0即可。
int isTmax(int x)
{
return !(x^~(1<<31));
}
4.
/*
* negate - 返回-x
* 例子: negate(1) = -1.
* 允许的操作符: ! ~ & ^ | + << >>
* 最多操作符数目: 5
* 分值: 2
*/
解题思路：正数取反加一即为负数。
int negate(int x)
{
return (~x+1);
}
5.
/*
* allOddBits - 如果所有奇数位都为1则返回1;否则返回0
* 例子： allOddBits(0xFFFFFFFD) = 0, allOddBits(0xAAAAAAAA) = 1
* 允许的操作符: ! ~ & ^ | + << >>
* 最多操作符数目: 12
* 分值: 2
*/
解题思路：：只有所有奇数位为1的数，与0x5555 5555进行&运算才会得到0。5->(0101)。故而需要得到0x5555 5555，将0x55（01010101）分别左移8、16、24得到3个数，然后将这三个数相加即可得到0x5555 5555。
int allOddBits(int x)
{
return !(~(x|(85+(85<<8)+(85<<16)+(85<<24))));
}
6.
/*
* isAsciiDigit - 如果x是ascii码中的0~9，返回1;否则返回0
* 例子: isAsciiDigit(0x35) = 1.
* isAsciiDigit(0x3a) = 0.
* isAsciiDigit(0x05) = 0.
* 允许的操作符: ! ~ & ^ | + << >>
* 最多操作符数目: 15
* 分值: 3
/*
解题思路：若x是数字，则x在‘0’~‘9’之间。可以用x-48>=0和x-58<0（x+~48+1>=0和x+~58+1<0）来计算。
int isAsciiDigit(int x)
{
return !((x+~48+1)>>31)&!!((x+~58+1)>>31);
}
7.
/*
* isLessOrEqual - 如果x<=y返回1否则返回0
* 例子: isLessOrEqual(4,5) = 1.
* 允许的操作符: ! ~ & ^ | + << >>
* 最多操作符数目: 24
* 分值: 3
*/
解题思路：
直接用y-x可能会超出int的表示范围，故而：当x与y同号时，转换为p=y-x>=0，然后p符号位(p>>31）&1为0则返回1，符号位1则返回0；异号时，只要x>=0，就要返回0，否则返回1，由(x>>31)&1能达到该效果。c=a（x>>31）+b(y>>31)可作为x,y同号异号的判断,异号的时候为1和0，相加为1；同号的时候为1和1或者0和0，相加得0或2，取反之后必为非0。
int isLessOrEqual(int x, int y)
{
int a=x>>31;
int b=y>>31;
int c=a+b;
int p=y+(~x+1);///p=y-x
int q=!((p>>31)&1);///若p>=0，则q为1,成立；反之，q为0，不成立。
return (c&(a&1))|((~c)&q);///若为异号，c为1，若a为1，说明x<=y，成立；反之说明x>y不成立。
///若为同号，c为0或者2，取反后为非0，若q为1,相与后必为非0。
}
8.
/*
* conditional - 实现x?y:z
* 例子: conditional(2,4,5) = 4
* 允许的操作符: ! ~ & ^ | + << >>
* 最多操作符数目: 16
* 分值: 3
*/
解题思路：当x不为0时，!x=0，函数结果为y。这时候需要(0xffff ffff)&y|(0x0)，来保存y。 当x为0时，!x=1，函数结果为z。这时候需要（0x0)|(0xffff ffff)&z,来保存z。
int conditional(int x, int y, int z)
{
return ((!x+~1+1)&y)|((~!x+1)&z);
}
9.
/*
* absVal - absolute value of x
* Example: absVal(-1) = 1.
* You may assume -TMax <= x <= TMax
* Legal ops: ! ~ & ^ | + << >>
* Max ops: 10
* Rating: 4
*/
解题思路：对整数取绝对值，我们知道int类型的实数，正负数的区别在于最高位是0还是1，正数最高位是0，负数最高位是1。正数右移31位后为0，负数右移31位后为-1（负数右移高位补1）。而负数要变为正数，我们知道需要-1再取反。那么我们就可以利用这两个性质来做题了。
/*
正数右移31位后为0，负数右移31位后为-1（负数右移高位补1）
异或1取反
异或0不变
负数要变为正数需要+1之后取反
*/
int absVal(int x)
{
int t = (x>>31);
return (x+t)^t;
/*正数右移31位后为0，负数右移31位后为-1（负数右移高位补1）*/
}
10.
/*
* bitCount - returns count of number of 1's in word
* Examples: bitCount(5) = 2, bitCount(7) = 3
* Legal ops: ! ~ & ^ | + << >>
* Max ops: 40
* Rating: 4
*/
解题思路：这题应该是这次作业里最难的题了，只用40次操作，并且不能用循环和if，计算x二进制表示中1的个数。首先需要设计5个常数，分别为0x55555555，0x33333333，0x0f0f0f0f，0x00ff00ff，0x0000ffff。
为什么这么设计呢，可以把5个数字的二进制写出来，分别是间隔1个0,2个0,4个0,8个0,16个0
然后下面的计算方法，和间隔对应，分别右移1,2,4,8,16次。如何理解呢，如果只给你一个只有2位的二进制数x，以及01，怎么计算里面1的个数呢，是不是做(x&1)+((x>>1)&1)呢？通过移位，把高位的1，移到低位求和。32位的数字就可以看成是16个2位的，之后就可以等价看作，一个16位的数字，分成8段，做上面第二个计算操作。总的来看这个操作就是把高位的1往低位移动，然后类似分治，分成多段的移动。非常nice的一个题哦。关于这道题的一些理解，32位数字看成16个2位的，两个相邻位置作为一组进行一次计算统计1的个数，然后进行合并;再之后四个相邻位置作为一组进行一次计算统计1的个数；之后八个，十六个，三十二个作为一组。
int bitCount(int x)
{
int mask1 = 0x55;
int mask2 = 0x33;
int mask3 = 0x0f;
int mask4 = 0xff;
int mask5 = 0xff;
mask1 += mask1<<8;
mask1 += mask1<<16;//generate 0x55555555
mask2 += mask2<<8;
mask2 += mask2<<16;//generate 0x33333333
mask3 += mask3<<8;
mask3 += mask3<<16;//generate 0x0f0f0f0f
mask4 += mask4<<16;//generate 0x00ff00ff
mask5 += mask5<<8; //generate 0x0000ffff
x =((x>>1)&mask1) + (x&mask1);
x =((x>>2)&mask2) + (x&mask2);
x =((x>>4)&mask3) + (x&mask3);
x =((x>>8)&mask4) + (x&mask4);
x =((x>>16)&mask5) + (x&mask5);
return x;
}
11.
/*
* byteSwap - swaps the nth byte and the mth byte
* Examples: byteSwap(0x12345678, 1, 3) = 0x56341278
* byteSwap(0xDEADBEEF, 0, 2) = 0xDEEFBEAD
* You may assume that 0 <= n <= 3, 0 <= m <= 3
* Legal ops: ! ~ & ^ | + << >>
* Max ops: 25
* Rating: 2
*/
解题思路：需要我们将字节交换，主要这里交换的是字节而不是位！我们知道int型有4个字节，每个字节有8位，这里我们就以8位为一组组成字节进行整体交换。思路很简单，我们先将需要交换的字节转移到交换后的位置，在这个过程中不可避免的会夹带着其他的字节的变化，先不去管，再获得一个排除需要交换字节的原数（需要交换的字节的位置全是0），最后三者一与便得到交换后的数了。
int byteSwap(int x, int n, int m)
{
int a = n<<3;
int b = m<<3;//乘以8,因为8位一个字节，投射到该字节对应的位上
int step1 = ((x>>a)&0xff)<<b;
int step2 = ((x>>b)&0xff)<<a;
// int step3 = x&~(0xff<<b)&~(0xff<<a);
int step3 = x&(~((0xff<<a)|(0xff<<b)));
return (step1|step2|step3);//将需要交换的字节扣除来，错位交换
}
/* * oddBits - return word with all odd-numbered bits set to 1 * Legal ops: ! ~ & ^ | + << >> * Max ops: 8 * Rating: 2 */
解题思路：得到int型32位上一个奇数位全是1的数，那么就是0xaaaaaaaa(1010)，那么最简单的方法就是通过0x55构造就可以了。注意这里的第0位安排不是奇数位，安排到了偶数位上了。
int oddBits(void) { int a=0xaa;//1010 1010 a=a|(a<<8); a=a|(a<<16); return a; // return 0xaaaaaaaa;? }
12.
/*
* isLess - if x < y then return 1, else return 0
* Example: isLess(4,5) = 1.
* Legal ops: ! ~ & ^ | + << >>
* Max ops: 24
* Rating: 3
*/
解题思路：一开始的思路就是用x-y看看得到的最高位是1还是0，是1则是负数说明x<y，是0则是正数说明x>y，而且得到的最高位恰好是返回值。但是有这么一个问题，可能会出现溢出啊，int类型存不下！我在这里停了好久，也试着用long long 来存数，但是只能使用int类型来进行运算，不能使用其他类型的数，不能进行强制类型的转化。
其实我们可以把那些会造成溢出的数给分离出来，我们知道正数减负数和负数减正数才可能会造成溢出，也就是说只有x和y异号的时候才可能出现溢出。而如果没有溢出的可能，则x-y的最高位便必然是所求的结果。那么就来模拟一个if判断便可以了。这里将flag=x^y作为判断项，如果flag=1说明可能会溢出，那么如果是负数-正数返回1，如果是正数-负数返回0：如果flag=0则不会产生溢出了，就用x-y来判断。
/* 可能会造成溢出的情况：
负数-正数 1
正数-负数 0
（异号）
一定不会造成溢出：
正数-正数
负数-负数
（同号）
x-y
*/
int isLess(int x, int y)
{
int t = x+~y+1;///x-y
int flag = x^y;
return (((flag&x)|(t&~flag))>>31)&1;
}
13.
/*
* satAdd - adds two numbers but when positive overflow occurs, returns
* maximum possible value, and when negative overflow occurs,
* it returns minimum positive value.
* Examples: satAdd(0x40000000,0x40000000) = 0x7fffffff
* satAdd(0x80000000,0xffffffff) = 0x80000000
* Legal ops: ! ~ & ^ | + << >>
* Max ops: 30
* Rating: 4
*/
解题思路：题意要求如果两个数相加，如果产生了正溢出返回0x7fffffff，出现负溢出返回0x80000000，其他情况返回两数之和。
这里我的思路很简单就是使用位运算来模拟一下if判断，有点数据选择器的意思？开始就先构造0x80000000和0x7fffffff这两数数恰好构造出一个另一个取反就可以了。产生溢出只有两种情况正数加正数溢出产生负数，负数加负数溢出产生正数，所以根据这一特点就可以判断是否产生溢出，在根据两数相加得到的数的正负就可以继续判断正溢出和负溢出了。
/*
产生溢出：
1.正数+正数=负数 正溢出 0x7fffffff
2.负数+负数=正数 负溢出 0x80000000
不溢出：
x+y
*/
int satAdd(int x, int y) { int ans = x+y; int over = (x^ans)&(y^ans); int min_ans = 1<<31;///0x80000000 int max_ans = ~(min_ans);//0x7fffffff int neg_over = ((over&x)>>31)&1; int pos_over = ((over&~x)>>31)&1; return ((~pos_over+1)&max_ans)+((~neg_over+1)&min_ans)+((~(!(neg_over|pos_over))+1)&ans); }
14.
/* * 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 */
先插入一个怎么把十进制小数转换成二进制的小数的方法---->
解题思路：将一个浮点数扩大两倍。首先如果参数是非数NaN就返回参数本身，那么就先将这一种情况排除掉。对于大多数浮点数阶码不为0，那么阶码加1便可以加倍。对于那些阶码为0的，若是尾数不为0，尾数左移1位便可以实现加倍了；若也尾数为0，那么这个数就是0了，返回原来的0即可。
开始我在这里有一个疑惑，尾数左移一位要是进入了阶码的范围，还对吗？其实这也是正确的，因为若是尾数能够进位，那么阶码加1，整个浮点数值确实是加倍了。
同时这里还要说明一下，尾数是用23位数来表示24位尾数，基数是2，需要规格化尾数形式为+-0.1bb...b，其中第一位“1”不明显表示出来。
举个例子：
-5.625 = C 0 B 4 0 0 0 0
C 0 B 4 0 0 0 0 1100 0000 1011 0100 0000 0000 0000 0000 按照浮点数格式切割成相应的域 1 1000 0001 01101 000000000000000000 经分析：符号域1 意味着负数；指数域为129 意味着实际的指数为2 （减去偏差值127）； 尾数域为01101 意味着实际的二进制尾数为1.01101 （加上隐含的小数点前面的1）。
所以，实际的实数为：
= -1.01101 × 2^2
=- ( 1*2^0 + 1*2^(-2) + 1*2^(-3) + 1*2^(-5) ) × 2^2
= -(1+0.25+0.125+0.03125)*4
= -1.40625*4
= -5.625
unsigned float_twice(unsigned uf) { unsigned S = uf&0x80000000;///获得第0位的符号位 unsigned Exp = uf&0x7f800000;///获得第1~8位的阶码 unsigned M = uf&0x007fffff;///获得第9~31的尾数 unsigned T = uf&0x7fffffff; unsigned ans = uf; if(T >= 0x7f800000)///如果是NaN的情况 { return uf; } if(Exp!=0)///阶码不为0,那想要翻倍就只需要阶码加1即可。 { ans = uf + 0x00800000; // return S+Exp+0x00800000+M; } else///阶码为0，那就得通过变换尾数来加倍 { if(M!=0)///尾数左移一位加倍 { ans = (uf<<1) + S; // return S+E +(M<<1); } } return ans; }
/*
float中
第0位为符号位
第1~8位为阶码
第9~31位为24位二进制原码小数表示的尾数
举个例子：
（65878）10进制
= （1 0000 0001 0000 0110）2进制
= （0.1000 0000 1000 0011 0）2进制*2^17
符号S =0
阶码E =（128+17）10进制
= (145)10进制
= （1001 0001)二进制
所以浮点型表示为
0 1001 0001 000 0000 1000 0011 0000 0000
*/
