Can't Get My Engine To Start (why?) Introdução

Transcrição

1 Linguagens e Ambientes de Programação (2009/2010) [Eng.Inf. - DI/FCT/UNL] Enunciado do 1º Projecto Prático (OCaml) Datas 19/Mar (16:00) - Divulgação deste enunciado 25/Mar (22:00) - Abertura dum concurso no Mooshak, para início da submissão dos trabalhos 07/Abr (22:00) - Data e hora limite de entrega do 1º projecto Changelog 20/Mar - Os exemplos das funções "w" e "s" estavam trocados. Foi corrigido. 20/Mar - Possíveis correcções a este enunciado serão assinaladas aqui. Can't Get My Engine To Start (why?) Introdução Neste trabalho, propomos-lhe o desafio de implementar em OCaml um motor de pesquisa que suporte a funcionalidade mais essencial dos motores de pesquisa profissionais, usados por exemplo para procurar informação na Web. Motores de pesquisa Um motor de pesquisa (ou motor de busca) é um serviço que permite pesquisar informações em grandes repositórios de dados. As pesquisas são feitas com base em palavras ou agrupamentos de palavras, indicados pelo utilizador. As respostas devem ser muito rápidas, o que pressupõe que faz indexação dos dados antes das pesquisas se realizarem. Pesquisa em directoria de ficheiros de texto Neste projecto as pesquisas serão efectuada sobre o conjunto de ficheiros contidos numa directoria local. A directoria só contém ficheiros de texto contendo caracteres Latin-1, sendo as as mudanças de linha representadas pelo carácter com código 10 (de acordo com a convenção do Unix). A directoria não contém ficheiros binários nem sub-directorias. 1 of :41

2 Aqui, pretende-se enfatizar a capacidade para encontrar soluções elegantes usando a parte funcional da linguagem OCaml, relativizando um pouco à questão da eficiência. Assume-se que o número de ficheiros é apenas mediano (menos de 100) e que o comprimento de cada ficheiro também é mediano (menos de caracteres). Índice invertido Como é norma neste tipo de tecnologia, o nosso motor de pesquisa deve saber criar um índice invertido a partir do conteúdo da directoria. Um índice invertido baseia-se numa ideia simples: a cada palavra que possa ser objecto de pesquisa, associa-se uma lista de posições, que é uma lista de pares (documento, posição), que regista todas as ocorrências dessa palavra nos vários documentos. Numa posição, a componente "documento" representa o nome do ficheiro que contém o documento e a componente "posição" representa um inteiro não negativo que indica a posição da palavra, na sequência de palavras do documento ("0" indica a 1ª palavra, "1" indica a 2ª palavra, etc.) type position = string * int ;; type positions = position list ;; O nosso motor de pesquisa só indexa palavras de comprimento três ou maior. Uma palavra é uma sequência contígua de caracteres alfabéticos. Todos os outros caracteres, assim como palavras de comprimento inferior a três, não contam para as pesquisas. Para facilitar a manipulação, as nossas palavras serão representadas usando o seguinte tipo: type word = char list ;; Repare que, por cada palavra, a correspondente lista de pares pode ser muito longa. Uma palavra comum, como por exemplo "uma", pode ocorrer centenas de vezes nos diversos ficheiros. Pesquisas A especificação duma pesquisa envolve uma sequência onde podem ocorrer 2 tipos de elementos: Palavra simples. Sequência de palavras entre plicas. Eis um exemplo duma especificação duma pesquisa, com três elementos (duas palavras simples mais uma sequência de palavras entre plicas): princesa 'Era uma vez' sapo Esta pesquisa significa que se pretende descobrir todos os documentos onde estes três elementos ocorram em simultâneo. Além disso, o elemento "'Era uma vez'" indica que as três palavras constituintes têm de aparecer de seguida (ignorando todos os caracteres não significativos pelo meio), como por exemplo no texto "Era, a a ah uma ma ma ma, ma vez". Por outras palavras, a pesquisa "'Era uma vez'" permite descobrir "Era, a a ah uma ma ma ma, ma vez". Ranking Para cada query, o motor de pesquisa estabelece um ranking entre os documentos relevantes, baseado em três critérios: O critério primário é número total de ocorrências dos elementos que são especificados na 2 of :41

3 pesquisa. Em caso de empate no critério anterior, os documentos são ordenados simplesmente por nome. Só contam para o ranking os documentos onde todos os elementos da pesquisa ocorrem. Florestas lexicais e árvores lexicais Para que as pesquisas sejam rápidas convém implementar um índice invertido baseado num dicionário eficiente. Nesse dicionário, a partir duma palavra, deve ser possível obter depressa a lista de posições dessa palavra. A chave de pesquisa é a palavra e o valor correspondente é uma lista de posições. Há várias formas eficientes de implementar dicionários, por exemplo usando hash tables ou árvores binárias de pesquisa balanceadas. Neste projecto vamos usar uma outra técnica eficiente que vamos designar de técnica das florestas lexicais. O nosso índice invertido será implementado usando uma floresta lexical. Uma floresta lexical é simplesmente uma lista de árvores lexicais. A explicação do que é uma árvore lexical tem quatro pontos: Uma árvore lexical é uma árvore n-ária de letras, onde existe a opção de guardar um valor suplementar ao lado de cada letra. Portanto, cada nó é constituído por: (1) uma letra; (2) um valor suplementar opcional; (3) uma lista de árvores (portanto, uma floresta lexical). Numa floresta lexical, cada palavra é representada como um percurso descendente que se inicia na raiz alguma árvore e que termina num nó com valor suplementar. Esse valor tem uma dupla utilidade: (1) serve para indicar que a palavra existe como chave de pesquisa; (2) indica qual o valor correspondente a essa chave de pesquisa. As várias palavras guardadas numa floresta lexical devem partilhar prefixos, para evitar redundância. 4. Cada lista de árvores está ordenada crescentemente em função dos valores das raízes. Exemplificando, a seguinte floresta lexical, com três árvores, representa o seguinte conjunto de 8 palavras: "aba", "abano", "fa", "falso", "fato", "fogo", "foto", "uva". Os valores suplementares são representados por tracinhos cinzentos: há 8 palavras, logo há 8 tracinhos cinzentos. Uma árvore lexical nunca é vazia, mas uma floresta lexical pode ser vazia. Seria possível definir florestas lexicais genéricas para valores suplementares de tipo genérico 'a mas, neste trabalho, pedimos-lhe para definir directamente florestas lexicais para listas de posições: 3 of :41

4 type lexforest = lextree list and lextree = LTree of char * positions * lexforest ;; Nos nós das árvores, a ausência de valor é representada pela lista vazia: let none = [] ;; A floresta da imagem acima pode ser escrita em OCaml da seguinte forma: let somepos = ("", 0) ;; let some = [somepos] ;; let example = [LTree ('a', none, [LTree ('b', none, [LTree ('a', some, [LTree ('n', none, [LTree ('o', some, [])])])])]); LTree ('f', none, [LTree ('a', some, [LTree ('l', none, [LTree ('s', none, [LTree ('o', some, [])])]); LTree ('t', none, [LTree ('o', some, [])])]); LTree ('o', none, [LTree ('g', none, [LTree ('o', some, [])]); LTree ('t', none, [LTree ('o', some, [])])])]); LTree ('u', none, [LTree ('v', none, [LTree ('a', some, [])])])] ;; Problema Desenvolva em OCaml dois módulos fechados: O primeiro módulo, chamado LexForest, implementa florestas lexicais em que os valor suplementares são listas de posições. O segundo módulo, chamado Engine, implementa um motor de pesquisa sobre os ficheiros contidos numa directoria. Esses módulos destinam-se a ser carregados dentro do interpretador de OCaml, tornando este interpretador numa ferramenta interactiva que permite fazer experiências com florestas lexicais e com motores de busca. Os módulos só definem tipos abertos porque isso é o que convém para o tipo de utilização pretendida: certamente que o utilizador deseja poder observar o conteúdo das estruturas manipuladas. Contudo, os módulos ocultam possíveis funções auxiliares que possam ser definidas. Além disso, a interface dos módulos impõe às funções públicas os seus tipos correctos, o que dá mais garantias de que você não terá problemas na altura de submeter no Mooshak. O código fonte do primeiro módulo deve ser guardado em dois ficheiros chamados "LexForest.mli" e "LexForest.ml" e será compilado pelo Mooshak da seguinte forma: 4 of :41

5 ocamlc -c LexForest.mli LexForest.ml O código fonte do segundo módulo deve ser guardado em dois ficheiros chamados "Engine.mli" e "Engine.ml" e será compilado pelo Mooshak da seguinte forma: ocamlc -c Engine.mli Engine.ml Depois de compilados, os módulos são usados dentro do interpretador de OCaml, da seguinte forma: $ ocaml PDA.cmo Objective Caml version # #load "LexForest.cmo" ;; open LexForest ;; # #load "Engine.cmo" ;; open Engine ;;... Os trabalhos vão ser avaliados de forma parcialmente automática, pelo que o seu programa deve obedecer a um certo número de regras rígidas: É obrigatório usar todos os tipos de dados oferecidos neste enunciado. É obrigatório respeitar os nomes, tipos e especificação das funções públicas (apresentadas a seguir). Use os ficheiros "*.mli" fornecidos, sem os alterar, para evitar problemas. Neste projecto não se pede para você escrever qualquer programa principal. Só se pedem mesmo os dois módulos. Funções públicas do módulo LexForest As funções de interface do módulo LexForest ficam à disposição do utilizador para este as poder usar dentro do interpretador de OCaml. Apresentam-se de seguida as várias funções públicas deste módulo. Para cada uma delas dá-se uma breve explicação e mostra-se um exemplo de avaliação. Em alguns desses exemplos aproveita-se a floresta example que aparece na imagem atrás. w : string -> word Converte uma string numa palavra. Durante a conversão, a string é validada e deve-se garantir que só contém letras, maiúsculas ou minúsculas. Se contiver outros caracteres gera a excepção Arg.Bad. Esta função não se destina a ser usada como função auxiliar das outras funções. Apenas fornece ao utilizador do interpretador de OCaml uma forma prática de converter strings em palavras. # w "ola" ;; - : LexForest.word = ['o'; 'l'; 'a'] s : word -> string Converte uma palavra numa string. Durante a conversão, a palavra é validada e deve-se garantir que só contém letras, maiúsculas ou minúsculas. Se contiver outros caracteres gera a excepção Arg.Bad. Esta função não se destina a ser usada como função auxiliar das outras funções. Apenas fornece ao utilizador do interpretador de OCaml uma forma prática de converter palavras em strings. # s ['o'; 'l'; 'a'] ;; - : string = "ola" 5 of :41

6 count : lexforest -> int Conta o número de palavras contido numa floresta lexical. # count example ;; - : int = 8 validate : lexforest -> bool Verifica se uma floresta lexical é válida. Para uma floresta ser válida, nenhuma das suas folhas deve conter o valor none (isso seria um absurdo); além disso, dentro de cada lista de árvores, estas estão ordenadas por ordem crescente do valor das suas raízes. # validate example ;; - : bool = true lengthn : int -> lexforest -> int Conta o número de palavras com um dado comprimento, de entre as que se encontram numa floresta lexical. # lengthn 3 example ;; - : int = 2 insert : word -> position -> lexforest -> lexforest (*) Aumenta a lista de posições duma palavra, numa floresta lexical. A posição que é passada no segundo argumento é acrescentada à lista de posições da palavra. # insert (w "ola") ("a",0) [] ;; - : lexforest = LTree ('o', [], [LTree ('l', [], [LTree ('a', [("a", 0)], [])])])] delete : word -> lexforest -> lexforest (*) Apaga uma palavra duma floresta lexical. Apagar significa colocar a lista de posições da palavra com o valor none e poderá também significar a eliminação de alguns nós da floresta para garantir que a árvore resultante fica válida. # delete (w "fato") example ;; - : lexforest = [LTree ('a', [], [LTree ('b', [], [LTree ('a', [("", 0)], [LTree ('n', [], [LTree ('o', [("", 0)], [])])])])]); LTree ('f', [], [LTree ('a', [("", 0)], [LTree ('l', [], [LTree ('s', [], [LTree ('o', [("", 0)], [])])])]); LTree ('o', [], [LTree ('g', [], [LTree ('o', [("", 0)], [])]); LTree ('t', [], [LTree ('o', [("", 0)], [])])])]); LTree ('u', [], [LTree ('v', [], [LTree ('a', [("", 0)], [])])])] # count (delete (w "fato") example) ;; - : int = 7 words : lexforest -> word list Produz a lista de todas as palavras que estão guardadas numa floresta lexical. Deve ser produzida directamente uma lista ordenada, sem invocar qualquer função de ordenação e também sem usar as funções first e sucessor. # words example ;; - : word list = [['a'; 'b'; 'a']; ['a'; 'b'; 'a'; 'n'; 'o']; ['f'; 'a']; ['f'; 'a'; 'l'; 's'; 'o']; ['f'; 'a'; 't'; 'o']; ['f'; 'o'; 'g'; 'o']; ['f'; 'o'; 't'; 'o']; ['u'; 'v'; 'a']] 6 of :41

7 makelex : word list -> lexforest Cria uma floresta lexical a partir duma lista de palavras. # makelex [w "carro"; w "aviao"; w "navio"] ;; - : lexforest = [LTree ('a', [], [LTree ('v', [], [LTree ('i', [], [LTree ('a', [], [LTree ('o', [("", 0)], [])])])])]); LTree ('c', [], [LTree ('a', [], [LTree ('r', [], [LTree ('r', [], [LTree ('o', [("", 0)], [])])])])]); LTree ('n', [], [LTree ('a', [], [LTree ('v', [], [LTree ('i', [], [LTree ('o', [("", 0)], [])])])])])] first : lexforest -> word Produz directamente, de forma eficiente, a primeira palavra duma floresta lexical. Assume-se a ordenação lexicográfica crescente normal. Se a floresta lexical for vazia, deve ser produzida a lista vazia. # first example ;; - : char list = ['a'; 'b'; 'a'] sucessor : word -> lexforest -> word (*) Produz directamente, de forma eficiente, a palavra que se segue à palavra dada no argumento, numa floresta lexical. Assume-se a ordenação lexicográfica crescente normal. Se o argumento for a lista vazia, então deve ser gerada a primeira palavra da floresta lexical. Se não existir nenhuma palavra a seguir à palavra dada produz-se a lista vazia. # sucessor (w "") example ;; - : word = ['a'; 'b'; 'a'] # sucessor (w "aba") example ;; - : word = ['a'; 'b'; 'a'; 'n'; 'o'] # sucessor (w "b") example ;; - : word = ['f'; 'a'] # sucessor (w "z") example ;; - : word = [] Funções públicas do módulo Engine As funções de interface do módulo Engine ficam à disposição do utilizador para este as poder usar dentro do interpretador de OCaml. Apresentam-se de seguida as várias funções públicas deste módulo. Para cada uma delas dá-se uma breve explicação e mostra-se um exemplo de avaliação baseado numa directoria com path "/tpm/silly" contendo os seguintes quatro ficheiros: a: Era uma vez um rei e uma rainha. Então o rei disse: Conte-me uma história! e a rainha começou: Era uma vez um rei e uma rainha. b: Era uma vez uma má rainha e um bom rei. Então a rainha disse: Conte-me uma história! e o rei disse: Não me apetece! e a rainha disse: Não gostei da história! c: Era uma vez um casal real. Então o rei disse: Rainha, por favor, peça-me para eu lhe contar uma história..., sim, uma história! e a rainha disse: Conte-me uma história..., sim, uma história! e 7 of :41

8 o rei disse: Obrigado! d: Um, dois, três... wordsoffile : string -> word list Dado o path dum ficheiro, produz a lista de todas as palavras do ficheiro que tenham comprimento três ou maior. As palavras devem aparecer pela ordem em que ocorrem no ficheiro. # wordsoffile "/tmp/silly/d" ;; - : word list = [ ['d';'o';'i';'s']; ['t';'r';'ê';'s'] ] adddoc : word list -> string -> lexforest -> lexforest Dada uma lista das palavras dum ficheiro e o nome desse ficheiro, insere numa floresta lexical todas essas palavras. O nome do ficheiro deve ser um nome simples, não um path. # adddoc [ ['d';'o';'i';'s']; ['t';'r';'ê';'s'] ] "d" [] ;; - : lexforest = [LTree ('d', [], [LTree ('o', [], [LTree ('i', [], [LTree ('s', [("d", 0)], [])])])]); LTree ('t', [], [LTree ('r', [], [LTree ('ê', [], [LTree ('s', [("d", 1)], [])])])])] makeindex : string -> lexforest Dado o path duma directoria, cria o correspondente índice invertido. No Linux, para obter o nome de todos os ficheiros duma directoria use seguinte função: let files dir = List.filter (fun s -> String.get s 0 <> '.') (Array.to_list (Sys.readdir dir)) ;; # makeindex "/tmp/silly" ;; - : lexforest = (* too large to print *) buildquery : string -> word list list A partir duma string produz uma lista de elementos de pesquisa. Cada elemento de pesquisa é uma lista de palavras. # buildquery "história 'uma rainha'" ;; - : word list list = [ [['h'; 'i'; 's'; 't'; 'ó'; 'r'; 'i'; 'a']]; [['u'; 'm'; 'a']; ['r'; 'a'; 'i'; 'n'; 'h'; 'a']] ] rank: word list list -> lexforest -> string list Dada uma lista de elementos de pesquisa e um índice invertido, produz uma lista de nomes de ficheiros de acordo com as regras de ranking. # rank (buildquery "história 'uma rainha'") (makeindex "/tmp/silly") ;; - : string list = [ "a" ; "b" ] Regras principais O programa tem de incluir logo nas primeiras linhas do ficheiro ".ml", em comentário, o nome e número dos dois alunos que realizaram o projecto. O programa tem ainda de incluir um outro comentário inicial, com cerca de meia página, 8 of :41

9 referindo se os objectivos do projecto foram atingidos ou não (neste último caso quais não foram atingidos?) e ainda possivelmente alertando para alguns aspectos da implementação que possam ser menos óbvios para o avaliador. O projecto é para ser realizado por grupos de dois alunos. Um projecto entregue por três ou mais alunos vale zero valores. Poderão ser permitidos grupos de 1 aluno em circunstâncias especiais que têm de ser bem explicadas no comentário inicial atrás referido. Os grupos podem mudar de trabalho para trabalho. Na realização deste projecto é proibido usar os mecanismos imperativos que a linguagem OCaml suporta (excepto no tratamento das declarações - esse código já é dado na secção "Ajuda"). Mesmo que desenvolva o programa em Windows ou no MacOS, a versão final do seu programa deverá correr no sistema Linux. Faça essa verificação, pois é no sistema Linux que a correcção do projecto será efectuada. Programe as funções recursivas usando o método indutivo. Também pode usar livremente funções de biblioteca, especialmente as disponíveis no módulo List. Associe um comentário breve a cada função explicando o que ela faz. O comentário pode ser em Português ou Inglês. O programa deve ser bem indentado, por forma a ficar bem legível. Além disso, a largura do programa não deve exceder as 80 colunas para poderem ser impressos. Podem haver algumas excepções, muito pontuais. O não cumprimento das regras anteriores implica penalizações automáticas na nota. Regras de entrega Será activado um concurso do Mooshak, que servirá para submeter os trabalhos. Os detalhes da forma de fazer a submissão serão divulgados nessa altura. Até lá preocupe-se apenas em escrever um bom programa. Depois do prazo limite ainda se aceitam trabalhos atrasados, mas com forte penalização na nota: 2 valores de penalização por cada dia de atraso, e apenas durante dois dias. Outras regras Apesar de o projecto ser de grupo, cada aluno, a título individual, tem a responsabilidade de responder por todo o projecto. Assim é indispensável que os dois membros de cada grupo programem efectivamente. O ideal seria que cada grupo dividisse o projecto em duas partes, e que o desenvolvimento de cada uma das duas partes fosse "comandada" por um aluno distinto, sempre em diálogo com o outro. Não se proíbe que alunos de turnos práticos diferentes façam grupo. Isso é apenas desaconselhado. Não terá lugar qualquer pré-inscrição dos grupos. Basta que nos trabalhos submetidos figurem nomes de alunos inscritos na cadeira. A nota máxima do projecto é 20 valores. Avaliação A nota do projecto será em grande parte determinada por meios automáticos, através do Mooshak. Portanto é essencial respeitar a especificação contida neste enunciado. 9 of :41

10 Mas, relativamente a parte do código que respeita a especificação e que funciona, também haverá uma apreciação mais subjectiva da qualidade por parte dos docentes, tendo em conta aspectos, tais como: organização, clareza e simplicidade das ideias programadas, bom uso da linguagem, legibilidade do código. Não é obrigatório fazer o trabalho completo para obter nota positiva. Mas, claro, vale a pena trabalhar para produzir uma solução bastante completa e com a melhor qualidade possível. Observações Os grupos são incentivados a discutir entre si os detalhes da realização do projecto (inclusivamente no fórum). Mas sempre que chega o momento de escrever código concreto, esse tem de ser um esforço interno a cada grupo. A escrita de código exige esforço intelectual, mas só com esforço se consegue evoluir. O objectivo deste projecto é levar os alunos a praticar. Um aluno que pratique de forma genuína ganha experiência e provavelmente não terá dificuldade em conseguir aprovação no exame final. Cuidado com as fraudes. Por exemplo, se alguém dum grupo oferecer o projecto resolvido a um elemento de outro grupo, trata-se duma fraude envolvendo dois grupos (já tem acontecido). Também se um grupo deixa distraidamente a área aberta e se alguém de outro grupo "rouba" o projecto, então também se considera fraude dos dois grupos (já tem acontecido). Ainda um terceiro caso: se dois grupos se juntam para fazer o projecto conjuntamente e depois o entregam em duplicado, então também se considera fraude (já tem acontecido). Em suma, cada grupo é responsável pelo seu projecto e não o pode oferecer, directa ou indirectamente, a outro grupo. Note que é muito melhor ter zero num dos quatro projectos do que ser excluído da cadeira por motivo de fraude. Final Bom trabalho! Esperamos que goste. 10 of :41