fractions.po

# Copyright (C) 2001-2020, Python Software Foundation
# This file is distributed under the same license as the Python package.
# Maintained by the python-doc-es workteam.
# docs-es@python.org /
# https://mail.python.org/mailman3/lists/docs-es.python.org/
# Check https://github.com/python/python-docs-es/blob/3.8/TRANSLATORS to
# get the list of volunteers
#
msgid ""
msgstr ""
"Project-Id-Version: Python 3.8\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2023-10-12 19:43+0200\n"
"PO-Revision-Date: 2023-02-20 10:36-0300\n"
"Last-Translator: Cristián Maureira-Fredes <cmaureirafredes@gmail.com>\n"
"Language-Team: python-doc-es\n"
"Language: es_AR\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=utf-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=2; plural=(n != 1);\n"
"Generated-By: Babel 2.13.0\n"

#: ../Doc/library/fractions.rst:2
msgid ":mod:`fractions` --- Rational numbers"
msgstr ":mod:`fractions` --- Números racionales"

#: ../Doc/library/fractions.rst:10
msgid "**Source code:** :source:`Lib/fractions.py`"
msgstr "**Source code:** :source:`Lib/fractions.py`"

#: ../Doc/library/fractions.rst:14
msgid ""
"The :mod:`fractions` module provides support for rational number arithmetic."
msgstr ""
"El módulo :mod:`fractions` provee soporte para aritmética de números "
"racionales."

#: ../Doc/library/fractions.rst:17
msgid ""
"A Fraction instance can be constructed from a pair of integers, from another "
"rational number, or from a string."
msgstr ""
"Una instancia de *Fraction* puede construirse desde dos enteros, desde otro "
"número racional, o desde una cadena de caracteres."

#: ../Doc/library/fractions.rst:26
msgid ""
"The first version requires that *numerator* and *denominator* are instances "
"of :class:`numbers.Rational` and returns a new :class:`Fraction` instance "
"with value ``numerator/denominator``. If *denominator* is ``0``, it raises "
"a :exc:`ZeroDivisionError`. The second version requires that "
"*other_fraction* is an instance of :class:`numbers.Rational` and returns a :"
"class:`Fraction` instance with the same value.  The next two versions accept "
"either a :class:`float` or a :class:`decimal.Decimal` instance, and return "
"a :class:`Fraction` instance with exactly the same value.  Note that due to "
"the usual issues with binary floating-point (see :ref:`tut-fp-issues`), the "
"argument to ``Fraction(1.1)`` is not exactly equal to 11/10, and so "
"``Fraction(1.1)`` does *not* return ``Fraction(11, 10)`` as one might "
"expect. (But see the documentation for the :meth:`limit_denominator` method "
"below.) The last version of the constructor expects a string or unicode "
"instance. The usual form for this instance is::"
msgstr ""
"La primera versión requiere que *numerator* y *denominator* sean instancias "
"de :class:`numbers.Rational`  y retorna una nueva instancia de :class:"
"`Fraction` con valor ``numerator/denominator``. Si *denominator* es ``0``, "
"esto arrojará un error :exc:`ZeroDivisionError`. La segunda versión necesita "
"que *other_fraction* sea una instancia de :class:`numbers.Rational` y "
"retorna una instancia de :class:`Fraction`  con el mismo valor. Las "
"siguientes dos versiones aceptan igualmente instancias :class:`float` o :"
"class:`decimal.Decimal` y retornan una instancia :class:`Fraction` con "
"exactamente el mismo valor. Nota que debido a los problemas usuales con la "
"representación binaria en punto flotante (ver :ref:`tut-fp-issues`), el "
"argumento de ``Fraction(1.1)`` no es exactamente igual a 11/10, por lo que "
"``Fraction(1.1)`` no retorna ``Fraction(11, 10)`` como uno esperaría. (Mira "
"la documentación para el método :meth:`limit_denominator` abajo.) La última "
"versión del constructor espera una cadena de caracteres o una instancia "
"Unicode. La forma usual para esta instancia es:"

#: ../Doc/library/fractions.rst:43
msgid ""
"where the optional ``sign`` may be either '+' or '-' and ``numerator`` and "
"``denominator`` (if present) are strings of decimal digits (underscores may "
"be used to delimit digits as with integral literals in code).  In addition, "
"any string that represents a finite value and is accepted by the :class:"
"`float` constructor is also accepted by the :class:`Fraction` constructor.  "
"In either form the input string may also have leading and/or trailing "
"whitespace. Here are some examples::"
msgstr ""
"donde el ``sign`` opcional puede ser '+' o '-' y ``numerator`` y "
"``denominator`` (si están presentes) son cadenas de caracteres de dígitos "
"decimales (guiones bajos se pueden usar para delimitar dígitos como con las "
"integrales literales en el código). Además, cualquier cadena de caracteres "
"que represente un valor finito y sea aceptado por el constructor de :class:"
"`float` también es aceptado por el constructor de :class:`Fraction`. En "
"cualquier caso, la cadena de caracteres de entrada también puede tener "
"espacios en blanco iniciales y / o finales. Aquí hay unos ejemplos:"

#: ../Doc/library/fractions.rst:78
msgid ""
"The :class:`Fraction` class inherits from the abstract base class :class:"
"`numbers.Rational`, and implements all of the methods and operations from "
"that class.  :class:`Fraction` instances are :term:`hashable`, and should be "
"treated as immutable.  In addition, :class:`Fraction` has the following "
"properties and methods:"
msgstr ""
"La clase :class:`Fraction` hereda de la clase base abstracta :class:`numbers."
"Rational`, e implementa todos los métodos y operaciones de esa clase. Las "
"instancias :class:`Fraction` son :term:`hashable`, y deben ser tratadas como "
"inmutables. Adicionalmente :class:`Fraction` tiene los siguientes "
"propiedades y métodos:"

#: ../Doc/library/fractions.rst:84
msgid ""
"The :class:`Fraction` constructor now accepts :class:`float` and :class:"
"`decimal.Decimal` instances."
msgstr ""
"El constructor de :class:`Fraction` ahora acepta instancias de :class:"
"`float` y :class:`decimal`."

#: ../Doc/library/fractions.rst:88
msgid ""
"The :func:`math.gcd` function is now used to normalize the *numerator* and "
"*denominator*. :func:`math.gcd` always return a :class:`int` type. "
"Previously, the GCD type depended on *numerator* and *denominator*."
msgstr ""
"La función :func:`math.gcd` ahora se usa para normalizar el *numerator* y "
"*denominator*. :func:`math.gcd` siempre retorna un tipo :class:`int`. "
"Anteriormente, el tipo de GCD dependía de *numerator* y *denominator*."

#: ../Doc/library/fractions.rst:93
msgid ""
"Underscores are now permitted when creating a :class:`Fraction` instance "
"from a string, following :PEP:`515` rules."
msgstr ""
"Ahora se permiten guiones bajos al crear una instancia de :class:`Fraction` "
"a partir de una cadena de caracteres, siguiendo las reglas de :PEP:`515`."

#: ../Doc/library/fractions.rst:97
msgid ""
":class:`Fraction` implements ``__int__`` now to satisfy ``typing."
"SupportsInt`` instance checks."
msgstr ""
":class:`Fraction` ahora implementa ``__int__`` para satisfacer las "
"comprobaciones de instancia de ``typing.SupportsInt``."

#: ../Doc/library/fractions.rst:101
msgid ""
"Space is allowed around the slash for string inputs: ``Fraction('2 / 3')``."
msgstr ""
"Se permite espacio alrededor de la barra para entrada de cadena de "
"caracteres: ``Fraction('2 / 3')``."

#: ../Doc/library/fractions.rst:104
msgid ""
":class:`Fraction` instances now support float-style formatting, with "
"presentation types ``\"e\"``, ``\"E\"``, ``\"f\"``, ``\"F\"``, ``\"g\"``, "
"``\"G\"`` and ``\"%\"\"``."
msgstr ""
":class:`Fraction` instancias ahora apoya formato de estilo flotante, con "
"tipos de presentación ``\"e\"``, ``\"E\"``, ``\"f\"``, ``\"F\"``, ``\"g\"``, "
"``\"G\"`` and ``\"%\"\"``."

#: ../Doc/library/fractions.rst:111
msgid "Numerator of the Fraction in lowest term."
msgstr "Numerador de la fracción irreducible."

#: ../Doc/library/fractions.rst:115
msgid "Denominator of the Fraction in lowest term."
msgstr "Denominador de la fracción irreducible."

#: ../Doc/library/fractions.rst:120
msgid ""
"Return a tuple of two integers, whose ratio is equal to the original "
"Fraction.  The ratio is in lowest terms and has a positive denominator."
msgstr ""
"Retorna una tupla de dos números enteros, cuyo relación es igual a la "
"fracción original.La relación está en términos más bajos y tiene un "
"denominador positivo."

#: ../Doc/library/fractions.rst:128
msgid "Return ``True`` if the Fraction is an integer."
msgstr "Retorna ``True`` si la fracción es un número entero."

#: ../Doc/library/fractions.rst:134
msgid ""
"Alternative constructor which only accepts instances of :class:`float` or :"
"class:`numbers.Integral`. Beware that ``Fraction.from_float(0.3)`` is not "
"the same value as ``Fraction(3, 10)``."
msgstr ""
"Constructor alternativo que solo acepta instancias de :class:`float` o :"
"class:`numbers.Integral`. Ten cuidado que ``Fraction.from_float(0.3)`` no es "
"lo mismo  que ``Fraction(3, 10)``."

#: ../Doc/library/fractions.rst:140
msgid ""
"From Python 3.2 onwards, you can also construct a :class:`Fraction` instance "
"directly from a :class:`float`."
msgstr ""
"Desde Python 3.2 en adelante, puedes construir una instancia :class:"
"`Fraction` directamente desde :class:`float`."

#: ../Doc/library/fractions.rst:146
msgid ""
"Alternative constructor which only accepts instances of :class:`decimal."
"Decimal` or :class:`numbers.Integral`."
msgstr ""
"Constructor alternativo que solo acepta instancias de :class:`decimal."
"Decimal` o :class:`numbers.Integral`."

#: ../Doc/library/fractions.rst:151
msgid ""
"From Python 3.2 onwards, you can also construct a :class:`Fraction` instance "
"directly from a :class:`decimal.Decimal` instance."
msgstr ""
"Desde Python 3.2 en adelante, puedes construir una instancia :class:"
"`Fraction` directamente desde una instancia :class:`decimal.Decimal`."

#: ../Doc/library/fractions.rst:158
msgid ""
"Finds and returns the closest :class:`Fraction` to ``self`` that has "
"denominator at most max_denominator.  This method is useful for finding "
"rational approximations to a given floating-point number:"
msgstr ""
"Busca y retorna la instancia de :class:`Fraction` mas cercana a ``self`` que "
"tenga como denominador *max_denominator*. Este método es útil para encontrar "
"aproximaciones racionales a un número en punto flotante determinado:"

#: ../Doc/library/fractions.rst:166
msgid "or for recovering a rational number that's represented as a float:"
msgstr ""
"o para recuperar un numero racional que esta representado como flotante:"

#: ../Doc/library/fractions.rst:179
msgid ""
"Returns the greatest :class:`int` ``<= self``.  This method can also be "
"accessed through the :func:`math.floor` function:"
msgstr ""
"Retorna el máximo :class:`int` ``<= self``. Este método puede accederse "
"también a través de la función :func:`math.floor`:"

#: ../Doc/library/fractions.rst:189
msgid ""
"Returns the least :class:`int` ``>= self``.  This method can also be "
"accessed through the :func:`math.ceil` function."
msgstr ""
"Retorna el mínimo :class:`int` ``>= self``. Este método puede accederse "
"también a través de la función :func:`math.ceil`."

#: ../Doc/library/fractions.rst:196
msgid ""
"The first version returns the nearest :class:`int` to ``self``, rounding "
"half to even. The second version rounds ``self`` to the nearest multiple of "
"``Fraction(1, 10**ndigits)`` (logically, if ``ndigits`` is negative), again "
"rounding half toward even.  This method can also be accessed through the :"
"func:`round` function."
msgstr ""
"La primera versión retorna el valor :class:`int` mas cercano a ``self`` "
"redondeando mitades al valor par. La segunda versión redondea ``self`` al "
"múltiplo mas cercano de ``Fraction(1, 10**ndigits)`` (lógicamente, si "
"``ndigits`` es negativo), nuevamente redondeando mitades al valor par. Este "
"método también puede accederse a través de la función :func:`round`."

#: ../Doc/library/fractions.rst:204
msgid ""
"Provides support for float-style formatting of :class:`Fraction` instances "
"via the :meth:`str.format` method, the :func:`format` built-in function, or :"
"ref:`Formatted string literals <f-strings>`. The presentation types "
"``\"e\"``, ``\"E\"``, ``\"f\"``, ``\"F\"``, ``\"g\"``, ``\"G\"`` and ``\"%"
"\"`` are supported. For these presentation types, formatting for a :class:"
"`Fraction` object ``x`` follows the rules outlined for the :class:`float` "
"type in the :ref:`formatspec` section."
msgstr ""
"Provee apoyo para el formato de estilo flotante de instancias :class:"
"`Fraction` a través del método :meth:`str.format`, la función incorporada :"
"func:`format`, o :ref:`Formatted string literals <f-strings>`. Los tipos de "
"presentación ``\"e\"``, ``\"E\"``, ``\"f\"``, ``\"F\"``, ``\"g\"``, "
"``\"G\"`` and ``\"%\"`` son compatibles. Para estos tipos de presentación, "
"el formato para una :class:`Fraction` object ``x`` sigue las reglas "
"descritas para el :class:`float` tipo en la :ref:`formatspec` sección."

#: ../Doc/library/fractions.rst:212
msgid "Here are some examples::"
msgstr "Aquí hay unos ejemplos::"

#: ../Doc/library/fractions.rst:228
msgid "Module :mod:`numbers`"
msgstr "Módulo :mod:`numbers`"

#: ../Doc/library/fractions.rst:229
msgid "The abstract base classes making up the numeric tower."
msgstr "Las clases base abstractas que representan la jerarquía de números."