LifeLife

Leonardo Lemos (lal)

Paulo Oliva (pbo)&

Controle de FluxoControle de Fluxo

de predicados:• Como em Prolog:

fail.conjunção (A,B). disjunção (A;B).

• Diferente de Prolog:succeed (em Prolog, true).

de funções:• disjunção {A;B}.

Cut (!): • como Prolog exceto com

disjunção de funcões.

grandparent(X,Z) :- parent(X,Y), parent(Y,Z).

pessoa(X) :- mulher(X); homem(X).

A = {1;2;3;4}A=1, A=2, A=3 ou A=4.

P(A) :- !, write(A).P(X:{1;2;3})?123

Q(A:{1;2;3}) :- !, write(A).Q(X)?1

Controle de FluxoControle de Fluxo

Condicionador• cond(B,T,F)

Ex.: abs(V:real) -> cond(V>=0,V,-V).

Tal que• <expressão> | <predicado>

função call_once(P)• Tente provar P:

se P é verificado devolve true

se P falha devolve false

• Ponte entre funções e predicados

Ap3([ ],L,R) -> true | R=L. Ap3([X|L1],L2,R) -> true |

R=[X|L3], Ap3(L1,L2,L3).

call_once(person(John)).

Cálculos AritméticosCálculos Aritméticos

Funções Aritméticas Binárias• Soma (A+B)• Diferença (A-B, -A)• Produto (A*B)• Divisão (A/B)• Parte inteira da divisão

(A//B)

fatorial em Prologfat(0, 1).fat(N, R) :- N1 is N - 1, fat(N1, A), R is N * A.

fatorial em LIFEfat(0) ->1.fat(N) -> N * fat(N - 1).

Cálculos AritméticosCálculos Aritméticos

Funções Aritméticas bit a bit.• E lógico de A com B, A / \ B. • Ou lógico de A com B, A \ / B.• Right Shift de A, B vezes, A

>> B.• Left Shift de A, B vezes, A <<

B.• Negação de A, (\A).

12 /\ 5 = 41100 /\ 0101 = 0100

12 \/ 5 = 131100 \/ 0101 = 1101

12 >> 1 = 61100 >> 1 = 0110

12 << 1 = 2401100 << 1 = 11000

\12 = 3 \...001100 = ...110011

Cálculos AritméticosCálculos Aritméticos

Funções Aritméticas Unárias.• Maior inteiro menor ou igual a

A, floor(A).• Menor inteiro maior igual a A,

ceiling(A).• Raiz quadrada de A, sqrt(A).• e elevado a A, exp(A).• Logarítmo na base 10, log(A).• Seno, Cosseno e Tangente

sin(A), cos(A), tan(A).

floor(4.5) = 4.0 ceiling(4.5) = 5.0 sqrt(4.0) = 2.0 exp(1) = 2.7189... log(100) = 2 sin(3.1415) = 0.0 sin(1.57) = 1.0

Cálculos AritméticosCálculos Aritméticos

Gerador de números aleatórios• initrandom(S:Real)• random(N:Int)• genint

initrandom(10). random(30)?

4 random(30)?

23 random(30)?

4 genint?

234 genint?

931

Comparação AritméticaComparação Aritmética

Maior (A>B) Maior igual (A>=B) Menor (A<B) Menor igual (A<=B) Igualdade (A=:=B) Diferença (A=\=B)

> maior2(X) :- X > 2.> maior2(A)?*** YesA = real~.--1> A = 3?*** YesA = 3.----2>*** NoA = real~.--1>

Aritmética BooleanaAritmética Booleana

E (A and B) Ou (A or B) Ou exclusivo (A xor B)

• Não existem em Prolog Negação (not A)

• Lógica, não por falha.

> person1(X) -> man(X) or woman(X).

true/false> person2(X) -> man(X);

woman(X). succeed/fail

Exemplos:• greater_lower_bound

glb(c,d) = {a;b}

• least_upper_bound lub(a,b) = {c;d}

• parents(a) = {c;d}• parents(c) = [@]• children(c) = {a;b}• children(a) = [ ]• subsort(a,a) = true• subsort(a,a(b=>2)) =

true• least_sorts = {a;b}

d

a

c

@

b

{}

Cálculo de SortsCálculo de Sorts

Comparação de SortsComparação de Sorts

Maior (c:>d = false) Maior igual (c:>=c = true) Menor (b:<d = true) Menor igual (b:<=d = true) Igual na hierarquia dos

sorts (a:==a = true) Se os sorts são

comparáveis (a:><d = true)

d

a

c

@

b

{}

Comparação de SortsComparação de Sorts

d

a

c

@

b

{}

Não maior (c:\>d = true) Não maior igual (c:\>=c =

false) Não menor (b\:<d = false) Não menor igual (b:\<=d =

false) Não igual na hierarquia dos

sorts (a:\==a = false) Se os sorts não são

comparáveis (a:\><d = false)

Cálculo de StringsCálculo de Strings

É tratada como um sort e usa menos mémoria que termos .

Tamanho da string, strlen(“abcdef”) = 6.

Parte de string, substr(“abcdef”,5, 2) = “ef”.

Concatenarstrcon(“abc”, “def”) = “abcdef”.

Código ASCII de S, asc(S:String).

Carácter do código ASCII, chr(I:Int).

Transforma a string em um termo .str2psi(“foo”) = foo

Inverso de str2psi, psi2str(X). psi2str(int) = “int”

Comparação de StringsComparação de Strings

Maior (A$>B) Maior igual (A$>=B) Menor (A$<B) Menor igual (A$=<B) Igual (A$= =B) Não igual (A$\= =B)

“aba” $> “bab”?false

“a” $< “aa”?true

“jaca” $== ”caja”?false

Verificação de TipoVerificação de Tipo

ap1([ ], L) -> L ap1([X|L1], L2) -> [X|ap1(L1,L2)]

ap2 ([ ],L,L).ap2 ([X|L1],L2,[X|L3]) :- ap2(L1,L2,L3).

is_function(ap1).True.

is_predicate(ap1).False.

is_sort(ap2).False.

Se X é um @ sem argumentos: var(X)

Se X não é @ ou tem argumentos: nonvar(X)

Se X é um termo persistente: is_persistent(X)

Variáveis globaisVariáveis globais Variável lógica cujo

nome é visível em todo o programa. (módulo)

Devem ser declaradas. Comporta-se com um

parâmetro extra passado para todos os predicados, funções e conjuntos.

Não contribuem para a manutenção do programa

Usadas para rastrear programas sem usar parâmetros extras.

> global (warfare)? % declarar variável gb.

*** yes> warfare=34? % unificar com 34*** yes--1> write (warfare)? % escrever o

valor34*** yes----2> .> write (warfare)? % backtracking

desfaz@ % a unificação*** yes

Termos e variáveis persistentesTermos e variáveis persistentes

Termos Persistentes• É um termo que não muda o valor no backtracking.• São termos apenas de leitura que só pode ser modificado por

chamadas explícitas por atribuições não-backtracking (<<-)• Um termo persistente pode ser armazenado em uma variável

padrão.• Toda interação entre termos locais e termos persistentes é

feita através de matching. Unificar dois termos persistentes gera erro.

Variável Persistente:• É um termo persistente armazenado em uma variável global.• O valor nunca fica inacessível.• Tem que ser declaradas.• Atualmente não diferencia entre variáveis persistentes e

globais

Exemplo de Variável PersistenteExemplo de Variável Persistente

> persistent (trouble)? *** yes> trouble<<-with_harry? *** yes --1> write (trouble)?with_harry *** yes----2> .> write (trouble)? with_harry*** yes

> global (trouble)? *** yes> trouble<<-with_harry? *** yes --1> write (trouble)? with_harry *** yes----2> .> write (trouble)? @*** yes

Atribuição DestrutivaAtribuição Destrutiva

Atribuição destrutiva• Life provê uma integração

limpa de atribuições destrutivas.

• Utiliza dois tipos de termos: normais e persistentes.

• Dois tipos de atribuições destrutivas:

Atribuição destrutiva backtrackable• X sobrepõe Y. Backtracking

recupera os valores originais de X. (X <- Y)

> X=5, (X<-6;X<-7;succeed), write(X), nl, fail?

675*** No

Atribuição Destrutiva não-BacktrackableAtribuição Destrutiva não-Backtrackable

X sobrepõe Y. Backtracking não recupera os valores originais de X. (X <<- Y)

> X=5?*** yesX = 5.--1> X <<- 10?*** yesX = 10.----2> X <<- 20?*** yesX = 20?------3>*** noX = 20.----2>X = 5.

Gramáticas de Cláusulas Definidas (GCD)Gramáticas de Cláusulas Definidas (GCD)

Notação popular de gramática: Backus-Naur Form, BNF, para a linguagem anbn <s> ::= a b<s> ::= a <s> b

Notação DCG (definite clause grammar)s --> [a], [b].s --> [a], s, [b].

Diretamente utilizável para os processamentos morfológico e sintático na interpretação de LN (parsing)

Também utilizado para os processamentos semântico e pragmático na interpretação de LN.

Noção de Difference List[1,2,3] = [1,2,3,4] - [4][x] = [x|A] - A[a,b,c,d] = [a,b,c,d] - [ ]

Conversão de GCD para PrologConversão de GCD para Prolog

f(T,F) :- sn(T,R), gv(R, F). f(T,F) :- sn(T,R1), gv(R1,R2),

sn(R2,F). sn(T,F) :- nome(T,F). sn(T,F) :- det(T,R), subs(R,F). gv(R,F) :- v(T,F).

v([come|F],F). v([canta|F],F). subs([pera|F],F). nome([ana|F],F). det([pera|F],F).

F --> SN, GV. F --> SN, GV, SN. SN --> Nome SN --> Det, Subs. GV --> V.

V --> [come]. V --> [canta]. Nome --> [ana]. Subs --> [pera]. Det --> [a].

Parsing Bottom-Up com GCDsParsing Bottom-Up com GCDs

f([Ana,come,a,pera],[])

sn gv sn

nome

ana

v

come a

det subs

pera

f(T,F) :- sn(T,R), gv(R, F). f(T,F) :- sn(T,R1), gv(R1,R2),

sn(R2,F). sn(T,F) :- nome(T,F). sn(T,F) :- det(T,R), subs(R,F). gv(R,F) :- v(T,F).

v([come|F],F). v([canta|F],F). subs([pera|F],F). nome([ana|F],F). det([pera|F],F).

Rastreamento do Parsing...Rastreamento do Parsing...

? f([ana,come,a,pera],[]).1) 0 CALL: f([ana,come,a,pera][]) ? 2) 1 CALL: sn([ana,come,a,pera],_72) ? 3) 2 CALL: nome([ana,come,a,pera],_72) ? 4) 3 CALL: C(ana,[ana,come,a,pera],_72) {dec10} ? 4) 3 EXIT: C(ana, [ana,come,a,pera],[come,a,pera]) 3) 2 EXIT: nome([ana,come,a,pera],[come,a,pera]) 2) 1 EXIT: sn([ana,come,a,pera],[come,a,pera])

5) 1 CALL: gv([come,a,pera],[]) ? 6) 2 CALL: v([come,a,pera],[])? 7) 3 CALL: C(come,[come,a,pera],[]) {dec10} ? 7) 3 FAIL: C(come,[come,a,pera],[]) 8) 3 CALL: C(canta,[come,a,pera],[]) {dec10} ? ....

Utilização de Restrições com ArgumentosUtilização de Restrições com Argumentos

GCDf(Num, Gen) --> sn(Num, Gen), gv(Num, Gen).

PROLOG f(T, F, Num, Gen) :- sn(T,R,Num,Gen), gv(R,F,Num,Gen).

?- f(Num,Gen,[ana,come,as, peras], []).Num = sing, Gen = femMore(y/n)? Nyes?- f(Num,Gen,[ana,come,as, pera], []).no?- f(Num,Gen,[as,peras,come, ana], []).no

That’s all folks!!That’s all folks!!