(print (list 'practica 'de 'lisp))
(print (list 'realizada 'por))
(print (list 'Carmen 'Blanco 'Vives))
(print (list 'Alejandro 'Sobrino 'Beltran))
(print (list 'Ruben 'Toribio 'Aldeguer))

;		abans
; DESCR: función encargada de encontrar los elementos que estén antes del símbolo x
; PRE: lista
(defun abans (x l)
	(cond ((null l) ())
		((equal x (car l)) ())
		(t (cons (car l) (abans x (cdr l))))
	)
)
; POST: devuelve una lista que contiene los elementos que están antes del símbolo x



; 		despres
; DESCR: función encargada de encontrar los elementos que estén después del símbolo x
; PRE: lista 
(defun despres (x l)
	(cond ((null l) ())
		((equal x (car l)) (cdr l))
		(t (despres x (cdr l)))
	)
)
; POST: devuelve una lista que contiene los elementos que están después del símbolo x



;		prefixa
; DESCR: función encargada de pasar una expresión de inorden a preorden
; PRE: expresión en inorden
(defun prefixa (l)
	(cond ((null l) ())																	; caso básico
		((member '+ l) (list '+ (prefixa (abans '+ l)) (prefixa (despres '+ l))))		; (A + B) -> (+ A B)
		((member '- l) (list '- (prefixa (abans '- l)) (prefixa (despres '- l))))		; (A - B) -> (- A B)
		((member '* l) (list '* (prefixa (abans '* l)) (prefixa (despres '* l))))		; (A * B) -> (* A B)
		((member '/ l) (list '/ (prefixa (abans '/ l)) (prefixa (despres '/ l))))		; (A / B) -> (/ A B)
		((member '^ l) (list '^ (prefixa (abans '^ l)) (prefixa (despres '^ l))))		; (A ^ B) -> (^ A B)
		(t (car l))																		; caso básico
	)
)
; POST: expresión en preorden



;		deriva
; DESCR: función encargada de derivar una expresión en preorden
; PRE: expresión en preorden a derivar
(defun deriva (l)
	(cond ((null l) ())															; caso básico
	    ((numberp l) 0)															; caso básico
		((atom l) 1)															; caso básico
		((equal (car l) '+) (list '+ (deriva (cadr l)) (deriva (caddr l))))		; (A + B)' = A' + B'
		((equal (car l) '-) (list '- (deriva (cadr l)) (deriva (caddr l))))		; (A - B)' = A' - B'
		((equal (car l) '*) (list '+ (list '* (deriva (cadr l)) (caddr l)) (list '* (cadr l) (deriva (caddr l))) )) 	; (A * B)' = (A' * B) + (A * B')
		((equal (car l) '/) (list '/ (list '- (list '* (deriva (cadr l)) (caddr l)) (list '* (cadr l) (deriva (caddr l))) (list '^ (caddr l) 2)) ))	; (A / B)' = ((A' * B) - (A * B')) / B ^ 2
		((equal (car l) '^) (list '* (caddr l) (list '^ (cadr l) (list '- (caddr l) 1))))								; (A ^ B)' = B * (A ^ (B - 1))
	)
)
; POST: expresión en preorden derivada



;		simplifica-suma
; DESCR: función encargada de comprobar los casos básicos de una suma
; PRE: expresión suma sin simplifica
(defun simplifica-suma (l)
	(cond ((equal (simplifica (cadr l)) '0) (simplifica (caddr l)))					; 0 + B = B
		((equal (simplifica (caddr l)) '0) (simplifica(cadr l)))						; A + 0 = A
		((AND (simplifica (numberp (cadr l))) (simplifica (numberp (caddr l)))) (eval (+ (simplifica (cadr l)) (simplifica (caddr l)))))	; calcular a + b si son constantes
		(t (list '+ (simplifica (cadr l)) (simplifica (caddr l))))					; en caso contrario
	)
)
; POST: expresión suma simplificada



;		simplifica-resta
; DESCR: función encargada de comprobar los casos básicos de una resta
; PRE: expresión resta sin simplifica
(defun simplifica-resta (l)
	(cond ((equal (simplifica (caddr l)) '0) (simplifica (cadr l)))					; A - 0 = A
		((equal (simplifica (cadr l)) (simplifica (caddr l))) 0)						; si A = B -> A - B = 0
		((AND (simplifica (numberp (cadr l))) (simplifica (numberp (caddr l)))) (eval (- (simplifica (cadr l)) (simplifica (caddr l)))))	; calcular a - b si son constantes
		(t (list '- (simplifica (cadr l)) (simplifica (caddr l))))					; en caso contrario
	)
)
; POST: expresión resta simplificada



;		simplifica-prod
; DESCR: función encargada de comprobar los casos básicos de una multiplicación
; PRE: expresión producto sin simplifica
(defun simplifica-prod (l)
	(cond ((equal (simplifica (cadr l)) '1) (simplifica (caddr l)))					; 1 * B = B
		((equal (simplifica (caddr l)) '1) (simplifica (cadr l)))						; A * 1 = A
		((equal (simplifica (cadr l)) '0) 0)											; 0 * B = 0
		((equal (simplifica (caddr l)) '0) 0)											; A * 0 = 0
		((AND (simplifica (numberp (cadr l))) (simplifica (numberp (caddr l)))) (eval (* (simplifica (cadr l)) (simplifica (caddr l)))))	; calcular a * b si son constantes
		(t (list '* (simplifica (cadr l)) (simplifica (caddr l))))					; en caso contrario
	)
)
; POST: expresión producto simplificada



;		simplifica-div
; DESCR: función encargada de comprobar los casos básicos de una división
; PRE: expresión división sin simplifica
(defun simplifica-div (l)
	(cond ((equal (simplifica (caddr l)) '1) (simplifica (cadr l)))					; A / 1 = A
		((equal (simplifica (cadr l)) '0) 0) 											; 0 / B = 0
		;((AND (numberp (cadr l)) (numberp (caddr l))) (eval (/ (cadr l) (caddr l))))	; calcular a / b si son constantes MIRAR DE PONER SIMPLIFICAR
		((AND (simplifica (numberp (cadr l))) (simplifica (numberp (caddr l)))) (eval (/ (simplifica (cadr l)) (simplifica (caddr l)))))	; calcular a / b si son constantes MIRAR DE PONER SIMPLIFICAR
		(t (list '/ (simplifica (cadr l)) (simplifica (caddr l))))					; en caso contrario
	)
)
; POST: expresión división simplificada



;		simplifica-exp
; DESCR: función encargada de comprobar los casos básicos de una exponencial
; PRE: expresión exponencial sin simplifica
(defun simplifica-exp (l)
	(cond ((equal (simplifica (cadr l)) '1) 1) 										; 1 ^ B = 1
		((equal (simplifica (cadr l)) '0) 0) 											; 0 ^ B = 0
		((equal (simplifica (caddr l)) '0) 1)											; A ^ 0 = 1 
		((equal (simplifica (caddr l)) '1) (simplifica (cadr l)))						; A ^ 1 = A
		;((AND (numberp (cadr l)) (numberp (caddr l))) (eval (^ (cadr l) (caddr l))))	; calcular a ^ b si son constantes MIRAR DE PONER SIMPLIFICAR
		((AND (simplifica (numberp (cadr l))) (simplifica (numberp (caddr l)))) (eval (^ (simplifica (cadr l)) (simplifica (caddr l)))))	; calcular a ^ b si son constantes MIRAR DE PONER SIMPLIFICAR
		(t (list '^ (simplifica (cadr l)) (simplifica (caddr l))))					; en caso contrario
	)
)
; POST: expresión exponencial simplificada
		


;		simplifica
; DESCR: función encargada de simplifica los casos básicos de una expresión
; PRE: lista con expresión sin simplifica
(defun simplifica (l)
	(cond ((null l) ())								; caso básico
		((numberp l) l)								; caso básico
		((atom l) l)								; caso básico
		((equal (car l) '+) (simplifica-suma l))	; comprobamos las simplificaciones básicas de la suma
		((equal (car l) '-) (simplifica-resta l))	; comprobamos las simplificaciones básicas de la resta
		((equal (car l) '*) (simplifica-prod l))	; comprobamos las simplificaciones básicas de la multiplicación
		((equal (car l) '/) (simplifica-div l))		; comprobamos las simplificaciones básicas de la división
		((equal (car l) '^) (simplifica-exp l))		; comprobamos las simplificaciones básicas del exponencial
	)
)
; POST: lista con expresión simplificada



;  		infixa
; DESCR: función encargada de pasar una expresión en preorden a inorden
; PRE: lista con la expresión en preorden
(defun infixa (l)
	(cond ((null l) ())
		((numberp l) (list l))						; caso básico: el list es necesario, ya que el append espera una lista como parámetro
		((atom l) (list l))							; caso básico: ver comentario anterior
		(t (append (infixa (cadr l)) (append (list (car l)) (infixa (caddr l)))))	; construimos la lista reordenando sus elementos
	)
)
; POST: expresión dada en inorden



;		deriva-be 
; DESCR: función encargada de realizar las llamadas a todas las funciones
; PRE: recibimos una lista con la expresión a derivar (en inorden)
(defun deriva-be (l)
	(infixa (simplifica (deriva (prefixa l))))
)
; POST: derivada de la expresión calculada (en inorden)