Création d'un compte pour un collaborateur extérieur au laboratoire depuis l'intranet ICube : https://intranet.icube.unistra.fr/fr/labs/member/profile

Commit 4b013a30 authored by maitre's avatar maitre
Browse files

Un-broken INSTEAD_EVAL CUDA.tpl

parent 2434f345
......@@ -27,6 +27,8 @@ Centre de Math
#define CUDA_FLAVOR_SO 0
#define CUDA_FLAVOR_MO 1
#define CUDA_FLAVOR_CMAES 2
#define CUDA_FLAVOR_GP 3
#define UNIX 1
#define WINDOWS 2
......
......@@ -1828,7 +1828,7 @@ int CEASEALexer::create(CEASEAParser* pParser, CSymbolTable* pSymTable)
strcat(sTemp,"CUDA.tpl");
else if(TARGET_FLAVOR == CUDA_FLAVOR_CMAES )
strcat(sTemp,"CMAES_CUDA.tpl");
else
else
strcat(sTemp,"CUDA_MO.tpl");
if (!(yyin = fpTemplateFile = fopen(sTemp, "r"))){
......@@ -1842,6 +1842,8 @@ int CEASEALexer::create(CEASEAParser* pParser, CSymbolTable* pSymTable)
strcat(sTemp,"STD.tpl");
else if (TARGET_FLAVOR == STD_FLAVOR_CMAES)
strcat(sTemp,"CMAES.tpl");
else if( TARGET_FLAVOR == CUDA_FLAVOR_GP )
strcat(sTemp,"CUDA_GP.tpl");
else
strcat(sTemp,"STD_MO.tpl");
if (!(yyin = fpTemplateFile = fopen(sTemp, "r"))){
......
......@@ -657,6 +657,10 @@ int main(int argc, char *argv[]){
TARGET=CUDA;
TARGET_FLAVOR = CUDA_FLAVOR_MO;
}
else if( !mystricmp(sTemp,"cuda_gp") ){
TARGET=STD;
TARGET_FLAVOR = CUDA_FLAVOR_GP;
}
else if (!mystricmp(sTemp,"std")) {
TARGET=STD;
......@@ -675,8 +679,12 @@ int main(int argc, char *argv[]){
TARGET_FLAVOR = CUDA_FLAVOR_CMAES;
}
else if (!mystricmp(sTemp,"v")) bVERBOSE=true;
else if (!mystricmp(sTemp,"tl")) bLINE_NUM_EZ_FILE=false;
else if (!mystricmp(sTemp,"tl")){
printf("yopyop true line\n");
bLINE_NUM_EZ_FILE=false;
}
else if (!mystricmp(sTemp,"path")) {
if (argv[++nParamNb][0]=='"') {
strcpy(sEZ_PATH,&(argv[nParamNb][1]));
......
77
0.05,0.61,0.3,5,27.2
0.05,0.61,0.3,15,44.9
0.05,0.61,0.3,30,59.3
0.05,0.61,0.3,45,68.7
0.05,0.61,0.3,75,80.1
0.05,0.61,0.3,120,87.2
0.05,0.61,0.3,180,94.2
0.05,0.86,0.61,5,27.2
0.05,0.86,0.61,15,41.6
0.05,0.86,0.61,30,56.4
0.05,0.86,0.61,45,64.7
0.05,0.86,0.61,75,74
0.05,0.86,0.61,120,81.4
0.05,0.86,0.61,180,86.2
0.05,0.76,0.76,5,8.7
0.05,0.76,0.76,15,21.3
0.05,0.76,0.76,30,33.9
0.05,0.76,0.76,45,42.9
0.05,0.76,0.76,75,57.3
0.05,0.76,0.76,120,65.5
0.05,0.76,0.76,180,69.2
0.06,0.86,0.61,5,17.7
0.06,0.86,0.61,15,30.1
0.06,0.86,0.61,30,43.9
0.06,0.86,0.61,45,52
0.06,0.86,0.61,75,64.7
0.06,0.86,0.61,120,74.6
0.06,0.86,0.61,180,82
0.25,0.86,0.61,5,8.5
0.25,0.86,0.61,15,20.9
0.25,0.86,0.61,30,33.6
0.25,0.86,0.61,45,44.6
0.25,0.86,0.61,75,56.6
0.25,0.86,0.61,120,68.2
0.25,0.86,0.61,180,76
0.35,0.76,0.76,5,5
0.35,0.76,0.76,15,14.9
0.35,0.76,0.76,30,28.6
0.35,0.76,0.76,45,37.3
0.35,0.76,0.76,75,51.3
0.35,0.76,0.76,120,63.6
0.35,0.76,0.76,180,72.1
0.5,0.86,0.61,5,5
0.5,0.86,0.61,15,14.5
0.5,0.86,0.61,30,27.6
0.5,0.86,0.61,45,36.4
0.5,0.86,0.61,75,52.3
0.5,0.86,0.61,120,64.3
0.5,0.86,0.61,180,72
0.5,1.52,0.76,5,10.5
0.5,1.52,0.76,15,20.4
0.5,1.52,0.76,30,34
0.5,1.52,0.76,45,46.4
0.5,1.52,0.76,75,61.2
0.5,1.52,0.76,120,76.2
0.5,1.52,0.76,180,80
0.5,1.07,0.76,5,10.5
0.5,1.07,0.76,15,19.7
0.5,1.07,0.76,30,32.3
0.5,1.07,0.76,45,42.3
0.5,1.07,0.76,75,57.1
0.5,1.07,0.76,120,70.8
0.5,1.07,0.76,180,76
0.5,0.94,0.76,5,9.1
0.5,0.94,0.76,15,18.4
0.5,0.94,0.76,30,31.7
0.5,0.94,0.76,45,40.3
0.5,0.94,0.76,75,54.1
0.5,0.94,0.76,120,67.8
0.5,0.94,0.76,180,74
0.5,0.76,0.76,5,9.5
0.5,0.76,0.76,15,17.3
0.5,0.76,0.76,30,28.3
0.5,0.76,0.76,45,37.2
0.5,0.76,0.76,75,49
0.5,0.76,0.76,120,61.7
0.5,0.76,0.76,180,66
......@@ -10,6 +10,11 @@ __________________________________________________________*/
#include <errno.h>
#include <sstream>
#include <math.h>
#include <cutil.h>
#define OPERAND 0
......@@ -191,7 +196,7 @@ void toDotFile(GPNode* root, const char* baseFileName, int treeId){
std::ostringstream oss;
oss << baseFileName << "-" << treeId << ".gv";
FILE* outputFile = fopen(oss.str().c_str(),"w");
FILE* outputFile = fopen(oss.str().c_str(),"a");
if( !outputFile ){
perror("Opening file for outputing dot representation ");
exit(-1);
......@@ -356,9 +361,15 @@ GPNode* selectNode( GPNode* root, int* childId, int* depth){
fitnessCasesSetLength = load_data(&inputs,&outputs,"quadra_reg_data.csv");
cout << "number of point in fitness cases set : " << fitnessCasesSetLength << endl;
INSTEAD_EVAL_STEP=true;
// Adding another stopping, as we are minimizing, the goal is 0
CGoalCriterion* gc = new CGoalCriterion(0,true);
EA->stoppingCriteria.push_back(gc);
// Here starts the CUDA parts
cudaSetDevice(1); // on GTX295 ;) we want to use the second card for computation
}
\end
......@@ -393,7 +404,11 @@ GPNode* selectNode( GPNode* root, int* childId, int* depth){
\end
\Instead evaluation function:
cout << "yopyop" << endl;
{
for( int i=0 ; i<popSize ; i++ ){
cout << population[i] << endl;
}
}
\end
\User classes :
......@@ -627,7 +642,6 @@ GenomeClass {
\end
\User Makefile options:
CPPFLAGS+=
\end
\Default run parameters : // Please let the parameters appear in this order
......
/* 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;