Add java ocaml and swift tests

koka_bench/ocaml/CMakeLists.txt

@@ -0,0 +1,39 @@
+#see <https://github.com/ocaml-multicore/multicore-opam> for installation (including domainslib)
+#> opam update
+#> opam switch create 4.12.0+domains+effects --repositories=multicore=git+https://github.com/ocaml-multicore/multicore-opam.git,default
+#> opam install dune domainslib
+#
+#compile as:
+#> ocamlopt -O2  -o ./mcml_bintrees -I ~/.opam/4.12.0+domains+effects/lib/domainslib/ domainslib.cmxa test/bench/ocaml/binarytrees_mc.ml
+
+
+set(sources cfold.ml deriv.ml nqueens.ml rbtree.ml)
+
+# find_program(ocamlopt "ocamlopt" REQUIRED)
+set(ocamlopt "ocamlopt")
+
+# no domains
+set(domainslib "unix.cmxa")
+
+# with domains
+# set(domainslib "-I $ENV{HOME}/.opam/4.12.0+domains+effects/lib/domainslib/ domainslib.cmxa")
+# set(sources cfold.ml deriv.ml nqueens.ml rbtree.ml rbtree-ck.ml binarytrees.ml)
+
+foreach (source IN LISTS sources)
+  get_filename_component(name "${source}" NAME_WE)
+  set(name "ml-${name}")
+  
+  add_custom_command(
+    OUTPUT  ${name}    
+    COMMAND ${ocamlopt} -O2 -o ${name} ${domainslib} "$<SHELL_PATH:${CMAKE_CURRENT_SOURCE_DIR}/${source}>"
+    DEPENDS ${source}
+    VERBATIM)
+
+  add_custom_target(update-${name} ALL DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/${name})
+
+  add_executable(${name}-exe IMPORTED)
+  set_target_properties(${name}-exe PROPERTIES IMPORTED_LOCATION "${CMAKE_CURRENT_BINARY_DIR}/${name}")
+
+  add_test(NAME ${name} COMMAND ${name}-exe)
+  set_tests_properties(${name} PROPERTIES LABELS ocaml)
+endforeach ()

koka_bench/ocaml/cfold.ml

@@ -0,0 +1,72 @@
+type expr =
+| Var of int
+| Val of int
+| Add of expr * expr
+| Mul of expr * expr;;
+
+let dec n =
+  if n == 0 then 0 else n - 1;;
+
+let rec mk_expr n v =
+  if n == 0 then (if v == 0 then Var 1 else Val v)
+  else Add (mk_expr (n-1) (v+1), mk_expr (n-1) (dec v));;
+
+let rec append_add e0 e3 =
+match (e0) with
+| Add (e1, e2) -> Add (e1, append_add e2 e3)
+| _            -> Add (e0, e3);;
+
+let rec append_mul e0 e3 =
+match e0 with
+| Mul (e1, e2) -> Mul (e1, append_mul e2 e3)
+| _            -> Mul (e0, e3);;
+
+let rec reassoc e =
+match e with
+| Add (e1, e2) ->
+  let e1' = reassoc e1 in
+  let e2' = reassoc e2 in
+  append_add e1' e2'
+| Mul (e1, e2) ->
+  let e1' = reassoc e1 in
+  let e2' = reassoc e2 in
+  append_mul e1' e2'
+| e -> e;;
+
+let rec const_folding e =
+match e with
+| Add (e1, e2) ->
+  let e1 = const_folding e1 in
+  let e2 = const_folding e2 in
+  (match (e1, e2) with
+   | (Val a, Val b)          -> Val (a+b)
+   | (Val a, Add (e, Val b)) -> Add (Val (a+b), e)
+   | (Val a, Add (Val b, e)) -> Add (Val (a+b), e)
+   | _                       -> Add (e1, e2))
+| Mul (e1, e2) ->
+  let e1 = const_folding e1 in
+  let e2 = const_folding e2 in
+  (match (e1, e2) with
+   | (Val a, Val b)          -> Val (a*b)
+   | (Val a, Mul (e, Val b)) -> Mul (Val (a*b), e)
+   | (Val a, Mul (Val b, e)) -> Mul (Val (a*b), e)
+   | _                       -> Mul (e1, e2))
+| e ->  e;;
+
+let rec size e =
+match e with
+| Add (e1, e2) -> size e1 + size e2 + 1
+| Mul (e1, e2) -> size e1 + size e2 + 1
+| e            -> 1;;
+
+let rec eeval e =
+ match e with
+ | Val n -> n
+ | Var x -> 0
+ | Add (e1, e2) -> eeval e1 + eeval e2
+ | Mul (e1, e2) -> eeval e1 * eeval e2;;
+
+let e  = (mk_expr (int_of_string Sys.argv.(1)) 1) in
+let v1 = eeval e in
+let v2 = eeval (const_folding (reassoc e)) in
+Printf.printf "%8d %8d\n" v1 v2;;

koka_bench/ocaml/deriv.ml

@@ -0,0 +1,85 @@
+type expr =
+| Val of int
+| Var of string
+| Add of expr * expr
+| Mul of expr * expr
+| Pow of expr * expr
+| Ln of expr;;
+
+let rec pown a n =
+if n == 0 then 1
+else if n == 1 then a
+else let b = pown a (n / 2) in
+b * b * (if n mod 2 == 0 then 1 else a);;
+
+let rec add n m =
+match (n, m) with
+| (Val n, Val m) -> Val (n+m)
+| (Val 0, f)     -> f
+| (f, Val 0)     -> f
+| (f, Val n)     -> add (Val n) f
+| (Val n, Add(Val m, f)) -> add (Val (n+m)) f
+| (f, Add(Val n, g))     -> add (Val n) (add f g)
+| (Add(f, g), h)         -> add f (add g h)
+| (f, g)                 -> Add (f, g);;
+
+let rec mul n m =
+match (n, m) with
+| (Val n, Val m) -> Val (n*m)
+| (Val 0, _)     -> Val 0
+| (_, Val 0)     -> Val 0
+| (Val 1, f)     -> f
+| (f, Val 1)     -> f
+| (f, Val n)     -> mul (Val n) f
+| (Val n, Mul (Val m, f)) -> mul (Val (n*m)) f
+| (f, Mul (Val n, g))     -> mul (Val n) (mul f g)
+| (Mul (f, g), h)         -> mul f (mul g h)
+| (f, g)                  -> Mul (f, g);;
+
+let rec pow m n =
+match (m, n) with
+| (Val m, Val n) -> Val (pown m n)
+| (_,  Val 0)    -> Val 1
+| (f, Val 1)     -> f
+| (Val 0, _)     -> Val 0
+| (f, g)         -> Pow (f, g);;
+
+let rec ln n =
+match n with
+| (Val 1) -> Val 0
+| f       -> Ln f;;
+
+let rec d x f =
+match f with
+| Val _      -> Val 0
+| Var y      -> if x = y then Val 1 else Val 0
+| Add (f, g) -> add (d x f) (d x g)
+| Mul (f, g) -> add (mul f (d x g)) (mul g (d x f))
+| Pow (f, g) -> mul (pow f g) (add (mul (mul g (d x f)) (pow f (Val (-1)))) (mul (ln f) (d x g)))
+| Ln f       -> mul (d x f) (pow f (Val (-1)));;
+
+let rec count f =
+match f with
+| Val _ -> 1
+| Var _ -> 1
+| Add (f, g) -> count f + count g
+| Mul (f, g) -> count f + count g
+| Pow (f, g) -> count f + count g
+| Ln f       -> count f;;
+
+let rec nest_aux s f n x =
+if n == 0 then x
+else let x = f (s - n) x in
+     nest_aux s f (n - 1) x;;
+
+let nest f n e =
+nest_aux n f n e;;
+
+let deriv i f =
+  let d = d "x" f in
+  Printf.printf "%8d count: %8d\n" (i+1) (count d);
+  d;;
+
+let x = Var "x" in
+let f = pow x x in
+nest deriv (int_of_string Sys.argv.(1)) f;;

koka_bench/ocaml/nqueens.ml

@@ -0,0 +1,24 @@
+open List;;
+
+let rec safe queen diag xs = 
+  match xs with
+  | q :: qs -> queen <> q && queen <> q + diag && queen <> q - diag && safe queen (diag + 1) qs
+  | [] -> true;;
+
+let rec append_safe queen xs xss =
+  if (queen <= 0) then xss
+  else if (safe queen 1 xs) then append_safe (queen - 1) xs ((queen :: xs) :: xss)
+  else append_safe (queen - 1) xs xss;;
+
+let rec extend queen acc xss =
+  match xss with
+  | xs :: rest -> extend queen (append_safe queen xs acc) rest
+  | [] -> acc;;
+
+let rec find_solutions n queen =
+  if (queen == 0) then [[]]
+   else extend n [] (find_solutions n (queen - 1));;
+   
+let queens n = List.length (find_solutions n n);;
+
+Printf.printf "%8d\n" (queens (int_of_string Sys.argv.(1)));;

koka_bench/ocaml/rbtree.ml

@@ -0,0 +1,72 @@
+(* Adapted from https://github.com/leanprover/lean4/blob/IFL19/tests/bench/rbmap.ml *)
+
+type color =
+| Red
+| Black;;
+
+type node =
+| Leaf
+| Node of color * node * int * bool * node;;
+
+let balance1 kv vv t n =
+match n with
+| Node (c, Node (Red, l, kx, vx, r1), ky, vy, r2) -> Node (Red, Node (Black, l, kx, vx, r1), ky, vy, Node (Black, r2, kv, vv, t))
+| Node (c, l1, ky, vy, Node (Red, l2, kx, vx, r)) -> Node (Red, Node (Black, l1, ky, vy, l2), kx, vx, Node (Black, r, kv, vv, t))
+| Node (c, l,  ky, vy, r)                         -> Node (Black, Node (Red, l, ky, vy, r), kv, vv, t)
+| n -> Leaf;;
+
+let balance2 t kv vv n =
+match n with
+| Node (_, Node (Red, l, kx1, vx1, r1), ky, vy, r2)  -> Node (Red, Node (Black, t, kv, vv, l), kx1, vx1, Node (Black, r1, ky, vy, r2))
+| Node (_, l1, ky, vy, Node (Red, l2, kx2, vx2, r2)) -> Node (Red, Node (Black, t, kv, vv, l1), ky, vy, Node (Black, l2, kx2, vx2, r2))
+| Node (_, l, ky, vy, r)                             -> Node (Black, t, kv, vv, Node (Red, l, ky, vy, r))
+| n   -> Leaf;;
+
+let is_red t =
+match t with
+| Node (Red, _, _, _, _) -> true
+| _ -> false;;
+
+let rec ins t kx vx =
+match t with
+| Leaf -> Node (Red, Leaf, kx, vx, Leaf)
+| Node (Red, a, ky, vy, b) ->
+  if kx < ky then Node (Red, ins a kx vx, ky, vy, b)
+  else if ky = kx then Node (Red, a, kx, vx, b)
+  else Node (Red, a, ky, vy, ins b kx vx)
+| Node (Black, a, ky, vy, b) ->
+  if kx < ky then
+    (if is_red a then balance1 ky vy b (ins a kx vx)
+      else Node (Black, (ins a kx vx), ky, vy, b))
+  else if kx = ky then Node (Black, a, kx, vx, b)
+  else if is_red b then balance2 a ky vy (ins b kx vx)
+       else Node (Black, a, ky, vy, (ins b kx vx));;
+
+let set_black n =
+match n with
+| Node (_, l, k, v, r) -> Node (Black, l, k, v, r)
+| e                    -> e;;
+
+let insert t k v =
+if is_red t then set_black (ins t k v)
+else ins t k v;;
+
+let rec fold f n d =
+match n with
+| Leaf -> d
+| Node(_, l, k, v, r) -> fold f r (f k v (fold f l d));;
+
+let rec mk_map_aux n m =
+if n = 0 then m
+else let n1 = n-1 in
+     mk_map_aux n1 (insert m n1 (n1 mod 10 == 0));;
+
+let mk_map n = mk_map_aux n Leaf;;
+
+let main n =
+let m = mk_map n in
+let v = fold (fun k v r -> if v then r + 1 else r) m 0 in
+Printf.printf "%8d\n" v;
+v;;
+
+main (int_of_string Sys.argv.(1));;