/*****************************计算log2(x)向下取整*******************************/

 int ilog2(int x) {

     int bit_16, bit_8, bit_4, bit_2, bit_1;

     bit_16 = (!!(x >> )) << ;                //如果x >> 16非零，则至少有16位

     x = x >> bit_16;

     bit_8 = (!!(x >> )) << ;

     x = x >> bit_8;

     bit_4 = (!!(x >> )) << ;

     x = x >> bit_4;

     bit_2 = (!!(x >> )) << ;

     x = x >> bit_2;

     bit_1 = x >> ;      //还剩两位时，直接判断首位。bit_1 == 1,剩两位；bit_1 == 0,剩一位

     return bit_16 + bit_8 + bit_4 + bit_2 + bit_1;
　　　　　//实际是（bit_1 + 1）-1；由于向下舍入，总位数减一

 }

 /****************************表达x所需要的最少位数******************************/

 int howManyBits(int x) {

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

     int k = x >> ;

     int temp = x ^ k;                      
　　　　　//x为正，temp = x;x为负，temp = ~x

     int isZero = (!!(temp << )) >> ; 
　　　　 //x = 0或x = -1时，temp = 0,isZero = 0...0；否则isZero = 1...1

     bit_16 = (!!(temp >> )) << ;

     temp = temp >> bit_16;

     bit_8 = (!!(temp << )) << ;

     temp = temp >> bit_8;

     bit_4 = (!!(temp << )) << ;

     temp = temp >> bit_4;

     bit_2 = (!!(temp << )) << ;

     temp = temp >> bit_2;

     bit_1 = temp >> ;

     result = bit_16 + bit_8 + bit_4 + bit_2 + bit_1 + ;
　　　　　　//真正位数为bit_16 + ... + bit_1 + 1,再加符号位一位

     return (!isZero) | (result & isZero);

 }

 /************************************逻辑右移*************************************/

 int logicshift(int x, int n)

 {

     int temp = ~( << );

     temp = ((temp >> n) << ) + ;                //生成掩码0...01...1(前面为n个0)

     return (x >> n) & temp;

 }

 /*************************类似于c语言中的x ? y : z**********************************/

 int conditional(int x, int y,int z)

 {

     int temp = (~(!x)) + ;                      //要在return中完成，必须生成x,y的掩码

     return (temp & z) | ((~temp) & y);           //当x = 0时，temp = 1...1;当x != 0时，temp = 0...0

 }

 /*********************************** x/ 2^n *****************************************/

 int divpwr2(int x, int n)

 {

     int temp = ( << n) + (~);                  //temp为baising(偏置),1...1(共n个1)

     return (x + ((x >> ) & temp)) >> n;        //只有负数才要加偏置，所以temp要与符号位相与

 }

 /****************************** x < y ? ***********************************/

 int isLessOrEqual(int x, int y)

 {

     int signx = x >> ;

     int signy = y >> ;

     int signEqual = (!(signx ^ signy) & ((x + (~y)) >> ));//符号位不同时，做差

     int signDiffer = signx & (!signy);                      //符号位相同，直接比较符号位

     return signEqual | signDiffer;

 }

 /**********************操作数更小的版本**************************/

 int isLessOrEqual_2(int x, int y)

 {

     int not_y = ~y;

     return ((((x + not_y) & (x ^ not_y)) | (x & not_y)) >> ) & ;

     //        x-y-1<0 <----------x,y不同号------>x为负，y为正，才为正

 }

 /****************************不用负号得到-x*********************************/

 int negate(int x)

 {

     return ~x + ;                //按位取反，末位加一

 }

 /**********************返回最小的补码***************************************/

 int tmin(void)

 {

     return  << ;

 }

 /*************************只用~ 和 | 实现x&y*****************************/

 int bitAnd(int x, int y)

 {

     return ~(~x | y);            //摩根律

 }

 /**************************从字x中取出第n个字节*********************************/

 int getByte(int x, int n)

 {

     return (x >> (n << )) & 0xff;        //是从0开始数的

 }

 /*********************************计算x中1的数目*********************************/

 int bitCount(int x)

 {

     int result;

     int tmpmark1 = 0x55 + (0x55 << );                //最大0xff

     int mark1 = tmpmark1 + (tmpmark1 << );

     int tmpmark2 = 0x33 + (0x33 <<);

     int mark2 = tmpmark2 + (tmpmark2 << );

     int tmpmark3 = 0x0f + (0x0f << );

     int mark3 = tmpmark3 + (tmpmark3 << );

     int mark4 = 0xff + (0xff << );

     int mark5 = 0xff + (0xff << );                  //以上生成5个掩码

     result = (x & mark1) + ((x >> ) & mark1);

     result = (result & mark2) + ((result >> ) & mark2);   //这两个由于进位问题，不能先加再与

     result = (result + (result >> )) & mark3;              //分治

     result = (result + (result >> )) & mark4;

     result = (result + (result >> )) & mark5;

     return result;

 }

 /***************************计算uf/2*********************************/

 unsigned float_half(unsigned uf)

 {

     unsigned s = uf & 0x80000000;

     unsigned exp = uf & 0x7f800000;

     int lsb = ((uf & ) == );                //判断frac最后两位是否为11

     if (exp == 0x7f800000)

         return uf;

     else if (exp <= 0x800000)

         return s | (((uf ^ s) + lsb) >> );  //uf^s将符号位置零，uf^s = frac + exp末位

     else

         return uf - 0x800000;                 //整体思路就是模拟

 }

 /****************************计算（float）x***********************************/

 int float_f2i(unsigned uf)

 {

     int abs;

     int sign = uf >> ;

     int exp = (uf >> ) & 0xff;

     int frac = uf & 0x007fffff;

     if (exp < 0x7f)        return ;

     if (exp > )        return 0x80000000;                //Tmax = 2^31 -1

     abs = ((frac >> ) + ) << (exp - );            //模拟

     if (sign)

         return -abs;

     else

         return abs;

 }

 /****************************计算2*f***************************************/

 unsigned float_twice(unsigned uf)

 {

     int result;

     int exp = uf & 0x7f800000;

     int frac = uf & 0x7fffff;

     if (exp == 0x7f800000)

         return uf;

     else if (exp == )

         frac = frac << ;              //frac也可用uf代替，因为此时frac = uf

     else

         exp = exp + 0x800000;

     result = (uf & 0x80000000) | exp | frac;

     return result;

 }