decimal.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-12-15 23:37-0500\n"
"Last-Translator: Adolfo Hristo David Roque Gámez <aroquega@gmail.com>\n"
"Language: es_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/library/decimal.rst:2
msgid ":mod:`decimal` --- Decimal fixed point and floating point arithmetic"
msgstr ":mod:`decimal` --- Aritmética decimal de coma fija y coma flotante"

#: ../Doc/library/decimal.rst:15
msgid "**Source code:** :source:`Lib/decimal.py`"
msgstr "**Código fuente:** :source:`Lib/decimal.py`"

#: ../Doc/library/decimal.rst:33
#, fuzzy
msgid ""
"The :mod:`decimal` module provides support for fast correctly rounded "
"decimal floating point arithmetic. It offers several advantages over the :"
"class:`float` datatype:"
msgstr ""
"El módulo :mod:`decimal` proporciona soporte para aritmética decimal de coma "
"flotante rápida y con redondeo matemáticamente correcto. Ofrece varias "
"ventajas en comparación con el tipo de dato :class:`float`:"

#: ../Doc/library/decimal.rst:37
msgid ""
"Decimal \"is based on a floating-point model which was designed with people "
"in mind, and necessarily has a paramount guiding principle -- computers must "
"provide an arithmetic that works in the same way as the arithmetic that "
"people learn at school.\" -- excerpt from the decimal arithmetic "
"specification."
msgstr ""
"Decimal \"se basa en un modelo de coma flotante que se diseñó pensando en "
"las personas, y necesariamente tiene un principio rector supremo: las "
"computadoras deben proporcionar una aritmética que funcione de la misma "
"manera que la aritmética que las personas aprenden en la escuela.\" -- "
"extracto (traducido) de la especificación de la aritmética decimal."

#: ../Doc/library/decimal.rst:42
msgid ""
"Decimal numbers can be represented exactly.  In contrast, numbers like :"
"const:`1.1` and :const:`2.2` do not have exact representations in binary "
"floating point. End users typically would not expect ``1.1 + 2.2`` to "
"display as :const:`3.3000000000000003` as it does with binary floating point."
msgstr ""
"Los números decimales se pueden representar de forma exacta en coma flotante "
"decimal. En cambio, números como :const:`1.1` y :const:`2.2` no tienen "
"representaciones exactas en coma flotante binaria. Los usuarios finales "
"normalmente no esperaran que ``1.1 + 2.2`` se muestre como :const:"
"`3.3000000000000003`, como ocurre al usar la representación binaria en coma "
"flotante."

#: ../Doc/library/decimal.rst:47
msgid ""
"The exactness carries over into arithmetic.  In decimal floating point, "
"``0.1 + 0.1 + 0.1 - 0.3`` is exactly equal to zero.  In binary floating "
"point, the result is :const:`5.5511151231257827e-017`.  While near to zero, "
"the differences prevent reliable equality testing and differences can "
"accumulate. For this reason, decimal is preferred in accounting applications "
"which have strict equality invariants."
msgstr ""
"La exactitud se traslada a la aritmética. En coma flotante decimal, ``0.1 + "
"0.1 + 0.1 - 0.3`` es exactamente igual a cero. En coma flotante binaria, el "
"resultado es :const:`5.5511151231257827e-017`. Aunque cercanas a cero, las "
"diferencias impiden pruebas de igualdad confiables y las diferencias pueden "
"acumularse. Por estas razones, se recomienda el uso de decimal en "
"aplicaciones de contabilidad con estrictas restricciones de confiabilidad."

#: ../Doc/library/decimal.rst:54
msgid ""
"The decimal module incorporates a notion of significant places so that "
"``1.30 + 1.20`` is :const:`2.50`.  The trailing zero is kept to indicate "
"significance. This is the customary presentation for monetary applications. "
"For multiplication, the \"schoolbook\" approach uses all the figures in the "
"multiplicands.  For instance, ``1.3 * 1.2`` gives :const:`1.56` while ``1.30 "
"* 1.20`` gives :const:`1.5600`."
msgstr ""
"El módulo decimal incorpora una noción de dígitos significativos, de modo "
"que ``1.30 + 1.20`` es :const:`2.50`. El cero final se mantiene para indicar "
"el número de dígitos significativos. Esta es la representación habitual en "
"aplicaciones monetarias. Para la multiplicación, el método de \"libro "
"escolar\" utilizado usa todas las cifras de los multiplicandos. Por ejemplo, "
"``1.3 * 1.2`` es igual a :const:`1.56`, mientras que ``1.30 * 1.20`` es "
"igual a :const:`1.5600`."

#: ../Doc/library/decimal.rst:61
msgid ""
"Unlike hardware based binary floating point, the decimal module has a user "
"alterable precision (defaulting to 28 places) which can be as large as "
"needed for a given problem:"
msgstr ""
"A diferencia del punto flotante binario basado en hardware, el módulo "
"decimal tiene una precisión modificable por el usuario (por defecto es de 28 "
"dígitos decimales) que puede ser tan grande como sea necesario para un "
"problema dado:"

#: ../Doc/library/decimal.rst:73
msgid ""
"Both binary and decimal floating point are implemented in terms of published "
"standards.  While the built-in float type exposes only a modest portion of "
"its capabilities, the decimal module exposes all required parts of the "
"standard. When needed, the programmer has full control over rounding and "
"signal handling. This includes an option to enforce exact arithmetic by "
"using exceptions to block any inexact operations."
msgstr ""
"Tanto la representación en coma flotante binaria como la decimal se "
"implementan de acuerdo a estándares publicados. Mientras que el tipo float "
"expone solo una pequeña parte de sus capacidades, el módulo decimal expone "
"todos los componentes requeridos del estándar. Cuando es necesario, el "
"desarrollador tiene control total sobre el redondeo y la gestión de las "
"señales. Esto incluye la capacidad de forzar la aritmética exacta, "
"utilizando excepciones para bloquear cualquier operación inexacta."

#: ../Doc/library/decimal.rst:80
msgid ""
"The decimal module was designed to support \"without prejudice, both exact "
"unrounded decimal arithmetic (sometimes called fixed-point arithmetic) and "
"rounded floating-point arithmetic.\"  -- excerpt from the decimal arithmetic "
"specification."
msgstr ""
"El módulo decimal fue diseñado para admitir \"indiscriminadamente, tanto "
"aritmética decimal exacta sin redondeo (a veces llamada aritmética de coma "
"fija) como la aritmética de coma flotante con redondeo.\" -- extracto "
"(traducido) de la especificación de la aritmética decimal."

#: ../Doc/library/decimal.rst:85
msgid ""
"The module design is centered around three concepts:  the decimal number, "
"the context for arithmetic, and signals."
msgstr ""
"El módulo está diseñado en torno a tres conceptos: el número decimal, el "
"contexto aritmético y las señales."

#: ../Doc/library/decimal.rst:88
msgid ""
"A decimal number is immutable.  It has a sign, coefficient digits, and an "
"exponent.  To preserve significance, the coefficient digits do not truncate "
"trailing zeros.  Decimals also include special values such as :const:"
"`Infinity`, :const:`-Infinity`, and :const:`NaN`.  The standard also "
"differentiates :const:`-0` from :const:`+0`."
msgstr ""
"Un número decimal es inmutable. Tiene un signo, un coeficiente y un "
"exponente. Para conservar el número de dígitos significativos, los ceros "
"iniciales no se truncan. Los números decimales también incluyen valores "
"especiales como :const:`Infinity`, :const:`-Infinity` y :const:`NaN`. El "
"estándar también marca la diferencia entre :const:`-0` y :const:`+0`."

#: ../Doc/library/decimal.rst:94
msgid ""
"The context for arithmetic is an environment specifying precision, rounding "
"rules, limits on exponents, flags indicating the results of operations, and "
"trap enablers which determine whether signals are treated as exceptions.  "
"Rounding options include :const:`ROUND_CEILING`, :const:`ROUND_DOWN`, :const:"
"`ROUND_FLOOR`, :const:`ROUND_HALF_DOWN`, :const:`ROUND_HALF_EVEN`, :const:"
"`ROUND_HALF_UP`, :const:`ROUND_UP`, and :const:`ROUND_05UP`."
msgstr ""
"El contexto aritmético es un entorno que permite especificar una precisión, "
"reglas de redondeo, límites en los exponentes, flags que indican el "
"resultado de las operaciones y habilitadores de trampas que especifican si "
"las señales (reportadas durante operaciones ilegales) son tratadas o no como "
"excepciones de Python. Las opciones de redondeo incluyen :const:"
"`ROUND_CEILING`, :const:`ROUND_DOWN`, :const:`ROUND_FLOOR`, :const:"
"`ROUND_HALF_DOWN`, :const:`ROUND_HALF_EVEN`, :const:`ROUND_HALF_UP`, :const:"
"`ROUND_UP` y :const:`ROUND_05UP`."

#: ../Doc/library/decimal.rst:101
msgid ""
"Signals are groups of exceptional conditions arising during the course of "
"computation.  Depending on the needs of the application, signals may be "
"ignored, considered as informational, or treated as exceptions. The signals "
"in the decimal module are: :const:`Clamped`, :const:`InvalidOperation`, :"
"const:`DivisionByZero`, :const:`Inexact`, :const:`Rounded`, :const:"
"`Subnormal`, :const:`Overflow`, :const:`Underflow` and :const:"
"`FloatOperation`."
msgstr ""
"Las señales son grupos de condiciones excepcionales que ocurren durante el "
"cálculo. Dependiendo de las necesidades de la aplicación, las señales pueden "
"ignorarse, tratarse como información o tratarse como excepciones. Las "
"señales existentes en el módulo decimal son :const:`Clamped`, :const:"
"`InvalidOperation`, :const:`DivisionByZero`, :const:`Inexact`, :const:"
"`Rounded`, :const:`Subnormal`, :const:`Overflow`, :const:`Underflow` y :"
"const:`FloatOperation`."

#: ../Doc/library/decimal.rst:108
msgid ""
"For each signal there is a flag and a trap enabler.  When a signal is "
"encountered, its flag is set to one, then, if the trap enabler is set to "
"one, an exception is raised.  Flags are sticky, so the user needs to reset "
"them before monitoring a calculation."
msgstr ""
"Por cada señal hay un flag y un habilitador de trampa. Cuando ocurre una "
"operación ilegal, su flag se establece en uno, luego, si su habilitador de "
"trampa está establecido en uno, se lanza una excepción. La configuración de "
"los flags es persistente, por lo que el usuario debe restablecerlos antes de "
"comenzar un cálculo que desee monitorear."

#: ../Doc/library/decimal.rst:116
#, fuzzy
msgid ""
"IBM's General Decimal Arithmetic Specification, `The General Decimal "
"Arithmetic Specification <https://speleotrove.com/decimal/decarith.html>`_."
msgstr ""
"Especificación general de la aritmética decimal de IBM, `The General Decimal "
"Arithmetic Specification <http://speleotrove.com/decimal/decarith.html>`_."

#: ../Doc/library/decimal.rst:125
msgid "Quick-start Tutorial"
msgstr "Tutorial de inicio rápido"

#: ../Doc/library/decimal.rst:127
msgid ""
"The usual start to using decimals is importing the module, viewing the "
"current context with :func:`getcontext` and, if necessary, setting new "
"values for precision, rounding, or enabled traps::"
msgstr ""
"El punto de partida habitual para usar decimales es importar el módulo, ver "
"el contexto actual con :func:`getcontext` y, si es necesario, establecer "
"nuevos valores para la precisión, el redondeo o trampas de señales "
"habilitadas::"

#: ../Doc/library/decimal.rst:139
msgid ""
"Decimal instances can be constructed from integers, strings, floats, or "
"tuples. Construction from an integer or a float performs an exact conversion "
"of the value of that integer or float.  Decimal numbers include special "
"values such as :const:`NaN` which stands for \"Not a number\", positive and "
"negative :const:`Infinity`, and :const:`-0`::"
msgstr ""
"Las instancias de la clase Decimal se pueden construir a partir de números "
"enteros, cadenas de caracteres, flotantes o tuplas. La construcción a partir "
"de un número entero o flotante realiza una conversión exacta del valor de "
"ese número. Los números decimales incluyen valores especiales como :const:"
"`NaN`, que significa \"No es un número\", :const:`Infinity` positivo y "
"negativo o :const:`-0`::"

#: ../Doc/library/decimal.rst:163
msgid ""
"If the :exc:`FloatOperation` signal is trapped, accidental mixing of "
"decimals and floats in constructors or ordering comparisons raises an "
"exception::"
msgstr ""
"Si la señal :exc:`FloatOperation` es atrapada, la mezcla accidental de "
"decimales y flotantes en constructores o comparaciones de orden lanzará una "
"excepción::"

#: ../Doc/library/decimal.rst:182
msgid ""
"The significance of a new Decimal is determined solely by the number of "
"digits input.  Context precision and rounding only come into play during "
"arithmetic operations."
msgstr ""
"La significación de un nuevo objeto Decimal es determinada únicamente por el "
"número de dígitos ingresados. La precisión y el redondeo establecidos en el "
"contexto solo entran en juego durante las operaciones aritméticas."

#: ../Doc/library/decimal.rst:199
msgid ""
"If the internal limits of the C version are exceeded, constructing a decimal "
"raises :class:`InvalidOperation`::"
msgstr ""
"Se lanza una excepción :class:`InvalidOperation` si durante la construcción "
"de un objeto Decimal se exceden los límites internos de la versión de C::"

#: ../Doc/library/decimal.rst:209
msgid ""
"Decimals interact well with much of the rest of Python.  Here is a small "
"decimal floating point flying circus:"
msgstr ""
"Los objetos Decimal interactúan bien con gran parte del resto de Python. "
"Aquí hay un pequeño circo volador de punto flotante decimal:"

#: ../Doc/library/decimal.rst:241
msgid "And some mathematical functions are also available to Decimal:"
msgstr ""
"Y algunas funciones matemáticas también están disponibles para Decimal:"

#: ../Doc/library/decimal.rst:253
msgid ""
"The :meth:`quantize` method rounds a number to a fixed exponent.  This "
"method is useful for monetary applications that often round results to a "
"fixed number of places:"
msgstr ""
"El método :meth:`quantize` redondea un número a un exponente fijo. Este "
"método es útil para aplicaciones monetarias, que a menudo redondean los "
"resultados a un número fijo de dígitos significativos:"

#: ../Doc/library/decimal.rst:262
msgid ""
"As shown above, the :func:`getcontext` function accesses the current context "
"and allows the settings to be changed.  This approach meets the needs of "
"most applications."
msgstr ""
"Como se muestra arriba, la función :func:`getcontext` accede al contexto "
"actual y permite cambiar la configuración. Este enfoque satisface las "
"necesidades de la mayoría de las aplicaciones."

#: ../Doc/library/decimal.rst:266
msgid ""
"For more advanced work, it may be useful to create alternate contexts using "
"the Context() constructor.  To make an alternate active, use the :func:"
"`setcontext` function."
msgstr ""
"Para trabajos más avanzados, puede resultar útil crear contextos "
"alternativos utilizando el constructor Context(). Para activar un contexto "
"alternativo, usa la función :func:`setcontext`."

#: ../Doc/library/decimal.rst:270
msgid ""
"In accordance with the standard, the :mod:`decimal` module provides two "
"ready to use standard contexts, :const:`BasicContext` and :const:"
"`ExtendedContext`. The former is especially useful for debugging because "
"many of the traps are enabled:"
msgstr ""
"De acuerdo con el estándar, el módulo :mod:`decimal` proporciona dos "
"contextos estándar listos para usar, :const:`BasicContext` y :const:"
"`ExtendedContext`. El primero es particularmente útil para la depuración, ya "
"que muchas de las trampas de señales están habilitadas por defecto:"

#: ../Doc/library/decimal.rst:299
msgid ""
"Contexts also have signal flags for monitoring exceptional conditions "
"encountered during computations.  The flags remain set until explicitly "
"cleared, so it is best to clear the flags before each set of monitored "
"computations by using the :meth:`clear_flags` method. ::"
msgstr ""
"Los objetos Context también tienen flags de señalización para detectar "
"condiciones excepcionales detectadas durante los cálculos. Estos flags "
"permanecen habilitados hasta que se restablecen explícitamente. Por esta "
"razón, suele ser buena idea restablecerlos mediante el método :meth:"
"`clear_flags` antes de proceder con cada conjunto de cálculos "
"monitorizados. ::"

#: ../Doc/library/decimal.rst:312
msgid ""
"The *flags* entry shows that the rational approximation to :const:`Pi` was "
"rounded (digits beyond the context precision were thrown away) and that the "
"result is inexact (some of the discarded digits were non-zero)."
msgstr ""
"La entrada *flags* muestra que la aproximación racional de :const:`Pi` fue "
"redondeada (los dígitos más allá de la precisión especificada por el "
"contexto se descartaron) y que el resultado es inexacto (algunos de los "
"dígitos descartados no eran cero)."

#: ../Doc/library/decimal.rst:316
msgid ""
"Individual traps are set using the dictionary in the :attr:`traps` field of "
"a context:"
msgstr ""
"Las trampas de señales se habilitan a través del diccionario expuesto por el "
"atributo :attr:`traps` del objeto Context:"

#: ../Doc/library/decimal.rst:331
msgid ""
"Most programs adjust the current context only once, at the beginning of the "
"program.  And, in many applications, data is converted to :class:`Decimal` "
"with a single cast inside a loop.  With context set and decimals created, "
"the bulk of the program manipulates the data no differently than with other "
"Python numeric types."
msgstr ""
"La mayoría de los programas ajustan el contexto actual una sola vez, al "
"comienzo del programa. Y, en muchas aplicaciones, los datos se convierten a :"
"class:`Decimal` mediante una única conversión dentro de un bucle. Con el "
"contexto establecido y los decimales creados, la mayor parte del programa "
"manipula los datos de la misma forma que con otros tipos numéricos de Python."

#: ../Doc/library/decimal.rst:343
msgid "Decimal objects"
msgstr "Objetos Decimal"

#: ../Doc/library/decimal.rst:348
msgid "Construct a new :class:`Decimal` object based from *value*."
msgstr "Construye un nuevo objeto :class:`Decimal` basado en *value*."

#: ../Doc/library/decimal.rst:350
msgid ""
"*value* can be an integer, string, tuple, :class:`float`, or another :class:"
"`Decimal` object. If no *value* is given, returns ``Decimal('0')``.  If "
"*value* is a string, it should conform to the decimal numeric string syntax "
"after leading and trailing whitespace characters, as well as underscores "
"throughout, are removed::"
msgstr ""
"*value* puede ser un entero, una cadena de caracteres, una tupla, un :class:"
"`float` u otro objeto :class:`Decimal`. Si no se proporciona *value*, "
"retorna ``Decimal('0')``. Si *value* es una cadena, debe ajustarse a la "
"sintaxis de cadena numérica decimal después de que los espacios en blanco "
"iniciales y finales, así como los guiones bajos, sean eliminados::"

#: ../Doc/library/decimal.rst:366
msgid ""
"Other Unicode decimal digits are also permitted where ``digit`` appears "
"above.  These include decimal digits from various other alphabets (for "
"example, Arabic-Indic and Devanāgarī digits) along with the fullwidth digits "
"``'\\uff10'`` through ``'\\uff19'``."
msgstr ""
"También se permiten otros dígitos decimales Unicode en aquellos lugares en "
"los que arriba aparece ``digit``. Estos incluyen dígitos decimales de otros "
"alfabetos (por ejemplo, dígitos del alfabeto árabe-índico y devanāgarī) "
"junto con los dígitos de ancho completo desde ``'\\uff10'`` a ``'\\uff19'``."

#: ../Doc/library/decimal.rst:371
msgid ""
"If *value* is a :class:`tuple`, it should have three components, a sign (:"
"const:`0` for positive or :const:`1` for negative), a :class:`tuple` of "
"digits, and an integer exponent. For example, ``Decimal((0, (1, 4, 1, 4), "
"-3))`` returns ``Decimal('1.414')``."
msgstr ""
"Si *value* es un objeto :class:`tuple`, debe tener tres componentes, un "
"signo (:const:`0` para positivo o :const:`1` para negativo), un objeto :"
"class:`tuple` con los dígitos y un exponente entero. Por ejemplo, "
"``Decimal((0, (1, 4, 1, 4), -3))`` retorna ``Decimal('1.414')``."

#: ../Doc/library/decimal.rst:376
msgid ""
"If *value* is a :class:`float`, the binary floating point value is "
"losslessly converted to its exact decimal equivalent.  This conversion can "
"often require 53 or more digits of precision.  For example, "
"``Decimal(float('1.1'))`` converts to "
"``Decimal('1.100000000000000088817841970012523233890533447265625')``."
msgstr ""
"Si *value* es un :class:`float`, el valor binario de coma flotante se "
"convierte sin pérdidas a su equivalente decimal exacto. Esta conversión a "
"menudo puede requerir 53 o más dígitos de precisión. Por ejemplo, "
"``Decimal(float('1.1'))`` se convierte en "
"``Decimal('1.100000000000000088817841970012523233890533447265625')``."

#: ../Doc/library/decimal.rst:382
msgid ""
"The *context* precision does not affect how many digits are stored. That is "
"determined exclusively by the number of digits in *value*. For example, "
"``Decimal('3.00000')`` records all five zeros even if the context precision "
"is only three."
msgstr ""
"La precisión de *context* no afecta a la cantidad de dígitos almacenados. "
"Eso está determinado exclusivamente por el número de dígitos en *value*. Por "
"ejemplo, ``Decimal('3.00000')`` registra los cinco ceros incluso si la "
"precisión del contexto es solo tres."

#: ../Doc/library/decimal.rst:387
msgid ""
"The purpose of the *context* argument is determining what to do if *value* "
"is a malformed string.  If the context traps :const:`InvalidOperation`, an "
"exception is raised; otherwise, the constructor returns a new Decimal with "
"the value of :const:`NaN`."
msgstr ""
"El propósito del argumento *context* es determinar qué hacer si *value* es "
"una cadena de caracteres mal formada. Si el contexto atrapa la señal :const:"
"`InvalidOperation`, se genera una excepción; de lo contrario, el constructor "
"retorna un nuevo decimal con el valor :const:`NaN`."

#: ../Doc/library/decimal.rst:392
msgid "Once constructed, :class:`Decimal` objects are immutable."
msgstr "Una vez construidos, los objetos :class:`Decimal` son inmutables."

#: ../Doc/library/decimal.rst:394
msgid ""
"The argument to the constructor is now permitted to be a :class:`float` "
"instance."
msgstr ""
"Ahora se permite que el argumento del constructor sea una instancia :class:"
"`float`."

#: ../Doc/library/decimal.rst:398
msgid ""
":class:`float` arguments raise an exception if the :exc:`FloatOperation` "
"trap is set. By default the trap is off."
msgstr ""
"Los argumentos :class:`float` ahora generan una excepción si se establece la "
"trampa :exc:`FloatOperation`. Por defecto, la trampa está desactivada."

#: ../Doc/library/decimal.rst:402
msgid ""
"Underscores are allowed for grouping, as with integral and floating-point "
"literals in code."
msgstr ""
"Se permiten guiones bajos para la agrupación, como ocurre en el código con "
"los literales enteros y de punto flotante."

#: ../Doc/library/decimal.rst:406
msgid ""
"Decimal floating point objects share many properties with the other built-in "
"numeric types such as :class:`float` and :class:`int`.  All of the usual "
"math operations and special methods apply.  Likewise, decimal objects can be "
"copied, pickled, printed, used as dictionary keys, used as set elements, "
"compared, sorted, and coerced to another type (such as :class:`float` or :"
"class:`int`)."
msgstr ""
"Los objetos de coma flotante decimal comparten muchas propiedades con los "
"otros tipos numéricos integrados, como :class:`float` e :class:`int`. Se "
"aplican todas las operaciones matemáticas habituales y los métodos "
"especiales. Asimismo, los objetos decimales se pueden copiar, serializar con "
"pickle, imprimir, usar como claves de un diccionario o como elementos de un "
"conjunto, comparar, ordenar y convertir a otros tipos (como :class:`float` "
"o :class:`int`)."

#: ../Doc/library/decimal.rst:413
msgid ""
"There are some small differences between arithmetic on Decimal objects and "
"arithmetic on integers and floats.  When the remainder operator ``%`` is "
"applied to Decimal objects, the sign of the result is the sign of the "
"*dividend* rather than the sign of the divisor::"
msgstr ""
"Hay algunas pequeñas diferencias entre la aritmética en objetos decimales y "
"la aritmética en enteros y flotantes. Cuando el operador de resto ``%`` se "
"aplica a objetos Decimal, el signo del resultado es el signo del *dividendo* "
"en lugar del signo del divisor::"

#: ../Doc/library/decimal.rst:423
msgid ""
"The integer division operator ``//`` behaves analogously, returning the "
"integer part of the true quotient (truncating towards zero) rather than its "
"floor, so as to preserve the usual identity ``x == (x // y) * y + x % y``::"
msgstr ""
"El operador de división entera ``//`` se comporta de manera análoga, "
"retornando la parte entera del cociente verdadero (truncando hacia cero) en "
"lugar del resultado de aplicarle la función suelo. Esto se hace con la "
"finalidad de preservar la identidad habitual ``x == (x // y) * y + x % y``::"

#: ../Doc/library/decimal.rst:432
msgid ""
"The ``%`` and ``//`` operators implement the ``remainder`` and ``divide-"
"integer`` operations (respectively) as described in the specification."
msgstr ""
"Los operadores ``%`` y ``//`` implementan las operaciones ``remainder`` y "
"``divide-integer`` (respectivamente) como se describe en la especificación."

#: ../Doc/library/decimal.rst:436
msgid ""
"Decimal objects cannot generally be combined with floats or instances of :"
"class:`fractions.Fraction` in arithmetic operations: an attempt to add a :"
"class:`Decimal` to a :class:`float`, for example, will raise a :exc:"
"`TypeError`.  However, it is possible to use Python's comparison operators "
"to compare a :class:`Decimal` instance ``x`` with another number ``y``.  "
"This avoids confusing results when doing equality comparisons between "
"numbers of different types."
msgstr ""
"Los objetos de la clase Decimal generalmente no se pueden combinar con "
"flotantes o instancias de :class:`fractions.Fraction` en operaciones "
"aritméticas: un intento de agregar un objeto :class:`Decimal` a un :class:"
"`float`, por ejemplo, lanzará una excepción :exc:`TypeError`. Sin embargo, "
"es posible usar los operadores de comparación de Python para comparar una "
"instancia de :class:`Decimal` ``x`` con otro número ``y``. Esto evita "
"resultados confusos al hacer comparaciones de igualdad entre números de "
"diferentes tipos."

#: ../Doc/library/decimal.rst:444
msgid ""
"Mixed-type comparisons between :class:`Decimal` instances and other numeric "
"types are now fully supported."
msgstr ""
"Las comparaciones de tipo mixto entre instancias de :class:`Decimal` y otros "
"tipos numéricos ahora son totalmente compatibles."

#: ../Doc/library/decimal.rst:448
msgid ""
"In addition to the standard numeric properties, decimal floating point "
"objects also have a number of specialized methods:"
msgstr ""
"Además de las propiedades numéricas estándar, los objetos de coma flotante "
"decimal también tienen varios métodos especializados:"

#: ../Doc/library/decimal.rst:454
msgid ""
"Return the adjusted exponent after shifting out the coefficient's rightmost "
"digits until only the lead digit remains: ``Decimal('321e+5').adjusted()`` "
"returns seven.  Used for determining the position of the most significant "
"digit with respect to the decimal point."
msgstr ""
"Retorna el exponente ajustado después de desplazar los dígitos del extremo "
"derecho del coeficiente hasta que solo quede el dígito principal: "
"``Decimal('321e+5').adjusted()`` retorna siete. Se utiliza para determinar "
"la posición del dígito más significativo con respecto al punto decimal."

#: ../Doc/library/decimal.rst:461
msgid ""
"Return a pair ``(n, d)`` of integers that represent the given :class:"
"`Decimal` instance as a fraction, in lowest terms and with a positive "
"denominator::"
msgstr ""
"Retorna un par de enteros ``(n, d)`` que representan la instancia de :class:"
"`Decimal` proporcionada como una fracción irreducible y con un denominador "
"positivo::"

#: ../Doc/library/decimal.rst:468
msgid ""
"The conversion is exact.  Raise OverflowError on infinities and ValueError "
"on NaNs."
msgstr ""
"La conversión es exacta. Lanza una excepción OverflowError si se "
"proporcionan valores infinitos y ValueError con valores NaN."

#: ../Doc/library/decimal.rst:475
msgid ""
"Return a :term:`named tuple` representation of the number: "
"``DecimalTuple(sign, digits, exponent)``."
msgstr ""
"Retorna una representación en forma de :term:`named tuple` del número: "
"``DecimalTuple(sign, digits, exponent)``."

#: ../Doc/library/decimal.rst:481
msgid ""
"Return the canonical encoding of the argument.  Currently, the encoding of "
"a :class:`Decimal` instance is always canonical, so this operation returns "
"its argument unchanged."
msgstr ""
"Retorna la codificación canónica del argumento. Actualmente, la codificación "
"de una instancia de :class:`Decimal` es siempre canónica, por lo que esta "
"operación retorna su argumento sin cambios."

#: ../Doc/library/decimal.rst:487
msgid ""
"Compare the values of two Decimal instances.  :meth:`compare` returns a "
"Decimal instance, and if either operand is a NaN then the result is a NaN::"
msgstr ""
"Compara los valores de dos instancias de Decimal. El método :meth:`compare` "
"retorna una instancia de Decimal, y si alguno de los operandos es un NaN, el "
"resultado es un NaN::"

#: ../Doc/library/decimal.rst:498
msgid ""
"This operation is identical to the :meth:`compare` method, except that all "
"NaNs signal.  That is, if neither operand is a signaling NaN then any quiet "
"NaN operand is treated as though it were a signaling NaN."
msgstr ""
"Esta operación es idéntica al método :meth:`compare`, excepto que todos los "
"valores NaN generan una señal. Es decir, si ninguno de los operandos es un "
"NaN señalizador, cualquier operando de NaN silencioso se trata como si fuera "
"un NaN señalizador."

#: ../Doc/library/decimal.rst:504
msgid ""
"Compare two operands using their abstract representation rather than their "
"numerical value.  Similar to the :meth:`compare` method, but the result "
"gives a total ordering on :class:`Decimal` instances.  Two :class:`Decimal` "
"instances with the same numeric value but different representations compare "
"unequal in this ordering:"
msgstr ""
"Compara dos operandos utilizando su representación abstracta en lugar de su "
"valor numérico. Similar al método :meth:`compare`, pero el resultado "
"proporciona un ordenamiento total en las instancias de :class:`Decimal`. Dos "
"instancias de :class:`Decimal` con el mismo valor numérico, pero diferentes "
"representaciones, se comparan como desiguales usando este orden:"

#: ../Doc/library/decimal.rst:513
msgid ""
"Quiet and signaling NaNs are also included in the total ordering.  The "
"result of this function is ``Decimal('0')`` if both operands have the same "
"representation, ``Decimal('-1')`` if the first operand is lower in the total "
"order than the second, and ``Decimal('1')`` if the first operand is higher "
"in the total order than the second operand.  See the specification for "
"details of the total order."
msgstr ""
"Los NaN silenciosos y señalizadores también se incluyen en el ordenamiento "
"total. El resultado de esta función es ``Decimal('0')`` si ambos operandos "
"tienen la misma representación, ``Decimal('-1')`` si el primer operando es "
"menor en el orden total que el segundo y ``Decimal('1')`` si el primer "
"operando es mayor en el orden total que el segundo operando. Consulta las "
"especificaciones para obtener detalles sobre el ordenamiento total."

#: ../Doc/library/decimal.rst:520 ../Doc/library/decimal.rst:531
#: ../Doc/library/decimal.rst:559 ../Doc/library/decimal.rst:835
msgid ""
"This operation is unaffected by context and is quiet: no flags are changed "
"and no rounding is performed.  As an exception, the C version may raise "
"InvalidOperation if the second operand cannot be converted exactly."
msgstr ""
"Esta operación no se ve afectada por el contexto y es silenciosa: no se "
"cambian los flags y no se realiza ningún redondeo. Como excepción, la "
"versión de C puede lanzar InvalidOperation si el segundo operando no se "
"puede convertir exactamente."

#: ../Doc/library/decimal.rst:526
msgid ""
"Compare two operands using their abstract representation rather than their "
"value as in :meth:`compare_total`, but ignoring the sign of each operand. "
"``x.compare_total_mag(y)`` is equivalent to ``x.copy_abs().compare_total(y."
"copy_abs())``."
msgstr ""
"Compara dos operandos usando su representación abstracta en lugar de su "
"valor, como en :meth:`compare_total`, pero ignorando el signo de cada "
"operando. ``x.compare_total_mag(y)`` es equivalente a ``x.copy_abs()."
"compare_total(y.copy_abs())``."

#: ../Doc/library/decimal.rst:537
msgid ""
"Just returns self, this method is only to comply with the Decimal "
"Specification."
msgstr ""
"Simplemente retorna self (el propio objeto al que pertenece el método "
"invocado). Este método existe solo para cumplir con la Especificación "
"decimal."

#: ../Doc/library/decimal.rst:542
msgid ""
"Return the absolute value of the argument.  This operation is unaffected by "
"the context and is quiet: no flags are changed and no rounding is performed."
msgstr ""
"Retorna el valor absoluto del argumento. Esta operación no se ve afectada "
"por el contexto y es silenciosa: no se modifican los flags y no se realiza "
"ningún redondeo."

#: ../Doc/library/decimal.rst:548
msgid ""
"Return the negation of the argument.  This operation is unaffected by the "
"context and is quiet: no flags are changed and no rounding is performed."
msgstr ""
"Retorna la negación del argumento. Esta operación no se ve afectada por el "
"contexto y es silenciosa: no se cambian los flags y no se realiza ningún "
"redondeo."

#: ../Doc/library/decimal.rst:553
msgid ""
"Return a copy of the first operand with the sign set to be the same as the "
"sign of the second operand.  For example:"
msgstr ""
"Retorna una copia del primer operando pero con el signo establecido para que "
"sea el mismo que el del segundo operando. Por ejemplo:"

#: ../Doc/library/decimal.rst:565
msgid ""
"Return the value of the (natural) exponential function ``e**x`` at the given "
"number.  The result is correctly rounded using the :const:`ROUND_HALF_EVEN` "
"rounding mode."
msgstr ""
"Retorna el valor de la función exponencial (natural) ``e**x`` en el número "
"dado. El resultado es correctamente redondeado utilizando el modo de "
"redondeo :const:`ROUND_HALF_EVEN`."

#: ../Doc/library/decimal.rst:576
msgid ""
"Alternative constructor that only accepts instances of :class:`float` or :"
"class:`int`."
msgstr ""

#: ../Doc/library/decimal.rst:579
#, fuzzy
msgid ""
"Note ``Decimal.from_float(0.1)`` is not the same as ``Decimal('0.1')``. "
"Since 0.1 is not exactly representable in binary floating point, the value "
"is stored as the nearest representable value which is "
"``0x1.999999999999ap-4``.  That equivalent value in decimal is "
"``0.1000000000000000055511151231257827021181583404541015625``."
msgstr ""
"Nota que `Decimal.from_float (0.1)` no es lo mismo que `Decimal('0.1')`. "
"Dado que 0.1 no es exactamente representable en coma flotante binaria, el "
"valor se almacena como el valor representable más cercano, que es "
"`0x1.999999999999ap-4`. Ese valor equivalente en decimal es "
"`0.1000000000000000055511151231257827021181583404541015625`."

#: ../Doc/library/decimal.rst:585
msgid ""
"From Python 3.2 onwards, a :class:`Decimal` instance can also be constructed "
"directly from a :class:`float`."
msgstr ""
"Desde Python 3.2 en adelante, una instancia de :class:`Decimal` también se "
"puede construir directamente desde una instancia de :class:`float`."

#: ../Doc/library/decimal.rst:603
msgid ""
"Fused multiply-add.  Return self*other+third with no rounding of the "
"intermediate product self*other."
msgstr ""
"Fusión de la multiplicación y la suma. Retorna self*other+third sin redondeo "
"del producto intermedio self*other."

#: ../Doc/library/decimal.rst:611
msgid ""
"Return :const:`True` if the argument is canonical and :const:`False` "
"otherwise.  Currently, a :class:`Decimal` instance is always canonical, so "
"this operation always returns :const:`True`."
msgstr ""
"Retorna :const:`True` si el argumento es canónico y :const:`False` en caso "
"contrario. Actualmente, una instancia de :class:`Decimal` es siempre "
"canónica, por lo que esta operación siempre retorna :const:`True`."

#: ../Doc/library/decimal.rst:617
msgid ""
"Return :const:`True` if the argument is a finite number, and :const:`False` "
"if the argument is an infinity or a NaN."
msgstr ""
"Retorna :const:`True` si el argumento es un número finito y :const:`False` "
"si el argumento es un valor infinito o un NaN."

#: ../Doc/library/decimal.rst:622
msgid ""
"Return :const:`True` if the argument is either positive or negative infinity "
"and :const:`False` otherwise."
msgstr ""
"Retorna :const:`True` si el argumento es un valor infinito positivo o "
"negativo y :const:`False` en caso contrario."

#: ../Doc/library/decimal.rst:627
msgid ""
"Return :const:`True` if the argument is a (quiet or signaling) NaN and :"
"const:`False` otherwise."
msgstr ""
"Retorna :const:`True` si el argumento es un NaN (silencioso o señalizador) "
"y :const:`False` en caso contrario."

#: ../Doc/library/decimal.rst:632
msgid ""
"Return :const:`True` if the argument is a *normal* finite number.  Return :"
"const:`False` if the argument is zero, subnormal, infinite or a NaN."
msgstr ""
"Retorna :const:`True` si el argumento es un número finito *normal*. Retorna :"
"const:`False` si el argumento es cero, subnormal, infinito o un NaN."

#: ../Doc/library/decimal.rst:637
msgid ""
"Return :const:`True` if the argument is a quiet NaN, and :const:`False` "
"otherwise."
msgstr ""
"Retorna :const:`True` si el argumento es un NaN silencioso y :const:`False` "
"en caso contrario."

#: ../Doc/library/decimal.rst:642
msgid ""
"Return :const:`True` if the argument has a negative sign and :const:`False` "
"otherwise.  Note that zeros and NaNs can both carry signs."
msgstr ""
"Retorna :const:`True` si el argumento tiene signo negativo y :const:`False` "
"en caso contrario. Ten en cuenta que tanto los ceros como los NaN pueden "
"tener signo."

#: ../Doc/library/decimal.rst:647
msgid ""
"Return :const:`True` if the argument is a signaling NaN and :const:`False` "
"otherwise."
msgstr ""
"Retorna :const:`True` si el argumento es un NaN señalizador y :const:`False` "
"en caso contrario."

#: ../Doc/library/decimal.rst:652
msgid ""
"Return :const:`True` if the argument is subnormal, and :const:`False` "
"otherwise."
msgstr ""
"Retorna :const:`True` si el argumento es subnormal y :const:`False` en caso "
"contrario."

#: ../Doc/library/decimal.rst:657
msgid ""
"Return :const:`True` if the argument is a (positive or negative) zero and :"
"const:`False` otherwise."
msgstr ""
"Retorna :const:`True` si el argumento es un cero (positivo o negativo) y :"
"const:`False` en caso contrario."

#: ../Doc/library/decimal.rst:662
msgid ""
"Return the natural (base e) logarithm of the operand.  The result is "
"correctly rounded using the :const:`ROUND_HALF_EVEN` rounding mode."
msgstr ""
"Retorna el logaritmo natural (base e) del operando. El resultado es "
"correctamente redondeado utilizando el modo de redondeo :const:"
"`ROUND_HALF_EVEN`."

#: ../Doc/library/decimal.rst:667
msgid ""
"Return the base ten logarithm of the operand.  The result is correctly "
"rounded using the :const:`ROUND_HALF_EVEN` rounding mode."
msgstr ""
"Retorna el logaritmo en base diez del operando. El resultado es "
"correctamente redondeado utilizando el modo de redondeo :const:"
"`ROUND_HALF_EVEN`."

#: ../Doc/library/decimal.rst:672
msgid ""
"For a nonzero number, return the adjusted exponent of its operand as a :"
"class:`Decimal` instance.  If the operand is a zero then ``Decimal('-"
"Infinity')`` is returned and the :const:`DivisionByZero` flag is raised.  If "
"the operand is an infinity then ``Decimal('Infinity')`` is returned."
msgstr ""
"Para un número distinto de cero, retorna el exponente ajustado de su "
"operando como una instancia de :class:`Decimal`. Si el operando es cero, se "
"retorna ``Decimal('-Infinity')`` y se activa el flag :const:"
"`DivisionByZero`. Si el operando es infinito, se retorna "
"``Decimal('Infinity')``."

#: ../Doc/library/decimal.rst:680
msgid ""
":meth:`logical_and` is a logical operation which takes two *logical "
"operands* (see :ref:`logical_operands_label`).  The result is the digit-wise "
"``and`` of the two operands."
msgstr ""
":meth:`logic_and` es una operación lógica que toma dos *operandos lógicos* "
"(consultar :ref:`logical_operands_label`). El resultado es el ``and`` dígito "
"por dígito de los dos operandos."

#: ../Doc/library/decimal.rst:686
msgid ""
":meth:`logical_invert` is a logical operation.  The result is the digit-wise "
"inversion of the operand."
msgstr ""
":meth:`logic_invert` es una operación lógica. El resultado es la inversión "
"dígito a dígito del operando."

#: ../Doc/library/decimal.rst:691
msgid ""
":meth:`logical_or` is a logical operation which takes two *logical operands* "
"(see :ref:`logical_operands_label`).  The result is the digit-wise ``or`` of "
"the two operands."
msgstr ""
":meth:`logical_or` es una operación lógica que toma dos *operandos lógicos* "
"(consultar :ref:`logical_operands_label`). El resultado es un ``or`` dígito "
"a dígito de los dos operandos."

#: ../Doc/library/decimal.rst:697
msgid ""
":meth:`logical_xor` is a logical operation which takes two *logical "
"operands* (see :ref:`logical_operands_label`).  The result is the digit-wise "
"exclusive or of the two operands."
msgstr ""
":meth:`logic_xor` es una operación lógica que toma dos *operandos lógicos* "
"(consultar :ref:`logical_operands_label`). El resultado es la disyunción "
"exclusiva (\"exclusive or\") dígito a dígito de ambos operandos."

#: ../Doc/library/decimal.rst:703
msgid ""
"Like ``max(self, other)`` except that the context rounding rule is applied "
"before returning and that :const:`NaN` values are either signaled or ignored "
"(depending on the context and whether they are signaling or quiet)."
msgstr ""
"Como ``max(self, other)``, excepto que la regla de redondeo del contexto se "
"aplica antes de retornar y que los valores :const:`NaN` generan una señal o "
"son ignorados (dependiendo del contexto y de si son señalizadores o "
"silenciosos)."

#: ../Doc/library/decimal.rst:710
msgid ""
"Similar to the :meth:`.max` method, but the comparison is done using the "
"absolute values of the operands."
msgstr ""
"Similar al método :meth:`.max`, pero la comparación se realiza utilizando "
"los valores absolutos de los operandos."

#: ../Doc/library/decimal.rst:715
msgid ""
"Like ``min(self, other)`` except that the context rounding rule is applied "
"before returning and that :const:`NaN` values are either signaled or ignored "
"(depending on the context and whether they are signaling or quiet)."
msgstr ""
"Como ``min(self, other)``, excepto que la regla de redondeo del contexto se "
"aplica antes de retornar y que los valores :const:`NaN` generan una señal o "
"se ignoran (según el contexto y si son señalizadores o no)."

#: ../Doc/library/decimal.rst:722
msgid ""
"Similar to the :meth:`.min` method, but the comparison is done using the "
"absolute values of the operands."
msgstr ""
"Similar al método :meth:`.min`, pero la comparación se realiza utilizando "
"los valores absolutos de los operandos."

#: ../Doc/library/decimal.rst:727
msgid ""
"Return the largest number representable in the given context (or in the "
"current thread's context if no context is given) that is smaller than the "
"given operand."
msgstr ""
"Retorna el número más grande representable en el contexto proporcionado (o "
"en el contexto del hilo actual si no se proporciona un contexto) que sea más "
"pequeño que el operando proporcionado."

#: ../Doc/library/decimal.rst:733
msgid ""
"Return the smallest number representable in the given context (or in the "
"current thread's context if no context is given) that is larger than the "
"given operand."
msgstr ""
"Retorna el número más pequeño representable en el contexto proporcionado (o "
"en el contexto del hilo actual si no se proporciona ningún contexto) que sea "
"más grande que el operando proporcionado."

#: ../Doc/library/decimal.rst:739
msgid ""
"If the two operands are unequal, return the number closest to the first "
"operand in the direction of the second operand.  If both operands are "
"numerically equal, return a copy of the first operand with the sign set to "
"be the same as the sign of the second operand."
msgstr ""
"Si los dos operandos no son iguales, retorna el número más cercano al primer "
"operando en la dirección del segundo operando. Si ambos operandos son "