# 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: 2024-11-21 16:38-0300\n" "PO-Revision-Date: 2023-11-23 16:41+0100\n" "Last-Translator: Francisco Mora \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.16.0\n" #: ../Doc/library/decimal.rst:2 #, fuzzy 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 de coma " "flotante decimal rápida y redondeada correctamente. 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 " "``1.1`` and ``2.2`` do not have exact representations in binary floating " "point. End users typically would not expect ``1.1 + 2.2`` to display as " "``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 ``1.1`` y ``2.2`` no tienen " "representaciones exactas en coma flotante binaria. Los usuarios finales " "normalmente no esperaran que ``1.1 + 2.2`` se muestre como " "``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 ``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 ``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 ``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 ``1.56`` while ``1.30 * " "1.20`` gives ``1.5600``." msgstr "" "El módulo decimal incorpora una noción de dígitos significativos, de modo " "que ``1.30 + 1.20`` es ``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 ``1.56``, mientras que ``1.30 * 1.20`` es igual a " "``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 " "incorporado 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 ``Infinity``, " "``-Infinity``, and ``NaN``. The standard also differentiates ``-0`` from " "``+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 ``Infinity``, ``-Infinity`` y ``NaN``. El estándar también " "marca la diferencia entre ``-0`` y ``+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 msgid "" "IBM's General Decimal Arithmetic Specification, `The General Decimal " "Arithmetic Specification `_." msgstr "" "Especificación general de la aritmética decimal de IBM, `The General Decimal " "Arithmetic Specification `_." #: ../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:131 msgid "" ">>> from decimal import *\n" ">>> getcontext()\n" "Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,\n" " capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,\n" " InvalidOperation])\n" "\n" ">>> getcontext().prec = 7 # Set a new precision" msgstr "" #: ../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 ``NaN`` which stands for \"Not a number\", positive and " "negative ``Infinity``, and ``-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 ``NaN``, " "que significa \"No es un número\", ``Infinity`` positivo y negativo o " "``-0``::" #: ../Doc/library/decimal.rst:145 msgid "" ">>> getcontext().prec = 28\n" ">>> Decimal(10)\n" "Decimal('10')\n" ">>> Decimal('3.14')\n" "Decimal('3.14')\n" ">>> Decimal(3.14)\n" "Decimal('3.140000000000000124344978758017532527446746826171875')\n" ">>> Decimal((0, (3, 1, 4), -2))\n" "Decimal('3.14')\n" ">>> Decimal(str(2.0 ** 0.5))\n" "Decimal('1.4142135623730951')\n" ">>> Decimal(2) ** Decimal('0.5')\n" "Decimal('1.414213562373095048801688724')\n" ">>> Decimal('NaN')\n" "Decimal('NaN')\n" ">>> Decimal('-Infinity')\n" "Decimal('-Infinity')" msgstr "" #: ../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:167 msgid "" ">>> c = getcontext()\n" ">>> c.traps[FloatOperation] = True\n" ">>> Decimal(3.14)\n" "Traceback (most recent call last):\n" " File \"\", line 1, in \n" "decimal.FloatOperation: []\n" ">>> Decimal('3.5') < 3.7\n" "Traceback (most recent call last):\n" " File \"\", line 1, in \n" "decimal.FloatOperation: []\n" ">>> Decimal('3.5') == 3.5\n" "True" msgstr "" #: ../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:186 msgid "" ">>> getcontext().prec = 6\n" ">>> Decimal('3.0')\n" "Decimal('3.0')\n" ">>> Decimal('3.1415926535')\n" "Decimal('3.1415926535')\n" ">>> Decimal('3.1415926535') + Decimal('2.7182818285')\n" "Decimal('5.85987')\n" ">>> getcontext().rounding = ROUND_UP\n" ">>> Decimal('3.1415926535') + Decimal('2.7182818285')\n" "Decimal('5.85988')" msgstr "" #: ../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:202 msgid "" ">>> Decimal(\"1e9999999999999999999\")\n" "Traceback (most recent call last):\n" " File \"\", line 1, in \n" "decimal.InvalidOperation: []" msgstr "" #: ../Doc/library/decimal.rst:209 #, fuzzy 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:212 msgid "" ">>> data = list(map(Decimal, '1.34 1.87 3.45 2.35 1.00 0.03 9.25'.split()))\n" ">>> max(data)\n" "Decimal('9.25')\n" ">>> min(data)\n" "Decimal('0.03')\n" ">>> sorted(data)\n" "[Decimal('0.03'), Decimal('1.00'), Decimal('1.34'), Decimal('1.87'),\n" " Decimal('2.35'), Decimal('3.45'), Decimal('9.25')]\n" ">>> sum(data)\n" "Decimal('19.29')\n" ">>> a,b,c = data[:3]\n" ">>> str(a)\n" "'1.34'\n" ">>> float(a)\n" "1.34\n" ">>> round(a, 1)\n" "Decimal('1.3')\n" ">>> int(a)\n" "1\n" ">>> a * 5\n" "Decimal('6.70')\n" ">>> a * b\n" "Decimal('2.5058')\n" ">>> c % a\n" "Decimal('0.77')" msgstr "" #: ../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:`~Decimal.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:`~Decimal.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:275 msgid "" ">>> myothercontext = Context(prec=60, rounding=ROUND_HALF_DOWN)\n" ">>> setcontext(myothercontext)\n" ">>> Decimal(1) / Decimal(7)\n" "Decimal('0.142857142857142857142857142857142857142857142857142857142857')\n" "\n" ">>> ExtendedContext\n" "Context(prec=9, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,\n" " capitals=1, clamp=0, flags=[], traps=[])\n" ">>> setcontext(ExtendedContext)\n" ">>> Decimal(1) / Decimal(7)\n" "Decimal('0.142857143')\n" ">>> Decimal(42) / Decimal(0)\n" "Decimal('Infinity')\n" "\n" ">>> setcontext(BasicContext)\n" ">>> Decimal(42) / Decimal(0)\n" "Traceback (most recent call last):\n" " File \"\", line 1, in -toplevel-\n" " Decimal(42) / Decimal(0)\n" "DivisionByZero: x / 0" msgstr "" #: ../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:`~Context.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:" "`~Context.clear_flags` antes de proceder con cada conjunto de cálculos " "monitorizados. ::" #: ../Doc/library/decimal.rst:304 msgid "" ">>> setcontext(ExtendedContext)\n" ">>> getcontext().clear_flags()\n" ">>> Decimal(355) / Decimal(113)\n" "Decimal('3.14159292')\n" ">>> getcontext()\n" "Context(prec=9, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,\n" " capitals=1, clamp=0, flags=[Inexact, Rounded], traps=[])" msgstr "" #: ../Doc/library/decimal.rst:312 msgid "" "The *flags* entry shows that the rational approximation to 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 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:`~Context.traps` " "attribute of a context:" msgstr "" "Las trampas de señales se habilitan a través del diccionario expuesto por el " "atributo :attr:`~Context.traps` del objeto Context:" #: ../Doc/library/decimal.rst:319 msgid "" ">>> setcontext(ExtendedContext)\n" ">>> Decimal(1) / Decimal(0)\n" "Decimal('Infinity')\n" ">>> getcontext().traps[DivisionByZero] = 1\n" ">>> Decimal(1) / Decimal(0)\n" "Traceback (most recent call last):\n" " File \"\", line 1, in -toplevel-\n" " Decimal(1) / Decimal(0)\n" "DivisionByZero: x / 0" msgstr "" #: ../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:355 msgid "" "sign ::= '+' | '-'\n" "digit ::= '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | " "'9'\n" "indicator ::= 'e' | 'E'\n" "digits ::= digit [digit]...\n" "decimal-part ::= digits '.' [digits] | ['.'] digits\n" "exponent-part ::= indicator [sign] digits\n" "infinity ::= 'Infinity' | 'Inf'\n" "nan ::= 'NaN' [digits] | 'sNaN' [digits]\n" "numeric-value ::= decimal-part [exponent-part] | infinity\n" "numeric-string ::= [sign] numeric-value | [sign] nan" msgstr "" #: ../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 " "(``0`` for positive or ``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 (``0`` para positivo o ``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 #, fuzzy 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 ``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 ``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 #, fuzzy 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:418 msgid "" ">>> (-7) % 4\n" "1\n" ">>> Decimal(-7) % Decimal(4)\n" "Decimal('-3')" msgstr "" #: ../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:427 msgid "" ">>> -7 // 4\n" "-2\n" ">>> Decimal(-7) // Decimal(4)\n" "Decimal('-1')" msgstr "" #: ../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 #, fuzzy 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:465 msgid "" ">>> Decimal('-3.14').as_integer_ratio()\n" "(-157, 50)" msgstr "" #: ../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:491 msgid "" "a or b is a NaN ==> Decimal('NaN')\n" "a < b ==> Decimal('-1')\n" "a == b ==> Decimal('0')\n" "a > b ==> Decimal('1')" msgstr "" #: ../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:846 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 "" "Constructor alternativo que acepta únicamente instancias de :class:`float` " "o :class:`int`." #: ../Doc/library/decimal.rst:579 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 "" "Fíjate 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:588 msgid "" ">>> Decimal.from_float(0.1)\n" "Decimal('0.1000000000000000055511151231257827021181583404541015625')\n" ">>> Decimal.from_float(float('nan'))\n" "Decimal('NaN')\n" ">>> Decimal.from_float(float('inf'))\n" "Decimal('Infinity')\n" ">>> Decimal.from_float(float('-inf'))\n" "Decimal('-Infinity')" msgstr "" #: ../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 ``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 ``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 ``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 ``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 " "numéricamente iguales, retorna una copia del primer operando con el signo " "establecido para que sea el mismo que el signo del segundo operando." #: ../Doc/library/decimal.rst:746 msgid "" "Used for producing canonical values of an equivalence class within either " "the current context or the specified context." msgstr "" "Usado para producir valores canónicos de una clase de equivalencia dentro " "del contexto actual o del contexto especificado." #: ../Doc/library/decimal.rst:749 msgid "" "This has the same semantics as the unary plus operation, except that if the " "final result is finite it is reduced to its simplest form, with all trailing " "zeros removed and its sign preserved. That is, while the coefficient is non-" "zero and a multiple of ten the coefficient is divided by ten and the " "exponent is incremented by 1. Otherwise (the coefficient is zero) the " "exponent is set to 0. In all cases the sign is unchanged." msgstr "" "Este tiene la misma semántica que el operador unario ``+``, excepto que si " "el resultado final es finito, entonces se reduce a su forma más simple, " "eliminando todos los ceros finales y preservando el signo. Es decir, que " "mientras que el coeficiente sea distinto de cero y múltiplo de 10, el " "coeficiente se divide por 10 y el exponente se incremente por 1. En otro " "caso (el coeficiente es cero), el exponente se establece en 0. En todos los " "casos el signo no se modifica." #: ../Doc/library/decimal.rst:756 msgid "" "For example, ``Decimal('32.100')`` and ``Decimal('0.321000e+2')`` both " "normalize to the equivalent value ``Decimal('32.1')``." msgstr "" "Por ejemplo, ``Decimal('32.100')`` y ``Decimal('0.321000e+2')`` ambos se " "normalizan al valor equivalente ``Decimal('32.1')``." #: ../Doc/library/decimal.rst:759 msgid "Note that rounding is applied *before* reducing to simplest form." msgstr "" "Fíjate que el redondeo se aplica *antes* de reducir a la forma más simple." #: ../Doc/library/decimal.rst:761 msgid "" "In the latest versions of the specification, this operation is also known as " "``reduce``." msgstr "" "En las últimas versiones de la especificación, esta operación también era " "conocida como ``reduce``." #: ../Doc/library/decimal.rst:766 msgid "" "Return a string describing the *class* of the operand. The returned value " "is one of the following ten strings." msgstr "" "Retorna una cadena de caracteres que describe la *class* del operando. El " "valor retornado es una de las siguientes diez cadenas de caracteres." #: ../Doc/library/decimal.rst:769 msgid "``\"-Infinity\"``, indicating that the operand is negative infinity." msgstr "``\"-Infinity\"``, que indica que el operando es un infinito negativo." #: ../Doc/library/decimal.rst:770 msgid "" "``\"-Normal\"``, indicating that the operand is a negative normal number." msgstr "" "``\"-Normal\"``, que indica que el operando es un número normal negativo." #: ../Doc/library/decimal.rst:771 msgid "" "``\"-Subnormal\"``, indicating that the operand is negative and subnormal." msgstr "" "``\"-Subnormal\"``, que indica que el operando es negativo y subnormal." #: ../Doc/library/decimal.rst:772 msgid "``\"-Zero\"``, indicating that the operand is a negative zero." msgstr "``\"-Zero\"``, que indica que el operando es un cero negativo." #: ../Doc/library/decimal.rst:773 msgid "``\"+Zero\"``, indicating that the operand is a positive zero." msgstr "``\"+Zero\"``, que indica que el operando es un cero positivo." #: ../Doc/library/decimal.rst:774 msgid "" "``\"+Subnormal\"``, indicating that the operand is positive and subnormal." msgstr "``\"+Subnormal\"``,que indica que el operando es positivo y subnormal." #: ../Doc/library/decimal.rst:775 msgid "" "``\"+Normal\"``, indicating that the operand is a positive normal number." msgstr "" "``\"+Normal\"``, que indica que el operando es un número normal positivo." #: ../Doc/library/decimal.rst:776 msgid "``\"+Infinity\"``, indicating that the operand is positive infinity." msgstr "``\"+Infinity\"``, que indica que el operando es un infinito positivo." #: ../Doc/library/decimal.rst:777 msgid "``\"NaN\"``, indicating that the operand is a quiet NaN (Not a Number)." msgstr "" "``\"NaN\"``, que indica que el operando es un NaN (no es un número) " "silencioso." #: ../Doc/library/decimal.rst:778 msgid "``\"sNaN\"``, indicating that the operand is a signaling NaN." msgstr "" "``\"sNaN\"``, que indica que el operando es un NaN (no es un número) " "señalizador." #: ../Doc/library/decimal.rst:782 msgid "" "Return a value equal to the first operand after rounding and having the " "exponent of the second operand." msgstr "" "Retorna un valor igual al primer operando después de ser redondeado y de " "asignarle el exponente del segundo operando." #: ../Doc/library/decimal.rst:788 msgid "" "Unlike other operations, if the length of the coefficient after the quantize " "operation would be greater than precision, then an :const:`InvalidOperation` " "is signaled. This guarantees that, unless there is an error condition, the " "quantized exponent is always equal to that of the right-hand operand." msgstr "" "A diferencia de otras operaciones, se genera una señal :const:" "`InvalidOperation` si la longitud del coeficiente después de la operación " "quantize es mayor que la precisión. Esto garantiza que, a menos que exista " "una condición de error, el exponente cuantificado sea siempre igual al del " "operando de la derecha." #: ../Doc/library/decimal.rst:794 msgid "" "Also unlike other operations, quantize never signals Underflow, even if the " "result is subnormal and inexact." msgstr "" "Además, a diferencia de otras operaciones, quantize nunca genera una señal " "Underflow, incluso si el resultado es subnormal e inexacto." #: ../Doc/library/decimal.rst:797 msgid "" "If the exponent of the second operand is larger than that of the first then " "rounding may be necessary. In this case, the rounding mode is determined by " "the ``rounding`` argument if given, else by the given ``context`` argument; " "if neither argument is given the rounding mode of the current thread's " "context is used." msgstr "" "Si el exponente del segundo operando es mayor que el del primero, puede ser " "necesario redondear. En este caso, el modo de redondeo está determinado por " "el argumento ``rounding``, si se proporciona, o por el argumento ``context`` " "en caso contrario. Si no se proporciona ninguno de estos dos argumentos, se " "utiliza el modo de redondeo establecido en el contexto del hilo actual." #: ../Doc/library/decimal.rst:803 msgid "" "An error is returned whenever the resulting exponent is greater than :attr:" "`~Context.Emax` or less than :meth:`~Context.Etiny`." msgstr "" "Se retorna un error siempre que el exponente resultante sea mayor que :attr:" "`~Context.Emax` o menor que :meth:`~Context.Etiny`." #: ../Doc/library/decimal.rst:808 msgid "" "Return ``Decimal(10)``, the radix (base) in which the :class:`Decimal` class " "does all its arithmetic. Included for compatibility with the specification." msgstr "" "Retorna ``Decimal(10)``, que es la raíz (base) en la que la clase :class:" "`Decimal` hace toda su aritmética. Este método está incluido solo por " "compatibilidad con la especificación." #: ../Doc/library/decimal.rst:814 #, python-format msgid "" "Return the remainder from dividing *self* by *other*. This differs from " "``self % other`` in that the sign of the remainder is chosen so as to " "minimize its absolute value. More precisely, the return value is ``self - n " "* other`` where ``n`` is the integer nearest to the exact value of ``self / " "other``, and if two integers are equally near then the even one is chosen." msgstr "" "Retorna el resto de dividir *self* entre *other*. Esto difiere de la " "operación ``self % other``, en la que el signo del resto se elige para " "minimizar su valor absoluto. Más precisamente, el valor de retorno es ``self " "- n * other``, donde ``n`` es el número entero más cercano al valor exacto " "de ``self / other``. Si dos enteros están igualmente cerca, entonces el " "valor par es el elegido." #: ../Doc/library/decimal.rst:821 msgid "If the result is zero then its sign will be the sign of *self*." msgstr "Si el resultado es cero, entonces su signo será el signo de *self*." #: ../Doc/library/decimal.rst:832 msgid "" "Return the result of rotating the digits of the first operand by an amount " "specified by the second operand. The second operand must be an integer in " "the range -precision through precision. The absolute value of the second " "operand gives the number of places to rotate. If the second operand is " "positive then rotation is to the left; otherwise rotation is to the right. " "The coefficient of the first operand is padded on the left with zeros to " "length precision if necessary. The sign and exponent of the first operand " "are unchanged." msgstr "" "Retorna el resultado de rotar los dígitos del primer operando en una " "cantidad especificada por el segundo operando. El segundo operando debe ser " "un número entero en el rango comprendido desde -precisión hasta precisión. " "El valor absoluto del segundo operando da el número de lugares a rotar. Si " "el segundo operando es positivo, la rotación es hacia la izquierda; de lo " "contrario, la rotación es hacia la derecha. El coeficiente del primer " "operando se rellena con ceros a la izquierda para satisfacer la precisión de " "longitud si es necesario. El signo y el exponente del primer operando no se " "modifican." #: ../Doc/library/decimal.rst:843 msgid "" "Test whether self and other have the same exponent or whether both are " "``NaN``." msgstr "" "Comprueba si self y other tienen el mismo exponente o si ambos son ``NaN``." #: ../Doc/library/decimal.rst:852 msgid "" "Return the first operand with exponent adjusted by the second. Equivalently, " "return the first operand multiplied by ``10**other``. The second operand " "must be an integer." msgstr "" "Retorna el primer operando con su exponente ajustado por el segundo. De " "manera equivalente, retorna el primer operando multiplicado por " "``10**other``. El segundo operando debe ser un número entero." #: ../Doc/library/decimal.rst:858 msgid "" "Return the result of shifting the digits of the first operand by an amount " "specified by the second operand. The second operand must be an integer in " "the range -precision through precision. The absolute value of the second " "operand gives the number of places to shift. If the second operand is " "positive then the shift is to the left; otherwise the shift is to the " "right. Digits shifted into the coefficient are zeros. The sign and " "exponent of the first operand are unchanged." msgstr "" "Retorna el resultado de cambiar los dígitos del primer operando en una " "cantidad especificada por el segundo operando. El segundo operando debe ser " "un número entero en el rango comprendido desde -precisión hasta precisión. " "El valor absoluto del segundo operando da el número de lugares a desplazar. " "Si el segundo operando es positivo, el desplazamiento es hacia la izquierda; " "de lo contrario, el desplazamiento es hacia la derecha. Los dígitos " "desplazados en el coeficiente son ceros. El signo y el exponente del primer " "operando no se modifican." #: ../Doc/library/decimal.rst:868 msgid "Return the square root of the argument to full precision." msgstr "Retorna la raíz cuadrada del argumento con precisión total." #: ../Doc/library/decimal.rst:873 ../Doc/library/decimal.rst:1510 msgid "" "Convert to a string, using engineering notation if an exponent is needed." msgstr "" "Convierte a una cadena de caracteres, usando notación de ingeniería si se " "necesita un exponente." #: ../Doc/library/decimal.rst:875 ../Doc/library/decimal.rst:1512 msgid "" "Engineering notation has an exponent which is a multiple of 3. This can " "leave up to 3 digits to the left of the decimal place and may require the " "addition of either one or two trailing zeros." msgstr "" "La notación de ingeniería tiene como exponente un múltiplo de 3. Esto puede " "dejar hasta 3 dígitos a la izquierda del punto decimal y puede requerir la " "adición de uno o dos ceros finales." #: ../Doc/library/decimal.rst:879 msgid "" "For example, this converts ``Decimal('123E+1')`` to ``Decimal('1.23E+3')``." msgstr "" "Por ejemplo, este método convierte ``Decimal('123E+1')`` en " "``Decimal('1.23E+3')``." #: ../Doc/library/decimal.rst:883 msgid "" "Identical to the :meth:`to_integral_value` method. The ``to_integral`` name " "has been kept for compatibility with older versions." msgstr "" "Idéntico al método :meth:`to_integral_value`. El nombre ``to_integral`` se " "ha mantenido por compatibilidad con versiones anteriores." #: ../Doc/library/decimal.rst:888 msgid "" "Round to the nearest integer, signaling :const:`Inexact` or :const:`Rounded` " "as appropriate if rounding occurs. The rounding mode is determined by the " "``rounding`` parameter if given, else by the given ``context``. If neither " "parameter is given then the rounding mode of the current context is used." msgstr "" "Redondea al entero más cercano, generando la señal :const:`Inexact` o :const:" "`Rounded`, según corresponda, si se produce un redondeo. El modo de redondeo " "está determinado por el parámetro ``rounding`` si es proporcionado, o por el " "establecido en el ``context`` proporcionado en caso contrario. Si no se " "proporciona ninguno de estos dos parámetros, se utiliza el modo de redondeo " "establecido en el contexto actual." #: ../Doc/library/decimal.rst:896 msgid "" "Round to the nearest integer without signaling :const:`Inexact` or :const:" "`Rounded`. If given, applies *rounding*; otherwise, uses the rounding " "method in either the supplied *context* or the current context." msgstr "" "Redondea al entero más cercano sin generar la señal :const:`Inexact` o :" "const:`Rounded`. Si se proporciona, se aplica el método de redondeo " "especificado por *rounding*; en caso contrario, se utiliza el método de " "redondeo del *context* proporcionado o el del contexto actual." #: ../Doc/library/decimal.rst:900 msgid "Decimal numbers can be rounded using the :func:`.round` function:" msgstr "" #: ../Doc/library/decimal.rst:905 msgid "" "If *ndigits* is not given or ``None``, returns the nearest :class:`int` to " "*number*, rounding ties to even, and ignoring the rounding mode of the :" "class:`Decimal` context. Raises :exc:`OverflowError` if *number* is an " "infinity or :exc:`ValueError` if it is a (quiet or signaling) NaN." msgstr "" #: ../Doc/library/decimal.rst:911 msgid "" "If *ndigits* is an :class:`int`, the context's rounding mode is respected " "and a :class:`Decimal` representing *number* rounded to the nearest multiple " "of ``Decimal('1E-ndigits')`` is returned; in this case, ``round(number, " "ndigits)`` is equivalent to ``self.quantize(Decimal('1E-ndigits'))``. " "Returns ``Decimal('NaN')`` if *number* is a quiet NaN. Raises :class:" "`InvalidOperation` if *number* is an infinity, a signaling NaN, or if the " "length of the coefficient after the quantize operation would be greater than " "the current context's precision. In other words, for the non-corner cases:" msgstr "" #: ../Doc/library/decimal.rst:921 msgid "" "if *ndigits* is positive, return *number* rounded to *ndigits* decimal " "places;" msgstr "" #: ../Doc/library/decimal.rst:923 msgid "if *ndigits* is zero, return *number* rounded to the nearest integer;" msgstr "" #: ../Doc/library/decimal.rst:924 msgid "" "if *ndigits* is negative, return *number* rounded to the nearest multiple of " "``10**abs(ndigits)``." msgstr "" #: ../Doc/library/decimal.rst:927 msgid "For example::" msgstr "" #: ../Doc/library/decimal.rst:929 msgid "" ">>> from decimal import Decimal, getcontext, ROUND_DOWN\n" ">>> getcontext().rounding = ROUND_DOWN\n" ">>> round(Decimal('3.75')) # context rounding ignored\n" "4\n" ">>> round(Decimal('3.5')) # round-ties-to-even\n" "4\n" ">>> round(Decimal('3.75'), 0) # uses the context rounding\n" "Decimal('3')\n" ">>> round(Decimal('3.75'), 1)\n" "Decimal('3.7')\n" ">>> round(Decimal('3.75'), -1)\n" "Decimal('0E+1')" msgstr "" #: ../Doc/library/decimal.rst:946 msgid "Logical operands" msgstr "Operandos lógicos" #: ../Doc/library/decimal.rst:948 msgid "" "The :meth:`~Decimal.logical_and`, :meth:`~Decimal.logical_invert`, :meth:" "`~Decimal.logical_or`, and :meth:`~Decimal.logical_xor` methods expect their " "arguments to be *logical operands*. A *logical operand* is a :class:" "`Decimal` instance whose exponent and sign are both zero, and whose digits " "are all either ``0`` or ``1``." msgstr "" "Los métodos :meth:`~Decimal.logical_and`, :meth:`~Decimal.logical_invert`, :" "meth:`~Decimal.logical_or`, y :meth:`~Decimal.logical_xor` esperan que sus " "argumentos sean *operandos lógicos*. Un *operando lógico* es una instancia " "de :class:`Decimal` cuyo exponente y signo son ambos cero, y cuyos dígitos " "son todos ``0`` o ``1``." #: ../Doc/library/decimal.rst:960 msgid "Context objects" msgstr "Objetos context" #: ../Doc/library/decimal.rst:962 msgid "" "Contexts are environments for arithmetic operations. They govern precision, " "set rules for rounding, determine which signals are treated as exceptions, " "and limit the range for exponents." msgstr "" "Los contextos son entornos para operaciones aritméticas. Gobiernan la " "precisión, establecen reglas para el redondeo, determinan qué señales se " "tratan como excepciones y limitan el rango para los exponentes." #: ../Doc/library/decimal.rst:966 msgid "" "Each thread has its own current context which is accessed or changed using " "the :func:`getcontext` and :func:`setcontext` functions:" msgstr "" "Cada hilo tiene su propio contexto actual, al que se accede o se reemplaza " "usando las funciones :func:`getcontext` y :func:`setcontext` respectivamente:" #: ../Doc/library/decimal.rst:972 msgid "Return the current context for the active thread." msgstr "Retorna el contexto actual del hilo activo." #: ../Doc/library/decimal.rst:977 msgid "Set the current context for the active thread to *c*." msgstr "Establece *c* como contexto actual para el hilo activo." #: ../Doc/library/decimal.rst:979 msgid "" "You can also use the :keyword:`with` statement and the :func:`localcontext` " "function to temporarily change the active context." msgstr "" "También puedes usar la declaración :keyword:`with` y la función :func:" "`localcontext` para cambiar temporalmente el contexto activo." #: ../Doc/library/decimal.rst:984 msgid "" "Return a context manager that will set the current context for the active " "thread to a copy of *ctx* on entry to the with-statement and restore the " "previous context when exiting the with-statement. If no context is " "specified, a copy of the current context is used. The *kwargs* argument is " "used to set the attributes of the new context." msgstr "" "Retorna un gestor de contexto que establecerá el contexto actual para el " "hilo activo en una copia de *ctx* al ingresar en la sentencia with y " "restaurará el contexto anterior al salir de la misma. Si no se especifica " "ningún contexto, se utiliza una copia del contexto actual. El argumento " "*kwargs* se usa para establecer los atributos del nuevo contexto." #: ../Doc/library/decimal.rst:990 msgid "" "For example, the following code sets the current decimal precision to 42 " "places, performs a calculation, and then automatically restores the previous " "context::" msgstr "" "Por ejemplo, el siguiente código establece la precisión decimal actual en 42 " "lugares, realiza un cálculo y luego restaura automáticamente el contexto " "anterior::" #: ../Doc/library/decimal.rst:993 msgid "" "from decimal import localcontext\n" "\n" "with localcontext() as ctx:\n" " ctx.prec = 42 # Perform a high precision calculation\n" " s = calculate_something()\n" "s = +s # Round the final result back to the default precision" msgstr "" #: ../Doc/library/decimal.rst:1000 msgid "Using keyword arguments, the code would be the following::" msgstr "Usando argumentos de palabra clave, el código sería el siguiente::" #: ../Doc/library/decimal.rst:1002 msgid "" "from decimal import localcontext\n" "\n" "with localcontext(prec=42) as ctx:\n" " s = calculate_something()\n" "s = +s" msgstr "" #: ../Doc/library/decimal.rst:1008 msgid "" "Raises :exc:`TypeError` if *kwargs* supplies an attribute that :class:" "`Context` doesn't support. Raises either :exc:`TypeError` or :exc:" "`ValueError` if *kwargs* supplies an invalid value for an attribute." msgstr "" "Lanza :exc:`TypeError` si *kwargs* proporciona un atributo que :class:" "`Context` no soporta. Lanza también :exc:`TypeError` o :exc:`ValueError` si " "*kwargs* proporciona un valor no válido para un atributo." #: ../Doc/library/decimal.rst:1012 msgid "" ":meth:`localcontext` now supports setting context attributes through the use " "of keyword arguments." msgstr "" ":meth:`localcontext` ahora admite la configuración de atributos de contexto " "mediante el uso de argumentos de palabra clave." #: ../Doc/library/decimal.rst:1015 msgid "" "New contexts can also be created using the :class:`Context` constructor " "described below. In addition, the module provides three pre-made contexts:" msgstr "" "También se pueden crear nuevos contextos utilizando el constructor de la " "clase :class:`Context` que se describe a continuación. Además, el módulo " "proporciona tres contextos prediseñados:" #: ../Doc/library/decimal.rst:1021 msgid "" "This is a standard context defined by the General Decimal Arithmetic " "Specification. Precision is set to nine. Rounding is set to :const:" "`ROUND_HALF_UP`. All flags are cleared. All traps are enabled (treated as " "exceptions) except :const:`Inexact`, :const:`Rounded`, and :const:" "`Subnormal`." msgstr "" "Este es un contexto estándar definido por la Especificación general de la " "aritmética decimal. La precisión se establece en nueve. El redondeo se " "establece en :const:`ROUND_HALF_UP`. Se restablecen todos los flags. Todas " "las trampas están habilitadas (las señales son tratadas como excepciones) " "excepto :const:`Inexact`, :const:`Rounded` y :const:`Subnormal`." #: ../Doc/library/decimal.rst:1027 msgid "" "Because many of the traps are enabled, this context is useful for debugging." msgstr "" "Debido a que la mayoría de las trampas están habilitadas, este contexto es " "especialmente útil para la depuración." #: ../Doc/library/decimal.rst:1032 msgid "" "This is a standard context defined by the General Decimal Arithmetic " "Specification. Precision is set to nine. Rounding is set to :const:" "`ROUND_HALF_EVEN`. All flags are cleared. No traps are enabled (so that " "exceptions are not raised during computations)." msgstr "" "Este es un contexto estándar definido por la Especificación general de la " "aritmética decimal. La precisión se establece en nueve. El redondeo se " "establece en :const:`ROUND_HALF_EVEN`. Se restablecen todos los flags. No se " "habilitan trampas (para que no se generen excepciones durante los cálculos)." #: ../Doc/library/decimal.rst:1037 msgid "" "Because the traps are disabled, this context is useful for applications that " "prefer to have result value of ``NaN`` or ``Infinity`` instead of raising " "exceptions. This allows an application to complete a run in the presence of " "conditions that would otherwise halt the program." msgstr "" "Debido a que las trampas están deshabilitadas, este contexto es útil para " "aplicaciones que prefieren tener un valor ``NaN`` o ``Infinity`` como " "resultado en lugar de lanzar excepciones. Esto permite que una aplicación " "complete una ejecución en presencia de condiciones que, de otra manera, " "detendrían el programa." #: ../Doc/library/decimal.rst:1045 msgid "" "This context is used by the :class:`Context` constructor as a prototype for " "new contexts. Changing a field (such a precision) has the effect of " "changing the default for new contexts created by the :class:`Context` " "constructor." msgstr "" "Este contexto es utilizado por el constructor de la clase :class:`Context` " "como un prototipo para nuevos contextos. Cambiar un campo (como la " "precisión) tiene el efecto de cambiar el valor predeterminado para los " "nuevos contextos creados por el constructor de :class:`Context`." #: ../Doc/library/decimal.rst:1049 msgid "" "This context is most useful in multi-threaded environments. Changing one of " "the fields before threads are started has the effect of setting system-wide " "defaults. Changing the fields after threads have started is not recommended " "as it would require thread synchronization to prevent race conditions." msgstr "" "Este contexto es más útil en entornos con múltiples hilos. Cambiar uno de " "los campos antes de que se inicien los hilos tiene el efecto de establecer " "valores predeterminados en todo el sistema. No se recomienda cambiar los " "campos después de que se hayan iniciado los hilos, ya que requeriría el uso " "de mecanismos de sincronización para evitar condiciones de carrera entre los " "hilos." #: ../Doc/library/decimal.rst:1054 msgid "" "In single threaded environments, it is preferable to not use this context at " "all. Instead, simply create contexts explicitly as described below." msgstr "" "En entornos de un solo hilo, es preferible no utilizar este contexto en " "absoluto. En su lugar, simplemente crea contextos explícitamente como se " "describe a continuación." #: ../Doc/library/decimal.rst:1057 msgid "" "The default values are :attr:`Context.prec`\\ =\\ ``28``, :attr:`Context." "rounding`\\ =\\ :const:`ROUND_HALF_EVEN`, and enabled traps for :class:" "`Overflow`, :class:`InvalidOperation`, and :class:`DivisionByZero`." msgstr "" "Los valores predeterminados son :attr:`Context.prec`\\ =\\ ``28``, :attr:" "`Context.rounding`\\ =\\ :const:`ROUND_HALF_EVEN`, y trampas habilitadas " "para :class:`Overflow`, :class:`InvalidOperation`, y :class:`DivisionByZero`." #: ../Doc/library/decimal.rst:1062 msgid "" "In addition to the three supplied contexts, new contexts can be created with " "the :class:`Context` constructor." msgstr "" "Además de los tres contextos proporcionados, se pueden crear nuevos " "contextos mediante el constructor de la clase :class:`Context`." #: ../Doc/library/decimal.rst:1068 msgid "" "Creates a new context. If a field is not specified or is :const:`None`, the " "default values are copied from the :const:`DefaultContext`. If the *flags* " "field is not specified or is :const:`None`, all flags are cleared." msgstr "" "Crea un nuevo contexto. Si no se especifica un campo, o es :const:`None`, " "los valores predeterminados se copian de :const:`DefaultContext`. Si el " "campo *flags* no está especificado, o es :const:`None`, se restablecen todas " "los flags." #: ../Doc/library/decimal.rst:1072 msgid "" "*prec* is an integer in the range [``1``, :const:`MAX_PREC`] that sets the " "precision for arithmetic operations in the context." msgstr "" "*prec* es un número entero en el rango [``1``, :const:`MAX_PREC`] que " "establece la precisión para las operaciones aritméticas en el contexto." #: ../Doc/library/decimal.rst:1075 msgid "" "The *rounding* option is one of the constants listed in the section " "`Rounding Modes`_." msgstr "" "La opción *rounding* es una de las constantes enumeradas en la sección " "`Rounding Modes`_." #: ../Doc/library/decimal.rst:1078 msgid "" "The *traps* and *flags* fields list any signals to be set. Generally, new " "contexts should only set traps and leave the flags clear." msgstr "" "Los campos *traps* y *flags* enumeran las señales que se deben establecer. " "Generalmente, los nuevos contextos solo deben establecer trampas y dejar los " "flags sin establecer." #: ../Doc/library/decimal.rst:1081 msgid "" "The *Emin* and *Emax* fields are integers specifying the outer limits " "allowable for exponents. *Emin* must be in the range [:const:`MIN_EMIN`, " "``0``], *Emax* in the range [``0``, :const:`MAX_EMAX`]." msgstr "" "Los campos *Emin* y *Emax* son números enteros que especifican los límites " "externos permitidos para los exponentes. *Emin* debe estar en el rango [:" "const:`MIN_EMIN`, ``0``] y *Emax* en el rango [``0``, :const:`MAX_EMAX`]." #: ../Doc/library/decimal.rst:1085 msgid "" "The *capitals* field is either ``0`` or ``1`` (the default). If set to " "``1``, exponents are printed with a capital ``E``; otherwise, a lowercase " "``e`` is used: ``Decimal('6.02e+23')``." msgstr "" "El campo *capitals* es ``0`` o ``1`` (por defecto). Si se establece en " "``1``, los exponentes se imprimen usando una ``E`` mayúscula; de lo " "contrario, se usa una ``e`` minúscula: ``Decimal('6.02e+23')``." #: ../Doc/library/decimal.rst:1089 msgid "" "The *clamp* field is either ``0`` (the default) or ``1``. If set to ``1``, " "the exponent ``e`` of a :class:`Decimal` instance representable in this " "context is strictly limited to the range ``Emin - prec + 1 <= e <= Emax - " "prec + 1``. If *clamp* is ``0`` then a weaker condition holds: the adjusted " "exponent of the :class:`Decimal` instance is at most :attr:`~Context.Emax`. " "When *clamp* is ``1``, a large normal number will, where possible, have its " "exponent reduced and a corresponding number of zeros added to its " "coefficient, in order to fit the exponent constraints; this preserves the " "value of the number but loses information about significant trailing zeros. " "For example::" msgstr "" "El campo *clamp* es ``0`` (por defecto) o ``1``. Si se establece en ``1``, " "el exponente ``e`` representable en este contexto de una instancia de :class:" "`Decimal` está estrictamente limitado al rango ``Emin - prec + 1 <= e <= " "Emax - prec + 1``. Si *clamp* es ``0``, entonces se cumple una condición más " "laxa: el exponente ajustado de la instancia de :class:`Decimal` es como " "máximo :attr:`~Context.Emax`. Cuando *clamp* es ``1``, cuando sea posible, " "se reducirá el exponente de un número normal grande y se agregarán el número " "correspondiente de ceros a su coeficiente, a fin de que se ajuste a las " "restricciones del exponente; esto conserva el valor del número pero conlleva " "una pérdida de información causada por los ceros finales significativos. Por " "ejemplo::" #: ../Doc/library/decimal.rst:1101 msgid "" ">>> Context(prec=6, Emax=999, clamp=1).create_decimal('1.23e999')\n" "Decimal('1.23000E+999')" msgstr "" #: ../Doc/library/decimal.rst:1104 msgid "" "A *clamp* value of ``1`` allows compatibility with the fixed-width decimal " "interchange formats specified in IEEE 754." msgstr "" "Un valor *clamp* de ``1`` permite la compatibilidad con los formatos de " "intercambio decimal de ancho fijo especificados en IEEE 754." #: ../Doc/library/decimal.rst:1107 msgid "" "The :class:`Context` class defines several general purpose methods as well " "as a large number of methods for doing arithmetic directly in a given " "context. In addition, for each of the :class:`Decimal` methods described " "above (with the exception of the :meth:`~Decimal.adjusted` and :meth:" "`~Decimal.as_tuple` methods) there is a corresponding :class:`Context` " "method. For example, for a :class:`Context` instance ``C`` and :class:" "`Decimal` instance ``x``, ``C.exp(x)`` is equivalent to ``x." "exp(context=C)``. Each :class:`Context` method accepts a Python integer (an " "instance of :class:`int`) anywhere that a Decimal instance is accepted." msgstr "" "La clase :class:`Context` define varios métodos de propósito general, así " "como una gran cantidad de métodos para hacer aritmética directamente en un " "contexto dado. Además, para cada uno de los métodos de la clase :class:" "`Decimal` descritos anteriormente (con la excepción de los métodos :meth:" "`~Decimal.adjusted` y :meth:`~Decimal.as_tuple`) hay un método " "correspondiente en la clase :class:`Context`. Por ejemplo, para una " "instancia de :class:`Context` ``C`` y una instancia de :class:`Decimal` " "``x``, ``C.exp(x)`` es equivalente a ``x.exp(context=C)``. Cada método :" "class:`Context` acepta también un entero de Python (una instancia de :class:" "`int`) en cualquier lugar donde se acepte una instancia de Decimal." #: ../Doc/library/decimal.rst:1120 msgid "Resets all of the flags to ``0``." msgstr "Restablece todos los flags a ``0``." #: ../Doc/library/decimal.rst:1124 msgid "Resets all of the traps to ``0``." msgstr "Restablece todas las trampas a ``0``." #: ../Doc/library/decimal.rst:1130 msgid "Return a duplicate of the context." msgstr "Retorna un duplicado del contexto." #: ../Doc/library/decimal.rst:1134 msgid "Return a copy of the Decimal instance num." msgstr "Retorna una copia de la instancia de Decimal num." #: ../Doc/library/decimal.rst:1138 msgid "" "Creates a new Decimal instance from *num* but using *self* as context. " "Unlike the :class:`Decimal` constructor, the context precision, rounding " "method, flags, and traps are applied to the conversion." msgstr "" "Crea una nueva instancia de Decimal a partir de *num* pero usando *self* " "como contexto. A diferencia del constructor de :class:`Decimal`, la " "precisión del contexto, el método de redondeo, los flags y las trampas se " "aplican a la conversión." #: ../Doc/library/decimal.rst:1142 msgid "" "This is useful because constants are often given to a greater precision than " "is needed by the application. Another benefit is that rounding immediately " "eliminates unintended effects from digits beyond the current precision. In " "the following example, using unrounded inputs means that adding zero to a " "sum can change the result:" msgstr "" "Esto es útil porque las constantes a menudo se proporcionan con una " "precisión mayor que la que necesita la aplicación. Otro beneficio es que el " "redondeo elimina inmediatamente los efectos no deseados de los dígitos más " "allá de la precisión actual. En el siguiente ejemplo, usar entradas no " "redondeadas significa que agregar cero a una suma puede cambiar el resultado:" #: ../Doc/library/decimal.rst:1148 msgid "" ">>> getcontext().prec = 3\n" ">>> Decimal('3.4445') + Decimal('1.0023')\n" "Decimal('4.45')\n" ">>> Decimal('3.4445') + Decimal(0) + Decimal('1.0023')\n" "Decimal('4.44')" msgstr "" #: ../Doc/library/decimal.rst:1156 msgid "" "This method implements the to-number operation of the IBM specification. If " "the argument is a string, no leading or trailing whitespace or underscores " "are permitted." msgstr "" "Este método implementa la operación to-number de la especificación de IBM. " "Si el argumento es una cadena de caracteres, no se permiten espacios en " "blanco ni guiones bajos, ni al principio ni al final." #: ../Doc/library/decimal.rst:1162 msgid "" "Creates a new Decimal instance from a float *f* but rounding using *self* as " "the context. Unlike the :meth:`Decimal.from_float` class method, the " "context precision, rounding method, flags, and traps are applied to the " "conversion." msgstr "" "Crea una nueva instancia de Decimal a partir de un flotante *f*, pero " "redondeando usando *self* como contexto. A diferencia del método de clase :" "meth:`Decimal.from_float`, la precisión del contexto, el método de redondeo, " "los flags y las trampas se aplican a la conversión." #: ../Doc/library/decimal.rst:1167 msgid "" ">>> context = Context(prec=5, rounding=ROUND_DOWN)\n" ">>> context.create_decimal_from_float(math.pi)\n" "Decimal('3.1415')\n" ">>> context = Context(prec=5, traps=[Inexact])\n" ">>> context.create_decimal_from_float(math.pi)\n" "Traceback (most recent call last):\n" " ...\n" "decimal.Inexact: None" msgstr "" #: ../Doc/library/decimal.rst:1182 msgid "" "Returns a value equal to ``Emin - prec + 1`` which is the minimum exponent " "value for subnormal results. When underflow occurs, the exponent is set to :" "const:`Etiny`." msgstr "" "Retorna un valor igual a ``Emin - prec + 1`` que es el valor mínimo del " "exponente para resultados subnormales. Cuando ocurre un desbordamiento " "numérico negativo (\"underflow\"), el exponente se establece en :const:" "`Etiny`." #: ../Doc/library/decimal.rst:1188 msgid "Returns a value equal to ``Emax - prec + 1``." msgstr "Retorna un valor igual a ``Emax - prec + 1``." #: ../Doc/library/decimal.rst:1190 msgid "" "The usual approach to working with decimals is to create :class:`Decimal` " "instances and then apply arithmetic operations which take place within the " "current context for the active thread. An alternative approach is to use " "context methods for calculating within a specific context. The methods are " "similar to those for the :class:`Decimal` class and are only briefly " "recounted here." msgstr "" "El enfoque habitual para trabajar con decimales es crear instancias de la " "clase :class:`Decimal` y luego aplicar operaciones aritméticas que tienen " "lugar dentro del contexto actual para el hilo activo. Un enfoque alternativo " "es utilizar métodos de contexto para calcular dentro de un contexto " "específico. Los métodos son similares a los de la clase :class:`Decimal` y " "aquí solo se relatan brevemente." #: ../Doc/library/decimal.rst:1200 msgid "Returns the absolute value of *x*." msgstr "Retorna el valor absoluto de *x*." #: ../Doc/library/decimal.rst:1205 msgid "Return the sum of *x* and *y*." msgstr "Retorna la suma de *x* e *y*." #: ../Doc/library/decimal.rst:1210 msgid "Returns the same Decimal object *x*." msgstr "Retorna el mismo objeto Decimal *x*." #: ../Doc/library/decimal.rst:1215 msgid "Compares *x* and *y* numerically." msgstr "Compara *x* e *y* numéricamente." #: ../Doc/library/decimal.rst:1220 msgid "Compares the values of the two operands numerically." msgstr "Compara los valores de los dos operandos numéricamente." #: ../Doc/library/decimal.rst:1225 msgid "Compares two operands using their abstract representation." msgstr "Compara los dos operandos utilizando su representación abstracta." #: ../Doc/library/decimal.rst:1230 msgid "" "Compares two operands using their abstract representation, ignoring sign." msgstr "" "Compara los dos operandos utilizando su representación abstracta, ignorando " "el signo." #: ../Doc/library/decimal.rst:1235 msgid "Returns a copy of *x* with the sign set to 0." msgstr "Retorna una copia de *x* con el signo establecido en 0." #: ../Doc/library/decimal.rst:1240 msgid "Returns a copy of *x* with the sign inverted." msgstr "Retorna una copia de *x* con el signo invertido." #: ../Doc/library/decimal.rst:1245 msgid "Copies the sign from *y* to *x*." msgstr "Copia el signo de *y* en *x*." #: ../Doc/library/decimal.rst:1250 msgid "Return *x* divided by *y*." msgstr "Retorna *x* dividido entre *y*." #: ../Doc/library/decimal.rst:1255 msgid "Return *x* divided by *y*, truncated to an integer." msgstr "" "Retorna *x* dividido entre *y*, truncando el resultado a un número entero." #: ../Doc/library/decimal.rst:1260 msgid "Divides two numbers and returns the integer part of the result." msgstr "Divide dos números y retorna la parte entera del resultado." #: ../Doc/library/decimal.rst:1265 msgid "Returns ``e ** x``." msgstr "Retorna ``e ** x``." #: ../Doc/library/decimal.rst:1270 msgid "Returns *x* multiplied by *y*, plus *z*." msgstr "Retorna *x* multiplicado por *y*, más *z*." #: ../Doc/library/decimal.rst:1275 msgid "Returns ``True`` if *x* is canonical; otherwise returns ``False``." msgstr "" "Retorna ``True`` si *x* está en forma canónica, en caso contrario retorna " "``False``." #: ../Doc/library/decimal.rst:1280 msgid "Returns ``True`` if *x* is finite; otherwise returns ``False``." msgstr "" "Retorna ``True`` si *x* es un valor finito, en caso contrario retorna " "``False``." #: ../Doc/library/decimal.rst:1285 msgid "Returns ``True`` if *x* is infinite; otherwise returns ``False``." msgstr "" "Retorna ``True`` si *x* es un valor infinito, en caso contrario retorna " "``False``." #: ../Doc/library/decimal.rst:1290 msgid "Returns ``True`` if *x* is a qNaN or sNaN; otherwise returns ``False``." msgstr "" "Retorna ``True`` si *x* es un valor qNaN o sNaN , en caso contrario retorna " "``False``." #: ../Doc/library/decimal.rst:1295 msgid "" "Returns ``True`` if *x* is a normal number; otherwise returns ``False``." msgstr "" "Retorna ``True`` si *x* es un número normal, en caso contrario retorna " "``False``." #: ../Doc/library/decimal.rst:1300 msgid "Returns ``True`` if *x* is a quiet NaN; otherwise returns ``False``." msgstr "" "Retorna ``True`` si *x* es un NaN silencioso, en caso contrario retorna " "``False``." #: ../Doc/library/decimal.rst:1305 msgid "Returns ``True`` if *x* is negative; otherwise returns ``False``." msgstr "" "Retorna ``True`` si *x* es un valor negativo, en caso contrario retorna " "``False``." #: ../Doc/library/decimal.rst:1310 msgid "" "Returns ``True`` if *x* is a signaling NaN; otherwise returns ``False``." msgstr "" "Retorna ``True`` si *x* es un NaN señalizador, en caso contrario retorna " "``False``." #: ../Doc/library/decimal.rst:1315 msgid "Returns ``True`` if *x* is subnormal; otherwise returns ``False``." msgstr "" "Retorna ``True`` si *x* es un número subnormal, en caso contrario retorna " "``False``." #: ../Doc/library/decimal.rst:1320 msgid "Returns ``True`` if *x* is a zero; otherwise returns ``False``." msgstr "" "Retorna ``True`` si *x* es un cero, en caso contrario retorna ``False``." #: ../Doc/library/decimal.rst:1325 msgid "Returns the natural (base e) logarithm of *x*." msgstr "Retorna el logaritmo natural (base e) de *x*." #: ../Doc/library/decimal.rst:1330 msgid "Returns the base 10 logarithm of *x*." msgstr "Retorna el logaritmo en base 10 de *x*." #: ../Doc/library/decimal.rst:1335 msgid "Returns the exponent of the magnitude of the operand's MSD." msgstr "" "Retorna el exponente de la magnitud del MSD (\"dígito más significativo\") " "del operando." #: ../Doc/library/decimal.rst:1340 msgid "Applies the logical operation *and* between each operand's digits." msgstr "Aplica la operación lógica *and* entre los dígitos de cada operando." #: ../Doc/library/decimal.rst:1345 msgid "Invert all the digits in *x*." msgstr "Invierte todos los dígitos en *x*." #: ../Doc/library/decimal.rst:1350 msgid "Applies the logical operation *or* between each operand's digits." msgstr "Aplica la operación lógica *or* entre los dígitos de cada operando." #: ../Doc/library/decimal.rst:1355 msgid "Applies the logical operation *xor* between each operand's digits." msgstr "Aplica la operación lógica *xor* entre los dígitos de cada operando." #: ../Doc/library/decimal.rst:1360 msgid "Compares two values numerically and returns the maximum." msgstr "Compara dos valores numéricamente y retorna el mayor de ellos." #: ../Doc/library/decimal.rst:1365 ../Doc/library/decimal.rst:1375 msgid "Compares the values numerically with their sign ignored." msgstr "Compara los valores numéricamente ignorando sus signos." #: ../Doc/library/decimal.rst:1370 msgid "Compares two values numerically and returns the minimum." msgstr "Compara dos valores numéricamente y retorna el menor de ellos." #: ../Doc/library/decimal.rst:1380 msgid "Minus corresponds to the unary prefix minus operator in Python." msgstr "Se corresponde con el operador unario de resta (prefijo) de Python." #: ../Doc/library/decimal.rst:1385 msgid "Return the product of *x* and *y*." msgstr "Retorna el producto de *x* por *y*." #: ../Doc/library/decimal.rst:1390 msgid "Returns the largest representable number smaller than *x*." msgstr "Retorna el número más grande representable menor que *x*." #: ../Doc/library/decimal.rst:1395 msgid "Returns the smallest representable number larger than *x*." msgstr "Retorna el número más pequeño representable mayor que *x*." #: ../Doc/library/decimal.rst:1400 msgid "Returns the number closest to *x*, in direction towards *y*." msgstr "Retorna el número más cercano a *x*, en la dirección de *y*." #: ../Doc/library/decimal.rst:1405 msgid "Reduces *x* to its simplest form." msgstr "Reduce *x* a su forma más simple." #: ../Doc/library/decimal.rst:1410 msgid "Returns an indication of the class of *x*." msgstr "Retorna una cadena de caracteres indicando la clase de *x*." #: ../Doc/library/decimal.rst:1415 msgid "" "Plus corresponds to the unary prefix plus operator in Python. This " "operation applies the context precision and rounding, so it is *not* an " "identity operation." msgstr "" "Se corresponde con el operador unario de suma (prefijo) de Python. Esta " "operación aplica la precisión y el redondeo establecidos en el contexto, por " "lo que *no* es una operación de identidad." #: ../Doc/library/decimal.rst:1422 msgid "Return ``x`` to the power of ``y``, reduced modulo ``modulo`` if given." msgstr "" "Retorna ``x`` elevado a la potencia ``y``, reconduciendo al módulo " "``modulo`` si se proporciona." #: ../Doc/library/decimal.rst:1424 msgid "" "With two arguments, compute ``x**y``. If ``x`` is negative then ``y`` must " "be integral. The result will be inexact unless ``y`` is integral and the " "result is finite and can be expressed exactly in 'precision' digits. The " "rounding mode of the context is used. Results are always correctly rounded " "in the Python version." msgstr "" "Con dos argumentos, calcula ``x**y``. Si ``x`` es negativo, entonces ``y`` " "debe ser un entero. El resultado será inexacto, a menos que ``y`` sea un " "entero y el resultado sea finito y pueda expresarse exactamente con los " "dígitos de la 'precisión' establecida. Se utiliza el modo de redondeo " "establecido en el contexto. Los resultados siempre se redondean " "correctamente en la versión de Python." #: ../Doc/library/decimal.rst:1430 msgid "" "``Decimal(0) ** Decimal(0)`` results in ``InvalidOperation``, and if " "``InvalidOperation`` is not trapped, then results in ``Decimal('NaN')``." msgstr "" "``Decimal(0) ** Decimal(0)`` da como resultado ``InvalidOperation``, y si " "``InvalidOperation`` no es atrapada, entonces da como resultado " "``Decimal('NaN')``." #: ../Doc/library/decimal.rst:1433 msgid "" "The C module computes :meth:`power` in terms of the correctly rounded :meth:" "`exp` and :meth:`ln` functions. The result is well-defined but only \"almost " "always correctly rounded\"." msgstr "" "El módulo C calcula :meth:`power` en términos de las funciones :meth:`exp` " "y :meth:`ln` redondeadas correctamente. El resultado está bien definido pero " "sólo \"casi siempre correctamente redondeado\"." #: ../Doc/library/decimal.rst:1438 msgid "" "With three arguments, compute ``(x**y) % modulo``. For the three argument " "form, the following restrictions on the arguments hold:" msgstr "" "Con tres argumentos, calcula ``(x**y) % modulo``. Para la forma de tres " "argumentos, se mantienen las siguientes restricciones sobre los argumentos:" #: ../Doc/library/decimal.rst:1441 msgid "all three arguments must be integral" msgstr "los tres argumentos deben ser enteros" #: ../Doc/library/decimal.rst:1442 msgid "``y`` must be nonnegative" msgstr "``y`` debe ser un valor no negativo" #: ../Doc/library/decimal.rst:1443 msgid "at least one of ``x`` or ``y`` must be nonzero" msgstr "al menos uno, ``x`` o ``y`` , no debe ser cero" #: ../Doc/library/decimal.rst:1444 msgid "``modulo`` must be nonzero and have at most 'precision' digits" msgstr "" "``modulo`` no debe ser cero y tener como mínimo los dígitos de la 'precisión'" #: ../Doc/library/decimal.rst:1446 msgid "" "The value resulting from ``Context.power(x, y, modulo)`` is equal to the " "value that would be obtained by computing ``(x**y) % modulo`` with unbounded " "precision, but is computed more efficiently. The exponent of the result is " "zero, regardless of the exponents of ``x``, ``y`` and ``modulo``. The " "result is always exact." msgstr "" "El valor resultante de ``Context.power(x, y, modulo)`` es igual al valor que " "se obtendría calculando ``(x**y) % modulo`` con precisión ilimitada, la " "diferencia es que se calcula de manera más eficiente . El exponente del " "resultado es cero, independientemente de los exponentes de ``x``, ``y`` y " "``modulo``. El resultado siempre es exacto." #: ../Doc/library/decimal.rst:1456 msgid "Returns a value equal to *x* (rounded), having the exponent of *y*." msgstr "" "Retorna un valor igual a *x* (redondeado), pero que tiene el exponente de " "*y*." #: ../Doc/library/decimal.rst:1461 msgid "Just returns 10, as this is Decimal, :)" msgstr "Simplemente retorna 10, ya que es Decimal, :)" #: ../Doc/library/decimal.rst:1466 msgid "Returns the remainder from integer division." msgstr "Retorna el resto de la división entera." #: ../Doc/library/decimal.rst:1468 msgid "" "The sign of the result, if non-zero, is the same as that of the original " "dividend." msgstr "" "El signo del resultado, si no es cero, es el mismo que el del dividendo " "original." #: ../Doc/library/decimal.rst:1474 msgid "" "Returns ``x - y * n``, where *n* is the integer nearest the exact value of " "``x / y`` (if the result is 0 then its sign will be the sign of *x*)." msgstr "" "Retorna ``x - y * n``, donde *n* es el número entero más cercano al valor " "exacto de ``x / y`` (si el resultado es 0, entonces su signo será el signo " "de *x*)." #: ../Doc/library/decimal.rst:1480 msgid "Returns a rotated copy of *x*, *y* times." msgstr "Retorna una copia de *x* rotada *y* veces." #: ../Doc/library/decimal.rst:1485 msgid "Returns ``True`` if the two operands have the same exponent." msgstr "Retorna ``True`` si los dos operandos tienen el mismo exponente." #: ../Doc/library/decimal.rst:1490 msgid "Returns the first operand after adding the second value its exp." msgstr "" "Retorna el primer operando después de agregar el segundo valor a su " "exponente." #: ../Doc/library/decimal.rst:1495 msgid "Returns a shifted copy of *x*, *y* times." msgstr "Retorna una copia de *x* desplazada *y* veces." #: ../Doc/library/decimal.rst:1500 msgid "Square root of a non-negative number to context precision." msgstr "" "Retorna la raíz cuadrada de un número no negativo para la precisión del " "contexto." #: ../Doc/library/decimal.rst:1505 msgid "Return the difference between *x* and *y*." msgstr "Retorna la diferencia entre *x* e *y*." #: ../Doc/library/decimal.rst:1519 msgid "Rounds to an integer." msgstr "Redondea a un entero." #: ../Doc/library/decimal.rst:1524 msgid "Converts a number to a string using scientific notation." msgstr "" "Convierte un número en una cadena de caracteres usando notación científica." #: ../Doc/library/decimal.rst:1531 msgid "Constants" msgstr "Constantes" #: ../Doc/library/decimal.rst:1533 msgid "" "The constants in this section are only relevant for the C module. They are " "also included in the pure Python version for compatibility." msgstr "" "Las constantes detalladas en esta sección solo son relevantes para el módulo " "de C. Se incluyen también en la versión pura de Python por compatibilidad." #: ../Doc/library/decimal.rst:1537 msgid "32-bit" msgstr "32-bit" #: ../Doc/library/decimal.rst:1537 msgid "64-bit" msgstr "64-bit" #: ../Doc/library/decimal.rst:1539 ../Doc/library/decimal.rst:1541 msgid "``425000000``" msgstr "``425000000``" #: ../Doc/library/decimal.rst:1539 ../Doc/library/decimal.rst:1541 msgid "``999999999999999999``" msgstr "``999999999999999999``" #: ../Doc/library/decimal.rst:1543 msgid "``-425000000``" msgstr "``-425000000``" #: ../Doc/library/decimal.rst:1543 msgid "``-999999999999999999``" msgstr "``-999999999999999999``" #: ../Doc/library/decimal.rst:1545 msgid "``-849999999``" msgstr "``-849999999``" #: ../Doc/library/decimal.rst:1545 msgid "``-1999999999999999997``" msgstr "``-1999999999999999997``" #: ../Doc/library/decimal.rst:1551 msgid "" "The value is ``True``. Deprecated, because Python now always has threads." msgstr "" "El valor es ``True``. Está obsoleta, debido ha que Python ahora siempre " "tiene soporte para hilos." #: ../Doc/library/decimal.rst:1557 msgid "" "The default value is ``True``. If Python is :option:`configured using the --" "without-decimal-contextvar option <--without-decimal-contextvar>`, the C " "version uses a thread-local rather than a coroutine-local context and the " "value is ``False``. This is slightly faster in some nested context " "scenarios." msgstr "" "El valor predeterminado es ``True``. Si Python se :option:`configura usando " "--without-decimal-contextvar <--without-decimal-contextvar>`, la versión de " "C usa un contexto de hilos-locales en lugar de un contexto de corrutinas-" "locales y el valor de la constante es ``False``. Esto es algo más rápido en " "algunos escenarios de contexto anidado." #: ../Doc/library/decimal.rst:1566 msgid "Rounding modes" msgstr "Modos de redondeo" #: ../Doc/library/decimal.rst:1570 msgid "Round towards ``Infinity``." msgstr "Redondear hacia ``Infinity``." #: ../Doc/library/decimal.rst:1574 msgid "Round towards zero." msgstr "Redondear hacia cero." #: ../Doc/library/decimal.rst:1578 msgid "Round towards ``-Infinity``." msgstr "Redondear hacia ``-Infinity``." #: ../Doc/library/decimal.rst:1582 msgid "Round to nearest with ties going towards zero." msgstr "Redondear al valor contiguo más cercano, con empates hacia cero." #: ../Doc/library/decimal.rst:1586 msgid "Round to nearest with ties going to nearest even integer." msgstr "" "Redondear al valor contiguo más cercano, con empates al entero par contiguo." #: ../Doc/library/decimal.rst:1590 msgid "Round to nearest with ties going away from zero." msgstr "" "Redondear al valor contiguo más cercano, con empates alejándose de cero." #: ../Doc/library/decimal.rst:1594 msgid "Round away from zero." msgstr "Redondear alejándose de cero." #: ../Doc/library/decimal.rst:1598 msgid "" "Round away from zero if last digit after rounding towards zero would have " "been 0 or 5; otherwise round towards zero." msgstr "" "Si el último dígito después de redondear hacia cero es 0 ó 5, redondear " "alejándose de cero, en caso contrario, redondear hacia cero." #: ../Doc/library/decimal.rst:1605 msgid "Signals" msgstr "Señales" #: ../Doc/library/decimal.rst:1607 msgid "" "Signals represent conditions that arise during computation. Each corresponds " "to one context flag and one context trap enabler." msgstr "" "Las señales representan condiciones que surgen durante el cálculo. Cada una " "se corresponde con un solo flag de contexto y un habilitador de trampas de " "contexto." #: ../Doc/library/decimal.rst:1610 msgid "" "The context flag is set whenever the condition is encountered. After the " "computation, flags may be checked for informational purposes (for instance, " "to determine whether a computation was exact). After checking the flags, be " "sure to clear all flags before starting the next computation." msgstr "" "El flag de contexto se establece siempre que se encuentra la condición. " "Después del cálculo, los flags pueden comprobarse con fines informativos " "(por ejemplo, para determinar si un cálculo fue exacto). Después de " "verificar los flags, asegúrate de borrarlos antes de comenzar con el " "siguiente cálculo." #: ../Doc/library/decimal.rst:1615 msgid "" "If the context's trap enabler is set for the signal, then the condition " "causes a Python exception to be raised. For example, if the :class:" "`DivisionByZero` trap is set, then a :exc:`DivisionByZero` exception is " "raised upon encountering the condition." msgstr "" "Si el habilitador de trampas del contexto está configurado para la señal, " "entonces la condición hace que se lance una excepción de Python. Por " "ejemplo, si se establece la trampa :class:`DivisionByZero`, se genera una " "excepción :exc:`DivisionByZero` al encontrar la condición." #: ../Doc/library/decimal.rst:1623 msgid "Altered an exponent to fit representation constraints." msgstr "Cambia un exponente para ajustar las restricciones de representación." #: ../Doc/library/decimal.rst:1625 msgid "" "Typically, clamping occurs when an exponent falls outside the context's :" "attr:`~Context.Emin` and :attr:`~Context.Emax` limits. If possible, the " "exponent is reduced to fit by adding zeros to the coefficient." msgstr "" "Normalmente, la restricción ocurre cuando un exponente cae fuera de los " "límites :attr:`~Context.Emin` y :attr:`~Context.Emax` del contexto. Si es " "posible, el exponente se reduce para ajustar agregando ceros al coeficiente." #: ../Doc/library/decimal.rst:1632 msgid "Base class for other signals and a subclass of :exc:`ArithmeticError`." msgstr "" "Clase base para otras señales. Es una subclase de :exc:`ArithmeticError`." #: ../Doc/library/decimal.rst:1637 msgid "Signals the division of a non-infinite number by zero." msgstr "Señala la división de un número no infinito entre cero." #: ../Doc/library/decimal.rst:1639 msgid "" "Can occur with division, modulo division, or when raising a number to a " "negative power. If this signal is not trapped, returns ``Infinity`` or ``-" "Infinity`` with the sign determined by the inputs to the calculation." msgstr "" "Puede ocurrir en la división, en la división modular o al elevar un número a " "una potencia negativa. Si esta señal no es atrapada, se retorna ``Infinity`` " "o ``-Infinity``, con el signo determinado por las entradas del cálculo." #: ../Doc/library/decimal.rst:1646 msgid "Indicates that rounding occurred and the result is not exact." msgstr "Indica que se produjo un redondeo y el resultado no es exacto." #: ../Doc/library/decimal.rst:1648 msgid "" "Signals when non-zero digits were discarded during rounding. The rounded " "result is returned. The signal flag or trap is used to detect when results " "are inexact." msgstr "" "Señala que se descartaron dígitos distintos de cero durante el redondeo. Se " "retorna el resultado redondeado. El flag o la trampa de señal se utiliza " "para detectar cuando los resultados son inexactos." #: ../Doc/library/decimal.rst:1655 msgid "An invalid operation was performed." msgstr "Señala que se realizó una operación no válida." #: ../Doc/library/decimal.rst:1657 msgid "" "Indicates that an operation was requested that does not make sense. If not " "trapped, returns ``NaN``. Possible causes include::" msgstr "" "Indica que se solicitó una operación que no tiene lógica. Si esta señal no " "está atrapada, se retorna ``NaN``. Las posibles causas incluyen::" #: ../Doc/library/decimal.rst:1660 #, python-format msgid "" "Infinity - Infinity\n" "0 * Infinity\n" "Infinity / Infinity\n" "x % 0\n" "Infinity % x\n" "sqrt(-x) and x > 0\n" "0 ** 0\n" "x ** (non-integer)\n" "x ** Infinity" msgstr "" #: ../Doc/library/decimal.rst:1673 msgid "Numerical overflow." msgstr "Desbordamiento numérico." #: ../Doc/library/decimal.rst:1675 msgid "" "Indicates the exponent is larger than :attr:`Context.Emax` after rounding " "has occurred. If not trapped, the result depends on the rounding mode, " "either pulling inward to the largest representable finite number or rounding " "outward to ``Infinity``. In either case, :class:`Inexact` and :class:" "`Rounded` are also signaled." msgstr "" "Indica que el exponente es mayor que :attr:`Context.Emax` después de que se " "haya producido el redondeo. Si no está atrapada, el resultado depende del " "modo de redondeo, ya sea tirando hacia adentro hasta el mayor número finito " "representable o redondeando hacia afuera a ``Infinity``. En cualquier caso, " "también se activan las señales :class:`Inexact` y :class:`Rounded`." #: ../Doc/library/decimal.rst:1684 msgid "Rounding occurred though possibly no information was lost." msgstr "" "Se produjo un redondeo, aunque posiblemente no hubo pérdida de información." #: ../Doc/library/decimal.rst:1686 msgid "" "Signaled whenever rounding discards digits; even if those digits are zero " "(such as rounding ``5.00`` to ``5.0``). If not trapped, returns the result " "unchanged. This signal is used to detect loss of significant digits." msgstr "" "Señal lanzada cada vez que el redondeo descarta dígitos; incluso si esos " "dígitos son cero (como al redondear ``5.00`` a ``5.0``). Si no está " "atrapada, se retorna el resultado sin cambios. Esta señal se utiliza para " "detectar la pérdida de dígitos significativos." #: ../Doc/library/decimal.rst:1694 msgid "Exponent was lower than :attr:`~Context.Emin` prior to rounding." msgstr "El exponente antes del redondeo era menor que :attr:`~Context.Emin`." #: ../Doc/library/decimal.rst:1696 msgid "" "Occurs when an operation result is subnormal (the exponent is too small). If " "not trapped, returns the result unchanged." msgstr "" "Ocurre cuando el resultado de una operación es subnormal (el exponente es " "demasiado pequeño). Si no está atrapada, se retorna el resultado sin cambios." #: ../Doc/library/decimal.rst:1702 msgid "Numerical underflow with result rounded to zero." msgstr "Desbordamiento numérico negativo con resultado redondeado a cero." #: ../Doc/library/decimal.rst:1704 msgid "" "Occurs when a subnormal result is pushed to zero by rounding. :class:" "`Inexact` and :class:`Subnormal` are also signaled." msgstr "" "Ocurre cuando un resultado subnormal se lleva a cero mediante redondeo. :" "class:`Inexact` y :class:`Subnormal` también se señalan." #: ../Doc/library/decimal.rst:1710 msgid "Enable stricter semantics for mixing floats and Decimals." msgstr "" "Habilita una semántica más estricta para mezclar flotantes y objetos Decimal." #: ../Doc/library/decimal.rst:1712 msgid "" "If the signal is not trapped (default), mixing floats and Decimals is " "permitted in the :class:`~decimal.Decimal` constructor, :meth:`~decimal." "Context.create_decimal` and all comparison operators. Both conversion and " "comparisons are exact. Any occurrence of a mixed operation is silently " "recorded by setting :exc:`FloatOperation` in the context flags. Explicit " "conversions with :meth:`~decimal.Decimal.from_float` or :meth:`~decimal." "Context.create_decimal_from_float` do not set the flag." msgstr "" "Si la señal no está atrapada (predeterminado), se permite mezclar flotantes " "y objetos Decimal en el constructor de :class:`~decimal.Decimal`, en el " "método :meth:`~decimal.Context.create_decimal` y en todos los operadores de " "comparación. Tanto la conversión como las comparaciones son exactas. " "Cualquier ocurrencia de una operación mixta se registra silenciosamente " "estableciendo :exc:`FloatOperation` a los flags del contexto. Las " "conversiones explícitas usando :meth:`~decimal.Decimal.from_float` o :meth:" "`~decimal.Context.create_decimal_from_float` no establecen el flag." #: ../Doc/library/decimal.rst:1720 msgid "" "Otherwise (the signal is trapped), only equality comparisons and explicit " "conversions are silent. All other mixed operations raise :exc:" "`FloatOperation`." msgstr "" "En caso contrario (la señal está atrapada), solo las comparaciones de " "igualdad y las conversiones explícitas permanecen silenciadas. Todas las " "demás operaciones mixtas lanzan una excepción :exc:`FloatOperation`." #: ../Doc/library/decimal.rst:1724 msgid "The following table summarizes the hierarchy of signals::" msgstr "La siguiente tabla resume la jerarquía de señales::" #: ../Doc/library/decimal.rst:1726 msgid "" "exceptions.ArithmeticError(exceptions.Exception)\n" " DecimalException\n" " Clamped\n" " DivisionByZero(DecimalException, exceptions.ZeroDivisionError)\n" " Inexact\n" " Overflow(Inexact, Rounded)\n" " Underflow(Inexact, Rounded, Subnormal)\n" " InvalidOperation\n" " Rounded\n" " Subnormal\n" " FloatOperation(DecimalException, exceptions.TypeError)" msgstr "" #: ../Doc/library/decimal.rst:1745 #, fuzzy msgid "Floating-Point Notes" msgstr "Notas sobre la representación en coma flotante" #: ../Doc/library/decimal.rst:1749 msgid "Mitigating round-off error with increased precision" msgstr "Mitigación del error de redondeo usando mayor precisión" #: ../Doc/library/decimal.rst:1751 msgid "" "The use of decimal floating point eliminates decimal representation error " "(making it possible to represent ``0.1`` exactly); however, some operations " "can still incur round-off error when non-zero digits exceed the fixed " "precision." msgstr "" "El uso de la coma flotante decimal elimina el error de representación " "decimal (haciendo posible representar ``0.1`` de forma exacta). Sin embargo, " "algunas operaciones aún pueden incurrir en errores de redondeo cuando los " "dígitos distintos de cero exceden la precisión fija." #: ../Doc/library/decimal.rst:1755 #, fuzzy msgid "" "The effects of round-off error can be amplified by the addition or " "subtraction of nearly offsetting quantities resulting in loss of " "significance. Knuth provides two instructive examples where rounded " "floating-point arithmetic with insufficient precision causes the breakdown " "of the associative and distributive properties of addition:" msgstr "" "Los efectos del error de redondeo pueden amplificarse mediante la suma o " "resta de cantidades casi compensadas, lo que da como resultado una pérdida " "de significación. Knuth proporciona dos ejemplos instructivos en los que la " "aritmética de coma flotante redondeada con precisión insuficiente provoca la " "ruptura de las propiedades asociativas y distributivas de la suma:" #: ../Doc/library/decimal.rst:1761 msgid "" "# Examples from Seminumerical Algorithms, Section 4.2.2.\n" ">>> from decimal import Decimal, getcontext\n" ">>> getcontext().prec = 8\n" "\n" ">>> u, v, w = Decimal(11111113), Decimal(-11111111), Decimal('7.51111111')\n" ">>> (u + v) + w\n" "Decimal('9.5111111')\n" ">>> u + (v + w)\n" "Decimal('10')\n" "\n" ">>> u, v, w = Decimal(20000), Decimal(-6), Decimal('6.0000003')\n" ">>> (u*v) + (u*w)\n" "Decimal('0.01')\n" ">>> u * (v+w)\n" "Decimal('0.0060000')" msgstr "" #: ../Doc/library/decimal.rst:1779 msgid "" "The :mod:`decimal` module makes it possible to restore the identities by " "expanding the precision sufficiently to avoid loss of significance:" msgstr "" "El módulo :mod:`decimal` permite restaurar las identidades ampliando la " "precisión lo suficiente para evitar la pérdida de significación:" #: ../Doc/library/decimal.rst:1782 msgid "" ">>> getcontext().prec = 20\n" ">>> u, v, w = Decimal(11111113), Decimal(-11111111), Decimal('7.51111111')\n" ">>> (u + v) + w\n" "Decimal('9.51111111')\n" ">>> u + (v + w)\n" "Decimal('9.51111111')\n" ">>>\n" ">>> u, v, w = Decimal(20000), Decimal(-6), Decimal('6.0000003')\n" ">>> (u*v) + (u*w)\n" "Decimal('0.0060000')\n" ">>> u * (v+w)\n" "Decimal('0.0060000')" msgstr "" #: ../Doc/library/decimal.rst:1799 msgid "Special values" msgstr "Valores especiales" #: ../Doc/library/decimal.rst:1801 msgid "" "The number system for the :mod:`decimal` module provides special values " "including ``NaN``, ``sNaN``, ``-Infinity``, ``Infinity``, and two zeros, " "``+0`` and ``-0``." msgstr "" "El sistema numérico para el módulo :mod:`decimal` proporciona valores " "especiales que incluyen: ``NaN``, ``sNaN``, ``-Infinity``, ``Infinity``, y " "dos ceros, ``+0`` y ``-0``." #: ../Doc/library/decimal.rst:1805 msgid "" "Infinities can be constructed directly with: ``Decimal('Infinity')``. Also, " "they can arise from dividing by zero when the :exc:`DivisionByZero` signal " "is not trapped. Likewise, when the :exc:`Overflow` signal is not trapped, " "infinity can result from rounding beyond the limits of the largest " "representable number." msgstr "" "Los infinitos se pueden construir directamente con ``Decimal('Infinity')``. " "Además, pueden surgir al dividir entre cero cuando la señal :exc:" "`DivisionByZero` no es interceptada. Asimismo, cuando la señal :exc:" "`Overflow` no es interceptada, un infinito puede resultar del redondeo más " "allá de los límites del mayor número representable." #: ../Doc/library/decimal.rst:1810 msgid "" "The infinities are signed (affine) and can be used in arithmetic operations " "where they get treated as very large, indeterminate numbers. For instance, " "adding a constant to infinity gives another infinite result." msgstr "" "Los infinitos tienen signo (afín) y se pueden usar en operaciones " "aritméticas donde se tratan como números muy grandes e indeterminados. Por " "ejemplo, adicionar una constante a infinito resulta en otro infinito." #: ../Doc/library/decimal.rst:1814 msgid "" "Some operations are indeterminate and return ``NaN``, or if the :exc:" "`InvalidOperation` signal is trapped, raise an exception. For example, " "``0/0`` returns ``NaN`` which means \"not a number\". This variety of " "``NaN`` is quiet and, once created, will flow through other computations " "always resulting in another ``NaN``. This behavior can be useful for a " "series of computations that occasionally have missing inputs --- it allows " "the calculation to proceed while flagging specific results as invalid." msgstr "" "Algunas operaciones son indeterminadas y retornan ``NaN``, o lanzan una " "excepción si la señal :exc:`InvalidOperation` es atrapada. Por ejemplo, " "``0/0`` retorna ``NaN`` que significa \"no es un número\". Esta variedad de " "``NaN`` es silenciosa y, una vez creada, fluirá a través de otros cálculos " "dando siempre como resultado otro ``NaN``. Este comportamiento puede ser " "útil para una serie de cálculos a los que ocasionalmente les faltan " "entradas, permitiendo que el cálculo continúe mientras se marcan resultados " "específicos como no válidos." #: ../Doc/library/decimal.rst:1822 msgid "" "A variant is ``sNaN`` which signals rather than remaining quiet after every " "operation. This is a useful return value when an invalid result needs to " "interrupt a calculation for special handling." msgstr "" "Una variante es ``sNaN``, que emite una señal en lugar de permanecer en " "silencio después de cada operación. Este es un valor de retorno útil cuando " "un resultado no válido requiere interrumpir un cálculo para un manejo " "especial." #: ../Doc/library/decimal.rst:1826 msgid "" "The behavior of Python's comparison operators can be a little surprising " "where a ``NaN`` is involved. A test for equality where one of the operands " "is a quiet or signaling ``NaN`` always returns :const:`False` (even when " "doing ``Decimal('NaN')==Decimal('NaN')``), while a test for inequality " "always returns :const:`True`. An attempt to compare two Decimals using any " "of the ``<``, ``<=``, ``>`` or ``>=`` operators will raise the :exc:" "`InvalidOperation` signal if either operand is a ``NaN``, and return :const:" "`False` if this signal is not trapped. Note that the General Decimal " "Arithmetic specification does not specify the behavior of direct " "comparisons; these rules for comparisons involving a ``NaN`` were taken from " "the IEEE 854 standard (see Table 3 in section 5.7). To ensure strict " "standards-compliance, use the :meth:`~Decimal.compare` and :meth:`~Decimal." "compare_signal` methods instead." msgstr "" "El comportamiento de los operadores de comparación de Python puede ser un " "poco sorprendente cuando está involucrado un valor ``NaN``. Una prueba de " "igualdad donde uno de los operandos es un ``NaN`` silencioso o señalizador " "siempre retorna :const:`False`` (incluso cuando se hace " "``Decimal('NaN')==Decimal('NaN')``), mientras que una prueba de desigualdad " "siempre retorna :const:`True`. Un intento de comparar dos objetos Decimal " "usando cualquiera de los operadores ``<``, ``<=``, ``>`` o ``>=`` lanzará la " "señal :exc:`InvalidOperation` si alguno de los operandos es ``NaN``, y " "retornará :const:`False` si esta señal no es capturada. Ten en cuenta que la " "Especificación General de la Aritmética Decimal no especifica el " "comportamiento de las comparaciones directas. Estas reglas para las " "comparaciones que involucran a ``NaN`` se tomaron del estándar IEEE 854 " "(consulta la Tabla 3 en la sección 5.7). Utiliza en su lugar los métodos :" "meth:`~Decimal.compare` y :meth:`~Decimal.compare_signal` para garantizar el " "cumplimiento estricto de los estándares." #: ../Doc/library/decimal.rst:1839 msgid "" "The signed zeros can result from calculations that underflow. They keep the " "sign that would have resulted if the calculation had been carried out to " "greater precision. Since their magnitude is zero, both positive and " "negative zeros are treated as equal and their sign is informational." msgstr "" "Los ceros con signo pueden resultar de cálculos que desbordan la precisión " "establecida. Mantienen el signo que habría resultado si el cálculo se " "hubiera realizado con mayor precisión. Dado que su magnitud es cero, los " "ceros positivos y negativos se tratan como iguales y su signo es solo " "informativo." #: ../Doc/library/decimal.rst:1844 #, fuzzy msgid "" "In addition to the two signed zeros which are distinct yet equal, there are " "various representations of zero with differing precisions yet equivalent in " "value. This takes a bit of getting used to. For an eye accustomed to " "normalized floating-point representations, it is not immediately obvious " "that the following calculation returns a value equal to zero:" msgstr "" "Además de los dos ceros con signo, que son distintos pero iguales, hay " "varias representaciones del cero con diferente precisión pero equivalentes " "en valor. Esto requiere de algo de tiempo para acostumbrarse. Para un ojo " "habituado a las representaciones normalizadas de coma flotante, no es " "inmediatamente obvio que el siguiente cálculo retorne un valor igual a cero:" #: ../Doc/library/decimal.rst:1859 msgid "Working with threads" msgstr "Trabajando con hilos" #: ../Doc/library/decimal.rst:1861 msgid "" "The :func:`getcontext` function accesses a different :class:`Context` object " "for each thread. Having separate thread contexts means that threads may " "make changes (such as ``getcontext().prec=10``) without interfering with " "other threads." msgstr "" "La función :func:`getcontext` accede a un objeto :class:`Context` diferente " "para cada hilo. Tener contextos de hilo separados significa que los hilos " "pueden realizar cambios (como ``getcontext().prec=10``) sin interferir con " "otros hilos." #: ../Doc/library/decimal.rst:1865 msgid "" "Likewise, the :func:`setcontext` function automatically assigns its target " "to the current thread." msgstr "" "Asimismo, la función :func:`setcontext` asigna automáticamente su objetivo " "al hilo actual." #: ../Doc/library/decimal.rst:1868 msgid "" "If :func:`setcontext` has not been called before :func:`getcontext`, then :" "func:`getcontext` will automatically create a new context for use in the " "current thread." msgstr "" "Si :func:`setcontext` no ha sido invocada antes de :func:`getcontext`, " "entonces :func:`getcontext` creará automáticamente un nuevo contexto para " "usar en el hilo actual." #: ../Doc/library/decimal.rst:1872 msgid "" "The new context is copied from a prototype context called *DefaultContext*. " "To control the defaults so that each thread will use the same values " "throughout the application, directly modify the *DefaultContext* object. " "This should be done *before* any threads are started so that there won't be " "a race condition between threads calling :func:`getcontext`. For example::" msgstr "" "El nuevo contexto es copiado a partir de un contexto prototipo llamado " "*DefaultContext*. Modifica directamente el objeto *DefaultContext* para " "controlar los valores predeterminados, de modo que cada hilo utilice los " "mismos valores en toda la aplicación. Esto debe hacerse *antes* de que se " "inicien los hilos, para evitar que tenga lugar una condición de carrera " "entre los mismos al invocar a :func:`getcontext`. Por ejemplo::" #: ../Doc/library/decimal.rst:1878 msgid "" "# Set applicationwide defaults for all threads about to be launched\n" "DefaultContext.prec = 12\n" "DefaultContext.rounding = ROUND_DOWN\n" "DefaultContext.traps = ExtendedContext.traps.copy()\n" "DefaultContext.traps[InvalidOperation] = 1\n" "setcontext(DefaultContext)\n" "\n" "# Afterwards, the threads can be started\n" "t1.start()\n" "t2.start()\n" "t3.start()\n" " . . ." msgstr "" #: ../Doc/library/decimal.rst:1897 msgid "Recipes" msgstr "Casos prácticos" #: ../Doc/library/decimal.rst:1899 msgid "" "Here are a few recipes that serve as utility functions and that demonstrate " "ways to work with the :class:`Decimal` class::" msgstr "" "A continuación hay algunos casos prácticos que sirven como funciones de " "utilidad y que muestran formas de trabajar con la clase :class:`Decimal`::" #: ../Doc/library/decimal.rst:1902 msgid "" "def moneyfmt(value, places=2, curr='', sep=',', dp='.',\n" " pos='', neg='-', trailneg=''):\n" " \"\"\"Convert Decimal to a money formatted string.\n" "\n" " places: required number of places after the decimal point\n" " curr: optional currency symbol before the sign (may be blank)\n" " sep: optional grouping separator (comma, period, space, or blank)\n" " dp: decimal point indicator (comma or period)\n" " only specify as blank when places is zero\n" " pos: optional sign for positive numbers: '+', space or blank\n" " neg: optional sign for negative numbers: '-', '(', space or blank\n" " trailneg:optional trailing minus indicator: '-', ')', space or blank\n" "\n" " >>> d = Decimal('-1234567.8901')\n" " >>> moneyfmt(d, curr='$')\n" " '-$1,234,567.89'\n" " >>> moneyfmt(d, places=0, sep='.', dp='', neg='', trailneg='-')\n" " '1.234.568-'\n" " >>> moneyfmt(d, curr='$', neg='(', trailneg=')')\n" " '($1,234,567.89)'\n" " >>> moneyfmt(Decimal(123456789), sep=' ')\n" " '123 456 789.00'\n" " >>> moneyfmt(Decimal('-0.02'), neg='<', trailneg='>')\n" " '<0.02>'\n" "\n" " \"\"\"\n" " q = Decimal(10) ** -places # 2 places --> '0.01'\n" " sign, digits, exp = value.quantize(q).as_tuple()\n" " result = []\n" " digits = list(map(str, digits))\n" " build, next = result.append, digits.pop\n" " if sign:\n" " build(trailneg)\n" " for i in range(places):\n" " build(next() if digits else '0')\n" " if places:\n" " build(dp)\n" " if not digits:\n" " build('0')\n" " i = 0\n" " while digits:\n" " build(next())\n" " i += 1\n" " if i == 3 and digits:\n" " i = 0\n" " build(sep)\n" " build(curr)\n" " build(neg if sign else pos)\n" " return ''.join(reversed(result))\n" "\n" "def pi():\n" " \"\"\"Compute Pi to the current precision.\n" "\n" " >>> print(pi())\n" " 3.141592653589793238462643383\n" "\n" " \"\"\"\n" " getcontext().prec += 2 # extra digits for intermediate steps\n" " three = Decimal(3) # substitute \"three=3.0\" for regular floats\n" " lasts, t, s, n, na, d, da = 0, three, 3, 1, 0, 0, 24\n" " while s != lasts:\n" " lasts = s\n" " n, na = n+na, na+8\n" " d, da = d+da, da+32\n" " t = (t * n) / d\n" " s += t\n" " getcontext().prec -= 2\n" " return +s # unary plus applies the new precision\n" "\n" "def exp(x):\n" " \"\"\"Return e raised to the power of x. Result type matches input " "type.\n" "\n" " >>> print(exp(Decimal(1)))\n" " 2.718281828459045235360287471\n" " >>> print(exp(Decimal(2)))\n" " 7.389056098930650227230427461\n" " >>> print(exp(2.0))\n" " 7.38905609893\n" " >>> print(exp(2+0j))\n" " (7.38905609893+0j)\n" "\n" " \"\"\"\n" " getcontext().prec += 2\n" " i, lasts, s, fact, num = 0, 0, 1, 1, 1\n" " while s != lasts:\n" " lasts = s\n" " i += 1\n" " fact *= i\n" " num *= x\n" " s += num / fact\n" " getcontext().prec -= 2\n" " return +s\n" "\n" "def cos(x):\n" " \"\"\"Return the cosine of x as measured in radians.\n" "\n" " The Taylor series approximation works best for a small value of x.\n" " For larger values, first compute x = x % (2 * pi).\n" "\n" " >>> print(cos(Decimal('0.5')))\n" " 0.8775825618903727161162815826\n" " >>> print(cos(0.5))\n" " 0.87758256189\n" " >>> print(cos(0.5+0j))\n" " (0.87758256189+0j)\n" "\n" " \"\"\"\n" " getcontext().prec += 2\n" " i, lasts, s, fact, num, sign = 0, 0, 1, 1, 1, 1\n" " while s != lasts:\n" " lasts = s\n" " i += 2\n" " fact *= i * (i-1)\n" " num *= x * x\n" " sign *= -1\n" " s += num / fact * sign\n" " getcontext().prec -= 2\n" " return +s\n" "\n" "def sin(x):\n" " \"\"\"Return the sine of x as measured in radians.\n" "\n" " The Taylor series approximation works best for a small value of x.\n" " For larger values, first compute x = x % (2 * pi).\n" "\n" " >>> print(sin(Decimal('0.5')))\n" " 0.4794255386042030002732879352\n" " >>> print(sin(0.5))\n" " 0.479425538604\n" " >>> print(sin(0.5+0j))\n" " (0.479425538604+0j)\n" "\n" " \"\"\"\n" " getcontext().prec += 2\n" " i, lasts, s, fact, num, sign = 1, 0, x, 1, x, 1\n" " while s != lasts:\n" " lasts = s\n" " i += 2\n" " fact *= i * (i-1)\n" " num *= x * x\n" " sign *= -1\n" " s += num / fact * sign\n" " getcontext().prec -= 2\n" " return +s" msgstr "" #: ../Doc/library/decimal.rst:2054 msgid "Decimal FAQ" msgstr "Preguntas frecuentes sobre decimal" #: ../Doc/library/decimal.rst:2056 msgid "" "Q. It is cumbersome to type ``decimal.Decimal('1234.5')``. Is there a way " "to minimize typing when using the interactive interpreter?" msgstr "" "P. Es engorroso escribir ``decimal.Decimal('1234.5')``. ¿Hay alguna forma de " "minimizar la escritura cuando se usa el intérprete interactivo?" #: ../Doc/library/decimal.rst:2059 msgid "A. Some users abbreviate the constructor to just a single letter:" msgstr "R. Algunos usuarios abrevian el constructor a una sola letra:" #: ../Doc/library/decimal.rst:2065 msgid "" "Q. In a fixed-point application with two decimal places, some inputs have " "many places and need to be rounded. Others are not supposed to have excess " "digits and need to be validated. What methods should be used?" msgstr "" "P. En una aplicación de coma fija con dos decimales, algunas entradas tienen " "muchos dígitos decimales y deben redondearse. En cambio, otras no tienen " "dígitos en exceso y deben ser validadas. ¿Qué métodos deben utilizarse?" #: ../Doc/library/decimal.rst:2069 msgid "" "A. The :meth:`~Decimal.quantize` method rounds to a fixed number of decimal " "places. If the :const:`Inexact` trap is set, it is also useful for " "validation:" msgstr "" "R. El método :meth:`~Decimal.quantize` redondea a un número fijo de " "decimales. Si se establece la trampa :const:`Inexact`, también es útil para " "la validación:" #: ../Doc/library/decimal.rst:2087 msgid "" "Q. Once I have valid two place inputs, how do I maintain that invariant " "throughout an application?" msgstr "" "P. Si tengo entradas validadas con dos dígitos decimales, ¿cómo mantengo eso " "invariante en una aplicación?" #: ../Doc/library/decimal.rst:2090 msgid "" "A. Some operations like addition, subtraction, and multiplication by an " "integer will automatically preserve fixed point. Others operations, like " "division and non-integer multiplication, will change the number of decimal " "places and need to be followed-up with a :meth:`~Decimal.quantize` step:" msgstr "" "R. Algunas operaciones como la suma, la resta y la multiplicación por un " "número entero conservarán automáticamente el punto fijo. Otras operaciones, " "como la división y la multiplicación de números no enteros, cambiarán el " "número de lugares decimales y deberá aplicarse :meth:`~Decimal.quantize` " "después de ellas:" #: ../Doc/library/decimal.rst:2108 msgid "" "In developing fixed-point applications, it is convenient to define functions " "to handle the :meth:`~Decimal.quantize` step:" msgstr "" "Al desarrollar aplicaciones de coma fija, es conveniente definir funciones " "para gestionar el paso :meth:`~Decimal.quantize`:" #: ../Doc/library/decimal.rst:2122 msgid "" "Q. There are many ways to express the same value. The numbers ``200``, " "``200.000``, ``2E2``, and ``.02E+4`` all have the same value at various " "precisions. Is there a way to transform them to a single recognizable " "canonical value?" msgstr "" "P. Hay muchas formas de expresar un mismo valor. Los números ``200``, " "``200.000``, ``2E2`` y ``.02E+4`` tienen todos el mismo valor pero con " "varias precisiones. ¿Hay alguna manera de transformarlos en un único valor " "canónico reconocible?" #: ../Doc/library/decimal.rst:2127 msgid "" "A. The :meth:`~Decimal.normalize` method maps all equivalent values to a " "single representative:" msgstr "" "R. El método :meth:`~Decimal.normalize` mapea todos los valores equivalentes " "a un solo representante:" #: ../Doc/library/decimal.rst:2134 msgid "Q. When does rounding occur in a computation?" msgstr "P. ¿Cuándo se realiza el redondeo en un cálculo?" #: ../Doc/library/decimal.rst:2136 msgid "" "A. It occurs *after* the computation. The philosophy of the decimal " "specification is that numbers are considered exact and are created " "independent of the current context. They can even have greater precision " "than current context. Computations process with those exact inputs and then " "rounding (or other context operations) is applied to the *result* of the " "computation::" msgstr "" "R. Se realiza *después* del cálculo. La filosofía de la especificación de " "decimal es que los números se consideran exactos y se crean " "independientemente del contexto actual. Pueden incluso tener más precisión " "que en el contexto actual. Los cálculo se procesan con esas entradas exactas " "y luego se aplica el redondeo (u otras operaciones de contexto) al " "*resultado* del cálculo::" #: ../Doc/library/decimal.rst:2143 msgid "" ">>> getcontext().prec = 5\n" ">>> pi = Decimal('3.1415926535') # More than 5 digits\n" ">>> pi # All digits are retained\n" "Decimal('3.1415926535')\n" ">>> pi + 0 # Rounded after an addition\n" "Decimal('3.1416')\n" ">>> pi - Decimal('0.00005') # Subtract unrounded numbers, then round\n" "Decimal('3.1415')\n" ">>> pi + 0 - Decimal('0.00005'). # Intermediate values are rounded\n" "Decimal('3.1416')" msgstr "" #: ../Doc/library/decimal.rst:2154 msgid "" "Q. Some decimal values always print with exponential notation. Is there a " "way to get a non-exponential representation?" msgstr "" "P. Algunos valores decimales siempre se imprimen usando notación " "exponencial. ¿Hay alguna forma de obtener una representación no exponencial?" #: ../Doc/library/decimal.rst:2157 msgid "" "A. For some values, exponential notation is the only way to express the " "number of significant places in the coefficient. For example, expressing " "``5.0E+3`` as ``5000`` keeps the value constant but cannot show the " "original's two-place significance." msgstr "" "R. Para algunos valores, la notación exponencial es la única forma de " "expresar el número de lugares significativos que tiene el coeficiente. Por " "ejemplo, expresar ``5.0E+3`` como ``5000`` mantiene el valor constante, pero " "no puede mostrar la significación de dos lugares que tiene el original." #: ../Doc/library/decimal.rst:2162 msgid "" "If an application does not care about tracking significance, it is easy to " "remove the exponent and trailing zeroes, losing significance, but keeping " "the value unchanged:" msgstr "" "Si una aplicación no necesita preocuparse por el seguimiento de " "significación, es fácil eliminar el exponente y los ceros finales, perdiendo " "significación, pero manteniendo el valor sin cambios:" #: ../Doc/library/decimal.rst:2172 msgid "Q. Is there a way to convert a regular float to a :class:`Decimal`?" msgstr "" "P. ¿Hay alguna forma de convertir un flotante regular en un :class:`Decimal`?" #: ../Doc/library/decimal.rst:2174 #, fuzzy msgid "" "A. Yes, any binary floating-point number can be exactly expressed as a " "Decimal though an exact conversion may take more precision than intuition " "would suggest:" msgstr "" "R. Sí, cualquier número de coma flotante binario se puede expresar " "exactamente mediante un Decimal, aunque una conversión exacta puede requerir " "más precisión de la que sugiere la intuición:" #: ../Doc/library/decimal.rst:2178 msgid "" ">>> Decimal(math.pi)\n" "Decimal('3.141592653589793115997963468544185161590576171875')" msgstr "" #: ../Doc/library/decimal.rst:2183 msgid "" "Q. Within a complex calculation, how can I make sure that I haven't gotten a " "spurious result because of insufficient precision or rounding anomalies." msgstr "" "P. Dentro de un cálculo complejo, cómo puedo asegurarme de que no he " "obtenido un resultado adulterado debido a una precisión insuficiente o " "anomalías de redondeo." #: ../Doc/library/decimal.rst:2186 msgid "" "A. The decimal module makes it easy to test results. A best practice is to " "re-run calculations using greater precision and with various rounding modes. " "Widely differing results indicate insufficient precision, rounding mode " "issues, ill-conditioned inputs, or a numerically unstable algorithm." msgstr "" "R. El módulo decimal facilita la comprobación de resultados. Una buena " "práctica es volver a ejecutar los cálculos con mayor precisión y con varios " "modos de redondeo. La obtención de resultados muy dispares indica una " "precisión insuficiente, problemas relacionados con el modo de redondeo, " "entradas mal acondicionadas o un algoritmo numéricamente inestable." #: ../Doc/library/decimal.rst:2191 msgid "" "Q. I noticed that context precision is applied to the results of operations " "but not to the inputs. Is there anything to watch out for when mixing " "values of different precisions?" msgstr "" "P. Noté que la precisión del contexto se aplica a los resultados de las " "operaciones pero no a las entradas. ¿Hay algo a tener en cuenta al mezclar " "valores con distintas precisiones?" #: ../Doc/library/decimal.rst:2195 msgid "" "A. Yes. The principle is that all values are considered to be exact and so " "is the arithmetic on those values. Only the results are rounded. The " "advantage for inputs is that \"what you type is what you get\". A " "disadvantage is that the results can look odd if you forget that the inputs " "haven't been rounded:" msgstr "" "R. Sí. El principio es que todos los valores se consideran exactos y también " "lo es la aritmética de esos valores. Solo se redondean los resultados. La " "ventaja para las entradas es que \"lo que escribes es lo que obtienes\". Una " "desventaja es que los resultados pueden parecer extraños si olvidas que las " "entradas no se han redondeado:" #: ../Doc/library/decimal.rst:2200 msgid "" ">>> getcontext().prec = 3\n" ">>> Decimal('3.104') + Decimal('2.104')\n" "Decimal('5.21')\n" ">>> Decimal('3.104') + Decimal('0.000') + Decimal('2.104')\n" "Decimal('5.20')" msgstr "" #: ../Doc/library/decimal.rst:2208 msgid "" "The solution is either to increase precision or to force rounding of inputs " "using the unary plus operation:" msgstr "" "La solución es aumentar la precisión o forzar el redondeo de las entradas " "utilizando la operación unaria más:" #: ../Doc/library/decimal.rst:2211 msgid "" ">>> getcontext().prec = 3\n" ">>> +Decimal('1.23456789') # unary plus triggers rounding\n" "Decimal('1.23')" msgstr "" #: ../Doc/library/decimal.rst:2217 msgid "" "Alternatively, inputs can be rounded upon creation using the :meth:`Context." "create_decimal` method:" msgstr "" "Alternativamente, las entradas se pueden redondear en el momento que se " "crean usando el método :meth:`Context.create_decimal`:" #: ../Doc/library/decimal.rst:2223 msgid "Q. Is the CPython implementation fast for large numbers?" msgstr "P. ¿La implementación de CPython es rápida para números grandes?" #: ../Doc/library/decimal.rst:2225 #, fuzzy msgid "" "A. Yes. In the CPython and PyPy3 implementations, the C/CFFI versions of " "the decimal module integrate the high speed `libmpdec `_ library for arbitrary precision " "correctly rounded decimal floating-point arithmetic [#]_. ``libmpdec`` uses " "`Karatsuba multiplication `_ for medium-sized numbers and the `Number Theoretic " "Transform `_ for very " "large numbers." msgstr "" "R. Sí. En las implementaciones de CPython y PyPy3, las versiones C/CFFI del " "módulo decimal integran la biblioteca de alta velocidad `libmpdec `_ para aritmética de " "precisión arbitraria de coma flotante decimal correctamente redondeada [#]_. " "``libmpdec`` usa la `multiplicación de Karatsuba `_ para números de tamaño mediano y la " "\"Transformada Teórico-Numérica\" (`Number Theoretic Transform `_) para números muy grandes." #: ../Doc/library/decimal.rst:2235 msgid "" "The context must be adapted for exact arbitrary precision arithmetic. :attr:" "`~Context.Emin` and :attr:`~Context.Emax` should always be set to the " "maximum values, :attr:`~Context.clamp` should always be 0 (the default). " "Setting :attr:`~Context.prec` requires some care." msgstr "" "El contexto debe adaptarse para una aritmética de precisión arbitraria " "exacta. :attr:`~Context.Emin` y :attr:`~Context.Emax` siempre deben " "establecerse en sus valores máximos, :attr:`~Context.clamp` siempre debe ser " "0 (el valor predeterminado). Establecer :attr:`~Context.prec` requiere " "cierto cuidado." #: ../Doc/library/decimal.rst:2239 msgid "" "The easiest approach for trying out bignum arithmetic is to use the maximum " "value for :attr:`~Context.prec` as well [#]_::" msgstr "" "El enfoque más fácil para probar la aritmética bignum es usar también el " "valor máximo para :attr:`~Context.prec` [#]_::" #: ../Doc/library/decimal.rst:2242 msgid "" ">>> setcontext(Context(prec=MAX_PREC, Emax=MAX_EMAX, Emin=MIN_EMIN))\n" ">>> x = Decimal(2) ** 256\n" ">>> x / 128\n" "Decimal('904625697166532776746648320380374280103671755200316906558262375061821325312')" msgstr "" #: ../Doc/library/decimal.rst:2248 msgid "" "For inexact results, :attr:`MAX_PREC` is far too large on 64-bit platforms " "and the available memory will be insufficient::" msgstr "" "Para resultados inexactos, :attr:`MAX_PREC` es demasiado grande en " "plataformas de 64 bits y la memoria disponible será insuficiente::" #: ../Doc/library/decimal.rst:2251 msgid "" ">>> Decimal(1) / 3\n" "Traceback (most recent call last):\n" " File \"\", line 1, in \n" "MemoryError" msgstr "" #: ../Doc/library/decimal.rst:2256 msgid "" "On systems with overallocation (e.g. Linux), a more sophisticated approach " "is to adjust :attr:`~Context.prec` to the amount of available RAM. Suppose " "that you have 8GB of RAM and expect 10 simultaneous operands using a maximum " "of 500MB each::" msgstr "" "En sistemas con sobreasignación (por ejemplo, Linux), un enfoque más " "sofisticado es establecer :attr:`~Context.prec` a la cantidad de RAM " "disponible. Supongamos que tenemos 8GB de RAM y esperamos 10 operandos " "simultáneos usando un máximo de 500 MB cada uno::" #: ../Doc/library/decimal.rst:2260 msgid "" ">>> import sys\n" ">>>\n" ">>> # Maximum number of digits for a single operand using 500MB in 8-byte " "words\n" ">>> # with 19 digits per word (4-byte and 9 digits for the 32-bit build):\n" ">>> maxdigits = 19 * ((500 * 1024**2) // 8)\n" ">>>\n" ">>> # Check that this works:\n" ">>> c = Context(prec=maxdigits, Emax=MAX_EMAX, Emin=MIN_EMIN)\n" ">>> c.traps[Inexact] = True\n" ">>> setcontext(c)\n" ">>>\n" ">>> # Fill the available precision with nines:\n" ">>> x = Decimal(0).logical_invert() * 9\n" ">>> sys.getsizeof(x)\n" "524288112\n" ">>> x + 2\n" "Traceback (most recent call last):\n" " File \"\", line 1, in \n" " decimal.Inexact: []" msgstr "" #: ../Doc/library/decimal.rst:2280 msgid "" "In general (and especially on systems without overallocation), it is " "recommended to estimate even tighter bounds and set the :attr:`Inexact` trap " "if all calculations are expected to be exact." msgstr "" "En general (y especialmente en sistemas sin sobreasignación), se recomienda " "estimar límites aún más estrictos y establecer la trampa :attr:`Inexact` si " "se espera que todos los cálculos sean exactos." #: ../Doc/library/decimal.rst:2289 msgid "" "This approach now works for all exact results except for non-integer powers." msgstr "" "Este enfoque ahora funciona para todos los resultados exactos excepto para " "las potencias no enteras. También retro-portado a 3.7 y 3.8."