LISP EXAMPLES


Script started on Thu Sep 26 10:41:12 1996

vestavia% cat min.lsp
(defun min (x y)
    (cond
        ((< x y) x)
        (t y)))

vestavia% gcl
GCL (GNU Common Lisp)  Version(2.2) Thu Mar 28 13:41:41 CST 1996
Licensed under GNU Public Library License
Contains Enhancements by W. Schelter
>(load "min")
Loading min.lsp
Warning: MIN is being redefined.
Finished loading min.lsp
T
>(min 17 45)
17
>(min 0 1)
0
>(min 65 3)
3
>^D

vestavia% cat factorial.lsp
(defun factorial (n)
    (cond
        ((= n 0) 1)
        (t (* n (factorial (- n 1))))))

vestavia% gcl
GCL (GNU Common Lisp)  Version(2.2) Thu Mar 28 13:41:41 CST 1996
Licensed under GNU Public Library License
Contains Enhancements by W. Schelter
>(load "factorial")
Loading factorial.lsp
Finished loading factorial.lsp
T
>(factorial 5)
120
>(factorial 10)
3628800
>^D

vestavia% cat length.lsp
(defun length (list)
    (cond
        ((null list) 0)
        (t (+ 1 (length (cdr list))))))

vestavia% gcl
GCL (GNU Common Lisp)  Version(2.2) Thu Mar 28 13:41:41 CST 1996
Licensed under GNU Public Library License
Contains Enhancements by W. Schelter
>(load "length")
Loading length.lsp
Warning: LENGTH is being redefined.
Finished loading length.lsp
T
>(length '(a b c d))
4
>(length '(a (b c)))
2
>(length nil)
0
>(length '(a (b c) d (e f (g h))))
4
>^D

vestavia% gcl
GCL (GNU Common Lisp)  Version(2.2) Thu Mar 28 13:41:41 CST 1996
Licensed under GNU Public Library License
Contains Enhancements by W. Schelter
> (setq a (cons 'x nil))
(x)
> (setq b (cons 'y a))
(y x)
> (setq c (append b 'z))
(y x . z)
> (car c)
y
> (cadr c)
x
> (cddr c)
z
> (setq d (append b '(z)))
(y x z)
> (setq e (cons d d))
((y x z) y x z)
> (setq f (append d d))
(y x z y x z)
> (setq g (cons d (list d)))
((y x z) (y x z))
> (car g)
(y x z)
> (cdr g)
((y x z))
> (cadr g)
(y x z)
> (caadr g)
y
> (cdadr g)
(x z)
> ^D

vestavia% gcl
GCL (GNU Common Lisp)  Version(2.2) Thu Mar 28 13:41:41 CST 1996
Licensed under GNU Public Library License
Contains Enhancements by W. Schelter
>(setq add '(lambda (x y) (+ x y)))
(LAMBDA (X Y) (+ X Y))
>(car add)
LAMBDA
>(cdr add)
((X Y) (+ X Y))
>(cadr add)
(X Y)
>(cddr add)
((+ X Y))
>(caadr add)
X
>(cdadr add)
(Y)
>(caddr add)
(+ X Y)
>(caaddr add)
+
>(apply add '(3 4))
7
>(eval '(apply add '(3 4)))
7
>^D

vestavia% cat postfix.lsp
; postfix converts a postfix expression, represented as a list of
; operands and operators, into a syntax tree.

(defun postfix (exp) (car (postfixstack exp nil)))

; postfixstack scans the expression to build the syntax tree. If the
; expression symbol is an operator, then it is for the top two operands
; of the stack and a new tree can be constructed. If the expression symbol
; is an operand (i.e. anything besides an operator), then it is pushed
; on the stack for later processing.

(defun postfixstack (exp stack)
    (cond
        ((null exp) stack)
        (t
            (cond
                ((eq (car exp) '+)
                    (postfixstack (cdr exp)
                        (cons (list '+ (cadr stack) (car stack)) (cddr stack))))
                ((eq (car exp) '-)
                    (postfixstack (cdr exp)
                        (cons (list '- (cadr stack) (car stack)) (cddr stack))))
                ((eq (car exp) '*)
                    (postfixstack (cdr exp)
                        (cons (list '* (cadr stack) (car stack)) (cddr stack))))
                ((eq (car exp) '/)
                    (postfixstack (cdr exp)
                        (cons (list '/ (cadr stack) (car stack)) (cddr stack))))
                (t (postfixstack (cdr exp) (cons (car exp) stack)))))))

vestavia% gcl
GCL (GNU Common Lisp)  Version(2.2) Thu Mar 28 13:41:41 CST 1996
Licensed under GNU Public Library License
Contains Enhancements by W. Schelter

>(load "postfix")
Loading postfix.lsp
Finished loading postfix.lsp
T

>(postfix '(a b c * +))
(+ A (* B C))

>(postfix '(a b + c * d / e -))
(- (/ (* (+ A B) C) D) E)

>^D

vestavia% exit
script done on Thu Sep 26 10:55:28 1996