| 1
|
> (defun f (x) (+ x (- 3 5)))
F
> (f 4)
2 |
|
|
|
> (defun g (x y) (+ (/ x y) (/ y x)))
G
> (g 3 4)
25/12 |
|
|
|
> (defun h (x y z) (* x (* y (/ z (* x y)))))
H
> (h 1 2 3)
3 |
|
|
|
|
| 2a
|
> (defun f (x) (* 2 x))
F
> (f 4)
8 |
|
|
|
> (defun g (x) (* x x))
G
> (g 4)
16 |
|
|
|
|
| 2b
|
> (defun sum-func (f1 f2 x) (+ (funcall f1 x) (funcall f2 x)))
SUM-FUNC
> (sum-func 'f 'g 4)
24 |
|
|
|
|
| 2c
|
> (defun maximum (x y) (if (> x y) x y))
MAXIMUM
> (maximum 3 4)
4 |
|
|
|
> (defun max-func (f1 f2 x) (maximum (funcall f1 x) (funcall f2 x)))
MAX-FUNC
> (max-func 'f 'g 4)
16 |
|
|
|
|
| 3
|
> (defun liste-sum (liste)
(if liste
(+
(car liste)
(liste-sum (cdr liste))
)
0
)
)
LISTE-SUM
> (liste-sum (list 1 2 3 4))
10 |
|
|
| Ligesom nil betyder
falsk, således betyder en ikke-tom liste modsat sandt.
|
|
| Bemærk hvordan car
og cdr indgår
på netop car
og cdr's pladser
i den nye cons vi
laver.
|
|
|
|
| 4
|
> (defun liste-func (liste f)
(if liste
(cons
(funcall f (car liste))
(liste-func (cdr liste) f)
)
nil
)
)
LISTE-FUNC
> (defun g (x) (+ x 1))
G
> (liste-func (list 1 2 3 4) 'g)
(2 3 4 5) |
|
|
| Udover funktionen: liste-func,
laver vi også en funktion: g,
til testformål.
|
|
|
|
| 5a
|
> (defun len (liste)
(if liste
(+ 1 (len (cdr liste)))
0
)
)
LEN
> (len (List 2 4 6 8 10))
5 |
|
|
|
|
| 5b
|
> (defun antal (&rest y) (len y))
ANTAL
> (antal 1 3 5 7 9)
5 |
|
|
| Man bemærker, at det er len-funktionen,
der gør hele arbejdet, mens antal
kun er katalysator for transformationen fra parameter-liste til liste.
|
|
|
|
| 6a
|
> (defun maximum (x y) (if (> x y) x y))
MAXIMUM
> (defun maximum-liste (liste)
(if liste
(maximum (car liste) (maximum-liste (cdr liste)))
0
)
)
MAXIMUM-LISTE
> (maximum-liste (list 3 5 9 7 1))
9 |
|
|
|
|
| 6b
|
> (defun maximum-parametre (&rest y) (maximum-liste y))
MAXIMUM-PARAMETRE
> (maximum-parametre 3 5 9 7 1)
9 |
|
|
| Igen er det liste-funktionen, der laver arbejdet, mens parameter-funktionen
blot er katalysator for "parameter til liste"-transformationen.
|
|
|
|
| 7
|
> (defun f (&optional x y) (if y 2 (if x 1 0)))
F
> (f 1 2)
2
> (f 1)
1
> (f)
0 |
|
|
| Bemærk, hvordan vi udnytter, at x,
henholdsvis y, evalueres
til sand/falsk alt efter om de har en rigtig værdi
eller nil.
|
|
|
|
|
8
|
> (defun f (x)
(setq i -1)
(loop
(setq i (+ i 1))
(if (> i x)
(return nil)
(print i))
)
)
F
> (f 5)
0
1
2
3
4
5
NIL |
|
|
|
> (defun f (x)
(do ((i 0 (+ i 1)))
((> i x) nil)
(print i))
)
F
> (f 5)
0
1
2
3
4
5
NIL |
|
|
|
|
|
9
|
> (defun f (x)
(do ((i 0 (+ i 1)))
((> i 10))
(print (* x i))
)
)
F
> (f 8)
0
8
16
24
32
40
48
56
64
72
80
NIL |
|
|
|
|
|
| |