adding lisp-interpreter

lisp-interpreter/test.lisp

@@ -0,0 +1,78 @@
+; a1 a2 ... an
+
+; We must end up with n multiplications of three numbers.
+; Each one must have a distinct ai in the middle.
+; (* aj ai ak) where j < i and i < k.
+
+; The neighboring elements are determined by the order of selection,
+; so we can just look at the order of select elements. This is all the permutations
+; of i in [1...n] so n! total possibilites.
+
+; However, this also tells us how to estimate.
+
+
+(defun smallest-index (array)
+  "requires: array is non-empty"
+    (prog ((smallest 0)
+           (i 0)
+           (N (length array)))
+          loop
+          (when (>= i N) 
+              (return smallest))
+          (when (< (aref array i) (aref array smallest))
+              (setf smallest i))
+          (incf i)
+          (go loop)))
+
+(defun ref (array i)
+  (if (or (< i 0) (>= i  (length array)))
+      1
+      (aref array i)))
+
+(defun estimate (array)
+    (if (= (length array) 1)
+        (aref array 0)
+        (let ((i (smallest-index array)))
+          (+
+            (*
+              (ref array i)
+              (ref array (- i 1))
+              (ref array (+ i 1)))
+
+            (estimate (concatenate 'vector
+                                   (subseq array 0 i) 
+                                   (subseq array (+ i 1))))))))
+
+(defun upper-bound (array)
+  (loop for i from 0 below (length array) sum
+        (* (reduce #'max (subseq array 0 i) :initial-value 1)
+           (aref array i) 
+           (reduce #'max (subseq array (+ i 1)) :initial-value 1))))
+
+(defun upper-bound2 (array)
+  (let ((N (length array))
+        (x (reduce #'max array)))
+    (+ (* (- N 2) (* x x x))
+       (* (* x x))
+       (* x))
+    ))
+
+(defun lower-bound2 (array)
+  (let ((N (length array))
+        (x (reduce #'min array)))
+    (+ (* (- N 2) (* x x x))
+       (* (* x x))
+       (* x))))
+
+
+
+
+(print (estimate #(5 3 2 8)))
+(print (estimate #(10 10 10 10 10 10)))
+
+;(print (upper-bound #(5 3 2 8)))
+
+
+
+;(print (lower-bound2 #(10 10 10 10 10 10)))
+;(print (upper-bound2 #(10 10 10 10 10 10)))