"fractions" --- Números racionales
**********************************

**Source code:** Lib/fractions.py

======================================================================

El módulo "fractions" provee soporte para aritmética de números
racionales.

Una instancia de *Fraction* puede construirse desde dos enteros, desde
otro número racional, o desde una cadena de caracteres.

class fractions.Fraction(numerator=0, denominator=1)
class fractions.Fraction(other_fraction)
class fractions.Fraction(float)
class fractions.Fraction(decimal)
class fractions.Fraction(string)

   La primera versión necesita que *numerator* y *denominator* sean
   instancias de "numbers.Rational"  y retorna una nueva instancia de
   "Fraction" con valor "numerator/denominator". Si *denominator* es
   "0", esto arrojará un error "ZeroDivisionError". La segunda versión
   necesita que *other_fraction* sea una instancia de
   "numbers.Rational" y retorna una instancia "Fraction"  con el mismo
   valor. Las restantes dos versiones aceptan igualmente instancias
   "float" o "decimal.Decimal" y retornan una instancia "Fraction" con
   exactamente el mismo valor. Nota que debido a los problemas usuales
   con la representación binaria en punto flotante (ver Aritmética de
   Punto Flotante: Problemas y Limitaciones), 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 "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:

      [sign] numerator ['/' denominator]

   donde el "sign" opcional puede ser '+' o '-' y "numerator" y
   "denominator" (si están presentes) son cadenas de caracteres de
   dígitos decimales. Además, cualquier cadena de caracteres que
   represente un valor finito y sea aceptado por el constructor de
   "float" también es aceptado por el constructor de "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:

      >>> from fractions import Fraction
      >>> Fraction(16, -10)
      Fraction(-8, 5)
      >>> Fraction(123)
      Fraction(123, 1)
      >>> Fraction()
      Fraction(0, 1)
      >>> Fraction('3/7')
      Fraction(3, 7)
      >>> Fraction(' -3/7 ')
      Fraction(-3, 7)
      >>> Fraction('1.414213 \t\n')
      Fraction(1414213, 1000000)
      >>> Fraction('-.125')
      Fraction(-1, 8)
      >>> Fraction('7e-6')
      Fraction(7, 1000000)
      >>> Fraction(2.25)
      Fraction(9, 4)
      >>> Fraction(1.1)
      Fraction(2476979795053773, 2251799813685248)
      >>> from decimal import Decimal
      >>> Fraction(Decimal('1.1'))
      Fraction(11, 10)

   La clase "Fraction" hereda de la clase base abstracta
   "numbers.Rational", e implementa todos los métodos y operaciones de
   esa clase. Las instancias "Fraction" son *hashable*, y deben ser
   tratadas como inmutables. Adicionalmente "Fraction" tiene los
   siguientes métodos y propiedades:

   Distinto en la versión 3.2: El constructor de "Fraction" ahora
   acepta instancias de "float" y "decimal".

   numerator

      Numerador de la fracción irreducible.

   denominator

      Denominador de la fracción irreducible.

   as_integer_ratio()

      Retorna una tupla de dos enteros, cuyo ratio es igual a la
      fracción y con un denominador positivo.

      Nuevo en la versión 3.8.

   from_float(flt)

      Este método de clase construye una instancia de "Fraction"
      representando el valor exacto de *flt* que debe ser un "float".
      Ten cuidado, observa que "Fraction.from_float(0.3)" no es el
      mismo valor que "Fraction(3, 10)".

      Nota:

        Desde Python 3.2 en adelante, puedes construir una instancia
        "Fraction" directamente desde "float".

   from_decimal(dec)

      Este método de clase construye una instancia de "Fraction"
      representando el valor exacto de *dec*, que debe ser una
      instancia de "decimal.Decimal".

      Nota:

        Desde Python 3.2 en adelante, puedes construir una instancia
        "Fraction" directamente desde una instancia "decimal.Decimal".

   limit_denominator(max_denominator=1000000)

      Busca y retorna la instancia de "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:

      >>> from fractions import Fraction
      >>> Fraction('3.1415926535897932').limit_denominator(1000)
      Fraction(355, 113)

      o para recuperar un numero racional que esta representado como
      flotante:

      >>> from math import pi, cos
      >>> Fraction(cos(pi/3))
      Fraction(4503599627370497, 9007199254740992)
      >>> Fraction(cos(pi/3)).limit_denominator()
      Fraction(1, 2)
      >>> Fraction(1.1).limit_denominator()
      Fraction(11, 10)

   __floor__()

      Retorna el máximo "int" "<= self". Este método puede accederse
      también a través de la función "math.floor()":

      >>> from math import floor
      >>> floor(Fraction(355, 113))
      3

   __ceil__()

      Retorna el mínimo "int" ">= self". Este método puede accederse
      también a través de la función "math.ceil()".

   __round__()
   __round__(ndigits)

      La primera versión retorna el valor "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 "round()".

fractions.gcd(a, b)

   Retorna el máximo común divisor de los enteros *a* y *b*. Si *a* o
   *b* no son cero, entonces el valor absoluto de "gcd(a, b)" es el
   entero mas grande que divide ambos, *a* y *b*. "gcd(a,b)" tiene el
   mismo signo que *b* si *b* no es cero; sino toma el signo de *a*.
   "gcd(0, 0)" retorna "0".

   Obsoleto desde la versión 3.5: Usa en cambio la función
   "math.gcd()".

Ver también:

  Módulo "numbers"
     Las clases base abstractas que representan la jerarquía de
     números.
