guias de practica sistemas expertos

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



- 2 -

CONTENIDO

PÁGINA

Guía de práctica 01: 03

Introducción Al Lenguaje Lips Usando Visual Clisp Versión 3.1415


Grafos y procedimientos en VisualCLisp

Guía de práctica 03: 30, 39

Introducción al Visual Prolog


Introducción al Visual Prolog: Programación de aplicaciones

con entornos Visuales


KAPPA – PC 2.0: Un sistema experto basado en reglas


KAPPA – PC 2.0: Personalización de un sistema experto



- 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”



- 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.



- 5 -

$ (betha)

$ (zetha)

$ (SETQ alpha 23 )

$ (SETQ betha 10 )

$ (+ alpha betha )

$ ( - alpha betha )

$ ( * alpha betha )

$ (SETQ zetha (+ alpha betha) )


$ (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


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 )



(SETQ ala ‘( + 9 5 ) )


de listas, donde ala es una lista (en este

caso, una lista que luego tiene 3 valores

atómicos) con los elementos

+ 9 5



- 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


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 )



- 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)

)



- 8 -

;-----------------------------------------------------------

(DEFUN RESTAR ( L )

(SETQ TEMP L)

(SETQ x 0)

(SETQ RESULTADO (CAR TEMP))



(SETQ x (CAR TEMP))

( IF (NOT (EQUAL x NIL)) (SETQ RESULTADO (- RESULTADO x)) )


)

; (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)


(SETQ x (CAR TEMP))

( IF (NOT (EQUAL x NIL)) (SETQ RESULTADO (* RESULTADO x)) )


)




)

)

;-----------------------------------------------------------

Esta es una línea de comentario



- 9 -

(DEFUN DIVIDIR ( L )

(SETQ TEMP L)



(SETQ x 0)


( SETQ x (CAR TEMP))

( IF (NOT (EQUAL x NIL)) (SETQ RESULTADO (/ RESULTADO x)) )

( SETQ TEMP (CDR TEMP))

)




)

)

;-----------------------------------------------------------

(DEFUN SUME ( L )

(SETQ TEMP L)

(SETQ RESULTADO 0)

(SETQ x 0)


(SETQ x (CAR TEMP))

( IF (NOT (EQUAL x NIL)) (SETQ RESULTADO (+ RESULTADO x)) )


)

(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?



- 10 -

(DEFUN OPERARMODO1 ( OP L )

(SETQ TEMP L)

(SETQ RESULTADO 0)

(SETQ x 0)


(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 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))


( COND





)

)



- 11 -


)

; (if test then else) == (cond (test then) (t else))



)

)

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



- 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


$ (SUMAR '(3 5)) ; Llamado a la función SUMAR

8 ; Resultados devueltos por SUMAR

$ (SUMAR '(3 5 7)) ; Llamado a la función 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


$ (OPERAR / '(80 4 2)) ; Llamado a la función OPERAR


$ (OPERAR + '( ) ) ; Llamado a la función 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.



- 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)



- 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?



- 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))

)

)

)

)



- 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



- 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 )

)

)

)

)

)

)

)

;-----------------------------------------



- 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


" Hijo: " Maria Perez

" Hijo: " Jose Luis

" Hijo: " Belinda Salas

"El Nodo: " Alumnos


" Hijo: " Kike_Vega

" Hijo: " Ubaldo

" Hijo: " Yuli

" Hijo: " Benedicto

"El Nodo: " Visitas



- 19 -


" 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) )



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


(SETQ X 56 )


X=56

(SETQ alpha 23 )


alpha = 23



- 20 -

$ (+ alpha betha )

$ ( - alpha betha )

$ ( * alpha betha )

$ (SETQ zetha (+ alpha betha) )


$ (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


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) )


(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



- 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


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



- 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)


(SETQ x (CAR TEMP))

( IF (NOT (EQUAL x NIL)) (SETQ RESULTADO (+ RESULTADO x)))


)

(SETQ x RESULTADO)

)



- 23 -

;-----------------------------------------------------------

(DEFUN RESTAR ( L )

(SETQ TEMP L)

(SETQ x 0)




(SETQ x (CAR TEMP))

( IF (NOT (EQUAL x NIL)) (SETQ RESULTADO (- RESULTADO x)) )


)




)

)

;----------------------------------------------------------

(DEFUN MULTIPLICAR ( L )

(SETQ TEMP L)

(SETQ RESULTADO 1)

(SETQ x 0)


(SETQ x (CAR TEMP))

( IF (NOT (EQUAL x NIL)) (SETQ RESULTADO (* RESULTADO x)) )


)




)

)

;-----------------------------------------------------------

(DEFUN DIVIDIR ( L )

(SETQ TEMP L)

Esta es una línea

de comentario

(Empieza con

punto y coma)



- 24 -



(SETQ x 0)


( SETQ x (CAR TEMP))

( IF (NOT (EQUAL x NIL)) (SETQ RESULTADO (/ RESULTADO x)) )

( SETQ TEMP (CDR TEMP))

)




)

)

;-----------------------------------------------------------

(DEFUN SUME ( L )

(SETQ TEMP L)

(SETQ RESULTADO 0)

(SETQ x 0)


(SETQ x (CAR TEMP))

( IF (NOT (EQUAL x NIL)) (SETQ RESULTADO (+ RESULTADO x)) )


)

(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?



- 25 -

(SETQ TEMP L)

(SETQ RESULTADO 0)

(SETQ x 0)


(SETQ x (CAR TEMP))


( COND





)

)


)

(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))


( COND





)

)



- 26 -


)

; (if test then else) == (cond (test then) (t else))



)

)

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



- 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


$ (DIVIDIR '(20)) ; Llamado a la función DIVIDIR


$ (SUMAR '(3 5)) ; Llamado a la función SUMAR


$ (SUMAR '(3 5 7)) ; Llamado a la función 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


$ (OPERAR * '(3 4 2)) ; Llamado a la función OPERAR


$ (OPERAR / '(80 4 2)) ; Llamado a la función OPERAR


$ (OPERAR + '( ) ) ; Llamado a la función OPERAR


13. Guardar todo.



- 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



- 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?



- 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.



- 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).



- 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



- 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



- 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.



- 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)



- 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



- 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.



- 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.



- 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.



- 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.”



- 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”.



- 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).






¿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: "),



- 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.



- 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([]),



- 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),



- 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.



- 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



- 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



- 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.



- 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.



- 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



- 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



- 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



- 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



- 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.



- 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



- 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):



- 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.



- 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



- 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!



- 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



- 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



- 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.



- 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)



- 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



- 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


Priority 0

If Gente:Nacimiento #= Bolivia;

Then Gente:Nacionalidad=Boliviano;

b) Regla: Regla3

SECCION CONTENIDO


Priority 0

If Gente:Nacimiento #= Chile;

Then Gente:Nacionalidad=Chileno;

c) Regla: Regla4



- 67 -

SECCION CONTENIDO


Priority 0

If Gente:Nacimiento #= Ecuador;

Then Gente:Nacionalidad=Ecuatoriano;

d) Regla: Regla5

SECCION CONTENIDO


Priority 0

If Gente:Nacimiento #= Colombia;

Then Gente:Nacionalidad=Colombiano;

e) Regla: Regla6

SECCION CONTENIDO


Priority 0

If Gente:Nacimiento #= Venezuela;

Then Gente:Nacionalidad=Venezolano;

f) Regla: Regla7

SECCION CONTENIDO


Priority 0

If Gente:Nacimiento #= Argentina;

Then Gente:Nacionalidad=Argentino;

g) Regla: Regla8

SECCION CONTENIDO


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:



- 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.



- 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



- 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



- 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



- 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



- 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



- 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 );

};



- 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



- 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



- 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



- 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).



- 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



- 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.



- 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

guias de practica sistemas expertos

Documents