精华内容
下载资源
问答
  • 该工具为单精度与双精度浮点转换成十进制,或者十进制转换为单精度或双精度的工具,可以验证你的计算方法是否错误。
  • IEEE 754 格式转换工具, 十六进制 与 双精度浮点型 格式转换
  • int与hex互转,double、float与hex互转,string与hex互转,个人总结,不需要积分。
  • 双精度浮点数转换

    热门讨论 2013-08-19 17:24:54
    双精度浮点数、单精度浮点数与十六进制,二进制之间可以进行任意转换
  • S7-200SMART 双精度浮点型数据转换为单精度浮点型的方法
  • 浮点数和十六进制数的相互转换,包括:1.单精度浮点数(32位)和十六进制数的相互转换,2.双精度浮点数(64位)和十六进制数的相互转换
  • 1、在发送端定义一个发送数据 a = 12; 2、与网络通信助手连接后,生成的hex值为:0C 00 00 00 ...该如何编写接收端的代码才能才能把双精度浮点型的数据转换成十进制数据? 请大佬们帮忙!感谢!欢迎交流!
  • 本代码将双精度浮点数转换为单精度浮点数,适合浮点数为正值的转换。 使用后将占用VD2810~VD2970字节,欢迎交流。 本代码的完成经历了一段时间的刻苦研究,无偿提供给真正需要的人,希望同行少走弯路。 代码允许复制...
  • 单精度双精度浮点数转换

    热门讨论 2013-05-02 12:36:32
    单精度双精度浮点数转换,浮点数与16进制转换工具
  • 二进制,十进制,十六进制,单双精度浮点转换
  • #资源达人分享计划#
  • 浮点数转换工具

    2017-03-10 15:24:35
    支持单精度、多精度浮点数与十六进制、十进制、二进制整数之间的转换
  • 单、双精度浮点数与16进制相互转换,文档中已列出相应函数,可直接调用。
  • 包含数字的字符可以使用 char.GetNumericValue 方法转换为数字(双精度浮点型)。 代码如下: double d = char.GetNumericValue('5'); Console.WriteLine(d); 输出值:5 那么,为什...

    目录:https://www.cnblogs.com/liqingwen/p/10261436.html

    包含数字的字符可以使用 char.GetNumericValue 方法转换为数字(双精度浮点型)。

    代码如下:

      double d = char.GetNumericValue('5');
      
      Console.WriteLine(d);
    

    输出值:5

    那么,为什么当一个 char ,并且只能为单字符时,GetNumericValue 会返回一个单位数“数字”(“0”到“9”)的 double 变量呢?

    这是因为 char 保存 Unicode 字符,它可以容纳三分之二的 Unicode 字符。当这三分之二的 Unicode 字符与 GetNumericValue 方法一起使用时,返回值为:0.666666666666667。

    章节:Converting Chars to Doubles
    译书名:《C# 奇淫巧技 -- 编写更优雅的 C#》
    原书名:《C# Tips -- Write Better C#》
    网址:https://leanpub.com/cstips

    转载于:https://www.cnblogs.com/liqingwen/p/10269594.html

    展开全文
  • C++双精度浮点格式,仅供参考

    千次阅读 2019-12-26 11:10:43
    #include <stdlib.h> #include <stdio.h> #include <stdint.h> typedef union { double f; uint32_t i[2]; }Packet; #define M ((1<<20)-1) void test( double f) ......
    #include <stdlib.h>
    #include <stdio.h>
    #include <stdint.h>
    
    typedef union
    {
       double f;
       uint32_t i[2];
    }Packet;
    
    #define M  ((1<<20)-1)
    void test( double f)
    {
      Packet p;
      p.f=f;
      printf("f1 = %.16f ~= (1.0+%u/2^20)*2^%u\n", p.f, p.i[1]&M, (p.i[1]>>20)-1023 );
    }
    
    int main(int argc, char* argv[] )
    {
       double f;
       printf("Please input a double?");
       scanf("%lf",&f);
       test(f);
       return 0;
    }

    展开全文
  • 首先,float单精度浮点型,计算机会分配4字节,32位来进行存储,而double float双精度浮点型,计算机则会分配8个字节,即64位来进行小数的存储,这是后面进行详细解释的必备知识。 其次,计算机在存储浮点型数据时,...

    1问题的提出

    最近在学习过程中,遇到了题目中出现的陈述,但是对于原因没有头绪,同时在互联网上很难找的到合理的我想要的解释,因此我搜罗了一些前人的知识,结合自己的理解,总结一下。

    2问题的解释

    首先,float单精度浮点型,计算机会分配4字节,32位来进行存储,而double float双精度浮点型,计算机则会分配8个字节,即64位来进行小数的存储,这是后面进行详细解释的必备知识。
    其次,计算机在存储浮点型数据时,会将浮点型数据分为3个部分来进行存储(至于为什么,规定),分别为:
    (1)符号位(这个熟悉整型的二进制存储应该知道的,首尾二进制0表示正数,1表示负数,不多说,占一个字节);
    (2)指数部分(计算机使用浮点型存储时,会将源数据转换为科学计数法来存储,例如,8.25,转化为二进制为1000.01,然后转化为科学计数法,注意是2进制,将底数10换为2为,1.00001 × 2的3次方,指数为3,这个指数部分的数据就是存储着源10进制数据转换为2进制时科学计数法表示的指数相关,这里说的是相关,并不是存储着3,多说一句,这个指数部分的首位二进制表示着指数的正负,换句话说,1表示源十进制数的绝对值大于等于1,0表示小于1,更多了解,自行见文尾参考链接
    (3)尾部存储的是二进制科学计数法的所精确的小数数值(二进制存储),例如1.00001 × 2的3次方的00001,超出存储位数‘四舍五入’,不足位数补向左补0.
    具体float和double float见下图:
    float类型:
    在这里插入图片描述
    double float类型
    在这里插入图片描述
    至于其中的指数部分为什么是8和11,没法解释,这么设计的。
    即,符号位都是表示源十进制数据的正负,指数部分的首位都是0或1表示二进制科学计数法的指数正负,其余位数存储着和指数相关的值,最后尾数部分存储着二进制科学计数法的小数部分数值。
    因此,尾数部分决定着精确的实际能够存储的十进制数据位数精度:
    (1)单精度:23位能存储的数据量为2的(23+1)次幂为16777216,结果取10常用对数发现,在7和8之间,因此,精度最大不要超过7位小数,常常称为不要超过6位
    (2)双精度:相应地,对于双精度的64位存储,去掉首尾符号位1字节和指数部分的11字节,尾数的52字节能存储最大数据量为2的(52+1)次幂为9007199254740992,同样发现,最大的十进制小数位位数16~17之间,因此最好不要超过15位

    最后

    不知道大家有没有理解,下面是我发现写的非常好的文章,有更深度需求的同学可以参考。
    参考链接:https://www.cnblogs.com/Reverse-xiaoyu/p/11618913.html

    展开全文
  • FloatBin 浮点转换工具

    2020-11-26 10:00:30
    该软件可以将单精度(single)浮点数或双精度(double)浮点数转换成二进制、十进制、十六进制字节内码表示,也可以将字节内码转换浮点进行逆变换。不到1M的数据量,精简而不失实用性。全免费,无需注册,解压即...
  • 因为做机械臂项目需要提取机械臂坐标,所以当初为了把64位双精度浮点数转换为十六进制为可累死我了,看了挺多博客。但后来学长告诉我其实指针地址就是IEEE 754 16进制编码,C可以直接调用就不用写函数计算了,????...

    因为做机械臂项目需要提取机械臂坐标,所以当初为了把64位双精度浮点数转换为十六进制可累死我了,看了挺多博客。但后来学长告诉我其实指针地址就是IEEE 754 16进制编码,C可以直接调用就不用写函数计算了,😭还是自己见识少了。在此分享大家,避免跟我一样多花时间查找相关资料。

    原理可参考这里:IEEE 754 16进制编码转为64位双精度浮点数

    doubleToHex:
    #include<iostream>
    #include<stdio.h>
    using namespace std;
    int main()
    {
    	double x;
    	char str[16];
    	cout << "输入浮点数: ";
    	cin >> x;
    	sprintf(str, "%p", x);
    	cout << "十六进制编码:" << str << endl;
    }
    
    HexToDouble:

    找不到当时参考哪位大佬的了,在此谢谢大佬。我稍微把函数都封装成一个类。

    #include <iostream>
    #include <bitset>
    #include <cmath>
    #include <stdio.h>
    #include <string>
    using namespace std;
    
    class HexToDouble
    {
    public:
        static double putin(string temp1)
        {
            int i;
            string temp;
            temp = temp1;
            string S_Bin = "";//转化后的二进制字符串
        //cout<<temp.length()<<endl;//字符串长度16位
            for (int i = 0; i < temp.length(); i++)
            {
                char temp1 = temp[i];
                S_Bin = S_Bin + charToBin(temp1);//十六进制转二进制串
            }
    
            //  cout<<"转化后的二进制串 "<<S_Bin<<endl;//
            int sign = 0;//符号位
            if (S_Bin.at(0) == '1')//判断符号位
            {
                sign = 1;
            }
            string exponent = ""; //定义指数部分Exp
            for (i = 1; i < 12; i++)
            {
                if (S_Bin.at(i) == '1')
                {
                    exponent = exponent + '1';
                }
                else
                    exponent = exponent + '0';
            }
            int exponent_double = 0;//阶码
            exponent_double = stringToDouble(exponent);
            // cout<<"偏移位数 "<<exponent_double<<endl;
            exponent_double = exponent_double - 1023;//计算出偏移位数 ,64位双精度浮点数的偏置码为1023
           // cout<<"偏移位数 "<<exponent_double<<endl;
            string mantissa_temp = ""; //定义尾数部分Fraction
            for (i = 12; i < 64; i++)
            {
                if (S_Bin.at(i) == '1')
                {
                    mantissa_temp = mantissa_temp + '1';
                }
                else
                    mantissa_temp = mantissa_temp + '0';
            }
            double mantissa = 0;
            mantissa = BenToDex(mantissa_temp); //二进制串到double(小数)
          //  cout<<"小数点 "<<mantissa<<endl;
            mantissa = mantissa + 1.0;
            double res = 0;
            double a, c;
            a = pow((-1), sign);
            c = pow(2, exponent_double);
            res = a * mantissa * c;
            return res;
        }
        static string charToBin(char temp)//十六进制转二进制串
        {
            switch (temp)
            {
            case '0':
                return "0000";
                break;
            case '1':
                return "0001";
                break;
            case '2':
                return "0010";
                break;
            case '3':
                return "0011";
                break;
            case '4':
                return "0100";
                break;
            case '5':
                return "0101";
                break;
            case '6':
                return "0110";
                break;
            case '7':
                return "0111";
                break;
            case '8':
                return "1000";
                break;
            case '9':
                return "1001";
                break;
            case 'A':case 'a':
                return "1010";
                break;
            case 'B':case 'b':
                return "1011";
                break;
            case 'C':case 'c':
                return "1100";
                break;
            case 'D':case 'd':
                return "1101";
                break;
            case 'E':case 'e':
                return "1110";
                break;
            case 'F':case 'f':
                return "1111";
                break;
            default:
                return "WRONG!";
            }
        }
    
        static int stringToDouble(string temp)//二进制串到double(整数)
        {
            double res = 0;
            for (int i = 0; i < temp.length(); i++)
            {
                res = res * 2 + (temp[i] - '0');
            }
            return res;
        }
    
        static double BenToDex(string temp)//二进制串到double(小数)
        {
            int m = temp.length();
            double res = 0;
            for (int i = 0; i < m; i++)
            {
                res = res + (temp[i] - '0') * pow(2, -i - 1);
            }
            return res;
        }
    };
    
    int main()
    {
        string x, y, z;
        cin >> x;//输入十六进制
       // cin>>z;
        double x1 = HexToDouble::putin(x);
        cout << x1 << endl;
        cin >> y;
        double y1 = HexToDouble::putin(y);
        //double z1=HexToDouble::putin(z);
        cout << y1 << endl;
        //  cout<<"z "<<z1<<endl;
        return 0;
    }
    
    doubleToHex:

    也是找不到当时参考哪位大佬的了,谢谢大佬。我也稍微把函数都封装成一个类了。

    #include <iostream>
    #include <cmath>
    #include <bitset>
    #include <string.h>
    #include <string>
    using namespace std;
    
    class doubleToHex
    {
    public:
        static void TestDouble(double value)
        {
            int count = 0;
            string x;
            if (value > 0)
            {
                x += "0";                                      //判断符号
            }
            else
            {
                x += "1";
                value = -value;
            }
            while (2 <= value)                                //获得小数点后值
            {
                value = value / 2.0;
                count++;
            }
            while (value < 1)
            {
                value = value * 2;
                count--;
            }
            count = count + 1023;
            bitset<11>code(count);//将阶码变成二进制表示
            x += code.to_string();//前半部分二进制表示
            int digit = -1;
            value -= 1.0;
            //将数值用二进制表示/
            double posval = 0.0;
            double tempval = 0.0;
            while (value != 0 && digit > -54)
            {
                posval = pow(2, digit);
                tempval = value - posval;
                if (tempval > 0)
                {
                    x += "1";
                    value = tempval;
                }
                else if (tempval == 0)
                {
                    x += "1";
                    break;
                }
                else
                    x += "0";
                --digit;
            }
            int size = 64 - x.size();
            if (size > 0)
            {
                char* temp = new char[size];
                memset(temp, '0', size);
                x.append(temp, size);
                delete temp;
            }
            cout << binTohexstr(x) << endl;
        }
        static string binTohexstr(string temp)
        {
            string value = "";
            if (temp.size() % 4 != 0)
            {
                return NULL;
            }
            while ((temp.size() - 4) > 0)
            {
                value += binTohex(temp.substr(0, 4));
                temp = temp.substr(4, temp.size() - 4);
            }
            value += binTohex(temp);
            return value;
        }
        static char binTohex(string temp)
        {
            if ("0000" == temp)
                return '0';
            else if ("0001" == temp)
                return '1';
            else if ("0010" == temp)
                return '2';
            else if ("0011" == temp)
                return '3';
            else if ("0100" == temp)
                return '4';
            else if ("0101" == temp)
                return '5';
            else if ("0110" == temp)
                return '6';
            else if ("0111" == temp)
                return '7';
            else if ("1000" == temp)
                return '8';
            else if ("1001" == temp)
                return '9';
            else if ("1010" == temp)
                return 'A';
            else if ("1011" == temp)
                return 'B';
            else if ("1100" == temp)
                return 'C';
            else if ("1101" == temp)
                return 'D';
            else if ("1110" == temp)
                return 'E';
            else if ("1111" == temp)
                return 'F';
            else
                return 'G';
        }
    
    };
    
    int main()
    {
        double x;
        cin >> x;
        doubleToHex::TestDouble(x);
        return 0;
    }
    
    展开全文
  • IEEE二进制浮点数算术标准(IEEE 754)是1980年代以来最广泛使用的浮点数运算标准,为许多CPU与浮点运算器所采用。这个标准定义了表示浮点数的格式(包括负零-0)与反常值...本程序就是IEEE-754双精度转换程序
  • IEEE754字节转单精度/双精度浮点数
  • Trans(double)返回2进制 TransToHex(double)返回16进制 GetCrcstring(string data, ref string crc)返回冗余校验
  • 单精度与双精度浮点

    千次阅读 2014-09-16 20:41:53
     一个浮点二进制数手工转换成十进制数的例子:   假设浮点二进制数是  1011 1101 0100 0000 0000 0000 0000 0000  按 1  , 8  , 23  位分成三段:  1  01111010   10000000000000000000000  ...
  • 在CUDA 中如果不指明是 单精度, CUDA会调用双精度实现。 (血泪呀!!!) 如果要使用单精度,要指明, 即使用 形如__fmul_rn(x,y)的函数。 详见链接!! ...
  • 单精度,双精度浮点存储表示 剖析float型的精度丢失问题
  • 如果有: float a=3.14159; 在进行编译时,对float变量分配4个字节,但对于浮点型常量3.14159,则按双精度处理,分配8个字节。编译系统会发出“警告”...把一个双精度常量转换为float型”这种转换可能损失精度。 ...
  • 单精度浮点数、双精度浮点数与16进制之间的相互转换。文档中已列出相应函数,可直接调用。
  • 将单精度和双精度浮点数据转换为对应的16进制表示形式 包括一个基于VC6.0的工程和工具安装包(可直接安装运行)
  • 本文就带各位温顾温顾java浮点型、单精度浮点数、双精度浮点数。 浮点浮点浮点型别给我整些花里胡哨的定义,浮点型简单来说就是表示带有小数的数据,而恰恰小数点可以在相应的二进制的不同位置浮动,可能是...
  • 绿色软件,免安装,解压即可使用。单精度浮点数转换工具

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 47,125
精华内容 18,850
关键字:

双精度浮点转换