ó
|
L\¬Qc @ sª d Z d d l m Z d d l m Z d d l Z d d l Z d d l Z d d l Z d d g Z e j
|
Z
|
d Z e j d e j e j B Z d e
|
f d YZ d S(
|
s+ Rational, infinite-precision, real numbers.iÿÿÿÿ( t division( t DecimalNt Fractiont gcdc C s" x | r | | | } } q W| S( s¶ Calculate the Greatest Common Divisor of a and b.
|
|
Unless b==0, the result will have the same sign as b (so that when
|
b is divided by it, the result comes out positive).
|
( ( t at b( ( sQ /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/fractions.pyR s sC
|
\A\s* # optional whitespace at the start, then
|
(?P<sign>[-+]?) # an optional sign, then
|
(?=\d|\.\d) # lookahead for digit or .digit
|
(?P<num>\d*) # numerator (possibly empty)
|
(?: # followed by
|
(?:/(?P<denom>\d+))? # an optional denominator
|
| # or
|
(?:\.(?P<decimal>\d*))? # an optional fractional part
|
(?:E(?P<exp>[-+]?\d+))? # and optional exponent
|
)
|
\s*\Z # and optional whitespace to finish
|
c B sß e Z d Z d' Z d d( d Z e d Z e d Z d d Z e
|
d Z e
|
d
|
Z d Z d Z d Z d Z e e e j \ Z Z d Z e e e j \ Z Z d Z e e e j \ Z Z d Z e e e j \ Z Z e e e j! \ Z" Z# d Z$ d Z% d Z& d Z' d Z( d Z) d Z* d Z+ d Z, d Z- d Z. d Z/ d Z0 d Z1 d Z2 d! Z3 d" Z4 d# Z5 d$ Z6 d% Z7 d& Z8 RS() s] This class implements rational numbers.
|
|
In the two-argument form of the constructor, Fraction(8, 6) will
|
produce a rational number equivalent to 4/3. Both arguments must
|
be Rational. The numerator defaults to 0 and the denominator
|
defaults to 1 so that Fraction(3) == 3 and Fraction() == 0.
|
|
Fractions can also be constructed from:
|
|
- numeric strings similar to those accepted by the
|
float constructor (for example, '-2.3' or '1e10')
|
|
- strings of the form '123/456'
|
|
- float and Decimal instances
|
|
- other Rational instances (including integers)
|
|
t
|
_numeratort _denominatori c C s¦ t t | j | } | d k r t | t rO | j | _ | j | _ | St | t
|
r t j | } | j | _ | j | _ | St | t rà t j | } | j | _ | j | _ | St | t rýt j | } | d k r t d | n t | j d pd } | j d } | r?t | } n d } | j d } | rd t | } | | t | } | | 9} n | j d } | rÛt | } | d k rÉ| d | 9} qÛ| d | 9} n | j d
|
d k r | } q qZt d nN t | t rNt | t rN| j | j | j | j } } n t d | d k ryt d | n t | | }
|
| |
|
| _ | |
|
| _ | S( s£ Constructs a Fraction.
|
|
Takes a string like '3/2' or '1.5', another Rational instance, a
|
numerator/denominator pair, or a float.
|
|
Examples
|
--------
|
|
>>> Fraction(10, -8)
|
Fraction(-5, 4)
|
>>> Fraction(Fraction(1, 7), 5)
|
Fraction(1, 35)
|
>>> Fraction(Fraction(1, 7), Fraction(2, 3))
|
Fraction(3, 14)
|
>>> Fraction('314')
|
Fraction(314, 1)
|
>>> Fraction('-35/4')
|
Fraction(-35, 4)
|
>>> Fraction('3.1415') # conversion from numeric string
|
Fraction(6283, 2000)
|
>>> Fraction('-47e-2') # string may include a decimal exponent
|
Fraction(-47, 100)
|
>>> Fraction(1.47) # direct construction from float (exact conversion)
|
Fraction(6620291452234629, 4503599627370496)
|
>>> Fraction(2.25)
|
Fraction(9, 4)
|
>>> Fraction(Decimal('1.47'))
|
Fraction(147, 100)
|
|
s Invalid literal for Fraction: %rt numt 0t denomi t decimali
|
t expi t signt -s2 argument should be a string or a Rational instances+ both arguments should be Rational instancess Fraction(%s, 0)N( t superR t __new__t Nonet
|
isinstancet Rationalt numeratorR t denominatorR t floatt
|
from_floatR t from_decimalt
|
basestringt _RATIONAL_FORMATt matcht
|
ValueErrort intt groupt lent TypeErrort ZeroDivisionErrorR ( t clsR R t selft valuet mR
|
R t scaleR t g( ( sQ /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/fractions.pyR D sf c C s t | t j r | | St | t sS t d | j | t | j f n t j | sq t j | r t d | | j f n | | j
|
S( s Converts a finite float to a rational number, exactly.
|
|
Beware that Fraction.from_float(0.3) != Fraction(3, 10).
|
|
s. %s.from_float() only takes floats, not %r (%s)s Cannot convert %r to %s.( R t numberst IntegralR R t __name__t typet matht isnant isinft as_integer_ratio( R" t f( ( sQ /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/fractions.pyR ¨ s
|
" c C s d d l m } t | t j r7 | t | } n7 t | | sn t d | j | t | j f n | j s t d | | j f n | j
|
\ } } } t d j t t | } | rÙ | } n | d k r÷ | | d | S| | d | Sd S( sA Converts a finite Decimal instance to a rational number, exactly.iÿÿÿÿ( R s2 %s.from_decimal() only takes Decimals, not %r (%s)s Cannot convert %s to %s.t i i
|
N( R R R R( R) R R R* R+ t is_finitet as_tuplet joint mapt str( R" t decR R t digitsR ( ( sQ /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/fractions.pyR ¸ s "
|
i@B c C s1 | d k r t d n | j | k r4 t | Sd \ } } } } | j | j } } xm t rÈ | | } | | | } | | k r Pn | | | | | | f \ } } } } | | | | } } q\ W| | | }
|
t | |
|
| | |
|
| } t | | } t | | t | | k r)| S| Sd S( sW Closest Fraction to self with denominator at most max_denominator.
|
|
>>> Fraction('3.141592653589793').limit_denominator(10)
|
Fraction(22, 7)
|
>>> Fraction('3.141592653589793').limit_denominator(100)
|
Fraction(311, 99)
|
>>> Fraction(4321, 8765).limit_denominator(10000)
|
Fraction(4321, 8765)
|
|
i s$ max_denominator should be at least 1i N( i i i i ( R R R R t Truet abs( R# t max_denominatort p0t q0t p1t q1t nt dR t q2t kt bound1t bound2( ( sQ /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/fractions.pyt limit_denominatorÎ s&
|
|
& c C s | j S( N( R ( R ( ( sQ /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/fractions.pyR s c C s | j S( N( R ( R ( ( sQ /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/fractions.pyR s c C s d | j | j f S( s
|
repr(self)s Fraction(%s, %s)( R R ( R# ( ( sQ /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/fractions.pyt __repr__ s c C s4 | j d k r t | j Sd | j | j f Sd S( s str(self)i s %s/%sN( R R6 R ( R# ( ( sQ /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/fractions.pyt __str__ s c sn f d } d j d | _ j | _ f d } d j d | _ j | _ | | f S( sÓ Generates forward and reverse operators given a purely-rational
|
operator and a function from the operator module.
|
|
Use this like:
|
__op__, __rop__ = _operator_fallbacks(just_rational_op, operator.op)
|
|
In general, we want to implement the arithmetic operations so
|
that mixed-mode operations either call an implementation whose
|
author knew about the types of both arguments, or convert both
|
to the nearest built in type and do the operation there. In
|
Fraction, that means that we define __add__ and __radd__ as:
|
|
def __add__(self, other):
|
# Both types have numerators/denominator attributes,
|
# so do the operation directly
|
if isinstance(other, (int, long, Fraction)):
|
return Fraction(self.numerator * other.denominator +
|
other.numerator * self.denominator,
|
self.denominator * other.denominator)
|
# float and complex don't have those operations, but we
|
# know about those types, so special case them.
|
elif isinstance(other, float):
|
return float(self) + other
|
elif isinstance(other, complex):
|
return complex(self) + other
|
# Let the other type take over.
|
return NotImplemented
|
|
def __radd__(self, other):
|
# radd handles more types than add because there's
|
# nothing left to fall back to.
|
if isinstance(other, Rational):
|
return Fraction(self.numerator * other.denominator +
|
other.numerator * self.denominator,
|
self.denominator * other.denominator)
|
elif isinstance(other, Real):
|
return float(other) + float(self)
|
elif isinstance(other, Complex):
|
return complex(other) + complex(self)
|
return NotImplemented
|
|
|
There are 5 different cases for a mixed-type addition on
|
Fraction. I'll refer to all of the above code that doesn't
|
refer to Fraction, float, or complex as "boilerplate". 'r'
|
will be an instance of Fraction, which is a subtype of
|
Rational (r : Fraction <: Rational), and b : B <:
|
Complex. The first three involve 'r + b':
|
|
1. If B <: Fraction, int, float, or complex, we handle
|
that specially, and all is well.
|
2. If Fraction falls back to the boilerplate code, and it
|
were to return a value from __add__, we'd miss the
|
possibility that B defines a more intelligent __radd__,
|
so the boilerplate should return NotImplemented from
|
__add__. In particular, we don't handle Rational
|
here, even though we could get an exact answer, in case
|
the other type wants to do something special.
|
3. If B <: Fraction, Python tries B.__radd__ before
|
Fraction.__add__. This is ok, because it was
|
implemented with knowledge of Fraction, so it can
|
handle those instances before delegating to Real or
|
Complex.
|
|
The next two situations describe 'b + r'. We assume that b
|
didn't know about Fraction in its implementation, and that it
|
uses similar boilerplate code:
|
|
4. If B <: Rational, then __radd_ converts both to the
|
builtin rational type (hey look, that's us) and
|
proceeds.
|
5. Otherwise, __radd__ tries to find the nearest common
|
base ABC, and fall back to its builtin type. Since this
|
class doesn't subclass a concrete type, there's no
|
implementation to fall back to, so we need to try as
|
hard as possible to return an actual value, or the user
|
will get a TypeError.
|
|
c sq t | t t t f r% | | St | t rG t | | St | t ri t | | St Sd S( N( R R t longR R t complext NotImplemented( R R ( t fallback_operatort monomorphic_operator( sQ /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/fractions.pyt forwardh s t __c sz t | t r | | St | t j rG t | t | St | t j rr t | t | St Sd S( N( R R R( t RealR t ComplexRJ RK ( R R ( RL RM ( sQ /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/fractions.pyt reverset s t __r( R* t __doc__( RM RL RN RR ( ( RL RM sQ /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/fractions.pyt _operator_fallbacks s P
|
c C s/ t | j | j | j | j | j | j S( s a + b( R R R ( R R ( ( sQ /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/fractions.pyt _add s c C s/ t | j | j | j | j | j | j S( s a - b( R R R ( R R ( ( sQ /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/fractions.pyt _sub s c C s! t | j | j | j | j S( s a * b( R R R ( R R ( ( sQ /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/fractions.pyt _mul s c C s! t | j | j | j | j S( s a / b( R R R ( R R ( ( sQ /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/fractions.pyt _div s c C s8 | | } t | t r' | j | j St j | Sd S( s a // bN( R R R R R, t floor( R R t div( ( sQ /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/fractions.pyt __floordiv__¡ s
|
c C s8 | | } t | t r' | j | j St j | Sd S( s a // bN( R R R R R, RZ ( R R R[ ( ( sQ /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/fractions.pyt __rfloordiv__ s
|
c C s | | } | | | S( s a % b( ( R R R[ ( ( sQ /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/fractions.pyt __mod__¹ s
|
c C s | | } | | | S( s a % b( ( R R R[ ( ( sQ /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/fractions.pyt __rmod__¾ s
|
c C s t | t r
| j d k rn | j } | d k rN t | j | | j | St | j | | j | Sq t | t | Sn t | | Sd S( s¾ a ** b
|
|
If b is not an integer, the result will be a float or complex
|
since roots are generally irrational. If b is an integer, the
|
result will be rational.
|
|
i i N( R R R R R R R R ( R R t power( ( sQ /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/fractions.pyt __pow__Ã s c C sw | j d k r) | j d k r) | | j St | t rO t | j | j | S| j d k ri | | j S| t | S( s a ** bi i ( R R R R R R R R ( R R ( ( sQ /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/fractions.pyt __rpow__Û s c C s t | j | j S( s+ +a: Coerces a subclass instance to Fraction( R R R ( R ( ( sQ /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/fractions.pyt __pos__é s c C s t | j | j S( s -a( R R R ( R ( ( sQ /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/fractions.pyt __neg__í s c C s t t | j | j S( s abs(a)( R R: R R ( R ( ( sQ /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/fractions.pyt __abs__ñ s c C s1 | j d k r | j | j S| j | j Sd S( s trunc(a)i N( R R ( R ( ( sQ /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/fractions.pyt __trunc__õ s c C sX | j d k r t | j S| t | k r> t t | St | j | j f Sd S( s hash(self)
|
|
Tricky because values that are exactly representable as a
|
float must have the same hash as that float.
|
|
i N( R t hashR R ( R# ( ( sQ /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/fractions.pyt __hash__ü s
|
c C s³ t | t r1 | j | j k o0 | j | j k St | t j r^ | j d k r^ | j } n t | t
|
r« t j | s t j | r d | k S| | j | k Sn t Sd S( s a == bi g N( R R R R R R R( RQ t imagt realR R, R- R. R RK ( R R ( ( sQ /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/fractions.pyt __eq__ s !
|
c C s© t | t r0 | | j | j | j | j St | t rN t d n t | t r¡ t j
|
| s{ t j | r | d | S| | | j | Sn t Sd S( sc Helper for comparison operators, for internal use only.
|
|
Implement comparison between a Rational instance `self`, and
|
either another Rational instance or a float `other`. If
|
`other` is not a Rational instance or a float, return
|
NotImplemented. `op` should be one of the six standard
|
comparison operators.
|
|
s3 no ordering relation is defined for complex numbersg N( R R R R R R RJ R R R, R- R. R RK ( R# t othert op( ( sQ /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/fractions.pyt _richcmp" s c C s | j | t j S( s a < b( Rn t operatort lt( R R ( ( sQ /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/fractions.pyt __lt__< s c C s | j | t j S( s a > b( Rn Ro t gt( R R ( ( sQ /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/fractions.pyt __gt__@ s c C s | j | t j S( s a <= b( Rn Ro t le( R R ( ( sQ /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/fractions.pyt __le__D s c C s | j | t j S( s a >= b( Rn Ro t ge( R R ( ( sQ /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/fractions.pyt __ge__H s c C s | j d k S( s a != 0i ( R ( R ( ( sQ /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/fractions.pyt __nonzero__L s c C s | j t | f f S( N( t __class__R6 ( R# ( ( sQ /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/fractions.pyt
|
__reduce__R s c C s, t | t k r | S| j | j | j S( N( R+ R Ry R R ( R# ( ( sQ /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/fractions.pyt __copy__U s c C s, t | t k r | S| j | j | j S( N( R+ R Ry R R ( R# t memo( ( sQ /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/fractions.pyt __deepcopy__Z s ( s
|
_numerators _denominatorN(9 R* t
|
__module__RT t __slots__R R t classmethodR R RF t propertyR R RG RH RU RV Ro t addt __add__t __radd__RW t subt __sub__t __rsub__RX t mult __mul__t __rmul__RY t truedivt __truediv__t __rtruediv__R[ t __div__t __rdiv__R\ R] R^ R_ Ra Rb Rc Rd Re Rf Rh Rk Rn Rq Rs Ru Rw Rx Rz R{ R} ( ( ( sQ /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/fractions.pyR , sR d 7 k ( RT t
|
__future__R R R R, R( Ro t ret __all__R R t compilet VERBOSEt
|
IGNORECASER R ( ( ( sQ /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/fractions.pyt <module> s
|
