计算机中的浮点数
浮点数
1. 什么是浮点数
在计算机系统的发展过程中，曾经提出过多种方法表达实数。典型的比如相对于浮点数的定点数（Fixed Point Number）。在这种表达方式中，小数点固定的位于实数所有数字中间的某个位置。货币的表达就可以使用这种方式，比如99.00 或者00.99 可以用于表达具有四位精度（Precision），小数点后有两位的货币值。由于小数点位置固定，所以可以直接用四位数值来表达相应的数值。SQL 中的NUMBER 数据类型就是利用定点数来定义的。还有一种提议的表达方式为有理数表达方式，即用两个整数的比值来表达实数。
定点数表达法的缺点在于其形式过于僵硬，固定的小数点位置决定了固定位数的整数部分和小数部分，不利于同时表达特别大的数或者特别小的数。最终，绝大多数现代的计算机系统采纳了所谓的浮点数表达方式。这种表达方式利用科学计数法来表达实数，即用一个尾数（Mantissa，尾数有时也称为有效数字——Significand；尾数实际上是有效数字的非正式说法），一个基数（Base），一个指数（Exponent）以及一个表示正负的符号来表达实数。比如123.45 用十进制科学计数法可以表达为1.2345 ×102 ，其中1.2345 为尾数，10 为基数，2 为指数。浮点数利用指数达到了浮动小数点的效果，从而可以灵活地表达更大范围的实数。
2. IEEE 浮点数
计算机中是用有限的连续字节保存浮点数的。在IEEE 标准中，浮点数是将特定长度的连续字节的所有二进制位分割为特定宽度的符号域，指数域和尾数域三个域，其中保存的值分别用于表示给定二进制浮点数中的符号，指数和尾数。这样，通过尾数和可以调节的指数（所以称为"浮点"）就可以表达给定的数值了。
IEEE 754 指定：
n 两种基本的浮点格式：单精度和双精度。
? IEEE 单精度格式具有24 位有效数字精度，并总共占用32 位。
? IEEE 双精度格式具有53 位有效数字精度，并总共占用64 位。
n 两种扩展浮点格式：单精度扩展和双精度扩展。此标准并未规定这些格式的精确精度和和大小，但它指定了最小精度和大小。例如，IEEE 双精度扩展格式必须至少具有64 位有效数字精度，并总共占用至少79 位。
具体的格式参见下面的图例：
3. 浮点格式
浮点格式是一种数据结构，用于指定包含浮点数的字段、这些字段的布局及其算术解释。浮点存储格式指定如何将浮点格式存储在内存中。IEEE 标准定义了这些格式，但具体选择哪种存储格式由实现工具决定。
汇编语言软件有时取决于所使用的存储格式，但更高级别的语言通常仅处理浮点数据类型的语言概念。这些类型在不同的高级语言中具有不同的名称，并且与表中所示的IEEE 格式相对应。
IEEE 精度
C、C++
Fortran （仅限SPARC）
单精度
float
REAL 或REAL*4
双精度
double
DOUBLE PRECISION 或REAL*8
双精度扩展
long double
REAL*16
IEEE 754 明确规定了单精度浮点格式和双精度浮点格式，并为这两种基本格式分别定义了一组扩展格式。表中显示的long double 和REAL*16 类型适用于IEEE 标准定义的一种双精度扩展格式。
3.1.单精度格式
IEEE 单精度格式由三个字段组成：23 位小数f ；8 位偏置指数e ；以及1 位符号s。这些字段连续存储在一个32 位字中（如下图所示）。
? 0:22 位包含23 位小数f，其中第0 位是小数的最低有效位，第22 位是最高有效位。
IEEE 标准要求浮点数必须是规范的。这意味着尾数的小数点左侧必须为1，因此我们在保存尾数的时候，可以省略小数点前面这个1，从而腾出一个二进制位来保存更多的尾数。这样我们实际上用23 位长的尾数域表达了24 位的尾数。
? 23:30 位包含8 位偏置指数e，第23 位是偏置指数的最低有效位，第30 位是最高有效位。
8 位的指数为可以表达0 到255 之间的256 个指数值。但是，指数可以为正数，也可以为负数。为了处理负指数的情况，实际的指数值按要求需要加上一个偏差（Bias）值作为保存在指数域中的值，单精度数的偏差值为127；偏差的引入使得对于单精度数，实际可以表达的指数值的范围就变成-127 到128 之间（包含两端）。在本文中，最小指数和最大指数分别用emin 和emax 来表达。稍后将介绍实际的指数值-127（保存为全0）以及+128（保存为全1）保留用作特殊值的处理。
? 最高的第31 位包含符号位s。s为0表示数值为正数，而s为1则表示负数。
3.2.双精度格式
IEEE 双精度格式由三个字段组成：52 位小数f ；11 位偏置指数e ；以及1 位符号s。这些字段连续存储在两个32 位字中（如下图所示）。在SPARC 体系结构中，较高地址的32 位字包含小数的32 位最低有效位，而在x86体系结构中，则较低地址的32-位字包含小数的32 位最低有效位。
如果用f[31:0] 表示小数的32 位最低有效位，则在这32 位最低有效位中，第0 位是整个小数的最低有效位，而第31 位则是最高有效位。在另一个32 位字中，0:19 位包含20 位小数的最高有效位f[51:32]，其中第0 位是这20 位最高有效位中的最低有效位，而第19 位是整个小数的最高有效位；20:30 位包含11 位偏置指数e，其中第20 位是偏置指数的最低有效位，而第30 位是最高有效位；最高的第31 位包含符号位s。
上图将这两个连续的32 位字按一个64 位字那样进行了编号，其中
? 0:51 位包含52 位小数f，其中第0 位是小数的最低有效位，第51 位是最高有效位。
IEEE 标准要求浮点数必须是规范的。这意味着尾数的小数点左侧必须为1，因此我们在保存尾数的时候，可以省略小数点前面这个1，从而腾出一个二进制位来保存更多的尾数。这样我们实际上用52 位长的尾数域表达了53 位的尾数。
? 52:62 位包含11 位偏置指数e，第52 位是偏置指数的最低有效位，第62 位是最高有效位。
11 位的指数为可以表达0 到2047 之间的2048个指数值。但是，指数可以为正数，也可以为负数。为了处理负指数的情况，实际的指数值按要求需要加上一个偏差（Bias）值作为保存在指数域中的值，单精度数的偏差值为1023；偏差的引入使得对于单精度数，实际可以表达的指数值的范围就变成-1023到1024之间（包含两端）。在本文中，最小指数和最大指数分别用emin 和emax 来表达。稍后将介绍实际的指数值-1023（保存为全0）以及+1024（保存为全1）保留用作特殊值的处理。
? 最高的第63 位包含符号位s。s为0表示数值为正数，而s为1则表示负数。
3.3.双精度扩展格式(SPARC)
SPARC 浮点环境的四倍精度格式符合双精度扩展格式的IEEE 定义。四倍精度格式占用32 位字并包含以下三个字段：112 位小数f、15 位偏置指数e 和1 位符号s。这三个字段连续存储，如图2-3 所示。
地址最高的32 位字包含小数的32 位最低有效位，用f[31:0] 表示。紧邻的两个32 位字分别包含f[63:32] 和f[95:64]。下面的0:15 位包含小数的16 位最高有效位f[111:96]，其中第0 位是这16 位的最低有效位，而第15 位是整个小数的最高有效位。16:30 位包含15 位偏置指数e，其中第16 位是该偏置指数的最低有效位，而第30 位是最高有效位；第31 位包含符号位s。
下图将这四个连续的32 位字按一个128 位字那样进行了编号，其中0:111 位存储小数f ；112:126 位存储15 位偏置指数e ；而第127 位存储符号位s。
3.4.双精度扩展格式(x86)
该浮点环境双精度扩展格式符合双精度扩展格式的IEEE 定义。它包含四个字段：63 位小数f、1 位显式前导有效数位j、15 位偏置指数 e 以及1 位符号s。
在x86 体系结构系列中，这些字段连续存储在十个相连地址的8 位字节中。由于UNIXSystem V Application Binary Interface Intel 386 Processor Supplement (Intel ABI) 要求双精度扩展参数，从而占用堆栈中三个相连地址的32 位字，其中地址最高字的16 位最高有效位未用，如下图所示。
地址最低的32 位字包含小数的32 位最低有效位f[31:0]，其中第0 位是整个小数的最低有效位，而第31 位则是32 位最低有效位的最高有效位。地址居中的32 位字中，0:30 位包含小数的31 位最高有效位f[62:32] （其中第0 位是这31 位最高有效位的最低有效位，而第30 位是整个小数的最高有效位）；地址居中32 位字的第31 位包含显式前导有效数位j。
地址最高的32 位字中，0:14 位包含15 位偏置指数e，其中第0 位是该偏置指数的最低有效位，而第14 位是最高有效位；第15 位包含符号位s。虽然地址最高的32 位字的最高16 位未被x86 体系结构系列使用，但如上所述，它们对于符合Intel ABI 规定是至关重要的。
4. 将实数转换成浮点数
4.1 浮点数的规范化
同样的数值可以有多种浮点数表达方式，比如上面例子中的123.45 可以表达为12.345 ×101，0.12345 ×103 或者1.2345 ×102。因为这种多样性，有必要对其加以规范化以达到统一表达的目标。规范的（Normalized）浮点数表达方式具有如下形式：
±d.dd...d ×βe , (0 ≤ d i < β)
其中d.dd...d 即尾数，β为基数，e 为指数。尾数中数字的个数称为精度，在本文中用p 来表示。每个数字d 介于0 和基数之间，包括0。小数点左侧的数字不为0。
基于规范表达的浮点数对应的具体值可由下面的表达式计算而得：
±(d 0 + d 1β-1 + ... + d p-1β-(p-1))βe , (0 ≤d i < β)
对于十进制的浮点数，即基数β等于10 的浮点数而言，上面的表达式非常容易理解，也很直白。计算机内部的数值表达是基于二进制的。从上面的表达式，我们可以知道，二进制数同样可以有小数点，也同样具有类似于十进制的表达方式。只是此时β等于2，而每个数字d 只能在0 和1 之间取值。比如二进制数1001.101 相当于1 ×2 3 + 0 ×22 + 0 ×21 + 1 ×20 + 1 ×2-1 + 0 ×2-2 + 1 ×2-3，对应于十进制的9.625。其规范浮点数表达为1.001101 ×23。
4.2 根据精度表示浮点数
以上面的9.625为例，其规范浮点数表达为 1.001101 ×23，
因此按单精度格式表示为：
1 10000010 00110100000000000000000
同理按双精度格式表示为：
1 10000000010 0011010000000000000000000000000000000000000000000000
5. 特殊值
通过前面的介绍，你应该已经了解的浮点数的基本知识，这些知识对于一个不接触浮点数应用的人应该足够了。不过，如果你兴趣正浓，或者面对着一个棘手的浮点数应用，可以通过本节了解到关于浮点数的一些值得注意的特殊之处。
我们已经知道，单精度浮点数指数域实际可以表达的指数值的范围为-127 到128 之间（包含两端）。其中，值-127（保存为全0）以及+128（保存为全1）保留用作特殊值的处理。本节将详细IEEE 标准中所定义的这些特殊值。
浮点数中的特殊值主要用于特殊情况或者错误的处理。比如在程序对一个负数进行开平方时，一个特殊的返回值将用于标记这种错误，该值为NaN（Not a Number）。没有这样的特殊值，对于此类错误只能粗暴地终止计算。除了NaN 之外，IEEE 标准还定义了±0，±∞以及非规范化数（Denormalized Number）。
对于单精度浮点数，所有这些特殊值都由保留的特殊指数值-127 和128 来编码。如果我们分别用emin 和emax 来表达其它常规指数值范围的边界，即-126 和127，则保留的特殊指数值可以分别表达为emin - 1 和emax + 1; 。基于这个表达方式，IEEE 标准的特殊值如下所示：
其中f 表示尾数中的小数点右侧的（Fraction）部分。第一行即我们之前介绍的普通的规范化浮点数。随后我们将分别对余下的特殊值加以介绍。
5.1 NaN
NaN 用于处理计算中出现的错误情况，比如0.0 除以0.0 或者求负数的平方根。由上面的表中可以看出，对于单精度浮点数，NaN 表示为指数为emax + 1 = 128（指数域全为1），且尾数域不等于零的浮点数。IEEE 标准没有要求具体的尾数域，所以NaN 实际上不是一个，而是一族。不同的实现可以自由选择尾数域的值来表达NaN，比如Java 中的常量Float.NaN 的浮点数可能表达为01111111110000000000000000000000，其中尾数域的第一位为1，其余均为0（不计隐藏的一位），但这取决系统的硬件架构。Java 中甚至允许程序员自己构造具有特定位模式的NaN 值（通过Float.intBitsToFloat() 方法）。比如，程序员可以利用这种定制的NaN 值中的特定位模式来表达某些诊断信息。
定制的NaN 值，可以通过Float.isNaN() 方法判定其为NaN，但是它和Float.NaN 常量却不相等。实际上，所有的NaN 值都是无序的。数值比较操作符<，<=，> 和>= 在任一
操作数为NaN 时均返回false。等于操作符== 在任一操作数为NaN 时均返回false，即使是两个具有相同位模式的NaN 也一样。而操作符!= 则当任一操作数为NaN 时返回true。这个规则的一个有趣的结果是x!=x 当x 为NaN 时竟然为真。
可以产生NaN 的操作如下所示：
此外，任何有NaN 作为操作数的操作也将产生NaN。用特殊的NaN 来表达上述运算错误的意义在于避免了因这些错误而导致运算的不必要的终止。比如，如果一个被循环调用的浮点运算方法，可能由于输入的参数问题而导致发生这些错误，NaN 使得即使某次循环发生了这样的错误，也可以简单地继续执行循环以进行那些没有错误的运算。你可能想到，既然Java 有异常处理机制，也许可以通过捕获并忽略异常达到相同的效果。但是，要知道，IEEE 标准不是仅仅为Java 而制定的，各种语言处理异常的机制不尽相同，这将使得代码的迁移变得更加困难。何况，不是所有语言都有类似的异常或者信号（Signal）处理机制。
注意: Java 中，不同于浮点数的处理，整数的0 除以0 将抛出https://www.wendangku.net/doc/b06634539.html,ng.ArithmeticException 异常。
5.2 无穷
和NaN 一样，特殊值无穷（Infinity）的指数部分同样为emax + 1 = 128，不过无穷的尾数域必须为零。无穷用于表达计算中产生的上溢（Overflow）问题。比如两个极大的数相乘时，尽管两个操作数本身可以用保存为浮点数，但其结果可能大到无法保存为浮点数，而必须进行舍入。根据IEEE 标准，此时不是将结果舍入为可以保存的最大的浮点数（因为这个数可能离实际的结果相差太远而毫无意义），而是将其舍入为无穷。对于负数结果也是如此，只不过此时舍入为负无穷，也就是说符号域为1 的无穷。有了NaN 的经验我们不难理解，特殊值无穷使得计算中发生的上溢错误不必以终止运算为结果。
无穷和除NaN 以外的其它浮点数一样是有序的，从小到大依次为负无穷，负的有穷非零值，正负零（随后介绍），正的有穷非零值以及正无穷。除NaN 以外的任何非零值除以零，结果都将是无穷，而符号则由作为除数的零的符号决定。
回顾我们对NaN 的介绍，当零除以零时得到的结果不是无穷而是NaN 。原因不难理解，当除数和被除数都逼近于零时，其商可能为任何值，所以IEEE 标准决定此时用NaN 作为商比较合适。
5.3 有符号的零
因为IEEE 标准的浮点数格式中，小数点左侧的 1 是隐藏的，而零显然需要尾数必须是零。所以，零也就无法直接用这种格式表达而只能特殊处理。
实际上，零保存为尾数域为全为0，指数域为emin - 1 = -127，也就是说指数域也全为0。考虑到符号域的作用，所以存在着两个零，即+0 和-0。不同于正负无穷之间是有序的，IEEE 标准规定正负零是相等的。
零有正负之分，的确非常容易让人困惑。这一点是基于数值分析的多种考虑，经利弊权衡后形成的结果。有符号的零可以避免运算中，特别是涉及无穷的运算中，符号信息的丢失。举例而言，如果零无符号，则等式1/(1/x) = x 当x = ±∞时不再成立。原因是如果零无符号，1 和正负无穷的比值为同一个零，然后1 与0 的比值为正无穷，符号没有了。解决这个问题，除非无穷也没有符号。但是无穷的符号表达了上溢发生在数轴的哪一侧，这个信息显然是不能不要的。零有符号也造成了其它问题，比如当x=y 时，等式1/x = 1/y 在x 和y 分别为+0 和-0 时，两端分别为正无穷和负无穷而不再成立。当然，解决这个问题的另一个思路是和无穷一样，规定零也是有序的。但是，如果零是有序的，则即使if (x==0) 这样简单的判断也由于x 可能是±0 而变得不确定了。两害取其轻者，零还是无序的好。
5.4 非规范化数
我们来考察浮点数的一个特殊情况。选择两个绝对值极小的浮点数，以单精度的二进制浮点数为例，比如 1.001 ×2-125 和 1.0001 ×2-125 这两个数（分别对应于十进制的2.6448623 ×10-38 和2.4979255 ×10-38）。显然，他们都是普通的浮点数（指数为-125，大于允许的最小值-126；尾数更没问题），按照IEEE 754 可以分别保存为00000001000100000000000000000000（0x1100000）和00000001000010000000000000000000（0x1080000）。
现在我们看看这两个浮点数的差值。不难得出，该差值为0.0001 ×2-125，表达为规范浮点数则为 1.0 ×2-129。问题在于其指数大于允许的最小指数值，所以无法保存为规范浮点数。最终，只能近似为零（Flush to Zero）。这中特殊情况意味着下面本来十分可靠的代码也可能出现问题：
if (x != y) {
z = 1 / (x -y);
}
正如我们精心选择的两个浮点数展现的问题一样，即使x 不等于y，x 和y 的差值仍然可能绝对值过小，而近似为零，导致除以0 的情况发生。
为了解决此类问题，IEEE 标准中引入了非规范（Denormalized）浮点数。规定当浮点数的指数为允许的最小指数值，即emin 时，尾数不必是规范化的。比如上面例子中的差值可以表达为非规范的浮点数0.001 ×2-126，其中指数-126 等于emin。注意，这里规定的是"不必"，这也就意味着"可以"。当浮点数实际的指数为emin，且指数域也为emin 时，该浮点数仍是规范的，也就是说，保存时隐含着一个隐藏的尾数位。为了保存非规范浮点数，IEEE 标准采用了类似处理特殊值零时所采用的办法，即用特殊的指数域值emin - 1 加以标记，当然，此时的尾数域不能为零。这样，例子中的差值可以保存为
00000000000100000000000000000000（0x100000），没有隐含的尾数位。
有了非规范浮点数，去掉了隐含的尾数位的制约，可以保存绝对值更小的浮点数。而且，也由于不再受到隐含尾数域的制约，上述关于极小差值的问题也不存在了，因为所有可以保存的浮点数之间的差值同样可以保存。
6. 范围和精度
很多小数根本无法在二进制计算机中精确表示（比如最简单的0.1）由于浮点数尾数域的位数是有限的，为此，浮点数的处理办法是持续该过程直到由此得到的尾数足以填满尾数域，之后对多余的位进行舍入。换句话说，除了我们之前讲到的精度问题之外，十进制到二进制的变换也并不能保证总是精确的，而只能是近似值。事实上，只有很少一部分十进制小数具有精确的二进制浮点数表达。再加上浮点数运算过程中的误差累积，结果是很多我们看来非常简单的十进制运算在计算机上却往往出人意料。这就是最常见的浮点运算的"不准确"问题。
参见下面的Java 示例：
System.out.print("34.6-34.0=" + (34.6f-34.0f));
这段代码的输出结果如下：
34.6-34.0=0.5999985
产生这个误差的原因是34.6 无法精确的表达为相应的浮点数，而只能保存为经过舍入的近似值。这个近似值与34.0 之间的运算自然无法产生精确的结果。
存储格式的范围和精度
格式
有效数字（二进制）
最小正正规数
最大正数
有效数字（十进制）
单精
24
1.175... 10-38
3.402... 10+38
6-9
双精度
53
2.225... 10-308
1.797...10+308
15-17
双精度扩展(SPARC)
113
3.362... 10-4932
1.189...10+4932
33-36
双精度扩展(x86)
64
3.362... 10-4932
1.189...10+4932
18-21
7. 舍入
值得注意的是，对于单精度数，由于我们只有24 位的指数（其中一位隐藏），所以可以表达的最大指数为224 - 1 = 16,777,215。特别的，16,777,216 是偶数，所以我们可以通过将它除以2 并相应地调整指数来保存这个数，这样16,777,216 同样可以被精确的保存。相反，数值16,777,217 则无法被精确的保存。由此，我们可以看到单精度的浮点数可以表达的十进制数值中，真正有效的数字不高于8 位。事实上，对相对误差的数值分析结果显示有效的精度大约为7.22 位。参考下面的示例：
真值（true value）
存储值（stored value）
16,777,215
1.6777215E7
16,777,216
1.6777216E7
16,777,217
1.6777216E7
16,777,218
1.6777218E7
16,777,219
1.677722E7
16,777,220
1.677722E7
16,777,221
1.677722E7
16,777,222
1.6777222E7
16,777,223
1.6777224E7
16,777,224
1.6777224E7
16,777,225
1.6777224E7
根据标准要求，无法精确保存的值必须向最接近的可保存的值进行舍入。这有点像我们熟悉的十进制的四舍五入，即不足一半则舍，一半以上（包括一半）则进。不过对于二进制浮点数而言，还多一条规矩，就是当需要舍入的值刚好是一半时，不是简单地进，而是在前后两个等距接近的可保存的值中，取其中最后一位有效数字为零者。从上面的示例中可以看出，奇数都被舍入为偶数，且有舍有进。我们可以将这种舍入误差理解为"半位"的误差。所以，为了避免7.22 对很多人造成的困惑，有些文章经常以7.5 位来说明单精度浮点数的精度问题。
提示: 这里采用的浮点数舍入规则有时被称为舍入到偶数（Round to Even）。相比简单地逢一半则进的舍入规则，舍入到偶数有助于从某些角度减小计算中产生的舍入误差累积问题。因此为IEEE 标准所采用。
本文来自CSDN博客，转载请标明出处：https://www.wendangku.net/doc/b06634539.html,/KingWolfOfSky/archive/2009/09/08/4533404.aspx
C语言float类型浮点数的存储方法
C语言float类型浮点数的存储方法 #include
浮点数存储
浮点数存储.txt世上最珍贵的不是永远得不到或已经得到的，而是你已经得到并且随时都有可能失去的东西！爱情是灯，友情是影子。灯灭时，你会发现周围都是影子。朋友，是在最后可以给你力量的人。浮点数： 浮点型变量在计算机内存中占用4字节（Byte）,即32-bit。遵循IEEE-754格式标准。一个浮点数由2部分组成：底数m 和指数e。 ±mantissa × 2exponent （注意，公式中的mantissa 和 exponent使用二进制表示） 底数部分使用２进制数来表示此浮点数的实际值。 指数部分占用８-bit的二进制数，可表示数值范围为0－255。 指数应可正可负，所以IEEE规定，此处算出的次方须减去127才是真正的指数。所以float 的指数可从 -126到128 底数部分实际是占用24-bit的一个值，由于其最高位始终为 1 ，所以最高位省去不存储，在存储中只有23-bit。 到目前为止，底数部分 23位加上指数部分 8位使用了31位。那么前面说过，float是占用4个字节即32-bit,那么还有一位是干嘛用的呢？还有一位，其实就是4字节中的最高位，用来指示浮点数的正负，当最高位是1时，为负数，最高位是0时，为正数。 浮点数据就是按下表的格式存储在4个字节中： Address+0 Address+1 Address+2 Address+3 Contents SEEE EEEE EMMM MMMM MMMM MMMM MMMM MMMM S: 表示浮点数正负，1为负数，0为正数 E: 指数加上127后的值的二进制数 M: 24-bit的底数（只存储23-bit） 注意：这里有个特例，浮点数为0时，指数和底数都为0，但此前的公式不成立。因为2的0次方为1，所以，0是个特例。当然，这个特例也不用认为去干扰，编译器会自动去识别。 举例1：计算机存储中的二进制数如何转换成实际浮点数 通过上面的格式，我们下面举例看下-12.5在计算机中存储的具体数据： Address+0 Address+1 Address+2 Address+3 Contents 0xC1 0x48 0x00 0x00 接下来我们验证下上面的数据表示的到底是不是-12.5，从而也看下它的转换过程。 由于浮点数不是以直接格式存储，他有几部分组成，所以要转换浮点数，首先要把各部分的值分离出来。 Address+0 Address+1 Address+2 Address+3 格式 SEEEEEEE EMMMMMMM MMMMMMMM MMMMMMMM
IEEE浮点数的表示方法及规则
计算机组成原理课程作业报告 解决的问题： IEEE浮点数的表示方法及规则 班级： 10021101 学号： 2011302610 姓名：最天使 日期： 2013年10月29日
一、什么是IEEE754标准 1．两种基本浮点格式：单精度和双精度； 2．两种扩展浮点格式：单精度扩展和双精度扩展； 3．浮点数运算的准确度要求：加、减、乘、除、平方、余数，将浮点格式的数舍入为整数值； 4．在十进制字符串和两种基本浮点格式之一的二进制浮点数格式之间的转换的准确度、单一性和一致性要求； 5．五种异常：乘、除、平方根、余数、在不同浮点格； 6．四种舍入方向： ①向最接近的可表示的值：Round(0.5) = 0; Round(1.5) = 2; Round(2.5) = 2; ②当有两个最接近的可表示的值时首选“偶数”值； ③向负无穷大（向下）：floor(1.324) = 1 floor(-1.324) = -2 ④向正无穷大（向上）以及向（截断）：C/C++ 函数ceil() ceil(1.324) = 2 Ceil(-1.324) = -1; 二、IEEE754表示浮点数的格式参数： 类型存储位数偏移值 数符S （位）阶码E （位） 尾数M （位） 总位数 （位） 十六进制十进制 短实数 1 8 23 32 0X7FH +127 长实数 1 11 52 64 0X3FFH +1023 临时实数 1 15 64 80 0X3FFFH +16383 特殊情况： 对于阶码为0或者255时，IEEE有特殊的规定: 1．如果E是0并且M是0，这个数+0（和符号位相关）； 2．如果E=2-1并且M是0，这个数是正负无穷大（和符号相关）； 3．如果E=2-1并且M不是0，这个数表示为不是一个数（NaN）。
数的定点表示和浮点表示
计算机处理的数值数据多数带有小数，小数点在计算机常有两种表示方法，一种是约定所有数值数据的小数点隐含在某一个固定位置上，称为定点表示法，简称定点数；另一种是小数点位置可以浮动，称为浮点表示法，简称浮点数。 1. 定点数表示法(fixed-point) 所谓定点格式，即约定机器中所有数据的小数点位置是固定不变的。在计算机常采用两种简单的约定：将小数点的位置固定在数据的最高位之前，或者是固定在最低位之后。一般常称前者为定点小数，后者为定点整数。 定点小数是纯小数，约定的小数点位置在符号位之后、有效数值部分最高位之前。若数据x的形式为x=x0.x1x2… xn(其中x0为符号位，x1～xn是数值的有效部分，也称为尾数，x1为最高有效位)，则在计算机中的表示形式为： 一般说来，如果最末位xn= 1，前面各位都为0，则数的绝对值最小，即|x|min= 2-n。如果各位均为1，则数的绝对值最大，即|x|max=1-2-n。所以定点小数的表示围是：
2-n≤|x|≤1 -2-n 定点整数是纯整数，约定的小数点位置在有效数值部分最低位之后。若数据x的形式为x=x0x1x2…xn(其中x0为符号位，x1～xn是尾数，xn为最低有效位)，则在计算机中的表示形式为： 定点整数的表示围是： 1≤|x|≤2n-1 当数据小于定点数能表示的最小值时，计算机将它们作0处理，称为下溢；大于定点数能表示的最大值时，计算机将无法表示，称为上溢，上溢和下溢统称为溢出。 计算机采用定点数表示时，对于既有整数又有小数的原始数据，需要设定一个比例因子，数据按其缩小成定点小数或扩大成定点整数再参加运算，运算结果，根据比例因子，还原
C语言的数据类型→浮点型数据
C语言的数据类型→浮点型数据 一、浮点型常量的表示方法： C语言中的浮点数（floating point unmber）就是平常所说的实数。 浮点数有两种表示形式： （1）、十进制小数形式。它由数字和小数点组成（注意必须有小数点）。 如：0.123 、 123.、123.0、0.0 都是十进制小数形式。 （2）、指数形式。 如：123e3或123E3都代表123*103。 注意字母e(或E)之前必须有数字，且e后面的指数必须为整数，如e3、 2.1e 3.5、 e3、 e 等都不是合法的指数形式。 一个浮点数可以有多种指数表示形式。例如123.456e0、 12.3456e1、1.23456e2 、 0.123456e3 、 0.0123456e4 、 0.00123456e5等。其中的1.23456e2称为“规范化的指数形式”。即在字母e(或E)之前的小数部分中，小数点左边应有一位（且只能有一位）非零的数字。例如2.3478e2 、 3.099E5 、 6.46832E12都属于规范化的指数形式，而
12.908e10 、0.4578E3 、 756e0则不属于规范化的指数形式。一个浮点数在用指数形式输出时，是规范化的指数形式输出的。例如。若指定将实数5689.65按指数形式输出。输出的形式是5.68965e+003,而不会是0.568965e+004或56.8965e+002。 二、浮点型变量 一个浮点型数据一般在内存中4个字节（32位）。与整型数据的存储方式不同，浮点型数据是按照指数形式存储的。系统把一个浮点型数据分成小数部分和指数部分，分别存放。指数部分采用规范化的指数形式。例如：实数3.14159在内存中的存放形式可以用下图来表示： 1、浮点型变量在内存中的存放形式。 上图使用十进制数来表示的，实际上在计算机中是用二进制数来表示小数部分以及用2的幂次来表示指数部分的。
2.浮点数的存储原理
问题：long和float类型都是四个字节，为什么存储数值的范围相差极大？ 原因：因为两者的存储原理时不同的。 浮点数的存储原理 作者： jillzhang 联系方式：jillzhang@https://www.wendangku.net/doc/b06634539.html, 本文为原创，转载请保留出处以及作者，谢谢 C语言和C#语言中，对于浮点类型的数据采用单精度类型（float）和双精度类型(double)来存储，float数据占用32bit,double数据占用64bit,我们在声明一个变量float f= 2.25f的时候，是如何分配内存的呢？如果胡乱分配，那世界岂不是乱套了么，其实不论是float还是double在存储方式上都是遵从IEEE的规范的，float遵从的是IEEE R32.24 ,而double 遵从的是R64.53。 无论是单精度还是双精度在存储中都分为三个部分： 1.符号位(Sign) : 0代表正，1代表为负 2.指数位（Exponent）:用于存储科学计数法中的指数数据，并且采用移位存储 3.尾数部分（Mantissa）：尾数部分 其中float的存储方式如下图所示： 而双精度的存储方式为:
R32.24和R64.53的存储方式都是用科学计数法来存储数据的，比如8.25用十进制的科学计数法表示就为:8.25*,而120.5可以表示为:1.205*,这些小学的知识就不用多说了吧。而我们傻蛋计算机根本不认识十进制的数据，他只认识0，1，所以在计算机存储中，首先要将上面的数更改为二进制的科学计数法表示，8.25用二进制表示可表示为1000.01,我靠，不会连这都不会转换吧?那我估计要没辙了。120.5用二进制表示为：1110110.1用二进制的科学计数法表示1000.01可以表示为1.0001* ,1110110.1可以表示为1.1101101*,任何一个数都的科学计数法表示都为1.xxx*,尾数部分就可以表示为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* 按照上面的存储方式，符号位为:0，表示为正，指数位为:3+127=130 ,位数部分为,故8.25的存储方式如下图所示: 而单精度浮点数120.5的存储方式如下图所示:
浮点数的表示和基本运算
浮点数的表示和基本运算 1 浮点数的表示 通常，我们可以用下面的格式来表示浮点数 S P M 其中S是符号位，P是阶码，M是尾数 对于IBM-PC而言，单精度浮点数是32位（即4字节）的，双精度浮点数是64位（即8字节）的。两者的S，P，M所占的位数以及表示方法由下表可知 S P M表示公式偏移量 1823(-1)S*2(P-127)*1.M127 11152(-1)S*2(P-1023)*1.M1023 以单精度浮点数为例，可以得到其二进制的表示格式如下 S(第31位)P(30位到 23位) M(22位到 0位) 其中S是符号位，只有0和1，分别表示正负；P是阶码，通常使用移码表示（移码和补码只有符号位相反，其余都一样。对于正数而言，原码，反码和补码都一样；对于负数而言，补码就是其绝对值的原码全部取反，然后加1.） 为了简单起见，本文都只讨论单精度浮点数，双精度浮点数也是用一样的方式存储和表示的。 2 浮点数的表示约定 单精度浮点数和双精度浮点数都是用IEEE754标准定义的，其中有一些特殊约定。 （1） 当P = 0, M = 0时，表示0。 （2） 当P = 255, M = 0时，表示无穷大，用符号位来确定是正无穷大还是负无穷大。
（3） 当P = 255, M != 0时，表示NaN（Not a Number，不是一个数）。 当我们使用.Net Framework的时候，我们通常会用到下面三个常量 Console.WriteLine(float.MaxValue); // 3.402823E+38 Console.WriteLine(float.MinValue); //-3.402823E+38 Console.WriteLine(float.Epsilon); // 1.401298E-45 //如果我们把它们转换成双精度类型，它们的值如下 Console.WriteLine(Convert.ToDouble(float.MaxValue)); // 3.40282346638529E+38 Console.WriteLine(Convert.ToDouble(float.MinValue)); //-3.40282346638529E+38 Console.WriteLine(Convert.ToDouble(float.Epsilon)); // 1.40129846432482E-45 那么这些值是如何求出来的呢？ 根据上面的约定，我们可以知道阶码P的最大值是11111110（这个值是254，因为255用于特殊的约定，那么对于可以精确表示的数来说，254就是最大的阶码了）。尾数的最大值是11111111111111111111111。 那么这个最大值就是：0 11111110 11111111111111111111111。 也就是 2(254-127) * (1.11111111111111111111111)2 = 2127 * (1+1-2-23) = 3.40282346638529E+38 从上面的双精度表示可以看出，两者是一致的。最小的数自然就是- 3.40282346638529E+38。 对于最接近于0的数，根据IEEE754的约定，为了扩大对0值附近数据的表示能力，取阶码P = -126，尾数 M = (0.00000000000000000000001)2 。此时该数的二进制表示为：0 00000000 00000000000000000000001 也就是2-126 * 2-23 = 2-149 = 1.40129846432482E-45。这个数字和上面的Epsilon 是一致的。 如果我们要精确表示最接近于0的数字，它应该是 0 00000001 00000000000000000000000 也就是：2-126 * (1+0) = 1.17549435082229E-38。 3 浮点数的精度问题 浮点数以有限的32bit长度来反映无限的实数集合，因此大多数情况下都是一个近似值。同时，对于浮点数的运算还同时伴有误差扩散现象。特定精度下看似
有关浮点数在内存中的存储
有关浮点数在内存中的存储 最近想看一下C中float和double型数据在内存中是如何表示的，找到了如下一些东东，与大家分享一下 c语言中FLOAT 是如何表示的？尾数，阶码是如何在32位上安排的，即哪几位是尾数，哪几位是阶码，那一位是符号位。听说与CPU有关，是真的吗？ 在C++里，实数（float）是用四个字节即三十二位二进制位来存储的。其中有1位符号位，8位指数位和23位有效数字位。实际上有效数字位是24位，因为第一位有效数字总是“1”，不必存储。 有效数字位是一个二进制纯小数。8位指数位中第一位是符号位，这符号位和一般的符号位不同，它用“1”代表正，用”0“代表负。整个实数的符号位用“1”代表负，“0”代表正。 在这存储实数的四个字节中，将最高地址字节的最高位编号为31，最低地址字节的最低位编号为0，则实数各个部分在这32个二进制位中的分布是这样的：31位是实数符号位，30位是指数符号位，29---23是指数位，22---0位是有效数字位。注意第一位有效数字是不出现在内存中的，它总是“1”。 将一个实数转化为C++实数存储格式的步骤为： （1）先将这个实数的绝对值化为二进制格式，注意实数的整数部分和小数部分化为二进制的方法是不同的。 （2）将这个二进制格式实数的小数点左移或右移n位，直到小数点移动到第一个有效数字的右边。 （3）从小数点右边第一位开始数出二十三位数字放入第22到第0位。 （4）如果实数是正的，则在第31位放入“0”，否则放入“1”。 （5）如果n 是左移得到的，说明指数是正的，第30位放入“1”。如果n是右移得到的或n=0，则第30位放入“0”。 （6）如果n是左移得到的，则将n减去一然后化为二进制，并在左边加“0”补足七位，放入第29到第23位。如果n是右移得到的或n=0，则将n化为二进制后在左边加“0”补足七位，再各位求反，再放入第29到第23位。 将一个计算机里存储的实数格式转化为通常的十进制的格式的方法如下： （1）将第22位到第0位的二进制数写出来，在最左边补一位“1”，得到二十四位有效数字。将小数点点在最左边那个“1”的右边。 （2）取出第29到第23位所表示的值n。当30位是“0”时将n各位求反。当30位是“1”时将n增1。 （3）将小数点左移n位（当30位是“0”时）或右移n位（当30位是“1”时），得到一个二进制表示的实数。 （4）将这个二进制实数化为十进制，并根据第31位是“0”还是“1”加上正号或负号即可。
浮点数在内存中的表示方法
浮点数在内存中的表示方法 浮点数保存的字节格式如下： 地址+0 +1 +2 +3 内容SEEE EEEE EMMM MMMM MMMM MMMM MMMM MMMM 这里 S 代表符号位，1是负，0是正 E 偏移127的幂，二进制阶码=(EEEEEEEE)-127。 M 24位的尾数保存在23位中，只存储23位，最高位固定为1。此方法用最较少的位数实现了 较高的有效位数，提高了精度。 零是一个特定值，幂是0 尾数也是0。 浮点数-12.5作为一个十六进制数0xC1480000保存在存储区中，这个值如下：地址+0 +1 +2 +3 内容0xC1 0x48 0x00 0x00 浮点数和十六进制等效保存值之间的转换相当简单。下面的例子说明上面的值-12.5如何转换。浮点保存值不是一个直接的格式，要转换为一个浮点数，位必须按上面的浮点数保存格式表 所列的那样分开，例如： 地址+0 +1 +2 +3 格式SEEE EEEE EMMM MMMM MMMM MMMM MMMM MMMM 二进制11000001 01001000 00000000 00000000 十六进制C1 48 00 00 从这个例子可以得到下面的信息： 符号位是1 表示一个负数 幂是二进制10000010或十进制130，130减去127是3，就是实际的幂。尾数是后面的二进制数10010000000000000000000 在尾数的左边有一个省略的小数点和1,这个1在浮点数的保存中经常省略,加上一个1和小数 点到尾数的开头,得到尾数值如下: 1.10010000000000000000000
接着,根据指数调整尾数.一个负的指数向左移动小数点.一个正的指数向右移动 小数点.因为 指数是3,尾数调整如下: 1100.10000000000000000000 结果是一个二进制浮点数，小数点左边的二进制数代表所处位置的2的幂，例如：1100表示 (1*2^3)+(1*2^2)+(0*2^1)+(0*2^0)=12。 小数点的右边也代表所处位置的2的幂，只是幂是负的。例如：.100...表示 (1*2^(-1))+ (0*2^(-2))+(0*2^(-2))...=0.5。 这些值的和是12.5。因为设置的符号位表示这数是负的，因此十六进制值 0xC1480000表示-12.5。 所有的C/C++编译器都是按照IEEE（国际电子电器工程师协会）制定的IEE E 浮点数表示法来进行运算的。这种结构是一种科学表示法，用符号（正或负）、指数和尾数来表示，底数被确定为2，也就是说是把一个浮点数表示为尾数乘以2的指数次方再加上符号。下面来看一下具体的规格: 符号位指数位小数部分 指数偏移量单精度浮点数 1 位[31] 8位 [30-23] 23位 [22-00] 127 双精度浮点数 1 位[63] 11 位[62-52] 52 位[51-00] 1023 我们以单精度浮点数来说明： 指数是8位，可表达的范围是0到255 而对应的实际的指数是－127到＋128 这里特殊说明，－127和＋128这两个数据在IEEE当中是保留的用作多种用途的 －127表示的数字是0 128和其他位数组合表示多种意义，最典型的就是NAN状态
浮点数在内存中的存储方式
浮点数在内存中的存储方式 任何数据在内存中都是以二进制的形式存储的，例如一个short型数据1156，其二进制表示形式为00000100 10000100。则在Intel CPU架构的系统中，存放方式 为10000100(低地址单元) 00000100(高地址单元)，因为Intel CPU的架构是小端模式。但是对于浮点数在内存是如何存储的?目前所有的C/C++编译器都是采用IEEE所制定的标准浮点格式，即二进制科学表示法。 在二进制科学表示法中，S=M*2^N 主要由三部分构成：符号位+阶码(N)+尾数(M)。对于float型数据，其二进制有32位，其中符号位1位，阶码8位，尾数23位；对于double型数据，其二进制为64位，符号位1位，阶码11位，尾数52位。 31 30-23 22-0 float 符号位阶码尾数 63 62-52 51-0 double 符号位阶码尾数 符号位：0表示正，1表示负 阶码：这里阶码采用移码表示，对于float型数据其规定偏置量为127,阶码有正有负，对于8位二进制，则其表示范围为-128-127，double型规定为1023，其表示范围为 -1024-1023。比如对于float型数据，若阶码的真实值为2，则加上127后为129，其阶码表示形式为10000010 尾数:有效数字位，即部分二进制位(小数点后面的二进制位)，因为规定M的整数部分恒为1，所以这个1就不进行存储了。
下面举例说明： float型数据125.5转换为标准浮点格式 125二进制表示形式为1111101，小数部分表示为二进制为1，则125.5二进制表示为1111101.1，由于规定尾数的整数部分恒为1，则表示为1.1111011*2^6，阶码为6，加上127为133，则表示为10000101，而对于尾数将整数部分1去掉，为1111011，在其后面补0使其位数达到23位，则为11110110000000000000000 则其二进制表示形式为 0 10000101 11110110000000000000000，则在内存中存放方式为： 00000000 低地址 00000000 11111011 01000010 高地址 而反过来若要根据二进制形式求算浮点数如0 10000101 11110110000000000000000 由于符号为为0，则为正数。阶码为133-127=6，尾数为11110110000000000000000，则其真实尾数为1.1111011。所以其大小为 1.1111011*2^6，将小数点右移6位，得到1111101.1，而1111101的十进制为125，0.1的十进制为1*2^(-1)=0.5，所以其大小为125.5。 同理若将float型数据0.5转换为二进制形式
浮点数和定点数的区别
cloudseawang 定点数与浮点数区别 最近做HDR时，经常要用NV提供的16位纹理，它的说明书16位能达到24位的精度，就很奇怪？一直搞不懂浮点数的精度怎么算的？ 今天认真看了一下IEEE float point的标准，终于明白是什么了 1. 什么是浮点数 在计算机系统的发展过程中，曾经提出过多种方法表达实数。典型的比如相对于浮点数的定点数（Fixed Point Number）。在这种表达方式中，小数点固定的位于实数所有数字中间的某个位置。货币的表达就可以使用这种方式，比如99.00 或者00.99 可以用于表达具有四位精度（Precision），小数点后有两位的货币值。由于小数点位置固定，所以可以直接用四位数值来表达相应的数值。SQL 中的NUMBER 数据类型就是利用定点数来定义的。还有一种提议的表达方式为有理数表达方式，即用两个整数的比值来表达实数。 定点数表达法的缺点在于其形式过于僵硬，固定的小数点位置决定了固定位数的整数部分和小数部分，不利于同时表达特别大的数或者特别小的数。最终，绝大多数现代的计算机系统采纳了所谓的浮点数表达方式。这种表达方式利用科学计数法来表达实数，即用一个尾数（Mantissa ），一个基数（Base），一个指数（Exponent）以及一个表示正负的符号来表达实数。比如123.45 用十进制科学计数法可以表达为1.2345 × 102 ，其中1.2345 为尾数，10 为基数，2 为指数。浮点数利用指数达到了浮动小数点的效果，从而可以灵活地表达更大范围的实数。 提示: 尾数有时也称为有效数字（Significand）。尾数实际上是有效数字的非正式说法。同样的数值可以有多种浮点数表达方式，比如上面例子中的123.45 可以表达为12.345 ×101，0.12345 × 103 或者1.2345 × 102。因为这种多样性，有必要对其加以规范化以达到统一表达的目标。规范的（Normalized）浮点数表达方式具有如下形式： ±d.dd...d × β e , (0 ≤ d i < β) 其中 d.dd...d 即尾数，β 为基数，e 为指数。尾数中数字的个数称为精度，在本文中用p 来表示。每个数字d 介于0 和基数之间，包括0。小数点左侧的数字不为0。 基于规范表达的浮点数对应的具体值可由下面的表达式计算而得： ±(d 0 + d 1β-1 + ... + d p-1β-(p-1))β e , (0 ≤ d i < β) 对于十进制的浮点数，即基数β 等于10 的浮点数而言，上面的表达式非常容易理解，也很直白。计算机内部的数值表达是基于二进制的。从上面的表达式，我们可以知道，二进制数同样可以有小数点，也同样具有类似于十进制的表达方式。只是此时β 等于2，而每个数字d 只能在0 和 1 之间取值。比如二进制数1001.101 相当于1 × 2 3 + 0 × 22 + 0 ×21 + 1 ×20 + 1 ×2-1 + 0 ×2-2 + 1 ×2-3，对应于十进制的9.625。其规范浮点数表达为1.001101 × 23。 2. IEEE 浮点数 计算机中是用有限的连续字节保存浮点数的。保存这些浮点数当然必须有特定的格式，Java 平台上的浮点数类型float 和double 采纳了IEEE 754 标准中所定义的单精度32 位浮点数和双精度64 位浮点数的格式。 注意: Java 平台还支持该标准定义的两种扩展格式，即float-extended-exponent 和double-extended-exponent 扩展格式。这里将不作介绍，有兴趣的读者可以参考相应的参考资料。 在IEEE 标准中，浮点数是将特定长度的连续字节的所有二进制位分割为特定宽度的符号域，指数域和尾数域三个域，其中保存的值分别用于表示给定二进制浮点数中的符号，
浮点数在计算机内存中的存储格式
浮点数在计算机内存中的存储格式 对于浮点类型的数据采用单精度类型(float)和双精度类型(double)来存储，float数据占用 32bit,double数据占用 64bit,我们在声明一个变量float f = 2.25f的时候，是如何分配内存的呢？其实不论是float类型还是double类型，在计算机内存中的存储方式都是遵从IEEE的规范的，float 遵从的是IEEE R32.24 ,而double 遵从的是R64.53。 无论是单精度还是双精度，在内存存储中都分为3个部分： 1) 符号位(Sign)：0代表正，1代表为负； 2) 指数位(Exponent)：用于存储科学计数法中的指数数据，并且采用移位存储； 3) 尾数部分(Mantissa)：尾数部分； 其中float的存储方式如下图所示： 而双精度的存储方式为: R32.24和R64.53的存储方式都是用科学计数法来存储数据的，比如8.25用十 进制的科学计数法表示就为:8.25*,而120.5可以表示为:1.205*。而我 们傻蛋计算机根本不认识十进制的数据，它只认识0和1，所以在计算机内存中，首先要将上面的数更改为二进制的科学计数法表示，8.25用二进制表示可表示为1000.01，120.5用二进制表示为：1110110.1。用二进制的科学计数法 表示1000.01可以表示为1.00001*，1110110.1可以表示为 1.1101101*,任何一个数的科学计数法表示都为 1.xxx*, 尾数部分就可以表示为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* 按照上面的存储方式，符号位为0，表示为正；指数位为3+127=130，位数部分为 1.00001，故8.25的存储方式如下： 0xbffff380: 01000001000001000000000000000000 分解如下：0--10000010--00001000000000000000000 符号位为0，指数部分为10000010，位数部分为 00001000000000000000000 同理，120.5在内存中的存储格式如下： 0xbffff384: 01000010111100010000000000000000 分解如下：0--10000101--11100010000000000000000 那么如果给出内存中一段数据，并且告诉你是单精度存储的话，你如何知道该数据的十进制数值呢？其实就是对上面的反推过程，比如给出如下内存数据： 01000001001000100000000000000000 第一步：符号位为0，表示是正数； 第二步：指数位为10000010，换算成十进制为130，所以指数为130-127=3； 第三步：尾数位为01000100000000000000000，换算成十进制为 (1+1/4+1/64)； 所以相应的十进制数值为：2^3*(1+1/4+1/64)=8+2+1/8=10.125 再看一个例子，观察其输出： 02 { 03 float f1 = 2.2; 04 float f2 = 2.25;
浮点数表示方法的分析研究
浮点数表示方法的分析研究.txt13母爱是迷惘时苦口婆心的规劝；母爱是远行时一声殷切的叮咛；母爱是孤苦无助时慈祥的微笑。 浮点数表示方法的分析研究 [日期：2006-06-10] 来源：作者： [字体：大中小] 摘要：在《计算机组成原理》课程的教学中，浮点数的表示与运算是一个重点，也是难点。本文对浮点数的一般表示及标准表示的方法、范围、存储格式等进行了比较深入地比较、分析和研究，力求给读者一个清晰的概述。 关键词：浮点数，表示方法，符号，尾数，阶码，范围 《计算机组成原理》课程是计算机科学与技术专业的一门必修专业基础课，主要是讲述计算机系统几大硬件的组成结构和工作原理。在其核心部件——运算器(Arithmetician)的运算机制中，浮点数（Floating-point）的表示与运算方法是一个重点，也是难点，笔者在查阅了大量中外文文献的基础上，根据多年的教学实践经验，对浮点数的表示方法、规格化处理方法、表示范围进行了比较详细地分析研究，以方便学生的学习，共同行们参考。 1、浮点数的一般表示方法 在数学中，表示一个浮点数需要三要素：尾数（mantissa）、指数（exponent，又称阶码）和基数（base），都用其第一个字母来表示的话，那么任意一个浮点数N可以表示成下列形式：N=M×BE，例如N1=1.234×10-6， N2= -0.001011×2011等，同样的数字对于不同的基数是不相同的，移动小数点的位置，其指数相应地跟着变化。在计算机中，表示一个浮点数，同样需要以上三要素，只是阶码与尾数一同存储，基数常有2、8、16等数值，下面的讨论以2为基数进行。 将浮点数放在计算机中存储时，尾数M用定点（Fixed-point）小数的形式，阶码E用有符号整数形式，改变M中小数点的位置，同时需要修改E的值，可以给出有效数字（significant number）的位数，因此M和E决定了浮点数的精度（precision），E指明小数点在B进制数据中的位置，因而E和B决定了浮点数的表示范围（range），浮点数的符号（Sign）是单独考虑，设阶码有m+1位，尾数有n+1位，则一般浮点数的表示方法如图1所示，其中，下标s代表符号位，下标数字代表数字所处的位数，尾数的小数点默认最高数字位M1之前。图（b）是将尾数的符号位提在最前面，其它部分与图（a）一样，是目前常用的一种表示形式。 图1 浮点数的一般表示形式 在这种表示方法中，阶码的二进制编码（binary code）一般是原码（sign magnitude）、补码（twos complement）或移码（bias），尾数的编码一般是原码或补码。 2、浮点数的规格化处理 在浮点数系统中，小数点的浮动使数值的表示不能惟一，从而给数据处理带来困难，因此有必要使浮点数的表示与存储有一定的标准，考虑到阶码、尾数之间的关系，常将尾数的最高数字位是有效值的数值称为规格化（normalization），由于尾数可以是原码或补码，所以有两种规格化的形式，如表1所示。
数的定点表示和浮点表示
计算机处理的数值数据多数带有小数，小数点在计算机中通常有两种表示方法，一种是约定所有数值数据的小数点隐含在某一个固定位置上，称为定点表示法，简称定点数；另一种是小数点位置可以浮动，称为浮点表示法，简称浮点数。 1. 定点数表示法(fixed-point) 所谓定点格式，即约定机器中所有数据的小数点位置是固定不变的。在计算机中通常采用两种简单的约定：将小数点的位置固定在数据的最高位之前，或者是固定在最低位之后。一般常称前者为定点小数，后者为定点整数。 定点小数是纯小数，约定的小数点位置在符号位之后、有效数值部分最高位之前。若数据x的形式为x=x0.x1x2… xn(其中x0为符号位，x1～xn是数值的有效部分，也称为尾数，x1为最高有效位)，则在计算机中的表示形式为： 一般说来，如果最末位xn= 1，前面各位都为0，则数的绝对值最小，即|x|min= 2-n。如果各位均为1，则数的绝对值最大，即|x|max=1-2-n。所以定点小数的表示范围是：
2-n≤|x|≤1 -2-n 定点整数是纯整数，约定的小数点位置在有效数值部分最低位之后。若数据x的形式为x=x0x1x2…xn(其中x0为符号位，x1～xn是尾数，xn为最低有效位)，则在计算机中的表示形式为： 定点整数的表示范围是： 1≤|x|≤2n-1 当数据小于定点数能表示的最小值时，计算机将它们作0处理，称为下溢；大于定点数能表示的最大值时，计算机将无法表示，称为上溢，上溢和下溢统称为溢出。 计算机采用定点数表示时，对于既有整数又有小数的原始数据，需要设定一个比例因子，数据按其缩小成定点小数或扩大成定点整数再参加运算，运算结果，根据比例因子，还原
单双精度浮点数的IEEE标准格式
单双精度浮点数的IEEE标准格式 目前大多数高级语言（包括C）都按照IEEE-754标准来规定浮点数的存储格式，IEEE754规定，单精度浮点数用4字节存储，双精度浮点数用 8字节存储，分为三个部分：符号位、阶和尾数。阶即指数，尾数即有效小数位数。单精度格式阶占8位，尾数占24位，符号位1位，双精度则为11为阶，53 位尾数和1位符号位，如下图所示： 31 30 23 22 0 63 62 52 51 0 细心的人会发现，单双精度各部分所占字节数量比实际存储格式都了一位，的确是这样，事实是，尾数部分包括了一位隐藏位，允许只存储23位就可以表示24位尾数，默认的1位是规格化浮点数的第一位，当规格化一个浮点数时，总是调整它使其值大于等于1而小于2，亦即个位总是为1。例如1100B，对其规格化的结果为1.1乘以2的三次方，但个位1并不存储在23位尾数部分内，这个1是默认位。 阶以移码的形式存储。对于单精度浮点数，偏移量为127（7FH），而双精度的偏移量为1023（3FFH）。存储浮点数的阶码之前，偏移量要先加到阶码上。前面例子中，阶为2的三次方，在单精度浮点数中，移码后的结果为127+3即130（82H），双精度为1026（402H）。 浮点数有两个例外。数0.0存储为全零。无限大数的阶码存储为全1，尾数部分全零。符号位指示正无穷或者负无穷。 下面举几个例子：
所有字节在内存中的排列顺序，intel的cpu按little endian顺序，motorola 的cpu按big endian顺序排列。
IEEE754标准的一个规格化 32位浮点数x的真值可表示为 x=（-1）^S*（1.M）*2^（E-127）e=E－127 31 30 23 0 ｜S ｜ E ｜M ｜ [例1]若浮点数x的754标准存储格式为（41360000）16，求其浮点数的十进制数值。 解：将16进制展开后，可得二进制数格式为 0 100，0001，0 011，0110，0000，0000，0000，0000 S E M 指数e=100，0001，0－01111111=00000011=（3）10 包含隐藏位1的尾数1.M=1.011，0110，0000，0000，0000，0000 于是有x=（-1）^0*（1.M）*2^（E-127） =+（1.011011）2*2^3 =（11.375）10 [例2]将数（20.59375）10转化为754标准的32位浮点数的二进制存储格式。解：首先分别将整数部分和小数部分转换成二进制 （20.59375）10=+（10100.10011）2 然后移动小数点使其在1，2位之间 10100.10011=1.010010011*2^4 e=4 于是得到：S=0，E=e+127=131，M=010010011 最后得到32位浮点数的二进制存储格式为 0 100，0001，1 010，0100，1100，0000，0000，0000 =（41A4C000）16 从存储结构和算法上来讲，double和float是一样的，不一样的地方仅仅是float是32位的，double是64位的，所以double能存储更高的精度。 任何数据在内存中都是以二进制（0或1）顺序存储的，每一个1或0被称为1位，而在 x86CPU上一个字节是8位。比如一个16位（2字节）的 short int型变量的值是1000，那么它的二进制表达就是：00000011 11101000。由于Intel CPU的架构原因，它是按字节倒序存储的，那么就因该是这样：11101000 00000011，这就是定点数1000在内存中的结构。 目前C/C++编译器标准都遵照IEEE制定的浮点数表示法来进行float,double运算。这种结构是一种科学计数法，用符号、指数和尾数来表示，底数定为2——即把一个浮点数表示为尾数乘以2的指数次方再添上符号。下面是具体的规格： ````````符号位阶码尾数长度 float 1 8 23 32 double 1 11 52 64
IEEE浮点数表示法
IEEE浮点数表示法 ------------------------------------------------- float 共计32位(4字节) 由最高到最低位分别是第31、30、29、 0 31位是符号位，1表示该数为负，0反之 30~23位，一共8位是指数位(-128~127) 22~ 0位，一共23位是尾数位 每8位分为一组，分成4组，分别是A组、B组、C组、D组 每一组是一个字节，在内存中逆序存储，即: DCBA 31 30 23 22 0 |-|--------|-----------------------| | | || |-|--------|-----------------------| 注: 尾数的存储位为23位，由于没有存储最高位的1，所以实际有效位为24位。如果其中20位都用来表示小数部分，能表示的最大值为0.999999 我们先不考虑逆序存储的问题，因为那样会把读者彻底搞晕，所以我先按照顺序的来讲，最后再把他们翻过来就行了。
纯整数的表示方法 ------------------------------------------------- 现在让我们按照IEEE浮点数表示法，一步步的将float型浮点数123456.0f转换为十六进制代码。在处理这种不带小数的浮点数时，直接将整数部转化为二进制表示: 1 11100010 01000000 也可以这样表示: 1 11100010 01000000.0 然后将小数点向左移，一直移到离最高位只有1位: 1.11100010 01000000 一共移动了16位，在布耳运算中小数点每向左移一位就等于在以2为底的科学计算法表示中指数+1，所以原数就等于这样 1 11100010 01000000 = 1.11100010 01000000 * (2^16) 现在我们要的尾数和指数都出来了。显而易见，最高位永远是1，因为你不可能把买了16个鸡蛋说成是买了0016个鸡蛋吧?(呵呵，可别拿你买的臭鸡蛋甩我)，所以这个1我们还有必要保留他吗?(众：没有!)好的，我们删掉他。这样尾数的二进制就变成了: 11100010