# Copyright (C) 2001-2020, Python Software Foundation

# This file is distributed under the same license as the Python package.

# Maintained by the python-doc-es workteam.

# docs-es@python.org /

# https://mail.python.org/mailman3/lists/docs-es.python.org/

# Check https://github.com/python/python-docs-es/blob/3.8/TRANSLATORS to get

# the list of volunteers

#

msgid ""

msgstr ""

"Project-Id-Version: Python 3.8\n"

"Report-Msgid-Bugs-To: \n"

"POT-Creation-Date: 2023-10-12 19:43+0200\n"

"PO-Revision-Date: 2023-10-14 20:05-0300\n"

"Last-Translator: Carlos A. Crespo <lvccrespo@gmail.com>\n"

"Language-Team: python-doc-es\n"

"Language: es\n"

"MIME-Version: 1.0\n"

"Content-Type: text/plain; charset=utf-8\n"

"Content-Transfer-Encoding: 8bit\n"

"Plural-Forms: nplurals=2; plural=(n != 1);\n"

"Generated-By: Babel 2.13.0\n"

"X-Generator: Poedit 3.0.1\n"

#: ../Doc/tutorial/floatingpoint.rst:10

msgid "Floating Point Arithmetic: Issues and Limitations"

msgstr "Aritmética de Punto Flotante: Problemas y Limitaciones"

#: ../Doc/tutorial/floatingpoint.rst:16

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 ""

"Los números de punto flotante se representan en el hardware de computadoras "

"como fracciones en base 2 (binarias). Por ejemplo, la fracción **decimal** "

"``0.625`` tiene un valor de 6/10 + 2/100 + 5/1000, y de la misma manera, la "

"fracción binaria ``0.101`` tiene un valor de 1/2 + 0/4 + 1/8. Estas dos "

"fracciones tienen valores idénticos; la única diferencia real radica en que "

"la primera se escribe en notación fraccional en base 10, y la segunda en "

"base 2."

#: ../Doc/tutorial/floatingpoint.rst:23

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 ""

"Desafortunadamente, la mayoría de las fracciones decimales no pueden "

"representarse exactamente como fracciones binarias. Como consecuencia, en "

"general los números de punto flotante decimal que ingresás en la computadora "

"son sólo aproximados por los números de punto flotante binario que realmente "

"se guardan en la máquina."

#: ../Doc/tutorial/floatingpoint.rst:28

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 ""

"El problema es más fácil de entender primero en base 10. Considerá la "

"fracción 1/3. Podés aproximarla como una fracción de base 10 ::"

#: ../Doc/tutorial/floatingpoint.rst:33 ../Doc/tutorial/floatingpoint.rst:37

msgid "or, better, ::"

msgstr "...o, mejor, ::"

#: ../Doc/tutorial/floatingpoint.rst:41

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 ""

"...y así. No importa cuantos dígitos desees escribir, el resultado nunca "

"será exactamente 1/3, pero será una aproximación cada vez mejor de 1/3."

#: ../Doc/tutorial/floatingpoint.rst:45

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 misma manera, no importa cuantos dígitos en base 2 quieras usar, el "

"valor decimal 0.1 no puede representarse exactamente como una fracción en "

"base 2. En base 2, 1/10 es la siguiente fracción que se repite "

"infinitamente::"

#: ../Doc/tutorial/floatingpoint.rst:51

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 ""

"Frená en cualquier número finito de bits, y tendrás una aproximación. En la "

"mayoría de las máquinas hoy en día, los float se aproximan usando una "

"fracción binaria con el numerador usando los primeros 53 bits con el bit más "

"significativos y el denominador como una potencia de dos. En el caso de "

"1/10, la fracción binaria es ``3602879701896397 / 2 ** 55`` que está cerca "

"pero no es exactamente el valor verdadero de 1/10."

#: ../Doc/tutorial/floatingpoint.rst:58

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 ""

"La mayoría de los usuarios no son conscientes de esta aproximación por la "

"forma en que se muestran los valores. Python solamente muestra una "

"aproximación decimal al valor verdadero decimal de la aproximación binaria "

"almacenada por la máquina. En la mayoría de las máquinas, si Python fuera a "

"imprimir el verdadero valor decimal de la aproximación binaria almacenada "

"para 0.1, debería mostrar::"

#: ../Doc/tutorial/floatingpoint.rst:67

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 ""

"Esos son más dígitos que lo que la mayoría de la gente encuentra útil, por "

"lo que Python mantiene manejable la cantidad de dígitos al mostrar un valor "

"redondeado en su lugar:"

#: ../Doc/tutorial/floatingpoint.rst:75

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 ""

"Sólo recordá que, a pesar de que el valor mostrado resulta ser exactamente "

"1/10, el valor almacenado realmente es la fracción binaria más cercana "

"posible."

#: ../Doc/tutorial/floatingpoint.rst:78

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 ""

"Interesantemente, hay varios números decimales que comparten la misma "

"fracción binaria más aproximada. Por ejemplo, los números ``0.1``, "

"``0.10000000000000001`` y "

"``0.1000000000000000055511151231257827021181583404541015625`` son todos "

"aproximados por ``3602879701896397 / 2 ** 55``. Ya que todos estos valores "

"decimales comparten la misma aproximación, se podría mostrar cualquiera de "

"ellos para preservar el invariante ``eval(repr(x)) == x``."

#: ../Doc/tutorial/floatingpoint.rst:86

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 ""

"Históricamente, el prompt de Python y la función integrada :func:`repr` "

"eligieron el valor con los 17 dígitos, ``0.10000000000000001``. Desde "

"Python 3.1, en la mayoría de los sistemas Python ahora es capaz de elegir la "

"forma más corta de ellos y mostrar ``0.1``."

#: ../Doc/tutorial/floatingpoint.rst:91

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 ""

"Notá que esta es la verdadera naturaleza del punto flotante binario: no es "

"un error de Python, y tampoco es un error en tu código. Verás lo mismo en "

"todos los lenguajes que soportan la aritmética de punto flotante de tu "

"hardware (a pesar de que en algunos lenguajes por omisión no *muestren* la "

"diferencia, o no lo hagan en todos los modos de salida)."

#: ../Doc/tutorial/floatingpoint.rst:97

msgid ""

"For more pleasant output, you may wish to use string formatting to produce a "

"limited number of significant digits:"

msgstr ""

"Para una salida más elegante, quizás quieras usar el formateo de cadenas de "

"texto para generar un número limitado de dígitos significativos:"

#: ../Doc/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 ""

"Es importante darse cuenta que esto es, realmente, una ilusión: estás "

"simplemente redondeando al *mostrar* el valor verdadero de la máquina."

#: ../Doc/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 ""

"Una ilusión puede generar otra. Por ejemplo, ya que 0.1 no es exactamente "

"1/10, sumar tres veces 0.1 podría también no generar exactamente 0.3:"

#: ../Doc/tutorial/floatingpoint.rst:122

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 ""

"También, ya que 0.1 no puede acercarse más al valor exacto de 1/10 y 0.3 no "

"puede acercarse más al valor exacto de 3/10, redondear primero con la "

"función :func:`round` no puede ayudar:"

#: ../Doc/tutorial/floatingpoint.rst:131

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 ""

"Aunque los números no pueden acercarse más a sus valores exactos previstos, "

"la función :func:`math.isclose` puede ser útil para comparar valores "

"inexactos:"

#: ../Doc/tutorial/floatingpoint.rst:139

msgid ""

"Alternatively, the :func:`round` function can be used to compare rough "

"approximations::"

msgstr ""

"Alternativamente, la función :func:`round` se puede usar para comparar "

"aproximaciones imprecisas::"

#: ../Doc/tutorial/floatingpoint.rst:147

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 <https://www.lahey.com/float.htm>`_ for a more complete account of "

"other common surprises."

msgstr ""

"La aritmética de punto flotante binaria tiene varias sorpresas como esta. El "

"problema con \"0.1\" es explicado con detalle abajo, en la sección \"Error "

"de Representación\". Consultar `Ejemplos de Problemas de Punto Flotante "

"<https://jvns.ca/blog/2023/01/13/examples-of-floating-point-problems/>`_ "

"para obtener un agradable resumen de cómo funciona la aritmética de punto "

"flotante binaria y los tipos de problemas que comúnmente se encuentran en la "

"práctica. También consultar Los Peligros del Punto Flotante ( `The Perils of "

"Floating Point <http://www.lahey.com/float.htm>`_) para una más completa "

"recopilación de otras sorpresas comunes."

#: ../Doc/tutorial/floatingpoint.rst:156

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 ""

"Como dice cerca del final, \"no hay respuestas fáciles\". A pesar de eso, "

"¡no le tengas mucho miedo al punto flotante! Los errores en las operaciones "

"flotantes de Python se heredan del hardware de punto flotante, y en la "

"mayoría de las máquinas están en el orden de no más de una 1 parte en "

"2\\*\\*53 por operación. Eso es más que adecuado para la mayoría de las "

"tareas, pero necesitás tener en cuenta que no es aritmética decimal, y que "

"cada operación de punto flotante sufre un nuevo error de redondeo."

#: ../Doc/tutorial/floatingpoint.rst:163

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 ""

"A pesar de que existen casos patológicos, para la mayoría de usos casuales "

"de la aritmética de punto flotante al final verás el resultado que esperás "

"si simplemente redondeás lo que mostrás de tus resultados finales al número "

"de dígitos decimales que esperás. :func:`str` es normalmente suficiente, y "

"para un control más fino mirá los parámetros del método de formateo :meth:"

"`str.format` en :ref:`string-formatting`."

#: ../Doc/tutorial/floatingpoint.rst:169

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 ""

"Para los casos de uso que necesitan una representación decimal exacta, probá "

"el módulo :mod:`decimal`, que implementa aritmética decimal útil para "

"aplicaciones de contabilidad y de alta precisión."

#: ../Doc/tutorial/floatingpoint.rst:173

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 ""

"El módulo :mod:`fractions` soporta otra forma de aritmética exacta, ya que "

"implementa aritmética basada en números racionales (por lo que números como "

"1/3 pueden ser representados exactamente)."

#: ../Doc/tutorial/floatingpoint.rst:177

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 eres un usuario intensivo de operaciones de punto flotante, deberías "

"echar un vistazo al paquete NumPy y a muchos otros paquetes para operaciones "

"matemáticas y estadísticas proporcionados por el proyecto SciPy. Ver "

"<https://scipy.org>."

#: ../Doc/tutorial/floatingpoint.rst:181

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 provee herramientas que pueden ayudar en esas raras ocasiones cuando "

"realmente *querés* saber el valor exacto de un punto flotante. El método :"

"meth:`float.as_integer_ratio` expresa el valor del punto flotante como una "

"fracción:"

#: ../Doc/tutorial/floatingpoint.rst:192

msgid ""

"Since the ratio is exact, it can be used to losslessly recreate the original "

"value:"

msgstr ""

"Ya que la fracción es exacta, se puede usar para recrear sin pérdidas el "

"valor original:"

#: ../Doc/tutorial/floatingpoint.rst:200

msgid ""

"The :meth:`float.hex` method expresses a float in hexadecimal (base 16), "

"again giving the exact value stored by your computer:"

msgstr ""

"El método :meth:`float.hex` expresa un punto flotante en hexadecimal (base "

"16), nuevamente retornando el valor exacto almacenado por tu computadora:"

#: ../Doc/tutorial/floatingpoint.rst:208

msgid ""

"This precise hexadecimal representation can be used to reconstruct the float "

"value exactly:"

msgstr ""

"Esta representación hexadecimal precisa se puede usar para reconstruir el "

"valor exacto del punto flotante:"

#: ../Doc/tutorial/floatingpoint.rst:216

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 ""

"Ya que la representación es exacta, es útil para portar valores a través de "

"diferentes versiones de Python de manera confiable (independencia de "

"plataformas) e intercambiar datos con otros lenguajes que soportan el mismo "

"formato (como Java y C99)."

#: ../Doc/tutorial/floatingpoint.rst:220

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 ""

"Otra herramienta útil es la función :func:`sum` que ayuda a mitigar la "

"pérdida de precisión durante la suma. Utiliza precisión extendida para pasos "

"de redondeo intermedios a medida que se agregan valores a un total en "

"ejecución. Esto puede marcar la diferencia en la precisión general para que "

"los errores no se acumulen hasta el punto en que afecten el total final:"

#: ../Doc/tutorial/floatingpoint.rst:233

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 ""

"La función :func:`math.fsum()` va más allá y realiza un seguimiento de todos "

"los \"dígitos perdidos\" a medida que se agregan valores a un total en "

"ejecución, de modo que el resultado tiene solo un redondeo. Esto es más "

"lento que :func:`sum`, pero será más preciso en casos poco comunes en los "

"que las entradas de gran magnitud se cancelan en su mayoría entre sí, "

"dejando una suma final cercana a cero:"

#: ../Doc/tutorial/floatingpoint.rst:260

msgid "Representation Error"

msgstr "Error de Representación"

#: ../Doc/tutorial/floatingpoint.rst:262

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 ""

"Esta sección explica el ejemplo \"0.1\" en detalle, y muestra como en la "

"mayoría de los casos vos mismo podés realizar un análisis exacto como este. "

"Se asume un conocimiento básico de la representación de punto flotante "

"binario."

#: ../Doc/tutorial/floatingpoint.rst:266

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:`Error de representación` se refiere al hecho de que algunas (la "

"mayoría) de las fracciones decimales no pueden representarse exactamente "

"como fracciones binarias (en base 2). Esta es la razón principal de por qué "

"Python (o Perl, C, C++, Java, Fortran, y tantos otros) frecuentemente no "

"mostrarán el número decimal exacto que esperás."

#: ../Doc/tutorial/floatingpoint.rst:271

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 ""

"¿Por qué sucede esto? 1/10 no es exactamente representable como una fracción "

"binaria. Desde al menos el año 2000, casi todas las máquinas utilizan la "

"aritmética de punto flotante binaria IEEE 754, y casi todas las plataformas "

"asignan los números de punto flotante de Python a valores binarios de 64 "

"bits de precisión \"doble\" de IEEE 754. Los valores binarios de IEEE 754 de "

"64 bits contienen 53 bits de precisión, por lo que en la entrada, la "

"computadora se esfuerza por convertir 0.1 en la fracción más cercana de la "

"forma *J*/2**\\ *N* donde *J* es un número entero que contiene exactamente "

"53 bits. Reescribiendo ::"

#: ../Doc/tutorial/floatingpoint.rst:282

msgid "as ::"

msgstr "...como ::"

#: ../Doc/tutorial/floatingpoint.rst:286

msgid ""

"and recalling that *J* has exactly 53 bits (is ``>= 2**52`` but ``< "

"2**53``), the best value for *N* is 56:"

msgstr ""

"...y recordando que *J* tiene exactamente 53 bits (es ``>= 2**52`` pero ``< "

"2**53``), el mejor valor para *N* es 56:"

#: ../Doc/tutorial/floatingpoint.rst:294

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 ""

"O sea, 56 es el único valor para *N* que deja *J* con exactamente 53 bits. "

"El mejor valor posible para *J* es entonces el cociente redondeado:"

#: ../Doc/tutorial/floatingpoint.rst:303

msgid ""

"Since the remainder is more than half of 10, the best approximation is "

"obtained by rounding up:"

msgstr ""

"Ya que el resto es más que la mitad de 10, la mejor aproximación se obtiene "

"redondeándolo:"

#: ../Doc/tutorial/floatingpoint.rst:313

msgid ""

"Therefore the best possible approximation to 1/10 in IEEE 754 double "

"precision is::"

msgstr ""

"Por lo tanto la mejor aproximación a 1/10 en doble precisión IEEE 754 es::"

#: ../Doc/tutorial/floatingpoint.rst:318

msgid ""

"Dividing both the numerator and denominator by two reduces the fraction to::"

msgstr ""

"El dividir tanto el numerador como el denominador reduce la fracción a::"

#: ../Doc/tutorial/floatingpoint.rst:322

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 ""

"Notá que como lo redondeamos, esto es un poquito más grande que 1/10; si no "

"lo hubiéramos redondeado, el cociente hubiese sido un poquito menor que "

"1/10. ¡Pero no hay caso en que sea *exactamente* 1/10!"

#: ../Doc/tutorial/floatingpoint.rst:326

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 ""

"Entonces la computadora nunca \"ve\" 1/10: lo que ve es la fracción exacta "

"de arriba, la mejor aproximación al flotante doble IEEE 754 que puede "

"obtener:"

#: ../Doc/tutorial/floatingpoint.rst:334

msgid ""

"If we multiply that fraction by 10\\*\\*55, we can see the value out to 55 "

"decimal digits:"

msgstr ""

"Si multiplicamos esa fracción por 10\\*\\*55, podemos ver el valor hasta los "

"55 dígitos decimales:"

#: ../Doc/tutorial/floatingpoint.rst:342

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 ""

"lo que significa que el valor exacto almacenado en la computadora es igual "

"al valor decimal 0.1000000000000000055511151231257827021181583404541015625. "

"En lugar de mostrar el valor decimal completo, muchos lenguajes (incluyendo "

"versiones anteriores de Python), redondean el resultado a 17 dígitos "

"significativos:"

#: ../Doc/tutorial/floatingpoint.rst:352

msgid ""

"The :mod:`fractions` and :mod:`decimal` modules make these calculations easy:"

msgstr ""

"Los módulos :mod:`fractions` y :mod:`decimal` hacen fácil estos cálculos:"