# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2021, Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
#
# Translators:
# tomo, 2020
#
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.8\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2021-01-01 16:06+0000\n"
"PO-Revision-Date: 2020-05-30 12:16+0000\n"
"Last-Translator: tomo, 2020\n"
"Language-Team: Japanese (https://www.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:9
msgid "Floating Point Arithmetic:  Issues and Limitations"
msgstr "浮動小数点演算、その問題と制限"

#: ../../tutorial/floatingpoint.rst:14
msgid ""
"Floating-point numbers are represented in computer hardware as base 2 "
"(binary) fractions.  For example, the decimal fraction ::"
msgstr ""
"浮動小数点数は、計算機ハードウェアの中では、基数を 2 とする (2進法の) 分数と"
"して表現されています。例えば、小数 ::"

#: ../../tutorial/floatingpoint.rst:19
msgid ""
"has value 1/10 + 2/100 + 5/1000, and in the same way the binary fraction ::"
msgstr ""
"は、 1/10 + 2/100 + 5/1000 という値を持ちますが、これと同様に、2 進法の分"
"数 ::"

#: ../../tutorial/floatingpoint.rst:23
msgid ""
"has value 0/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 ""
"は 0/2 + 0/4 + 1/8 という値になります。これら二つの分数は同じ値を持っています"
"が、ただ一つ、最初の分数は基数 10 で記述されており、二番目の分数は基数 2 で記"
"述されていることが違います。"

#: ../../tutorial/floatingpoint.rst:27
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 ""
"残念なことに、ほとんどの小数は 2 進法の分数として正確に表わすことができませ"
"ん。その結果、一般に、入力した 10 進の浮動小数点数は、 2 進法の浮動小数点数で"
"近似された後、実際にマシンに記憶されます。"

#: ../../tutorial/floatingpoint.rst:32
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 を考えてみましょう。"
"分数 1/3 は、基数 10 の分数として、以下のように近似することができます::"

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

#: ../../tutorial/floatingpoint.rst:45
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 には"
"なりません。しかし、少しづつ正確な近似にはなっていくでしょう。"

#: ../../tutorial/floatingpoint.rst:49
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 は循環小数 "
"(repeating fraction) となります ::"

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

#: ../../tutorial/floatingpoint.rst:62
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 は"
"マシンに格納されている二進近似値の10進小数での近似値を表示するので、格納され"
"ている値が元の10進小数の近似値でしか無いことを忘れがちです。ほとんどのマシン"
"で、もし Python が2進数で近似された 0.1 の近似値をそのまま10進数で表示してい"
"たら、その結果は次のようになったでしょう ::"

#: ../../tutorial/floatingpoint.rst:71
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:77
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 であるように見えたとしても、実際に格納されている"
"値は最も近く表現できる二進小数であるということだけは覚えておいてください。"

#: ../../tutorial/floatingpoint.rst:80
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:88
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`` のような10進数の値を選んで表示していました。 "
"Python 3.1 からは、ほとんどの場面で ``0.1`` のような最も短い桁数の10進数の値"
"を選ぶようになりました。"

#: ../../tutorial/floatingpoint.rst:93
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:99
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:111
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:114
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 ではないために、それ"
"を3回足した値もまた正確には 0.3 ではありません::"

#: ../../tutorial/floatingpoint.rst:120
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:127
msgid ""
"Though the numbers cannot be made closer to their intended exact values, "
"the :func:`round` function can be useful for post-rounding so that results "
"with inexact values become comparable to one another::"
msgstr ""
"数字が正確な値に最も近い値になっているとはいえ、 :func:`round` 関数を使って計"
"算後の値を丸めることで、不正確な代わりに他の値と比較できるようになる事があり"
"ます::"

#: ../../tutorial/floatingpoint.rst:134
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 `The Perils of Floating Point <http://"
"www.lahey.com/float.htm>`_ for a more complete account of other common "
"surprises."
msgstr ""
"2 進の浮動小数点数に対する算術演算は、このような意外性をたくさん持っていま"
"す。 \"0.1\" に関する問題は、以下の \"表現エラー\" の章で詳細に説明します。 "
"2 進法の浮動小数点演算にともなうその他のよく知られた意外な事象に関しては "
"`The Perils of Floating Point <http://www.lahey.com/float.htm>`_ を参照してく"
"ださい。"

#: ../../tutorial/floatingpoint.rst:139
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 の float 型操作におけるエラーは浮動小数点処理"
"ハードウェアから受けついたものであり、ほとんどのマシン上では一つの演算あたり"
"高々 2\\*\\*53 分の 1 です。この誤差はほとんどの作業で充分以上のものですが、"
"浮動小数点演算は 10 進の演算ではなく、浮動小数点の演算を新たに行うと、新たな"
"丸め誤差の影響を受けることを心にとどめておいてください。"

#: ../../tutorial/floatingpoint.rst:146
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:152
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:156
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:160
msgid ""
"If you are a heavy user of floating point operations you should take a look "
"at the Numerical Python package and many other packages for mathematical and "
"statistical operations supplied by the SciPy project. See <https://scipy."
"org>."
msgstr ""
"あなたが浮動小数点演算のヘビーユーザーなら、SciPy プロジェクトが提供している "
"Numerical Python パッケージやその他の数学用パッケージを調べてみるべきです。 "
"<https://scipy.org> を参照してください。"

#: ../../tutorial/floatingpoint.rst:164
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 は *本当に* float の正確な値が必要なレアケースに対応するためのツールを"
"提供しています。 :meth:`float.as_integer_ratio` メソッドは float の値を有理数"
"として表現します::"

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

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

#: ../../tutorial/floatingpoint.rst:191
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:195
msgid ""
"Another helpful tool is the :func:`math.fsum` function which helps mitigate "
"loss-of-precision during summation.  It tracks \"lost digits\" 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:"
"`math.fsum` 関数があります。この関数は値を合計値に足し込みながら、 \"失われた"
"桁\" を管理します。これにより、誤差が最終的な合計値に影響を与えるまで蓄積され"
"なくなり、結果が改善されます:"

#: ../../tutorial/floatingpoint.rst:209
msgid "Representation Error"
msgstr "表現エラー"

#: ../../tutorial/floatingpoint.rst:211
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:215
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 進法 (基数 2)の分数として表現できないという事実に関係していま"
"す。これは Python (あるいは Perl, C, C++, Java, Fortran. およびその他多く) が"
"期待通りの正確な 10 進数を表示できない主要な理由です。"

#: ../../tutorial/floatingpoint.rst:220
msgid ""
"Why is that?  1/10 is not exactly representable as a binary fraction. Almost "
"all machines today (November 2000) use IEEE-754 floating point arithmetic, "
"and almost all platforms map Python floats to IEEE-754 \"double "
"precision\".  754 doubles 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年11月) のマシンは、ほとんどすべて IEEE-754 浮動小数点演算を使"
"用しており、ほとんどすべてのプラットフォームでは Python の浮動小数点を "
"IEEE-754 における \"倍精度(double precision)\" に対応付けます。754 の double "
"には 53 ビットの精度を持つ数が入るので、計算機に入力を行おうとすると、可能な"
"限り 0.1 を最も近い値の分数に変換し、*J*/2**\\ *N* の形式にしようと努力しま"
"す。*J* はちょうど 53 ビットの精度の整数です ::"

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

#: ../../tutorial/floatingpoint.rst:233
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:239
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 ""
"すなわち、56 は *J* をちょうど 53 ビットの精度のままに保つ *N* の唯一の値で"
"す。*J* の取りえる値はその商を丸めたものです::"

#: ../../tutorial/floatingpoint.rst:246
msgid ""
"Since the remainder is more than half of 10, the best approximation is "
"obtained by rounding up::"
msgstr ""
"剰余が 10 の半分以上なので、最良の近似は切り上げて丸めたものになります。"

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

#: ../../tutorial/floatingpoint.rst:256
msgid ""
"Dividing both the numerator and denominator by two reduces the fraction to::"
msgstr "分子と分母を2で割って分数を小さくします::"

#: ../../tutorial/floatingpoint.rst:260
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:264
msgid ""
"So the computer never \"sees\" 1/10:  what it sees is the exact fraction "
"given above, the best 754 double approximation it can get::"
msgstr ""
"つまり、計算機は 1/10 を \"理解する\" ことは決してありません。計算機が理解で"
"きるのは、上記のような厳密な分数であり、 754 の倍精度浮動小数点数で得られる"
"もっともよい近似は以下になります::"

#: ../../tutorial/floatingpoint.rst:270
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:276
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:284
msgid ""
"The :mod:`fractions` and :mod:`decimal` modules make these calculations "
"easy::"
msgstr ""
":mod:`fractions` モジュールと :mod:`decimal` モジュールを使うとこれらの計算を"
"簡単に行えます::"