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

Programación Exploratoria

- Predicados Predefinidos en Prolog -

Universidad Nacional del Centro de la Provincia de Buenos AiresFacultad de Ciencias Exactas