floatingpoint.po

# 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: 2022-10-25 19:47+0200\n"
"PO-Revision-Date: 2021-08-02 19:49+0200\n"
"Last-Translator: Cristián Maureira-Fredes <cmaureirafredes@gmail.com>\n"
"Language: es\n"
"Language-Team: python-doc-es\n"
"Plural-Forms: nplurals=2; plural=(n != 1);\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=utf-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Generated-By: Babel 2.10.3\n"

#: ../Doc/tutorial/floatingpoint.rst:9
msgid "Floating Point Arithmetic:  Issues and Limitations"
msgstr "Aritmética de Punto Flotante: Problemas y Limitaciones"

#: ../Doc/tutorial/floatingpoint.rst:14
#, fuzzy
msgid ""
"Floating-point numbers are represented in computer hardware as base 2 "
"(binary) fractions.  For example, the **decimal** fraction ``0.125`` has "
"value 1/10 + 2/100 + 5/1000, and in the same way the **binary** fraction "
"``0.001`` 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 ""
"...tiene el valor 0/2 + 0/4 + 1/8.  Estas dos fracciones tienen valores "
"idénticos, la única diferencia real es que la primera está escrita en "
"notación fraccional en base 10 y la segunda en base 2."

#: ../Doc/tutorial/floatingpoint.rst:21
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:26
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:31 ../Doc/tutorial/floatingpoint.rst:35
msgid "or, better, ::"
msgstr "...o, mejor, ::"

#: ../Doc/tutorial/floatingpoint.rst:39
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:43
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:49
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:56
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:65
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 en su "
"lugar un valor redondeado ::"

#: ../Doc/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 ""
"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: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 ""
"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: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 ""
"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: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 ""
"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:93
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:105
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:108
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:114
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:121
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 ""
"A pesar que los números no pueden acercarse a los valores exactos que "
"pretendemos, la función :func:`round` puede ser útil para redondear a "
"posteriori, para que los resultados con valores inexactos se puedan comparar "
"entre sí::"

#: ../Doc/tutorial/floatingpoint.rst:128
#, 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 `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\".  Mirá los Peligros del Punto Flotante (en inglés, `The "
"Perils of Floating Point <http://www.lahey.com/float.htm>`_) para una más "
"completa recopilación de otras sorpresas normales."

#: ../Doc/tutorial/floatingpoint.rst:133
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:140
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:146
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:150
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:154
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 es un gran usuario de operaciones de coma flotante, debería echar un "
"vistazo al paquete NumPy y muchos otros paquetes para operaciones "
"matemáticas y estadísticas suministrados por el proyecto SciPy. Consulte "
"<https://scipy.org>."

#: ../Doc/tutorial/floatingpoint.rst:158
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 float. El método :meth:`float."
"as_integer_ratio` expresa el valor del float como una fracción::"

#: ../Doc/tutorial/floatingpoint.rst:167
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:173
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 float en hexadecimal (base 16), "
"nuevamente retornando el valor exacto almacenado por tu computadora::"

#: ../Doc/tutorial/floatingpoint.rst:179
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 float::"

#: ../Doc/tutorial/floatingpoint.rst:185
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:189
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 ""
"Otra herramienta útil es la función :func:`math.fsum` que ayuda a mitigar la "
"pérdida de precisión durante la suma.  Esta función lleva la cuenta de "
"\"dígitos perdidos\" mientras se suman los valores en un total.  Eso puede "
"hacer una diferencia en la exactitud de lo que se va sumando para que los "
"errores no se acumulen al punto en que afecten el total final::"

#: ../Doc/tutorial/floatingpoint.rst:203
msgid "Representation Error"
msgstr "Error de Representación"

#: ../Doc/tutorial/floatingpoint.rst:205
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:209
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:214
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 ""
"¿Por qué es eso?  1/10 no es representable exactamente como una fracción "
"binaria.  Casi todas las máquinas de hoy en día (Noviembre del 2000) usan "
"aritmética de punto flotante IEEE-754, y casi todas las plataformas mapean "
"los flotantes de Python al \"doble precisión\" de IEEE-754.  Estos "
"\"dobles\" tienen 53 bits de precisión, por lo tanto en la entrada la "
"computadora intenta convertir 0.1 a la fracción más cercana que puede de la "
"forma *J*/2\\*\\**N* donde *J* es un entero que contiene exactamente 53 "
"bits. Reescribiendo ::"

#: ../Doc/tutorial/floatingpoint.rst:223
msgid "as ::"
msgstr "...como ::"

#: ../Doc/tutorial/floatingpoint.rst:227
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:233
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:240
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:246
msgid ""
"Therefore the best possible approximation to 1/10 in 754 double precision "
"is::"
msgstr "Por lo tanto la mejor aproximación a 1/10 en doble precisión 754 es::"

#: ../Doc/tutorial/floatingpoint.rst:250
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:254
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:258
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 ""
"Entonces la computadora nunca \"ve\" 1/10:  lo que ve es la fracción exacta "
"de arriba, la mejor aproximación al flotante doble de 754 que puede obtener::"

#: ../Doc/tutorial/floatingpoint.rst:264
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:270
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 "
"más viejas de Python), redondean el resultado a 17 dígitos significativos::"

#: ../Doc/tutorial/floatingpoint.rst:278
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::"