IEEE 754 单精度浮点数转换 在线计算器
 
http://www.styb.cn/cms/ieee_754.php
 
十进制小数的二进制表示：
 
整数部分：除以2，取出余数，商继续除以2，直到得到0为止，将取出的余数逆序
 
小数部分：乘以2，然后取出整数部分，将剩下的小数部分继续乘以2，然后再取整数部分，一直取到小数部分为零为止。如果永远不为零，则按要求保留足够位数的小数，最后一位做0舍1入。将取出的整数顺序排列。
 
举例：22.8125 转二进制的计算过程：
 
整数部分：除以2，商继续除以2，得到0为止，将余数逆序排列。
 22 / 2 11 余0
 11/2 5 余 1
 5 /2 2 余 1
 2 /2 1 余 0
 1 /2 0 余 1
 得到22的二进制是10110
 
小数部分：乘以2，取整，小数部分继续乘以2，取整，得到小数部分0为止，将整数顺序排列。
 0.8125x2=1.625 取整1,小数部分是0.625
 0.625x2=1.25 取整1,小数部分是0.25
 0.25x2=0.5 取整0,小数部分是0.5
 0.5x2=1.0 取整1,小数部分是0，
 
得到0.8125的二进制是0.1101
 
结果：十进制22.8125等于二进制00010110.1101
 
C语言和C#语言中，对于浮点类型的数据采用单精度类型（float）和双精度类型(double)来存储，float数据占用32bit,double数据占用64bit,我们在声明一个变量float f= 2.25f的时候，是如何分配内存的呢？如果胡乱分配，那世界岂不是乱套了么，其实不论是float还是double在存储方式上都是遵从IEEE的规范的，float遵从的是IEEE R32.24 ,而double 遵从的是R64.53。
 
无论是单精度还是双精度在存储中都分为三个部分：
 
符号位(Sign) : 0代表正，1代表为负
 指数位（Exponent）:用于存储科学计数法中的指数数据，并且采用移位存储
 尾数部分（Mantissa）：尾数部分
 其中float的存储方式如下图所示：
 
 
而双精度的存储方式为:
 
 
R32.24和R64.53的存储方式都是用科学计数法来存储数据的，比如8.25用十进制的科学计数法表示就为:8.25*clip_image0021,而120.5可以表示为:1.205*clip_image0022,这些小学的知识就不用多说了吧。而我们傻蛋计算机根本不认识十进制的数据，他只认识0，1，所以在计算机存储中，首先要将上面的数更改为二进制的科学计数法表示，8.25用二进制表示可表示为1000.01,我靠，不会连这都不会转换吧?那我估计要没辙了。120.5用二进制表示为：1110110.1用二进制的科学计数法表示1000.01可以表示为1.0001*clip_image002[2],1110110.1可以表示为1.1101101*clip_image002[3],任何一个数都的科学计数法表示都为1.xxx*clip_image002[1],尾数部分就可以表示为xxxx,第一位都是1嘛，干嘛还要表示呀？可以将小数点前面的1省略，所以23bit的尾数部分，可以表示的精度却变成了24bit，道理就是在这里，那24bit能精确到小数点后几位呢，我们知道9的二进制表示为1001，所以4bit能精确十进制中的1位小数点，24bit就能使float能精确到小数点后6位，而对于指数部分，因为指数可正可负，8位的指数位能表示的指数范围就应该为:-127-128了，所以指数部分的存储采用移位存储，存储的数据为元数据+127，下面就看看8.25和120.5在内存中真正的存储方式。

 首先看下8.25，用二进制的科学计数法表示为:1.0001*clip_image002[2]
 
按照上面的存储方式，符号位为:0，表示为正，指数位为:3+127=130 ,位数部分为,故8.25的存储方式如下图所示:
 
 
而单精度浮点数120.5的存储方式如下图所示:
 
 
那么如果给出内存中一段数据，并且告诉你是单精度存储的话，你如何知道该数据的十进制数值呢？其实就是对上面的反推过程，比如给出如下内存数据：0100001011101101000000000000，首先我们现将该数据分段，0 10000 0101 110 1101 0000 0000 0000 0000，在内存中的存储就为下图所示：
 
 
而双精度浮点数的存储和单精度的存储大同小异，不同的是指数部分和尾数部分的位数。所以这里不再详细的介绍双精度的存储方式了，只将120.5的最后存储方式图给出，大家可以仔细想想为何是这样子的
 
 
下面我就这个基础知识点来解决一个我们的一个疑惑，请看下面一段程序，注意观察输出结果
 
        float f = 2.2f;
        double d = (double)f;
        Console.WriteLine(d.ToString("0.0000000000000"));
        f = 2.25f;
        d = (double)f;
        Console.WriteLine(d.ToString("0.0000000000000"));
 
可能输出的结果让大家疑惑不解，单精度的2.2转换为双精度后，精确到小数点后13位后变为了2.2000000476837，而单精度的2.25转换为双精度后，变为了2.2500000000000，为何2.2在转换后的数值更改了而2.25却没有更改呢？很奇怪吧？其实通过上面关于两种存储结果的介绍，我们已经大概能找到答案。首先我们看看2.25的单精度存储方式，很简单 0 1000 0001 001 0000 0000 0000 0000 0000,而2.25的双精度表示为:0 100 0000 0001 0010 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000,这样2.25在进行强制转换的时候，数值是不会变的，而我们再看看2.2呢，2.2用科学计数法表示应该为：将十进制的小数转换为二进制的小数的方法为将小数2，取整数部分，所以0.282=0.4，所以二进制小数第一位为0.4的整数部分0，0.4×2=0.8，第二位为0,0.82=1.6,第三位为1，0.6×2 = 1.2，第四位为1，0.2*2=0.4，第五位为0，这样永远也不可能乘到=1.0，得到的二进制是一个无限循环的排列 00110011001100110011… ,对于单精度数据来说，尾数只能表示24bit的精度，所以2.2的float存储为:
 
 
但是这样存储方式，换算成十进制的值，却不会是2.2的，应为十进制在转换为二进制的时候可能会不准确，如2.2，而double类型的数据也存在同样的问题，所以在浮点数表示中会产生些许的误差，在单精度转换为双精度的时候，也会存在误差的问题，对于能够用二进制表示的十进制数据，如2.25，这个误差就会不存在，所以会出现上面比较奇怪的输出结果。

 
#include "stdio.h"
 
#include "stdlib.h"
 
#include "string.h"
 
#define datatype int
 
#define MAX_SIZE 50
 
#define OK  1
 
#define Err 0
 
/**
 
*        Code :     By YangLong    2014年9月21日,
 
*
 
*        0x00:  函数说明
 
*                    XD2B 将任意一个 浮点数 转换为 2 进制
 
*                    XD2B(double f,char* s, bool z)
 
*                    参数一:  需要转换的浮点数
 
*                    参数二:  存放结果的字符数组
 
*                    参数三:  z = true 时 代表 整数转换
 
*                             z = false 时 表示浮点数 转换
 
*
 
*        0x01    IEEE754(char* s)
 
*                    参数一: 将 XD2B中的字符数组 转换为 IEEE754格式
 
*        0x02    不足:
 
*                    结果显示为 拆分项
 
*                    要链接起来 用 字符串 拼接 就行
 
*
 
*        0x03    待优化:
 
*                    结果显示为    16进制
 
*                    将IEEE754转换为真值
 
*
 
*    不是程序复杂，而是编写的有点乱。
 
*/
 
typedef struct Stack
 
{
 
datatype data[MAX_SIZE];
 
int top;
 
}stk;
 
void Init(stk* s)
 
{
 
s->top = -1;
 
}
 
bool push(stk *s,datatype d)
 
{
 
if(s->top+1>MAX_SIZE-1)
 
{
 
printf(" 'push' Error: Overflow!\n");
 
exit(0);
 
}
 
s->data[++s->top] = d;
 
return OK;
 
}
 
datatype pop(stk* s)
 
{
 
if(s->top<0)
 
{
 
printf(" 'pop' Error: Overflow!");
 
exit(0);
 
}
 
datatype data = s->data[s->top--];
 
return data;
 
}
 
bool IsEmpty(stk* s)
 
{
 
return s->top == -1 ? OK : Err;
 
}
 
void XD2B(double f,char* s, bool z)
 
{
 
int i=0,j=0;
 
stk ss;
 
Init(&ss);
 
if(f<0)
 
{
 
s[0] = '1';
 
j = 1;
 
f = f*(-1.0);
 
}
 
else
 
{
 
s[0] = '0';
 
j = 1;
 
}
 
int q = (int)f;
 
while(q)
 
{
 
push(&ss,q%2);
 
q = q/2;
 
}
 
while(!IsEmpty(&ss))
 
{
 
s[j++] = pop(&ss) + '0';
 
}
 
if(z)        // z×××运算
 
return;
 
s[j++] = '.';
 
f = f - (int)f;
 
while(i<23)
 
{
 
f = f*2;
 
s[j+i] = (int)f + '0';
 
f = f - (int)f;
 
i++;
 
}
 
}
 
void IEEE754(char* s)
 
{
 
int j=1,i = 0,q,e,jm=0;
 
while(s[++i]!='.');
 
int m=1;
 
if(i>1)
 
{
 
while(s[m]!='1' && m
 
//printf("\n i = %d m= %d i - m = %d ",i,m,i - m-1); //去掉符号位
 
jm = i-m-1;
 
}
 
else
 
{
 
while(s[m]!='1' && m
 
//printf("\n i = %d m= %d i - m = %d ",i,m,i - m); //去掉符号位
 
jm = i-m;
 
}
 
int js = jm;
 
jm = jm + 127;
 
char cjm[16] = {0};
 
char ws[65]={0};
 
XD2B(jm,cjm,true);    //××× 转换
 
printf("\n符号位: %c",s[0]);
 
printf("\n阶码: %s\n",&cjm[1]);
 
for(q= i -js,e=0; q
 
{
 
if(s[q] != '.')
 
ws[e++] = s[q];
 
}
 
printf("尾数: %s",ws);
 
}
 
void main()
 
{
 
printf("Code By YangLong   0.o\n ");
 
printf("IEEE754  ->：");
 
char s[80]={0};
 
double df=0.0;
 
scanf("%lf",&df);
 
XD2B(df,s,false);
 
printf("%.16lf 二进制小数: ",df);
 
bool flag =true;
 
int j = 0;
 
for(int i=0;i
 
{
 
putchar(s[i]);
 
if(i == 0)
 
{
 
putchar(' '); //符号位
 
}
 
else if(i%4 ==0 )  //控制
 
putchar(' ');
 
}
 
IEEE754(s);
 
printf("\n");
 
getchar();
 
getchar();
 
}
 

 
C＃IEEE754到十进制(C# IEEE754 to decimal)
 
I got a HEX FLOAT IEEE 754 data, example "0x0017A8A6", how do I get it to decimal "1550502" in C#.
 
Thanks.
 
原文：https://stackoverflow.com/questions/36208341
 
更新时间：2019-12-04 06:13
 
最满意答案
 
您可以使用以下行解析C＃中的Hex-String(不带前导0x)：
 
int test = Int32.Parse("0017A8A6", NumberStyles.HexNumber);
 
但是，如果该位模式被解释为IEEE754，则它具有不同的含义，其含义为“2.172716E-39”。
 
最后15位是尾数(可以认为是数字)，接下来的8位是用于缩放尾数的指数。 最后一点是符号位。
 
You can parse a Hex-String (without the leading 0x) in C# by using the following line:
 
int test = Int32.Parse("0017A8A6", NumberStyles.HexNumber);
 
However if that Bit-Pattern is interpreted as IEEE754 it has a different meaning and that meaning is "2.172716E-39".
 
The last 15 bits are the Mantissa (which can be thought of as the number) and the next 8 bits are the exponent that is used to scale the mantissa. Finally the last bit is the sign bit.
 
2016-03-24
 
相关问答
 
我相信以下是执行您描述的操作： 我使用int作为中间表示，因为它与float(在我的机器上)具有相同的位数，并且允许从二进制字符串轻松转换。 #include 
 
union {
 
int i;
 
float f;
 
} myunion;
 
int binstr2int(char *s)
 
{
 
int rc;
 
for (rc = 0; '\0' != *s; s++) {
 
if ('1' == *s) {
 
rc =
 
...
 
你打电话的时候 Scanner.nextInt();
 
其次是 Scanner.nextLine();
 
表示nextLine()将读取该数字后面的其余部分。 您可能没有在数字后输入任何内容，因此nextLine返回空字符串“”，您可以在抛出的异常中看到它。 解决这个问题的简单方法就是打电话 int option = scanner.nextInt();
 
scanner.nextLine(); // ignore the rest of the line.
 
// now reads the ne
 
...
 
您可以使用以下行解析C＃中的Hex-String(不带前导0x)： int test = Int32.Parse("0017A8A6", NumberStyles.HexNumber);
 
但是，如果该位模式被解释为IEEE754，则它具有不同的含义，其含义为“2.172716E-39”。 最后15位是尾数(可以认为是数字)，接下来的8位是用于缩放尾数的指数。 最后一点是符号位。 You can parse a Hex-String (without the leading 0x) in C# b
 
...
 
严格的弱排序要求存在强排序的等价类。 IEEE754并非如此。 问题不在于存在多个彼此相等的NaN值，而是整个NaN类相对于实际线是无序的。 (4.2)的违反会导致你在维基百科引用的第四个项目符号中的测试也失败(让y为NaN)。 对于在严格弱排序中允许的不兼容性示例，请考虑符号幅度整数。 然后： -4 
 
...
 
要表示的值将是2147483647.可以用这种方式表示的下两个值是2147483520和2147483648。 由于后者更接近无法代表的“理想状态”，因此使用它：在浮点数中，值得到舍入而不是截断。 The value to be represented would be 2147483647. the next two values which can be represented this way are 2147483520 and 2147483648. As the latter is c
 
...
 
你已经弄明白了，似乎你没有意识到这一点。 转换DWORD_TO_REAL采用存储在4bytesData的整数(十六进制)值并将其转换为IEEE754 REAL格式。 这不是你想要做的。 4479FFFF 已经采用IEEE754 REAL格式 - 您将获取该值，将REAL解释为DWORD，然后将DWORD值转换为REAL。 简短的回答是你不需要转换 - 4bytesData已经是正确的格式。 编辑 跟进评论： 这里FunctionBlock2 delclares rIn(REAL)，rOut(REA
 
...
 
在Vivado的IP目录中，可以找到浮动IP。 它通过AXI-4连接，但它对我来说很好，因为我正在使用MicroBlaze。 In Vivado's IP catalog a float IP can be found. It is connected via AXI-4, but it is fine for me, because I'm using MicroBlaze.
 
在要求澄清之后，问题是关于IEEE 754，独立于编程语言。 在这种情况下，在“圆到最近”中，对于所考虑的除法，获得结果2.4196151872870495e-72纯粹而且简单地是不正确的。 根据问题中的定义，正确的结果是2.41961518728705e-72 ： [...]每个操作都应该执行，就好像它首先产生一个正确到无限精度和无限范围的中间结果，然后舍入结果[...]。 在实践中发生的事情是，大多数编程语言实现(通常是规范)并没有过多强调严格遵守IEEE 754语义用于浮点运算。 即使使用I
 
...
 
你可能不得不问一下IEEE 754-1985背后的主要架构师William Kahan，但是这个答案对这个话题有所启发： 更重要的是，当NaN在8087算术中形式化时，没有isnan()谓词; 有必要为程序员提供一种方便有效的检测NaN值的方法，这些方法不依赖于编程语言，提供类似isnan()的东西可能需要很多年。 我将引用卡汉自己关于这个主题的文章： 如果没有办法摆脱NaNs，它们就像CRAYs上的Indefinites一样无用; 一旦遇到一个人，计算将最好停止，而不是无限期地持续到无限期结束。
 
...
 
我认为问题是关于可表示值的约束。 只有相当基本的约束条件没有在C ++中明确说明，但在第5.2.4.2.2节(“浮动类型的特性 )中的C标准中有详细说明，第11段(我只是引用我认为在此上下文中感兴趣的值)： 以下列表中给出的值应由具有实现定义值的常量表达式替换，这些值的大小(绝对值)大于或等于显示的值，具有相同的符号： FLT_DECIMAL_DIG 6 DBL_DECIMAL_DIG 10 LDBL_DECIMAL_DIG 10 FLT_MIN_10_EXP -37 DBL_M
 
...

 

 
I was only able to convert a decimal into a binary single-precision IEEE754, using the struct.pack module, or do the opposite (float16 or float32) using numpy.frombuffer
 
Is it possible to convert a decimal to a binary half precision floating point, using Numpy?
 
I need to print the result of the conversion, so if I type "117.0", it should print "0101011101010000"
 
解决方案if I type "117.0", it should print "0101011101010000"
 
>>> import numpy as np
 
>>> bin(np.float16(117.0).view('H'))[2:].zfill(16)
 
'0101011101010000'
 
.view('H') reinterprets the memory occupied by the float16 value as an unsigned integer.