Eingang in Prolog

Question

arbeite ich zur Zeit auf einem rekursive Prolog-Programm Routen miteinander zu verknüpfen ein Grund GPS des Birmingham-Bereichs zu schaffen. Im Moment kann ich Ausgang erhalten, wie so:

Input

routeplan(selly_oak, aston, P).

Output

P = [selly_oak, edgbaston, ... , aston]

Was würde Ich mag zu tun ist mein Programm eine Art Schnittstelle bieten, also wenn ich etwas entlang der Linien geben von:

Route from selly_oak to aston

Es würde mich mit:

Go from selly_oak to edgbaston
Go from edgbaston to ...
Finally, Go from ... to aston.

Prolog ist eine mächtige Sprache, damit ich nehme an, dies ohne weiteres möglich ist, aber viele der Bücher, die ich genommen habe aus scheinen über diesen Teil zu überspringen. Soweit ich weiß, ich habe etwas entlang der Linien von Schreib () verwenden und lesen (), obwohl die Details zu mir unbekannt sind.

Könnte jemand hier ein Prolog Anfänger mit ein paar grundlegende Beispiele oder Links zu weiteren Informationen?

EDIT: Viele dieser Antworten scheinen sehr kompliziert, wo die Lösung nur etwa 5-10 Zeilen Code sein sollte. in einem Wert zu lesen, ist kein Problem, da ich etwas entlang der Linien von tun können:

find:- 
    write('Where are you? '), 
    read(X), 
    nl, write('Where do you want to go? '),
    read(Y), 
    loopForRoute(X,Y).

Ich würde es vorziehen, wenn die Ausgabe aus Schreib mit geschrieben werden kann () so eine neue Zeile (nl) verwendet werden kann, so dass sie durch die Ausgabe über zeigen wie.

Wenn dies meine Eingabe ist, wie würde ich dann die obere routeplan arrangieren () mit diesen Eingängen zu arbeiten? Auch wenn ich die Linien für diese Stationen als zusätzliche Parameter hinzuzufügen waren, wie würde diese dann umgesetzt werden? Alle Links sind am Anfang der Datei definiert wie folgt:

rlinks(selly_oak, edgbaston, uob_line).
rlinks(edgbaston, bham_new_street, main_line).

Daher wird mit dieser Information würde es gut sein, um die Linie als so zu lesen.

Go from selly_oak to edgbaston using the uob_line
Go from edgbaston to ... using the ...
Finally, go from ... to aston using the astuni_line

Answer 1

Für diese Art der Sache, ich schaffe in der Regel Shell Prädikate. So in Ihrem Fall ...

guided:-
    print('Enter your start point'),nl,
    read(Start),
    print('Enter your destination'),nl,
    read(Dest),
    routeplan(Start, Dest, Route),
    print_route(Route).

Und print_route / 1 etwas rekursiv so sein könnte:

print_route([]).

print_route([[A,B,Method]|Tail]):-
    print_route(Tail),
    print('Go from '), print(A),
    print(' to '), print(B),
    print(' by '), print(Method), nl.

Ich habe angenommen, dass die dritte Variable des routeplan / 3 Prädikats eine Liste von Listen ist. Auch, dass es, indem den Schwanz gebaut. Wenn es nicht ist, sollte es recht einfach sein, sich anzupassen. Fragen Sie in den Kommentaren.

Answer 2

Ein Buch, das solche Dinge im Detail diskutiert ist Natural Language Processing für Prolog Programmierer von Michael A. Covington.

In der Regel, was Sie tun müssen, ist

1. tokenize die Eingabe
2. Parsen die Token (zum Beispiel mit DCG) den Eingang für routeplan/3 zu bekommen
3. Anruf routeplan/3
4. Generieren etwas Englisch auf der Grundlage der Ausgabe von routeplan/3

So etwas wie dies (funktioniert in SWI-Prolog):

% Usage example:
%
% ?- query_to_response('Route from selly_oak to aston', Response).
%
% Response = 'go from selly_oak to edgbaston then go from edgbaston
%         to aston then stop .'
%
query_to_response(Query, Response) :-
    concat_atom(QueryTokens, ' ', Query), % simple tokenizer
    query(path(From, To), QueryTokens, []),
    routeplan(From, To, Plan),
    response(Plan, EnglishTokens, []),
    concat_atom(EnglishTokens, ' ', Response).

% Query parser
query(path(From, To)) --> ['Route'], from(From), to(To).
from(From) --> [from], [From], { placename(From) }.
to(To) --> [to], [To], { placename(To) }.

% Response generator
response([_]) --> [stop], [.].
response([From, To | Tail]) -->
    goto(path(From, To)), [then], response([To | Tail]).
goto(path(From, To)) --> [go], from(From), to(To).

% Placenames
placename(selly_oak).
placename(aston).
placename(edgbaston).

% Mock routeplan/3
routeplan(selly_oak, aston, [selly_oak, edgbaston, aston]).

Answer 3

Hm, wenn ich Sie richtig verstehe Sie wollen einfach nur schön die Liste Format für Druck aus, nicht wahr?

In SWI-Prolog dies funktioniert:

output_string([A,B],StrIn,StrOut) :-
 concat_atom([StrIn, 'Finally, Go from ', A, ' to ', B, '.'],StrOut),
 write(StrOut).

output_string([A,B|Rest],StrIn,StrOut) :-
 concat_atom([StrIn,'Go from ', A, ' to ', B, '.\n'],StrAB),
 output_string([B|Rest],StrAB,StrOut).

rufen Sie dann mit

output_string(P,'',_).

Es ist wahrscheinlich nicht sehr effizient, aber es macht den Job. :)

Answer 4

Hier sind ein paar Prädikate Zeilen aus einer Datei / Strom in einen Prolog Zeichenfolge zu lesen:

%%% get_line(S, CL): CL is the string read up to the end of the line from S.
%%% If reading past end of file, returns 'end_of_file' in CL first, raises
%%% an exception second time.
%%% :- pred get_string(+stream, -list(int)).
get_line(S, CL) :-
    peek_code(S, C),
    (   C = -1
    ->  get_code(S, _),
        CL = end_of_file
    ;   get_line(S, C, CL)).

get_line(_, -1, CL) :- !, CL = [].  % leave end of file mark on stream
get_line(S, 0'\n, CL) :- !,
    get_code(S, _),
    CL = [].
get_line(S, C, [C|CL]) :-
    get_code(S, _),
    peek_code(S, NC),
    get_line(S, NC, CL).

%% read_lines(L): reads lines from current input to L.  L is a list of list
%% of character codes, newline characters are not included.
%% :- pred read_lines(-list(list(char))).
read_lines(L) :-
    current_input(In),
    get_line(In, L0),
    read_lines(In, L0, L).

%% read_lines(F, L): reads lines from F to L.  L is a list of list of character
%% codes, newline characters are not included.
%% :- pred read_lines(+atom, -list(list(char))).
read_lines(F, L) :-
    fail_on_error(open(F, read, S)),
    call_cleanup((get_line(S, L0),
              read_lines(S, L0, L)),
             close(S)).

read_lines(_, end_of_file, L) :- !, L = [].
read_lines(S, H, [H|T]) :-
    get_line(S, NH),
    read_lines(S, NH, T).

Dann nehmen Sie einen Blick auf DCG s Informationen über wie eine Zeichenfolge zu analysieren.