Guias de Practica Sistemas Expertos

UNIVERSIDAD NACIONAL JORGE BASADRE GROHMANN
FACULTA D DE IN GENIE RA
Escuela Acadmico Profesional de Ingeniera en Informtica y Sistemas
GUASDEPRCTICADELABORATORIO
GuadePrctica01:IntroduccinAlLenguajeLipsUsandoVisualClisp Versin3.1415 GuadePrctica02:GrafosyprocedimientosenVisualCLisp GuadePrctica03:IntroduccinalVisualProlog GuadePrctica04:IntroduccinalVisualProlog:Programacinde aplicacionesconentornosVisuales GuadePrctica05:KAPPAPC2.0:Unsistemaexpertobasadoenreglas GuadePrctica06:KAPPAPC2.0:Personalizacindeunsistemaexperto
ELABORADASPOR: ING.EDGARAURELIOTAYAACOSTA ING.EDWINOCTAVIORAMOSVELSQUEZ TACNAPER
GuasdeLaboratoriodeSistemasExpertosInteligenciaArtificial IngenieraenInformticaySistemasIng.EdgarA.TayaAcosta/Ing.EdwinO.RamosVelsquez
UNIVERSIDAD NACIONAL JORGE BASADRE GROHMANN

FACULTAD DE INGENIERA
Escuela Acadmico Profesional de Ingeniera en Informtica y Sistemas
GUASDEPRCTICADELABORATORIO DESISTEMASEXPERTOS INTELIGENCIAARTIFICIAL

ELABORADOPOR: ING.EDGARAURELIOTAYAACOSTA ING.EDWINOCTAVIORAMOSVELSQUEZ TACNAPER
- 1 -
CONTENIDO
PGINA
Gua de prctica 01: Introduccin Al Lenguaje Lips Usando Visual Clisp Versin 3.1415
03
Gua de prctica 02: Grafos y procedimientos en VisualCLisp
15
Gua de prctica 03: Introduccin al Visual Prolog
30, 39
Gua de prctica 04: Introduccin al Visual Prolog: Programacin de aplicaciones con entornos Visuales
50
Gua de prctica 05: KAPPA PC 2.0: Un sistema experto basado en reglas
62
Gua de prctica 06: KAPPA PC 2.0: Personalizacin de un sistema experto
72
- 2 -
GUA DE PRACTICA DE LABORATORIO 01 INTRODUCCION AL LENGUAJE LIPS USANDO VISUAL CLisp Versin 3.1415
OBJETIVOS El alumno podr utilizar el entorno de programacin VisualCLisp Versin 3.1415 (una versin Freeware de Lisp) en la elaboracin y ejecucin de programas bsicos en Lisp El alumno podr familiarizarse con instrucciones bsicas de referenciacin y asignacin en el lenguaje Lisp.
METODOLOGIA Se describirn algunos conceptos bsicos de Lisp. Se mostrarn ejemplos de programa en Lisp haciendo analogas con lenguajes imperativos tales como C++. A continuacin se solicitar al alumno la elaboracin y ejecucin de programas propuestos en clase. Se proporcionar al alumno, junto con esta prctica, de un manual bsico de Lisp.
DESARROLLO DE LA PRCTICA Ejecucin de Visual Lisp en modo Debug (depuracin 1. )
Usando el Explorador de Windows, crear un directorio denominado C:\MiLisp. All se guardaran todos los archivos generados en esta prctica de laboratorio. Ejecutar VisualLisp (menInicio\Programas\VisualCLisp\VisualCLisp).
2.
Ventana de Edicin de programas y funciones
Compilar. Este botn permite verificar la correcta edicin de programas en la ventana de edicin de programas
Run (Modo debug)
Aqu escriba las Instrucciones LISP (en modo depuracin)
3. 4.
Seleccionar la pgina Debug. Ingresar al modo de depuracin (Presionar el botn Debug). Si se le presenta un cuadro de dilogo similar al siguiente, presionar el botn SI
- 3 -
Esta ventana hace referencia al hecho de que el contenido en la ventana de edicin de programas y funciones debera guardarse previamente en un archivo.
El aspecto de la interfaz de programacin ser similar al siguiente:
Cuadro edicin rutinas
de de
5.
Escribir secuencialmente las siguientes instrucciones Qu sucede cuando se ejecuta cada una de ellas?: (Presentar informe de resultados: Informe Parte 01.doc) Ejecucin de instrucciones atmicas $ ()
$ (pedro juan) $ (+ 12 40 -20) $( ( ) ( ) )
Lisp trata de procesar toda lnea de instruccin, por ello mensajes tales como: - EVAL: the function ALG is undefined
$ ( (america) )
$ (pedro (matematica 12 13) (geografia 15) ) Qu sucede al ejecutarse cada instruccin? 6.
A continuacin ejecute las siguientes instrucciones (Presentar informe de resultados: Informe Parte 02.doc) Ejecucin de funciones con valores atmicos $ (alpha)
- 4 -
$ (betha) $ (zetha)
Notas sobre Equivalencias (SETQ X 56 ) Equivale a la instruccin de asignacin X = 56 (SETQ alpha 23 ) Equivale a la instruccin de asignacin
$ (SETQ alpha 23 ) $ (SETQ betha 10 ) $ (+
alpha betha )
$ ( - alpha betha $ ( * alpha betha $ (SETQ zetha
) )
(+ alpha betha)
$ (pedro (matematica 12 13) (geografia 15) )
$ (SETQ ala $ (EVAL ala
'(+ )
5)
Notas sobre Equivalencias (SETQ ala ( + 9 5 ) ) Equivale a la instruccin de asignacin de listas, donde ala es una lista (en este caso, una lista que luego tiene 3 valores atmicos) con los elementos + 9 5
) )
$ (SETQ A 100 $ (SETQ B 300 $ (SETQ OP $ (EVAL OP

A B) )
(+ )
$ (SETQ B 20 $ (EVAL OP $ (SETQ A 5 $ (EVAL OP $ ala $ A $ B $ OP )
) )
Qu sucede al ejecutarse cada instruccin? 7. A continuacin ejecute las siguientes instrucciones (Informe Parte 03.doc)
- 5 -
Ejecucin de operaciones con listas ; Eliminacin del 1er elemento de una lista $ (CDR $ (CDR (1 (8 4 5 7 1 8 7 9) 2) ) )
; Extraccin de 1er elemento de una lista $ (CAR $ (CAR (8 (9 5 3 1 7 7 2) 20 )
36)
;Inversin de listas $ (REVERSE $ (SETQ L1 $ (SETQ L2 (1 2 ( 1 2 ( 6 7 3 3 8 4 4 11 5) 5) ) )
13)
$ (PRINC L1 ) $ (PRINC L2 ) $ (SETQ L3
(REVERSE L1)
;Valor actual de las variables $ L1 $ L2 $ L3
Qu sucede al ejecutarse cada instruccin? 8. Ejecutar las siguientes instrucciones (Informe Parte 04.doc) ; DEFINICION DE LAS FUNCIONES $ ( DEFUN ULTIMO ( X ) $ ( DEFUN SUMAR $ ( DEFUN ( A ( CAR A (LAST X ) ) ) B X Y ) ) ) )
B ) ( +
PAR ( X
Y ) ( LIST
; Ejecucin de las funciones $ (ULTIMO $ (SUMAR $ (PAR 4 ( A 7 B C ) )
8 )
5 )
- 6 -
CREACION DE FUNCIONES 9. En la pantalla de edicin escribir las siguientes rutinas ; Cdigo preparado por Ing. Edwin Ramos Velsquez ; Las lneas de cdigo de este archivo son reconocidos ; Por Visual CLisp Versin 3.1415 ;-----------------------------------------------------------; Parte 01: Operaciones donde los parmetros son Numeros
(DEFUN SUMA( A B ) (+ A B) ) ;-----------------------------------------------------------(DEFUN RESTA( A B ) (- A B) )
;-----------------------------------------------------------(DEFUN MULTIPLICA( A B ) (* A B) )
;-----------------------------------------------------------(DEFUN DIVIDE( A B ) (/ A B) )
;-----------------------------------------------------------; Parte 02: Operaciones donde los parmetros son Listas (DEFUN SUMAR ( L ) (SETQ TEMP L) (SETQ RESULTADO 0) (SETQ x 0) ( LOOP UNTIL (EQUAL TEMP NIL)DO (SETQ x (CAR TEMP)) ( IF (NOT (EQUAL x NIL)) (SETQ RESULTADO (+ RESULTADO x))) (SETQ TEMP (CDR TEMP)) ) (SETQ x RESULTADO) )
- 7 -
;----------------------------------------------------------(DEFUN RESTAR ( L ) (SETQ TEMP L) (SETQ x 0) (SETQ RESULTADO (CAR TEMP)) (SETQ TEMP (CDR TEMP)) ( LOOP UNTIL (EQUAL TEMP NIL)DO (SETQ x (CAR TEMP)) ( IF (NOT (EQUAL x NIL)) (SETQ RESULTADO (- RESULTADO x)) ) (SETQ TEMP (CDR TEMP)) ) ; (IF test THEN else) == (COND(test then) (T else)) (COND ( (EQUAL L NIL) (SETQ x 0) ( ) ) T )
(SETQ x RESULTADO) )
Esta es una lnea de comentario
;---------------------------------------------------------(DEFUN MULTIPLICAR ( L ) (SETQ TEMP L) (SETQ RESULTADO 1) (SETQ x 0)
( LOOP UNTIL (EQUAL TEMP NIL)DO (SETQ x (CAR TEMP)) ( IF (NOT (EQUAL x NIL)) (SETQ RESULTADO (* RESULTADO x)) ) (SETQ TEMP (CDR TEMP)) )
; (IF test THEN else) == (COND(test then) (T else)) (COND ( (EQUAL L NIL) (SETQ x 0) ( ) T )
;-----------------------------------------------------------
- 8 -
(DEFUN DIVIDIR ( L ) (SETQ TEMP L) (SETQ RESULTADO (CAR TEMP)) (SETQ TEMP (CDR TEMP)) (SETQ x 0)
( LOOP UNTIL (EQUAL TEMP NIL)DO ( SETQ x (CAR TEMP)) ( IF (NOT (EQUAL x NIL)) (SETQ RESULTADO (/ RESULTADO x)) ) ( SETQ TEMP (CDR TEMP)) )
) ;----------------------------------------------------------(DEFUN SUME ( L ) (SETQ TEMP L) (SETQ RESULTADO 0) (SETQ x 0) ( LOOP UNTIL (EQUAL TEMP NIL)DO (SETQ x (CAR TEMP)) ( IF (NOT (EQUAL x NIL)) (SETQ RESULTADO (+ RESULTADO x)) ) (SETQ TEMP (CDR TEMP)) ) (SETQ x RESULTADO) ) ;----------------------------------------------------------(DEFUN Primer ( L ) Para qu cree que (SETQ TEMP L) (SETQ RESULTADO 0) (SETQ x 0) (SETQ x (CAR TEMP)) (SETQ RESULTADO (+ RESULTADO x)) ) ;-----------------------------------------------------------
servira esta funcin Primer?
- 9 -
(DEFUN OPERARMODO1 ( OP L ) (SETQ TEMP L) (SETQ RESULTADO 0) (SETQ x 0) ( LOOP UNTIL (EQUAL TEMP NIL)DO (SETQ x (CAR TEMP)) ( IF (NOT (EQUAL x NIL)) ( COND ( (EQUAL OP +) (SETQ RESULTADO (+ RESULTADO x)) ) ( (EQUAL OP -) (SETQ RESULTADO (- RESULTADO x)) ) ( (EQUAL OP *) (SETQ RESULTADO (* RESULTADO x)) ) ( (EQUAL OP /) (SETQ RESULTADO (/ RESULTADO x)) ) ) ) (SETQ TEMP (CDR TEMP)) ) (SETQ x RESULTADO) ) ;----------------------------------------------------------(DEFUN OPERAR ( OP L ) (SETQ TEMP L) (COND ( (EQUAL OP +) (SETQ RESULTADO 0) ) ( (EQUAL OP *) (SETQ RESULTADO 1) ) ( T (SETQ RESULTADO (CAR TEMP)) (SETQ TEMP (CDR TEMP) ) ) )
(LOOP UNTIL (EQUAL TEMP NIL)DO (SETQ x (CAR TEMP)) ( IF (NOT (EQUAL x NIL)) ( COND ( (EQUAL OP +) (SETQ RESULTADO (+ RESULTADO x)) ) ( (EQUAL OP -) (SETQ RESULTADO (- RESULTADO x)) ) ( (EQUAL OP *) (SETQ RESULTADO (* RESULTADO x)) ) ( (EQUAL OP /) (SETQ RESULTADO (/ RESULTADO x)) ) ) )
- 10 -
(SETQ TEMP (CDR TEMP)) ) ; (if test then else) == (cond (test then) (t else)) (COND ( (EQUAL L NIL) (SETQ x 0) ( ) ) T )
10. Compilar el programa para verificar que est correctamente escrito Guardar el archivo 11. A continuacin guardar el archivo como: c:\MiLisp\Operaciones.lsp Cargar y ejecutar funciones contenidas en un archivo 12. A continuacin Activar el modo de depuracin ( ), es decir elegir el men compilerDebug 13. Escribir en la ventana de depuracin la instruccin LOAD como se muestra: (LOAD "C:/MiLisp/Operaciones.lsp")
NOTA: Investigue sobre el uso de las funciones:
$ RUN
14. A continuacin, desde la misma ventana de ejecucin, verificar el adecuado funcionamiento de las funciones (llmelas con rutinas) Por ejemplo: $ (SUMA 12 7 5) ; Llamado a la funcin SUMA ; Resultados devueltos por SUMA
$ (RESTA 2
5)
; Llamado a la funcin RESTA ; Resultados devueltos por RESTA
$ (MULTIPLICA 35
5)
; Llamado a la funcin MULTIPLICA ; Resultados devueltos por MULTIPLICA
$ (DIVIDE 40
80
2)
; Llamado a la funcin DIVIDE ; Resultados devueltos por DIVIDE
$ (RESTAR '(80 7 1) ) 72
; Llamado a la funcin RESTAR ; Resultados devueltos por RESTAR
- 11 -
$ (MULTIPLICAR '(2 2 3 3) ) ; Llamado a la funcin MULTIPLICAR 36 ; Resultados devueltos por MULTIPLICAR
$ (DIVIDIR '(81 3)) 27
; Llamado a la funcin DIVIDIR ; Resultados devueltos por DIVIDIR
$ (DIVIDIR '(20)) 20
$ (SUMAR '(3 5)) 8
; Llamado a la funcin SUMAR ; Resultados devueltos por SUMAR
$ (SUMAR '(3 5 7)) 15
$ (SUME '(2 4 5 6)) 17
; Llamado a la funcin SUME ; Resultados devueltos por SUME
$ (OPERAR + '(3 4 2)) 9
; Llamado a la funcin OPERAR ; Resultados devueltos por OPERAR
$ (OPERAR * '(3 4 2)) 24
$ (OPERAR / '(80 4 2)) 9
$ (OPERAR + '( ) ) 0
15. Guardar todo.
TAREAS (Presente el informe respectivo: Informe Parte 05.doc) 1. Escribir una funcin que reciba una lista de nmeros y retorne una lista de nmeros sumndole su posicin a cada nmero de la lista.
- 12 -
> (suma-posicion (1 3 7 -2)) > (2 5 10 2) 2. Escribir la funcin calcula-diferencia que recibe una lista de nmeros y devuelve otra lista con la diferencia entre un nmero y su sucesor en la lista. (El ltimo elemento no cuenta) > (calcula-diferencia (10 6 2 5 -4)) > (4 4 -3 9)
3. Escribir la funcin separar-parimpar que recibe una lista de nmeros y retorna una lista con una sublista de los pares y otra sublista con los impares. > (separar-parimpar (1 2 3 5 6 8 9 11 12)) > ((12 8 6 2) (11 9 5 3 1)) 4. Escribir la funcin cambiar-notacion que transforme una expresin con operaciones matemticas escritas en notacin funcional de LISP a su notacin infija correspondiente. > (cambiar-notacion (+ (* 7 4) (* 5 3) (- (/ 30 (* 2 3)) 1))) > ((7 * 4) + (5 * 3) + ((30 / (2 * 3)) - 1)) 5. Escribir una funcin que a partir de los elementos de una lista cree un conjunto de todos los posibles pares ordenados > (pares-ordenados (a b c )) > ((A . B) (A . C) (B . A) (B . C) (C . A) (C . B))
6. Dada la siguiente estructura (defstruct punto (valx 0) (valy 0)) Escribir una funcin que reciba como parmetros 2 puntos y calcule la distancia eucldea entre ellos. > (distancia-puntos (make-punto :valx 8 :valy 6) (make-punto)) > 10
7. Escribir una funcin que convierta una lista de nmeros en un vector de nmeros con los mismos elementos. >(array-to-vector '(1 2 3 4 6 7)) > #(1 2 3 4 6 7)
- 13 -
8. Escribir una funcin que determine si una lista de nmeros esta ordenada o no. >(is-ordenada '(1 3 5 7 10)) >T >(is-ordenada '(1 3 15 5 7)) > NIL >(is-ordenada '(15 11 3)) >T 9. Escribir la funcin que divida una lista en 2 partes iguales y retorne una lista con las 2 nuevas sublistas (Si la cantidad de elementos es impar la primera sublista deber tener un elemento ms). > (dividir-lista '(a b c d e)) > ((a b c) (d e)) > (dividir-lista '(1 2 3 4 5 6)) > ((1 2 3) (4 5 6)) 10. Escribir una funcin que a partir de una lista copie en un fichero inversa.txt la lista y la versin invertida de la misma. > (guardar-lista-invertida '(w x y z )) > nil 11. En qu se diferencian las funciones OPERARMODO1 y OPERAR?
- 14 -
GUA DE PRCTICA DE LABORATORIO 02 GRAFOS Y PROCEDIMIENTOS EN VisualCLisp
OBJETIVOS El alumno podr utilizar el entorno de programacin VisualCLisp Versin 3.1415 (una versin Freeware de Lisp) en la elaboracin y ejecucin de programas avanzados en Lisp El alumno podr familiarizarse con instrucciones de referenciacin y asignacin en el lenguaje Lisp.
METODOLOGIA Se describirn algunos conceptos bsicos de Lisp. Se mostrarn ejemplos de programa en Lisp haciendo analogas con lenguajes imperativos tales como C++. A continuacin se solicitar al alumno la elaboracin y ejecucin de programas propuestos en clase. Se proporcionar al alumno, junto con esta prctica, de un manual bsico de Lisp.
Listas Simples Sea la lista de cadenas tal como la que se muestra a continuacin 1 Juan 2 Pedro 3 Alicia 4 Natale 5 Pedrito 6 Mara 7 Tatiana 8 Magali
Esta puede crearse a travs de la siguiente instruccin:

(SETQ P (LIST "Juan" "Pedro" "Alicia" "Natale" "Pedrito" "Maria" "Tatiana" "Magali" ))
Un ejemplo de esto podemos verlo en el siguiente programa:
(DEFUN MuestraLista (L index) (block pe (COND ( (NOT(EQUAL (CAR L) NIL)) ( PRINT index ) ( PRINC ".- " ) ( PRINC ( CAR L) ) ( MuestraLista (CDR L) (+ index 1)) ) ) ) )
- 15 -
;----------------------------------------(DEFUN ProcesarLista() (SETQ P (LIST "Juan" "Pedro" "Alicia" "Natale" "Pedrito" "Maria" "Tatiana" "Magali" )) (PRINT "Listado de nombres: ") (MuestraLista P 1 ) )
Al ejecutar la instruccin $ (ProcesarLista ), podremos observar un listado de lo siguiente:
"Listado de nombres: " 1 .- Juan 2 .- Pedro 3 .- Liu Alvarez 4 .- Natale 5 .- Pedrito 6 .- Maria 7 .- Tatiana 8 .- Magali
Listas Compuestas: (Cadena + Lista1 + Lista2 + + ListaN) Sea la lista de cadenas tal como la que se muestra a continuacin (los dos rboles son
Persona
Personas
Empleados Pedrito --- Lucho --- Anita
Empleados Pedrito Lucho Anita
Docentes Mara Prez Jos Luis Belinda Salas
Alumnos Kike Vega Ubaldo Yuli Benedicto
Visitas Alvaro Juan Pereda Hector Lucy
Docente Alumno Visitas
Mara Prez --- Jos Luis --- Belinda Salas Kike Vega --- Ubaldo --- Yuli --- Benedicto Alvaro --- Juan Pereda --- Hector --- Lucy
equivalentes)
Esta puede crearse a travs de la siguiente instruccin:
- 16 -
(SETQ P1 (LIST "Empleados" (SETQ P2 (LIST "Docentes" (SETQ P3 (LIST "Alumnos" (SETQ P4 (LIST "Visitas" (SETQ P
'("Pedrito" "Lucho" "Anita")) ) '("Maria_Perez" "Jose_Luis" "Belinda_Salas")) ) '("Kike_Vega" "Ubaldo" "Yuli" "Benedicto")) ) '("Alvaro" "Juan Pereda" "Hector" "Lucy")) )
(LIST "Personas" P1 P2 P3 P4) )
Un ejemplo de esto podemos verlo en el siguiente programa:
(DEFUN Muestra_Arbol ( L EsNodoRaiz ) ; Impresion del nombre de la lista ( COND ( (NOT(EQUAL L NIL)) (SETQ X (CAR L)) (COND ( (LISTP X) (Muestra_Arbol X 1)
(Muestra_Arbol (CDR L) 1 ) ) ( T (SETQ Y 0) (IF (EQUAL EsNodoRaiz 1) (SETQ Y (CAR (CDR L)) )) ( COND ( (LISTP Y) (PRINT "El nodo: ") (PRINC (CAR L)) (PRINT "Tiene los hijos siguientes: ") (Muestra_Arbol (CAR (CDR L)) 1 ) (Muestra_Arbol (CDR (CDR L)) 1 ) ) ( T (PRINT " Hijo: ")
(PRINC (CAR L)) (Muestra_Arbol (CDR L) 0 ) ) ) ) ) ) )
;-----------------------------------------
- 17 -
(DEFUN crear_lista ( L ) ( block pepe (SETQ P1 (LIST "Empleados" (SETQ P2 (LIST "Docentes" (SETQ P3 (LIST "Alumnos" (SETQ P4 (LIST "Visitas" (SETQ P '("Pedrito" "Lucho" "Anita")) ) '("Maria Perez" "Jose Luis" "Belinda Salas")) ) '("Kike Vega" "Ubaldo" "Yuli" "Benedicto")) ) '("Alvaro" "Juan Pereda" "Hector" "Lucy")) )
(LIST "Personas" P1 P2 P3 P4) )
(return-from pepe P) ) ) ;----------------------------------------(DEFUN ProcesarArbolGenealogico() (SETQ H '() ) (SETQ P (crear_lista H )) (PRINT "-------------------") (Muestra_Arbol P 1 ) )
Al ejecutar la instruccin $ (ProcesarLista ), podremos observar un listado de lo siguiente:
"El Nodo: " Personas "Que tiene los hijos siguientes : " "El Nodo: " Empleado "Tiene los hijos siguientes : " " " " Hijo: " Pedrito Hijo: " Lucho Hijo: " Anita
"El Nodo: " Docentes "Tiene los hijos siguientes : " " " " Hijo: " Maria Perez Hijo: " Jose Luis Hijo: " Belinda Salas
"El Nodo: " Alumnos "Tiene los hijos siguientes : " " " " " Hijo: " Kike_Vega Hijo: " Ubaldo Hijo: " Yuli Hijo: " Benedicto
"El Nodo: " Visitas
- 18 -
"Tiene los hijos siguientes : " " " " " Hijo: " Malito Vega Hijo: " Juan Peredad Hijo: " Hector Barreda Hijo: " Lucy
DESARROLLO DE LA PRCTICA Ejecucin de Visual Lisp en modo Debug (depuracin )
1. Usando el Explorador de Windows, crear un directorio denominado C:\MiLisp2. All se guardaran todos los archivos generados en esta prctica de laboratorio.
Implementacin e implementacin de listas 2. 3. Ejecutar VisualLisp (menInicio\Programas\VisualCLisp\VisualCLisp). Escribir secuencialmente las siguientes instrucciones Qu sucede cuando se ejecuta cada una de ellas?: (Presentar informe de resultados: Informe Parte 01.doc) Ejecucin de instrucciones atmicas $ ()
$ (pedro juan) $ (+ 12 40 -20) $( ( ) ( ) )
Lisp trata de procesar toda lnea de instruccin, por ello mensajes tales como:
- EVAL: the function ALG is undefined
$ ( (america) )
$ (pedro (matematica 12 13) (geografia 15) ) Qu sucede al ejecutarse cada instruccin?
4. A continuacin ejecute las siguientes instrucciones (Presentar informe de resultados: Informe Parte 02.doc) Ejecucin de funciones con valores atmicos $ (alpha) $ (betha) $ (zetha)
Notas sobre Equivalencias (SETQ X 56 ) Equivale a la instruccin de asignacin X=56 (SETQ alpha 23 ) Equivale a la instruccin de asignacin alpha = 23
$ (SETQ alpha 23 ) $ (SETQ betha 10 )
- 19 -
$ (+
alpha betha )
$ ( - alpha betha $ ( * alpha betha $ (SETQ zetha
) )
(+ alpha betha)
$ (pedro (matematica 12 13) (geografia 15) )
$ (SETQ ala $ (EVAL ala
'(+ )
5)
) )
Notas sobre Equivalencias (SETQ ala ( + 9 5 ) ) Equivale a la instruccin de asignacin de listas, donde ala es una lista (en este caso, una lista que luego tiene 3 valores atmicos) con los elementos
$ (SETQ A 100 $ (SETQ B 300 $ (SETQ OP $ (EVAL OP

A B) )
(+ )
$ (SETQ B 20 $ (EVAL OP $ (SETQ A 5 $ (EVAL OP $ ala $ A $ B $ OP )
) )
Qu sucede al ejecutarse cada instruccin? 5. A continuacin ejecute las siguientes instrucciones (Informe Parte 03.doc) Ejecucin de operaciones con listas ; Eliminacin del 1er elemento de una lista $ (CDR $ (CDR (1 (8 4 5 7 1 8 7 9) 2) ) )
- 20 -
; Extraccin de 1er elemento de una lista $ (CAR $ (CAR (8 (9 5 3 1 7 7 2) 20 )
36)
;Inversin de listas $ (REVERSE (1 2 3 4 5) )
$ (SETQ L1 $ (SETQ L2
( 1 2 ( 6 7
3 8
4 11
5)
13)
$ (PRINC L1 ) $ (PRINC L2 ) $ (SETQ L3
(REVERSE L1)
;Valor actual de las variables $ L1 $ L2 $ L3
Qu sucede al ejecutarse cada instruccin? 6. Ejecutar las siguientes instrucciones (Informe Parte 04.doc) ; DEFINICION DE LAS FUNCIONES $ ( DEFUN ULTIMO ( X ) $ ( DEFUN SUMAR $ ( DEFUN ( A ( CAR A (LAST X ) ) ) B X Y ) ) ) )
B ) ( +
PAR ( X
Y ) ( LIST
; Ejecucin de las funciones $ (ULTIMO $ (SUMAR $ (PAR 4 ( A 7 B C ) )
8 )
5 )
CREACION DE FUNCIONES 7. En la pantalla de edicin escribir las siguientes rutinas ; Cdigo preparado por Ing. Edwin Ramos Velsquez ; Las lineas de codigo de este archivo son reconocidos ; Por Visual CLisp Versin 3.1415
- 21 -
;-----------------------------------------------------------; Parte 01: Operaciones donde los parmetros son Numeros
(DEFUN SUMA( A B ) (+ A B) )
;-----------------------------------------------------------(DEFUN RESTA( A B ) (- A B) )
;-----------------------------------------------------------(DEFUN MULTIPLICA( A B ) (* A B) )
;-----------------------------------------------------------(DEFUN DIVIDE( A B ) (/ A B) )
;-----------------------------------------------------------; Parte 02: Operaciones donde los parmetros son Listas
(DEFUN SUMAR ( L ) (SETQ TEMP L) (SETQ RESULTADO 0) (SETQ x 0) ( LOOP UNTIL (EQUAL TEMP NIL)DO (SETQ x (CAR TEMP)) ( IF (NOT (EQUAL x NIL)) (SETQ RESULTADO (+ RESULTADO x))) (SETQ TEMP (CDR TEMP)) ) (SETQ x RESULTADO) )
- 22 -
;----------------------------------------------------------(DEFUN RESTAR ( L ) (SETQ TEMP L) (SETQ x 0) (SETQ RESULTADO (CAR TEMP)) (SETQ TEMP (CDR TEMP)) ( LOOP UNTIL (EQUAL TEMP NIL)DO (SETQ x (CAR TEMP)) ( IF (NOT (EQUAL x NIL)) (SETQ RESULTADO (- RESULTADO x)) ) (SETQ TEMP (CDR TEMP)) ) ; (IF test THEN else) == (COND(test then) (T else)) (COND ( (EQUAL L NIL) (SETQ x 0) ( ) ) T )
Esta es una lnea de comentario (Empieza con punto y coma)
;---------------------------------------------------------(DEFUN MULTIPLICAR ( L ) (SETQ TEMP L) (SETQ RESULTADO 1) (SETQ x 0)
( LOOP UNTIL (EQUAL TEMP NIL)DO (SETQ x (CAR TEMP)) ( IF (NOT (EQUAL x NIL)) (SETQ RESULTADO (* RESULTADO x)) ) (SETQ TEMP (CDR TEMP)) )
;----------------------------------------------------------(DEFUN DIVIDIR ( L ) (SETQ TEMP L)
- 23 -
(SETQ RESULTADO (CAR TEMP)) (SETQ TEMP (CDR TEMP)) (SETQ x 0)
( LOOP UNTIL (EQUAL TEMP NIL)DO ( SETQ x (CAR TEMP)) ( IF (NOT (EQUAL x NIL)) (SETQ RESULTADO (/ RESULTADO x)) ) ( SETQ TEMP (CDR TEMP)) )
; (IF test THEN else) == (COND(test then) (T else)) (COND ( (EQUAL L NIL) (SETQ x 0) ( ) ) T )
;----------------------------------------------------------(DEFUN SUME ( L ) (SETQ TEMP L) (SETQ RESULTADO 0) (SETQ x 0) ( LOOP UNTIL (EQUAL TEMP NIL)DO (SETQ x (CAR TEMP)) ( IF (NOT (EQUAL x NIL)) (SETQ RESULTADO (+ RESULTADO x)) ) (SETQ TEMP (CDR TEMP)) ) (SETQ x RESULTADO) )
Para qu cree ;----------------------------------------------------------- que

(DEFUN Primer ( L ) (SETQ TEMP L) (SETQ RESULTADO 0) (SETQ x 0) (SETQ x (CAR TEMP)) (SETQ RESULTADO (+ RESULTADO x)) ) ;----------------------------------------------------------(DEFUN OPERARMODO1 ( OP L )
servira esta funcin Primer?
- 24 -
(SETQ TEMP L) (SETQ RESULTADO 0) (SETQ x 0) ( LOOP UNTIL (EQUAL TEMP NIL)DO (SETQ x (CAR TEMP)) ( IF (NOT (EQUAL x NIL)) ( COND ( (EQUAL OP +) (SETQ RESULTADO (+ RESULTADO x)) ) ( (EQUAL OP -) (SETQ RESULTADO (- RESULTADO x)) ) ( (EQUAL OP *) (SETQ RESULTADO (* RESULTADO x)) ) ( (EQUAL OP /) (SETQ RESULTADO (/ RESULTADO x)) ) ) ) (SETQ TEMP (CDR TEMP)) ) (SETQ x RESULTADO) )
;----------------------------------------------------------(DEFUN OPERAR ( OP L ) (SETQ TEMP L) (COND ( (EQUAL OP +) (SETQ RESULTADO 0) ) ( (EQUAL OP *) (SETQ RESULTADO 1) ) ( T (SETQ RESULTADO (CAR TEMP)) (SETQ TEMP (CDR TEMP) ) ) )
(LOOP UNTIL (EQUAL TEMP NIL)DO (SETQ x (CAR TEMP)) ( IF (NOT (EQUAL x NIL)) ( COND ( (EQUAL OP +) (SETQ RESULTADO (+ RESULTADO x)) ) ( (EQUAL OP -) (SETQ RESULTADO (- RESULTADO x)) ) ( (EQUAL OP *) (SETQ RESULTADO (* RESULTADO x)) ) ( (EQUAL OP /) (SETQ RESULTADO (/ RESULTADO x)) ) ) )
- 25 -
(SETQ TEMP (CDR TEMP)) ) ; (if test then else) == (cond (test then) (t else)) (COND ( (EQUAL L NIL) (SETQ x 0) ( ) ) T )
8. Compilar el programa para verificar que est correctamente escrito
Guardar el archivo 9. A continuacin guardar el archivo como: c:\MiLisp\Operaciones.lsp
Cargar y ejecutar funciones contenidas en un archivo 10. A continuacin Activar el modo de depuracin ( ), es decir elegir el men compilerDebug 11. Escribir en la ventana de depuracin la instruccin LOAD como se muestra: (LOAD "C:/MiLisp/Operaciones.lsp")
NOTA: Investigue sobre el uso de las funciones:
$ RUN
12. A continuacin, desde la misma ventana de ejecucin, verificar el adecuado funcionamiento de las funciones (llmelas con rutinas) Por ejemplo: $ (SUMA 12 7 5) ; Llamado a la funcin SUMA ; Resultados devueltos por SUMA
$ (RESTA 2
5)
; Llamado a la funcin RESTA ; Resultados devueltos por RESTA
$ (MULTIPLICA 35
5)
; Llamado a la funcin MULTIPLICA ; Resultados devueltos por MULTIPLICA
$ (DIVIDE
80
2)
; Llamado a la funcin DIVIDE
- 26 -
40
; Resultados devueltos por DIVIDE
$ (RESTAR '(80 7 1) ) 72
; Llamado a la funcin RESTAR ; Resultados devueltos por RESTAR
$ (MULTIPLICAR '(2 2 3 3) ) ; Llamado a la funcin MULTIPLICAR 36 ; Resultados devueltos por MULTIPLICAR
$ (DIVIDIR '(81 3)) 27
$ (DIVIDIR '(20)) 20
$ (SUMAR '(3 5)) 8
$ (SUMAR '(3 5 7)) 15
$ (SUME '(2 4 5 6)) 17
; Llamado a la funcin SUME ; Resultados devueltos por SUME
$ (OPERAR + '(3 4 2)) 9
$ (OPERAR * '(3 4 2)) 24
$ (OPERAR / '(80 4 2)) 9
$ (OPERAR + '( ) ) 0
13. Guardar todo.
- 27 -
TAREAS (Presente el informe respectivo: Informe Parte 05.doc) 1. Escribir una funcin que reciba una lista de nmeros y retorne una lista de nmeros sumndole su posicin a cada nmero de la lista. > (suma-posicion (1 3 7 -2)) > (2 5 10 2) 2. Escribir la funcin calcula-diferencia que recibe una lista de nmeros y devuelve otra lista con la diferencia entre un nmero y su sucesor en la lista. (El ltimo elemento no cuenta) > (calcula-diferencia (10 6 2 5 -4)) > (4 4 -3 9)
3. Escribir la funcin separar-parimpar que recibe una lista de nmeros y retorna una lista con una sublista de los pares y otra sublista con los impares. > (separar-parimpar (1 2 3 5 6 8 9 11 12)) > ((12 8 6 2) (11 9 5 3 1)) 4. Escribir la funcin cambiar-notacion que transforme una expresin con operaciones matemticas escritas en notacin funcional de LISP a su notacin infija correspondiente. > (cambiar-notacion (+ (* 7 4) (* 5 3) (- (/ 30 (* 2 3)) 1))) > ((7 * 4) + (5 * 3) + ((30 / (2 * 3)) - 1)) 5. Escribir una funcin que a partir de los elementos de una lista cree un conjunto de todos los posibles pares ordenados > (pares-ordenados (a b c )) > ((A . B) (A . C) (B . A) (B . C) (C . A) (C . B)) 6. Dada la siguiente estructura (defstruct punto (valx 0) (valy 0) ) Escribir una funcin que reciba como parmetros 2 puntos y calcule la distancia eucldea entre ellos. > (distancia-puntos (make-punto :valx 8 :valy 6) (make-punto)) > 10
- 28 -
7. Escribir una funcin que convierta una lista de nmeros en un vector de nmeros con los mismos elementos. >(array-to-vector '(1 2 3 4 6 7)) > #(1 2 3 4 6 7) 8. Escribir una funcin que determine si una lista de nmeros esta ordenada o no. >(is-ordenada '(1 3 5 7 10)) >T >(is-ordenada '(1 3 15 5 7)) > NIL >(is-ordenada '(15 11 3)) >T 9. Escribir la funcin que divida una lista en 2 partes iguales y retorne una lista con las 2 nuevas sublistas (Si la cantidad de elementos es impar la primera sublista deber tener un elemento ms). > (dividir-lista '(a b c d e)) > ((a b c) (d e)) > (dividir-lista '(1 2 3 4 5 6)) > ((1 2 3) (4 5 6)) 10. Escribir una funcin que a partir de una lista copie en un fichero inversa.txt la lista y la versin invertida de la misma. > (guardar-lista-invertida '(w x y z )) > nil 11. En qu se diferencian las funciones OPERARMODO1 y OPERAR?
- 29 -
GUA DE PRCTICA 03: INTRODUCCIN AL VISUAL PROLOG: ASPECTOS TEORICOS
ASPECTOS TEORICOS Secciones de un programa en Visual Prolog Un programa en Visual Prolog est compuesto de varias secciones que se describen a continuacin: Directivas de compilacin: que se dan al comienzo del programa. Seccin de constantes: puede contener cero, una o varias constantes (CONSTANTS). Seccin de dominios: puede contener cero, uno o varios dominios (DOMAIN). Seccin de la base de datos: puede contener cero, uno o varios predicados de la base de datos. Seccin de predicados: puede contener cero, una o varias declaraciones de predicados. Seccin de clusulas: puede contener cero, una o varias clusulas. Seccin de meta: para que el programa se ejecute de forma independiente debe existir una meta construida dentro del propio programa. A. Directivas de compilacin Nos permiten controlar las caractersticas del compilador. Estas directivas pueden ser cambiadas a travs del men, mediante opciones de lnea de comando y en el propio cdigo fuente. En caso de activar una misma directiva de forma distinta en el entorno y en el cdigo fuente, prevalece la activacin realizada en el cdigo fuente. Ver Error! No se encuentra el origen de la referencia. Directiva bgidriver Significado
Esta directiva se utiliza de un modo similar a este ejemplo: bgidriver "_CGA_driver_far", para establecer el tipo de controlador de grficos que se debe linkar con un programa MS-DOS de grficos BGI. Esta directiva se utiliza de un modo similar a este ejemplo: bgifont "_gothic_font_far", para establecer el tipo de fuente de texto que se debe utilizar con el programa a la hora de escribir un programa para MS-DOS basado en grficos BGI. Esta directiva activa la deteccin de clusulas no deterministas. Si especificamos esta directiva, Visual Prolog dar un warning cada vez que se detecte un predicado de tipo no determinista. Hay dos tipos de clusulas no deterministas: Aquellas que no poseen corte y hay una o ms clusulas que pueden casar con los mismos argumentos de entrada para un patrn de flujo. Aquellas que llaman a otras no deterministas y el predicado llamado no est seguido de un corte. Especifica el tamao del array interno de cdigo. Por defecto son 2000 prrafos (unidades de 16 bits), para la versin VP de 16 bits. En otro caso, son 10000. Por ejemplo si escribimos code=1024 tenemos un array de cdigo de 16 * 1024 bytes=16Kbytes de tamao. Permite definir el aspecto de los programas en modo texto en MS-DOS antiguo. Permite observar los un conjunto de parmetros de un programa Prolog. Produce mensajes de error en tiempo de compilacin. Cuando se encuentra un error de este tipo al llegar a la lnea de la directiva, se visualiza en pantalla el mensaje escrito al lado de #error. Es muy til para encontrar inconsistencias debidas al programador y violacin de restricciones impuestas. Permite establecer el grado de detalle con que VP informa de los errores al programador. Puede ser 0, 1 2. Sirve para especificar la cantidad de memoria que se reservar para un ejecutable TSR en MS-DOS. Se debe escribir en la seccin MAIN para que sea tenida en cuenta y permite establecer el nmero de bytes de la pila global (cantidad de memoria virtual que el sistema operativo debe reservar), mientras el programa est cargado.
bgifont
check_determ
code config diagnostics error
errorlevel heap gstacksize
- 30 -
GuasdeLaboratoriodeSistemasExpertosInteligenciaArtificial IngenieraenInformticaySistemasIng.EdgarA.TayaAcosta/Ing.EdwinO.RamosVelsquez En ausencia de esta directiva cada vez que se realice una llamada a un predicado, se examinar el teclado para ver si se ha pulsado ctrl-break, por lo que se ralentiza la ejecucin de la aplicacin y, adems, ocupa un pequeo espacio de programa. El uso de la directiva evita que se genere este cdigo examinador. Cuando se utiliza esta directiva, la nica forma de salir de un bucle infinito es mediante un proceso de reset. Suprime los avisos generados por la existencia de una variable una sola vez en una clusula. Estas variables pueden ser sustituidas por variables annimas, luego, en principio, no deben aparecer en un programa bien escrito. Permite la generacin de cdigo en programas MS-DOS que facilita la impresin de pantallas en modo texto, mediante la pulsacin del conjunto AltP Se usa cuando utilizamos una metodologa de diseo e implementacin modular. Permite especificar a qu proyecto pertenece un mdulo determinado.
nobreak
nowarnings printermenu Project
B. Seccin de constantes (CONSTANTS) En la seccin de constantes podemos declarar constantes simblicas que pueden usarse en el cuerpo del programa. La utilidad de las constantes en Visual Prolog es similar a la que estos elementos tienen en otros lenguajes de programacin, normalmente, sirven para facilitar el uso de diversas cantidades, expresiones y smbolos. La definicin de la seccin de constantes se encabeza con la palabra reservada CONSTANTS, y cada lnea de definicin es de la forma <Nombre Constante> = <Definicin de Macro>. Por ejemplo, el siguiente fragmento de programa visualiza en pantalla el contenido: Programa en Visual Prolog Resultados CONSTANTS ( texto impreso en numero = 1 pantalla) expresion = 1+1 12 GOAL A=1, B=2 A=numero, B=expresion, write(A), write(B), nl. 1 Solution C. Seccin de dominios1 En la seccin DOMAINS se pueden definir dominios no especificados por defecto por Visual Prolog. Por ejemplo, el dominio integer es estndar para el compilador, no as el dominio sinnimo ENTERO o dominios complejos. En estos ltimos casos, el programador debe definirlo en esta seccin. Cada seccin de dominios debe comenzar con la palabra DOMAINS. Ejemplo: DOMAINS ENTERO = INTEGER Es posible usar 5 formatos de declaraciones para dominios definidos por el usuario. C.1. Dominios de Objetos Compuestos Para declaracin de dominios del tipo funciones. El siguiente programa lista lo que cada lector lee en las variables X e Y respectivamente. DOMAINS LECTOR = lee(SYMBOL Nombre, LECTURA Item) LECTURA = libro(SYMBOL Autor, SYMBOL Titulo, SYMBOL Editorial); revista (SYMBOL Titulo, INTEGER Numero) PREDICATES lectores(LECTOR)
Para los familiarizados con lenguajes imperativos tales como Pascal, podemos decir que esta seccin, de alguna forma, es anloga a la seccin de declaracin de tipos de datos o estructuras (por ejemplo: TYPE).
- 31 -
CLAUSES lectores(lee(antonio, libro(cervantes, quijote, anaya))). lectores(lee(pepe, revista(hola, 22))). lectores(lee(juan, libro(delphi4, alvarez, anaya))). GOAL lectores(lee(X,Y)). El resultado obtenido tras la ejecucin del objetivo propuesto en la seccin de metas es: X=antonio, Y=libro("cervantes","quijote","anaya") X=pepe, Y=revista("hola",22) X=juan, Y=libro("delphi4","alvarez","anaya") 3 Solutions
C.2. Dominios de Objetos Compuestos Functorless. En estos dominios podemos definir tipos de objetos que slo se pueden comportar como una nica clase de objetos DOMAINS ESCULT = struct escultura (INTEGER ns, SYMBOL autor, SYMBOL material) PINTURA = struct cuadro (INTEGER ns, SYMBOL autor, SYMBOL tecnica) C.3. Sinnimos de Dominios Estndar En ocasiones, puede ser til definir sinnimos de dominios que son estndar, para una mayor legibilidad del programa, por ejemplo. As pues en la siguiente declaracin: DOMAINS ENTERO = integer ESCULT = struct escultura (ENTERO ns, SYMBOL autor, SYMBOL material) PINTURA = struct cuadro (ENTERO ns, SYMBOL autor, SYMBOL tecnica)
C.4. Dominios tipo Lista Las listas son estructuras comunes de datos en Prolog consideradas como una forma de objeto compuesto. Son secuencias de elementos generalmente homogneos. Sin embargo, en Visual Prolog es fcil crear listas heterogneas mediante el uso eficaz de declaracin de dominios. DOMAINS listaenteros = integer* /* Lista de enteros */ listacaracteres = char* /* Lista de caracteres */ listacuadros = cuadro* /* Lista de estructuras del dominio cuadro */ Veamos ahora un ejemplo de lista polimrfica que puede almacenar tanto estructuras tipo cuadro como estructuras tipo escultura: DOMAINS objetos = escultura (ENTERO ns, SYMBOL autor, SYMBOL material); cuadro (ENTERO ns, SYMBOL autor, SYMBOL tecnica) /* Los objetos pueden ser esculturas o cuadros */ listapolim = objetos* /* Esto es una lista de objetos */ C.5. Dominios tipo Predicado
- 32 -
Un dominio predicado (dominio puntero a predicado), permite la declaracin de un grupo o una clase de predicados DOMAINS par = pares (INTEGER, INTEGER) listapares = par* listaenteros = integer* unaria = determ INTEGER (INTEGER) - (i) PREDICATES predicadosuma(par, INTEGER) cubo: unaria cuadrado: unaria operacion(listapares, unaria, listaenteros) CLAUSES cubo(E, ECubo):- ECubo=E*E*E. cuadrado(E, ECuadrado):- ECuadrado=E*E. predicadosuma(pares(E1, E2), Suma):- Suma=E1+E2. /*---*/ operacion([],_,[]). operacion([X|Y], OperacionUnaria, LRes):- predicadosuma(X, S), Res=OperacionUnaria(S), operacion(Y,OperacionUnaria,Aux), LRes=[Res|LAux]. GOAL operacion([pares(3,2), pares(2,1), pares(3,4)], cuadrado, ListaCuadrados), operacion([pares(3,2), pares(2,1), pares(3,4)], cubo, ListaCubos). Vamos a explicar detalladamente cmo funciona el ejemplo propuesto para ilustrar el uso de la seccin DOMAINS. El predicado principal se denomina operacion y admite como argumentos una lista de predicados del dominio listapares, un predicado del dominio OperacionUnaria y una lista de enteros. Es interesante notar que en Visual Prolog podemos pasar como argumentos de nuestros predicados, no slo datos y objetos compuestos sino tambin predicados y funciones que realizan diversas operaciones. De este modo, el predicado operacion recorre cada par de la lista, suma los nmeros que componen dicho par y les aplica el predicado (operacin unaria), pasado por parmetro, as el mismo predicado operacion sirve para calcular cuadrados, cubos, etc., sobre la suma de los pares de la lista original. Como vemos unaria = determ INTEGER (INTEGER) - (i) es la definicin de un dominio al que pertenecen todos los predicados que tengan esa forma. Cualquier predicado que realiza una operacin unaria de este tipo encaja en ese dominio. As pues en el ejemplo tenemos definidos los predicados cuadrado y cubo como del dominio unaria. En la seccin CLAUSES se define exactamente el cuerpo de ambos predicados que este caso actan como funciones. Para la meta especificada, el resultado de la ejecucin es el siguiente: ListaCuadrados=[25,9,49], ListaCubos=[125,27,343] 1 Solution D. Seccin de la base de datos Como sabemos un programa en Visual Prolog no es ms que un conjunto de hechos y reglas. En ocasiones, podemos querer actualizar este conjunto de hechos mientras el
- 33 -
programa se ejecuta. En tal caso, los hechos deben tratarse como un conjunto dinmico de datos que pertenecen a una base que puede ser actualizada y modificada convenientemente mientras dura la ejecucin del programa. Slo los hechos que se declaran en la seccin FACTS sern dinmicos y podrn ser actualizados en tiempo de ejecucin. La seccin FACTS (tambin llamada DATABASE) tiene la siguiente forma: [GLOBAL] {FACTS | DATABASE} [- nombre de la base de datos] [nocopy][{nondeterm|determ|single}] hecho_1[([Lista_Args_hecho_1])] ... [nocopy][{single|determ|nondeterm}] hecho_N[([Lista_Args_hecho_N])] ... donde: GLOBAL: determina si esta seccin es o no de mbito global a todo el proyecto. nocopy: determina que los datos que se van a enlazar o unificar con una variable al hacer una llamada al hecho no se almacenarn temporalmente en la pila global del programa. nodeterm: determina que pueden existir varias instancias para el hecho. determ: determina que slo puede existir una instancia para el hecho en el mismo momento. single: determina que slo puede existir una y slo una instancia para el hecho.
D.1 Predicados definidos en Visual Prolog para manejar la base de datos assert(<Dominio del hecho> Hecho) - (i) : Inserta un hecho tras otros encontrados pertenecientes al mismo predicado en la base de hechos. Si se trata de un hecho single lo sustituye. Este predicado nunca falla. assert(<De correspondientes dominios del hecho> Hecho, NombreSeccionHechos) - (i,i) : Inserta un hecho tras otros encontrados pertenecientes al mismo predicado en la base de hechos con el nombre especificado en NombreSeccionHechos. El hecho debe ser un trmino perteneciente al dominio de la seccin de hechos dados en NombreSeccionHechos. Este predicado nunca falla. asserta(<Dominio del hecho> Hecho) - (i): ) : Inserta un hecho delante de otros encontrados pertenecientes al mismo predicado en la base de hechos. Este predicado nunca falla. asserta(<De correspondientes dominios del hecho> Hecho, NombreSeccionHechos) - (i,i) : Inserta un hecho delante de otros encontrados pertenecientes al mismo predicado en la base de hechos con el nombre especificado en NombreSeccionHechos. El hecho debe ser un trmino perteneciente al dominio de la seccin de hechos dados en NombreSeccionHechos. Este predicado nunca falla. assertz(<Dominio del hecho> Hecho) - (i) : Como assert/1. Este predicado nunca falla. assertz(<De correspondientes dominios del hecho> Hecho, NombreSeccionHechos) - (i,i): Como assert/2. Este predicado nunca falla. consult(STRING OSNombreFichero) - (i): Sirve para leer hechos desde un fichero de hechos y almacenarlos en la base de hechos. Este fichero debe haber sido salvado con save. consult(STRING OSNombreFichero, NombreSeccionHechos) - (i,i): Sirve para leer hechos desde un fichero de hechos y almacenarlos en la base de hechos de nombre NombreSeccionHechos. Este fichero debe haber sido salvado con save. save(STRING OSNombreFichero) - (i) : Sirve para salvar los hechos de la seccin de hechos sin nombre en un fichero de texto.
- 34 -
save(STRING OSNombreFichero, NombreSeccionHechos) - (i,i) : Sirve para salvar los hechos de una seccin de hechos con nombre NombreSeccionHechos en un fichero de texto. nondeterm retract(<Dominio del hecho> Hecho) : Borra el primer hecho que encuentre que case con el hecho especificado en el argumento. Falla cuando no hay ms hechos que borrar. nondeterm retract(<De correspondientes dominios del hecho> Hecho, NombreSeccionHechos) - (i,i) : Borra el primer hecho que encuentre que case con el hecho especificado en el argumento. Acta sobre del dominio de hechos con nombre NombreSeccionHechos. Falla cuando no hay ms hechos que borrar. determ retractall(<Dominio del hecho> Hecho) - (i) : Borra el todos los hechos encontrados que casen con el hecho especificado en el argumento. Nunca falla. determ retractall(<De correspondientes dominios del hecho> Hecho, NombreSeccionHechos ) - (i,i) : Borra todos los hechos encontrados que casen con el hecho especificado en el argumento. Acta sobre del dominio de hechos con nombre NombreSeccionHechos.
Veamos ahora algunos ejemplos de uso de los predicados mostrados para manejar la base de hechos. FACTS padre(string, string) PREDICATES abuelo(string, string) CLAUSES padre(juan, pepe). padre(juan, luis). padre(pepe, manolo). abuelo(X, Y):-padre(X, Z), padre(Z, Y). GOAL assert(padre(pepe, beatriz)), assertz(padre(pepe, carlos)), asserta(padre(pepe, maria)), abuelo(juan, Y). Tenemos 3 hechos que definen quin es padre de quin y un predicado para deducir el parentesco abuelo. Tras la ejecucin de la meta obtenemos el siguiente resultado: Y=maria Y=manolo Y=beatriz Y=carlos 4 Solutions Si examinamos paso a paso esta ejecucin, lo que ha sucedido ha sido lo siguiente: Tras el primer assert hemos insertado el hecho padre(pepe, beatriz) tras padre(pepe, manolo). El predicado assertz funciona como assert, luego hemos insertado el hecho padre(pepe, carlos) tras el hecho padre(pepe, beatriz). Por ltimo asserta inserta al principio, luego el hecho padre(pepe, maria) ha quedado colocado el primero. Veamos ahora un ejemplo del uso de retract y retractall. FACTS padre(string, string)
- 35 -
PREDICATES abuelo(string, string) CLAUSES padre(juan, pepe). padre(juan, luis). padre(pepe, manolo). padre(pepe, beatriz). padre(pepe, carlos). padre(pepe, maria). abuelo(X, Y):-padre(X, Z), padre(Z, Y). GOAL retract(padre(pepe, _)), !, padre(pepe, L). En este caso retract borra todas la primera ocurrencia de padre, siempre que su primer argumento sea pepe. El corte que va despus de retract sirve para que Visual Prolog no haga backtracking y borre todas las ocurrencias de padre(pepe, ...), ya que por defecto el compilador intenta ofrecer todas las posibles soluciones para una meta dada. Con el corte situado en ese lugar, slo se hace bactracking sobre padre(pepe, L). El resultado de la ejecucin se muestra a continuacin: L=beatriz L=carlos L=maria En el ejemplo siguiente, vemos que en lugar de usar retract estamos usando retractall para borrar todas las ocurrencias de padre(pepe, ...). FACTS padre(string, string) PREDICATES abuelo(string, string) CLAUSES padre(juan, pepe). padre(juan, luis). padre(pepe, manolo). padre(pepe, beatriz). padre(pepe, carlos). padre(pepe, maria). abuelo(X, Y):-padre(X, Z), padre(Z, Y). GOAL retractall(padre(pepe, _)), padre(pepe, L). El resultado de esta ejecucin es: NO Solution
E. Seccin de definicin de predicados En esta seccin se definen los predicados que pueden pertenecer a dominios definidos en la seccin DOMAINS (punteros a predicados), o se definen los predicados con una forma determinada en caso de que no los hayamos agrupado en ningn dominio concreto (todas
- 36 -
las reglas de la seccin de clusulas deben pertenecer a algn predicado). La seccin de definicin de predicados va precedida siempre de la palabra PREDICATES. Por ejemplo podemos tener este caso: DOMAINS unaria = determ INTEGER (INTEGER) - (i) PREDICATES cubo: unaria CLAUSES cubo(E, Res):-Res=E*E*E. O podemos tener este otro: PREDICATES cubo(INTEGER, INTEGER) CLAUSES cubo(E, Res):-Res=E*E*E.
En el primer caso cubo se define como una funcin y debe ser llamada como A=cubo(3) y en el segundo caso la llamada debe hacerse como cubo(3, A). Ambas formas de definicin son igualmente correctas y su uso depender de la aplicacin en cuestin en la que estemos trabajando. Tipos de predicados Visual Prolog soporta los siguientes tipos de predicados: erroneous: nunca debe fallar y debe producir 0 soluciones. failure: puede fallar y debe producir 0 soluciones. nondeterm: puede fallar y puede producir mltiples soluciones. procedure: nunca debe fallar aunque pueden producirse errores en tiempo de ejecucin y debe producir una nica solucin. determ: puede fallar y debe producir una nica solucin, es decir, no hacen backtracking. multi: nunca debe fallar y puede producir mltiples soluciones mediante la tcnica de backtracking.
F. Seccin de clusulas La seccin de clusulas contiene la especificacin o implementacin del conjunto de hechos y reglas que componen el programa. Dicha seccin se encabeza con la palabra CLAUSES. Una clusula puede ser: - Un hecho: por ejemplo padre(juan, maria). Una regla de deduccin: por ejemplo abuelo(X, Y):-padre(X, Z), padre(Z, Y). Como se observa la regla de deduccin se puede interpretar del modo siguiente, la parte izquierda es cierta si la parte derecha de la regla es cierta. Para ello deben ser ciertas todas las clusulas separadas por conjunciones "," o, al menos, una de las que estn separadas por disyunciones ";". Si una parte de la regla falla, se intenta hacer backtracking con la inmediatamente anterior, y si esta es la parte izquierda de la clusula con la clusula siguiente en caso de que exista.
- 37 -
Una secuencia de clusulas que definen un predicado se denomina procedimiento.
G. Seccin de meta u objetivo En esta seccin se coloca la meta u objetivo que deseamos que Prolog satisfaga. Es similar a cualquier otra regla, ya que la meta est compuesta de un conjunto de submetas que hay que demostrar, la principal diferencia reside en que detrs de la palabra GOAL no se pone ":-", es decir no existe parte izquierda de la regla, y sta se ejecuta directamente cuando arranca el programa.
- 38 -
GUA DE PRCTICA 03: INTRODUCCIN AL VISUAL PROLOG: ASPECTOS PRACTICOS OBJETIVOS El alumno podr realizar programas bsicos en Prolog. METODOLOGIA Se pedir al alumno la implementacin de programas ejemplo. A continuacin se solicitar al alumno la elaboracin de programas como respuesta a problemas enunciados. Aunque se usar Visual Prolog 5.2, para simplificar el reconocimiento del lenguaje, los programas implementados sern programas para un entorno DOS. PARTE 01: Creacin de un proyecto en Prolog (MyPrograma.VPR) 1. Utilizando el explorador de Windows, crear un directorio denominado C:\EjercicioVP. Todos los archivos generados en esta prctica se guardarn en este directorio. 2. Ejecutar el programa Visual Prolog 5.2. (es decir, ejecutar InicioProgramasVisual Prolog 5.2 Personal Edition Vip32)
3. Ir al men ProjectNew Project (o Presionar CTRL + F7) 4. En la ventana de configuracin del proyecto, configurar las siguientes propiedades: Pgina Propiedad Valor General Project Name MiPrograma1 Name of .VPR File MiPrograma1.vpr Tarjet Plataform DOS User Info ---Aqu van los datos que usted desea personalizar.
- 39 -
5. A continuacin se le mostrar en pantalla el proyecto creado as como los dems archivos del proyecto en una ventana.
6. Abrir el archivo MiPrograma1.pro (Seleccionar el nodo MiPrograma1.pro y presionar el botn Edit) 7. Modificar el contenido del archivo, de forma tal que su aspecto final sea similar al que se muestra a continuacin: Algoritmo de la funcin Factorial INCLUDE "miprograma1.inc" Factorial (N) IF N>0 THEN PREDICATES Begin F1= Factorial(N1) F = F * F1 miprograma1() Return F factorial(INTEGER,INTEGER) End hallafactorial(INTEGER) CLAUSES La instruccin N>0, funciona a manera de una restriccin. Todas las dems instrucciones se ejecutarn siempre y cuando esta instruccin sea vlida. Toda instruccin Prolog se ejecutar siempre y cuando la anterior genere un valor booleano verdadero.
factorial(0,1):- !. factorial(N, F):- N>0, N1 = N - 1, factorial(N1, F1), F = N * F1. hallafactorial(N):- factorial(N,F), write("\n Factorial de ", N), write(" es: ",F).
- 40 -
miprograma1():hallafactorial(5). GOAL miprograma1().
Toda instruccin Prolog genera un valor booleano (Verdadero Falso). Luego, toda instruccin Prolog se ejecutar siempre y cuando la instruccin precedente gener un valor booleano verdadero.
NOTA: A continuacin el lector puede Ejemplo de instrucciones condicionales: Codificacin en Prolog Equivalente en seudocodigo factorial(N,F):- N>0, Factorial(N,F) N1 = N - 1, IF (N>0) THEN factorial(N1, F1), Begin F = N * F1. N1 = N 1 Factorial(N1,F1) F = N * F1 End ImprimeEdad(N):ImprimeEdad(N) Write("La person "), Write(La persona); N>15, IF N>15 Then write("\n No es un nio "), Begin N>18, Write(No es nio); write("\n Es mayor de edad "), IF (N>18) Then N>40, N<60, Begin write("\n y una persona madura "). Write(Mayor de edad);
IF (N>40)AND(N<60) THEN write(y una persona madura);
End End
PARTE 02: Anlisis y verificacin del comportamiento del compilador 8. Responda a las siguientes preguntas: a) Qu sucede cuando las expresiones de la seccin predicates son borradas? Corre el programa? S o no?. Investigue la utilidad del b) Cul es la diferencia entre las siguientes instrucciones? smbolo !. (verifique el qu es miprograma1():- hallafactorial(5). corte o fallo(fail) de una miprograma1():- hallafactorial(5)!. ejecucin) miprograma1():- hallafactorial(5), fail. c) En el siguiente programa Prolog, por qu cree que en la seccin clauses un programador escribira repetidamente la clusula fibonacci(1), fibonacci(2), fibonacci(3), etc.? /*Si reemplaza estas instrucciones PREDICATES por todas las funciones fibonnacci fibonacci(INTEGER, INTEGER) de la seccin clauses,qu ocurre?*/ HallarFibonacci(INTEGER) CLAUSES CLAUSES fibonacci(0, F):- F=0. fibonacci(1, F):- F=1. fibonacci(2, F):- F=1. fibonacci(3, F):- F=2. fibonacci(4, F):- F=3. fibonacci(5, F):- F=5. fibonacci(6, F):- F=8. HallarFibonacci(N):fibonacci(0, 0):- !. fibonacci(1, 1):- !. fibonacci(N, F):N1 = N-1, N2 = N-2, fibonacci(N1, F1), fibonacci(N2, F2), F = F1 + F2.
- 41 -
fibonacci(N, F), write("Resultado: " , F). GOAL HallarFibonacci(6). Qu sucede cuando en la seccin GOAL (Objetivo o meta)? Escribo cualquiera de las siguientes instrucciones de manera secuencial (una modificacin por vez): GOAL GOAL GOAL HallarFibonacci(1). HallarFibonacci(3). HallarFibonacci(5). GOAL HallarFibonacci(6). GOAL HallarFibonacci(7). GOAL HallarFibonacci(10).
Cul es su respuesta a las anormalidades que menciona el compilador Prolog cuando algunas de estas instrucciones es ejecutada y simplemente el programa no funciona?. Reemplaze el cdigo original por el que se sugiere reemplazar y responda porqu este cdigo si resuelve el problema?. PARTE 03: Implementacin de programas interactivos. 9. Crear un nuevo proyecto. 10. En el archivo *.pro escribir el siguiente programa: INCLUDE "programa3.inc" PREDICATES programa3() opcion(INTEGER) procesar() menu(INTEGER) CLAUSES opcion(0):- !. opcion(1):write ("\n Escriba el nmero A: "), readint(A), write ("\n Escriba el nmero B: "), readint(B), C= A + B, write("\n La SUMA resultante es: ",C). opcion(2):write ("\n Escriba el nmero A: "), readint(A), write ("\n Escriba el nmero B: "), readint(B), C= A - B, write("\n La RESTA resultante es: ",C). opcion(3):write ("\n Escriba el nmero A: "), readint(A), write ("\n Escriba el multiplicador B: "), readint(B), C= A * B, write("\n El PRODUCTO resultante es: ",C). opcion(4):write ("\n Escriba el nmero A: "),
- 42 -
readint(A), write ("\n Escriba el divisor B: "), readint(B), C= A / B, write("\n La DIVISION resultante es: ",C). opcion(5):opcion(6):opcion(7):opcion(8):opcion(9):menu(M):exit. !. !. !. !.
write("\n ---------------------------"), write("\n OPERACIONES MATEMATICAS "), write("\n ---------------------------"), write("\n [1] Suma de dos nmeros"), write("\n [2] Resta de dos nmeros"), write("\n [3] Multiplicacin de dos nmeros"), write("\n [4] Divisin de dos nmeros"), write("\n [5] Salir"), write("\n "), write("\n Escriba su opcin: "), readint(N), M=N.
procesar():menu(H), H>=0,H<10, opcion(H), procesar(), write("\n Opcion leida:",H). programa3():- procesar(), write("\n programa terminado"). GOAL programa3(). PARTE 04: Implementacin de programas de manejo de listas. 11. Crear un nuevo proyecto, y escriba el siguiente programa: INCLUDE "programa4.inc" DOMAINS TPersona= registro(Integer,String,String,INTEGER) TLista = TPersona* PREDICATES /*Posible agregado para permitir bsquedas de personas en lista*/ PREDICATES InsertToLista(TPersona, TLista, TLista) Buscar(TPersona, TLista,INTEGER) insertar(INTEGER, TLista, Tlista) writedatos(TPersona) CLAUSES nondeterm recorrerlista(TLista) Buscar(E,[],0):- !. opcion(INTEGER, TLista, TLista) procesar(TLista) menu(INTEGER) programa4() Buscar(E,[_|Y],F):- F=0, E\==Y, F=1,!. Buscar(E,[X|Y],F):Buscar(E,X,F1), Buscar(E,Y,F2), F = F1 + F2.
- 43 -
CLAUSES InsertToLista(E,[],[E]):-!. InsertToLista(E,[X|Y],[X|Cola]):- InsertToLista(E, Y, Cola), !. InsertToLista(E,LOr,[E|LOr]). insertar(N, L, LOut):write("Nombre del Empleado: "), readln(Nombre), write("Apellido del Empleado: "), readln(Apellido), write("Edad del Empleado: "), readint(Edad), P= registro(N, Nombre, Apellido, Edad), InsertToLista(P, L, LOut). writedatos(registro(Index, Nombre, Apellido, Edad)):write("\n Empleado ", Index), write("\n Nombre: ", Nombre), write("\n Apellido: ", Apellido), write("\n Edad: ", Edad), write("Pulsa para continuar..."), readint(_). recorrerlista([]):-!. recorrerlista([X|Y]):- writedatos(X), recorrerlista(Y). recorrerlista([_|Y]):- recorrerlista(Y). opcion(0, opcion(1, opcion(2, opcion(3, opcion(4, opcion(5, opcion(6, opcion(7, opcion(8, opcion(9, menu(M):L, L, L, L, L, L, L, L, L, L, L):- !. NuevaL):- insertar(1, L, LOut), NuevaL = LOut,!. LNueva):- recorrerlista(L), LNueva = L,!. L):- !. L):- !. L):- exit. L):- !. L):- !. L):- !. L):- !.
write("\n ---------------------------"), write("\n OPERACIONES DE LISTAS "), write("\n ---------------------------"), write("\n [1] Agregar elemento"), write("\n [2] Mostrar Lista"), write("\n [3] Buscar Empleado"), write("\n [4] Eliminar empleado"), write("\n [5] Salir"), write("\n "), write("\n Escriba su opcin: "), readint(N), M=N. procesar(L):menu(H), H>=0,H<10, opcion(H, L, NuevaL), procesar(NuevaL),!. procesar(_):-write("Hasta Pronto."). programa4():- procesar([]),
- 44 -
write("\n programa terminado"). GOAL programa4(). 12. Agregarle funcionalidad a todos los mens faltantes de este programa.
PARTE 05: Implementacin de programas con Base de conocimientos. 13. Crear un nuevo proyecto, y escriba el siguiente programa: INCLUDE "programa5.inc" FACTS - MyDBConocimientos padre(STRING, STRING) PREDICATES abuelo(STRING, STRING) ElPapaDe(STRING, STRING) programa5() InicializaBD() opcion(INTEGER) procesar() menu(INTEGER) CLAUSES padre("juan", "pepe"). padre("juan", "luis"). padre("pepe", "manolo"). abuelo(X, Y):- padre(X, Z), padre(Z, Y),!. ElPapaDe(X,Y):- padre(Y, X),!. InicializaBD():- assert(padre("pepe", "beatriz")), assertz(padre("pepe", "carlos")), asserta(padre("pepe", "maria")). opcion(0):- !. opcion(1):write ("\n Escriba el nombre del padre: "), readln(A), write ("\n Escriba el nombre del hijo: "), readln(B), assert(padre(A, B)). opcion(2):write ("\n Mencione el abuelo: "), readln(A), write("\n Sus Nietos son: "), abuelo(A, Y), write("\n ",Y). opcion(3):write ("\n Mencione el nombre del hijo: "), readln(A), write("\n Su Padre es: "), ElPapaDe(A, Y),
- 45 -
write("\n
",Y).
opcion(4):retractall(_, MyDBConocimientos), consult("MyDBConocimientos.txt",MyDBConocimientos), write("Se cargo la BD de Conocimientos"),!. opcion(5):- save("MyDBConocimientos.txt",MyDBConocimientos), write("Se guardo la BD de Conocimientos"),!. opcion(6):- retractall(_, MyDBConocimientos), write("Se Limpio la BD de Conocimientos"),!. opcion(7):- exit. opcion(8):- !. opcion(9):- !. menu(M):write("\n -----------------------------"), write("\n OPERACIONES DE INTELIGENCIA ARTIFICIAL "), write("\n -----------------------------"), write("\n [1] Aadir conocimiento"), write("\n [2] Preguntar por descendientes"), write("\n [3] Preguntar por Asccendientes"), write("\n [4] Cargar la Base de conocimientos"), write("\n [5] Guardar Base de conocimientos"), write("\n [6] Limpiar Base de conocimientos"), write("\n [7] Salir"), write("\n "), write("\n Escriba su opcin: "), readint(N), M=N.
procesar():menu(H), H>=0,H<10, opcion(H), procesar(). programa5():InicializaBD(), procesar(). GOAL programa5().
Este programa almacena en una base de conocimientos informacin con el siguiente formato: X es padre de Y. En la seccin FACTS se han declarado todos los formatos que se utilizan para almacenar conocimiento en la base de datos. Usted, a partir de este ejemplo puede crear otros programas similares. Esta nica estructura X es padre de Y, nos puede servir para determinar que X padre de Y, que Y es hijo de X , tambin, que X es abuelo de Z, o a la inversa. En realidad, se trata de que en la base de conocimientos se est almacenando un grafo, y las instrucciones Prolog me permiten indagar por su contenido. Puede constatar, que el contenido inicial del rbol de conocimientos es similar a la siguiente estructura.
- 46 -
Juan Pepe Luis
Manolo
Beatriz
Carlos
Mara
Estructura: X es padre de Y Padre(juan, pepe) Padre(juan, luis) Padre(pepe,Manolo) Padre(pepe,Beatriz) Padre(pepe,Carlos) Padre(pepe,Mara)
Arbol de conocimientos almacenado en la Base de Conocimientos inicial
PARTE 06: Tareas de implementacin Problema 1 Implemente programas que realicen clculos matemticos simples. Por ejemplo, una calculadora. Problema 2 Implemente programas que manipulen listas. Incluya los mtodos: Agregar, Eliminar, Buscar, Reemplazar, Salir, etc.
Problema 3 Implemente programas que almacenen conocimientos respecto de las reglas de trabajo en una empresa, y que cuando el usuario pregunte al sistema respecto si alguna accin podra violar alguna regla empresaria, el sistema le responda de no debera realizar tal accin. Problema 4: Programar la siguiente funcin matemtica en Prolog
8 7 6 5 4 3 2 1 0 -1 -2 -3 0 3 6 9 12
h(x)=
No definida x, x 3, x 6, no definida,
x 3 0 x < 3 3 x < 6 6 x < 9 x 6
Problema 5: Dado el siguiente rbol genealgico, crear una base de hechos que lo represente y el conjunto de clusulas necesarias que me permitan establecer las relaciones habituales en cualquier familia, como por ejemplo: hermanos(X,Y). X es hermano(a) de Y? padre(X,Y). X es padre de Y? abuelos(X,Y). X es abuelo(a) de Y? primos(X,Y). X es primo(a) de Y? Tambin se disearn clausulas que nos permitan relacionar diferentes familias, por ejemplo
- 47 -
cuados(X,Y). X es cunado(a) de Y? Se crearn clusulas de caracter recursivo como: antepasado(X,Y). X es antepasado de Y?
Familia 1 Antonio ----- Cndida Rosa ------------------- David
Familia 2 Jos-----Micaela Lucio----Pilar
Juan----Mara
Jos
Mara-----Antonio Pep
Luis
Elena--- Juan Ana
Antonio
Alberto----Rosa Fiona
Enrique
Pilar------------------Mario Juan-------Sara Sonia
Problema 6: Modificar el programa anterior, para permitir la insercin de nuevos hechos en nuestra base de conocimientos. Como caracterstica bsica se considerar la insercin de este nuevo conocimiento: Juan, Cuyos padres son Pilar y Mario, decide casarse con Sara (sus padres no son conocidos para nuestra base de hechos). Como efecto de este matrimonio, tienen una hija a la que deciden ponerle el nombre de Sonia. Problema 7 En este apartado se pretende modelizar la computacin del parentesco entre dos personas de una familia, en primer lugar definiremos un conjunto de conceptos necesarios para poder realizar el clculo: Lnea: es el conjunto de serie de grados que pueden existir entre dos personas; puede ser recta o colateral. Linea Recta: es la integrada por individuos que descienden unos de otros: Padres, hijos, nietos, etc. Lnea colateral: Es la formada por personas que no descienden unas de otras, pero tienen ascendientes comunes: hermanos, tos, primos, sobrinos, etc. Grado: es, en materia de parentesco, cada una de las generaciones existentes entre dos personas relacionadas por vnculos de sangre. as del padre al hijo hay una generacin o grado, entre abuelo y nieto existen dos grados Para calcular el grado existen dos sistemas diferentes: Derecho Civil, existen tantos grados como generaciones, as en la lnea recta entre el nieto y el abuelo existen dos grados de parentesco. si utilizamos la lnea colateral, para calcular el grado de parentesco entre dos individuos, se asciende hasta el primer antepasado comn y luego se desciende hasta la persona respecto de la cual se computa el parentesco. La suma del Nmero de generaciones de ambas ramas nos proporcionar el grado que existe entre los individuos, por ejemplo, con este sistema, el hermano se halla en segundo grado con cualquier otro hermano, los primos hermanos distan cuatro grados, etc. Derecho Cannico: En el caso de la lnea recta, el cmputo es idntico que en el caso del derecho civil. En la lnea colateral se cuentan las generaciones o grados de la lnea ms larga y no se suman como en el derecho civil. de esta forma, el hermano se
- 48 -
encuentra en primer grado con sus hermanos, y los primos hermanos se encontraran en segundo grado. esta computacin rige solamente para el matrimonio cannico a efecto del impedimento de parentesco que ha de ser estimado conforme a ella. Se pide construir un conjunto de reglas en Prolog que me permitan obtener los anteriores conceptos, por ejemplo: recta(X,Y,Y):- Nos dice si X tiene un parentesco directo con Y. Colateral(X,Y):- nos dice si X tiene un parentesco colateral con Y. grado_civil(X,Y):- Calcula el grado existente entre las personas X e Y aplicando las leyes del derecho civil. Z estar instanciada al valor de ese grado. grado_canonico(X,Y):- Calcula el grado existente entre las personas X e Y aplicando las leyes del derecho civil. Z estar instanciada al valor de ese grado.
- 49 -
GUA DE PRCTICA 04: INTRODUCCIN AL VISUAL PROLOG: PROGRAMACION DE APLICACIONES CON ENTORNOS VISUALES OBJETIVOS El alumno podr realizar programas bsicos en Visual Prolog usando las interfaces graficas
METODOLOGIA Se pedir al alumno la implementacin de programas ejemplo. A continuacin se solicitar al alumno la elaboracin de programas como respuesta a problemas enunciados. Aunque se usar Visual Prolog 5.2, para simplificar el reconocimiento del lenguaje, los programas implementados en esta prctica sern programas para un entorno Visual Windows. PARTE 01: Creacin de un proyecto Visual en Prolog (MyProgramaVisual.VPR) A) Creacin del programa con un formulario MDI predeterminado 1. Utilizando el explorador de Windows, crear un directorio denominado C:\ProgramaVP. Todos los archivos generados en esta prctica se guardarn en este directorio. 2. Ejecutar el programa Visual Prolog 5.2. (es decir, ejecutar InicioProgramasVisual Prolog 5.2 Personal Edition Vip32)
3. Ir al men ProjectNew Project (o Presionar CTRL + F7) 4. En la ventana de configuracin del proyecto, configurar las siguientes propiedades: Pgina General Tarjet User Info Propiedad Project Name Name of .VPR File Plataform ---Valor ProgramaVisual ProgramaVisual.vpr Windows32 Aqu van los datos que usted desea personalizar.
- 50 -
5. A continuacin se le mostrar en pantalla el proyecto creado as como los dems archivos del proyecto en una ventana.
Ventana: Administrador proyecto del
Luego de esta accin Usted habr creado un programa con un formulario MDI. 6. Ejecutar el programa predeterminado (ir al men ProjectRun) La aplicacin creada de manera predeterminada tendr el siguiente aspecto.
- 51 -
7. Detener el programa en ejecucin. 8. Guardar todo. B) PERSONALIZACION DEL FORMULARIO PREDETERMINADO 9. Abrir la ventana del Administrador del proyecto. 10. Seleccionar el botn Men. Luego seleccione Task men y a continuacin presione el botn Edit.
Presionar el botn Edit
Presionar el botn Attributes
11. En la ventana Task Men, seleccionar el Item &file y presionar el botn Attributes, a continuacin modifique el texto como Archivo tal como se muestra en la imagen siguiente:
- 52 -
12. Proceder de la misma manera con los otros tems del men. 13. Correr la aplicacin. Usted podr ver a continuacin todo el men personalizado.
14. Detener la ejecucin del programa y grabar todo.
PARTE 02: CREAR UN FORMULARIO frmCalculo 15. Abrir el Administrador de proyectos. 16. Seleccionar el botn Dialog. 17. A continuacin seleccionar el botn New (Nuevo formulario de dilogo.) 18. Configurar las propiedades del nuevo formulario segn se indica a continuacin 19. Luego de la correcta configuracin, presionar el botn OK El aspecto del nuevo formulario recin creado ser semejante al que se muestra a continuacin.
Presione botn OK
el
- 53 -
Paleta de controles
20. Usando la paleta de controles, agregar tres controles Edit controls al formulario frmCalculo, y configurar sus propiedades segn se muestra a continuacin:
21. Agregar tres controles Static Text al formulario frmCalculo, y configurar sus propiedades segn se muestran a continuacin:
al formulario frmCalculo, y configure sus 22. Agregue un control Push Button propiedades segn se presenta a continuacin:
- 54 -
El aspecto final del formulario recin creado ser semejante al que se muestra a continuacin:
23. Grabar Todo.
PARTE 03: AGREGAR UN ITEM AL MENU PRINCIPAL 24. En la Ventana administrador de proyectos, seleccionar el botn Men, y agregar el Men Procesar (ver figura 1). 25. Luego agregarle un submen Clculos (figura 2) ( es decir crear MenProcesar)
Figura 1. 26. Presionar OK, y luego Grabar todo.
Figura 2
- 55 -
PARTE 04: AGREGAR COMMANDOS (CLAUSULAS) PARA EL SUBMEN Clculos (que tiene el identificador id_Procesar_calculos). A ) Implementar Procedimientos de creacin del formulario fmrCalculo. 27. Ir a la ventana de Administrador del proyecto y mostrar las tareas del men (Figura A) 28. Presionar el botn Code Expert. Se le mostrar el cuadro de dilogo mostrado en la Figura B. Configurarlo segn se muestra en esa imagen.
Presionar el botn Code Expert
Presionar el botn OK
Figura A
Figura C
Figura B
Presionar el botn Yes
29. Presionar el botn Yes, en el cuadro de dilogo que se le mostrare (figura C). Luego de realizada esta accin usted podr constatar (si as lo desea), que en el archivo de programa ProgramaVisual.pro se han agregado de manera automtica las siguientes lneas de cdigo (CUIDADO! NO modifique esas lneas. Es cdigo autogenerado por el Visual Prolog), las cuales servirn para poder llamar al formulario frmCalculo desde el men principal.
- 56 -
GuasdeLaboratoriodeSistemasExpertosInteligenciaArtificial IngenieraenInformticaySistemasIng.EdgarA.TayaAcosta/Ing.EdwinO.RamosVelsquez %BEGIN_DLG frmCalculo /************************************************************************** Creation and event handling for dialog: frmCalculo **************************************************************************/ constants %BEGIN frmCalculo, CreateParms, 00:56:06-1.2.2007, Code automatically updated! dlg_frmcalculo_ResID = idd_frmcalculo dlg_frmcalculo_DlgType = wd_Modal dlg_frmcalculo_Help = idh_contents %END frmCalculo, CreateParms predicates dlg_frmcalculo_eh : EHANDLER dlg_frmcalculo_handle_answer(INTEGER EndButton,DIALOG_VAL_LIST) dlg_frmcalculo_update(DIALOG_VAL_LIST) clauses dlg_frmcalculo_Create(Parent):%MARK frmCalculo, new variables dialog_CreateModal(Parent,dlg_frmcalculo_ResID,"", [ %BEGIN frmCalculo, ControlList, 00:56:06-1.2.2007, Code automatically updated! df(idcalculo_1,editstr("1",[]),nopr), df(idcalculo_2,editstr("2",[]),nopr), df(idcalculo_3,editstr("3",[]),nopr) %END frmCalculo, ControlList ], dlg_frmcalculo_eh,0,VALLIST,ANSWER), dlg_frmcalculo_handle_answer(ANSWER,VALLIST). dlg_frmcalculo_handle_answer(idc_ok,VALLIST):-!, dlg_frmcalculo_update(VALLIST). dlg_frmcalculo_handle_answer(idc_cancel,_):-!. % Handle Esc and Cancel here dlg_frmcalculo_handle_answer(_,_):errorexit(). dlg_frmcalculo_update(_VALLIST):%BEGIN frmCalculo, Update controls, 00:56:06-1.2.2007, Code automatically updated! _IDCALCULO_1_VALUE = dialog_VLGetstr(idcalculo_1,_VALLIST), _IDCALCULO_2_VALUE = dialog_VLGetstr(idcalculo_2,_VALLIST), _IDCALCULO_3_VALUE = dialog_VLGetstr(idcalculo_3,_VALLIST), %END frmCalculo, Update controls true. %MARK frmCalculo, new events dlg_frmcalculo_eh(_,_,_):-!,fail. %END_DLG frmCalculo
B) Habilitar el men id_Procesarcalculos 30. A continuacin, para crear el cdigo que activar el submen id_Procesar_Calculos, activar nuevamente el botn Cod Expert, pero en esta ocasin, configurar el siguiente cuadro de dilogo (Figura D):
- 57 -
31. Presionar el botn Add Clause.
Presionar el botn Add Clause.
Figura D
32. Grabar todo. 33. En la ventana Administrador de proyectos presionar el botn module y se le mostrar en pantalla el cdigo del programa principal. Una seccin del archivo se parecer a la imagen que se muestra a continuacin:
%BEGIN Task Window, ToolbarCreate, 22:00:01-31.1.2007, % Code automatically updated! tb_project_toolbar_Create(_Win), tb_help_line_Create(_Win), %END Task Window, ToolbarCreate ifdef use_message msg_Create(100), enddef !. %END Task Window, e_Create
Estas lneas debern ser modificadas por las que se indica abajo
%MARK Task Window, new events %BEGIN Task Window, id_Procesar_calculos task_win_eh(_Win,e_Menu(id_Procesar_calculos,_ShiftCtlAlt),0):-!, !. %END Task Window, id_Procesar_calculos %BEGIN Task Window, id_help_contents task_win_eh(_Win,e_Menu(id_help_contents,_ShiftCtlAlt),0):-!, vpi_ShowHelp("programavisual.hlp"), !. %END Task Window, id_help_contents
34. Modificar las lneas resaltadas por las siguientes lneas: %BEGIN Task Window, id_Procesar_calculos task_win_eh(Win,e_Menu(id_Procesar_calculos,_ShiftCtlAlt),0):- !, dlg_frmcalculo_Create(Win), !. %END Task Window, id_Procesar_calculos 35. Grabar todo 36. Correr el programa. Y podris contemplar que la aplicacin tiene un aspecto similar al que se muestra a continuacin:
- 58 -
37. Grabar todo.
PARTE 05: IMPLEMENTACION FORMULARIO frmCalculo
DE
LA
IMPLEMENTACION
DE
RUTINAS
DEL
38. Abrir el archivo Administrador de proyectos. Y seleccionar el botn Code Expert. 39. Se le mostrar un cuadro de dilogo. Configurar este cuadro de dilogo segn se muestra a continuacin Figura A:
Figura A
Figura B
40. A continuacin, presionar el botn Edit Clause. Luego de esta accin, se le mostrar la ventana de cdigos, Una parte de la misma tendr un aspecto similar a la siguiente imagen: %BEGIN frmCalculo, Update controls, 00:56:06-1.2.2007, Code automatically updated! _IDCALCULO_1_VALUE = dialog_VLGetstr(idcalculo_1,_VALLIST), _IDCALCULO_2_VALUE = dialog_VLGetstr(idcalculo_2,_VALLIST),
- 59 -
_IDCALCULO_3_VALUE = dialog_VLGetstr(idcalculo_3,_VALLIST), %END frmCalculo, Update controls true. %MARK frmCalculo, new events %BEGIN frmCalculo, e_CloseRequest dlg_frmcalculo_eh(_Win,e_CloseRequest,0):-!, !. %END frmCalculo, e_CloseRequest %BEGIN frmCalculo, idcalculo_cmdprocesar _CtlInfo dlg_frmcalculo_eh(_Win,e_Control(idcalculo_cmdprocesar,_CtrlType,_CtrlWin,_CtlInfo),0):!, !. %END frmCalculo, idcalculo_cmdprocesar _CtlInfo dlg_frmcalculo_eh(_,_,_):-!,fail. %END_DLG frmCalculo 41. Modificar la codificacin para el procedimiento idcalculo_cmdProcesar., el cual, actualmente tiene el siguiente aspecto: %BEGIN frmCalculo, idcalculo_cmdprocesar _CtlInfo dlg_frmcalculo_eh(_Win,e_Control(idcalculo_cmdprocesar,_CtrlType,_CtrlWin,_CtlInfo),0):!, !. %END frmCalculo, idcalculo_cmdprocesar _CtlInfo 42. Modificar este procedimiento, de forma tal que su aspecto sea el siguiente: %BEGIN frmCalculo, idcalculo_cmdprocesar _CtlInfo dlg_frmcalculo_eh(_Win,e_Control(idcalculo_cmdprocesar,_CtrlType,_CtrlWin,_CtlInfo),0):% Lee el primer Valor A W1 = win_GetCtlHandle(_Win,idcalculo_1), Str1 = win_GetText(W1), str_int(Str1,N1), Identificador de uno de los controles % Lee el Valor B W2 = win_GetCtlHandle(_Win,idcalculo_2), Str2 = win_GetText(W2), str_int(Str2,N2), % Realiza operacion de procesamiento N = N1 + N2, % Asigna Resultado al Recuadro C W3 = win_GetCtlHandle(_Win,idcalculo_3), str_int(StrResultado, N), win_SetText(W3, StrResultado), !. %END frmCalculo, idcalculo_cmdprocesar _CtlInfo 43. Correr el programa. 44. En el programa, seleccionar el men ProcesarCalculos, y se mostrar la ventana de dilogo siguiente(es un programa que realiza la Suma de dos nmeros A y B):
TextBox del frmCalculo. !Recuerde la parte 02!
- 60 -
45. Guardar todo. La prctica de laboratorio ha finalizado. NOTA: Para aprender a crear programas visuales con una mayor fluidez, podis abrir los ejemplos que se incluyen con el paquete Visual Prolog 5.2. Ejemplos de programas visuales: En el directorio de instalacin C:\VIP\VPI\EXAMPLES Ejemplos de programas DOS: En el directorio de instalacin C:\VIP\EXAMPLES
TAREAS Implementar un programa que realice los clculos matemticos. (Figura Tarea 1) Implementar un formulario de similar aspecto al que se muestra (Fig. Tarea 2) Implementar un formulario de similar aspecto al que se muestra (Fig. Tarea 3)
Figura Tarea 1 I
3.
Figura Tarea 1
Figura Tarea 2
Figura Tarea 3
- 61 -
GUA DE PRACTICA 05 KAPPA PC 2.0: UN SISTEMA EXPERTO BASADO EN REGLAS
OBJETIVO GENERAL Reconocimiento del entorno del lenguaje de programacin para sistemas expertos basados en reglas Kappa PC versin 2.0
OBJETIVOS ESPECFICOS El estudiante: Estar en condiciones de programar reglas en un sistema experto basado en reglas usando el Kappa PC Podr realizar el encadenamiento hacia delante utilizando una interfaz visual proporcionada por el Kappa PC.
METODOLOGIA 1. Se realizar la descripcin (definicin) de una clase (Class) denominada TGente con los siguientes atributos (Slots): Nacimiento: en el que se almacenar el pas en el cual naci la persona Nacionalidad: en el que se registrar la nacionalidad de la persona 2. Se realizar el almacenamiento de reglas relativas a la nacionalidad de una persona (objeto perteneciente a la clase TGente) 3. Se definir una instancia de la clase TGente a la que denominaremos Juan. 4. Se definir una funcin denominada Procesar en la que escribiremos las rutinas relativas al procesamiento de un recorrido hacia delante (para la instancia Juan) 5. Se definir una funcin denominada Cerrar, en la que insertaremos una instruccin de finalizacin de un programa. 6. Se crear una interfaz de usuario (objeto Session) en la que insertaremos: Un objeto tipo RadioButtonGroup (Lista de opciones) el cual enlazaremos al objeto Juan y a su atributo Nacimiento. Un objeto tipo Button (Botn) el que enlazaremos con la funcin Procesar (creada previamente). Un objeto tipo Button (Botn) el que enlazaremos con la funcin Cerrar (creada previamente). 7. Ejecutar la interfaz de usuario. CONOCIMIENTO PREVIO a) Descripcin de las reglas Las reglas a implementarse son las siguientes: Regla Regla1 Si Gente.Nacimiento = Peru Entonces Gente.Nacionalidad = Peruano Descripcin
- 62 -
Regla2
Si Gente.Nacimiento = Bolivia Entonces Gente.Nacionalidad = Boliviano
Regla3
Si Gente.Nacimiento = Chile Entonces Gente.Nacionalidad = Chileno
Regla4
Si Gente.Nacimiento = Ecuador Entonces Gente.Nacionalidad = Ecuatoriano
Regla Regla5 Si
Descripcin
Gente.Nacimiento = Colombia Entonces Gente.Nacionalidad = Colocho Regla6 Si Gente.Nacimiento = Venezuela Entonces Gente.Nacionalidad = Venezolano Regla7 Si Gente.Nacimiento = Argentina Entonces Gente.Nacionalidad = Argentino Regla8 Si Gente.Nacimiento = Brasil Entonces Gente.Nacionalidad = Brasileo b) El objeto (instancia de una clase TGente) a definirse se llamar Juan. c) El almacenamiento de proposiciones se ajusta al formato Objeto Atributo - Valor2
Me parece que esto ya debiera haberlo deducido el lector.
- 63 -
DESARROLLO DE LA PRCTICA DE LABORATORIO PRIMERA PARTE: CREACION DEL ARCHIVO PRACT01.KAL 1. Correr el programa Kappa-PC 2.0. 2. Ir al men FILE seleccionar la opcin NEW 3. Ir al men FILE seleccionar la opcin SAVE AS y guardar el archivo con el nombre pract01.kal
Ventana Principal
Ventana de herramientas de edicin (Edit Tools)
SEGUNDA PARTE : DEFINICION DE LA CLASE TGENTE (Class) a) Definicin de la clase 4. Visualizar la ventana de herramientas de edicin (Presionar el cono Edit Tools) 5. Crear una nueva clase y configurarla segn lo indicado(Presion el cono Class): Class Name: TGente Parent Class: Root Se le mostrar a continuacin la ventana de edicin de clases, que ser similar a:
- 64 -
b) Definicin de los atributos de la clase 6. En el editor de clases, ir al men Slots y usando el submen NEW (por dos veces) definir los siguientes atributos para la clase TGente: Nacimiento Nacionalidad
7. Guardar todo TERCERA PARTE: DEFINICION DE LA REGLA Regla1 8. Presione el cono RULES 9. Defina el nombre de la primera regla: Regla1
Se le mostrar la ventana de edicin de reglas
- 65 -
10. Escriba el detalle de la regla Regla1 segn como se indica a continuacin: SECCION Patterns Priority If Then CONTENIDO Gente|TGente 0 Gente:Nacimiento #= Peru; Gente:Nacionalidad=Peruano;
11. Guardar todo (Ir al men UPDATE y seleccionar la opcin SAVE) y cerrar esta ventana. Usted ha definido la regla Regla1. CUARTA PARTE: DEFINICION DE LAS OTRAS REGLAS 12. Repetir los pasos realizados en la tercera parte de esta prctica (pasos 8 al 11) pero en esta ocasin con las siguientes especificaciones: a) Regla: Regla2 SECCION Patterns Priority If Then b) Regla: Regla3 SECCION Patterns Priority If Then c) Regla: Regla4 CONTENIDO Gente|TGente 0 Gente:Nacimiento #= Chile; Gente:Nacionalidad=Chileno; CONTENIDO Gente|TGente 0 Gente:Nacimiento #= Bolivia; Gente:Nacionalidad=Boliviano;
- 66 -
SECCION Patterns Priority If Then d) Regla: Regla5 SECCION Patterns Priority If Then e) Regla: Regla6 SECCION Patterns Priority If Then f) Regla: Regla7 SECCION Patterns Priority If Then g) Regla: Regla8
CONTENIDO Gente|TGente 0 Gente:Nacimiento #= Ecuador; Gente:Nacionalidad=Ecuatoriano;
CONTENIDO Gente|TGente 0 Gente:Nacimiento #= Colombia; Gente:Nacionalidad=Colombiano;
CONTENIDO Gente|TGente 0 Gente:Nacimiento #= Venezuela; Gente:Nacionalidad=Venezolano;
CONTENIDO Gente|TGente 0 Gente:Nacimiento #= Argentina; Gente:Nacionalidad=Argentino;
SECCION Patterns Priority If Then
CONTENIDO Gente|TGente 0 Gente:Nacimiento #= Brasil; Gente:Nacionalidad=Brasileo;
QUINTA PARTE: DEFINICION DE LA INSTANCIA JUAN (perteneciente a la clase TGente) 13. Presione el cono INSTANCE y defina la instancia JUAN perteneciente a la clase TGente La configuracin en el cuadro de dilogo es el siguiente:
- 67 -
Instance Name: Juan
Parent Class: TGente 14. Cerrar la ventana de edicin de instancias (Editor Instance) SEXTA PARTE: ESCRITURA DE LA FUNCION Procesar 15. Presione el cono FUNCTION, y defina el nombre de la funcin Procesar.
Se le presentar a continuacin la ventana editor de funciones: 16. En la ventana editor de funciones (Function editor), escribir en la seccin Body lo siguiente: { Assert( Juan:Nacimiento ); ForwardChain( NULL, Regla1, Regla2, Regla3, Regla4,Regla5,Regla6,Regla7,Regla8 ); PostMessage( "Juan es de nacionalidad: ", Juan:Nacionalidad ); };
17. Grabar todo. Cerrar la ventana de edicin de funciones.
- 68 -
SETIMA PARTE: ESCRITURA DE LA FUNCION Finalizar 18. Repetir los pasos de la parte SEXTA, pero esta vez para la funcin Finalizar. Funcin: Finalizar Cdigo: { Exit( }; );
19. Grabar todo. Cerrar la ventana de edicin de funciones OCTAVA PARTE: ESCRITURA DE LA INTERFAZ DE USUARIO (Session) 20. Presione el cono SESSION. Se le mostrar la ventana Session (Formulario de interfaz)
21. En el submen OPTIONS seleccione la opcin Layout Mode. Se le mostrar la respectiva ventana de controles insertables.
Ventana de graficacin RadioButtonGroup (Lista de opciones) Button (Botn)
22. Insertar en la ventana de graficacin dos controles Button y un control RadioButtonGroup.
- 69 -
RadioButtonG
23. Configurar las propiedades de los controles de la siguiente forma
COMPONENTE Button1
PROPIEDAD Title Action Nacionalidad Procesar Cerrar Finalizar
VALOR
Button2
Title Action
RadioButton Group1
Title Owner OwnerSlot Allowable Values3
Juan nacio en el pas: Juan Nacimiento Peru Bolivia Chile Ecuador Colombia Venezuela Argentina Brasil
24. Guarde todo. Cierre esta ventana.
NOVENA PARTE: EJECUCION DE LA INTERFAZ DE USUARIO. 25. Presione el cono SESSION. Se desplegar la ventana Sessin. 26. Ir al men OPTIONS y cerciorarse de que la opcin Layout Mode est desactivada.
Los tems se escriben separados por un nico espacio en blanco.
- 70 -
27. Puede ahora trabajar con este formulario como si estuviera en tiempo de ejecucin (realmente est ejecutndose el programa). Seleccione el lugar de nacimiento de Juan y podr ver que el software le dice la correspondiente nacionalidad de Juan.
28. Guarde todo. La prctica ha terminado. NOVENA PARTE: EJECUCION DE LA INTERFAZ DE USUARIO. 29. Implemente su propio programa basado en reglas usando el Kappa-PC DESCRIPCION GRAFICA DE LA APLICACIN GENERADA
SESSI Objeto: Juan Atributo: Nacimiento
Enlazado a
Es de la
TGente Nacimiento
Es
de
la
Root
Enlazado a
Es una Procesar Es una DEFINICION Funcion
Enlazado INTERFAZ DE USUARIO
Finaliza
OBJETO/FUNCION
- 71 -
GUA DE PRACTICA 06: KAPPA PC 2.0: PERSONALIZACION DE UN SISTEMA EXPERTO
OBJETIVO GENERAL Reconocimiento del entorno del lenguaje de programacin para sistemas expertos basados en reglas Kappa PC versin 2.0
OBJETIVOS ESPECFICOS El estudiante: Estar en condiciones de programar reglas en un sistema experto basado en reglas usando el Kappa PC Podr realizar el encadenamiento hacia delante utilizando una interfaz visual proporcionada por el Kappa PC.
DESARROLLO DE LA PRCTICA DE LABORATORIO 1. Abrir el archivo pract01.kal (archivo generado en la primera sesin de la prctica). 2. Guardar todo el contenido en un archivo con el nombre pract02.kal TAREA 1: REDEFINIR LA ESTRUCTURA DE LA CLASE TGENTE Modificar la clase TGente, de modo que la nueva estructura de la clase sea la siguiente:
TGente Atributo Edad Caracter Nacimiento Nacionalidad
TAREA 2: AGREGAR REGLAS Agregue las siguientes reglas al nuevo sistema experto.
Regla Regla01 Si Gente.Edad = 15 Entonces
Descripcin
Gente.Atributo = Sabelotodo
- 72 -
Regla02
Si Gente.Edad = 18 Entonces Gente.Atributo = Nuevo_ciudadano
Regla101
Si Gente.Nacionalidad = Peruano y Gente.Atributo =Sabelotodo Entonces Gente.Caracter = Peruano_Sabelotodo
Regla102
Si Gente.Nacionalidad = Peruano y Gente.Atributo = Nuevo_Ciudadano Entonces Gente.Caracter = Peruano_Nuevo_Ciudadano
Regla201
Si Gente.Nacionalidad = Boliviano y Gente.Atributo = Sabelotodo Entonces Gente.Caracter = Boliviano_Sabelotodo
Regla202
Si Gente.Nacionalidad = Boiviano y Gente.Atributo =Nuevo_Ciudadano Entonces Gente.Caracter = Boliviano_Nuevo_Ciudadano
- 73 -
TAREA 3: AGREGAR FUNCIONES Agregue las siguientes funciones al sistema experto Funcin: Edades
{ Assert( Juan:Edad ); ForwardChain( NULL, Regla01, Regla02 ); PostMessage( "Juan es un: ", Juan:Atributo ); };
Funcin: Combinar { Assert( Juan:Nacimiento ); Assert( Juan:Edad ); ForwardChain( NULL, Regla1, Regla2, Regla3, Regla4, Regla5, Regla6, Regla7, Regla8, Regla01, Regla02, Regla101, Regla102, Regla201, Regla202 ); PostMessage( "Juan es : ", Juan:Caracter ); };
- 74 -
TAREA 4: MODIFICAR LA INTERFAZ DE USUARIO Modificar la interfaz de usuario de forma que la nueva interfaz de usuario tenga el siguiente aspecto, con las relaciones que all se indican:
Enlazado a Enlazado a Enlazado a Enlazado a
Procesar Edades Combinar Finalizar
Enlazado a Objeto: Juan Atributo: Edad
Enlazado a Objeto: Juan Atributo: Nacimiento
- 75 -
DETALLE DE LA ACCIN CONFIGURADA
Regla 1
Regla101
Regla2
Regla102
Regla01
Regla201 Regla202
Regla02
Descripcin de las reglas enlazadas
Regla 1 Regla101 Regla102 Regla3 Regla201 Regla202 Regla301 Regla302 Regla6 Regla401 Regla402
Regla01
Regla2
Regla02
Regla4
Regla5
Regla7 Regla8
..... ....
Regla801 Regla802
Descripcin de todas las reglas enlazables
- 76 -
PASOS A REALIZAR PARA PROGRAMAR USANDO EL KAPPA - PC Hasta aqu, usted podr deducir que para programar en el Kappa se deben seguir los siguientes pasos:
En la ventana EditTools estn los conos que nos permitirn definir una clase, definir una instancia, definir reglas y definir funciones
1. Definir la estructura de la clase En la ventana EditTools, presionar el cono Class. En esta ventana usted puede crear la estructura de la nueva clase (TGente por ejemplo), definiendo los atributos (slots) que poseer, as como opcionalmente definir los valores posibles de cada atributo
En esta ventana usted puede definir los valores probables que pueden tener los atributos respectivos
- 77 -
Ventana de definicin de los atributos (slots) de una clase4
2. Definir las instancias a utilizar En la ventana EditTools, presionar el cono Instance De forma predeterminada ya est definida la instancia SESSION (que es de la clase KSession), que es el formulario predeterminado con cada programa. Si usted deseare contar con ms de un solo formulario, es esta la opcin que debe utilizar, definiendo la nueva instancia y referir que pertenecer a la clase Ksession. No es solamente instancias de formularios los que pueden definirse en esta ventana, sino tambin instancias de las clases existentes (Juan por ejemplo, que es de la clase TGente)
Al hacer un doble click (con el mouse) sobre el respectivo atributo, se visualizar la ventana para definir los valores predeterminados de tal atributo (el uso de esta opcin es opcional).
- 78 -
3. Definir las reglas En la ventana EditTools, presionar el cono Rules Haciendo uso de esta opcin, usted podr definir las reglas de su sistema experto
4. Definir las funciones En la ventana EditTools, presionar el cono Functions
5. Implementar la interfaz (formularios) En la ventana principal del Kappa-PC, presionar el cono Session
- 79 -
Esta opcin le permitir visualizar los formularios que desee modificar. Por supuesto que para modificar un formulario tiene que cambiarle su estatus al modo edicin5.
Para cambiar el estado de un formulario, basta modificar la opcin Layout mode del respectivo formulario.
RESUMEN DE LOS PASOS A REALIZAR PARA PROGRAMAR EN KAPPAPC En resumen, podemos decir que los pasos a realizar para programar usando el Kappa-PC son los siguientes: PASO 1. 2. 3. 4. 5. 6. Definir la estructura de la clase Definir las instancias a utilizar Definir las reglas Definir las funciones Implementar la interfaz (formularios) Ejecutar el formulario TGente Juan Regla1, Regla2 Procesar, Terminar SESSION1, SESSION2(crear/modificar) Layout Mode (en el formulario inicial) EJEMPLO
TAREA Implementar un programa con la siguiente interfaz
Un formulario, en Kappa-PC tiene dos estados: Diseo (Layout) y ejecucin. Un formulario solamente puede ser modificado cuando est en el estado de diseo.
- 80 -
Donde esta se comporte de la siguiente forma: Si el usuario selecciono el color rojo, al presionar el botn procesar debe aparecer un mensaje como el que se muestra a continuacin: El semforo est rojo, detenga el auto
Si el usuario selecciono el color Ambar, al presionar el botn procesar debe aparecer un mensaje como el que se muestra a continuacin: El semforo est en ambar, peligro
Si el usuario selecciono el color verde, al presionar el botn procesar debe aparecer un mensaje como el que se muestra a continuacin: El semforo est verde, puede continuar
- 81 -

Guias de Practica Sistemas Expertos

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Guias de Practica Sistemas Expertos

Uploaded by

Copyright:

Available Formats

UNIVERSIDAD NACIONAL JORGE BASADRE GROHMANN

Escuela Acadmico Profesional de Ingeniera en Informtica y Sistemas

ELABORADASPOR: ING.EDGARAURELIOTAYAACOSTA ING.EDWINOCTAVIORAMOSVELSQUEZ TACNAPER

UNIVERSIDAD NACIONAL JORGE BASADRE GROHMANN

Escuela Acadmico Profesional de Ingeniera en Informtica y Sistemas

GUASDEPRCTICADELABORATORIO DESISTEMASEXPERTOS INTELIGENCIAARTIFICIAL

Gua de prctica 02: Grafos y procedimientos en VisualCLisp

Gua de prctica 03: Introduccin al Visual Prolog

Gua de prctica 05: KAPPA PC 2.0: Un sistema experto basado en reglas

Gua de prctica 06: KAPPA PC 2.0: Personalizacin de un sistema experto

DESARROLLO DE LA PRCTICA Ejecucin de Visual Lisp en modo Debug (depuracin 1. )

Ventana de Edicin de programas y funciones

Run (Modo debug)

Aqu escriba las Instrucciones LISP (en modo depuracin)

El aspecto de la interfaz de programacin ser similar al siguiente:

Cuadro edicin rutinas

$ (pedro juan) $ (+ 12 40 -20) $( ( ) ( ) )

$ (pedro (matematica 12 13) (geografia 15) ) Qu sucede al ejecutarse cada instruccin? 6.

$ (SETQ alpha 23 ) $ (SETQ betha 10 ) $ (+

$ ( - alpha betha $ ( * alpha betha $ (SETQ zetha

$ (pedro (matematica 12 13) (geografia 15) )

$ (SETQ ala $ (EVAL ala

$ (SETQ A 100 $ (SETQ B 300 $ (SETQ OP $ (EVAL OP

$ (SETQ B 20 $ (EVAL OP $ (SETQ A 5 $ (EVAL OP $ ala $ A $ B $ OP )

; Extraccin de 1er elemento de una lista $ (CAR $ (CAR (8 (9 5 3 1 7 7 2) 20 )

;Inversin de listas $ (REVERSE $ (SETQ L1 $ (SETQ L2 (1 2 ( 1 2 ( 6 7 3 3 8 4 4 11 5) 5) ) )

$ (PRINC L1 ) $ (PRINC L2 ) $ (SETQ L3

;Valor actual de las variables $ L1 $ L2 $ L3

; Ejecucin de las funciones $ (ULTIMO $ (SUMAR $ (PAR 4 ( A 7 B C ) )

(DEFUN SUMA( A B ) (+ A B) ) ;-----------------------------------------------------------(DEFUN RESTA( A B ) (- A B) )

Esta es una lnea de comentario

;---------------------------------------------------------(DEFUN MULTIPLICAR ( L ) (SETQ TEMP L) (SETQ RESULTADO 1) (SETQ x 0)

servira esta funcin Primer?

NOTA: Investigue sobre el uso de las funciones:

; Llamado a la funcin RESTA ; Resultados devueltos por RESTA

; Llamado a la funcin MULTIPLICA ; Resultados devueltos por MULTIPLICA

; Llamado a la funcin DIVIDE ; Resultados devueltos por DIVIDE

; Llamado a la funcin RESTAR ; Resultados devueltos por RESTAR

$ (MULTIPLICAR '(2 2 3 3) ) ; Llamado a la funcin MULTIPLICAR 36 ; Resultados devueltos por MULTIPLICAR

$ (DIVIDIR '(81 3)) 27

; Llamado a la funcin DIVIDIR ; Resultados devueltos por DIVIDIR

; Llamado a la funcin DIVIDIR ; Resultados devueltos por DIVIDIR

$ (SUMAR '(3 5)) 8

; Llamado a la funcin SUMAR ; Resultados devueltos por SUMAR

$ (SUMAR '(3 5 7)) 15

; Llamado a la funcin SUMAR ; Resultados devueltos por SUMAR

$ (SUME '(2 4 5 6)) 17

; Llamado a la funcin SUME ; Resultados devueltos por SUME

$ (OPERAR + '(3 4 2)) 9

; Llamado a la funcin OPERAR ; Resultados devueltos por OPERAR

$ (OPERAR * '(3 4 2)) 24

; Llamado a la funcin OPERAR ; Resultados devueltos por OPERAR

$ (OPERAR / '(80 4 2)) 9

; Llamado a la funcin OPERAR ; Resultados devueltos por OPERAR

; Llamado a la funcin OPERAR ; Resultados devueltos por OPERAR

15. Guardar todo.

GUA DE PRCTICA DE LABORATORIO 02 GRAFOS Y PROCEDIMIENTOS EN VisualCLisp

Esta puede crearse a travs de la siguiente instruccin:

Un ejemplo de esto podemos verlo en el siguiente programa:

Al ejecutar la instruccin $ (ProcesarLista ), podremos observar un listado de lo siguiente:

Empleados Pedrito Lucho Anita

Docentes Mara Prez Jos Luis Belinda Salas

Alumnos Kike Vega Ubaldo Yuli Benedicto

Visitas Alvaro Juan Pereda Hector Lucy