PRACTICA-3.TXT 
 Reglas en CLIPS.
===============================================================================


*******************************************************************************
* PROBLEMA 1:
*******************************************************************************

 Implimentar el tipo de dato pila, para ello será necesario utilizar una
   plantilla adecuada para representar el tipo de dato. Escribir reglas CLIPS
   que sirvan para añadir y para eliminar elementos, utilizando para ello
   hechos de la forma "(poner-valor ?pila ?valor)" y "(quitar-valor ?pila)",
   respectivamente. 
 Cargar el programa en CLIPS y utilizarlo para crear la pila vacía, apilar los
   elementos A, B y C y después desapilarlos. Intentar desapilar un elemento de
   la pila vacía, debería dar un mensaje de error. 

*******************************************************************************
* PROBLEMA 2:
*******************************************************************************

 Escribir una o más reglas que generen todas las permutaciones de una lista de
   elementos. Por ejemplo para la lista (rojo verde azul) se tendría que
   generar la salida: 
     Una permutación es rojo verde azul
     Una permutación es rojo azul verde
     Una permutación es verde azul rojo
     Una permutación es verde rojo azul
     Una permutación es azul rojo verde 
     Una permutación es azul verde rojo
   aunque no necesariamente en dicho orden.
 Cargar el programa en CLIPS y ejecutarlo para permutar la lista (rojo verde
   azul). Hacer un seguimiento de las activaciones de las reglas y comentar
   la salida.

*******************************************************************************
* PROBLEMA 3:
*******************************************************************************

 Consideremos los conjuntos representados usando el siguiente patrón de hecho:
   (deftemplate conjunto
     (slot nombre
       (type SYMBOL))
     (multislot elementos
       (type SYMBOL)
       (default ?DERIVE)))
 Escribir una o más reglas en CLIPS para:
 - calcular la unión de dos conjuntos dados en un hecho de la forma
     (union <conjunto-1> <conjunto-2>).
 - calcular la intersección de dos conjuntos dados en un hecho de la forma
     (interseccion <conjunto-1> <conjunto-2>).

*******************************************************************************
* PROBLEMA 4:
*******************************************************************************

 El algorimo de ordenación de la burbuja actúa como sigue:
   1. Si existen elementos consecutivos del vector de datos que no se
      encuentren en el orden deseado, 
   1.1. considerar dos elementos en dicha situación, permutarlos y volver al
        punto 1.; 
   1.2. en caso contrario el algoritmo ha terminado.
 Cargar el programa en CLIPS y ejecutarlo para ordenar la siguiente lista de
   números: 20 19 18 17 16 15 14 13 12 10 9 8 7 6 5 4 3 2 1 0 -1 -2 -3 -4
   -5 -6 -7 -8 -9 -10.
 Examinar el número de reglas ejecutadas con (watch statistics).

*******************************************************************************
* PROBLEMA 5:
*******************************************************************************

 Convertir el siguiente árbol de decisión para la clasificación de animales en
   un conjunto de reglas CLIPS. Crear condiciones que equiparen con hechos de
   la forma (pregunta (texto <pregunta>) (respuesta <respuesta>)).
 Arbol de decisión:
 ¿ Es muy grande ? 
   |          |
   |          |<- No
   |          |
   |        ¿ Emite chillidos ?
   |          |          |
   |          |          |<- Si
   |          |          |
   |          |<- No   Posiblemente es un ratón.
   |          |
   |<- Si   Posiblemente es una ardilla.
   |
 ¿ Tiene un cuello largo ? 
   |          |
   |          |<- Si
   |          |
   |<- No   Posiblemente es una jirafa.
   |
 ¿ Tiene una trompa ?
   |          |
   |          |<- Si
   |          |
   |<- No   Posiblemente es un elefante.
   |
 ¿ Le gusta estar en el agua ?
   |          |
   |          |<- Si
   |          |
   |<- No   Posiblemente es un hipopótamo.
   |
 Posiblemente es un rinoceronte.     

 Cargar el programa en CLIPS y utilizar el conjunto de reglas construido para
   averiguar qué tipo de animal puede ser aquel que es grande, no tiene el
   cuello largo y tiene trompa. Examinar y explicar las activaciones de las
   reglas.  

*******************************************************************************
* PROBLEMA 6:
*******************************************************************************

 Escribir un programa que indique si cierta presión de aceite es adecuada o
   no. Se considera que la presión de aceite es adecuada si es mayor o igual a
   60, y no es adecuada si el valor es menor. Los datos son proporcionados en
   el fichero "aceite.dat" y la salida debe almacenarse en el fichero
   "aceite.exp". 
 Cargar el programa en CLIPS y evaluarlo cuando el fichero "aceite.dat" 
   contiene los siguientes datos:
    71
    64
    60
    56
    58
    61

*******************************************************************************
* PROBLEMA 7:
*******************************************************************************

 Escribir un programa que indique si cierta presión de aceite es adecuada o
   no. Se considera que la presión de aceite es adecuada si es mayor o igual a
   60, y no es adecuada si el valor es menor. Los datos son proporcionados en
   el fichero "aceite.dat" y la salida debe almacenarse en el fichero
   "aceite.exp". 
 Cargar el programa en CLIPS y evaluarlo cuando el fichero "aceite.dat" 
   contiene los siguientes datos:
    71
    64
    60
    56
    58
    61
 Utilizar módulos para controlar la ejecución del programa.

*******************************************************************************
* PROBLEMA 8:
*******************************************************************************

 Juego Nim modificado: El objetivo del juego es obligar al jugador contrario a
   coger la última pieza de un conjunto de piezas situadas en tres filas, la
   primera con N piezas, la segunda con N-1 y la tercera con N-2. Cada jugador
   puede coger tantas piezas como desee pero sólo de una de las filas.
 En este caso los jugadores son la computadora y un ser humano. El control de
   las fases se hace a través de hechos de control sin el uso de una fase de
   control propiamente dicha.  
 El número de piezas de la primera fila y el jugador que empieza deberán ser
   elegidos por el jugador humano al comienzo de la partida.