home *** CD-ROM | disk | FTP | other *** search
/ Chip 2011 November / CHIP_2011_11.iso / Programy / Narzedzia / Calibre / calibre-0.8.18.msi / file_262 / fractions.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2011-09-09  |  11.3 KB  |  341 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.7)
  3.  
  4. from __future__ import division
  5. from decimal import Decimal
  6. import math
  7. import numbers
  8. import operator
  9. import re
  10. __all__ = [
  11.     'Fraction',
  12.     'gcd']
  13. Rational = numbers.Rational
  14.  
  15. def gcd(a, b):
  16.     while b:
  17.         a = b
  18.         b = a % b
  19.     return a
  20.  
  21. _RATIONAL_FORMAT = re.compile('\n    \\A\\s*                      # optional whitespace at the start, then\n    (?P<sign>[-+]?)            # an optional sign, then\n    (?=\\d|\\.\\d)                # lookahead for digit or .digit\n    (?P<num>\\d*)               # numerator (possibly empty)\n    (?:                        # followed by\n       (?:/(?P<denom>\\d+))?    # an optional denominator\n    |                          # or\n       (?:\\.(?P<decimal>\\d*))? # an optional fractional part\n       (?:E(?P<exp>[-+]?\\d+))? # and optional exponent\n    )\n    \\s*\\Z                      # and optional whitespace to finish\n', re.VERBOSE | re.IGNORECASE)
  22.  
  23. class Fraction(Rational):
  24.     __slots__ = ('_numerator', '_denominator')
  25.     
  26.     def __new__(cls, numerator = 0, denominator = None):
  27.         self = super(Fraction, cls).__new__(cls)
  28.         if denominator is None:
  29.             if isinstance(numerator, Rational):
  30.                 self._numerator = numerator.numerator
  31.                 self._denominator = numerator.denominator
  32.                 return self
  33.             if None(numerator, float):
  34.                 value = Fraction.from_float(numerator)
  35.                 self._numerator = value._numerator
  36.                 self._denominator = value._denominator
  37.                 return self
  38.             if None(numerator, Decimal):
  39.                 value = Fraction.from_decimal(numerator)
  40.                 self._numerator = value._numerator
  41.                 self._denominator = value._denominator
  42.                 return self
  43.             if None(numerator, basestring):
  44.                 m = _RATIONAL_FORMAT.match(numerator)
  45.                 if m is None:
  46.                     raise ValueError('Invalid literal for Fraction: %r' % numerator)
  47.                 if not m.group('num'):
  48.                     pass
  49.                 numerator = int('0')
  50.                 denom = m.group('denom')
  51.                 if denom:
  52.                     denominator = int(denom)
  53.                 else:
  54.                     denominator = 1
  55.                     decimal = m.group('decimal')
  56.                     if decimal:
  57.                         scale = 10 ** len(decimal)
  58.                         numerator = numerator * scale + int(decimal)
  59.                         denominator *= scale
  60.                     exp = m.group('exp')
  61.                     if exp:
  62.                         exp = int(exp)
  63.                         if exp >= 0:
  64.                             numerator *= 10 ** exp
  65.                         else:
  66.                             denominator *= 10 ** (-exp)
  67.                 if m.group('sign') == '-':
  68.                     numerator = -numerator
  69.                 
  70.             else:
  71.                 raise TypeError('argument should be a string or a Rational instance')
  72.         if isinstance(numerator, Rational) and isinstance(denominator, Rational):
  73.             numerator = numerator.numerator * denominator.denominator
  74.             denominator = denominator.numerator * numerator.denominator
  75.         else:
  76.             raise TypeError('both arguments should be Rational instances')
  77.         if None == 0:
  78.             raise ZeroDivisionError('Fraction(%s, 0)' % numerator)
  79.         g = gcd(numerator, denominator)
  80.         self._numerator = numerator // g
  81.         self._denominator = denominator // g
  82.         return self
  83.  
  84.     
  85.     def from_float(cls, f):
  86.         if isinstance(f, numbers.Integral):
  87.             return cls(f)
  88.         if not None(f, float):
  89.             raise TypeError('%s.from_float() only takes floats, not %r (%s)' % (cls.__name__, f, type(f).__name__))
  90.         if math.isnan(f) or math.isinf(f):
  91.             raise TypeError('Cannot convert %r to %s.' % (f, cls.__name__))
  92.         return cls(*f.as_integer_ratio())
  93.  
  94.     from_float = classmethod(from_float)
  95.     
  96.     def from_decimal(cls, dec):
  97.         Decimal = Decimal
  98.         import decimal
  99.         if isinstance(dec, numbers.Integral):
  100.             dec = Decimal(int(dec))
  101.         elif not isinstance(dec, Decimal):
  102.             raise TypeError('%s.from_decimal() only takes Decimals, not %r (%s)' % (cls.__name__, dec, type(dec).__name__))
  103.         if not dec.is_finite():
  104.             raise TypeError('Cannot convert %s to %s.' % (dec, cls.__name__))
  105.         (sign, digits, exp) = dec.as_tuple()
  106.         digits = int(''.join(map(str, digits)))
  107.         if sign:
  108.             digits = -digits
  109.         if exp >= 0:
  110.             return cls(digits * 10 ** exp)
  111.         return None(digits, 10 ** (-exp))
  112.  
  113.     from_decimal = classmethod(from_decimal)
  114.     
  115.     def limit_denominator(self, max_denominator = 1000000):
  116.         if max_denominator < 1:
  117.             raise ValueError('max_denominator should be at least 1')
  118.         if self._denominator <= max_denominator:
  119.             return Fraction(self)
  120.         (p0, q0, p1, q1) = None
  121.         n = self._numerator
  122.         d = self._denominator
  123.         while True:
  124.             a = n // d
  125.             q2 = q0 + a * q1
  126.             if q2 > max_denominator:
  127.                 break
  128.             (p0, q0, p1, q1) = (p1, q1, p0 + a * p1, q2)
  129.             n = d
  130.             d = n - a * d
  131.         k = (max_denominator - q0) // q1
  132.         bound1 = Fraction(p0 + k * p1, q0 + k * q1)
  133.         bound2 = Fraction(p1, q1)
  134.         if abs(bound2 - self) <= abs(bound1 - self):
  135.             return bound2
  136.         return None
  137.  
  138.     
  139.     def numerator(a):
  140.         return a._numerator
  141.  
  142.     numerator = property(numerator)
  143.     
  144.     def denominator(a):
  145.         return a._denominator
  146.  
  147.     denominator = property(denominator)
  148.     
  149.     def __repr__(self):
  150.         return 'Fraction(%s, %s)' % (self._numerator, self._denominator)
  151.  
  152.     
  153.     def __str__(self):
  154.         if self._denominator == 1:
  155.             return str(self._numerator)
  156.         return None % (self._numerator, self._denominator)
  157.  
  158.     
  159.     def _operator_fallbacks(monomorphic_operator, fallback_operator):
  160.         
  161.         def forward(a, b):
  162.             if isinstance(b, (int, long, Fraction)):
  163.                 return monomorphic_operator(a, b)
  164.             if None(b, float):
  165.                 return fallback_operator(float(a), b)
  166.             if None(b, complex):
  167.                 return fallback_operator(complex(a), b)
  168.             return None
  169.  
  170.         forward.__name__ = '__' + fallback_operator.__name__ + '__'
  171.         forward.__doc__ = monomorphic_operator.__doc__
  172.         
  173.         def reverse(b, a):
  174.             if isinstance(a, Rational):
  175.                 return monomorphic_operator(a, b)
  176.             if None(a, numbers.Real):
  177.                 return fallback_operator(float(a), float(b))
  178.             if None(a, numbers.Complex):
  179.                 return fallback_operator(complex(a), complex(b))
  180.             return None
  181.  
  182.         reverse.__name__ = '__r' + fallback_operator.__name__ + '__'
  183.         reverse.__doc__ = monomorphic_operator.__doc__
  184.         return (forward, reverse)
  185.  
  186.     
  187.     def _add(a, b):
  188.         return Fraction(a.numerator * b.denominator + b.numerator * a.denominator, a.denominator * b.denominator)
  189.  
  190.     (__add__, __radd__) = _operator_fallbacks(_add, operator.add)
  191.     
  192.     def _sub(a, b):
  193.         return Fraction(a.numerator * b.denominator - b.numerator * a.denominator, a.denominator * b.denominator)
  194.  
  195.     (__sub__, __rsub__) = _operator_fallbacks(_sub, operator.sub)
  196.     
  197.     def _mul(a, b):
  198.         return Fraction(a.numerator * b.numerator, a.denominator * b.denominator)
  199.  
  200.     (__mul__, __rmul__) = _operator_fallbacks(_mul, operator.mul)
  201.     
  202.     def _div(a, b):
  203.         return Fraction(a.numerator * b.denominator, a.denominator * b.numerator)
  204.  
  205.     (__truediv__, __rtruediv__) = _operator_fallbacks(_div, operator.truediv)
  206.     (__div__, __rdiv__) = _operator_fallbacks(_div, operator.div)
  207.     
  208.     def __floordiv__(a, b):
  209.         div = a / b
  210.         if isinstance(div, Rational):
  211.             return div.numerator // div.denominator
  212.         return None.floor(div)
  213.  
  214.     
  215.     def __rfloordiv__(b, a):
  216.         div = a / b
  217.         if isinstance(div, Rational):
  218.             return div.numerator // div.denominator
  219.         return None.floor(div)
  220.  
  221.     
  222.     def __mod__(a, b):
  223.         div = a // b
  224.         return a - b * div
  225.  
  226.     
  227.     def __rmod__(b, a):
  228.         div = a // b
  229.         return a - b * div
  230.  
  231.     
  232.     def __pow__(a, b):
  233.         if isinstance(b, Rational):
  234.             if b.denominator == 1:
  235.                 power = b.numerator
  236.                 if power >= 0:
  237.                     return Fraction(a._numerator ** power, a._denominator ** power)
  238.                 return None(a._denominator ** (-power), a._numerator ** (-power))
  239.             return float(a) ** float(b)
  240.         return float(a) ** b
  241.  
  242.     
  243.     def __rpow__(b, a):
  244.         if b._denominator == 1 and b._numerator >= 0:
  245.             return a ** b._numerator
  246.         if None(a, Rational):
  247.             return Fraction(a.numerator, a.denominator) ** b
  248.         if None._denominator == 1:
  249.             return a ** b._numerator
  250.         return None ** float(b)
  251.  
  252.     
  253.     def __pos__(a):
  254.         return Fraction(a._numerator, a._denominator)
  255.  
  256.     
  257.     def __neg__(a):
  258.         return Fraction(-(a._numerator), a._denominator)
  259.  
  260.     
  261.     def __abs__(a):
  262.         return Fraction(abs(a._numerator), a._denominator)
  263.  
  264.     
  265.     def __trunc__(a):
  266.         if a._numerator < 0:
  267.             return -(-(a._numerator) // a._denominator)
  268.         return None._numerator // a._denominator
  269.  
  270.     
  271.     def __hash__(self):
  272.         if self._denominator == 1:
  273.             return hash(self._numerator)
  274.         if None == float(self):
  275.             return hash(float(self))
  276.         return None((self._numerator, self._denominator))
  277.  
  278.     
  279.     def __eq__(a, b):
  280.         if isinstance(b, Rational):
  281.             if a._numerator == b.numerator:
  282.                 pass
  283.             return a._denominator == b.denominator
  284.         if None(b, numbers.Complex) and b.imag == 0:
  285.             b = b.real
  286.         if isinstance(b, float):
  287.             if math.isnan(b) or math.isinf(b):
  288.                 return 0 == b
  289.             return None == a.from_float(b)
  290.         return NotImplemented
  291.  
  292.     
  293.     def _richcmp(self, other, op):
  294.         if isinstance(other, Rational):
  295.             return op(self._numerator * other.denominator, self._denominator * other.numerator)
  296.         if None(other, complex):
  297.             raise TypeError('no ordering relation is defined for complex numbers')
  298.         if isinstance(other, float):
  299.             if math.isnan(other) or math.isinf(other):
  300.                 return op(0, other)
  301.             return None(self, self.from_float(other))
  302.         return NotImplemented
  303.  
  304.     
  305.     def __lt__(a, b):
  306.         return a._richcmp(b, operator.lt)
  307.  
  308.     
  309.     def __gt__(a, b):
  310.         return a._richcmp(b, operator.gt)
  311.  
  312.     
  313.     def __le__(a, b):
  314.         return a._richcmp(b, operator.le)
  315.  
  316.     
  317.     def __ge__(a, b):
  318.         return a._richcmp(b, operator.ge)
  319.  
  320.     
  321.     def __nonzero__(a):
  322.         return a._numerator != 0
  323.  
  324.     
  325.     def __reduce__(self):
  326.         return (self.__class__, (str(self),))
  327.  
  328.     
  329.     def __copy__(self):
  330.         if type(self) == Fraction:
  331.             return self
  332.         return None.__class__(self._numerator, self._denominator)
  333.  
  334.     
  335.     def __deepcopy__(self, memo):
  336.         if type(self) == Fraction:
  337.             return self
  338.         return None.__class__(self._numerator, self._denominator)
  339.  
  340.  
  341.