1 Lisp Functions –Built-in functions –Defining functions –Function Evaluation and Special...
-
Upload
wendy-roberts -
Category
Documents
-
view
225 -
download
0
Transcript of 1 Lisp Functions –Built-in functions –Defining functions –Function Evaluation and Special...
1
Lisp • Functions
– Built-in functions– Defining functions– Function Evaluation and Special Forms
• defun, if
• Control statements– Conditional
• if , cond
– Repetition (loops)• do
– Sequence• prog
2
The CONS Cell – List Building • Cons
– A pair of pointers:• the first is the car, and
• the second is the cdr
• Atom– Basic lisp entity
• a symbol, a number (real, rational (ratio integer), float, complex), a vector, an array, a character, a string
• Everything that is not a cons
(defun our-atomp (x) (not (consp x)))
• List– An ordered collection of atoms or lists (the elements of the list)– A list is either nil or a cons
(defun our-listp (x) (or (null x) (consp x)))
a b
3
Basic List Processing Functions• list
– takes any number args, returns a list:– (list 'x 'y 'z) => (X Y Z)– (list (list 'x 'y) (list 'x 'y)) => ((X Y) (X Y))
• car (or first)– returns the first element of a list– (car (list 'x 'y)) => X
• cdr (or rest) – everything but first element:– (cdr '(a b c)) => (B C)
• cons– prepends a symbol to a list– (cons (list 'x 'y) (list 'x 'y)) => ((X Y) X Y)
4
cons and car• (setf x (cons 'a nil))
(A)
• (setf x (cons (car x) '(b c)))
(A B C)
a
x nil
a
x
b c
nil
5
cdr and list• (setf y (list 'a (list 'b 'c) 'd))
(A (B C) D)• (setf z (car (cdr y)))
(B C)
• (eql z (cdr x))
NIL• (equal z (cdr x))
T• (eql z (car (cdr y)))
T
y
d
nil
nil
a
z
b c
6Predicate Functions listp and null
• listp – takes one parameter– it returns
• T if the parameter is a list• NIL otherwise
• null– takes one parameter– it returns
• T if the parameter is the empty list• NIL otherwise
– Note that null returns T if the parameter is ()!• What is this equivalent to?
7Examples - cons, car, cdr, consp
• (setf x (cons 'a 'b))
(A . B)• (car x)
A• (cdr x)
B
• (setf y (cons 'a (cons (cons 'b 'c) (cons 'd 'e))))
(A (B . C) D . E)
• (setf z (car (cdr y)))
(B . C)• (consp (cdr y))
T• (consp (cdr z))
NIL
y
a b
y
a d e
b c
8
List Processing Functions, cont.• append
– takes any number of lists as arguments – returns them appended together
(append '(a b c) '(d e f)) => (A B C D E F)
• equal– takes two arguments– returns T if they are structurally equal or of
equal value
9
Sublists• (list (list 'blue 'sky)
(list 'green 'grass)
(list 'brown 'earth))
((blue sky) (green grass) (brown earth))
sky
nil
blue grass
nil
green earth
nil
brown
nil
10
Cons Cells and Lists as Trees• Binary tree
– car as the left subtree,– cdr as the right subtree
• (setf x
'(((a) ((b) (c)))
((d (e)) f))) x
c
nil
b
nila
nil
f
nil
e
nild
11
SDRAW program• See the structure of anything
– sdraw.lisp – available at
• www2.hawaii.edu/~janst/313/lisp/sdraw.lisp
– (from
• Common Lisp: A Gentle Introduction to Symbolic Computation by David S. Touretzky
• Benjamin/Cummings Publishing Co., 1990.)
• Save a copy to your account and try it out
12(sdraw:sdraw '(2 (a b) 3))
> (sdraw:sdraw '(2 (a b) 3))
[*|*]--->[*|*]------------------>[*|*]--->NIL
| | |
v v v
2 [*|*]--->[*|*]--->NIL 3
| |
v v
A B
13Predicate Functions – usually end in P Return NIL or something else (True)
• What type is it? (typep … )• Is it a list? (listp … )• Is it a number? (numberp … )• Is it an integer? (integerp … )• Is it a string? (stringp … )• Is it an atom? (atom … )• Is it nil? (null … )• etc.
14Predicate Functions eq and equal
• eq takes two symbolic parameters;– returns T if both parameters are atoms and the two
are the same
e.g., (eq 'a 'a) yields T
(eq 'a 'b) yields NIL– Note that if eq is called with list parameters, the result
is not reliable– Also eq does not work for numeric atoms
• equal takes two parameters– Returns T if both parameters “look/print the same”– Works on lists, structures, etc.– Try equal first
15
Functions Return a Value• Is arg a list? (listp <arg> )
– (listp "foo") => NIL
• Is arg the empty list? (null <arg> )– (null nil) => T
• Return new list with all args (list <args>* )– (list 4 5 6) => (4 5 6)
• Return first item (car <arglist> )– (car (list 4 5 6)) => 4
• Return new list with everything except the first item (rest)
(cdr <arglist> )– (cdr (list 4 5 6)) => (5 6)
• Return new list with arg1 1st, then everything in arg2
(cons <item> <inlist> )– (cons 5 (list 4 5 6) ) => (5 4 5 6)
• These functions do not have side effects
16
Function Definition• To create a named function, use defun:
(defun <name> (<param list>) <docu> <forms>)
>(defun sumsq (x y)
"Returns sum of X and Y squared."
(+ (* x x) (* y y)))
SUMSQ
• The documentation string is saved in the environment and can be recalled with(documentation (quote <name>) 'function)
>(documentation 'sumsq 'function)
"Returns sum of X and Y squared."
17
Special forms• Already used one – defun!• Syntax is the same as function calls
(<special word> <arg1> <arg2> …)• Special word is one of:
-defun, if, let, function, quote, setq, setf, etc.
• Not evaluated in the same way as functions
(i.e. lazy - not eager evaluation)• Quiz - What would happen with eager evaluation here:
(if (> x 0)
(/ 10 x)
x)
• Why can’t eager evaluation be used for if ?
18
Special Form - quote • quote takes one parameter and the entire
expression evaluates to the parameter– (quote (a b c)) => (A B C) – '(a b c) => (A B C) ; alternate syntax
• quote can’t work under eager evaluation. Why?• quote allows us to represent functions as data
– (+ 1 2) is a program (computes 3 when evaled)– '(+ 1 2) is data (the list of three elements)– (+ 2 (+ 1 2)) is 5, but– (+ 2 '(+ 1 2)) is an error (why?)
19
More Lisp Features• Execution flow control
– order of code execution• Sequence (statement by statement)• Selection (conditionals)• Iteration (repetition, loops)
• Declaration – create new variables, functions
• Assignment – assign values to variables
• Input/Output – read from the keyboard/files– write to the screen/files
20
Iteration Examples(do ((x 0) (y 99 -1)) (= x 100)
(setf (aref a x) (aref b y))
(when (= (aref a x) 15)
(return)))
(dotimes (x 100)
(format t "~%Number: ~a" x))
(loop do
(setq x (next-leaf my-tree))
(format t "~%This one? ~a" x)
while x)
(loop while (/= x 3) do
(terpri) (princ "Guess Again!")
(setq x (read)))
21
(defun compute-pi (hex-digit)
(print (bbb-pi
hex-digit) ) )
(defun bbb-pi (n)
(let ((result 0.0))
(dotimes (x n)
(incf result (* (expt (/ 1.0 16) x)
(- (/ 4.0 (+ 1 (* 8 x)))
(/ 2.0 (+ 4 (* 8 x)))
(/ 1.0 (+ 5 (* 8 x)))
(/ 1.0 (+ 6 (* 8 x)))))))
result))
(compute-pi 9)
The “Miraculous”
Bailey-Borwein-Plouffe (BBP)
Pi Algorithm
• Can find the nth hexadecimal digit of π without knowing digits 0...n-1!
• Recently computed 10 billionth hexadecimal digit of π
(it’s 9)
dotimes Example
22
Conditional statements - if• if special form:
– (if <test>
<then form>
<else form> )
– (if (= x 0)
0
(/ 10 x))
– Evaluates <test>• if true, evaluate <then form>• if false, evaluate < else form>
23Conditional statements - cond
• cond special form syntax:• (cond <cond-clause>*)
where <cond-clause> is (<test form> <form>*)
• Example• (cond
((= x 1)
(print "x is a small number"))
((>= x 2)
(print "x is a larger number")))
24
Evaluation of cond • (cond
((= x 1)
(print "x is a small number"))
((>= x 2)
(print "x is a larger number")))• Evaluate test in first clause (= x 1)
– If true, execute all other statements in the same clause,– Returns the result of last statement in that clause
• Else, evaluate the test in the next clause (= x 2)– If true, execute all other statements in the same clause,– Returns result of last statement in that clause
• Repeat until the first true test or until out of clauses
25
Function eval• Mostly used in Lisp’s REPL loop • eval can be called separately
– quote prevents the evaluation
> (setf s1 '(cadr '(one two three)))(CADR '(ONE TWO THREE))
> (eval s1)TWO
> (eval (list
'cdr (car
'((quote (a . b)) c))))B
• What is the result of– (eval (quote (list list)))