Repository navigation
Expand file tree
/
Copy pathfloatingpoint.po
More file actions
546 lines (498 loc) · 24.3 KB
/
Copy pathfloatingpoint.po
File metadata and controls
546 lines (498 loc) · 24.3 KB
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
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
# Copyright (C) 2001-2018, Python Software Foundation
# For licence information, see README file.
#
msgid ""
msgstr ""
"Project-Id-Version: Python 3\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2026-10-17 14:27+0200\n"
"PO-Revision-Date: 2022-11-16 22:33+0100\n"
"Last-Translator: Mathieu Dupuy <deronnax@gmail.com>\n"
"Language-Team: FRENCH <traductions@lists.afpy.org>\n"
"Language: fr\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"X-Generator: Poedit 2.4.2\n"
#: tutorial/floatingpoint.rst:10
#, fuzzy
msgid "Floating-Point Arithmetic: Issues and Limitations"
msgstr "Arithmétique en nombres à virgule flottante : problèmes et limites"
#: tutorial/floatingpoint.rst:12
#, fuzzy
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 ""
"Les nombres à virgule flottante sont représentés, au niveau matériel, en "
"fractions de nombres binaires (base 2). Par exemple, en représentation "
"**décimale** le nombre ``0.125`` exprime 1/10 + 2/100 + 5/1000. De la même "
"manière, en représentation **binaire** le nombre ``0.001`` exprime 0/2 + 0/4 "
"+ 1/8. Ces deux fractions de l'unité ont une valeur identique, la seule "
"différence est que la première est une fraction dont la notation est en base "
"10, la seconde est une fraction dont la notation est en base 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 ""
"Malheureusement, la plupart des fractions décimales ne peuvent pas avoir de "
"représentation exacte en fractions binaires. Par conséquent, en général, les "
"nombres à virgule flottante que vous donnez sont seulement approximés en "
"fractions binaires pour être stockés dans la machine."
#: 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 ""
"Le problème est plus simple à aborder en base 10. Prenons par exemple, la "
"fraction 1/3. Vous pouvez l'approximer en une fraction décimale ::"
#: tutorial/floatingpoint.rst:33
msgid "or, better, ::"
msgstr "ou, mieux ::"
#: 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 ""
"etc. Peu importe le nombre de décimales que vous écrivez, le résultat ne "
"vaut jamais exactement 1/3, mais c'est une estimation s'en approchant "
"toujours mieux."
#: 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 ""
"De la même manière, peu importe combien de décimales en base 2 vous "
"utilisez, la valeur décimale 0.1 ne peut pas être représentée exactement en "
"fraction binaire. En base 2, 1/10 est le nombre périodique suivant ::"
#: 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 ""
"En se limitant à une quantité finie de bits, on ne peut obtenir qu'une "
"approximation. Sur la majorité des machines aujourd'hui, les nombres à "
"virgule flottante sont approximés par une fraction binaire avec les 53 "
"premiers bits comme numérateur et une puissance de deux au dénominateur. "
"Dans le cas de 1/10, la fraction binaire est ``3602879701896397 / 2 ** 55`` "
"qui est proche mais ne vaut pas exactement 1/10."
#: tutorial/floatingpoint.rst:54
#, fuzzy
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 ""
"Du fait de la manière dont les flottants sont affichés par l'interpréteur, "
"il est facile d'oublier que la valeur stockée est une approximation de la "
"fraction décimale d'origine. Python n'affiche qu'une approximation décimale "
"de la valeur stockée en binaire. Si Python devait afficher la vraie valeur "
"décimale de l'approximation binaire stockée pour 0,1, il afficherait ::"
#: tutorial/floatingpoint.rst:63
#, fuzzy
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 ""
"C'est bien plus de décimales que ce qu'attendent la plupart des "
"utilisateurs, donc Python affiche une valeur arrondie afin d'améliorer la "
"lisibilité ::"
#: 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 ""
"Rappelez-vous simplement que, bien que la valeur affichée ressemble à la "
"valeur exacte de 1/10, la valeur stockée est la représentation la plus "
"proche en fraction binaire."
#: 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 ""
"Il existe beaucoup de nombres décimaux qui partagent une même approximation "
"en fraction binaire. Par exemple, ``0.1``, ``0.10000000000000001`` et "
"``0.1000000000000000055511151231257827021181583404541015625`` ont tous pour "
"approximation ``3602879701896397 / 2 ** 55``. Puisque toutes ces valeurs "
"décimales partagent la même approximation, chacune peut être affichée tout "
"en respectant ``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 ""
"Historiquement, le mode interactif de Python et la primitive :func:`repr` "
"choisissaient la version avec 17 décimales significatives, "
"``0.10000000000000001``. Python, depuis la version 3.1 (sur la majorité des "
"systèmes) est maintenant capable de choisir la plus courte représentation et "
"n'affiche que ``0.1``."
#: tutorial/floatingpoint.rst:87
#, fuzzy
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 ""
"Ce comportement est inhérent à la nature même de la représentation des "
"nombres à virgule flottante dans la machine : ce n'est pas un bogue dans "
"Python et ce n'est pas non plus un bogue dans votre code. Vous pouvez "
"observer le même type de comportement dans tous les autres langages "
"utilisant le support matériel pour le calcul des nombres à virgule flottante "
"(bien que certains langages ne rendent pas visible la différence par défaut, "
"ou pas dans tous les modes d'affichage)."
#: tutorial/floatingpoint.rst:93
#, fuzzy
msgid ""
"For more pleasant output, you may wish to use string formatting to produce a "
"limited number of significant digits:"
msgstr ""
"Pour obtenir un affichage plus plaisant, les fonctions de formatage de "
"chaînes de caractères peuvent limiter le nombre de décimales significatives "
"affichées ::"
#: 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 ""
"Il est important de comprendre que tout cela n'est, au sens propre, qu'une "
"illusion : vous demandez simplement à Python d'arrondir la valeur stockée "
"réellement dans la machine à *l'affichage*."
#: tutorial/floatingpoint.rst:110
#, fuzzy
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 ""
"Une autre conséquence du fait que 0,1 n'est pas exactement stocké 1/10 est "
"que la somme de trois valeurs de 0,1 ne donne pas 0,3 non plus ::"
#: tutorial/floatingpoint.rst:118
#, fuzzy
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 ""
"Aussi, puisque 0,1 ne peut pas être stocké avec une représentation plus "
"proche de sa valeur exacte 1/10, comme 0,3 qui ne peut pas être plus proche "
"de sa valeur exacte 3/10, arrondir au préalable avec la "
"fonction :func:`round` n'aide en rien ::"
#: tutorial/floatingpoint.rst:127
#, fuzzy
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 ""
"Bien que les nombres ne peuvent se rapprocher plus de la valeur qu’on attend "
"qu’ils aient, la fonction :func:`round` peut être utile à postériori pour "
"arrondir deux valeurs inexactes et pouvoir les comparer ::"
#: tutorial/floatingpoint.rst:135
msgid ""
"Alternatively, the :func:`round` function can be used to compare rough "
"approximations:"
msgstr ""
#: tutorial/floatingpoint.rst:143
#, fuzzy
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 ""
"L'arithmétique des nombres binaires à virgule flottante réserve beaucoup de "
"surprises de ce genre. Le problème avec « 0.1 » est expliqué en détails ci-"
"dessous, dans la section « Erreurs de représentation ». Voir `The Perils of "
"Floating Point <http://www.lahey.com/float.htm>`_ pour une liste plus "
"complète de ce genre de surprises."
#: tutorial/floatingpoint.rst:152
#, fuzzy
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 ""
"Même s'il est vrai qu'il n'existe pas de réponse simple, ce n'est pas la "
"peine de vous méfier outre mesure des nombres à virgule flottante ! Les "
"erreurs, en Python, dans les opérations de nombres à virgule flottante sont "
"dues au matériel sous-jacent et, sur la plupart des machines, sont de "
"l'ordre de 1 sur 2\\*\\*53 par opération. C'est plus que suffisant pour la "
"plupart des tâches, mais vous devez garder à l'esprit que ce ne sont pas des "
"opérations décimales et que chaque opération sur des nombres à virgule "
"flottante peut souffrir d'une nouvelle erreur."
#: 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 ""
"Bien que des cas pathologiques existent, pour la plupart des cas "
"d'utilisations courants vous obtiendrez le résultat attendu à la fin en "
"arrondissant simplement au nombre de décimales désirées à l'affichage "
"avec :func:`str`. Pour un contrôle fin sur la manière dont les décimales "
"sont affichées, consultez dans :ref:`formatstrings` les spécifications de "
"formatage de la méthode :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 ""
"Pour les cas requérant une représentation décimale exacte, le "
"module :mod:`decimal` peut être utile : il implémente l'arithmétique "
"décimale et peut donc être un choix adapté pour des applications nécessitant "
"une grande précision."
#: 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 ""
"Une autre forme d'arithmétique exacte est implémentée dans le "
"module :mod:`fractions` qui se base sur les nombres rationnels (donc 1/3 "
"peut y être représenté exactement)."
#: tutorial/floatingpoint.rst:173
#, fuzzy
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 ""
"Si vous êtes un utilisateur intensif des opérations sur les nombres à "
"virgule flottante, nous vous conseillons de considérer le paquet *NumPy* "
"ainsi que les paquets pour les opérations statistiques et mathématiques "
"fournis par le projet SciPy. Consultez <https://scipy.org>."
#: tutorial/floatingpoint.rst:177
#, fuzzy
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 fournit des outils qui peuvent être utiles dans les rares occasions "
"où vous voulez réellement connaître la valeur exacte d'un nombre à virgule "
"flottante. La méthode :meth:`float.as_integer_ratio` donne la valeur du "
"nombre sous forme de fraction ::"
#: tutorial/floatingpoint.rst:188
#, fuzzy
msgid ""
"Since the ratio is exact, it can be used to losslessly recreate the original "
"value:"
msgstr ""
"Puisque le ratio est exact, il peut être utilisé pour recréer la valeur "
"originale sans perte ::"
#: tutorial/floatingpoint.rst:196
#, fuzzy
msgid ""
"The :meth:`float.hex` method expresses a float in hexadecimal (base 16), "
"again giving the exact value stored by your computer:"
msgstr ""
"La méthode :meth:`float.hex` donne le nombre en hexadécimal (base 16), "
"donnant ici aussi la valeur exacte stockée par la machine ::"
#: tutorial/floatingpoint.rst:204
#, fuzzy
msgid ""
"This precise hexadecimal representation can be used to reconstruct the float "
"value exactly:"
msgstr ""
"Cette représentation hexadécimale petit être utilisée pour reconstruire, "
"sans approximation, le *float* ::"
#: 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 ""
"Puisque cette représentation est exacte, elle est pratique pour échanger des "
"valeurs entre différentes versions de Python (indépendamment de la machine) "
"ou d'autres langages qui comprennent ce format (tels que Java et C99)."
#: tutorial/floatingpoint.rst:216
#, fuzzy
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 ""
"Une autre fonction utile est :func:`math.fsum`, elle aide à diminuer les "
"pertes de précision lors des additions. Elle surveille les *décimales "
"perdues* au fur et à mesure que les valeurs sont ajoutées au total. Cela "
"peut faire une différence au niveau de la précision globale en empêchant les "
"erreurs de s'accumuler jusqu'à affecter le résultat final :"
#: 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 ""
#: tutorial/floatingpoint.rst:256
msgid "Representation Error"
msgstr "Erreurs de représentation"
#: 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 ""
"Cette section explique en détail l'exemple du « 0.1 » et montre comment vous "
"pouvez effectuer une analyse exacte de ce type de cas par vous-même. Nous "
"supposons que la représentation binaire des nombres flottants vous est "
"familière."
#: 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 ""
"Le terme :dfn:`Erreur de représentation` (*representation error* en anglais) "
"signifie que la plupart des fractions décimales ne peuvent être représentées "
"exactement en binaire. C'est la principale raison pour laquelle Python (ou "
"Perl, C, C++, Java, Fortran et beaucoup d'autres) n'affiche habituellement "
"pas le résultat exact en décimal."
#: tutorial/floatingpoint.rst:267
#, fuzzy
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 ""
"Pourquoi ? 1/10 n'est pas représentable de manière exacte en fraction "
"binaire. Cependant, toutes les machines d'aujourd'hui (novembre 2000) "
"suivent la norme IEEE-754 en ce qui concerne l'arithmétique des nombres à "
"virgule flottante et la plupart des plateformes utilisent un « IEEE-754 "
"double précision » pour représenter les *floats* de Python. Les « IEEE-754 "
"double précision » utilisent 53 bits de précision donc, à la lecture, "
"l'ordinateur essaie de convertir 0,1 dans la fraction la plus proche "
"possible de la forme *J*/2**\\ *N* avec *J* un nombre entier d'exactement 53 "
"bits. Pour réécrire ::"
#: tutorial/floatingpoint.rst:278
msgid "as ::"
msgstr "en ::"
#: tutorial/floatingpoint.rst:282
#, fuzzy
msgid ""
"and recalling that *J* has exactly 53 bits (is ``>= 2**52`` but ``< "
"2**53``), the best value for *N* is 56:"
msgstr ""
"en se rappelant que *J* fait exactement 53 bits (donc ``>= 2**52`` mais ``< "
"2**53``), la meilleure valeur possible pour *N* est 56 ::"
#: tutorial/floatingpoint.rst:290
#, fuzzy
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 ""
"Donc 56 est la seule valeur possible pour *N* qui laisse exactement 53 bits "
"pour *J*. La meilleure valeur possible pour *J* est donc ce quotient, "
"arrondi ::"
#: tutorial/floatingpoint.rst:299
#, fuzzy
msgid ""
"Since the remainder is more than half of 10, the best approximation is "
"obtained by rounding up:"
msgstr ""
"Puisque la retenue est plus grande que la moitié de 10, la meilleure "
"approximation est obtenue en arrondissant par le haut ::"
#: tutorial/floatingpoint.rst:309
#, fuzzy
msgid ""
"Therefore the best possible approximation to 1/10 in IEEE 754 double "
"precision is::"
msgstr ""
"Par conséquent la meilleure approximation possible pour 1/10 en « IEEE-754 "
"double précision » est celle au-dessus de 2\\*\\*56, soit ::"
#: tutorial/floatingpoint.rst:314
msgid ""
"Dividing both the numerator and denominator by two reduces the fraction to::"
msgstr ""
"Diviser le numérateur et le dénominateur par deux réduit la fraction à ::"
#: 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 ""
"Notez que puisque l'arrondi a été fait vers le haut, le résultat est en "
"réalité légèrement plus grand que 1/10 ; si nous n'avions pas arrondi par le "
"haut, le quotient aurait été légèrement plus petit que 1/10. Mais dans aucun "
"cas il ne vaut *exactement* 1/10 !"
#: tutorial/floatingpoint.rst:322
#, fuzzy
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 ""
"Donc l'ordinateur ne « voit » jamais 1/10 : ce qu'il voit est la fraction "
"exacte donnée ci-dessus, la meilleure approximation utilisant les nombres à "
"virgule flottante double précision de l'« IEEE-754 » ::"
#: tutorial/floatingpoint.rst:330
#, fuzzy
msgid ""
"If we multiply that fraction by 10\\*\\*55, we can see the value out to 55 "
"decimal digits:"
msgstr ""
"Si nous multiplions cette fraction par 10\\*\\*55, nous pouvons observer les "
"valeurs de ses 55 décimales de poids fort ::"
#: tutorial/floatingpoint.rst:338
#, fuzzy
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 ""
"La valeur stockée dans l'ordinateur est donc égale à "
"0,1000000000000000055511151231257827021181583404541015625. Au lieu "
"d'afficher toutes les décimales, beaucoup de langages (dont les vieilles "
"versions de Python) arrondissent le résultat à la 17\\ :sup:`e` décimale "
"significative ::"
#: tutorial/floatingpoint.rst:348
#, fuzzy
msgid ""
"The :mod:`fractions` and :mod:`decimal` modules make these calculations easy:"
msgstr ""
"Les modules :mod:`fractions` et :mod:`decimal` rendent simples ces calculs ::"