1;;;BEGIN
2;;;FRPOLY
3;;; Franz Lisp benchmark from Fateman
4;; test from Berkeley based on polynomial arithmetic.
5
6(defvar **v**)
7(defvar ***x***)
8(defvar **u***)
9(defvar frpoly-r)
10(defvar frpoly-r2)
11(defvar frpoly-r3)
12
13;;(declare (localf pcoefadd pcplus pcplus1 pplus ptimes ptimes1
14;;                ptimes2 ptimes3 psimp pctimes pctimes1
15;;                pplus1))
16;; Franz uses maclisp hackery here; you can rewrite lots of ways.
17(defmacro pointergp (x y) `(> (get ,x 'order)(get ,y 'order)))
18
19(defmacro pcoefp (e) `(atom ,e))
20(defmacro pzerop (x)
21  (let ( (var (gensym)) )
22    `(let ((,var ,x))
23       (if (numberp ,var) (zerop ,var)))));true for 0 or 0.0
24(defmacro pzero () 0)
25(defmacro cplus (x y) `(+ ,x ,y))
26(defmacro ctimes (x y) `(* ,x ,y))
27
28
29(defun pcoefadd (e c x) (cond ((pzerop c) x)
30                              (t (cons e (cons c x)))))
31
32(defun pcplus (c p) (cond ((pcoefp p) (cplus p c))
33                          (t (psimp (car p) (pcplus1 c (cdr p))))))
34
35(defun pcplus1 (c x)
36       (cond ((null x)
37              (cond ((pzerop c) nil) (t (cons 0 (cons c nil)))))
38             ((pzerop (car x)) (pcoefadd 0 (pplus c (cadr x)) nil))
39             (t (cons (car x) (cons (cadr x) (pcplus1 c (cddr x)))))))
40
41(defun pctimes (c p) (cond ((pcoefp p) (ctimes c p))
42                           (t (psimp (car p) (pctimes1 c (cdr p))))))
43
44(defun pctimes1 (c x)
45       (cond ((null x) nil)
46             (t (pcoefadd (car x)
47                          (ptimes c (cadr x))
48                          (pctimes1 c (cddr x))))))
49
50(defun pplus (x y) (cond ((pcoefp x) (pcplus x y))
51                         ((pcoefp y) (pcplus y x))
52                         ((eq (car x) (car y))
53                          (psimp (car x) (pplus1 (cdr y) (cdr x))))
54                         ((pointergp (car x) (car y))
55                          (psimp (car x) (pcplus1 y (cdr x))))
56                         (t (psimp (car y) (pcplus1 x (cdr y))))))
57
58(defun pplus1 (x y)
59       (cond ((null x) y)
60             ((null y) x)
61             ((= (car x) (car y))
62              (pcoefadd (car x)
63                        (pplus (cadr x) (cadr y))
64                        (pplus1 (cddr x) (cddr y))))
65             ((> (car x) (car y))
66              (cons (car x) (cons (cadr x) (pplus1 (cddr x) y))))
67             (t (cons (car y) (cons (cadr y) (pplus1 x (cddr y)))))))
68
69(defun psimp (var x)
70       (cond ((null x) 0)
71             ((atom x) x)
72             ((zerop (car x)) (cadr x))
73              (t (cons var x))))
74
75(defun ptimes (x y) (cond ((or (pzerop x) (pzerop y)) (pzero))
76                          ((pcoefp x) (pctimes x y))
77                          ((pcoefp y) (pctimes y x))
78                          ((eq (car x) (car y))
79                           (psimp (car x) (ptimes1 (cdr x) (cdr y))))
80                          ((pointergp (car x) (car y))
81                           (psimp (car x) (pctimes1 y (cdr x))))
82                          (t (psimp (car y) (pctimes1 x (cdr y))))))
83
84(defun ptimes1 (***x*** y) (prog (**u*** **v**)
85                               (setq **v** (setq **u*** (ptimes2 y)))
86                          a    (setq ***x*** (cddr ***x***))
87                               (cond ((null ***x***) (return **u***)))
88                               (ptimes3 y)
89                               (go a)))
90
91(defun ptimes2 (y) (cond ((null y) nil)
92                         (t (pcoefadd (+ (car ***x***) (car y))
93                                      (ptimes (cadr ***x***) (cadr y))
94                                      (ptimes2 (cddr y))))))
95
96(defun ptimes3 (y)
97  (prog (e u c)
98     a1 (cond ((null y) (return nil)))
99        (setq e (+ (car ***x***) (car y)))
100        (setq c (ptimes (cadr y) (cadr ***x***) ))
101        (cond ((pzerop c) (setq y (cddr y)) (go a1))
102              ((or (null **v**) (> e (car **v**)))
103               (setq **u*** (setq **v** (pplus1 **u*** (list e c))))
104               (setq y (cddr y)) (go a1))
105              ((= e (car **v**))
106               (setq c (pplus c (cadr **v**)))
107               (cond ((pzerop c)
108                      (setq **u***
109                            (setq **v**
110                                  (pdiffer1 **u***
111                                            (list (car **v**) (cadr **v**))))))
112                     (t (rplaca (cdr **v**) c)))
113               (setq y (cddr y))
114               (go a1)))
115     a  (cond ((and (cddr **v**)
116                    (> (caddr **v**) e))
117               (setq **v** (cddr **v**)) (go a)))
118        (setq u (cdr **v**))
119     b  (cond ((or (null (cdr u)) (< (cadr u) e))
120               (rplacd u (cons e (cons c (cdr u)))) (go e)))
121        (cond ((pzerop (setq c (pplus (caddr u) c)))
122                                        (rplacd u (cdddr u)) (go d))
123              (t (rplaca (cddr u) c)))
124     e  (setq u (cddr u))
125     d  (setq y (cddr y))
126        (cond ((null y) (return nil)))
127        (setq e (+ (car ***x***) (car y)))
128        (setq c (ptimes (cadr y) (cadr ***x***)))
129     c  (cond ((and (cdr u) (> (cadr u) e)) (setq u (cddr u)) (go c)))
130        (go b)))
131
132(defun pexptsq (p n)
133        (do ((n (floor n 2) (floor n 2))
134             (s (cond ((oddp n) p) (t 1))))
135            ;;((zerop n) s)
136            ((zerop n) nil) ;;The results make a mess when printed!
137            (setq p (ptimes p p))
138            (and (oddp n) (setq s (ptimes s p))) ))
139
140(eval-when (load eval)
141  (setf (get 'x 'order) 1)
142  (setf (get 'y 'order) 2)
143  (setf (get 'z 'order) 3)
144  (setq
145   ;; frpoly-r= x+y+z+1
146   frpoly-r (pplus '(x 1 1 0 1) (pplus '(y 1 1) '(z 1 1)))
147   ;; frpoly-r2 = 100000*r
148   frpoly-r2 (ptimes frpoly-r 100000)
149   ;; frpoly-r3 = frpoly-r with floating point coefficients
150   frpoly-r3 (ptimes frpoly-r 1.0)))
151
152;;; four sets of three tests, call:
153;;; (pexptsq frpoly-r 2) (pexptsq frpoly-r2 2) (pexptsq frpoly-r3 2)
154;;; (pexptsq frpoly-r 5) (pexptsq frpoly-r2 5) (pexptsq frpoly-r3 5)
155;;; (pexptsq frpoly-r 10) (pexptsq frpoly-r2 10) (pexptsq frpoly-r3 10)
156;;; (pexptsq frpoly-r 15) (pexptsq frpoly-r2 15) (pexptsq frpoly-r3 15)
157
158#|
159
160 (defun setup nil
161  (putprop 'x 1 'order)
162  (putprop 'y 2 'order)
163  (putprop 'z 3 'order)
164  (setq r (pplus '(x 1 1 0 1) (pplus '(y 1 1) '(z 1 1)))) ; r= x+y+z+1
165  (setq r2 (ptimes r 100000)) ;r2 = 100000*r
166  (setq r3 (ptimes r 1.0))); r3 = r with floating point coefficients
167
168;; time various computations of powers of polynomials, not counting
169;;printing but including gc time ; provide account of g.c. time.
170
171 (include "timer.lsp")
172 (timer timit1
173  (pexptsq r n) n)
174 (timer timit2
175  (pexptsq r2 n) n)
176 (timer timit3
177  (pexptsq r3 n) n)
178
179 (defun bench (n)
180 (print 'test1)
181 (timit1 n)
182 (print 'test2)
183 (timit2 n)
184 (print 'test3)(timit3 n))
185
186 (setup)
187; then (bench 2) ; this should be pretty fast.
188; then (bench 5)
189; then (bench 10)
190; then (bench 15)
191;...
192
193;;;END
194
195|#
196;;This is a cross-compiler kludge, too. The names are stupid.
197
198(defun pdiffer1 (stupidx stupidy)
199  (declare (ignore stupidx stupidy))
200  nil)
201
202