merge with master

halgari · halgari · commit 724ebcde9377 · 2014-10-29T17:00:42.000-06:00
diff --git a/pixie/stdlib.lisp b/pixie/stdlib.lisp
@@ -115,6 +115,8 @@
 (extend -hash Integer hash-int)
 
 (extend -eq Integer -num-eq)
+(extend -eq Float -num-eq)
+(extend -eq Ratio -num-eq)
 
 (def ordered-hash-reducing-fn
   (fn ordered-hash-reducing-fn
@@ -437,7 +439,6 @@
   (fn [x & args]
     (apply f (if (nil? x) else x) args)))
 
-
 (defmacro foreach [binding & body]
   (assert (= 2 (count binding)) "binding and collection required")
   `(reduce
diff --git a/pixie/vm/compiler.py b/pixie/vm/compiler.py
@@ -313,6 +313,9 @@ def compile_form(form, ctx):
     if isinstance(form, numbers.Float):
         ctx.push_const(form)
         return
+    if isinstance(form, numbers.Ratio):
+        ctx.push_const(form)
+        return
 
     if isinstance(form, symbol.Symbol):
         name = form._str
diff --git a/pixie/vm/numbers.py b/pixie/vm/numbers.py
@@ -45,6 +45,23 @@ def float_val(self):
     def type(self):
         return Float._type
 
+class Ratio(Number):
+    _type = object.Type(u"pixie.stdlib.Ratio")
+    _immutable_fields_ = ["_numerator", "_denominator"]
+
+    def __init__(self, numerator, denominator):
+        self._numerator = numerator
+        self._denominator = denominator
+
+    def numerator(self):
+        return self._numerator
+
+    def denominator(self):
+        return self._denominator
+
+    def type(self):
+        return Ratio._type
+
 IMath = as_var("IMath")(Protocol(u"IMath"))
 _add = as_var("-add")(DoublePolymorphicFn(u"-add", IMath))
 _sub = as_var("-sub")(DoublePolymorphicFn(u"-sub", IMath))
@@ -72,13 +89,117 @@ def define_num_ops():
     for (c1, conv1) in num_classes:
         for (c2, conv2) in num_classes:
             for (op, sym) in [("_add", "+"), ("_sub", "-"), ("_mul", "*"), ("_div", "/")]:
+                if op == "_div" and c1 == Integer and c2 == Integer:
+                    continue
                 extend_num_op(op, c1, c2, conv1, sym, conv2)
             extend_num_op("_num_eq", c1, c2, conv1, "==", conv2,
                           wrap_start = "true if ", wrap_end = " else false")
 
 define_num_ops()
 
 
+def gcd(u, v):
+    while v != 0:
+        r = u % v
+        u = v
+        v = r
+    return u
+
+@extend(_div, Integer._type, Integer._type)
+def _div(n, d):
+    assert isinstance(n, Integer) and isinstance(d, Integer)
+    nv = n.int_val()
+    dv = d.int_val()
+    object.affirm(dv != 0, u"Divide by zero")
+    g = gcd(nv, dv)
+    if g == 0:
+        return rt.wrap(0)
+    nv = nv / g
+    dv = dv / g
+    if dv == 1:
+        return rt.wrap(nv)
+    elif dv == -1:
+        return rt.wrap(-1 * nv)
+    else:
+        if dv < 0:
+            nv = nv * -1
+            dv = dv * -1
+        return Ratio(nv, dv)
+
+@extend(_add, Ratio._type, Ratio._type)
+def _add(a, b):
+    assert isinstance(a, Ratio) and isinstance(b, Ratio)
+    return rt._div(rt._add(rt.wrap(b.numerator() * a.denominator()),
+                           rt.wrap(a.numerator() * b.denominator())),
+                   rt.wrap(a.denominator() * b.denominator()))
+
+@extend(_sub, Ratio._type, Ratio._type)
+def _sub(a, b):
+    assert isinstance(a, Ratio) and isinstance(b, Ratio)
+    return rt._div(rt._add(rt.wrap(-1 * b.numerator() * a.denominator()),
+                           rt.wrap(a.numerator() * b.denominator())),
+                   rt.wrap(a.denominator() * b.denominator()))
+
+@extend(_mul, Ratio._type, Ratio._type)
+def _mul(a, b):
+    assert isinstance(a, Ratio) and isinstance(b, Ratio)
+    return rt._div(rt.wrap(b.numerator() * a.numerator()),
+                   rt.wrap(b.denominator() * a.denominator()))
+
+@extend(_div, Ratio._type, Ratio._type)
+def _div(a, b):
+    assert isinstance(a, Ratio) and isinstance(b, Ratio)
+    return rt._div(rt.wrap(b.denominator() * a.numerator()),
+                   rt.wrap(b.numerator() * a.denominator()))
+
+@extend(_num_eq, Ratio._type, Ratio._type)
+def _num_eq(a, b):
+    assert isinstance(a, Ratio) and isinstance(b, Ratio)
+    return true if a.numerator() == b.numerator() and a.denominator() == b.denominator() else false
+
+ratio_op_tmpl = """@extend({pfn}, {ty1}._type, {ty2}._type)
+def {pfn}_{ty1}_{ty2}(a, b):
+    assert isinstance(a, {ty1}) and isinstance(b, {ty2})
+    return rt.{pfn}({conv1}(a), {conv2}(b))
+"""
+
+def to_ratio(x):
+    if isinstance(x, Ratio):
+        return x
+    else:
+        return Ratio(x.int_val(), 1)
+
+def to_ratio_conv(c):
+    if c == Ratio:
+        return ""
+    else:
+        return "to_ratio"
+
+def to_float(x):
+    if isinstance(x, Float):
+        return x
+    else:
+        return rt.wrap(x.numerator() / float(x.denominator()))
+
+def to_float_conv(c):
+    if c == Float:
+        return ""
+    else:
+        return "to_float"
+
+def define_ratio_ops():
+    for (c1, c2) in [(Integer, Ratio), (Ratio, Integer)]:
+        for op in ["_add", "_sub", "_mul", "_div", "_num_eq"]:
+            code = ratio_op_tmpl.format(pfn=op, ty1=c1.__name__, ty2=c2.__name__, conv1=to_ratio_conv(c1), conv2=to_ratio_conv(c2))
+            exec code
+
+    for (c1, c2) in [(Float, Ratio), (Ratio, Float)]:
+        for op in ["_add", "_sub", "_mul", "_div", "_num_eq"]:
+            code = ratio_op_tmpl.format(pfn=op, ty1=c1.__name__, ty2=c2.__name__, conv1=to_float_conv(c1), conv2=to_float_conv(c2))
+            exec code
+
+define_ratio_ops()
+
 # def add(a, b):
 #     if isinstance(a, Integer):
 #         if isinstance(b, Integer):
@@ -113,3 +234,11 @@ def _str(f):
     @extend(proto._repr, Float._type)
     def _repr(f):
         return rt.wrap(unicode(str(f.float_val())))
+
+    @extend(proto._repr, Ratio._type)
+    def _repr(r):
+        return rt.wrap(unicode(str(r.numerator()) + "/" + str(r.denominator())))
+
+    @extend(proto._str, Ratio._type)
+    def _str(r):
+        return rt.wrap(unicode(str(r.numerator()) + "/" + str(r.denominator())))
diff --git a/pixie/vm/reader.py b/pixie/vm/reader.py
@@ -400,6 +400,7 @@ def invoke(self, rdr, ch):
 int_matcher = re.compile(u'^([-+]?)(?:(0[xX])([0-9a-fA-F]+)|0([0-7]+)|([1-9][0-9]?)[rR]([0-9a-zA-Z]+)|([0-9]*))$')
 
 float_matcher = re.compile(u'^([-+]?[0-9]+(\.[0-9]*)?([eE][-+]?[0-9]+)?)$')
+ratio_matcher = re.compile(u'^([-+]?[0-9]+)/([0-9]+)$')
 
 def parse_int(m):
     sign = 1
@@ -427,6 +428,11 @@ def parse_int(m):
 def parse_float(m):
     return rt.wrap(float(str(m.group(0))))
 
+def parse_ratio(m):
+    n = rt.wrap(int(str(m.group(1))))
+    d = rt.wrap(int(str(m.group(2))))
+    return rt._div(n, d)
+
 def parse_number(s):
     m = int_matcher.match(s)
     if m:
@@ -436,7 +442,11 @@ def parse_number(s):
         if m:
             return parse_float(m)
         else:
-            return None
+            m = ratio_matcher.match(s)
+            if m:
+                return parse_ratio(m)
+            else:
+                return None
 
 def read_number(rdr, ch):
     acc = [ch]
diff --git a/pixie/vm/rt.py b/pixie/vm/rt.py
@@ -66,13 +66,16 @@ def wrapper(*args):
     import pixie.vm.libs.ffi
     import pixie.vm.symbol
     import pixie.vm.libs.path
+    import pixie.vm.libs.string
 
 
 
     numbers.init()
 
     @specialize.argtype(0)
     def wrap(x):
+        if isinstance(x, bool):
+            return true if x else false
         if isinstance(x, int):
             return numbers.Integer(x)
         if isinstance(x, float):
