Manual Visual Prolog 7.5

Manual Visual Prolog 7.
Julio Luis Tenorio Cabrera.
Manual Visual Prolog 7.5
INDICE
INDICE..................................................................................................................................... 1
MODO CONSOLA...................................................................................................................... 2
SESIN 01................................................................................................................................ 2
Figura 01: cono de Visual Prolog..................................................................................................... 2
Figura 02: Pantalla inicial de Visual Prolog......................................................................................... 3
Figura 03: Pantalla de datos del proyecto del ejercicio 01.......................................................................4
Figura 04: Pantalla de estructura del proyecto del ejercicio 01..................................................................5
Figura 05: Pantalla visualizacin de resultado de la ejecucin del proyecto del ejercicio 01..............................9
SESIN 02.............................................................................................................................. 14
SESIN 03.............................................................................................................................. 23
SESIN 04.............................................................................................................................. 30
MODO GUI............................................................................................................................. 35
SESIN 05.............................................................................................................................. 35
Tenorio Cabrera Julio Luis
Pgina 1
MODO CONSOLA
SESIN 01
Visual Prolog, es un entorno de desarrollo para Sistemas Expertos, basado en la programacin
lgica utilizando asimismo el mecanismo de razonamiento con encadenamiento hacia atrs para
realizar el proceso de razonamiento.
En Visual Prolog, no es necesario programar el proceso de razonamiento ya que, cmo se
mencion anteriormente, ya se encuentra implementado, por lo que slo se le debe de alimentar de
la experiencia, es decir del conocimiento del experto o especialista humano, para la construccin
de la Base de Conocimiento del Sistema Experto que se vaya a desarrollar.
Visual Prolog, permite el desarrollo de aplicaciones tanto a nivel consola como aplicaciones de
tipo GUI. Para el presente manual, empezaremos explicando el desarrollo de aplicaciones a nivel
consola y luego con las aplicaciones tipo GUI.
Para el ingreso a Visual Prolog, hacemos doble click sobre el cono respectivo, el que se muestra a
continuacin:
Figura 01: cono de Visual Prolog

Luego observaremos la siguiente interfaz, en la que podemos crear un nuevo proyecto, abrir un
proyecto de la lista de proyectos que se muestren en dicha interfaz o buscar ayuda en la wiki de
Visual Prolog (http://wiki.visual-prolog.com/index.php?title=Getting%20Started). La interfaz que
se muestra es:
Pgina 2
Figura 02: Pantalla inicial de Visual Prolog

Para la creacin de un nuevo proyecto (Ejercicio 01) llamado Hola Mundo (por el momento de
tipo consola), se hace click en el botn New Project y en la interfaz que aparece se escriben los
datos necesario para el proyecto, tal como se muestra a continuacin: (no olvidar que el tipo de
proyecto Project Kind es Console Application)
Pgina 3
Figura 03: Pantalla de datos del proyecto del ejercicio 01

Luego de haber registrado los datos respectivos, se hace click en el botn Finish con lo que
aparecer la siguiente interfaz y a la vez Visual Prolog compilar por defecto la aplicacin que se
est desarrollando, mostrndose en la ventana Messages el proceso de compilacin y
finalmente mostrndose el mensaje Project has been built es decir que el Proyecto ha sido
construido:
Pgina 4
Figura 04: Pantalla de estructura del proyecto del ejercicio 01

En este punto es importante explicar el contenido de la ventana del proyecto en donde se observan
dos carpetas, una que lleva el nombre del proyecto, en este caso Hola Mundo y la otra $
(ProDir). La carpeta Hola Mundo contiene los archivos del proyecto que se deben de trabajar
por parte del desarrollador del proyecto, como por ejemplo los archivos: Hola Mundo.vipprj,
main.cl, main.manifest, main.pack, main.ph, main.pro, etc., y la carpeta $
(ProDir) contiene dos carpetas: lib y pfc que contienen las libreras a ser utilizadas en el
proyecto. Por ejemplo el archivo main.pack, se relaciona con la carpeta pfc (que est dentro de
la carpeta $(ProDir), ya que incluye a algunos paquetes y archivos que la carpeta pfc
contiene. Asimismo el archivo main.pack tambin contiene al archivo main.ph y
main.pro. Esto se muestra a continuacin:
Pgina 5
#include @"main.ph"
% privately used packages
#include @"pfc\console\console.ph"
#include @"pfc\core.ph"
% private interfaces
% private classes
% implementations
#include @"main.pro"
Asimismo por ejemplo, el archivo main.ph, requiere al archivo main.pack e incluye tambin al
archivo core.pro de la carpeta pfc y al archivo main.cl. Se debe hacer mencin que el
archivo core.pro, es fundamental ya que contiene todos los predicados para el funcionamiento
de un programa por ejemplo, la definicin de los tipos de datos. Esto se muestra a continuacin:
#requires @"main.pack"
% publicly used packages
#include @"pfc\core.ph"
% exported interfaces
% exported classes
#include @"main.cl"
El archivo main.cl, contiene la declaracin del predicado run, el que se va a definir en main.pro.
Esto se muestra a continuacin:
class main
open core
predicates
run : core::runnable.
end class main
El archivo main.manifest contiene el cdigo XML del proyecto tal como se muestra a
continuacin:
<?xml version="1.0" encoding="utf-8" standalone="yes"?>

<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0">
<assemblyIdentity
name="Hola Mundo"
version="1.0.0.0"
Pgina 6
processorArchitecture="X86"
type="win32"
/>
<trustInfo xmlns="urn:schemas-microsoft-com:asm.v3">
<security>
<requestedPrivileges>
<requestedExecutionLevel level="asInvoker" uiAccess="false"/>
</requestedPrivileges>
</security>
</trustInfo>
<dependency>
<dependentAssembly>
<assemblyIdentity
name="Microsoft.Windows.Common-Controls"
version="6.0.0.0"
processorArchitecture="X86"
type="win32"
publicKeyToken="6595b64144ccf1df"
language="*"
/>
</dependentAssembly>
</dependency>
</assembly>
El archivo console.pro, que est ubicado en la carpeta console de la carpeta pfc, contiene
por ejemplo al predicado write. Esto se puede verificar visualizando el archivo consola.pro,
desde el Visual Prolog.
Ahora, continuando con el desarrollo del programa Hola Mundo, se procede a escribir el
cdigo respectivo en el archivo main.pro, ya que es el archivo que contiene el cdigo fuente
principal de la aplicacin cuando se trabaja en modo consola. Entonces se hace doble click sobre
el archivo main.pro con lo que se muestra el siguiente cdigo:
implement main
open core
clauses
run() :succeed. % place your own code here
end implement main
Pgina 7
goal
console::runUtf8(main::run).
Ahora se procede a completar el cdigo por defecto tal como se muestra a continuacin:
implement main
open core
clauses
run() :console::write("Hola Mundo..."),
_=console::readChar().
end implement main
goal
Otra versin del programa Hola Mundo, que es la que usaremos de ahora en adelante en el
presente manual, es la que se muestra a continuacin:
implement main
open core,console
clauses
run() :write("Hola Mundo..."),
_=readChar().
end implement main
goal
Lo que sucede es que se ha incluido la carpeta console de la carpeta pfc ya explicada

anteriormente, con lo que ya no es necesario estar escribiendo la palabra console cuando se use
el predicado write o el predicado readChar. Ahora, para ejecutar la aplicacin y observar los
resultados, se hace click en la opcin Build, luego en la subopcin Build, con lo que si no
existen inconvenientes, Visual Prolog enviar el mensaje: Project has been built y luego se
selecciona la subopcin Execute ubicada en la opcin del men principal: Build, con lo
que se mostrar el resultado de la ejecucin de la aplicacin Hola Mundo, tal como se muestra
a continuacin:
Pgina 8
Figura 05: Pantalla visualizacin de resultado de la ejecucin del proyecto del ejercicio 01
Luego para terminar la ejecucin de la aplicacin se presiona la tecla Enter.
Ejercicio 02: Desarrollar una aplicacin que solicite un nombre y le enve un saludo incluido el
nombre ingresado.
Solucin:
Se muestra el cdigo de main.pro:
implement main
open core, console
clauses
run() :write("Ingrese su nombre por favor:"),
User=readLine(),
write("Bienvenido ",User," presiona por favor una tecla para continuar..."),
_=readChar().
end implement main
goal
Pgina 9
Ejercicio 03: Desarrollar una aplicacin que muestre la capital de un Departamento.

Solucin:
En la solucin del presente programa se utilizar la variable annima o blanca o no ligada, que
se representa con el guion bajo o underscore (_) el cul se utiliza para ignorar el valor que se
capture con el predicado readChar(), ya que para el caso presente no es de inters. Asimismo se
utiliza el predicado corte (!) el que evitar que el motor de inferencia de Visual Prolog ejecute la
otra implementacin del predicado run ya que ste se debera ejecutar cuando la primera
implementacin de run falle.
implement main
open core, console
class facts
capital : (string,string).
clauses
capital("La Libertad","Trujillo").
run() :write("A continuacin mostrar la capital de un Departamento, por favor presione una tecla para continuar..."),
_=readChar(),
capital(X,Y),
write("La capital de ",X," es: ",Y),
_=readChar(),
!.
run().
end implement main
goal
Pgina 10
Ejercicio 04: Desarrollar una aplicacin que muestre la capital de un Departamento el que ser
ingresada por teclado, y en el caso que no se conozca la capital, se debe enviar un mensaje al
usuario.
Solucin:
implement main
open core,console
class facts
clauses
capital("Lambayeque","Chiclayo").
capital("Lima","Lima").
capital("Piura","Piura").
run() :write("A continuacin mostrar cul es la capital de un Departamento, ingrese el nombre del Departamento:"),
Dpto=readLine(),
capital(Dpto,Capi),
write("La capital de ",Dpto," es: ",Capi),
_=readChar(),
!.
run():write("Lo siento no conozco la capital para el Departamento ingresado..."),
_=readChar().
end implement main
goal
Ejercicio 05: Desarrollar una aplicacin que muestre la capital de un Departamento el que ser
ingresada por teclado, y en el caso que no se conozca la capital, se debe enviar un mensaje al
usuario conteniendo el nombre del Departamento.
Pgina 11
Solucin:
implement main
open core,console
class predicates
busca_capital : (string).
class facts
clauses
run() :write("A continuacin mostrar cul es la capital de un Departamento, ingrese el nombre del Departamento:"),
Dpto=readLine(),
busca_capital(Dpto).
busca_capital(Dpto):capital(Dpto,Capi),
_=readChar(),
!.
busca_capital(Dpto):write("Lo siento no conozco la capital para el Departamento ",Dpto),
_=readChar().
end implement main
goal
Pgina 12
SESIN 02
El predicado fail conocido como el predicado opuesto al predicado corte !, fuerza a que
Visual Prolog ejecute el backtracking, es decir, hace que Visual Prolog ejecute todas las
implementaciones de una regla de conocimiento. A continuacin se muestra un ejemplo en el
ejercicio 06.
Ejercicio 06: Desarrollar una aplicacin que muestre las capitales de un nmero determinado de
pases, mostrando un mensaje de culminacin cuando ya no encuentre ms pases en la Base de
Conocimiento.
Solucin:
Se muestra el cdigo en main.pro:
implement main
open core,console
class facts
clauses
capital("Per","Lima").
capital("Chile","Santiago de Chile").
capital("Bolivia","La Paz").
capital("Ecuador","Quito").
run() :write("A continuacin mostrar las capitales de los pases registrados en la Base de Conocimiento"),
nl,
capital(P,C),
write("La capital de ",P," es ",C),
nl,
fail.
run():write("Es todo lo que tengo registrado en la Base de Conocimiento"),
_=readChar().
end implement main
Pgina 13
goal
El predicado nondeterm modifica la naturaleza determinstica que por defecto posee una regla
de conocimiento, es decir, cuando se declara una regla de conocimiento, siempre Visual Prolog,
espera que se construya por lo menos dos implementaciones de la regla de conocimiento ya que si
una de ellas falla se ejecuta la siguiente implementacin de la regla. Entonces cuando no se desea
construir otra implementacin de una regla de conocimiento, se utiliza el predicado nondeterm
cuando se declara la regla. Esto se muestra en el siguiente ejemplo.
Ejercicio 07: Desarrollar una aplicacin que muestre las capitales de un nmero determinado de
ciudades, mostrando un mensaje de culminacin cuando ya no encuentre ms ciudades en la Base
de Conocimiento.
Solucin:
implement main
open core,console
class predicates
busca_capital : () nondeterm.
class facts
clauses
Pgina 14
busca_capital():capital(Dpto,Capi),
nl.
run() :busca_capital(),
fail.
run():write("Eso es todo lo que tengo en la Base de Conocimiento"),
_=readChar().
end implement main
goal
El predicado anyflow, se utiliza cuando se va en una regla de conocimiento no vas a existir

restricciones en los tipos de argumentos de la misma, es decir, los argumentos pueden estar o no
ligados a un valor por defecto o por algn asignacin particular. Esto se muestra en el siguiente
ejemplo.
Ejercicio 08: Desarrollar una aplicacin que muestre los lugares que le agrada visitar a un esposo
siempre y cuando estos lugares sean del agrado de su esposa.
Solucin:
implement main
open core,console
class predicates
le_gusta_al_esposo : (string,string) nondeterm anyflow.
class facts
le_gusta_a_la_esposa : (string,string).
clauses
le_gusta_a_la_esposa("Lucy","Cine").
le_gusta_a_la_esposa("Lucy","Discoteca").
le_gusta_a_la_esposa("Isabel","Playas").
le_gusta_al_esposo(Esposo,Lugar):le_gusta_a_la_esposa(Esposa,Lugar),
Pgina 15
nl.
run() :le_gusta_al_esposo("Luis",Lugar),
write("A Luis le gusta ",Lugar),
fail.
run():nl,
write("Eso es todo lo que le gusta al esposo"),
_=readChar().
end implement main
goal
Con respecto al ejercicio 08, debe aclararse que el predicado anyflow debe utilizarse con
mucho cuidado, claro esto depende de las condiciones del problema, ya que podra mostrar en los
resultados alguna incoherencia como la mostrada en el ejercicio en mencin.
Uno de los tipos de datos que ofrece Visual Prolog, es string_list, el cual se caracteriza por
permitir el manejo de los clsicos arreglos, en este caso de caracteres. A continuacin el siguiente
Ejercicio 09 muestra la aplicacin de este tipo de dato.
Ejercicio 09:
implement main
open core,console
class facts
soyunstringlist : (string_list).
clauses
soyunstringlist(["algo01","algo02"]).
soyunstringlist(["algo03"]).
run() :soyunstringlist(TipoString),
write(TipoString),
nl,
fail.
run():_=readChar().
end implement main
goal
Pgina 16
As tambin Visual Prolog, ofrece otro tipo de datos que es unsigned, el cual se caracteriza por
solamente permitir datos de tipo entero positivo (incluyendo el cero). A continuacin el Ejercicio
10 muestra la aplicacin de este tipo de dato.
Ejercicio 10:
implement main
open core,console
class facts
soyununsigned : (unsigned).
clauses
soyununsigned(1).
soyununsigned(0).
run() :soyununsigned(TipoUnsigned),
write(TipoUnsigned),
nl,
fail.
run():_=readChar().
end implement main
goal
As tambin se puede utilizar otro tipo de dato que ofrece Visual Prolog, como es
unsigned_list, el cual se usa igual que string_list, pero con nmeros enteros positivos
incluyendo el cero.
Por otro lado Visual Prolog ofrece los otros tipos de datos clsicos que otros lenguajes ofrecen
como integer, real, char, etc., para cada uno de los cuales permite implementar tambin listas, es
decir por ejemplo: integer_list, real_list, char_list, etc.
Visual Prolog ofrece la conversin de tipos de datos entre s, por ejemplo para convertir el proceso
de convertir el string 20 a nmero se observa el Ejercicio 11 y para convertir de nmero a string
se observa el Ejercicio 12.
Ejercicio 11:
implement main
open core,console
clauses
run() :-
Pgina 17
ValorString="20",
ValorNumero= toTerm(ValorString) + 0,
write("En nmero es:", ValorNumero),
fail.
run():_=readChar().
end implement main
goal
Ejercicio 12:
implement main
open core,console
clauses
run() :ValorNumero=20,
ValorString= toString(ValorNumero),
write("En String es:", ValorString),
fail.
run():_=readChar().
end implement main
goal
Visual Prolog, ofrece tambin predicados para el manejo de cadenas, tal como lo muestra el
Ejercicio 13.
Ejercicio 13:
implement main
open core,console
clauses
run() :-
Pgina 18
Cadena="Luis Tenorio",
PartedeCadena= string::subChar(Cadena,5),
write("El caracter estrado es:", PartedeCadena),
fail.
run():_=readChar().
end implement main
goal
Visual Prolog, dentro de la estructura de un programa permite el uso de la seccin: domains, esta
seccin permite declarar los tipos de argumentos que se utilizarn en un hecho o regla de
conocimiento. El Ejercicio 14 muestra el uso de domains.
Ejercicio 14:
implement main
open core,console
domains
nombre = string.
class facts
persona : (nombre).
clauses
persona("Luis").
persona("Isabel").
run() :persona(Nombre),
write("Personas registrada:", Nombre),
nl,
fail.
run():_=readChar().
end implement main
goal
Un objeto dominio, puede ser declarado para que asuma ms de un valor en momentos distintos.
El Ejercicio 15 muestra lo mencionado:
Pgina 19
Ejercicio 15:
implement main
open core,console
domains
cargo = operativo;administrativo;gerencial.
class facts
labora : (string,cargo).
clauses
labora("Jorge",operativo).
labora("Manuel",administrativo).
labora("Carla",gerencial).
run() :labora(Colaborador,Cargo),
write(Colaborador," ocupa un cargo ",Cargo),
nl,
fail.
run():_=readChar().
end implement main
goal
Pgina 20
SESIN 03
En Visual Prolog, es posible asignar varios tipos de dominios a un argumento de un predicado.
Esto se observa en el Ejercicio 16.
Ejercicio 16:
implement main
open core,console
domains
datos = nombre(string) ; apellidos(string) ; edad(integer).
class facts
persona : (datos).
clauses
persona(nombre("Luis")).
persona(apellidos("Tenorio")).
persona(edad(83)).
run() :persona(nombre(N)),
persona(apellidos(A)),
persona(edad(E)),
write("Los datos son:"),
nl,
write("Nombre: ",N),
nl,
write("Apelliidos: ",A),
nl,
write("Edad: ",E),
nl,
fail.
run():write("Es todo lo que puedo mostrar..."),
_=readChar().
end implement main
goal
En Visual Prolog, es posible asignar a un predicado varios tipos de dominio asignado a un solo
objeto de tipo dominio. Esto se observa en el Ejercicio 17.
Ejercicio 17:
implement main
open core,console
Pgina 21
domains
datos = nombre(string) ; apellidos(string) ; edad(integer).
class facts
persona : (datos,datos,datos).
clauses
persona(nombre("Luis"),nombre("Rafael"),nombre("Alfredo")).
persona(apellidos("Tenorio"),apellidos("Lozada"),apellidos("Cabrera")).
persona(edad(83),edad(90),edad(45)).
run() :persona(nombre(N),nombre(M),nombre(O)),
persona(apellidos(A),apellidos(B),apellidos(C)),
persona(edad(E),edad(F),edad(G)),
write("Los NOMBRES son:",N," ",M," ",O),nl,
write("Los APELIDOS son:",A," ",B," ",C),nl,
write("Las EDADES son:",E," ",F," ",G),nl,
fail.
run():write("Es todo lo que puedo mostrar..."),
_=readChar().
end implement main
goal
Como se haba referenciado en el Ejercicio 11, Visual Prolog ofrece la conversin de tipos de
datos entre s, por ejemplo para convertir el proceso de convertir el string 20 a nmero entero se
observa el Ejercicio 18. Debe hacerse mencin que en esta oportunidad se utilizar otro predicado
llamado hasDomain, el que permitir hacer la conversin mencionada anteriormente.
Ejercicio 18:
implement main
open core,console
clauses
run() :ValorString="20",
hasDomain(integer,ValorNumero),
ValorNumero= toTerm(ValorString),
write("En nmero original ",ValorNumero," incrementado en 40 es: ", ValorNumero+40),
Pgina 22
fail.
run():_=readChar().
end implement main
goal
Otro uso del predicado hasDomain es cuando se desea leer un dato por teclado tal como lo
muestra el Ejercicio 19.
Ejercicio 19:
implement main
open core,console
clauses
run() :hasDomain(real,ValorNumero),
write("Ingrese un valor:"),
ValorNumero= read(),
write("En nmero original ",ValorNumero," incrementado en 40.5 es: ", ValorNumero+40.5),
_=readChar(),
fail.
run():_=readChar().
end implement main
goal
Visual Prolog ofrece un predicado llamado readString, el que permite leer un nmero limitado y
obligatorio de caracteres por teclado, por ejemplo, si se quiere ingresar obligatoriamente una
cantidad de 8 caracteres, se escribira readString(8), por lo que en el caso de ingresar una
cantidad menor que la dimension indicada por mas que se presione la tecla enter, la aplicacin
esperar a que se complete la cantidad de caracteres indicados en readString, y en el caso de
ingresar una cantidad mayor de caracteres, el siguiente caracter que est fuera de la dimension
ser tomado como el haber presionado la tecla enter. Esto se muestra por ejemplo en el Ejercicio
20. Es necesario el uso del predicado stdio.
Ejercicio 20:
Pgina 23
implement main
open core,console
clauses
run() :write("Ingrese una cadena no mayor de 8 caracteres :"),
Cadena= stdio::readString(8),
write("La cadena finalmente qued as ",Cadena),
_=readChar(),
fail.
run():_=readChar().
end implement main
goal
En Visual Prolog, las condicionales tambin estn presentes, como el caso de if then end if, el
cul se comporta de la misma manera que en los dems lenguajes de programacin. Una
aplicacin de la condicional if then end if, se muestra en el Ejercicio 21.
Ejercicio 21:
implement main
open core,console
class predicates
evalua : () nondeterm anyflow.
clauses
evalua():write("Ingrese un nmero menor a 20:"),
hasDomain(integer,Numero),
Numero=read(),
if(Numero<20) then
write("Correcto")
end if.
run() :evalua(),
_=readChar(),
fail.
run():-
Pgina 24
_=readChar().
end implement main
goal
Otra condicional tambin presente en Visual Prolog es: if then else - end if, la que tambin se
comporta como en los otros lenguajes de programacin. Una aplicacin de esta condicional se
muestra en el Ejercicio 22.
Ejercicio 22:
implement main
open core,console
class predicates
clauses
Numero=read(),
if(Numero<20) then
write("Correcto")
else
write("Incorrecto")
end if.
run() :evalua(),
_=readChar(),
fail.
run():_=readChar().
end implement main
goal
Pgina 25
Otra condicional tambin presente en Visual Prolog es: if then elseif then - else - end if, la
que tambin se comporta como en los otros lenguajes de programacin. Una aplicacin de esta
condicional se muestra en el Ejercicio 23.
Ejercicio 23:
implement main
open core,console
class predicates
clauses
Numero=read(),
if(Numero<20) then
write("Correcto")
elseif (Numero=20) then
write("Casi Correcto porque es igual a 20")
else
write("Incorrecto porque es mayor a 20")
end if.
run() :evalua(),
_=readChar(),
fail.
run():_=readChar().
end implement main
goal
Pgina 26
SESIN 04
En Visual Prolog se usa tambin el predicado repeat, el que permite repetir la ejecucin de una
determinada parte de una aplicacin mientras se cumpla una condicin, y para indicar el final de la
parte del cdigo que se repetir se utiliza el predicado corte (!). En el Ejercicio 24 se observa la
aplicacin de este predicado, pero debe incluirse la librera std.
Ejercicio 24:
implement main
open core,console,std
class predicates
bucle: () nondeterm.
clauses
bucle():write("Esta parte est fuera de lo que se va a repetir..."),
nl,
repeat,
write("Esta parte ya est dentro de lo que se va a repetir..."),
nl,
write("Si desea detener la repeticin escriba la letra s..."),
Para=readLine(),
Para="s",
!,
write("Esta parte ya est fuera de lo que se va a repetir...").
run() :bucle(),
fail.
run():_=readChar().
end implement main
goal
Pgina 27
El predicado procedure, se utiliza en Visual Prolog cuando una regla de conocimiento se quiere
tartar como un procedimiento por lo que no ser necesario definer otra alternative de cdigo para
la regla de conocimiento, es decir se trata como si le regla de conocimiento fuese nondeterm. En
el Ejercicio 25 se observa la aplicacin del predicado procedure.
Ejercicio 25:
implement main
open core,console
class predicates
procedimiento : (integer) procedure.
clauses
procedimiento(Numero):write("El nmero ingresado fu ",Numero),
nl.
run() :nl,
write("Ingrese un nmero:"),
Numero=read(),
procedimiento(Numero),
_=readChar(),
fail.
run():_=readChar().
end implement main
goal
El predicado multi, se utiliza cuando se quiere definer a una regla de conocimiento para que
acepte varias implementaciones de ella pero como si el predicado fuese determinstico, es decir el
final de cada implementacin de la regla de conocimiento de tipo multi no se necesita poner el
predicado corte (!) . El Ejercicio 26 muestra la aplicacin del predicado multi.
Ejercicio 26:
Pgina 28
implement main
open core,console
class predicates
procedimiento : (integer) multi.
clauses
procedimiento(Numero):Numero<0,
write("El nmero ingresado fu ",Numero," y es menor que cero..."),
nl.
procedimiento(Numero):Numero>0,
write("El nmero ingresado fu ",Numero," y es mayor que cero..."),
nl.
procedimiento(Numero):write("El nmero ingresado fu ",Numero),
nl.
run() :nl,
Numero=read(),
_=readChar(),
fail.
run().
end implement main
goal
El predicado determ, permite declarar una regla de conocimiento la que solo deber
implementarse una sola vez, esto siempre y cuando la regla de conocimiento que la contiene (es
decir a la regla del tipo determ) contenga el predicado fail lo que, por ejemplo para la regla run()
del Ejercicio 27 ejecute automticamente el backtracking. Esto se observa en el Ejercicio 27.
Ejercicio 27:
implement main
open core,console
class predicates
procedimiento : (integer) determ.
Pgina 29
clauses
_=readChar(),
nl.
run() :nl,
Numero=read(),
_=readChar(),
fail.
run().
end implement main
goal
Otro uso del predicado nondeterm es para cuando se define mas de una implementacn para una
regla de conocimiento y se puede presentar la situacn de no encontrar solucin en las
implementaciones de la regla cuando se llama a dicha regla de conocimiento, con lo que no se
generar error. El Ejercicio 28 muestra la aplicacin del predicado nondeterm que no generar
error al momento del proceso de ejecucin si se ingresa el nmero cero (0) a pesar que no se ha
comtemplado una implementacin para tal situacin en la regla de conocimiento procedimiento,
esto gracias a que el predicado en mencin es del tipo nondeterm.
Ejercicio 28:
implement main
open core,console
class predicates
procedimiento : (integer) nondeterm.
clauses
Pgina 30
_=readChar(),
nl.
procedimiento(Numero):Numero>0,
write("El nmero ingresado fu ",Numero," y es mayor que cero..."),
_=readChar(),
nl.
run() :nl,
Numero=read(),
_=readChar(),
fail.
run():_=readLine().
end implement main
goal
MODO GUI
SESIN 05
El otro modo para el desarrollo de aplicaciones en Visual Prolog, es el modo GUI, es decir
modalidad de interfaz grfica. Para esto cuando se crea un nuevo proyecto ya no se elige Console
como el tipo de proyecto (Project Kind), ahora se elige MDI (Multi Document Interface), como
pimer paso para la creacin de un proyecto tip GUI.
Luego de escribir los datos necesarios, como por ejemplo, el nombre del proyecto, en este caso el
Ejercicio 39 (Figura 05) el cul se llamar Hola Mundo GUI, Visual Prolog compilar
Pgina 31
automticamente el proyecto, y luego de ejecutar el mismo, se mostrar una pantalla inicial tal
como se muestra a continuacin:
Figura 06: Pantalla inicial de ejecucin del Proyecto Hola Mundo GUI.
Luego, al abrir el archivo main.pro, se observa el cdigo que crea la interfaz mostrada en la
Figura 05, tal como se muestra a continuacin:
implement main
open core
clauses
run() :TaskWindow = taskWindow::new(),
TaskWindow:show().
end implement main
goal
mainExe::run(main::run).
Asimismo dentro de la carpeta TaskWindow, se genera un archivo llamado TaskWindow.cl en el

que se observa el
constructor new el cual a su vez se implementa en el archive
Pgina 32
TaskWindow.pro para permitir la creacin de la interfaz mostrada en la figura 05. Esto se observa
a continuacin:
class taskWindow : taskWindow
TaskWindow.cl
constructors
new : ().
end class taskWindow
TaskWindow.pro (se muestra el cdigo de la implementacin de new)

clauses
new() :applicationWindow::new(),
generatedInitialize().
Para poder personalizar el men de opciones que por defecto considera Visual Prolog en la
aplicacin creada, hacemos doble click sobre el archive TaskMenu.mnu (tambin ubicado en la
carpeta TaskWindow), con lo que se mostrar la siguiente interfaz (Figura 07):
Pgina 33
Figura 07: Interfaz de TaskMenu.mnu.

Luego, al abrir, en la interfaz mostrada en la Figura 07, la opcin &File se observan un
conjunto de opciones, que por el momento nos centraremos en la subopcin &New\tF7 la cul
se habilitar quitando el check de la opcin Disabled, para finalmente grabar los cambios y
cerrar la interfaz de TaskMenu.mnu.
Ahora, se hace doble click, en el archivo TaskMenu.win para poder empezar a crear el cdigo
asociado a la opcin &New\tF7, tal como se muestra en la figura 08:
Pgina 34
Figura 08: Interfaz de TaskWindow.win para generar cdigo.

Luego, se hace doble click sobre id_file_new, con lo que se abrir el archivo
TaskWindow.pro en donde se escribir el cdigo para mostrar el mensaje Hola Mundo, esto
se
muestra
continuacin
(no
olvidar
incluir
la
librera
stdio,
al
final
open core, vpiDomains, stdio):

predicates
onFileNew : window::menuItemListener.
clauses
onFileNew(_Source, _MenuTag):write("Hola Mundo !!!").
Luego al ejecutar el proyecto, se mostrar el siguiente resultado, mostrado en la Figura 09:
Pgina 35
de
Figura 09: Resultado de le ejecucin del Proyecto Hola Mundo GUI.
Pgina 36

Manual Visual Prolog 7.5 - I Parte

Загружено:

Сведения о документе

Исходное описание:

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

Manual Visual Prolog 7.5 - I Parte

Загружено:

Авторское право:

Доступные форматы

Manual Visual Prolog 7.

Julio Luis Tenorio Cabrera.

Tenorio Cabrera Julio Luis