homework8.cpp

计算机组成原理 .有试验报告 程序可以完成由定点运算实现浮点运算

#include<stdio.h>
#include<string.h>
#include<math.h>
#include<stdlib.h>
int len1,len2,op;
float nu1,nu2,nu;
void inputs();
void format_nu();
void main()
{  	
  int temp,n; 
  do{ 
     do{
	   inputs();
       format_nu();
       if(op==1)
	   printf("你的输入为:%f+E%d  +  %f+E%d\n",nu1,len1,nu2,len2); 
	   if(op==2)
	   printf("你的输入为:%f+E%d  -  %f+E%d\n",nu1,len1,nu2,len2); 
	   if(op==3)
 	   printf("你的输入为:%f+E%d  *  %f+E%d\n",nu1,len1,nu2,len2); 
	   if(op==4)
	   printf("你的输入为:%f+E%d  /  %f+E%d\n",nu1,len1,nu2,len2);
	   printf("请确认你的输入，如果正确无误请输入1,否则请输入0:");
	   scanf("%d",&temp); }while(temp==0);
       //重新执行输入程序和判断，初始化操作
	if(op==1)
	{   
      if(len1==len2)
	  {  
	   if(nu1==(-nu2))
			    printf("%f+E%d\n",0.0,0);//两者恰为相反数，和为0
	   else{ 
		       nu=nu1+nu2;
		       while(fabs(nu)>=1.0)
			   {  
			     if(len1==999999999)
				 {
				 printf("结果上溢，错误!!!\n");   //相加后会产生进位，如果其阶码已经到达最大值，则结果溢出
		         break ;
				 }
			     else
				 { 
					 nu=nu/10;//对结果进行规格化
		             len1++;
				 }
			   }
		      printf("%f+E%d\n",nu,len1);
		  }
	  }
	 else if(len1<len2)
		{   
			n=len2-len1;//两数的阶码不同，首先要对阶然后才能计算
			for(;n>0;n--)
			{
				 nu1=nu1/10;
			     len1=len1+1;
			}//小阶向大阶对齐
			if(nu1==(-nu2))
			   printf("%f+E%d\n",0.0,0);//两者恰为相反数，和为0
		  else{ 
               nu=nu1+nu2;
		   	   while(fabs(nu)>=1.0)
			   {
			    if(len1==999999999)
				{
				 printf("结果上溢，错误!!!\n");
		         break ;
				}
			   else
			   {
		        nu=nu/10;
		        len1++;
			   }
			   }
             printf("%f+E%d\n",nu,len1);
		  }
		}
	//if(len1>len2)
   else	
	 {
			n=len1-len2;//两数的阶码不同，首先要对阶然后才能计算
			for(;n>0;n--)
			{
				 nu2=nu2/10;
			     len2=len2+1;//小阶向大阶对齐
			}
		if(nu1==(-nu2))
			   printf("%f+E%d\n",0.0,0);//两者恰为相反数，和为0
		else{ 
             nu=nu1+nu2;
		     while(fabs(nu)>=1.0)
			 {
		      if(len1==999999999)
			  {
				 printf("结果上溢，错误!!!\n");
		         break ;
			  }
			 else
			 {
			    nu=nu/10;
		        len1++;
			 }
			}
		   printf("%f+E%d\n",nu,len1);
		  }
		}
		
	}

	if(op==2)
	{
		if(len1==len2)
			{
		      if(nu1==nu2)
			    printf("%f+E%d\n",0.0,0);//两数相等，相减为零
		      else{ 
                   nu=nu1-nu2;
		           while(fabs(nu)>=1.0)
				   {  
			         if(len1==999999999)
					 {
				       printf("结果上溢，错误!!!\n");//相减后会产生进位，如果其阶码已经到达最大值，则结果溢出
		               break ;
					 } 
		             else
					 {
		              nu=nu/10;    //未到阶码的最大值，对结果进行规格化
		              len1++;
					 }
				  }
		      printf("%f+E%d\n",nu,len1);
		  }
		}
	 else if(len1<len2)
		{   
			n=len2-len1;//两数的阶码不同，首先要对阶然后才能计算
			for(;n>0;n--)
			{
				 nu1=nu1/10;
			     len1=len1+1;
			}
		   if(nu1==nu2)
			   printf("%f+E%d\n",0.0,0);//两数相等，相减为零
	       else{ 
                 nu=nu1-nu2;
		         while(fabs(nu)>=1.0)
				 {
			       if(len1==999999999)
				   {
				     printf("结果上溢，错误!!!\n");//相减后会产生进位，如果其阶码已经到达最大值，则结果溢出
		             break ;
				   }
			      else
				  {
		             nu=nu/10;       //未到阶码的最大值，对结果进行规格化
		             len1++;
				  }
				 }
               while((fabs(nu))<=0.1)
			   {
			     if(len1==-1000000000)
				 {
				     printf("结果下溢：\n"); //已到阶码的最小值，再减就会溢出
				     printf("%d",0);
		             break ;
				 }
			else
			{
			  nu=nu*10;
			  len1=len1-1;//未到阶码的最小值，可以再减
		   }
		 }
		   printf("%f+E%d\n",nu,len1);
	   }
	}
	//	if(len1>len2)
	else	{
			n=len1-len2;//两数的阶码不同，首先要对阶然后才能计算
			for(;n>0;n--)
			{
				 nu2=nu2/10;
			     len2=len2+1;
			}
		  if(nu1==nu2)
			   printf("%f+E%d\n",0.0,0);
		  else{ 
               nu=nu1-nu2;
		       while(fabs(nu)>=1.0)
			   {
		         nu=nu/10;
		         len1++;
			   }
         while((fabs(nu))<=0.1)
		   {
			   if(len1==-1000000000)
			   {
				 printf("结果下溢：\n");
				 printf("%d",0);
		         break ;
			  }
			else
			{
			   nu=nu*10;
			   len1=len1-1;
			}
		 }
		   printf("%f+E%d\n",nu,len1);
		  }
		}
	}

   if(op==3)
   { 
	   if(nu1==0||nu2==0)
		   printf("%f+E%d\n",0.0,0);//两个乘数中有一个为0，则结果为0
	   else
	   {
		    nu=nu1*nu2;     //尾数相乘
	        n=len1+len2;   //阶码相加，有待进一步处理，应首先判断相加是否溢出，然后再相加：实现方法为在两阶码同为正或负时if((length(最大长度)-abs(len1))<abs(len2))则溢出，否则不溢出
            if(n>999999999||n<-1000000000)//在此只做简单处理，使用了小于n的最大值的数来做判断条件
			{
				 if(n>0)
				 {
					 printf("结果上溢错误！\n");
				     return;
				 }
				 else
				 {
                   	 printf("结果下溢！\n");
					 printf("%d",0);//直接把结果作0处理
				     return;
				 }
			}
		  else
			{
	          if(fabs(nu)<0.1)   //需要对结果进行规格化,结果只能是纯小数所以只考虑左规不考虑右规；
				{
		          for(;fabs(nu)<0.1;)
				  {
				    if(n==-1000000000)
					{
				      printf("结果下溢近似为0：\n");
				      printf("%d",0.0);
		              break ;
					}
			       else
				   {
			         nu=nu*10;
		             n--;
				   }
				  }
			  }
			 printf("%f+E%d\n",nu,n);
		  }
		  
	   }
	      
   }
 if(op==4)
  {  
	 if(nu1==0&&nu2!=0)
         printf("%f+E%d\n",0.0,0);     //被除数为0，结果为0
     if(nu2==0)
		 printf("除数为零，出错!!!!"); //除数为0，操作错误，提示出错不必真正计算
     else {
	        nu=nu1/nu2;
	        n=len1-len2;   //阶码相减，有待进一步处理，应首先判断相加是否溢出，然后再相加：实现方法为在两阶码异号时if((length(最大长度)-abs(len1))<abs(len2))则溢出，否则不溢出；这里只做简单处理
            if(n>999999999||n<-1000000000)
			  {
				 if(n>0)
				 {
					 printf("结果上溢错误，超过了计算机的表示范围！\n");
				     return;
				 }
				 else
				 {
                   	 printf("结果下溢！\n");
					 printf("%d",0);
				     return;
				 }
			  }
		    else     //没有溢出
			{
	         
			 if(fabs(nu)<0.1)   //对结果进行规格化处理
			   {
		         for(;fabs(nu)<0.1;)
				 {
			       if( n==-1000000000)
				   {
				      printf("结果下溢：\n");
				      printf("%d",0);
		              break ;
				   }
			      else
				  {
			        nu=nu*10;
		            n--;
				  }
				 }
			   } 
            if(fabs(nu)>=1.0)
			{
		      if(n==999999999)
			  {
				 printf("结果上溢，错误!!!\n");
		         break ;
			  }
			 else
			 {
		      nu=nu/10;
		      n++;
			 }
			}
		  printf("%f+E%d\n",nu,n);
		  }
	 }
 }
puts(" 要继续操作吗?如果继续输入 1 ,否则按 0 \n");
scanf("%d",&temp);
}while(temp==1);
}
void inputs()
{
	puts("********************************************************************************");
	puts("NOTICE：1.  输入时不能输入非数值型字符! \n");
	puts("        2.  输入时为了扩大表示范围可以在输入浮点数的基础上再输入阶码!\n");
  	puts("        3.  输入为浮点数,小数点后6位有效数字;阶码为整数！\n");
	puts("        4.  为了处理方便当阶码<-1000000000或〉999999999时作溢出处理 !\n");
	puts("             实际的整型数的范围为-2147483648---2147483647(32位机)!\n");
	puts("********************************************************************************");
	printf("请输入包含符号位的参数1:\n");     
	scanf("%f",&nu1);
	printf("请输入阶码:\n");
    scanf("%d",&len1);
	puts("请输入操作符：1 (+) 2(-) 3(*) 4(/)");
	scanf("%d",&op);
    while(op!=1&&op!=2&&op!=3&&op!=4)
	{
	puts("没有此运算，请确认后再重新输入.....");
	puts(" *****************************************************************************\n");
	scanf("%d",&op);
	}
    printf("请输入包含符号位的参数2:\n");
	scanf("%f",&nu2);
    printf("请输入阶码:\n");
    scanf("%d",&len2);
}
//格式化操作部分
void format_nu()
{
	printf("对输入数据进行规格化.....\n");
    if(len1<-1000000000||len1>999999999)
		   {printf("你的输入其阶码已超过了本计算机可表示的范围，请重新输入本计算机可处理范围的数据..\n");
            printf("对于给你造成的不便请原谅!你的此次输入无效:请输入 0 重新开始操作！\n");//改进可以设置一标志量，用一程序来检测，程序运行机器的整型数的表示范围，再自动填入此处即可
			return;
		   } 
    else if(len2<-1000000000||len2>999999999)
			{printf("你的输入其阶码已超过了本计算机可表示的范围，请重新输入本计算机可处理范围的数据..\n");
             printf("对于给你造成的不便请原谅!你的此次输入无效:请输入 0 重新开始操作！\n");//改进可以设置一标志量，用一程序来检测，程序运行机器的整型数的表示范围，再自动填入此处即可
			 return;}
	else{
          if(nu1==0)
	         nu1=0;
          else
		  { 
			while(fabs(nu1)>=1)
			  {
				if(len1>=999999999)  //阶码为正数时需判断，负数是阶码加不需判断，不会溢出。
				{printf("你的输入其阶码已超过了本计算机可表示的范围，请重新输入本计算机可处理范围的数据..\n");
                 printf("对于给你造成的不便请原谅!你的此次输入无效:请输入 0 重新开始操作！\n");//改进可以设置一标志量，用一程序来检测，程序运行机器的整型数的表示范围，再自动填入此处即可
				}
			else{
					nu1=nu1/10;
		            len1=len1+1;
				}
			  }
	        while(fabs(nu1)<0.1)
			{
		      if(len1<-1000000000)
			  {
				 printf("你的输入其阶码已超过了本计算机可表示的范围，请重新输入本计算机可处理范围的数据..\n");

                 printf("对于给你造成的不便请原谅!你的此次输入无效:请输入 0 重新开始操作！\n");//改进可以设置一标志量，用一程序来检测，程序运行机器的整型数的表示范围，再自动填入此处即可
				 
			  }
		   
		     else
			 {
			    nu1=nu1*10;
		        len1=len1-1;
			 }
			}
		  }
        if(nu2==0)
	         nu2=0;
        else
		{
			while(fabs(nu2)>=1)  
			  {
				if(len2>=999999999)    //阶码为正数时需判断，负数是阶码加不需判断，不会溢出。
				{printf("你的输入其阶码已超过了本计算机可表示的范围，请重新输入本计算机可处理范围的数据..\n");
                 printf("对于给你造成的不便请原谅!你的此次输入无效:请输入 0 重新开始操作！\n");//改进可以设置一标志量，用一程序来检测，程序运行机器的整型数的表示范围，再自动填入此处即可
				}
			else{
					nu2=nu2/10;
		            len2=len2+1;
				}
			  }
           while(fabs(nu2)<0.1)
		   {   
		    	if(len2<-1000000000)
				{
				   printf("你的输入其阶码已超过了本计算机可表示的范围，请重新输入本计算机可处理范围的数据..\n");

                   printf("对于给你造成的不便请原谅!你的此次输入无效:请输入 0 重新开始操作！\n");//改进可以设置一标志量，用一程序来检测，程序运行机器的整型数的表示范围，再自动填入此处即可
				} 
		    	else
				 
				{
				nu2=nu2*10;
		        len2=len2-1;
				}
		   }
		} 
	}
}