Add Acton programs for binarytrees, merkletrees and nsieve

bench/algorithm/binarytrees/1.act

@@ -0,0 +1,48 @@
+#!/usr/bin/env runacton
+
+class Node(object):
+    left: ?Node
+    right: ?Node
+    def __init__(self, left, right):
+        self.left = left
+        self.right = right
+
+def make(depth: int) -> Node:
+    if depth == 0:
+        return Node(None, None)
+    else:
+        d = depth - 1
+        return Node(make(d), make(d))
+
+def check(node: Node) -> int:
+    l = node.left
+    r = node.right
+    sum = 1
+    if l is not None:
+        sum += check(l)
+    if r is not None:
+        sum += check(r)
+    return sum
+
+def binary_tree(n: int):
+    min_depth = 4
+    max_depth = max([min_depth + 2, n], 0)
+    stretch_depth = max_depth + 1
+    print("stretch tree of depth %d\t check: %d" % (stretch_depth, check(make(stretch_depth))))
+
+    long_lived_tree = make(max_depth)
+
+    mmd = max_depth + min_depth
+    for d in range(min_depth, stretch_depth, 2):
+        i = 2 ** (mmd - d)
+        cs = 0
+        for _ in range(0, i, 1):
+            cs += check(make(d))
+        print("%d\t trees of depth %d\t check: %d" % (i, d, cs))
+
+    print("long lived tree of depth %d\t check: %d" % (max_depth, check(long_lived_tree)))
+
+actor main(env):
+    n = int(env.argv[1]) if len(env.argv) > 1 else 6
+    binary_tree(n)
+    env.exit(0)

bench/algorithm/edigits/1.act

@@ -1,4 +1,7 @@
+#!/usr/bin/env runacton
+
 # port of 1.py
+
 import math
 
 ln_tau = math.log(6.283185307179586)
@@ -53,4 +56,4 @@ actor main(env):
                 spaces += " "
             print(s[i:] + spaces + "\t:" + str(n))
             #print(f'{s[i:]}{" "*(10-n%10)}\t:{n}')
-    await async env.exit(0)
+    env.exit(0)

bench/algorithm/helloworld/1.act

@@ -4,4 +4,4 @@ actor main(env):
         print("Hello world %s!" % env.argv[1])
     else:
         print("Hello world !")
-    await async env.exit(0)
+    env.exit(0)

bench/algorithm/merkletrees/1.act

@@ -0,0 +1,76 @@
+
+class Node(object):
+    hash: ?int
+    def __init__(self, value: ?int, left: ?Node, right: ?Node):
+        self.value = value
+        self.left = left
+        self.right = right
+        self.hash = None
+
+    def check(self) -> bool:
+        h = self.hash
+        v = self.value
+        l = self.left
+        r = self.right
+        if h != None:
+            if v != None:
+                return True
+            elif l is not None and r is not None:
+                return l.check() and r.check()
+        return False
+
+    def calc_hash(self):
+        h = self.hash
+        v = self.value
+        if h is None:
+            l = self.left
+            r = self.right
+            if v is not None:
+                self.hash = self.value
+            elif l is not None and r is not None:
+                l.calc_hash()
+                r.calc_hash()
+                self.hash = l.get_hash() + r.get_hash()
+
+    def get_hash(self) -> int:
+        h = self.hash
+        if h is not None:
+            return h
+        else:
+            return -1
+
+def make(depth):
+    if depth == 0:
+        return Node(1, None, None)
+    else:
+        depth -= 1
+        return Node(None, make(depth), make(depth))
+
+def mtree(n):
+    min_depth=4
+    max_depth = max([min_depth + 2, n], 0)
+    stretch_depth = max_depth + 1
+    stretch_tree = make(stretch_depth)
+    stretch_tree.calc_hash()
+
+    print("stretch tree of depth %d\t root hash: %d check: %s" % (stretch_depth, stretch_tree.get_hash(), str(stretch_tree.check()).lower()))
+
+    long_lived_tree = make(max_depth)
+
+    mmd = max_depth + min_depth
+    for d in range(min_depth, stretch_depth, 2):
+        iterations = 2 ** (mmd - d)
+        sum = 0
+        for _ in range(0, iterations, 1):
+            tree = make(d)
+            tree.calc_hash()
+            sum += tree.get_hash()
+        print("%d\t trees of depth %d\t root hash sum: %d" % (iterations, d, sum))
+
+    long_lived_tree.calc_hash()
+    print("long lived tree of depth %d\t root hash: %d check: %s" % (max_depth, long_lived_tree.get_hash(), str(long_lived_tree.check()).lower()))
+
+actor main(env):
+    n = int(env.argv[1]) if len(env.argv) > 1 else 6
+    mtree(n)
+    env.exit(0)

bench/algorithm/nsieve/1.act

@@ -0,0 +1,23 @@
+#!/usr/bin/env runacton
+
+def nsieve(n: int):
+    count = 0
+    flags = [True] * n
+    for i in range(2, n, 1):
+        if flags[i]:
+            count += 1
+            for j in range(i, n, i):
+                flags[j] = False
+    n_s = ""
+    for j in range(0, (8-(len(str(n)))), 1):
+        n_s += " "
+    c_s = ""
+    for j in range(0, (8-(len(str(count)))), 1):
+        c_s += " "
+    print("Primes up to %s%d %s%d" % (n_s, n, c_s, count))
+
+actor main(env):
+    n = 4 if len(env.argv) < 2 else int(env.argv[1])
+    for i in range(0, 3, 1):
+        nsieve(10000 << (n - i))
+    env.exit(0)

bench/algorithm/pidigits/1.act

@@ -54,4 +54,4 @@ actor main(env):
         for j in range(0, (10-(len(res))), 1):
             spaces += " "
         print("%s%s\t:%d" % (res, spaces, i))
-    await async env.exit(0)
+    env.exit(0)

bench/bench_acton.yaml

@@ -1,11 +1,20 @@
 lang: acton
 problems:
-  - name: helloworld
+  - name: binarytrees
     source:
       - 1.act
   - name: edigits
     source:
       - 1.act
+  - name: helloworld
+    source:
+      - 1.act
+  - name: merkletrees
+    source:
+      - 1.act
+  - name: nsieve
+    source:
+      - 1.act
   - name: pidigits
     source:
       - 1.act