datalab 数据表示实验
一直都想每天写博客，然后又经常拖，还有这个是作业，用的时间比较久，然后自己又是脑子不灵活的那种，所以写出来的东西可能会有很多错误，欢迎大家指出来交流交流，互相进步。下次实验室bomb，拆炸弹，不知道能不能坚持把它做完，加油~
1、根据bits.c中的要求补全以下的函数：
int bitXor(int x, int y);
int tmin(void);
int isTmax(int x);
nt allOddBits(int x);
int negate(int x);
int isAsciiDigit(int x);
int conditional(int x, int y, int z);
int isLessOrEqual(int x, int y);
int logicalNeg(int x);
int howManyBits(int x);
unsigned float_twice(unsigned uf);
unsigned float_i2f(int x);
int float_f2i(unsigned uf);
2、在Linux下测试以上函数是否正确，指令如下：
*编译：./dlc bits.c
*测试：make btest
./btest
四、实验结果
1. bitXor。思路：根据离散数学的真值表即可得出结果：
/*
* bitXor - x^y using only ~ and &
* Example: bitXor(4, 5) = 1
* Legal ops: ~ &
* Maxops: 14
* Rating: 1
*/
intbitXor(int x, int y) {
return ~(~(~x&y)&~(x&~y));
}
2. tmin。思路：最小值为0x8000 0000，由1左移31即可得到：
/* tmin - return minimum two's complementinteger
* Legal ops: ! ~ & ^ | + << >>
* Maxops: 4
* Rating: 1
*/
inttmin(void) {
return 1<<31;
}
3. isTmax。思路：最大值为0x7fff ffff，加一会变为0x10000000，而此数加上本身后会变为0，本身加本身为0的数只有0和0x1000 0000，故而再将0xffffffff排除即可：
/*
* isTmax - returns 1 if x is the maximum,two's complement number,
* and 0 otherwise
* Legal ops: ! ~ & ^ | +
* Maxops: 10
* Rating: 2
*/
intisTmax(int x) {
return (!(x+1+x+1))&(!!(x+1));
}
4. allOddBits。思路：只有所有奇数位为1的数（二进制），与0x5555 5555进行&预算才会得到0，故而需要得到0x5555 5555即可，将0x5分别左移4、8、16、24得到4个数，然后将这四个数和0x5相加即可得到0x5555 5555：
/*
* 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) {
unsigned inta=85;
unsigned intb=a+(a<<8)+(a<<16)+(a<<24);
return !~(b|x);
}
5. isAsciiDigit。思路：x需要>=’0’且<=’9’，将x与临界点作差，然后判断符号位的为0还是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) {
return(!((x+~48+1)>>31))&!!((x+~58+1)>>31);
}
6. conditional。思路：首先使用t=!x，当x为0时返回1，当x不为0时，返回0，根据题意得到( _ &y)|( _ &z)，首先空1，当x不为0，即t=0时，需要t转换为0xffffffff（-1），当t=1时，需要将t转换为0x0（0），，将t-1即可，得到空1为“!x+~1+1”，同理空2为“~!x+1”：
/*
* 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) {
return ((!x+~1+1)&y)|((~!x+1)&z);
}
7. isLessOrEqual。思路：直接用y-x可能会超出int的表示范围，故而：
A、在x与y同号的情况下转换为p=y-x>=0，然后p符号位(p>>31）&1为0则返回1，符号位1则返回0；
B、 异号时，只要x>=0，就要返回0，否则返回1，由(x>>31)&1能达到该效果；
C、 c=a+b可作为x,y同号异号的判断。
/*
* isLessOrEqual -if x <= y then return 1, else return0
* Example: isLessOrEqual(4,5) = 1.
* Legal ops: ! ~ & ^ | + << >>
* Max ops: 24
* Rating: 3
*/
int isLessOrEqual(int x, int y) {
inta=x>>31;
intb=y>>31;
int c=a+b;
int p=y+(~x+1);
intq=!((p>>31)&1);
intr=(c&(a&1))|((~c)&q);
return r;
}
8. logicalNeg。思路：令y=~x+1，考虑x与y的符号位：
A. 当x为0时，两者符号位都为0；
B. 当x=0x8000 0000时，两者符号位都为1；
C. 否则，两者符号位为01或10；
D. 根据离散数学的真值表得出(~x)&(~y).
/*
* 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+1)&~x)>>31)&1;
}
9. howManyBits。思路：二分法，举例x=0000 1000 1001 0000 0000 0000 0000 0000说明：
A. 令y=x>>16=0000 1000 1001 0000，shift16=(!!y)<<4使用(!!y)如果y为0，则返回0，说明前16位都为0，shift16=0，否则!!y=1，shift16=16，使x=x>>shift16=10001001 0000;
B. 同理，令y=x>>8=0000 1000，shift8=(!!y)<<3使用(!!y)如果y为0，则返回0，说明前8位都为0，shift8=0，否则!!y=1，shift8=8，使x=x>>shift8=00001000;
C. 令y=x>>4=0000，shift4=(!!y)<<2使用(!!y)如果y为0，则返回0，说明前4位都为0，shift4=0，否则!!y=1，shift4=4，使x=x>>shift4=00001000;
D. 令y=x>>2=0000 10，shift2=(!!y)<<1使用(!!y)，如果y为0，则返回0，说明前2位（原始的x[27]x[26]）都为0，shift2=0，否则!!y=1，shift2=2，使x=x>>shift2=000010;
E. 令y=x>>1=0000 1，shift1=(!!y),使用(!!y)如果y为0，则返回0，说明前1位都为0，shift1=0，否则!!y=1，shift1=1，使x=x>>shift1=00001;
F. 然后令sum=2+ shift16+shift8+shift4+shift2+shift1即可；
G. 对于负数取反码即可，对于-1和0特殊考虑。
/* howManyBits - return the minimum number of bitsrequired 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) {
intshift1,shift2,shift4,shift8,shift16;
int sum;
intt=((!x)<<31)>>31;//x为0时，t（二进制）全为1，x不为0时，全为1
intt2=((!~x)<<31)>>31;//当x为-1时，t2全为1，否则，全为0
//printf("x=%x\n",x);
intop=x^((x>>31));//正数不变，负数取反
//printf("op=%x\n!!(op>>16)=%x\n",op,!!(op>>16));
shift16=(!!(op>>16))<<4;//如果高十六位全为0，则0左移4位，不全为0，则1左移4（表示op要右移2^4位）位
op=op>>shift16;
shift8=(!!(op>>8))<<3;
op=op>>shift8;
shift4=(!!(op>>4))<<2;
op=op>>shift4;
shift2=(!!(op>>2))<<1;
op=op>>shift2;
shift1=(!!(op>>1));
op=op>>shift1;
//printf("shift16=%x shift8=%x shift4=%x shift2=%xshift1=%x\n",shift16,shift8,shift4,shift2,shift1);
sum=2+shift16+shift8+shift4+shift2+shift1;
//printf("t=%x sum=%x\n",t,sum);
return(t2&1)|((~t2)&((t&1)|((~t)&sum)));
}
10. float_twice。思路：分三种情况考虑
A. 当exp=0xff时，直接返回本身；
B. 当exp=0时，分两种情况考虑：
a) 当uf[22]=0时，直接即可frac<<1；
b) 当uf[22]=1时，exp++，然后frac<<1;
C．否则，exp++，然后分两种情况：
a) 当exp==0xff，令frac=0即可。
b) 否则不做处理。
/*
* float_twice -Return bit-level equivalent of expression 2*f for
* floating point argument f.
* Both the argument and result are passed asunsigned int's, but
* they are to be interpreted as the bit-levelrepresentation of
* single-precision floating point values.
* When argument is NaN, return argument
* Legal ops: Any integer/unsigned operationsincl. ||, &&. also if, while
* Max ops: 30
* Rating: 4
*/
unsigned float_twice(unsigned uf) {
//scanf("%x",&uf);
unsigned intexp=0x7f800000&uf;
unsigned intfrac=0x007fffff&uf;
unsigned ints=0x80000000&uf;
if(((~exp)&0x7f800000)==0){//exp=11111111
//printf("%x\n",uf&0xff800000);
return uf;
}else{
if(exp==0){
if((0x00400000&uf)==0){
frac=frac<<1;
}else{
exp=0x00800000;
frac=frac<<1;
}
}else{
exp=exp+0x00800000;
if(((~exp)&0x7f800000)==0)
frac=0;
}
//unsigned intx=(exp|frac|s);
//printf("%x\n%x\n%x\n%x\n",s,exp,frac,x);
return(exp|frac|s);
}
}
11. float_i2f。思路：首先我们需要知道int型的范围为-2^31~2^31-1主要有两种情况：
A. 用（二进制）科学计数法表示int型数时，尾数位数<=23，例如0x00008001，此时将0x8001左移24-16=8位得到frac，而exp则127+16-1；
B. 当尾数位数>23时，找到位数最末一位记作x[i]，然后对尾数的舍去分3种情况考虑，初始化c=0：
a) 当x[i-1]=1且x[i-2]、x[i-3]…x[0]都为0（即要偶端舍入情况），且x[i]=1,令c=1（此处frac若是全为1，则会导致frac+c超出范围，这是bug,当还是通过了）；
b) 当x[i-1]=1且x[i-2]、x[i-3]…x[0]不都为0，令c=1（与a存在同样的bug）;
c) 除a、b的情况，c=0；
C. 其他特殊情况再考虑一下就好了；
/*
* 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-levelrepresentation of a
* single-precision floating point values.
* Legal ops: Any integer/unsigned operationsincl. ||, &&. also if, while
* Max ops: 30
* Rating: 4
*/
unsigned float_i2f(int x) {
unsigned abs=x;
unsigneds=0x80000000&x;
unsignedtem=0x40000000;
unsignedexp_sign=0;
unsigned exp=0;
unsigned frac;
unsigned c=0;
if(x==0)
return x;
elseif(x==0x80000000)
return(s+(158<<23));
else{
if(x<0)
abs=-x;
while(1){
if(tem&abs)
break;
tem=tem>>1;
//printf("%x\n%x\n",tem,abs);
exp_sign=exp_sign+1;
}
// printf("exp_sign=%d\nx=%x\n",exp_sign,x);
frac=(tem-1)&abs;
//printf("frac=%x\n",frac);
if(31-1-exp_sign>23){//wei shu da yu 23wei de qingkuang
inti=30-exp_sign-23;
if((frac<<(31-(i-1)))==0x80000000){//ouduan quzhi
if((frac&(1<
c=1;
}
elseif((frac&(1<<(i-1)))!=0)//dayu yiban jia 1
c=1;
frac=frac>>i;
}
else
frac=frac<<(23-(31-exp_sign-1));
exp=157-exp_sign;
//printf("exp=%d\n s=%x\n",exp,s);
//printf("frac=%x\n",frac);
//printf("result=%x\n",(s+(exp<<23)+frac+c));
return (s+(exp<<23)+frac+c);
}
}
12. float_f2i。思路：exp为0，x=(-1)^s*0.frac*2^(-126)；否则x=(-1)^s*1.frac*2^(exp-127)分情况考虑：
A. 根据float转为int是向0舍入的情况，当exp=0或者exp<127(由exp-127<0得到)；
B. 令exp_sign=((exp>>23)-127)>=0，根据x=(-1)^s*1.frac*(exp-127)，
a) exp_sign=0,x=1.x[22]x[21]…x[0]-->x=1;
b) exp_sign=1,x=1x[22].x[21]…x[0]-->x=1x[22];
c) exp_sign=2,x=1x[22]x[21].x[20]…x[0]-->x=1x[22]x[21];
d) exp_sign=23,x=1x[22]x[21]x[20]…x[0]-->x=1x[22]x[21]…x[0]
e) exp_sign=30,x=1x[22]x[21]x[20]…x[0]-->x=1x[22]x[21]…x[0]0…0(共31位)
f) exp_sign=32,x=1x[22]x[21]x[20]…x[0]-->x=1x[22]x[21]…x[0]0…0(共32位)，此时，因为int为有符号，只有0x0000 00000能被表示出来，其他都是NAN;
C. 当exp_sign=((exp>>23)-127)>=33,NAN
/*
* 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-levelrepresentation of a
* single-precision floating point value.
* Anything out of range (including NaN andinfinity) should return
* 0x80000000u.
* Legal ops: Any integer/unsigned operationsincl. ||, &&. also if, while
* Max ops: 30
* Rating: 4
*/
int float_f2i(unsigned uf) {
intexp=0x7f800000&uf;
unsigneds=0x80000000&uf;
intfrac=0x007fffff&uf;
intfrac2=frac+0x008fffff;
int exp_sign=((exp>>23)-127);
//printf("uf=%x\n",uf);
if(exp==0x7f800000)
return0x80000000u;
else if(exp==0)
return 0;
elseif(exp_sign<=-1&&exp_sign>=-126)
return 0;
elseif(exp==31&&frac==0&&s!=0)
return0x80000000;
else if(exp_sign>=31)
return0x80000000u;
elseif(exp_sign<=23)
frac2=frac2>>(23-exp);
else
frac2=frac2<<(exp-23);
if(s==0)
return frac2;
else
return -frac2;
}