编译器浮点计算公式

① 二进制中浮点数怎么表示

目前C/C++编译器标准都遵照IEEE制定的浮点数表示法来进行float,double运算。这种结构是一种科学计数法，用符号、指数和尾数来表示，底数定为2——即把一个浮点数表示为尾数乘以2的指数次方再添上符号。下面是具体的规格：
符号位 阶码 尾数 长度
float 1 8 23 32
double 1 11 52 64 以下通过几个例子讲解浮点数如何转换为二进制数例一：已知：double类型38414.4。求：其对应的二进制表示。分析：double类型共计64位，折合8字节。由最高到最低位分别是第63、62、61、……、0位：
最高位63位是符号位，1表示该数为负，0表示该数为正；
62-52位，一共11位是指数位；
51-0位，一共52位是尾数位。

步骤：按照IEEE浮点数表示法，下面先把38414.4转换为十六进制数。
把整数部和小数部分开处理:整数部直接化十六进制：960E。小数的处理:
0.4=0.5*0+0.25*1+0.125*1+0.0625*0+……
实际上这永远算不完！这就是着名的浮点数精度问题。所以直到加上前面的整数部分算够53位就行了。隐藏位技术：最高位的1不写入内存（最终保留下来的还是52位）。
如果你够耐心，手工算到53位那么因该是：38414.4(10)=1001011000001110.(2)科学记数法为：1.001011000001110 ，右移了15位，所以指数为15。或者可以如下理解：1.001011000001110 ×2^15
于是来看阶码，按IEEE标准一共11位，可以表示范围是-1024 ~ 1023。因为指数可以为负，为了便于计算，规定都先加上1023(2^10-1)，在这里，阶码：15+1023=1038。二进制表示为：100 00001110；
符号位：因为38414.4为正对应 为0；
合在一起（注：尾数二进制最高位的1不要）：
01000000 11100010 11000001 110 01100 11001100 11001100 11001100 11001100 例二：已知：整数3490593(16进制表示为0x354321)。求：其对应的浮点数3490593.0的二进制表示。 解法如下：先求出整数3490593的二进制表示： H: 3 5 4 3 2 1 （十六进制表示） B: 0011 0101 0100 0011 0010 0001 （二进制表示） │←──────21─────→│ 即： 1.1010101000011001000012×221可见，从左算起第一个1后有21位，我们将这21为作为浮点数的小数表示，单精度浮点数float由符号位1位，指数域位k=8位，小数域位(尾数)n=23位构成，因此对上面得到的21位小数位我们还需要补上2个0，得到浮点数的小数域表示为： 1 0101 0100 0011 0010 0001 00 float类型的偏置量Bias=2k-1-1=28-1-1=127，但还要补上刚才因为右移作为小数部分的21位，因此偏置量为127+21=148，就是IEEE浮点数表示标准： V = (-1)s×M×2E E = e-Bias中的e，此前计算Bias=127，刚好验证了E=148-127=21。 将148转为二进制表示为10010100，加上符号位0，最后得到二进制浮点数表示，其16进制表示为： H: 4 A 5 5 0 C 8 4 B: 0100 1010 0101 0101 0000 1100 1000 0100 |←──── 21 ─────→ | 1|←─8 ─→||←───── 23 ─────→ | 这就是浮点数3490593.0(0x4A550C84)的二进制表示。 例三：0.5的二进制形式是0.1它用浮点数的形式写出来是如下格式 0 01111110 00000000000000000000000
符号位 阶码 小数位正数符号位为0，负数符号位为1阶码是以2为底的指数小数位表示小数点后面的数字
下面我们来分析一下0.5是如何写成0 01111110 00000000000000000000000
首先0.5是正数所以符号位为0再来看阶码部分,0.5的二进制数是0.1,而0.1是1.0*2^(-1),所以我们总结出来:要把二进制数变成(1.f)*2^(exponent)的形式,其中exponent是指数而由于阶码有正负之分所以阶码=127+exponent;即阶码=127+(-1)=126 即 01111110余下的小数位为二进制小数点后面的数字,即00000000000000000000000
由以上分析得0.5的浮点数存储形式为0 01111110 00000000000000000000000 注：如果只有小数部分,那么需要右移小数点. 比如右移3位才能放到第一个1的后面, 阶码就是127-3=124.例四 （20.59375）10 =（10100.10011 ）2

首先分别将整数和分数部分转换成二进制数：

20.59375＝10100.10011

然后移动小数点，使其在第1，2位之间

10100.10011＝1.010010011×2^4 即e＝4

于是得到：

S＝0， E＝4＋127＝131， M＝010010011

最后得到32位浮点数的二进制存储格式为：

0100 1001 1010 0100 1100 0000 0000 0000＝(41A4C000)16 例五：
-12.5转为单精度二进制表示
12.5:
1. 整数部分12，二进制为1100; 小数部分0.5, 二进制是.1，先把他们连起来，从第一个1数起取24位（后面补0）：
1100.10000000000000000000
这部分是有效数字。（把小数点前后两部分连起来再取掉头前的1，就是尾数）
2. 把小数点移到第一个1的后面，需要左移3位（1.10010000000000000000000*2^3）, 加上偏移量127：127+3=130，二进制是10000010，这是阶码。
3. -12.5是负数，所以符号位是1。把符号位，阶码和尾数连起来。注意，尾数的第一位总是1，所以规定不存这一位的1，只取后23位：
1 10000010 10010000000000000000000
把这32位按8位一节整理一下，得：
11000001 01001000 00000000 00000000
就是十六进制的 C1480000.

例六：2.025675
1. 整数部分2，二进制为10; 小数部分0.025675, 二进制是.0000011010010010101001，先把他们连起来，从第一个1数起取24位（后面补0）：
10.0000011010010010101001
这部分是有效数字。把小数点前后两部分连起来再取掉头前的1，就是尾数: 00000011010010010101001
2. 把小数点移到第一个1的后面，左移了1位, 加上偏移量127：127+1=128，二进制是10000000，这是阶码。
3. 2.025675是正数，所以符号位是0。把符号位，阶码和尾数连起来：
0 10000000 00000011010010010101001
把这32位按8位一节整理一下，得：
01000000 00000001 10100100 10101001
就是十六进制的 4001A4A9.

例七：
(逆向求十进制整数)一个浮点二进制数手工转换成十进制数的例子：
假设浮点二进制数是 1011 1101 0100 0000 0000 0000 0000 0000
按1，8，23位分成三段：
1 01111010 10000000000000000000000
最后一段是尾数。前面加上"1.", 就是 1.10000000000000000000000
下面确定小数点位置。由E = e-Bias，阶码E是01111010，加上00000101才是01111111（127），
所以他减去127的偏移量得e=-5。（或者化成十进制得122，122-127=-5）。
因此尾数1.10（后面的0不写了）是小数点右移5位的结果。要复原它就要左移5位小数点，得0.0000110, 即十进制的0.046875 。
最后是符号：1代表负数，所以最后的结果是 -0.046875 。

注意：其他机器的浮点数表示方法可能与此不同. 不能任意移植。 再看一例(类似例七)：比如：53004d3e二进制表示为：按照1个符号 8个指数 23个小数位划分0 10100110 00000000100110100111110正确的结果转出来应该是551051722752.0该怎么算？好，我们根据IEEE的浮点数表示规则划分，得到这个浮点数的小数位是：

00000000100110100111110

那么它的二进制表示就应该是：

1.000000001001101001111102 × 239

这是怎么来的呢？ 别急，听我慢慢道来。
标准化公式中的M要求在规格化的情况下，取值范围1<M<(2-ε)正因为如此，我们才需要对原始的整数二进制表示做偏移，偏移多少呢？偏移2E。
这个“E”怎么算？上面的239怎么得来的呢？浮点数表示中的8位指数为就是告诉这个的。我们知道：
E = e-Bias
那么根据指数位:101001102=>16610
即e=166，由此算出E=e-Bias=166-127=39，就是说将整数二进制表示转为标准的浮点数二进制表示的时候需要将小数点左移39位，好，我们现在把它还原得到整数的二进制表示：1 00000000100110100111110 00000000000000001│←───── 23─────→│←─── 16───→│

23+16=39，后面接着就是小数点了。
拿出计算器，输入二进制数
转为十进制数，不正是：551051722752么！

通过这例六例七，介绍了将整数二进制表示转浮点数二进制表示的逆过程，还是希望大家不但能掌握转化的方法，更要理解转化的基本原理。

② 32位浮点数计算

编程嘛！
用C语言的union
union Para
{
float t;
unsigned char buf[4];
}
如果Para.t=100.0008;
则Para.buf[0]=0x42;
Para.buf[1]=0xC8;
Para.buf[2]=0x00;
Para.buf[3]=0x69;

如果要计算原理的话，请参考：
http://www.psc.e/general/software/packages/ieee/ieee.php

③ 浮点数在计算机中是如何表示的

浮点数浮点数是属于有理数中某特定子集的数的数字表示，在计算机中用以近似表示任意某个实数。具体的说，这个实数由一个整数或定点数（即尾数）乘以某个基数（计算机中通常是2）的整数次幂得到，这种表示方法类似于基数为10的科学记数法。
浮点计算是指浮点数参与的运算，这种运算通常伴随着因为无法精确表示而进行的近似或舍入。
一个浮点数a由两个数m和e来表示：a = m × b^e。在任意一个这样的系统中，我们选择一个基数b（记数系统的基）和精度p（即使用多少位来存储）。m（即尾数）是形如±d.ddd...ddd的p位数（每一位是一个介于0到b-1之间的整数，包括0和b-1）。如果m的第一位是非0整数，m称作规格化的。有一些描述使用一个单独的符号位（s 代表+或者-）来表示正负，这样m必须是正的。e是指数。
由此可以看出，在计算机中表示一个浮点数，其结构如下：
尾数部分（定点小数） 阶码部分（定点整数）数符±尾数m阶符±阶码e
这种设计可以在某个固定长度的存储空间内表示定点数无法表示的更大范围的数。
例如，一个指数范围为±4的4位十进制浮点数可以用来表示43210，4.321或0.0004321，但是没有足够的精度来表示432.123和43212.3（必须近似为432.1和43210）。当然，实际使用的位数通常远大于4。
此外，浮点数表示法通常还包括一些特别的数值：+∞和�6�1∞（正负无穷大）以及NaN（'Not a Number'）。无穷大用于数太大而无法表示的时候，NaN则指示非法操作或者无法定义的结果。
众所周知，计算机中的所有数据都是以二进制表示的，浮点数也不例外。然而浮点数的二进制表示法却不像定点数那么简单了。
先澄清一个概念，浮点数并不一定等于小数，定点数也并不一定就是整数。所谓浮点数就是小数点在逻辑上是不固定的，而定点数只能表示小数点固定的数值，具用浮点数或定点数表示某哪一种数要看用户赋予了这个数的意义是什么。
C++中的浮点数有6种，分别是：
float：单精度，32位
unsigned float：单精度无符号，32位
double：双精度，64位
unsigned double：双精度无符号，64位
long double：高双精度，80位
unsigned long double：高双精度无符号，80位（嚯，应该是C++中最长的内置类型了吧！）
然而不同的编译器对它们的支持也略有不同，据我所知，很多编译器都没有按照IEEE规定的标准80位支持后两种浮点数的，大多数编译器将它们视为double，或许还有极个别的编译器将它们视为128位？！对于128位的long double我也仅是听说过，没有求证，哪位高人知道这一细节烦劳告知。
下面我仅以float（带符号，单精度，32位）类型的浮点数说明C++中的浮点数是如何在内存中表示的。先讲一下基础知识，纯小数的二进制表示。（纯小数就是没有整数部分的小数，讲给小学没好好学的人）
纯小数要想用二进制表示，必须先进行规格化，即化为 1.xxxxx * ( 2 ^ n ) 的形式（“^”代表乘方，2 ^ n表示2的n次方）。对于一个纯小数D，求n的公式如下：
n = 1 + log2(D); // 纯小数求得的n必为负数
再用 D / ( 2 ^ n ) 就可以得到规格化后的小数了。接下来就是十进制到二进制的转化问题，为了更好的理解，先来看一下10进制的纯小数是怎么表示的，假设有纯小数D，它小数点后的每一位数字按顺序形成一个数列：
{k1, k2, k3, ... , kn}
那么D又可以这样表示：
D = k1 / (10 ^ 1 ) + k2 / (10 ^ 2 ) + k3 / (10 ^ 3 ) + ... + kn / (10 ^ n )
推广到二进制中，纯小数的表示法即为：
D = b1 / (2 ^ 1 ) + b2 / (2 ^ 2 ) + b3 / (2 ^ 3 ) + ... + bn / (2 ^ n )
现在问题就是怎样求得b1, b2, b3，……，bn。算法描述起来比较复杂，还是用数字来说话吧。声明一下，1 / ( 2 ^ n )这个数比较特殊，我称之为位阶值。
例如0.456，第1位，0.456小于位阶值0.5故为0；第2位，0.456大于位阶值0.25，该位为1，并将0.45减去0.25得0.206进下一位；第3位，0.206大于位阶值0.125，该位为1，并将0.206减去0.125得0.081进下一位；第4位，0.081大于0.0625，为1，并将0.081减去0.0625得0.0185进下一位；第5位0.0185小于0.03125……
最后把计算得到的足够多的1和0按位顺序组合起来，就得到了一个比较精确的用二进制表示的纯小数了，同时精度问题也就由此产生，许多数都是无法在有限的n内完全精确的表示出来的，我们只能利用更大的n值来更精确的表示这个数，这就是为什么在许多领域，程序员都更喜欢用double而不是float。
float的内存结构，我用一个带位域的结构体描述如下：
struct MYFLOAT
{
bool bSign : 1; // 符号，表示正负，1位
char cExponent : 8; // 指数，8位
unsigned long ulMantissa : 23; // 尾数，23位
};
符号就不用多说了，1表示负，0表示正
指数是以2为底的，范围是 -128 到 127，实际数据中的指数是原始指数加上127得到的，如果超过了127，则从-128开始计，其行为和X86架构的CPU处理加减法的溢出是一样的。
比如：127 + 2 = -127；-127 - 2 = 127
尾数都省去了第1位的1，所以在还原时要先在第一位加上1。它可能包含整数和纯小数两部分，也可能只包含其中一部分，视数字大小而定。对于带有整数部分的浮点数，其整数的表示法有两种，当整数大于十进制的16777215时使用的是科学计数法，如果小于或等于则直接采用一般的二进制表示法。科学计数法和小数的表示法是一样的。
小数部分则是直接使用科学计数法，但形式不是X * ( 10 ^ n )，而是X * ( 2 ^ n )。拆开来看。
0 00000000 0000000000000000000000
符号位 指数位 尾数位

④ 单精度的浮点数有效数字为什么是七位如何计算为什么谢谢啦

浮点数7位有效数字.
双精度数16位有效数字.
浮点数取值范围：
负数取值范围为 -3.4028235E+38 到 -1.401298E-45,正数取值范围为 1.401298E-45 到 3.4028235E+38.
双精度数取值范围：
负值取值范围-1.79769313486231570E+308 到 -4.94065645841246544E-324,正值取值范围为 4.94065645841246544E-324 到 1.79769313486231570E+308.
C/C++中浮点数的表示遵循IEEE 754标准.
一个浮点数由三部分组成：符号位S、指数部分E（阶码）以及尾数部分M（如下）.
Floating
S--------E-------M
1位-----8位-----23位
Double
S--------E-------M
1位-----11位----52位
十进制数的换算计算公式为（n^m表示n的m次幂,B表示前面的数字是二进制）：
S * 2^(E-127) * (1.M)B
浮点数的精度取决于尾数部分.尾数部分的位数越多,能够表示的有效数字越多.
单精度数的尾数用23位存储,加上默认的小数点前的1位1,2^(23+1) = 16777216.因为 10^7 < 16777216 < 10^8,所以说单精度浮点数的有效位数是7位.
双精度的尾数用52位存储,2^(52+1) = 9007199254740992,10^16 < 9007199254740992 < 10^17,所以双精度的有效位数是16位.
另外：
如果你在PI值的有效位后增加数字的话,结果是不会变化的,由于PI值是以常数方式赋值,可以在常数后面加个'f',如PI = 3.1415926f;否则编译器会先把常数当作double类型,然后再截断后面的值变为浮点值,这样的话,就有可能PI的值会有不同,造成你看到的现象.

⑤ 谁能告诉我一下服务器cpu浮点运算的计算公式是什么

处理器的浮点运算：
浮点运算就是实数运算。

因为计算机只能存储整数，所以实数都是约数，这样浮点运算是很慢的而且会有误差。现在大多数机器都是32位的，也就是说64位都用来表示整数的话，那么对于无符号整数就是0 到 2^32-1，对于有符号的话就是-2^31 到 2^31-1。

计算机里整数和小数形式就是按普通格式进行存储，例如1024、3.1415926等等，这个没什么特点，但是这样的数精度不高，表达也不够全面，为了能够有一种数的通用表示法，就发明了浮点数。
浮点数的表示形式有点像科学计数法（*.*****×10^***），它的表示形式是0.*****×10^***，在计算机中的形式为 .***** e ±***），其中前面的星号代表定点小数，也就是整数部分为0的纯小数，后面的指数部分是定点整数。利用这样的形式就能表示出任意一个整数和小数，例如1024就能表示成0.1024×10^4，也就是 .1024e+004，3.1415926就能表示成0.31415926×10^1，也就是 .31415926e+001，这就是浮点数。浮点数进行的运算就是浮点运算。

浮点运算比常规运算更复杂，因此计算机进行浮点运算速度要比进行常规运算慢得多。

⑥ 浮点数表示方法是什么

是已知的C/C++编译器都是按照IEEE（国际电子电器工程师协会）制定的IEEE浮点数表示法来进行运算的。这种结构是一种科学表示法，用符号（+或-）、指数和尾数来表示，底数被确定为2。所以在IEEE浮点数表示法里，一个浮点数为尾数乘以2的指数次方再加上符号。

(6)编译器浮点计算公式扩展阅读：

格式

()

其中Ef到E7这部分叫做阶码，用移码表示，Ef是阶符，Mf到M7称作尾数，用补码表示，Mf为数符，小数点的位置在Mf后面对于浮点数的表示，字长是由硬件决定，如字长可以是32位，其中阶码8位，含一位阶符，则阶码的表示范围为-128到127，尾数为23位。

例如，原数为-1101.110101000100...0如果用上述32位表示，-1101.110101000100...0=-0.1101110101000100...0*2^4，4=0000100，其移码=2^7+0000100=10000100

Mf为1，M1后为1101110101000100...，不足23位后的空位置用0补够，则其浮点数表示为10000100，1.1101110101000100...0。

⑦ java的double类型的浮点运算(要解释的)。

double f=0.0005;
double i=3;
double d=f*i;
double f1=0.0005;
double j=3;
double d1=f1*j;
if(d==d1){
System.out.println("aaa");
}这样就相当,java中基本数据类型称为自动变量,自动变量存的是字面值,由于字面值的数据大小可知,生存期可知,出于速度的原因就把它们放在栈中,栈中的数据可以共享.如int a=3 int b=3 编译器先处理int a=3;首先它会在栈中创建一个变量为a的引用,然后在找字面值等于3的地址,没有 就开辟一个存放3这个字面值的地址,接着处理int b=3;在创建完变量为b的应用后,查找有没有3这个字面值的地址,现在有了,则指向3的地址,这时用==(判断地址是否相同时)就会为True

⑧ 浮点数怎么计算要详细过程··

一个浮点数a由两个数m和e来表示：a = m × b^e。

在任意一个这样的系统中，我们选择一个基数b（记数系统的基）和精度p（即使用多少位来存储）。m（即尾数）是形如±d.ddd...ddd的p位数（每一位是一个介于0到b-1之间的整数，包括0和b-1)。如果m的第一位是非0整数,m称作规格化的。

有一些描述使用一个单独的符号位(s 代表+或者-）来表示正负，这样m必须是正的。e是指数。

例如，一个指数范围为±4的4位十进制浮点数可以用来表示43210,4.321或0.0004321,但是没有足够的精度来表示432.123和43212.3（必须近似为432.1和43210)。当然，实际使用的位数通常远大于4。

(8)编译器浮点计算公式扩展阅读：

浮点数并不一定等于小数，定点数也并不一定就是整数。

C++中的浮点数有6种，分别是：

float：单精度，32位

unsigned float：单精度无符号，32位

double：双精度，64位

long double：高双精度，80位

纯小数要想用二进制表示，必须先进行规格化，即化为 1.xxxxx * ( 2 ^ n ) 的形式（“^”代表乘方,2 ^ n表示2的n次方）。对于一个纯小数D,求n的公式如下：

n = 1 + log2(D); // 纯小数求得的n必为负数

再用 D / ( 2 ^ n ) 就可以得到规格化后的小数了。接下来就是十进制到二进制的转化问题，为了更好的理解，先来看一下10进制的纯小数是怎么表示的，假设有纯小数D,它小数点后的每一位数字按顺序形成一个数列：

{k1,k2,k3,...,kn}

那么D又可以这样表示：

D = k1 / (10 ^ 1 ) + k2 / (10 ^ 2 ) + k3 / (10 ^ 3 ) + ... + kn / (10 ^ n )

推广到二进制中，纯小数的表示法即为：

D = b1 / (2 ^ 1 ) + b2 / (2 ^ 2 ) + b3 / (2 ^ 3 ) + ... + bn / (2 ^ n )

⑨ 计算机组成原理——浮点数表示方法

就是在二进制中，一个数的小数点可以可以通过乘以2的幂次来改变位置，这是其原理 。

浮点数的组成：阶符+ 阶码 +数符+ 尾数

计算机中表示浮点数的字长通常为32位，其中7位作阶码，1位为阶符，23位尾数，1位作数符

例如用2个字节表示一个浮点数（32写起来麻烦，所以用2个字节就是16位来举例，呵呵希望谅解） （72.45x10^5)D先换成普通二进制数（11011101000110011001000）B

然后开始像十进制数的科学计数法那样写成约等于（0.1101110）Bx(2^23)D

之后再将后半部分的(2^23)D转换成（2^10111)B

于是整个数就变成了（0.1101110x2^10111)B

在计算机中表示成0001011101101110 其中第一个0是阶符表示指数是正的第九个0表示尾数是正的他们中间的就是阶码，后面的就是尾数。

⑩ 计算机原理 浮点数的那个公式 我没明白他是怎么把一个二进制数转换成这种格式的比如说100

我给你举个例子吧，假设在一个16位的机器上，约定浮点数的格式为：1位阶符+6位阶码+1位数符+8位尾数，那么 1010 0011 0110 0011就代表着：
最高位（阶符）为1，代表阶数为负数；
6位阶码为010001，也就是阶码的绝对值为17；
数符为1，代表这个浮点数本身是负数；
尾数为0110 0011，一般代表着这个浮点数的二进制形式为1.0110 0011，也就是1.38671875。
所以这个浮点数就是-1.38671875乘以2的-17次方。（注意，前提是浮点数的格式按照开头的假设。实际生活中的浮点数格式很少有这样的）