T1 primer tutorial de lisp-grupo6

INTELIGENCIA ARTIFICIAL - CICLO 2012-I - GRUPO 6


• Para salir escriba (exit)

• Pruebe un comando de ejemplo como la multiplicación :

(* 5 6 20) => 600

• La anterior instrucción hará una multiplicación de los tres números devolviendo 600 como resultado.

• Tenemos 2 tipos de datos: Atómicos y Listas


b,4, color-casa ,etc.

Al evaluar un tipo de dato atómico, nos devuelve el valor que se le ha asignado. Los números son un caso especial, siempre devuelven el mismo valor.

20 = > 20

Si ponemos “edad-hermano” sin definirla con un valor, devuelve:

edad-hermano => Error (variable not defined)

Se asigna un valor con el comando:

(setq edad-hermano 19)=> 19

edad-hermano => 19

Existen palabras reservadas como nil , T, etc.

No se distinguen mayúscula y minúsculas: las variables ola y Ola son la misma.


(b), ( * 9 8) , (casa ( silla mesa e) j ), (), nil

• nil es a la vez un valor atómico y una lista : ()

• La evaluación de una lista siempre invoca una función.

(nombre-de-la-función argumento1…argumento n)

(* 50 10) => 5

(e 45,46,47) => Error (function not defined)

(+ edad-hermano 8) => 27

• Cuando evaluamos una lista, primero evaluamos los argumentos para después aplicar la función


• Lisp incluye operadores como +, - , * , /

• Además, incluye varias operaciones importantes.

Cons construye una lista de datos con una cola.

(cons 10 (cons 12 nil)) => (10 12)

Hay que tener en cuenta que el valor de la cola que significa 'nada' es nulo.

Si probamos con átomos que no están reservados.

(cons Jose nil) => Error: variable a is not defined.

¿Por qué sale ese error?


Tenemos que decirle al intérprete que no evalúe al átomo Jose. Para ello se pone adelante ‘

(cons ‘Jose nil) => (JOSE)

De forma abreviada se puede aplicar a una lista completa :

(cons ‘Jose ‘(Pepe Marta Carlos ))=> (JOSE PEPE MARTA CARLOS)

Veremos diferencias entre list y append.

(list ‘Jose ‘Marta ‘Carlos) => (JOSE MARTA CARLOS)

(list ‘Jose ‘(Marta Carlos)) => (JOSE (MARTA CARLOS))

(append ‘(Jose Marta) ‘(Carlos Carmen))=> (JOSE MARTA CARLOS CARMEN)

La diferencia es que append, usa a listas como argumentos para formar otra lista.


Si queremos listar, pero uno de los elementos a listar es resultado de una operación, se pondrá entre paréntesis. Por ejemplo:

(list ‘Jose ‘24 (* edad-hermano 3) ‘ Marta ‘24) => (JOSE 24 75 MARTA 24)

Una coma dentro de un par de paréntesis antepuesto por una apóstrofe, le dice a Lisp que, tiene evaluar lo que le sigue a la coma. Por ejemplo:

‘(Jose 24 ,(* edad-hermano 3) Marta 24)=> (JOSE 24 75 MARIA 24)


Una vez que tenemos una lista construida, ¿Cómo accedemos a los miembros de la lista?

• first : Primero de una lista.

(first ‘(Jose Marta Carlos)) => JOSE

(first ‘((Jose Marta Carlos) Carmen) )=> (JOSE MARTA CARLOS)

• rest : Toda la lista menos el primer elemento

(rest ‘(Jose Marta Carlos)) => (MARTA CARLOS)

(rest ‘((Jose Marta Carlos) Carmen) )=> (CARMEN)

• car y cdr se pueden combinar

(caar '((Jose Marta ) Carmen Miguel)) => JOSE (cdar '((Jose Marta ) Carmen Miguel)) => (MARTA)

Se tiene que trabajar desde la derecha hacia la izquierda.


• Por ejemplo, si escribimos:

(setq listaPrueba ‘(Ana Carla Patricia)) => (ANA CARLA PATRICIA)

(cons ‘Marcos listaPrueba) => (MARCOS ANA CARLA PATRICIA)

listaPrueba => (ANA CARLA PATRICIA)

• No tiene efectos secundarios, la lista no cambió. Necesitamos setq para cambiar el valor de un átomo.

• setf es una versión de setq que tiene una función como primer argumento.

(setf (cadr listaPrueba) ‘Antonio) => ANTONIO

listaPrueba => (ANA ANTONIO PATRICIA)


• A continuación veremos 2 tipos de igualdad

(eq ‘Marta ‘Carlos) => nil

(eq ‘(jose) ‘(Jose)) => nil

(eq ‘Jose ‘JoSe) => T

(equal ‘Carlos ‘Carlos) => T

(equal ‘(Marta) ‘(Marta)) => T

(equal ‘(alumno profesor) ‘(alumno profesor)) => T

• (equal x, y) es T cuando (eq x y) es verdadero y cuando las cosas se escriben iguales son verdaderas .


• ¿Se puede el tratar a una lista como un conjunto, es decir, sin preservar el orden?

(union ‘(Marta Carla) ‘(Marta Luis Juan)) => (JUAN LUIS MARTA CARLA)

(union ‘((Marta) (Carmen)) ‘((Marta))) => ((MARTA) (MARTA) (CARMEN))

(union ‘((Marta) (Carmen)) ‘((Marta)) :test ‘equal) => ((MARTA) (CARMEN))

• La condición de prueba para determinar si los 2 elementos en el conjunto son los mismos es la función equal.

(adjoin ‘Marta ‘(Marta Carla Juan)) => (MARTA CARLA JUAN)

(set-difference ‘(Juan Marta Carla ) ‘(Marta Pedro Carla)) => (JUAN)

• adjoin y set-difference también pueden usar :test ‘equal. Incluso puede proporcionar su propia función.


(length ‘(Richard Cecilia Alonso)) => 3

(atom ‘1) => T

(atom ‘(Richard Cecilia Alonso)) => NIL

(listp ‘inteligencia) => NIL

(listp ‘(IA Modelos Redes)) => T


(<= Alonso (and Bruno Carmen))

(not (not Daniel))

(or Pablo (not Pedro) Marcos)

(list ‘<= ‘Alonso (list ‘and ‘Bruno ‘Carmen)) => (<= ALONSO (AND BRUNO CARMEN))

(list ‘not (list ‘not ‘Daniel)) => (NOT (NOT DANIEL))

(list ‘or ‘Pablo (list ‘not ‘Pedro) ‘Marcos) => (OR PABLO (NOT PEDRO) MARCOS)

Tener en cuenta que los operadores KIF =>, <=, <=>, and, or, not serán siempre el primer elemento de la lista.


(defun <nombre> <documentación-de-cadena> (<argumentos>) <cuerpo>)

(defun cubo (dato1) (* dato1 dato1 dato1))

cubo 6 => 216

Tenga en cuenta que no tenemos que citar a ninguno de los argumentos de defun. Se atiende de forma automática.

La evaluación de una función para un conjunto de argumentos como resultado en la última expresión valuada en el función de seguimiento.


(if <expresión> <entonces - expresión> <de lo contrario - expresión>)

Por ejemplo:

setq dat1 5 => 5

setq dat2 6 => 6

(if (> dat1 dat2) (- dat1 dat2) (* dat1 dat2)) => 30

(if (> 3 4) (+ 3 4) (- 3 4)) => -1

(if (eq 3 3) (+ 20 1) (/ 10 2)) => 21


La evaluación de cond evalúa las pruebas hasta que una de ellas se evalúe como verdadera. A continuación, se evalúa cada uno de las formas adecuadas; la última evaluación es el valor de toda la función cond.

Por ejemplo:

setq listaN ‘(25 12 100 20) => (25 12 100 20)

listaN => (25 12 100 20)

car listaN => 25

atom listaN => NIL

listp listaN => T

( cond ( (atom listaN) NIL) ((listp listaN) (car listaN)) (T NIL) ) => 25

T1 primer tutorial de lisp-grupo6

Education

Transcript of T1 primer tutorial de lisp-grupo6