Lisp Praktikum 1

;; 10 * (4 + 3 + 3 + 1) - 20 = 90
* (- (* 10 (+ 4 3 3 1)) 20)
90
* 42
42      ;;evalueates to itself
* pi
3.141592653589793d0
* (/4 3)
4/3
* (/ 12 3)
4
* (/ 4 3.0)
1.3333334
* (+ 0.5 1/2)
1.0
* (+ 0.5 1/4)
0.75
* (+ 1/2 1/4)
3/4
* (* 35 1.16)
40.6
* (* 5 0.06)
0.29999998                           ;;why??? > default is single-float which is not very precise
* (* 5 0.06d0)
0.3d0                                ;;that's better
* (sqrt 2)
1.4142135
* (expt 12 32)
34182189187166852111368841966125056
* (floor 5/2)
2
1/2                                   ;;that was unexpected (type-of 5/2) >> RATIO
* (zerop 25)
NIL
* (zerop 0)
T

* 'zitrone
ZITRONE
* (quote zitrone)
ZITRONE
* (list 'apfel 'banane 'zitrone)
(APFEL BANANE ZITRONE)
* (car '(apfel banane zitrone))
APFEL
* (cdr '(apfel banane zitrone))
(BANANE ZITRONE)
* (caaddr '((apfel banane) zitrone (dattel erdbeere)))       ;;why??  >> cdr always creates an "extra" outer list 
DATTEL                                                       ;;since it has to return multiple items
                                                             ;;* (cdr '(A (B))) >> ((B))
* (length '((apfel banane) zitrone (dattel erdbeere)))
3
* (append '(apfel banane zitrone) '(dattel erdbeere))
(APFEL BANANE ZITRONE DATTEL ERDBEERE)
* (cons 'zitrone '(apfel banane))                            ;;Creates a fresh cons, the car of which is object-1 and
(ZITRONE APFEL BANANE)                                       ;;the cdr of which is object-2. 
* (reverse '(apfel banane zitrone))
(ZITRONE BANANE APFEL)

* (car (cdadar '((w (x y)))))
Y
* (cadr'((w u) y z))
Y
* (caddar'((w (x) y) u))
Y
* (caaaar '((((y))) w))
Y

;; double every entry in a list
(defun double-list (seq)
  (if (null seq) nil ;; else
    (cons (* 2 (car seq)) (double-list (cdr seq)))))

;;checks wether a number is 0, positiv or negativ
(defun sign (a)
  (cond 
    ((> a 0) '1)
    ((< a 0) '-1)
    (t '0)))
   
;;sign function like above but for a list
(defun list-sign (seq)
  (if (not(null seq))
    (cons (sign (car seq)) (list-sign (cdr seq)))))

;;recursive processing of lists, pass desired function as an argument
(defun map-list (f lst)
  (if (null lst) nil
    ;; else
    (cons (funcall f (car lst))
      (map-list f (cdr lst)))))

;;double a number
(defun double (number)
	(* number 2))

;;square root of a number
(defun sqr (number)
	(sqrt number))

;;verdoppelt jeden eintrag einer Liste
(defun double-list2 (seq)
	(map-list #'double seq))

;;zieht die Wurzel von jedem Eintrag einer Liste
(defun sqr-list2 (seq)
	(map-list #'sqr seq))

;;zeigt das vorzeichen jedes Listeneintrags an (0,-1,1)
(defun sign-list2 (seq)
	(map-list #'sign seq))

;;summiert alle Einträge einer Liste
(defun list-sum (seq)
	(if (not(null seq))
		(+ (car seq) (list-sum (cdr seq)))0))

;;Multipliziert alle Einträge einer Liste
(defun list-mult (seq)
	(if (not(null seq))
		(* (car seq) (list-mult (cdr seq)))1))

;;gibt True zurück wenn alle Einträge der Liste True sind
(defun all-true (list)
    (if (null list) t
    (and (car list)
        (all-true (cdr list)))))