15. Floating-Point Arithmetic:  Issues and Limitations
******************************************************

浮動小数点数はコンピューターのハードウェア上は2進数(binary)の分数で表
されます。 たとえば、**10進数** の分数では "0.625" は 6/10 + 2/100 +
5/1000 という値を持ち、**2進数** の分数では "0.101" は 1/2 + 0/4 + 1/8
という値を持ちます。 この2つの分数はまったく同じ値を持ち、唯一異なる点
は1つ目が10進数の分数で書かれており、2つ目は2進数の分数で書かれている
ということです。

残念なことに、ほとんどの小数は 2 進法の分数として正確に表わすことがで
きません。その結果、一般に、入力した 10 進の浮動小数点数は、 2 進法の
浮動小数点数で近似された後、実際にマシンに記憶されます。

最初は基数 10 を使うと問題を簡単に理解できます。分数 1/3 を考えてみま
しょう。分数 1/3 は、基数 10 の分数として、以下のように近似することが
できます:

   0.3

さらに正確な近似は、

   0.33

さらに正確な近似は、

   0.333

となり、以後同様です。何個桁数を増やして書こうが、結果は決して厳密な
1/3 にはなりません。しかし、少しづつ正確な近似にはなっていくでしょう。

同様に、基数を 2 とした表現で何桁使おうとも、10 進数の 0.1 は基数を 2
とした小数で正確に表現することはできません。基数 2 では、1/10 は循環小
数 (repeating fraction) となります

   0.0001100110011001100110011001100110011001100110011...

どこか有限の桁で止めると、近似値を得ることになります。近年の殆どのコン
ピュータでは float 型は、最上位ビットから数えて最初の 53 ビットを分子
、2 の冪乗を分母とした、二進小数で近似されます。1/10 の場合は、二進小
数は "3602879701896397 / 2 ** 55" となります。これは、1/10 に近いです
が、厳密に同じ値ではありません。

値が表示される方法のために、ほとんどのユーザは、近似に気づきません。
Python はマシンに格納されている二進近似値の10進小数での近似値を表示す
るので、格納されている値が元の10進小数の近似値でしか無いことを忘れがち
です。ほとんどのマシンで、もし Python が2進数で近似された 0.1 の近似値
をそのまま10進数で表示していたら、その結果は次のようになったでしょう:

   >>> 0.1
   0.1000000000000000055511151231257827021181583404541015625

これは、ほとんどの人が必要と感じるよりも多すぎる桁数です。なので、
Python は丸めた値を表示することで、桁数を扱いやすい範囲にとどめます:

   >>> 1 / 10
   0.1

表示された結果が正確に 1/10 であるように見えたとしても、実際に格納され
ている値は最も近く表現できる二進小数であるということだけは覚えておいて
ください。

幾つかの異なる10進数の値が、同じ2進有理数の近似値を共有しています。例
えば、"0.1" と "0.10000000000000001" と
"0.1000000000000000055511151231257827021181583404541015625" はどれも
"3602879701896397 / 2 ** 55" に近似されます。同じ近似値を共有している
ので、どの10進数の値も "eval(repr(x)) == x" という条件を満たしたまま同
じように表示されます。

昔の Python は、プロンプトと "repr()" ビルトイン関数は 17 桁の有効数字
を持つ "0.10000000000000001" のような10進数の値を選んで表示していまし
た。 Python 3.1 からは、ほとんどの場面で "0.1" のような最も短い桁数の
10進数の値を選ぶようになりました。

Note that this is in the very nature of binary floating point: this is
not a bug in Python, and it is not a bug in your code either.  You'll
see the same kind of thing in all languages that support your
hardware's floating-point arithmetic (although some languages may not
*display* the difference by default, or in all output modes).

よりよい出力のために、文字列フォーマットを利用して有効桁数を制限した10
進数表現を得ることができます:

   >>> format(math.pi, '.12g')  # give 12 significant digits
   '3.14159265359'

   >>> format(math.pi, '.2f')   # give 2 digits after the point
   '3.14'

   >>> repr(math.pi)
   '3.141592653589793'

これが、実際のコンピューター上の値の *表示* を丸めているだけの、いわば
錯覚だということを認識しておいてください。

もう一つの錯覚を紹介します。例えば、0.1 が正確には 1/10 ではないために
、それを3回足した値もまた正確には 0.3 ではありません:

   >>> 0.1 + 0.1 + 0.1 == 0.3
   False

0.1 はこれ以上 1/10 に近くなることができない値で、 0.3 もまた 3/10 に
一番近い値なので、 "round()" 関数を使って計算前に丸めを行なっても意味
がありません:

   >>> round(0.1, 1) + round(0.1, 1) + round(0.1, 1) == round(0.3, 1)
   False

数値を意図した正確な値に近づけることはできませんが、 "math.isclose()"
関数は不正確な値を比べるのに便利です:

   >>> math.isclose(0.1 + 0.1 + 0.1, 0.3)
   True

あるいは、 "round()" 関数を粗い近似値比較に使うこともできます:

   >>> round(math.pi, ndigits=2) == round(22 / 7, ndigits=2)
   True

Binary floating-point arithmetic holds many surprises like this.  The
problem with "0.1" is explained in precise detail below, in the
"Representation Error" section.  See Examples of Floating Point
Problems for a pleasant summary of how binary floating point works and
the kinds of problems commonly encountered in practice.  Also see The
Perils of Floating Point for a more complete account of other common
surprises.

As that says near the end, "there are no easy answers."  Still, don't
be unduly wary of floating point!  The errors in Python float
operations are inherited from the floating-point hardware, and on most
machines are on the order of no more than 1 part in 2**53 per
operation.  That's more than adequate for most tasks, but you do need
to keep in mind that it's not decimal arithmetic and that every float
operation can suffer a new rounding error.

異常なケースが存在する一方で、普段の浮動小数点演算の利用では、単に最終
的な結果の値を必要な 10 進の桁数に丸めて表示するのなら、最終的には期待
通りの結果を得ることになるでしょう。たいては "str()" で十分ですが、き
め細かな制御をしたければ、 書式指定文字列の文法 にある "str.format()"
メソッドのフォーマット仕様を参照してください。

正確な10進数表現が必要となるような場合には、 "decimal" モジュールを利
用してみてください。このモジュールは会計アプリケーションや高精度の計算
が求められるアプリケーションに適した、10進数の計算を実装しています。

別の正確な計算方法として、 "fractions" モジュールが有理数に基づく計算
を実装しています (1/3 のような数を正確に表すことができます)。

あなたが浮動小数点演算のヘビーユーザーなら、SciPy プロジェクトが提供し
ている NumPy パッケージやその他の数学用パッケージを調べてみるべきです
。 <https://scipy.org> を参照してください。

Python は *本当に* float の正確な値が必要なレアケースに対応するための
ツールを提供しています。 "float.as_integer_ratio()" メソッドは float
の値を有理数として表現します:

   >>> x = 3.14159
   >>> x.as_integer_ratio()
   (3537115888337719, 1125899906842624)

この分数は正確なので、元の値を完全に復元することができます:

   >>> x == 3537115888337719 / 1125899906842624
   True

"float.hex()" メソッドは float の値を16進数で表現します。この値もコン
ピューターが持っている正確な値を表現できます:

   >>> x.hex()
   '0x1.921f9f01b866ep+1'

この正確な16進数表現はもとの float 値を正確に復元するために使うことが
できます:

   >>> x == float.fromhex('0x1.921f9f01b866ep+1')
   True

この16進数表現は正確なので、値を (プラットフォームにも依存せず) バージ
ョンの異なるPython 間でやり取りしたり、他のこのフォーマットをサポート
した言語 (Java や C99 など) と正確にやり取りするのに利用することができ
ます。

別の便利なツールとして、合計処理における精度のロスを緩和してくれる
"sum()" 関数があります。これは累計加算中の丸めに拡張精度を使います。こ
れにより、誤差が最終的な合計値に影響を与えるまで蓄積されなくなり、結果
が改善されます:

   >>> 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 == 1.0
   False
   >>> sum([0.1] * 10) == 1.0
   True

"math.fsum()" はさらに進んで、累計の加算時に「失われた桁」をすべて追跡
し、結果の丸めは一度だけです。これは "sum()" より遅いものの、大きな入
力がほとんど相殺され、最終的な合計がゼロに近くなるような珍しいケースで
は、より正確です:

   >>> arr = [-0.10430216751806065, -266310978.67179024, 143401161448607.16,
   ...        -143401161400469.7, 266262841.31058735, -0.003244936839808227]
   >>> float(sum(map(Fraction, arr)))   # Exact summation with single rounding
   8.042173697819788e-13
   >>> math.fsum(arr)                   # Single rounding
   8.042173697819788e-13
   >>> sum(arr)                         # Multiple roundings in extended precision
   8.042178034628478e-13
   >>> total = 0.0
   >>> for x in arr:
   ...     total += x                   # Multiple roundings in standard precision
   ...
   >>> total                            # Straight addition has no correct digits!
   -0.0051575902860057365


15.1. 表現エラー
================

この章では、"0.1" の例について詳細に説明し、このようなケースに対してど
のようにすれば正確な分析を自分で行えるかを示します。ここでは、 2 進法
表現の浮動小数点数についての基礎的な知識があるものとして話を進めます。

表現エラー(*Representation error*)は、いくつかの (実際にはほとんどの)
10 進の小数が 2 進法 (基数 2)の分数として表現できないという事実に関係
しています。これは Python (あるいは Perl, C, C++, Java, Fortran. およ
びその他多く) が期待通りの正確な 10 進数を表示できない主要な理由です。

なぜそうなるのでしょう？ 1/10 は２進法の小数で厳密に表現できません。少
なくとも2000年以降、ほぼすべてのマシンは IEEE 754 2進数の浮動小数点演
算を用いており、ほぼすべてのプラットフォームでは Python の浮動小数点を
IEEE 754 binary64 "倍精度 (double precision)" 値に対応付けます。 IEEE
754 binary64 値は 53 ビットの精度を持つため、計算機に入力を行おうとす
ると、可能な限り 0.1 を最も近い値の分数に変換し、*J*/2***N* の形式にし
ようと努力します。*J* はちょうど 53 ビットの精度の整数です。

   1 / 10 ~= J / (2**N)

を書き直すと

   J ~= 2**N / 10

となります。 *J* は厳密に 53 ビットの精度を持っている (">= 2**52" だが
"< 2**53" ) ことを思い出すと、 *N* として最適な値は 56 になります:

   >>> 2**52 <=  2**56 // 10  < 2**53
   True

すなわち、56 は *J* をちょうど 53 ビットの精度のままに保つ *N* の唯一
の値です。*J* の取りえる値はその商を丸めたものです:

   >>> q, r = divmod(2**56, 10)
   >>> r
   6

剰余が 10 の半分以上なので、最良の近似は切り上げて丸めたものになります
。:

   >>> q+1
   7205759403792794

従って、IEEE 754の倍精度における 1/10 の取りえる最良の近似は:

   7205759403792794 / 2 ** 56

分子と分母を2で割って分数を小さくします:

   3602879701896397 / 2 ** 55

丸めたときに切り上げたので、この値は実際には 1/10 より少し大きいことに
注目してください。 もし切り捨てをした場合は、商は 1/10 よりもわずかに
小さくなります。どちらにしろ *厳密な* 1/10 ではありません！

つまり、計算機は 1/10 を "理解する" ことは決してありません。計算機が理
解できるのは、上記のような厳密な分数であり、IEEE 754 の倍精度浮動小数
点数で得られるもっともよい近似は以下になります:

   >>> 0.1 * 2 ** 55
   3602879701896397.0

この分数に 10**55 を掛ければ、55 桁の十進数の値を見ることができます:

   >>> 3602879701896397 * 10 ** 55 // 2 ** 55
   1000000000000000055511151231257827021181583404541015625

これは、計算機が記憶している正確な数値が、10 進数値
0.1000000000000000055511151231257827021181583404541015625 にほぼ等しい
ということです。多くの言語 (古いバージョンの Python を含む) では、完全
な 10 進値を表示するのではなく、結果を有効数字 17 桁に丸めます:

   >>> format(0.1, '.17f')
   '0.10000000000000001'

"fractions" モジュールと "decimal" モジュールを使うとこれらの計算を簡
単に行えます:

   >>> from decimal import Decimal
   >>> from fractions import Fraction

   >>> Fraction.from_float(0.1)
   Fraction(3602879701896397, 36028797018963968)

   >>> (0.1).as_integer_ratio()
   (3602879701896397, 36028797018963968)

   >>> Decimal.from_float(0.1)
   Decimal('0.1000000000000000055511151231257827021181583404541015625')

   >>> format(Decimal.from_float(0.1), '.17')
   '0.10000000000000001'
