Movatterモバイル変換

[0]ホーム
URL:

Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly

 Sign up
Appearance settings

Traducido tutorial/floatingpoint.po#2669

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to ourterms of service andprivacy statement. We’ll occasionally send you account related emails.

Already on GitHub?Sign in to your account

Merged
rtobar merged 3 commits intopython:3.12fromcacrespo:tutorial_floatingpoint.po
Oct 15, 2023
Merged
Changes fromall commits
Commits
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
159 changes: 78 additions & 81 deletionstutorial/floatingpoint.po
View file
Open in desktop
Original file line numberDiff line numberDiff line change
Expand Up@@ -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 <cmaureirafredes@gmail.com>\n"
"Language: es\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"
"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 "
Expand All@@ -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 ""
Expand DownExpand Up@@ -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 "
Expand All@@ -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 mostraren su "
"lugar un valor redondeado ::"
"lo que Python mantiene manejable la cantidad de dígitos al mostrarun valor "
"redondeado en su lugar:"

#: ../Doc/tutorial/floatingpoint.rst:75
msgid ""
Expand DownExpand Up@@ -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 ""
Expand All@@ -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 "
Expand All@@ -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 ""
Expand DownExpand Up@@ -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 ""
"Sies ungranusuario de operaciones decoma flotante,debería echar un "
"vistazo al paquete NumPy y muchos otros paquetes para operaciones "
"matemáticas y estadísticassuministrados por el proyecto SciPy.Consulte "
"Sieres un usuariointensivode operaciones depunto flotante,deberías "
"echar unvistazo al paquete NumPy y a muchos otros paquetes para operaciones "
"matemáticas y estadísticasproporcionados 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 unfloaten hexadecimal (base 16), "
"nuevamente retornando el valor exacto almacenado por tu computadora::"
"El método :meth:`float.hex` expresa unpunto flotanteen 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 delfloat::"
"valor exacto delpunto flotante:"

#: ../Doc/tutorial/floatingpoint.rst:216
msgid ""
Expand All@@ -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 losvaloresen un total. Eso puede "
"hacer una diferencia en laexactitud de lo que se va sumandopara que los "
"errores no se acumulenalpunto 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 agreganvaloresa un total en "
"ejecución. Esto puede marcar ladiferencia en la precisión generalpara que "
"loserrores no se acumulenhasta elpunto en que afecten el total final:"

#: ../Doc/tutorial/floatingpoint.rst:233
msgid ""
Expand All@@ -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"
Expand DownExpand Up@@ -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 "
Expand All@@ -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 ""
Expand All@@ -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 "
"igualal 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ígitossignificativos::"
"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:"
[8]ページ先頭
©2009-2025 Movatter.jp