浮点数的加减运算

最新推荐文章于 2024-01-31 16:02:21 发布
最新推荐文章于 2024-01-31 16:02:21 发布
阅读量656 收藏
点赞数 3
分类专栏： 课设
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/duling2/article/details/80858732
版权 
改正：https://blog.csdn.net/duling2/article/details/80788690
#include <iostream>
#include <bitset>
#include <string>
#include <conio.h>
#include <QString>
using namespace std;

const int n=28;

//右移几位 谁右移
std::bitset<n> RightMove
(int RightMoveBit/*右移几位 */,std::bitset<n> WhoRightMove/*谁右移*/)
{
    std::bitset<n> Result;

    WhoRightMove >>=RightMoveBit;

    Result=WhoRightMove;

    return Result;
}

//保存右移时 移出去的位数
std::bitset<n> SaveRightMoveOutBIt
(int RightMoveBit/*右移几位 */,std::bitset<n> WhoRightMove/*谁右移*/,
 int SavedNumber/*以前有保存过的位数*/,std::bitset<n> HasSavedBit)
{
    //以前有右移的话，HasSavedBit里是有东西的
    std::bitset<n> Result;
    int i=0;

    if(SavedNumber>0)
    {
        for(i=0;i<RightMoveBit;i++)
        {
            Result[i]=WhoRightMove[i];
        }
        Result <<=SavedNumber;
        for(i=0;i<SavedNumber;i++)
        {
             Result[i]=HasSavedBit[i];
        }
    }else
    {
        for(i=0;i<RightMoveBit;i++)
        {
            Result[i]=WhoRightMove[i];
        }
    }
    return Result;
}

//取反加1
std::bitset<n> Invert
(int BitNumber/*取反几位*/,std::bitset<n> WhoInvert/*谁取反*/,bool JiaYi)
{
    std::bitset<n> Result;
    std::bitset<n> yihuo;
    int i=0,j=0;
    bool HasAdd=false;
    bool Over=false;

    for(int i=0;i<BitNumber;i++)
    {
          yihuo.set(i);
    }

   std::cout<<"WhoInvert:\t\t\t"<<WhoInvert<<"\n";
   std::cout<<"yihuo:\t\t\t\t"<<yihuo<<"\n";
   WhoInvert=WhoInvert^yihuo;//异或
   std::cout<<"WhoInvert:\t\t\t"<<WhoInvert<<"\n";

 /这里可以设个标志  加不加1//
if(JiaYi)
{
    //加1
    HasAdd=false;
    Over=false;
    i=0;
    j=0;
    while(i<WhoInvert.size())
    {
        if(!HasAdd)
        {
            //1
            if(WhoInvert.test(i))
            {
                WhoInvert.set(i,0);
                HasAdd=true;
                i++;
                continue;
            }else
            {//0
                WhoInvert.set(i);
                HasAdd=false;
                i++;
                break;
            }
        }else
        {
            //1
            if(WhoInvert.test(i))
            {
                WhoInvert.set(i,0);
                HasAdd=true;
                i++;
                if(i>=WhoInvert.size())
                        Over=true;
                continue;
            }else
            {//0
                WhoInvert.set(i);
                HasAdd=false;
                i++;
                break;
            }
        }
    }
    if(Over)
        std::cout<<"yichu\n";
}
    Result=WhoInvert;
    return Result;
}


//两个数连同符号位相加
std::bitset<n> AddTogether
(int Count/*输入补码的长度，超过将丢弃*/,std::bitset<n> GetOne,std::bitset<n> GetSecond)
{

    //两个数连同符号位相加
    bool HasAdd=false;
    bool Over=false;
    int i=0;
    int j=0;
    std::bitset<n> Result;

    while(i<Count)
    {
        if(!HasAdd)
        {
            //两个都是1
            if(GetSecond.test(i)&&GetOne.test(i))
            {
                Result.set(i,0);
                HasAdd=true;
                i++;
                continue;
            }else   if(!GetSecond.test(i)&&!GetOne.test(i))
            {//两个都是 0
                Result.set(i,0);
                HasAdd=false;
                i++;
                continue;
            }else
            {
                Result.set(i);
                HasAdd=false;
                i++;
                continue;
            }
        }else
        {
            //两个都是1
            if(GetSecond.test(i)&&GetOne.test(i))
            {
                Result.set(i);
                HasAdd=true;
                i++;
                if(i>=GetSecond.size())
                    Over=true;
                continue;
            }else   if(!GetSecond.test(i)&&!GetOne.test(i))
            {//两个都是 0
                Result.set(i);
                HasAdd=false;
                i++;
                continue;
            }else
            {
                Result.set(i,0);
                HasAdd=true;
                i++;
                if(i>=GetSecond.size())
                    Over=true;
                continue;
            }
        }
    }
    if(Over)
        std::cout<<"yichu\n";


    return Result;
}

//减1操作
std::bitset<n> SubOne
(int Count/*要操作的位数*/,std::bitset<n> Source)
{
    std::bitset<n> Result=Source;
    bool JieWei=false;
    bool Over=false;
    int i=0;

    while(i<Count)
    {
        if(!JieWei)
        {
            if(Result.test(i))
            {
                Result.set(i,0);
                JieWei=false;
                i++;
                break;
            }else
            {
                Result.set(i,1);
                JieWei=true;
                 i++;
                continue;
            }
        }else
        {//被借位了
            if(Result.test(i))
            {
                Result.set(i,0);
                JieWei=false;
                 i++;
                break;
            }else
            {
                Result.set(i,1);
                JieWei=true;
                 i++;
                if(i>=Count)
                    Over=true;
                continue;
            }
        }
    }//while

    if(Over)
        std::cout<<"jie wei jie chu jie le\n";
    return Result;
}

std::bitset<n>
AddOne(int Count/*要操作的位数*/,std::bitset<n> Source)
{
    std::bitset<n> Result=Source;
    bool HasAdd=false;
    bool Over=false;
    int i=0;

    while(i<Count)
    {
        if(!HasAdd)
        {
            if(Result.test(i))
            {
                Result.set(i,0);
                HasAdd=true;
                i++;
                continue;
            }else
            {
                Result.set(i,1);
                HasAdd=false;
                 i++;
                break;
            }
        }else
        {//进位了
            if(Result.test(i))
            {
                Result.set(i,0);
                HasAdd=true;
                i++;
                if(i>=Count)
                    Over=true;
                continue;
            }else
            {
                Result.set(i,1);
                HasAdd=false;
                 i++;
                break;
            }
        }
    }//while

    if(Over)
        std::cout<<"jing wei jie chu jie le\n";
    return Result;
}

int main ()
{
    std::string strj1;
    std::string strj2;
    std::string strw1;
    std::string strw2;
    std::bitset<n> b_j1;
    std::bitset<n> b_j2;
    std::bitset<n> b_QiuFu_j2;
    std::bitset<n> b_QiuFu_w2;
    std::bitset<n> b_w1;
    std::bitset<n> b_w2;
    std::bitset<n> b_Save_Outw;//保存右移出的位
    std::bitset<n> b_Temp_j;//b_j1 b_j2 计算结果的中间变量
    std::bitset<n> b_Temp_w;//b_w1 b_w2 计算结果的中间变量
    std::bitset<n> b_Result_j;//结果阶码
    std::bitset<n> b_One;

    int i,j;
    int jCout=0;  //用来判断符号位
    int wCount=0;//输入尾数总的字数个数
    int RightMoveWhichWei=2;//0 w1移  1 w2移  2不移
    int RightMoveBit=0;//右移的位数

    b_One.set(0);//b_One是个常量   最后一个是1   000000****1


     std::cout<<"qin shu ru deng chang de bu ma zuo wei jie ma\n";

    //得到string  补码
    std::cin>>strj1;
    std::cin>>strj2;
    //赋值给bitset
    b_j1=std::bitset<n>(strj1);
    b_j2=std::bitset<n>(strj2);

    //一定要保证输入的两阶码是等长双符号位
    jCout=strj1.size();
  //  std::cout<<jCout;

    //都存在1 即0操作数检查
    if(b_j1.any()&&b_j2.any())
        std::cout<<"b_j1 any  && b_j2 any\n";
对阶//
    //对阶
    //计算相差
    //因为输入的要求是双符号等长补码
    //所以直接对第二个数连同符号位取反加1

    //取反加1
    b_QiuFu_j2=Invert(jCout,b_j2,true);

    std::cout<<"b_QiuFu_j2:\t\t\t"<<b_QiuFu_j2<<"\n";
    std::cout<<"b_j1:\t\t\t\t"<<b_j1<<"\n";
    //相加 得出双符号位阶差  只加到符号位最高位，超过将丢弃
    b_Temp_j=AddTogether(jCout,b_j1,b_QiuFu_j2);

    std::cout<<"b_Temp_j:\t\t\t"<<b_Temp_j<<"\n";
    //判断有没溢出
    if(b_Temp_j.test(jCout-1)&&b_Temp_j.test(jCout-2))
        std::cout<<"mei you yi chu\n";
    else if (!b_Temp_j.test(jCout-1)&&!b_Temp_j.test(jCout-2))
        std::cout<<"mei you yi chu\n";
    else
    {
            std::cout<<"yi chu le\n";
            getch();
            getch();
            return 0;
    }

    /这里溢出了的话，下面就进行不了了


    //阶码是负的 //除符号位  先减1再取反
    //这里得到了尾数要右移的位数
    if(b_Temp_j.test(jCout-1)&&b_Temp_j.test(jCout-2))
    {//阶码是负数
        //除符号位  先减1再取反
        b_Temp_j[jCout-1]=0;
        b_Temp_j[jCout-2]=0;
        b_Temp_j=SubOne(jCout,b_Temp_j);
        b_Temp_j=Invert(jCout-2,b_Temp_j,false);
        RightMoveWhichWei=0;//第一个尾数将右移
    }else if(!b_Temp_j.test(jCout-1)&&!b_Temp_j.test(jCout-2)&&b_Temp_j.to_ulong())
    {
         RightMoveWhichWei=1;//第二个尾数将右移
    }

    std::cout<<"b_Temp_j:\t\t\t"<<b_Temp_j<<"\n";
    RightMoveBit=b_Temp_j.to_ulong();
    std::cout<<"RightMoveBit:\t\t\t"<<RightMoveBit<<"\n";

 尾数求和求差///

    //要求双符号位等长尾数
    //得到string
     std::cout<<"qin shu ru deng chang de bu ma zuo wei Wei shu\n";
    std::cin>>strw1;
    std::cin>>strw2;
    //赋值给bitset
    b_w1=std::bitset<n>(strw1);
    b_w2=std::bitset<n>(strw2);

    wCount=strw1.size();
    std::cout<<"\nwCount\t\t\t"<<wCount<<"\n";

    if(0==RightMoveWhichWei)
    {   //第一个尾数右移  右移符号位之后的东西           //第一个数的阶码将加1   RightMoveBit次
        for(i=0;i<RightMoveBit;i++)
        {
        std::cout<<"\nb_Onej1 fin\t\t"<<b_j1<<"\n";
        b_j1=AddTogether(jCout,b_j1,b_One);
        std::cout<<"\nb_Onej1 fout\t\t"<<b_j1<<"\n";
        }
        std::cout<<"\nb_Onej1\t\t"<<b_j1<<"\n";
        b_Result_j=b_j1;
        // 保存右移出的位
        b_Save_Outw=SaveRightMoveOutBIt(RightMoveBit,b_w1,0,NULL);
        b_w1=RightMove(RightMoveBit,b_w1);
         std::cout<<"\nb_Save_Outw\t\t"<<b_Save_Outw<<"\n";
         std::cout<<"b_w1\t\t\t"<<b_w1<<"\n";
         std::cout<<"b_w2\t\t\t"<<b_w2<<"\n";
    }else if(1==RightMoveWhichWei)
    {
        //第二个尾数右移   右移符号位之后的东西    //第二个数的阶码将加1   RightMoveBit次
        for(i=0;i<RightMoveBit;i++)
        {
            std::cout<<"\nb_Onej2 fin\t\t"<<b_j2<<"\n";
            b_j2=AddTogether(jCout,b_j2,b_One);
            std::cout<<"\nb_Onej2 fout\t\t"<<b_j2<<"\n";
        }
        std::cout<<"\nb_Onej2\t\t\t"<<b_j2<<"\n";
        b_Result_j=b_j2;
        // 保存右移出的位
        b_Save_Outw=SaveRightMoveOutBIt(RightMoveBit,b_w2,0,NULL);
        b_w2=RightMove(RightMoveBit,b_w2);
        std::cout<<"\n2b_Save_Outw\t\t"<<b_Save_Outw<<"\n";
        std::cout<<"2b_w1\t\t\t"<<b_w1<<"\n";
        std::cout<<"2b_w2\t\t\t"<<b_w2<<"\n";
    }else if(2==RightMoveWhichWei)
    {//尾数即不左移 也不右移  说明阶码一样大
        b_Result_j=b_j1;
    }


# if 1
    //加法
    b_Temp_w=AddTogether(wCount,b_w1,b_w2);
    std::cout<<"b_Temp_w\t\t"<<b_Temp_w<<"\n";
#endif

# if 0
    //减法
    //对第二个数连同符号位取反加1
    //如果是第二个数右移了   因为右移了，所以位数也减了(要用到异或)
    if(1==RightMoveWhichWei)
        b_QiuFu_w2=Invert(wCount-RightMoveBit,b_w2,true);
    else
        b_QiuFu_w2=Invert(wCount,b_w2,true);
    std::cout<<"b_QiuFu_w2\t\t"<<b_QiuFu_w2<<"\n";
    std::cout<<"b_w1\t\t\t"<<b_w1<<"\n";
    b_Temp_w=AddTogether(wCount,b_w1,b_QiuFu_w2);
    std::cout<<"b_Temp_w\t\t"<<b_Temp_w<<"\n";
#endif
/规格化///


    i=wCount;
    j=RightMoveBit;
 while(b_Temp_w[i-1]==b_Temp_w[i-3]&&b_Temp_w[i-1]==b_Temp_w[i-2])
{//左规 符号位与最高数值位不同
        b_Temp_w[i-1]=0;//去除最高位
        b_Temp_w <<= 1;//左移一位
        //阶码减1一次
        b_Result_j=SubOne(jCout,b_Result_j);
        std::cout<<"zuo gui b_Result_j\t\t"<<b_Result_j<<"\n";

        //将前面右移出去的位补回来 如果需要
        if(j>=0)
        {
            b_Temp_w[0]=b_Save_Outw[j-1];
            b_Save_Outw[j-1]=0;  //将补出去的位置0
            b_Save_Outw <<=1;  //左移 即与RightMoveBit对应
            std::cout<<"zuo gui b_Save_Outw\t\t"<<b_Save_Outw<<"\n";
            j--;
        }
        std::cout<<"zuo gui b_Temp_w\t\t"<<b_Temp_w<<"\n";
}//while

 i=wCount;
 while(b_Temp_w[i-1]!=b_Temp_w[i-2])
 {//右规  符号位不同
         // 保存右移出的位
          b_Save_Outw=SaveRightMoveOutBIt(1,b_Temp_w,RightMoveBit,b_Save_Outw);
          RightMoveBit++;
          b_Temp_w >>= 1;//右移一位
          std::cout<<"you gui b_Save_Outw\t\t"<<b_Save_Outw<<"\n";
          std::cout<<"you gui b_Temp_w\t\t"<<b_Temp_w<<"\n";
          //阶码加1一次
          b_Result_j=AddOne(jCout,b_Result_j);
          std::cout<<"you gui b_Result_j\t\t"<<b_Result_j<<"\n";
 }


/舍入处理/
 std::cout<<"\n\nshe rv chu li\t\t\n";
 //0舍1入 尾数加1一次
 if(RightMoveBit!=0)//有右移
 if(b_Save_Outw.test(RightMoveBit-1))//最高位为1
    b_Temp_w=AddOne(wCount,b_Temp_w);

 std::cout<<"b_Temp_w\t\t"<<b_Temp_w<<"\n";

//再规格化
 i=wCount;
 j=RightMoveBit;
while(b_Temp_w[i-1]==b_Temp_w[i-3]&&b_Temp_w[i-1]==b_Temp_w[i-2])
{//左规 符号位与最高数值位不同
     b_Temp_w[i-1]=0;//去除最高位
     b_Temp_w <<= 1;//左移一位
     //阶码减1一次
     b_Result_j=SubOne(jCout,b_Result_j);
     std::cout<<"zuo gui b_Result_j\t\t"<<b_Result_j<<"\n";

     //将前面右移出去的位补回来 如果需要
     if(j>=0)
     {
         b_Temp_w[0]=b_Save_Outw[j-1];
         b_Save_Outw[j-1]=0;  //将补出去的位置0
         b_Save_Outw <<=1;  //左移 即与RightMoveBit对应
         std::cout<<"zuo gui b_Save_Outw\t\t"<<b_Save_Outw<<"\n";
         j--;
     }
     std::cout<<"zuo gui b_Temp_w\t\t"<<b_Temp_w<<"\n";
}//while

i=wCount;
while(b_Temp_w[i-1]!=b_Temp_w[i-2])
{//右规  符号位不同
      // 保存右移出的位
       b_Save_Outw=SaveRightMoveOutBIt(1,b_Temp_w,RightMoveBit,b_Save_Outw);
       RightMoveBit++;
       b_Temp_w >>= 1;//右移一位
       std::cout<<"you gui b_Save_Outw\t\t"<<b_Save_Outw<<"\n";
       std::cout<<"you gui b_Temp_w\t\t"<<b_Temp_w<<"\n";
       //阶码加1一次
       b_Result_j=AddOne(jCout,b_Result_j);
       std::cout<<"you gui b_Result_j\t\t"<<b_Result_j<<"\n";
}



 /判溢出/
  std::cout<<"\n\npang duan yi chu\t\t\n";
if((0==b_Result_j[jCout-1]&&0==b_Result_j[jCout-2])
        ||(1==b_Result_j[jCout-1]&&1==b_Result_j[jCout-2]))
{
    //没有溢出
    std::cout<<"RightMoveBit\t\t"<<RightMoveBit<<"\n";
     std::cout<<"b_Save_Outw\t\t"<<b_Save_Outw<<"\n";
     std::cout<<"b_Temp_w\t\t"<<b_Temp_w<<"\n";
     std::cout<<"b_Result_j\t\t"<<b_Result_j<<"\n";

}else if(0==b_Result_j[jCout-1]&&1==b_Result_j[jCout-2])
{
    //上溢
     std::cout<<"上溢\t\t\n";


}else if(1==b_Result_j[jCout-1]&&0==b_Result_j[jCout-2])
{
    //下溢
    b_Temp_w.reset();
    b_Result_j.reset();
    std::cout<<"b_Temp_w\t\t"<<b_Temp_w<<"\n";
    std::cout<<"b_Result_j\t\t"<<b_Result_j<<"\n";
}


    getch();
    getch();
    return 0;
}
duling2
关注
专栏目录
(王道计算机组成原理)第二章数据的表示和运算-第三节3：浮点数加减运算
快乐江湖的博客
08-10 2178
文章目录一：以十进制下的科学计数法的加减运算为例说明浮点数加减运算二：浮点数的加减运算（不舍入） 一：以十进制下的科学计数法的加减运算为例说明浮点数加减运算 比如有浮点数9.85211×1012+9.96007×10109.85211×10^{12}+9.96007×10^{10}9.85211×1012+9.96007×1010，其运算基本步骤如下 1：对阶 所谓对阶就是对齐两个浮点数的阶数，由于计算机内部尾数是定点小数，所以对阶是一律向大阶看其 也即9.85211×1012+0.0996007×1010
计算机组成原理——浮点数加减运算&强制类型转换
流楚丶格念的博客
05-14 3786
文章目录浮点数的加减运算十进制浮点数加减运算步骤：二进制浮点数的加减运算1. 对阶2. 尾数加减3. 规格化4. 舍入5. 判溢出浮点数的加减运算——舍入规则“0”舍“1”入法：恒置“1”法：强制类型转换转化的可操作性 浮点数的加减运算 我们可以先通过十进制的浮点数加减运算步骤来类推二进制的 十进制浮点数加减运算步骤： 浮点数加减运算包括五个步骤：① 对阶② 尾数加减③ 规格化④ 舍入⑤ 判溢出 例如：计算9.85211 × 1012 + 9.96007 × 1010 解： 二进制浮点数的加减运算 上面我们
浮点数减法运算
05-26
linux下实现的浮点数精确计算，可以实现小数位借位
浮点数的加减法运算
foolish_one
03-06 2101
浮点数的加法运算分为六个步骤： 1> 真值到机器数的转化（补码） 2> 对阶 3> 尾数加减 4> 结果规格化 5> 舍入处理 6> 溢出判断 我们先来看一个例子( 干八八的讲是在不好 X = -5/256, Y = +59/1024，按照补码运算规则计算 X-Y?，其中阶符占2位，阶码占3位，数符占2位，尾数占9位。 1> 真值到机器数的转化 -5(D)...
浮点数加、减运算步骤
最新发布
gghhb12的博客
01-31 3163
精度位数格式单精度 float4个字节32位符号位1位，阶码8位，尾数23位双精度 double8个字节64位符号位1位，阶码11位，尾数52位1.2 浮点的表示方法浮点数在机器中的形式如下所示，采用这种数据格式的机器称为浮点机浮点数由阶码j和尾数S两部分组成，阶码是整数，阶符和阶码的位数m合起来反应浮点数的表述范围及小数点的实际位置；尾数是小数，其位数n反映了浮点数的精度，数符表示浮点数的正负。1.3 浮点数表示范围。
浮点数加减运算器.zip
05-12
浮点数加法、减法运算器 根据浮点数的四则运算规则，实现浮点数的加法、减法运算器。 浮点数的格式：阶码4位（包含2位符号位,2位数值位），尾数8位（包含2位符号位，6位数值位），阶码和尾数都用补码表示。要求完整...
计算机组成与原理运算器之浮点数加减运算.txt
12-15
本资源用于研究运算器实现的浮点数的加减运算，里面有比较详细的步骤以及注意事项，另外我的博客上也有相关解说，需要的小伙伴可以前往观看！谢谢
float_sub_add.rar_浮点数_浮点数 加减_浮点数加减_浮点数运算_浮点运算
09-21
浮点数在计算机科学中扮演着至关重要的角色，特别是在数值计算、科学计算和图形处理等领域。...通过阅读和分析"float_sub_add.rar"中的源代码，我们可以深化对浮点数加减运算的理解，并学习如何在实践中实现这些运算。
浮点数的加减法运算过程详解（面向小白的）
热门推荐
qq_40663469的博客
04-07 5万+
浮点数的加减法运算过程详解（面向小白的）一. 浮点数在计算机内的表示二. 浮点数的加减运算步骤 第一次写博客，难免有疏漏之处，如果有错误请批评指正，感谢！ 对于浮点数的加减运算，书上写的名词太多，例子过程不太详细，面对查到的博客也有这种感觉，想明白后准备写个博客加深一下印象，也可能帮助到其他人。 一. 浮点数在计算机内的表示 1.定点数：小数点固定在某个位置不动的数据。 有两种可能的表示方法（第一...
计算机组成原理15-浮点数的加减法运算
swadian2008的博客
01-12 1万+
目录 一、对阶 二、规格化 1、规格化的判断 2、如何进行规格化 （1）左归 （2）右归 三、舍入 （1）0舍1入法 （2）置1法 四、溢出判断 浮点数的加减法运算步骤： 对阶，使得两数的阶数位置对齐 尾数求和，将对阶后的尾数按定点加减运算规则求和/差 规格化，将求和/差后的尾数进行规格化 舍入，为提高精度，要考虑尾数右移时丢失的数值位 溢出判断，即判断结果是否溢出 一、对阶 类比平常我们用到的带阶数的加减法，我们常常会把两个数的阶数转化为一致，再针对尾数进行加减法运算，计
计算机原理--浮点数的加减法运算
weixin_43871658的博客
08-24 757
浮点数的加减法对阶尾数求和尾数规格化溢出判断 对阶 对阶的目的是使得两个浮点数阶码一致，使得尾数可以进行运算 浮点数尾数运算简单 浮点数位数实际小数位与阶码有关 阶码按小阶看齐大阶的原则 尾数求和 使用补码进行运算 减法运算转化为加法运算：A-B = A+（-B） 尾数规格化 对补码进行规格化需要判断两种情况：S>0和S<0 如果不满足此格式（符号位与最高位不一致），需要进行左移，同时阶码相应变化，以满足规格化 一般情况下都是左移 双符号位不一致下需要右移（定点运算的溢出情况） 右移的
计算机组成原理：浮点数的加、减、乘、除运算（含实例完整运算）
m0_51783792的博客
04-06 3万+
浮点数的加减运算 零操作数的判断 一个操作数为零，也不必计算，节省时间 若加数或被加数其中有 0，则等于其中不为0 的那个数；若全为 0 则等于 0 若被减数为 0，则等于减数的相反数 ；若减数为 0，则等于被减数 ,若全为0则等于0 对阶操作 以阶码加大（绝对值）的为标准，阶码较小的 向较大的对齐 目的：计算机中的浮点数定点表示时小数点的位置是固定的，在小数的数值位的最前面，为了避免阶码较大的浮点数尾数左移导致最高位的丢失 如x 的阶码为 Ex=010，y的阶码Ey=1...
浮点数的加减法
weixin_53364209的博客
03-14 1123
#include <stdio.h> #include <malloc.h> #include <stdlib.h> #include <string.h> #include <math.h> //计算机组成原理作业：浮点数的加减法 //************ 二进制整数 ************ //由真值求补码（二进制整数） void trueInt_to_twocomplement(char* bin); //由补码求真值（二进制整数）.
浮点数加（减）法、乘法、除法运算
whocarea的博客
03-25 5441
IEEE754标准规定了3种浮点数格式：单精度、双精度与扩展精度 IEEE754标准从逻辑上用三元组{S,E,M}表示一个数N，对于双精度而言，其编码格式为1位符号位，11位阶码和52位尾数 N = (-1)^S x 2^(E-1023) x (1.M) 1、浮点数的加减法运算 加减法的本质相同，减法可以通过对减数的符号位取反变为加法。浮点数加法器一般运算规则是： a.指数相减：将两个指...
浮点数加减运算
mathor的博客
10-29 2万+
浮点运算要把阶码和尾数分别处理。 阶码的运算是定点整数运算，对阶码的运算四种：阶码加1，阶码减1，两阶码求和，两阶码求差。 尾数的运算是定点小数运算，运算过程中一般取双符号位 浮点运算器总是由处理阶码和处理尾数的两部分组成 浮点数的溢出(Overflow) 当一个数的大小超出了浮点数的表示范围时，机器无法表示该数，就发生溢出。浮点数的溢出判断方法与定点数不同，是对规格化数的阶码进行判断。 当浮点数...
浮点的加减计算方法
weixin_42454243的博客
03-24 2万+
浮点的计算方法1、计算步骤2、基本要素2.1 浮点数2.2 规格化浮点数2.3 偏置指数一、pandas是什么？二、扩展：乘除计算步骤 1、计算步骤 浮点数格式： 单精度：符号位1位，阶码8位，尾数23位 双精度：符号位1位，阶码11位，尾数52位 阶码是移码表示 浮点数的加减运算的五个步骤：对阶、尾数运算、规格化、舍入（要求使用对偶舍入）（0舍1入）、溢出判断。 对阶：小阶向大阶转换，对完阶后浮点数组成为大阶码+尾数；尾数相加用新的尾数（包括低位移出的位数） 规格化：（保证小数点左右两边不同，可能规格
浮点数加减运算：溢出判断与处理
本文主要探讨了浮点数加减运算中的结果溢出判断以及运算方法，涉及到了运算器的相关知识。在计算机系统中，浮点数的运算比定点数复杂，因为它们的小数点位置是浮动的，可以表示更大的数值范围。 浮点数运算的关键...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值