floatingpoint.po

# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001 Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
#
# Translators:
# python-doc bot, 2025
# Takanori Suzuki <takanori@takanory.net>, 2025
#
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.15\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2026-10-01 19:07+0000\n"
"PO-Revision-Date: 2025-09-16 00:02+0000\n"
"Last-Translator: Takanori Suzuki <takanori@takanory.net>, 2025\n"
"Language-Team: Japanese (https://app.transifex.com/python-doc/teams/5390/"
"ja/)\n"
"Language: ja\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=1; plural=0;\n"

#: ../../tutorial/floatingpoint.rst:10
msgid "Floating-Point Arithmetic:  Issues and Limitations"
msgstr "浮動小数点演算、その問題と制限"

#: ../../tutorial/floatingpoint.rst:12
msgid ""
"Floating-point numbers are represented in computer hardware as base 2 "
"(binary) fractions.  For example, the **decimal** fraction ``0.625`` has "
"value 6/10 + 2/100 + 5/1000, and in the same way the **binary** fraction "
"``0.101`` has value 1/2 + 0/4 + 1/8. These two fractions have identical "
"values, the only real difference being that the first is written in base 10 "
"fractional notation, and the second in base 2."
msgstr ""
"浮動小数点数は、コンピューターのハードウェア上では 2 進小数で表されます。\n"
"例えば、 **10 進小数** の ``0.625`` は 6/10 + 2/100 + 5/1000 という値を持ち、"
"同様に **2 進小数** の ``0.101`` は 1/2 + 0/4 + 1/8 という値を持ちます。\n"
"この二つの小数は同じ値を表しています。違いは、前者が 10 進法、後者が 2 進法の"
"小数表記で書かれていることだけです。"

#: ../../tutorial/floatingpoint.rst:19
msgid ""
"Unfortunately, most decimal fractions cannot be represented exactly as "
"binary fractions.  A consequence is that, in general, the decimal floating-"
"point numbers you enter are only approximated by the binary floating-point "
"numbers actually stored in the machine."
msgstr ""
"残念ながら、ほとんどの 10 進小数は 2 進小数として正確に表せません。そのため、"
"入力した 10 進の浮動小数点数に対して、実際にコンピューターに格納される 2 進の"
"浮動小数点数は、一般に近似値にすぎません。"

#: ../../tutorial/floatingpoint.rst:24
msgid ""
"The problem is easier to understand at first in base 10.  Consider the "
"fraction 1/3.  You can approximate that as a base 10 fraction::"
msgstr ""
"まず 10 進法で考えると、この問題を理解しやすくなります。分数 1/3 を考えてみま"
"しょう。これは 10 進小数で次のように近似できます::"

#: ../../tutorial/floatingpoint.rst:27
msgid "0.3"
msgstr "0.3"

#: ../../tutorial/floatingpoint.rst:29 ../../tutorial/floatingpoint.rst:33
msgid "or, better, ::"
msgstr "さらに正確な近似は、 ::"

#: ../../tutorial/floatingpoint.rst:31
msgid "0.33"
msgstr "0.33"

#: ../../tutorial/floatingpoint.rst:35
msgid "0.333"
msgstr "0.333"

#: ../../tutorial/floatingpoint.rst:37
msgid ""
"and so on.  No matter how many digits you're willing to write down, the "
"result will never be exactly 1/3, but will be an increasingly better "
"approximation of 1/3."
msgstr ""
"というように続きます。何桁まで書いても、結果が正確に 1/3 になることはありませ"
"んが、桁数を増やすほど 1/3 に近い近似値になります。"

#: ../../tutorial/floatingpoint.rst:41
msgid ""
"In the same way, no matter how many base 2 digits you're willing to use, the "
"decimal value 0.1 cannot be represented exactly as a base 2 fraction.  In "
"base 2, 1/10 is the infinitely repeating fraction ::"
msgstr ""
"同様に、2 進法で何桁使っても、10 進数の 0.1 を 2 進小数として正確に表すことは"
"できません。2 進法では、1/10 は次のように無限に繰り返す循環小数になります::"

#: ../../tutorial/floatingpoint.rst:45
msgid "0.0001100110011001100110011001100110011001100110011..."
msgstr "0.0001100110011001100110011001100110011001100110011..."

#: ../../tutorial/floatingpoint.rst:47
msgid ""
"Stop at any finite number of bits, and you get an approximation.  On most "
"machines today, floats are approximated using a binary fraction with the "
"numerator using the first 53 bits starting with the most significant bit and "
"with the denominator as a power of two.  In the case of 1/10, the binary "
"fraction is ``3602879701896397 / 2 ** 55`` which is close to but not exactly "
"equal to the true value of 1/10."
msgstr ""
"有限のビット数で打ち切ると、得られるのは近似値です。現在のほとんどのコン"
"ピューターでは、浮動小数点数は、最上位ビットから数えて最初の 53 ビットを分子"
"に使い、2 の冪乗を分母とする分数で近似されます。1/10 の場合、この分数は "
"``3602879701896397 / 2 ** 55`` です。これは 1/10 に近い値ですが、正確に等しい"
"わけではありません。"

#: ../../tutorial/floatingpoint.rst:54
msgid ""
"Many users are not aware of the approximation because of the way values are "
"displayed.  Python only prints a decimal approximation to the true decimal "
"value of the binary approximation stored by the machine.  On most machines, "
"if Python were to print the true decimal value of the binary approximation "
"stored for 0.1, it would have to display::"
msgstr ""
"値の表示方式によって、ほとんどのユーザーはこの近似に気づきません。Python が表"
"示するのは、コンピューターに格納された 2 進の近似値を正確に 10 進数で表した値"
"ではなく、それをさらに 10 進数で近似した値です。ほとんどのコンピューターで、"
"0.1 に対して格納された 2 進の近似値を Python が正確に 10 進数で表示するとすれ"
"ば、次のように表示する必要があります::"

#: ../../tutorial/floatingpoint.rst:60
msgid ""
">>> 0.1\n"
"0.1000000000000000055511151231257827021181583404541015625"
msgstr ""
">>> 0.1\n"
"0.1000000000000000055511151231257827021181583404541015625"

#: ../../tutorial/floatingpoint.rst:63
msgid ""
"That is more digits than most people find useful, so Python keeps the number "
"of digits manageable by displaying a rounded value instead:"
msgstr ""
"これは、ほとんどの人が必要と感じるよりも多すぎる桁数です。なので、Python は丸"
"めた値を表示することで、桁数を扱いやすい範囲にとどめます:"

#: ../../tutorial/floatingpoint.rst:66
msgid ""
">>> 1 / 10\n"
"0.1"
msgstr ""
">>> 1 / 10\n"
"0.1"

#: ../../tutorial/floatingpoint.rst:71
msgid ""
"Just remember, even though the printed result looks like the exact value of "
"1/10, the actual stored value is the nearest representable binary fraction."
msgstr ""
"表示された結果が正確に 1/10 であるように見えても、実際に格納されている値は、"
"表現可能な 2 進小数のうち 1/10 に最も近い値だということを覚えておいてくださ"
"い。"

#: ../../tutorial/floatingpoint.rst:74
msgid ""
"Interestingly, there are many different decimal numbers that share the same "
"nearest approximate binary fraction.  For example, the numbers ``0.1`` and "
"``0.10000000000000001`` and "
"``0.1000000000000000055511151231257827021181583404541015625`` are all "
"approximated by ``3602879701896397 / 2 ** 55``.  Since all of these decimal "
"values share the same approximation, any one of them could be displayed "
"while still preserving the invariant ``eval(repr(x)) == x``."
msgstr ""
"興味深いことに、異なる多くの 10 進数が、最も近い近似値として同じ 2 進小数に対"
"応します。例えば、``0.1`` と ``0.10000000000000001`` と "
"``0.1000000000000000055511151231257827021181583404541015625`` はどれも "
"``3602879701896397 / 2 ** 55`` で近似されます。これらの 10 進数は同じ近似値に"
"対応するため、どれを選んで表示しても、 ``eval(repr(x)) == x`` という条件を保"
"てます。"

#: ../../tutorial/floatingpoint.rst:82
msgid ""
"Historically, the Python prompt and built-in :func:`repr` function would "
"choose the one with 17 significant digits, ``0.10000000000000001``.   "
"Starting with Python 3.1, Python (on most systems) is now able to choose the "
"shortest of these and simply display ``0.1``."
msgstr ""
"以前は、Python のプロンプトと組み込み関数 :func:`repr` は、有効数字 17 桁の "
"``0.10000000000000001`` を選んで表示していました。Python 3.1 以降は、ほとんど"
"のシステムで、これらのうち最も短い表現を選び、単に ``0.1`` と表示できるように"
"なりました。"

#: ../../tutorial/floatingpoint.rst:87
msgid ""
"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)."
msgstr ""
"この動作は2進数の浮動小数点にとってはごく自然なものです。これは Python のバグ"
"ではありませんし、あなたのコードのバグでもありません。ハードウェアの浮動小数"
"点演算をサポートしている全ての言語で同じ種類の問題を見つけることができます "
"(いくつかの言語ではデフォルトの、あるいはどの出力モードを選んでも、この差を "
"**表示** しないかもしれませんが)。"

#: ../../tutorial/floatingpoint.rst:93
msgid ""
"For more pleasant output, you may wish to use string formatting to produce a "
"limited number of significant digits:"
msgstr ""
"よりよい出力のために、文字列フォーマットを利用して有効桁数を制限した10進数表"
"現を得ることができます:"

#: ../../tutorial/floatingpoint.rst:96
msgid ""
">>> format(math.pi, '.12g')  # give 12 significant digits\n"
"'3.14159265359'\n"
"\n"
">>> format(math.pi, '.2f')   # give 2 digits after the point\n"
"'3.14'\n"
"\n"
">>> repr(math.pi)\n"
"'3.141592653589793'"
msgstr ""
">>> format(math.pi, '.12g')  # 有効数字 12 桁で表示\n"
"'3.14159265359'\n"
"\n"
">>> format(math.pi, '.2f')   # 小数点以下 2 桁で表示\n"
"'3.14'\n"
"\n"
">>> repr(math.pi)\n"
"'3.141592653589793'"

#: ../../tutorial/floatingpoint.rst:107
msgid ""
"It's important to realize that this is, in a real sense, an illusion: you're "
"simply rounding the *display* of the true machine value."
msgstr ""
"これが、実際のコンピューター上の値の *表示* を丸めているだけの、いわば錯覚だ"
"ということを認識しておいてください。"

#: ../../tutorial/floatingpoint.rst:110
msgid ""
"One illusion may beget another.  For example, since 0.1 is not exactly 1/10, "
"summing three values of 0.1 may not yield exactly 0.3, either:"
msgstr ""
"一つの錯覚が別の錯覚を生むこともあります。例えば、0.1 は正確には 1/10 ではな"
"いため、0.1 を三つ足した結果も正確に 0.3 になるとは限りません:"

#: ../../tutorial/floatingpoint.rst:113
msgid ""
">>> 0.1 + 0.1 + 0.1 == 0.3\n"
"False"
msgstr ""
">>> 0.1 + 0.1 + 0.1 == 0.3\n"
"False"

#: ../../tutorial/floatingpoint.rst:118
msgid ""
"Also, since the 0.1 cannot get any closer to the exact value of 1/10 and 0.3 "
"cannot get any closer to the exact value of 3/10, then pre-rounding with :"
"func:`round` function cannot help:"
msgstr ""
"0.1 はこれ以上 1/10 に近くなることができない値で、 0.3 もまた 3/10 に一番近い"
"値なので、 :func:`round` 関数を使って計算前に丸めを行なっても意味がありませ"
"ん:"

#: ../../tutorial/floatingpoint.rst:122
msgid ""
">>> round(0.1, 1) + round(0.1, 1) + round(0.1, 1) == round(0.3, 1)\n"
"False"
msgstr ""
">>> round(0.1, 1) + round(0.1, 1) + round(0.1, 1) == round(0.3, 1)\n"
"False"

#: ../../tutorial/floatingpoint.rst:127
msgid ""
"Though the numbers cannot be made closer to their intended exact values, "
"the :func:`math.isclose` function can be useful for comparing inexact values:"
msgstr ""
"これらの数値を意図した正確な値にさらに近づけることはできませんが、誤差を含む"
"値を比較するには :func:`math.isclose` 関数が役立ちます:"

#: ../../tutorial/floatingpoint.rst:130
msgid ""
">>> math.isclose(0.1 + 0.1 + 0.1, 0.3)\n"
"True"
msgstr ""
">>> math.isclose(0.1 + 0.1 + 0.1, 0.3)\n"
"True"

#: ../../tutorial/floatingpoint.rst:135
msgid ""
"Alternatively, the :func:`round` function can be used to compare rough "
"approximations:"
msgstr "あるいは、 :func:`round` 関数を粗い近似値比較に使うこともできます:"

#: ../../tutorial/floatingpoint.rst:138
msgid ""
">>> round(math.pi, ndigits=2) == round(22 / 7, ndigits=2)\n"
"True"
msgstr ""
">>> round(math.pi, ndigits=2) == round(22 / 7, ndigits=2)\n"
"True"

#: ../../tutorial/floatingpoint.rst:143
msgid ""
"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 "
"<https://jvns.ca/blog/2023/01/13/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 <http://www.indowsway.com/floatingpoint.htm>`_ for a more complete "
"account of other common surprises."
msgstr ""
"2 進浮動小数点演算には、このような意外な挙動が数多くあります。「0.1」の問題に"
"ついて詳しい説明は、「表現誤差」セクションで行います。2進数の浮動小数点の仕組"
"みと、実際によく遭遇する問題各種についての分かりやすい概要は、 `Examples of "
"Floating Point Problems <https://jvns.ca/blog/2023/01/13/examples-of-"
"floating-point-problems/>`_ を参照してください。その他のよく見られる意外な挙"
"動について、より詳しくは `The Perils of Floating Point <http://www.indowsway."
"com/floatingpoint.htm>`_ も参照してください。"

#: ../../tutorial/floatingpoint.rst:152
msgid ""
"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."
msgstr ""
"その記事の終わり近くにもあるように、「簡単な答えはありません」。とはいえ、浮"
"動小数点数を過度に警戒しないでください。Python の浮動小数点演算の誤差は浮動小"
"数点演算を行うハードウェアに由来し、ほとんどのコンピューターでは演算ごとに"
"高々 2\\*\\*53 分の 1 程度です。これはほとんどの用途で十分な精度です。ただ"
"し、10 進の演算ではないこと、そして浮動小数点演算のたびに新たな丸め誤差が生じ"
"る可能性があることを覚えておく必要があります。"

#: ../../tutorial/floatingpoint.rst:159
msgid ""
"While pathological cases do exist, for most casual use of floating-point "
"arithmetic you'll see the result you expect in the end if you simply round "
"the display of your final results to the number of decimal digits you "
"expect. :func:`str` usually suffices, and for finer control see the :meth:"
"`str.format` method's format specifiers in :ref:`formatstrings`."
msgstr ""
"極端なケースはあるものの、普段の浮動小数点演算では最終結果の表示を必要な 10 "
"進の桁数に丸めるだけで、たいていは期待する結果が得られます。通常は :func:"
"`str` で十分ですが、より細かく制御するには、 :ref:`formatstrings` にある :"
"meth:`str.format` メソッドの書式指定子を参照してください。"

#: ../../tutorial/floatingpoint.rst:165
msgid ""
"For use cases which require exact decimal representation, try using the :mod:"
"`decimal` module which implements decimal arithmetic suitable for accounting "
"applications and high-precision applications."
msgstr ""
"正確な10進数表現が必要となるような場合には、 :mod:`decimal` モジュールを利用"
"してみてください。このモジュールは会計アプリケーションや高精度の計算が求めら"
"れるアプリケーションに適した、10進数の計算を実装しています。"

#: ../../tutorial/floatingpoint.rst:169
msgid ""
"Another form of exact arithmetic is supported by the :mod:`fractions` module "
"which implements arithmetic based on rational numbers (so the numbers like "
"1/3 can be represented exactly)."
msgstr ""
"別の正確な計算方法として、 :mod:`fractions` モジュールが有理数に基づく計算を"
"実装しています (1/3 のような数を正確に表すことができます)。"

#: ../../tutorial/floatingpoint.rst:173
msgid ""
"If you are a heavy user of floating-point operations you should take a look "
"at the NumPy package and many other packages for mathematical and "
"statistical operations supplied by the SciPy project. See <https://scipy."
"org>."
msgstr ""
"浮動小数点演算を頻繁に使う場合は、NumPy パッケージや、SciPy プロジェクトが提"
"供するその他の数学・統計演算用の多くのパッケージを調べてみてください。 "
"<https://scipy.org> を参照してください。"

#: ../../tutorial/floatingpoint.rst:177
msgid ""
"Python provides tools that may help on those rare occasions when you really "
"*do* want to know the exact value of a float.  The :meth:`float."
"as_integer_ratio` method expresses the value of a float as a fraction:"
msgstr ""
"浮動小数点数の正確な値を *本当に* 知りたいというまれな場合に役立つツールも、"
"Python は提供しています。 :meth:`float.as_integer_ratio` メソッドは、浮動小数"
"点数の値を分数として表します:"

#: ../../tutorial/floatingpoint.rst:182
msgid ""
">>> x = 3.14159\n"
">>> x.as_integer_ratio()\n"
"(3537115888337719, 1125899906842624)"
msgstr ""
">>> x = 3.14159\n"
">>> x.as_integer_ratio()\n"
"(3537115888337719, 1125899906842624)"

#: ../../tutorial/floatingpoint.rst:188
msgid ""
"Since the ratio is exact, it can be used to losslessly recreate the original "
"value:"
msgstr "この分数は正確なので、元の値を完全に復元することができます:"

#: ../../tutorial/floatingpoint.rst:191
msgid ""
">>> x == 3537115888337719 / 1125899906842624\n"
"True"
msgstr ""
">>> x == 3537115888337719 / 1125899906842624\n"
"True"

#: ../../tutorial/floatingpoint.rst:196
msgid ""
"The :meth:`float.hex` method expresses a float in hexadecimal (base 16), "
"again giving the exact value stored by your computer:"
msgstr ""
":meth:`float.hex` メソッドは float の値を16進数で表現します。この値もコン"
"ピューターが持っている正確な値を表現できます:"

#: ../../tutorial/floatingpoint.rst:199
msgid ""
">>> x.hex()\n"
"'0x1.921f9f01b866ep+1'"
msgstr ""
">>> x.hex()\n"
"'0x1.921f9f01b866ep+1'"

#: ../../tutorial/floatingpoint.rst:204
msgid ""
"This precise hexadecimal representation can be used to reconstruct the float "
"value exactly:"
msgstr ""
"この正確な16進数表現はもとの float 値を正確に復元するために使うことができま"
"す:"

#: ../../tutorial/floatingpoint.rst:207
msgid ""
">>> x == float.fromhex('0x1.921f9f01b866ep+1')\n"
"True"
msgstr ""
">>> x == float.fromhex('0x1.921f9f01b866ep+1')\n"
"True"

#: ../../tutorial/floatingpoint.rst:212
msgid ""
"Since the representation is exact, it is useful for reliably porting values "
"across different versions of Python (platform independence) and exchanging "
"data with other languages that support the same format (such as Java and "
"C99)."
msgstr ""
"この16進数表現は正確なので、値を (プラットフォームにも依存せず) バージョンの"
"異なるPython 間でやり取りしたり、他のこのフォーマットをサポートした言語 "
"(Java や C99 など) と正確にやり取りするのに利用することができます。"

#: ../../tutorial/floatingpoint.rst:216
msgid ""
"Another helpful tool is the :func:`sum` function which helps mitigate loss-"
"of-precision during summation.  It uses extended precision for intermediate "
"rounding steps as values are added onto a running total. That can make a "
"difference in overall accuracy so that the errors do not accumulate to the "
"point where they affect the final total:"
msgstr ""
"もう一つ便利なのが、合計を求める際の精度の低下を抑える :func:`sum` 関数です。"
"累計に値を加えていく途中の丸め処理に拡張精度を使います。これにより、誤差が蓄"
"積して最終的な合計値に影響するのを抑え、結果の精度を改善できる場合があります:"

#: ../../tutorial/floatingpoint.rst:222
msgid ""
">>> 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 == 1.0\n"
"False\n"
">>> sum([0.1] * 10) == 1.0\n"
"True"
msgstr ""
">>> 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 == 1.0\n"
"False\n"
">>> sum([0.1] * 10) == 1.0\n"
"True"

#: ../../tutorial/floatingpoint.rst:229
msgid ""
"The :func:`math.fsum` goes further and tracks all of the \"lost digits\" as "
"values are added onto a running total so that the result has only a single "
"rounding.  This is slower than :func:`sum` but will be more accurate in "
"uncommon cases where large magnitude inputs mostly cancel each other out "
"leaving a final sum near zero:"
msgstr ""
":func:`math.fsum` はさらに進んで、累計に値を加える際に「失われた桁」を全て追"
"跡し、結果を得るまでの丸めを一度だけに抑えます。これは :func:`sum` より低速で"
"すが、絶対値の大きい入力値が互いにほぼ打ち消し合い、最終的な合計がゼロに近く"
"なるようなまれな場合には、より正確な結果が得られます:"

#: ../../tutorial/floatingpoint.rst:235
msgid ""
">>> arr = [-0.10430216751806065, -266310978.67179024, 143401161448607.16,\n"
"...        -143401161400469.7, 266262841.31058735, -0.003244936839808227]\n"
">>> float(sum(map(Fraction, arr)))   # Exact summation with single rounding\n"
"8.042173697819788e-13\n"
">>> math.fsum(arr)                   # Single rounding\n"
"8.042173697819788e-13\n"
">>> sum(arr)                         # Multiple roundings in extended "
"precision\n"
"8.042178034628478e-13\n"
">>> total = 0.0\n"
">>> for x in arr:\n"
"...     total += x                   # Multiple roundings in standard "
"precision\n"
"...\n"
">>> total                            # Straight addition has no correct "
"digits!\n"
"-0.0051575902860057365"
msgstr ""
">>> arr = [-0.10430216751806065, -266310978.67179024, 143401161448607.16,\n"
"...        -143401161400469.7, 266262841.31058735, -0.003244936839808227]\n"
">>> float(sum(map(Fraction, arr)))   # 正確に合計し、一度だけ丸める\n"
"8.042173697819788e-13\n"
">>> math.fsum(arr)                   # 一度だけ丸める\n"
"8.042173697819788e-13\n"
">>> sum(arr)                         # 拡張精度で複数回丸める\n"
"8.042178034628478e-13\n"
">>> total = 0.0\n"
">>> for x in arr:\n"
"...     total += x                   # 標準精度で複数回丸める\n"
"...\n"
">>> total                            # 単純な加算では正しい桁が一つもない！\n"
"-0.0051575902860057365"

#: ../../tutorial/floatingpoint.rst:256
msgid "Representation Error"
msgstr "表現誤差"

#: ../../tutorial/floatingpoint.rst:258
msgid ""
"This section explains the \"0.1\" example in detail, and shows how you can "
"perform an exact analysis of cases like this yourself.  Basic familiarity "
"with binary floating-point representation is assumed."
msgstr ""
"この章では、\"0.1\" の例について詳細に説明し、このようなケースに対してどのよ"
"うにすれば正確な分析を自分で行えるかを示します。ここでは、 2 進法表現の浮動小"
"数点数についての基礎的な知識があるものとして話を進めます。"

#: ../../tutorial/floatingpoint.rst:262
msgid ""
":dfn:`Representation error` refers to the fact that some (most, actually) "
"decimal fractions cannot be represented exactly as binary (base 2) "
"fractions. This is the chief reason why Python (or Perl, C, C++, Java, "
"Fortran, and many others) often won't display the exact decimal number you "
"expect."
msgstr ""
"表現誤差 (:dfn:`Representation error`) とは、一部の (実際にはほとんどの) 10 "
"進小数を 2 進小数として正確に表せないことを指します。これが、Python (あるい"
"は Perl、C、C++、Java、Fortran など多くの言語) で、期待した正確な 10 進数が表"
"示されないことがよくある主な理由です。"

#: ../../tutorial/floatingpoint.rst:267
msgid ""
"Why is that?  1/10 is not exactly representable as a binary fraction.  Since "
"at least 2000, almost all machines use IEEE 754 binary floating-point "
"arithmetic, and almost all platforms map Python floats to IEEE 754 binary64 "
"\"double precision\" values.  IEEE 754 binary64 values contain 53 bits of "
"precision, so on input the computer strives to convert 0.1 to the closest "
"fraction it can of the form *J*/2**\\ *N* where *J* is an integer containing "
"exactly 53 bits. Rewriting ::"
msgstr ""
"なぜそうなるのでしょうか。1/10 は 2 進小数として正確に表せません。少なくとも "
"2000 年以降、ほぼ全てのコンピューターは IEEE 754 の 2 進浮動小数点演算を使"
"い、ほぼ全てのプラットフォームで Python の浮動小数点数は IEEE 754 binary64 の"
"「倍精度」値に対応しています。IEEE 754 binary64 の値は 53 ビットの精度を持つ"
"ため、0.1 を入力すると、コンピューターは *J*/2**\\ *N* の形で表せる分数のうち"
"最も近い値に変換します。ここで *J* はちょうど 53 ビットの整数です。次の式::"

#: ../../tutorial/floatingpoint.rst:276
msgid "1 / 10 ~= J / (2**N)"
msgstr "1 / 10 ~= J / (2**N)"

#: ../../tutorial/floatingpoint.rst:278
msgid "as ::"
msgstr "を書き直すと ::"

#: ../../tutorial/floatingpoint.rst:280
msgid "J ~= 2**N / 10"
msgstr "J ~= 2**N / 10"

#: ../../tutorial/floatingpoint.rst:282
msgid ""
"and recalling that *J* has exactly 53 bits (is ``>= 2**52`` but ``< "
"2**53``), the best value for *N* is 56:"
msgstr ""
"となります。 *J* がちょうど 53 ビットの整数である (``>= 2**52`` かつ ``< "
"2**53``) ことを思い出すと、 *N* として最適な値は 56 になります:"

#: ../../tutorial/floatingpoint.rst:285
msgid ""
">>> 2**52 <=  2**56 // 10  < 2**53\n"
"True"
msgstr ""
">>> 2**52 <=  2**56 // 10  < 2**53\n"
"True"

#: ../../tutorial/floatingpoint.rst:290
msgid ""
"That is, 56 is the only value for *N* that leaves *J* with exactly 53 bits.  "
"The best possible value for *J* is then that quotient rounded:"
msgstr ""
"つまり、 *J* がちょうど 53 ビットになる *N* の値は 56 だけです。このとき、 "
"*J* として最適な値は、その商を丸めたものになります:"

#: ../../tutorial/floatingpoint.rst:293
msgid ""
">>> q, r = divmod(2**56, 10)\n"
">>> r\n"
"6"
msgstr ""
">>> q, r = divmod(2**56, 10)\n"
">>> r\n"
"6"

#: ../../tutorial/floatingpoint.rst:299
msgid ""
"Since the remainder is more than half of 10, the best approximation is "
"obtained by rounding up:"
msgstr "余りが 10 の半分より大きいため、切り上げると最もよい近似が得られます:"

#: ../../tutorial/floatingpoint.rst:302
msgid ""
">>> q+1\n"
"7205759403792794"
msgstr ""
">>> q+1\n"
"7205759403792794"

#: ../../tutorial/floatingpoint.rst:309
msgid ""
"Therefore the best possible approximation to 1/10 in IEEE 754 double "
"precision is::"
msgstr "従って、IEEE 754の倍精度における 1/10 の取りえる最良の近似は::"

#: ../../tutorial/floatingpoint.rst:312
msgid "7205759403792794 / 2 ** 56"
msgstr "7205759403792794 / 2 ** 56"

#: ../../tutorial/floatingpoint.rst:314
msgid ""
"Dividing both the numerator and denominator by two reduces the fraction to::"
msgstr "分子と分母を 2 で割って約分すると、次のようになります::"

#: ../../tutorial/floatingpoint.rst:316
msgid "3602879701896397 / 2 ** 55"
msgstr "3602879701896397 / 2 ** 55"

#: ../../tutorial/floatingpoint.rst:318
msgid ""
"Note that since we rounded up, this is actually a little bit larger than "
"1/10; if we had not rounded up, the quotient would have been a little bit "
"smaller than 1/10.  But in no case can it be *exactly* 1/10!"
msgstr ""
"丸めたときに切り上げたので、この値は実際には 1/10 より少し大きいことに注目し"
"てください。\n"
"もし切り捨てをした場合は、商は 1/10 よりもわずかに小さくなります。どちらにし"
"ろ *厳密な* 1/10 ではありません！"

#: ../../tutorial/floatingpoint.rst:322
msgid ""
"So the computer never \"sees\" 1/10:  what it sees is the exact fraction "
"given above, the best IEEE 754 double approximation it can get:"
msgstr ""
"つまり、コンピューターが扱っている値は 1/10 そのものではなく、上に示した分数"
"の正確な値です。これは、IEEE 754 の倍精度で表せる、1/10 の最もよい近似値です:"

#: ../../tutorial/floatingpoint.rst:325
msgid ""
">>> 0.1 * 2 ** 55\n"
"3602879701896397.0"
msgstr ""
">>> 0.1 * 2 ** 55\n"
"3602879701896397.0"

#: ../../tutorial/floatingpoint.rst:330
msgid ""
"If we multiply that fraction by 10\\*\\*55, we can see the value out to 55 "
"decimal digits:"
msgstr ""
"この分数に 10\\*\\*55 を掛ければ、55 桁の十進数の値を見ることができます:"

#: ../../tutorial/floatingpoint.rst:333
msgid ""
">>> 3602879701896397 * 10 ** 55 // 2 ** 55\n"
"1000000000000000055511151231257827021181583404541015625"
msgstr ""
">>> 3602879701896397 * 10 ** 55 // 2 ** 55\n"
"1000000000000000055511151231257827021181583404541015625"

#: ../../tutorial/floatingpoint.rst:338
msgid ""
"meaning that the exact number stored in the computer is equal to the decimal "
"value 0.1000000000000000055511151231257827021181583404541015625. Instead of "
"displaying the full decimal value, many languages (including older versions "
"of Python), round the result to 17 significant digits:"
msgstr ""
"これは、コンピューターに格納されている数値が、10 進数の "
"0.1000000000000000055511151231257827021181583404541015625 と正確に等しいこと"
"を意味します。多くの言語 (古いバージョンの Python を含む) では、全ての桁を "
"10 進数で表示する代わりに、結果を有効数字 17 桁に丸めます:"

#: ../../tutorial/floatingpoint.rst:343
msgid ""
">>> format(0.1, '.17f')\n"
"'0.10000000000000001'"
msgstr ""
">>> format(0.1, '.17f')\n"
"'0.10000000000000001'"

#: ../../tutorial/floatingpoint.rst:348
msgid ""
"The :mod:`fractions` and :mod:`decimal` modules make these calculations easy:"
msgstr ""
":mod:`fractions` モジュールと :mod:`decimal` モジュールを使うとこれらの計算を"
"簡単に行えます:"

#: ../../tutorial/floatingpoint.rst:351
msgid ""
">>> from decimal import Decimal\n"
">>> from fractions import Fraction\n"
"\n"
">>> Fraction.from_float(0.1)\n"
"Fraction(3602879701896397, 36028797018963968)\n"
"\n"
">>> (0.1).as_integer_ratio()\n"
"(3602879701896397, 36028797018963968)\n"
"\n"
">>> Decimal.from_float(0.1)\n"
"Decimal('0.1000000000000000055511151231257827021181583404541015625')\n"
"\n"
">>> format(Decimal.from_float(0.1), '.17')\n"
"'0.10000000000000001'"
msgstr ""
">>> from decimal import Decimal\n"
">>> from fractions import Fraction\n"
"\n"
">>> Fraction.from_float(0.1)\n"
"Fraction(3602879701896397, 36028797018963968)\n"
"\n"
">>> (0.1).as_integer_ratio()\n"
"(3602879701896397, 36028797018963968)\n"
"\n"
">>> Decimal.from_float(0.1)\n"
"Decimal('0.1000000000000000055511151231257827021181583404541015625')\n"
"\n"
">>> format(Decimal.from_float(0.1), '.17')\n"
"'0.10000000000000001'"