-
-
Notifications
You must be signed in to change notification settings - Fork 32
/
Copy pathfloatingpoint.po
433 lines (385 loc) · 24.6 KB
/
floatingpoint.po
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2018, Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
#
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.7\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2018-06-30 05:56+0900\n"
"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
"Last-Translator: 秘湯 <[email protected]>, 2017\n"
"Language-Team: Japanese (https://www.transifex.com/python-doc/teams/5390/ja/)\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Language: ja\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` モジュールを使うとこれらの計算を簡単に行えます::"