Skip to content
GitLab
Projects
Groups
Snippets
Help
Loading...
Help
Help
Support
Community forum
Keyboard shortcuts
?
Submit feedback
Contribute to GitLab
Sign in
Toggle navigation
E
easea
Project overview
Project overview
Details
Activity
Releases
Repository
Repository
Files
Commits
Branches
Tags
Contributors
Graph
Compare
Issues
0
Issues
0
List
Boards
Labels
Service Desk
Milestones
Merge Requests
0
Merge Requests
0
Operations
Operations
Incidents
Packages & Registries
Packages & Registries
Container Registry
Analytics
Analytics
Repository
Value Stream
Wiki
Wiki
Snippets
Snippets
Members
Members
Collapse sidebar
Close sidebar
Activity
Graph
Create a new issue
Commits
Issue Boards
Open sidebar
Arnaud Kress
easea
Commits
4660d658
Commit
4660d658
authored
Dec 11, 2009
by
kruger
Browse files
Options
Browse Files
Download
Email Patches
Plain Diff
Modif de Fred
parent
7bf02f47
Changes
7
Expand all
Hide whitespace changes
Inline
Side-by-side
Showing
7 changed files
with
2041 additions
and
1 deletion
+2041
-1
examples/ant/ant.ez
examples/ant/ant.ez
+648
-0
examples/cmaes_cuda_test/cigtabGPU.ez
examples/cmaes_cuda_test/cigtabGPU.ez
+120
-0
examples/cmaes_tests/cigtab.ez
examples/cmaes_tests/cigtab.ez
+125
-0
examples/weierstrass_gpu/weierstrass.ez
examples/weierstrass_gpu/weierstrass.ez
+172
-0
examples/weierstrass_std/weierstrass.ez
examples/weierstrass_std/weierstrass.ez
+177
-0
libeasea/COptionParser.cpp
libeasea/COptionParser.cpp
+1
-1
tpl/CMAES_CUDA.tpl
tpl/CMAES_CUDA.tpl
+798
-0
No files found.
examples/ant/ant.ez
0 → 100644
View file @
4660d658
/* ANTPROJECT */
\User declarations:
int nbEvalTotal = 0; //Le nombre d'evaluations
short nbPasMax = 600; //Le nombre max de mouvements autorises
double pMutPerGene=0.05; // La probabilité de muter un gene
enum symboles {food_ahead, progn2, progn3, LEFT, RIGHT, MOVE}; //L'ensemble des valeurs que peut prendre un noeud de l'arbre
enum orientations {nord, est, sud, ouest}; //Les 4 orientations possibles
int profondeurMax = 2; //La profondeur max d'un arbre a sa cration (racine = 0)
int profondeurMax1 = 9; //La profondeur max d'un arbre au cours de l'évolution
int taille = 32; //taille de la grille
int SIZE=0;//taille d'un individu
int carte[32][32]; //la grille
inline void swap(int& a,int& b) {int c=a; a=b; b=c;}
\end
\User functions:
#include <math.h>
void echangeNoeud(Element *child, Element *parent){
swap(child->Value,parent->Value);
}
/*
Creation de la carte avec le chemin.
*/
void initCarte(){
int i,j;
for(i=0;i<32;i++)
for(j=0;j<32;j++)
carte[i][j]=0;
carte[0][1]=1;carte[0][2]=1;carte[0][3]=1;carte[1][3]=1;carte[2][3]=1;
carte[3][3]=1;carte[4][3]=1;carte[5][3]=1;carte[5][4]=1;carte[5][5]=1;
carte[5][6]=1;carte[5][8]=1;carte[5][9]=1;carte[5][10]=1;carte[5][11]=1;
carte[5][12]=1;carte[6][12]=1;carte[7][12]=1;carte[8][12]=1;carte[9][12]=1;
carte[11][12]=1;carte[12][12]=1;carte[13][12]=1;carte[14][12]=1;carte[17][12]=1;
carte[18][12]=1;carte[19][12]=1;carte[20][12]=1;carte[21][12]=1;carte[22][12]=1;
carte[23][12]=1;carte[24][11]=1;carte[24][10]=1;carte[24][9]=1;carte[24][8]=1;
carte[24][7]=1; carte[24][4]=1;carte[24][3]=1;carte[25][1]=1;carte[26][1]=1;
carte[27][1]=1;carte[28][1]=1;carte[30][2]=1;carte[30][3]=1;carte[30][4]=1;
carte[30][5]=1;carte[29][7]=1;carte[28][7]=1;carte[27][8]=1;carte[27][9]=1;//50
carte[27][10]=1;carte[27][11]=1;carte[27][12]=1;carte[27][13]=1;carte[27][14]=1;
carte[26][16]=1;carte[25][16]=1;carte[24][16]=1;carte[21][16]=1;carte[20][16]=1;
carte[19][16]=1;carte[18][16]=1;carte[15][17]=1;carte[14][20]=1;carte[13][20]=1;
carte[10][20]=1;carte[9][20]=1;carte[8][20]=1;carte[7][20]=1;carte[5][21]=1;
carte[5][22]=1;carte[4][24]=1;carte[3][24]=1;carte[2][25]=1;carte[2][26]=1;
carte[2][27]=1;carte[3][29]=1;carte[4][29]=1;carte[6][29]=1;carte[9][29]=1;//80
carte[12][29]=1;carte[14][28]=1;carte[14][27]=1;carte[14][26]=1;carte[15][23]=1;
carte[18][24]=1;carte[19][27]=1;carte[22][26]=1;carte[23][23]=1;//89
}
/*
Creation de la carte avec le chemin sans trou.
*/
void initCarteFull(){
int i,j;
for(i=0;i<32;i++)
for(j=0;j<32;j++)
carte[i][j]=0;
carte[0][1]=1;carte[0][2]=1;carte[0][3]=1;carte[1][3]=1;carte[2][3]=1;
carte[3][3]=1;carte[4][3]=1;carte[5][3]=1;carte[5][4]=1;carte[5][5]=1;
carte[5][6]=1;carte[5][7]=1;carte[5][8]=1;carte[5][9]=1;carte[5][10]=1;
carte[5][11]=1;carte[5][12]=1;carte[6][12]=1;carte[7][12]=1;carte[8][12]=1;
carte[9][12]=1;carte[10][12]=1;carte[11][12]=1;carte[12][12]=1;carte[13][12]=1;
carte[14][12]=1;carte[15][12]=1;carte[16][12]=1;carte[17][12]=1;carte[18][12]=1;
carte[19][12]=1;carte[20][12]=1;carte[21][12]=1;carte[22][12]=1;carte[23][12]=1;
carte[24][12]=1;carte[24][11]=1;carte[24][10]=1;carte[24][9]=1;carte[24][8]=1;
carte[24][7]=1;carte[24][6]=1;carte[24][5]=1;carte[24][4]=1;carte[24][3]=1;
carte[24][2]=1;carte[24][1]=1;carte[25][1]=1;carte[26][1]=1;carte[27][1]=1;//50
carte[28][1]=1;carte[29][1]=1;carte[30][1]=1;carte[30][2]=1;carte[30][3]=1;
carte[30][4]=1;carte[30][5]=1;carte[30][6]=1;carte[30][7]=1;carte[29][7]=1;
carte[28][7]=1;carte[27][7]=1;carte[27][8]=1;carte[27][9]=1;carte[27][10]=1;
carte[27][11]=1;carte[27][12]=1;carte[27][13]=1;carte[27][14]=1;carte[27][15]=1;
carte[27][16]=1;carte[26][16]=1;carte[25][16]=1;carte[24][16]=1;carte[23][16]=1;
carte[22][16]=1;carte[21][16]=1;carte[20][16]=1;carte[19][16]=1;carte[18][16]=1;
carte[17][16]=1;carte[16][16]=1;carte[15][16]=1;carte[15][17]=1;carte[15][18]=1;
carte[15][19]=1;carte[15][20]=1;carte[14][20]=1;carte[13][20]=1;carte[12][20]=1;
carte[11][20]=1;carte[10][20]=1;carte[9][20]=1;carte[8][20]=1;carte[7][20]=1;
carte[6][20]=1;carte[5][20]=1;carte[5][21]=1;carte[5][22]=1;carte[5][23]=1;//100
carte[5][24]=1;carte[4][24]=1;carte[3][24]=1;carte[2][24]=1;carte[2][25]=1;
carte[2][26]=1;carte[2][27]=1;carte[2][28]=1;carte[2][29]=1;carte[3][29]=1;
carte[4][29]=1;carte[5][29]=1;carte[6][29]=1;carte[7][29]=1;carte[8][29]=1;
carte[9][29]=1;carte[10][29]=1;carte[11][29]=1;carte[12][29]=1;carte[13][29]=1;
carte[14][29]=1;carte[14][28]=1;carte[14][27]=1;carte[14][26]=1;carte[14][25]=1;
carte[14][24]=1;carte[14][23]=1;carte[15][23]=1;carte[16][23]=1;carte[17][23]=1;
carte[18][23]=1;carte[18][24]=1;carte[18][25]=1;carte[18][26]=1;carte[18][27]=1;
carte[19][27]=1;carte[20][27]=1;carte[21][27]=1;carte[22][27]=1;carte[22][26]=1;
carte[22][25]=1;carte[22][24]=1;carte[22][23]=1;carte[23][23]=1;//144
}
/*
Fonction qui recopie un sous arbre. Il s'agit d'un vrai clonage et pas d'un
simple echange de références !
*/
Element *copierSousArbreRec(Element* ssArbreSource, int profondeur, int pMax){
Element *elt = new Element;
elt->numero = SIZE++;
elt->profondeur = profondeur;
if(ssArbreSource==NULL)
return NULL;
if(profondeur == pMax){
elt->filsG = NULL;
elt->filsD = NULL;
elt->filsC = NULL;
double rnd = random(0.,1.);
//Left
if(rnd<1./3.)
elt->Value = LEFT;
else if(rnd<2./3.)
elt->Value = RIGHT;
else
elt->Value = MOVE;
}
else{
elt->Value=ssArbreSource->Value;
elt->filsG=copierSousArbreRec(ssArbreSource->filsG,profondeur+1,pMax);
elt->filsC=copierSousArbreRec(ssArbreSource->filsC,profondeur+1,pMax);
elt->filsD=copierSousArbreRec(ssArbreSource->filsD,profondeur+1,pMax);
}
return elt;
}
/*
Fonction de génération d'un noeud.
*/
Element *genererNoeud(int profondeur, int profondeurMaxAutorisee){
Element *elt = new Element;
elt->numero = SIZE++;
elt->profondeur = profondeur;
//Cas d'un symbole terminal (feuille)
if(profondeur == profondeurMaxAutorisee ){
elt->filsG = NULL;
elt->filsD = NULL;
elt->filsC = NULL;
double rnd = random(0.,1.);
//Left
if(rnd<1./3.){
elt->Value = LEFT;
}
else if(rnd<2./3.){
elt->Value = RIGHT;
}
else{
elt->Value = MOVE;
}
}
//Cas d'une fonction (noeud non feuille)
else{
double rnd = random(0.,1.);
if(rnd<1./3.){
elt->Value = food_ahead;
elt->filsG = genererNoeud(profondeur+1,profondeurMaxAutorisee);
elt->filsC = NULL;
elt->filsD = genererNoeud(profondeur+1,profondeurMaxAutorisee);
}
else if(rnd<2./3.){
elt->Value = progn2;
elt->filsG = genererNoeud(profondeur+1,profondeurMaxAutorisee);
elt->filsC = NULL;
elt->filsD = genererNoeud(profondeur+1,profondeurMaxAutorisee);
}
else{
elt->Value = progn3;
elt->filsG = genererNoeud(profondeur+1,profondeurMaxAutorisee);
elt->filsC = genererNoeud(profondeur+1,profondeurMaxAutorisee);
elt->filsD = genererNoeud(profondeur+1,profondeurMaxAutorisee);
}
}
return elt;
}
/*
Cette fonction cherche un noeud dont le numero est passé en paramètre
dans l'arbre passé également en paramètre.
*/
Element *chercheNoeud(Element *eltDepart, int numero){
fflush(stdout);
if(eltDepart == NULL){
return NULL;
}
if(eltDepart->numero == numero){
return eltDepart;
}
else{
Element *tmp = NULL;
if(eltDepart->filsG !=NULL)
tmp = chercheNoeud(eltDepart->filsG, numero);
if(tmp != NULL)
return tmp;
if(eltDepart->filsC !=NULL)
tmp = chercheNoeud(eltDepart->filsC, numero);
if(tmp != NULL)
return tmp;
if(eltDepart->filsD !=NULL)
tmp = chercheNoeud(eltDepart->filsD, numero);
if(tmp != NULL)
return tmp;
}
return NULL;
}
/*
Cette fonction remplace le noeud numero "numero" dans l'arbre de racine "dst"
par l'element src.
*/
void remplace(Element *dst, Element *src, int numero){
if(dst == NULL){
return;
}
if(dst->numero == numero){
dst->Value=src->Value;
dst->filsG=src->filsG;
dst->filsC=src->filsC;
dst->filsD=src->filsD;
}
else{
if(dst->filsG !=NULL)
remplace(dst->filsG, src, numero);
if(dst->filsC !=NULL)
remplace(dst->filsC, src, numero);
if(dst->filsD !=NULL)
remplace(dst->filsD, src, numero);
}
}
/*
Renumerote les noeuds de l'arbre et regenere sa taille
*/
void regenSizeRec(Element *racine, int p){
racine->numero=SIZE++;
racine->profondeur=p;
if(racine->filsG!=NULL)
regenSizeRec(racine->filsG, p+1);
if(racine->filsC!=NULL)
regenSizeRec(racine->filsC, p+1);
if(racine->filsD!=NULL)
regenSizeRec(racine->filsD, p+1);
}
void regenSize(Element *racine){
SIZE=0;
regenSizeRec(racine, 0);
}
int evaluerFoodAhead(int *orientationCourante, int *ligneCourante, int *colCourante){
switch(*orientationCourante){
case nord : {
int l = ((*ligneCourante)-1<0)?(*ligneCourante)-1+taille:(*ligneCourante)-1;
if(carte[l][(*colCourante)]!=1)
return 0;
else
return 1;
}
case sud : {
int l = ((*ligneCourante)+1==taille)?0:(*ligneCourante)+1;
if(carte[l][(*colCourante)]!=1)
return 0;
else
return 1;
}
case est : {
int c = ((*colCourante)+1==taille)?0:(*colCourante)+1;
if(carte[(*ligneCourante)][c]!=1)
return 0;
else
return 1;
}
case ouest : {
int c = ((*colCourante)-1<0)?(*colCourante)-1+taille:(*colCourante)-1;
if(carte[(*ligneCourante)][c]!=1)
return 0;
else
return 1;
}
default:return 0;
}
}
void evaluerMove(int *orientationCourante, int *ligneCourante, int *colCourante, int *fitnessCourant){
switch(*orientationCourante){
case nord : {
(*ligneCourante) = ((*ligneCourante)-1<0)?(*ligneCourante)-1+taille:(*ligneCourante)-1;
break;
}
case sud : {
(*ligneCourante) = ((*ligneCourante)+1==taille)?0:(*ligneCourante)+1;
break;
}
case est : {
(*colCourante) = ((*colCourante)+1==taille)?0:(*colCourante)+1;
break;
}
case ouest : {
(*colCourante) = ((*colCourante)-1<0)?(*colCourante)-1+taille:(*colCourante)-1;
break;
}
}
if(carte[(*ligneCourante)][(*colCourante)]==1){
*fitnessCourant = *fitnessCourant-1;
carte[(*ligneCourante)][(*colCourante)]=-1;
//Partie utile si l'on veut stopper l'évolution immédiatement apres avoir trouve l'individu
//(pour calculer le nombre d'évaluations precis)
/* if(*fitnessCourant==0){
FILE *fichier;
fichier = fopen("sortie.txt","a");
fprintf(fichier,"Individu idéal trouvé après %d évaluations\t %d\n",nbEvalTotal,nbEvalTotal);
fclose(fichier);
exit(0);
} */
}
}
void evaluerNoeud(Element *elt, int *orientationCourante, int *ligneCourante, int *colCourante, int *fitnessCourant, int *nbPas){
if(*nbPas>=nbPasMax)
return;
switch(elt->Value){
case food_ahead : {
if(evaluerFoodAhead(orientationCourante, ligneCourante, colCourante)>0)
evaluerNoeud(elt->filsG,orientationCourante, ligneCourante, colCourante, fitnessCourant, nbPas);
else
evaluerNoeud(elt->filsD,orientationCourante, ligneCourante, colCourante, fitnessCourant, nbPas);
break;
}
case progn2 : {
evaluerNoeud(elt->filsG,orientationCourante, ligneCourante, colCourante, fitnessCourant, nbPas);
evaluerNoeud(elt->filsD,orientationCourante, ligneCourante, colCourante, fitnessCourant, nbPas);
break;
}
case progn3 : {
evaluerNoeud(elt->filsG,orientationCourante, ligneCourante, colCourante, fitnessCourant, nbPas);
evaluerNoeud(elt->filsC,orientationCourante, ligneCourante, colCourante, fitnessCourant, nbPas);
evaluerNoeud(elt->filsD,orientationCourante, ligneCourante, colCourante, fitnessCourant, nbPas);
break;
}
case LEFT : {
switch(*orientationCourante){
case est:*orientationCourante=nord;(*nbPas)++;break;
case sud:*orientationCourante=est;(*nbPas)++;break;
case ouest:*orientationCourante=sud;(*nbPas)++;break;
case nord:*orientationCourante=ouest;(*nbPas)++;break;
}
break;
}
case RIGHT : {
switch(*orientationCourante){
case est:*orientationCourante=sud;(*nbPas)++;break;
case sud:*orientationCourante=ouest;(*nbPas)++;break;
case ouest:*orientationCourante=nord;(*nbPas)++;break;
case nord:*orientationCourante=est;(*nbPas)++;break;
}
break;
}
case MOVE : {
evaluerMove(orientationCourante, ligneCourante, colCourante, fitnessCourant);(*nbPas)++;
break;
}
}
}
void imprimerArbre(Element *elt){
switch(elt->Value){
case food_ahead : {
printf("IF_FOOD-");
imprimerArbre(elt->filsG);
imprimerArbre(elt->filsD);
break;
}
case progn2 : {
printf("PROGN2-");
imprimerArbre(elt->filsG);
imprimerArbre(elt->filsD);
break;
}
case progn3 : {printf("PROGN3-");
imprimerArbre(elt->filsG);
imprimerArbre(elt->filsC);
imprimerArbre(elt->filsD);
break;
}
case LEFT : {printf("LEFT-");
break;
}
case RIGHT : {printf("RIGHT-");
break;
}
case MOVE : {printf("MOVE-");
break;
}
}
}
void imprimerArbreDansFichier(Element *elt, FILE *fichier){
switch(elt->Value){
case food_ahead : {
fprintf(fichier,"IF_FOOD-");
imprimerArbreDansFichier(elt->filsG, fichier);
imprimerArbreDansFichier(elt->filsD, fichier);
break;
}
case progn2 : {
fprintf(fichier,"PROGN2-");
imprimerArbreDansFichier(elt->filsG, fichier);
imprimerArbreDansFichier(elt->filsD, fichier);
break;
}
case progn3 : {fprintf(fichier,"PROGN3-");
imprimerArbreDansFichier(elt->filsG, fichier);
imprimerArbreDansFichier(elt->filsC, fichier);
imprimerArbreDansFichier(elt->filsD, fichier);
break;
}
case LEFT : {fprintf(fichier,"LEFT-");
break;
}
case RIGHT : {fprintf(fichier,"RIGHT-");
break;
}
case MOVE : {fprintf(fichier,"MOVE-");
break;
}
}
}
\end
\Before everything else function:
if ((argc>1)&&(!strcmp(argv[1],"size"))) SIZE=atoi(argv[2]);
\end
\User classes:
Element {
int Value;
int numero;
int profondeur;
Element *filsG;
Element *filsC;
Element *filsD;
}
GenomeClass {
Element *arbre;
int Size;
int nbPas;
int ligneCourante;
int colCourante;
int orientationCourante ;
int fitnessCourant;
int seqlen;
}
\end
\After everything else function:
/**
*Version utilisée pour les lancement en sequence pour les stats.
* Attention : penser à décommenter dans la fonction evaluerMove
FILE *fichier;
fichier = fopen("sortie.txt","a");
fprintf(fichier,"Individu idéal non trouvé \n");
fclose(fichier);
exit(0);
*/
/**Version de la fonction de finalisation pour visualiser l'arbre vainqueur
*C'est ce qu'il faut utiliser pour generer le fichier pour le viewer java.
* Attention : penser à commenter dans la fonction evaluerMove
*/
imprimerArbre(bBest->arbre);
printf("\nfitness = %d\n",pPopulation[0]->getFitness());
FILE *fichier;
fichier = fopen("sortieEasea.txt","w");
imprimerArbreDansFichier(pPopulation[0]->arbre, fichier);
fclose(fichier);
\end
\GenomeClass::initialiser:
SIZE = 0;
//Creation de l'arbre.
Element *pElt = genererNoeud(0,profondeurMax);
Genome.arbre= pElt;
Genome.Size=SIZE;
SIZE=0;
\end
\GenomeClass::crossover:
int locusC = random(0,child1.Size-1);
int locusP2 = random(0,parent2.Size-1);
Element * elt1=chercheNoeud(child1.arbre,locusC);
Element * eltParent2=chercheNoeud(parent2.arbre,locusP2);
Element *elt11 = copierSousArbreRec(eltParent2, elt1->profondeur,profondeurMax1);
remplace(child1.arbre,elt11,locusC);
regenSize(child1.arbre);
child1.Size=SIZE;
\end
\GenomeClass::mutator:
int nbMut=0;
int i=0;
Element *racine = Genome.arbre;
int nbMutATest = Genome.Size;
for(i=1;i<nbMutATest;i++){
double d = random(0.0,1.0);
if(d<pMutPerGene){
Element *elt=chercheNoeud(racine,i);
if(elt==NULL){
return 0;
}
double rnd = random(0.0,1.0);
switch(elt->Value){
case food_ahead : {
if(rnd<0.5)
elt->Value = progn2;
else{
int profondeurMaxVoulue = random(elt->profondeur,profondeurMax1);
elt->Value = progn3;
elt->filsC = genererNoeud(elt->profondeur,profondeurMaxVoulue);
}
break;
}
case progn2 : {
if(rnd<0.5)
elt->Value = food_ahead;
else{
int profondeurMaxVoulue = random(elt->profondeur,profondeurMax1);
elt->Value = progn3;
elt->filsC = genererNoeud(elt->profondeur,profondeurMaxVoulue);
}
break;
}
case progn3 : {
if(rnd<0.5)
elt->Value = food_ahead;
else{
elt->Value = progn2;
elt->filsC = NULL;
}
break;
}
case LEFT : {
if(rnd<0.5)
elt->Value = MOVE;
else
elt->Value = RIGHT;
break;
}
case RIGHT : {
if(rnd<0.5)
elt->Value = MOVE;
else
elt->Value = LEFT;
break;
}
case MOVE : {
if(rnd<0.5)
elt->Value = LEFT;
else
elt->Value = RIGHT;
break;
}
}
regenSize(racine);
Genome.Size = SIZE;
nbMut++;
}
}
return nbMut;
\end
\GenomeClass::evaluator:
initCarte();
nbEvalTotal++;
fitnessCourant=89;
nbPas=0;
ligneCourante=0;
colCourante=0;
orientationCourante = est;
Element *elt = Genome.arbre;
while(nbPas<nbPasMax && fitnessCourant>0)
evaluerNoeud(elt,&orientationCourante, &ligneCourante, &colCourante, &fitnessCourant, &nbPas);
return fitnessCourant;
\end
\GenomeClass::display:
\end
\Default run parameters:
// Variation operators:
Mutation probability: 1.0
Crossover probability: 1.0
// Evolution Engine:
Evaluator goal: minimize
Number of generations: 100
Population size: 100
Elite: 4
Selection operator: Tournament 7
Offspring size: 50%
Reduce parents operator: Tournament 4
Surviving parents: 50
Reduce offspring operator: Tournament 2
Surviving offspring: 96
Final reduce operator: Tournament 2
Elitism: Weak
\end
examples/cmaes_cuda_test/cigtabGPU.ez
0 → 100755
View file @
4660d658
*_________________________________________________________
Test functions
log normal adaptive mutation
Selection operator: Tournament
__________________________________________________________*/
\User declarations :
#define SIZE 22
#define X_MIN -1.
#define X_MAX 1.
#define ITER 50
#define SIGMA 1. /* mutation parameter */
#define PI 3.141592654