Odczytywanie danych w różnych formatach

Odczytywanie danych
w różnych formatach
Problem INPUT-a w wolnej formie
W tym rozdziale pokażemy, jak sprawić, aby Prolog przeczytał dane w
dowolnym wybranym formacie; na końcu przedstawimy program w
Prologu, który odczytuje arkusz kalkulacyjny. Ilość uwagi
poświęconej temu działowi będzie zależała od potrzeb. Nie ma tu
logicznej teorii programowania - tylko praktyczne algorytmy. Jeśli
jesteś eksperymentatorem AI, możesz podejść do niego z lekkim
dystansem, powracając później jeśli zajdzie taka potrzeba. Lecz jeśli
jesteś producentem oprogramowania komercyjnego, może to być
rozdział który uczyni Prolog użytecznym dla twojej aplikacji.
Procedury określone w niniejszym rozdziale nie są przeznaczone do
pracy na oślep. Są tu zawarte pouczające przykłady, i zakładamy, że
przed wprowadzeniem ich do waszych programów, będziecie
studiowali, jak one działają i bardziej dokładnie dostosowywali je do
swoich potrzeb.
Konwertowanie stringów i liczb
atomowych
Zacznijmy od wejścia klawiatury(input). Chcielibyśmy, aby
użytkownik mógł wpisać cokolwiek z klawiatury i aby poszło
to w Prologu jako atom lub liczba, np.:
?- read_atom(What).
this is an atom (typed by user)
What = 'this is an atom'
?- read_num(What).
3.1416 (typed by user)
What = 3.1416
Aby to zadziałało, będziemy polegać na read_str, określonym
w rozdziale 3 i pokazanym wraz z innymi predykatach.
Istnieją trzy sposoby podejścia do
procesu konwersji:
•
Po pierwsze, ISO Prolog Standard definiuje dwa wbudowane
predykaty, atom_codes i number_codes, które przechodzą,
odpowiednio, atomy w stringi i liczby w stringi, np.:
?- atom_codes(abc,What).
What = [97,98,99]
?- atom_codes(What,"abc").
What = abc
?- number_codes(3.14,What).
What = [51,46,49,52]
?- number_codes(What,"3.14").
What = 3.14
Jeśli number_codes daje stringa, który nie podaje prawidłowego
numeru, lub jeżeli jeden z jego argumentów jest niewłaściwego
typu, wywołuje to stan runtime error.
Istnieją trzy sposoby podejścia do
procesu konwersji:
•
Wiele starszych Prologów używa name/2 aby wykonać oba rodzaje konwersji:
?- name(abc,What).
What = [97,98,99]
?- name(What,"abc").
What = abc
?- name(3.14,What).
What = [51,46,49,52]
?- name(What,"3.14").
What = 3.14
Ale istnieje kilka Prologów w których name posiada zachowanie określone dla kodów atomowych i
konwersja liczb odbywa się w zupełnie inny sposób. Ponadto, name ogólnie radzi sobie z błędami,
po prostu nie kompilując się, ale należy sprawdzić implementację aby się o tym upewnić. W dalszej
części zakładamy, że już z powodzeniem wdrożony read_atom i read_num, zdefiniowano mniej
więcej w następujący sposób:
read_atom(Atom) :- read_str(String), atom_codes(Atom,String).
read_num(Num) :- read_str(String), number_codes(Number,String).
i że są one w pliku READSTR.PL (Przykład 5.1). Pamiętajmy, aby sprawdzić, czy instrukcja działa
poprawnie w twoim Prologu.
Istnieją trzy sposoby podejścia do
procesu konwersji:
•
Jest jeszcze trzeci sposób konwersji stringów na liczby:
wybierać cyfry jedna po drugiej, konwertować je do ich wartości
liczbowych i wykonać obliczenia. W szczególności to, co robimy to
utrzymanie sumy bieżącej, która rozpoczyna się od 0. Za każdym
razem dostajemy inną cyfrę, mnożymy sumę przez 10, a następnie
dodajemy do niej wartość tej cyfry. Na przykład, konwertując string
"249", należy wykonać następujące obliczenia:
Digit ‘2’ (0 10) + 2 = 2
Digit ‘4’ (2 10) + 4 = 24
Digit ‘9’ (24 10) + 9 = 249
Możemy nigdy nie musieć używać tego sposobu, ale algorytm jest
warty zapamiętania w przypadku, gdy będziemy mieli do czynienia z
nietypowym bazami lub formatami (np. system szesnastkowy, lub
liczby rozdzielone przecinkami).
• przyklady
Łączenie naszego kodu z wyrazami
Załóżmy, że piszemy program, w którym chcemy używać predykatów, które są
zdefiniowane w READSTR.PL. Mamy dwie możliwości:
– Możemy kopiować READSTR.PL, cały, do swojego programu.
– Możemy wstawić dyrektywę w programie, która powoduje, że READSTR.PL jest
przetwarzany. Drugim z nich jest to, co będziemy badać tutaj. W ISO Prolog oraz w
wielu istniejących implementacjach (w tym Quintus, SWI i LPA), dyrektywa
:- ensure_loaded('readstr.pl').
oznacza: "Jeśli READSTR.PL nie jest jeszcze skonsultowany , skonsultuj go teraz.„
(Oczywiście, to działa tylko wtedy, gdy READSTR.PL jest w bieżącym katalogu.) Inne
Prologi nie mają ensure_loaded, dlatego uzasadnione jest stosowanie zastępczego
reconsulta, jak poniżej:
:- reconsult('readstr.pl').
Po napotkaniu tej linii w programie, system Prolog skonsultuje READSTR.PL, nawet
jeśli READSTR.PL skonsultowano wcześniej. To trochę marnuje czas, ale nic
poważnego się nie stanie.
Weryfikacja danych Użytkownika
Za każdym razem gdy Program akceptuje od użytkownika wejście z klawiatury mogą
powstać dwa problemy:
– Użytkownik może wpisać coś, co nie jest akceptowalna odpowiedzią (np. 4 gdy
wybory w menu to 1, 2 i 3).
– Użytkownik może wpisać coś, co nie jest nawet interpretowane (np. xyz, gdy
oczekiwana jest liczba).
W obu przypadkach program powinien zrobić coś sensownego. Wygodne w użyciu jest
zastosowanie powtarzającej się pętli aby sprawdzić poprawności danych
wprowadzanych przez użytkownika, na przykład:
get_number(N) :- repeat,
write('Type a number between 1 and 3: '),
read_num(N),
N =< 3,
N >= 1,
!.
Weryfikacja danych Użytkownika
Jeśli użytkownik wpisze numer, który jest poza zakresem, wykonanie cofa się do
powtórzenia, komputer wyświetla monit ponownie, a użytkownik dostaje jeszcze
jedną szansę. Jeśli jest kilka odrębnych wyborów, wygodne jest użycie member z
listy alternatyw:
get_choice(C) :- repeat,
write('Type a, b, or c: '),
read_atom(C),
member(C,[a,b,c]),
!.
Nadal szybsze, ale cięższe(większe objętościowo), jest następujące podejście:
get_ok(C) :- repeat,
write('Type a, b, or c: '),
read_atom(C),
ok(C),
!.
ok(a).
ok(b).
ok(c).
Konstruowanie Menu
Ponieważ Prolog jest dobry w obsłudze skomplikowanych struktur danych, to prostą
sprawą jest napisać procedurę, która będzie tworzyć i wyświetlać menu gdy
powiesz jakie powinny być jego wybory. Przykład 5.2 przedstawia jeden przykład.
Zdefiniowany tam Generator menu jest wywoływany przez zapytania, takie jak to:
?- menu([item('Georgia',ga),item('Florida',fl),item('Hawaii',hi)], What).
1 Georgia
2 Florida
3 Hawaii
Your choice (1 to 3): 2
What = fl
Oczywiście menu / 2 byłoby normalnie wywoływane z innej procedury, która musi
wyświetlać menu. Jej pierwszy argument składa się z listy form
[item(Message1,Value1),item(Message2,Value2),item(Message3,Value3)]
Z maksymalnie 9 elementów, każdy składający się z wiadomości, która ma być
wyświetlana i wyniku, który ma być zwrócony (w drugim położeniu argumentu)
jeżeli użytkownik wybierze tę opcję.
Wiadomość jest zwykle atomem;"value" może być terminem jakiegokolwiek rodzaju.
Czytanie plików z „get byte”
Gdy przechodzimy od czytania z klawiatury do odczytu plików, pojawiają się dwa nowe
problemy:
- Czy będziemy uzyskiwać każdy bajt pliku, nienaruszony i niezmieniony?
- Co wydarzy się na końcu pliku?
Tutaj, niestety, różne implementacje Prologu rozdzielają się. W Prologu Arity get0 po
prostu nie zadziała na końcu pliku, podczas gdy w większości innych Prologów
zwraca kod -1. w ALS Prolog, get0 pomija wszystkie bajty o wartości 0 lub 13; w
Cogent Prolog, get0 traktuje wartość 26 jako końcowy znak w pliku; w innych
Prologach, get0 zachowuje wszystkie bajty nienaruszone.
Dla uproszczenia będziemy używać predykatu ISO Prolog get_byte / 1, który czyta
każdy bajt w postaci kodu numerycznego i zwraca -1 na końcu pliku. (Różnica
między get_byte i get_code jest to, że get_byte gwarantuje, ze nie będą robione
jakieś specjalne manipulacje w znakach na końcach linii i na końcach plików lub w
kodach których nie można wyświetlić) Jeśli get_byte nie jest wbudowany w
Prologu, trzeba będzie go zdefiniować. W większości Prologów, ta definicja
wystarczy:
get_byte(C) :- get0(C).
bo get0 i get_byte to to samo. W Arity Prolog, użyj tej definicji zamiast:
get_byte(C) :- get0(C), !.
get_byte(-1).
Uchwytów plików (identyfikatorów
Stream)
W pozostałej części tego rozdziału, będziemy wykonywać wszystkie wejścia pliku(input)
przez przekierowanie standardowego inputa z poleceniem see. Robimy to
niechętnie; jest to przenośne(portable), ale ryzykowne. W szczególności, w
przypadku gdy program wyrzuca błąd podczas gdy wejście jest przekierowywane,
możemy nie być w stanie wpisać jakichkolwiek dalszych komend do systemu
Prologa. Prawie każda implementacja w Prologu to sposób, aby uzyskać dostęp do
plików poprzez uchwyty (identyfikatory Stream). Na przykład,
read(H,X)
zwykle oznacza to: "Wczytaj wyrażenie do X z pliku, którego uchwytem jest H."
uchwyt jest wartością, która jest dana podczas otwierania pliku. Niestety, składnia
dostępu do plików w ten sposób jest znacznie zróżnicowana. Proponowany system
ISO jest opisany w Załączniku A; Rzeczywista Składnia w Quintus Prolog i SWI
Prolog wygląda tak:
test :- open('myfile1.txt',read,File1),
read(File1,Term),
close(File1),
open('myfile2.txt',write,File2),
write(File2,Term),
close(File2).
Ideą jest to, że otwarty predykat otwiera plik do zarówno czytania bądź pisania oraz
tworzy instancję File1 do uchwytu. Następnie dajemy File1 jako argument
wszystkich kolejnych predykatów, które używają pliku.
Pola Stałej Długości
Wiele plików z danymi w świecie biznesu składa się z pól o stałej długości. Każda linia jest nazwana
RECORD. Pola mogą lub nie mogą składać się ze znaków i rekordy mogą lub nie muszą kończyć się
znakami na końcach linii( end–of–line). Oznacza to, że plik może lub nie być plikiem tekstowym.
Odczyt pola o stałej długości jest prosty: zaczynamy od liczby bajtów która ma być odczytana i
odliczamy w dół do 0, jak w przykładzie niżej:
% read_bytes(+N,-String) %%% wstępna wersja
% Wczytuje „N” bitów do Stringa.
read_bytes(0,[]) :- !.
read_bytes(N,[C|Rest]) :get_byte(C),
NextN is N-1,
read_bytes(NextN,Rest).
Zauważmy, że w Prologu, często odliczamy, podczas gdy zwykły język programowania liczyłby „w górę”
(dla i = 1 do n lub podobnie). To pozwala nam porównać zmienną pętli do 0 (stała) niż porównywać
do N (która ma być kolejnym parametrem dostarczonym w czasie wykonywania). Wersja read_bytes
, której używamy jest bardziej skomplikowana. Wykorzystuje jeden znak LookAhead aby sprawdzić
nieoczekiwany znak na końcu pliku(end-of-file). Możemy również zdefiniować skip_bytes, który
pomija określoną liczba bajtów, bez zapisywania ich na liście. Większość Prologów zawiera także
polecenie szukania, aby przejść do określonej pozycji w pliku o dostępie swobodnym, ale nie
używamy go tutaj ze względu na brak standaryzacji. Nawet norma ISO sprawia, że szczegóły tej
operacji są pozostawione realizatorowi.
Co teraz zrobić z danymi?
Teraz, gdy już można odczytać pliki danych z Prologa, co z nimi zrobić? W
zależności od potrzeb programu, istnieją trzy główne opcje:
- Wczytać jeden rekord naraz i w jakiś sposób go przetworzyć. To jest
odpowiednie podejście, jeśli celem programu jest praca i obliczanie czegoś
w całym pliku.
- Wczytać każdy rekord i przekonwertować go do Prologa, który następnie jest
ukazany w bazie danych. To praktyczne podejście, jeśli chcesz użyć pliku
aby odpowiedzieć na zapytania oraz gdy plik (lub jego część, którą jesteś
zainteresowany) nie jest zbyt duży. (wbudowane predykatywne statystyki
powiedzą, ile pamięci jest dostępnej w twojej implementacji Prologa.)
- Przeszukać cały plik na dysku, gdy potrzebujesz z niego informacji. To jest
najwolniejsza opcja, ale czasami jedyna praktyczna, jeśli plik jest
gigantyczny. Na szczęście, większość dużych plików baz danych może być
przeszukiwana sposobami które są szybsze niż wyszukiwanie
sekwencyjne - każdy rekord zawiera odnośniki do innych rekordów, lub
istnieje algorytm haszujący, lub oba z nich.
Pola rozdzielone przecinkami
Przykład:
4633,"Covington","M","A","Athens","Georgia„
5462,"Nute","D","E","Athens","Georgia"
123,"Vellino","A",,"Ottawa","Ontario„
przedstawia inny format danych który jest popularny w
przesyłaniu danych między pakietami oprogramowania :
COMMA–DELIMITED FIELDS, czyli tekst z pola oddzielony
przecinkami. Często, choć nie zawsze, pola alfabetyczne są
zamknięte w cudzysłowie, tak że przecinki w nich nie będą
traktowane jako separatory. Wczytywanie pól oddzielonych
przecinkami w Prologu jest proste. Kluczem do sukcesu jest
wdrożenie procedury zwanej read_until która akceptuje
maxymalną ilośc bajtów oraz włącza określony kod (koniec
pliku lub koniec linii, w zalezności co nastąpi wcześniej).
Następnie, aby przeczytać pola rozdzielane przecinkami, po
prostu wpisujemy - read_until przecinek.
Pola rozdzielone przecinkami
Cytaty mogą nieco skomplikować problem.
Bieżący algorytm służy do tego, aby przeczytać
pierwszy znak z pola, a następnie, jeśli nie jest
to cytat, read_until przecinek. Lecz jeślinpole
zaczyna się cytatem, komputer musi
read_until zamykający cytat (tym samym
uzyskując dane), a następnie read_until
przecinek (aby je odrzucić). Przykład 5.6
pokazuje kompletną implementację. (wrzucic z
wykladu)
Liczby Binarne
Nie wszystkie pliki danych składają się z drukowalnych znaków. Niektóre z pól w
jakimkolwiek pliku mogą być liczbami binarnymi. Oznacza to, że na przykład numer
36, może być reprezentowany nie jako bajty dla znaków '3' i '6', ale jako liczba
binarna 36 (100100). Małe liczby całkowite często przechowywane są w 16 bitach
(dwóch bajtach). Na przykład:
numer 1993 jest w formacie binarnym, 0000011111001001.
To nie pasuje do jednego bajta, więc jest podzielone na dwa:. 00000111 11001001.
Zadaniem programu Prolog jest to, aby przeczytać te dwa bajty (które pojedynczo
mają wartości odpowiednio 7 i 201) i umieścić je razem: (7 * 256) + 201 = 1993. W
efekcie traktujemy bajty jako baza-256 cyfr.
Istnieją trzy komplikacje. Po pierwsze: na maszynach zgodnych z IBM PC, bajty są
przechowywane w przeciwnym porządku jakiego można by było się spodziewać:
mniej znaczący bajt jest na pierwszym miejscu. (Sun SPARC umieścił bardziej
znaczący bajt pierwszy.) Po drugie: liczby ujemne są reprezentowane w zapisie
dwójki-dopełniacza(twos–complement), więc jeśli mamy 65535, to należy
przekonwertować go na 1; Faktycznie, każda wartość większa niż 32767 jest
reprezentowana przez liczbę ujemną. Po trzecie, wszelkie te obliczenia zakładają,
że arytmetyka systemu Prolog nie jest ograniczona do 16 bitów przypadających na
liczbę całkowitą. Praktycznie wszystkie systemy Prolog automatycznie przełączają
się do zmiennoprzecinkowej arytmetyki gdzie dostępne liczby całkowite nie są już
tak duże, więc nie spodziewamy się tutaj problemu. Kod do czytania podpisanych i
niepodpisanych 16-bitowych liczb całkowitych przedstawiono na przykładzie 5.7.
Czytanie arkusza kalkulacyjnego LOTUS
Przykład 5.9 przedstawia program Prolog, który odczytuje arkusze kalkulacyjne LOTUS w formacie WKS.
Ponieważ tak dużo informacji w świecie biznesu jest przechowywane w arkuszach kalkulacyjnych,
bądź są one do nich łatwo importowane , taki program może znacznie przedłużyć przydatność
Prologa. Walden (1986) daje pełny opis formatu WKS, który jest formatem pliku wykorzystywanym
przez wczesnych wersjach Lotus'a 1-2-3. Nowsze programy arkuszy kalkulacyjnych mogą nadal
używać formatu .WKS jeśli im się na to wskaże, jako, że nie jest to już ustawienie domyślnie. plik
arkusza kalkulacyjnego składa się z szeregu pól (rekordów), z których każdy obejmuje:
– 16-bitowy OPCODE (kod operacji) wskazujący typ pola;
– Liczba 16-bitowa podająca długość pola;
– Zawartość pola, która zależy od jego rodzaju.
Większość pól w zwykłym arkuszu kalkulacyjnym to NON–DATA FIELDS - to znaczy, zawierają informacje
o tym, jak wydrukować lub wyświetlić arkusz kalkulacyjny. W celu zachowania wszystkich ustawień
domyślnych, pełny ich zestaw jest zapisany w nawet najmniejszym arkuszu kalkulacyjnym. W
związku z powyższym, możemy zignorować prawie wszystkie „opcodes”(kody operacji). Te kody
operacji, które są istotne to:
0 Początek pliku
1 koniec pliku
13 Liczba całkowita
14 Stała zmiennoprzecinkowa
15 Stała tekstowa („label”)
16 Formuła z przechowywaną wartością zmiennoprzecinkową
Mimo, że nasz program nie próbuje rozszyfrować formuły, to byłoby całkiem możliwe aby to zrobić,
tworząc wyrażenia, które mogą być oceniane przy użyciu wyrażenia „is”. Możemy to zrobić
pobierając wartości zmiennoprzecinkowe, które są przechowywane razem z każdą formułą.
Podobnie jak wszystkie przykłady w tym rozdziale, LOTUS.PL czyta ze standardowego wejścia.
Oczywiście, w dowolnej praktycznej aplikacji, powinien być dostosowany do odczytu z pliku
identyfikowanego przez uchwyt.
Język i Metajęzyk
Metajęzyk jest językiem używanym do opisania innego języka. W całej tej książce opisujemy Prolog w
języku angielskim; Oznacza to, że używamy języka angielskiego jako metajęzyka dla Prologa.
Możemy używać języka angielskiego lub dowolnego języka jako metajęzyk dla każdego języka
programowania. Niektóre języki programowania, takie jak Algol, mają specjalne metajęzyki.
Prolog jest niemalże wyjątkowy, jednakże w zakresie w jakim może służyć jako własny metajęzyk.
Przejawia się to w wielu funkcjach:
– Program może tworzyć nowe funkcje poprzez obliczenia, a następnie wykonując je. W istocie,
można użyć Prologa aby opisać konstrukcje funkcji.
– Program może zbadać sam siebie(za pomocą klauzuli) i modyfikować się (używając assert i retract).
– Deklarując operatory, program może sam zmienić składnię języka Prologa
– Program w Prologu może rozszerzyć i zmodyfikować silnik inferencji, który kontroluje wykonywanie
programu. Tak więc, język może zmienić sam siebie w sposób , który wykracza poza zewnętrzną
składnię.
Funkcje te umożliwiają Prologowi robić rzeczy, które są zupełnie obce dla większości języków
programowania. Co najważniejsze, Prolog zaciera różnicę między programem a danymi. W
większości języków programowania, trzeba bardzo wyraźnie odróżnić decyzje które
podejmujemy podczas pisania programu od decyzji, które podejmuje komputer podczas
uruchamiania programu. Na przykład, wszystkie arytmetyczne wyrażenia w programie BASIC lub
Pascal są napisane przez programistę z wyprzedzeniem, choć program może zdecydować, w
czasie pracy, których z nich użyć. W Prologu program może sam siebie rozszerzyć i zmodyfikować,
podczas działania. Z tego powodu często nauka Prologa przychodzi łatwiej początkującym
programistom, niż ludziom którzy programowali już w wielu językach programowania i nauczyli
się już, że komputer nie pracuje w ten sposób.
Zbieranie alternatywnych rozwiązań
do listy
Rozważmy małą bazę danych:
father(michael,cathy).
father(charles_gordon,michael).
father(jim,melody).
Możemy zapytać Prologa, aby wyświetlił imiona wszystkich ojców wydając
zapytanie takie jak:
?- father(X,_), write(X), nl, fail.
To jest: Znajdź X, dla którego ojciec (X, _) się powiedzie, wypisać, i wycofać
aby znaleźć
kolejne.
Ale co, jeśli zamiast wyświetlania imion, chcemy je dalej przetwarzać jako
lista? Stoi przed dylematem. W celu uzyskania wszystkich imion, program
musi wracać się. Ale w celu skonstruowania listy, musi użyć rekurencji,
przechodząc przez częściowo zbudowaną listę od jednej iteracji do
następnej – czego program wykorzystujący backtracking nie zrobi.
Zbieranie alternatywnych rozwiązań do listy
Jedną z możliwości byłoby użycie „assert” i „retract” do wdrożenia mniej więcej
następującego algorytmu:
1. Wracać się przez wszystkie rozwiązania father (X, _), przechowywując każdą
wartość X oddzielnie w bazie danych;
2. Po wypróbowaniu wszystkich rozwiązań, wykonać pętlę rekurencyjną, która cofnie
wszystkie zapisane klauzule i zgromadzi informacje na liście.
Na szczęście nie musimy przechodzić przez to wszystko. Wbudowany predykat „findall”
zgromadzi rozwiązania kwerendy do listy, bez potrzeby wykonywania „asserts” i
„retracts”. Oto przykład:
?- findall(X,father(X,_),L).
L = [michael,charles_gordon,jim]
Bardziej ogólnie, zapytanie z formularza
?- findall(Variable,Goal,List).
Utworzy instancję „List” do listy wszystkich instancji „Variable”, które odnoszą się do
rozwiązań „Goal”. Następnie można przetwarzać tą listę, w jakikolwiek sposób
chcemy.
Pierwszym argumentem FindAll nie musi być zmienna; może to być dowolne pojęcie
ze zmiennymi. Trzeci argument będzie wówczas listą instancji pierwszego
argumentu z której każdy odpowiadać będzie rozwiązaniu. Na przykład:
?- findall(Parent+Child,father(Parent,Child),L).
L = [michael+cathy,charles_gordon+michael,jim+melody]
Znakiem (+) jest tutaj po prostu funktor wpisany pomiędzy swoimi argumentami.
Używanie „bagof” i „setof”
BAG jest matematycznym obiektem takim jak zbiór z tym wyjątkiem,
że ten sam element może się wnim pojawić więcej niż raz.
Oczywiście „findall” tworzy „bag”, nie zbiór, ponieważ to samo
rozwiązanie może pojawić się w nim więcej niż raz. Podobnie
„bagof” tworzy torbę w formie listy zawierającej wszystkie
rozwiązania kwerendy; „setof” robi to samo oprócz tego, że lista
jest posortowana w kolejności alfabetycznej, a duplikaty są
usuwane.
Operacja sortowania wymaga dodatkowego czasu, ale może to być
korzystne, ponieważ chroni nas przed duplikatami w późniejszej
pracy.
Największa różnica między „bagof” i „setof” z jednej strony, a FindAll z
drugiej strony, dotyczy sposobu obsługi zmiennych w „Goals”, któr
nie występują w X. Jak można się spodziewać, „findall” traktuje je
jako „niewystępujące” na każdym przejściu.
Używanie „bagof” i „setof”
Zatem:
?- findall(X,parent(X,Y),L).
oznacza "Znajdź każdego kto jest rodzicem kogokolwiek" – Y
nie musi mieć takiej samej wartości dla każdego z
rodziców. Ale
?- bagof(X,parent(X,Y),L).
oznacza "Znajdź wszystkie wartości X-a, które wiążą się z jakąś
konkretną wartością Y-a.„ Inne wartości
Y-a przyniosą alternatywne rozwiązania do bagof, a nie
dodatkowe wpisy do tej samej listy.
Używanie „bagof” i „setof”
Oto przykład:
parent(michael,cathy).
parent(melody,cathy).
parent(greg,stephanie).
parent(crystal,stephanie).
?- findall(X,parent(X,Y),L).
X = _0001, Y = _0002, L=[michael,melody,greg,crystal]
?- bagof(X,parent(X,Y),L).
X = _0001, Y = cathy, L = [michael,melody] ;
X = _0001, Y = stephanie, L = [greg,crystal]
?- setof(X,parent(X,Y),L).
X = _0001, Y = cathy, L = [melody,michael] ;
X = _0001, Y = stephanie, L = [crystal,greg]
Oczywiście „setof” jest jak „bagof” z wyjątkiem, że sortuje listy i usuwa duplikaty (jeśli jakiekolwiek
występują).
Ale jest inny sposób. Można zrobić to:
?- bagof(X,Y^parent(X,Y),L).
X = _0001, Y = _0002, L = [michael,melody,greg,crystal]
Poprzedzenie Y^ wskazuje, że Y ma być traktowana jako egzystencjalnie skwantyfikowana.
Znajdowanie najmniejszego, największego, lub
„najlepszego” rozwiązania
Dość często, będziemy chcieli znaleźć "najlepsze" z wielu
alternatywnych rozwiązań dla zapytania. Oczywiście
"najlepsze" oznacza różne rzeczy w różnych sytuacjach, ale
podstawową ideą jest to, że ze wszystkich możliwych
rozwiązań, chcesz to, które przewyższa wszystkie inne
zgodnie z pewnymi kryteriami. Istnieją trzy główne metody:
– Użyć „setof” i wykorzystać wbudowany proces sortowania,
tak że "najlepsze" rozwiązanie wychodzi na początku (a
może na końcu) listy;
– Użyć „bagof” lub „setof” a następnie pracować z listą , aby
wybrać rozwiązanie, którego potrzebujesz;
– Szukaj bezpośrednio „najlepszego” rozwiązania, porównując
każdą alternatywę na tle wszystkich pozostałych
Znajdowanie najmniejszego, największego, lub
„najlepszego” rozwiązania
Popracujmy z następującą bazą danych:
age(cathy,8).
age(sharon,4).
age(aaron,3).
age(stephanie,7).
age(danielle,4).
Które dziecko jest najmłodsze? Spróbujemy pierwszej i trzeciej strategii, pozostawiając
drugą jako ćwiczenie. Jest to łatwe do wykonania. „setof” daje nam wiek
najmłodszego dziecka. Weźmy pod uwagę te zapytania:
?- setof(A,N^age(N,A),L).
L = [3,4,7,8]
?- setof(A,N^age(N,A),[Youngest|_]).
Youngest = 3
Pierwsza kwerenda pobiera posortowaną listę wieku dzieci; druga kwerenda pobiera
tylko pierwszy element tej listy.
(dalszy ciąg przykład str. 23)
Zapytania Intensjonalne i
Ekstensjonalne
Wiemy, w jaki sposób w Prologu stwierdzić fakty na temat jednostek oraz uogólnień:
dog(fido).
“Fido is a dog.”
animal(X) :- dog(X).
“Dogs are animals.”
Wiemy również, jak zadawać pytania dotyczące jednostek:
?- dog(fido).
“Is Fido a dog?”
Ale w jaki sposób możemy zadać pytanie "Czy psy są zwierzętami?" Istnieją dwa
znaczenia takiego pytania:
(1) Czy istnieje reguła lub zbiór zasad za pomocą których możne dowieść, że
wszystkie psy są zwierzętami?
(2)Niezależnie od tego co mówią zasady, czy jest to przypadek, że wszystkie psy
wymienione w bazie danych są w rzeczywistości zwierzętami?
Możemy nazwać (1) i (2) intensjonalną oraz ekstensjonalną operacją, odpowiednia na
pytanie „Czy psy są zwierzętami?” Spośród nich (1) jest przede wszystkim pytaniem
o zawartość zestawu reguł, a (2) pyta Prologa o zrobienie generalizacji zestawu
znanych już jednostek. Oczywiście, jeżeli pytanie (1) jest prawdziwe to pytanie (2)
również będzie, aczkolwiek konwersja nie jest tutaj przypadkiem do rozważania.
Zapytania Intensjonalne i Ekstensjonalne
Będziemy realizować pytanie (2) . Intuicyjnie, chcemy powiedzieć, że "Wszystkie psy są zwierzętami". To prawda, jeśli (a)
istnieje co najmniej jeden pies w bazie danych, oraz (b) nie ma psa w bazie danych, która nie jest zwierzęciem.
Wymagamy, że musi być co najmniej jeden pies w bazie danych, tak że, na przykład zdanie, "Ślimaki są małpami" nie
wyjdzie jako prawdziwe tylko dlatego, że nie ma ślimaków w bazie danych.
Chcemy zdefiniować predykat for_all(GoalA, GoalB), który się powiedzie, jeśli wszystkie instancję które czynią GoalA
prawdziwym, czynią prawdziwym również GoalB. Jeżeli wyniki mają być sensowne, GoalA i GoalB muszą dzielić się
co najmniej jedną zmienną. Moglibyśmy wtedy zapytać: "Czy psy zwierzętami?" za pomocą zapytania:
?- for_all(dog(X),animal(X)).
Jeden ze sposobów zdefiniowania „for_all” jest następujący:
% for_all(GoalA,GoalB)
% Powiedzie się, jeśli wszystkie rozwiązania GoalA będą spełniać również rozwiązania GoalB,
% oraz istnieje co najmniej jedno rozwiązanie dla obu funkcji.
for_all(GoalA,GoalB) :\+ (call(GoalA), \+ call(GoalB)), % 1
call(GoalA), % 2
!. % 3
Zagnieżdżone negacje w linii 1 mogą być mylące. Linia pierwsza nie powiedzie się jeśli funkcja złożona(compound goal)
się powiedzie i vice cersa.
(call(GoalA), \+ call(GoalB))
Z kolei ta złożona funkcja(compound goal) , powiedzie się jeżeli istnieje sposób aby GoalA zadziałał ( tworząc instancję
kilku zmiennych współdzielonych w procesie z GoalB ) tak, że następnie GoalB zawiedzie. Jeśli linia 1 się uda,
następnie linia 2 sprawdza, czy rzeczywiście istnieje co najmniej jeden pies w baza danych. Nie możemy odwrócić
kolejność linii 1 i 2, ponieważ linia 2 tworzy instancje pewnych zmiennych, które muszą być potem usunięte w linii 1.
Cięcia w linii 3 zapewniają, że nie generujemy fałszywych alternatyw dokonując poprawnego zaimplementowania
linii 2 dowolnymi sposobami.
Definicje operatora
Większość funktorów w Prologu jest zapisana
bezpośrednio przed nawiasami argumentu listy:
Funktor(arg1, arg2). Funktory, które mogą być napisane
w innych pozycjach są nazywane Operatorami. Na
przykład, struktura +(2,3) może być zapisana jako 2+3,
ponieważ jej funktor, +, Jest operatorem wrostkowym.
Nie należy mylić operatorów z operacjami. Niektóre
operatory oznaczają arytmetyczne operacje(+-*/), ale
inne operatory służą zupełnie innym celom. W
rzeczywistości jakikolwiek funktor w Prologu może być
uznany za operator oraz zmieniając w ten sposób tylko
jego składnie, nie znaczenie.
Powszechnie predefiniowane operatory w
PROLOGu.
Pierwszeństwo
1200
1200
1100
1050
1000
900
Specyfikator
xfx
fx
xfy
xfy
xfy
fy
700
xfx
500
400
200
200
yfx
yfx
xfy
fy
Operatory
:- -->
:- ?;
->
,
\+ (lub w niektorych
Prologach, not)
= \= == \== @< @=< @> @>= is =:= =\= <
=< > >= =..
+* / // mod
^
-
Specyfikatory składni operatora
Specyfikator
fx
fy
xf
yf
xfx
xfy
yfx
Znaczenie
Prefix, not associative
Prefix, right-associative (like \+)
Postfix, not associative
Postfix, left-associative
Infix, not associative (like =)
Infix, right-associative (like the
comma in compound goals)
Infix, left-associative (like +)
Nadawanie znaczeń operatorom
Definicje operatora określają jedynie jego składnie. Znaczenie lub semantyka operatora zależy już od
programisty.
W przeszłości niektóre Prologi używały ampersandu (&) zamiast przecinka aby łączyć elementy funkcji
złożonych . Jest to wielką zaletą, ponieważ złożone funkcje nie wyglądają jak listy argumentów;
zapytanie
?- call(p(a) & q(a) & r(a)).
wyraźnie wywołuje „call” tylko z jednym argumentem. W zwykłym Prologu, musimy użyć dodatkowych
nawiasów, aby uzyskać ten sam efekt, jak tutaj:
?- call( (p(a), q(a), r(a)) ).
ponieważ bez dodatkowych nawiasów, „call” będzie traktowane jako posiadające trzy argumenty.
Możemy zdefiniować ampersanda aby pracował w ten sposób nawet w zwykłym Prologu.
Najpierw zdefiniujmy jego składnię. Chcemy aby & był operatorem wrostkowym z nieco niższym
priorytetem niż przecinek, dzięki czemu f (& b, c) będzie oznaczać f ((& b), c),a nie f (i (b, c)).
Ponadto, jak wkrótce zobaczymy, & powinno być w prawo-asocjacyjne. Tak więc, w większości
Prologów stosowną definicją operatora będzie:
:- op(950,xfy,&).
Następnie musimy powiedzieć Prologowi jak rozwiązać funkcję zawierającą ampersandy. Oczywiście
zapytanie GoalA & GoalB powinno zadziałać jeżeli GoalA zadziała a następnie GoalB zadziała z tymi
samymi instancjami. Czyli:
GoalA & GoalB :- call(GoalA), call(GoalB).
To jest po prostu zwykła reguła Prologa. Równie dobrze może to być zapisane jako:
'&'(GoalA,GoalB) :- call(GoalA), call(GoalB).
Nadawanie znaczeń operatorom
Ponieważ ampersand & jest asocjacyjny z prawej strony(prawostronny),
zasada ta może w rzeczywistości obsługiwać nieograniczoną liczbę zadań
połączonych Ampersandami. Załóżmy, że mamy wydać zapytanie:
?- write(one) & write(two) & write(three).
Ze względu na „prawostronność” funkcja ta jest równoważna funkcji:
?- write(one) & (write(two) & write(three)).
To łączy się z regułą definiującą ampersand „&” z instancjami:
GoalA = write(one)
GoalB = (write(two) & write(three))
Nowymi funkcjami są call(GoalA), która jest realizowana wypisując „one” na
ekranie, oraz call(GoalB), która rekurencyjnie powołuje się na ręgułę
ampersandu „&”.
PROLOG W PROLOGu
Nasza definicja ampersandu „&” sugeruje strategię przepisania całego mechanizmu inferencji Prologa do
Prologa, aby rozwinąć tym samym zmodyfikowaną wersję języka. Przypomnijmy, że predykat
clause(Head, Body) może odzyskać jakąkolwiek z klauzul w bazie danych, a przynajmniej te, które są
zadeklarowane dynamicznie; Robi to, próbując połączyć Head z nagłówkiem klauzuli oraz body z ciałem
klauzuli(lub z „true” jeśli klauzula jest faktem). Klauzule alternatywne są otrzymywane jako wielokrotne
rozwiązania „clause” przy pomocy backtrackingu.
Ciało reguły jest zazwyczaj funkcją złożoną(compound goal), czyli struktura utrzymywana jest przy pomocy
prawostronnych(right-associative) przecinków, które działają dokładnie jak ampersandy zaprezentowane
wcześniej. Tak więc biorąc pod uwagę regułę:
f(X) :- g(X), h(X), i(X), j(X).
zapytanie:
?- clause(f(abc),Body).
Utworzy instancję „Body”
g(abc), h(abc), i(abc), j(abc)
która odpowiada:
g(abc), (h(abc), (i(abc), j(abc)))
Aby wykonać to zadanie postąpimy w ten sam sposób jak zrobiliśmy to w przypadku ampersandów. Możemy
zdefniować interpret ( który pobiera funkcję jako argument i wykonuje ją).
Następnie aby użyć „interpret” wystarczy napisać, np.:
?- interpret(grandparent(X,Y)). zamiast ?- grandparent(X,Y).
Jest to algorytm Clocksin'a i Mellish'a (1984:177) . Cięcia są „zielone” : zachowują kroki, ale nie wpływają na
logikę programu. Zauważmy, że nie jest tu używane wywołanie; Każda udana funkcja kończy się
wywołaniem interpret(true).
Rozszerzenie silnika wnioskowania(inferencji)
Mniej radykalnym sposobem na rozszerzenie Prologa jest dodanie kolejnej strategii inferencyjnej na wierzchu istniejącego już silnika wnioskowania. Taki system
nie wymaga meta-interpretatora. Przetwarza on funkcję próbując ją wykonać poleceniem „call”, a następnie próbuje innej strategi jeżeli „call” nie skutkuje.
Tak więc typowe funkcje w Prologu są przetwarzane w normalny sposób, zarówno jak i inne ich typy. Na konkretnym przykładzie, zastanówmy się, jak
wyrazić w Prologu fakt, że wszystkie psy są z rodziny psowatych oraz, że wszystkimi członkami rodziny psowatych są psy. Jeśli użyjemy dwóch reguł,
canine(X) :- dog(X).
dog(X) :- canine(X).
otrzymamy pętle, ponieważ każda reguła wywoła inną. Jest tutaj potrzebna inna strategia inferencji.
Najpierw musimy zapisać fakt, że canine(x) oraz dog(x) wsą w bikondycjonalnej relacji. Możemy użyć predykatu :bicond” i umieścić nastepujący fakt w bazie
danych:
bicond(canine(X),dog(X)).
Lecz jest możliwe bardziej eleganckie podejście. Zamiast ”bicond” wywołajmy predykat '-:-‘ (operator podobny do ':-' lecz symetryczny). Do tego potrzebujemy
definicji operatora:
:- op(950,xfx,'-:-').
Teraz możemy odnieść się do „dog” oraz „canine” korzystając z faktu:
canine(X) -:- dog(X).
Nazwiemy to zasadą bikondycjonalną. Żadna z jej stron nie może być funkcją złożoną.
Plik BICOND.PL definiuje predykat „prove”, który odpowiada predykatowi „call” tym , że może on również sotsować zasad bikondycjonalnych. Jego strategia jest
nastepująca: najpierw sprawdzić czy funkcja może być wywołana przez „call”. Jeżeli nie, sprawdzić czy jest ona zgodna z jedną ze stron zasady
bikondycjonalnej. Jeśli tak, wywołać drugą z tych zasad. Aby sprawdzić, że mamy poprawne wyniki, należy rozważyć następującą bazę danych i zapytania:
dog(fido).
canine(rolf).
dog(X) -:- canine(X).
?- dog(X).
X = fido
?- canine(X).
X = rolf
?- prove(dog(X)).
X = fido ;
X = rolf
?- prove(canine(X)).
X = rolf ;
X = fido
Zapytania z „prove” rozpoznają bikondycjonale, podczas gdy zwykłe zapytania, nie. Bikondycjonale nie powodują pętli ponieważ „prove” nie może sam siebie
wywołać. Niestety „prove” ma swoje ograniczenia. Ponieważ nie jest rekurencyjny, nie rozpoznaje, że bikondycjonale są przechodnie. Baza danych nie
umozliwia komputerowi aby wywnioskował f(fido) z h(fido). Jeśli potraktujemy „prove” rekurencja w prosty sposób – tak, że wywoła samą siebie zamiast
wywoływać „call” - otrzymamy przechodniość, ale również przywrócimy pętle. Bardziej wyrafinowana wersja „prove” może przechowywać zapis tych
bikondycjonalnych zasad których używała, tak, że może ona zespoić zasady ze sobą bez użycia tej samej reguły więcej niż jeden raz.
(przykład 5.12 wyklad)
Dostosowywanie interfejsu użytkownika
Nie tylko silnik inferencji, ale również interfejs najwyższego poziomu Prologa może być
spersonalizowany. W typowym najwyższym poziomie Prologa, komputer ustala:
?a użytkownik odpowiada wpisując zapytanie. Niektóre Prologi pozwalają również
użytkownikowi ustalić fakty i zasady, które są dodane do bazy danych. Plik
TOPLEVEL.PL określa najwyższy poziom, którego dialogi z użytkownikiem wyglądają
następująco:
Type a query:
father(X,cathy).
Solution found:
father(michael,cathy)
Look for another? (Y/N): n
Type a query:
No (more) solutions
father(joe,cathy).
Type a query:
Solution found:
Look for another? (Y/N): y
parent(X,Y).
parent(michael,cathy)
Solution found:
Look for another? (Y/N): y
No (more) solutions
parent(melody,cathy)
Dostosowywanie interfejsu użytkownika
Jest to zwykły „najwyższy poziom” w Prologu z tym wyjątkiem, że komunikaty są
znacznie bardziej jawne, a odpowiedzi są podawane poprzez wyświetlanie zapytań z
wypełnionymi wartościami zmiennych. Wszystkie zapytania Prologa są dopuszczalne nie tylko zapytania o bazę danych, ale również wywołania do wbudowanych
predykatów takich jak „consult”.
Kod określający ten „najwyższy poziom” ma tylko 18 linii. Procedura top_level jest
nieskończoną pętlą repeat-fail , która akceptuje zapytania i przekazuje je do
find_solutions. (Zauważ przy okazji, że nazwa top_level nie ma specjalnego
znaczenia. Ta procedura staje się najwyższym poziomem środowiska Prologa zaraz po
uruchomieniu go, wpisując '?- top_level.')
W find_solutions procedura ma dwie klauzule. Pierwsza klauzula znajduje rozwiązanie,
wypisuje je, i pyta użytkownika, czy szukać innych. Jeśli użytkownik wpisze N lub n
(na "nie"), find_solutions wykonuje cięcie, i sterowanie powraca do top_level. W
przeciwnym razie, find_solutions cofa się. Jeśli nie można znaleźć dalszych rozwiązań
i cięcie nie zostało wykonane, sterowanie przechodzi do drugiej klauzuli i wyświetla
się komunikat "Brak (dalszych) rozwiązań".
Jak wyjść z top_level? Po prostu wpisz 'halt.' aby wyjść z Prologa, tak jakbyś używał
zwykłego „najwyższego poziomu”.
Spersonalizowany „najwyższy poziom” może uczynić Prolog znacznie bardziej przyjaznym
dla użytkownika. Przydatnym okazało się przedstawienie Prologa początkującym
programistom poprzez interfejs użytkownika kierowanym za pomocą menu, który
pozwalał im wyświetlać bazę danych, dodawać lub usuwać klauzule, oraz wykonywać
zapytania. Dzięki temu używanie edytora plików jest wyeliminowane. Ponadto
spersonalizowany „najwyższy poziom” może być połączony z wzmocnionym silnikiem
inferencji, po to aby zamienić Prologa w potężny system inżynierii danych.