GUÍAS DE PRÁCTICA DE LABORATORIO
Guía de Práctica 01: Introducción Al Lenguaje Lips Usando Visual Clisp Versión 3.1415
Guía de Práctica 02: Grafos y procedimientos en VisualCLisp
Guía de Práctica 03: Introducción al Visual Prolog
Guía de Práctica 04: Introducción al Visual Prolog: Programación de aplicaciones con entornos Visuales
Guía de Práctica 05: KAPPA – PC 2.0: Un sistema experto basado en reglas
Guía de Práctica 06: KAPPA – PC 2.0: Personalización de un sistema experto
ELABORADAS POR:
ING. EDGAR AURELIO TAYA ACOSTA
ING. EDWIN OCTAVIO RAMOS VELÁSQUEZ
TACNA – PERÚ
UNIVERSIDAD NACIONAL JORGE BASADRE GROHMANN FACULTAD DE INGENIERÍA
Escuela Académico Profesional de Ingeniería en Informática y Sistemas
Guías de Laboratorio de Sistemas Expertos Inteligencia Artificial
Ingeniería en Informática y Sistemas Ing. Edgar A. Taya Acosta/ Ing. Edwin O. Ramos Velásquez
- 1 -
GUÍAS DE PRÁCTICA DE LABORATORIO
DE SISTEMAS EXPERTOS
‐ INTELIGENCIA ARTIFICIAL ‐
ELABORADO POR:
ING. EDGAR AURELIO TAYA ACOSTA
ING. EDWIN OCTAVIO RAMOS VELÁSQUEZ
TACNA – PERÚ
UNIVERSIDAD NACIONAL JORGE BASADRE GROHMANN
FACULTAD DE INGENIERÍA
Escuela Académico Profesional de Ingeniería en Informática y Sistemas
Guías de Laboratorio de Sistemas Expertos Inteligencia Artificial
Ingeniería en Informática y Sistemas Ing. Edgar A. Taya Acosta/ Ing. Edwin O. Ramos Velásquez
- 2 -
CONTENIDO
PÁGINA
Guía de práctica 01: 03
Introducción Al Lenguaje Lips Usando Visual Clisp Versión 3.1415
Guía de práctica 02: 15
Grafos y procedimientos en VisualCLisp
Guía de práctica 03: 30, 39
Introducción al Visual Prolog
Guía de práctica 04: 50
Introducción al Visual Prolog: Programación de aplicaciones
con entornos Visuales
Guía de práctica 05: 62
KAPPA – PC 2.0: Un sistema experto basado en reglas
Guía de práctica 06: 72
KAPPA – PC 2.0: Personalización de un sistema experto
Guías de Laboratorio de Sistemas Expertos Inteligencia Artificial
Ingeniería en Informática y Sistemas Ing. Edgar A. Taya Acosta/ Ing. Edwin O. Ramos Velásquez
- 3 -
GUÍA DE PRACTICA DE LABORATORIO 01
INTRODUCCION AL LENGUAJE LIPS
USANDO VISUAL CLisp Versión 3.1415
OBJETIVOS
El alumno podrá utilizar el entorno de programación VisualCLisp Versión 3.1415 (una versión Freeware de Lisp) en la elaboración y ejecución de programas básicos en Lisp
El alumno podrá familiarizarse con instrucciones básicas de referenciación y asignación en el lenguaje Lisp.
METODOLOGIA
Se describirán algunos conceptos básicos de Lisp. Se mostrarán ejemplos de programa en Lisp haciendo analogías con lenguajes imperativos tales como C++. A continuación se solicitará al alumno la elaboración y ejecución de programas propuestos en clase.
Se proporcionará al alumno, junto con esta práctica, de un manual básico de Lisp.
DESARROLLO DE LA PRÁCTICA
Ejecución de Visual Lisp en modo Debug (depuración )
1. Usando el Explorador de Windows, crear un directorio denominado C:\MiLisp. Allí se guardaran todos los archivos generados en esta práctica de laboratorio.
2. Ejecutar VisualLisp (menúInicio\Programas\VisualCLisp\VisualCLisp).
3. Seleccionar la página Debug. 4. Ingresar al modo de depuración (Presionar el botón Debug).
Si se le presenta un cuadro de diálogo similar al siguiente, presionar el botón “SI”
Ventana de Edición de programas y funciones
Aquí escriba las Instrucciones LISP (en modo depuración)
Run (Modo debug)
Compilar. Este botón permite verificar la correcta edición de programas en la “ventana de edición de programas”
Guías de Laboratorio de Sistemas Expertos Inteligencia Artificial
Ingeniería en Informática y Sistemas Ing. Edgar A. Taya Acosta/ Ing. Edwin O. Ramos Velásquez
- 4 -
El aspecto de la interfaz de programación será similar al siguiente:
5. Escribir secuencialmente las siguientes instrucciones ¿Qué sucede cuando se ejecuta cada una de ellas?: (Presentar informe de resultados: Informe Parte 01.doc)
Ejecución de instrucciones atómicas
$ ()
$ (pedro juan)
$ (+ 12 40 -20)
$ ( ( ) ( ) )
$ ( (america) )
$ (pedro (matematica 12 13) (geografia 15) )
¿Qué sucede al ejecutarse cada instrucción?
6. A continuación ejecute las siguientes instrucciones (Presentar informe de resultados: Informe Parte 02.doc)
Ejecución de funciones con valores atómicos
$ (alpha)
Cuadro de edición de rutinas
Lisp “trata” de procesar toda línea de instrucción, por ello mensajes tales como: - EVAL: the function ALG is undefined
Esta ventana hace referencia al hecho de que el contenido en la “ventana de edición de programas y funciones” debería guardarse previamente en un archivo.
Guías de Laboratorio de Sistemas Expertos Inteligencia Artificial
Ingeniería en Informática y Sistemas Ing. Edgar A. Taya Acosta/ Ing. Edwin O. Ramos Velásquez
- 5 -
$ (betha)
$ (zetha)
$ (SETQ alpha 23 )
$ (SETQ betha 10 )
$ (+ alpha betha )
$ ( - alpha betha )
$ ( * alpha betha )
$ (SETQ zetha (+ alpha betha) )
$ (pedro (matematica 12 13) (geografia 15) )
$ (SETQ ala '(+ 9 5) )
$ (EVAL ala )
$ (SETQ A 100 )
$ (SETQ B 300 )
$ (SETQ OP ‘ (+ A B) )
$ (EVAL OP )
$ (SETQ B 20 )
$ (EVAL OP )
$ (SETQ A 5 )
$ (EVAL OP )
$ ala
$ A
$ B
$ OP
¿Qué sucede al ejecutarse cada instrucción?
7. A continuación ejecute las siguientes instrucciones (Informe Parte 03.doc)
Notas sobre Equivalencias
(SETQ X 56 )
Equivale a la instrucción de asignación
X = 56
(SETQ alpha 23 )
Equivale a la instrucción de asignación
Notas sobre Equivalencias
(SETQ ala ‘( + 9 5 ) )
Equivale a la instrucción de asignación
de listas, donde ala es una lista (en este
caso, una lista que luego tiene 3 valores
atómicos) con los elementos
+ 9 5
Guías de Laboratorio de Sistemas Expertos Inteligencia Artificial
Ingeniería en Informática y Sistemas Ing. Edgar A. Taya Acosta/ Ing. Edwin O. Ramos Velásquez
- 6 -
Ejecución de operaciones con listas
; Eliminación del 1er elemento de una lista
$ (CDR ‘(1 4 7 8 9) )
$ (CDR ‘(8 5 1 7 2) )
; Extracción de 1er elemento de una lista
$ (CAR ‘(8 5 1 7 2) )
$ (CAR ‘(9 3 7 20 36) )
;Inversión de listas
$ (REVERSE ‘ (1 2 3 4 5) )
$ (SETQ L1 ‘( 1 2 3 4 5) )
$ (SETQ L2 ‘( 6 7 8 11 13) )
$ (PRINC L1 )
$ (PRINC L2 )
$ (SETQ L3 (REVERSE L1) )
;Valor actual de las variables
$ L1
$ L2
$ L3
¿Qué sucede al ejecutarse cada instrucción?
8. Ejecutar las siguientes instrucciones (Informe Parte 04.doc)
; DEFINICION DE LAS FUNCIONES
$ ( DEFUN ULTIMO ( X ) ( CAR (LAST X ) ) )
$ ( DEFUN SUMAR ( A B ) ( + A B ) )
$ ( DEFUN PAR ( X Y ) ( LIST X Y ) )
; Ejecución de las funciones
$ (ULTIMO ‘( A B C ) )
$ (SUMAR ‘7 ‘8 )
$ (PAR ‘4 ‘5 )
Guías de Laboratorio de Sistemas Expertos Inteligencia Artificial
Ingeniería en Informática y Sistemas Ing. Edgar A. Taya Acosta/ Ing. Edwin O. Ramos Velásquez
- 7 -
CREACION DE FUNCIONES
9. En la pantalla de edición escribir las siguientes rutinas
; Código preparado por Ing. Edwin Ramos Velásquez
; Las líneas de código de este archivo son reconocidos
; Por Visual CLisp Versión 3.1415
;------------------------------------------------------------
; Parte 01: Operaciones donde los parámetros 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 parámetros 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)
)
Guías de Laboratorio de Sistemas Expertos Inteligencia Artificial
Ingeniería en Informática y Sistemas Ing. Edgar A. Taya Acosta/ Ing. Edwin O. Ramos Velásquez
- 8 -
;-----------------------------------------------------------
(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) )
)
)
;----------------------------------------------------------
(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 (SETQ x RESULTADO) )
)
)
;-----------------------------------------------------------
Esta es una línea de comentario
Guías de Laboratorio de Sistemas Expertos Inteligencia Artificial
Ingeniería en Informática y Sistemas Ing. Edgar A. Taya Acosta/ Ing. Edwin O. Ramos Velásquez
- 9 -
(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))
)
; (IF test THEN else) == (COND(test then) (T else))
(COND ( (EQUAL L NIL) (SETQ x 0) )
( T (SETQ x RESULTADO) )
)
)
;-----------------------------------------------------------
(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 )
(SETQ TEMP L)
(SETQ RESULTADO 0)
(SETQ x 0)
(SETQ x (CAR TEMP))
(SETQ RESULTADO (+ RESULTADO x))
)
;-----------------------------------------------------------
¿Para qué cree que
serviría esta función
Primer?
Guías de Laboratorio de Sistemas Expertos Inteligencia Artificial
Ingeniería en Informática y Sistemas Ing. Edgar A. Taya Acosta/ Ing. Edwin O. Ramos Velásquez
- 10 -
(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)) )
)
)
Guías de Laboratorio de Sistemas Expertos Inteligencia Artificial
Ingeniería en Informática y Sistemas Ing. Edgar A. Taya Acosta/ Ing. Edwin O. Ramos Velásquez
- 11 -
(SETQ TEMP (CDR TEMP))
)
; (if test then else) == (cond (test then) (t else))
(COND ( (EQUAL L NIL) (SETQ x 0) )
( T (SETQ x RESULTADO) )
)
)
10. Compilar el programa para verificar que esté correctamente escrito
Guardar el archivo
11. A continuación guardar el archivo como: c:\MiLisp\Operaciones.lsp
Cargar y ejecutar funciones contenidas en un archivo
12. A continuación Activar el modo de depuración ( ), es decir elegir el menú compilerDebug
13. Escribir en la ventana de depuración la instrucción LOAD como se muestra:
(LOAD "C:/MiLisp/Operaciones.lsp")
NOTA: Investigue sobre el uso de las funciones: $ RUN
14. A continuación, desde la misma ventana de ejecución, verificar el adecuado funcionamiento de las funciones (llámelas con rutinas)
Por ejemplo:
$ (SUMA 7 5) ; Llamado a la función SUMA
12 ; Resultados devueltos por SUMA
$ (RESTA 7 5) ; Llamado a la función RESTA
2 ; Resultados devueltos por RESTA
$ (MULTIPLICA 7 5) ; Llamado a la función MULTIPLICA
35 ; Resultados devueltos por MULTIPLICA
$ (DIVIDE 80 2) ; Llamado a la función DIVIDE
40 ; Resultados devueltos por DIVIDE
$ (RESTAR '(80 7 1) ) ; Llamado a la función RESTAR
72 ; Resultados devueltos por RESTAR
Guías de Laboratorio de Sistemas Expertos Inteligencia Artificial
Ingeniería en Informática y Sistemas Ing. Edgar A. Taya Acosta/ Ing. Edwin O. Ramos Velásquez
- 12 -
$ (MULTIPLICAR '(2 2 3 3) ) ; Llamado a la función MULTIPLICAR
36 ; Resultados devueltos por MULTIPLICAR
$ (DIVIDIR '(81 3)) ; Llamado a la función DIVIDIR
27 ; Resultados devueltos por DIVIDIR
$ (DIVIDIR '(20)) ; Llamado a la función DIVIDIR
20 ; Resultados devueltos por DIVIDIR
$ (SUMAR '(3 5)) ; Llamado a la función SUMAR
8 ; Resultados devueltos por SUMAR
$ (SUMAR '(3 5 7)) ; Llamado a la función SUMAR
15 ; Resultados devueltos por SUMAR
$ (SUME '(2 4 5 6)) ; Llamado a la función SUME
17 ; Resultados devueltos por SUME
$ (OPERAR + '(3 4 2)) ; Llamado a la función OPERAR
9 ; Resultados devueltos por OPERAR
$ (OPERAR * '(3 4 2)) ; Llamado a la función OPERAR
24 ; Resultados devueltos por OPERAR
$ (OPERAR / '(80 4 2)) ; Llamado a la función OPERAR
9 ; Resultados devueltos por OPERAR
$ (OPERAR + '( ) ) ; Llamado a la función OPERAR
0 ; Resultados devueltos por OPERAR
15. Guardar todo.
TAREAS (Presente el informe respectivo: Informe Parte 05.doc)
1. Escribir una función que reciba una lista de números y retorne una lista de números
sumándole su posición a cada número de la lista.
Guías de Laboratorio de Sistemas Expertos Inteligencia Artificial
Ingeniería en Informática y Sistemas Ing. Edgar A. Taya Acosta/ Ing. Edwin O. Ramos Velásquez
- 13 -
> (suma-posicion ’(1 3 7 -2))
> (2 5 10 2)
2. Escribir la función calcula-diferencia que recibe una lista de números y devuelve otra lista
con la diferencia entre un número 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 función separar-parimpar que recibe una lista de números 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 función cambiar-notacion que transforme una expresión con operaciones
matemáticas escritas en notación funcional de LISP a su notación infija correspondiente.
> (cambiar-notacion ’(+ (* 7 4) (* 5 3) (- (/ 30 (* 2 3)) 1)))
> ((7 * 4) + (5 * 3) + ((30 / (2 * 3)) - 1))
5. Escribir una función 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 función que reciba como parámetros 2 puntos y calcule la distancia euclídea
entre ellos.
> (distancia-puntos (make-punto :valx 8 :valy 6) (make-punto))
> 10
7. Escribir una función que convierta una lista de números en un vector de números con los
mismos elementos.
>(array-to-vector '(1 2 3 4 6 7))
> #(1 2 3 4 6 7)
Guías de Laboratorio de Sistemas Expertos Inteligencia Artificial
Ingeniería en Informática y Sistemas Ing. Edgar A. Taya Acosta/ Ing. Edwin O. Ramos Velásquez
- 14 -
8. Escribir una función que determine si una lista de números 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 función 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 más).
> (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 función que a partir de una lista copie en un fichero “inversa.txt” la lista
y la versión invertida de la misma.
> (guardar-lista-invertida '(w x y z ))
> nil
11. ¿En qué se diferencian las funciones OPERARMODO1 y OPERAR?
Guías de Laboratorio de Sistemas Expertos Inteligencia Artificial
Ingeniería en Informática y Sistemas Ing. Edgar A. Taya Acosta/ Ing. Edwin O. Ramos Velásquez
- 15 -
GUÍA DE PRÁCTICA DE LABORATORIO 02
GRAFOS Y PROCEDIMIENTOS EN VisualCLisp
OBJETIVOS
El alumno podrá utilizar el entorno de programación VisualCLisp Versión 3.1415 (una versión Freeware de Lisp) en la elaboración y ejecución de programas avanzados en Lisp
El alumno podrá familiarizarse con instrucciones de referenciación y asignación en el lenguaje Lisp.
METODOLOGIA
Se describirán algunos conceptos básicos de Lisp. Se mostrarán ejemplos de programa en Lisp haciendo analogías con lenguajes imperativos tales como C++. A continuación se solicitará al alumno la elaboración y ejecución de programas propuestos en clase.
Se proporcionará al alumno, junto con esta práctica, de un manual básico de Lisp.
Listas Simples
Sea la lista de cadenas tal como la que se muestra a continuación
1 2 3 4 5 6 7 8
Juan Pedro Alicia Natale Pedrito María Tatiana Magali
Esta puede crearse a través de la siguiente instrucción:
(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))
)
)
)
)
Guías de Laboratorio de Sistemas Expertos Inteligencia Artificial
Ingeniería en Informática y Sistemas Ing. Edgar A. Taya Acosta/ Ing. Edwin O. Ramos Velásquez
- 16 -
;-----------------------------------------
(DEFUN ProcesarLista()
(SETQ P (LIST "Juan" "Pedro" "Alicia" "Natale" "Pedrito" "Maria"
"Tatiana" "Magali" ))
(PRINT "Listado de nombres: ")
(MuestraLista P 1 )
)
Al ejecutar la instrucción $ (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 continuación (los dos árboles son
equivalentes)
Esta puede crearse a través de la siguiente instrucción:
Personas
Empleados Docentes Alumnos Visitas
PedritoLuchoAnita
María PérezJosé LuisBelinda Salas
Kike VegaUbaldoYuliBenedicto
AlvaroJuan PeredaHectorLucy
Empleados
Docente
Alumno
Visitas
Persona
Pedrito --- Lucho --- Anita
María Pérez --- José Luis --- Belinda Salas
Kike Vega --- Ubaldo --- Yuli --- Benedicto
Alvaro --- Juan Pereda --- Hector --- Lucy
Guías de Laboratorio de Sistemas Expertos Inteligencia Artificial
Ingeniería en Informática y Sistemas Ing. Edgar A. Taya Acosta/ Ing. Edwin O. Ramos Velásquez
- 17 -
(SETQ P1 (LIST "Empleados" '("Pedrito" "Lucho" "Anita")) )
(SETQ P2 (LIST "Docentes" '("Maria_Perez" "Jose_Luis" "Belinda_Salas")) )
(SETQ P3 (LIST "Alumnos" '("Kike_Vega" "Ubaldo" "Yuli" "Benedicto")) )
(SETQ P4 (LIST "Visitas" '("Alvaro" "Juan Pereda" "Hector" "Lucy")) )
(SETQ P (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 )
)
)
)
)
)
)
)
;-----------------------------------------
Guías de Laboratorio de Sistemas Expertos Inteligencia Artificial
Ingeniería en Informática y Sistemas Ing. Edgar A. Taya Acosta/ Ing. Edwin O. Ramos Velásquez
- 18 -
(DEFUN crear_lista ( L )
( block pepe
(SETQ P1 (LIST "Empleados" '("Pedrito" "Lucho" "Anita")) )
(SETQ P2 (LIST "Docentes" '("Maria Perez" "Jose Luis" "Belinda Salas")) )
(SETQ P3 (LIST "Alumnos" '("Kike Vega" "Ubaldo" "Yuli" "Benedicto")) )
(SETQ P4 (LIST "Visitas" '("Alvaro" "Juan Pereda" "Hector" "Lucy")) )
(SETQ P (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 instrucción $ (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
Guías de Laboratorio de Sistemas Expertos Inteligencia Artificial
Ingeniería en Informática y Sistemas Ing. Edgar A. Taya Acosta/ Ing. Edwin O. Ramos Velásquez
- 19 -
"Tiene los hijos siguientes : "
" Hijo: " Malito Vega
" Hijo: " Juan Peredad
" Hijo: " Hector Barreda
" Hijo: " Lucy
DESARROLLO DE LA PRÁCTICA
Ejecución de Visual Lisp en modo Debug (depuración )
1. Usando el Explorador de Windows, crear un directorio denominado C:\MiLisp2. Allí se guardaran todos los archivos generados en esta práctica de laboratorio.
Implementación e implementación de listas
2. Ejecutar VisualLisp (menúInicio\Programas\VisualCLisp\VisualCLisp). 3. Escribir secuencialmente las siguientes instrucciones ¿Qué sucede cuando se ejecuta
cada una de ellas?: (Presentar informe de resultados: Informe Parte 01.doc)
Ejecución de instrucciones atómicas
$ ()
$ (pedro juan)
$ (+ 12 40 -20)
$ ( ( ) ( ) )
$ ( (america) )
$ (pedro (matematica 12 13) (geografia 15) )
¿Qué sucede al ejecutarse cada instrucción?
4. A continuación ejecute las siguientes instrucciones (Presentar informe de resultados: Informe Parte 02.doc)
Ejecución de funciones con valores atómicos
$ (alpha)
$ (betha)
$ (zetha)
$ (SETQ alpha 23 )
$ (SETQ betha 10 )
Lisp “trata” de procesar toda línea
de instrucción, por ello mensajes
tales como:
- EVAL: the function ALG is undefined
Notas sobre Equivalencias
(SETQ X 56 )
Equivale a la instrucción de asignación
X=56
(SETQ alpha 23 )
Equivale a la instrucción de asignación
alpha = 23
Guías de Laboratorio de Sistemas Expertos Inteligencia Artificial
Ingeniería en Informática y Sistemas Ing. Edgar A. Taya Acosta/ Ing. Edwin O. Ramos Velásquez
- 20 -
$ (+ alpha betha )
$ ( - alpha betha )
$ ( * alpha betha )
$ (SETQ zetha (+ alpha betha) )
$ (pedro (matematica 12 13) (geografia 15) )
$ (SETQ ala '(+ 9 5) )
$ (EVAL ala )
$ (SETQ A 100 )
$ (SETQ B 300 )
$ (SETQ OP ‘ (+ A B) )
$ (EVAL OP )
$ (SETQ B 20 )
$ (EVAL OP )
$ (SETQ A 5 )
$ (EVAL OP )
$ ala
$ A
$ B
$ OP
¿Qué sucede al ejecutarse cada instrucción?
5. A continuación ejecute las siguientes instrucciones (Informe Parte 03.doc)
Ejecución de operaciones con listas
; Eliminación del 1er elemento de una lista
$ (CDR ‘(1 4 7 8 9) )
$ (CDR ‘(8 5 1 7 2) )
Notas sobre Equivalencias
(SETQ ala ‘( + 9 5 ) )
Equivale a la instrucción de asignación de
listas, donde ala es una lista (en este caso, una
lista que luego tiene 3 valores atómicos) con
los elementos
Guías de Laboratorio de Sistemas Expertos Inteligencia Artificial
Ingeniería en Informática y Sistemas Ing. Edgar A. Taya Acosta/ Ing. Edwin O. Ramos Velásquez
- 21 -
; Extracción de 1er elemento de una lista
$ (CAR ‘(8 5 1 7 2) )
$ (CAR ‘(9 3 7 20 36) )
;Inversión de listas
$ (REVERSE ‘ (1 2 3 4 5) )
$ (SETQ L1 ‘( 1 2 3 4 5) )
$ (SETQ L2 ‘( 6 7 8 11 13) )
$ (PRINC L1 )
$ (PRINC L2 )
$ (SETQ L3 (REVERSE L1) )
;Valor actual de las variables
$ L1
$ L2
$ L3
¿Qué sucede al ejecutarse cada instrucción?
6. Ejecutar las siguientes instrucciones (Informe Parte 04.doc)
; DEFINICION DE LAS FUNCIONES
$ ( DEFUN ULTIMO ( X ) ( CAR (LAST X ) ) )
$ ( DEFUN SUMAR ( A B ) ( + A B ) )
$ ( DEFUN PAR ( X Y ) ( LIST X Y ) )
; Ejecución de las funciones
$ (ULTIMO ‘( A B C ) )
$ (SUMAR ‘7 ‘8 )
$ (PAR ‘4 ‘5 )
CREACION DE FUNCIONES
7. En la pantalla de edición escribir las siguientes rutinas
; Código preparado por Ing. Edwin Ramos Velásquez
; Las lineas de codigo de este archivo son reconocidos
; Por Visual CLisp Versión 3.1415
Guías de Laboratorio de Sistemas Expertos Inteligencia Artificial
Ingeniería en Informática y Sistemas Ing. Edgar A. Taya Acosta/ Ing. Edwin O. Ramos Velásquez
- 22 -
;------------------------------------------------------------
; Parte 01: Operaciones donde los parámetros 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 parámetros 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)
)
Guías de Laboratorio de Sistemas Expertos Inteligencia Artificial
Ingeniería en Informática y Sistemas Ing. Edgar A. Taya Acosta/ Ing. Edwin O. Ramos Velásquez
- 23 -
;-----------------------------------------------------------
(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) )
)
)
;----------------------------------------------------------
(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 (SETQ x RESULTADO) )
)
)
;-----------------------------------------------------------
(DEFUN DIVIDIR ( L )
(SETQ TEMP L)
Esta es una línea
de comentario
(Empieza con
punto y coma)
Guías de Laboratorio de Sistemas Expertos Inteligencia Artificial
Ingeniería en Informática y Sistemas Ing. Edgar A. Taya Acosta/ Ing. Edwin O. Ramos Velásquez
- 24 -
(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 (SETQ x RESULTADO) )
)
)
;-----------------------------------------------------------
(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 )
(SETQ TEMP L)
(SETQ RESULTADO 0)
(SETQ x 0)
(SETQ x (CAR TEMP))
(SETQ RESULTADO (+ RESULTADO x))
)
;-----------------------------------------------------------
(DEFUN OPERARMODO1 ( OP L )
¿Para qué cree que
serviría esta función
Primer?
Guías de Laboratorio de Sistemas Expertos Inteligencia Artificial
Ingeniería en Informática y Sistemas Ing. Edgar A. Taya Acosta/ Ing. Edwin O. Ramos Velásquez
- 25 -
(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)) )
)
)
Guías de Laboratorio de Sistemas Expertos Inteligencia Artificial
Ingeniería en Informática y Sistemas Ing. Edgar A. Taya Acosta/ Ing. Edwin O. Ramos Velásquez
- 26 -
(SETQ TEMP (CDR TEMP))
)
; (if test then else) == (cond (test then) (t else))
(COND ( (EQUAL L NIL) (SETQ x 0) )
( T (SETQ x RESULTADO) )
)
)
8. Compilar el programa para verificar que esté correctamente escrito
Guardar el archivo
9. A continuación guardar el archivo como: c:\MiLisp\Operaciones.lsp
Cargar y ejecutar funciones contenidas en un archivo
10. A continuación Activar el modo de depuración ( ), es decir elegir el menú compilerDebug
11. Escribir en la ventana de depuración la instrucción LOAD como se muestra:
(LOAD "C:/MiLisp/Operaciones.lsp")
NOTA: Investigue sobre el uso de las funciones: $ RUN
12. A continuación, desde la misma ventana de ejecución, verificar el adecuado funcionamiento de las funciones (llámelas con rutinas)
Por ejemplo:
$ (SUMA 7 5) ; Llamado a la función SUMA
12 ; Resultados devueltos por SUMA
$ (RESTA 7 5) ; Llamado a la función RESTA
2 ; Resultados devueltos por RESTA
$ (MULTIPLICA 7 5) ; Llamado a la función MULTIPLICA
35 ; Resultados devueltos por MULTIPLICA
$ (DIVIDE 80 2) ; Llamado a la función DIVIDE
Guías de Laboratorio de Sistemas Expertos Inteligencia Artificial
Ingeniería en Informática y Sistemas Ing. Edgar A. Taya Acosta/ Ing. Edwin O. Ramos Velásquez
- 27 -
40 ; Resultados devueltos por DIVIDE
$ (RESTAR '(80 7 1) ) ; Llamado a la función RESTAR
72 ; Resultados devueltos por RESTAR
$ (MULTIPLICAR '(2 2 3 3) ) ; Llamado a la función MULTIPLICAR
36 ; Resultados devueltos por MULTIPLICAR
$ (DIVIDIR '(81 3)) ; Llamado a la función DIVIDIR
27 ; Resultados devueltos por DIVIDIR
$ (DIVIDIR '(20)) ; Llamado a la función DIVIDIR
20 ; Resultados devueltos por DIVIDIR
$ (SUMAR '(3 5)) ; Llamado a la función SUMAR
8 ; Resultados devueltos por SUMAR
$ (SUMAR '(3 5 7)) ; Llamado a la función SUMAR
15 ; Resultados devueltos por SUMAR
$ (SUME '(2 4 5 6)) ; Llamado a la función SUME
17 ; Resultados devueltos por SUME
$ (OPERAR + '(3 4 2)) ; Llamado a la función OPERAR
9 ; Resultados devueltos por OPERAR
$ (OPERAR * '(3 4 2)) ; Llamado a la función OPERAR
24 ; Resultados devueltos por OPERAR
$ (OPERAR / '(80 4 2)) ; Llamado a la función OPERAR
9 ; Resultados devueltos por OPERAR
$ (OPERAR + '( ) ) ; Llamado a la función OPERAR
0 ; Resultados devueltos por OPERAR
13. Guardar todo.
Guías de Laboratorio de Sistemas Expertos Inteligencia Artificial
Ingeniería en Informática y Sistemas Ing. Edgar A. Taya Acosta/ Ing. Edwin O. Ramos Velásquez
- 28 -
TAREAS (Presente el informe respectivo: Informe Parte 05.doc)
1. Escribir una función que reciba una lista de números y retorne una lista de números
sumándole su posición a cada número de la lista.
> (suma-posicion ’(1 3 7 -2))
> (2 5 10 2)
2. Escribir la función calcula-diferencia que recibe una lista de números y devuelve otra lista
con la diferencia entre un número 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 función separar-parimpar que recibe una lista de números 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 función cambiar-notacion que transforme una expresión con operaciones
matemáticas escritas en notación funcional de LISP a su notación infija correspondiente.
> (cambiar-notacion ’(+ (* 7 4) (* 5 3) (- (/ 30 (* 2 3)) 1)))
> ((7 * 4) + (5 * 3) + ((30 / (2 * 3)) - 1))
5. Escribir una función 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 función que reciba como parámetros 2 puntos y calcule la distancia euclídea
entre ellos.
> (distancia-puntos (make-punto :valx 8 :valy 6) (make-punto))
> 10
Guías de Laboratorio de Sistemas Expertos Inteligencia Artificial
Ingeniería en Informática y Sistemas Ing. Edgar A. Taya Acosta/ Ing. Edwin O. Ramos Velásquez
- 29 -
7. Escribir una función que convierta una lista de números en un vector de números con los
mismos elementos.
>(array-to-vector '(1 2 3 4 6 7))
> #(1 2 3 4 6 7)
8. Escribir una función que determine si una lista de números 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 función 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 más).
> (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 función que a partir de una lista copie en un fichero “inversa.txt” la lista
y la versión invertida de la misma.
> (guardar-lista-invertida '(w x y z ))
> nil
11. ¿En qué se diferencian las funciones OPERARMODO1 y OPERAR?
Guías de Laboratorio de Sistemas Expertos Inteligencia Artificial
Ingeniería en Informática y Sistemas Ing. Edgar A. Taya Acosta/ Ing. Edwin O. Ramos Velásquez
- 30 -
GUÍA DE PRÁCTICA 03: INTRODUCCIÓN 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 continuación:
Directivas de compilación: que se dan al comienzo del programa. Sección de constantes: puede contener cero, una o varias constantes
(CONSTANTS). Sección de dominios: puede contener cero, uno o varios dominios (DOMAIN). Sección de la base de datos: puede contener cero, uno o varios predicados de la
base de datos. Sección de predicados: puede contener cero, una o varias declaraciones de
predicados. Sección de cláusulas: puede contener cero, una o varias cláusulas. Sección de meta: para que el programa se ejecute de forma independiente debe
existir una meta construida dentro del propio programa. A. Directivas de compilación
Nos permiten controlar las características del compilador. Estas directivas pueden ser cambiadas a través del menú, mediante opciones de línea de comando y en el propio código fuente. En caso de activar una misma directiva de forma distinta en el entorno y en el código fuente, prevalece la activación realizada en el código fuente. Ver ¡Error! No se encuentra el origen de la referencia.
Directiva Significado
bgidriver Esta directiva se utiliza de un modo similar a este ejemplo: bgidriver "_CGA_driver_far", para establecer el tipo de controlador de gráficos que se debe linkar con un programa MS-DOS de gráficos BGI.
bgifont 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 gráficos BGI.
check_determ
Esta directiva activa la detección de cláusulas 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 cláusulas no deterministas: - Aquellas que no poseen corte y hay una o más cláusulas que pueden casar con los
mismos argumentos de entrada para un patrón de flujo. - Aquellas que llaman a otras no deterministas y el predicado llamado no está seguido de
un corte.
code Especifica el tamaño del array interno de código. Por defecto son 2000 párrafos (unidades de 16 bits), para la versión VP de 16 bits. En otro caso, son 10000. Por ejemplo si escribimos code=1024 tenemos un array de código de 16 * 1024 bytes=16Kbytes de tamaño.
config Permite definir el aspecto de los programas en modo texto en MS-DOS antiguo. diagnostics Permite observar los un conjunto de parámetros de un programa Prolog.
error
Produce mensajes de error en tiempo de compilación. Cuando se encuentra un error de este tipo al llegar a la línea de la directiva, se visualiza en pantalla el mensaje escrito al lado de #error. Es muy útil para encontrar inconsistencias debidas al programador y violación de restricciones impuestas.
errorlevel Permite establecer el grado de detalle con que VP informa de los errores al programador. Puede ser 0, 1 ó 2.
heap Sirve para especificar la cantidad de memoria que se reservará para un ejecutable TSR en MS-DOS.
gstacksize Se debe escribir en la sección MAIN para que sea tenida en cuenta y permite establecer el número de bytes de la pila global (cantidad de memoria virtual que el sistema operativo debe reservar), mientras el programa está cargado.
Guías de Laboratorio de Sistemas Expertos Inteligencia Artificial
Ingeniería en Informática y Sistemas Ing. Edgar A. Taya Acosta/ Ing. Edwin O. Ramos Velásquez
- 31 -
nobreak
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 ejecución de la aplicación y, además, ocupa un pequeño espacio de programa. El uso de la directiva evita que se genere este código examinador. Cuando se utiliza esta directiva, la única forma de salir de un bucle infinito es mediante un proceso de reset.
nowarnings Suprime los avisos generados por la existencia de una variable una sola vez en una cláusula. Estas variables pueden ser sustituidas por variables anónimas, luego, en principio, no deben aparecer en un programa bien escrito.
printermenu Permite la generación de código en programas MS-DOS que facilita la impresión de pantallas en modo texto, mediante la pulsación del conjunto Alt–P
Project Se usa cuando utilizamos una metodología de diseño e implementación modular. Permite especificar a qué proyecto pertenece un módulo determinado.
B. Sección de constantes (CONSTANTS) En la sección de constantes podemos declarar constantes simbólicas 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 programación, normalmente, sirven para facilitar el uso de diversas cantidades, expresiones y símbolos. La definición de la sección de constantes se encabeza con la palabra reservada CONSTANTS, y cada línea de definición es de la forma <Nombre Constante> = <Definición de Macro>. Por ejemplo, el siguiente fragmento de programa visualiza en pantalla el contenido:
Programa en Visual Prolog Resultados CONSTANTS numero = 1 expresion = 1+1 GOAL A=numero, B=expresion, write(A), write(B), nl.
( texto impreso en pantalla) 12 A=1, B=2 1 Solution
C. Sección de dominios1
En la sección DOMAINS se pueden definir dominios no especificados por defecto por Visual Prolog. Por ejemplo, el dominio integer es estándar para el compilador, no así el dominio sinónimo ENTERO o dominios complejos. En estos últimos casos, el programador debe definirlo en esta sección. Cada sección 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 declaración 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)
1 Para los familiarizados con lenguajes imperativos tales como Pascal, podemos decir que esta sección, de alguna forma, es análoga a la sección de declaración de tipos de datos o estructuras (por ejemplo: TYPE).
Guías de Laboratorio de Sistemas Expertos Inteligencia Artificial
Ingeniería en Informática y Sistemas Ing. Edgar A. Taya Acosta/ Ing. Edwin O. Ramos Velásquez
- 32 -
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 ejecución del objetivo propuesto en la sección 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 sólo 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. Sinónimos de Dominios Estándar
En ocasiones, puede ser útil definir sinónimos de dominios que son estándar, para una mayor legibilidad del programa, por ejemplo. Así pues en la siguiente declaración: 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 homogéneos. Sin embargo, en Visual Prolog es fácil crear listas heterogéneas mediante el uso eficaz de declaración 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 polimórfica 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
Guías de Laboratorio de Sistemas Expertos Inteligencia Artificial
Ingeniería en Informática y Sistemas Ing. Edgar A. Taya Acosta/ Ing. Edwin O. Ramos Velásquez
- 33 -
Un dominio predicado (dominio puntero a predicado), permite la declaración 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 cómo funciona el ejemplo propuesto para ilustrar el uso de la sección 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 sólo datos y objetos compuestos sino también predicados y funciones que realizan diversas operaciones. De este modo, el predicado operacion recorre cada par de la lista, suma los números que componen dicho par y les aplica el predicado (operación unaria), pasado por parámetro, 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 definición de un dominio al que pertenecen todos los predicados que tengan esa forma. Cualquier predicado que realiza una operación 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 sección CLAUSES se define exactamente el cuerpo de ambos predicados que este caso actúan como funciones. Para la meta especificada, el resultado de la ejecución es el siguiente:
ListaCuadrados=[25,9,49], ListaCubos=[125,27,343] 1 Solution
D. Sección de la base de datos Como sabemos un programa en Visual Prolog no es más que un conjunto de hechos y reglas. En ocasiones, podemos querer actualizar este conjunto de hechos mientras el
Guías de Laboratorio de Sistemas Expertos Inteligencia Artificial
Ingeniería en Informática y Sistemas Ing. Edgar A. Taya Acosta/ Ing. Edwin O. Ramos Velásquez
- 34 -
programa se ejecuta. En tal caso, los hechos deben tratarse como un conjunto dinámico de datos que pertenecen a una base que puede ser actualizada y modificada convenientemente mientras dura la ejecución del programa. Sólo los hechos que se declaran en la sección FACTS serán dinámicos y podrán ser actualizados en tiempo de ejecución. La sección FACTS (también 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 sección 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 almacenarán temporalmente en la pila global del programa.
nodeterm: determina que pueden existir varias instancias para el hecho. determ: determina que sólo puede existir una instancia para el hecho en el mismo
momento. single: determina que sólo puede existir una y sólo 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 término perteneciente al dominio de la sección 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 término perteneciente al dominio de la sección 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 sección de hechos sin nombre en un fichero de texto.
Guías de Laboratorio de Sistemas Expertos Inteligencia Artificial
Ingeniería en Informática y Sistemas Ing. Edgar A. Taya Acosta/ Ing. Edwin O. Ramos Velásquez
- 35 -
– save(STRING OSNombreFichero, NombreSeccionHechos) - (i,i) : Sirve para salvar los hechos de una sección 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 más 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. Actúa sobre del dominio de hechos con nombre NombreSeccionHechos. Falla cuando no hay más 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. Actúa 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 quién es padre de quién y un predicado para deducir el parentesco abuelo.
Tras la ejecución de la meta obtenemos el siguiente resultado:
Y=maria Y=manolo Y=beatriz Y=carlos 4 Solutions
Si examinamos paso a paso esta ejecución, 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)
Guías de Laboratorio de Sistemas Expertos Inteligencia Artificial
Ingeniería en Informática y Sistemas Ing. Edgar A. Taya Acosta/ Ing. Edwin O. Ramos Velásquez
- 36 -
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 después 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, sólo se hace bactracking sobre padre(pepe, L). El resultado de la ejecución se muestra a continuación:
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 ejecución es: NO Solution
E. Sección de definición de predicados
En esta sección se definen los predicados que pueden pertenecer a dominios definidos en la sección DOMAINS (punteros a predicados), o se definen los predicados con una forma determinada en caso de que no los hayamos agrupado en ningún dominio concreto (todas
Guías de Laboratorio de Sistemas Expertos Inteligencia Artificial
Ingeniería en Informática y Sistemas Ing. Edgar A. Taya Acosta/ Ing. Edwin O. Ramos Velásquez
- 37 -
las reglas de la sección de cláusulas deben pertenecer a algún predicado). La sección de definición 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 función y debe ser llamada como A=cubo(3) y en el segundo caso la llamada debe hacerse como cubo(3, A).
Ambas formas de definición son igualmente correctas y su uso dependerá de la aplicación en cuestión 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 múltiples soluciones. procedure: nunca debe fallar aunque pueden producirse errores en tiempo de
ejecución y debe producir una única solución. determ: puede fallar y debe producir una única solución, es decir, no hacen
backtracking. multi: nunca debe fallar y puede producir múltiples soluciones mediante la técnica
de backtracking.
F. Sección de cláusulas
La sección de cláusulas contiene la especificación o implementación del conjunto de hechos y reglas que componen el programa. Dicha sección se encabeza con la palabra CLAUSES. Una cláusula puede ser:
- Un hecho: por ejemplo padre(juan, maria).
- Una regla de deducción: por ejemplo abuelo(X, Y):-padre(X, Z), padre(Z, Y). Como se
observa la regla de deducción 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 cláusulas separadas por conjunciones "," o, al menos, una de las que estén
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
cláusula con la cláusula siguiente en caso de que exista.
Guías de Laboratorio de Sistemas Expertos Inteligencia Artificial
Ingeniería en Informática y Sistemas Ing. Edgar A. Taya Acosta/ Ing. Edwin O. Ramos Velásquez
- 38 -
Una secuencia de cláusulas que definen un predicado se denomina procedimiento.
G. Sección de meta u objetivo
En esta sección 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 detrás 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.
Guías de Laboratorio de Sistemas Expertos Inteligencia Artificial
Ingeniería en Informática y Sistemas Ing. Edgar A. Taya Acosta/ Ing. Edwin O. Ramos Velásquez
- 39 -
GUÍA DE PRÁCTICA 03: INTRODUCCIÓN AL VISUAL PROLOG: ASPECTOS PRACTICOS
OBJETIVOS El alumno podrá realizar programas básicos en Prolog. METODOLOGIA Se pedirá al alumno la implementación de programas ejemplo. A continuación se solicitará al alumno la elaboración de programas como respuesta a problemas enunciados. Aunque se usará Visual Prolog 5.2, para simplificar el reconocimiento del lenguaje, los programas implementados serán programas para un entorno DOS. PARTE 01: Creación 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 práctica se guardarán 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 configuración del proyecto, configurar las siguientes propiedades:
Pàgina 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.
Guías de Laboratorio de Sistemas Expertos Inteligencia Artificial
Ingeniería en Informática y Sistemas Ing. Edgar A. Taya Acosta/ Ing. Edwin O. Ramos Velásquez
- 40 -
5. A continuación se le mostrará en pantalla el proyecto creado así como los demás archivos del proyecto en una ventana.
6. Abrir el archivo MiPrograma1.pro (Seleccionar el nodo MiPrograma1.pro y presionar el botón Edit)
7. Modificar el contenido del archivo, de forma tal que su aspecto final sea similar al que se muestra a continuación: INCLUDE "miprograma1.inc" PREDICATES miprograma1() factorial(INTEGER,INTEGER) hallafactorial(INTEGER) CLAUSES 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).
Algoritmo de la función Factorial Factorial (N) IF N>0 THEN Begin F1= Factorial(N–1) F = F * F1 Return F End
La instrucción “N>0”, funciona a manera de una restricción. Todas las demás instrucciones se ejecutarán siempre y cuando esta instrucción sea válida. “Toda instrucción Prolog se ejecutará siempre y cuando la anterior genere un valor booleano verdadero.”
Guías de Laboratorio de Sistemas Expertos Inteligencia Artificial
Ingeniería en Informática y Sistemas Ing. Edgar A. Taya Acosta/ Ing. Edwin O. Ramos Velásquez
- 41 -
miprograma1():- hallafactorial(5). GOAL miprograma1().
NOTA: A continuación el lector puede Ejemplo de instrucciones condicionales:
Codificación en Prolog Equivalente en seudocodigo factorial(N,F):- N>0, N1 = N - 1, factorial(N1, F1), F = N * F1.
Factorial(N,F) IF (N>0) THEN Begin
N1 = N – 1 Factorial(N1,F1) F = N * F1
End ImprimeEdad(N):- Write("La person "), N>15, write("\n No es un niño "), N>18, write("\n Es mayor de edad "), N>40, N<60, write("\n y una persona madura ").
ImprimeEdad(N) Write(“La persona”); IF N>15 Then
Begin Write(“No es niño”); IF (N>18) Then Begin Write(“Mayor de edad”);
IF (N>40)AND(N<60) THEN write(“y una persona madura”);
End End
PARTE 02: Análisis y verificación del comportamiento del compilador
8. Responda a las siguientes preguntas: a) ¿Qué sucede cuando las expresiones de la sección predicates son borradas? Corre el
programa? ¿Sí o no?. b) ¿Cuál es la diferencia entre las siguientes instrucciones?
miprograma1():- hallafactorial(5). miprograma1():- hallafactorial(5)!. miprograma1():- hallafactorial(5), fail.
c) En el siguiente programa Prolog, ¿por qué cree que en la sección clauses un programador escribiría repetidamente la cláusula fibonacci(1), fibonacci(2), fibonacci(3), etc.?
PREDICATES fibonacci(INTEGER, INTEGER)
HallarFibonacci(INTEGER) 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):-
Investigue la utilidad del
símbolo !. (verifique el qué es corte o fallo(fail) de una ejecución)
/*¿Si reemplaza estas instrucciones por todas las funciones fibonnacci de la sección clauses,qué ocurre?*/ CLAUSES
fibonacci(0, 0):- !. fibonacci(1, 1):- !. fibonacci(N, F):- N1 = N-1,
N2 = N-2, fibonacci(N1, F1), fibonacci(N2, F2), F = F1 + F2.
Toda instrucción Prolog genera un valor booleano (Verdadero ó Falso). Luego, “toda instrucción Prolog se ejecutará siempre y cuando la instrucción precedente generó un valor booleano verdadero”.
Guías de Laboratorio de Sistemas Expertos Inteligencia Artificial
Ingeniería en Informática y Sistemas Ing. Edgar A. Taya Acosta/ Ing. Edwin O. Ramos Velásquez
- 42 -
fibonacci(N, F), write("Resultado: " , F). GOAL HallarFibonacci(6).
¿Qué sucede cuando en la sección GOAL (Objetivo o meta)? Escribo cualquiera de las siguientes instrucciones de manera secuencial (una modificación por vez):
GOAL HallarFibonacci(1).
GOAL HallarFibonacci(3).
GOAL HallarFibonacci(5).
GOAL HallarFibonacci(6).
GOAL HallarFibonacci(7).
GOAL HallarFibonacci(10).
¿Cuál 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 código original por el que se sugiere reemplazar y responda ¿porqué este código si resuelve el problema?.
PARTE 03: Implementación 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 número A: "), readint(A), write ("\n Escriba el número B: "), readint(B), C= A + B, write("\n La SUMA resultante es: ",C). opcion(2):- write ("\n Escriba el número A: "), readint(A), write ("\n Escriba el número B: "), readint(B), C= A - B, write("\n La RESTA resultante es: ",C). opcion(3):- write ("\n Escriba el número 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 número A: "),
Guías de Laboratorio de Sistemas Expertos Inteligencia Artificial
Ingeniería en Informática y Sistemas Ing. Edgar A. Taya Acosta/ Ing. Edwin O. Ramos Velásquez
- 43 -
readint(A), write ("\n Escriba el divisor B: "), readint(B), C= A / B, write("\n La DIVISION resultante es: ",C). opcion(5):- exit. opcion(6):- !. opcion(7):- !. opcion(8):- !. opcion(9):- !. menu(M):- write("\n ---------------------------"), write("\n OPERACIONES MATEMATICAS "), write("\n ---------------------------"), write("\n [1] Suma de dos números"), write("\n [2] Resta de dos números"), write("\n [3] Multiplicación de dos números"), write("\n [4] División de dos números"), write("\n [5] Salir"), write("\n "), write("\n Escriba su opción: "), 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: Implementación 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 InsertToLista(TPersona, TLista, TLista) insertar(INTEGER, TLista, Tlista) writedatos(TPersona) nondeterm recorrerlista(TLista) opcion(INTEGER, TLista, TLista) procesar(TLista) menu(INTEGER) programa4()
/*Posible agregado para permitir búsquedas de personas en lista*/ PREDICATES Buscar(TPersona, TLista,INTEGER) CLAUSES Buscar(E,[],0):- !. 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.
Guías de Laboratorio de Sistemas Expertos Inteligencia Artificial
Ingeniería en Informática y Sistemas Ing. Edgar A. Taya Acosta/ Ing. Edwin O. Ramos Velásquez
- 44 -
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, L, L):- !. opcion(1, L, NuevaL):- insertar(1, L, LOut), NuevaL = LOut,!. opcion(2, L, LNueva):- recorrerlista(L), LNueva = L,!. opcion(3, L, L):- !. opcion(4, L, L):- !. opcion(5, L, L):- exit. opcion(6, L, L):- !. opcion(7, L, L):- !. opcion(8, L, L):- !. opcion(9, L, L):- !. menu(M):- 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 opción: "), readint(N), M=N. procesar(L):- menu(H), H>=0,H<10, opcion(H, L, NuevaL), procesar(NuevaL),!. procesar(_):-write("Hasta Pronto."). programa4():- procesar([]),
Guías de Laboratorio de Sistemas Expertos Inteligencia Artificial
Ingeniería en Informática y Sistemas Ing. Edgar A. Taya Acosta/ Ing. Edwin O. Ramos Velásquez
- 45 -
write("\n programa terminado"). GOAL programa4().
12. Agregarle funcionalidad a todos los menús faltantes de este programa.
PARTE 05: Implementación 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),
Guías de Laboratorio de Sistemas Expertos Inteligencia Artificial
Ingeniería en Informática y Sistemas Ing. Edgar A. Taya Acosta/ Ing. Edwin O. Ramos Velásquez
- 46 -
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] Añadir 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 opción: "), 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 información con el siguiente formato: “X es padre de Y”. En la sección 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 , también, 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.
Guías de Laboratorio de Sistemas Expertos Inteligencia Artificial
Ingeniería en Informática y Sistemas Ing. Edgar A. Taya Acosta/ Ing. Edwin O. Ramos Velásquez
- 47 -
Juan
Pepe Luis
Manolo Beatriz Carlos María
Arbol de conocimientos almacenado en la Base de Conocimientos inicial PARTE 06: Tareas de implementación Problema 1 Implemente programas que realicen cálculos matemáticos simples. Por ejemplo, una calculadora. Problema 2 Implemente programas que manipulen listas. Incluya los métodos: 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 acción podría violar alguna regla empresaria, el sistema le responda de no debería realizar tal acción. Problema 4: Programar la siguiente función matemática en Prolog
8 7 6 5 4 3 2 1 0-1-2
-3 0 3 6 9 12
Problema 5: Dado el siguiente árbol genealógico, crear una base de hechos que lo represente y el conjunto de cláusulas 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?
También se diseñarán clausulas que nos permitan relacionar diferentes familias, por ejemplo
Estructura: “X es padre de Y” Padre(juan, pepe) Padre(juan, luis) Padre(pepe,Manolo) Padre(pepe,Beatriz) Padre(pepe,Carlos)
Padre(pepe,María)
No definida x ≤ 3 x, 0 ≤ x < 3
h(x)= x – 3, 3 ≤ x < 6 x – 6, 6 ≤ x < 9 no definida, x ≥ 6
Guías de Laboratorio de Sistemas Expertos Inteligencia Artificial
Ingeniería en Informática y Sistemas Ing. Edgar A. Taya Acosta/ Ing. Edwin O. Ramos Velásquez
- 48 -
cuñados(X,Y). X es cunado(a) de Y? Se crearán cláusulas de caracter recursivo como:
antepasado(X,Y). X es antepasado de Y?
Familia 1 Familia 2
Antonio ----- Cándida José-----Micaela
Juan----María Rosa ------------------- David Lucio----Pilar
Elena--- Juan Antonio Alberto----Rosa EnriqueJosé María-----Antonio Luis
Pep Ana Pilar------------------Mario Fiona
Juan-------Sara
Sonia
Problema 6: Modificar el programa anterior, para permitir la inserción de nuevos hechos en nuestra base de conocimientos. Como característica básica se considerará la inserción 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 computación del parentesco entre dos personas de una familia, en primer lugar definiremos un conjunto de conceptos necesarios para poder realizar el cálculo:
Línea: 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.
Línea colateral: Es la formada por personas que no descienden unas de otras, pero tienen ascendientes comunes: hermanos, tíos, primos, sobrinos, etc.
Grado: es, en materia de parentesco, cada una de las generaciones existentes entre dos personas relacionadas por vínculos de sangre. así del padre al hijo hay una generación 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 línea recta entre el nieto y el abuelo existen dos grados de parentesco. si utilizamos la línea colateral, para calcular el grado de parentesco entre dos individuos, se asciende hasta el primer antepasado común y luego se desciende hasta la persona respecto de la cual se computa el parentesco. La suma del Número 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 Canónico: En el caso de la línea recta, el cómputo es idéntico que en el caso del derecho civil. En la línea colateral se cuentan las generaciones o grados de la línea más larga y no se suman como en el derecho civil. de esta forma, el hermano se
Guías de Laboratorio de Sistemas Expertos Inteligencia Artificial
Ingeniería en Informática y Sistemas Ing. Edgar A. Taya Acosta/ Ing. Edwin O. Ramos Velásquez
- 49 -
encuentra en primer grado con sus hermanos, y los primos hermanos se encontrarían en segundo grado. esta computación rige solamente para el matrimonio canónico 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.
Guías de Laboratorio de Sistemas Expertos Inteligencia Artificial
Ingeniería en Informática y Sistemas Ing. Edgar A. Taya Acosta/ Ing. Edwin O. Ramos Velásquez
- 50 -
GUÍA DE PRÁCTICA 04:
INTRODUCCIÓN AL VISUAL PROLOG: PROGRAMACION DE APLICACIONES CON ENTORNOS VISUALES
OBJETIVOS El alumno podrá realizar programas básicos en Visual Prolog usando las interfaces graficas METODOLOGIA Se pedirá al alumno la implementación de programas ejemplo. A continuación se solicitará al alumno la elaboración 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 práctica serán programas para un entorno Visual Windows. PARTE 01: Creación de un proyecto Visual en Prolog (MyProgramaVisual.VPR) A) Creación 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 práctica se guardarán 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 configuración del proyecto, configurar las siguientes propiedades:
Pàgina Propiedad Valor
General Project Name ProgramaVisual Name of .VPR File ProgramaVisual.vpr Tarjet Plataform Windows32 User Info ---- Aquí van los datos que usted
desea personalizar.
Guías de Laboratorio de Sistemas Expertos Inteligencia Artificial
Ingeniería en Informática y Sistemas Ing. Edgar A. Taya Acosta/ Ing. Edwin O. Ramos Velásquez
- 51 -
5. A continuación se le mostrará en pantalla el proyecto creado así como los demás archivos del proyecto en una ventana.
Luego de esta acción Usted habrá creado un programa con un formulario MDI.
6. Ejecutar el programa predeterminado (ir al menú ProjectRun) La aplicación creada de manera predeterminada tendrá el siguiente aspecto.
Ventana:
Administrador del
proyecto
Guías de Laboratorio de Sistemas Expertos Inteligencia Artificial
Ingeniería en Informática y Sistemas Ing. Edgar A. Taya Acosta/ Ing. Edwin O. Ramos Velásquez
- 52 -
7. Detener el programa en ejecución. 8. Guardar todo.
B) PERSONALIZACION DEL FORMULARIO PREDETERMINADO
9. Abrir la ventana del “Administrador del proyecto”. 10. Seleccionar el botón Menú. Luego seleccione “Task menú” y a continuación presione el
botón “Edit”.
11. En la ventana Task Menú, seleccionar el Item “&file” y presionar el botón “Attributes”, a continuación modifique el texto como “”Archivo” tal como se muestra en la imagen siguiente:
Presionar el botón Edit
Presionar el botón Attributes
Guías de Laboratorio de Sistemas Expertos Inteligencia Artificial
Ingeniería en Informática y Sistemas Ing. Edgar A. Taya Acosta/ Ing. Edwin O. Ramos Velásquez
- 53 -
12. Proceder de la misma manera con los otros ítems del menú. 13. Correr la aplicación. Usted podrá ver a continuación todo el menú personalizado.
14. Detener la ejecución del programa y grabar todo.
PARTE 02: CREAR UN FORMULARIO frmCalculo 15. Abrir el “Administrador de proyectos”. 16. Seleccionar el botón
“Dialog”. 17. A continuación
seleccionar el botón “New” (Nuevo formulario de diálogo.)
18. Configurar las
propiedades del nuevo formulario según se indica a continuación
19. Luego de la correcta
configuración, presionar el botón OK El aspecto del nuevo formulario recién creado será semejante al que se muestra a continuación.
Presione el botón OK
Guías de Laboratorio de Sistemas Expertos Inteligencia Artificial
Ingeniería en Informática y Sistemas Ing. Edgar A. Taya Acosta/ Ing. Edwin O. Ramos Velásquez
- 54 -
20. Usando la paleta de controles, agregar tres controles “Edit controls” al formulario frmCalculo, y configurar sus propiedades según se muestra a continuación:
21. Agregar tres controles Static Text al formulario frmCalculo, y configurar sus propiedades según se muestran a continuación:
22. Agregue un control “Push Button” al formulario frmCalculo, y configure sus propiedades según se presenta a continuación:
Paleta de controles
Guías de Laboratorio de Sistemas Expertos Inteligencia Artificial
Ingeniería en Informática y Sistemas Ing. Edgar A. Taya Acosta/ Ing. Edwin O. Ramos Velásquez
- 55 -
El aspecto final del formulario recién creado será semejante al que se muestra a continuación:
23. Grabar Todo. PARTE 03: AGREGAR UN ITEM AL MENU PRINCIPAL
24. En la Ventana “administrador de proyectos”, seleccionar el botón Menú, y agregar el Menú “Procesar” (ver figura 1).
25. Luego agregarle un submenú Cálculos (figura 2) ( es decir crear MenúProcesar)
Figura 1. Figura 2
26. Presionar OK, y luego Grabar todo.
Guías de Laboratorio de Sistemas Expertos Inteligencia Artificial
Ingeniería en Informática y Sistemas Ing. Edgar A. Taya Acosta/ Ing. Edwin O. Ramos Velásquez
- 56 -
PARTE 04: AGREGAR COMMANDOS (CLAUSULAS) PARA EL SUBMENÚ Cálculos (que tiene el identificador id_Procesar_calculos). A ) Implementar Procedimientos de creación del formulario fmrCalculo.
27. Ir a la ventana de “Administrador del proyecto” y mostrar las tareas del menú (Figura A) 28. Presionar el botón “Code Expert”. Se le mostrará el cuadro de diálogo mostrado en la
Figura B. Configurarlo según se muestra en esa imagen.
Figura B
29. Presionar el botón “Yes”, en el cuadro de diálogo que se le mostrare (figura C).
Luego de realizada esta acción usted podrá constatar (si así lo desea), que en el archivo de programa “ProgramaVisual.pro” se han agregado de manera automática las siguientes líneas de código (¡CUIDADO! NO modifique esas líneas. Es código autogenerado por el Visual Prolog), las cuales servirán para poder llamar al formulario frmCalculo desde el menú principal.
Figura A
Figura C
Presionar el botón
OK
Presionar el botón
Code Expert
Presionar el botón Yes
Guías de Laboratorio de Sistemas Expertos Inteligencia Artificial
Ingeniería en Informática y Sistemas Ing. Edgar A. Taya Acosta/ Ing. Edwin O. Ramos Velásquez
- 57 -
%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 continuación, para crear el código que activará el submenú id_Procesar_Calculos, activar nuevamente el botón “Cod Expert”, pero en esta ocasión, configurar el siguiente cuadro de diálogo (Figura D):
Guías de Laboratorio de Sistemas Expertos Inteligencia Artificial
Ingeniería en Informática y Sistemas Ing. Edgar A. Taya Acosta/ Ing. Edwin O. Ramos Velásquez
- 58 -
31. Presionar el botón Add Clause.
32. Grabar todo. 33. En la ventana “Administrador
de proyectos” presionar el botón “module” y se le mostrará en pantalla el código del programa principal. Una sección del archivo se parecerá a la imagen que se muestra a continuación:
%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 %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 líneas resaltadas por las siguientes líneas: %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 podréis contemplar que la aplicación tiene un aspecto similar al
que se muestra a continuación:
Figura D
Estas líneas deberán ser modificadas por las que se indica abajo
Presionar el botón
Add Clause.
Guías de Laboratorio de Sistemas Expertos Inteligencia Artificial
Ingeniería en Informática y Sistemas Ing. Edgar A. Taya Acosta/ Ing. Edwin O. Ramos Velásquez
- 59 -
37. Grabar todo.
PARTE 05: IMPLEMENTACION DE LA IMPLEMENTACION DE RUTINAS DEL FORMULARIO frmCalculo
38. Abrir el archivo “Administrador de proyectos”. Y seleccionar el botón “Code Expert”. 39. Se le mostrará un cuadro de diálogo. Configurar este cuadro de diálogo según se
muestra a continuación Figura A:
40. A continuación, presionar el botón Edit Clause. Luego de esta acción, se le mostrará la
ventana de códigos, 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),
Figura A
Figura B
Guías de Laboratorio de Sistemas Expertos Inteligencia Artificial
Ingeniería en Informática y Sistemas Ing. Edgar A. Taya Acosta/ Ing. Edwin O. Ramos Velásquez
- 60 -
_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 codificación 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), % 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
diálogo siguiente(es un programa que realiza la Suma de dos números A y B):
Identificador de uno de los controles TextBox del frmCalculo. !Recuerde la parte 02!
Guías de Laboratorio de Sistemas Expertos Inteligencia Artificial
Ingeniería en Informática y Sistemas Ing. Edgar A. Taya Acosta/ Ing. Edwin O. Ramos Velásquez
- 61 -
45. Guardar todo. La práctica de laboratorio ha finalizado. NOTA: Para aprender a crear programas visuales con una mayor fluidez, podéis abrir los ejemplos que se incluyen con el paquete Visual Prolog 5.2.
Ejemplos de programas visuales: En el directorio de instalación C:\VIP\VPI\EXAMPLES
Ejemplos de programas DOS: En el directorio de instalación C:\VIP\EXAMPLES
TAREAS Implementar un programa que realice los cálculos matemáticos. (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
Guías de Laboratorio de Sistemas Expertos Inteligencia Artificial
Ingeniería en Informática y Sistemas Ing. Edgar A. Taya Acosta/ Ing. Edwin O. Ramos Velásquez
- 62 -
GUÍA DE PRACTICA 05
KAPPA – PC 2.0:
UN SISTEMA EXPERTO BASADO EN REGLAS
OBJETIVO GENERAL
Reconocimiento del entorno del lenguaje de programación para sistemas expertos basados en
reglas Kappa – PC versión 2.0
OBJETIVOS ESPECÍFICOS
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 descripción (definición) de una clase (Class) denominada TGente con los siguientes atributos (Slots):
Nacimiento: en el que se almacenará el país 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 función denominada Procesar en la que escribiremos las rutinas relativas
al procesamiento de un recorrido hacia delante (para la instancia Juan) 5. Se definirá una función denominada Cerrar, en la que insertaremos una instrucción de
finalización 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 (Botón) el que enlazaremos con la función Procesar (creada previamente).
Un objeto tipo Button (Botón) el que enlazaremos con la función Cerrar (creada previamente).
7. Ejecutar la interfaz de usuario.
CONOCIMIENTO PREVIO
a) Descripción de las reglas
Las reglas a implementarse son las siguientes:
Regla Descripción
Regla1 Si
Gente.Nacimiento = Peru
Entonces
Gente.Nacionalidad = Peruano
Guías de Laboratorio de Sistemas Expertos Inteligencia Artificial
Ingeniería en Informática y Sistemas Ing. Edgar A. Taya Acosta/ Ing. Edwin O. Ramos Velásquez
- 63 -
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 Descripción
Regla5 Si
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 = Brasileño
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
2 Me parece que esto ya debiera haberlo deducido el lector.
Guías de Laboratorio de Sistemas Expertos Inteligencia Artificial
Ingeniería en Informática y Sistemas Ing. Edgar A. Taya Acosta/ Ing. Edwin O. Ramos Velásquez
- 64 -
DESARROLLO DE LA PRÁCTICA DE LABORATORIO
PRIMERA PARTE: CREACION DEL ARCHIVO PRACT01.KAL
1. Correr el programa Kappa-PC 2.0. 2. Ir al menú FILE seleccionar la opción NEW 3. Ir al menú FILE seleccionar la opción SAVE AS y guardar el archivo con el nombre
pract01.kal
SEGUNDA PARTE : DEFINICION DE LA CLASE TGENTE (Class)
a) Definición de la clase
4. Visualizar la ventana de herramientas de edición (Presionar el ícono Edit Tools) 5. Crear una nueva clase y configurarla según lo indicado(Presion el ícono Class):
Class Name: TGente
Parent Class: Root
Se le mostrará a continuación la ventana de edición de clases, que será similar a:
Ventana Principal
Ventana de herramientas de edición (Edit Tools)
Guías de Laboratorio de Sistemas Expertos Inteligencia Artificial
Ingeniería en Informática y Sistemas Ing. Edgar A. Taya Acosta/ Ing. Edwin O. Ramos Velásquez
- 65 -
b) Definición 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 edición de reglas
Guías de Laboratorio de Sistemas Expertos Inteligencia Artificial
Ingeniería en Informática y Sistemas Ing. Edgar A. Taya Acosta/ Ing. Edwin O. Ramos Velásquez
- 66 -
10. Escriba el detalle de la regla Regla1 según como se indica a continuación:
SECCION CONTENIDO
Patterns Gente|TGente
Priority 0
If Gente:Nacimiento #= Peru;
Then Gente:Nacionalidad=Peruano;
11. Guardar todo (Ir al menú UPDATE y seleccionar la opción 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 práctica (pasos 8 al 11) pero en esta ocasión con las siguientes especificaciones: a) Regla: Regla2
SECCION CONTENIDO
Patterns Gente|TGente
Priority 0
If Gente:Nacimiento #= Bolivia;
Then Gente:Nacionalidad=Boliviano;
b) Regla: Regla3
SECCION CONTENIDO
Patterns Gente|TGente
Priority 0
If Gente:Nacimiento #= Chile;
Then Gente:Nacionalidad=Chileno;
c) Regla: Regla4
Guías de Laboratorio de Sistemas Expertos Inteligencia Artificial
Ingeniería en Informática y Sistemas Ing. Edgar A. Taya Acosta/ Ing. Edwin O. Ramos Velásquez
- 67 -
SECCION CONTENIDO
Patterns Gente|TGente
Priority 0
If Gente:Nacimiento #= Ecuador;
Then Gente:Nacionalidad=Ecuatoriano;
d) Regla: Regla5
SECCION CONTENIDO
Patterns Gente|TGente
Priority 0
If Gente:Nacimiento #= Colombia;
Then Gente:Nacionalidad=Colombiano;
e) Regla: Regla6
SECCION CONTENIDO
Patterns Gente|TGente
Priority 0
If Gente:Nacimiento #= Venezuela;
Then Gente:Nacionalidad=Venezolano;
f) Regla: Regla7
SECCION CONTENIDO
Patterns Gente|TGente
Priority 0
If Gente:Nacimiento #= Argentina;
Then Gente:Nacionalidad=Argentino;
g) Regla: Regla8
SECCION CONTENIDO
Patterns Gente|TGente
Priority 0
If Gente:Nacimiento #= Brasil;
Then Gente:Nacionalidad=Brasileño;
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 configuración en el cuadro de diálogo es el siguiente:
Guías de Laboratorio de Sistemas Expertos Inteligencia Artificial
Ingeniería en Informática y Sistemas Ing. Edgar A. Taya Acosta/ Ing. Edwin O. Ramos Velásquez
- 68 -
Instance Name: Juan
Parent Class: TGente
14. Cerrar la ventana de edición de instancias (Editor Instance)
SEXTA PARTE: ESCRITURA DE LA FUNCION Procesar
15. Presione el ícono FUNCTION, y defina el nombre de la función Procesar.
Se le presentará a continuación la ventana editor de funciones:
16. En la ventana editor de funciones (Function editor), escribir en la sección 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 edición de funciones.
Guías de Laboratorio de Sistemas Expertos Inteligencia Artificial
Ingeniería en Informática y Sistemas Ing. Edgar A. Taya Acosta/ Ing. Edwin O. Ramos Velásquez
- 69 -
SETIMA PARTE: ESCRITURA DE LA FUNCION Finalizar
18. Repetir los pasos de la parte SEXTA, pero esta vez para la función Finalizar.
Función: Finalizar
Código:
{
Exit( );
};
19. Grabar todo. Cerrar la ventana de edición 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 opción Layout Mode. Se le mostrará la respectiva ventana de controles insertables.
22. Insertar en la ventana de graficación dos controles Button y un control RadioButtonGroup.
Button (Botón)
RadioButtonGroup (Lista de opciones)
Ventana de graficación
Guías de Laboratorio de Sistemas Expertos Inteligencia Artificial
Ingeniería en Informática y Sistemas Ing. Edgar A. Taya Acosta/ Ing. Edwin O. Ramos Velásquez
- 70 -
23. Configurar las propiedades de los controles de la siguiente forma
COMPONENTE PROPIEDAD VALOR
Button1 Title Nacionalidad
Action Procesar
Button2 Title Cerrar
Action Finalizar
RadioButton
Group1
Title Juan nacio en el país:
Owner Juan
OwnerSlot Nacimiento
Allowable
Values3
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 Sessión. 26. Ir al menú OPTIONS y cerciorarse de que la opción Layout Mode esté desactivada.
3 Los ítems se escriben separados por un único espacio en blanco.
RadioButtonG
Guías de Laboratorio de Sistemas Expertos Inteligencia Artificial
Ingeniería en Informática y Sistemas Ing. Edgar A. Taya Acosta/ Ing. Edwin O. Ramos Velásquez
- 71 -
27. Puede ahora trabajar con este formulario como si estuviera en tiempo de ejecución (realmente está ejecutándose 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 práctica 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 APLICACIÓN GENERADA
Enlazado a
Es de la
Es una
Es una
Objeto: Juan
Atributo: Nacimiento
TGente
Nacimiento
Procesar
Root
Funcion
Finaliza
Es de la
Enlazado a
Enlazado
INTERFAZ DE USUARIO OBJETO/FUNCION DEFINICION
SESSI
Guías de Laboratorio de Sistemas Expertos Inteligencia Artificial
Ingeniería en Informática y Sistemas Ing. Edgar A. Taya Acosta/ Ing. Edwin O. Ramos Velásquez
- 72 -
GUÍA DE PRACTICA 06:
KAPPA – PC 2.0:
PERSONALIZACION DE UN SISTEMA EXPERTO
OBJETIVO GENERAL
Reconocimiento del entorno del lenguaje de programación para sistemas expertos basados en
reglas Kappa – PC versión 2.0
OBJETIVOS ESPECÍFICOS
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 PRÁCTICA DE LABORATORIO
1. Abrir el archivo pract01.kal (archivo generado en la primera sesión de la práctica). 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 Descripción
Regla01 Si
Gente.Edad = 15
Entonces
Gente.Atributo = Sabelotodo
Guías de Laboratorio de Sistemas Expertos Inteligencia Artificial
Ingeniería en Informática y Sistemas Ing. Edgar A. Taya Acosta/ Ing. Edwin O. Ramos Velásquez
- 73 -
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
Guías de Laboratorio de Sistemas Expertos Inteligencia Artificial
Ingeniería en Informática y Sistemas Ing. Edgar A. Taya Acosta/ Ing. Edwin O. Ramos Velásquez
- 74 -
TAREA 3: AGREGAR FUNCIONES
Agregue las siguientes funciones al sistema experto
Función: Edades
{
Assert( Juan:Edad );
ForwardChain( NULL, Regla01, Regla02 );
PostMessage( "Juan es un: ", Juan:Atributo );
};
Función: 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 );
};
Guías de Laboratorio de Sistemas Expertos Inteligencia Artificial
Ingeniería en Informática y Sistemas Ing. Edgar A. Taya Acosta/ Ing. Edwin O. Ramos Velásquez
- 75 -
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:
Objeto: Juan
Atributo: Edad
Procesar
Edades
Combinar
Finalizar
Objeto: Juan
Atributo: Nacimiento
Enlazado a Enlazado a
Enlazado a
Enlazado a
Enlazado a
Enlazado a
Guías de Laboratorio de Sistemas Expertos Inteligencia Artificial
Ingeniería en Informática y Sistemas Ing. Edgar A. Taya Acosta/ Ing. Edwin O. Ramos Velásquez
- 76 -
DETALLE DE LA ACCIÓN CONFIGURADA
Descripción de las reglas enlazadas
Descripción de todas las reglas enlazables
Regla 1
Regla2
Regla01
Regla02
Regla102
Regla101
Regla202
Regla201
Regla301
Regla302
Regla401
Regla801
Regla 1
Regla2
Regla3
Regla4
Regla5
Regla6
Regla7
Regla8
Regla01
Regla02Regla102
Regla101
Regla201
Regla202
Regla802
.....
....
Regla402
Guías de Laboratorio de Sistemas Expertos Inteligencia Artificial
Ingeniería en Informática y Sistemas Ing. Edgar A. Taya Acosta/ Ing. Edwin O. Ramos Velásquez
- 77 -
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 están los íconos que nos permitirán 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
Guías de Laboratorio de Sistemas Expertos Inteligencia Artificial
Ingeniería en Informática y Sistemas Ing. Edgar A. Taya Acosta/ Ing. Edwin O. Ramos Velásquez
- 78 -
Ventana de definición 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 más de un solo formulario, es esta la opción 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
también instancias de las clases existentes (Juan por ejemplo, que es de la clase TGente)
4 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 opción es opcional).
Guías de Laboratorio de Sistemas Expertos Inteligencia Artificial
Ingeniería en Informática y Sistemas Ing. Edgar A. Taya Acosta/ Ing. Edwin O. Ramos Velásquez
- 79 -
3. Definir las reglas
En la ventana EditTools, presionar el ícono Rules
Haciendo uso de esta opción, 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
Guías de Laboratorio de Sistemas Expertos Inteligencia Artificial
Ingeniería en Informática y Sistemas Ing. Edgar A. Taya Acosta/ Ing. Edwin O. Ramos Velásquez
- 80 -
Esta opción le permitirá visualizar los formularios que desee modificar. Por supuesto que
para modificar un formulario tiene que cambiarle su estatus al modo edición5.
Para cambiar el estado de un formulario, basta modificar la opción Layout mode del
respectivo formulario.
RESUMEN DE LOS PASOS A REALIZAR PARA PROGRAMAR EN KAPPA–PC
En resumen, podemos decir que los pasos a realizar para programar usando el Kappa-PC son
los siguientes:
PASO EJEMPLO
1. Definir la estructura de la clase 2. Definir las instancias a utilizar 3. Definir las reglas 4. Definir las funciones 5. Implementar la interfaz (formularios) 6. Ejecutar el formulario
TGente
Juan
Regla1, Regla2
Procesar, Terminar
SESSION1, SESSION2(crear/modificar)
Layout Mode (en el formulario inicial)
TAREA
Implementar un programa con la siguiente interfaz
5 Un formulario, en Kappa-PC tiene dos estados: Diseño (Layout) y ejecución. Un formulario
solamente puede ser modificado cuando está en el estado de diseño.
Guías de Laboratorio de Sistemas Expertos Inteligencia Artificial
Ingeniería en Informática y Sistemas Ing. Edgar A. Taya Acosta/ Ing. Edwin O. Ramos Velásquez
- 81 -
Donde esta se comporte de la siguiente forma:
Si el usuario selecciono el color rojo, al presionar el botón procesar debe aparecer un mensaje como el que se muestra a continuación:
El semáforo está rojo, detenga el auto
Si el usuario selecciono el color Ambar, al presionar el botón procesar debe aparecer un mensaje como el que se muestra a continuación:
El semáforo está en ambar, peligro
Si el usuario selecciono el color verde, al presionar el botón procesar debe aparecer un mensaje como el que se muestra a continuación:
El semáforo está verde, puede continuar
Top Related