\section{Introduction to the GA (genetic algorithm)}

The genetic algorithm can change different parameters of an agent.
The information of the agent (ANN and sensors) is encoded as a bitstring chromosome,
which is an object to be manipulated by us.\\

For each agent a fitness value is calculated after every
simulation-run, which indicates how successful the agent did his
work. Agents which have been very successful have the higher
possibilities to transmit their genotype to the next generation.
To accomplish this target we need a mating algorithm.
The mutation happens as a point mutation or cross-over mutation.\\

{\bf Point mutation}\\
The user enters the probability of point mutation to select a
random bit in the bitstring to alter.\\

{\bf Cross-over mutation}\\
Two bitstrings are exchanged at randomly chosen positions and two
new agents
are generated.\\

A new generation of agents is created. And the quality of these
agents is probably better than the predecessors.

%-------------------------------------------------------------------------------------------

\newpage
\section{Use Case diagram}

\begin{figure}[h]
\centerline{\epsfxsize=10cm
\epsfbox{\GA/Pics/usecase1.eps}}
\caption{GA: use case initialization}
\end{figure}

The figure shows the initialization of our \verb+CGAL_MAN+. This can be caused by two ways.
The first way is to construct a random generation. The second one to load a
saved generation.
 More you can read in section~\ref{seqdiag}.

\begin{figure}[h]
\centerline{\epsfxsize=10cm
\epsfbox{\GA/Pics/usecase2.eps}}
\caption{GA: use case evolve}
\end{figure}

In the case of evolution there are two procedures of major importance:
\verb+putFitnessTable+ and \verb+doGAall+. They are called by
turns. The first one determines how successful an agent was and
the second one introduces the evolution step.

%-------------------------------------------------------------------------------------------

\section{Interfaces to other Groups}

\subsection{Our interface to the other packages}

Because of the reflection on the last discussions you can see our interface diagram.

\begin{figure}[h]
\centerline{\epsfxsize=17cm
\epsfbox{\GA/Pics/Klassendiagramm.eps}}
\caption{GA: interface diagram}
\end{figure}

\begin{itemize}

\item The \verb+initgen0+-method creates a database of random agents. The parameters
maxHiddenNeurons, maxNumberofSensors, maxInterpolNodes have to be
available and it is not possible to change their values after the
construction of the generation null. The parameter
\verb+'+numberofAgents\verb+'+ also has to be available and it is not
possible
 for the user to change it, only the program itself through the
steady-state-system.

\item The method \verb+length+ returns the current size of the population.

\item The method \verb+getPhenotype+ returns the phenotype of an agent. The phenotype is handed over
by two CNV-lists. One includes information about the sensors and
the other about the ANN. One function of the managers is
responsible for this hand over. They pass the ANN-CNV-list to the
ANN-group. The relevant data of the sensor group is processed in a
similar way.

\item The method \verb+getPhenotypeAll+ returns the whole population.

\item The method \verb+putFitnessTable+ requires a CNV-list as an argument. The fitnessvalues
are defined in \ref{GALfit}.

\item The method \verb+doGAall+ starts the process of evolution and stores the new agents in
the same \verb+CGAL_MAN+-object.

\item The method \verb+saveState+ is needed to save the agents in an XML-file.
The filename is passed as a parameter.

\item The method \verb+loadState+ is called with the filename as a parameter and reads
the whole population from an XML-file. As a consequence the four
parameters maxHiddenNeurons, maxNumberofSensors, maxInterpolNodes,
numberofAgents are defined through this file. It is not possible
for the user to change this parameters. This method is called as
an alternative to the method \verb+initgen0+.

\end{itemize}

\subsection{Phenotype-hand over (ANN and Sensors)}

The hand over is realized with CNV-lists. We need two CNV-lists. One for the information
about the ANN, which is built like it is described in \verb+'+NVPairs needed
to create a net\verb+'+ with the following addition:\\

\texttt{
\begin{tabular}[t]{lcl}
\textbf{agentnumber (INT)} & :: & indicates our number of the agent\\
\end{tabular}
}\\

For the sensor-group the list is realized as follows:\\

\texttt{
\begin{tabular}[t]{lcl}
\textbf{sen[n]range[m] (DOUBLE)} & :: & indicates the range of the sensor [n]\\
                       &         & of the agent [m]; range (0..255.9921875)\\
\textbf{sen[n]angle[m] (INT)} & :: & indicates the angle of the sensor [n]\\
                       &         & of the agent [m]; range (0..255)\\
\textbf{sen[n]type[m] (INT)} & :: & indicates the typ of the sensor [n]\\
                      & :: & of the agent [m]; range (0..3)\\
\textbf{ann[m] (INT)} & :: & indicates the netnumber, provided by the ANNs,\\
                      &  & of the agent [m]\\
\end{tabular}
}\\
\\

Where {[n]} indicates the number of the sensors and is within the
range from 0 to the value of the parameter maxNumberofSensors. Is
the sensor inactive the range-value 0.0 is handed over and the
type ''value'' is verified with the value the sensor has if it is
active.

%-------------------------------------------------------------------------------------------

\subsection{Statistics-hand over (Manager and Statistics)}
\label{interface-statistic}

The statistics are read with getStatistics(). This function returns a CNV-list, which
is manufactured by the Statistic-group. The most interesting and reprocessing values are
the fitnessvalues of the agents, that we calculate and we need for the selection.
This values are handed over in the following way:\\

\texttt{
\begin{tabular}[t]{lcl}
\textbf{fitness:[r]:[m]:0 (DOUBLE)} & :: & indicates the fitnessvalue from the agent[m]\\
                       &  & from the generation[r]\\
\end{tabular}
}\\
\\

The value [r] starts with zero and is increased by one if there
are new data of statistics, i.~e. at every call of
putFitnessTable. The value [m] indicates the number of the agent.
The list will be deleted after every getStatistics call.

%-------------------------------------------------------------------------------------------

\subsection{Fitnessfunction-hand over (Statistics and Manager)}
\label{GALfit}

For every fitnesscriterion, for example number of places visited,
numer of collisions, ..., there is introduced a weight. It is
possible to introduce lots of fitnesscriterions. If the weight
is missing it will be set with the value 0.0.\\

\texttt{
\begin{tabular}[t]{lcl}
\textbf{weight[i] (DOUBLE)}  & :: & indicates the valence for the\\
                  &          & criterion[i]\\
\textbf{agent[n]value[i] (DOUBLE)} & :: & indicates for agent[n]\\
                  &         & the value of the criterion[i]\\
\end{tabular}
}\\
\\

The definitive fitnessvalue we use for the selection is calculated in the following way:\\
Let $I$ be the maximum number of criterions, then
\[ fit_{n} = \sum^{I}_{i=0} w_i \cdot v_{n,i} \]
in which $fit_n$ indicates the fitnessvalue of an agent $n$, $w_i$ indicates the weight of the criterion $i$
and $v_{n,i}$ indicates the value for the agent $n$ and the criterion $i$.

%-------------------------------------------------------------------------------------------

\section{Parameters}

\begin{itemize}

\item GALmaxHiddenNeurons:

\begin{itemize}
\item Type: integer
\item Description: maximum number of hidden neurons
\item Range: minimum: 2, maximum: 100 (limitation through the performance of
the computer)
 \item Standardvalue: 5
\item Remark: After the initialization of the population this parameter must not
change. In case of loading a population this value is determined
by the XML-file.
\end{itemize}

\item GALmaxNumberofSensors:

\begin{itemize}
\item Type: integer
\item Description: maximum number of sensors for one agent
\item Range: minimum: 1, maximum: 360
\item Standardvalue: 8
\item Remark: After the initialization of the population this parameter must not
change. When a population is loaded this value is determined by
the XML-file.
\end{itemize}


\item GALmaxInterpolNodes:

\begin{itemize}
\item Type: integer
\item Description: maximum number of interpolation nodes for the transferfunction
\item Range: minimum: 3, maximum: 100
\item Standardvalue: 8
\item Remark: After the initialization of the population this parameter must not
change. When a population is loaded this value is determined by
the XML-file.
\end{itemize}

\item MANnumberofAgents:

\begin{itemize}
\item Type: integer
\item Description: number of agents of the generation 0
\item Range: minimum: 2, maximum: 100 (limitation through the performance of
the computer)
 \item Remark: At the load of a population this value is give
from the XML-file.
 The parameter is changeable during a simulation.
\end{itemize}

\item GALcrossoverPoints:

\begin{itemize}
\item Type: integer
\item Description: number of intersections at the cross-over mutation
\item Range: minimum: 1, maximum: 2
\item Standardvalue: 1
\item Remark: This parameter can change at any time.
\end{itemize}

\item GALmutationRate:

\begin{itemize}
\item Type: double
\item Description: probability of point mutation
\item Range: minimum: 0.0, maximum: $<$ 0.5
\item Standardvalue: 0.0
\item Remark: This parameter can change at any time.
\end{itemize}

\item GALcrossoverRate:

\begin{itemize}
\item Type: double
\item Description: probability of cross-over mutation
\item range: minimum: 0.0, maximum: $<$ 0.5
\item Standardvalue: 0.0
\item Remark: This parameter can change at any time.
\end{itemize}

\end{itemize}

Additional remark: If parameters are not available their standardvalues are used.

%-------------------------------------------------------------------------------------------
\newpage
\section{Class diagram}

Because of the reflection on the last discussions these are our class
diagrams.
 Details about the classes itself you will find in the JavaDoc
files.
 
Remark: These are simplified diagrams of our classes.

\begin{figure}[ht!]
\centerline{%\epsfxsize=17cm
\epsfbox{\GA/Pics/CGAL_MAN.eps}}
\caption{GA: class diagram CGAL\_MAN}
\end{figure}

\begin{figure}[ht!]
\centerline{%\epsfxsize=17cm
\epsfbox{\GA/Pics/IGAL_MAN.eps}}
\caption{GA: class diagram IGAL\_MAN}
\end{figure}

\begin{figure}[ht!]
\centerline{%\epsfxsize=17cm
\epsfbox{\GA/Pics/CGALparamhandler.eps}}
\caption{GA: class diagram CGALparamhandler}
\end{figure}

\begin{figure}[ht!]
\centerline{%\epsfxsize=17cm
\epsfbox{\GA/Pics/CGALagentGen.eps}}
\caption{GA: class diagram CGALagentGen}
\end{figure}

\begin{figure}[ht!]
\centerline{%\epsfxsize=17cm
\epsfbox{\GA/Pics/CGALgenotype.eps}}
\caption{GA: class diagram CGALgenotype}
\end{figure}

\begin{figure}[ht!]
\centerline{%\epsfxsize=17cm
\epsfbox{\GA/Pics/CGALInitGen0.eps}}
\caption{GA: class diagram CGALInitGen0}
\end{figure}

\begin{figure}[ht!]
\centerline{%\epsfxsize=17cm
\epsfbox{\GA/Pics/CGALGeneration0Phenotype.eps}}
\caption{GA: class diagram CGALGeneration0Phenotype}
\end{figure}

\begin{figure}[ht!]
\centerline{%\epsfxsize=17cm
\epsfbox{\GA/Pics/CGALDoGA.eps}}
\caption{GA: class diagram CGALDoGA}
\end{figure}

\begin{figure}[ht!]
\centerline{%\epsfxsize=17cm
\epsfbox{\GA/Pics/CGALdoGAPhenotype.eps}}
\caption{GA: class diagram CGALdoGAPhenotype}
\end{figure}

\begin{figure}[ht!]
\centerline{%\epsfxsize=17cm
\epsfbox{\GA/Pics/CGALconvert.eps}}
\caption{GA: class diagram CGALconvert}
\end{figure}

\begin{figure}[ht!]
\centerline{%\epsfxsize=17cm
\epsfbox{\GA/Pics/CGALSaveXml.eps}}
\caption{GA: class diagram CGALSaveXml}
\end{figure}

\begin{figure}[ht!]
\centerline{%\epsfxsize=17cm
\epsfbox{\GA/Pics/CGALLoadXml.eps}}
\caption{GA: class diagram CGALLoadXml}
\end{figure}

\begin{figure}[ht!]
\centerline{%\epsfxsize=17cm
\epsfbox{\GA/Pics/CGALbeanwind.eps}}
\caption{GA: class diagram CGALbeanwind}
\end{figure}

\begin{figure}[ht!]
\centerline{%\epsfxsize=17cm
\epsfbox{\GA/Pics/CGAL_Bean.eps}}
\caption{GA: class diagram CGAL\_Bean}
\end{figure}

\begin{figure}[ht!]
\centerline{%\epsfxsize=17cm
\epsfbox{\GA/Pics/CGALshowMut.eps}}
\caption{GA: class diagram CGALshowMut}
\end{figure}

%-------------------------------------------------------------------------------------------
\clearpage
\section{Sequence diagram} \label{seqdiag}

\begin{figure}[h]
\centerline{\epsfxsize=13cm
\epsfbox{\GA/Pics/Sequenzdiagramm.eps}}
\caption{GA: sequence diagram (communication with other groups)}
\end{figure}

Our main class can be instantiated in two ways:
\begin{verbatim}    CGAL_MAN g = new CGAL_MAN(CMAN_Sim, CERR);\end{verbatim}
This constructor is used to initialize a population of randomly
generated agents,
\begin{verbatim}    CGAL_MAN g = new CGAL_MAN(CMAN_Sim, CERR, CNVList<"file">);\end{verbatim}
whereas this constructor creates a population out of a XML-file.
The phenotypes can be received by
\begin{verbatim}    g.getPheontypeAll();.\end{verbatim}
If one cycle of evolution has be done, we first have to get the
fitnessvalues of each agent with
\begin{verbatim}    g.putFitnessTable(CNVList);\end{verbatim}
and then we can start the selection and mutation by calling
\begin{verbatim}    g.doGAall();.\end{verbatim}
After this process the phenotypes can be picked out with
\begin{verbatim}    g.getPhenotypeAll();.\end{verbatim}
The accumulated statistics are possible to read back with
\begin{verbatim}    CNVList stat = g.getStatistics();.\end{verbatim}

%-------------------------------------------------------------------------------------------

\section{Packages}

\subsection{JDOM}

There is the possibility to save the whole population for a later
use. Therefore XML serves as file format.

We use the package JDOM\footnote{\texttt{http://www.jdom.org}} to
generate XML-files, save and read them with JAVA.

To start a simulation, which initializes the generation 0 by
reading the information of an agent from a XML-file, we also have
to save other information:

\begin{itemize}
 \item{maxHiddenNeurons}
 \item{maxNumberofSensors}
 \item{maxInterpolNodes}
\end{itemize}

When a population is loaded, these values are passed to the
parametermanager.

The XML-tree consists of two subtrees. One subtree includes the
additional information and the other one the information about the
agents, which is structered as follows:

Each agent again consists of a subtree and includes its three
chromosomes, furthermore three chromosomes representing the
changing since the last generation and its netnumber.

Because of this structure it is easy to calculate the number of
agents during the loading process. This value (numberofAgents) is
also forwarded to the parametermanager.

%-------------------------------------------------------------------------------------------

\subsection{JEvolution}

The package we use to mutate and select a generation -
JEvolution v0.4\footnote{Download under
\texttt{http://www.cosy.sbg.ac.at/$\sim$rschwaig/teaching/ppkt/ppkt2001/ppkt.html}}
- has been placed at DI Dr. Helmut A. Mayer's disposal.
Complementary to the documentation, which is enclosed in the
package, we want to explain some functions of the interface
genotype more detailed. Essentially there are defined three
functions, which include the problem-specific code. For each
creature an instance of a class is generated, which implements the
interface.

\begin {itemize}

\item doOntogeny(): This function should change the genotype to the phenotype. The genotype is
handed over as a vector of chromosomes (bitstrings). These could be for example integers, which
have been calculated from the genotype. These values can be saved in the object phenotype.

\item calcFitness(): In this function the fitness is calculated for a single creature.
This can happen in different ways.

\item getFitness(): The fitnessvalue of the mating-algorithm is tested.

\end{itemize}

This three functions are called in the following order:

\begin{tabbing}
aaa \= aaa \= \kill
\> doOntogeny() for creature $1$\\
\> calcFitness() for creature $1$\\
\> doOntogeny() for creature $2$\\
\> calcFitness() for creature $2$\\
\> \> ...\\
\> doOntogeny() for creature $n$\\
\> calcFitness() for creature $n$\\
\> getFitness() for all agents, as often as the value is needed\\
\end{tabbing}

%-------------------------------------------------------------------------------------------

\subsection{PGAL}

Our package implements the following classes:

\begin{itemize}
\item{\verb+CGAL_MAN:+} main class which contains the genotype manager
\item{\verb+CGALbeanwind:+} the JInternalFrame for the GUI
\item{\verb+CGAL_Bean:+} visualisation
\item{\verb+CGALgenotype:+} type for a chromosome
\item{\verb+CGALagentGen:+} typedefiniton for one agent (agent-ID, 3 chromosomes, number of the ANN, fitnessvalue)
\item{\verb+CGALconvert:+} function to convert the genotype to the phenotype
\item{\verb+CGALDoGA:+} set parameters and call JEvolution for one genetic step
\item{\verb+CGALdoGAPhenotype:+} the genotpye/phenotype mapper for JEvolution in the case of GA
\item{\verb+CGALInitGen0:+} to initialize the generation 0 with the JEvolution
\item{\verb+CGALGeneration0Phenotype:+} the genotype/phenotype mapper for JEvolution in the case of creating the generation 0
\item{\verb+CGALparamhandler:+} communication with the simulationmanager and definition of standardparameters
\item{\verb+CGALSaveXml:+} to save the actual generation to an XML file
\item{\verb+CGALLoadXml:+} to load a generation from an XML file
\end{itemize}

%-------------------------------------------------------------------------------------------

\section{Encoding of the agents}
\label{encoding-agents}

Each single agent is encoded with three chromosomes. These chromosomes include
the following information:

\begin{itemize}

\item First chromosome: MMM, biases and weights:

This encoding is the same as in the ELC-system. Only the ''stand still'' field
at the beginning of the chromosome has changed or is rather leaved out.

\begin {itemize}

\item MMM (Modified-Miller-Matrix): The MMM includes information about the
neuronmarkers and the connections. The neuronmarker indicates
which hidden neuron is active and which is not. The encoding
occurs along the main diagonal. If the value of MMM(i,i) equals
true, the hidden neuron is active. If the value MMM(i,i) is false
then it is not active. The rest of the MMM includes the
connections between the neurons. It is possible that a inactive
hidden neuron is connected but this fact is not relevant for us.
Only the connections below the main diagonal are interesting for
us. They are written bit by bit from the left to the right and
from the top to the bottom into the chromosomes.

\item Biases: Each neuron - except the input neurons - needs a biasvalue for the
internal function.
The biasvalue is a number between -128 and +127. These values are written as two bytes one
after the other for each neuron into the chromosome.

\item Weights: For each connection one value is saved into a chromosome. Using the same
method we used in the biases.

\end{itemize}

The number of the maximum hidden neurons is constant for one simulation. This results in a
constant length of the first chromosome.

\item Second chromosome: Transferfunction:

We need the transferfunction for the calculation of the activity
of the output neurons. Therefore we need the approximation of
interpolation nodes. The interpolation nodes are encoded and saved
one after the other as pairs of $x$ and $y$ values into two bytes.
To control the activity of the interpolation nodes we use
codemarkers. This is repeated for each neuron of the output and
hidden layer.

\begin{figure}[h]
\centerline{\epsfxsize=10.5cm
\epsfbox{\GA/Pics/Chrom2.eps}}
\caption{GA: scheme of the second chromosome}
\end{figure}

The length of the second chromosome is calculated in the following
way: Let $h$ be the maximum number of hidden neuron, then the
number of the bits for the CodeMarker is: $h+junk$ where $junk$ is
defined in the same way as in the ELC system:
\[ junk = \left\{ \begin{array}{ll}
                    (16-h~mod~16), & \mbox{if $h~mod~16 \neq 0$;}\\
                    0, & \mbox{otherwise.}
                 \end{array}
         \right. \]

Further we need for each $x,y$ pair four bytes which results in 32
bits: $32 \cdot h$. The memory space needed for one neuron is
therefore $32 \cdot h + h+junk$. Now let the number of the output
neurons be four, then the result for the total length of the
chromosome is: $(32 \cdot h + h+junk) \cdot (h+4)$

\item Third chromosome: Sensorinformations:

Each agent is equipped with a fixed, maximal number of sensors.
These sensors are either active or not. They are defined as a
SensorMarker and as a tuple $(r, \alpha, t)$. $r$ indicates the
range and $\alpha$ indicates the angle of spread. The type for the
value $r$ is double in the range of 0 to 255.9921875 and $\alpha$
is an integer between 0 and 255. The value $t$ indicates the type
of the sensor with a range from 0 to 3. $t$ is encoded with 8 bit
but only the first two are used. Therefore there is the
possibility to realize 256 different sensors.

\begin{figure}[h]
\centerline{\epsfxsize=8cm
\epsfbox{\GA/Pics/Chrom3.eps}}
\caption{GA: scheme of the third chromosome}
\end{figure}

The length of the third chromosome is calculated as follows: Let
$s$ be the maximum number of sensors for each agent, then the
number of bits for the SensorMarker is: $s+junk$ where $junk$ is
defined in the same way as in the ELC system:
\[ junk = \left\{ \begin{array}{ll}
                    (16-s~mod~16), & \mbox{if $s~mod~16 \neq 0$;}\\
                    0, & \mbox{otherwise.}
                 \end{array}
         \right. \]

Further we need for each tuple $(r, \alpha, t)$ 32 bit for saving
(16 bit for the double value, 8 bit for the integer values and 8
bit for the type value). This results in the total length of the
chromosome: $32 \cdot s + s + junk$

\end{itemize}

%-------------------------------------------------------------------------------------------

\section{Visualisation (Beans)}
\label{visualisation}

To give the user the most possible realistic view into the
mutation-process we tried to visualize the mutation happening to
an agent. Therefore we generated a JavaBean, which shows this
changing for every single bit of the agents chromosomes. If a bit
gets changed the bean shows this by highlighting the accurate part
of the chromosome. To help the user to get his bearings, we also
implemented three overview-chromosomes, which show the different
parts of the particular chromosome. (1st: Modified-Miller-Matrix,
biases, weights; 2nd: spline, spline, ...; 3rd:
sensor-marker,sensor, sensor, ...). These parts get highlighted
too, if any changes happen within them.

\begin{figure}[!hhht]
\centerline{\epsfxsize=10cm \epsfbox{\GA/Pics/bean1.eps}}
\caption{GA: bean} This figure shows the mutation for the
following values: GALmaxHiddenNeurons: 3, GALmaxNumberofSensors:
15, GALmaxInterpolNodes: 3, GALmutationRate: 0.01,
GALcrossoverRate: 0.8, GALcrossoverPoints: 2;
\end{figure}

\newpage
%-------------------------------------------------------------------------------------------

\section{Protocols}

\subsection{Summary of the protocols before 1st of June 2001}

We think it is not useful to translate the old protocols from
german to english. We give only a short general view what we have
done. The works we have done every week
you can see on the homework sheets. \\

On the 6th of april we talked the first time about our GAL\_Manager
as some kind of database and as an interface to the
SIM\_Manager. \\

On the 11th of april Andreas Naderlinger and Paul Haller had an appointment
with Mag.~DI
 Roland Schwaiger. There were questions about the structure of
the ANN, the encoding of the
 sensors, about the transferfunction, the package
JEvolution and about XML and Java.
 The result of this conversation you can
see in the chapter~\ref{encoding-agents}.
 
\subsection{2001/06/01}

\begin{itemize}
\item Persons: members of the single groups and the supervisor Mag. DI Roland Schwaiger
\item Topics:
\begin{itemize}
\item Paper: We get new instructions about the structure of the paper.
\item Beans: We talk about the visualisation.
\item Question: Should we show only one agent or the whole population?
\item Statistics: In our presentation we give an overview about the statistic interface
(details see~\ref{interface-statistic}).
\end{itemize}
\end{itemize}

On the 6th of may all members of our group discuss with Mag. DI
Roland Schwaiger about the realization of the Java-Bean. We had
made thoughts about this and we also found solutions but due to
the fact that the strings to display are such long we want to
speak with the supervisor. The results of this
discussion you can see in the chapter~\ref{visualisation}.\\

\subsection{2001/06/08}

\begin{itemize}
\item Persons: members of the single groups and the supervisor Mag. DI Roland Schwaiger
\item Topics:
\begin{itemize}
\item JEvolution: We have to alter the maximum values of the mutationrate and the crossoverrate.
\item Appointments: We get the dates and the duties to do for the next weeks (see homework sheet 6)
\item Save: Interface of the managers to saveState and loadState.
\item Documentation: We have to extend the documentation and to submit it.
\item Statistic: We discuss about the save of the statistics (generations and
timestamps). More
 you can see in the chapter of the statistic-group.
\end{itemize}
\end{itemize}

\subsection{2001/06/15}

\begin{itemize}
\item Persons: members of the single groups and the supervisor Mag. DI Roland Schwaiger
\item Topics:
\begin{itemize}
\item There was the first run of the ELC but only in batch modus, because the GUI has to alter
its surface. That will be finished until next friday.
\item Bean: We have to alter our bean that it can be integrated in the surface of the GUI.
The selection, which agent has to be showed, has to be implemented
in two different ways: First there must be a \verb+'+Combo-Box\verb+'+ 
in our frame to make this selection, and second we have
to offer a methode (\textit{setAgentID}), so that a global
agent-specific graphical representation (controlled by the
world-bean) is possible. So the user has the possibility to
overview all the information for one agent very easily (e.g. ANN,
chromosomes, sensors).
\end{itemize}
\end{itemize}

\subsection{2001/06/29}

\begin{itemize}
\item Persons: members of the single groups and the supervisor Mag. DI Roland Schwaiger
\item Topics:
\begin{itemize}
\item The second run of the ELC was in connection with the GUI. There were still a few problems, but on
next Friday we hope they are eliminated.
\item Until to next Friday we have to implement an error class.
\item On the 6th of July there is the end presentation of the project.
The duties we have to do you can see on homework sheet 7.
\end{itemize}
\end{itemize}

%-------------------------------------------------------------------------------------------
