Programación Exploratoria
- Predicados Predefinidos
en Prolog
-Universidad Nacional del Centro de la Provincia de Buenos Aires Facultad de Ciencias Exactas
Tipos de Predicados
•
Construcción
de
Predicados
o
Consultas
:
and,
or,
call
•
Análisis
Términos
:
name
•
Igualdad
:
=,
==,
\=,\==
•
Comparación
de
números:
=,
\=,
<,
=<,
>,
>=
•
Verificación
de
tipos
de
términos
:
atom,
integer,
atomic,
var,
nonvar,
float,
compound
•
Aritmética
Entera:
+,
‐
,
*,
/,
mod,
is
Base
de
datos
de
ejemplo
Base de datos del TP1, Ej 1.
vuelo(buenos_aires, cordoba).
vuelo(buenos_aires, santa_rosa).
vuelo(buenos_aires, san_juan).
vuelo(cordoba, santa_fe).
vuelo(cordoba, tucuman).
vuelo(cordoba, santa_rosa).
vuelo(san_juan, tucuman).
vuelo(san_juan, mendoza).
vuelo(san_juan, neuquen).
vuelo(mendoza, cordoba).
vuelo(santa_rosa, san_juan).
And
•
Term1
,
Term2
(and):
Es
verdadero
si
Term1
es
verdadero
y
Term2
es
verdadero
?
‐
vuelo(buenos_aires,
cordoba),
vuelo(cordoba,
santa_fe).
Yes
?
‐
vuelo(buenos_aires,
cordoba),
vuelo(cordoba,
posadas).
No
Or
•
Term1;
Term2
(or):
Es
verdadero
si
Term1
es
verdadero
o
si
Term2
es
verdadero
?‐ vuelo(buenos_aires, cordoba); vuelo(cordoba, posadas).
Yes
?‐ vuelo(buenos_aires, rio_de_janeiro); vuelo(buenos_aires, sao_pablo).
No
En la definición de reglas, el OR puede reemplazarse por múltiples definiciones ruta(X,Y):‐vuelo(X,Y). ruta(X,Y):‐ vuelo(X,Y); (ruta(X,Z),
vuelo(Z,Y)).
ruta(X,Y):‐ruta(X,Z), vuelo(Z,Y).
Call
•
call(+Term):
es
verdadero
si
y
solo
si
Term
representa
un
objetivo
el
cual
es
verdadero
?
‐
call(
vuelo(buenos_aires,
cordoba)
).
Yes
?
‐
call(
vuelo(cordoba,
posadas)
).
No
Name
•
name(+Term,?List):
Relaciona
un
átomo
con
su
lista
de
caracteres
(código
ASCII).
?
‐
name(apple,
X).
Yes
X=[97,112,112,108,101]
?
‐
name(apple,
[97,
112,
112,
108,
101]).
Yes
Igualdad:
=,
==,
\=,
\==
En
general,
•‘=‘
se
utiliza
para
comparar
y
asignar
una
variable
•‘=‘
considera
a
una
variable
libre
como
igual
a
cualquier
término,
dado
que
siempre
puede
unificar
(matching)
con
dicho
término.
•‘==‘
se
utiliza
sólo
para
comparar,
es
más
restrictivo
•‘==’
sólo
considera
a
una
variable
libre
igual
a
otra
variable
libre
•
Si
X==Y,
entonces
X=Y
(pero
no
al
revés)
•
‘=’ es
el
opuesto
de
‘\=’,
y
‘==’ el
opuesto
de
‘\==’
?Term1 = ?Term2. (COMPARA Y ASIGNA) ?Term1 \= ?Term2. (COMPARA Y ASIGNA)
?Term1 == ?Term2 (más restrictivo que “=“) (SOLO PARA COMPARAR) ?Term1 \== ?Term2 (más restrictivo que “\=“) (SOLO PARA COMPARAR) Igualdad
Igualdad
‐
Ejemplos
?
‐
X
=
Y.
Yes
?
‐
X
=
2
Yes
?
‐
X
==
Y.
Yes
?
‐
X
==
2
No
?
‐
X=Y
,
X==Y.
Yes
?
‐
X\=Y.
No
?
‐
X\=2.
No
?
‐
X\==Y.
No
?
‐
X\==2.
Yes
IgualdadComparación de números: =, \=, <, =<, >, >=
•
=
:
Igual
•
\=
:
Distinto
•
<
:
Menor
•
=<
:
Menor
o
igual
•
>
:
Mayor
•
>=
:
Mayor
o
igual
?
‐
1=1.
Yes
?
‐
1=2.
No
?
‐
1<2.
Yes
?
‐
1>1.
No
?
‐
1>=1.
Yes
?
‐
1>1;1=1
Yes
Comparación de númerosAtom
•
atom(+Term):
el
predicado
atom
tendrá éxito
si
el
argumento
es
un
átomo
o
una
variable
instanciada
previamente
con
un
átomo
Átomos
:
Son
palabras
que
no
requieren
de
una
sintaxis
especial.
Sin
embargo,
los
átomos
que
contienen
espacios
o
algunos
otros
caracteres
especiales
deben
estar
rodeados
por
comillas
simples
(o
los
que
empiezan
con
letra
capital
para
distinguirlos
de
las
variables).
•
La
lista
vacía
también
es
un
átomo.
•
Ejemplos
de
átomos:
x,
blue,
'Taco',
and
'some
atom'.
Atom
‐
Ejemplos
?‐ atom(abc). Yes ?‐ atom(‘Programación Exploratoria’). Yes ?‐ Var=abc, atom(Var). Yes, Var=abcEl predicado atom fallará si el argumento es
una variable sin instanciar, un número o un
objeto estructurado (incluyendo una lista) Ejemplo: ?‐ atom(X). No ?‐ atom(13). No ?‐ atom([1,2,3|[X]]). No ?‐ atom([]). Yes Verificación de tipos
Integer
•
integer(+Term):
integer
tendrá éxito
si
el
argumento
es
un
entero
o
una
variable
previamente
instanciada
con
un
entero
Integer fallará si el argumento es una variable
sin instanciar, un átomo, un número flotante o
un objeto estructurado ?‐ integer(Var). No ?‐ integer(abc). No ?‐ integer(1.3). No ?‐ integer([a,b,c]). No ?‐ integer(1). Yes ?‐ Var=2, integer(Var). Yes Verificación de tipos
Atomic
•
atomic(+Term):
tendrá éxito
si
el
argumento
es
un
integer,
un
átomo
o
una
variable
previamente
instanciada
con
un
átomo
o
un
integer.
atomic(X) :‐ integer(X).atomic(X) :‐ atom(X).
atomic fallará si el argumento es una variable sin
instanciar o un objeto estructurado ?‐atomic(Var). No ?‐atomic(a(x,y,z)). No ?‐atomic([a,b,c]). No ?‐atomic([]). Yes ?‐ atomic(abc). Yes ?‐ atomic(1). Yes ?‐ Var=abc, atomic(Var). Yes ?‐ Var=1, atomic(Var). Yes Verificación de tipos
Float
•
float(+Term):
float
tendrá éxito
si
el
argumento
es
un
flotante
(con
punto)
o
una
variable
previamente
instanciada
con
un
flotante
Float fallará si el argumento es una variable sin
instanciar, un átomo o un objeto estructurado: ?‐float(Var). No ?‐float(abc). No ?‐float(a(b,c)). No ?‐float([a,b,c]). No ?‐float(1.3). Yes ?‐float(0). No Verificación de tipos
Var
•
var(+Term):
Es
verdad
cuando
+Term es
una
variable
sin
instanciar.
Una
variable
sin
instanciar
puede
representar
parte
de
una
estructura
que
aún
no
ha
sido
instanciada.
Var fallará si el argumento es una variable
instanciada, un átomo, un número o un objeto
estructurado ?‐ var(abc). No ?‐ var(123). No ?‐ var(a(X,Y,Z)). No ?‐ var([X,Y,Z]). No
?‐X=Y, Y=23, var(X). No ?‐var(X). Yes ?‐Var1=Var2, var(Var1). Yes Verificación de tipos
Nonvar
•
nonvar(+Term):
Tiene
éxito
si
Term NO
es
una
variable
libre.
Es
el
opuesto
del
predicado
var(+Term).
Nonvar fallará si el argumento es una
variable sin instanciar ?‐nonvar(Var). No ?‐nonvar(abc). Yes ?‐nonvar(1). Yes ?‐nonvar(a(x,y,z)). Yes ?‐nonvar([X,Y,Z]). Yes
Si una variable es previamente instanciada también se tiene éxito: ?‐Var=abc, nonvar(Var).
Yes
Compound
•
compound(+Term):
tendrá éxito
si
el
argumento
es
una
estructura
o
una
lista
compound fallará si el argumento es una
variable sin instanciar, un átomo o un número: Ejemplos: ?‐ compound(Var). no ?‐ compound(abc). no ?‐ compound(1). no ?‐ compound(a(X)). Yes ?‐ compound([a, B]). Yes Verificación de tipos
Aritmética
Entera:
+,
‐
,
*,
/,
mod,
is
•
+
:
Suma
•
‐
:
Resta
•
*
:
Multiplicación
•
/
:
División
•
mod
:
Módulo
•
is
:
Comparación/Asignación
aritmética
?
‐
X
=
1+2
Yes,
X=+(1,2)
?
‐
X
is
1+2.
Yes,
X=3
?
‐
X
=
3
mod
2
Yes,
X=mod(3,2)
?
‐
X
is
3
mod
2
Yes,
X=1
Aritmética EnteraFunctor
•
functor(T,F,N):
T
es
una
estructura
con
nombre
o
functor
F
y
aridad
(cantidad
de
argumentos)
N.
Este
predicado
permite
extraer
el
functor
y
la
aridad
de
un
término
cualquiera.
Pero,
al
ser
reversible,
también
permite
construir
nuevos
términos
a
partir
del
functor
y
la
aridad
deseada.
•
Los
modos
de
uso
son
(
+
instanciado,
‐
libre):
functor(+Termino,+Functor,+Aridad).
functor(+Termino,
‐
Functor,
‐
Aridad).
functor(
‐
Termino,+Functor,+Aridad).
?‐ functor(vuelo(buenos_aires, cordoba), vuelo, 2)
Yes
?‐ functor(vuelo(buenos_aires, cordoba), vuelo, 4) No
Functor(T,F,N)
‐
Ejemplos
Si T está instanciado…
?‐ functor(vuelo(bsas,cordoba), X, Y). Yes, X=vuelo, Y=2
?‐ functor(cordoba, X, Y). Yes, X=cordoba, Y=0 ?‐ functor([1,2,3], X, Y).
Yes, X=[|], Y=2 (cabeza y cola)
Si T no está instanciado… ?‐ functor(X, vuelo, 2) Yes, X=vuelo(_,_) ?‐ functor(X, vuelo, 0) Yes, X=vuelo Construcción de términos
Arg
•
arg(I,T,A).
Permite
asignar
argumentos
a
términos
(T)
construidos
con
functor.
Para
ello,
se
indica
el
número
de
índice
(I)
del
argumento
(A)
deseado,
empezando
a
numerar
por
el
1
de
izquierda
a
derecha.
•
Los
modos
de
uso
es
(
+
instanciado,
‐
libre):
arg(+Indice,+Termino,+Argumento).
arg(+Indice,+Termino,
‐
Argumento).
arg(+Indice,
‐
Termino,+Argumento).
arg(
‐
Indice,+Termino,+Argumento).
?‐ arg(2, vuelo(bsas, cordoba), X) Yes, X=cordoba
?‐ arg(X, vuelo(bsas, cordoba), cordoba) Yes, X=2
?‐ functor(X, vuelo, 2), arg(1, X, bsas), arg(2, X, cordoba) Yes, X=vuelo(bsas, cordoba)
Programación Exploratoria
- Predicados Predefinidos
en Prolog
-Universidad Nacional del Centro de la Provincia de Buenos Aires Facultad de Ciencias Exactas
