精华内容
下载资源
问答
  • 双精度浮点数转换

    热门讨论 2013-08-19 17:24:54
    双精度浮点数、单精度浮点数与十六进制,二进制之间可以进行任意转换
  • 单精度双精度浮点数转换

    热门讨论 2013-05-02 12:36:32
    单精度双精度浮点数转换,浮点数与16进制转换工具
  • #资源达人分享计划#
  • 浮点数和十六进制数的相互转换,包括:1.单精度浮点数(32位)和十六进制数的相互转换,2.双精度浮点数(64位)和十六进制数的相互转换
  • 单、双精度浮点数与16进制相互转换,文档中已列出相应函数,可直接调用。
  • 在C语言中,单精度浮点数(float)和双精度浮点数(double)类型都是用来储存实数的,双精度是用记忆较多,有效数字较多,数值范围较大。
  • IEEE754字节转单精度/双精度浮点数
  • 因为做机械臂项目需要提取机械臂坐标,所以当初为了把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;
    }
    
    展开全文
  • #资源达人分享计划#
  • 本代码将双精度浮点数转换为单精度浮点数,适合浮点数为正值的转换。 使用后将占用VD2810~VD2970字节,欢迎交流。 本代码的完成经历了一段时间的刻苦研究,无偿提供给真正需要的人,希望同行少走弯路。 代码允许复制...
  • 该工具为单精度与双精度的浮点转换成十进制,或者十进制转换为单精度或双精度的工具,可以验证你的计算方法是否错误。
  • IEEE 754 格式转换工具, 十六进制 与 双精度浮点型 格式转换
  • 浮点数转换工具

    2017-03-10 15:24:35
    支持单精度、多精度浮点数与十六进制、十进制、二进制整数之间的转换
  • 绿色软件,免安装,解压即可使用。单精度浮点数转换工具
  • VB小工具,免费使用,实现float数据与四字节数据相互转化以及Double数据与八字节数据相互转化。
  • 单精度浮点数、双精度浮点数与16进制之间的相互转换。文档中已列出相应函数,可直接调用。
  • //8字节转换双精度浮点型 int main() { BYTE *nums = new BYTE [8]; nums[0] = 0xC0; nums[1] = 0x18; nums[2] = 0xE1; nums[3] = 0x47; nums[4] = 0xAE; nums[5] = 0x14; nums[6] = 0x7A; nums[7] = 0...

    功能函数,其中BYTE 为unsigned char型

    double B2D(BYTE *pData) {
    	//double 型的格式8个字节
    	// S/E/M
    	//-1/-----------11/------.....52/
    	//获取符号位,1表示负数,0表示正数;
    	int sign = int(pData[0] >> 7);
    	cout << "sign= "<<sign << endl;
    	//指数位  11位
    	int e = int(pData[0] & 0x7F) * 16 + int(pData[1]>>4) - 1023;
    	cout << "e = " << e << endl;
    	// M 位
    	double  m = pow (2,-52)*(pow(256,6) *int(pData[1] &0x0F) + pow(256, 5)* int(pData[2]) + pow(256,4)* int(pData[3]) + pow(256, 3) * int(pData[4]) + pow(256, 2) * int(pData[5]) + 256 * int(pData[6]) + int(pData[7]))  +1;
    	cout << "m = " << m << endl;
    	double res = pow(-1, sign) * m * pow(2, e);
    	return res;
    }
    

    主函数

    #include "pch.h"
    #include <iostream>
    #include "math.h"
    
    using namespace std;
    typedef unsigned char BYTE;
    
    double B2D(BYTE *pData); //8字节转换为双精度浮点型
    int main()
    {
    	BYTE  *nums = new BYTE [8];
    	nums[0] = 0xC0;
    	nums[1] = 0x18;
    	nums[2] = 0xE1;
    	nums[3] = 0x47;
    	nums[4] = 0xAE;
    	nums[5] = 0x14;
    	nums[6] = 0x7A;
    	nums[7] = 0xE1;
    	
    
    	//cout << "所占字节数"<< sizeof(nums) << endl;
    	double res = B2D(nums);
    	cout << "res: "<<res << endl;
    	//cout << sizeof(double) << endl;
    }
    
    展开全文
  • 8字节16进制转双精度浮点数 前言 一、JS处理32位整型位运算? 示例:在JS中无论是整数还是小数都是按照64位的浮点数形式存储,而整数运算会自动转化为32位有符号整数。 有符号整数使用 31 位表示整数的数值,用第...



    一、JS处理32位整型位运算?

    示例:在JS中无论是整数还是小数都是按照64位的浮点数形式存储,而整数运算会自动转化为32位有符号整数。
    有符号整数使用 31 位表示整数的数值,用第 32 位表示整数的符号,0 表示正数,1 表示负数。数值范围为 [-2^31 , 2^31-1], 即[ -2147483648 , 2147483647 ]。
    JavaScript 进行位操作时,采用32位有符号整型,这意味着其转换的结果也是32位有符号整型。 有时我们进行移位会由于符号的存在产生与c语言无符号整数不一样的结果。
    针对该问题,我们可以把JavaScript 中的有符号数,转换成无符号数。只需要进行 >>>0 移位操作就好了。

    二、js 16进制转浮点数

    1. 4字节16进制转单精度浮点数

    代码如下(示例):

    function hexToSingle(num){
    	var a = num;
    	var b = parseInt(a,16);
    	var s = b&0x80000000/0x80000000;
    	var e = (b&0x7f800000)/0x800000-127;
    	var c = (b&0x7fffff)/0x800000;
    	var re = Math.pow(-1,s)*(1+c)*Math.pow(2,e);
    	return re;
    }
    例如
    const str = '42a0774c'
    hexToSingle(str) = 80.23300170898438(js浮点数可能有误差)
    

    2. 8字节16进制转双精度浮点数

    代码如下(示例):

    function HexToDouble(t){
        var t = parseInt(ca2,16).toString(2);
    	if (t.length < 64) {
    	    t = FillString(t, "0", 64, true);
    	};
    	var s = t.substring(0, 1);
    	var e = t.substring(1, 12);
    	var m = t.substring(12);
    	e = parseInt(e, 2) - 1023;
    	m = "1" + m;
    	if (e >= 0) {
    	    m = m.substring(0, e + 1) + "." + m.substring(e + 1)
    	}
    	else {
    	    m = "0." + FillString(m, "0", m.length - e - 1, true)
    	}
    	if (m.indexOf(".") == -1) {
    	    m = m + ".0";
    	}
    	var a = m.split(".");
    	var mi = parseInt(a[0], 2);
    	var mf = 0;
    	for (var i = 0; i < a[1].length; i++) {
    	    mf += parseFloat(a[1].charAt(i)) * Math.pow(2, -(i + 1));
    	}
    	m = parseInt(mi) + parseFloat(mf);
    	if (s == 1) {
    	    m = 0 - m;
    	}
    	return m;
    }
    function FillString(t, c, n, b) {
        if ((t == "") || (c.length != 1) || (n <= t.length)) {
            return t;
        }
        var l = t.length;
        for (var i = 0; i < n - l; i++) {
            if (b == true) {
                t = c + t;
            }
             else {
                t += c;
            }
        }
        return t;
    }
    例如
    var str = "40dd7ac4b41562f9";
    HexToDouble(x) = 30187.073491428047 (js浮点数可能有误差)
    

    贴上参考的文章
    https://blog.csdn.net/u014322206/article/details/84745987;
    https://bbs.csdn.net/topics/391956637;
    https://www.cnblogs.com/ampedZ/p/HexToSingle.html;

    展开全文
  • 本文就带各位温顾温顾java浮点型、单精度浮点数、双精度浮点数。浮点型首先明确java中浮点型数据类型主要有:单精度float、双精度double至于浮点型就是跟int ,string类型差不多。都是数据类型。浮点型浮点型别给我...

    作为一名java学习者,怎能不懂这些java基础中的基础呢?本文就带各位温顾温顾java浮点型、单精度浮点数、双精度浮点数。

    30f6733ee811fcf550af0502f164f63e.png

    浮点型首先明确java中浮点型数据类型主要有:单精度float、双精度double

    至于浮点型就是跟int ,string类型差不多。都是数据类型。

    浮点型浮点型别给我整些花里胡哨的定义,浮点型简单来说就是表示带有小数的数据,而恰恰小数点可以在相应的二进制的不同位置浮动,可能是这样就被定义成浮点型了。~不得不佩服这文化程度,定义个数据名称都这么有深度~

    浮点型常量 Java的实常数有两种表示形式:1、 十进制数形式:由数字和小数点组成,且必须有小数点,如0.123 , 123.0

    2、科学计数法形式:如:123e3或123E3,其中e或E之前必须有数字,且e或E后面的指数必须为整数(当然也包括负整数)。

    科学计数法中的E

    了解浮点型常量 Java的实常数有两种表示形式之后,很有必要给各位科普科普下科学计数法中E的面貌了~E是指数的意思,E代表的英文是exponent,E表示10的多少次方的意思。

    比如7.823E5 = 782300 这里E5表示10的5次方,再比如54.3E-2 = 0.543这里E-2表示10的-2次方

    再补充一点(针对负次方理解)一个数的负几次方就是这个数的几次方的倒数。

    比如: 2的负1次方=2的1次方分之一=1/2

    比如: 3的负2次方=3的2次方分之一=1/9

    单精度浮点数(float)单精度浮点数在机内占4个字节、有效数字8位、表示范围:-3.40E+38 ~ +3.40E+38

    在Java语言当中,所有的浮点型字面值 ~【V8提示】浮点型简单来说就是表示带有小数的数据~ 默认当做double类型来处理,要想该字面值当做float类型来处理,需要在字面值后面添加F/f,或者强制装换为float。具体如下代码:public static void main(String[] args) {

    //3.10是浮点型,浮点型字面值默认当做double类型来处理,直接编译通过;

    double d=3.10;

    //3.10是浮点型,则必须加 F或者f,若没加,直接编译不通过,会报错“损失精度”

    float f=3.10; //编译出错会报错“损失精度”

    // 解决办法:

    // 第一种方式:强制类型转换

    float f1=(float)5.1;

    // 第二种方式:没有类型转换;

    folat f2=5.1f;

    }

    再来看看下面的测试,结果肯定十之八九会在意料之外,哈哈~public static void main(String[] args) {

    float a = 12345678.90123456789f;

    double b=0.12345678901234567890;

    float c=0.12345678901234567890f;

    System.out.println(a);

    System.out.println(b);

    System.out.println(c);

    打印结果

    a = 1.2345679E7

    b = 0.12345678901234568

    c = 0.12345679

    }

    双精度浮点数(double)双精度浮点数在机内占8个字节、有效数字16位、表示范围:-1.79E+308 ~ +1.79E+308

    double的精度太低,不适合用于做财务软件,财务涉及到钱的问题,要求精度较高,所以在java中有一个基础的类库名为:java.math.BigDecimal,但这个BigDecimal类型是引用类型不是基础类型,切记!!!

    在讲单精度浮点数(float)的时候,差不多顺道把double之间的区别讲了哈哈,所以最后给张很经典的图片“敷衍敷衍”下,哈哈哈 ~哎哎哎..别打...别打...别打脸QAQ~

    1295eb5af6c3e237a4589e8b63b02422.png

    本文来自 java入门 栏目,欢迎学习!

    展开全文
  • 我需要先把它转换成double,乘以100,然后再转换成int,但是我遇到了麻烦。 这就是我写的: ^{pr2}$ C语言中从浮点到整数的转换有什么问题吗?当用户提示0到1之间的数字时,程序返回错误的结果(总是0)。在 谢谢!...
  • labview子vi
  • 此文章描述了如何将十进制小数转换为二进制小数以及浮点数再内存中时如何进行存储。 二进制小数 在计算机中,无论什么数据,最终存储都为二进制,对于整数部分很容易表示,但是对于非整数则比较困难。例如,十进制数...
  • 精度浮点数转十进制方法一、单精度浮点数符合IEEE754标准,32位,前面第一位是符号位,接下来的8位是指数,最后23位是尾数。编程中了解这些就够了,转换方法如下:二、VB中转换示例:'VB浮点数转换程序Option ...
  • 浮点数转换小工具

    2015-05-29 16:51:50
    之前做一个FPGA项目时用到了浮点数定点数转换的IP,最后验结果时...于是只能网上找浮点数转换工具,找了几个发现都不好用,不过有一个在线转换器还不错。之后空下来自己用LabVIEW编了一个简单的浮点数转实数的程序
  • 所以我目前正在开发一个将IEEE-754单精度和双精度浮点数转换为十进制数的程序 . 该程序有一个 java.lang.NumberFormatException 抛出 . 我希望有人向我解释为什么会抛出它以及我应该如何修复它 .//This is the ...
  • float被称为单精度浮点类型,double被称为双精度浮点类型. 与整数不同,小数没有太多的飞蛾,小数的长度是固定的,浮点数始终占用4个字节,双精度数始终占用8个字节. 十进制输出小数也可以使用printf函数输出,包括...
  • 浮点数转十六进制转换器,包含32位、64位浮点数转换和10进制到16进制的转换

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 45,584
精华内容 18,233
关键字:

双精度浮点数转换