Upload rational.py with huggingface_hub

rational.py

@@ -0,0 +1,240 @@
+import operator
+import sys
+from .libmp import int_types, mpf_hash, bitcount, from_man_exp, HASH_MODULUS
+
+new = object.__new__
+
+def create_reduced(p, q, _cache={}):
+    key = p, q
+    if key in _cache:
+        return _cache[key]
+    x, y = p, q
+    while y:
+        x, y = y, x % y
+    if x != 1:
+        p //= x
+        q //= x
+    v = new(mpq)
+    v._mpq_ = p, q
+    # Speedup integers, half-integers and other small fractions
+    if q <= 4 and abs(key[0]) < 100:
+        _cache[key] = v
+    return v
+
+class mpq(object):
+    """
+    Exact rational type, currently only intended for internal use.
+    """
+
+    __slots__ = ["_mpq_"]
+
+    def __new__(cls, p, q=1):
+        if type(p) is tuple:
+            p, q = p
+        elif hasattr(p, '_mpq_'):
+            p, q = p._mpq_
+        return create_reduced(p, q)
+
+    def __repr__(s):
+        return "mpq(%s,%s)" % s._mpq_
+
+    def __str__(s):
+        return "(%s/%s)" % s._mpq_
+
+    def __int__(s):
+        a, b = s._mpq_
+        return a // b
+
+    def __nonzero__(s):
+        return bool(s._mpq_[0])
+
+    __bool__ = __nonzero__
+
+    def __hash__(s):
+        a, b = s._mpq_
+        if sys.version_info >= (3, 2):
+            inverse = pow(b, HASH_MODULUS-2, HASH_MODULUS)
+            if not inverse:
+                h = sys.hash_info.inf
+            else:
+                h = (abs(a) * inverse) % HASH_MODULUS
+            if a < 0: h = -h
+            if h == -1: h = -2
+            return h
+        else:
+            if b == 1:
+                return hash(a)
+            # Power of two: mpf compatible hash
+            if not (b & (b-1)):
+                return mpf_hash(from_man_exp(a, 1-bitcount(b)))
+            return hash((a,b))
+
+    def __eq__(s, t):
+        ttype = type(t)
+        if ttype is mpq:
+            return s._mpq_ == t._mpq_
+        if ttype in int_types:
+            a, b = s._mpq_
+            if b != 1:
+                return False
+            return a == t
+        return NotImplemented
+
+    def __ne__(s, t):
+        ttype = type(t)
+        if ttype is mpq:
+            return s._mpq_ != t._mpq_
+        if ttype in int_types:
+            a, b = s._mpq_
+            if b != 1:
+                return True
+            return a != t
+        return NotImplemented
+
+    def _cmp(s, t, op):
+        ttype = type(t)
+        if ttype in int_types:
+            a, b = s._mpq_
+            return op(a, t*b)
+        if ttype is mpq:
+            a, b = s._mpq_
+            c, d = t._mpq_
+            return op(a*d, b*c)
+        return NotImplementedError
+
+    def __lt__(s, t): return s._cmp(t, operator.lt)
+    def __le__(s, t): return s._cmp(t, operator.le)
+    def __gt__(s, t): return s._cmp(t, operator.gt)
+    def __ge__(s, t): return s._cmp(t, operator.ge)
+
+    def __abs__(s):
+        a, b = s._mpq_
+        if a >= 0:
+            return s
+        v = new(mpq)
+        v._mpq_ = -a, b
+        return v
+
+    def __neg__(s):
+        a, b = s._mpq_
+        v = new(mpq)
+        v._mpq_ = -a, b
+        return v
+
+    def __pos__(s):
+        return s
+
+    def __add__(s, t):
+        ttype = type(t)
+        if ttype is mpq:
+            a, b = s._mpq_
+            c, d = t._mpq_
+            return create_reduced(a*d+b*c, b*d)
+        if ttype in int_types:
+            a, b = s._mpq_
+            v = new(mpq)
+            v._mpq_ = a+b*t, b
+            return v
+        return NotImplemented
+
+    __radd__ = __add__
+
+    def __sub__(s, t):
+        ttype = type(t)
+        if ttype is mpq:
+            a, b = s._mpq_
+            c, d = t._mpq_
+            return create_reduced(a*d-b*c, b*d)
+        if ttype in int_types:
+            a, b = s._mpq_
+            v = new(mpq)
+            v._mpq_ = a-b*t, b
+            return v
+        return NotImplemented
+
+    def __rsub__(s, t):
+        ttype = type(t)
+        if ttype is mpq:
+            a, b = s._mpq_
+            c, d = t._mpq_
+            return create_reduced(b*c-a*d, b*d)
+        if ttype in int_types:
+            a, b = s._mpq_
+            v = new(mpq)
+            v._mpq_ = b*t-a, b
+            return v
+        return NotImplemented
+
+    def __mul__(s, t):
+        ttype = type(t)
+        if ttype is mpq:
+            a, b = s._mpq_
+            c, d = t._mpq_
+            return create_reduced(a*c, b*d)
+        if ttype in int_types:
+            a, b = s._mpq_
+            return create_reduced(a*t, b)
+        return NotImplemented
+
+    __rmul__ = __mul__
+
+    def __div__(s, t):
+        ttype = type(t)
+        if ttype is mpq:
+            a, b = s._mpq_
+            c, d = t._mpq_
+            return create_reduced(a*d, b*c)
+        if ttype in int_types:
+            a, b = s._mpq_
+            return create_reduced(a, b*t)
+        return NotImplemented
+
+    def __rdiv__(s, t):
+        ttype = type(t)
+        if ttype is mpq:
+            a, b = s._mpq_
+            c, d = t._mpq_
+            return create_reduced(b*c, a*d)
+        if ttype in int_types:
+            a, b = s._mpq_
+            return create_reduced(b*t, a)
+        return NotImplemented
+
+    def __pow__(s, t):
+        ttype = type(t)
+        if ttype in int_types:
+            a, b = s._mpq_
+            if t:
+                if t < 0:
+                    a, b, t = b, a, -t
+                v = new(mpq)
+                v._mpq_ = a**t, b**t
+                return v
+            raise ZeroDivisionError
+        return NotImplemented
+
+
+mpq_1 = mpq((1,1))
+mpq_0 = mpq((0,1))
+mpq_1_2 = mpq((1,2))
+mpq_3_2 = mpq((3,2))
+mpq_1_4 = mpq((1,4))
+mpq_1_16 = mpq((1,16))
+mpq_3_16 = mpq((3,16))
+mpq_5_2 = mpq((5,2))
+mpq_3_4 = mpq((3,4))
+mpq_7_4 = mpq((7,4))
+mpq_5_4 = mpq((5,4))
+
+
+# Register with "numbers" ABC
+#     We do not subclass, hence we do not use the @abstractmethod checks. While
+#     this is less invasive it may turn out that we do not actually support
+#     parts of the expected interfaces.  See
+#     http://docs.python.org/2/library/numbers.html for list of abstract
+#     methods.
+try:
+    import numbers
+    numbers.Rational.register(mpq)
+except ImportError:
+    pass