Entrada e Saí - FACOMRecuperação Eficiente • Em grandes bases de dados, devemos ter cuidado:...

Entrada e Saída

Prof. Elaine Faria e Hiran NonatoProgramação Lógica

UFU ­ 2012

Arquivo de Entrada

• Exemplo do uso do see...see(arq1).le_do_arquivo(Informacao).see(user)....

Arquivos de Saída

• A fonte de saída corrente pode ser mudada – tell(novoArqSai).

• Exemplo do uso do tell...tell(arq3).grava_no_arquivo(Informacao).tell(user)....

Arquivos de Dados

• Dois outros predicados devem ser utilizados para fechar os arquivos correntes de entrada e saída respectivamente– seen/0 e told/0

Abertura de um arquivo

• Pode­se também abrir um fluxo (stream)

…open(‘arquivo.txt‘, write, Fluxo),...close(Fluxo),…

Abertura de um arquivo

• Para estender um arquivo existente, temos que abrir um fluxo em modo append

…open(‘arquivo.txt‘, append, Fluxo),....close(Fluxo),...

Exemplo 5principal:­    open('casas.txt',read,F),    leiaCasas(F,Casas),    close(F),    write(Casas), nl.

leiaCasas(F,[]):­      at_end_of_stream(F).

leiaCasas(F,[X|L]):­      \+ at_end_of_stream(F),     read(F,X),      leiaCasas(F, L).

Leitura de programas

• A forma mais simples de dizer ao Prolog para ler as definições de predicados armazenadas em um arquivo é usar os colchetes

?­ [meuArq].{consulting(meuArq.pl)…}{meuArq.pl consulted, 233 bytes}true?­

Leitura de programas

• Você também pode consultar mais de um arquivo por vez

?­ [meuArq1, meuArq2, meuArq3].{consulting meuArq1.pl…}{consulting meuArq2.pl…}{consulting meuArq3.pl…}

Usando módulos• Predicado pré­construído module: 

– module/1 e module/2– Para criar um módulo/biblioteca

• Predicado pré­construído use_module: – use_module/1 e use_module/2– Para importar predicados de uma biblioteca

• Argumentos– O primeiro argumento é o nome do módulo– O segundo e opcional argumento é uma lista dos predicados 

exportados

Importando bibliotecas

• Ao especificar o nome de uma biblioteca que você quer usar, você pode informar que este módulo é uma biblioteca

• Prolog procurará no lugar certo, ou seja, em um diretório onde todas as bibliotecas estão guardadas

:­ use_module(library(lists)). 

Predicados extra­lógicos

Prof. Elaine Faria e Hiran NonatoProgramação Lógica

UFU ­ 2012

Tipos de termos

Luis, A. M. Palazzo,  Introdução à Programação Prolog, Educat, 1997.

Tipos de termos 

Construção e decomposição de termos

• Há  três  predicados  pré­definidos  para  a decomposição  de  termos  e  construção  de  novos termos: – functor/3 – arg/3 – =../2

Construção e decomposição de termos

• =../2  "univ“ (operador infixo)– O objetivo Termo =.. L é bem­sucedido se L é uma lista contendo 

como  primeiro  elemento  o  functor  principal  de  Termo,  seguido pelos seus argumentos. 

?­f(a, b) =.. L.L=[f, a, b]

?­T =.. [retângulo, 3, 5].T=retângulo(3, 5)

?­Z =.. [p, X, f(X, Y)].Z=p(X, f(X, Y))

Construção e decomposição de termos

• functor/3functor(Termo, Functor, Aridade)

é verdadeiro se Functor é o functor principal de Termo e Aridade é o seu número de argumentos

• arg/3arg(N, Termo, Argumento)

é verdadeiro se Argumento é o N­ésimo argumento em Termo

Construção e decomposição de termos

• Exemplos?­functor(teste(f(X), X, t), Functor, Aridade).

Functor=teste Aridade=3

?­arg(2, teste(X, t(a), t(b)), Argumento).Argumento=t(a)

?­functor(D, data, 3), arg(1, D, 5), arg(2, D, abril), arg(3, D, 1994).D=data(5, abril, 1994)

Programas ou Bases de Dados• Modelo relacional

– uma base de dados é a especificação de um conjunto de relações

• Um programa Prolog pode ser visto como uma base de dados – A especificação das relações é parcialmente implícita (regras) e 

parcialmente explícita (fatos). 

• Prolog possui cinco comandos básicos para a manipulação da base de dados:

– assert/1– asserta/1– assertz/1

– retract/1– retractall/1

Adicionar informação

Remover informação

Manipulação da base de dados

Recursos para o controle de programas

• call(P) – dispara um objetivo P. Será bem­sucedido se e 

somente se P também o for• repeat 

– objetivo que sempre é bem­sucedido. Sua principal propriedade é ser não determinístico

• toda vez que é alcançado por backtracking ele gera um caminho alternativo para a execução

repeat.      repeat :­ repeat.

Recursos para o controle de programas

• Exemplos do uso do repeatquadrado :­

repeat, read(X),(X=fim, !; Y is X*X, write(Y), fail).

executa :­repeat, menu(X),(X=fim, !; exec(X), fail).

Bagof, Setof e Findall

• Pode­se gerar, através de backtracking, todos os objetos, um a um, que satisfazem algum objetivo

• Cada  vez  que  uma  nova  solução  é  gerada,  a anterior desaparece e não é mais acessível

• O  que  fazer  quando  deseja­se  dispor  de  todos  os objetos gerados?

Bagof, Setof e Findall

bagof(X, P, L)irá produzir uma lista L de todos os objetos X que satisfazem ao objetivo P

classe(a, vog).classe(b, con).classe(c, con).classe(d, con).classe(e, vog).. . .

?­bagof(Letra, classe(Letra, con), Consoantes).Consoantes=[b, c, d, ..., z]

Bagof, Setof e Findall?­ bagof(Letra, classe(Letra, Classe), Letras).

Classe=vog, Letras=[a, e, i, o, u];Classe=con, Letras=[b, c, d, f, ..., z].

– Se não houver solução para P no objetivo bagof(X, P, L), então este falha

– Se algum objeto X é encontrado repetidamente, todas as suas ocorrências irão aparecer em L 

• possibilidade de existência de elementos duplicados em L

Bagof, Setof e Findall

setof(X, P, L)irá produzir uma lista L dos objetos X que satisfazem a P, sendo que a lista L estará ordenada e itens duplicados serão eliminados

?­setof(Classe/Letra, classe(Letra, Classe), Letras).Letras=[con/b, con/c, ..., con/z, vog/a, ..., vog/u]

Bagof, Setof e Findall

findall(X, P, L)produz a lista L de todos os objetos X que satisfazem P

• Diferença entre findall e o bagof – todos os objetos X são coletados sem considerar eventuais 

soluções diferentes para as variáveis em P que não são compartilhadas com X

?­findall(Letra, classe(Letra, Classe), Letras).Letras=[a, b, c, ..., z]

Bagof, Setof e Findallidade(pedro,7).idade(ana,5).idade(alice,8).idade(tomaz,5).

?­findall(Crianca,idade(Crianca,Idade),L).L = [pedro,ana,alice,tomaz]

?­findall(Crianca/Idade,idade(Crianca,Idade),L).L = [pedro/7, ana/5, alice/8, tomaz/5]

?­findall(Crianca/Idade, (idade(Crianca,Idade),Idade>5),L).L = [pedro/7, alice/8]

Bagof, Setof e Findall

• Se não há nenhum objeto X que satisfaça P, então o predicado findall(X, P, L) resulta bem­sucedido com L=[]

Lógica e Bases de Dados

Prof. Elaine Faria e Hiran NonatoProgramação Lógica

UFU ­ 2012

Bases de Dados Relacionais

• Base de dados Prolog para a tabela pessoapessoa(marcelo, m, luiz, gilda).pessoa(luiz, m, alfredo, lina).pessoa(gilda, f, miguel, ana).pessoa(lúcia, f, luiz, gilda).pessoa(paulo, m, miguel, ana).pessoa(lina, f, francisco, júlia).

pessoa(marcelo, m, luiz, gilda).pessoa(luiz, m, alfredo, lina).pessoa(gilda, f, miguel, ana).pessoa(lúcia, f, luiz, gilda).pessoa(paulo, m, miguel, ana).pessoa(lina, f, francisco, júlia).

carro(abc­4590,vw, alfredo, azul).carro(xyz­1211,ford, lina,branco).carro(rtc­9004,fiat, luiz,vermelho).carro(llz­7533,gm,gilda,prata).

?­ pessoa(N, f, _, _),     carro(_, Fabr, N, _).

Recuperação de Informações

Recuperação Eficiente• Em grandes bases de dados, devemos ter cuidado:

– Quando há combinação de tuplas distribuídas em duas ou mais tabelas

• Sistemas Prolog devem possuir um “otimizador de consultas”

• Exemplo– Suponha que um crime tenha sido cometido e está sendo procurado um 

homem em um ford azul– A base de dados da polícia possui duas tabelas: uma com 3000 carros e 

outra com 10000 pessoas suspeitas– Uma pessoa pode possuir mais de um carro– Suponha que haja dez fords azuis e que metade das pessoas na base de 

dados sejam homens

Recuperação EficienteSoluções:

?­ carro(Placa, ford, X, azul), pessoa(X, m, _, _).

ou

?­ pessoa(X, m, _, _), carro(Placa, ford, X, azul).

Recuperação EficienteSoluções:

• No primeiro caso – 3000 tentativas de unificação na tabela de carros– Dessas, apenas 10 serão bem sucedidas (só há 10 fords azuis) – 10 acessos diretos à tabela de pessoas para verificar o sexo, num total de 

3010 unificações

• No segundo caso– 10000 tentativas de unificação na tabela de pessoas, das quais 5000 serão 

bem sucedidas – Para cada uma dessas unificações bem sucedidas, 3000 acessos deverão ser 

feitos à tabela de carros, uma vez que não se dispõe da chave, que é “placa”

Atualização da Base de Dados• O modelo relacional impõe a restrição de que certos campos devem ser 

campos chaves, cujo valor deve ser único em uma tabela

• Em  Prolog,  um  sistema  para  o  gerenciamento  de  bases  de  dados relacionais pode ser implementado de forma muito natural

• Operações básicas– remove(T)          % Remove a tupla T– insere(T)           % Insere a tupla T, se já não estiver lá– atualiza(VT, NT)           % Remove a velha e insere a nova tupla

Atualização da Base de Dados

• Exemplos?­ remove(carro(_, _, gilda, _)).

irá remover da base de dados todos os carros que pertencem a Gilda

?­ insere(carro(flt­5455, honda, gilda, cor­de­rosa)).irá introduzir o novo ­ e único ­ carro de Gilda na base de dados.

Atualização da Base de Dadosremove(X) :­             

  removeAux(X), fail.    remove(X).

removeAux(X) :­  retract(X).

removeAux(X).

insere(X) :­  remove(X), assert(X).

insere(X) :­  assert(X).

Formas Normais Relacionais

• Exemplo de uso da 1FN– Evitar repetir grupos

empregador empregado1, empregado2, ..., empregadon

– Não usar a representaçãoempregados(joão, [josé, júlia, jorge, josefina, jane]).

– Usar a representaçãoempr(josé, joão).empr(júlia, joão).empr(jorge, joão).empr(josefina, joão).empr(jane, joão).

Formas Normais Relacionais

• Exemplo de uso da 1FN – cont.– o benefício acontece quando um novo empregado (por exemplo, 

jonas) é contratado 

?­ insere(empr(jonas, joão)).

– O programador não necessita(1) Selecionar a lista de empregados de joão(2) Adicionar Jonas(3) Produzir uma nova lista(4) Apagar a tupla corrente, com a velha lista(5) Produzir uma nova tupla, com a nova lista

Formas Normais Relacionais

• Exemplo de uso da 2FN– Identificar/remover atributos não dependentes da chave primária– Regra aplicada apenas à chaves compostas

empregado nomeEmpregado     (tabela empregado)empregado projeto nomeProjeto horas   (tabela alocação)

– nomeProjeto não depende funcionalmente da chave:[empregado, projeto]

Formas Normais Relacionais

• Exemplo de uso da 2FN ­ cont– Identificar/remover atributos não dependentes da chave primária (nova 

tabela criada, ok)

Solução:empregado nomeEmpregado     (tabela empregado)

empregado projeto horas    (tabela alocação)projeto nomeProjeto (tabela projeto) 

– Dessa  forma,  caso  o  atributo  nomeProjeto  mude,  a  alteração  se  dará apenas na tabela ‘projeto’.

Formas Normais Relacionais

• Exemplo de uso da 3FN– Identificar/remover atributos não dependentes de atributos não chave

empregado empregador endereçoEmpregador   (tabela empregado)

– ‘endereçoEmpregador’ não é dependente da chave ‘empregado’

Formas Normais Relacionais

• Exemplo de uso da 3FN ­ cont– Identificar/remover atributos não dependentes de atributos não chave 

(nova tabela criada, ok)

Solução:empregado empregador          (tabela empregado)

empregador endereçoEmpregador      (tabela empregador)

– Assim como na 2FN, problemas de redundância e múltiplas atualização justificam a aplicação dessa normalização.