Add some semi-primitives as compiled functions, for performance

kernel/modelverse_kernel/compiled.py

@@ -113,3 +113,85 @@ def string_substr(a, b, c, **remainder):
     result, = yield [("CNV", [new_value])]
     #PROFILE print("[COMPILED]string_substr : %s : %s" % (time.time() - start, time.time() - start))
     raise PrimitiveFinished(result)
+
+def integer_gt(a, b, **remainder):
+    a_value, b_value =  yield [("RV", [a]), ("RV", [b])]
+    result, = yield [("CNV", [a_value > b_value])]
+    raise PrimitiveFinished(result)
+
+def integer_neg(a, **remainder):
+    a_value, =          yield [("RV", [a])]
+    result, = yield [("CNV", [-a_value])]
+    raise PrimitiveFinished(result)
+
+def float_gt(a, b, **remainder):
+    a_value, b_value =  yield [("RV", [a]), ("RV", [b])]
+    result, = yield [("CNV", [a_value > b_value])]
+    raise PrimitiveFinished(result)
+
+def float_neg(a, **remainder):
+    a_value, =          yield [("RV", [a])]
+    result, = yield [("CNV", [-a_value])]
+    raise PrimitiveFinished(result)
+
+def value_neq(a, b, **remainder):
+    a_value, b_value =  yield [("RV", [a]), ("RV", [b])]
+    result, = yield [("CNV", [a_value != b_value])]
+    raise PrimitiveFinished(result)
+
+def element_neq(a, b, **remainder):
+    result, = yield [("CNV", [a != b])]
+    raise PrimitiveFinished(result)
+
+def list_append(a, b, **remainder):
+    a_outgoing, = yield [("RO", [a])]
+    _ = yield [("CD", [a, len(a_outgoing), b])]
+    raise PrimitiveFinished(a)
+
+def list_read(a, b, **remainder):
+    b_value, = yield [("RV", [b])]
+    result, = yield [("RD", [a, b_value])]
+    if result is None:
+        raise Exception("List read out of bounds: %s" % b_value)
+    raise PrimitiveFinished(result)
+
+def list_len(a, **remainder):
+    outgoings, = yield [("RO", [a])]
+    result, = yield [("CNV", [len(outgoings)])]
+    raise PrimitiveFinished(result)
+
+def dict_add(a, b, c, **remainder):
+    new_edge, = yield [("CE", [a, c])]
+    yield [("CE", [new_edge, b])]
+    raise PrimitiveFinished(a)
+
+def dict_len(a, **remainder):
+    outgoings, = yield [("RO", [a])]
+    result, = yield [("CNV", [len(outgoings)])]
+    raise PrimitiveFinished(result)
+
+def set_add(a, b, **remainder):
+    outgoing, b_value = yield [("RO", [a]), ("RV", [b])]
+    if outgoing:
+        elements = yield [("RE", [i]) for i in outgoing]
+        values = yield [("RV", [i[1]]) for i in elements]
+        if b_value is not None and b_value in values:
+            raise PrimitiveFinished(a)
+        elif b_value is None and b in elements:
+            raise PrimitiveFinished(a)
+        else:
+            yield [("CE", [a, b])]
+            raise PrimitiveFinished(a)
+    else:
+        yield [("CE", [a, b])]
+        raise PrimitiveFinished(a)
+
+def set_pop(a, **remainder):
+    outgoing, = yield [("RO", [a])]
+    if outgoing:
+        v, _ = yield [("RE", [outgoing[0]]), ("DE", [outgoing[0]])]
+        raise PrimitiveFinished(v[1])
+    else:
+        print("Pop from empty set!")
+        raise PrimitiveFinished(remainder["root"])
+

kernel/modelverse_kernel/primitives.py

@@ -115,27 +115,12 @@ def float_division(a, b, **remainder):
     result, = yield [("CNV", [float(a_value) / float(b_value)])]
     raise PrimitiveFinished(result)
 
-"""
-def float_gt(a, b, **remainder):
-    a_value, b_value =  yield [("RV", [a]), ("RV", [b])]
-    result, = yield [("CNV", [a_value > b_value])]
-    raise PrimitiveFinished(result)
-"""
-
 def float_lt(a, b, **remainder):
     # TODO make non-primitive, though compiled
     a_value, b_value =  yield [("RV", [a]), ("RV", [b])]
     result, = yield [("CNV", [a_value < b_value])]
     raise PrimitiveFinished(result)
 
-"""
-def float_neg(a, **remainder):
-    # TODO make non-primitive, though compiled
-    a_value, =          yield [("RV", [a])]
-    result, = yield [("CNV", [-a_value])]
-    raise PrimitiveFinished(result)
-"""
-
 def string_join(a, b, **remainder):
     a_value, b_value =  yield [("RV", [a]), ("RV", [b])]
     result, = yield [("CNV", [str(a_value) + str(b_value)])]
@@ -165,25 +150,10 @@ def value_eq(a, b, **remainder):
     result, = yield [("CNV", [a_value == b_value])]
     raise PrimitiveFinished(result)
 
-"""
-def value_neq(a, b, **remainder):
-    # TODO make non-primitive, though compiled
-    a_value, b_value =  yield [("RV", [a]), ("RV", [b])]
-    result, = yield [("CNV", [a_value != b_value])]
-    raise PrimitiveFinished(result)
-"""
-
 def element_eq(a, b, **remainder):
     result, = yield [("CNV", [a == b])]
     raise PrimitiveFinished(result)
 
-"""
-def element_neq(a, b, **remainder):
-    # TODO make non-primitive, though compiled
-    result, = yield [("CNV", [a != b])]
-    raise PrimitiveFinished(result)
-"""
-
 def cast_a2s(a, **remainder):
     a_value, = yield [("RV", [a])]
     result, = yield [("CNV", [str(a_value["value"])])]
@@ -269,14 +239,6 @@ def cast_id2s(a, **remainder):
     result, = yield [("CNV", ["%s" % (a)])]
     raise PrimitiveFinished(result)
 
-"""
-def list_append(a, b, **remainder):
-    # TODO make non-primitive, though compiled
-    a_outgoing, = yield [("RO", [a])]
-    _ = yield [("CD", [a, len(a_outgoing), b])]
-    raise PrimitiveFinished(a)
-"""
-
 def list_insert(a, b, c, **remainder):
     # TODO make non-primitive, though compiled
     a_outgoing, c_value = yield [("RO", [a]), ("RV", [c])]
@@ -300,31 +262,6 @@ def list_delete(a, b, **remainder):
           [("DE", [i]) for i in edges]
     raise PrimitiveFinished(a)
 
-"""
-def list_read(a, b, **remainder):
-    # TODO same as dictionary read
-    b_value, = yield [("RV", [b])]
-    result, = yield [("RD", [a, b_value])]
-    if result is None:
-        raise Exception("List read out of bounds: %s" % b_value)
-    raise PrimitiveFinished(result)
-"""
-
-"""
-def list_len(a, **remainder):
-    # TODO same as read_nr_out
-    outgoings, = yield [("RO", [a])]
-    result, = yield [("CNV", [len(outgoings)])]
-    raise PrimitiveFinished(result)
-"""
-
-"""
-def dict_add(a, b, c, **remainder):
-    new_edge, = yield [("CE", [a, c])]
-    yield [("CE", [new_edge, b])]
-    raise PrimitiveFinished(a)
-"""
-
 def dict_add_fast(a, b, c, **remainder):
     # TODO deprecate, as dict_add is now also efficient
     v, = yield [("RV", [b])]
@@ -375,14 +312,6 @@ def dict_in_node(a, b, **remainder):
     result, = yield [("CNV", [value is not None])]
     raise PrimitiveFinished(result)
 
-"""
-def dict_len(a, **remainder):
-    # TODO same as read_nr_out
-    outgoings, = yield [("RO", [a])]
-    result, = yield [("CNV", [len(outgoings)])]
-    raise PrimitiveFinished(result)
-"""
-
 def dict_keys(a, **remainder):
     keys, result = yield [("RDK", [a]), ("CN", [])]
     yield [("CE", [result, v]) for v in keys]
@@ -467,41 +396,6 @@ def delete_element(a, **remainder):
 def read_root(root, **remainder):
     raise PrimitiveFinished(root)
 
-"""
-def set_add(a, b, **remainder):
-    # TODO make non-primitive, though compiled
-
-    #yield [("CE", [a, b])]
-    #raise PrimitiveFinished(a)
-
-    outgoing, b_value = yield [("RO", [a]), ("RV", [b])]
-    if outgoing:
-        elements = yield [("RE", [i]) for i in outgoing]
-        values = yield [("RV", [i[1]]) for i in elements]
-        if b_value is not None and b_value in values:
-            raise PrimitiveFinished(a)
-        elif b_value is None and b in elements:
-            raise PrimitiveFinished(a)
-        else:
-            yield [("CE", [a, b])]
-            raise PrimitiveFinished(a)
-    else:
-        yield [("CE", [a, b])]
-        raise PrimitiveFinished(a)
-"""
-
-"""
-def set_pop(a, **remainder):
-    # TODO make non-primitive, though compiled
-    outgoing, = yield [("RO", [a])]
-    if outgoing:
-        v, _ = yield [("RE", [outgoing[0]]), ("DE", [outgoing[0]])]
-        raise PrimitiveFinished(v[1])
-    else:
-        print("Pop from empty set!")
-        raise PrimitiveFinished(remainder["root"])
-"""
-
 def set_remove(a, b, **remainder):
     outgoing, b_value = yield [("RO", [a]), ("RV", [b])]
     elements = yield [("RE", [i]) for i in outgoing]