Programación Exploratoria - Predicados Predefinidos en ... · Programación Exploratoria -...
Transcript of Programación Exploratoria - Predicados Predefinidos en ... · Programación Exploratoria -...
Programación Exploratoria
- Predicados Predefinidos en Prolog -
Universidad Nacional del Centro de la Provincia de Buenos AiresFacultad 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
• Construcción de Términos: functor, arg
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
Construcción de Predicados
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).
Construcción de Predicados
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
Construcción de Predicados
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
Análisis de Términos
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
Igualdad
Comparació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úmeros
Atom
• 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'.
Verificación de tipos
Atom ‐ Ejemplos
?‐ atom(abc).
Yes
?‐ atom(‘Programación Exploratoria’).
Yes
?‐ Var=abc, atom(Var).
Yes, Var=abc
El 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
Verificación de tipos
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 Entera
Functor
• 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
Construcción de términos
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)
Construcción de términos