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