二进制表示浮点数
 
Prerequisite: Number systems
 
 
 先决条件： 数字系统 
 
 
We all very well know that very small and very large numbers in the decimal number system are represented using scientific notation form by stating a number (mantissa) and an exponent in the power of 10. Some of the examples are 6.27 * 10-27 and 5.21 * 1034. Similarly, Binary numbers can also be represented in the same form by stating a number (mantissa) and an exponent of 2. The format of this representation will be different for different machines.
 
 
 众所周知，十进制数系统中的非常小和非常大的数字都是用科学计数形式表示的，即数字( 尾数 )和幂为10的指数。 一些示例是6.27 * 10 -27和5.21 * 10 34 。 类似地，二进制数字也可以通过表示数字( 尾数 )和2的指数来以相同的形式表示。 对于不同的机器，此表示形式的格式将有所不同。 
 
 
The 16-bit machine consists of 10 bits as the mantissa and 6 bits for the exponent part whereas 24-bit machine consists of 15 bits for mantissa and 9 bits for exponent.
 
 
 16位机器由10位尾数组成， 指数部分为6位，而24位机器由尾数15位组成， 指数部分为9位。 
 
 
Format of the 16-bit machine can be represented as:
 
 
 16位计算机的格式可以表示为： 
 
 
  
Mantissa Part
Exponent Part
0110011010
101010
 
  
 尾数部分 
 指数部分 
 0110011010 
 101010 
 
 
The mantissa is written in 2's complement form, so the MSB of the Mantissa can be thought of as a sign bit. The binary point is assumed to be to the right of this sign bit. The 6-bit of the exponent can be used to represent 0 to 63, however, to express negative exponents a number (32)10 or (100000)2 is added to the desired exponent.
 
 
 尾数以2的补码形式编写，因此可以将尾数的MSB视为符号位。 假定二进制点在该符号位的右边。 指数的6位可用于表示0到63 ，但是，要表示负指数，则将数字(32) 10或(100000) 2添加到所需的指数。 
 
 
Excess-32 Representation: This is a common system to represent floating-point numbers. In this notation, to represent a negative exponent, we add (32)10 to the given exponent which are given by the 6 bits.
 
 
 Excess-32表示法 ：这是表示浮点数的通用系统。 在这种表示法中，为了表示负指数，我们将(32) 10加到由6位给出的给定指数上。 
 
 
Given table illustrates representation of exponent part.
 
 
 给定的表说明了指数部分的表示。 
 
 
  
Desired Exponent
2's complement notation
Excess-32 notation (in 6 bits)
Binary representation
-32
100000
100000 +100000 = 000000
000000
-31
100001
100001 +100000 = 000001
000001
-30
100010
100010 +100000 = 000010
000010
-15
110001
110001 +100000 = 010001
010001
 0
000000
000000 +100000 = 100000
100000
 +1
000001
000001 +100000 = 100001
100001
+15
001111
001111 +100000 = 101111
101111
+30
011110
011110 +100000 = 111110
111110
+31
011111
011111 +100000 = 111111
111111
 
  
 期望指数 
 2的补码表示法 
 多余的32位表示法(6位) 
 二进制表示 
 -32 
 100000 
 100000 +100000 = 000000 
 000000 
 -31 
 100001 
 100001 +100000 = 000001 
 000001 
 -30 
 100010 
 100010 +100000 = 000010 
 000010 
 -15 
 110001 
 110001 +100000 = 010001 
 010001 
 0 
 000000 
 000000 +100000 = 100000 
 100000 
 +1 
 000001 
 000001 +100000 = 100001 
 100001 
 +15 
 001111 
 001111 +100000 = 101111 
 101111 
 +30 
 011110 
 011110 +100000 = 111110 
 111110 
 +31 
 011111 
 011111 +100000 = 111111 
 111111 
 
 
  
Mantissa Part
Exponent Part
0110011010
101010
 
  
 尾数部分 
 指数部分 
 0110011010 
 101010 
 
 
As given above, the floating-point number given in the above format is:
 
 
 如上所述，以上述格式给出的浮点数为： 
 
 
At the extreme left (MSB) is the sign-bit '0', which represents it is a positive number. Also, just after the sign-bit, we assume a binary point. Thus,
 
 
 最左端( MSB )是符号位“ 0” ，表示它是一个正数。 同样，在符号位之后，我们假设一个二进制点。 从而， 
 
 
    In Mantissa Part: .110011010
    In Exponent Part:  101010, In Excess-32 notation,32 is already added. So
    Subtracting 100000   001010 (i.e.,10 in decimal, so exponent part is 210)
    The number is N
        = +(.110011010)2 * 210
        = +(1100110100.00)
        = +(820)10


 
Example 1: Express the following decimal number into 16-bit floating point number (45365.125)10
 
 
 示例1：将以下十进制数表示为16位浮点数(45365.125) 10 
 
 
Solution:
 
 
 解： 
 
 
    Binary equivalent of (45365.125)10: 1011000100110101.001
    Binary format: .1011000100110101 * 216
    Mantissa: + .101100010
    Exponent: 010000 (Value of exponent is 16)
    Equivalent exponent: 010000 + 100000 = 110000


 
Since the number is a positive number an additional sign-bit '0' is added in the MSB.
 
 
 由于该数字为正数，因此在MSB中添加了一个附加符号位“ 0”。 
 
 
So, the floating-point format will be 0101100010110000
 
 
 因此，浮点格式将为0101100010110000 
 
 
Example 2: What floating point number do the given number 0100101001101011 represents?
 
 
 示例2：给定的数字0100101001101011代表什么浮点数？ 
 
 
Solution:
 
 
 解： 
 
 
At the extreme left (MSB) is the sign-bit '0' which represents it is a positive number. Also, just after the sign-bit we assume a binary point. Thus,
 
 
 最左边(MSB)是符号位“ 0”，表示它是一个正数。 同样，在符号位之后，我们假设一个二进制点。 从而， 
 
 
    In Mantissa Part: .100101001
    In Exponent Part: 10101, In Excess-32 notation,32 is already added. So
    Subtracting 100000 001011 (i.e.,11 in decimal, so exponent part is 211)
    The number is N 
        = +(.100101001)2 * 211
        = +(10010100100.0)
        = +(1188)10


 

  
翻译自: https://www.includehelp.com/basics/floating-point-representation-of-binary-numbers.aspx
 
 
二进制表示浮点数

一、十进制数转换为二进制数
 十进制数转换为二进制数时，由于整数和小数的转换方法不同，所以先将十进制数的整数部分和小数部分分别转换后，再加以合并。
 1. 十进制整数转换为二进制整数
 十进制整数转换为二进制整数采用"除2取余，逆序排列"法。具体做法是：用2去除十进制整数，可以得到一个商和余数；再用2去除商，又会得到一个商和余数，如此进行，直到商为零时为止，然后把先得到的余数作为二进制数的低位有效位，后得到的余数作为二进制数的高位有效位，依次排列起来。
 【例1 】 把 (173)10 转换为二进制数。
 
 
2．十进制小数转换为二进制小数
 十进制小数转换成二进制小数采用"乘2取整，顺序排列"法。具体做法是：用2乘十进制小数，可以得到积，将积的整数部分取出，再用2乘余下的小数 部分，又得到一个积，再将积的整数部分取出，如此进行，直到积中的小数部分为零，或者达到所要求的精度为止。
 然后把取出的整数部分按顺序排列起来，先取的整数作为二进制小数的高位有效位，后取的整数作为低位有效位。
 【例2】把（0.8125）10转换为二进制小数。
 
 【例3】（173.8125）10＝（ ）2
 解： 由【例1】得（173）10＝（10101101）2
 由【例2】得（0.8125）10＝（0.1101）2
 把整数部分和小数部分合并得： （173.8125）10＝（10101101.1101）2
 更具体二进制和十进制之间的转换参考：https://jingyan.baidu.com/article/597a0643614568312b5243c0.html
 
二、浮点类型数据的存储
 对于浮点类型的数据采用单精度类型（float）和双精度类型(double)来存储，float数据占用32bit,double数据占用64bit,不论是float还是double在存储方式上都是遵从IEEE的规范的，float遵从的是IEEE R32.24 ,而double 遵从的是R64.53。
 
无论是单精度还是双精度在存储中都分为三个部分：
 
符号位(Sign) : 0代表正，1代表为负
 指数位（Exponent）:用于存储科学计数法中的指数数据，并且采用移位存储
 尾数部分（Mantissa）：尾数部分
 其中float类型数据的存储方式如下图所示：
 
 
而double类型数据的存储方式为:
 
 
R32.24和R64.53的存储方式都是用科学计数法来存储数据的，比如8.25用十进制的科学计数法表示为:8.2510º,而120.5可以表示为:1.20510²。而计算机根本不认识十进制的数据，他只认识0，1。所以在计算机存储中，首先要将上面的数更改为二进制的科学计数法表示。8.25用二进制表示可表示为1000.01。120.5用二进制表示为：1111000.1。用二进制的科学计数法表示1000.01可以表示为1.0000110³,1111000.1可以表示为1.111000110^6。第一位都是1，所以可以将小数点前面的1省略，所以23bit的尾数部分，可以表示的精度却变成了24bit，道理就是在这里，那24bit能精确到小数点后几位呢，我们知道9的二进制表示为1001，所以4bit能精确十进制中的1位小数点，24bit就能使float能精确到小数点后6位，而对于指数部分，因为指数可正可负，8位的指数位能表示的指数范围就应该为:-127-128了，所以指数部分的存储采用移位存储，存储的数据为元数据+127，下面就看看8.25和120.5在内存中真正的存储方式。
 
值得注意的一个问题是：书上说之所以要将指数加上 127 来得到阶码，是为了简化浮点数的比较运算，这一点我没有体会出来。但是通过 127 这个偏移量 (移码)，可以区分出指数的正负。阶码为 127 时表示指数为 0；阶码小于 127 时表示负指数；阶码大于 127 时表示正指数。
 
首先看下8.25，用二进制的科学计数法表示为:1.00001*10³
 
按照上面的存储方式，符号位为:0，表示为正，指数位为:3+127=130 ,位数部分为,故8.25的存储方式如下图所示:
 
 
而单精度浮点数120.5的存储方式如下图所示:
 
 具体浮点型数据存储方式参考：https://wenku.baidu.com/view/905828797fd5360cbb1adb07.html

整数转化为二进制
 1.正整数用源码表示
 2.负整数用绝对值的补码表示（将绝对值取反+1）
 如-50用50的补码表示
 50的源码为 00000000000000000000000000110010
 反码则为   11111111111111111111111111001101
 补码为反码+1 11111111111111111111111111001110
 
二进制转化为整数
 1.如果符号位为0，表示为正，直接将二进制数据翻译即可
 2.如果符号位为1，表示为负，将数据－1取反.或者（取反+1）
 如： 11111111111111111111111111001110
 -1： 11111111111111111111111111001101 
 取反： 00000000000000000000000000110010
 源码： 11111111111111111111111111001110
 取反： 00000000000000000000000000110001
 +1： 00000000000000000000000000110010
 
浮点型转化为二进制
 将整数转化为二进制，去掉首位1，小数转化为二进制，整数去1后二进制位数+127转化为二进制，然后根据浮点型正负在最前面加上符号位。
 如：-40.125
 整数为101000，去掉首位1则为01000，小数为001，则整数位数为5，+127＝132（10000100），加上符号位1，则二进制数据为 100 0010 0
 整数：         1010 00
 去掉首位1：         010 00
 加上前八位表示小数点位置： 100 0010 0010 0000 1
 加上小数位：               100 0010 0010 0000 1000 0000 0000 0000
 加上符号位：    1100 0010 0010 0000 1000 0000 0000 0000  
 
二进制转化为浮点型
 去掉首位符号位，取前八位-127然后将剩余的二进制数据小数点后移所得值，首位+1，小数点之前位整数，之后为小数，由符号位判断正负。
 如：正数： 0100 0011 0100 0100 0100 0110 1111 1100
 去掉符号位：     100 0011 0100 0100 0100 0110 1111 1100
 前八位   100 0011 0＝134    -124 ＝7； 
 整数：      100 0100    首位+1   1100 0100＝196 
 小数：        0100 0110 1111 1100 
 小数依次乘1/2，1/4，1/8，1/16....＝1/2*0+1/4*1+1/8*0+1/16*0+1/32*0+1/64*1......最后得出保留四位小数的话是196.2769
 负数：
 如：  1100 0010 0010 0010 0111 1110 1001 0000
 取掉符号位：   100 0010 0010 0010 0111 1110 1001 0000
 取前八位  100 0010 0    ＝132  -127＝5
 整数部分：                 010 00                           首位+1  ＝1010 00   ＝40
 小数部分    10 0111 1110 1001 0000   ＝1/2+1/16+1/32+1/64+1/128+1/256+....＝0.621浮点数为 -40.621  
 
十进制小数→→→→→二进制小数 方法：“乘2取整”
 
对十进制小数乘2得到的整数部分和小数部分,整数部分既是相应的二进制数码,再用2乘小数部分(之前乘后得到新的小数部分),又得到整数和小数部分.
 
如此不断重复,直到小数部分为0或达到精度要求为止.第一次所得到为最高位,最后一次得到为最低位
 
如:0.25的二进制
 
0.25*2=0.5  取整是0
 
0.5*2=1.0    取整是1
 
即0.25的二进制为 0.01 ( 第一次所得到为最高位,最后一次得到为最低位)
 
0.8125的二进制
 
0.8125*2=1.625   取整是1
 
0.625*2=1.25     取整是1
 
0.25*2=0.5       取整是0
 
0.5*2=1.0        取整是1
 
即0.8125的二进制是0.1101（第一次所得到为最高位,最后一次得到为最低位）
 
 
 
十进制小数→→→→→八进制小数 方法：“乘8取整”
 
0.71875）10 =（0.56）8
 
 
 
0.71875*8=5.75  取整5
 
0.75*8=6.0      取整6
 
即0.56
 
十进制小数→→→→→十六进制小数方法：“乘16取整”例如：
 
(0.142578125)10=(0.248)16
 
 
 
0.142578125*16=2.28125  取整2
 
0.28125*16=4.5          取整4
 
0.5*16=8.0              取整8
 
即0.248
 
 
 
 
 
 
 
 
 
非十进制数之间的转换
 
（1）二进制数与八进制数之间的转换
 
转换方法是：以小数点为界，分别向左右每三位二进制数合成一位八进制数，或每一位八进制数展成三位二进制数，不足三位者补0。例如：
 
（423。45）8=（100 010 011.100 101）2
 
（1001001.1101）2=（001 001 001.110 100）2=（111.64）8
 
（2）二进制与十六进制转换
 
转换方法：以小数点为界，分别向左右每四位二进制合成一位十六进制数，或每一位十六进制数展成四位二进制数，不足四位者补0。例如：
 
（ABCD。EF）16=（1010 1011 1100 1101.1110 1111）2

上一篇我们讲了二进制转十进制的规则，这一篇我们来看看浮点数是如何用二进制表示的。
 
像100.011这样带小数点的表现形式，是方便我们阅读的二进制形式，在计算机内部是无法直接使用的，那么实际上计算机内部是如何处理小数的呢？很多编程语言都提供了两种表示小数的数据类型，单精度浮点数和双精度浮点数。
 
单精度浮点数类型float用32位数据表示，双精度浮点数类型double用64位数据表示，这些数据类型都用浮点数来表示小数，浮点数又是什么东西呢？我们来看一下。
 
在六、七十年代，各家计算机公司的各个型号的计算机，有着千差万别的浮点数表示，却没有一个业界通用的标准。这给数据交换、计算机协同工作造成了极大不便。各自为政，那怎么行呢？直到1985年，IEEE（电气和电子工程师协会）统一了浮点数的表示规则，后来此标准被称为IEEE745浮点标准，大大提高了科学应用程序在不同机器上的可移植性。
 
IEEE浮点数标准用以下形式表示一个数：
 
 
1.S表示符号位，0表示正数，1表示负数
 
2.M表示尾数，大于等于1小于2
 
3.E表示2的E次幂
 
 
 
由于1≤M<2，也就是说，M可以写成1.xxxxxx的形式，其中xxxxxx表示小数部分。IEEE 754规定，在计算机内部保存M时，默认这个数的第一位总是1，因此可以被舍去，只保存后面的xxxxxx部分。比如保存1.101的时候，只保存101，等到读取的时候，再把第一位的1加上去。这样做的目的，是节省1位有效数字。以32位浮点数为例，留给M只有23位，将第一位的1舍去以后，等于可以保存24位有效数字。你看，一不小心又提高了一位精度，科学家为了少用1位的空间都绞尽脑汁，我们平时写程序经常浪费巨大的开销都浑然不觉，相比之下，实在汗颜。
 
 
 
单精度的浮点数表示如下：
 
 
 
 
双精度的浮点数表示如下：
 
 
第一位是符号位，0表示正数，1表示负数，这个很好理解。
 
指数部分有点特殊，因为指数有正数也有负数，指数部分没有符号位，那如何表示正数和负数呢？聪明的科学家找到了一个方法，取一个中间值，小于中间值的表示负数，等于中间值的表示0，大于中间值的表示正数，中间值的定义如下：
 
 
 
 
单精度的中间值是127
 
 
 
 
双精度的中间值是1023
 
 
 
 
 
比如单精度的指数部分为10110001，转换成十进制是177，那么指数部分就是177-127 等于 50。
 
 
 
我们来看一下1.25用浮点数是怎么表示的，在Java中输出1.25的二进制如下：
 
 
 
由于输出的二进制数量不足32位，在前面补2个0，让它的长度变成32位：00111111101000000000000000000000
 
 
 
浮点数转换成十进制计算过程如下：
 
 
 
 
1. 符号位0表示正数
 
2. 指数部分，01111111的十进制值是127，单精度的中间值是127，127-127=0，所以指数部分是0
 
3. 尾数部分，前面隐藏了1，加上1后就是1.01000000000000000000000转成十进制就是1.25
 
4. 1.25 * 2^0 = 1.25 * 1 = 1.25
 
 
 
这样分析一下，对浮点数是不是更了解一些了呢？欢迎关注我的公众号，嘻嘻。