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)>>1使用(!!y)如果y为0，则返回0，说明前1位都为0，shift1=0，否则!!y=1，shift2=2，使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<<i))!=0)

          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;

}