Traducido tutorial/floatingpoint.po

tutorial/floatingpoint.po

@@ -11,22 +11,22 @@ 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: 2021-08-02 19:49+0200\n"
-"Last-Translator: Cristián Maureira-Fredes <[email protected]>\n"
-"Language: es\n"
+"PO-Revision-Date: 2023-10-14 20:05-0300\n"
+"Last-Translator: Carlos A. Crespo <[email protected]>\n"
 "Language-Team: python-doc-es\n"
-"Plural-Forms: nplurals=2; plural=(n != 1);\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
-#, fuzzy
 msgid ""
 "Floating-point numbers are represented in computer hardware as base 2 "
 "(binary) fractions.  For example, the **decimal** fraction ``0.625`` has "
@@ -35,9 +35,13 @@ msgid ""
 "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."
+"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 ""
@@ -101,7 +105,6 @@ msgstr ""
 "pero no es exactamente el valor verdadero de 1/10."
 
 #: ../Doc/tutorial/floatingpoint.rst:58
-#, 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 "
@@ -110,21 +113,20 @@ msgid ""
 "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 "
+"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 "
+"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 ::"
+"para 0.1, debería mostrar::"
 
 #: ../Doc/tutorial/floatingpoint.rst:67
-#, 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 ""
 "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 ::"
+"lo que Python mantiene manejable la cantidad de dígitos al mostrar un valor "
+"redondeado en su lugar:"
 
 #: ../Doc/tutorial/floatingpoint.rst:75
 msgid ""
@@ -180,13 +182,12 @@ msgstr ""
 "diferencia, o no lo hagan en todos los modos de salida)."
 
 #: ../Doc/tutorial/floatingpoint.rst:97
-#, fuzzy
 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::"
+"texto para generar un número limitado de dígitos significativos:"
 
 #: ../Doc/tutorial/floatingpoint.rst:111
 msgid ""
@@ -197,44 +198,41 @@ msgstr ""
 "simplemente redondeando al *mostrar* el valor verdadero de la máquina."
 
 #: ../Doc/tutorial/floatingpoint.rst:114
-#, 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 ""
-"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::"
+"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
-#, 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 ""
 "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::"
+"función :func:`round` no puede ayudar:"
 
 #: ../Doc/tutorial/floatingpoint.rst:131
-#, 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 ""
-"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í::"
+"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
-#, fuzzy
 msgid ""
 "Binary floating-point arithmetic holds many surprises like this.  The "
 "problem with \"0.1\" is explained in precise detail below, in the "
@@ -247,9 +245,13 @@ msgid ""
 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."
+"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 ""
@@ -305,55 +307,51 @@ msgstr ""
 "1/3 pueden ser representados exactamente)."
 
 #: ../Doc/tutorial/floatingpoint.rst:177
-#, 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 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 "
+"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
-#, 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 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::"
+"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
-#, fuzzy
 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::"
+"valor original:"
 
 #: ../Doc/tutorial/floatingpoint.rst:200
-#, fuzzy
 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::"
+"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
-#, fuzzy
 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::"
+"valor exacto del punto flotante:"
 
 #: ../Doc/tutorial/floatingpoint.rst:216
 msgid ""
@@ -368,19 +366,18 @@ msgstr ""
 "formato (como Java y C99)."
 
 #: ../Doc/tutorial/floatingpoint.rst:220
-#, 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 ""
-"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::"
+"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 ""
@@ -390,6 +387,12 @@ msgid ""
 "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"
@@ -421,7 +424,6 @@ msgstr ""
 "mostrarán el número decimal exacto que esperás."
 
 #: ../Doc/tutorial/floatingpoint.rst:271
-#, 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 "
@@ -431,52 +433,50 @@ msgid ""
 "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 ::"
+"¿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
-#, fuzzy
 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::"
+"2**53``), el mejor valor para *N* es 56:"
 
 #: ../Doc/tutorial/floatingpoint.rst:294
-#, 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 ""
 "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::"
+"El mejor valor posible para *J* es entonces el cociente redondeado:"
 
 #: ../Doc/tutorial/floatingpoint.rst:303
-#, fuzzy
 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::"
+"redondeándolo:"
 
 #: ../Doc/tutorial/floatingpoint.rst:313
-#, fuzzy
 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 754 es::"
+msgstr ""
+"Por lo tanto la mejor aproximación a 1/10 en doble precisión IEEE 754 es::"
 
 #: ../Doc/tutorial/floatingpoint.rst:318
 msgid ""
@@ -495,40 +495,37 @@ msgstr ""
 "1/10.  ¡Pero no hay caso en que sea *exactamente* 1/10!"
 
 #: ../Doc/tutorial/floatingpoint.rst:326
-#, 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 ""
-"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::"
+"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
-#, fuzzy
 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::"
+"55 dígitos decimales:"
 
 #: ../Doc/tutorial/floatingpoint.rst:342
-#, 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 ""
-"...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::"
+"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
-#, fuzzy
 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::"
+"Los módulos :mod:`fractions` y :mod:`decimal` hacen fácil estos cálculos:"