AppPkg/Applications/Python/Python-2.7.2/Lib/fractions.py

   1 # Originally contributed by Sjoerd Mullender.
   2 # Significantly modified by Jeffrey Yasskin <jyasskin at gmail.com>.
   3
   4 """Rational, infinite-precision, real numbers."""
   5
   6 from __future__ import division
   7 from decimal import Decimal
   8 import math
   9 import numbers
  10 import operator
  11 import re
  12
  13 __all__ = ['Fraction', 'gcd']
  14
  15 Rational = numbers.Rational
  16
  17
  18 def gcd(a, b):
  19     """Calculate the Greatest Common Divisor of a and b.
  20
  21     Unless b==0, the result will have the same sign as b (so that when
  22     b is divided by it, the result comes out positive).
  23     """
  24     while b:
  25         a, b = b, a%b
  26     return a
  27
  28
  29 _RATIONAL_FORMAT = re.compile(r"""
  30     \A\s*                      # optional whitespace at the start, then
  31     (?P<sign>[-+]?)            # an optional sign, then
  32     (?=\d|\.\d)                # lookahead for digit or .digit
  33     (?P<num>\d*)               # numerator (possibly empty)
  34     (?:                        # followed by
  35        (?:/(?P<denom>\d+))?    # an optional denominator
  36     |                          # or
  37        (?:\.(?P<decimal>\d*))? # an optional fractional part
  38        (?:E(?P<exp>[-+]?\d+))? # and optional exponent
  39     )
  40     \s*\Z                      # and optional whitespace to finish
  41 """, re.VERBOSE | re.IGNORECASE)
  42
  43
  44 class Fraction(Rational):
  45     """This class implements rational numbers.
  46
  47     In the two-argument form of the constructor, Fraction(8, 6) will
  48     produce a rational number equivalent to 4/3. Both arguments must
  49     be Rational. The numerator defaults to 0 and the denominator
  50     defaults to 1 so that Fraction(3) == 3 and Fraction() == 0.
  51
  52     Fractions can also be constructed from:
  53
  54       - numeric strings similar to those accepted by the
  55         float constructor (for example, '-2.3' or '1e10')
  56
  57       - strings of the form '123/456'
  58
  59       - float and Decimal instances
  60
  61       - other Rational instances (including integers)
  62
  63     """
  64
  65     __slots__ = ('_numerator', '_denominator')
  66
  67     # We're immutable, so use __new__ not __init__
  68     def __new__(cls, numerator=0, denominator=None):
  69         """Constructs a Fraction.
  70
  71         Takes a string like '3/2' or '1.5', another Rational instance, a
  72         numerator/denominator pair, or a float.
  73
  74         Examples
  75         --------
  76
  77         >>> Fraction(10, -8)
  78         Fraction(-5, 4)
  79         >>> Fraction(Fraction(1, 7), 5)
  80         Fraction(1, 35)
  81         >>> Fraction(Fraction(1, 7), Fraction(2, 3))
  82         Fraction(3, 14)
  83         >>> Fraction('314')
  84         Fraction(314, 1)
  85         >>> Fraction('-35/4')
  86         Fraction(-35, 4)
  87         >>> Fraction('3.1415') # conversion from numeric string
  88         Fraction(6283, 2000)
  89         >>> Fraction('-47e-2') # string may include a decimal exponent
  90         Fraction(-47, 100)
  91         >>> Fraction(1.47)  # direct construction from float (exact conversion)
  92         Fraction(6620291452234629, 4503599627370496)
  93         >>> Fraction(2.25)
  94         Fraction(9, 4)
  95         >>> Fraction(Decimal('1.47'))
  96         Fraction(147, 100)
  97
  98         """
  99         self = super(Fraction, cls).__new__(cls)
 100
 101         if denominator is None:
 102             if isinstance(numerator, Rational):
 103                 self._numerator = numerator.numerator
 104                 self._denominator = numerator.denominator
 105                 return self
 106
 107             elif isinstance(numerator, float):
 108                 # Exact conversion from float
 109                 value = Fraction.from_float(numerator)
 110                 self._numerator = value._numerator
 111                 self._denominator = value._denominator
 112                 return self
 113
 114             elif isinstance(numerator, Decimal):
 115                 value = Fraction.from_decimal(numerator)
 116                 self._numerator = value._numerator
 117                 self._denominator = value._denominator
 118                 return self
 119
 120             elif isinstance(numerator, basestring):
 121                 # Handle construction from strings.
 122                 m = _RATIONAL_FORMAT.match(numerator)
 123                 if m is None:
 124                     raise ValueError('Invalid literal for Fraction: %r' %
 125                                      numerator)
 126                 numerator = int(m.group('num') or '0')
 127                 denom = m.group('denom')
 128                 if denom:
 129                     denominator = int(denom)
 130                 else:
 131                     denominator = 1
 132                     decimal = m.group('decimal')
 133                     if decimal:
 134                         scale = 10**len(decimal)
 135                         numerator = numerator * scale + int(decimal)
 136                         denominator *= scale
 137                     exp = m.group('exp')
 138                     if exp:
 139                         exp = int(exp)
 140                         if exp >= 0:
 141                             numerator *= 10**exp
 142                         else:
 143                             denominator *= 10**-exp
 144                 if m.group('sign') == '-':
 145                     numerator = -numerator
 146
 147             else:
 148                 raise TypeError("argument should be a string "
 149                                 "or a Rational instance")
 150
 151         elif (isinstance(numerator, Rational) and
 152             isinstance(denominator, Rational)):
 153             numerator, denominator = (
 154                 numerator.numerator * denominator.denominator,
 155                 denominator.numerator * numerator.denominator
 156                 )
 157         else:
 158             raise TypeError("both arguments should be "
 159                             "Rational instances")
 160
 161         if denominator == 0:
 162             raise ZeroDivisionError('Fraction(%s, 0)' % numerator)
 163         g = gcd(numerator, denominator)
 164         self._numerator = numerator // g
 165         self._denominator = denominator // g
 166         return self
 167
 168     @classmethod
 169     def from_float(cls, f):
 170         """Converts a finite float to a rational number, exactly.
 171
 172         Beware that Fraction.from_float(0.3) != Fraction(3, 10).
 173
 174         """
 175         if isinstance(f, numbers.Integral):
 176             return cls(f)
 177         elif not isinstance(f, float):
 178             raise TypeError("%s.from_float() only takes floats, not %r (%s)" %
 179                             (cls.__name__, f, type(f).__name__))
 180         if math.isnan(f) or math.isinf(f):
 181             raise TypeError("Cannot convert %r to %s." % (f, cls.__name__))
 182         return cls(*f.as_integer_ratio())
 183
 184     @classmethod
 185     def from_decimal(cls, dec):
 186         """Converts a finite Decimal instance to a rational number, exactly."""
 187         from decimal import Decimal
 188         if isinstance(dec, numbers.Integral):
 189             dec = Decimal(int(dec))
 190         elif not isinstance(dec, Decimal):
 191             raise TypeError(
 192                 "%s.from_decimal() only takes Decimals, not %r (%s)" %
 193                 (cls.__name__, dec, type(dec).__name__))
 194         if not dec.is_finite():
 195             # Catches infinities and nans.
 196             raise TypeError("Cannot convert %s to %s." % (dec, cls.__name__))
 197         sign, digits, exp = dec.as_tuple()
 198         digits = int(''.join(map(str, digits)))
 199         if sign:
 200             digits = -digits
 201         if exp >= 0:
 202             return cls(digits * 10 ** exp)
 203         else:
 204             return cls(digits, 10 ** -exp)
 205
 206     def limit_denominator(self, max_denominator=1000000):
 207         """Closest Fraction to self with denominator at most max_denominator.
 208
 209         >>> Fraction('3.141592653589793').limit_denominator(10)
 210         Fraction(22, 7)
 211         >>> Fraction('3.141592653589793').limit_denominator(100)
 212         Fraction(311, 99)
 213         >>> Fraction(4321, 8765).limit_denominator(10000)
 214         Fraction(4321, 8765)
 215
 216         """
 217         # Algorithm notes: For any real number x, define a *best upper
 218         # approximation* to x to be a rational number p/q such that:
 219         #
 220         #   (1) p/q >= x, and
 221         #   (2) if p/q > r/s >= x then s > q, for any rational r/s.
 222         #
 223         # Define *best lower approximation* similarly.  Then it can be
 224         # proved that a rational number is a best upper or lower
 225         # approximation to x if, and only if, it is a convergent or
 226         # semiconvergent of the (unique shortest) continued fraction
 227         # associated to x.
 228         #
 229         # To find a best rational approximation with denominator <= M,
 230         # we find the best upper and lower approximations with
 231         # denominator <= M and take whichever of these is closer to x.
 232         # In the event of a tie, the bound with smaller denominator is
 233         # chosen.  If both denominators are equal (which can happen
 234         # only when max_denominator == 1 and self is midway between
 235         # two integers) the lower bound---i.e., the floor of self, is
 236         # taken.
 237
 238         if max_denominator < 1:
 239             raise ValueError("max_denominator should be at least 1")
 240         if self._denominator <= max_denominator:
 241             return Fraction(self)
 242
 243         p0, q0, p1, q1 = 0, 1, 1, 0
 244         n, d = self._numerator, self._denominator
 245         while True:
 246             a = n//d
 247             q2 = q0+a*q1
 248             if q2 > max_denominator:
 249                 break
 250             p0, q0, p1, q1 = p1, q1, p0+a*p1, q2
 251             n, d = d, n-a*d
 252
 253         k = (max_denominator-q0)//q1
 254         bound1 = Fraction(p0+k*p1, q0+k*q1)
 255         bound2 = Fraction(p1, q1)
 256         if abs(bound2 - self) <= abs(bound1-self):
 257             return bound2
 258         else:
 259             return bound1
 260
 261     @property
 262     def numerator(a):
 263         return a._numerator
 264
 265     @property
 266     def denominator(a):
 267         return a._denominator
 268
 269     def __repr__(self):
 270         """repr(self)"""
 271         return ('Fraction(%s, %s)' % (self._numerator, self._denominator))
 272
 273     def __str__(self):
 274         """str(self)"""
 275         if self._denominator == 1:
 276             return str(self._numerator)
 277         else:
 278             return '%s/%s' % (self._numerator, self._denominator)
 279
 280     def _operator_fallbacks(monomorphic_operator, fallback_operator):
 281         """Generates forward and reverse operators given a purely-rational
 282         operator and a function from the operator module.
 283
 284         Use this like:
 285         __op__, __rop__ = _operator_fallbacks(just_rational_op, operator.op)
 286
 287         In general, we want to implement the arithmetic operations so
 288         that mixed-mode operations either call an implementation whose
 289         author knew about the types of both arguments, or convert both
 290         to the nearest built in type and do the operation there. In
 291         Fraction, that means that we define __add__ and __radd__ as:
 292
 293             def __add__(self, other):
 294                 # Both types have numerators/denominator attributes,
 295                 # so do the operation directly
 296                 if isinstance(other, (int, long, Fraction)):
 297                     return Fraction(self.numerator * other.denominator +
 298                                     other.numerator * self.denominator,
 299                                     self.denominator * other.denominator)
 300                 # float and complex don't have those operations, but we
 301                 # know about those types, so special case them.
 302                 elif isinstance(other, float):
 303                     return float(self) + other
 304                 elif isinstance(other, complex):
 305                     return complex(self) + other
 306                 # Let the other type take over.
 307                 return NotImplemented
 308
 309             def __radd__(self, other):
 310                 # radd handles more types than add because there's
 311                 # nothing left to fall back to.
 312                 if isinstance(other, Rational):
 313                     return Fraction(self.numerator * other.denominator +
 314                                     other.numerator * self.denominator,
 315                                     self.denominator * other.denominator)
 316                 elif isinstance(other, Real):
 317                     return float(other) + float(self)
 318                 elif isinstance(other, Complex):
 319                     return complex(other) + complex(self)
 320                 return NotImplemented
 321
 322
 323         There are 5 different cases for a mixed-type addition on
 324         Fraction. I'll refer to all of the above code that doesn't
 325         refer to Fraction, float, or complex as "boilerplate". 'r'
 326         will be an instance of Fraction, which is a subtype of
 327         Rational (r : Fraction <: Rational), and b : B <:
 328         Complex. The first three involve 'r + b':
 329
 330             1. If B <: Fraction, int, float, or complex, we handle
 331                that specially, and all is well.
 332             2. If Fraction falls back to the boilerplate code, and it
 333                were to return a value from __add__, we'd miss the
 334                possibility that B defines a more intelligent __radd__,
 335                so the boilerplate should return NotImplemented from
 336                __add__. In particular, we don't handle Rational
 337                here, even though we could get an exact answer, in case
 338                the other type wants to do something special.
 339             3. If B <: Fraction, Python tries B.__radd__ before
 340                Fraction.__add__. This is ok, because it was
 341                implemented with knowledge of Fraction, so it can
 342                handle those instances before delegating to Real or
 343                Complex.
 344
 345         The next two situations describe 'b + r'. We assume that b
 346         didn't know about Fraction in its implementation, and that it
 347         uses similar boilerplate code:
 348
 349             4. If B <: Rational, then __radd_ converts both to the
 350                builtin rational type (hey look, that's us) and
 351                proceeds.
 352             5. Otherwise, __radd__ tries to find the nearest common
 353                base ABC, and fall back to its builtin type. Since this
 354                class doesn't subclass a concrete type, there's no
 355                implementation to fall back to, so we need to try as
 356                hard as possible to return an actual value, or the user
 357                will get a TypeError.
 358
 359         """
 360         def forward(a, b):
 361             if isinstance(b, (int, long, Fraction)):
 362                 return monomorphic_operator(a, b)
 363             elif isinstance(b, float):
 364                 return fallback_operator(float(a), b)
 365             elif isinstance(b, complex):
 366                 return fallback_operator(complex(a), b)
 367             else:
 368                 return NotImplemented
 369         forward.__name__ = '__' + fallback_operator.__name__ + '__'
 370         forward.__doc__ = monomorphic_operator.__doc__
 371
 372         def reverse(b, a):
 373             if isinstance(a, Rational):
 374                 # Includes ints.
 375                 return monomorphic_operator(a, b)
 376             elif isinstance(a, numbers.Real):
 377                 return fallback_operator(float(a), float(b))
 378             elif isinstance(a, numbers.Complex):
 379                 return fallback_operator(complex(a), complex(b))
 380             else:
 381                 return NotImplemented
 382         reverse.__name__ = '__r' + fallback_operator.__name__ + '__'
 383         reverse.__doc__ = monomorphic_operator.__doc__
 384
 385         return forward, reverse
 386
 387     def _add(a, b):
 388         """a + b"""
 389         return Fraction(a.numerator * b.denominator +
 390                         b.numerator * a.denominator,
 391                         a.denominator * b.denominator)
 392
 393     __add__, __radd__ = _operator_fallbacks(_add, operator.add)
 394
 395     def _sub(a, b):
 396         """a - b"""
 397         return Fraction(a.numerator * b.denominator -
 398                         b.numerator * a.denominator,
 399                         a.denominator * b.denominator)
 400
 401     __sub__, __rsub__ = _operator_fallbacks(_sub, operator.sub)
 402
 403     def _mul(a, b):
 404         """a * b"""
 405         return Fraction(a.numerator * b.numerator, a.denominator * b.denominator)
 406
 407     __mul__, __rmul__ = _operator_fallbacks(_mul, operator.mul)
 408
 409     def _div(a, b):
 410         """a / b"""
 411         return Fraction(a.numerator * b.denominator,
 412                         a.denominator * b.numerator)
 413
 414     __truediv__, __rtruediv__ = _operator_fallbacks(_div, operator.truediv)
 415     __div__, __rdiv__ = _operator_fallbacks(_div, operator.div)
 416
 417     def __floordiv__(a, b):
 418         """a // b"""
 419         # Will be math.floor(a / b) in 3.0.
 420         div = a / b
 421         if isinstance(div, Rational):
 422             # trunc(math.floor(div)) doesn't work if the rational is
 423             # more precise than a float because the intermediate
 424             # rounding may cross an integer boundary.
 425             return div.numerator // div.denominator
 426         else:
 427             return math.floor(div)
 428
 429     def __rfloordiv__(b, a):
 430         """a // b"""
 431         # Will be math.floor(a / b) in 3.0.
 432         div = a / b
 433         if isinstance(div, Rational):
 434             # trunc(math.floor(div)) doesn't work if the rational is
 435             # more precise than a float because the intermediate
 436             # rounding may cross an integer boundary.
 437             return div.numerator // div.denominator
 438         else:
 439             return math.floor(div)
 440
 441     def __mod__(a, b):
 442         """a % b"""
 443         div = a // b
 444         return a - b * div
 445
 446     def __rmod__(b, a):
 447         """a % b"""
 448         div = a // b
 449         return a - b * div
 450
 451     def __pow__(a, b):
 452         """a ** b
 453
 454         If b is not an integer, the result will be a float or complex
 455         since roots are generally irrational. If b is an integer, the
 456         result will be rational.
 457
 458         """
 459         if isinstance(b, Rational):
 460             if b.denominator == 1:
 461                 power = b.numerator
 462                 if power >= 0:
 463                     return Fraction(a._numerator ** power,
 464                                     a._denominator ** power)
 465                 else:
 466                     return Fraction(a._denominator ** -power,
 467                                     a._numerator ** -power)
 468             else:
 469                 # A fractional power will generally produce an
 470                 # irrational number.
 471                 return float(a) ** float(b)
 472         else:
 473             return float(a) ** b
 474
 475     def __rpow__(b, a):
 476         """a ** b"""
 477         if b._denominator == 1 and b._numerator >= 0:
 478             # If a is an int, keep it that way if possible.
 479             return a ** b._numerator
 480
 481         if isinstance(a, Rational):
 482             return Fraction(a.numerator, a.denominator) ** b
 483
 484         if b._denominator == 1:
 485             return a ** b._numerator
 486
 487         return a ** float(b)
 488
 489     def __pos__(a):
 490         """+a: Coerces a subclass instance to Fraction"""
 491         return Fraction(a._numerator, a._denominator)
 492
 493     def __neg__(a):
 494         """-a"""
 495         return Fraction(-a._numerator, a._denominator)
 496
 497     def __abs__(a):
 498         """abs(a)"""
 499         return Fraction(abs(a._numerator), a._denominator)
 500
 501     def __trunc__(a):
 502         """trunc(a)"""
 503         if a._numerator < 0:
 504             return -(-a._numerator // a._denominator)
 505         else:
 506             return a._numerator // a._denominator
 507
 508     def __hash__(self):
 509         """hash(self)
 510
 511         Tricky because values that are exactly representable as a
 512         float must have the same hash as that float.
 513
 514         """
 515         # XXX since this method is expensive, consider caching the result
 516         if self._denominator == 1:
 517             # Get integers right.
 518             return hash(self._numerator)
 519         # Expensive check, but definitely correct.
 520         if self == float(self):
 521             return hash(float(self))
 522         else:
 523             # Use tuple's hash to avoid a high collision rate on
 524             # simple fractions.
 525             return hash((self._numerator, self._denominator))
 526
 527     def __eq__(a, b):
 528         """a == b"""
 529         if isinstance(b, Rational):
 530             return (a._numerator == b.numerator and
 531                     a._denominator == b.denominator)
 532         if isinstance(b, numbers.Complex) and b.imag == 0:
 533             b = b.real
 534         if isinstance(b, float):
 535             if math.isnan(b) or math.isinf(b):
 536                 # comparisons with an infinity or nan should behave in
 537                 # the same way for any finite a, so treat a as zero.
 538                 return 0.0 == b
 539             else:
 540                 return a == a.from_float(b)
 541         else:
 542             # Since a doesn't know how to compare with b, let's give b
 543             # a chance to compare itself with a.
 544             return NotImplemented
 545
 546     def _richcmp(self, other, op):
 547         """Helper for comparison operators, for internal use only.
 548
 549         Implement comparison between a Rational instance `self`, and
 550         either another Rational instance or a float `other`.  If
 551         `other` is not a Rational instance or a float, return
 552         NotImplemented. `op` should be one of the six standard
 553         comparison operators.
 554
 555         """
 556         # convert other to a Rational instance where reasonable.
 557         if isinstance(other, Rational):
 558             return op(self._numerator * other.denominator,
 559                       self._denominator * other.numerator)
 560         # comparisons with complex should raise a TypeError, for consistency
 561         # with int<->complex, float<->complex, and complex<->complex comparisons.
 562         if isinstance(other, complex):
 563             raise TypeError("no ordering relation is defined for complex numbers")
 564         if isinstance(other, float):
 565             if math.isnan(other) or math.isinf(other):
 566                 return op(0.0, other)
 567             else:
 568                 return op(self, self.from_float(other))
 569         else:
 570             return NotImplemented
 571
 572     def __lt__(a, b):
 573         """a < b"""
 574         return a._richcmp(b, operator.lt)
 575
 576     def __gt__(a, b):
 577         """a > b"""
 578         return a._richcmp(b, operator.gt)
 579
 580     def __le__(a, b):
 581         """a <= b"""
 582         return a._richcmp(b, operator.le)
 583
 584     def __ge__(a, b):
 585         """a >= b"""
 586         return a._richcmp(b, operator.ge)
 587
 588     def __nonzero__(a):
 589         """a != 0"""
 590         return a._numerator != 0
 591
 592     # support for pickling, copy, and deepcopy
 593
 594     def __reduce__(self):
 595         return (self.__class__, (str(self),))
 596
 597     def __copy__(self):
 598         if type(self) == Fraction:
 599             return self     # I'm immutable; therefore I am my own clone
 600         return self.__class__(self._numerator, self._denominator)
 601
 602     def __deepcopy__(self, memo):
 603         if type(self) == Fraction:
 604             return self     # My components are also immutable
 605         return self.__class__(self._numerator, self._denominator)