【计算机系统基础03】Lab1数据表示

实验要求

一、实验目的：

1更好地熟悉和掌握计算机中整数和浮点数的二进制编码表示。
2.实验中使用有限类型和数量的运算操作实现一组给定功能的函数,在此过程中加深对数据二进制编码表示的了解
3.熟悉linux基本操作命令，其中常用工具和程序开发环境
4.完善bits.c的各个函数，实现其功能，并通过.btest的测试

二、实验要求

1. 尽快熟悉linux基本操作命令，还有其中常用工具和程序开发环境
2. 除浮点数函数实现外，只能使用顺序程序结构，禁用if, do, while, for, switch等。
   有限操作类型，！ ~ & ^ | + << >> 各函数不一样
   禁用（！=、==、&&、|| 等组合操作符）
   常量值范围 0~255
   禁用强制类型转换
   禁用整型外的任何其它数据类型
   禁用定义和宏
   不得使用函数
   具体要求可参看bits.c各函数框架的注释
   可以使用循环和条件控制；
   可以使用整型和无符号整型常量及变量（取值不受[0,255]限制）；
   不使用任何浮点数据类型、操作及常量。
   可以使用int和unsigned两种整型数据
   禁用浮点数据类型、struct、union或数组结构。
   浮点数函数均使用unsigned型数据表示浮点数据。
   float_abs等函数必须能处理全范围的变量值，包括(NaN)和infinity。

实验内容

主要操作内容：位操作函数; 补码运算函数; 浮点数表示函数
例：

/*
功能:将整形x最后一位置零
*/
 int lsbZero(int x) {
    return x>>1<<1; //通过先向右移一位将最低位舍弃,再向左移动,最低位补零
} 

1、

/* 
 *   lsbZero - set 0 to the least significant bit of x 
 *   Example: lsbZero(0x87654321) = 0x87654320
 *   Legal ops: ! ~ & ^ | + << >>
 *   Max ops: 5
 *   Rating: 1
 */
int lsbZero(int x) {
    x = x >> 1;
    x = x << 1;
  return x;
}

功能：最后一位置0
解释：x右移一位原来的末位舍去，左移一位后末位添0
2、

/* 
 * byteNot - bit-inversion to byte n from word x  
 *   Bytes numbered from 0 (LSB) to 3 (MSB)
 *   Examples: getByteNot(0x12345678,1) = 0x1234A978
 *   Legal ops: ! ~ & ^ | + << >>
 *   Max ops: 6
 *   Rating: 2
 */
int byteNot(int x, int n) {
    int y = 0xff;
    n = n << 3;
    y = y << n;
    x = x ^ y;
  return x;
}

功能：把第n个字节的每位取反
解释：n左移三位确定需要移动的位数，y左移所得位数后与x对应位置异或，使相应位的数字取反。
3、

/* 
 *   byteXor - compare the nth byte of x and y, if it is same, return 0, if not, return 1

 *   example: byteXor(0x12345678, 0x87654321, 1) = 1

 *			  byteXor(0x12345678, 0x87344321, 2) = 0
 *   Legal ops: ! ~ & ^ | + << >>
 *   Max ops: 20
 *   Rating: 2 
 */
int byteXor(int x, int y, int n) {
    int a = ((x >> (n << 3))&0xff);
    int b = ((y >> (n << 3))&0xff);
    
  return !!(a ^ b);
}

功能：比较x和y的第n个字节是否相同，相同返回0，不同返回1
解释：取出对应字节内容后进行异或操作，通过！！得到0或1。
4、

/* 
 *   logicalAnd - x && y
 *   Legal ops: ! ~ & ^ | + << >>
 *   Max ops: 20
 *   Rating: 3 
 */
int logicalAnd(int x, int y) {
    return (!!x) & (!!y);
}

功能： 实现与运算
解释：通过！！把x和y对应变成0或1后进行&运算
5、

/* 
 *   logicalOr - x || y
 *   Legal ops: ! ~ & ^ | + << >>
 *   Max ops: 20
 *   Rating: 3 
 */
int logicalOr(int x, int y) {
    return (!!x) | (!!y);
}

功能：实现或运算
解释：通过！！把x和y对应变成0或1后进行|运算
6、

/* 
 * rotateLeft - Rotate x to the left by n
 *   Can assume that 0 <= n <= 31
 *   Examples: rotateLeft(0x87654321,4) = 0x76543218
 *   Legal ops: ~ & ^ | + << >> !
 *   Max ops: 25
 *   Rating: 3 
 */
int rotateLeft(int x, int n) {
    int qu = ~(~0 << n);//~0 >> (32 + (~n + 1)) is wrong for ~0 >> (32 + (~n +1) = 0x11111111 
    int right = x >> (32 + (~n + 1));
    int high = qu & right;                                                                                              
    int left = x << n; 
    return (high + left);
}

功能：把x的左边n位移到最后
解释：_{0得到32位1，左移n位右边添0，再}得到后n位为1，其他位为0；x右移(32-n）位后通过和取x的前n位；x左移n位即将前n位移出，然后再加上得到的前n位
7、

/*
 * parityCheck - returns 1 if x contains an odd number of 1's
 *   Examples: parityCheck(5) = 0, parityCheck(7) = 1
 *   Legal ops: ! ~ & ^ | + << >>
 *   Max ops: 20
 *   Rating: 4
 */
int parityCheck(int x) {
    x = (x << 16) ^ x;
    x = (x << 8) ^ x;
    x = (x << 4) ^ x;
    x = (x << 2) ^ x;
    x = (x << 1) ^ x;
    x = x >> 31;
    return (x & 0x1);//x & 0xf is wrong for 0xffffffff & 0xf = 0xf rather than 0x1
}                    // !!x is ok too

功能：如果x的二进制里有奇数个1，那么返回1，否则返回0
解释：一直对半异或，最后最高位为1则x里有奇数个1，然后右移再和0x1和取，得到1或0
8、

/*
 * mul2OK - Determine if can compute 2*x without overflow
 *   Examples: mul2OK(0x30000000) = 1
 *             mul2OK(0x40000000) = 0
 *         
 *   Legal ops: ~ & ^ | + << >>
 *   Max ops: 20
 *   Rating: 2
 */

int mul2OK(int x) {//compare 32 and 31,+ or -
    int a = x >> 31;
    int b = x >> 30;
    a = a & 0x1;//0001
    b = b & 0x1;//0000
    return (a ^ b) ^ 0x1;//! is illegal
}

功能：判断x*2之后是否会溢出
解释：乘2就是左移一位，判断最高位和次高位是否相同，也就是移完之后符号是否会改变，然后返回0或1

9、

/*
 * mult3div2 - multiplies by 3/2 rounding toward 0,
 *   Should exactly duplicate effect of C expression (x*3/2),
 *   including overflow behavior.
 *   Examples: mult3div2(11) = 16
 *             mult3div2(-9) = -13
 *             mult3div2(1073741824) = -536870912(overflow)
 *   Legal ops: ! ~ & ^ | + << >>
 *   Max ops: 12
 *   Rating: 2
 */
int mult3div2(int x) {
    int product = (x << 1) + x;//0x1 = 0001 << 1    0010= 0x2 + 0x1 = 3 
    int low = product & 0x1;
    int sign = (product >> 31) & 0x1;
    int quotient = product >> 1;
    quotient = quotient + (low & sign);//low is 1 so there is fraction,sign is 1 so -
  return quotient;
}

功能：x乘3/2之后朝0取整
解释：x先乘三，如果符号位和末位都是1，那就是负数除2后有小数部分，是朝小取整，需要加一，否则直接处二取整。此外左移一位再加x就是x*3.
10、

/* 
 * subOK - Determine if can compute x-y without overflow
 *   Example: subOK(0x80000000,0x80000000) = 1,
 *            subOK(0x80000000,0x70000000) = 0, //1000 - 0111
 *   Legal ops: ! ~ & ^ | + << >>
 *   Max ops: 20
 *   Rating: 3
 */
//1000, 0111,get 0111, negtive sub positive get positive,is wrong   
//0111, 1000,get 1111, positive sub negtive get negtive,is wrong//0111 + 0111 + 1,1111
int subOK(int x, int y) {
    int x_sign = (x >> 31) & 0x1;
    int y_sign = (y >> 31) & 0x1;
    int xandy = x_sign ^ y_sign;
    int sub_sign = (x + (~y + 1)) >> 31 & 0x1;
    int xandsub = x_sign ^ sub_sign;
  return !(xandy & xandsub);
}

功能：判断x-y后结果是否溢出
解释：如果x和y的符号位不同且x和相减结果的符号位也不同，那么返回0。
11、

/* 
 * absVal - absolute value of x
 *   Example: absVal(-1) = 1.
 *   You may assume -TMax <= x <= TMax
 *   Legal ops: ! ~ & ^ | + << >>
 *   Max ops: 10
 *   Rating: 4
 */
int absVal(int x) {
    int sign = x >> 31;//no (& 0x1)
    int fushu = sign & (~x + 1);
    int zhengshu = ~sign & x;
  return (fushu + zhengshu);
}

功能：求x的绝对值
解释：如果符号位为1，那就减1再取反，也可以取反再加1，如果符号位为0，那绝对值就是x本身。
12、

/* 
 * float_abs - Return bit-level equivalent of absolute value of 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 representations of
 *   single-precision floating point values.
 *   When argument is NaN, return argument..
 *   Legal ops: Any integer/unsigned operations incl. ||, &&. also if, while
 *   Max ops: 10
 *   Rating: 2
 */
unsigned float_abs(unsigned uf) {
    int x = uf &0x7fffffff;
    if(x > 0x7f800000)
        return uf;
    else 
        return x;
}

功能：返回f绝对值相等的位等级
解释：uf&0x7fffffff 最高位置0，如果结果大于0x7f800000，那么x的阶码全都为1，但是尾数不全为0，也就是x是NAN，返回uf。
13、

/* 
 * 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) {
    int jiema = (uf >> 23) & 0xff;
    int xiaoshu = (uf & 0x007fffff) ^ 0x00800000;
    unsigned over = 0x80000000u;
    if(jiema > 158)//127 + 31,the most int
        return over;
    else if(jiema < 127)
        return 0;
    else if(((uf >> 31) & 0x1) == 1){
        if(jiema > 150) 
            return(~(xiaoshu << (jiema - 150))+1);
        if(jiema < 150)
            return(~(xiaoshu >> (150 - jiema))+1);
    }
    else{
        if(jiema > 150)
            return(xiaoshu << (jiema - 150));
        if(jiema < 150)
            return(xiaoshu >> (150 - jiema));
    }
}

功能：返回unsigned uf的整型数的二进制形式
解释：uf右移23位和0xff和取得到阶码，然后得到尾数再把最高位置0；如果阶码大于127+31，那就超过int最大范围，如果小于127，那就是0点几，取整为0；然后看是否是负数，以及x和150的大小决定y的左移和右移。

实验结果