Prolog EN -- Laboratory 2 -- 2006-2007 -- info.uvt.ro

• Prolog EN -- 2006-2007 -- info.uvt.ro
  • Prolog EN -- Laboratory 1 -- 2006-2007 -- info.uvt.ro
  • Prolog EN -- Laboratory 2 -- 2006-2007 -- info.uvt.ro
  • Prolog EN -- Laboratory 3 -- 2006-2007 -- info.uvt.ro
  • Prolog EN -- Laboratory 4 -- 2006-2007 -- info.uvt.ro
  • Prolog EN -- Test -- 2006-2007 -- info.uvt.ro

The contents of this section is structured base on the GNU Prolog Manual.

Directives

consult

The consult directive is used to load a program from a source file.

Syntax:

consult(user). %=> Allows us to enter the source code by hand ending by pressing Control+D
consult(<file-name>). %=> Tries to load the given file in the current folder. (The file must have the .pl extension.)

If in the source code appears a predicate (either a fact or a rule) that was already defined, the previous definition is discarded.

Example:

consult(user).
  e(1).
  e(2).
  <<Control+D>>
%=> Loads the facts for the predicate e.

consult(ex1). %=> Loads all the predicates (facts and rules) from the file 'ex1.pl' in the current folder.

load

The load directive is used to load a compiled file. It behaves just like consult. The source files are compiled by using gplc.

listing

The listing directive is used to list all or a selection of the loaded predicates (facts and rules).

Syntax:

listing. %=> Lists all the known predicates.
listing(<predicate>). %=> Lists all the predicates with the given functor.

Example:

listing.
%=>
%  e(1).
%  e(2).
%  f(a).
%  f(b).

listing(f).
%=>
%  f(a).
%  f(b).

halt

The halt directive is used to exit from the interpreter.

Syntax and example:

halt.

Control structures

true, fail, and !

These are built-in predicates but act more as control structures:

• true is a predicate that always succeeds.
• fail is a predicate that always fails, and thus it forces backtracking.
• ! is a predicate that always succeeds, and removes all the backtracking information up to this point.

Syntax and example:

true. %=> yes
fail. %=> no
!. %=> yes

, -- conjunction, ; -- disjunction, and -> -- if-then

• , represents the conjunction of two goals. It is used to chain two goals together, and forms a new goal which succeeds if both given goals succeed.
• ; represents the disjunction of two goals. It is used to create a choice-point between tho two coals, and forms a new goal that succeeds if either one succeeds.
• -> represents an if-then construct, and behaves just like ,, except that it has a particular behavior.

Syntax:

Goal1, Goal2.
Goal1; Goal2.

Example:

atom(a), number(1). %=> yes
atom(a), number(a). %=> no
atom(a); number(a). %=> yes
atom(1); number(1). %=> yes
atom(1), number(1). %=> no
atom(1), number(1). %=> no

abort

The abort directive (or predicate) is used to abort the current running query.

for

For is used to iterate a given variable over a range.

Syntax:

for(<iterator>, <lower-bound>, <upper-bound>).

Example:

for(X, 1, 10). %=> X = 1; X = 2; ...; X = 10

\+

This predicate is used to negate a goal. It succeeds if the following goal fails, and fails otherwise.

Syntax:

\+ <goal>.

Example:

\+ member(1, [1, 2, 3]). %=> no
\+ 1 = 2. %=> yes

Predicates

Type predicates

The following predicates are used to determine if the given argument has a certain type.

• var and nonvar check if the argument is (or is not) an unbound variable. If the variable is bound it will not succeed.
• atom is used to determine if the given argument is an atom.
• number, integer, and float are used to determine if the given argument is a number, integer, respectively a float.
• compound is used to determine if the given argument is a structure.
• callable is used to determine if the given argument is a goal (a query).
• list, partial_list, and list_or_partial_list are used to determine if the given argument is a list, a partial list or both. list succeeds if the given list has as tail another proper list, meanwhile a partial list has as tail an unbound variable.

Syntax:

var(<expression>).
atom(<expression>).
...

Examples:

var(X). %=> yes
X = 1, var(X). %=> no
list([1, 2, 3]). %=> yes
list([1, A, B]). %=> yes
list([1 | A]). %=> no

Unification predicates = and \=

• = is used to unify two expressions. The predicate succeeds if the expressions can unify, and as an output the variables are bound to the values that make the unification possible.
• \= succeeds only if the two expressions cannot unify. It does not produce any bindings.

Syntax:

<expression-1> = <expression-2>.
<expression-1> \= <expression-2>.

Examples:

1 = 1. %=> yes
a = a. %=> yes
1 + 2 = 3 %=> no
1 + 2 = A %=> A = 1 + 2
A = B %=> A = B

1 \= 2. %=> yes
1 \= A. %=> no

Arithmetic

Arithmetic operators

The following operators are the standard operators found in other programming languages.

Syntax:

+ E
- E

E1 + E2
E1 - E2
E1 * E2
E1 / E2
E1 // E2 -- integer division
E1 rem E2
E1 mod E2
E1 ** E2 -- power raising

E1 /\ E2 -- bitwise and
E1 \/ E2 -- bitwise or
E1 ^ E2 -- bitwise xor
E1 << E2 -- bitwise left shift
E1 >> E2 -- bitwise right shift

inc(E)
dec(E)
abs(E)
sign(E)
floor(E)
ceiling(E)
round(E)

min(E1, E2)
max(E1, E2)

sqrt(E)
exp(E)
log(E)

cos(E)
acos(E)
sin(E)
asin(E)
atan(E)

is -- used to force the evaluation.
=:=
=\=
<
=<
>
>=

Examples:

1 + 2 = 3. %=> no
1 + 2 is 3. %=> no
3 is 1 + 2. %=> yes

List predicates

append

Syntax:

append(<list-1>, <list-2>, <list-1-2>).

Implementation:

append_([], L, L).
append_([H|L1], L2, [H|L]) :- append_(L1, L2, L).

member

Syntax:

member(<member>, <list>).

Implementation:

member_(M, [M|_]).
member_(M, [_|L]) :- member_(M, L).

reverse

Syntax:

reverse(<list>, <reversed>).

Implementation:

reverse_([], []).
reverse_([H|L1], R) :- reverse_(L1, R1), append(R1, [H], R).

delete and select

Syntax:

delete(<list>, <element>, <result>). %=> Removes all the occurrences in the list.
select(<element>, <list>, <result>). %=> Removes only one occurrence in the list.

Implementation:

select_([], _, []).
select_(E, [E|T], T).
select_(E, [H|T], [H|R]) :- select_(E, T, R).

permutation

Syntax:

permutation(<list>, <permutation>).

Implementation:

permutation_([], []).
permutation_([H|T], P) :- permutation(T, TP), select(H, P, TP).

prefix and suffix

Syntax:

prefix(<prefix>, <list>).
suffix(<suffix>, <list>).

Implementation:

prefix_([], _).
prefix_([H|P], [H|L]) :- prefix_(P, L).

sublist

Syntax:

sublist(<sublist>, <list>).

last and nth

Syntax:

last(<list>, <element>).
nth(<index>, <list>, <element>).

Implementation:

last_([L], L).
last_([_|T], L) :- last_(T, L).

length

Syntax:

length(<list>).

Implementation.

length_([], 0).
length_([_|T], L) :- length_(T, L1), L is inc(L1).

max_list, min_list, sum_list

Syntax:

max_list(<list>, <max>).
min_list(<list>, <min>).
sum_list(<list>, <sum>).

sort

Syntax:

sort(<list>, <sorted>).

Resolution explanation

ccraciun@info.uvt.ro