
Die GP-System verwendet eine Vielzahl von Funktionen, die schachspezifisches
Wissen verwenden und auch nur für schachspielende Individuen sinnvoll sind. Alle
diese Funktionen haben neben den individuelle Besonderheiten, die in den folgenden
Abschnitten erklärt werden.

%----------------------------------------------------------------------
\section{Funktionen ChessGP}
%----------------------------------------------------------------------
\label{sec:FunktionenChessGP}

%Das ChessGP-System verwendet eine Vielzahl von Funktionen, die schachspezifisches
%Wissen verwenden und auch nur für schachspielende Individuen sinnvoll sind. Alle
%diese Funktionen haben neben den individuelle Besonderheiten, die in den folgenden
%Abschnitten erklärt werden, aber auch gemeinsame Besonderheiten, die sie von
%Funktionen die üblicherweise in der Genetischen Programmierung verwendet werden
%unterscheiden.

%Eine wichtige Besonderheit ist die Verwendung von Datenstrukturen, wie sie
%im Abschnitt~\ref{sec:ChessGPDatenstruktur} beschrieben wird. Diese Struktur
%ist für die verschiedenen Ebenen des Systems unterschiedlich, sie begründet
%sich aber immer auf eine semantische Trennung der genutzten und erzeugten
%Daten. Diese Datenstruktur wird auch bei den Konstanten weitergeführt, so dass
%auch die verwendeten Operationen diese Trennung aufnehmen und es somit nicht
%zu semantisch \emph{sinnlosen} Operationen kommt. So sind in diesem System
%Operationen unmöglich, die eine Addition eines Figurwertes mit der Feldposition
%einer anderen Figur durchführen.

%Ein weitere wichtiger Aspekt der Operationen ist die Verwendung eines ausgezeichneten
%Registers, welches von vielen Operationen lesen wie auch schreibend genutzt wird.
%Diese Register wird im folgenden auch Akkumulator oder kurz Akku genannt. Jedoch
%sind der Akku oder die anderen Register nicht die einzigste Möglichkeit für die
%Funktionen ihrer Eingabedaten zu erhalten. Die meisten Funktionen können
%auf das Schachbrett lesend zugreifen um so weitere Informationen für die Berechnung
%zu erhalten.

%----------------------------------------------------------------------
\subsection{Funktionen der Materialbewertungsebene}
%----------------------------------------------------------------------
\label{sec:FunkMatChessGP}

Die Funktionen für die Materialbewertungsebene müssen es dem Individuum erlauben,
das Schachbrett als Eingabe zu nutzen und zusammen eine Bewertung für das Brett
zu berechnen. Hierzu verwendet die Ebene einen Datenstruktur die aus einem
dreier-Tupel besteht, dass aus Feld-, Figur- und Zahlenelementen
zusammengesetzt ist, siehe hierzu Abschnitt~\ref{sec:ChessGPDatenstruktur}.


\subsubsection*{Operationen zur Steuerung des Programmflusses:}
\begin{description}
\item [boardLoop] Die Funktion wiederholt die folgenden $n$ Operationen für alle
	Felder des Schachbrettes. Der Wert $n$ wird aus dem Akkumulator Register gelesen.
	Der Wert $n$ wird immer modulo 100 gerechnet, somit ist die Obergrenze der
	Schleifengröße 100 Instruktionen. Eine weitere Besonderheit der Funktion ist,
	dass weitere \emph{Loop} Funktionen innerhalb der Schleife ignoriert werden,
	somit werden eine Schachtelung von Schleifen und damit verbundene Laufzeitprobleme
	vermieden.

\item [rowLoop] Diese Funktion wiederholt die folgenden $n$ Operationen für alle
	Felder einer Reihe des Schachbrettes. Ansonsten analog zu boardLoop.

\item [lineLoop] Diese Funktion wiederholt die folgenden $n$ Operationen für alle
	Felder einer Zeile des Schachbrettes. Ansonsten analog zu boardLoop.

\item [pieceLoop] Wiederholt die folgenden $n$ Operationen für alle
	Felder, die von der Figur erreicht werden können, die durch den Akkumulator
	bestimmt wird.

\item [ifThen] Die Methode ist eine Sprungfunktion wie sie für lineare Strukturen
	verwendet wird. Wenn das Zahlenelement der Datenstruktur im Akkumulator größer
	als Null ist, werden die $n$ nächsten Instruktionen übersprungen. Sprünge sind
	immer in Richtung der Ausführungsreihenfolge. %Ist der Wert $n$ größer als die
	%Anzahl der Instruktionen bis zum Ende des Individuums, wird die Ausführung
	%des Individuums beendet. Wird eine Sprungbefehl innerhalb einer Schleife
	%aufgerufen, und der Sprungbefehl springt außerhalb der Schleife, wird diese
	%vorzeitig abgebrochen.
\end{description}


\subsubsection*{Operationen Ermittlung von Figurwerten:}

\begin{description}
\item [whichPiece] Gibt den Typ der Figur zurück, die im Figurelement der Akku
	Datenstruktur gespeichert ist.

\item [pieceValue] Liefert den Figurwert der Figur, auf die im Akku verwiesen
	wird. Weiße Figuren bekommen dabei positive Werte und schwarze negative
	Werte. Die Absolutbeträge sind gleich: Bauer = 10, Springer und Läufer = 30,
	Türme = 50, Dame = 90 und König = 1000.

\item [attackedByValue] Ermittelt den Wert der Figur, die
	das Feld angreift, auf das der Akku verweist. Greifen mehrere Figuren das
	Feld an, wird der kleinste Wert genommen.

\item [attackedByNumber] Ermittelt die Anzahl der Figur, die
	das Feld angreift, auf das der Akku verweist. Greifen mehrere Figuren das
	Feld an, wird der kleinste Wert genommen.

\item [legalMovesNumber] Berechnet die Anzahl der legalen Züge, die die Figur
	durchführen kann, die auf dem im Akku gespeicherten Feld steht.
\end{description}


\subsubsection*{Operationen zum Verschieben des aktuellen Feldes:}

\begin{description}
\item [rowShift] Die Methode verschiebt das Feld, das im Akku gespeichert ist
	um eine variable Anzahl von Reihen. Dazu wird das Zahlenelement des Akku-Register
	verwendet. Der Wert wird immer modulo 8 gerechnet, so dass ein Feld maximal
	um acht Reihen verschoben werden kann. Ist der Wert positiv wird in die Richtung
	der schwarzen Grundlinie verschoben, bei negativen Werten in Richtung der weißen
	Grundlinie. Analog die Funktion \textbf{lineShift}.

%\item [lineShift] Die Methode arbeitet analog zur rowShift Funktion, nur das sie
%	das Feld bezüglich der Zeilen verschiebt.

\item [northWestShift] Die Funktion verschiebt das Feld auf der Diagonale, die von oben
	rechts nach unten links verläuft. Die Randbedingungen sind analog zur rowShift Funktion.
	Analog die Funktion \textbf{northEastShift}.

%\item [northEastShift] Die Funktion verschiebt das Feld auf der Diagonale, die von oben
%	links nach unten rechts verläuft. Sonst analog zur northWestShift Funktion.
\end{description}


\subsubsection*{Lade- und Speicheroperationen:}

\begin{description}
\item [loadAll] Die Methode kopiert den gesamte Inhalt der Datenstruktur eines
	Registers, dessen Adresse übergeben wird, in den Akku.

\item [loadPiece] Die Methode kopiert den Inhalt der Figur-Komponente der
	Datenstruktur eines Registers, dessen Adresse übergeben wird, in den Akku.

\item [loadValue] Die Methode kopiert den Inhalt der Wert-Komponente der
	Datenstruktur eines Registers, dessen Adresse übergeben wird, in den Akku.

\item [loadLine] Die Methode kopiert den Zeilenposition der Feld-Komponente der
	Datenstruktur eines Registers, dessen Adresse übergeben wird, in den Akku.
	Dazu wird für die Feldposition im Akku die Zeilenposition berechnet und damit
	Zeilenposition der Feld-Komponente im Register verändert.

\item [loadRow] Die Methode kopiert den Reihenposition der Feld-Komponente der
	Datenstruktur eines Registers, dessen Adresse übergeben wird, in den Akku.
	Dazu wird für die Feldposition im Akku die Reihenposition berechnet und damit
	Reihenposition der Feld-Komponente im Register verändert.

\item [storeAll] Die Funktion kopiert den gesamten Inhalt des Akkus in einem Register,
	dessen Adresse übergeben wird.

\item [storePiece] Die Funktion kopiert den Inhalt der Figur-Komponente des Akkus
	in einem Register, dessen Adresse übergeben wird.

\item [storeValue] Die Funktion kopiert den Inhalt der Wert-Komponente des Akkus
	in einem Register, dessen Adresse übergeben wird.

\item [storeLine] Die Funktion kopiert den Zeilenwert der Feld-Komponente des Akkus
	in einem Register, dessen Adresse übergeben wird. Analog die Funktion \textbf{storeRow}.

%\item [storeRow] Die Funktion kopiert den Reihenwert der Feld-Komponente des Akkus
%	in einem Register, dessen Adresse übergeben wird.
\end{description}


\subsubsection*{Operationen zum Setzen von Konstanten:}

\begin{description}
\item [setAll] Die Methode kopiert den gesamte Inhalt einer Konstante in den Akku.

\item [setPiece] Die Funktion kopiert den Inhalt der Figur-Komponente einer Konstante in den Akku.

\item [setValue] Die Funktion kopiert den Inhalt der Wert-Komponente einer Konstante in den Akku.

\item [setLine] Die Funktion kopiert den Zeilenwert der Feld-Komponente einer Konstante in den Akku.
	Analog die Funktion \textbf{setRow}.

%\item [setRow] Die Funktion kopiert den Reihenwert der Feld-Komponente einer Konstante in den Akku.

\item [swap] Tauscht die Werte eines Registers mit denen des Akkus.
\end{description}

\subsubsection*{Arithmetische Operationen}

Zuzüglich zu den schachspezifischen Operationen, verwendet die Materialbewertungsebenen
noch die folgenden Arithmetische Operationen.

\begin{description}
\item [add] Addition des Zahlenwertes der Datenstruktur, die Übergeben wird
	 mit dem Akku. Der Wert kann ein Registerwert, eine Konstante oder das
	 Ergebnis einer Operation sein. Analog die Funktionen \textbf{sub, mul, div}.
%\item [sub] Subtraktion des Zahlenwertes der Datenstruktur, die Übergeben wird
%	 mit dem Akku. Der Wert kann ein Registerwert, eine Konstante oder das
%	 Ergebnis einer Operation sein.
%\item [mul] Multiplikation des Zahlenwertes der Datenstruktur, die Übergeben wird
%	 mit dem Akku. Der Wert kann ein Registerwert, eine Konstante oder das
%	 Ergebnis einer Operation sein.

%\item [div] Division des Zahlenwertes der Datenstruktur, die Übergeben wird
%	 mit dem Akku. Der Wert kann ein Registerwert, eine Konstante oder das
%	 Ergebnis einer Operation sein.

\item [absolute] Ersetzt den Zahlenwert der Datenstruktur im Akku durch den
	Betrag des Wertes.
\end{description}


%----------------------------------------------------------------------
\subsection{Funktionen der Planungsebene}
%----------------------------------------------------------------------
\label{sec:FunkPlanChessGP}

Die Aufgabe der Planungsebene ist es zu einer gegebenen Stellung eine Zugliste
zu ermitteln. Mit diesen Zuglisten wird das Individuum, dann in der Variantenebene
den Suchbaum aufspannen. Dazu wird eine komplizierte Datenstruktur verwendet,
die aus einem Zahlenwert, einer Suchmaske für einen Zug und einer Liste von Zügen
besteht, siehe hierzu Abschnitt~\ref{sec:ChessGPDatenstruktur}. Zu der Datenstruktur
ist noch hinzuzufügen, dass es für jede Komponente der Datenstruktur ein spezielles
Element gibt, das als Wildcard fungiert. Dieses Ersetzungssymbol ($\ast$), bezeichnet
einen beliebigen Inhalt und somit können ganze Mengen von Züge beschreiben werden.
Dies ermöglicht aber auch verschiedene Funktionen Zuglisten zu Filtern und Züge zu
vergleichen.

\subsubsection*{Operationen zur Steuerung des Programmflusses}
\begin{description}
\item [b\_ifThen] Die Operation realisiert eine Verzweigung im Programm. Ist der
	Zahlwert im Akku größer 0 wird der rechte von zwei Pfaden ausgewertet, sonst
	der linke.

\item [b\_callAdfA] Diese Funktion ruft mit der aktuellen Brettstellung ein Programm
	der Materialbewertungsebenen auf, hierbei wird über die Zahlkomponente des Akkumulators
	das Programm bestimmt.
\end{description}

\subsubsection*{Arithmetische Operationen}

\begin{description}
\item [b\_add] Addition einer Zahl zur Zahlkomponente im Akku. Das Ergebnis
	wird in ein Register geschrieben, welches durch den Knoten der ausgewertet
	wird angegeben wird. Analog die Funktionen \textbf{b\_sub, b\_mul, b\_div}.
%\item [b\_sub] Eine Subtraktion, die Berechung ist analog zur Addition.
%\item [b\_mult]Eine Multiplikation, die Berechung ist analog zur Addition.
%\item [b\_div] Eine Division, die Berechung ist analog zur Addition.
\end{description}

\subsubsection*{Mengen Operationen auf den Zuglisten}

\begin{description}
\item [b\_getAllMoves] Schreibt alle legalen Züge für die aktuelle Stellung
	in die Zugliste eines Registers.

\item [b\_unionize] Die Methode vereinigt die Zugliste des Akkus mit der eines
	übergebenen Registers. Das Ergebnis ersetzt die Liste des Akkumulators.

\item [b\_difference] Differenz der Zugliste des Akkus und eines Registers.
	Das Ergebnis ersetzt die Liste des Akkumulators.

\item [b\_sortByValue] Die Zugliste des Akkus wird gemäß des Zahlenwerte absteigend
	sortiert.

\item [b\_cardinality] Die Länge der Zugliste des Akkus wird in das Zahlenfeld
	des Akkus geschrieben.

\item [b\_subset] Die Funktion filtert die Teilmenge der Züge aus dem Akku, die durch
	die Suchmaske eines anderen Attributs angegeben wird. Die neue Liste ersetzt
	die Zugliste des Akkus.

\item [b\_subsetByBorder] Die Methode arbeitet analog zur Funktion b\_subset, nur
	das der Zahlenwert des übergebenen Attributs nun als untere Schranke für
	die Menge genutzt wird.

\item [b\_number] Anzahl der Züge in der Zugliste des Akkus, die der Suchmaske
	des übergebenen Attributes entsprechen. Der Wert wird in die Zahlenkomponente
	des Akkus geschrieben.

\item [b\_numberByBorder] Die Methode arbeitet analog zur Funktion b\_number, nur
	das der Zahlenwert des übergebenen Attributs nun als untere Schranke für
	Operation genutzt wird.

\item [b\_set2Mask] Die Funktion sucht eine minimale Suchmaske zu einer Zugliste.
	Minimal bedeutet, dass so wenig Wildcards wie möglich benutzt werden.

\item [b\_incrementIfEqual] Die Funktion erhöht den Zahlenwert im Akku um eins,
	wenn die Zugliste des Akkus mit der des übergebenen Registers übereinstimmt.

\item [b\_setAllValues] Setzt den Zahlenwert jedes Zuges der Zugliste eines
	Registers auf den Wert, der in der Zahlenkomponente des Registers steht.

\item [b\_increaseAlsValues] Erhöht das Zahlattribut jedes Zuges der Zugliste eines
	Registers, um den Wert, der in der Zahlenkomponente des Registers steht.

\item [b\_storeMoveValue] Speichert die Zahl aus der Suchmaske des Akkus in
	dem i-ten Zug der Zugliste des Akkus, wobei i dem Zahlattribut des Akkus entspricht.

\item [b\_loadMedianMoveValue] Berechnet den Median der in der Zugliste vorkommenden
	Züge und speichert den Wert im Akku.

\item [b\_loadMinMoveValue] Speichert den niedrigsten Wert der Zugliste im Akku.

\item [b\_loadMaxMoveValue] Speichert den höchsten Wert der Zugliste im Akku.

\item [b\_loadMoveValue] Speichert der Wert des i-ten Zuges der Zugliste im Akku.
	Der Wert i wird durch den Akku bestimmt.

\end{description}

\subsubsection*{Lade- und Speicher Operationen}

\begin{description}

\item [b\_loadValue] Lädt das Zahlattribut eines Registers in das Zahlattribut des
	Akkus.

\item [b\_storeValue] Speichert das Zahlattribut des Akkus in das eines Registers.

\item [b\_loadValueIndirect] Das Zahlenattribut des Registers wird im Akku gespeichert,
	dabei wird die Adresse des Registers übergeben (indirekte Adressierung).

\item [b\_storeValueIndirect] Speichert das Zahlattribut des Akkus in das eines Registers
	indirekt.

\item [b\_loadSearchMask] Diese Operation lädt eine Suchmaske aus einem Register und
	speichert sie im Akku.

\item [b\_storeSearchMask] Speichert die Suchmaske des Akkus in der eines Registers.

\item [b\_loadSearchmaskIndirect] Wie b\_loadSearchMask nur mit indirekter Adressierung.

\item [b\_storeSearchmaskIndirect] Wie b\_storeSearchMask nur mit indirekter Adressierung.

\item [b\_storeMoveList, b\_loadAll] Analog zu b\_loadValue.

\item [b\_loadMoveList, b\_storeAll] Analog zu b\_storeValue.

\item [b\_storeMoveListIndirect, b\_storeAllIndirect] Analog zu b\_storeValueIndirect.

\item [b\_loadMoveListIndirect, b\_loadAllIndirect] Analog zu b\_loadValueIndirect.

%\item [b\_loadAll] Analog zu b\_loadValue.

%\item [b\_storeAll] Analog zu b\_storeValue.

%\item [b\_loadAllIndirect] Analog zu b\_loadValueIndirect.

%\item [b\_storeAllIndirect] Analog zu b\_storeValueIndirect.

\item [b\_swap] Tauscht die Inhalte von Akku und einem Register aus.

\end{description}

\subsubsection*{Operationen zum setzen von Konstanten und sonstige}

\begin{description}
\item [setAll2WildCard] Diese Operation setzt bis auf das Zahlenattribut der Suchmaske
	alle Elemente der Suchmaske eines Registers auf Wildcardwerte.

\item [setSourceRow2WildCard] Analog zu setAll2WildCard berührt aber nur das
	Row-Attribut der Datenstruktur.
	
\item [setSourceLine2WildCard] Analog zu setAll2WildCard berührt aber nur das
	Line-Attribut der Datenstruktur.
	
\item [setDestinationRow2WildCard] Analog zu setAll2WildCard berührt aber nur das
	DestinationRow-Attribut der Datenstruktur.
	
\item [setDestinationLine2WildCard] Analog zu setAll2WildCard berührt aber nur das
	DestinationLine-Attribut der Datenstruktur.
	
\item [setDirection2WildCard] Analog zu setAll2WildCard berührt aber nur das
	Direction-Attribut der Datenstruktur.
	
\item [setPiece2WildCard, setHitPiece2WildCard] Analog zu setAll2WildCard berührt aber nur das
	Piece-, HitPiece-Attribut der Datenstruktur.
	
%\item [setHitPiece2WildCard] Analog zu setAll2WildCard berührt aber nur das
%	HitPiece-Attribut der Datenstruktur.
	
\item [setColour2WildCard] Analog zu setAll2WildCard berührt aber nur das
	Colour-Attribut der Datenstruktur.
	
\item [setSourceRow] Diese Operation setzt das Reihen-Attribut des Startfeldes
	in der Suchmaske eines Registers auf den übergebenen Wert.
	
\item [setSourceLine, setDestinationRow, setDestinationLine, setDirection,]
	\textbf{setPiece, setHitPiece, setValue, setColour, setSearchMaskValue }
	Analog zu setSourceRow verändert das Attribut der Datenstruktur.
	
%\item [setDestinationRow] Analog zu setSourceRow verändert das DestinationRow-Attribut
%	der Datenstruktur.
	
%\item [setDestinationLine] Analog zu setSourceRow verändert das DestinationLine-Attribut
%	der Datenstruktur.
	
%\item [setDirection] Analog zu setSourceRow verändert das Direction-Attribut
%	der Datenstruktur.
	
%\item [setPiece] Analog zu setSourceRow verändert das Piece-Attribut
%	der Datenstruktur.
	
%\item [setHitPiece] Analog zu setSourceRow verändert das HitPiece-Attribut
%	der Datenstruktur.
	
%\item [setValue] Analog zu setSourceRow verändert das Value-Attribut
%	der Datenstruktur.
	
%\item [setColour] Analog zu setSourceRow verändert das Colour-Attribut
	%der Datenstruktur.
	
%\item [setSearchMaskValue] Analog zu setSourceRow verändert das SearchMaskValue-Attribut
%	der Datenstruktur.

\item [copyPiece2HitPiece] Diese Funktion kopiert innerhalb der Suchmaske des
	Akkus den Figurtyp in das Typ-Feld der geschlagenen Figur.

\item [copyHitPiece2Piece] Analog zu copyPiece2HitPiece.
\end{description}


%----------------------------------------------------------------------
\subsection{Funktionen der Variantenebene}
%----------------------------------------------------------------------
\label{sec:FunkVariantChessGP}

%Die Aufgabe der Variantenebene ist es mit den Bausteinen der Materialebene und
%der Planungsebene ein Gesamtindividuum zu erstellen, das zu einer gegebenen Stellung
%einen guten Zug zu berechnen. Die Variantenebene führt dazu eine Baumsuche durch,
%wobei sie Individuen der ersten beiden Ebenen als Unterprogramme nutzt. Hierzu verfügt
%diese Ebene über eine eigene Datenstruktur uns spezielle Funktionen. Die Datenstruktur
%für die Variantenebene besteht aus drei Elementen, einem Zahlwert, der eine
%Eingabe oder das Ergebnis der Funktionsmenge ist, und zwei Indexwerten. Die
%Indexwerte geben das Programm der Materialbewertung- oder Planungsebene an, das
%durch die Programme der Variantenebene aufgerufen werden kann. Diese Werte können
%durch verschiedene Funktionen verändert werden. Dem Individuum stehen als
%Globaleregister neben dem Akku-Register noch zwei Farbregister (Weiß und Schwarz)
%zur Verfügung. Zusätzlich haben die Individuen noch Zugriff auf Lokaleregister, die
%für jede Ebene des Spielbaums zur Verfügung stehen, siehe auch
%Abschnitt~\ref{sec:ChessGP-Variantenebene}.

\subsubsection*{Operationen zur Steuerung des Programmablaufs}

\begin{description}
\item [callAdfA] Ruft das Programm der Matreialbewertungsebene mit dem Index auf,
	der in dem Akkumulator gespeichert ist.
\item [ifThen] Vorwärtsgerichteter Sprung.
\item [exit] Stoppt die Ausführung des Entscheidungs-Moduls und startet das
	Blatt-Modul. Diese Operation wird im Fall der Wurzel ignoriert.
\item [cut] Stoppt die Ausführung des Entscheidungs-Moduls und startet das
	Blatt-Modul. Es schneidet die weiteren Züge des Elternknotens ab.
	Diese Operation wird im Fall der Wurzel ignoriert.
\end{description}

\subsubsection*{Arithmetische Operationen}

\begin{description}
\item [add-, sub-, mult-, divConst] Die Methode verknüpfen eine
	Konstante mit dem Wertelement des Akkus, durch eine Grundrechenart.
%\item [subConst]
%\item [divConst]
%\item [multConst]
\item [add-, sub-, mult-, divColourConst] Analog, verändert jedoch ein Farbregister.
\item [add-, sub-, mult-, divLevelConst] Analog, verändert ein Levelregister.
\item [add-, sub-, mutl-, divColourValue2Global] Die Methode verknüpfen den
	Wert des Farbregisters mit dem Wert des Akkus. Wird ein Blatt- oder Entscheidungsmodul
	der Seite Weiß ausgeführt wird das Weiße Farbregister benutzt, sonst das schwarze.
%\item [subColourValue2Global]
%\item [multColourValue2Global]
%\item [divColourValue2Global]

\item [add- ,sub- ,mult- ,divLevelValue2Global] Analog.
\end{description}


\subsubsection*{Lade- und Speicheroperationen}

\begin{description}
\item [storeValueInAdfA] Die Methode kopiert das Wertelement des Akkus in den Indexwert
	für die Materialebene.
\item [storeValueInAdfB] Die Methode kopiert das Wertelement des Akkus in den Indexwert
	für die Planungsebene.
\item [loadValueFromAdfA] Die Methode kopiert den Indexwert für die Materialebene
	in  das Wertelement den Akku.
\item [loadValueFromAdfB] Die Methode kopiert den Indexwert für die Planungsebene
	in  das Wertelement den Akku.
\item [storeColourRegister] Die Funktion kopiert das gesamte Akkuregister in ein
	Farbregister. Ob das Ziel des Kopiervorgangs das schwarze oder das weiße Register
	ist, hängt davon ab, für welche Farbe
\item [storeAdfAIn-, storeAdfB-, storeValueInColourRegister] Analog zu storeColourRegister
	kopiert jedoch nur die entsprechenden Elemente eines Registers.
%\item [storeAdfBInColourRegister]
%\item [storeValueInColourRegister]
\item [storeLevelRegister] Die Funktion kopiert den Akku in das aktuelle Levelregister.
\item [storeAdfA-, storeAdfB-, storeValueInLevelRegister] Analog zu storeLevelRegister,
	kopiert jedoch nur die entsprechenden Elemente eines Registers.
%\item [storeAdfBInLevelRegister]
%\item [storeValueInLevelRegister]
\item [load- ,loadAdfA- ,loadAdfB- ,loadValueInColourRegister] Analog zu den store-Methoden
	kopiert nur in das Akkuregister.
\item [load- ,loadAdfA- ,loadAdfB- ,loadValueInLevelRegister] Analog zu den store-Methoden
	kopiert nur in das Akkuregister.
\end{description}


\subsubsection*{Operationen zum setzen von Konstanten und sonstiges}

\begin{description}
\item [getDepth] Ermittelt die aktuelle Tiefe des Suchbaumes und speichert
	sie im Akku.
\item [setAdfA] Setzt den Indexwert der Materialebene auf eine konstante Zahl.
\item [setAdfB] Setzt den Indexwert der Planungsebene auf eine konstante Zahl.
\item [setValue] Setzt das Wertelement des Akkus  auf eine konstante Zahl.
\end{description}


%----------------------------------------------------------------------
\section{Funktionen qoopy}
%----------------------------------------------------------------------
\label{sec:FunktionenQoopy}


Zustandsfunktionen die aktuelle Brettstellung überprüfen, sie haben einen
Boolschen-Wert als Rückgabewert.
\begin{description}   
\item [Eröffung] Die Methode prüft, ob eine Eröffnung vorliegt. Dies ist
	der Fall, wenn der weiße Spieler über mindestens neun Figuren in der ursprünglichen
	Position befinden.
\item [Mittelspiel] Ein Mittelspiel liegt vor, wenn mehr als fünf Figuren vom
	Typ Springer, Läufer, Turm oder Dame nicht in der Anfangsstellung sind, oder
	keine Eröffnung festgestellt wird.
\item [Endspiel] Ein Endspiel liegt vor wenn keine Eröffnung oder kein Mittelspiel
	erkannt wird.
\item [Schlagzug] Ein Schlagzug liegt vor, wenn die aktuelle Brettstellung durch
	einen Zug erreicht wurde, bei dem eine Figur geschlagen wurde.
\item [WeissAmZug] Die Methode gibt den Wert wahr zurück, wenn der weiße Spieler
	in der aktuellen Brettstellung am Zug ist.
\item [Schach] Es wird Schach angezeigt, wenn der Spieler der am Zug ist in
	der untersuchten Brettstellung im Schach steht.
\item [Wurzel] Gibt wahr zurück, wenn der Knoten des Spielbaums der ausgeführt
	wird die Wurzel ist.
\item [Bauernzug] Ein Bauernzug liegt vor, wenn der Zug, der zur aktuellen Brettstellung
	geführt hat ein Bauernzug war. Analog die Funktionen \textbf{Sringerzug, Läuferzug, Turmzug, Damenzug, Königszug}.
%\item [] Analog zu Bauernzug.
%\item [Läuferzug] Analog zu Bauernzug.
%\item [Turmzug] Analog zu Bauernzug.
%\item [Damenzug] Analog zu Bauernzug.
%\item [Königszug] Analog zu Bauernzug.
\item [Promotion] Eine Promotion wird erkannt, wenn der Zug, der zur aktuellen Brettstellung
	geführt hat ein, eine Umwandlung eines Bauern war.
\item [100000KnotenVerbraucht] Die Methode gibt wahr zurück, wenn bei der aktuellen
	Suche mindestens 100.000 Knoten verbraucht wurden.
\end{description}
 
Die Terminal Funktionen des Tiefen Modul bilden zusammen mit den Zustandsfunktionen
das Schachwissen des GP-Module im qoopy System.

\begin{description}   
\item [Figurenwert] Der Wert der Figur, die gezogen wurde, um die aktuelle
	Brettstellung zu erreichen.
\item [WertDerGeschlagenenFunktion]  Die Methode gibt den Wert der geschlagenen
	Figur zurück, wenn keine Figur geschlagen wurde wird der Wert 0 zurückgegeben.  
\item [Zugnummer]  Die Funktion ermittelt die Anzahl der Halbzüge, die zum
	erreichen der Stellung gebraucht wurden.
\item [Suchtiefe] Die aktuelle Suchtiefe im Spielbaum.
\item [Resttiefe] Die restliche Suchtiefe, die das Suchtiefenmodule noch
	maximal ausführen kann.
\item [ResttiefenDelta] Der Deltawert gibt an, um wie viel die Resttiefe im
	nächsten Schritt verändert wird. Der Wert von Delta kann nur -2, -1, 0, 1 oder 2 sein.
\item [Alpha] Die Alpha-Scharanke des Alpha-Beta Algorithmus im aktuellen Knoten.
\item [Beta]  Die Beta-Scharanke des Alpha-Beta Algorithmus im aktuellen Knoten.  
\item [Stellungswert] Der Wert der aktuellen Brettstellung in Suchbaum. Der Wert
	wird durch das Stellungsbewertungsmoduledes Individuums ermittelt.
\item [LetzterVerzweigungsgrad] Der Verzweigungsgrad des Knotens, als der Spieler
	das letzte Mal gezogen hat.
\item [Zugsortierungswert] Die Methode ermittelt den Wert für den Zug, der zur aktuellen
	Stellung geführt hat. Hierzu wird das Zugsortierungsmodul des Individuums genutzt.
\item [Knotenverbrauch] Der aktuelle prozentuale Verbrauch, des für diese Suche zur Verfügung
	stehenden Kontenmenge.
\item [AnzahlSpringerLäuferTurmDame] Anzahl der Springer, Läufer, Türme und der Dame
	auf dem Feld.
\end{description}

Die Funktionsmenge des Tiefen Modul haben anders als die Terminalfunktionen kein
Schachwissen.

\begin{description}  
\item [ +, -, * /] Die arithmetischen Funktionen verknüpfen den Akkumulator mit
	einem anderen Operanden und legen das Ergebnis wieder im Akkumulator ab. 
\item [IncHorizon] Die Funktion erhöht den Deltawert, mit dem die Resttiefe, nach der
	Ausführung des Suchtiefen-Modules, verändert wird. Der Deltawert kann maximal
	um den Wert zwei erhöht werden. Analog die Funktion \textbf{DecHorizon}.
\item [Sinus, Sigmoid] Die Sinusfunktion und die Sigmoidfunktion $ \frac{1}{1+e^{-operand}}$.  
\item [SpeicherLevelReg] Die Funktion speichert ein Levelregister im Akkumulator.
\item [SpeicherGameReg]  Die Funktion speichert ein Gameregister im Akkumulator.
\item [SpeicherSearchReg]  Die Funktion speichert ein Searchregister im Akkumulator.
\item [Laden] Die Funktion lädt den Wert des Operanden in das Level-, Game- oder Searchregister.
\item [If] Wenn der Konditionalteil der Funktion wahr ist, wird die Funktion
	in der Konklusion ausgeführt, sonst wird die Funktion übersprungen.
\end{description}



%----------------------------------------------------------------------
\subsection{Parameter der Gegnerprogramme im qoopy-System}
%----------------------------------------------------------------------
\label{an:qoopyGegnerPara}

\begin{enumerate}
\item  Bauer [100], Springer [340], Läufer [340], Turm [500], Dame [900]
%\item  Springer [340]
%\item  Läufer [340]
%\item  Turm [500]
%\item  Dame [900]
\item  Bestrafung für einen Läufer in der Anfangsposition [15].
\item  Bonus für einen Bauern, der das Zentrum des Schachbrettes erreicht hat [15].
\item  Bestrafung, wenn zwei Bauern auf der gleichen Linie stehen [30].
\item  Bonus für einen Bauern, der auf beiden Nachbarlinien keinen
        gegnerischen Bauern hat [20].
\item  Bestrafung für einen Bauern der keinen Bauern auf den Nachbarlinien
        hat, der näher an der ersten Reihe des Gegners ist [15].
\item  Bonus für einen Freibauern, der durch einen Turm beschützt wird [20].
\item  Bonus für einen Bauern, wenn er in der nähe der ersten Reihe des Gegners
        ist (Promotionsmöglichkeit) [300].
\item  Bonus wenn beide Läufer vorhanden sind [20].
\item  Bestrafung für einen Läufer, der sich in der Startposition aufhält
  [15].
\item  Bestrafung für Läufer in einer blockierten Stellung. Eine blockierte
  Stellung ist in diesem Zusammenhang eine Stellung in der drei eigene Bauern
  sich im Bereich des erweiterten Zentrums befinden und Felder besetzen, die
  die gleiche Farbe haben wie die Felder auf denen sich der Läufer bewegt
  [20].
\item  Bonus für den Springer, wenn es sich um einen blockierte Stellung
  handelt. Für einen Springer handelt es sich um eine blockierte Stellung,
  wenn sich mehr als sechs Bauern im erweiterten Zentrum auf halten. Durch die
  Fortbewegungsweise des Springers wird er aufgewertet [20].
\item  Bonus für den Springer, wenn er mehr als sechs Felder erreichen kann [15].
\item  Bonus für das Pferd in einer geschlossenen Position [20].
\item  Bestrafung wenn auf jeder Seite des Pferdes ein generischer Bauer steht
  [25].
\item  Bonus für den Turm, falls er von dem anderen Turm gedeckt wird [15].
\item  Bonus für den Turm, wenn er auf eine halb offenen Linie steht [15].
\item  Bonus für den Turm, wenn er auf eine offenen Linie steht [15].
\item  Bonus für den Turm für andere Vorteile [10].
\item  Bestrafung für den König, wenn er die erste Reihe während des
        Eröffnungs- oder Mittelspiels verlässt [15].
\item  Bonus nachdem eine Rochade ausgeführt wurde [20].
\item  Bestrafung für die Rochade, wenn es eine Schwäche in der Bauernstruktur
        vor dem König gibt [15].
\item  Bestrafung wenn die Möglichkeit einer Rochade vergeben wurde [20].
\item  Zufallswert, der zum Wert der Stellung addiert oder subtrahiert wird [20].
\end{enumerate} 

%----------------------------------------------------------------------
\section{Funktionen GeneticChess}
%----------------------------------------------------------------------
\label{sec:FunktionenGeneticChess}




%----------------------------------------------------------------------
\subsection{Materialbewertungs Modul}
%----------------------------------------------------------------------
\label{sub:FunkGCMat}


\begin{description}
\item [getFigureValue] Die Funktion gibt den Wert einer abgefragten Figur zurück.
	Der Wert einer Figur wird mittels des Individuen ROMs bestimmt.

\item [getFigureValueAtPos] Die Funktion gibt den Wert einer Figur an einer Position
	des Brettes zurück. Steht auf dem Feld keine Figur, wird der Wert 0 zurück gegeben.

\item [getWhiteValue, getBlackValue] Die Funktion gibt den Materialwert aller weißen (schwarzen) Figuren zurück.

%\item [getBlackValue] Die Funktion gibt den Materialwert aller schwarzen Figuren zurück.

\item [getNumOfWhitePawns, -Knigths, -Bishops, -Rooks] Die Funktion gibt den Materialwert des weißen Bauern (Pferdes, Läufers, Turmes) zurück,
	wie sie durch das Individuen ROM definiert wird.

%\item [getNumOfWhiteKnigths] Die Funktion gibt den Materialwert des weißen Pferdes zurück,
%	wie sie durch das Individuen ROM definiert wird.

%\item [getNumOfWhiteBishops] Die Funktion gibt den Materialwert des weißen Läufers zurück,
%	wie sie durch das Individuen ROM definiert wird.

%\item [getNumOfWhiteRooks] Die Funktion gibt den Materialwert des weißen Turmes zurück,
%	wie sie durch das Individuen ROM definiert wird.

\item [getNumOfBlackPawns, -Knigths, -Bishops, -Rooks] Die Funktion gibt den Materialwert des schwarzen Bauern (Pferdes, Läufers, Turmes) zurück,
	wie sie durch das Individuen ROM definiert wird.

%\item [getNumOfBlackKnigths] Die Funktion gibt den Materialwert des schwarzen Pferdes zurück,
%	wie sie durch das Individuen ROM definiert wird.

%\item [getNumOfBlackBishops] Die Funktion gibt den Materialwert des schwarzen Läufers zurück,
%	wie sie durch das Individuen ROM definiert wird.

%\item [getNumOfBlackRooks] Die Funktion gibt den Materialwert des schwarzen Turmes zurück,
%	wie sie durch das Individuen ROM definiert wird.

\item [numOfWhiteFiguresInBlackCenter] Die Funktion berechnet die Anzahl der weißen Figuren 
	im schwarzen Zentrum. Analog die Funktionen \textbf{numOfBlackFiguresInBlackCenter,
	numOfWhiteFiguresInWhiteCenter, numOfBlackFiguresInWhiteCenter}.

%\item [numOfBlackFiguresInBlackCenter] Die Funktion berechnet die Anzahl der schwarzen Figuren 
%	im schwarzen Zentrum.

%\item [numOfWhiteFiguresInWhiteCenter]Die Funktion berechnet die Anzahl der weißen Figuren 
%	im weißen Zentrum.

%\item [numOfBlackFiguresInWhiteCenter] Die Funktion berechnet die Anzahl der schwarzen Figuren 
%	im weißen Zentrum.

\item [advancedPawnValueWhite] Die Funktion berechnet den Bonus für den weißen Bauern, wenn er sich
	im erweiterten Zentrum aufhält. Analog die Funktionen \textbf{advancedKnightValueWhite, 
	advancedBishopValueWhite, advancedRookValueWhite, advancedPawnValueBlack, advancedKnightValueBlack, 
	advancedKnightValueBlack, advancedBishopValueBlack, advancedRookValueBlack}.

%\item [advancedKnightValueWhite] Die Funktion berechnet den Bonus für den weißen Springer, wenn er sich
%	im erweiterten Zentrum aufhält.

%\item [advancedBishopValueWhite] Die Funktion berechnet den Bonus für den weißen Läufer, wenn er sich
%	im erweiterten Zentrum aufhält.

%\item [advancedRookValueWhite] Die Funktion berechnet den Bonus für den weißen Turm, wenn er sich
%	im erweiterten Zentrum aufhält.

%\item [advancedPawnValueBlack] Die Funktion berechnet den Bonus für den schwarzen Bauern, wenn er sich
%	im erweiterten Zentrum aufhält.

%\item [advancedKnightValueBlack] Die Funktion berechnet den Bonus für den schwarzen Springer, wenn er sich
%	im erweiterten Zentrum aufhält.

%\item [advancedBishopValueBlack] Die Funktion berechnet den Bonus für den schwarzen Läufer, wenn er sich
%	im erweiterten Zentrum aufhält.

%\item [advancedRookValueBlack] Die Funktion berechnet den Bonus für den schwarzen Turm, wenn er sich
%	im erweiterten Zentrum aufhält.

\item [endgameIndex] Die Funktion bewertet, ob eine Stellung eine Endspielstellung ist. 
\end{description}



%----------------------------------------------------------------------
\subsection{Zugbewertungs Modul}
%----------------------------------------------------------------------

\label{sub:FunkGCZug}

\begin{description}

\item [numOfAttacksBefore] Die Anzahl der angegriffenen Figuren bevor der aktuelle 
	Zug ausgeführt wird. Dies wird von dem Spieler mit dem Zugrecht aus betrachtet.

\item [numOfDefensedBefore] Die Anzahl der gedeckten Figuren bevor der aktuelle Zug
	ausgeführt wird.

\item [attackDefenseDiffBefore] Die Differenz der angegriffenen Figuren und der
	gedeckten Figuren bevor der Zug ausgeführt wird.

\item [numOfAttacksAfter] Die Anzahl der angegriffenen Figuren nachdem der aktuelle 
	Zug ausgeführt wird.

\item [numOfDefensedAfter] Die Anzahl der gedeckten Figuren nachdem der aktuelle Zug
	ausgeführt wird.

\item [attackDefenseDiffAfter] Die Differenz der angegriffenen Figuren und der
	gedeckten Figuren nachdem der Zug ausgeführt wird.

\item [captureValueOfMove] Wert der Figur, die durch den Zug geschlagen würde. Wenn
	keine Figur geschlagen wird, gibt die Funktion den Wert Null zurück.

\item [captureFigureOfMove] Die Methode gibt die interne Zahl der Spielfigur zurück, 
		die durch den letzten Zug geschlagen wurde.

\item [looseValueOfMove] Die Methode berechnet den Wert der Figur die durch den
	letzten Zug geschlagen wurde.

\item [maxLooseValueAfterMove] Die Funktion berechnet den maximalen Materialverlust,
	der nach einem Zug auftreten kann.

\item [maxLooseValueBeforeMove] Die Funktion berechnet den maximalen Materialverlust,
	der durch einen Zug bei der aktuellen Stellung passieren kann.

\item [maxCaptureValueAfterMove] Die Funktion berechnet den maximalen Materialverlust,
	der nach einem Zug auftreten kann.

\item [maxCaptureValueBeforeMove] Die Funktion berechnet den maximalen Materialgewinn,
	der durch einen Zug bei der aktuellen Stellung passieren kann.

\item [numOfThreatsOfSide] Die Methode berechnet die Anzahl der Züge, die eine
	eigene Figur bedrochen.

\item [numOfCoverOfSide] Die Funktion zählt alle Deckungen für eigene Figuren.

\item [moveFigureValue] Die Methode gibt den Wert der Figur zurück, die greade am Zug ist.

\item [getValue] Die Methode gibt den Wert eines Knotens im Suchbaum zurück, der
	für diese Stellung berechnet wurde.

\item [getBoardValue] Der einfache Matrialwert der Stellung.

\end{description}



%----------------------------------------------------------------------
\subsection{Tiefen Modul}
%----------------------------------------------------------------------
\label{sub:FunkGCTief}


\begin{description}

\item [currentDepth] Die Funktion gibt die aktuelle Tiefe in der Rekursion an.

\item [maxDepth] Die Funktion gibt die maximale erlaubte Tiefe für die Rekursion an,
	die durch einen Parameter angegeben wird.

\item [numOfExpandedNodes] Die Methode zählt die Anzahl der expandierten Züge in der
	aktuellen Stellung.

\item [numOfUnexpandedNodes] Die Methode zählt noch nicht expandierten Züge der
	aktuellen Stellung.

\item [isInWindow] Die Funktion überprüft ob sich der Wert der Stellung in dem
	Alpha-Beta Fenster befindet oder nicht.

\item [moveRang] Die Funktion gibt den Rang des aktuellen Zuges in der Liste aller
	Züge nach der Sortierung an.

\item [boardValue] Die Funktion gibt einen den Wert der aktuellen Stellung an.

\item [moveValue] Die Funktion gibt die Wert des Zuges an.

\item [wasBeatMove] Test ob der aktuelle Zug ein Schlagzug ist.

\item [numOfKingMoves] Anzahl der Züge die ein König durchführen kann. Analog die Funktionen \textbf{numOfQueenMoves, numOfPawnMoves, numOfBishopMoves, numOfKnightMoves, numOfRookMoves}.

\item [bestMoveValue] Der Wert des besten Zuges. Analog die Funktionen \textbf{worstMoveValue, currentMoveValue}.

\item [numOfThreatsOfInd] Anzahl der Bedrohungen für das Individuum. Analog die Funktionen \textbf{numOfThreatsOfOppo, numOfCoversOfOppo}.

\item [ifCurrentDepthIsBigger] Test ob die aktuelle Tiefe größer ist als ein gegebener Wert. Analog die Funktion \textbf{ifCurrentDepthIsSmaller}.

\item [isBiggerThanAlpha] Test ob ein gegebener Wert größer ist als der Alphawert. Analog die Funktion \textbf{isSmallerThanBeta}.



\end{description}



%----------------------------------------------------------------------
\subsection{Entscheidungsfunktionen}
%----------------------------------------------------------------------
\label{sub:FunkEntscheidungs}
               
\begin{description}

\item [isOpenPhase] Es wird überprüft ob das Spiel noch in der Eröffnungsphase ist. Analog die Funktionen \textbf{isMiddlePhase, isEndPhase}.

\item [ifCurrentDepthIsBigger] Überprüft ob die aktuelle Tiefe im Suchbaum größer ist als die maximale
	Tiefe. Analog die Funktion \textbf{ifCurrentDepthIsSmaller}.

\item [isBiggerThanAlpha] Die Methode überprüft ob der aktuelle Wert der Stellung
	größer als der Alphawert ist. Analog die Funktion \textbf{isSmallerThanBeta}.

\item [isIndKingUnderAttack] Die Methode überprüft ob der König des Individuums
	von einer anderen Figur angegriffen wird. Analog die Funktionen \textbf{isIndQueenUnderAttack, isOppoKingUnderAttack, isOppoQueenUnderAttack}.

\item [isIndKingUnderCover] Die Methode überprüft ob der König des Individuums gedeckt ist.
	 Analog die Funktionen \textbf{isIndQueenUnderCover, isOppoKingUnderCover, isOppoQueenUnderCover}.


\end{description}


%----------------------------------------------------------------------
\subsection{Branchingfunktionen}
%----------------------------------------------------------------------
\label{sub:FunkBranching}
     

\begin{description}

\item [R0$<$ und R0$>$] Überprüft ob das Register Null größer oder kleiner einem Wert ist.
\item [ifIndOfQueens] Die Funktion überprüft ob in der Stellung des Individuums
	noch eine Königin vorhanden ist. Analog die Funktionen \textbf{ifIndTwoBishops, ifIndMoreKnights, ifIndMoreBishops}.
\item [ifOppoOfQueens] Die Funktion überprüft ob in der Stellung des Gegners
	noch eine Königin vorhanden ist. Analog die Funktionen \textbf{ifOppoTwoBishops, ifOppoTwoKnights}.
\item [currentDepthIsBigger] Überprüft ob die aktuelle Tiefe im Suchbaum größer ist als die maximale
	Tiefe. Analog die Funktion \textbf{currentDepthIsSmaller}.
\item [biggerThanAlpha] Die Methode überprüft ob der aktuelle Wert der Stellung
	größer als der Alphawert ist. Analog die Funktion \textbf{smallerThanBeta}.


\end{description}

\vfill
\pagebreak

\section*{Über den Autor}

Von 1992 bis 1998 Studium der Informatik mit Nebenfach Betriebswirtschaftslehre an der Universität 
Dortmund, Abschluss Diplom­Informatiker. Von 1998 bis 2003 wissenschaftlicher Mitarbeiter 
in der Arbeitsgruppe von Prof. Dr. Wolfgang Banzhaf am Lehrstuhl für Systemanalyse der Universität 
Dortmund. Seit 2002 Mitarbeiter und Gesellschafter der Firma Dortmund Intelligence Project GmbH. 
Schwerpunkte der wissenschaftlichen Arbeit liegen auf den Gebieten der Genetischen Programmierung.


\subsection*{Publikationen}

[2002b] R. Groß, K. Albrecht, W. Kantschik und W. Banzhaf,
\emph{Evolving Chess Playing Programs},
In: Proceedings of the Genetic and Evolutionary Computation Conference (GECCO 2002), p. 740-747, Morgan Kaufmann Publishers, San Francisco, CA 94104, USA , 2002.

Der Eigenanteil beträgt 30 \%, er umfasst das Schreiben des Papers, die Begleitung der Implementierung und die Durchführung der Tests.

[2002a] W. Kantschik und W. Banzhaf,
\emph{Linear-Graph GP - A new GP Structure},
In: Genetic Programming, Proceedings of EuroGP'2002,
James A. Foster, Evelyne Lutton, Julian Miller, Conor Ryan und Andrea G. B. Tettamanzi (eds.), LNCS 2278, p. 83-92, Springer-Verlag,
Berlin, 2001.

Der Eigenanteil beträgt 90 \%, er umfasst das Schreiben des Papers, die Implementierung des Systems und die Durchführung der Tests.

[2001] W. Kantschik und W. Banzhaf,
\emph{Linear-Tree GP and its comparison with other GP structures},
In Genetic Programming, Proceedings of EuroGP'2001,
J. F. Miller, M. Tomassini, P. Luca Lanzi, C. Ryan, A. G. B. Tettamanzi 
und  W. B. Langdon (eds.), LNCS 2038, p. 302-312, Springer-Verlag,
Berlin, 2001.

Der Eigenanteil beträgt 90 \%, er umfasst das Schreiben des Papers, die Implementierung des Systems und die Durchführung der Tests.

[2000] J. Busch, W. Kantschik, H. Aburaya, K. Albrecht, R. Groß, 
P. Gundlach, M. Kleefeld, A. Skusa, M. Villwock,T. Vogd und W. Banzhaf 
\emph{Evolution von GP-Agenten mit Schachwissen sowie deren 
Integration in ein Computerschachsystem}
SYS Report,  Nummer SYS-01/00, ISSN 0941-4568, 308 Seiten,
Univ. Dortmund, Informatik.

Der Eigenanteil beträgt 15 \%, er umfasst die Koordination der PG, Korrekturlesen, Auswahl der Tests, Anpassung des SYSGP-Systems.


[1999c] P. Dittrich, A. Skusa, W. Kantschik, and W. Banzhaf  
\emph{Dynamical Properties of the Fitness Landscape of a GP Controlled Random Morphology Robot} 
In: Proceedings of the Genetic and Evolutionary Computation Conference (GECCO'99), vol. 2, p. 1002-1008, Morgan Kaufmann, San Francisco, CA, Orlando, Florida, July 13-17, 1999. 

Der Eigenanteil beträgt 15 \%, er umfasst die Anpassung des SYSGP-Systems für die Robotersteuerung.

[1999b] W. Kantschik, P. Dittrich, M. Brameier, and W. Banzhaf 
\emph{Empirical Analysis of Different Levels of Meta-Evolution} 
Congress on Evolutionary Computation (CEC99), July 6-9, 1999, Washington DC, USA, vol. 3, p.
2086-2093, IEEE, 1999. 

Der Eigenanteil beträgt 80 \%, er umfasst das Schreiben des Papers, die Implementierung des Systems und die Durchführung der Tests.


[1999a] W. Kantschik, P. Dittrich, M. Brameier, und W. Banzhaf 
\emph{Meta-Evolution in Graph GP} In: Genetic Programming, Second European Workshop (EuroGP'99), Proceedings, R. Poli, P. Nordin, W.B. Langdon, T.C. Fogarty (eds.), LNCS 1598, p. 15-28, Springer, Berlin, 1999 

Der Eigenanteil beträgt 80 \%, er umfasst das Schreiben des Papers, die Implementierung des Systems und die Durchführung der Tests.


[1998] M. Brameier, W. Kantschik, P. Dittrich, und W. Banzhaf 
\emph{SYSGP - A C ++ library of different GP variants} 
Series "Computational Intelligence", Internal Report of SFB 531, No. 48/98, ISSN 1433-3325, Univ. of Dortmund, D-44221 Dortmund, Germany, 1998.

Der Eigenanteil beträgt 50 \%, er umfasst die Implementierung des SYSGP-Systems und die Durchführung der Tests.



%%% Local Variables:
%%% mode: latex
%%% TeX-master: "mainChessDiss"
%%% End:
%
