;-- Ableitung von Funktionen -----------------------------------------

(define ableitung
  (lambda (ausdr var)
    (cond
      [(number? ausdr) 0]
      [(symbol? ausdr) (if (eqv? ausdr var) 1 0)]
      [(= (length ausdr) 2)
       (let ([op (car ausdr)] [term1 (cadr ausdr)])
         (case op
           [(+) (list '+ (ableitung term1 var))]
           [(-) (list '- (ableitung term1 var))]
           [(*) (list '* (ableitung term1 var))]
           [(/) (list '/ (ableitung term1 var))]
           [(sqrt) (list '/ 1 (list '* 2 (list 'sqrt term1)))]
           [(sqr) (list '* term1 2)]
           [(exp) (list '* (list 'exp term1) (ableitung term1 var))]
           [(sin) (list 'cos term1)]
           [(cos) (list '* -1 (list 'sin term1))]
           [(tan) (list '+  1 (list 'sqr (list 'tan term1)))]
           [(log) (list '/ 1 term1)]
           ;hier stehen weitere Regeln unärer Operationen
           [else
            'Unbekannt!]))]
      [(= (length ausdr) 3)
       (let ([op (car ausdr)] [term1 (cadr ausdr)] [term2 (caddr ausdr)])
         (case op
           [(+) (list '+ (ableitung term1 var) (ableitung term2 var))]
           [(-) (list '- (ableitung term1 var) (ableitung term2 var))]
           [(*) (list '+ (list '* (ableitung term1 var) term2) (list '* term1 (ableitung term2 var)))]
           [(/) (list '/ (list '- (list '* (ableitung term1 var) term2) (list '* term1 (ableitung term2 var))) (list 'exp term2 2))]
           [(expt) (cond
                       [(x? term1) (list '* term2 (list 'expt term1 (list '- term2 1)))]
                       [else (list '* (list 'expt term1 term2) (list 'log term1))])]
           [(log) (list '/ 1 (list '* term1 (list 'log term2)))]
           ;hier stehen weitere Regeln binärer Operationen
           [else
            'Unbekannt!]))]
      [else
       'Unbekannt!])))

(define x?
  (lambda (ausdr)
    (not (not (memv 'x (list ausdr))))))

;Vereinfachungsregeln
(define vereinfache
  (lambda (ausdr)
    (letrec
        ([help-unop
          (lambda (op term1)
            (case op
              [(+ *) (vereinfache term1)]
              [(/) (list '/ 1 (vereinfache term1))]
              [(sin) (cond
                       [(number? term1) (sin term1)]
                       [(and (list? term1) (= (length term1) 2) (eqv? (car term1) 'asin))
                        (vereinfache (cadr term1))]
                       [else
                        (list 'sin (vereinfache term1))])]
              [(cos) (cond
                       [(number? term1) (sin term1)]
                       [(and (list? term1) (= (length term1) 2) (eqv? (car term1) 'acos))
                        (vereinfache (cadr term1))]
                       [else
                        (list 'cos (vereinfache term1))])]
              [(exp) (cond
                       [(and (list? term1) (= (length term1) 2) (eqv? (car term1) 'log))
                        (vereinfache (cadr term1))]
                       [else
                        (list 'exp (vereinfache term1))])]
              [(sqr) (cond
                       [(and (list? term1) (= (length term1) 2) (eqv? (car term1) 'sqrt))
                        (vereinfache (cadr term1))]
                       [(number? term1) (sqr term1)]
                       [else
                        (list 'sqr (vereinfache term1))])]
              [(sqrt) (cond
                       [(and (list? term1) (= (length term1) 2) (eqv? (car term1) 'sqr))
                        (vereinfache (cadr term1))]
                       [(number? term1) (sqrt term1)]
                       [else
                        (list 'sqrt (vereinfache term1))])]


             [else
              (list op (vereinfache term1))]))]
         [help-binop
          (lambda (op term1 term2)
            (case op
              [(+) (cond
                     [(eqv? term1 0) (vereinfache term2)]
                     [(eqv? term2 0) (vereinfache term1)]
                     [(equal? term1 term2) (list '* 2 (vereinfache term1))]
                     [(and (number? term1) (number? term2)) (+ term1 term2)]
                     [else
                      (list '+ (vereinfache term1) (vereinfache term2))])]
              [(*) (cond
                     [(or (eqv? term1 0) (eqv? term2 0)) 0]
                     [(eqv? term1 1) (vereinfache term2)]
                     [(eqv? term2 1) (vereinfache term1)]
                     [(equal? term1 term2) (list 'expt (vereinfache term1) 2)]
                     [(and (number? term1) (number? term2)) (* term1 term2)]
                     [else
                      (list '* (vereinfache term1) (vereinfache term2))])]
              [(-) (cond
                     [(eqv? term1 0) (list '- (vereinfache term2))]
                     [(eqv? term2 0) (vereinfache term1)]
                     [(equal? term1 term2) 0]
                     [(and (number? term1) (number? term2)) (- term1 term2)]
                     [else
                      (list '- (vereinfache term1) (vereinfache term2))])]
              [(/) (cond
                     [(eqv? term1 0) 0]
                     [(eqv? term2 1) (vereinfache term1)]
                     [(equal? term1 term2) 1]
                     [(and (number? term1) (number? term2)) (/ term1 term2)]
                     [else
                      (list '/ (vereinfache term1) (vereinfache term2))])]
              [(expt) (cond
                     [(eqv? term1 0) 0]
                     [(eqv? term2 1) (vereinfache term1)]
                     [(eqv? term2 0) 1]
                     [(and (number? term1) (number? term2)) (expt term1 term2)]
                     [else
                      (list 'expt (vereinfache term1) (vereinfache term2))])]
              [(log) (cond
                     [(equal? term1 term2) 1]
                     [(and (number? term1) (number? term2)) (log term1 term2)]
                     [else
                      (list 'expt (vereinfache term1) (vereinfache term2))])]
              ;hier stehen weitere Vereinfachungsregeln für binäre Operationen
              [else
               (list op (vereinfache term1) (vereinfache term2))]))])
      (cond
        [(or (number? ausdr) (symbol? ausdr)) ausdr]
        [(= (length ausdr) 2) (help-unop (car ausdr) (cadr ausdr))]
        [(= (length ausdr) 3)
         (help-binop (car ausdr) (cadr ausdr) (caddr ausdr))]
        [else
         ausdr]))))

(define supervereinfache
  (lambda (ausdr)
    (if (equal? ausdr (vereinfache ausdr)) ausdr
        (supervereinfache (vereinfache ausdr)))))

(define super
  (lambda (ausdr)
    (supervereinfache (ableitung ausdr 'x))))


(super '(* (cos x) (sqrt x)))

;(define f1-term '(+ (* 3 x) (sqr (+ 1 (sqr x)))))
;(define f1 (eval (list 'lambda '(x) f1-term)))
;(define df1-term (ableitung f1-term 'x))
;(define df1 (eval (list 'lambda '(x) df1-term)))
;f1-term
;(f1 1)
;df1-term
;(df1 -1)
;(schaubild '(f1 df1) -5 5 -20 20 '("red" "blue"))

;(supervereinfache '(+ (* 3 4) (+ 2 0)))
;(supervereinfache '(sin 3.14))
;(supervereinfache '(sin (asin (* 2 x))))
;(ableitung '(+ (sqr x) (* 3 x)) 'x)
;(supervereinfache (ableitung '(+ (sqr x) (* 3 x)) 'x))

;(supervereinfache '(sin (asin (* x (expt x 1)))))