CSAPP_DataLab

/* 
 * bitXor - x^y using only ~ and & 
 *   Example: bitXor(4, 5) = 1
 *   Legal ops: ~ &
 *   Max ops: 14
 *   Rating: 1
 */
int bitXor(int x, int y) {
  int m = (~x) & y;
  int n = (~y) & x;
  return ~((~m) &  (~n));
}

/* 
 * tmin - return minimum two's complement integer 
 *   Legal ops: ! ~ & ^ | + << >>
 *   Max ops: 4
 *   Rating: 1
 */
int tmin(void) {
  // easy
  return (1 << 31);
}

/*
 * 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) {
  int y = x + x + 2;
  return ((!y) & (!!(x + 1)));
}

/* 
 * 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) {
  // even-numbered bits can also be 1
  int mask1 = 0xaa;
  int mask2 = mask1 << 8;
  int mask3 = mask2 << 8;
  int mask4 = mask3 << 8;
  int mask = (mask1 | mask2 | mask3 | mask4);
  // x & mask clears the impact of even-numbered 1s
  // to judge whether it equals to 0xaaaaaaaa
  return !((x & mask) + (~mask) + 1);
}

/* 
 * negate - return -x 
 *   Example: negate(1) = -1.
 *   Legal ops: ! ~ & ^ | + << >>
 *   Max ops: 5
 *   Rating: 2
 */
int negate(int x) {
  // easy
  return (~x) + 1;
}

//3
/* 
 * 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) {
  // my first method run out of all the 15 available ops

  // int mask1 = 0xff;
  // int mask2 = mask1 << 8;
  // int mask3 = mask2 << 8;
  // int mask4 = mask3 << 8;
  // int mask = (0xc0 | mask2 | mask3 | mask4);

  // int c = (x & mask); 

  // int xx = x & 0x3f;

  // int c1 = !(((xx + (~0x30) +1) >> 31) & (0x1)); // == 0
  // int c2 = !((((~xx) + 1 + 0x39) >> 31) & (0x1)); // == 0

  // return (!c) & (c1 & c2);


  // first step is to fetch the low four bits
  int mask = 0xf;
  int low = mask & x;
  // then judge the upper 28 bits;use ^ to judge whether it equals to 0x30
  int xx = x + (~low) +1;
  int c = xx ^ 0x30;

  // two cases of the low four bits
  // 0xxx or 1000 or 1001
  int mid = low & 0x6;
  int high = low >> 3;

  return (!c) & ((!high) | (!mid));
}

/* 
 * 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) {
  // use ! to judge , to change odinary nums to 0 or 1
  // after we get 0 or 1
  // for 0 : we can use !x to change it to 1 , then ~x + 1 to get -1 , with
  // all bits of 1
  // for 1 : we can use !!x to change it back to 1, then ~x+1 to get -1
  return ((~(!(!x)) + 1) & y) | ((~(!x) + 1) & z);
}

/* 
 * isLessOrEqual - if x <= y  then return 1, else return 0 
 *   Example: isLessOrEqual(4,5) = 1.
 *   Legal ops: ! ~ & ^ | + << >>
 *   Max ops: 24
 *   Rating: 3
 */
int isLessOrEqual(int x, int y) {
  // use ^ to judge equalance
  // to avoid overflow , use the most significant bit to deal with different cases
  int xs = x >> 31;
  int ys = y >> 31;
  return (!(x ^ y)) | (xs & (!ys)) | ((!(xs ^ ys)) & (x + (~y) +1) >> 31);
}

/* 
 * 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) {
  // we divide all x into three groups: 0,positive,negative
  // for negative and positive,one and only one of the significant bit of x and -x will be 1
  // but for 0,they are all 0
  // so we add 1 ,keep the trait for positive and negative numbers,but change the case of 0
  // last,for non-zero : xs == 0 && negxs == 1 || xs == 1 && negxs == 0
  // for zero : xs == 1 || negxs == 1 
  int xs = (((x >> 31) & 0x1) + 1) & 0x1 ;
  int negxs = (((((~x) + 1) >> 31) & 0x1) + 1) & 0x1 ;
  return xs & negxs;
}

/* 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 isZero = !x;
  int mask = ((!!x) << 31) >> 31;

  int flag = x >> 31;

  x = ((~flag) & x) | (flag & (~x));

  int bit_16, bit_8, bit_4, bit_2, bit_1, bit_0;

  bit_16 = (!((!!(x >> 16)) ^ 0x1)) << 4;
  x >>= bit_16;

  bit_8 = (!((!!(x >> 8)) ^ 0x1)) << 3;
  x >>= bit_8;

  bit_4 = (!((!!(x >> 4)) ^ 0x1)) << 2;
  x >>= bit_4;

  bit_2 = (!((!!(x >> 2)) ^ 0x1)) << 1;
  x >>= bit_2;

  bit_1 = (!((!!(x >> 1)) ^ 0x1));
  x >>= bit_1;

  bit_0 = x;

  int res = bit_16 + bit_8 + bit_4 + bit_2 + bit_1 + bit_0 + 1;

  return (isZero | (mask & res));
}

/* 
 * 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) {
  int expmask = 0xff << 23;
  int s = uf >> 31;
  int fmask1 = 0xff;
  int fmask2 = fmask1 << 8;
  int fmask3 = fmask2 << 7;
  int fmask = fmask1 | fmask2 | fmask3;
  int frac = uf & fmask;
  int exp = (uf & expmask) >> 23;
  if(exp && (exp - 0xff))
    exp = exp + 1;
  if(!exp)
    frac = frac << 1;
  uf = (s << 31) | (exp << 23) | (frac);
  return uf;
}

/* 
 * 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) {
  int expmask = 0xff << 23;
  int exp = (uf & expmask) >> 23;
  
  int s = uf >> 31;
  
  int fmask1 = 0xff;
  int fmask2 = fmask1 << 8;
  int fmask3 = fmask2 << 7;
  int fmask = fmask1 | fmask2 | fmask3;
  int frac = uf & fmask;

  int M;
  int E;
  int bias = 127;

  if(exp == 0xff){
    return 0x80000000u;
  }

  if(exp && (exp - 0xff)){
    M = 1 << 23 | frac;
    E = exp - bias;
  }
  else{
    M = frac;
    E = 1 - bias;
  }

  int res;
  if(E > 23){
    res = M << E;
    // do not forget this anything out of range
    if(E >= 8) return 0x80000000u;
  }
  else if(E == 23) res = M;
  else{
    int e = 23 - E;
    if(e >= 24) return 0;
    res = M >> (23 - E);
  }
  if(s) return -res;
  return res;
}

/* 
 * 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
 */
#include<stdio.h>
unsigned floatPower2(int x) {
  int exp;
  int frac;
  int s = 0;
  int res = 0;

  if(x >= 128){
    exp = 0xff;
    frac = 0;
    s = 0;
  }
  else if(x < -126 - 23){
    frac = 0;
    exp = 0;
  }
  else if(x >= -126 - 23 && x <= -127){
    exp = 0;
    frac = 1 << (x - (-126 - 23));
  }
  else {
    frac = 0;
    exp = 127 + x;
  }

  res = (exp << 23) | (frac) | (s << 31);

  return res;
}