Commit 6afc42bb authored by Joseph Pallamidessi's avatar Joseph Pallamidessi

The easea user and developer manual; currently WIP

parent 35b0aa2b
\documentclass{article}
\documentclass{book}
\usepackage{array}
\usepackage[francais]{babel}
\usepackage[utf8]{inputenc}
......@@ -10,32 +10,41 @@
\maketitle
\setcounter{tocdepth}{3}
\tableofcontents
\section{This manual} % (fold)
\label{sec:introduction}
\paragraph{} % (fold)
\label{par:}
This document is intended to programimer working on the EASEA platform and to
This document is intended to programmer working on the EASEA platform and to
everyone working with it. It contain the language and idioms description, the
concept behind it and the documentation related to the compiler and its genetic
algorithm library.
% paragraph (end)
% section introduction (end)
\chapter{About EASEA}
\section{Introduction} % (fold)
\label{sec:Introduction}
\paragraph{} % (fold)
\label{par:}
EASEA and EASEA-CLOUD are Free Open Source Software (under GNU Affero v3 General Public License) developed by the SONIC (Stochastic Optimisation and Nature Inspired Computing) group of the BFO team at Université de Strasbourg. Through the Strasbourg Complex Systems Digital Campus, the platforms are shared with the UNESCO CS-DC UniTwin and E-laboratory on Complex Computational Ecosystems (ECCE).
% paragraph (end)
\paragraph{} % (fold)
\label{par:}
EASEA (EAsy Specification of Evolutionary Algorithms) is an Artificial Evolution
platform that allows scientists with only basic skills in computer science to
implement evolutionary algorithms and to exploit the massive parallelism of
many-core architectures in order to optimize virtually any real-world problems
(continous, discrete, combinatorial, mixed and more (with Genetic Programming)),
typically allowing for speedups up to x500 on a \$3,000 machine, depending on the complexity of the evaluation function of the inverse problem to be solved.
% paragraph (end)
\paragraph{} % (fold)
\label{par:}
Then, for very large problems, EASEA can also exploit computational ecosystems as it can parallelize (using an embedded island model) over loosely coupled heterogenous machines (Windows, Linux or Macintosh, with or without GPGPU cards, provided that they have internet access) a grid of computers or a Cloud.
% paragraph (end)
% section Introduction (end)
......@@ -52,9 +61,11 @@ Then, for very large problems, EASEA can also exploit computational ecosystems a
Distribution can be done locally on the same machine or over the internet (using a embedded island model).
Parallelization over GPGPU cards leading to massive speedup (x100 to x1000).
C++-like description language.
\\
EASEA use CUDA to parallelize over GPGPU card. There is, as absurd as it sound, no
parallelization over CPU at the time of redaction, but a working openMP prototype
enters its final testing phase.
\\
EASEA offer a high level of parametrization and the possibility to include large
chunk of C/C++ code with little to no change at all.
% paragraph (end)
......@@ -67,12 +78,12 @@ Then, for very large problems, EASEA can also exploit computational ecosystems a
Genetic programming
CMA-ES (Covariance Matrix Adaptation Evolution Strategy)
Memetic approach
\\
EASEA also offer out-of-the-box a wide range of selector: Max/Min deterministic,
Max/Min Random, Max/Min tournament and MaxRoulette.
Three stopping criterion are possible : by generation, by time and by user
defined control.
\\
The main advantage of EASEA
% paragraph (end)
% subsection current genetic algorithm implementation (end)
......@@ -82,1084 +93,1030 @@ Then, for very large problems, EASEA can also exploit computational ecosystems a
\section{Support} % (fold)
\label{sec:Support}
In order to have a working grapher, java jre 1.6 is required. Without it, an error appears at the start of easea's compiled programs but can be safely ignored.
\\
EASEA had been compiled and tested with those following compilers:
Gcc 4.4 to 4.8.2
Clang 3.0 to 3.3
Mingw-gcc 4.8.2
CUDA SDK > 4.1
\begin{itemize}
\item Gcc 4.4 to 4.8.2
\item Clang 3.0 to 3.3
\item Mingw-gcc 4.8.2
\item CUDA SDK > 4.1
\end{itemize}
% section Support (end)
\section{Workflow} % (fold)
\label{sec:Workflow}
easea compiler [GP,CUDA,CUDA_GP, etc ...]-> geneticAlgo.ez -> make -> geneticAlgo
\paragraph{} % (fold)
\label{par:}
easea compiler \[GP,CUDA,CUDA_GP, etc ...\]-> geneticAlgo.ez -> make -> geneticAlgo
(executable)
% paragraph (end)
% section Workflow (end)
\section{The language} % (fold)
\chapter{The language} % (fold)
\label{sec:the language}
\subsection{EASEA defined sections} % (fold)
\section{EASEA defined sections} % (fold)
\label{sub:EASEA defined sections}
Genome specific fields
Genome Initialiser
Description
\subsection{Genome specific fields}\label{genome-specific-fields}
Uses the Genome EASEA variable to access the individual's genome.
EASEA syntax
\subsubsection{Genome Initialiser}\label{genome-initialiser}
\GenomeClass::initialiser :
...
\end
\paragraph{Description}\label{description}
~\\
Uses the Genome EASEA variable
to access the individual's genome.
Example
\paragraph{EASEA syntax}\label{easea-syntax}
~\\
\GenomeClass::initialiser :
for(int i=0; i<SIZE; i++ ) {
Genome.x[i] = (float)random(X_MIN,X_MAX);
Genome.sigma[i]=(float)random(0.,0.5);
}
\end
\texttt{\textbackslash{}GenomeClass::initialiser~:}\\\texttt{~~~~~...}\\\texttt{\textbackslash{}end}
Genome Crossover
Description
\paragraph{Example}\label{example}
~\\
Binary crossover that results in the production of a single child.
\texttt{\textbackslash{}GenomeClass::initialiser~:}\\\texttt{~~for(int~i=0;~i}\texttt{(y)?(x):(y))~~~~~//Definition~of~the~MAX~global~function}\\\texttt{~~\#define~MIN(x,y)~((x)\textless{}(y)?(x):(y))~~~~~~//Definition~of~the~MIN~global~function}\\\texttt{~~\#define~PI~3.141592654~~~~~~~~~~~~~~~~~//Definition~of~the~PI~global~variable}\\\texttt{\textbackslash{}end}
The child is initialized by cloning the first parent.
\subsubsection{User functions}\label{user-functions}
Uses parent1 and parent 2 EASEA variables to access the parents genome.
\paragraph{Description}\label{description-1}
~\\
Uses the child EASEA variable to access the child's genome.
EASEA syntax
This is the section where the user can declare the different functions
he will need.
\GenomeClass::crossover :
...
\end
\paragraph{EASEA syntax}\label{easea-syntax-1}
~\\
Example
\texttt{\textbackslash{}User~declarations~:}\\\texttt{~~~~~...}\\\texttt{\textbackslash{}end}
\GenomeClass::crossover :
for (int i=0; i<SIZE; i++)
{
float alpha = (float)random(0.,1.); // barycentric crossover
child.x[i] = alpha*parent1.x[i] + (1.-alpha)*parent2.x[i];
}
\end
\paragraph{Example}\label{example-1}
~\\
Genome mutator
Description
\texttt{\textbackslash{}User~declarations~:}\\\texttt{~~float~gauss()}\\\texttt{~~/*~Generates~a~normally~distributed~random~value~with~variance~1~and~0~mean.}\\\texttt{~~~~~~Algorithm~based~on~}``\texttt{gasdev}''\texttt{~from~Numerical~recipes'~pg.~203.~*/}\\\texttt{~~\{}\\\texttt{~~~~int~iset~=~0;}\\\texttt{~~~~float~gset~=~0.0;}\\\texttt{~~~~float~v1~=~0.0,~v2~=~0.0,~r~=~0.0;}\\\texttt{~~~~float~factor~=~0.0;}\\\texttt{~~~~if~(iset)~\{}\\\texttt{~~~~~~iset~=~0;}\\\texttt{~~~~~~return~gset;}\\\texttt{~~~~\}}\\\texttt{~~~~else~\{~~~~}\\\texttt{~~~~~~do~\{}\\\texttt{~~~~~~~~~v1~=~(float)random(0.,1.)~*~2.0~-~1.0;}\\\texttt{~~~~~~~~~v2~=~(float)random(0.,1.)~*~2.0~-~1.0;}\\\texttt{~~~~~~~~~r~=~v1~*~v1~+~v2~*~v2;}\\\texttt{~~~~~~\}~}\\\texttt{~~~~~~while~(r~\textgreater{}~1.0);}\\\texttt{~~~~~~factor~=~sqrt~(-2.0~*~log~(r)~/~r);}\\\texttt{~~~~~~gset~=~v1~*~factor;}\\\texttt{~~~~~~iset~=~1;}\\\texttt{~~~~~~return~(v2~*~factor);}\\\texttt{~~~~\}}\\\texttt{~~\}}\\\texttt{\textbackslash{}end}
Must return the number of mutations.
\subsubsection{User Classes}\label{user-classes}
Uses the Genome variable to access the individual's genome.
EASEA syntax
\paragraph{Description}\label{description-2}
~\\
\GenomeClass::mutator :
...
\end
This is the section where the user will be able to declare:
Example
\begin{enumerate}
\itemsep1pt\parskip0pt\parsep0pt
\item
The genome of the individuals trough the GenomeClass class
\item
Different classes that will be needed.
\end{enumerate}
\GenomeClass::mutator : // Must return the number of mutations
int NbMut=0;
float pond = (float)random(0.,1.);
for (int i=0; i<SIZE; i++) {
if (tossCoin(pMutPerGene)){
NbMut++;
Genome[i] += pond;
}
}
return NbMut;
\end
Genome Evaluator
The evaluation function is expected to be autonomous and independent from the rest of the code, for correct parallelization.
Description
Must return the fitness of the individual.
The GenomeClass field has to be present and ideally not empty. All the
variables defined in this field (the genome) will be accessible in
several other fields using the 'Genome' variable. Other ``hidden''
variables can be accessed such as:
Uses the Genome defined variable to access the individual's genome.
EASEA syntax
\begin{enumerate}
\item
\begin{enumerate}
\itemsep1pt\parskip0pt\parsep0pt
\item
The fitness (variable: fitness. Ex: Genome.fitness)
\end{enumerate}
\end{enumerate}
\GenomeClass::evaluator :
...
\end
\paragraph{EASEA syntax}\label{easea-syntax-2}
~\\
Example
\texttt{\textbackslash{}User~Class~:}\\\texttt{~~~~~...}\\\texttt{~~GenomeClass\{}\\\texttt{~~~~~...}\\\texttt{~~\}}\\\texttt{\textbackslash{}end}
\GenomeClass::evaluator :
float Score= 0.0;
Score= Weierstrass(Genome.x, SIZE);
return Score;
\end
\paragraph{Example}\label{example-2}
~\\
Genome Display
Description
\texttt{\textbackslash{}User~classes:}\\\texttt{~~Element~~~~~\{~}\\\texttt{~~~~int~~~~~Value;}\\\texttt{~~~~Element~*pNext;~\}}\\\texttt{~~GenomeClass~\{~}\\\texttt{~~~~Element~*pList;~}\\\texttt{~~~~int~~~~~Size;~~~\}}\\\texttt{\textbackslash{}end}
Uses the Genome variable to access the individual's genome.
EASEA syntax
\subsubsection{User Makefile}\label{user-makefile}
\GenomeClass::display :
...
\end
\paragraph{Description}\label{description-3}
~\\
Example
This section allows the user to add some flags to the compiler typically
to include some custom libraries.
\GenomeClass::display :
for( size_t i=0 ; i<SIZE ; i++){
cout << Genome.x[i] << ":" << "|";
}
cout << Genome.fitness <<< "\n";
\end
Two flags of the Makefile are accessible to the user in this section:
\begin{enumerate}
\itemsep1pt\parskip0pt\parsep0pt
\item
CPPFLAGS
\item
LDFLAGS
\end{enumerate}
\paragraph{EASEA syntax}\label{easea-syntax-3}
~\\
User definition fields
User Declarations
Description
This is the section where the user can declare some global variables and some global function.
EASEA syntax
\User declarations :
...
\end
Example
\User declarations :
#define SIZE 100 //Problem size
#define Abs(x) ((x) < 0 ? -(x) : (x)) //Definition of the Abs global function
#define MAX(x,y) ((x)>(y)?(x):(y)) //Definition of the MAX global function
#define MIN(x,y) ((x)<(y)?(x):(y)) //Definition of the MIN global function
#define PI 3.141592654 //Definition of the PI global variable
\end
User functions
Description
This is the section where the user can declare the different functions he will need.
EASEA syntax
\User declarations :
...
\end
Example
\User declarations :
float gauss()
/* Generates a normally distributed random value with variance 1 and 0 mean.
Algorithm based on "gasdev" from Numerical recipes' pg. 203. */
{
int iset = 0;
float gset = 0.0;
float v1 = 0.0, v2 = 0.0, r = 0.0;
float factor = 0.0;
if (iset) {
iset = 0;
return gset;
}
else {
do {
v1 = (float)random(0.,1.) * 2.0 - 1.0;
v2 = (float)random(0.,1.) * 2.0 - 1.0;
r = v1 * v1 + v2 * v2;
}
while (r > 1.0);
factor = sqrt (-2.0 * log (r) / r);
gset = v1 * factor;
iset = 1;
return (v2 * factor);
}
}
\end
User Classes
Description
\texttt{\textbackslash{}User~Makefile~options~:}\\\texttt{~~~~~...}\\\texttt{\textbackslash{}end}
This is the section where the user will be able to declare:
\paragraph{Example}\label{example-3}
~\\
The genome of the individuals trough the GenomeClass class
Different classes that will be needed.
\texttt{\textbackslash{}User~Makefile~options~:}\\\texttt{~~CPPLAGS~+=~-llibrary}\\\texttt{~~LDFLAGS~+=~-I/path/to/include}\\\texttt{\textbackslash{}end}
The GenomeClass field has to be present and ideally not empty. All the variables defined in this field (the genome) will be accessible in several other fields using the 'Genome' variable. Other "hidden" variables can be accessed such as:
\subsection{Miscellaneous fields}\label{miscellaneous-fields}
The fitness (variable: fitness. Ex: Genome.fitness)
\subsubsection{Before everything else
function}\label{before-everything-else-function}
EASEA syntax
\paragraph{Description}\label{description-4}
~\\
\User Class :
...
GenomeClass{
...
}
\end
This function will be called at the start of the algorithm before the
parent initialization.
Example
\paragraph{EASEA syntax}\label{easea-syntax-4}
~\\
\User classes:
Element {
int Value;
Element *pNext; }
GenomeClass {
Element *pList;
int Size; }
\end
\texttt{\textbackslash{}Before~everything~else~function~:}\\\texttt{~~~~~...}\\\texttt{\textbackslash{}end}
User Makefile
Description
\subsubsection{After everything else
function}\label{after-everything-else-function}
This section allows the user to add some flags to the compiler typically to include some custom libraries.
\paragraph{Description}\label{description-5}
~\\
Two flags of the Makefile are accessible to the user in this section:
This function will be called once the last generation has finished.
CPPFLAGS
LDFLAGS
The population can be accessed.
EASEA syntax
\paragraph{EASEA syntax}\label{easea-syntax-5}
~\\
\User Makefile options :
...
\end
\texttt{\textbackslash{}After~everything~else~function~:}\\\texttt{~~~~~...}\\\texttt{\textbackslash{}end}
Example
\subsubsection{At the beginning of each generation
function}\label{at-the-beginning-of-each-generation-function}
\User Makefile options :
CPPLAGS += -llibrary
LDFLAGS += -I/path/to/include
\end
\paragraph{Description}\label{description-6}
~\\
This function will be called every generation before the reproduction
phase.
The population can be accessed.
\paragraph{EASEA syntax}\label{easea-syntax-6}
~\\
\texttt{\textbackslash{}At~the~~beginning~of~each~generation~function~:}\\\texttt{~~~~~...}\\\texttt{\textbackslash{}end}
Miscellaneous fields
Before everything else function
Description
\subsubsection{At the end of each generation
function}\label{at-the-end-of-each-generation-function}
This function will be called at the start of the algorithm before the parent initialization.
EASEA syntax
\paragraph{Description}\label{description-7}
~\\
\Before everything else function :
...
\end
This function will be called at every generation after the printing of
generation statistics.
After everything else function
Description
The population can be accessed.
This function will be called once the last generation has finished.
\paragraph{EASEA syntax}\label{easea-syntax-7}
~\\
The population can be accessed.
EASEA syntax
\texttt{\textbackslash{}At~the~end~of~each~generation~function~:}\\\texttt{~~~~~...}\\\texttt{\textbackslash{}end}
\After everything else function :
...
\end
\subsubsection{At each generation before reduce
function}\label{at-each-generation-before-reduce-function}
At the beginning of each generation function
Description
\paragraph{Description}\label{description-8}
~\\
This function will be called every generation before the reproduction phase.
This function will be called at every generation before performing the
different population reductions.
The population can be accessed.
EASEA syntax
The parent population AND the offspring population can be accessed
(merged into a single population).
\At the beginning of each generation function :
...
\end
\paragraph{EASEA syntax}\label{easea-syntax-8}
~\\
At the end of each generation function
Description
\texttt{\textbackslash{}At~every~generation~before~reduce~function~:}\\\texttt{~~~~~...}\\\texttt{\textbackslash{}end}
This function will be called at every generation after the printing of generation statistics.
\subsection{Memetic specific field}\label{memetic-specific-field}
The population can be accessed.
EASEA syntax
\subsubsection{Genome Optimiser}\label{genome-optimiser}
\At the end of each generation function :
...
\end
\paragraph{Description}\label{description-9}
~\\
At each generation before reduce function
Description
The optimiser field is a Genome specific field. It is meant to contain
the function defining the way an individual will be locally optimized
\emph{n} times. The function will hence be called sequentially as many
times as the user desires for each individual.
This function will be called at every generation before performing the different population reductions.
EASEA gives the user two possibilities when designing their local
optimization function :
The parent population AND the offspring population can be accessed (merged into a single population).
EASEA syntax
\begin{enumerate}
\itemsep1pt\parskip0pt\parsep0pt
\item
The user can choose to design the function that will enhance the
genome of their individuals only in which case the rest of the local
optimizer (i.e. creating the local optimizing loop, checking if an
individual has improved or not, storing temporary individuals, calling
of the evaluation function, etc ...) will be taken care of by the
EASEA memetic algorithm. The function will have to be called as many
times as specified by the
Number of optimisation iterations parameter.
\item
The user can choose to write the complete local optimizer. This way,
he will have the complete freedom to design a more complex and
specific optimizer, but he will also have to deal with the creation of
the local optimization loop, the management of temporary individuals,
the calling of the evaluation function etc... The
Number of optimisation iterations parameter will have to be set to 1 as the
function desigend by the user will contain it's own optimization loop
requiring it's own specific number of optimization iterations.
\end{enumerate}
\At every generation before reduce function :
...
\end
\paragraph{EASEA syntax}\label{easea-syntax-9}
~\\
\texttt{\textbackslash{}GenomeClass::optimiser~:}\\\texttt{~~~~~...}\\\texttt{\textbackslash{}end}
\paragraph{Examples}\label{examples}
~\\
The two following examples will expose the two different ways the
optimizer field can be used. The first example will show a simple
\emph{mutation} function. The second example will show the design of a
complete local optimizer. Both examples are GPU compatible.
Memetic specific field
Genome Optimiser
Description
\begin{description}
\itemsep1pt\parskip0pt\parsep0pt
\item[Genome optimization only]
\end{description}
The optimiser field is a Genome specific field. It is meant to contain the function defining the way an individual will be locally optimized n times. The function will hence be called sequentially as many times as the user desires for each individual.
\texttt{\textbackslash{}GenomeClass::optimiser~:}\\\texttt{~float~pas~=~0.001;}\\\texttt{~Genome.x{[}currentIteration\%SIZE{]}+=pas;}\\\texttt{\textbackslash{}end}
EASEA gives the user two possibilities when designing their local optimization function :
This example shows a simple \emph{mutation} function that will add a
small variation to one of the genes of an individual. The call to this
function will be followed by a call to the evaluation function, and a
replacement process. If the modification of the genome has improved the
individual, it will replace the original one. This is being taken care
of by the EASEA memetic algorithm.
The user can choose to design the function that will enhance the genome of their individuals only in which case the rest of the local optimizer (i.e. creating the local optimizing loop, checking if an individual has improved or not, storing temporary individuals, calling of the evaluation function, etc ...) will be taken care of by the EASEA memetic algorithm. The function will have to be called as many times as specified by the Number of optimisation iterations parameter.
The user can choose to write the complete local optimizer. This way, he will have the complete freedom to design a more complex and specific optimizer, but he will also have to deal with the creation of the local optimization loop, the management of temporary individuals, the calling of the evaluation function etc... The Number of optimisation iterations parameter will have to be set to 1 as the function desigend by the user will contain it's own optimization loop requiring it's own specific number of optimization iterations.
\begin{description}
\itemsep1pt\parskip0pt\parsep0pt
\item[Complete local optimizer]
\end{description}
EASEA syntax
\texttt{\textbackslash{}GenomeClass~:~:~optimiser~:~~~//~~Optimises~~~the~Genome~}\\\texttt{~float~pas=0.001;}\\\texttt{~float~fitnesstmp~=~Genome.fitness~;~}\\\texttt{~float~tmp{[}SIZE{]};~}\\\texttt{~int~index~=~0;}\\\texttt{~for(int~i=0;~i}\texttt{fitness}
\GenomeClass::optimiser :
...
\end
\subsubsection{Best individual}\label{best-individual}
Examples
Returns a pointer to the best individual found to this point. All the
genome field can be accessed as well as the fitness field. All the
genome fields can be modified.
The two following examples will expose the two different ways the optimizer field can be used. The first example will show a simple mutation function. The second example will show the design of a complete local optimizer. Both examples are GPU compatible.
\paragraph{EASEA syntax}\label{easea-syntax-10}
~\\
Genome optimization only
\texttt{bBest~("-\textgreater{}"~operator~to~access~variables)}
\GenomeClass::optimiser :
float pas = 0.001;
Genome.x[currentIteration%SIZE]+=pas;
\end
\subsubsection{Genome}\label{genome}
This example shows a simple mutation function that will add a small variation to one of the genes of an individual. The call to this function will be followed by a call to the evaluation function, and a replacement process. If the modification of the genome has improved the individual, it will replace the original one. This is being taken care of by the EASEA memetic algorithm.
Returns the genome of an individual (can only be used in genome specific
EASEA subsections such as
mutation,
initialisation,
evaluation and
. All the fields
can be modified.
Complete local optimizer
\paragraph{EASEA syntax}\label{easea-syntax-11}
~\\
\GenomeClass : : optimiser : // Optimises the Genome
float pas=0.001;
float fitnesstmp = Genome.fitness ;
float tmp[SIZE];
int index = 0;
for(int i=0; i<SIZE; i++)
tmp[ i ] = Genome.x[ i ];
for(int i=0; i<100; i++){
tmp[index] += pas;
fitnesstmp = Weierstrass(tmp, SIZE);
if(fitnesstmp < Genome.fitness){
Genome. fitness = fitnesstmp ;
Genome.x[ index ] = tmp[ index ];
}
else {
fitnesstmp = Genome.fitness;
tmp[ index ] = Genome.x[ index ];
if( pas < 0 )
index = ( index + 1)%SIZE;
pas *= -1;
}
}
\ end
\texttt{Genome~("."~operator~to~access~variables)}
This example shows how to design a complete local optimization function. The genome is almost being changed in the same way as in the first example.
% subsection EASEA defined sections (end)
\subsubsection{Parent 1}\label{parent-1}
\subsection{EASEA defined functions} % (fold)
\label{sub:EASEA defined functions}
Random Number Generators
TossCoin
Description
Returns the genome of the first selected parent. Can only be used in the
crossover genome
subsection.
Simulates the toss of a coin. There are two different definitions of the tossCoin function:
\paragraph{EASEA syntax}\label{easea-syntax-12}
~\\
A simple toss of a coin.
A biased toss of a coin.
\texttt{parent1}
EASEA syntax
\subsubsection{Parent 2}\label{parent-2}
bool tossCoin() // SImple tosscoin
Returns the genome of the second selected parent. Can only be used in
the crossover genome
subsection.
bool tossCoin(float bias) // Biased tossCoin
\paragraph{EASEA syntax}\label{easea-syntax-13}
~\\
Example
\texttt{parent2}
if( tossCoin(0.1)){
...
}
\subsubsection{Child}\label{child}
Random
Description
Returns the genome of the newly created individual. Can only be used in
the crossover genome
subsection.
Generates a random number. There are several definitions to the random function:
\paragraph{EASEA syntax}\label{easea-syntax-14}
~\\
Random function with Min Max Boundary
Random function with Max Boundary only
\texttt{child}
In the case of a Max boundary only, the Min boundary will be 0.
EASEA syntax
Here is a quick presentation of the various parameters that can be found
and used in a .ez file
\section{EASEA defined parameters}
\subsection{Basic Parameters}\label{basic-parameters}
int random( int Min, int Max)
\paragraph{Number of generations}\label{number-of-generations}
~\\
int random( int Max)
\textbf{Description :}\\Gives the maximum number of generations during
wich the evolutionary algorithm will run.
float random( float Min, float Max)
\textbf{EASEA syntax :}
double random( double Min, double Max)
\texttt{Number~of~generations:}
\textbf{Values :} Integer strictly over 0.
% subsection EASEA defined functions (end)
% section the language (end)
\subsection{EASEA defined variable} % (fold)
\label{sub:EASEA defined variable}
Current Generation
\textbf{Command line syntax :}
Return the current generation number. This variable can be modified.
EASEA syntax
\texttt{-{}-nbGen=}
currentGeneration
\textbf{Values :} Integer strictly over 0.
Number of Generation
\paragraph{Time limit}\label{time-limit}
~\\
Returns the generation limit. This variable can be modified.
EASEA syntax
\textbf{Description :}\\Sets the maximum amount of time in seconds
during wich the evolutionary algorithm will be allowed to run. Setting
this parameter to 0 deactivates the time limit.
NB_GEN
\textbf{EASEA syntax :}
Population Size
\texttt{Time~limit~:}