Prolog

[[PT]Devilishly]

Boas!

Ja ca nao vinha ha mto e entao reparei q aqui n se fala de Prolog! :evil:

Entao aki fica um interpretador de prolog:

SWI-Prolog

Vou deixar aqui dois ficheiros para quem necessitar de algumas estruturas:

Ficheiro com funcoes utilitarias relacionado com Sets(conjuntos)

/**
*	uteis:
*		subset(X,Y)	- Valido se X e um subconjunto de Y
*		union(X,Y,Z).	- Valido se Z for a reuniao de X e Y
*/

/**
*	prototipo: memberSet(H,A).
*	Verifica se o conjunto H, e´ membro do conjunto A
*
*	exemplo:
*		memberSet(a,[a,b,c,d,a]).	-> Yes
*/
memberSet(X,[X|_]).
memberSet(X,[_|Y]) :- memberSet(X,Y).

/**
*	prototipo: subSet(X,Y)
*	Valido se X e um subconjunto de Y
*
*	exemplo:
*		subSet([a],[a,c]).		-> Yes
*/
subSet([A|X],Y) :- member(A,Y), subset(X,Y).
subSet([],_).

/**
*	prototipo: intersection(X,Y,Z)
*	Valido se Z for a intersecçao de X e Y
*
*	exemplo:
*		intersection([a],[a,c],[a]).		-> Yes
*/
intersection([],_,[]).
intersection([X|R],Y,[X|Z]) :-
member(X,Y),
!,
intersection(R,Y,Z).
intersection([_|R],Y,Z) :- intersection(R,Y,Z).

/**
*	prototipo: union(X,Y,Z)
*	Valido se Z for a reuniao de X e Y
*
*	exemplo:
*		unionSet([a],[a,c],[a,c]).		-> Yes
*/
unionSet([],X,X).
unionSet([X|R],Y,Z) :- member(X,Y), !, unionSet(R,Y,Z).
unionSet([X|R],Y,[X|Z]) :- unionSet(R,Y,Z).

Ficheiro com funcoes utilitarias relacionado com Listas

/**
*	uteis:
*		append(L1,L2,Resultado).	- junta as listas L1 e L2, retornando em Resultado
*		reverse(L,R).			- Inverte a lista L e retorna em R (reverseList)
*		member(H,A).			- Verifica se o elemento H ´e membro da lista A
*/

/**
*	prototipo: substitui(X,L,A,M).
*	Constroi uma lista M feita dos elmentos de L, excepto nas ocorrencias de X, ser substiuido por A
*
*	exemplo:
*		substitui(a,[a,b,c,d,a],x,L).
*/
substitui(_,[],_,[]).
substitui(X,[X|L],A,[A|M]) :- !, substitui(X,L,A,M).
substitui(X,[Y|L],A,[Y|M]) :- substitui(X,L,A,M).

/**
*	prototipo: deleteFirst(X,Y,Z).
*	Constroi uma lista Z removendo a primeira ocorrencia do elemento X na lista Y
*
*	exemplo:
*		deleteFirst(a,[a,b,c,d,a],L).
*/
deleteFirst(_,[],[]).	
deleteFirst(A,[A|L],L) :- !.
deleteFirst(A,[B|L],[B|M]) :- deleteFirst(A,L,M).

/**
*	prototipo: deleteAll(X,L1,L2).
*	Constroi uma lista L2 removendo todas as ocorrencias do elemento X da lista L1
*
*	exemplo:
*		deleteAll(a,[a,b,c,d,a],L).
*/
deleteAll(_,[],[]).	
deleteAll(X,[X|L],M) :- !, deleteAll(X,L,M).
deleteAll(X,[Y|L1],[Y|L2]) :- deleteAll(X,L1,L2).

/**
*	prototipo: reverseList(L,R).
*	Inverte a lista L e retorna em R. Igual ao predicado reverse
*
*	exemplo:
*		reverseList([a,b,c,d,a],R).
*/
reverseList([],[]).	
reverseList([H|T],L) :- reverseList(T,Z), append(Z,[H],L).

/**
*	prototipo: sublista(X,Y).
*	Devolve verdadeiro, se X for uma sublista de Y e se todos os valores de X aparecerem 
*	de forma consecutiva e na mesma ordem em Y.
*
*	exemplo:
*		sublista([a,d],[a,b,c,d,a]).	-> No
*		sublista([a,b],[a,b,c,d,a]).	-> Yes
*/
sublista([X|L],[X|M]) :- prefix(L,M), !.
sublista(L,[_|M]) :- sublista(L,M).

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

/**
*	prototipo: removeDups(L,R).
*	Remove todos os duplicados de L e devolve em R
*
*	exemplo:
*		removeDups([a,a,b,c,a,d],L).
*/
removeDups(L,M) :- dupacc(L,[],M).

dupacc([],A,A).
dupacc([H|T],A,L) :- member(H,A), dupacc(T,A,L).
dupacc([H|T],A,L) :- dupacc(T,[H|A],L).

Informaçao recolhido do livro: "Programming in Prolog Fourth Edition"

Boas programaçoes pessoal 😄😄

[deathseeker25]

Boas,

Já algum tempo que não te viamos por estes lados... 😄

No entanto, bem-vindo de novo e obrigado pelo source de Prolog.

Agora diz-me por favor: em que tipo de aplicações se utiliza Prolog? É que pelo código pareceu-me uma linguagem bastante matemática sem vertente virada para grafismo ou algo do género.

Cumps

[[PT]Devilishly]

Boas!

Entao aqui vai:

Citação

O Prolog é uma linguagem declarativa, significando que em vez de o programa estipular a maneira de chegar à solução, passo a passo, (como nas linguagens procedimentais ou imperativas), limita-se a fornecer uma descrição do problema que se pretende computar. Usa uma colecção base de dados de fatos e de relações lógicas (regras) que exprimem o domínio relacional do problema a resolver.

Um programa pode correr num modo interactivo, a partir de perguntas (queries) formuladas pelo utente, usando a base de dados (os 'factos') e as regras relacionais (essencialmente implicações lógicas: se.. então), e o mecanismo de unificação para produzir a (por uma cadeia de deduções lógicas) a solução.O Prolog é baseado num subconjunto do cálculo de predicados de primeira ordem, o que é defenido por cláusulas de Horn. A execução de um programa em Prolog é efetivamente a prova de um teorema por resolução de primeira ordem. Alguns conceitos fundamentais são unificação, recursão, e backtracking.

Fonte: Prolog - Wikipedia

Mais informaçao:

O que e Prolog

Google: O que e Prolog

Google: What is Prolog

[saramgsilva]

eu em lógica falei em prolog, acho...acho que dei um teoremazito...mas muito por alto... :roll:

[Bruno]

Eu ja dei Prolog e gostei bastante! (é necessário puxar pela cabeça para programar nesta linguagem) 🙂

Prolog é a 2ª linguagem mais usada no que toca a inteligencia artificial! 😄 (pelo menos era há alguns anos) (a 1ª é LISP)

[Euronymous]

Eh pá ainda bem k alguem se lembrou de PROLOG

Tou com problemas nas listas vou ver s tiro proveito deste post

[Euronymous]

Tou a desenvolver um pequeno trabalho em prolog e vejo muitas referencias a functores... N sei o k isso é nem como usá los. Por acaso nao m podem ajudar?? Obrig