updated benchmarks

benchmarks/bcaryal-benchmark1.lisp

@@ -0,0 +1,34 @@
+(define (add-n-times x n)
+  (if (= n 0)
+      0
+      (+ x (add-n-times x (sub1 n)))))
+
+(define (find-root x current)
+  (let ((square (add-n-times current current)))
+    (if (= square x)
+        current
+        (if (< square x)
+            (find-root x (add1 current))
+            0))))
+
+(define (sum-sequence x)
+  (if (= x 0)
+      0
+      (+ x (sum-sequence (sub1 x)))))
+
+(define (fib n)
+  (if (< n 2)
+      1
+      (+ (fib (sub1 n))
+         (fib (- n 2)))))
+
+(define (process x)
+  (let ((root (find-root x 0)))
+    (let ((seq (sum-sequence 5)))
+      (let ((fib-val (fib 5)))
+        (if (= root 0)
+            (+ x seq)
+            (+ (+ x root) (+ seq fib-val)))))))
+
+(let ((x 16))
+  (print (process x)))

benchmarks/bcaryal-benchmark1.out

@@ -0,0 +1 @@
+43 

benchmarks/bcaryal-benchmark2.lisp

@@ -0,0 +1,19 @@
+(define (classify x)
+  (if (< x 10)
+      (+ x 1)
+      (if (< x 20)
+          (+ x 2)
+          (+ x 3))))
+
+(define (process x)
+  (if (= x 0)
+      0
+      (+ (classify x)
+         (classify (sub1 x)))))
+
+(define (chain x)
+  (+ (process x)
+     (process (add1 x))))
+
+(let ((x 15))
+  (print (chain x)))

benchmarks/bcaryal-benchmark3.lisp

@@ -0,0 +1,48 @@
+(define (constant-fold x)
+  (+ (+ 1 (+ 2 (+ 3 4))) 
+     (- (+ 5 (+ 6 7)) 
+        (+ 8 (+ 9 x)))))
+
+(define (small-func1 x) 
+  (add1 (add1 x)))
+
+(define (small-func2 x)
+  (sub1 (sub1 x)))
+
+(define (small-func3 x)
+  (+ (small-func1 x) (small-func2 x)))
+
+(define (complex-compute x y)
+  (if (< x y)
+      (+ (constant-fold x) 
+         (small-func3 y))
+      (+ (small-func3 x) 
+         (constant-fold y))))
+
+(define (repeated-expr x)
+  (let ((v1 (+ x (+ x (+ x x)))))
+    (let ((v2 (+ x (+ x (+ x x)))))
+      (let ((v3 (+ x (+ x (+ x x)))))
+        (+ v1 (+ v2 v3))))))
+
+(define (chain-calls x)
+  (small-func1 
+    (small-func2 
+      (small-func3 
+        (small-func1 
+          (small-func2 x))))))
+
+(define (conditional-chain x)
+  (if (< x 10)
+      (complex-compute x 20)
+      (if (< x 20)
+          (complex-compute x 30)
+          (complex-compute x 40))))
+
+(do
+  (let ((base (+ 1 (+ 2 (+ 3 (+ 4 (+ 5 6)))))))
+    (let ((x (chain-calls base)))
+      (let ((y (repeated-expr x)))
+        (let ((z (conditional-chain y)))
+          (print 
+            (+ z (complex-compute x y))))))))

benchmarks/bcaryal-benchmark3.out

@@ -0,0 +1 @@
+1956