[Qcell-commitlogs] SF.net SVN: qcell: [286] trunk/qcell/doc/licenciate_thesis

[<dhu...@us...>]

Revision: 286
          http://svn.sourceforge.net/qcell/?rev=286&view=rev
Author:   dhubleizh
Date:     2007-02-04 13:47:19 -0800 (Sun, 04 Feb 2007)

Log Message:
-----------
- chapters files which I've forgotten the last time
- started some preliminary math and CA definitions in chapter 2

Modified Paths:
--------------
    trunk/qcell/doc/licenciate_thesis/thesis.bib
    trunk/qcell/doc/licenciate_thesis/thesis.tex

Added Paths:
-----------
    trunk/qcell/doc/licenciate_thesis/chap1/chap1.tex
    trunk/qcell/doc/licenciate_thesis/chap2/chap2.tex
    trunk/qcell/doc/licenciate_thesis/chap3/chap3.tex
    trunk/qcell/doc/licenciate_thesis/chap4/chap4.tex
    trunk/qcell/doc/licenciate_thesis/chap5/chap5.tex
    trunk/qcell/doc/licenciate_thesis/chap6/chap6.tex
    trunk/qcell/doc/licenciate_thesis/chap7/chap7.tex

Added: trunk/qcell/doc/licenciate_thesis/chap1/chap1.tex
===================================================================
--- trunk/qcell/doc/licenciate_thesis/chap1/chap1.tex	                        (rev 0)
+++ trunk/qcell/doc/licenciate_thesis/chap1/chap1.tex	2007-02-04 21:47:19 UTC (rev 286)
@@ -0,0 +1,46 @@
+\chapterauthor{Cezary Krzy\xBFanowski}{Wprowadzenie}
+\label{chap:wpr}
+\section{Cel i~zakres pracy}
+Celem niniejszego opracowania jest stworzenie \x9Crodowiska do efektywnego przeprowadzania symulacji jedno-, dwu- oraz tr\xF3jwymiarowych automat\xF3w kom\xF3rkowych (\ac{AK}).
+
+W~zakres pracy wchodzi synteza funkcjonalno\x9Cci zapewniaj\xB9cych szerok\xB9 gam\xEA mo\xBFliwo\x9Cci prowadzenia eksperyment\xF3w z~\ac{AK}, oparta  o~krytyczn\xB9 analiz\xEA istniej\xB9cych rozwi\xB9za\xF1. Na podstawie uzyskanych wynik\xF3w powstanie implementacja \x9Crodowiska z~wybranymi pozycjami stworzonej wcze\x9Cniej listy funkcjonalno\x9Cci.
+
+\section{Uzasadnienie tematu}
+\label{sec:ute}
+Implementowanie symulator\xF3w jest integraln\xB9 cz\xEA\x9Cci\xB9 procesu tworzenie i~dowodzenia nowych teorii. Gdy nie mo\xBFna w~prosty spos\xF3b zdefiniowa\xE6 og\xF3lnego wzoru opisuj\xB9cego badane zachowanie, przeprowadzenie i~przeanalizowanie pewnej liczby eksperyment\xF3w mo\xBFe prowadzi\xE6 do wyizolowania czynnik\xF3w wp\xB3ywaj\xB9cych na dany proces. W~konsekwencji tworzona jest robocza teoria, kt\xF3r\xB9 nast\xEApnie mo\xBFna pr\xF3bowa\xE6 udoskonala\xE6 lub potwierdzi\xE6 przy pomocy kolejnych symulacji.
+
+Dziedzin\xB9 szczeg\xF3lnie nadaj\xB9c\xB9 si\xEA do komputerowego na\x9Cladowania s\xB9 \ac{DSZ}. \ac{AK} jest modelem \ac{DSZ}. Stworzenie odpowiedniego narz\xEAdzia do przeprowadzania eksperyment\xF3w na modelach kom\xF3rkowych mo\xBFe by\xE6 cennym \x9Crodkiem do bada\xF1 naukowych.
+
+Powy\xBFsze rozumowanie doprowadzi\xB3o do stworzenia pewnej liczby symulator\xF3w. Jednak\xBFe skupia\xB3y si\xEA one g\xB3\xF3wnie b\xB9d\x9F na zaprezentowaniu samej idei \ac{AK}, b\xB9d\x9F do przedstawienia wybranego, zwykle bardzo w\xB9skiego, zakresu ich dzia\xB3ania. W~literaturze oraz w~internecie nie pojawi\xB3a si\xEA dotychczas inicjatywa opracowania i~zaimplementowania systemu pozwalaj\xB9cego bada\xE6 te dziedzin\xEA w~szerokim spektrum. Koncepty teoretyczne, jak np. \ac{OL} nigdy nie doczeka\xB3y si\xEA implementacji.
+
+Dzisiejsze systemy komputerowe pozwalaj\xB9 na prowadzenie skomplikowanych oblicze\xF1 w~kr\xF3tkim czasie. Szczeg\xF3lnie na polu tr\xF3jwymiarowej grafiki komputerowej ostatnie lata pe\xB3ne by\xB3y innowacji wielokrotnie zwi\xEAkszaj\xB9cych mo\xBFliwo\x9Cci zwyk\xB3ych komputer\xF3w osobistych. Jest to idealne pod\xB3o\xBFe do pr\xF3by stworzenia symulatora \ac{AK} wykorzystuj\xB9cego mo\xBFliwo\x9Cci sprz\xEAtowe do zaprezentowania nowej jako\x9Cci wizualizacji tr\xF3jwymiarowych proces\xF3w kom\xF3rkowych.
+
+\section{Podzia\xB3 zada\xF1 szczeg\xF3\xB3owych}
+\subsection{Zadania szczeg\xF3\xB3owe - Cezary Krzy\xBFanowski}
+\subsubsection{Wymagania dla symulator\xF3w \acs{AK}}
+Zadanie polega na stworzeniu listy funkcjonalno\x9Cci, jakie powinien posiada\xE6 pe\xB3nowarto\x9Cciowy pakiet do przeprowadzania eksperyment\xF3w na wielowymiarowych \ac{AK}. Lista zostanie stworzona na podstawie analizy istniej\xB9cych rozwi\xB9za\xF1 oraz zaproponowanych nowych funkcjonalno\x9Cci.
+\subsubsection{Program symulacji modelu \ac{AK} 3d - interfejs i~\x9Crodki doboru modelu}
+Jest to implementacyjna cz\xEA\x9C\xE6 pracy. Polega na stworzeniu \ac{GUI} pozwalaj\xB9cego w~mo\xBFliwie prosty i~czytelny spos\xF3b operowa\xE6 na \ac{AK}.
+
+Dodatkowo do zadania nale\xBFy zaimplementowanie metod doboru modelu (\ac{N} i~\ac{FL}), rozumianych jako sposoby wczytywania predefiniowanych jego element\xF3w oraz wspomaganie przy tworzeniu i~utrwalaniu nowych.
+\subsubsection{Opracowanie i~wdro\xBFenie \x9Crodk\xF3w intensyfikacji eksperyment\xF3w}
+Przez \x9Crodki intensyfikacji eksperyment\xF3w rozumiane s\xB9 dodatkowe narz\xEAdzia i~tryby wspomagaj\xB9ce zmiany w~modelu b\xB9d\x9F danych na bie\xBF\xB9co celem uzyskania \xBF\xB9danej \ac{KB}.
+\subsubsection{Testy programu}
+Przeprowadzone zostan\xB9 dwie fazy test\xF3w. W~pierwszej fazie pakiet przetestowany zostanie pod wzgl\xEAdem poprawno\x9Cci prowadzonych oblicze\xF1 oraz zgodno\x9Cci z~ustalon\xB9 wcze\x9Cniej list\xB9 funkcjonalno\x9Cci. W drugiej fazie pakiet zostanie poddany testom wydajno\x9Cciowym oraz subiektywnym testom ergonomii u\xBFytkowania.
+
+\subsectionauthor{Leszek Smentek}{Zadania szczeg\xF3\xB3owe}
+\label{subsec:lsm}
+
+\subsubsection {Symulator modelu \ac{AK}}
+Zadanie ma na celu opracowanie i implementacje symulatora umo\xBFliwiaj\xB9cego prowadzenie poprawnej symulacji zgodnie z dobranym modelem oblicze\xF1.
+
+\subsubsection {\x8Crodki doboru danych}
+Przez \x9Crodki doboru danych rozumiany jest zestaw narz\xEAdzi pakietu umo\xBFliwiaj\xB9ce swobodn\xB9 generacj\xEA danych eksperymentu oraz podstawowe mo\xBFliwo\x9Cci edycji.
+
+\subsubsection {Wizualizacja i tryby eksperyment\xF3w dla r\xF3\xBFnych obserwator\xF3w}
+To zadanie szczeg\xF3\xB3owe ma na celu implementacje efektywnej i czytelnej metody wizualizacji prowadzonego eksperymentu zar\xF3wno dla obserwatora globalnego, jak i trybu obserwatora lokalnego. 
+
+\subsubsection {Opracowanie i wdro\xBFenie \x9Crodk\xF3w dokumentowania eksperyment\xF3w}
+Powy\xBFsze zadanie szczeg\xF3\xB3owe ma na celu opracowanie metod dokumentowania eksperyment\xF3w umo\xBFliwiaj\xB9cych prezentacje wynik\xF3w symulacji niezale\xBFnie od pakietu.
+
+% vim:fencs=cp1250:fenc=cp1250

Added: trunk/qcell/doc/licenciate_thesis/chap2/chap2.tex
===================================================================
--- trunk/qcell/doc/licenciate_thesis/chap2/chap2.tex	                        (rev 0)
+++ trunk/qcell/doc/licenciate_thesis/chap2/chap2.tex	2007-02-04 21:47:19 UTC (rev 286)
@@ -0,0 +1,260 @@
+\chapterauthor{Cezary Krzy\xBFanowski}{Zakres problematyki}
+\label{chap:zpr}
+W~tym rozdziale przedstawione zosta\xB3y podstawowe zagadnienia zwi\xB9zane z~\ac{AK}. Podrozdzia\xB3 \ref{sec:pak} opisuje mechanik\xEA funkcjonowania przetwarza\xF1 kom\xF3rkowych oraz terminologi\xEA u\xBFyt\xB9 do opisu symulator\xF3w. Wykorzystuj\xB9c te definicje sformu\xB3owano  list\xEA cech hipotetycznego ,,idealnego symulatora'' w~punkcie \ref{sec:syn}. Na tej podstawie przeanalizowano grup\xEA symulator\xF3w \ac{AK} istniej\xB9cych na rynku (\ref{sec:pmz}).
+
+\section{Og\xF3lne poj\xEAcia z~zakresu automat\xF3w kom\xF3rkowych}
+\label{sec:pak}
+
+\subsection{Definicja automatu kom\xF3rkowego}
+\label{subsec:dak}
+{\bf Automat kom\xF3rkowy} (\ac{AK}) jest uporz\xB9dkowan\xB9 czw\xF3rk\xB9\citep{kul}:
+
+\begin{displaymath}
+A \equiv (\alpha, S, N, f)
+\end{displaymath}
+
+gdzie:
+
+\begin{trivlist}
+\item $\alpha$~--- zbi\xF3r jednakowych kom\xF3rek
+\item $S$~--- sko\xF1czony zbi\xF3r stan\xF3w, jaki mo\xBFe przyj\xB9\xE6 kom\xF3rka
+\item $N$~--- sko\xF1czony zbi\xF3r s\xB9siad\xF3w
+\item $f$~--- funkcja lokalna (\ac{FL}) definiuj\xB9ca zmian\xEA stan\xF3w na podstawie s\xB9siedztwa $N$ oraz stanu bie\xBF\xB9cej kom\xF3rki $c$
+\end{trivlist}
+
+\begin{displaymath}
+    f : S_{N, c} \rightarrow S
+\end{displaymath}
+
+Wzajemne rozmieszczenie kom\xF3rek ze zbioru $\alpha$ wzgl\xEAdem siebie w przestrzeni jedno- lub wielowymiarowej wraz z przypisaniem ka\xBFdej kom\xF3rce stanu ze zbioru $S$ nazywamy {\bf konfiguracj\xB9 pocz\xB9tkow\xB9} (\ac{KP})\citep{siwy}.
+
+{\bf Iteracja} polega na przekszta\xB3ceniu aktualnego stanu \ac{AK} (tzw. {\bf konfiguracji bie\xBF\xB9cej}~--- \ac{KB}) w stan kolejny (tzw. {\bf konfiguracj\xEA nast\xEApn\xB9}~--- \ac{KN}) stosuj\xB9c \ac{FL} dla ka\xBFdej kom\xF3rki zbioru $\alpha$\citep{siwy}.
+
+Par\xEA w postaci uporz\xB9dkowanego zbioru s\xB9siad\xF3w oraz stanu kom\xF3rki jaki ten zbi\xF3r implikuje przy pomocy \ac{FL} nazywamy {\bf regu\xB3\xB9 elementarn\xB9} (\ac{RE})\citep{siit}.
+
+Okre\x9Claj\xB9c liczb\xEA przekszta\xB3ce\xF1 \ac{KB} w \ac{KN} m\xF3wimy o {\bf liczbie iteracji}, b\xB9d\x9F o {\bf pokoleniu \ac{AK}}. Aby przedstawi\xE6 przetwarzanie kom\xF3rkowe w czasie definiujemy {\bf chwil\xEA bie\xBF\xB9c\xB9} dla \ac{KB}, oraz o {\bf chwil\xEA nast\xEApn\xB9} dla \ac{KN}. By okre\x9Cli\xE6 punkt odniesienia w czasie, wzgl\xEAdem kt\xF3rego omawiane b\xEAd\xB9 kolejne iteracje, u\xBFywamy poj\xEAcia {\bf chwila zero} przetwarzania\citep{siwy}.
+
+\subsection{Elementy automatu kom\xF3rkowego}
+\label{subsec:mak}
+
+\ac{AK} sk\xB3ada si\xEA z dw\xF3ch element\xF3w - modelu oraz danych.
+
+Przez model rozumiemy s\xB9siedztwo (\ac{N}~--- ang. \emph{Neighbourhood}) i \ac{FL}. Aby model by\xB3 poprawny, funkcja przekszta\xB3caj\xB9ca \ac{KB} w \ac{KN} mo\xBFe przyjmowa\xE6 co najwy\xBFej tyle argument\xF3w, ilu s\xB9siad\xF3w definiuje \ac{N}. Sytuacja odwrotna jest dopuszczalna, gdy \ac{FL} nie uwzgl\xEAdnia warto\x9Cci wszystkich s\xB9siad\xF3w okre\x9Clonych przez \ac{N}.
+
+Podstawowym sposobem zapisywania \ac{FL} jest lista \ac{RE}. Format ten jest czytelny i pozwala \xB3atwo identyfikowa\xE6 regu\xB3\xEA, kt\xF3ra wp\xB3ynie na stan kom\xF3rki w chwili nast\xEApnej. Jednak\xBFe zapisywanie skomplikowanych zachowa\xF1 \ac{AK} w ten spos\xF3b jest nieefektywne. Z uwagi na to zosta\xB3y zdefiniowane inne formaty zapisu funkcji.
+
+Zwi\xEAz\xB3\xB9, a zarazem uniwersaln\xB9, metod\xB9 opisu zachowa\xF1 \ac{AK} jest funkcja kwazi-totalistyczna (\ac{FQT})\citep{siwy}. Polega na agregowaniu \ac{RE} przy pomocy sum. Sumy wyliczane s\xB9 z warto\x9Cci
+
+
+Danymi \ac{AK} nazywamy zbi\xF3r kom\xF3rek o okre\x9Clonym stanie oraz wzajemnym po\xB3o\xBFeniu wzgl\xEAdem siebie. Dla chwili zero m\xF3wimy o danych jako \ac{KP}. Informacje o kolejnych \ac{KB} powsta\xB3ych w wyniku przetwarzania \ac{AK} nazywamy {\bf histori\xB9 iteracji} b\xB9d\x9F {\bf histori\xB9 przetwarzania}.
+
+\section{Synteza optymalnej funkcjonalno\x9Cci symulatora przetwarza\xF1 kom\xF3rkowych}
+\label{sec:syn}
+
+\subsection{Dane wej\x9Cciowe}
+\label{subsec:dw}
+\subsubsection{Model}
+\label{subsubsec:model}
+Dobieranie modelu jest podstawowym elementem prowadzenia przetwarza\xF1 \ac{AK}. Na model sk\xB3ada si\xEA s\xB9siedztwo (\ac{N}) oraz funkcja lokalna (\ac{FL}). Z~uwagi na swoj\xB9 form\xEA, \ac{FL} wymaga wi\xEAcej ingerencji ze strony operatora, ni\xBF tworzenie danych.
+
+Niezale\xBFnie od formatu funkcji, s\xB9siedztwo okre\x9Cla si\xEA w~ten sam spos\xF3b, tak wi\xEAc jego dob\xF3r mo\xBFna ograniczy\xE6 do wczytywania z~jednego rodzaju pliku oraz do wspomagania wizualnego (uwzgl\xEAdniaj\xB9cego do 3 wymiar\xF3w). Rozmieszczanie s\xB9siad\xF3w w~przestrzeniach jedno- i~dwuwymiarowych jest jednoznaczne, natomiast tworzenie s\xB9siedztw w~przestrzeni tr\xF3jwymiarowej wymaga dodatkowych narz\xEAdzi, om\xF3wionych szerzej w~rozdziale \ref{sec:wiz}.
+
+Natomiast dobieranie \ac{FL} jest z\xB3o\xBFonym procesem i~w~zale\xBFno\x9Cci od celu eksperymentu powinno przybra\xE6 r\xF3\xBFny poziom szczeg\xF3\xB3owo\x9Cci. W~zwi\xB9zku z~tym, jeden spos\xF3b specyfikowania funkcji jest niewystarczaj\xB9cy. Symulator powinien wspiera\xE6 zar\xF3wno formaty pozwalaj\xB9ce w~szybki spos\xF3b zaprojektowa\xE6 proste regu\xB3y przetwarzania (tzw. regu\xB3y elementarne), jak i~te z\xB3o\xBFone, kt\xF3re agreguj\xB9 du\xBFa ilo\x9C\xE6 \ac{RE}, pozwalaj\xB9c tym samym na tworzenie skomplikowanych zachowa\xF1 \ac{AK}.
+
+Wspomaganie definiowania \ac{FL} jest bezpo\x9Crednio powi\xB9zane z~wykorzystywanym formatem. To prowadzi do potrzeby tworzenia osobnej procedury pomocniczej dla ka\xBFdego obs\xB3ugiwanego sposobu okre\x9Clania funkcji. Cennym elementem tworzenia \ac{FL} jest mo\xBFliwo\x9C\xE6 niepe\xB3nego okre\x9Clenia funkcji poprzez jawne zadeklarowanie symboli nieokre\x9Clonych (\ac{SN}). Symulator powinien akceptowa\xE6 takie symbole i~zaznacza\xE6 je w~wyra\x9Fny spos\xF3b celem p\xF3\x9Fniejszego uszczeg\xF3\xB3owienia.
+
+\subsubsection{Dane}
+\label{subsubsec:dane}
+Tworzenie danych, podobnie jak s\xB9siedztwa, jest procesem jednoznacznym dla przestrzeni jedno- i~dwuwymiarowych, natomiast nietrywialnym dla przestrzeni tr\xF3jwymiarowych. Konfigurowanie rozmieszczenia kom\xF3rek jest przede wszystkim \xBFmudne i~wymaga usprawnienia. Zatem format zapisu \ac{KP} nie jest tutaj kluczow\xB9 cech\xB9~--- winien jedynie, dla zachowania sp\xF3jno\x9Cci i~jednoznaczno\x9Cci zapisu, by\xE6 analogiczny do s\xB9siedztwa.
+
+Najcz\xEA\x9Cciej wykonywan\xB9 czynno\x9Cci\xB9 jest kopiowanie istniej\xB9cych struktur i~ich nieznaczne modyfikowanie. W~oczywisty spos\xF3b projektowany system powinien takie zachowania implementowa\xE6. Jednak aby efektywnie porusza\xE6 si\xEA i~rozmieszcza\xE6 obiekty w~przestrzeni tr\xF3jwymiarowej potrzeba dodatkowej funkcjonalno\x9Cci. Istniej\xB9 dwa podej\x9Ccia do kwestii nawigacji w~3D: poruszanie si\xEA wewn\xB9trz budowanych struktur lub obcinanie przestrzeni p\xB3aszczyznami, w~celu wyodr\xEAbnienia element\xF3w zas\xB3oni\xEAtych przez struktury znajduj\xB9ce si\xEA bli\xBFej obserwatora. Szczeg\xF3\xB3owe rozwa\xBFania na ten temat mo\xBFna znale\x9F\xE6 w~rozdziale \ref{subsec:wiz}.
+
+W~celu stworzenia du\xBFej liczby \ac{KP} przydatne by\xB3o by leksykograficzne uzupe\xB3nianie \ac{SN}. Operator m\xF3g\xB3by wczyta\xE6 nie w~pe\xB3ni okre\x9Clon\xB9 \ac{KP}, przegl\xB9da\xE6 kolejne podstawienia i~na podstawie kilku pierwszy iteracji, wybra\xE6 te, kt\xF3re odpowiadaj\xB9 jego potrzebom.
+
+\subsection{Ustawienia domy\x9Clne i~przyk\xB3ady}
+\label{subsec:udip}
+W~nat\xB3oku tryb\xF3w, narz\xEAdzi i~wizualizacji prezentowanie tylko i~wy\xB3\xB9cznie kluczowych dla danej sytuacji opcji znacznie usprawnia prac\xEA operatora. Na podstawie wczytywanych kolejno plik\xF3w, zar\xF3wno modelu jak i~danych, aplikacja powinna oszacowa\xE6 najbardziej prawdopodobny typ eksperymentu i~dobra\xE6 odpowiednie narz\xEAdzia.
+
+R\xF3wnie wa\xBFne wa\xBFne s\xB9 logiczne ustawienia domy\x9Clne dla parametr\xF3w, kt\xF3rych u\xBFytkownik jawnie nie okre\x9Cli\xB3. Dob\xF3r tych ustawie\xF1 powinien by\xE6 konsekwentny i~jednolity w~ca\xB3ym pakiecie. Nale\xBFy zwr\xF3ci\xE6 szczeg\xF3ln\xB9 uwag\xEA na zbalansowanie automatycznego dobierania parametr\xF3w, aby program nie poprawia\xB3 jawnych b\xB3\xEAd\xF3w u\xBFytkownika.
+
+Dobrym pomys\xB3em jest do\xB3\xB9czenie do pakietu zbioru eksperyment\xF3w przyk\xB3adowych wraz z~bibliotek\xB9 cz\xEAsto u\xBFywanych element\xF3w, w~szczeg\xF3lno\x9Cci tych obecnych w~literaturze, jak ,,\xB3aziki'' czy ``migacz''. Pozwoli to na szybsze wdro\xBFenie si\xEA nowych operator\xF3w w~mo\xBFliwo\x9Cci programu oraz u\xB3atwi p\xF3\x9Fniejsze programowanie nowych eksperyment\xF3w, kt\xF3re to zazwyczaj s\xB9 logicznym krokiem rozwijaj\xB9cym ju\xBF istniej\xB9ce koncepcje (a~co za tym idzie istniej\xB9ce struktury).
+% warto by tutaj poda\xE6 si\xEA na literature, gdzie takie \xB3aziki i~migacze wyst\xEApuj\xB9.
+
+\subsection{Wizualizacja}
+\label{subsec:wiz}
+\subsubsection{Uwagi og\xF3lne}
+\label{subsubsec:uog}
+Jednoznaczne i~wyra\x9Fne prezentowanie operatorowi element\xF3w modelu i~efekt\xF3w przetwarzania jest bezpo\x9Crednim powodem tworzenia symulator\xF3w. Jest to wi\xEAc funkcjonalno\x9C\xE6, na kt\xF3r\xB9 projektant tego typu oprogramowania powinien zwr\xF3ci\xE6 szczeg\xF3ln\xB9 uwag\xEA. W~szczeg\xF3lno\x9Cci wizualizowanie skomplikowanych struktur tr\xF3jwymiarowych w~czytelny spos\xF3b jest niebanalnym wyzwaniem, nie do ko\xF1ca programistycznym.
+
+\subsubsection{Funkcjonalno\x9C\xE6 podstawowa}
+\label{subsubsec:npo}
+Elementarnym zadaniem wizualizacji jest zaprezentowanie danych w~czytelny spos\xF3b. Nasuwa to problemy, takie jakie efektywne poruszanie si\xEA po obrazach znacznie wi\xEAkszych ni\xBF wielko\x9C\xE6 ekranu, czy swobodne zaznaczania dowolnego elementu, celem przeprowadzenia dzia\xB3a\xF1 z~nim zwi\xB9zanych.
+
+M\xF3wi\xB9c o~tr\xF3jwymiarowej wizualizacji, najcz\xEA\x9Cciej mamy na my\x9Cli narz\xEAdzia do operowania obiektami przestrzennymi. Obroty, przesuni\xEAcia, zbli\xBFenia czy oddalenia to swoisty elementarz. W~po\xB3\xB9czeniu z~manipulowaniem perspektyw\xB9 (patrz rozdzia\xB3 \ref{subsubsec:dane}) taki zestaw pozwala precyzyjnie pozycjonowa\xE6 pojedyncze elementy w~przestrzeni, jak i~zaznacza\xE6 ca\xB3e ich grupy, bez potrzeby zaznaczenia ka\xBFdej kom\xF3rki z~osobna. Tak wybran\xB9 struktur\xEA mo\xBFna nast\xEApnie \xB3atwo skopiowa\xE6 i~wklei\xE6 w~innym miejscu, czy wprost przemie\x9Cci\xE6.
+
+\subsubsection{Tryby wy\x9Cwietlania}
+\label{subsubsec:twy}
+
+\paragraph{Tekstowy}
+\label{par:tek}
+Jest to najbardziej oczywisty tryb wy\x9Cwietlania bior\xB9c pod uwag\xEA charakter plik\xF3w wej\x9Cciowych. Polega na tworzeniu linii (w~przypadku \ac{LAK}-a) lub tabel (w~\ac{DAK}-u). Tekstowe wizualizowanie przestrzeni tr\xF3jwymiarowych nie jest tak efektywne i~czytelne, w~szczeg\xF3lno\x9Cci z~uwagi na ma\xB3\xB9 foremno\x9C\xE6 symboli znakowych. Dopiero za pomoc\xB9 wyboru wy\x9Cwietlanych p\xB3aszczyzn mo\xBFliwe jest efektywne obrazowanie cz\xEA\x9Cci przestrzeni tr\xF3jwymiarowej plansz\xB9 dwuwymiarow\xB9.
+
+Tryb tekstowy u\xB3atwia analizowanie przetwarza\xF1 \ac{AK} z~uwagi na reprezentacj\xEA element\xF3w modelu (w~szczeg\xF3lno\x9Cci \ac{FL}). Mo\xBFna w~ten spos\xF3b \xB3atwo \x9Cledzi\xE6 poprawno\x9C\xE6 dzia\xB3ania \ac{FL}, lub na bie\xBF\xB9co modyfikowa\xE6 jej posta\xE6 u\xBFywaj\xB9c symboli bezpo\x9Crednio prezentowanych na ekranie.
+
+\paragraph{Graficzny}
+\label{par:graf}
+Tryb graficzny jest szczeg\xF3lnie efektywny w~wizualizacji przestrzeni tr\xF3jwymiarowych oraz przy odnajdywaniu pewnych globalnych zachowa\xF1 \ac{AK} bez wg\xB3\xEAbiania si\xEA w~techniczne przyczyny ich powstania (np. \x9Cledzenie przemieszczania si\xEA konkretnego elementu, formowanie si\xEA zgrupowa\xF1 jednakowych warto\x9Cci).
+
+Wy\x9Cwietlanie polega na zast\xEApowaniu element\xF3w alfabetu wyj\x9Cciowego modelu \ac{AK} kszta\xB3tami i/lub kolorami na planszy pikslowej (\ac{LAK} i~\ac{DAK}) lub w~przestrzeni tr\xF3jwymiarowej. Moc wyrazu takiej formy prezentacji polega na zdecydowanej poprawie czytelno\x9Cci konfiguracji z\xB3o\xBFonych z~wielu r\xF3\xBFnowarto\x9Cciowych kom\xF3rek. Ponadto pozwala nada\xE6 wizualizacji charakter bardziej intuicyjny, zbli\xBFony do symulowanej dziedziny, np. upodobnienie konkretnych warto\x9Cci kszta\xB3t\xF3w rzeczywistych obiekt\xF3w.
+
+Dodatkowym plusem, aczkolwiek mniej istotnym dla samego operatora,  jest tworzenie obiekt\xF3w graficznych bezpo\x9Crednio przez nowoczesne uk\xB3ady graficzne. To zdecydowanie poprawia wydajno\x9C\xE6 operowania rozleg\xB3ymi przestrzeniami, w~szczeg\xF3lno\x9Cci tr\xF3jwymiarowymi. W~po\xB3\xB9czeniu z~bardzo szybko rosn\xB9c\xB9 moc\xB9 obliczeniow\xB9 jednostek graficznych mo\xBFliwe jest wykorzystywanie efekt\xF3w dodatkowo poprawiaj\xB9cych czytelno\x9C\xE6 i~realistyczno\x9C\xE6 prezentacji, takich jak \gls{antyaliasing}, czy przezroczysto\x9C\xE6.
+
+\subsubsection{Interpretacja wy\x9Cwietlania}
+\label{subsubsec:iwy}
+Bardzo efektywn\xB9 metod\xB9 zwi\xEAkszenia czytelno\x9Cci prezentowanych danych jest interpretowanie obrazu. Polega ono na przypisywaniu znak\xF3w, kszta\xB3t\xF3w i~kolor\xF3w symbolom \ac{KB} przez operatora. Pozwala to uwypukli\xE6 konkretne cechy symulacji.
+
+Pakiet powinien umo\xBFliwi\xE6 definiowanie takich przyporz\xB9dkowa\xF1 zar\xF3wno dla trybu graficznego, jak i~tekstowego. Rozszerzeniem tej koncepcji jest mo\xBFliwo\x9C\xE6 tworzenie interpretacji dla grupy symboli.
+
+Potrzeb\xEA bardziej wyrafinowanego sterowanie wy\x9Cwietlaniem w~pe\xB3ni zaspokajaj\xB9 filtry. Pozwoli\xB3y by one na ustalanie lu\x9Fniejszych regu\xB3 sterowania wy\x9Cwietlaniem, np. wycinanie symboli o~warto\x9Cciach wi\xEAkszych lub mniejszych od zadanego progu, uwidacznianie pewnych struktur (np. 'poka\xBF co drug\xB9 kom\xF3rk\xEA').
+
+\subsubsection{Regu\xB3y elementarne}
+\label{subsubsec:rel}
+Rozwini\xEAciem koncepcji widoku interpretowanego jest wy\x9Cwietlanie przetwarzania uwidoczniaj\xB9c \ac{RE}, kt\xF3re wp\xB3yn\xEA\xB3y na przekszta\xB3cenie \ac{KB} w~\ac{KN}. Podobnie jak w~przypadku definiowania znak\xF3w, kolor\xF3w i~kszta\xB3t\xF3w dla konkretnych warto\x9Cci kom\xF3rki, pakiet powinien umo\xBFliwi\xE6 dobranie sposobu reprezentacji danej \ac{RE}. Efektem dodatkowym takich dzia\xB3a\xF1 jest stworzenie listy \ac{RE} ustalonych w~toku oblicze\xF1.
+
+\subsubsection{Obserwator lokalny i~globalny}
+\label{subsubsec:oli}
+Najcz\xEAstsz\xB9 metod\xB9 wizualizowania eksperymentu jest przedstawianie widoku z~perspektywy obserwatora globalnego, czyli takiego, kt\xF3ry nie jest cz\xEA\x9Cci\xB9 symulacji i~ma nieograniczony oraz natychmiastowy dost\xEAp do wszystkich obiekt\xF3w. Ciekaw\xB9 koncepcj\xB9 wydaje si\xEA tak\xBFe mo\xBFliwo\x9C\xE6 zaprezentowania przebiegu oblicze\xF1 z~punktu widzenia jednego z~obiekt\xF3w symulowanej przestrzeni, zwanego obserwatorem lokalnym. Mo\xBFliwo\x9C\xE6 dynamicznego definiowania i~zmieniania punktu widzenia powinna by\xE6 cz\xEA\x9Cci\xB9 pakietu.
+
+W~bardziej z\xB3o\xBFonym przypadku mo\xBFna sobie wyobrazi\xE6, i\xBF obserwator jest ruchomy i~przemieszcza si\xEA wraz z~biegiem przetwarzania.
+
+\subsection{Przebieg eksperymentu}
+\label{subsec:pek}
+\subsubsection{Rytmy przetwarzania}
+\label{subsubsec:rpr}
+Najprostszym przypadkiem jest przetwarzanie krokowe~--- jedna iteracja naraz. R\xEAczne taktowanie iteracji staje si\xEA jednak uci\xB9\xBFliwe na d\xB3u\xBFsz\xB9 met\xEA, wi\xEAc pakiet powinien przewidzie\xE6 mo\xBFliwo\x9C\xE6 wykonania ustalonej przez operatora liczby iteracji. Skrajnym przypadkiem takiego zachowania jest eksperyment ci\xB9g\xB3y. Jest on przydatny do \x9Cledzenia pewnych charakterystycznych obiekt\xF3w \ac{AK}, takich jak ,,\xB3azik'', w~szczeg\xF3lno\x9Cci przy torusowych warunk\xF3w brzegowych.
+
+Najefektywniejszym sposobem prowadzenia symulacji jest wyznaczanie warunk\xF3w ko\xF1cowych. Wyst\xB9pienie kt\xF3regokolwiek z~nich ko\xF1czy eksperyment. Szczeg\xF3lnym przypadkiem takich warunk\xF3w jest liczba przeprowadzonych iteracji, kt\xF3ra zapobiega zap\xEAtleniu si\xEA przetwarzania w~sytuacji, gdy pozosta\xB3e warunki ko\xF1cowe okaza\xB3yby si\xEA nieosi\xB9galne.
+
+Opracowanie sposobu deklarowania, a~nast\xEApnie wyszukiwania nietrywialnych warunk\xF3w ko\xF1cowych (pusta plansza, pojawienie si\xEA konkretnego wzorca), jest jednak trudnym zadaniem.
+
+Dodatkowym elementem wspomagaj\xB9cym mog\xB3a by by\xE6 mo\xBFliwo\x9C\xE6 wprowadzenia definiowalnego op\xF3\x9Fnienia czasowego mi\xEAdzy kolejnymi iteracjami, celem spowolnienia przetwarzania, np. dla dok\xB3adniejszej analizy zachowa\xF1 \ac{AK}.
+
+\subsubsection{Historia iteracji}
+\label{subsubsec:hit}
+Przechowywanie ca\xB3ej historii eksperymentu pozwala na powr\xF3t do wcze\x9Cniejszych iteracji w~celu dok\xB3adnej analizy, lub zmiany element\xF3w \ac{AK} (modelu lub danych). Inn\xB9 mo\xBFliwo\x9Cci\xB9 jest prze\x9Cledzenie alternatywnej \x9Ccie\xBFki przetwarzania. Pakiet powinien udost\xEApni\xE6 p\xB3ynne poruszanie si\xEA wstecz iteracji, edycj\xEA \ac{KB} i~wznowienie symulacji od momentu zmiany.
+
+W~sytuacji idealnej pakiet przechowywa\xB3by ca\xB3a histori\xEA przetwarzania, \xB3\xB9cznie z~rozga\xB3\xEAzieniami wynikaj\xB9cymi z~powrot\xF3w i~zmian, oraz p\xB3ynne po niej poruszanie si\xEA.
+
+\subsubsection{Dynamiczne zmiany modelu i~danych}
+\label{subsubsec:dzm}
+Wprowadzanie dynamicznych zmian we wszystkich trzech elementach \ac{AK} (\ac{N}, \ac{FL} i~\ac{KB}) oraz uwzgl\xEAdnianie tych zmian w~dalszych obliczeniach jest cenn\xB9 funkcjonalno\x9Cci\xB9. Edycja powinna by\xE6 rejestrowana, by umo\xBFliwi\xE6 cofni\xEAcie wykonanych poprawek i~powr\xF3t do pierwotnej konfiguracji.
+
+\subsubsection{Por\xF3wnywanie przetwarza\xF1}
+\label{subsubsec:ppr}
+Cz\xEA\x9C\xE6 zaproponowanych powy\xBFej funkcjonalno\x9Cci wprowadza pewne zmiany w~przetwarzaniu. Mo\xBFliwo\x9C\xE6 bezpo\x9Credniego por\xF3wnywania tych zmian wydaje si\xEA interesuj\xB9ca, np. r\xF3wnoczesne \x9Cledzenie przetwarzania dla \ac{OG} i~\ac{OL}. W~celu uzyskania pe\xB3nej kontroli nad procesem por\xF3wnywania, nale\xBFy zaimplementowa\xE6 osobne, jak i~wsp\xF3lne taktowanie obu symulacji, .
+
+\subsection{Utrwalanie wynik\xF3w}
+\label{subsec:uwy}
+\subsubsection{Utrwalanie pojedynczych element\xF3w}
+\label{subsubsec:upe}
+System powinien pozwoli\xE6 u\xBFytkownikowi w~dowolnym momencie zachowa\xE6 ka\xBFdy z~element\xF3w sk\xB3adowych \ac{AK} (\ac{N}, \ac{FL} i~\ac{KB}) z~osobna, zar\xF3wno nadpisuj\xB9c poprzednie konfiguracje, jak i~tworz\xB9c nowe pliki.
+\subsubsection{Utrwalanie historii przetwarzania}
+\label{subsubsec:uch}
+Zapisania ca\xB3o\x9Cci eksperymentu w~pojedynczym pliku u\xB3atwia p\xF3\x9Fniejsze jego wznowienie (lub analiz\xEA). Plik ten zawiera\xB3by zar\xF3wno elementy modelu, jak i~kompletn\xB9 histori\xEA przetwarzania \ac{KP} wraz z~rozga\xB3\xEAzieniami, wynikaj\xB9cymi ze zmian wprowadzonych w~trakcie trwania eksperymentu.
+
+Dodatkowym atutem by\xB3aby mo\xBFliwo\x9C\xE6 zachowania eksperymentu por\xF3wnawczego oraz taktowania obu przebieg\xF3w.
+\subsubsection{Tworzenie multimedi\xF3w}
+\label{subsubsec:tmu}
+Prowadzenie z\xB3o\xBFonych symulacji \ac{AK} mo\xBFe poci\xB9ga\xE6 za sob\xB9 potrzeb\xEA korzystania z~platformy dysponuj\xB9cej znacznymi mocami obliczeniowymi. W~szczeg\xF3lno\x9Cci ta uwaga dotyczy manipulowania wizualizacj\xB9 tr\xF3jwymiarowych przestrzeni. W~celu u\xB3atwienia p\xF3\x9Fniejszej prezentacji przebiegu symulacji pakiet powinien umo\xBFliwi\xE6 tworzenie plik\xF3w multimedialnych. Pozwala to na swobod\xEA w~dalszym dystrybuowaniu wynik\xF3w, w~szczeg\xF3lno\x9Cci w~internecie.
+
+Dodatkowo nale\xBFy zwr\xF3ci\xE6 uwag\xEA na fakt, i\xBF forma multimedialna pozwala prezentowa\xE6 w~p\xB3ynny spos\xF3b przebieg symulacji, kt\xF3ra w~rzeczywisto\x9Cci mog\xB3a by\xE6 generowana na przestrzeni wielu godzin.
+
+\sectionauthor{Leszek Smentek}{Przegl\xB9d mo\xBFliwo\x9Cci znanych automat\xF3w kom\xF3rkowych}
+\label{sec:pmz}
+\subsection {MCell}
+
+\begin{figure}[!hpt]
+\centering
+\includegraphics[width=10cm]{chap2/mcell}
+\caption{MCell}
+\label{fig:}
+\end{figure}
+
+MCell zosta\xB3 stworzonym przez Miros\xB3awa W\xF3jtowicza. Zas\xB3uguje na uwag\xEA ze wzgl\xEAdu na bogaty zestaw mo\xBFliwo\x9Cci funkcjonalnych, w jakie zosta\xB3 wyposa\xBFony.
+Najwa\xBFniejsze z nich to:
+\begin{itemize}
+\item obs\xB3uga jedno i dwu wymiarowych automat\xF3w kom\xF3rkowych
+\item wsparcie dla czternastu rodzin AK
+\item 256 elementowy alfabet
+\item bogaty zestaw gotowych regu\xB3 i konfiguracji pocz\xB9tkowych
+\item wsparcie dla kilku r\xF3\xBFnych rodzaj\xF3w s\xB9siedztwa
+\item zestaw narz\xEAdzi do analizy symulacji
+\item wygodny i prosty w obs\xB3udze interfejs u\xBFytkownika
+\item mo\xBFliwo\x9C\xE6 wsp\xF3\xB3pracy z innymi pakietami
+\end{itemize}
+
+\subsection {DDLab}
+\begin{figure}[!hpt]
+\centering
+\includegraphics[width=10cm]{chap2/ddlab}
+\caption{DDLab}
+\label{fig:}
+\end{figure}
+
+DDLab jest interaktywnym programem graficznym przewidzianym do badania sko\xF1czonych sieci binarnych. Posiada dwa alternatywne sposoby postrzegania dynamiki sieci: dynamik\xEA lokaln\xB9 obrazuj\xB9c\xB9 dzia\xB3anie sieci wraz z nast\xEApuj\xB9cymi chwilami czasowymi, oraz dynamik\xEA globaln\xB9 przedstawiaj\xB9c\xB9 prac\xEA wsteczn\xB9 sieci.
+Mo\xBFliwo\x9C\xE6 obrazowania dynamiki globalnej wyr\xF3\xBFnia ten produkt spo\x9Cr\xF3d innych symulator\xF3w sieci automat\xF3w kom\xF3rkowych.  
+
+\subsection{Life32}
+\begin{figure}[!hpt]
+\centering
+\includegraphics[width=10cm]{chap2/life32}
+\caption{Life32}
+\label{fig:}
+\end{figure}
+
+Life32 uznawany jest za jeden z najlepszych symulator\xF3w opartych o regu\xB3y "Game of Life". Do g\xB3\xF3wnych zalet tej aplikacji nale\xBF\xB9 maksymalny rozmiar przetwarzanej konfiguracji kt\xF3ry ograniczony jest do planszy o rozmiarach 1000000 x 1000000, oraz du\xBFa pr\xEAdko\x9C\xE6 przetwarzania. Symulator posiada mo\xBFliwo\x9C\xE6 wsp\xF3\xB3pracy z  innymi popularnymi pakietami. 
+
+\subsection{CelLab}
+\begin{figure}[!hpt]
+\centering
+\includegraphics[width=10cm]{chap2/cellab}
+\caption{CelLab}
+\label{fig:}
+\end{figure}
+
+CelLab jest jednym z najpe\xB3niejszych dost\xEApnych AK. Daje mo\xBFliwo\x9C\xE6 definiowania w\xB3asnych funkcji lokalnych poprzez stworzenie kr\xF3tkiego programu w j\xEAzykach: Java, C, BASIC lub Pascal. 
+
+\subsection{WinLife}
+\begin{figure}[!hpt]
+\centering
+\includegraphics[width=10cm]{chap2/winlife}
+\caption{WinLife}
+\label{fig:}
+\end{figure}
+
+WinLife to kolejny automat kom\xF3rkowy pracuj\xB9cy z modelem "Game of Life" 
+
+\subsection {Por\xF3wnanie dost\xEApnych AK}
+
+\begin{landscape}
+\begin{table}[!p]
+\centering
+\begin{tabular}{p{5em}|p{5em}|p{5em}|p{5em}|p{5em}|p{5em}|p{5em}|p{5em}}
+AK & Dynamika globalna & Definiowanie dowolnych funkcji lokalnych & Wymiana danych pomi\xEAdzy pakietami & Graficzna reprezentacja symulacji & Tekstowa reprezentacja symulacji & Obserwator lokalny & Wspomaganie doboru modelu\\
+\hline
+MCell & Nie & Tak & Tak & Tak & Nie & Nie & Nie\\
+\hline
+DDLab & Tak & Tak & Nie & Tak & Nie & Nie & Nie\\
+\hline
+Life32 & Nie & Nie & Tak & Tak & Nie & Nie & Nie\\
+\hline
+CelLab & Nie & Tak & Tak & Tak & Nie & Nie & Nie\\
+\hline
+WinLife & Nie & Nie & Nie & Tak & Nie & Nie & Nie
+\end{tabular}
+\caption{Por\xF3wnanie dost\xEApnych AK}
+\label{tab:}
+\end{table}
+\end{landscape}
+
+% vim:fencs=cp1250:fenc=cp1250

Added: trunk/qcell/doc/licenciate_thesis/chap3/chap3.tex
===================================================================
--- trunk/qcell/doc/licenciate_thesis/chap3/chap3.tex	                        (rev 0)
+++ trunk/qcell/doc/licenciate_thesis/chap3/chap3.tex	2007-02-04 21:47:19 UTC (rev 286)
@@ -0,0 +1,105 @@
+\chapterauthor{Leszek Smentek}{Za\xB3o\xBFenia szczeg\xF3\xB3owe}
+\label{chap:zsz}
+\section{Mo\xBFliwo\x9Cci funkcjonalne pakietu}
+	\subsection {Podstawowe funkcje programu}
+\subsubsection {Wczytywanie konfiguracji z pliku}
+	Do najbardziej podstawowych mo\xBFliwo\x9Cci funkcjonalnych ka\xBFdego symulatora AK zliczy\xE6 nale\xBFy praca z plikami zawieraj\xB9cymi informacje o prowadzonym eksperymencie. Pakiet dzieli konfiguracje prowadzonego eksperymentu na trzy podstawowe elementy niezb\xEAdne do symulacji:
+		\begin{itemize}
+		\item konfiguracja s\xB9siedztwo
+		\item funkcja lokalna
+		\item konfiguracja pocz\xB9tkowa eksperymentu
+		\end{itemize}
+Ka\xBFdy z element\xF3w mo\xBFe by\xE6 inicjowany osobno co daje mo\xBFliwo\x9C\xE6 wp\xB3ywania na model symulacji poprzez zmian\xEA dowolnego elementu. Pakiet wyposa\xBFony zosta\xB3 r\xF3wnie\xBF w mo\xBFliwo\x9C\xE6 sk\xB3adowania wszystkich konfiguracji jednocze\x9Cnie w celu ponownego rozpocz\xEAcia lub wznowienia eksperymentu.
+
+\subsubsection {Tryby pracy symulatora}
+Symulator wyposa\xBFony jest w podstawowe narz\xEAdzia prowadzenia eksperymentu umo\xBFliwiaj\xB9ce prace ci\xB9g\xB3\xB9 lub krokow\xB9.
+
+\subsubsection {Wizualizacja symulacji}
+
+Tryb wizualizacji podzielony zosta\xB3 na trzy modu\xB3y obrazowania symulacji Ka\xBFdy z modu\xB3\xF3w odpowiada stosowanemu automatowi kom\xF3rkowemu: jedno, dwu lub tr\xF3jwymiarowemu. 
+Wszystkie modu\xB3y posiadaj\xB9 zestaw narz\xEAdzi umo\xBFliwiaj\xB9cych zmian\xEA interpretacji obrazowanych wynik\xF3w przetwarzania.  
+
+Dla tr\xF3jwymiarowego automatu kom\xF3rkowego przewidziany zosta\xB3 dodatkowy zestaw funkcji niezb\xEAdnych z uwagi na specyfik\xEA tego trybu. W sk\xB3ad mo\xBFliwo\x9Cci funkcjonalnych specjalizowanych dla trybu 3D wchodz\xB9:
+\begin{itemize}
+	\item funkcje obrotu
+	\item funkcje przybli\xBFania oraz oddalania widoku
+	\item funkcje przycinania przestrzeni p\xB3aszczyznami
+\end{itemize}
+
+\subsubsection{Utrwalanie wynik\xF3w przetwarzania}
+
+Program umo\xBFliwia utrwalanie prowadzonych eksperyment\xF3w w czterech trybach:
+\begin{itemize}
+\item trybie cz\xEA\x9Cciowym gdy zapisujemy do pliku wybrany element modelu(FL, N, KB)
+\item zapisu ca\xB3kowitego tworz\xB9c jeden plik zawieraj\xB9cy wszystkie sk\xB3adowe modelu wraz z ca\xB3\xB9 histori\xB9 przetwarzania a tak\xBFe konfiguracje u\xBFytych symboli
+\item zapisu poszczeg\xF3lnych klatek do plik\xF3w graficznych
+\item zapisu eksperymentu do pliku multimedialnego
+\end{itemize}
+
+\subsection {Rozszerzone funkcje programu}
+Pakiet umo\xBFliwia edycje element\xF3w modelu na bie\xBF\xB9co podczas prowadzenia eksperymentu. Do edytowalnych element\xF3w wlicza si\xEA zmian\xEA bie\xBF\xB9cego s\xB9siedztwa, modyfikacja warto\x9Cci funkcji lokalnej, a tak\xBFe edycji konfiguracji bie\xBF\xB9cej eksperymentu. W celu u\xB3atwienia edycji do pakietu wprowadzono podstawowe narz\xEAdzia edycji umo\xBFliwiaj\xB9ce wype\xB3nianie obszar\xF3w KB zadan\xB9 warto\x9Cci\xB9 oraz kopiowanie i wklejanie obszar\xF3w przetwarzanych planszy.
+
+\subsubsection {Tworzenie element\xF3w modelu}
+
+Symulator wyposa\xBFono w kreatory daj\xB9ce mo\xBFliwo\x9C\xE6 przygotowanie podstawowych konfiguracji N, FL, KI. Przez podstawow\xB9 konfiguracje rozumie si\xEA minimalny stan elementu modelu kt\xF3ry umo\xBFliwia dalsz\xB9 edycje. Elementy konfiguracji nie mog\xB9 by\xE6 modyfikowane bez u\xBFycia kreator\xF3w. Podstawowe cechy konfiguracji dla poszczeg\xF3lnych element\xF3w modelu symulacji:
+
+\begin{itemize}
+\item s\xB9siedztwo - wymiar przestrzeni s\xB9siedztwa(1, 2, 3D), konkretne rozmiar bry\xB3y s\xB9siedztwa.
+\item funkcja lokalna - liczba argument\xF3w funkcji, argumenty totalizowane, rozmiar alfabetu wej\x9Cciowego.
+\item konfiguracja inicjalna - wymiary przestrzeni, rozmiary \x9Cwiata, domy\x9Clna warto\x9C\xE6 wype\xB3nienia \x9Cwiata.
+\end{itemize}
+
+\subsubsection {Tryby obserwatora}
+Wa\xBFn\xB9 funkcjonalno\x9Cci\xB9 programu jest mo\xBFliwo\x9C\xE6 prze\xB3\xB9czania tryb\xF3w obserwatora:
+\begin{itemize}
+\item obserwator globalny - wszystkie zmiany konfiguracji widoczne s\xB9 natychmiastowo
+\item obserwator lokalny - w trybie tym uwzgl\xEAdnione jest zjawisko op\xF3\x9Fnienia propagacji zmian wraz ze zwi\xEAkszaniem si\xEA odleg\xB3o\x9Cci od obserwatora 
+\end{itemize}  
+Tryb obserwatora lokalnego nie jest wspierany przez \xBFaden z powszechnie znanych symulator\xF3w AK.
+
+\subsubsection {Regu\xB3y elementarne}
+
+Pakiet umo\xBFliwia rejestrowania regu\xB3 elementarnych wykorzystanych w danej KB oraz funkcje interpretacji widoku symulacji za pomocom zarejestrowanych regu\xB3.
+
+\subsubsection{Dynamiczne dobieranie modelu symulacji}
+Symulator obs\xB3uguje mo\xBFliwo\x9Cci wyst\xB9pienia nieokre\x9Clono\x9Cci zar\xF3wno w FL jak i KI. Wprowadzenie tej funkcjonalno\x9Cci umo\xBFliwia dynamiczne dobieranie warto\x9Cci funkcji lokalnej oraz KB podczas symulacji w miejscach wyst\xB9pienia warto\x9Cci nieokre\x9Clonych. 
+
+\subsubsection{Model sieciowy}
+Program zawiera funkcje przetwarzania za pomoc\xB9 modelu sieciowego. W trybie tym ka\xBFda kom\xF3rka traktowana jest jako automat Moora, a jej warto\x9C\xE6 przedstawia stan automatu w danej chwili.
+
+\subsubsection {R\xF3wnoleg\xB3e \x9Cledzenie wynik\xF3w symulacji}
+Jedn\xB9 z mo\xBFliwo\x9Cci funkcjonalnych pakietu jest mo\xBFliwo\x9C\xE6 r\xF3wnoleg\xB3ego \x9Cledzenia wynik\xF3w symulacji. Opcja ta jest dost\xEApna w trybie obserwatora lokalnego. Ekran wizualizacji podzielony zostaje na dwie cz\xEA\x9Cci z kt\xF3rych jedna przedstawia przebieg symulacji w trybie obserwatora globalnego i druga widok z uwzgl\xEAdnieniem lokalno\x9Cci obserwatora.
+
+\subsubsection {Formaty danych}
+Wspierane formaty danych to:
+\begin{itemize}
+\item funkcja lokalna
+
+\begin{itemize}
+\item FQT
+\item ZIFW
+\item REAK
+\item LTFL
+\end{itemize}
+
+\item s\xB9siedztwo
+\begin{itemize}
+\item N
+\end{itemize}
+
+\item konfiguracja inicjalna
+\begin{itemize}
+\item  KI
+\end{itemize}
+
+\item inne formaty
+\begin{itemize}
+\item lif
+\item mcl
+\item MO
+\item formaty oparte na sk\xB3adni j\xEAzyka XML
+\end{itemize}
+
+\end{itemize}
+
+% vim:fencs=cp1250:fenc=cp1250

Added: trunk/qcell/doc/licenciate_thesis/chap4/chap4.tex
===================================================================
--- trunk/qcell/doc/licenciate_thesis/chap4/chap4.tex	                        (rev 0)
+++ trunk/qcell/doc/licenciate_thesis/chap4/chap4.tex	2007-02-04 21:47:19 UTC (rev 286)
@@ -0,0 +1,353 @@
+\chapterauthor{Cezary Krzy\xBFanowski}{Implementacja}
+\label{chap:imp}
+Rozdzia\xB3 ten opisuje architektur\xEA oraz techniczne aspekty zwi\xB9zane z~implementacj\xB9 symulatora om\xF3wionego w~rozdziale \ref{chap:zsz}. Znajduje si\xEA w~nim opis wykorzystanych narz\xEAdzi, paradygmat\xF3w i~wzorc\xF3w programistycznych oraz jednostek programowych wchodz\xB9cych w~sk\xB3ad aplikacji.
+
+\section{Stosowane narz\xEAdzia}
+\label{sec:sna}
+
+\subsection{Narz\xEAdzia stosowane przy implementacji}
+\label{subsec:npi}
+\begin{description}
+    \item [autotools] GNU Build System~--- Zestaw narz\xEAdzi stworzonych przez projekt GNU\footnote{\url{http://www.gnu.org/}} cz\xEA\x9Cciowo automatyzuj\xB9cych budowanie pakiet\xF3w w wielu systemach UNIXopodobnych. Jest cz\xEA\x9Cci\xB9 GNU Toolchain.\\\url{http://sources.redhat.com/autobook/}
+    \item[gcc] Wieloplatformowy zestaw kompilator\xF3w. U\xBFyto kompilatora j\xEAzyka C++~--- gcc-c++ w wersji 4.2.\\\url{http://gcc.gnu.org/}
+    \item[gdb] Wieloplatformowy \gls{debugger} w wersji 6.6.\\\url{http://www.gnu.org/software/gdb/}
+    \item[Microsoft Visual Studio .Net 2003] Narz\xEAdzie do edycji i kompilacji program\xF3w w \x9Crodowisku Microsoft Windows. U\xBFyto kompilatora j\xEAzyka C++.\\\url{http://msdn.microsoft.com/vstudio/previous/2003/}
+    \item[\Qt{}] Zestaw bibliotek firmy Trolltech do implementowania wieloplatformowego oprogramowania, w szczeg\xF3lno\x9Cci \ac{GUI} o natywnym, dla danej platformy, wygl\xB9dzie. Zawiera r\xF3wnie\xBF klasy og\xF3lnego zastosowania, oraz w\xB3asny system kompilacji. U\xBFyto wersji 4.2.\\\url{http://www.trolltech.com/products/qt/}
+    \item[Vim] Zaawansowany edytor plik\xF3w tekstowych. Posiada ponad 1700 wtyczek do pracy z~wieloma r\xF3\xBFnymi formatami plik\xF3w.Vim zosta\xB3 wykorzystany jako \ac{IDE}, \gls{debugger} oraz program do sk\xB3adu tekstu. U\xBFyto wersji 7.0.\\\url{http://www.vim.org/}
+\end{description}
+
+\subsection{Narz\xEAdzia stosowane przy pisaniu tekstu pracy}
+\label{subsec:npt}
+\begin{description}
+    \item [AcrobatReader] Interpreter plik\xF3w pdf.\\\url{http://www.adobe.com/products/acrobat/readstep2.html}.
+    \item [aspell] Wolnodost\xEApny program do sprawdzania pisowni i gramatyki wraz ze s\xB3ownikami w wielu j\xEAzykach.\\\url{http://aspell.sourceforge.net/}
+    \item [cmake] Wieloplatformowy generator skrypt\xF3w budowania.\\\url{http://www.cmake.org/}
+    \item [Evince] Interpreter plik\xF3w pdf w \x9Crodowisku \gls{GNOME} na platformie Linux.\\\url{http://www.gnome.org/projects/evince/}
+    \item [GIMP] Program do tworzenia grafiki rastrowej i przekszta\xB3cania obraz\xF3w do formatu \ac{EPS} wykorzystywanego w \TeX{}-u.\\\url{http://www.gimp.org/}
+    \item [Inkspace] Program do tworzenia grafiki wektorowej, g\xB3\xF3wnie w formacie \ac{SVG}.\\\url{http://www.inkscape.org/}
+    \item [TeTex] Implementacja j\xEAzyka sk\xB3adania tekstu \TeX{} na platformach UNIX-owych, wraz z zainstalowanym systemem makr \LaTeXe{}\citep{latex}.\\\url{http://www.tug.org/tetex/}
+    \item [TexLive 2005] Kompletne \x9Crodowisko \TeX{}-a tworzone przez \ac{TUG}.
+\end{description}
+
+\section{Za\xB3o\xBFenia wst\xEApne}
+\label{sec:zws}
+Fundamentalnym elementem pakietu, kt\xF3ry determinuje wszystkie p\xF3\x9Fniejsze ograniczenia, jest biblioteka \Qt{}. W~szczeg\xF3lno\x9Cci jej podstawowe struktury, takie jak \code{QVector} czy \code{QString}, kt\xF3re indeksowane s\xB9 liczbami ca\xB3kowitymi (int)\citep{qt4}.
+
+Pakiet powsta\xB3 przy intensywnym wykorzystaniu mechanizm\xF3w dostarczanych przez bibliotek\xEA \Qt{}. Modularn\xB9 (wtyczkow\xB9) architektur\xEA programu zapewni\xB3a klasa \code{QtPlugin}. Do implementacji graficznej reprezentacji \ac{AK} u\xBFyto bibliotek OpenGL w~standardzie 1.1 (dla kompatybilno\x9Cci z~mo\xBFliwie najszersz\xB9 gam\xB9 uk\xB3ad\xF3w graficznych), opakowanych przez modu\xB3 \code{QtOpenGL}. \code{QtXML} zapewni\xB3 parser \ac{XML}-a.
+
+Pozosta\xB3e elementy pakietu opieraj\xB9 si\xEA na g\xB3\xF3wnym module bibliotek \Qt{} (\code{QtCore}), implementuj\xB9cym podstawowe struktury og\xF3lnego u\xBFytku (listy, mapy, wektory), natomiast \ac{GUI} powsta\xB3o z~u\xBFyciem \code{QtGui}\citep{qt4}.
+
+\section{Og\xF3lna architektura programu}
+\label{sec:asy}
+Podstawowym za\xB3o\xBFeniem architektonicznym zbudowanej aplikacji jest maksymalna modu\xB3owo\x9C\xE6 oraz wymiana komunikat\xF3w przy pomocy \ac{XML}-a. Pozwala to na dzia\xB3anie w~\x9Crodowisku rozproszonym. Skutkiem ubocznym, aczkolwiek po\xBF\xB9danym, jest przymus projektowania dobrze zdefiniowanych interfejs\xF3w, zapewniaj\xB9cych komunikacj\xEA pomi\xEAdzy poszczeg\xF3lnymi elementami pakietu.
+
+Architektura programu przedstawiona jest na rysunku \ref{fig:arch}.
+
+\begin{figure}[!hpt]
+    \begin{center}
+	\includegraphics[height=200pt]{chap4/Architecture}
+    \end{center}
+    \caption{Architektura systemu}
+    \label{fig:arch}
+\end{figure}
+
+\begin{description}
+    \item[\ac{GUI}] Modu\xB3 definiuj\xB9cy warstw\xEA prezentacji. W~jego sk\xB3ad wchodz\xB9 okna programu, paski narz\xEAdzi, menu oraz przyborniki z~narz\xEAdziami. Modu\xB3 ten implementuje widok (\emph{View}) paradygmatu \ac{MVC}\citep{iowp}. \emph{Autorem jest Cezary Krzy\xBFanowski.}
+    \item[Baza danych] Modu\xB3 odpowiedzialny za przechowywanie element\xF3w modelu i~danych \ac{AK}. Implementuje r\xF3wnie\xBF struktury do przechowywania i~nawigacji po historii przetwarzania, w~szczeg\xF3lno\x9Cci historii iteracji (por. \ref{subsubsec:hit}). Modu\xB3 ten implementuje model (\emph{Model}) paradygmatu \ac{MVC}\citep{iowp}. \emph{Autorem jest Cezary Krzy\xBFanowski.}
+    \item[J\xB9dro logiczne] Modu\xB3 \xB3\xB9cz\xB9cy wszystkie elementy ze sob\xB9 oraz interpretuj\xB9cy polecenia u\xBFytkownika. Realizuje te funkcje wysy\xB3aj\xB9c lub po\x9Crednicz\xB9c w~wysy\xB3ce polece\xF1 w~formacie \ac{XML} do poszczeg\xF3lnych obiekt\xF3w. Modu\xB3 ten implementuje kontroler (\emph{Controller}) paradygmatu \ac{MVC}\citep{iowp}. \emph{Autorem jest Cezary Krzy\xBFanowski.}
+    \item[Modu\xB3 obliczeniowy] Modu\xB3 obliczeniowy zawiera zbi\xF3r algorytm\xF3w do manipulowania \ac{AK}, przede wszystkim zwi\xB9zanych z~generowaniem kolejnych iteracji. \emph{Autorem jest Leszek Smentek.}
+    \item[Parsery] Zbi\xF3r dynamicznych bibliotek (wtyczek) do interpretacji plik\xF3w wej\x9Cciowych i~wyj\x9Cciowych. Parsery przekszta\xB3caj\xB9 r\xF3\xBFne formaty zapisu element\xF3w \ac{AK} na struktury u\xBFywane wewn\xEAtrznie oraz po\x9Crednicz\xB9 przy zapisie danych. \emph{Autorem jest Cezary Krzy\xBFanowski.}
+    \item[Renderer] Modu\xB3 wykorzystuj\xB9cy bibliotek\xEA \gls{OpenGL} do wyliczania scen prezentuj\xB9cych \ac{KB}. Na podstawie danych o~rozmieszczeniu kom\xF3rek oraz zbiorze regu\xB3 interpretacyjnych okre\x9Clonych przez operatora, klasa Renderer ustawia scen\xEA i~zleca jej wyrenderowanie uk\xB3adowi graficznemu\citep{gl}. Modu\xB3 ten wykorzystywany jest do wy\x9Cwietlania w~trybie graficznym konfiguracji dwu- i~tr\xF3jwymiarowych \ac{AK}. \emph{Autorem jest Leszek Smentek.}
+\end{description}
+
+\section{Szczeg\xF3\xB3owa charakterystyka modu\xB3\xF3w pakietu}
+\label{sec:jpp}
+\subsection{Jednostki programowe \acs{GUI}}
+\label{subsec:jgu}
+
+Wykaz klas oraz jednostek programowych wchodz\xB9cych w~sk\xB3ad \ac{GUI} znajduje si\xEA w~tabeli \ref{tab:lgu}.
+
+\begin{table}[!hpt]
+    \centering
+    \begin{tabular}{l|p{20em}}
+	Klasa & Pliki z~implementacj\xB9 \\
+	\hline\hline
+	\code{BaseTools} & basetools.h basetools.cpp \\
+	\hline
+	\code{BetterDockWidget} & BetterDockWidget.h BetterDockWidget.cpp \\
+	\hline
+	\code{ElementalRulesWidget} & ElementalRulesWidget.h ElementalRulesWidget.cpp \\
+	\hline
+	\code{ExperimentSetup} & ExperimentSetup.h ExperimentSetup.cpp \\
+	\hline
+	\code{FunctionTable} & FunctionTable.h Funkcjonalno\x9C\xE6.cpp \\
+	\hline
+	\code{MainWindow} & MainWindow.h MainWindow.cpp \\
+	\hline
+	\code{NeighbourhoodTools} & NeighbourhoodTools.h NeighbourhoodTools.cpp \\
+	\hline
+	\code{NewNeighbourhoodWizard} & NewNeighbourhoodWizard.h NewNeighbourhoodWizard.cpp \\
+	\hline
+	\code{RuleProperties} & RuleProperties.h RuleProperties.cpp \\
+	\hline
+	\code{simulationWindow} & simulationWindow.h simulationWindow.cpp \\
+	\hline
+	\code{View1DTextTools} & View1DTextTools.h View1DTextTools.cpp \\
+	\hline
+	\code{View2DTextTools} & View2DTextTools.h View2DTextTools.cpp \\
+	\hline
+	\code{View3DTools} & View3DTools.h View3DTools.cpp
+    \end{tabular}
+    \caption{Wykaz klas i~jednostek programowych wchodz\xB9cych w~sk\xB3ad modu\xB3u GUI}
+    \label{tab:lgu}
+\end{table}
+
+G\xB3\xF3wn\xB9 klas\xB9 \ac{GUI} jest \code{MainWindow}, czyli okno g\xB3\xF3wne aplikacji. Definiuje ona rozmieszczenie poszczeg\xF3lnych element\xF3w interfejsu oraz po\x9Credniczy w~przekazywaniu zdarze\xF1, generowanych przez u\xBFytkownika, mi\xEAdzy elementami podrz\xEAdnymi a~j\xB9drem logicznym\citep{iowp} (por. \ref{subsec:jjl}).
+
+Klasy, kt\xF3rych nazwy ko\xF1cz\xB9 si\xEA s\xB3owem ,,Tools'' implementuj\xB9 przyborniki z~narz\xEAdziami do obs\xB3ugi konkretnego trybu wy\x9Cwietlania. Dla przyk\xB3adu pliki View3DTools.h oraz View3DTools.cpp opisuj\xB9 elementy \ac{GUI} do sterowania trybu 3D (por \ref{subsec:zwi}). Zgodnie z paradygmatem \ac{MVC} polecenia operatora zlecane s\xB9 do wykonania modu\xB3owi obliczeniowemu\citep{iowp}(por. \ref{subsec:jmo}). Wszystkie klasy z~tej rodziny dziedzicz\xB9 po \code{BetterDockWidget}, kt\xF3ry nieznacznie zmienia domy\x9Clne zachowanie \code{QDockWidget} z~bibliotek \Qt{}\citep{qt4doc}.
+
+Do wy\x9Cwietlania \ac{RE} s\xB3u\xBFy \code{ElementalRulesWidget}, kt\xF3ra wizualizuje dane zebrane przez \code{ElementalRules} (por. \ref{subsec:jmo}). Okienko dialogowe zaimplementowane w~pliku RuleProperties.cpp pozwala ustawia\xE6 regu\xB3y interpretacyjne dla zebranych \ac{RE}.
+
+\code{FunctionTable} oraz \code{simulationWindow} to specjalizowane \gls{widget}y do wy\x9Cwietlania odpowiednio tabeli \ac{FL} oraz wszystkich tryb\xF3w prezentowania \ac{KB}.
+
+Diagram kolaboracji \ac{GUI} przedstawiony zosta\xB3 na rysunku \ref{fig:gui}.
+
+\begin{figure}[!hpt]
+    \begin{center}
+	\includegraphics[width=\textwidth]{chap4/MainWindowArch}
+    \end{center}
+    \caption{Diagram kolaboracji modu\xB3u \ac*{GUI}}
+    \label{fig:gui}
+\end{figure}
+
+\subsection{Jednostki programowe modu\xB3u bazy danych}
+\label{subsec:jbd}
+
+Wykaz klas oraz jednostek programowych wchodz\xB9cych w~sk\xB3ad modu\xB3u bazy danych znajduje si\xEA w~tabeli \ref{tab:lbd}.
+
+\begin{table}[!hpt]
+    \centering
+    \begin{tabular}{l|p{20em}}
+	Klasa & Pliki z~implementacj\xB9 \\
+	\hline\hline
+	\code{Storage} & Storage.h Storage.cpp \\
+	\hline
+	\code{StorageInterface} & StorageInterface.h StorageInterface.cpp
+    \end{tabular}
+    \caption{Wykaz klas i~jednostek programowych wchodz\xB9cych w~sk\xB3ad modu\xB3u bazy danych}
+    \label{tab:lbd}
+\end{table}
+
+Baza danych zaimplementowana zosta\xB3a jako wtyczka. Definicja interfejsu komunikacji mi\xEAdzy j\xB9drem logicznym a~baz\xB9 znajduje si\xEA w~plikach StorageInterface.h oraz StorageInterface.cpp (por. \ref{subsec:jjl}). W\xB3a\x9Cciwa implementacja struktur przechowuj\xB9cych oraz indeksuj\xB9cych dane pierwotne (wczytane z~pliku), jak i~dane wt\xF3rne (powsta\xB3e w~trakcie dzia\xB3ania programu), widnieje w~klasie \code{Storage}.
+
+Magazynowaniu podlegaj\xB9 obiekty klas \code{Neighbourhood}, \code{LocalFunction} oraz \code{CalculationData}, b\xEAd\xB9ce cz\xEA\x9Cci\xB9 modu\xB3u obliczeniowego (por. \ref{subsec:jmo}). Dodatkowo przechowywane s\xB9 podstawowe informacje dot. przebiegu eksperymentu, takie jak numer porz\xB9dkowy ostatniej obliczonej iteracji, czy numer porz\xB9dkowy aktualnie wy\x9Cwietlonej \ac{KB} (kt\xF3re w~wyniku poruszania si\xEA wstecz historii iteracji mog\xB9 si\xEA r\xF3\xBFni\xE6 - por. \ref{subsubsec:hit}).
+
+\subsection{Jednostki programowe j\xB9dra logicznego}
+\label{subsec:jjl}
+
+Wykaz klas oraz jednostek programowych wchodz\xB9cych w~sk\xB3ad j\xB9dra logicznego znajduje si\xEA w~tabeli \ref{tab:ljl}.
+
+\begin{table}[!hpt]
+    \centering
+    \begin{tabular}{l|p{20em}}
+	Klasa & Pliki z~implementacj\xB9 \\
+	\hline\hline
+	\code{ElementalRules} & ElementalRules.h ElementalRules.cpp \\
+	\hline
+	\code{GenericParserPlugin} & GenericParserPlugin.h GenericParserPlugin.cpp \\
+	\hline
+	\code{MainWindow} & MainWindow.h MainWindow.cpp \\
+	\hline
+	\code{ParserInterface} & ParserInterface.h ParserInterface.cpp \\
+	\hline
+	\code{StorageInterface} & StorageInterface.h StorageInterface.cpp
+    \end{tabular}
+    \caption{Wykaz klas i~jednostek programowych wchodz\xB9cych w~sk\xB3ad modu\xB3u j\xB9dra logicznego}
+    \label{tab:ljl}
+\end{table}
+
+J\xB9dro logiczne zaimplementowane zosta\xB3o jako podzbi\xF3r funkcji klasy \code{MainWindow}. Przy pomocy interfejs\xF3w zdefiniowanych w~\code{ParserInterface} oraz \code{StorageInterface} aplikacja g\xB3\xF3wna komunikuje si\xEA z~wtyczkami, \xB3adowanymi podczas startu programu. W~celu ewentualnego rozproszenia modu\xB3\xF3w pakietu w~\x9Crodowisku sieciowym wymiana danych oraz komend odbywa si\xEA za pomoc\xB9 j\xEAzyka \ac{XML}.
+
+Klasa \code{GenericParserPlugin} stanowi implementacj\xEA podstawowych test\xF3w poprawno\x9Cci plik\xF3w wej\x9Cciowych, rozszerzanych nast\xEApnie specyficznie dla konkretnego formatu przez parsery (por. \ref{subsec:jpa}).
+
+\code{ElementalRules} zawiera logik\xEA zwi\xB9zan\xB9 z~rejestrowaniem \ac{RE}, kt\xF3re wy\x9Cwietlane s\xB9 za pomoc\xB9 klasy \code{ElementalRulesWidget} (por. \ref{subsec:jgu}).
+
+Diagram kolaboracji j\xB9dra logicznego przedstawiony zosta\xB3 na rysunku \ref{fig:gui}.
+
+\subsection{Jednostki programowe modu\xB3u oblicze\xF1}
+\label{subsec:jmo}
+
+Wykaz klas oraz jednostek programowych wchodz\xB9cych w~sk\xB3ad modu\xB3u oblicze\xF1 znajduje si\xEA w~tabeli \ref{tab:wmo}.
+
+\begin{table}[!hpt]
+    \centering
+    \begin{tabular}{l|p{20em}}
+	Klasa & Pliki z~implementacj\xB9 \\
+	\hline\hline
+	\code{baseDataTypes} & baseDataTypes.h baseDataTypes.cpp \\
+	\hline
+	\code{CalculationData} & CalculationData.h CalculationData.cpp \\
+	\hline
+	\code{Calculator} & Calculator.h Calculator.cpp \\
+	\hline
+	\code{LocalFunction} & LocalFunction.h LocalFunction.cpp \\
+	\hline
+	\code{Neighbourhood} & Neighbourhood.h Neighbourhood.cpp
+    \end{tabular}
+    \caption{Wykaz klas i~jednostek programowych wchodz\xB9cych w~sk\xB3ad modu\xB3u oblicze\xF1}
+    \label{tab:wmo}
+\end{table}
+
+Obliczanie \ac{KN} na podstawie \ac{KB} odbywaj\xB9 si\xEA w \code{Calculator}. Klasy \code{CalculationData}, \code{LocalFunction} oraz \code{Neighbourhood} implementuj\xB9 operacje na odpowiednio \ac{KB}, \ac{FL} oraz \ac{N}. Wszystkie dziedzicz\xB9 po \code{baseDataTypes} opisuj\xB9cym podstawowe typy proste, za pomoc\xB9 kt\xF3rych mo\xBFna zapisywa\xE6 dane. Kolejne obliczone \ac{KB} zapisywane s\xB9 w~module bazy danych (por. \ref{subsec:jbd}).
+
+Diagram kolaboracji modu\xB3u oblicze\xF1 przedstawiony zosta\xB3 na rysunku \ref{fig:kmo}.
+
+\begin{figure}[!hpt]
+    \begin{center}
+	\includegraphics[height=100pt]{chap4/Calculator}
+    \end{center}
+    \caption{Diagram kolaboracji modu\xB3u oblicze\xF1}
+    \label{fig:kmo}
+\end{figure}
+
+\subsection{Jednostki programowe zbioru parser\xF3w}
+\label{subsec:jpa}
+
+Wykaz klas oraz jednostek programowych wchodz\xB9cych w~sk\xB3ad zbioru parser\xF3w znajduje si\xEA w~tabeli \ref{tab:wpa}.
+
+\begin{table}[!hpt]
+    \centering
+    \begin{tabular}{l|p{20em}}
+	Klasa & Pliki z~implementacj\xB9 \\
+	\hline\hline
+	\code{GenericParserPlugin} & GenericParserPlugin.h GenericParserPlugin.cpp \\
+	\hline
+	\code{FQTParserPlugin} & FQTParserPlugin.h FQTParserPlugin.cpp \\
+	\hline
+	\code{LTFLParserPlugin} & LTFLParserPlugin.h LTFLParserPlugin.cpp \\
+	\hline
+	\code{NParserPlugin} & NParserPlugin.h NParserPlugin.cpp \\
+	\hline
+	\code{ParserInterface} & ParserInterface.h ParserInterface.cpp \\
+	\hline
+	\code{REAKParserPlugin} & REAKParserPlugin.h REAKParserPlugin.cpp \\
+	\hline
+	\code{ZIFWParserPlugin} & ZIFWParserPlugin.h ZIFWParserPlugin.cpp \\
+	\hline
+	\code{ZIFWPParserPlugin} & ZIFWPParserPlugin.h ZIFWPParserPlugin.cpp
+    \end{tabular}
+    \caption{Wykaz klas i~jednostek programowych wchodz\xB9cych w~sk\xB3ad zbioru parser\xF3w}
+    \label{tab:wpa}
+\end{table}
+
+Ka\xBFda klasa tej grupy programowej implementuje wczytywanie oraz zapisywanie danych z~innego formatu plik\xF3w. Odbywa si\xEA to poprzez por\xF3wnywanie kolejnych linijek pliku wej\x9Cciowego z~wyra\xBFeniami regularnymi, definiuj\xB9cymi poprawn\xB9 struktur\xEA dla konkretnego formatu. W~razie niezgodno\x9Cci u\xBFytkownik informowany jest o~miejscu wyst\xB9pienia b\xB3\xEAdu i~jego postaci. Dla ka\xBFdego b\xB3\xEAdu sk\xB3adniowego podawane jest wyra\xBFenie regularne definiuj\xB9ce poprawn\xB9 posta\xE6 linijki, w~kt\xF3rej wykryto nieprawid\xB3owo\x9Cci.
+
+Dane z~plik\xF3w przeparsowywane s\xB9 do struktur u\xB3atwiaj\xB9cych manipulacj\xEA nimi (np. \code{QMap}, \code{QVector}) a~nast\xEApnie zamieniane na posta\xE6 \ac{XML}-ow\xB9 z~wykorzystaniem klas og\xF3lnych (np. \code{LocalFunction} w~przypadku wszystkich format\xF3w definiuj\xB9cych \ac{FL}~--- por. \ref{subsec:jmo}).
+
+Parsery rozwi\xB9zane zosta\xB3y jako wtyczki (por. \ref{subsec:jjl}). Pozwala to na dodawanie kolejnych format\xF3w plik\xF3w do grupy obs\xB3ugiwanej przez projekt, bez potrzeby rekompilowania g\xB3\xF3wnego programu. Komunikacja z~aplikacj\xB9 odbywa si\xEA przy pomocy abstrakcyjnego interfejsu \code{ParserInterface}, implementowanego przez \code{GenericParserPlugin} (wraz z~podstawowymi testami poprawno\x9Cci plik\xF3w - por. \ref{subsec:jjl}).
+
+Diagram klas zbioru parser\xF3w przedstawiony zosta\xB3 na rysunku \ref{fig:dpa}.
+
+\begin{figure}[!htp]
+    \begin{center}
+	\includegraphics[height=150pt]{chap4/GenericParser}
+    \end{center}
+    \caption{Diagram klas zbioru parser\xF3w}
+    \label{fig:dpa}
+\end{figure}
+
+\subsection{Jednostki programowe modu\xB3u renderera}
+\label{subsec:jre}
+
+Wykaz klas oraz jednostek programowych wchodz\xB9cych w~sk\xB3ad modu\xB3u renderera znajduje si\xEA w~tabeli \ref{tab:wre}.
+
+\begin{table}[!hpt]
+    \centering
+    \begin{tabular}{l|p{20em}}
+	Klasa & Pliki z~implementacj\xB9 \\
+	\hline\hline
+	\code{Renderer} & Renderer.h Renderer.cpp
+    \end{tabular}
+    \caption{Wykaz klas i~jednostek programowych wchodzacych w~sk\xB3ad modu\xB3u renderera}
+    \label{tab:wre}
+\end{table}
+
+Na podstawie danych dostarczanych przez modu\xB3 bazy danych (por. \ref{subsec:jbd}) \code{Renderer} opisuje scen\xEA oraz zleca jej wy\x9Cwietlenie uk\xB3adowi graficznemu. W~tym celu wykorzystywane s\xB9 wywo\xB3ania biblioteki \gls{OpenGL}\citep{gl}. Klasa ta wykorzystywana jest w dwu- i~tr\xF3jwymiarowym trybie graficznym (por.\ref{par:graf}).
+
+Dzia\xB3anie tego modu\xB3u inicjowane jest wyliczeniem kolejnej iteracji przez modu\xB3 oblicze\xF1 (por. \ref{subsec:jmo}), b\xB9d\x9F przez narz\xEAdzia manipulowania wy\x9Cwietlaniem stosowane przez operatora (por. \ref{subsec:wiz} oraz \ref{subsec:jgu}).
+
+Diagram kolaboracji modu\xB3u renderera przedstawiony zosta\xB3 na rysunku \ref{fig:dre}.
+
+\begin{figure}[!hpt]
+    \begin{center}
+	\includegraphics[height=175pt]{chap4/Renderer}
+    \end{center}
+    \caption{Diagram kolaboracji modu\xB3u renderera}
+    \label{fig:dre}
+\end{figure}
+
+\section{Ograniczenia pakietu}
+\label{sec:opa}
+
+\subsection{Liczba r\xF3wnoleg\xB3ych eksperyment\xF3w}
+\label{subsec:lre}
+Zaimplementowany pakiet pozwala przeprowadza\xE6 do dw\xF3ch eksperyment\xF3w na raz. Jest zatem mo\xBFliwe prowadzenie eksperyment\xF3w por\xF3wnawczych, polegaj\xB9cych na obserwowaniu r\xF3wnoleg\xB3ego przetwarzania dw\xF3ch \ac{KB}.
+
+\subsection{Wielowymiarowe przestrzenie}
+\label{subsec:wpr}
+Pakiet pozwala na obserwowanie przetwarzania jedno-, dwu- i~tr\xF3jwymiarowych \ac{AK}. Implementacja wi\xEAcej ni\xBF tr\xF3jwymiarowych \ac{AK} jest osi\xB9galna, jednak\xBFe efektywna wizualizacja przestrzeni wielowymiarowych pozostaje kwesti\xB9 sporn\xB9. 
+
+\subsection{Ograniczenia s\xB9siedztwa}
+\label{subsec:osa}
+Implementacja silnika obliczeniowego pozwala na s\xB9siedztwo sk\xB3adaj\xB9ce si\xEA z~maksymalnie \maxint{} s\xB9siad\xF3w, oddalonych od punktu centralnego o~maksymalnie \maxint{} kom\xF3rek. Jednak\xBFe spos\xF3b wczytywania s\xB9siedztwa z~pliku tekstowego nak\xB3ada ograniczenia wynikaj\xB9ce z~liczby znak\xF3w czytelnych dla u\xBFytkownika ko\xF1cowego. Ograniczenia te zebrane s\xB9 w~tabeli \ref{tab:os}
+
+\begin{table}[!hpt]
+    \centering
+    \begin{tabular}{p{15em}|c}
+	Liczba s\xB9siad\xF3w & \maxchar \\
+	\hline
+	Odleg\xB3o\x9C\xE6 od punktu centralnego (w~kom\xF3rkach) & \maxint \\
+    \end{tabular}
+    \caption{Ograniczenia s\xB9siedztwa}
+    \label{tab:os}
+\end{table}
+
+Ograniczenia formalne znacznie przekraczaj\xB9 mo\xBFliwo\x9Cci wizualizacyjne pakietu. W~celu komfortowego prowadzenia eksperymentu wymiary s\xB9siedztwa powinny by\xE6 znacznie mniejsze. Szczeg\xF3\xB3owe testy wydajno\x9Cciowe s\xB9siedztwa znajduj\xB9 si\xEA w~rozdziale \ref{sec:wyd}.
+
+\subsection{Ograniczenia funkcji lokalnej}
+Teoretyczne mo\xBFliwo\x9Cci silnika obliczeniowego pozwalaj\xB9 na przechowywanie funkcji sk\xB3adaj\xB9cej si\xEA z~\maxint{} argument\xF3w, jednak\xBFe spos\xF3b wczytywania funkcji z~pliku nak\xB3ada ograniczenia wynikaj\xB9ce z~liczby znak\xF3w czytelnych dla u\xBFytkownika ko\xF1cowego. Praktyczne ograniczenia zebrane s\xB9 w~tabeli \ref{tab:ofl}
+
+\begin{table}[!hpt]
+    \centering
+    \begin{tabular}{p{15em}|c}
+	Rozmiar alfabetu wej\x9Cciowego & \maxchar \\
+	\hline
+	Rozmiar alfabetu wyj\x9Cciowego & \maxchar \\
+	\hline
+	Liczba argument\xF3w funkcji & \maxint \\
+    \end{tabular}
+    \caption{Ograniczenia funkcji lokalnej}
+    \label{tab:ofl}
+\end{table}
+
+W~praktyce rozmiar \ac{FL} ograniczony jest znacznie bardziej z~uwagi na sko\xF1czone zasoby obliczeniowe. Testy optymalnych rozmiar\xF3w funkcji znajduj\xB9 si\xEA w~rozdziale \ref{sec:wyd}
+
+\subsection{Ograniczenia konfiguracji pocz\xB9tkowej}
+Silnik aplikacji pozwala prowadzi\xE6 obliczenia na czterowymiarowych konfiguracjach kom\xF3rek o~warto\x9Cciach z~przedzia\xB3u 0 - \maxint{}, jednak\xBFe forma plik\xF3w wej\x9Cciowych nak\xB3ada ograniczenia wynikaj\xB9ce z~liczby znak\xF3w czytelnych dla u\xBFytkownika ko\xF1cowego. Praktyczne ograniczenia zebrane s\xB9 w~tabeli \ref{tab:okp}
+
+\begin{table}[!hpt]
+    \centering
+    \begin{tabular}{p{15em}|c}
+	Liczba wymiar\xF3w & 3 \\
+	\hline
+	Rozmiar wymiaru & \maxint \\
+	\hline
+	Liczba kom\xF3rek & \maxworld \\
+    \end{tabular}
+    \caption{Ograniczenia konfiguracji pocz\xB9tkowej}
+    \label{tab:okp}
+\end{table}
+
+Rozmiar \ac{KP}, a~co za tym idzie \ac{KB}, jest kluczowym elementem wp\xB3ywaj\xB9cym na z\xB3o\xBFono\x9C\xE6 obliczeniow\xB9 pojedynczej iteracji, a~wi\xEAc p\xB3ynno\x9Cci eksperymentu. Szczeg\xF3\xB3owe testy dotycz\xB9ce rozmiaru \ac{KP} pozwalaj\xB9cego na komfortow\xB9 prac\xEA znajduj\xB9 si\xEA w~rozdziale \ref{sec:wyd}
+
+% vim:fencs=cp1250:fenc=cp1250

Added: trunk/qcell/doc/licenciate_thesis/chap5/chap5.tex
===================================================================
--- trunk/qcell/doc/licenciate_thesis/chap5/chap5.tex	                        (rev 0)
+++ trunk/qcell/doc/licenciate_the...
 
[truncated message content]