Um eine Datei in Prolog zu lesen oder zu schreiben bietet die Prolog-Bibliothek viele Prädikaten. Mittels der Prädikat

Transkript

1 Lesen und schreiben aus einer Datei Um eine Datei in Prolog zu lesen oder zu schreiben bietet die Prolog-Bibliothek viele Prädikaten. Mittels der Prädikat /* working_directory(-old, +New) kann man den aktuelle Verzeichniss ändern bzw. durch den Aufruf von working directory(path, Path) das aktuelle Verzeichnis ablessen. open(file, read, Stream, [alias(in\_file)]) Öffnet die angegebene File zum Lesen und markiert den Inputstream mit in file. open(file, write, Stream, [alias(out\_file)]) Öffnet die angegebene File zum Schreiben und markiert den Outputstream mit out file. close(+stream) Schliesst der angegebenen Stream. Häufig ist das folgende repeat, % Markiert den Platz ab welche nach Alternativen gesucht wird ( Bedingung % Falls die Bedingung einmal true wird, wird mit dem Cut die repeat- ->! % Schleife abgebrochen ; % else Aktion, % tue etwas fail % Setze false, damit den Interpreter nach weitere Alternativen suchen kann, % d.h. tue der nexte Durchlauf. ) Programmkonstrukt sehr nützlich z.b. das folgende Prädikat liest eine Datei und gibt ihre Inhalt auf die Konsole aus. read_and_print_file(file):- open(file,read,stream), repeat, ( at_end_of_stream(stream) ->! ; get_char(stream, Char), write(char), fail ), Programmieren sie einen Prädikat /* copy_file(+input_file,+output_file)<- welches das obere Konstrukt benutzt um eine Datei in eine andere Datei zu kopieren. Man sieht sofort, dass bei der oberen repeat-konstruktion keine Parameterübergabe oder Mitführung von Listen in den einzelne Durchlaufe möglich ist. Dacher ist sinnvoll ein eigenes Prädikat zu schreiben, das flexibel den Stream behandelt. 1

2 /* pred(+stream,?param1 oder -Liste1,?Param2 oder -Liste2,...)<- pred(stream, Parameter1 oder Liste1, Parameter2 oder Liste2,...):- not(at end of stream(stream)), % Solange das Ende des Streams nicht erreicht wurde action, % tue etwas % Schneide die Alternativen, damit das Stream % korrekt geschlossen werden kann pred(stream, Prameter1 oder List1,...). % Nexter Durchlauf, wobei die Parametern % direkt übergeben werden und die Listen sind % das Ergebniss aus dem nexten Durchlauf. Konkretes Beispiel: /* get_file_in_codes(+file,-codes)<- get_file_in_codes(file,codes):- open(file,read,stream), get_codes(stream,codes). % Das Pr"adikat get_codes(stream,[code Codes]):- get_code(stream,code), get_codes(stream,codes). get_codes(stream,[]):- Ein weiteres Beispiel sollten Sie schreiben, welche eine Datei z.b.: line1 line2 line3 einliest und in eine Liste, deren Elementen Listen mit den Zeileninhalt sind z.b. Liste =[[l, i, n, e, 1 ], [l, i, n, e, 2 ], [l, i, n, e, 3 ]], speichert. Das Predikat soll die folgende Schnittstelle haben Hinweis: /* read_file_in_lines(+file,-lines)<- Benutzen einen Parameter Delim= n. Man wandelt eine Code in eine Character und umgekehrt mittels das Prädikat /* char_code(?char,?code)<- Denken Sie an ein drittes Predikat welche die Line-Listen bildet. Die Codes bzw. die Chars lassen sich genau so wie in C++ klassifizieren, unter?- help(4-22). 2

3 oder finden Sie eine Beschreibung für die verschiedenen Char-Typen in Prolog. Schreiben Sie ein Prädikat /* split_file_in_types(+file,-types)<- das eine Datei einliest und die Zeichen nach sienen Type anordnet. Zulässige Types sind csymf, digit, punct, newline und space. Beispiel: Sei die Datei ddb/input.txt : pred(x,y):- write(x), write(y). gegeben, dann liefert den Aufruf?- split_file_in_types( ddb/input.txt,types),write(types). Types = [csymf:[p, r, e, d], punct:[ ( ], csymf:[ X ], punct:[ (, )], csymf:[ Y ], punct:[ ), :, -], newline:[ \n ], space:[ \t ], csymf:[w, r, i, t, e], punct:[ ( ], csymf:[ X ], punct:[ ), (, )], newline:[ \n ], space:[ \t ], csymf:[w, r, i, t, e], punct:[ ( ], csymf:[ Y ], punct:[ ),. ], newline:[ \n ]]; No?- Anleitung: Sreiben Sie ein Prädikat /* ordne_type(?char,?type)<-,das?type mit dem Typ von?char gefolgt von Doppelpunkt und eine einlementige Liste mit?char unifiziert. Schreiben Sie ein Prädikat /* split_in_types_list(+stream,-types)<-, das jedes Zeichen aus dem Stream seinen Typ anordnet. z.b.?- open( ddb/input.txt,read,stream), split_in_types_list(stream,types). Stream = \$stream ( ) Types = [csymf:[p], csymf:[r], csymf:[e], csymf:[d], punct:[ ( ], csymf:[ X ], punct:[ (, )], csymf:[ Y ], punct:[ ) ], punct:[:], punct:[-], newline:[ \n ], space:[ \t ], csymf:[w], 3

4 csymf:[r], csymf:[i], csymf:[t], csymf:[e], punct:[ ( ], csymf:[ X ], punct:[ ) ], punct:[ (, )], newline:[ \n ], space:[ \t ], csymf:[w], csymf:[r], csymf:[i], csymf:[t], csymf:[e], punct:[ ( ], csymf:[ Y ], punct:[ ) ], punct:[. ], newline:[ \n ]] ; No?- Schreiben Sie ein Prädikat /* merge_types(+types,-merged)<-, welches benachbarte Zeichen von gleichen Typ zusammenfasst. oder Sie können die gelesenen Zeichen sofort anordnen, d.h. ohne den Stream zuerst in einer Liste zu speichern. In diesem Fall denke man an weitere Listen die eine muss am Ende der Rekursion direkt übergeben werden. Mit dem bis jetzt gelernten Techiken zum Arbeit mit einem Stream überlegen Sie sich wie könnte ein search in file(+file,+regex) Prädikat ohne das Zwischenspeichern des Codes in einer Liste implementiert werden? 4

5 Musterlösungen: /* copy_file(+input_file,+output_file)<- copy_file(file1,file2):- open(file1,read,_,[alias(in)]), open(file2,write,_,[alias(out)]), repeat, ( at_end_of_stream(in) ->! ; get_code(in, Code), put_code(out,code), fail ), close(in), close(out). /* read_file_in_lines(+file,-lines)<- read_file_in_lines(file,lines):- open(file,read,stream,[alias(in_file)]), read_from_stream(stream, \n,lines). read_from_stream(stream, Delim,[Line Lines]):- get_next_line(stream,delim,line), read_from_stream(stream,delim,lines). read_from_stream(stream,_,[]):- get_next_line(stream,delim,[char Chars]):- get_char(stream,char), Char \= Delim, get_next_line(stream,delim, Chars). get_next_line(_,_,[]). 5

6 /* split_file_in_types(file,types_2)<- split_file_in_types(file,types_2):- open(file,read,stream), split_in_types_list(stream,types_1), write(types_1), merge_types(types_1,types_2). /* split_in_types_list(+stream,-types)<- split_in_types_list(stream,[type Types]):- get_char(stream,char), ordne_type(char,type), split_in_types_list(stream,types). split_in_types_list(stream,types):- split_in_types_list(stream,types). split_in_types_list(stream,[]):- ordne_type(char,csymf:[char]):- char_type(char,csymf). ordne_type(char,digit:[char]):- char_type(char,digit). ordne_type(char,punct:[char]):- char_type(char,punct). ordne_type(char, newline:[char]):- char_type(char, newline). ordne_type(char,space:[char]):- char_type(char,space). /* merge_types(types,merged)<- merge_types(types,merged):- [T:_ _] = Types, merge_types(types,t:[],[],merged). merge_types([last:char Xs],Last:L,Merged,Merged2):- append(l,char,m), merge_types(xs,last:m,merged,merged2). merge_types([x Xs],Last:L,Merged,Merged2):- append(merged,[last:l],m), merge_types(xs,x,m,merged2). merge_types([],last:l,merged,m):- append(merged,[last:l],m). 6