%latex diplom_main.tex
%bibtex diplom_main

\documentclass[11pt,a4paper]{article}
\usepackage{ngerman} % Silbentrennung nach neuer Rechtschreibung
\usepackage[T1]{fontenc} % Type 1 Schriften
\usepackage{times} % Da die Standard-LaTeX-Schrift bei mir mit Acrobat nicht funkt.
\usepackage[ansinew]{inputenc} % Verwendung von Umlauten
\usepackage{scrpage2} % Seitenformat
\usepackage{titletoc}
\usepackage{titlesec}
%\usepackage{listings} % Programm-Listing
%\usepackage [usetoc]{titleref} 
\usepackage{graphicx} % Einbindung von Graphiken
\usepackage{url} % URLs durch \url{}
\usepackage{bibgerm} % deutsche Bibliographie
%\usepackage{txfonts}%Paket f"ur das nat Symbol
\usepackage{multicol}
\usepackage{makeidx}%for the index


% Seitenstil festlegen
\pagestyle{useheadings}%or: headings

% n"achste vier Zeilen: Format des Inhaltsverzeichnisses
%\titlespacing{\section}{0pt}{5cm}{5cm}%spacing by sections {in front}{above}{below}
%\dottedcontents{section}[1.5em]{\addvspace{1.0em}}{1.3em}{0.7pc}
%\dottedcontents{subsection}[3.8em]{}{2.2em}{0.7pc}
%\dottedcontents{subsubsection}[7.0em]{}{3.1em}{0.7pc}

%\setcounter{secnumdepth}{4}%%nummerierung der Unterabschnitte bis Tiefe

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Definitionen f"ur das Verwenden von Listings

\newtheorem{Def}{Definition}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Beginn des Dokuments

\makeindex 

\begin{document}

\title{Wilde Raumzeit}
\author{Betti "Osterholz}
\date{\today}

\begin{titlepage}
	\begin{center}
	\ \vspace{2.5cm} \\
	\Huge\bf Benutzerhandbuch\\
	\Huge\bf Simulatoren f"ur Wilde Raumzeit\\\vspace{3cm}
	\LARGE Betti "Osterholz\\\vspace{0.5cm}
	\large Betti\_Oesterholz@gmx.de\\\vspace{0.5cm}
	\large www.BioKom.info\\\vspace{0.5cm}
	Potsdam, \today\\\vspace{5cm}
	\end{center}
	
	\noindent
Copyright (c) 2005  Betti "Osterholz
\newline\newline
Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.2 or any later version published by the Free Software Foundation; with no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.
    
A copy of the license is included in the section entitled "`GNU Free Documentation License"'.
\end{titlepage}

\renewcommand{\sectionmark}[1]{\markboth{#1}{}}
\pagenumbering {Roman}
\automark{section}
\pagestyle{scrheadings} % individ. Seitenlayout
\setheadsepline{0.4pt}
\ihead{} % Titelzeile innen
\ohead{} % Titelzeile aussen
\chead{\slshape \headmark}  % Titelzeile mitte
\cfoot{\thepage} % Fusszeile mitte

% braucht man ein Inhaltsverzeichnis, so sind die n"achsten drei Zeilen auszukommentieren
%\setcounter{tocdepth}{3}
%\tableofcontents
%\clearpage

% Vorschlag f"ur Titelzeile:
% Bei umfangreicheren Dokumenten
\ihead{\slshape \headmark } % Darstellung von Sectionnummer und -name
\ohead{}
\chead{}
\clearpage

\tableofcontents
\contentsline{section}{Index}{\pageref{AbsIndex}}

\clearpage
\pagenumbering{arabic}


\section{Einleitung}

Zu meinem Universum "`Wilde Raumzeit"', dessen Dokumentation (\cite{wildeRZ}) unter \url{www.BioKom.info/Projekt_Wilde_Raumzeit.html} zu finden ist, habe ich auch drei Simulatoren (zu finden auf der gleichen Internetseite) geschrieben. Die vorliegende Arbeit ist als Dokumentation bzw. Benutzerhandbuch f"ur diese Simulatoren zu sehen.

Die Simulatoren berechnet dabei nicht das Universum, sondern g"ultige Folgen von Raumuniversen. Sie unterscheiden sich nur in den Wahrscheinlichkeiten mit der eine bestimmte Raumuniversumsfolge berechnet wird und der Zeit die Berechnung ben"otigt. Der Unterschied kommt durch die unterschiedlichen Wahlen der Transition zustande.

Der Simulator univers w"ahlt die Transitionen gleichwahrscheinlich aus der Menge der m"oglichen Transitionen aus und ist der wohl langsamste der drei Simulatoren.

Beim Simulator universD liegt der Wahl der Transitionen die Anzahl der ausgehenden Distanzen eines Punktes (plus Eins) zugrunde.

Im Simulator universP wird zuerst ein Punkt und dann zwei Distanzen (plus Eins) dieses Punktes gleichwahrscheinlich ausgew"ahlt. Dieser Simulator ist wohl der schnellste der drei Simulatoren, daf"ur sind die Wahrscheinlichkeiten, mit der Raumuniversumsfolgen erzeugt werden, am weitesten von dem Universum "`Wilde Raumzeit"' entfernt.

In diesem Benutzerhandbuch werden alle drei Simulatoren gleichzeitig behandelt, da ihre Funktionsweise sich nur in unterschiedlichen Wahlen der Transition unterscheidet. Nur wo dieser Unterschied zum Tragen kommt, werden die drei Simulatoren separat besprochen.


\bigskip\noindent
Diese Arbeit ist in zwei Teile untergliedert: 

Im ersten Teil werden die Grundlagen und Parameter der Simulatoren beschrieben. Er dient Anwendern die nur die vorhandene Funktionalit"at der Simulatoren nutzen wollen ohne diese zu erweitern. 

Im zweiten Teil wird die Implementierung der Simulatoren beschrieben. Er soll Anwendern die Erweiterung des Simulators erleichtern. %In ihm wird auf die Daten und einzelnen Methoden der Klassen eingegangen. Weiterhin wird beschrieben wie diese bei einer Erweiterung des Simulators genutzt werden k"onnen.%??

\bigskip\noindent
Die Simulatoren sind f"ur erfahrene Anwender gedacht die sich mit der Theorie "`Wilde Raumzeit"' auskennen. Daher ist der Umgang mit den Simulatoren nicht so einfach, wie z.B. mit normalen Windowsprogrammen. F"ur Jemanden der die Grundlagen der Theorie nicht kennt, haben die Simulatoren wohl auch keinen Verwendungszweck. 

Des weiteren sind die Simulatoren eine reine Konsolenanwendungen.

Die Simulatoren unterliegt zur Zeit auch einem Weiterentwicklungsprozess, so dass nicht garantiert werden kann, dass diese Dokumentation auf dem aktuellen Stand der Dinge ist.

Im Nachfolgendem werden Quelltextabschnitte im \texttt{Schreibmaschinenstil} geschrieben.


\section{Installation}
\label{Installation}

F"ur die Simulatoren gibt es keine direkte Installation. Das erhalten einer ausf"uhrbaren Datei f"ur die Simulatoren ist bei allen drei gleich. Die Dateien ausf"uhrbaren Dateien f"ur die Simulatoren unterscheidet sich nur in ihren Namen (genauer: in der Endung des Namens '','D' und 'P'). Alle Versionen sind in C++ geschrieben und liegen (auch) im Quelltext vor.

Bei den Linux Versionen muss der Quellcode kompiliert werden. Dazu speichern sie die Quellcode Dateien in ein Verzeichnis, "offnen eine Konsole, wechseln auf der Konsole in das Verzeichnis und f"uhren "`make"' aus (mittels "`\texttt{./make}"').

Die entstandene Simulatordatei z.B. "`univers"' kann nun mit "`\texttt{./univers parameter}"' ausgef"uhrt werden, wobei "`parameter"' die Datei ist, in der die Parameter gespeichert sind. Wird keine Parameterdatei angegeben, so werden die Standartparametern aus der Datei "`standart\_Parameter.txt"' geladen.

Wenn der Simulator "ofter verwendet werden soll, ist es sicherlich sinnvoll, den Pfad der Simulatordatei (z.B. "`univers"') zum Standartsuchpfad hinzuzuf"ugen. Daf"ur kann beispielsweise in der versteckten Datei "`.bashrc"' im Stammverzeichnis des Benutzers die Zeile "`\texttt{PATH=\$PATH:/username/simulator/}"' hinzugef"ugt werden, wobei "`/username/simulator/"' das Verzeichnis des Simulators ist.

Bei den Windows Versionen muss nur die ausf"uhrbare Datei heruntergeladen werden. Sie wurden von Linux portiert und sollten zumindest unter Windows XP laufen.


\section{Schnellstart}

Vor der ersten Ausf"uhrung eines Simulators ist die Simulatordatei, z.B. "`univers"', zu erzeugen, siehe hierzu Abschnitt \ref{Installation} . Im Nachfolgendem wird als angenommen das die Simulatordatei "`univers"' hei"st, wenn der Simulator "`universD"' oder "`universP"' verwendet wird, ist "`univers"' entsprechend zu ersetzen.

Die Simulatoren sind alle reine Konsolenanwendungen. Gestartet wird der Simulator mit "`\texttt{./univers parameter}"', wobei "`parameter"' die Datei ist, in der die Parameter gespeichert sind. Wird keine Parameterdatei angegeben, so wird die Datei "`standart\_Parameter.txt"' mit den standart Parametern geladen. Eine Parameterdatei kann z.B. dadurch erstellt werden, indem die Parameterdatei "`standart\_Parameter.txt"' mit einem Texteditor ge"offnet, entsprechend modifiziert und unter neuem Namen abgespeichert wird.

Was die einzelnen Parameter bedeuten wird im Nachfolgendem n"aher erl"autert.

Mit der Eingabe von "`E"' (End) oder "`C"' (Chancel), beides als Gro"sbuchstaben, kann die aktuelle Testreihe beendet werden. Dabei wird noch die aktuelle Iteration/Runde beendet. Die Eingaben f"uhren nur zu unterschiedlichen Ergebnissen, wenn die Testreihe fortgesetzt werden soll (siehe \ref{UniversumFortsetzen}).


\section{Simulatorbeschreibung}

In den Nachfolgenden Unterabschnitten werden meist zuerst die f"ur das angesprochene Thema relevanten Methoden, Daten, Klassen und/oder Parameter aufgef"uhrt. 

\subsection{\index{Raumuniversen}Raumuniversen}

\begin{tabbing}
\hspace{10mm} \= \kill
Methoden: \texttt{\index{start()}void start(unsigned long trans=0);} \\
\>\texttt{\index{endCondition()}bool endCondition(); }\\
\>\texttt{\index{getInternalTime()}unsigned long getInternalTime(); }\\
\>\texttt{\index{getUniversStructur()}list<TPoint*>* getUniversStructur(); }\\
\>\texttt{\index{getUnivers()}TUPart getUnivers(); }\\
\>\texttt{\index{getNumberOfPoints()}unsigned long getNumberOfPoints(); }\\
\>\texttt{\index{getLastName()}unsigned long getLastName(); }\\
\>\texttt{\index{getNumberOfPDistance()}unsigned long getNumberOfPDistance(); }\\
\>\texttt{\index{getNumberOfNDistance()}unsigned long getNumberOfNDistance()}\\
Daten: \texttt{\index{univers}list<TPoint*> univers}\>\\
Klassen: \texttt{\index{TPoint}TPoint; \index{TUPart}TUPart}
\end{tabbing}
Zentrales Objekt der Theorie "`Wilde Raumzeit"' sind Raumuniversen. Die Simulatoren bilden aus einem Raumuniversum durch (eine) Transition(en) ein neues Raumuniversum. 

Ein Raumuniversum wird repr"asentiert durch eine List von \index{Raumuniversen!Punkte} Punkten des Raumuniversums (\texttt{list<TPoint*> univers}). Jeder dieser Punkte \texttt{TPoint} enth"alt einen Namen in Form einer ganzen Zahl (\texttt{unsigned long name}) und zwei Listen von Zeigern auf Punkte, die seine positiven (\texttt{list<TPoint*> pPoint}) und negativen (\texttt{list<TPoint*> nPoint}) Nachbarpunkten sind (der Punkt ist verbunden mit dem Nachbarpunkt durch je eine positiven bzw. negative Distanz pro Eintrag). Auf diese Weise kann einfach eine Transition ausgef"uhrt werden, indem ein Punkt und von ihm zwei Nachbarpunkte (inklusive neuen Punkt) ausgew"ahlt werden. Es kann leicht durch das Raumuniversum "`gewandert"' werden, indem von einem Punkt "uber einem Zeiger aus seinen Nachbarpunktenlisten zu einem Nachbarpunkt gesprungen wird.
Au"serdem k"onnen die Punkte nach ihren Namen in der Ordnung der ganzen Zahlen eindeutig geordnet werden.

Im Programmsystem wird nur ein Raumuniversum (das aktuelle) im Arbeitsspeicher gehalten, um Arbeitsspeicher zu sparen. Dies ist sinnvoll, da die Raumuniversen schnell gr"o"ser werden. Es kann aber daf"ur gesorgt werden, dass das jeweils aktuelle Raumuniversum auf Festplatte persistent gespeichert wird.

Die Funktion \texttt{getNumberOfPoints()} liefert die Anzahl der Punkte, die Funktion
\texttt{getNumberOfPDistance()} die Anzahl der positiven Distanzen und \texttt{getNumberOfNDistance()} die Anzahl der negativen Distanzen im aktuellen Raumuniversum.
Mit der Funktion \texttt{getLastName()} wird der Name des letzten erzeugten Punktes zur"uckgegeben, bzw. der Name, der die h"ochste Nummer darstellt, da bei Transitionen entstehende Punkt nach der Ordnung der nat"urlichen Zahlen mit 1 beginnend benannt werden.

In der Klasse \texttt{TUPart} k"onnen die zu einem Raumuniversum geh"origen Daten abgespeichert werden. Dazu geh"oren die einzelnen Punkte (\texttt{TPoint}) des Raumuniversums plus die Anzahl der positiven, negativen Distanzen und der zuletzt vergebene Name im Raumuniversum.

Durch die Funktion \texttt{getUniversStructur()} wird ein Zeiger auf das aktuelle Raumuniversum (\texttt{list<TPoint*>*}) zur"uckgegeben. Jede Ver"anderung des zur"uckgegebenen Raumuniversums wirkt sich also direkt auf das aktuelle Raumuniversum aus. 
Mit der Funktion \texttt{getUnivers()} werden die Daten zu dem aktuellen Raumuniversum zur"uckgegeben. Dabei wirken sich nur Ver"anderungen in den Punkten der zur"uckgegebenen Struktur auf das aktuelle Raumuniversum aus. Wenn Beispielsweise nur neue Punkte im Raumuniversum der zur"uckgegebenen Struktur hinzugef"ugt werden, hat dies keinen Einfluss auf das aktuelle Raumuniversum.


\subsection{Transitionen}

\begin{tabbing}
\hspace{10mm} \= \kill
Methoden: \texttt{\index{tick()}void tick(unsigned long trans); void tick();}\\
\>\texttt{\index{evalueTransition()}void evalueTransition(TPoint* poi);}\\
\>\texttt{void evalueTransition(TPoint* poi, unsigned long wich);}\\
\>\texttt{\index{endCondition}bool endCondition();}\\
\>\texttt{\index{getInternalTime()}unsigned long getInternalTime();}\\
\>\texttt{\index{getNumberOfLastTransitions()}unsigned long* getNumberOfLastTransitions()}
\end{tabbing}
Die Simulatoren unterst"utzt nat"urlich nur die eine-Welt-Sicht. Es wird also eine Raumuniversenfolge berechnet. Das Berechnen aller Nachfolger nur eines Raumuniversums ist normalerweise viel zu aufw"andig, da es nur f"ur einen Punkt $n_a^2=(n_p+n_n+1)^2$ m"ogliche Transitionen gibt ($n_p$ Anzahl der positiven und $n_n$ Anzahl der negativen Nachbarn). F"ur die Wahl des n"achsten Transitionspunktes gibt es jeweils zwei unterschiedlich schnelle (\texttt{tick()}) Methoden

Eine Transition wird durch die Methode \texttt{evalueTransition(poi)} bzw. die Methode \texttt{evalueTransition(poi, wich)} ausgef"uhrt. Transitionenfolgen werden durch die \index{Ticks}\texttt{tick()} Methoden realisiert. In diesen Methoden liegt der Unterschied zwischen den drei Simulatoren.

Die Methode \texttt{tick()} ohne Parameter ist dabei jeweils die Standartmethode, die Methode \texttt{tick(trans)} ist nur von Interesse, wenn das Programmsystem abge"andert werden soll. Des weiteren ist die Art der Wahl der jeweiligen \texttt{tick(trans)} Methode n"aher an der Wahl der Theorie "`Wilde Raumzeit"', ist aber bei der gleichen Transitionsanzahl langsamer, als die Wahl der jeweiligen Methode \texttt{tick()} ohne Parameter. In wie weit die jeweils unterschiedlichen Arten der Wahl beider \texttt{tick()} Methoden aber Einfluss auf die entstehenden Raumuniversenfolgen und Wahrscheinlichkeiten haben, ist ungewiss. Nur bei der \texttt{tick(trans)} Methode des Simulators "`univers"', entspricht die Auswahlwahrscheinlichkeit einer Transition f"ur das Raumuniversum der in der Theorie "`Wilde Raumzeit"' geforderten. 

Im Nachfolgenden werden die \texttt{evalueTransition()} und \texttt{tick()} Methoden der einzelnen Simulatoren beschrieben.




\subsubsection{univers}

In diesem Simulator ist jedem Punkt und dem ganzem Raumuniversum eine Zahl f"ur die Zahl der m"oglichen Transitionen zugeordnet. Die Anzahl der m"oglichen Transitionen f"ur einen Punkt ist dabei (wie in der Theorie) $n_a^2=(n_p+n_n+1)^2$, mit $n_p$ Anzahl der positiven und $n_n$ Anzahl der negativen Nachbarn. Die Anzahl der m"oglichen Transitionen f"ur das Raumuniversum ist die Summe der Anzahlen der m"oglichen Transitionen aller Punkte des Raumuniversums.

Im Simulator "`univers"' wird mit der \texttt{evalueTransition(poi, wich)} eine Transition ausgef"uhrt. Ihr wird der Zeiger zu dem Punkt "ubergeben, welcher der Entstehungspunkt der Transition sein soll. Der der Methode "ubergebene Parameter \texttt{wich} ($0 \leq wich <(n_p+n_n+1)^2$) bestimmt die beiden Nachbarpunkte f"ur die Transition ($t(Raumuniversum,p_1,p_2,p_3)$). Der erste Punkt $p_1$ entspricht der Zahl $wich/(n_p+n_n+1)$ und der dritte Punkt $p_3$ der Zahl $(wich\pmod{n_p+n_n+1})$ (der zweite Punkt $p_2$ der Transition ist der "ubergebene Punkt \texttt{poi}). Ist die Zahl $P$, die dem Punkt entspricht, kleiner $n_p$ ($P<n_p$), ist der Punkt der $P$'te positive Nachbarpunkt (die Z"ahlung beginnt bei 0). Wenn die Zahl $P$ gr"o"ser gleich $n_p$ und kleiner als $n_p+n_n$ ist ($n_p \geq P<n_p+n_n$), ist der Punkt der $(P-n_p)$'te negative Punkt (die Z"ahlung beginnt auch bei 0). Sonst, wenn $P=n_p+n_n+1$ ist, ist der Punkt ein neuer Punkt. Wenn zwei neue Punkte gew"ahlt werden, dann werden immer zwei verschiedene neue Punkte gew"ahlt.
Mit den gew"ahlten Punkten wird nach der Transitionstabelle in \cite{wildeRZ} die Ver"anderungen im Raumuniversum durchgef"uhrt. Wird ein neuer Punkt erzeugt, ist dessen Name der Name des zuletzt erzeugten neuen Punktes erh"oht um Eins. Auf diese Weise sind die durch Transitionen vergebenen Namen eindeutig.

Die \texttt{tick()} Methode ohne Prameter f"uhrt f"ur jeden Punkt im Raumuniversum eine Transition (mit \texttt{evalueTransition(poi, wich)}) aus. 
Um die Auswahl zu beschleunigen, wird nicht aus dem ganzen Raumuniversum der n"achste Ursprungspunkt f"ur die Transition ausgew"ahlt, sondern das Raumuniversum wird von vorn nach hinten durchwandert, wobei nach dem letzten Punkt des Raumuniversums sein erster Punkt kommt. Daf"ur enth"alt das Universum einen aktuellen Punkt $p_a$, der beim Erzeugen, Beschneiden und Laden des Raumuniversums auf den ersten ("altesten) Punkt der Raumuniversumsliste (\texttt{list<TPoint*> univers}) gesetzt wird.

Nach dem Aufruf der \texttt{tick()} Methode wird die Anzahl der Punkte im Raumuniversum durch $256$ ermittelt, diese Zahl wird in eine ganze Zahl $S$ gr"o"ser $1$ umgewandelt (if ($Punkte/256>1$) Then $S=Punkte/256$ Else $S=1$). Nun wird eine Schleife die Anzahl der Punkte im Raumuniversum mal durchlaufen. In dieser Schleife wird f"ur den n"achsten Transitionsursprungspunkt jeweils eine Zahl $P$ ermittelt, welche die Anzahl m"oglichen Transitionen f"ur des aktuelle Raumuniversum durch die zuvor ermittelte Zahl $S$ ist. Nun wird auf eine Zahl $Z$, die beim Aufruf der \texttt{tick()} Methode mit 0 initialisiert wurde, eine Zufallszahl zwischen 0 und $P$ (im Bereich von $0...(P-1)$) addiert. Solange diese Zahl $Z$ gr"o"ser gleich die Anzahl $P_a$ der m"oglichen Transitionen des aktuellen Punkts $p_a$ ist, wird diese ($P_a$) von erstere $Z$ abgezogen ($Z=Z-P_a$) und f"ur den aktuellen Punkt $p_a$ der n"achste Punkt (in der Liste) genommen. Ist der aktuelle Punkt $p_a$ der letzte Punkt der Liste (des aktuellen Raumuniversums) wird der erste Punkt der Liste als aktueller Punkt $p_a$ genommen. 

Wenn Zahl $Z$ kleiner als die Anzahl $P_a$ der m"oglichen Transitionen des aktuellen Punkts $p_a$ ist, wird die \texttt{evalueTransition($p_a$, $Z$)} aufgerufen. Es wird also eine Transition ausgef"uhrt, mit $p_a$ als Ursprungspunkt und $Z$ als Zahl die die beiden anderen Nachbarpunkte bestimmt.

Durch diese Art der Wahl der Ursprungspunkte f"ur eine Transition, werden im Durchschnitt rund $128$ Punkte zwischen den Transitionen in der Raumuniversumsliste "ubersprungen, bevor wieder ein Punkt Ursprungspunkt einer Transition wird.
Die Wahl der Transitionsentstehungspunkte entspricht nicht der in der Theorie "`Wilde Raumzeit"' geforderten, verk"urzt aber die Berechnungszeit. 

Die Methode \texttt{tick(trans)} w"ahlt demgegen"uber aus allen m"oglichen Transitionen des aktuellen Raumuniversums eine zuf"allig Gleichwahrscheinlich als n"achste Transition aus. Dies wird dann \texttt{trans} mal wiederholt. Diese Art der Wahl entspricht der Wahl, wie sie mit der Theorie "`Wilde Raumzeit"' konsistent ist, ist aber bei der gleichen Transitionsanzahl langsamer, als die Wahl der Methode \texttt{tick()} ohne Parameter. 


\subsubsection{universD}

Dieser Simulator funktioniert wie der Simulator "'univers"' des vorhergehenden Abschnitts, nur dass der Anzahl der m"oglichen Transitionen nicht die Anzahl der Nachbarpunkte eines Punktes zugrunde liegt, sondern die Anzahl der ausgehenden Distanzen. Dadurch wird die Berechnung der m"oglichen Transitionen etwas einfacher. 

In diesem Simulator ist jedem Punkt und dem ganzem Raumuniversum eine Zahl f"ur die Zahl der m"oglichen Transitionen zugeordnet. Die Anzahl der m"oglichen Transitionen f"ur einen Punkt ist dabei (entgegen der Theorie) $d_a^2=(d_p+d_n+1)^2$, mit $d_p$ Anzahl der positiven und $d_n$ Anzahl der negativen ausgehenden Distanzen. Die Anzahl der m"oglichen Transitionen f"ur das Raumuniversum ist die Summe der Anzahlen der m"oglichen Transitionen aller Punkte des Raumuniversums.

Im Simulator "`universD"' wird mit der \texttt{evalueTransition(poi, wich)} eine Transition ausgef"uhrt. Ihr wird der Zeiger zu dem Punkt "ubergeben, welcher der Entstehungspunkt der Transition sein soll. Der der Methode "ubergebene Parameter \texttt{wich} ($0 \leq wich <(n_p+n_n+1)^2$) bestimmt die beiden Nachbarpunkte f"ur die Transition ($t(Raumuniversum,p_1,p_2,p_3)$). Ein Punkt $p$ wird dadurch gew"ahlt, dass eine von Ursprungspunkt $p_2$ ausgehenden Distanz $d$ gew"ahlt wird, die zu ihm geht.

Die erste Distanz $d_1$ (zu dem ersten Punkt $p_1$) entspricht der Zahl $wich/(d_p+d_n+1)$ und die zweite Distanz $d_2$ der Zahl $(wich\pmod{d_p+d_n+1})$, diese Distanz $d_2$ bestimmt den dritten Punkt $p_3$ (der zweite Punkt $p_2$ der Transition ist der "ubergebene Punkt). Ist die Zahl $D$, die der Distanz entspricht, kleiner $d_p$ ($D<d_p$), ist die Distanz die $D$'te positive Distanz (die Z"ahlung beginnt bei 0). Wenn die Zahl $D$ gr"o"ser gleich $d_p$ und kleiner als $d_p+d_n$ ist ($d_p \geq D<d_p+D_n$), ist die Distanz die $(D-d_p)$'te negative Distanz (die Z"ahlung beginnt auch bei 0). Sonst, wenn $D=d_p+d_n+1$ ist, ist der entsprechende Punkt ein neuer Punkt. Wenn zwei neue Punkte gew"ahlt werden, dann werden immer zwei verschiedene neue Punkte gew"ahlt.
Mit den durch die Distanzen gew"ahlten Punkten wird nach der Transitionstabelle in \cite{wildeRZ} die Ver"anderungen im Raumuniversum durchgef"uhrt. Wird ein neuer Punkt erzeugt, ist dessen Name der Name des zuletzt erzeugten neuen Punktes erh"oht um Eins. Auf diese Weise sind die durch Transitionen vergebenen Namen eindeutig.

Die \texttt{tick()} Methode ohne Prameter f"uhrt f"ur jeden Punkt im Raumuniversum eine Transition (mit \texttt{evalueTransition(poi, wich)}) aus. 
Um die Auswahl zu beschleunigen, wird nicht aus dem ganzen Raumuniversum der n"achste Ursprungspunkt f"ur die Transition ausgew"ahlt, sondern das Raumuniversum wird von vorn nach hinten durchwandert, wobei nach dem letzten Punkt des Raumuniversums sein erster Punkt kommt. Daf"ur enth"alt das Universum einen aktuellen Punkt $p_a$, der beim Erzeugen, Beschneiden und Laden des Raumuniversums auf den ersten ("altesten) Punkt der Raumuniversumsliste (\texttt{list<TPoint*> univers}) gesetzt wird.

Nach dem Aufruf der \texttt{tick()} Methode wird die Anzahl der Punkte im Raumuniversum durch $256$ ermittelt, diese Zahl wird in eine ganze Zahl $S$ gr"o"ser $1$ umgewandelt (if ($Punkte/256>1$) Then $S=Punkte/256$ Else $S=1$). Nun wird eine Schleife die Anzahl der Punkte im Raumuniversum mal durchlaufen. In dieser Schleife wird f"ur den n"achsten Transitionsursprungspunkt jeweils eine Zahl $P$ ermittelt, welche die Anzahl m"oglichen Transitionen f"ur des aktuelle Raumuniversum durch die zuvor ermittelte Zahl $S$ ist. Nun wird auf eine Zahl $Z$, die beim Aufruf der \texttt{tick()} Methode mit 0 initialisiert wurde, eine Zufallszahl zwischen 0 und $P$ (im Bereich von $0...(P-1)$) addiert. Solange diese Zahl $Z$ gr"o"ser gleich die Anzahl $P_a$ der m"oglichen Transitionen des aktuellen Punkts $p_a$ ist, wird diese ($P_a$) von erstere $Z$ abgezogen ($Z=Z-P_a$) und f"ur den aktuellen Punkt $p_a$ der n"achste Punkt (in der Liste) genommen. Ist der aktuelle Punkt $p_a$ der letzte Punkt der Liste (des aktuellen Raumuniversums) wird der erste Punkt der Liste als aktueller Punkt $p_a$ genommen. 

Wenn Zahl $Z$ kleiner als die Anzahl $P_a$ der m"oglichen Transitionen des aktuellen Punkts $p_a$ ist, wird die \texttt{evalueTransition($p_a$, $Z$)} aufgerufen. Es wird also eine Transition ausgef"uhrt, mit $p_a$ als Ursprungspunkt und $Z$ als Zahl, welche die beiden anderen Nachbarpunkte bestimmt.

Durch diese Art der Wahl der Ursprungspunkte f"ur eine Transition, werden im Durchschnitt rund $128$ Punkte zwischen den Transitionen in der Raumuniversumsliste "ubersprungen, bevor wieder ein Punkt Ursprungspunkt einer Transition wird.

Die Methode \texttt{tick(trans)} w"ahlt demgegen"uber aus allen m"oglichen Transitionen des aktuellen Raumuniversums einen zuf"allig Gleichwahrscheinlich als n"achste Transition aus. Dies wird dann \texttt{trans} mal wiederholt. 


\subsubsection{universP}

Im Simulator "`universP"' wird mit der \texttt{evalueTransition(poi)} Methode eine Transition ausgef"uhrt. Ihr wird der Zeiger zu dem Punkt "ubergeben, welcher der Entstehungspunkt der Transition sein soll. Die Methode w"ahlt dann zuf"allig, Gleichwahrscheinlich aus den Nachbarpunkten plus einem neuem Punkt zwei Punkte aus (wenn zwei neue Punkte gew"ahlt werden, dann werden immer zwei verschiedene neue Punkte gew"ahlt) und f"uhrt nach der Transitionstabelle in \cite{wildeRZ} die Ver"anderungen im Raumuniversum durch. Wird ein neuer Punkt erzeugt, ist dessen Name der Name des zuletzt erzeugten neuen Punktes erh"oht um Eins. Auf diese Weise sind die durch Transitionen vergebenen Namen eindeutig.

Die \texttt{tick()} Methode ohne Prameter f"uhrt f"ur jeden Punkt im Raumuniversum nacheinander eine Transition (mit \texttt{evalueTransition(poi)}) aus. Begonnen wird beim ersten ("altesten) Punkt der Raumuniversumsliste (\texttt{list<TPoint*> univers}) und geendet bei dem Punkt, der beim Aufruf der \texttt{tick()} Methode der letzte in der Liste war. Durch diese Art der Wahl ist diese \texttt{tick()} Methode die schnellst aller Simulatoren. 

Die Methode \texttt{tick(trans)} w"ahlt demgegen"uber aus allen Punkten des aktuellen Raumuniversums einen zuf"allig Gleichwahrscheinlich f"ur die erste Transition aus, dann wird auf den n"achsten \texttt{trans} Punkten jeweils eine Transition ausgef"uhrt.  




\subsubsection{Weitere Methoden}

Hier werden weitere Methoden der Simulatoren im Zusammenhang mit Transitionen aufgef"uhrt.

Wenn der \texttt{start(trans)} Methode 0 oder kein Wert "ubergeben wird, wird die \texttt{tick()} Methode benutzt, sonst wird die \texttt{tick(trans)} Methode benutzt, wobei der "ubergebene Wert \texttt{trans} gleich dem der \texttt{start()} Methode "ubergebene Wert \texttt{trans} ist.

Das Universum enth"alt eine \index{interne Zeit}interne Zeit \texttt{iTime}, die angibt, wie oft seit dem erzeugen des Universums eine der \texttt{tick()} Methoden aufgerufen wurde. Sie kann mit \texttt{getInternalTime()} abgefragt werden.

Die Methode \texttt{getNumberOfLastTransitions()} liefert ein Array mit 10 Elementen zur"uck. Der erste Wert (mit Index 0) liefert die gesamt Anzahl der Transitionen zur"uck, der Wert mit Index $i$ die Anzahl der Transition $t_i$ (nach der Transitionstabelle in \cite{wildeRZ}). Die Anzahlen beziehen sich jeweils entweder auf die Anzahl der Transitionen, die seit dem letzten Aufruf von \texttt{tick()} (ohne Parameter) gemacht wurden, oder, wenn \texttt{tick()} nicht verwendet wurde, auf die gesamte Anzahl der Transitionen.

Die Methode \texttt{endCondition()} gibt genau dann Wahr zur"uck, wenn die weitere Berechnung des Universums (weitere \index{Ticks}Ticks bzw. \texttt{tick()} Aufrufe) abgebrochen werden soll (siehe \ref{Endbedingung} auf Seite \pageref{Endbedingung}).


\subsection{Ein- und Ausgabe von Raumuniversen}
\label{ein-ausgabe}
\index{Raumuniversen!einlesen}
\index{Raumuniversen!ausgeben}

\begin{tabbing}
\hspace{10mm} \= \kill
Methoden: \texttt{\index{printUnivers()}bool printUnivers(ostream \&ostream);}\\
\>\texttt{\index{readUnivers()}bool readUnivers(istream \&stream)}\\
Klassen: \texttt{\index{TOPoint}TOPoint}
\end{tabbing}
Das aktuelle Raumuniversum kann mit der Methode \texttt{printUnivers()} in einen Stream (z.B. zur Festplatte) gespeichert und mit der Methode \texttt{readUnivers()} durch ein Raumuniversum aus dem Stream (z.B. aus einer Datei) ersetzt werden. Daf"ur wird den Methoden jeweils ein Zeiger auf den Stream "ubergeben. Die Methoden liefern \texttt{false} zur"uck, wenn die Ein- bzw. Ausgabe nicht erfolgreich war.

Im Stream werden die Punkt und ihre Verbindungen mithilfe ihrer Namen abgespeichert. Jede Zeile wird durch ein "`."' beendet. In der ersten Zeile steht die gesamte Anzahl der Punkte des im Stream abgespeicherten Raumuniversum. Danach folgt f"ur jeden Punkt des Raumuniversums eine eigene Zeile, wobei die Punkte nach ihren Namen (bzw. Entstehungszeit) aufsteigend geordnet sind. Als erstes steht dabei in der Zeile der Name des Punktes gefolgt von einem Semikolon "`;"', dann folgen jeweils die Nachbarpunkte, wobei vor jedem Nachbarpunkt ein Komma steht "`,"'. Zuerst werden die Nachbarn aufgef"uhrt zu denen eine positive Distanz geht und dann die Nachbarn zu denen eine negative Distanz geht, diese beiden Nachbarlisten werden, auch wenn sie leer sind, durch ein Semikolon "`;"' getrennt.

\bigskip\noindent
Beispiel eines gespeicherten Raumuniversums:
\begin{verbatim}
4.
2;,3;,6.
3;,2;,6.
6;;,2,3.
10;;.
\end{verbatim}


\subsection{Parameter}\index{Parameter|(}
\label{Parameter}

\begin{tabbing}
\hspace{10mm} \= \kill
Methoden: \texttt{\index{restoreParameter()}\index{Parameter!speichern}bool restoreParameter(char* pFile);}\\
\>\texttt{\index{storeParameter()}\index{Parameter!laden}bool storeParameter(char* pFile)}\\
Daten: \texttt{\index{parameter}list<TParameter> parameter}\\
Klassen: \texttt{\index{TParameter}class TParameter}\\
Dateien: \index{standart\_Parameter.txt}standart\_Parameter.txt; \index{Null\_Parameter.txt}Null\_Parameter.txt
\end{tabbing}
Die meisten Parameter dienen zur Ausgabe und Formatierung von Statistiken, nur sehr wenige (z.B. das Anfangsraumuniversum) haben einen Einfluss auf die Entwicklung der Raumuniversumsfolge.

F"ur die einzelnen Parameter gibt es jeweils zwei m"ogliche \index{Parameter!Methoden} Methoden, "`\texttt{get}"'- und "`\texttt{set}"'-Methoden. Die Methoden die mit "`\texttt{get}"' beginnen dienen zur Ausgabe des Wertes des Parameters. Dagegen kann mit Methoden die mit "`\texttt{set}"' beginnen der Wertes des Parameters gesetzt werden. Daneben werden von "`\texttt{set}"'-Methoden manchmal noch zugeh"orige Operationen ausgef"uhrt, z.B. wird eine zum Parameter geh"orende Datei ge"offnet. Ist eine der beiden oder sind beide Methoden nicht vorhanden, soll auf dem zugeh"origen Parameter nicht die Operation(-en) ausgef"uhrt werden k"onnen.

Ist f"ur einzelne \index{Statistik}Statistiken, die Daten f"ur Raumuniversen zu verschiedenen Zeiten in einer \index{Statistikdateien}Datei ausgeben, der Parameter zur Ausgabe gesetzt und wird ein neuer Dateiname gesetzt oder es wird nur der Parameter zur Ausgabe (auf gr"o"ser 0 oder wahr) gesetzt, so wird automatisch die Datei erzeugt. Deshalb ist beim setzen dieser Parameter mit etwas Vorsicht vorzugehen um Fehler oder zus"atzliche, leere und "uberfl"ussige Dateien zu vermeiden.

\bigskip\noindent
Jedem Parameter ist neben seinem Wert noch eine \index{Parameter!Nummer} Nummer, eine \index{Parameter!Zeilennummer} Zeilennummer und eine \index{Parameter!Beschreibung} Beschreibung bzw. ein \index{Parameter!Name} Name zugeordnet. Die Nummer, die Zeilennummer und die Beschreibung zu einem Parameter k"onnen in einem Objekt der Klasse \texttt{TParameter} gespeichert werden, wobei auf diesen Objekten eine Ordnung nach ihrer Zeilennummer (Parameter mit der niedrigerer Zeilennummer kommen zuerst) definiert ist. In der Parameterliste \texttt{parameter} (\texttt{list<TParameter> parameter}) sind diese Zusatzinformationen der Parameter des Programmsystems zusammengefasst.

Die Parameter k"onnen in \index{Parameter!Parameterdateien} Parameterdateien abgespeichert und aus diesen wieder geladen werden. Dabei identifiziert die Parameternummer den zu der Zeile zugeh"origen Parameter. Die Parameter k"onnen also in beliebiger Reihenfolge und Zeil geschrieben werden und eine beliebige Parameterbeschreibung haben, nur die richtige Parameternummer ist wichtig.
Mit der Methode \texttt{restoreParameter( pFile)} werden die Parameter mit Zusatzinformationen aus der Datei mit dem (Pfad-)Namen \texttt{pFile} gelesen. Mit der Methode \texttt{storeParameter(pFile)} werden die aktuellen Parameter mit Zusatzinformationen in die Datei mit dem (Pfad-)Namen \texttt{pFile} geschrieben. Daf"ur werden zuerst die Parameter ihrer Zeilennummer nach geordnet.

In der Paramerterdatei sind die Daten f"ur die Parameter in einer lesbaren und manipulierbaren Form abgespeichert. Jede Zeile steht dabei f"ur die Informationen "uber einen Parameter. Die Zeile beginnt dabei mit der Nummer des Parameters gefolgt von einem Punkt "`."', dann kommt die Parameterbeschreibung gefolgt von einem Doppelpunkt "`:"', als letztes kommt der Parameterwert, die Zeile wird durch ein Semikolon beendet.
Die Parameternummer 0 oder undefinierte Parameternummern stehen f"ur Kommentare. Zeilen f"ur Kommentare enthalten nur ihre Paramerternummer gefolgt von der Beschreibung (z.B. "`0. Kommentar;"').

Ist der Parameterwert ein Wahrheitswert, werden Zeichenketten die mit "`j"', "`t"', "`w"', "`y"' und "`1"' beginnen als wahr angesehen, sonst werden sie als falsch angesehen. Wenn der Parameterwert ein Zeichenketten ist, so sind die "`:"' und "`;"' Zeichen als Begrenzer der Zeichenkette anzusehen (z.B. bei "`12. Dateinamen :univers;"' ist der Parameterwert "`univers"').


Die Datei \index{standart\_Parameter.txt}"`standart\_Parameter.txt"' enth"alt die \index{Parameter!Standartwerte} Standartwerte und Zusatzinformationen der Parameter, diese werden geladen, wenn keine andere Parameterdatei angegeben wurde. Sie kann auch als Anfangsger"u"st f"ur neue Parameterdateien dienen, indem sie unter anderen Namen gespeichert und ver"andert wird.

Die Datei mit Namen \index{Null\_Parameter.txt}"`Null\_Parameter.txt"' dient einer Initialisierung des Programmsystems ohne Nebeneffekte und sollte deshalb nicht ver"andert werden. Sie ist aber nur von Interesse, wenn das Programmsystem ver"andert werden soll.


\subsubsection{Anfangswerte}\index{Anfangswerte}

Methoden: \texttt{\index{interne Zeit}\index{getTimeBase()}long getTimeBase(); \index{setTimeBase()}void setTimeBase(long bTim)}
\begin{tabbing}
\hspace{7mm} \=\hspace{50mm} \= \kill
\bfseries Nr. \> \bfseries Klassenvariable \> \bfseries Standartparameterbeschreibung\\
4 \>\texttt{\index{bTime}long bTime}\>Anfangszeit:\\
5 \>\texttt{\index{appendUnivers}bool appendUnivers}\>Universum fortsetzen:\\
6 \> \>Dateiname des Anfangsuniversums:
\end{tabbing}
Diese Parameter bestimmen die Anfangswerte des Universums.

Die Anfangszeit \texttt{bTime} (die dazugeh"orige Methoden: \texttt{getTimeBase()} und \texttt{setTimeBase()}) ist der Anfangswert bei welchem mit der Z"ahlung der Zeitschritte begonnen werden soll. Sie wirkt sich auf die Ausgabe der Statistiken aus.

Wenn bei Parameter 6 ("`Dateiname des Anfangsuniversums:"') ein g"ultiger Pfad einer Datei f"ur ein Raumuniversum angegeben wurde, wird dieses automatisch mit der Parameterdatei geladen. Dieses dient dann als aktuelles (Anfangs-) Raumuniversum.

Wenn neue Parameter in das Programmsystem geladen werden, kann angegeben werden, dass ein bestehendes Universum fortgesetzt werden soll. Daf"ur dienen Parameter 5 und 6. In diesem Fall wird das angegebene Universum geladen und die Statistikdateien an der aktuellen Universumszeit fortgesetzt. Mehr dazu im Abschnitt \ref{UniversumFortsetzen} auf Seite \pageref{UniversumFortsetzen} .

\subsubsection{Endbedingung}\index{Endbedingung}
\label{Endbedingung}

\begin{tabbing}
\hspace{10mm} \= \kill
Methoden: \texttt{\index{getMaxNumberOfTime()}unsigned long getMaxNumberOfTime();}\\
\>\texttt{\index{setMaxNumberOfTime()}void setMaxNumberOfTime(unsigned long mTm);}\\
\>\texttt{\index{getMaxNumberOfPoints()}unsigned long getMaxNumberOfPoints();}\\
\>\texttt{\index{setMaxNumberOfPoints()}void setMaxNumberOfPoints(unsigned long mPoi);}\\
\>\texttt{\index{getCheckMaxPoints()}unsigned long getCheckMaxPoints();}\\
\>\texttt{\index{setCheckMaxPoints()}void setCheckMaxPoints(unsigned long cMP)}
\end{tabbing}
\begin{tabbing}
\hspace{7mm} \=\hspace{50mm} \= \kill
\bfseries Nr. \> \bfseries Klassenvariable \> \bfseries Standartparameterbeschreibung\\
1 \>\texttt{\index{Endbedingung!maximale Zeit}\index{maxTime}unsigned long maxTime}\> Maximale Zeit:\\
2 \>\texttt{\index{Endbedingung!maximale Punkte}\index{maxPoints}unsigned long }\>  Maximale Anzahl von Punkten:\\
	\>\texttt{ maxPoints}\>  \\
3 \>\texttt{\index{checkMaxPoints}unsigned long }\>Ticks zwischen dem Pr"ufen\\
	\>\texttt{ checkMaxPoints}\>der maximale-Punkte-Bedingung\\
51\>\texttt{\index{Endbedingung!maximale Iterationsdauer}\index{timeMaxTimeIteration}time\_t}\>Zeit die eine Iteration maximal dauern darf\\
  \>\texttt{ timeMaxTimeIteration}\>\\
  \>\texttt{\index{Endbedingung!maximale Iterationsdauer}\index{timeOfIterationBegin}time\_t}\>Zeit wann die aktuelle Iteration began\\
  \>\texttt{ timeOfIterationBegin}\>\\
52\>\texttt{\index{Endbedingung!maximale Realzeitdauer}\index{timeMaxTime}time\_t timeMaxTime}\>Zeit die die Berechnung maximal dauern darf\\
  \>\texttt{\index{Endbedingung!maximale Realzeitdauer}\index{timeOfBegin}time\_t timeOfBegin}\>Zeit wann die erste Iteration began
\end{tabbing}
Diese Parameter geben an, wann die Berechnung weiterer Ticks abgebrochen werden soll.
Wenn die \index{Zeit}Zeit gr"o"ser als oder gleich \texttt{\index{maxTime}maxTime} (zugeh"orige Methoden: \texttt{getMaxNumberOfTime()} und \texttt{setMaxNumberOfTime()}) ist, werden keine weiteren \index{Ticks}Ticks berechnet. Weiterhin wird alle \texttt{\index{checkMaxPoints}checkMaxPoints} (zugeh"orige Methoden: \texttt{getCheckMaxPoints()} und \texttt{setCheckMaxPoints()}) Ticks "uberpr"uft, ob das aktuelle Raumuniversum weniger als \texttt{\index{maxPoints}maxPoints} (zugeh"orige Methoden: \texttt{getMaxNumberOfPoints()} und \texttt{setMaxNumberOfPoints()}) Punkte enth"alt, nur wenn dies der Fall ist, werden weiterer Ticks berechnet. 

Die Parameter 51 und 52 dienen dazu die (reale) Zeit, welche die Berechnung ben"otigt, zu begrenzen. Mit \texttt{\index{timeMaxTimeIteration}timeMaxTimeIteration} kann angegeben werden, wie lange eine einzelle Iteration maximal dauern darf. Wenn also "`2 Minuten"' angegeben wird, wird bei der ersten Iteration, welche mehr als zwei Minuten zur Berechnug ben"otigte, abgebrochen.
Der Parameter \texttt{\index{timeMaxTime}timeMaxTime} bezieht sich dem gegen"uber auf die Zeit, welche alle Iterationen zusammen ben"otigen d"urfen.
Als Werte f"ur \texttt{timeMaxTimeIteration} und \texttt{timeMaxTime} in der Parameterdatei sind dabei ein Zahl gefolgt von einer Zeichenkette zul"assig. Beginnt die Zeichenkette mit "`m"' oder "`M"' wird die Zahl als Anzahl von Minuten interpretiert, bei "`s"', "`S"', "`h"' oder "`H"' als Stunden und bei "`t"', "`T"', "`d"' oder "`D"' als Tage. Folgt keine Zeichenkette, wird die Zahl als Anzahl von Sekunden interpretiert.

F"ur alle Endbedingungsparameter gilt: Ist der Wert eines Parameters gleich $0$ wird die zugeh"orige Bedingung nicht "uberpr"uft.


\subsubsection{Grundstatistiken}
\index{Grundstatistiken}\index{Statistik!Grundstatistiken}

\begin{tabbing}
\hspace{10mm} \= \kill
Methoden: \texttt{\index{getCommentsActiv()}bool getCommentsActiv();}\\
\> \texttt{\index{setCommentsActiv()}void setCommentsActiv(bool comAc);}\\
\> \texttt{\index{getOutStatisticCycle()}unsigned long getOutStatisticCycle();}\\
\> \texttt{\index{setOutStatisticCycle()}void setOutStatisticCycle(unsigned long outS);}\\
\> \texttt{\index{getStatisticFileName()}char* getStatisticFileName();}\\
\> \texttt{\index{setStatisticFileName()}bool setStatisticFileName(char* statF)}\\
Daten: \texttt{\index{outComent}bool outComent; \index{outStat}unsigned long outStat;}\\
\> \texttt{\index{statFileName}char* statFileName; \index{statFile}fstream *statFile}
\end{tabbing}
\begin{tabbing}
\hspace{7mm} \=\hspace{50mm} \= \kill
\bfseries Nr. \> \bfseries Klassenvariable \> \bfseries Standartparameterbeschreibung\\
7 \>\texttt{\index{outComent}bool outComent}\>  Kommentare Ausgeben:\\
8 \>\texttt{\index{outStat}unsigned long outStat}\>  Ausgaben der Grundstatistiken:\\
9 \>\texttt{\index{statFileName}char* statFileName}\>  Name der Grundstatistikendatei:
\end{tabbing}
Diese Parameter regeln die Ausgabe von einfachen statistischen Werten.

Der Parameter \texttt{outComent} (zugeh"orige Methoden: \texttt{getCommentsActiv()} und \texttt{setCommentsActiv()}) gibt an, ob Statistiken und Meldungen in die Standardausgabe (Bildschirm) ausgegeben werden sollen (wenn er \texttt{true} ist, erfolgt die Ausgabe).

Bei jedem Tick-Schritt erfolgt daf"ur die Ausgabe der aktuellen Zeit (\texttt{"`time :"'}), der aktuellen Iteration (bzw. internen Zeit \texttt{"`iteration :"'}), der Anzahl der Punkte (\texttt{"`Points :"'}), positiven (\texttt{"`pos distances :"'}), negativen Distanzen (\texttt{"`neg distances :"'}) und aller Distanzen zusammen durch die Anzahl der Punkte (\texttt{"`distances/points :"'}). Bei den Simulatoren "`univers"' und "`universD"' wird zus"atzlich noch die Anzahl der m"oglichen Transitionen (\texttt{"`posible transitions :"'}) im aktuellen Raumuniversum ausgegeben.

Wenn das Raumuniversum beschnitten wird, wird ausgegeben, wie viele zusammenh"angende Teile das Raumuniversum enthielt ("`cutparts"') und dann, bis auf die Zeit und Iterationszahl, die Daten, die sonst bei jedem Tick ausgegeben werden, noch einmal f"ur das beschnittene Raumuniversum.

Beim Einlesen eines Raumuniversums aus einer Datei wird, wenn \texttt{outComent} \texttt{true} ist, ausgegeben, wie viele Punkte das eingelesene Raumuniversum enth"alt (\texttt{"`univers size :"'}), f"ur den Einlesefortschritt (bei der Konvertierung der Daten) wird alle 256 Punkte die Nummer des aktuellen Punktes (nicht sein Name) ausgegeben und am Ende wird der erfolgreiche Abschluss des Einlesevorgangs best"atigt.


Der Parameter \texttt{outStat} (Methoden dazu: \texttt{getOutStatisticCycle()} und \texttt{setOutStatisticCycle()}) regelt die Ausgabe von Statistikdaten in eine Statistikdatei. Die Statistik bezieht sich dabei auf das Raumuniversum nach dem Beschneiden. Ist der Parameter gr"o"ser 0 (bei 0 erfolgt keine Ausgabe) werden alle \texttt{outStat} Ticks die Werte des aktuellen Raumuniversums und die Werte der Anzahlen der Transitionen, seit dem letzten Aufruf der \texttt{tick()} Methode (ohne Parameter), in eine Datei mit dem Namen bzw. Pfad \texttt{statFileName} (zugeh"orige Methoden: \texttt{getStatisticFileName()} und \texttt{setStatisticFileName()}) ausgegeben. Die erste Zeile beinhaltet den Tabellenkopf. Danach werden die Werte f"ur das jeweils aktuelle Raumuniversum in eine neue Zeile geschrieben, wobei hinter jedem Wert ein Semikolon "`;"' kommt. Zu diesen Werten geh"oren der Reihenfolge nach die \index{Zeit}Zeit (interne Zeit plus Zeitbasis), die Anzahl der Punkte, positiven und negativen Distanzen im aktuellen Raumuniversum, sowie der Quotient der Anzahl aller Distanzen durch die Anzahl der Punkte im aktuellen Raumuniversum. Danach werden die Werte der Transitionen ausgegeben, daf"ur wird zuerst die Anzahl aller Transitionen zusammen ausgegeben und dann, mit der ersten Transition $t_1$ beginnend, der Reihenfolge nach jeweils die Anzahl der Transition und der entsprechende Anteil, an allen Transitionen, der einzelnen neun Transitionen. Bei den Simulatoren "`univers"' und "`universD"' wird am Ende zus"atzlich noch die Anzahl der m"oglichen Transitionen (\texttt{"`number of posible transitions"'}) im aktuellen Raumuniversum ausgegeben.





\subsubsection{Realzeitstatistik}
\index{Realzeit}\index{Zeit!Realzeit}\index{Statistik!Realzeit}

\begin{tabbing}
\hspace{10mm} \= \kill
Methoden: \texttt{\index{getOutRealTime()}bool getOutRealTime();}\\
\> \texttt{\index{setOutRealTime()}void setOutRealTime(bool rT);}\\
\> \texttt{\index{getRTimeFileName()}char* getRTimeFileName();}\\
\> \texttt{\index{setRTimeFileName()}bool setRTimeFileName(char* rTimeF)}\\
Daten: \texttt{\index{outRealTime}bool outRealTime; \index{rTimeFileName}char* rTimeFileName;}\\
\>\texttt{\index{rTimeFile}fstream *rTimeFile}
\end{tabbing}
\begin{tabbing}
\hspace{7mm} \=\hspace{50mm} \= \kill
\bfseries Nr. \> \bfseries Klassenvariable \> \bfseries Standartparameterbeschreibung\\
16 \>\texttt{\index{outRealTime}unsigned long}\> Realzeitstatistik ausgeben:\\
16 \>\texttt{ outRealTime}\> \\
17 \>\texttt{\index{rTimeFileName}char* rTimeFileName}\> Realzeitstatistik Datei:
\end{tabbing}
Diese Parameter regeln die Ausgabe von der Statistiken f"ur die reale Zeit. Diese Statistiken beinhalten die Uhrzeit und die Zeit, in Sekunden, welche die einzelnen Schritte ben"otigen.

Wenn der Parameter \texttt{outRealTime} (die zu ihm geh"origen Methoden sind: \texttt{getOutRealTime()} und \texttt{setOutRealTime()}) gr"o"ser als $0$ ist, wird alle \texttt{outRealTime} Runden/Iterationen die Realzeitstatistik in die Datei mit dem in \texttt{rTimeFileName} (die dazugeh"origen Methoden: \texttt{getRTimeFileName()} und \texttt{setRTimeFileName()}) stehenden Pfad ausgegeben. Die erste Zeile beinhaltet den Tabellenkopf. Danach werden die Werte f"ur das aktuelle Raumuniversum jeweils in eine neue Zeile geschrieben, wobei hinter jedem Wert ein Semikolon "`;"' kommt.
Zu diesen Werten geh"oren der Reihenfolge nach die \index{Zeit}Zeit (interne Zeit plus Zeitbasis), das aktuelle Datum und die aktuelle Zeit, dann kommen die Sekunden, die die Iteration insgesamt ben"otigt hat, danach kommen die Werte f"ur die Anzahlen der Sekunden, die die einzelnen Schritte ben"otigt haben. Zu diesen Werten geh"oren der Reihe nach die Zeit f"ur das erzeugen des neuen Raumuniversums (bzw. f"ur die \texttt{tick()} Methode), f"ur das Beschneiden des Raumuniversums, f"ur die Ausgabe des Raumuniversums, f"ur die direkte Rasterstatistik plus, wenn vorhanden, f"ur das erstellen des Raster, f"ur die Nachbarschaftsstatistik, f"ur die Abstandsstatistik und am Ende f"ur die Statistik f"ur die maximale Ausdehnung des Raumuniversums.


\subsubsection{Ausgabe der Raumuniversen}\index{Raumuniversen!ausgeben}
\label{RaumuniversenAusgeben}

\begin{tabbing}
\hspace{10mm} \= \kill
Methoden: \texttt{\index{getOutUniversCycle()}unsigned long getOutUniversCycle();}\\
\>\texttt{\index{setOutUniversCycle()}void setOutUniversCycle(unsigned long outU);}\\
\>\texttt{\index{getUniversFolderName()}char* getUniversFolderName();}\\ 
\>\texttt{\index{setUniversFolderName()}void setUniversFolderName(char* uFol);}\\
\>\texttt{\index{getUniversFileBaseName()}char* getUniversFileBaseName();}\\
\>\texttt{\index{setUniversFileBaseName()}void setUniversFileBaseName(char* uFB)}\\
Daten: \texttt{\index{uFolder}char* uFolder; \index{bUName}char* bUName; \index{outUniv}unsigned long outUniv}
\end{tabbing}
\begin{tabbing}
\hspace{7mm} \=\hspace{50mm} \= \kill
\bfseries Nr. \> \bfseries Klassenvariable \> \bfseries Standartparameterbeschreibung\\
10 \>\texttt{\index{outUniv}unsigned long outUniv}\>  Universen ausgeben:\\
50 \>\texttt{\index{timeMaxBetweanSaves}time\_t}\>Sicherheitskopie des Raumuniversums\\
\>\texttt{ timeMaxBetweanSaves}\>mindestens alle:\\
\>\texttt{\index{timeOfLasteSave}time\_t timeOfLasteSave}\\
11 \>\texttt{\index{uFolder}char* uFolder}\>  Verzeichnis in dem die Universen gespeichert\\
\>\>werden:\\
12 \>\texttt{\index{bUName}char* bUName}\>  Erster Teil der Dateinamen f"ur die Universen:
\end{tabbing}
W"ahrend eines Laufes k"onnen die Raumuniversen zwischen den einzelnen Ticks \index{Raumuniversen!ausgeben}ausgegeben werden. Der Parameter \texttt{outUniv} (die dazugeh"orige Methoden sind: \texttt{getOutUniversCycle()} und \texttt{setOutUniversCycle()}) gibt dabei an, alle wie vielen Ticks das dann aktuelle Raumuniversum ausgegeben werden soll. Ist \texttt{outUniv} gleich 0 wird kein Raumuniversum ausgegeben. In dem Parameter \texttt{uFolder} (die dazugeh"orige Methoden sind: \texttt{getUniversFolderName()} und \texttt{setUniversFolderName()}) ist der Name des Verzeichnisses abgespeichert, in dem die Raumuniversen ausgegeben werden. Der Parameter \texttt{bUName} (\texttt{getUniversFileBaseName()} und \texttt{setUniversFileBaseName()}) enth"alt den Basisdateinamen unter dem die Raumuniversen ausgegeben werden, an diesem Basisdateinamen wird dann die Nummer der aktuellen Zeit und die Endung "`.txt"' angeh"angt. Der vollst"andige Pfad der ausgegebenen Raumuniversums lautet: \texttt{uFolder} + \texttt{bUName} + Zeit + "`.txt"', ein m"oglicher Pfad w"are also: "`./universen/univ12.txt"'. In den Dateien werden die Daten der Raumuniversen in der im Abschnitt \ref{ein-ausgabe} auf Seite \pageref{ein-ausgabe} beschriebenen Form ausgegeben, bzw. zur Ausgabe wird die Methode \texttt{printUnivers()} verwendet.

Der Parameter \texttt{timeMaxBetweanSaves} gibt an, nach wie viel Zeit das Universum wieder ausgegeben werden soll. Wenn \texttt{timeMaxBetweanSaves} gr"o"ser 0 ist und der Zeitpunkt an dem das letzte mal ein Raumuniversum gespeichert wurde (\texttt{timeOfLasteSave}) l"anger als \texttt{timeMaxBetweanSaves} her ist, wird das aktuelle Raumuniversum, wie oben beschrieben, wieder ausgegeben. Als Werte f"ur \texttt{timeMaxBetweanSaves} in der Parameterdatei sind dabei ein Zahl gefolgt von einer Zeichenkette zul"assig. Beginnt die Zeichenkette mit "`m"' oder "`M"' wird die Zahl als Anzahl von Minuten interpretiert, bei "`s"', "`S"', "`h"' oder "`H"' als Stunden und bei "`t"', "`T"', "`d"' oder "`D"' als Tage. Folgt keine Zeichenkette, wird die Zahl als Anzahl von Sekunden interpretiert.


\subsubsection{Universum fortsetzen}\index{Universum!fortsetzen}
\label{UniversumFortsetzen}

\begin{tabbing}
\hspace{10mm} \= \kill
%Methoden: \\
Daten: \texttt{\index{appendUnivers}bool appendUnivers; \index{parameterFile}char* parameterFile}
\end{tabbing}
\begin{tabbing}
\hspace{7mm} \=\hspace{50mm} \= \kill
\bfseries Nr. \> \bfseries Klassenvariable \> \bfseries Standartparameterbeschreibung\\
4 \>\texttt{\index{bTime}long bTime}\>  Anfangszeit:\\
5 \>\texttt{\index{appendUnivers}bool appendUnivers}\>  Universum fortsetzen:\\
6 \>\>  Dateiname des Anfangsuniversums: 
\end{tabbing}
Es existiert die M"oglichkeit die Simulation einer Raumuniversumsfolge zu unterbrechen und sp"ater fortzusetzen. Dazu muss in der Parameterdatei der Parameter \texttt{appendUnivers} auf wahr gesetzt werden. Ist \texttt{appendUnivers} wahr, wird versucht ein vorhandenes Raumuniversum aus der Datei f"ur das Anfangsuniversum zu laden, wenn dies nicht m"oglich ist, wird mit einem neuen leeren Raumuniversum eine neue Testreihe begonnen. Wird ein Raumuniversum geladen, so werden auch die vorhandenen Statistikdateien, wenn m"oglich, bei dem Zeitpunkt \texttt{bTime} fortgesetzt. Die interne Zeit wird auf \texttt{bTime} gesetzt.

Wenn das Universum fortgesetzt wird, kann mit "`E"' (Gro"sbuchstabe) die aktuelle Testreihe beendet werden. Wird "`E"' eingegeben, wird die aktuelle Iteration bzw. Runde noch beendet, dann wird, wenn n"otig, das aktuelle Raumuniversum, wie im Abschnitt \ref{RaumuniversenAusgeben} beschrieben, gespeichert und das aktuelle Raster wird, wenn n"otig, in eine Datei "`grid.txt"' im Statistikverzeichnis gespeichert. In der zuletzt geladenen Parameterdatei (\texttt{parameterFile}) wird die Anfangszeit auf die aktuelle Zeit gesetzt und der Pfadname, des zuletzt gespeicherten Raumuniversums, unter "`Dateiname des Anfangsuniversums"' angegeben.

Wenn nun die vorher zuletzt geladenen Parameterdatei (\texttt{parameterFile}) erneut beim Start des Simulators angegeben wird, wird der begonnene Lauf automatisch fortgesetzt.

Wie gesagt wird das Raumuniversum wie im Abschnitt \ref{RaumuniversenAusgeben} beschrieben ausgegeben. Sollten die Parameter 11 \texttt{uFolder} und 12 \texttt{bUName} also leer sein, wird als Dateiname nur die aktuelle Zeit gefolgt von "`.txt"' genommen (z.B. "`34.txt"'). Wenn die Raumuniversen im allgemeinen nicht ausgegeben werden sollen, w"are es Beispielsweise sinnvoll \texttt{uFolder} leer zu lassen und f"ur \texttt{bUName} "`tmp"' anzugeben, so dass die zwischengespeicherten Universen im aktuellen Verzeichnis liegen und mit "`tmp"' beginnen. 

Die zwischengespeicherten Raumuniversen werden nicht automatisch gel"oscht, wenn sie nicht mehr gebraucht werden. Diese Aufgabe sollte der Benutzer "ubernehmen. F"ur die Fortsetzung einer Testreihe wird nur das zuletzt gespeicherte Raumuniversum ben"otigt, also das mit der h"ochsten Zahl f"ur die Zeit.

Wird w"ahrend des Testlaufes "`C"' eingegeben, so wird der Testlauf am Ende der Iteration abgebrochen, ohne den aktuellen Stand zu speichern. Der Testlauf wird dann nicht an der aktuellen Stelle fortgesetzt, wenn die zuletzt geladene Parameterdatei erneut geladen wird. 



\subsubsection{Universum beschneiden}\index{Raumuniversen!beschneiden}

\begin{tabbing}
\hspace{10mm} \= \kill
Methoden: \texttt{\index{getCutCycle()}unsigned long getCutCycle();}\\
\>\texttt{\index{setCutCycle()}void setCutCycle(unsigned long cutA);}\\
\>\texttt{\index{getCutNearDimension()}double getCutNearDimension();}\\
\>\texttt{\index{setCutNearDimension()}void setCutNearDimension(double cND);}\\
\>\texttt{\index{getCutMaxClassRatio()}double getCutMaxClassRatio();}\\
\>\texttt{\index{setCutMaxClassRatio()}void setCutMaxClassRatio(double cMCR);}\\
\>\texttt{\index{getCutRemainingParts()}double getCutRemainingParts();}\\
\>\texttt{\index{setCutRemainingParts()}void setCutRemainingParts(double dCutRemainingParts);}\\
\>\texttt{\index{cutUnivers()}void cutUnivers(double dim, double maxCl,}\\ 
\>\texttt{ double dInCutRemainingParts);}\\
Daten: \texttt{\index{cutAfter}unsigned long cutAfter;\index{cutNearDimension}double cutNearDimension;}\\
\>\texttt{\index{cutMaxClassRatio}double cutMaxClassRatio;}\texttt{\index{cutRemainingParts}double cutRemainingParts;}
\end{tabbing}
\begin{tabbing}
\hspace{7mm} \=\hspace{50mm} \= \kill
\bfseries Nr. \> \bfseries Klassenvariable \> \bfseries Standartparameterbeschreibung\\
13 \>\texttt{\index{cutAfter}unsigned long}\>  Ticks zwischen dem Beschneiden des\\
   \>\texttt{ cutAfter}\> Universums:\\
14 \>\texttt{\index{cutNearDimension}double}\>  Dimension dem der verbleibende\\
   \>\texttt{ cutNearDimension}\>  Raumuniversumsteil nahe kommen soll:\\
15 \>\texttt{\index{cutMaxClassRatio}double}\>  Gr"o"se der zusammenh"angenden Raum\\
   \>\texttt{ cutMaxClassRatio}\>  -universen, im Bezug auf den gr"o"sten\\
   \>\>  Raumuniversumsteil, die in der Auswahl- \\
   \>\>  menge sein d"urfen: \\
60 \>\texttt{\index{cutRemainingParts}double}\>  Anteil (bei < 1) oder Anzahl (bei >=1)\\
   \>\texttt{ cutRemainingParts}\> der Raumuniversumsteile die nicht herraus-\\
   \>\> geschnitten werden sollen:
\end{tabbing}
Bei Transitionen kann es vorkommen, dass das Universum in nicht zusammenh"angende Teile aufgespalten wird. Meist wird dabei nur ein kleiner Teil des Universums, der wenige Punkte und Distanzen enth"alt und schnell expandiert, vom Rest abgetrennt. Um Rechenzeit zu sparen k"onnen alle zusammenh"angende Teile des Universums, bis auf einige, gel"oscht werden, dies geschieht mit Hilfe der Methode \texttt{cutUnivers()}.

Dabei werden in der Methode \verb|cutUnivers(dim, maxCl,| \\\verb|dInCutRemainingParts)| zuerst alle zusammenh"angenden Teile, diese sind selbst wieder Raumuniversen, des aktuellen Raumuniversums ermittelt, einige dieser werden ausgew"ahlt und zum aktuellen Raumuniversum gemacht, die restlichen Teile werden gel"oscht. Die Auswahl der zusammenh"angenden Raumuniversen, die nicht gel"oscht werden soll, wird durch drei Parameter bestimmt \texttt{dim}, \texttt{maxCl} und \texttt{dInCutRemainingParts}.

Ausgew"ahlt wird aus der Menge der zusammenh"angenden Raumuniversen, deren Anzahl von Distanzen mindestens \texttt{maxCl} mal der Anzahl der Distanzen im gr"o"sten zusammenh"angenden Raumuniversum (dem mit dem meisten Distanzen) betr"agt. Auf diese Weise enthalten die ausgew"ahlten Raumuniversen mindestens einen Anteil von \texttt{maxCl} Distanzen des gr"o"sten Raumuniversums. So kann vermieden werden, dass nur sehr kleine zusammenh"angende Raumuniversen ausgew"ahlt werden.

Bei der Auswahl werden die Raumuniversumen gew"ahlt, deren \index{Dimension} Dimension am n"achsten zu \texttt{dim} ist. Die Dimension ergibt sich dabei aus der Anzahl der Distanzen (beider Arten zusammen) durch die Anzahl der Punkte im betrachteten Raumuniversum (Dimension=(positive Distanzen + negative Distanzen)/Punkte).

Mit dem Parameter \texttt{dInCutRemainingParts} wird die Anzahl der auszuw"ahlenden Raumuniversen bestimmt. Ist er kleiner $1$, werden von der Menge der zusammenh"angende Raumuniversumsteile der Anteil \texttt{dInCutRemainingParts} ausgew"ahlt. Gibt es also im ganzen Raumuniversum $N$ zusammenh"angende Raumuniversumsteile, werden davon $\lfloor N * dInCutRemainingParts \rfloor$ ausgew"ahlt. Ist \texttt{dInCutRemainingParts} gr"o"ser oder gleich $1$, werden von den zusammenh"angende Raumuniversumsteilen $\lfloor dInCutRemainingParts \rfloor$ ausgew"ahlt. Der Parameter \texttt{dInCutRemainingParts} gibt dann also direkt die Anzahl der auzuw"ahlenden zusammenh"angenden Raumuniversumsteile an.

In der \texttt{start()} Methode, also bei einem Lauf, wird alle \texttt{cutAfter} (zugeh"orige Methoden: \texttt{getCutCycle()} und \texttt{setCutCycle()}) Ticks das Universum beschnitten. Dabei wird beim Aufruf der Methode \verb|cutUnivers(dim, maxCl,| \\\verb|dInCutRemainingParts)|, der Parameter \texttt{maxCl} auf den Wert des Parameters \texttt{cutMaxClassRatio} (zum Parameter \texttt{maxCl} geh"origen Methoden sind: \texttt{getCutMaxClassRatio()} und \texttt{setCutMaxClassRatio()}), der Parameter \texttt{dim} wird auf den Wert von \texttt{cutNearDimension} (die dazugeh"orige Methoden sind: \texttt{getCutNearDimension()} und \texttt{setCutMaxClassRatio()}) und der Parameter \texttt{dInCutRemainingParts} auf \texttt{cutRemainingParts} (die zum diesem Parameter  zugeh"orige Methoden sind: \texttt{getCutRemainingParts()} und \texttt{setCutRemainingParts()}) gesetzt.



\subsubsection{Beschneidungsstatistik}
\index{Beschneidungsstatistik}\index{Statistik!beschneiden}
\label{beschneidungsstatistik}


\begin{tabbing}
\hspace{10mm} \= \kill
Methoden: \texttt{\index{getOutCutStatistic()}unsigned long getOutCutStatistic();}\\
\> \texttt{\index{setOutCutStatistic()}void setOutCutStatistic(unsigned long cut);}\\
\> \texttt{\index{getCutFileName()}char* getCutFileName();}\\
\> \texttt{\index{setCutFileName()}bool setCutFileName(char* cutF)}\\
Daten: \texttt{\index{outCutStatistic}unsigned long outCutStatistic; \index{cutFileName}char* cutFileName;}\\
\>\texttt{\index{cutFile}fstream *cutFile}
\end{tabbing}
\begin{tabbing}
\hspace{7mm} \=\hspace{50mm} \= \kill
\bfseries Nr. \> \bfseries Klassenvariable \> \bfseries Standartparameterbeschreibung\\
18 \>\texttt{\index{outCutStatistic}unsigned long }\> Beschneidungsstatistik ausgeben:\\
18 \>\texttt{ outCutStatistic}\>\\
19 \>\texttt{\index{cutFileName}char* cutFileName}\> Beschneidungsstatistik Dateiname:
\end{tabbing}
Zu dem Beschneiden der Raumuniversen kann eine Statistik in eine Datei ausgegeben werden.

Wenn der Parameter \texttt{outCutStatistic} (die zugeh"origen Methoden sind: \texttt{getOutCutStatistic()} und \texttt{setOutCutStatistic()}) gr"o"ser $0$ ist, wird alle \texttt{outCutStatistic} Ticks/Iterationen beim Beschneiden eines Raumuniversums die Beschneidungsstatistik in die Datei mit dem in \texttt{cutFileName} (zugeh"orige Methoden: \texttt{getCutFileName()} und \texttt{setCutFileName()}) stehenden Pfad ausgegeben. Die erste Zeile beinhaltet den Tabellenkopf. Danach werden die Werte f"ur das aktuelle Raumuniversum und der Beschneidung jeweils in eine neue Zeile geschrieben, wobei hinter jedem Wert ein Semikolon "`;"' kommt.

Zu diesen Werten geh"oren, der Reihenfolge nach, die \index{Zeit}Zeit (interne Zeit plus Zeitbasis), dann kommt die Anzahl der Punkte, positiven und negativen Distanzen des Raumuniversums vor dem Beschneiden, danach folgt die Anzahl der zusammenh"angenden Raumuniversumsteile und am Ende folgt eine Liste mit den Daten zu den einzelnen Raumuniversumsteilen.
In dieser Liste steht, nach der Gr"o"se bzw. Anzahl von Punkten geordnet, f"ur jeden zusammenh"angende Raumuniversumsteil ein Klammerausdruck. Zwischen den Klammern f"ur einen Raumuniversumsteil steht der Reihe nach, durch Komma "`,"' getrennt, die Anzahl der Punkte, positiven und negativen Distanzen in ihm.


\bigskip\noindent
Beispiel f"ur eine Zeile der Beschneidungsstatistik:
\begin{verbatim}
54; 11; 4; 5; 3; ( 6, 2, 4 ) ( 4, 2, 1 ) ( 1, 0, 0 ) ;
\end{verbatim}


\subsubsection{Maximale Ausdehnung des Raumuniversums}
\index{maximale Ausdehnung}\index{Ausdehnung}\index{Raumuniversum!Ausdehnung}
\label{MaximaleAusdehnung}

\begin{tabbing}
\hspace{10mm} \= \kill
Methoden: \texttt{\index{getPartSizeStatistics()}unsigned long getPartSizeStatistics();}\\
\>\texttt{\index{setGetPartSize()}void setGetPartSize(unsigned long pSize);}\\
\>\texttt{\index{getPartSizeFileName()}char* getPartSizeFileName();}\\
\>\texttt{\index{setPartSizeFileName()}void setPartSizeFileName(char* partN)}
\end{tabbing}
\begin{tabbing}
\hspace{7mm} \=\hspace{50mm} \= \kill
\bfseries Nr. \> \bfseries Klassenvariable \> \bfseries Standartparameterbeschreibung\\
25 \>\texttt{\index{getPartSize}unsigned long }\>Maximale Ausdehnung des Raumuniver-\\
 \>\texttt{ getPartSize}\>sums vom "altesten Punkt aus ausgeben:\\
26 \>\texttt{\index{partSizeName}char *partSizeName}\>Dateiname der maximalen Ausdehnungs-\\
\>\>statistik:
\end{tabbing}
Um eine Vorstellung von der Gr"o"se des aktuellen Raumuniversums zu bekommen, kann ein Wert f"ur die Ausdehnung eines Teils des Raumuniversums ermittelt werden. Der Wert f"ur die maximale Ausdehnung gibt den \index{Abstand}Abstand zwischen den ersten/"altesten Punkt des Raumuniversums und den Punkt, der von diesem am weitesten entfernt, aber noch im gleichen zusammenh"angenden Teil des Raumuniversums ist, wieder.  

Dieser Wert wird alle \texttt{getPartSize} (zum Parameter geh"orende Methoden: \texttt{getPartSizeStatistics()} und \texttt{setGetPartSize()}) Ticks ermittelt oder gar nicht, wenn \texttt{getPartSize} gleich 0 ist. Der ermittelten Werte wird in die Datei mit Namen \texttt{partSizeName} (die zum Parameter geh"orenden Methoden sind: \texttt{getPartSizeFileName()} und \texttt{setPartSizeFileName()}) geschrieben.
In der Datei sind die Daten f"ur die einzelnen Raumuniversen Zeilenweise getrennt (pro Tick eine Zeile). In einer Zeile kommt dabei als erstes die aktuelle Zeit und dann die maximale Ausdehnung, beides gefolgt durch ein Semikolon "`;"'.


\subsection{Parameter f"ur die Rasterestatistiken}\index{Raster!Statistik}


Um die lokalen \index{Strukturen}Strukturen und \index{Entwicklungsverl"aufe}Entwicklungsverl"aufe besser Untersuchen zu k"onnen, kann, wenn ein Raumuniversum der Folge eine bestimmte Gr"o"se "uberschritten hatte, ein Menge von n"aher benachbarten Punkten aus ihm als \index{Raster}Raster ausgew"ahlt werden.
Das gleiche Raster von Punkten kann dann bei den nachfolgenden Raum\-uni\-versen auf verschiedene Weisen untersucht werden und die entsprechenden Statistiken ausgegeben werden.

W"ahrend die Parameter und Methoden aus dem vorhergehenden Abschnitt \ref{Parameter}, bis auf die der Unterabschnitte \ref{MaximaleAusdehnung} und \ref{UniversumFortsetzen}, sich auf die Klasse \texttt{Univers} beziehen, beziehen sich die nachfolgenden Parameter und Methoden auf die Klasse \index{UniversNeib}\texttt{UniversNeib}.


\subsubsection{Raster erzeugen}\index{Raster!erzeugen}

\begin{tabbing}
\hspace{10mm} \= \kill
Methoden: \texttt{\index{makeGrid()}list<TPoint*> makeGrid(TPoint* sPoi,}\\
\>\texttt{ unsigned int dist, unsigned int number);}\\
\>\texttt{\index{getSurface()}list<TPoint*> getSurface(list<TPoint*> poiL);}\\
\>\texttt{\index{getGridNames()}list<unsigned long> getGridNames();}\\
\>\texttt{\index{setGridNames()}void setGridNames(list<unsigned long> grN);}\\
\>\texttt{\index{getGridDistance()}unsigned long getGridDistance();}\\
\>\texttt{\index{setGridDistance()}bool setGridDistance(unsigned long grD);}\\
\>\texttt{\index{getNumberOfGridPoints()}unsigned long getNumberOfGridPoints();}\\
\>\texttt{\index{setNumberOfGridPoints()}bool setNumberOfGridPoints(unsigned long grP);}\\
\>\texttt{\index{getGridAfterPoints()}unsigned long getGridAfterPoints();}\\
\>\texttt{\index{setGridAfterPoints()}bool setGridAfterPoints(unsigned long grAP);}\\
\>\texttt{\index{getGridStartPoint()}double getGridStartPoint();}\\
\>\texttt{\index{setGridStartPoint()}bool setGridStartPoint(double grSP);}\\
\>\texttt{\index{getStatisticFolderName()}char* getStatisticFolderName();}\\
\>\texttt{\index{setStatisticFolderName()}void setStatisticFolderName(char* statFN)}\\
Daten: \texttt{\index{gridN}list<unsigned long> gridN;}\\
\>\texttt{\index{gridAfterPoints}unsigned long gridAfterPoints;}\\
\>\texttt{\index{gridPoints}unsigned long gridPoints;}\\
\>\texttt{\index{gridDist}unsigned long gridDist; }\texttt{\index{gridStartPoint}double gridStartPoint;}\\
\>\texttt{\index{statisticFolderName}char *statisticFolderName}
\end{tabbing}
\begin{tabbing}
\hspace{7mm} \=\hspace{50mm} \= \kill
\bfseries Nr. \> \bfseries Klassenvariable \> \bfseries Standartparameterbeschreibung\\
20 \>\texttt{\index{gridAfterPoints}unsigned long}\>  Raster erzeugen wenn das Universum min-\\
\>\texttt{ gridAfterPoints}\> destens soviel Punkt enth"alt:\\
21 \>\texttt{\index{gridPoints}unsigned long }\>  Anzahl der Punkt im erzeugten Raster:\\
\>\texttt{ gridPoints}\\
22 \>\texttt{\index{gridDist}unsigned long }\>  Mindest Abstand zweier Punkte im erzeugten \\
\>\texttt{ gridDist}\>Raster:\\
23 \>\texttt{\index{gridStartPoint}double gridStartPoint}\>  Position des Rasterstartpunktes im Raumuni-\\
\>\>versum:\\
24 \>\texttt{\index{statisticFolderName}char }\> Name des Statistikverzeichnisses:\\
\>\texttt{ *statisticFolderName}
\end{tabbing}
Ausgangspunkt f"ur die \index{Raster!Statistik} Rasterstatistiken ist ein Raster (\texttt{gridN}) dessen Punkte im Raumuniversum, in dem es erzeugt wurde, bestimmte Vorgaben erf"ullen.
Das Raster wird automatisch (zwischen zwei Ticks) erzeugt, wenn kein Raster existiert (bzw. es (\texttt{gridN}) keine Punkte enth"alt), eines erzeugt werden soll (\texttt{gridPoints}$>0$) und das aktuelle Raumuniversum mehr als \texttt{gridAfterPoints} (zugeh"orige Methoden: \texttt{getGridAfterPoints()} und \texttt{setGridAfterPoints()}) Punkt enth"alt. Als Raster \texttt{gridN} (die dazugeh"orige Methoden sind: \texttt{getGridNames()} und \texttt{setGridNames()}) werden die Namen (bzw. Nummern) der Rasterpunkt abgespeichert. Bei der Auswertung des Rasters werden aber nur Punkte betrachtet die auch im aktuellen Raumuniversum enthalten sind.

Um das Raster zu erzeugen wird zuerst das Universum beschnitten, wenn es beschnitten werden soll (wenn \texttt{cutAfter} $>0$). Dann wird der \index{Raster!Startpunkt}Startpunkt f"ur das Raster ausgew"ahlt. Dies geschieht mithilfe des Parameters \texttt{gridStartPoint} (Methoden: \texttt{getGridStartPoint()} und \texttt{setGridStartPoint()}). Um den Startpunkt f"ur das Raster zu ermitteln wird die Anzahl der Punkte im aktuellen Raumuniversum mit \texttt{gridStartPoint} multipliziert, das abgerundete Ergebnis gibt die Position (begonnen mit den "altesten Punkt) des Startpunktes im aktuellen Raumuniversum an (Anzahl der Punkte im Raumuniversum $*$ \texttt{gridStartPoint} $=$ Position des Startpunktes).
Danach wird der Startpunkt heraus gesucht und die Methode \texttt{makeGrid()} (\texttt{makeGrid(}Startpunkt\texttt{,gridDist,gridPoints)}) aufgerufen, die das Raster erzeugt. Zu dem Parameter \texttt{gridDist} geh"oren die Methoden \texttt{getGridDistance()} und \texttt{setGridDistance()} und zu dem Parameter \texttt{gridPoints} geh"oren die Methoden \texttt{getNumberOfGridPoints()} und \texttt{setNumberOfGridPoints()}.

Die Methode \texttt{makeGrid()} arbeitet wie folgt.
Der "ubergebene Startpunkt wird als erster Punkt ins Raster eingef"ugt. Der n"achste Punkt wird aus der Punktmenge der Oberfl"ache im Abstand \texttt{gridDist} zum Raster gew"ahlt. F"ur alle nachfolgenden Punkte wird, aus dem Schnitt von der Oberfl"ache im Abstand \texttt{gridDist} zum Raster und der Oberfl"ache im Abstand \texttt{gridDist} zur Menge des aktuellen gew"ahlten Punktes, ein Punkt ausgew"ahlt. Der aktuelle gew"ahlte Punkt, ist der "alteste Punkt im Raster, der mit diesem gemeinsame Oberfl"achenpunkte hat. Dies wird solange wiederholt bis \texttt{gridPoints} Punkte im Raster sind oder die Oberfl"ache leer ist. Das so erzeugte Raster wird zur"uckgegeben und als Universumsraster verwendet.

Die Oberfl"ache $O$ zu einer Punktmenge $M$ im Abstand $a$, ist dabei die Menge aller Punkte, welche zu einem Punkt der Punktmenge $M$ den Abstand $a$ haben und zu keinem Punkt der Punktmenge $M$ einen Abstand kleiner als $a$. ($O=\{P \mid \exists P_1 \in M \wedge a=n(P_1,P) \wedge \forall P_2 \in M \wedge \neg(a>n(P_2,P)) \}$)

Beim Raster ist zu beachten, dass bei der Entwicklung der Raumuniversen (in der Raumuniversenfolge) nach und nach Punkte entfallen k"onnen, wenn das Universum beschnitten wird, oder bei Transitionen Punkte vom Rest des Rasters getrennt werden k"onnen.

Alle Rasterstatistiken bezogenen Daten werden in Dateien im Statistikverzeichnis (\texttt{statisticFolderName} Methoden: \texttt{getStatisticFolderName()} und \texttt{setStatisticFolderName()}) abgespeichert. Beim Setzen des Statistikverzeichnisses ist mit etwas Vorsicht vorzugehen, da eventuelle Dateien automatisch ge"offnet werden und, wenn Statistiken ausgegeben werden sollen, das Statistikverzeichnis automatisch erzeugt wird. Die Dateien f"ur die Ausgabe der allgemeinen Statistiken werden, wenn die zugeh"orige Statistik ausgegeben werden soll, automatisch erzeugt.



\subsubsection{Direkte Rasterstatistik}
\label{AbsDirektRasterStatistik}
\index{Raster!Statistik!Direkte}\index{Statistik!Direkte Rasterstatistik}

\begin{tabbing}
\hspace{10mm} \= \kill
Methoden: \texttt{\index{getDirectStatistics()}unsigned long getDirectStatistics();}\\
\>\texttt{\index{setDirectStatistics()}void setDirectStatistics(unsigned long gDi);}\\
\>\texttt{\index{getDirectBaseFileName()}char* getDirectBaseFileName();}\\
\>\texttt{\index{setDirectBaseFileName()}void setDirectBaseFileName(char* dircBN)}\\
Daten: \texttt{unsigned long getDirect; char *directBaseName}
\end{tabbing}
\begin{tabbing}
\hspace{7mm} \=\hspace{50mm} \= \kill
\bfseries Nr. \> \bfseries Klassenvariable \> \bfseries Standartparameterbeschreibung\\
27 \>\index{getDirect}\texttt{unsigned long}\>Direkte Rasterstatistik ermitteln:\\
\>\texttt{ getDirect}\\
28 \>\index{directBaseName}\texttt{char *directBaseName}\>Dateinamensanfang der direkten Statistik:
\end{tabbing}
Die direkte Statistik ist die einfachste der auf das Raster bezogenen Statistiken. Wenn \texttt{getDirect} (zugeh"orige Methoden: \texttt{getDirectStatistics()} und \texttt{setDirectStatistics()}) gr"o"ser 0 ist, wird sie alle \texttt{getDirect} Ticks ermittelt und ausgegeben. Die Ausgabe erfolgt dabei in zwei Dateien. In einer Datei wird die detailierter Statistik f"ur das aktuelle Raumuniversum ausgegeben und in einer zweiten Datei wird, f"ur alle betrachteten Raumuniversen, eine Zusammenfassung f"ur die einzelnen Raumuniversen Zeilenweise ausgegeben. Beide Dateien werden in das Statistikverzeichnis (\texttt{statisticFolderName}) abgespeichert. Jeder Eintrag in den Dateien wird von einem Semikolon "`;"' gefolgt.

Die Dateinamen der detailierten Statistik beginnen immer mit der Zeichenkette \texttt{directBaseName} (zugeh"orige Methoden: \texttt{getDirectBaseFileName()} und \texttt{setDirectBaseFileName()}), dann folgt die Zeit f"ur das aktuelle Raumuniversum mit einem vorgestellten "`U"' und am Ende die Endung "`.txt"', ein Beispiel daf"ur ist "`direktU13.txt"'.
In der Datei kommt nach einem Tabellenkopf die Daten f"ur die einzelnen Punkte im Raster. 
In einer Zeile kommt dabei zuerst der Punktname auf dem sich die Daten der Zeile beziehen, dann die Anzahl der direkten Nachbarpunkten, aller, der negativen und der positiven ausgehenden Distanzen, am Ende folgt der Unterschied zwischen den positiven und negativen Distanzen ((Anzahl positive Distanzen) - (Anzahl negative Distanzen)).
In den letzten drei Zeilen stehen die Daten f"ur den Durchschnitt, das Maximum und das Minimum aller Punkte.

Die Datei, in der die Zusammenfassungen f"ur alle Raumuniversen gespeichert wird, beginnt mit \texttt{directBaseName}, dann folgt "`UAll.txt"'. In der Datei steht, nach dem Tabellenkopf, f"ur jedes Raumuniversum, f"ur das die direkte Statistik ermittelt wurde, eine Zeile. Die Zeile beginnt jeweils mit der Zeit f"ur das Raum\-universum gefolgt von der Anzahl der Punkte im Raster. Danach folgen drei Bl"ocke nacheinander f"ur die Durchschnitts-, Maximal- und Minimalwerte. Jeder Block besteht aus vier Eintr"agen. Der erste Eintrag ist dabei jeweils f"ur alle direkten Nachbarpunkte der Punkte im Raster, dann folgen nacheinander die Eintr"age f"ur die Anzahl aller, der negativen und der positiven ausgehenden Distanzen, am Ende folgt der Unterschied zwischen den positiven und negativen Distanzen.



\subsubsection{Nachbarschaftsstatistik}


\begin{tabbing}
\hspace{10mm} \= \kill
Methoden: \texttt{\index{getNeibourStatistics()}unsigned long getNeibourStatistics();}\\
\>\texttt{\index{setNeibourStatistics()}void setNeibourStatistics(unsigned long gNeib);}\\
\>\texttt{\index{getNeibourDistance()}unsigned long getNeibourDistance();}\\
\>\texttt{\index{setNeibourDistance()}void setNeibourDistance(unsigned long neibD)}\\
\>\texttt{\index{getNeibourBaseFileName()}char* getNeibourBaseFileName();}\\
\>\texttt{\index{setNeibourBaseFileName()}void setNeibourBaseFileName(char* neibBN)}\\
Daten: \texttt{unsigned long getNeib; unsigned long neibDist} \\
\>\texttt{char *neibBaseName;}
\end{tabbing}
\begin{tabbing}
\hspace{7mm} \=\hspace{50mm} \= \kill
\bfseries Nr. \> \bfseries Klassenvariable \> \bfseries Standartparameterbeschreibung\\
29 \>\texttt{\index{getNeib}unsigned long getNeib}\>  Nachbarschaftsstatistik ermitteln:\\
30 \>\texttt{\index{neibBaseName}char *neibBaseName}\>  Dateinamensanfang der Nachbarschafts-\\
\>\> statistik:\\
31 \>\texttt{\index{neibDist}unsigned long neibDist}\>  Entfernung von den Rasterpunkten f"ur die \\
\>\> Nachbarschaftsstatistik:
\end{tabbing}
Bei der Nachbarschaftsstatistik wird die Nachbarschaft bzw. die Umgebung der einzelnen Rasterpunke untersucht. Zur Nachbarschaft eines Punktes geh"oren dabei alle Punkte bis zum Abstand (siehe \cite{wildeRZ}) \texttt{neibDist} (zugeh"orige Methoden: \texttt{getNeibourDistance()} und \texttt{setNeibourDistance()}) um den Punkt. Die ausgegebenen Statistiken sind die gleichen wie f"ur die direkte Statistik (aus dem vorhergehenden Abschnitt \ref{AbsDirektRasterStatistik}), nur beziehen sie sich auf die Punkte und Distanzen in der Nachbarschaft im Abstand \texttt{neibDist} und nicht nur um die direkten Nachbarschaft (Abstand $=1$).

Wenn \texttt{getNeib} (zugeh"orige Methoden: \texttt{getNeibourStatistics()} und \texttt{setNeibourStatistics()}) gr"o"ser 0 ist, wird die Nachbarschaftsstatistik alle \texttt{getNeib} Ticks ermittelt und ausgegeben. Die Ausgabe erfolgt dabei in zwei Dateien. In einer Datei wird die detailierte Statistik f"ur das aktuelle Raumuniversum ausgegeben und in einer zweiten Datei wird f"ur alle betrachteten Raumuniversen eine Zusammenfassung f"ur die einzelnen Raumuniversen Zeilenweise ausgegeben. Beide Dateien werden in das Statistikverzeichnis (\texttt{statisticFolderName}) abgespeichert. Jeder Eintrag in den Dateien wird von einem Semikolon "`;"' gefolgt.

Der Dateiname der detailierten Statistik beginnt mit der in \texttt{neibBaseName} (die dazugeh"orige Methoden sind hierbei: \texttt{getNeibourBaseFileName()} und \texttt{setNeibourBaseFileName()}) gespeicherten Zeichenkette, dann folgt die Zeit f"ur das aktuelle Raumuniversum mit einem vorgestellten "`U"' und am Ende die Endung "`.txt"', ein Beispiel daf"ur ist "`neibU13.txt"'.
In der Datei kommt nach einem Tabellenkopf die Daten f"ur die einzelnen Punkte im Raster. 
In einer Zeile kommt dabei zuerst der Punktname auf dem sich die Daten der Zeile bezieht, dann die Anzahl der Punkte, der negativen und der positiven Distanzen, am Ende folgt der Unterschied zwischen den positiven und negativen Distanzen ((Anzahl positive Distanzen) - (Anzahl negative Distanzen))  in der Nachbarschaft im Abstand \texttt{neibDist}.
In den Letzten drei Zeilen stehen die Daten f"ur den Durchschnitt, das Maximum und das Minimum aller Rasterpunkte.

Die Datei, in der die Zusammenfassungen f"ur alle Raumuniversen gespeichert wird, beginnt mit \texttt{neibBaseName} dann folgt "`UAll.txt"'. In der Datei steht, nach dem Tabellenkopf, f"ur jedes Raumuniversum, f"ur das die Nachbarschaftsstatistik ermittelt wurde, eine Zeile. Die Zeile beginnt mit der Zeit f"ur das Raumuniversum gefolgt von der Anzahl der Punkte im Raster. Danach folgen drei Bl"ocke nacheinander f"ur die Durchschnitts-, Maximal- und Minimalwerte. Jeder Block besteht aus vier Eintr"agen. Der erste Eintrag ist dabei jeweils f"ur alle Nachbarpunkte im Abstand \texttt{neibDist} der Punkte im Raster, dann folgen nacheinander die Eintr"age f"ur die Anzahl der negativen und der positiven ausgehenden Distanzen, am Ende folgt der Unterschied zwischen den positiven und negativen Distanzen.



\subsubsection{Abstandsstatistik}\index{Abstandsstatistik}

\begin{tabbing}
\hspace{10mm} \= \kill
Methoden: \texttt{\index{getDistanceStatistics()}unsigned long getDistanceStatistics();}\\
\>\texttt{\index{setDistanceStatistics()}void setDistanceStatistics(unsigned long gDist)}\\
\>\texttt{\index{getDistanceBaseFileName()}char* getDistanceBaseFileName();}\\
\>\texttt{\index{setDistanceBaseFileName()}void setDistanceBaseFileName(char* distBN)}\\
Daten: \texttt{unsigned long getDist; char *distBaseName}
\end{tabbing}
\begin{tabbing}
\hspace{7mm} \=\hspace{50mm} \= \kill
\bfseries Nr. \> \bfseries Klassenvariable \> \bfseries Standartparameterbeschreibung\\
32 \>\texttt{\index{getDist}unsigned long getDist}\>  Abstandsstatistik ermitteln:\\
33 \>\texttt{\index{distBaseName}char *distBaseName}\>  Dateinamensanfang der Abstandsstatistik:
\end{tabbing}

Mit der Abstandsstatistik werden die Abst"ande zwischen den einzelnen Rasterpunkten ermittelt. 

Wenn \texttt{getDist} (die zugeh"orige Methoden: \texttt{getDistanceStatistics()} und \texttt{setDistanceStatistics()}) gr"o"ser 0 ist, wird die Abstandsstatistik alle \texttt{getDist} Ticks ermittelt und ausgegeben. Die Ausgabe erfolgt dabei in zwei Dateien. In einer Datei wird die detailierter Statistik f"ur das aktuelle Raumuniversum ausgegeben und in einer zweiten Datei wird f"ur alle betrachteten Raumuniversen eine Zusammenfassung f"ur die einzelnen Raumuniversen Zeilenweise ausgegeben. Beide Dateien werden in das Statistikverzeichnis (\texttt{statisticFolderName}) abgespeichert. Jeder Eintrag in den Dateien wird von einem Semikolon "`;"' gefolgt.

Der Dateiname der detailierten Statistik beginnt mit der in \texttt{distBaseName} (die zum Parameter geh"origen Methoden sind: \texttt{getDistanceBaseFileName()} und \texttt{setDistanceBaseFileName()}) gespeicherten Zeichenkette, dann folgt die Zeit f"ur das aktuelle Raumuniversum mit einem vorgestellten "`U"' und am Ende die Endung "`.txt"', ein Beispiel daf"ur ist "`distU13.txt"'.

Die Daten in der Datei sind in drei Bl"ocke gegliedert. 

Der erste Block enth"alt die Abst"ande der Rasterpunkte zueinander. Daf"ur stehen dort in der ersten Zeile und Spalte die einzelnen Namen der Rasterpunkte. In den restlichen Zellen steht jeweils der Abstand den die beiden Rasterpunkte zu dieser Spalte und Zeile besitzen.

Der zweite Block enth"alt jeweils nacheinander eine Spalte f"ur den maximalen und durchschnittlichen Abstand, den die Rasterpunkte zu dem Rasterpunkt dieser Zeile haben.

Im dritten Block werden die Distanzen, welche die Rasterpunkte zu dem Punkt dieser Zeile haben, noch einmal geordnet aufgef"uhrt.

Zwischen dem ersten und zweiten Block gibt es eine Freispalte und zwischen dem zweiten und dritten Block gibt es zwei Freispalten (in der Datei stehen dort jeweils zwei "`;;"' oder drei "`;;;"' Semikolons direkt hintereinander).

Im Tabellenkopf steht in der erste Spalte "`name"', danach folgen die Namen der einzelnen Rasterpunkte, dann "`;; maximum; average ;;;dist sorted : ; number of grid points :"' und danach folgt die Anzahl der Punkte im Raster. 

\bigskip\noindent
Beispiel f"ur die detailierte Statistik:
\begin{verbatim}
name; 4 ;17 ;19 ;; maximum; average ;;;dist sorted : ; 
	number of grid points :3 ;
4 ;0;3;3; ;3 ;2 ;;;0;3;3;
17 ;3;0;6; ;6 ;3 ;;;0;3;6;
19 ;3;6;0; ;6 ;3 ;;;0;3;6;
\end{verbatim}

Die Datei, in der die Zusammenfassungen f"ur alle Raumuniversen gespeichert wird, beginnt mit \texttt{distBaseName} dann folgt "`UAll.txt"'. In der Datei steht, nach dem Tabellenkopf, f"ur jedes Raumuniversum, f"ur das die Abstandsstatistik ermittelt wurde, eine Zeile. Die Zeile beginnt mit der Zeit f"ur das Raumuniversum gefolgt von der Anzahl der Punkte im Raster. Danach folgen drei Spalten f"ur den durchschnittlichen Abstand aller Rasterpunkte zu allen Rasterpunkten, dann f"ur den maximalen Abstand zwischen allen Rasterpunkte und als letztes f"ur den kleinsten der zweit kleinsten Abst"ande zwischen den Rasterpunkten (der kleinste Abstand ist immer 0).


%TODO pr"ufen + Beschneidungsstatistik anpassen

\subsection{Statistik "uber die Raumuniversenteile}

\begin{tabbing}
\hspace{10mm} \= \kill
Methoden: \texttt{\index{getOutUniversPartStatistic()}unsigned long getOutUniversPartStatistic();}\\
\> \texttt{\index{setOutUniversPartStatistic()}void setOutUniversPartStatistic(unsigned long uniPart);}\\
\> \texttt{\index{getUniversPartFileName()}char* getUniversPartFileName();}\\
\> \texttt{\index{setUniversPartFileName()}long setUniversPartFileName(char* uniPartF)}\\
Daten: \texttt{\index{lOutUniversPartStatistic}unsigned long lOutUniversPartStatistic;}\\ \>\texttt{\index{szUniversPartStatisticFileName}char* szUniversPartStatisticFileName;}\\
\>\texttt{\index{universPartStatisticFile}fstream *universPartStatisticFile;}\\
\>\texttt{\index{bUniversPartStatisticParameterChanged}bool bUniversPartStatisticParameterChanged;}
\end{tabbing}
\begin{tabbing}
\hspace{7mm} \=\hspace{50mm} \= \kill
\bfseries Nr. \> \bfseries Klassenvariable \> \bfseries Standartparameterbeschreibung\\
34 \>\texttt{\index{outCutStatistic}unsigned long }\> Teiluniversumsstatistik ausgeben:\\
34 \>\texttt{ lOutUniversPartStatistic}\>\\
35 \>\texttt{\index{szUniversPartStatisticFileName}char* cutFileName}\> Teiluniversumsstatistik Dateiname:
\end{tabbing}
Zu den zusammenh"angenden Teilraumuniversen des Raumuniversums kann eine Statistik in eine Datei ausgegeben werden.

Wenn der Parameter \texttt{lOutUniversPartStatistic} (die Methoden sind: \texttt{getOutUniversPartStatistic()} und \texttt{setOutUniversPartStatistic()}) gr"o"ser $0$ ist, wird alle \texttt{lOutUniversPartStatistic} Ticks/Iterationen die Statistik "uber die zusammenh"angenden Teilraumuniversen in die Datei mit dem in \texttt{szUniversPartStatisticFileName} (\texttt{getUniversPartFileName()} und \texttt{setUniversPartFileName()}) stehenden Pfad ausgegeben. Die erste Zeile beinhaltet den Tabellenkopf. Danach werden die Werte f"ur das aktuelle Raumuniversum und der Teilraumuniversen jeweils in eine neue Zeile geschrieben, wobei hinter jedem Wert ein Semikolon "`;"' kommt.

Zu diesen Werten geh"oren, der Reihenfolge nach, die \index{Zeit}Zeit (interne Zeit plus Zeitbasis), dann kommt die Anzahl der Punkte, positiven und negativen Distanzen des Raumuniversums, danach folgt die Anzahl der zusammenh"angenden Raumuniversumsteile und am Ende folgt eine Liste mit den Daten zu den einzelnen Raumuniversumsteilen.
In dieser Liste steht, nach der Gr"o"se bzw. Anzahl von Punkten geordnet, f"ur jeden zusammenh"angende Raumuniversumsteil ein Klammerausdruck. Zwischen den Klammern f"ur einen Raumuniversumsteil steht der Reihe nach, durch Komma "`,"' getrennt, die Anzahl der Punkte, positiven und negativen Distanzen in ihm.


\bigskip\noindent
Beispiel f"ur eine Zeile der Teiluniversumsstatistik:
\begin{verbatim}
54; 11; 4; 5; 3; ( 6, 2, 4 ) ( 4, 2, 1 ) ( 1, 0, 0 ) ;
\end{verbatim}

Die ausgegebenen Daten sind identisch zur Beschneidungsstatistik (siehe \ref{beschneidungsstatistik} auf Seite \pageref{beschneidungsstatistik}) und sie wird nach dem Beschneiden des Raumuniversums erstellt (dann gibt es nur ein zusammen"angendes Teilraumuniversum).



\subsection{Standartparameter}\index{Standartparameter}

Die Standartparameter sind in der Datei \index{standart\_Parameter.txt}"`standart\_Parameter.txt"' zu finden. Diese wird geladen, wenn beim Start des Simulators keine Parameterdatei angegeben wird.

In der Datei \index{Null\_Parameter.txt}"`Null\_Parameter.txt"' ist ein Parametersatz angegeben, der keine Nebenwirkungen hat, bei dem also nicht automatisch Ausgabedateien erzeugt werden. Diese Datei sollte nicht ver"andert werden. Sie liefert die Anfangswerte f"ur den Simulator, die dann sp"ater durch spezifische Werte aus einer anderen Parameterdatei "uberschrieben werden k"onnen. Wenn in einer Paramerterdatei f"ur einen Parameter keine Angaben bzw. Zeile existiert, kommen die Werte der Datei "`Null\_Parameter.txt"' zum Einsatz.

\index{Parameter|)}

\section{Klassenbeschreibung} 
\index{Implementation}\index{Implementation!Klassen}\index{Klassen}

Die Systemimplementation umfasst drei Klassen: \index{Implementation!Univers}\index{Univers}\texttt{Univers}, \index{Implementation!UniversTools}\index{UniversTools}\texttt{UniversTools} und \index{Implementation!UniversNeib}\index{UniversNeib}\texttt{UniversNeib}.

Die Klasse \texttt{Univers} enth"alt den Basissimulator. In ihr sind die Methoden zur Erzeugung von Raumuniversenfolgen und f"ur einfachen Statistiken f"ur die Raumuniversen implementiert.

In der Klasse \texttt{UniversTools} sind Methoden implementiert mit denen Erzeugung und Auswertungen von Raumuniversen und Punktstrukturen m"oglich sind. Dazu geh"oren Beispielsweise, dass Erzeugen eines Rasters, den Durchschnitt zweier Punktmengen ermitteln oder die Berechnung der Entfernung zweier Punkte. \texttt{UniversTools} erbt von \texttt{Univers}.

Die Klasse \texttt{UniversNeib} erbt von der Klasse \texttt{UniversTools} und dient zur Ermittlung weiterer Statistiken. Mit ihr k"onnen insbesondere die Rasterstatistiken f"ur die Raumuniversenfolge ausgegeben werden.


\section{Unterschiede der Simulatoren}\index{Implementation!Unterschiede}

Die drei Simulatoren unterscheiden sich untereinander nur in der Implementation der Methoden \texttt{\index{tick()}tick()} und \texttt{\index{evalueTransition()}evalueTransition()}, sowie durch die implementation der Klasse \texttt{\index{TPoint}TPoint}. Die TPoint implementation f"ur den Simulator univers ist \texttt{TPoint.cpp}, f"ur universD ist \texttt{TPointD.cpp} und f"ur universP ist \texttt{TPointP.cpp}.
Durch die Definition des jeweiligen Makros \texttt{\index{Makro!UNIVERS}UNIVERS}, \texttt{\index{Makro!UNIVERS\_D}UNIVERS\_D} und \texttt{\index{Makro!UNIVERS\_P}UNIVERS\_P} kann bei der Komplierung der Klasse \texttt{Univers} der jeweilige Simulator erzeugt werden. Dann muss noch die richtige TPoint Implementation/das richtige TPoint Objekt hinzugelinkt werden.

\subsection{Unterschiede zwischen Linux und Windows}
\index{Implementation!Unterschiede!Windows}\index{Implementation!Unterschiede!Linux}

Die Windows-Versionen der Simulatoren unterscheiden sich von den Linux-Versionen dadurch, dass die Eingaben "uber Tastatur unter Linux mithilfe der \texttt{keyboard}-Klasse geschieht und unter Windows mit Windows spezifischen Funktionen aus \texttt{conio.h}. Dadurch fehlen unter Windows die "`keyboard.*"' Dateien und in der Datei "`UniversNeib.cpp"' wird die Eingabe umgestellt. Diese Umstellung in "`UniversNeib.cpp"'geschieht dadurch, dass \texttt{conio.h} eingebunden/includiert und die \texttt{keyboard} Instanz gel"oscht wird (\texttt{keyboard kb;} und \texttt{kb.} in der \texttt{start()}-Methode). (Die Umstellung geschieht automatisch durch \texttt{\#ifdef} .)


\section{Implementierungskonventionen}\index{Implementation!Konventionen}

Im Nachfolgendem sind einige Implementierungskonventionen aufgef"uhrt. Da sie erst im Nachhinein aufgestellt wurden, sind sie teilweise in der tats"achlichen Implementation noch nicht umgesetzt.

\input{implKonventions}


\section{Zusatztools}

\subsection{Raumuniversen erzeugen}\index{Raumuniversen!erzeugen}

\subsubsection{cutUniversPart}
\index{cutUniversPart}\index{Raumuniversen!ausschneiden}\index{Raumuniversen!erzeugen!ausschneiden}

Das Tool cutUniversPart ist in einer eigenen Implementation realisiert. Nachdem der zugeh"orige Quelltext heruntergeladen wurde, kann er durch "`./make"' kompiliert und durch "`cut"' gestartet werden.

Das Tool cutUniversPart dient dazu, aus einem existierenden Raumuniversum einen Teil bzw. Bereich auszuschneiden und in ein eigenes Raumuniversum umzuwandeln. Dazu wird um einem Punkt als Mittelpunkt bis zu einem vorgegebenen Abstand alle sein Nachbarpunkte zu dem Bereich hinzugef"ugt, dieser wird dann zu einem neuen Raumuniversum transformiert.

Nach dem Start von "`cut"' wird der Benutzer zuerst aufgefordert den Pfad f"ur das Raumuniversum anzugeben aus dem ein Teil ausgeschnitten werden soll, dieses wird dann geladen. Danach wird ein Punktname (bzw. Punktnummer) abgefragt, der als Mittelpunkt dienen soll, als n"achstes wird dann der Abstand angegeben, bis zu welchem ein Bereich um den Punkt ausgeschnitten werden soll. Dann wird der Pfad abgefragt unter dem der bearbeitete Teil des Raumuniversums am Ende abgespeichert werden soll. Nun kann noch der Bearbeitungsmodus gew"ahlt werden. 

Im den Modi 0 wird gleich der Teil in ein Raumuniversum umgewandelt. Bei den Modi 1 bis 4 werden vorher noch die Distanzen der Arten ver"andert. Im Modi 1 bzw. 2 werden alle negativen bzw. positiven Distanzen aus dem Bereich gel"oscht. Im Modi 3 bzw. 4 werden alle negativen bzw. positiven Distanzen in dem Bereich durch positiven bzw. negativen Distanzen ersetzt, negativen bzw. positiven Distanzen werden also in die andere Distanzart umgewandelt.
Im Modi 5 werden nur die Statistiken (Anzahl Punkte, positive und negative Distanzen) "uber die Gr"o"se des ausgeschnittenen Teils und seiner Oberfl"ache (Punkte und Distanzen die sowohl mit Punkten im wie au"serhalb des Teils verbunden sind) ausgegeben, ohne das der Teil zu einem neuen Raumuniversum gemacht wird.

Bei der Umwandlung des Teils in ein eigenes Raumuniversum werden Distanzpaare gesucht, die beide nur einen Endpunkt im Teil haben, die Endpunkt im Teil m"ussen verschieden sein, das Distanzpaare muss der gleichen Art (positiv oder negativ) zugeh"oren und deren Endpunkte im Teil m"oglichst genauso viele positive und negative Distanzen haben, wie der jeweils andere Endpunkt der nicht im Teil liegt. Diese Distanzpaare werden dann durch ein Distanzpaar der gleichen Art ersetzt, wobei nun aber die beiden Punkte im Bereich durch eine Distanz verbunden wird. Dies wird solange wiederholt wie es solche Distanzpaare gibt, die restlichen Distanzen die nur einen Endpunkt im Bereich haben werden gel"oscht. Am Ende sind alle Punkte des Teils nur mit Punkten des Teils verbunden und der Teil ist ein eigenst"andiges Raumuniversum.

Dieses Raumuniversum wird dann ausgegeben.

Weiterhin werden im Laufe der Bearbeitung noch weitere Statistiken ausgegeben. Dazu geh"oren die Anzahl der Punkte, positiven und negativen Distanzen im Teil vor und nach der Bearbeitung. Die Anzahl der Punkte in der Oberfl"ache des Bereichs, wobei die Oberfl"ache all die Punkte enth"alt, die Distanzen besitzen welche nur einen Endpunkt im Bereich haben. Weiterhin wird ausgegeben, wie viele positive und negative Distanzen bei der Bearbeitung gel"oscht oder versetzt wurden, sowie wie gro"s die Summe der Unterschiede der Anzahlen der positiven und negativen Distanzen der Punkte im Teil war, zwischen denen die Distanzen versetzt wurden. 

%??

%\subsubsection{\index{random}\index{Raumuniversen!erzeugen!random}Zuf"allige Raumuniversen erzeugen: random}

%\subsubsection{\index{euklid}\index{Raumuniversen!erzeugen!euklid}Euklidische Raumuniversen erzeugen: euklid}


\input{fdl}

\begin{thebibliography}{99}
	\bibitem{wildeRZ} Betti "Osterholz, Wilde Raumzeit

\end{thebibliography}

\clearpage
\label{AbsIndex}
\printindex 

\end{document}
