Golang 筆記之深刻浮點數

引言

下面的一段簡單程序 0.3 + 0.6 結果是什麼？

1 var f1 float64 = 0.32 var f2 float64 = 0.63 fmt.Println(f1 + f2)

有人會天真的認爲是0.9，但實際輸出倒是0.8999999999999999（go 1.13.5）

問題在於大多數小數表示成二進制以後是近似且無限的。
以0.1爲例。它多是你能想到的最簡單的十進制之一，可是二進制看起來卻很是複雜：0.0001100110011001100…
其是一串連續循環無限的數字（涉及到10進制轉換爲2進制，暫不介紹）。
結果的荒誕性告訴咱們，必須深刻理解浮點數在計算機中的存儲方式及其性質，才能正確處理數字的計算。
golang 與其餘不少語言（C、C++、Python…）同樣，使用了IEEE-754標準存儲浮點數。

IEEE-754 如何存儲浮點數

IEEE-754規範使用特殊的以2爲基數的科學表示法表示浮點數。

32位的單精度浮點數 與 64位的雙精度浮點數的差別

符號位：1 爲 負數， 0 爲正數。
指數位：存儲 指數加上偏移量，偏移量是爲了表達負數而設計的。
小數位：存儲係數的小數位的準確或者最接近的值。

以 數字 0.085 爲例。

小位數的表達方式

以0.36 爲例:
010 1110 0001 0100 0111 1011 = 0.36 (第一位數字表明1/2,第二位數字是1/4…，0.36 是全部位相加)
分解後的計算步驟爲:

go語言顯示浮點數 - 驗證以前的理論

接下來用一個案例有助於咱們理解並驗證IEEE-754 浮點數的表示方式。

math.Float32bits 能夠爲咱們打印出32位數據的二進制表示。(注：math.Float64bits能夠打印64位數據的二進制)

下面的go代碼將輸出0.085的浮點數二進制表達，而且爲了驗證以前理論的正確性，根據二進制表示反向推導出其所表示的原始十進制0.085

 

輸出：代表咱們對於浮點數的理解正確。

1 Starting Number: 0.0850002 Bit Pattern: 0 | 0111 1011 | 010 1110 0001 0100 0111 10113 Sign: 0 Exponent: 123 (-4) Mantissa: 0.360000 Value: 0.085000

經典問題：如何判斷一個浮點數其實存儲的是整數

下面是一個有趣的問題，如何判斷一個浮點數其實存儲的是整數？

思考10秒鐘…

下面是一段判斷浮點數是否爲整數的go代碼實現，咱們接下來逐行分析函數。
它能夠加深對於浮點數的理解

 

一、要保證是整數，一個重要的條件是必需要指數位大於127，若是指數位爲127，表明指數爲0. 指數位大於127，表明指數大於0， 反之小於0.

下面咱們以數字234523爲例子：

第一步,計算指數。因爲 多減去了23，因此在第一個判斷中 判斷條件爲 exponent < -23
exponent := int(bits >> 23) - bias - 23

第二步，
(bits & ((1 << 23) - 1)) 計算小數位。

| (1 << 23) 表明 將1加在前方。
1 + 小數 = 係數。

 第三步，計算intTest 只有當指數的倍數能夠彌補最小的小數位的時候，纔是一個整數。
以下，指數是17位，其不可以彌補最後6位的小數。即不能彌補1/2^18 的小數。
因爲2^18位以後爲0.因此是整數。

golang decimal 包詳解

要理解decimal包，首先須要知道兩個重要的概念，Normal number、denormal (or subnormal) number 以及精度。

1.概念：Normal number and denormal (or subnormal) number

wiki的解釋是：

 

什麼意思呢？在IEEE-754中指數位有一個偏移量，偏移量是爲了表達負數而設計的。好比單精度中的0.085，實際的指數是 -3， 存儲到指數位是123。
因此表達的負數就是有上限的。這個上限就是2^-126。若是比這個負數還要小，例如2^-127,這個時候應該表達爲0.1 * 2 ^ -126. 這時係數變爲了避免是1爲前導的數，這個數就叫作denormal (or subnormal) number。
正常的係數是以1爲前導的數就叫作Normal number。

2.概念：精度

精度是一個很是複雜的概念，在這裏筆者討論的是2進制浮點數的10進制精度。
精度爲d表示的是在一個範圍內，若是咱們將d位10進制（按照科學計數法表達）轉換爲二進制。再將二進制轉換爲d位10進制。數據不損失意味着在此範圍內是有d精度的。
精度的緣由在於，數據在進制之間相互轉換時，是不可以精準匹配的，而是匹配到一個最近的數。如圖所示：

                                          精度轉換

 

在這裏暫時不深刻探討，而是給出結論：（注：精度是動態變化的，不一樣的範圍可能有不一樣的精度。這是因爲 2的冪 與 10的冪之間的交錯是不一樣的。）

float32的精度爲6-8位，

float64的精度爲15-17位

目前使用比較多的精準操做浮點數的decimal包是shopspring/decimal。連接:https://github.com/shopspring/decimal

decimal包使用math/big包存儲大整數並進行大整數的計算。

好比對於字符串 「123.45」 咱們能夠將其轉換爲12345這個大整數，以及-2表明指數。參考decimal結構體：

在本文中，筆者不會探討math/big是如何進行大整數運算的，而是探討decimal包一個很是重要的函數：

NewFromFloat(value float64) Decimal

其主要調用了下面的函數：

 

此函數會將浮點數轉換爲Decimal結構。
讀者想象一下這個問題：若是存儲到浮點數中的值（例如0.1）自己就是一個近似值，爲何decimal包可以解決計算的準確性？
緣由在於，deciimal包能夠精準的將一個浮點數轉換爲10進制。這就是NewFromFloat爲咱們作的事情。
下面我將對此函數作逐行分析。

 

第5行：剝離出IEEE浮點數的指數位
exp := int(bits>>flt.mantbits) & (1<<flt.expbits - 1)

第6行：剝離出浮點數的係數的小數位
mant := bits & (uint64(1)<<flt.mantbits - 1)

第7行：若是是指數位爲0，表明浮點數是denormal (or subnormal) number；
默認狀況下會在mant以前加上1，由於mant只是係數的小數，在前面加上1後，表明真正的小數位。
如今 mant = IEEE浮點數係數 * 2^53

第13行：加上偏移量，exp如今表明真正的指數。
第14行：引入了一箇中間結構decimal

第15行：調用d.Assign(mant) , 將mant做爲10進制數，存起來。
10進制數的每一位都做爲一個字符存儲到 decimal的byte數組中

第16行：調用shift函數，這個函數很是難理解。

 

此函數的功能是爲了獲取此浮點數表明的10進制數據的整數位個數以及小數位個數，此函數的完整證實附後。（注1)
exp是真實的指數，其也是可以覆蓋小數部分2進制位的個數。（參考前面如何判斷浮點數是整數）
exp - int(flt.mantbits)表明不能被exp覆蓋的2進制位的個數
若是exp - int(flt.mantbits) > 0 表明exp可以徹底覆蓋小數位 所以 浮點數是一個很是大的整數，這時會調用leftShift(a, uint(k))。不然將調用rightShift(a, uint(-k)), 常規rightShift會調用得更多。所以咱們來看看rightShift函數的實現。

第5行：此for循環將計算浮點數10進製表示的小數部分的有效位爲 r-1 。
n >> k 是一個重要的衡量指標，表明了小數部分與整數部分的分割。此函數的完整證實附後。（注1)

第21行：此時整數部分所佔的有效位數爲a.dp -=（r-1）
第24行：這兩個循環作了2件事情：
一、計算10進製表示的有效位數
二、將10進製表示存入bytes數組中。例如對於浮點數64.125，如今byte數組存儲的前5位就是64125

 

繼續回到newFromFloat函數，第18行，調用了roundShortest函數，
此函數很是關鍵。其會將浮點數轉換爲離其最近的十進制數。
這是爲何decimal.NewFromFloat(0.1)可以精準表達0.1的緣由。

參考上面的精度，此函數主要考察了2的冪與10的冪之間的交錯關係。四捨五入到最接近的10進制值。
此函數實質實現的是Grisu3 算法,有想深刻了解的能夠去看看論文。筆者在這裏提示幾點：
一、2^exp <= d < 10^dp。
二、10進制數之間至少相聚10^(dp-nd)
三、2的冪之間的最小間距至少爲2^(exp-mantbits)
四、何時d就是最接近2進制的10進制數？
若是10^(dp-nd) > 2^(exp-mantbits)，代表 當十進制降低一個最小位數時，匹配到的是更小的數字value - 2^(exp-mantbits)，因此d就是最接近浮點數的10進制數。

 

 

繼續回到newFromFloat函數，第19行 若是精度小於19，是位於int64範圍內的，可使用快速路徑，不然使用math/big包進行賦值操做，效率稍微要慢一些。
第36行，正常狀況幾乎不會發生。若是setstring在異常的狀況下會調用NewFromFloatWithExponent 指定精度進行四捨五入截斷。

注一：快速的獲取一個浮點數表明的十進制

以典型的數字64.125 爲例 ， 它能夠被浮點數二進制精準表達爲：
Bit Patterns: 0 | 10000000101 | 0000000010000000000000000000000000000000000000000000
Sign: 0 | Exponent: 1029 (6) | Mantissa: 0.001953

即 64.125 = 1.001953125 * 2^6
注意觀察浮點數的小數位在第九位有1, 表明2^-9 即 0.001953125.

咱們在浮點數的小數位前 附上數字1，10000000010000000000000000000000000000000000000000000 表明其爲1 / 2^0 .

此時咱們能夠認爲這個數表明的是1.001953125. 那麼這樣長的二進制數變爲10進制又是多少呢:4512395720392704。

即 1.001953125 = 4512395720392704 * 2^(-52)

因此64.125 = 4512395720392704 * 2^(-52) * 2^6 = 4512395720392704 * 2^(-46)
在這裏，有一種重要的等式。即 (2 ^ -46) 等價於向左移動了46位。而且移動後剩下的部分即爲64,而捨棄的部分實際上是小數部分0.125。
這個等式看似複雜其實很好證實，即第46位其實表明的是2^45。其除以2^46後是一個小數。依次類推…

所以對於數字 4512395720392704 ， 咱們能夠用4，45，451，4512 … 依次除以 2 ^ 46. 一直到找到數451239572039270 其除以2^46不爲0。這個不爲0的數必定爲6。
接着咱們保留後46位，實際上是保留了小數位。

假設 4512395720392704 / 2^46 = (6 + num)
64.125 =(6 + num) * 10 + C = 60 + 10* num + C

當咱們將經過位運算保留後46位，設爲A, 則 A / 2^46 = num
因此 (A * 10 + C) / 2 ^46 =(num * 10 +C) = 4.125
此咱們又能夠把4提取出來。實在精彩。
10進制小數位的提取是同樣的，留給讀者本身探索。

總結

一、本文介紹了go語言使用的IEEE-754標準存儲浮點數的具體存儲方式。

二、本文經過實際代碼片斷和一個腦筋急轉彎幫助讀者理解浮點數的存儲方式。

三、本文介紹了normal number 以及精度這兩個重要概念。

四、本文詳細介紹了shopspring/decimal的實現方式，即藉助了big.int，以及進制的巧妙精準轉換。

五、shopspring/decimal其實在精度的巧妙轉換方面參考了go源碼ftoa函數的實現。讀者能夠參考go源碼

六、shopspring/decimal目前roundShortest函數有一個bug，筆者已經提交了pr，此bug已在go源碼中獲得了修復。

七、big.int計算存在效率問題，若是遇到特殊的快速大量計算的場景可能不太適合。

八、還有一些decimal的實現，例如tibd/decimal,代碼實在不忍淬讀。

九、浮點數計算，除了要解決進制的轉換外，還須要解決重要的溢出問題，例如相乘經常要超過int64的範圍，這就是爲何shopspring/decimal使用了big.int,而tibd/decimal將數據轉換爲了不少的word（int32），致使其計算很是複雜。

參考資料

1.Why 0.1 Does Not Exist In Floating-Point

2.Normal number

3.7-bits-are-not-enough-for-2-digit-accuracy

4.Decimal Precision of Binary Floating-Point Numbers

5.Introduction To Numeric Constants In Go