LIFE: predicados, funções e sorts built-in Jacques Robin Paulo Oliva Leonardo Lemos DI-UFPE.

Apresentação em tema: "LIFE: predicados, funções e sorts built-in Jacques Robin Paulo Oliva Leonardo Lemos DI-UFPE."— Transcrição da apresentação:

1 LIFE: predicados, funções e sorts built-in Jacques Robin Paulo Oliva Leonardo Lemos DI-UFPE

2 Controle 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})? 1 2 3 * Q(A:{1;2;3}) :- !, write(A). Q(X)? 1

3 Controle de Fluxo * Condicionador cond(B,T,F) Ex.: abs(V:real) -> cond(V>=0,V,-V). * Tal que | * função call_once(P) Tente provar P: t se P é verificado devolve true t 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)).

4 Cá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 Prolog fat(0, 1). fat(N, R) :- N1 is N - 1, fat(N1, A), R is N * A. * fatorial em LIFE fat(0) ->1. fat(N) -> N * fat(N - 1).

5 Cá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 = 4 1100 /\ 0101 = 0100 * 12 \/ 5 = 13 1100 \/ 0101 = 1101 * 12 >> 1 = 6 1100 >> 1 = 0110 * 12 << 1 = 24 01100 << 1 = 11000 * \12 = 3 * \...001100 =...110011

6 Cá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 t 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

7 Cá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

8 Comparaçã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)? *** Yes A = real~. --1> A = 3? *** Yes A = 3. ----2> *** No A = real~. --1>

9 Aritmé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

10 * Exemplos: greater_lower_bound t glb(c,d) = {a;b} least_upper_bound t 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 Sorts

11 Comparaçã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 {}

12 Comparaçã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)

13 Cá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. * Concatenar strcon(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

14 Comparaçã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

15 Verificaçã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)

16 Variá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 valor 34 *** yes ----2>. > write (warfare)? % backtracking desfaz @ % a unificação *** yes

17 Termos 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

18 Exemplo 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

19 Atribuiçã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? 6 7 5 *** No

20 Atribuição Destrutiva não-Backtrackable * X sobrepõe Y. Backtracking não recupera os valores originais de X. (X <<- Y) > X=5? *** yes X = 5. --1> X <<- 10? *** yes X = 10. ----2> X <<- 20? *** yes X = 20? ------3> *** no X = 20. ----2> X = 5.