用#if、#elif、#endif编译的
函数定义在前半段
main函数的测试在后半段
有些有注释，有些无注释的，基本上难点的题都有注释，全部是自己想的（没有参考），这个过程的确比较痛苦，但提升也比较大。
^&^希望各位大神多多提出宝贵意见，轻喷
#include<stdio.h>
#include<math.h>
#include<stdint.h>
#include<limits.h>
#include<memory.h>
#include<crtdefs.h>
typedef unsigned char byte_pointer;
typedef unsigned float_bits;
#define sz (sizeof(int)<<3)
//-----------2_55---------------
void showbytes(byte_pointer* start,unsigned int n)
{
int i;
for(i=0;i<n;++i)
{
printf("%.2x ",start[i]);
}
}
//-----------2_56/2_57---------------
void ShowLong(long x)
{
showbytes((byte_pointer*)&x,sizeof(long));
}
void ShowShort(short x)
{
showbytes((byte_pointer*)&x,sizeof(short));
}
void ShowDouble(double x)
{
showbytes((byte_pointer*)&x,sizeof(double));
}
//--------------2_58----------------
int is_little_endian()
{
int x=1;
return *(char*)&x;
}
//--------------2_59----------------
unsigned out_put_change(unsigned x,unsigned y)
{
return (x&0xff)|(y&~(0xff));
}
//--------------2_60----------------
unsigned replace_byte(unsigned x,unsigned n,unsigned b)
{
return (x & (~(0xff<<n*8)))|(b<<n*8);
}
/*Get most significant byte from x*/
int get_msb(int x)//for type (int) w=4
{
/* x by w-1 byte*/
int shift=(sizeof(int)-1)<<3;
/*shift*/
int currentNum=x>>shift;
/*get most significant byte*/
return currentNum&0xff;
}
//--------------2_61----------------
use equial == or !=
//int allf(int x)//全是1
//{
// int w=sizeof(int)<<3;
// int num=((1<<(w-1))-1)+(1<<(w-1));
// return num==x;
//}
//int allzero(int x)//全是0
//{
// return 0==x;
//}
//int lsb_allf(int x)//最低有效位全是1
//{
// return (x&0xff)==0xff;
//}
//int msb_allf(int x)//最高有效位全是1
//{
// int shift=(sizeof(int)-1)<<3;
// int num=x>>shift;
// return (num&0xff)==0xff;
//}
//-----------相等可以写成!(x^num)的形式
int allf(int x)//全是1
{
int w=sizeof(int)<<3;
int num=((1<<(w-1))-1)+(1<<(w-1));
return !(x^num);//if x is all 1,x^0xffffffff is 0
}
int allzero(int x)//全是0
{
return !(x^0);//if x is all 0,x^0x00000000 is 0(x is all zero)
}
int lsb_allf(int x)//最低有效位全是1
{
return !((x&0xff)^0xff);
//if x'lsb is all 1,((x&0xff)^0xff) is 0(x is all zero)
}
int msb_allf(int x)//最高有效位全是1
{
int shift=(sizeof(int)-1)<<3;
int num=x>>shift;
//x>>(32-8)
return !((num&0xff)^0xff);
//if x'lsb is all 1,((x&0xff)^0xff) is 0(x is all zero)
}
//--------------2_62----------------
int int_shift_are_arithemtic()
{
int a=(-1>>1);
return a&INT_MIN==INT_MIN;
}
//--------------2_63----------------
/*perform shift arithmetically*/
unsigned srl(unsigned x,int k)
{
unsigned xsra=(int)x>>k;
int w=sizeof(int)<<3;
int mask=((1<<(k-1))-1)+(1<<(k-1));
int shift=w-k;
return ~(mask<<shift)&xsra;
}
/*perform shift logically*/
int sra(int x,int k)
{
int xsrl=(unsigned)x>>k;
int mask=((1<<(k-1))-1)+(1<<(k-1));
int shift=sz-k;
return (mask<<shift)|xsrl;
}
//--------------2_64----------------
int any_odd_one(unsigned x)
{
return (x&0xAAAAAAAA)==0xAAAAAAAA;
}
//----------------2_65---------------
//共迭代五次
//将区间分为两部分，前半部分和后半部分做异或，
//将相等的两部分置0，剩下的1都是单身,需要在下次操作中做判断
int odd_ones(unsigned x)
{
unsigned move1=x>>16;
unsigned result1=move1^x;
unsigned move2=result1>>8;
unsigned result2=move2^result1;
unsigned move3=result2>>4;
unsigned result3=move3^result2;
unsigned move4=result3>>2;
unsigned result4=move4^result3;
unsigned move5=result4>>1;
unsigned result5=move5^result4;
return result5&0x01;
}
//----------------2_66---------------
//共迭代五次,将区间迭代复制给下个2^n个区间（n属于0~4）
//获得形如0..111111111...之类的数值
//返回((result5>>1)+1)&x
//将这个数字向右移动一位再加1(顺带考虑了0xffffffff的情况)
//&x考虑了x=0的情况
int leftmost_one(unsigned x)
{
unsigned move1=x>>1;
unsigned result1=x|move1;
unsigned move2=result1>>2;
unsigned result2=result1|move2;
unsigned move3=result2>>4;
unsigned result3=result2|move3;
unsigned move4=result3>>8;
unsigned result4=result3|move4;
unsigned move5=result4>>16;
unsigned result5=result4|move5;
return ((result5>>1)+1)&x;
}
//----------------2_67---------------
int int_size_is_32_RunIn32()
{
unsigned a=0xffffffff;
return (a>>31);
}
int int_size_is_32_RunIn16()
{
unsigned a=0xffffffff;
int b=a>>15;
int c=b>>15;
int d=c>>1;
return d;
}
//----------------2_68---------------
int lower_one_mask(int n)
{
unsigned x=1<<(n-1);
unsigned x2=(1<<(n-1))-1;
return x+x2;
}
//----------------2_69---------------
unsigned rotate_left(unsigned x,int n)
{
unsigned right=x<<n;
unsigned left1 =x>>((32-n)-1);
unsigned left2 =left1>>1;
return right+left2;
}
//----------------2_70----------------
//x可以被表示为n位2进制补码形式
//1.构造n位1进制数11111111111....为m
//2.m与x进行&操作
//若所得结果第n位为1
//3.~m与x执行^操作
//所得结果为0
int fits_bits(int x,int n)
{
unsigned m=((1<<(n-1))-1)+(1<<(n-1));
unsigned result1=m&x;
unsigned result2=~m&x;
return !(result2)&&(result1>>(n-1));
}
//----------------2_71----------------
typedef unsigned packed_t;
//受题干干扰——只能使用一个减号和左右移
//写了半天(-@-)
int xbyte(packed_t word,int bytenum)
{
int b=(word<<((3-bytenum)<<3));
return b>>(3<<3);
}
//----------------2_72----------------
//有符号数转化为无符号了
//----------------2_73----------------
//本题主要考察补码加法的溢出情况
//补码的溢出只发生在两正数相加或两负数相加
//正数溢出发生在到达INT_MAX
//负数溢出发生在到达INT_MIN
//结果是两正数相加得到一个负数，两负数相加得到一个正数
int saturating_add(int x,int y)
{
int sum=x+y;
unsigned a=x&(1<<(sz-1));//a为0X00000000或者0X70000000;
unsigned b=y&(1<<(sz-1));//b为0X00000000或者0X70000000;
unsigned c=sum&(1<<(sz-1));//b为0X00000000或者0X70000000;
//溢出只发生在a为0X00000000，b为0X00000000，c为0X70000000;
//或者是 a为0X70000000，b为0X70000000，c为0X00000000;
int most_significant_bit=((~(a^b))&(1<<(sz-1)))&(a^c);
//最关键的就是求most_significant_bit的值了
//如果满足a^b为 0X00000000(x和y同号)
//并且a^c为0X70000000(结果与其中之一的值不同号)
//u就被赋值为0X70000000;
int mask=most_significant_bit>>(sz-1);
//mask被赋值为int类型并执行算数右移
//若满足溢出条件，mask为0XFFFF FFFF
//不满足，mask为0X0000 0000
unsigned value=INT_MIN-(c>>(sz-1));
//第二关键的步骤是求value
//如果满足上式mask的条件
//那么此时存在两种溢出条件
//一是TMIN
//二是TMAX
//如果c是0X0000 0000,则是两负数相加溢出为正数
//如果c是0X7000 0000,则是两正数相加溢出为负数
return (~mask&sum)|(mask&value);
//若mask为0X0000 0000,则返回值不影响sum值
//若mask为0XFFFF FFFF,则返回值为对应c的(TMIN或者TMAX)
}
//----------------2_74----------------
int tsub_ok(int x,int y)
//溢出方式与上述形式不一样
{
unsigned a=(((unsigned)(-y))>>(sz-1))&&(y!=0x80000000);//主要这里的溢出条件改变了
unsigned b=((unsigned)x)>>(sz-1);
unsigned c=((unsigned)(x-y))>>(sz-1);
return !((!(a^b))&&(a^c));
}
//----------------2_75----------------用了乘法
//x和y都是w位数
//基于x*y=(x_pre*2^(w/2)+x_post)*(x_pre*2^(w/2)+x_post)等价于
/*
(x_pre*y_pre)*2^w //一
+(x_pre*y_post+y_pre*x_post)*2^(w/2) //二
+(x_post*y_post) //三
*/
//其中(x_pre*y_post+y_pre*x_post)*2^(w/2)等价于
/*
{(x_pre*y_post)_pre*2^(w/2)+(x_pre*y_post)_post+
(y_pre*x_post)_pre*2^(w/2)+(y_pre*x_post)_post}*2^(w/2)
=
(x_pre*y_post)_pre*2^w+
(y_pre*x_post)_pre*2^w+
(x_pre*y_post)_post*2^(w/2)+
(y_pre*x_post)_post*2^(w/2)
*/
//综上x*y=
/*
(x_pre*y_pre)*2^w
(x_pre*y_post)_pre*2^w+
(y_pre*x_post)_pre*2^w+ //可以证明以上不会溢出
(x_pre*y_post)_post*2^(w/2)+
(y_pre*x_post)_post*2^(w/2)+
+(x_post*y_post)
//这个过程可能会溢出两次
//考虑0X0001FFFF和0X0001FFFF 相乘的情况
//(x_pre*y_post)_post*2^(w/2)=0xFFFF0000
//(y_pre*x_post)_post*2^(w/2)=0xFFFF0000
//(x_post*y_post)=0xFFFE0001
//------以上三个数相加必然会溢出两次
*/
unsigned unsigned_high_prod(unsigned x,unsigned y)
{
unsigned w1pre=x>>(sz>>1);
//x的前半部分(sz/2位 )(执行逻辑右移)
unsigned w2pre=y>>(sz>>1);
//y的前半部分(sz/2位 )(执行逻辑右移)
unsigned w1post=x&(~((-1)<<(sz>>1)));
//x的后半部分(sz/2位 ),(~((-1)<<(sz>>1)))实际上是0X0000FFFF
unsigned w2post=y&(~((-1)<<(sz>>1)));
//y的后半部分(sz/2位 ),(~((-1)<<(sz>>1)))实际上是0X0000FFFF
printf("w1pre:%.4x\nw2pre:%.4x\nw1post:"
"%.4x\nw2post:%.4x\n",w1pre,w2pre,w1post,w2post);
//将以上四个部分的数输出
unsigned result2=w1post*w2pre;
//x的后半部分和y的前半部分相乘得到一个sz位数
unsigned sub1_pre_forth=result2>>(sz>>1);
//result2的前半部分
unsigned sub1_post_forth=result2<<(sz>>1);
//result2的后半部分
unsigned result3=w2post*w1pre;
//x的前半部分和y的后半部分相乘得到一个sz位数
unsigned sub2_pre_forth=result3>>(sz>>1);
//result3的前半部分
unsigned sub2_post_forth=result3<<(sz>>1);
//result3的后半部分
//-----------判断sub1_post_forth+sub2_post_forth是否溢出-------------
unsigned sub12_post_forth_add=sub1_post_forth+sub2_post_forth;
//判断两unsigned数相加(sub1_post_forth，sub2_post_forth)是否溢出
unsigned a1=((unsigned)sub1_post_forth)>>(sz-1);
//sub1_post_forth的msb
unsigned b1=((unsigned)sub2_post_forth)>>(sz-1);
//sub2_post_forth的msb
unsigned c1=((unsigned)(sub12_post_forth_add))>>(sz-1);
//sub12_post_forth_add的msb
unsigned u1=(a1&b1)|(((a1^b1)^c1)&(a1|b1)); //1 0 0;0 1 0;1 1;
//case1:判断条件是(a1,b1)都为1，则溢出
//case2:若(a1,b1)有一个为1，c1却为0，则溢出
//-----------判断result4+sub12_post_forth_add是否溢出-------------
unsigned result4=w1post*w2post;
//x的后半部分和y的后半部分相乘得到一个sz位数(必为正数,赋值为unsigned)
unsigned add_sub12_post_add_result4=sub12_post_forth_add+result4;
//判断两unsigned数相加(sub12_post_forth_add，result4)是否溢出
unsigned a2=((unsigned)sub12_post_forth_add)>>(sz-1);
//sub12_post_forth_add的msb
unsigned b2=((unsigned)result4)>>(sz-1);
//result4的msb
unsigned c2=((unsigned)(add_sub12_post_add_result4))>>(sz-1);
//add_sub12_post_add_result4的msb
unsigned u2=(a2&b2)|(((a2^b2)^c2)&(a2|b2));//1 0 0;0 1 0;1 1;
//case1:判断条件是(a2,b2)都为1，则溢出
//case2:若(a2,b2)有一个为1，c1却为0，则溢出
int result1=w1pre*w2pre;
//result1：x的前半部分和y的前半部分相乘得到一个sz位数
int result=result1+sub1_pre_forth+sub2_pre_forth+u1+u2;//加上溢出的数
return result;
}
int signed_high_prod(int x,int y)
{
int w1pre=x>>(sz>>1);//x的前半部分(sz/2位 )
//(有可能为负数)(负数执行算数右移，正数执行逻辑右移)
int w2pre=y>>(sz>>1);//y的前半部分(sz/2位 )(有可能为负数)
//(负数执行算数右移，正数执行逻辑右移)
int w1post=x&(~((-1)<<(sz>>1)));//x的后半部分(sz/2位 )(必为正数)
int w2post=y&(~((-1)<<(sz>>1)));//y的后半部分(sz/2位 )(必为正数)
printf("\nw1pre:%.4x\nw2pre:%.4x\nw1post:"
"%.4x\nw2post:%.4x\n",w1pre,w2pre,w1post,w2post);
//将以上四个部分的数输出
int result2=w1post*w2pre;
//x的后半部分和y的前半部分相乘得到一个sz位数 (有可能为负数，赋值为int)
int sub1_pre_forth=result2>>(sz>>1);
//result2的前半部分(有可能为负数，赋值为int)
unsigned sub1_post_forth=result2<<(sz>>1);
//result2的后半部分(必为正数,赋值为unsigned)
int result3=w2post*w1pre;
//x的前半部分和y的后半部分相乘得到一个sz位数(有可能为负数，赋值为int)
int sub2_pre_forth=result3>>(sz>>1);
//result3的前半部分(有可能为负数，赋值为int)
unsigned sub2_post_forth=result3<<(sz>>1);
//result3的后半部分(必为正数,赋值为unsigned)
//-----------判断sub12_post_forth_add是否溢出-------------
unsigned sub12_post_forth_add=sub1_post_forth+sub2_post_forth;
//判断两unsigned数相加(sub1_post_forth，sub2_post_forth)是否溢出
unsigned a1=((unsigned)sub1_post_forth)>>(sz-1);
//sub1_post_forth的msb
unsigned b1=((unsigned)sub2_post_forth)>>(sz-1);
//sub2_post_forth的msb
unsigned c1=((unsigned)(sub12_post_forth_add))>>(sz-1);
//sub12_post_forth_add的msb
unsigned u1=(a1&b1)|(((a1^b1)^c1)&(a1|b1)); //1 0 0;0 1 0;1 1;
//case1:判断条件是(a1,b1)都为1，则溢出
//case2:若(a1,b1)有一个为1，c1却为0，则溢出
//-----------判断result4是否溢出-------------
unsigned result4=w1post*w2post;
//x的后半部分和y的后半部分相乘得到一个sz位数(必为正数,赋值为unsigned)
unsigned add_sub12_post_add_result4=sub12_post_forth_add+result4;
//判断两unsigned数相加(sub12_post_forth_add，result4)是否溢出
unsigned a2=((unsigned)sub12_post_forth_add)>>(sz-1);
//sub12_post_forth_add的msb
unsigned b2=((unsigned)result4)>>(sz-1);
//result4的msb
unsigned c2=((unsigned)(add_sub12_post_add_result4))>>(sz-1);
//add_sub12_post_add_result4的msb
unsigned u2=(a2&b2)|(((a2^b2)^c2)&(a2|b2));//1 0 0;0 1 0;1 1;
//case1:判断条件是(a2,b2)都为1，则溢出
//case2:若(a2,b2)有一个为1，c1却为0，则溢出
int result1=w1pre*w2pre;
//result1：x的前半部分和y的前半部分相乘得到一个sz位数(有可能为负数)
int result=result1+sub1_pre_forth+sub2_pre_forth+u1+u2;//加上溢出的数
return result;
}
//----------------2_76----------------用了乘法和除法
/*
void* calloc(size_t nmemb,size_t size)
{
int bytes_size=sizeof(size_t)<<3;
size_t num=nmemb*size;
size_t result=!num|(num/nmemb==size);
size_t mask=~(result-1);
size_t real_num=mask#
void *p;
if(real_num==0)
{
return NULL;
}
p = malloc(real_num);
p=memset(p,0,real_num);
while(real_num)
{
printf("%.2x ",*(char*)p++);
--real_num;
}
printf("%d ",real_num);
return p;
}
*/
//---------------------2_77------------------
int mul_17(int x)
{
return (x<<4)+x;
}
int mul_sub7(int x)
{
return x-(x<<3);
}
int mul_60(int x)
{
return (x<<6)-(x<<2);
}
int mul_sub112(int x)
{
return (x<<4)-(x<<7);
}
//----------------2_78----------------
int divide_power2(int x,int k)
{
int signal1=(x>>(sz-1))&((1<<k)-1);
return (x+signal1)>>k;
}
//----------------2_79----------------
int divide_mul_3divide_4(int x)//x*3/4(额外实现向零舍入，但是它会溢出)
{
int signal1=(x>>(sz-1))&((1<<2)-1);
return (((x<<1)+x)+signal1)>>2;
}
//----------------2_80----------------
int threefourths(int x)//x*3/4(实现向零舍入，不会溢出)
{
int signal1=(x>>(sz-1))&((1<<2)-1);
int signal2=(x&0x3)+((x<<1)&0x2)+signal1;
return (x>>1)+(x>>2)+((signal2&0xc)>>2);
}
//----------------2_81----------------
unsigned bit_mode1(int k)
{
unsigned u=(1<<k)-1;
return ~u;
}
unsigned bit_mode2(int k,int j)
{
unsigned u1=(1<<k<<j)-1;
unsigned u2=(1<<j)-1;
return u1-u2;
}
//----------------2_82----------------
//经验证第一个为假，取INT_MIN不为真
//---------------2_90----------------------
float u2f(unsigned u)
{
return *(float*)(&u);
}
unsigned f2u(float f)
{
return *(unsigned*)(&f);
}
float fpwr2(int x)
{
unsigned exp,frac;
unsigned u;
if(x<-149)
{
exp=0;
frac=0;
}
else if(x<-126)
{
exp=0;
frac=1<<(x+149);
}
else if(x<128)
{
exp=x+127;
frac=0;
}
else
{
exp=127;
frac=0;
}
u=exp<<23|frac;
return u2f(u);
}
void showbyte_by_big_endian(byte_pointer *start,int n)
{
unsigned i;
for(i=n;i>=0;--i)
{
printf("%.2x ",start[i-1]);
}
}
//---------------2_91----------------------
//一、3.141592741012573242
//二、22/7=11.[001]
//三、22/7和223/71从第9位开始
//---------------2_92----------------------
float_bits float_negate(float_bits f)
{
float_bits sign=(0x01<<(sz-1));
float_bits exp=0xff<<23;
float_bits frac=(0x7fffff)&f;
if(((exp&f)==exp)&&frac)
return f;
f=f^sign;
return f;
}
//---------------2_93----------------------
float_bits float_absval(float_bits f)
{
float_bits sign=~(0x01<<(sz-1));
float_bits exp=0xff<<23;
float_bits frac=(0x7fffff)&f;
if((exp&f==exp)&&frac)
return f;
f=f&sign;
return f;
}
//---------------2_94----------------------
float_bits float_twice(float_bits f)
{
float_bits exp=0xff<<23;
float_bits frac=(0x7fffff)&f;
float_bits ture_exp=(((exp&f)>>23)+1)<<23;
if((exp&f==exp)&&frac)
return f;
f=((f&~(0xff<<23))|(ture_exp));
return f;
}
//---------------2_95----------------------
float_bits float_half(float_bits f)
{
float_bits exp=0xff<<23;
float_bits frac=(0x7fffff)&f;
float_bits ture_exp=(((exp&f)>>23)-1)<<23;
if((exp&f==exp)&&frac)
return f;
f=((f&~(0xff<<23))|(ture_exp));
return f;
}
//---------------2_96-----------------
//该函数未实现向零舍入和对NaN的判断
int float_f2i(float_bits f)
{
int sign=(0x01<<(sz-1))&f;
unsigned frac=f&0x7fffff;
unsigned exp=0xff<<23;
unsigned true_exp=((exp&f)>>23)-127;
int result;
// printf("%.2x\n",frac|(0x01<<23));
// printf("%.2x\n",true_exp);
if(true_exp>23)
result = (frac|(0x01<<23))<<(true_exp-23);
else
result = (frac|(0x01<<23))>>(23-true_exp);
return (result^(sign>>(sz-1)))+(((unsigned)sign)>>(sz-1));
}
//---------------2_97-----------------
int useful_bits(unsigned x)
{
unsigned move1=x>>1;
unsigned result1=x|move1;
unsigned move2=result1>>2;
unsigned result2=result1|move2;
unsigned move3=result2>>4;
unsigned result3=result2|move3;
unsigned move4=result3>>8;
unsigned result4=result3|move4;
unsigned move5=result4>>16;
unsigned result5=result4|move5;
return result5;
}
int num_of_bits(unsigned usefulbits)
{
unsigned nums=usefulbits-(usefulbits>>1)-(usefulbits>>2)-(usefulbits>>3)-
(usefulbits>>4)-(usefulbits>>5)-(usefulbits>>6)-(usefulbits>>7)-
(usefulbits>>8)-(usefulbits>>9)-(usefulbits>>10)-(usefulbits>>11)-
(usefulbits>>12)-(usefulbits>>13)-(usefulbits>>14)-(usefulbits>>15)-
(usefulbits>>16)-(usefulbits>>17)-(usefulbits>>18)-(usefulbits>>19)-
(usefulbits>>20)-(usefulbits>>21)-(usefulbits>>22)-(usefulbits>>23)-
(usefulbits>>24)-(usefulbits>>25)-(usefulbits>>26)-(usefulbits>>27)-
(usefulbits>>28)-(usefulbits>>29)-(usefulbits>>30)-(usefulbits>>31);
return nums;
}
float_bits float_i2f(int i)
{
int sign=(0x01<<(sz-1))&i;
//最高符号位
unsigned abs_i=(i^(sign>>(sz-1)))+(((unsigned)sign)>>(sz-1));
//取i的绝对值
unsigned usefulbits=useful_bits(abs_i);
//将abs_i的有效位全置为1
unsigned leftmostbits=((usefulbits>>1)+1)&abs_i;
//求abs_i的最高有效位的表示
unsigned value=num_of_bits(usefulbits^leftmostbits);
//求abs_i去除最高有效位后还剩下有效位的个数
int drop_leftmost=leftmostbits^abs_i;
//去除abs_i的最高有效位
float_bits frac=drop_leftmost;
//frac等于去除最高有效位后的位表示
float_bits exp=(value+127)<<23;
//求float中的指数部分的表示
if(value>23)
frac = frac>>(value-23);
else
frac = frac<<(23-value);
return sign|exp|frac;
}
//------------------main()------------
int main()
{
#if 1
//---------------2_97-----------------
int i=-26556;
float f=i;
float_bits fb=f2u(f);
printf("fb:%.2x\n",fb);
printf("i2f:%.2x\n",float_i2f(i));
#elif 0
//---------------2_96-----------------
int i=0;
float f=i;
float_bits fb=f2u(f);
printf("i:%d\n",i);
printf("f:%d\n",f);
printf("f2i:%d\n",float_f2i(fb));
#elif 0
//---------------2_95----------------------
float f1=-60;
float f2=-120;
float_bits fb1=f2u(f1);
float_bits fb2=f2u(f2);
printf("%.2x\n",fb1);
printf("%.2x\n",float_half(fb2));
#elif 0
//---------------2_94----------------------
float f1=-120;
float f2=-60;
float_bits fb1=f2u(f1);
float_bits fb2=f2u(f2);
printf("%.2x\n",fb1);
printf("%.2x\n",float_twice(fb2));
#elif 0
//---------------2_93----------------------
float f=-1e1000;
float_bits fb=f2u(f);
printf("%.2x\n",fb);
printf("%.2x\n",float_absval(fb));
#elif 0
//---------------2_92----------------------
float f=0;
float_bits fb1=f2u(f);
float_bits fb2=0x7f800001;
printf("%.2x\n",fb1);
printf("%.2x\n",float_negate(fb1));
printf("%.2x\n",fb2);
printf("%.2x\n",float_negate(fb2));
#elif 0
//---------------2_90----------------------
float p=fpwr2(-149);
showbyte_by_big_endian((byte_pointer*)&p,sizeof(float));
#elif 0
//----------------2_82----------------
int x=0x80000000;
int y=0x60000000;
unsigned ux=(unsigned)x;
unsigned uy=(unsigned)y;
printf("%.2x\n",ux-uy);
printf("%.2x\n",-(unsigned)(y-x));
#elif 0
//----------------2_81----------------
printf("%.16llx\n",bit_mode1(30));
printf("%.16llx\n",bit_mode2(5,8));
#elif 0
//----------------2_80----------------
printf("%d\n", threefourths(0x80000000));
#elif 0
//----------------2_79----------------
printf("%d\n", divide_mul_3divide_4(0x80000000));
#elif 0
//----------------2_78----------------
printf("%d\n", divide_power2(-5,3));
#elif 0
//----------------2_77----------------
printf("%d\n",mul_17(2));
#elif 0
//----------------2_76----------------
calloc(0xff,0xff);
#elif 0
//----------------2_75----------------
printf("%.8x\n%.8x\n\n",unsigned_high_prod(0xE396667C,0xE6E1B7C6),0xE396667C*0xE6E1B7C6);
printf("%.8x\n%.8x\n\n",unsigned_high_prod(0x1FFFF,0x1FFFF),0x1FFFF*0x1FFFF);
printf("%.2x\n",signed_high_prod(INT_MIN,INT_MIN));
#elif 0
//----------------2_74----------------
printf("%d",tsub_ok(0xffffffff,0xffffffff));
#elif 0
//----------------2_73----------------
printf("%d",saturating_add(INT_MIN,INT_MAX));
#elif 0
//----------------2_72----------------
//有符号数转化为无符号了
//----------------2_71----------------
printf("%x\n",xbyte(0x4fffffff,3));
#elif 0
//----------------2_70----------------
#elif 0
//----------------2_69---------------
printf("%x\n",rotate_left(0x12345678,0));
printf("%x\n",rotate_left(0x12345678,4));
printf("%x\n",rotate_left(0x12345678,20));
#elif 0
//----------------2_68---------------
printf("%x\n",lower_one_mask(17));
#elif 0
//----------------2_67---------------
printf("%x\n",int_size_is_32_RunIn32());
#elif 0
//----------------2_66---------------
printf("%x\n",leftmost_one(0x6600));
#elif 0
//--------------2_65----------------
printf("%x\n",odd_ones(0xfffffff8));
#elif 0
//--------------2_64----------------
printf("%x\n",any_odd_one(0xffffffff));
#elif 0
//--------------2_63----------------
printf("%.2x\n",srl(0xffffffff,16));//算术右移转化为逻辑右移
printf("%.2x\n",sra(0xffffffff,16));//逻辑右移转化为算数右移
#elif 0
//--------------2_62----------------
printf("%d\n",int_shift_are_arithemtic());
#elif 0
//--------------2_61 ----------------
printf("%d\n",allf(0xffffffff));//allf
printf("%d\n",allzero(0x00000000));//allzero
printf("%d\n",lsb_allf(0xff));//Least significant byte is all 1
printf("%d\n",msb_allf(0xff110a00));//most significant byte is all 1
#elif 0
//--------------2_60----------------
unsigned x=0x12345678;
unsigned n=0;
unsigned b=0xAB;
printf("%.2x",replace_byte(x,1,b));
#elif 0
//--------------2_59----------------
unsigned x=0x89ABCDEF;
unsigned y=0x76543210;
printf("%.2x",out_put_change(x,y));
#elif 0
//--------------2_58----------------
printf("%d",is_little_endian());
#elif 0
//-----------2_56/2_57---------------
int x=0xfff;
long x2=0xfff;
long x3=0xfff;
double x4=1.342;
showbytes((byte_pointer*)&x,sizeof(int));
printf("\n");
ShowLong(x2);
printf("\n");
ShowShort(x3);
printf("\n");
ShowDouble(x4);
#endif
} 
