From: Thomas Pietrzak Date: Sun, 23 Sep 2018 14:14:02 +0000 (+0200) Subject: init X-Git-Url: https://git.thomaspietrzak.com/?a=commitdiff_plain;p=projetcpo.git init --- b98eee6525c152f619b353df7cf3f075101126a1 diff --git a/Exemple b/Exemple new file mode 100644 index 0000000..8d9285d Binary files /dev/null and b/Exemple differ diff --git a/IExp.cpp b/IExp.cpp new file mode 100644 index 0000000..f094063 --- /dev/null +++ b/IExp.cpp @@ -0,0 +1,249 @@ +#include "IExp.h" + +#include +#include + +int IExp::nbindividus = 0; + +Variable **IExp::vars=NULL; + +IExp::IExp() +:but(NULL),genome(NULL) +{ + nbindividus++; + if (nbindividus == 1) + vars = NULL; +} + +IExp::IExp(const IExp &ie) +:genome(ie.genome->Copie()),but(ie.but) +{ + nbindividus++; + + if ((nbindividus == 1) || (vars == NULL)) + { + int i; + + vars = new Variable *[but->Nbvars()]; + for (i=0 ; iNbvars() ; i++) + vars[i] = new Variable(*ie.vars[i]); + } +} + +IExp::IExp(const TableVerite *tab) +:genome(NULL),but(tab) +{ + nbindividus++; + + if ((nbindividus == 1) || (vars == NULL)) + { + int i; + + vars = new Variable *[but->Nbvars()]; + for (i=0 ; iNbvars() ; i++) + vars[i] = new Variable(tab->Var(i)); + } + + //création d'un indidividu "viable" + //càd même nb de variables que le but + + Expression *e, *e1, *e2; + int i; + for (i=0 ; i< but->Nbvars() ; i++) + { + if (genome == NULL) + { + switch(random() % 4) + { + case 0: + genome = new VarExpr(vars[i]); + break; + case 1: + genome = new Non(e=new VarExpr(vars[i])); + delete e; + break; + case 2: + if (random()%2 == 0) + genome = new Ou(e1=new VarExpr(vars[i]), e2=new Constante(true)); + else + genome = new Ou(e1=new VarExpr(vars[i]), e2=new Constante(false)); + delete e1; + delete e2; + break; + case 3: + if (random()%2 == 0) + genome = new Et(e1=new VarExpr(vars[i]), e2=new Constante(true)); + else + genome = new Et(e1=new VarExpr(vars[i]), e2=new Constante(false)); + delete e1; + delete e2; + break; + } + } + else + { + switch(random() % 2) + { + case 0: + if (random()%2 == 0) + genome = new Ou(e=new VarExpr(vars[i]), genome); + else + genome = new Ou(genome, e=new VarExpr(vars[i])); + delete e; + break; + case 1: + if (random()%2 == 0) + genome = new Et(e=new VarExpr(vars[i]), genome); + else + genome = new Et(genome, e=new VarExpr(vars[i])); + delete e; + break; + } + + } + } +} + +IExp::IExp(const Expression *e, const TableVerite *tab) +:genome(e->Copie()),but(tab) +{ + nbindividus++; + + if ((nbindividus == 1) || (vars == NULL)) + { + int i; + + vars = new Variable *[but->Nbvars()]; + for (i=0 ; iNbvars() ; i++) + vars[i] = new Variable(tab->Var(i)); + } +} + +IExp::~IExp() +{ + nbindividus--; + if (nbindividus ==0) + { + int i; + if (vars != NULL) + { + for (i=0 ; iNbvars() ; i++) + if (vars[i] != NULL) + delete vars[i]; + delete []vars; + } + } + if (genome != NULL) + delete genome; +} + +void * IExp::PtCoupure()const +{ + if (genome->Fils() == NULL) + return (void *)genome; + else + return (void *)genome->Fils(); +} + +Individu *IExp::Croiser(const Individu *acroiser) const +{ + void *ptcoupa, *ptcoupb; + Expression *e; + Individu *resultat; + ptcoupa = PtCoupure(); + + ptcoupb = acroiser->PtCoupure(); + + switch(random()%2) + { + case 0: + if ((random()%2)==0) + resultat=new IExp(e=new Et((Expression *)ptcoupa,(Expression *)ptcoupb),but); + else + resultat=new IExp(e=new Et((Expression *)ptcoupb,(Expression *)ptcoupa),but); + delete e; + return resultat; + case 1: + if ((random()%2)==0) + resultat=new IExp(e=new Ou((Expression *)ptcoupa,(Expression *)ptcoupb),but); + else + resultat=new IExp(e=new Ou((Expression *)ptcoupb,(Expression *)ptcoupa),but); + delete e; + return resultat; + } +} + +Individu *IExp::Copie() const +{ + return new IExp(*this); +} + +void IExp::Muter() +{ + Expression *e; + switch(random() % 5) + { + case 0: + genome = new Non(genome); + break; + case 1: + if ((random()%2)==0) + genome = new Et(genome,e = new VarExpr(vars[random()%but->Nbvars()])); + else + genome = new Et(e = new VarExpr(vars[random()%but->Nbvars()]),genome); + delete e; + break; + case 2: + if ((random()%2)==0) + genome = new Ou(genome,e = new VarExpr(vars[random()%but->Nbvars()])); + else + genome = new Ou(e = new VarExpr(vars[random()%but->Nbvars()]),genome); + delete e; + break; + case 3: + if ((random()%2)==0) + if ((random()%2)==0) + genome = new Et(genome, e = new Constante(true)); + else + genome = new Et(e = new Constante(true),genome); + else + if ((random()%2)==0) + genome = new Et(genome,e = new Constante(false)); + else + genome = new Et(genome,e = new Constante(true)); + delete e; + break; + case 4: + if ((random()%2)==0) + if ((random()%2)==0) + genome = new Ou(genome,e = new Constante(true)); + else + genome = new Ou(e = new Constante(true),genome); + else + if ((random()%2)==0) + genome = new Ou(genome,e = new Constante(false)); + else + genome = new Ou(e = new Constante(false),genome); + delete e; + break; + } +} + +int IExp::Evaluation() const +{ + int i, score = 0; + TableVerite tab = genome->TabVerite(); + + int nbvals = (int)pow(2.,(double)but->Nbvars()); + + for (i=0 ; iIemeValeur(i) == tab.IemeValeur(i)) + score++; + + return score; +} + +void IExp::Afficher() const +{ + genome->Afficher(); +} diff --git a/IExp.h b/IExp.h new file mode 100644 index 0000000..7eeb48a --- /dev/null +++ b/IExp.h @@ -0,0 +1,56 @@ +#ifndef _IEXP_ +#define _IEXP_ + +#include "framework/Individu.h" +#include "expression/Expression.h" +#include "expression/VarExpr.h" +#include "expression/Variable.h" +#include "expression/Ou.h" +#include "expression/Et.h" +#include "expression/Non.h" +#include "expression/Constante.h" +#include "expression/TableVerite.h" + +class IExp : public Individu +{ + public : + IExp(); + IExp(const IExp &); + IExp(const TableVerite *); + IExp(const Expression *, const TableVerite *); + ~IExp(); + + //Fonctions utiles pour la population + + //retourne un point de coupure sur l'individu + void * PtCoupure()const; + + //croisement de deux individus : points de coupure etc... + Individu *Croiser(const Individu *) const; + + //copie d'un individu. + Individu *Copie() const; + + //modification d'une partie de l'individu + void Muter(); + + //évalue le score de l'individu. + int Evaluation() const; + + //affiche le genome de l'individu + void Afficher() const; + + private: + //génome de l'individu + Expression *genome; + //génome à atteindre + const TableVerite *but; + + //tableau des variables : static car c'est + //les mêmes variables pour tous les individus + static Variable **vars; + + static int nbindividus; +}; + +#endif diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..4947ed6 --- /dev/null +++ b/Makefile @@ -0,0 +1,15 @@ +CCPP = g++ +OBJS = main.o expression/TableVerite.o expression/Variable.o expression/Expression.o expression/VarExpr.o expression/Fonction.o expression/Constante.o expression/Ou.o expression/Et.o expression/Non.o PopExp.o IExp.o framework/Algogen.o framework/Population.o framework/Individu.o +CPPFLAGS = -D _NUNUX_ + +Exemple : $(OBJS) + $(CCPP) $(CPPFLAGS) -o Exemple $(OBJS) + +main.o : expression/TableVerite.o expression/Variable.o expression/Expression.o expression/Fonction.o expression/VarExpr.o expression/Constante.o expression/Ou.o expression/Et.h expression/Non.o + $(CCPP) $(CPPFLAGS) -c main.cpp + +PopExp.o : PopExp.h IExp.h expression/TableVerite.h framework/Population.h + $(CCPP) $(CPPFLAGS) -c PopExp.cpp + +IExp.o : IExp.h expression/Expression.h expression/Non.h expression/Ou.h expression/Et.h expression/Constante.h expression/VarExpr.h expression/Variable.h framework/Individu.h + $(CCPP) $(CPPFLAGS) -c IExp.cpp diff --git a/PopExp.cpp b/PopExp.cpp new file mode 100644 index 0000000..547aa79 --- /dev/null +++ b/PopExp.cpp @@ -0,0 +1,51 @@ +#include "PopExp.h" +#include +#include +using namespace std; + +PopExp::PopExp() +:but(NULL) +{ +} + +PopExp::PopExp(const PopExp &pop) +:Population(pop), but(pop.but) +{ +} + +PopExp::PopExp(const int &tp, const TableVerite *tbbut) +:Population(tp), but(tbbut) +{ +} + +PopExp::~PopExp() +{ +} + +//Création d'une population d'expressions booléennes totalement aléatoire +void PopExp::CreerPopulationAleatoire() +{ + int i; + for (i=0 ; iTaillepop() ; i++) + this->SetInd(i, new IExp(but)); +} + +//évalue si le but est atteint +bool PopExp::EvaluerCondition() const +{ + int i; + int scorebut = (int)pow(2., double(but->Nbvars())); + for (i=0 ; iTaillepop() ; i++) + if (this->Score(i) == scorebut) + { + cout << "element " << i << " : score : " << this-> Score(i) << " scorebut : " << scorebut << endl; + return true; + } + + return false; +} + +Population *PopExp::Copie() const +{ + return new PopExp(*this); +} diff --git a/PopExp.h b/PopExp.h new file mode 100644 index 0000000..aded505 --- /dev/null +++ b/PopExp.h @@ -0,0 +1,28 @@ +#ifndef _POPEXP_ +#define _POPEXP_ + +#include "IExp.h" +#include "expression/TableVerite.h" +#include "framework/Population.h" + +class PopExp : public Population +{ + public : + PopExp(); + PopExp(const PopExp &); + PopExp(const int &tp, const TableVerite*but); + ~PopExp(); + + //Création d'une population d'expressions booléennes totalement aléatoire + void CreerPopulationAleatoire(); + + //évalue si le but est atteint + bool EvaluerCondition() const; + + //copie d'une population. Pour un constructeur virtuel + Population * Copie() const; + + private : + const TableVerite *but; +}; +#endif diff --git a/doc.zip b/doc.zip new file mode 100644 index 0000000..a923617 Binary files /dev/null and b/doc.zip differ diff --git a/expression/Constante.cpp b/expression/Constante.cpp new file mode 100644 index 0000000..0fca9f3 --- /dev/null +++ b/expression/Constante.cpp @@ -0,0 +1,51 @@ +#include "Constante.h" + +#include +#include +#include +using namespace std; + +//CETTE PARTIE NE SERT QUE DANS LE CAS D'UNE COMPILATION AVEC +//C++ BUILDER. DONC AVEC GCC ON RAJOUTE -D _NUNUX_ A LA COMPIL ! +#ifndef _NUNUX_ + +#include +#pragma hdrstop + +#endif + +Constante::Constante(): +val(true) +{ + +} + +Constante::Constante(const Constante &c): +val(c.val) +{ +} + +Constante::Constante(const bool &v): +val(v) +{ + nbvars = 0; +} + +Constante::~Constante() +{ +} + +void Constante::Afficher () const +{ + cout << val; +} + +bool Constante::Evaluer() const +{ + return val; +} + +Expression *Constante::Copie() const +{ + return new Constante(val); +} diff --git a/expression/Constante.h b/expression/Constante.h new file mode 100644 index 0000000..a3ffc60 --- /dev/null +++ b/expression/Constante.h @@ -0,0 +1,64 @@ +#ifndef _CONST_ +#define _CONST_ + +#include "Fonction.h" + +//! Classe Constante. +/*! + C'est une fonction d'arité 0. Elle contient juste une valeur booleenne : true ou false. +*/ + +class Constante : public Fonction +{ + public : + //! Constructeur par defaut. + /*! + Constructeur par défaut pour les constantes. + */ + Constante(); + //! Constructeur par copie. + /*! + Constructeur par copie pour les constantes. + */ + Constante(const Constante &); + //! Constructeur standard. + /*! + Constructeur à partir d'un booléen pour les constantes. + \param v : Valeur de la constante. + */ + Constante(const bool &v); + //! Destructeur. + /*! + Destructeur pour les constantes. + */ + ~Constante(); + + //! Fonction membre d'affichage d'une constante. + /*! + Affiche une constante (un booléen). + */ + void Afficher () const; + + //! Fonction membre d'évaluation d'une constante. + /*! + \return Valeur de la constante. + */ + bool Evaluer() const; + + //! Fonction membre retournant une expression. + /*! + \sa Constante(const bool &). + \return Une nouvelle constante initialisée à la même valeur que celle implicite. + */ + Expression *Copie() const; + + private : + + //! Donnée privée. + /*! + Valeur de la constante. + */ + const bool val; +}; + +#endif diff --git a/expression/Et.cpp b/expression/Et.cpp new file mode 100644 index 0000000..5e68a0f --- /dev/null +++ b/expression/Et.cpp @@ -0,0 +1,50 @@ +#include "Et.h" + +#include +#include +#include +using namespace std; + +//CETTE PARTIE NE SERT QUE DANS LE CAS D'UNE COMPILATION AVEC +//C++ BUILDER. DONC AVEC GCC ON RAJOUTE -D _NUNUX_ A LA COMPIL ! +#ifndef _NUNUX_ + +#include +#pragma hdrstop + +#endif + +Et::Et(const Expression *e1, const Expression *e2): +Fonction(e1,e2) +{ + nbvars = (e1->NbVars() + e2->NbVars()); +} + +Et::Et(const Et &e): +Fonction(e.expr[0],e.expr[1]) +{ + nbvars = e.NbVars(); +} + +Et::~Et() +{ +} + +void Et::Afficher () const +{ + cout << "("; + expr[0]->Afficher(); + cout << "&"; + expr[1]->Afficher(); + cout << ")"; +} + +bool Et::Evaluer() const +{ + return (expr[0]->Evaluer() && expr[1]->Evaluer()); +} + +Expression *Et::Copie() const +{ + return new Et(expr[0], expr[1]); +} diff --git a/expression/Et.h b/expression/Et.h new file mode 100644 index 0000000..0441ebd --- /dev/null +++ b/expression/Et.h @@ -0,0 +1,56 @@ +#ifndef _ET_ +#define _ET_ + +#include "Fonction.h" +#include "TableVerite.h" + +//! Classe Et. +/*! + Opérateur logique binaire "et", classe dérivée de Fonction. +*/ +class Et : public Fonction +{ + public : + //! Constructeur standard. + /*! + Constructeur à partir de 2 expressions. + \param e1 : Première expression. + \param e2 : Seconde expression. + \sa Copie(), NbVars() + */ + Et(const Expression *e1, const Expression *e2); + //! Constructeur par copie. + /*! + Constructeur par copie pour l'opérateur "et". + \sa NbVars() + */ + Et(const Et &); + //! Destructeur. + /*! + Destructeur pour l'opérateur "et". + */ + ~Et(); + + //! Fonction membre d'affichage. + /*! + Affiche les 2 expressions séparées par le symbole "&". + */ + void Afficher () const; + + //! Fonction membre d'évaluation. + /*! + \return Resultat de l'expression. + */ + bool Evaluer() const; + + //! Fonction membre retournant une expression. + /*! + \sa Et(const Expression *, const Expression *). + \return Une copie de l'expression. + */ + Expression *Copie() const; + + private : +}; + +#endif diff --git a/expression/Expression.cpp b/expression/Expression.cpp new file mode 100644 index 0000000..00aabf5 --- /dev/null +++ b/expression/Expression.cpp @@ -0,0 +1,88 @@ +#include "Expression.h" + +#include +#include +using namespace std; + +//CETTE PARTIE NE SERT QUE DANS LE CAS D'UNE COMPILATION AVEC +//C++ BUILDER. DONC AVEC GCC ON RAJOUTE -D _NUNUX_ A LA COMPIL ! +#ifndef _NUNUX_ + +#include +#pragma hdrstop + +#endif + +Expression::Expression() +{ +} + +Expression::~Expression() +{ +} + +int Expression::NbVars() const +{ + return nbvars; +} + +TableVerite Expression::TabVerite() const +{ + Variable **vars; + Variable **nvars; + int nbv; + Expression *e = this->Copie(); + + int i,j,jpuiss,nbpuiss; + + //on initialise le nombre de variables à 0. Ce sera incrémenté lors de la recherche des variables. + nbv = 0; + + //allocation des tableaux de pointeurs vers les variables + //ces tableaux contiendront au plus nbvars pointeurs vers des Variable + //le premier sert à mémoriser les adresses des variables de l'expression d'origine + //le deuxième sert à contenir les adresses des nouvelles variables + vars = new Variable *[NbVars()]; + nvars = new Variable *[NbVars()]; + + //recherche des variables + e->Chercher_variables(vars, nvars, nbv, this->NbVars()); + + //calcul de 2^nbvars + nbpuiss = (int)pow(2.,(double)nbv); + //création de la table de vérité + TableVerite tab =TableVerite(nbv); + tab.SetVars(vars); + + //recherche des valeurs de vérité pour toutes les combinaisons de valeurs (true/false) + //pour toutes les variables + + //pour i de 0 à 2^nbvars + for (i=0 ; iAffecter(true); + else + nvars[nbv-j-1]->Affecter(false); + jpuiss *= 2; + } + tab.SetVal(i,e->Evaluer()); + } + + //libération des nouvelles variables + for (i=0 ; i + using namespace std; + +//CETTE PARTIE NE SERT QUE DANS LE CAS D'UNE COMPILATION AVEC +//C++ BUILDER. DONC AVEC GCC ON RAJOUTE -D _NUNUX_ A LA COMPIL ! +#ifndef _NUNUX_ + +#include +#pragma hdrstop + +#endif + +Fonction::Fonction(): +arite(0) +{ +} + +Fonction::Fonction(const Expression *e): +arite(1),expr(new Expression *[1]) +{ + expr[0] = e->Copie(); +} + +Fonction::Fonction(const Expression *e1, const Expression *e2): +arite(2),expr(new Expression *[2]) +{ + expr[0] = e1->Copie(); + expr[1] = e2->Copie(); +} + +Fonction::~Fonction() +{ + int i; + for (i=0 ; i0) + delete [] expr; +} + +void Fonction::ChangerExpr(const int &i, const Expression *e) +{ + if ((i>=0) && (iNbVars(); + delete expr[i]; + expr[i] = e->Copie(); + nbvars += e->NbVars(); + } +} + +void Fonction::Chercher_variables(Variable **vars, Variable **nvars, int &nbv, const int &nbvars) +{ + int i; + for (i=0 ; iChercher_variables(vars, nvars, nbv, nbvars); +} + +Expression *Fonction::Fils() const +{ + if (arite == 0) + return NULL; + return expr[random()%arite]; +} + diff --git a/expression/Fonction.h b/expression/Fonction.h new file mode 100644 index 0000000..18fd8d8 --- /dev/null +++ b/expression/Fonction.h @@ -0,0 +1,81 @@ +#ifndef _FCT_ +#define _FCT_ + +#include "Expression.h" +#include + +//! Classe fonction. +/*! + Cette classe est une classe dérivée de Expression. + C'est grâce à cette classe qu'on va pouvoir construire des fonction d'arité 0 (Constantes par exemple), + des fonctions d'arité 1 (Non par exemple) et des fonction d'arité 2 (Et par exemple) ... +*/ +class Fonction : public Expression +{ + public : + //! Constructeur par défaut. + /*! + Constructeur par défaut pour les fonctions. + */ + Fonction(); + + //! Constructeur standard. + /*! + Constructeur à partir d'une expression. + */ + Fonction(const Expression *e); + + //! Constructeur standard. + /*! + Constructeur à partir de deux expressions. + */ + Fonction(const Expression *e1, const Expression *e2); + + //! Destructeur. + /*! + Destructeur pour les fonctions. Il va s'occuper de détruire récursivement les expressions en données membres + qui sont des copies des fonctions d'origine et qu'il faut donc détruire. + */ + ~Fonction(); + + //! Fonction membre à 1 argument. + /*! + Accesseur permettant de modifier une expression de la Fonction. + \param i : indice de l'expression à modifier. + \param e : nouvelle expression + */ + void ChangerExpr(const int &i, const Expression *e); + + //! Fonction membre à 4 arguments. + /*! + \param vars : tableau des variables de l'expression + \param nvars : tableau des nouvelles variables associées à l'expression copiée + \param nbv : nombre de variables de l'expression (chacune est comptée une seule fois) + \param nbvars : Le nombre de variables différentes de l'expression + */ + void Chercher_variables(Variable **vars, Variable **nvars, int &nbv, const int &nbvars); + + //! Fonction membre qui retourne un fils au hasard ou NULL. + /*! + \return Un fils au hasard. + */ + Expression * Fils() const; + + + + protected : + //! Donnée protegée. + /*! + Arité de la fonction. + */ + int arite; + //! Donnée protegée. + /*! + Tableau d'Expressions. + */ + Expression **expr; + + private : +}; + +#endif diff --git a/expression/Makefile b/expression/Makefile new file mode 100644 index 0000000..95bf7a1 --- /dev/null +++ b/expression/Makefile @@ -0,0 +1,32 @@ +CCPP = g++ +OBJS = TableVerite.o Variable.o Expression.o VarExpr.o Fonction.o Constante.o Ou.o Et.o Non.o +CPPFLAGS = -D _NUNUX_ + +Exemple : $(OBJS) + +Constante.o : Constante.h Fonction.o + $(CCPP) $(CPPFLAGS) -c Constante.cpp + +Non.o : Non.h Fonction.o + $(CC) $(CPPFLAGS) -c Non.cpp + +Et.o : Et.h Fonction.o + $(CCPP) $(CPPFLAGS) -c Et.cpp + +Ou.o : Ou.h Fonction.o + $(CCPP) $(CPPFLAGS) -c Ou.cpp + +VarExpr.o : VarExpr.h Variable.o + $(CCPP) $(CPPFLAGS) -c VarExpr.cpp + +Fonction.o : Fonction.h Variable.o Expression.o + $(CCPP) $(CPPFLAGS) -c Fonction.cpp + +Expression.o : Expression.h TableVerite.o + $(CCPP) $(CPPFLAGS) -c Expression.cpp + +Variable.o : Variable.h + $(CCPP) $(CPPFLAGS) -c Variable.cpp + +TableVerite.o : TableVerite.h + $(CCPP) $(CPPFLAGS) -c TableVerite.cpp diff --git a/expression/Non.cpp b/expression/Non.cpp new file mode 100644 index 0000000..69cf9e3 --- /dev/null +++ b/expression/Non.cpp @@ -0,0 +1,52 @@ +#include "Non.h" + +#include +#include +#include +using namespace std; + +//CETTE PARTIE NE SERT QUE DANS LE CAS D'UNE COMPILATION AVEC +//C++ BUILDER. DONC AVEC GCC ON RAJOUTE -D _NUNUX_ A LA COMPIL ! +#ifndef _NUNUX_ + +#include +#pragma hdrstop + +#endif + +Non::Non(const Expression *e): +Fonction(e) +{ + nbvars = e->NbVars(); +} + +Non::Non(const Non &n): +Fonction(n.expr[0]) +{ + nbvars = n.NbVars(); +} + +Non::~Non() +{ +} + +void Non::Afficher () const +{ + cout << "!"; + expr[0]->Afficher(); +} + +bool Non::Evaluer() const +{ + return (! expr[0]->Evaluer()); +} + +Expression *Non::Copie() const +{ + return new Non(expr[0]); +} + +void Non::Chercher_variables(Variable **vars, Variable **nvars, int &nbv, const int &nbvars) +{ + expr[0]->Chercher_variables(vars, nvars, nbv, nbvars); +} diff --git a/expression/Non.h b/expression/Non.h new file mode 100644 index 0000000..f444d3c --- /dev/null +++ b/expression/Non.h @@ -0,0 +1,62 @@ +#ifndef _NON_ +#define _NON_ + +#include "Fonction.h" + +//! Classe Non. +/*! + Opérateur logique unaire "non", classe dérivée de Fonction. +*/ +class Non : public Fonction +{ + public : + //! Constructeur standard. + /*! + Constructeur à partir d'une expression. + \sa Copie(), NbVars() + */ + Non(const Expression *); + //! Constructeur par copie. + /*! + Constructeur par copie pour l'opérateur "non". + \sa NbVars() + */ + Non(const Non &); + //! Destructeur. + /*! + Destructeur pour l'opérateur "non". + */ + ~Non(); + + //! Fonction membre d'affichage. + /*! + Affiche l'expression précédée du symbole "!". + */ + void Afficher () const; + + //! Fonction membre d'évaluation. + /*! + \return Resultat de l'expression. + */ + bool Evaluer() const; + + //! Fonction membre à 4 arguments. + /*! + \param vars : tableau des variables de l'expression + \param nvars : tableau des nouvelles variables associées à l'expression copiée + \param nbv : nombre de variables de l'expression (chacune est comptée une seule fois) + \param nbvars : Le nombre de variables différentes de l'expression + */ + void Chercher_variables(Variable **vars, Variable **nvars, int &nbv, const int &nbvars); + + //! Fonction membre retournant une expression. + /*! + \sa Non(const Expression *). + \return Une copie de l'expression. + */ + Expression *Copie() const; + + private : +}; + +#endif diff --git a/expression/Ou.cpp b/expression/Ou.cpp new file mode 100644 index 0000000..0c6798a --- /dev/null +++ b/expression/Ou.cpp @@ -0,0 +1,51 @@ +#include "Ou.h" + +#include +#include +#include +using namespace std; + +//CETTE PARTIE NE SERT QUE DANS LE CAS D'UNE COMPILATION AVEC +//C++ BUILDER. DONC AVEC GCC ON RAJOUTE -D _NUNUX_ A LA COMPIL ! +#ifndef _NUNUX_ + +#include +#pragma hdrstop + +#endif + +Ou::Ou(const Expression *e1, const Expression *e2): +Fonction(e1,e2) +{ + nbvars = (e1->NbVars() + e2->NbVars()); +} + +Ou::Ou(const Ou &o): +Fonction(o.expr[0],o.expr[1]) +{ + nbvars = o.NbVars(); +} + +Ou::~Ou() +{ +} + +void Ou::Afficher () const +{ + cout << "("; + expr[0]->Afficher(); + cout << "V"; + expr[1]->Afficher(); + cout << ")"; +} + +bool Ou::Evaluer() const +{ + return (expr[0]->Evaluer() || expr[1]->Evaluer()); +} + + +Expression *Ou::Copie() const +{ + return new Ou(expr[0], expr[1]); +} diff --git a/expression/Ou.h b/expression/Ou.h new file mode 100644 index 0000000..e26b4e8 --- /dev/null +++ b/expression/Ou.h @@ -0,0 +1,53 @@ +#ifndef _OU_ +#define _OU_ + +#include "Fonction.h" + +//! Classe Ou. +/*! + Opérateur logique binaire "ou", classe dérivée de Fonction. +*/ +class Ou : public Fonction +{ + public : + //! Constructeur satndard. + /*! + Constructeur à partir de 2 expressions. + \sa Copie(), NbVars() + */ + Ou(const Expression *, const Expression *); + //! Constructeur par copie. + /*! + Constructeur par copie pour l'opérateur "ou". + \sa NbVars() + */ + Ou(const Ou &); + //! Destructeur. + /*! + Destructeur pour l'opérateur "ou". + */ + ~Ou(); + + //! Fonction membre d'affichage. + /*! + Affiche les 2 expressions séparée par le symbole "V". + */ + void Afficher () const; + + //! Fonction membre d'évaluation. + /*! + \return Resultat de l'expression. + */ + bool Evaluer() const; + + //! Fonction membre retournant une expression. + /*! + \sa Ou(const Expression *, const Expression *). + \return Une copie de l'expression. + */ + Expression *Copie() const; + + private : +}; + +#endif diff --git a/expression/TableVerite.cpp b/expression/TableVerite.cpp new file mode 100644 index 0000000..6085907 --- /dev/null +++ b/expression/TableVerite.cpp @@ -0,0 +1,113 @@ +#include "TableVerite.h" + +#include +#include +#include +#include +using namespace std; + +//CETTE PARTIE NE SERT QUE DANS LE CAS D'UNE COMPILATION AVEC +//C++ BUILDER. DONC AVEC GCC ON RAJOUTE -D _NUNUX_ A LA COMPIL ! +#ifndef _NUNUX_ + +#include +#pragma hdrstop + +#endif + +TableVerite::TableVerite(): +nbvars(0) +{ +} + +TableVerite::TableVerite(const int &nbv): +nbvars(nbv) +{ + int nbvals = (int)pow(2.,(double)nbv); + //allocation du tableau qui contiendra les valeurs de la table de vérité + vals = new bool[nbvals]; + + vars = new char *[nbvars]; +} + +TableVerite::TableVerite(const TableVerite &tab): +nbvars(tab.nbvars) +{ + int i, nbvals = (int)pow(2.,(double)nbvars); + //allocation du tableau qui contiendra les valeurs de la table de vérité + vals = new bool[nbvals]; + + vars = new char *[nbvars]; + + for (i=0 ; iNom()); +} + +//Affichage +void TableVerite::Afficher() const +{ + int i, j, nbpuiss = (int)pow(2.,(double)nbvars); + + for (i=0 ; i +#include +#include +using namespace std; + +//CETTE PARTIE NE SERT QUE DANS LE CAS D'UNE COMPILATION AVEC +//C++ BUILDER. DONC AVEC GCC ON RAJOUTE -D _NUNUX_ A LA COMPIL ! +#ifndef _NUNUX_ + +#include +#pragma hdrstop + +#endif + +VarExpr::VarExpr(Variable *v): +var(v) +{ + nbvars=1; +} + +VarExpr::VarExpr(const VarExpr &v): +var(v.var) +{ + nbvars=v.nbvars; +} + +VarExpr::~VarExpr() +{ +} + +void VarExpr::Afficher () const +{ + var->Afficher(); +} + +bool VarExpr::Evaluer() const +{ + return var->Valeur(); +} + +Expression *VarExpr::Copie() const +{ + return new VarExpr(var); +} + +void VarExpr::Chercher_variables(Variable **vars, Variable **nvars, int &nbv, const int &nbvars) +{ + + //création d'une nouvelle variable pour pouvoir + //essayer toutes les valeurs de vérités + Variable *temp = new Variable(strdup(var->Nom())); + + //ajout de la variable dans la liste des variables de la table de verite + int i=nbvars; + //recherche de la variable dans la liste des variables de la table de vérité + while (i>0) + { + //si la variable est déjà dans la liste il n'y a rien à faire + if (vars[nbvars-i] == var) + break; + i--; + } + + if (i==0) + { + //la Variable n'est pas dans la liste donc il faut l'ajouter. + vars[nbv]=var; + nvars[nbv]=temp; + nbv++; + + //remplacement de la Variable de la formule par la nouvelle + var = temp; + } + else + { + //la Variable est déjà dans la liste à l'emplacement nbvars-i + //on remplace juste la Variable de la formule par celle de nvars + var = nvars[nbvars-i]; + } +} + +Expression *VarExpr::Fils() const +{ + return NULL; +} diff --git a/expression/VarExpr.h b/expression/VarExpr.h new file mode 100644 index 0000000..2c37266 --- /dev/null +++ b/expression/VarExpr.h @@ -0,0 +1,75 @@ +#ifndef _VE_ +#define _VE_ + +#include "Variable.h" +#include "Expression.h" + +//! Classe VarExpr. +/*! + Expression de variables, classe dérivée de Fonction. +*/ +class VarExpr : public Expression +{ + public : + //! Constructeur standard. + /*! + Constructeur à partir d'une variable. + \param v : Variable a mettre dans l'expression. + */ + VarExpr(Variable *v); + //! Constructeur par copie. + /*! + Constructeur par copie pour les expression de variables. + */ + VarExpr(const VarExpr &); + //! Destructeur. + /*! + Destructeur pour les expression de variables. + */ + ~VarExpr(); + + //! Fonction membre d'affichage. + /*! + Affiche l'expression de variables. + */ + void Afficher () const; + + //! Fonction membre d'évaluation. + /*! + \sa Valeur() + \return Resultat de l'expression. + */ + bool Evaluer() const; + + //! Fonction membre à 4 arguments. + /*! + \param vars : tableau des variables de l'expression + \param nvars : tableau des nouvelles variables associées à l'expression copiée + \param nbv : nombre de variables de l'expression (chacune est comptée une seule fois) + \param nbvars : Le nombre de variables différentes de l'expression + */ + void Chercher_variables(Variable **vars, Variable **nvars, int &nbv, const int &nbvars); + + //! Fonction membre retournant une expression. + /*! + \sa Variable (const char *). + \return Une copie de l'expression. + */ + Expression *Copie() const; + + //! Fonction membre qui retourne un fils au hasard ou NULL. + /*! + \return Un fils au hasard. + */ + Expression * Fils() const; + + + private : + //! Donnée privée. + /*! + Une variable. + */ + Variable *var; +}; + +#endif diff --git a/expression/Variable.cpp b/expression/Variable.cpp new file mode 100644 index 0000000..56c8d09 --- /dev/null +++ b/expression/Variable.cpp @@ -0,0 +1,63 @@ +#include "Variable.h" + +#include +#include +#include +using namespace std; + +//CETTE PARTIE NE SERT QUE DANS LE CAS D'UNE COMPILATION AVEC +//C++ BUILDER. DONC AVEC GCC ON RAJOUTE -D _NUNUX_ A LA COMPIL ! +#ifndef _NUNUX_ + +#include +#pragma hdrstop + +#endif + +//Constructeurs / Destructeurs +Variable::Variable(): +N("Defaut"),val(true) +{ +} + +Variable::Variable(const Variable &v): +N(strdup(v.N)),val(v.val) +{ +} + +Variable::Variable(const char *nm): +N(strdup(nm)),val(true) +{ +} + +Variable::Variable(const char *nm, const bool &v): +N(strdup(nm)),val(v) +{ +} + +Variable::~Variable() +{ + delete N; +} + +//Accesseurs +char *Variable::Nom() const +{ + return N; +} + +bool Variable::Valeur() const +{ + return val; +} + +//Affichage +void Variable::Afficher() const +{ + cout << N;//"(" << N << ":" << val << ")"; +} + +void Variable::Affecter(const bool &v) +{ + val = v; +} diff --git a/expression/Variable.h b/expression/Variable.h new file mode 100644 index 0000000..c3b16bf --- /dev/null +++ b/expression/Variable.h @@ -0,0 +1,77 @@ +#ifndef _VAR_ + +#define _VAR_ + +//! Classe Variable. +/*! + Gestion des variables. +*/ +class Variable +{ + public : + //! Constructeur par défaut. + /*! + Constructeur par défaut pour une variable. + */ + Variable(); + //! Constructeur par copie. + /*! + Constructeur par copie pour une variable. + */ + Variable(const Variable &); + //! Constructeur standard. + /*! + Constructeur à partir d'une chaine de caractères. La variable est initialisée à true + \param nm : nom de la variable. + */ + Variable(const char *nm); + //! Constructeur standard. + /*! + Constructeur à partir d'une chaine de caractères et d'un booléen. + \param nm : nom de la variable + \param v : valeur de la variable + */ + Variable(const char *nm, const bool &v); + //! Destructeur. + /*! + Destructeur pour les variables. + */ + ~Variable(); + + //! Accesseur. + /*! + \return Le nom de la variable. + */ + char *Nom() const; + //! Accesseur. + /*! + \return La valeur de la variable. + */ + bool Valeur() const; + + //! Fonction membre d'affichage. + /*! + Affiche la variable. + */ + void Afficher() const; + //! Fonction membre d'affectation. + /*! + Modifie la valeur de la variable. + \param v : valeur à mettre dans la variable. + */ + void Affecter(const bool &v); + + private : + //! Donnée privée. + /*! + Le nom d'une variable. + */ + char *N; + //! Donnée privée. + /*! + La valeur d'une variable. + */ + bool val; +}; + +#endif diff --git a/framework/Algogen.cpp b/framework/Algogen.cpp new file mode 100644 index 0000000..5353fa3 --- /dev/null +++ b/framework/Algogen.cpp @@ -0,0 +1,78 @@ +#include "Algogen.h" +#include +#include +using namespace std; + +Algogen::Algogen() +:generation(1),generationmax(GENERATIONMAX),taillepop(TAILLEPOP),tauxmutation(TAUXMUT),pop(NULL) +{ +} + +Algogen::Algogen(const Algogen &a) +:generation(a.generation),generationmax(a.generationmax),taillepop(a.taillepop),tauxmutation(a.tauxmutation),pop(a.pop->Copie()) +{ +} + +Algogen::Algogen(Population *p, const double &tm, const int &gm) +:generation(1),generationmax(gm),taillepop(p->Taillepop()),tauxmutation(tm),pop(p) +{ + pop->CreerPopulationAleatoire(); + pop->Evaluation(); +} + +Algogen::~Algogen() +{ + delete pop; +} + +int Algogen::Generation() const +{ + return generation; +} + +double Algogen::GetTauxMutation() const +{ + return tauxmutation; +} + +void Algogen::SetTauxMutation(const double &tm) +{ + tauxmutation = tm; +} + +int Algogen::GetTaillePopulation() const +{ + return taillepop; +} + +void Algogen::SetTaillePopulation(const int &tp) +{ + taillepop = tp;; +} + + +void Algogen::Executer() +{ + Population *p1; + bool cont = true; + + while(cont && (generation < generationmax)) + { + p1 = pop->ReproductionParCroisement(); + p1->Mutation(tauxmutation); + p1->Evaluation(); + pop->Selection(p1); + delete p1; + generation++; + cont = !(pop->EvaluerCondition()); + } + if (!cont) + cout << "Objectif atteint" << endl; + else + cout << "Generation max atteinte" << endl; +} + +void Algogen::AfficherMeilleur() const +{ + pop->Ind(pop->Meilleur())->Afficher(); +} diff --git a/framework/Algogen.h b/framework/Algogen.h new file mode 100644 index 0000000..3a4c00a --- /dev/null +++ b/framework/Algogen.h @@ -0,0 +1,42 @@ +#ifndef _ALGOG_ +#define _ALGOG_ + +#define TAUXMUT 0.1 +#define GENERATIONMAX 100 +#include "Population.h" + +class Algogen +{ + public : + Algogen(); + Algogen(const Algogen &); + Algogen(Population *p, const double &tm, const int &gm); + ~Algogen(); + + //accesseurs + int Generation() const; + double GetTauxMutation() const; + void SetTauxMutation(const double &); + int GetTaillePopulation() const; + void SetTaillePopulation(const int &); + + //l'utilisateur peut vouloir ajouter des choses à faire + virtual void Executer(); + + //affichage du meilleur élément + void AfficherMeilleur() const; + + private : + //génération courante + int generation; + //generationmaximale + int generationmax; + //taille de la population + int taillepop; + //taux de mutation (en %) + double tauxmutation; + //population de la génération courante + Population *pop; +}; + +#endif diff --git a/framework/Individu.cpp b/framework/Individu.cpp new file mode 100644 index 0000000..f93ca6e --- /dev/null +++ b/framework/Individu.cpp @@ -0,0 +1,13 @@ +#include "Individu.h" + +Individu::Individu() +{ +} + +Individu::Individu(const Individu &i) +{ +} + +Individu::~Individu() +{ +} diff --git a/framework/Individu.h b/framework/Individu.h new file mode 100644 index 0000000..f7b2e50 --- /dev/null +++ b/framework/Individu.h @@ -0,0 +1,33 @@ +#ifndef _IND_ +#define _IND_ + +class Individu +{ + public : + Individu(); + Individu(const Individu &); + virtual ~Individu(); + + //Fonctions utiles pour la population + + //retourne un point de coupure sur l'individu. + virtual void * PtCoupure()const=0; + + //croisement de deux individus : points de coupure etc... + virtual Individu *Croiser(const Individu *) const=0; + + //copie d'un individu. + virtual Individu *Copie() const=0; + + //modification d'une partie de l'individu + virtual void Muter()=0; + + //évalue le score de l'individu. + virtual int Evaluation() const=0; + + //affiche l'individu + virtual void Afficher() const=0; + + private : +}; +#endif diff --git a/framework/Makefile b/framework/Makefile new file mode 100644 index 0000000..3e002ac --- /dev/null +++ b/framework/Makefile @@ -0,0 +1,14 @@ +CCPP = g++ +OBJS = Algogen.o Population.o +CPPFLAGS = -D _NUNUX_ + +framework : Algogen.o Population.o Individu.o + +Algogen.o : Algogen.h Population.h + $(CCPP) $(CPPFLAGS) -c Algogen.cpp + +Population.o : Population.h Individu.h + $(CCPP) $(CPPFLAGS) -c Population.cpp + +Individu.o : Individu.h + $(CCPP) $(CPPFLAGS) -c Individu.cpp diff --git a/framework/Population.cpp b/framework/Population.cpp new file mode 100644 index 0000000..45ee8a3 --- /dev/null +++ b/framework/Population.cpp @@ -0,0 +1,233 @@ +#include "Population.h" + +#include +#include +using namespace std; + +Population::Population() +:taillepop(TAILLEPOP),individus(new Individu *[taillepop]),score(new int[taillepop]) +{ + int i; + for (i=0 ; iCopie(); + score[i] = p.score[i]; + } +} + + +Population::Population(const int &tp) +:taillepop(tp),individus(new Individu *[taillepop]),score(new int[taillepop]) +{ + int i; + for (i=0 ; iCopie(); + + //réinitialisation de la nouvelle population + for (i=0 ; itaillepop ; i++) + { + if (newpop->individus[i] != NULL) + delete newpop->individus[i]; + newpop->individus[i] = NULL; + newpop->score[i] = -1; + } + + //création des individus + for (i=0 ; itaillepop ; i++) + { + j = random() % taillepop; + pere = individus[j]; + j = random() % taillepop; + mere = individus[j]; + newpop->individus[i] = pere->Croiser(mere); + } + + return newpop; +} + +void Population::Mutation(const double & tauxmutation) +{ + int nbamuter = (int) (tauxmutation * (double)taillepop); + int i,j; + Individu *amuter; + + for (i=0 ; iMuter(); + } +} + +void Population::Evaluation() +{ + int i; + for (i=0 ; iEvaluation(); +} + +void Population::Selection(const Population *pop2) +{ + int selectionnes = 0; + int i, i1 = taillepop - 1, i2 = pop2->taillepop - 1; + + //on copie la population présente afin de garantir de construire un population + //du même type. + Population *newpop = this->Copie(); + + //réinitialisation de la population + for (i=0 ; itaillepop-1); + Trier(pop2, 0, pop2->taillepop-1); + while (selectionnes < taillepop) + { + //on cherche l'élément qui a le plus gros score parmi les deux populations + if ((i2<0) || ((i1>=0)&&(newpop->score[i1] > pop2->score[i2]))) + { + individus[selectionnes] = newpop->individus[i1]->Copie(); + score[selectionnes] = newpop->score[i1]; + i1--; + } + else + { + individus[selectionnes] = pop2->individus[i2]->Copie(); + score[selectionnes] = pop2->score[i2]; + i2--; + } + selectionnes++; + } + delete newpop; +} + +void Trier(const Population*pop, const int &inf, const int &sup) +{ + int milieu; + if (sup > inf) + { + // s'il y a au moins 2 éléments + milieu = Partition(pop, inf,sup); + + // trier la partie de gauche + Trier(pop, inf,milieu); + + // trier la partie de droite + Trier(pop, milieu+1, sup); + } +} + +int Partition(const Population *pop, const int &inf, const int &sup) +{ + int pivot, tempo; + Individu *tempind; + int i,j; + + pivot = pop->score[(sup+inf)/2]; + i = inf -1; + j = sup+1; + + // tant que les index ne croisent pas + while (iscore[i]score[j]>pivot); + + // Permuter les éléments qui ne sont pas + // à leur place + if ( i < j ) + { + tempo = pop->score[i]; + pop->score[i]= pop->score[j]; + pop->score[j]= tempo; + tempind = pop->individus[i]; + pop->individus[i]= pop->individus[j]; + pop->individus[j]= tempind; + } + } + return j; +} + +int Population::Meilleur() const +{ + int i, max, scoremax=-1; + + for (i=0;i scoremax) + { + max = i; + scoremax=score[i]; + } + + return max; +} + +int Population::Taillepop() const +{ + return taillepop; +} + +int Population::Score(const int &i) const +{ + return score[i]; +} + +Individu * Population::Ind(const int &i) const +{ + return individus[i]; +} + +void Population::SetInd(const int &i, Individu *ind) +{ + individus[i]=ind; +} diff --git a/framework/Population.h b/framework/Population.h new file mode 100644 index 0000000..b0beb69 --- /dev/null +++ b/framework/Population.h @@ -0,0 +1,65 @@ +#ifndef _POP_ +#define _POP_ +#define TAILLEPOP 10 + +#include "Individu.h" + +class Population +{ + public : + Population(); + Population(const Population &); + Population(const int &tp); + virtual ~Population(); + + //on ne connait pas le type des individus donc on met en virtuel pur + virtual void CreerPopulationAleatoire()=0; + + //fonction virtuel car l'utilisateur du framework peut décider d'utiliser + //une stratégie de reproduction. Par exemple différencier les pères des mères + //ou faire se reproduire seulement les meilleurs, etc... + virtual Population *ReproductionParCroisement(); + + //fonction virtuelle car l'utilisateur peut vouloir appliquer une stratégie + //de mutation de population différente. Par exemple muter les plus mauvais + //ou éviter la possibiliter de muter plusieurs fois le même individu + virtual void Mutation(const double &); + + void Evaluation(); + + //cette fonction est virtuelle car l'utilisateur peut vouloir définir une + //stratégie de sélection plus précise. Il peut décider de favoriser soit + //l'ancienne soit la nouvelle génération. Dans la fonction implémentée ici + //c'est la nouvelle qui est privilégiée. + virtual void Selection(const Population *); + + //on ne sait pas quel est le but à atteindre donc cette fonction est virtuelle + //pure. + virtual bool EvaluerCondition() const=0; + + //retourne l'indice du meilleur individu + int Meilleur() const; + + //copie d'une population. Pour un constructeur virtuel + virtual Population * Copie() const=0; + + //accesseurs + int Taillepop() const; + + int Score(const int &) const; + + Individu * Ind(const int &) const; + void SetInd(const int &, Individu *); + + private : + int taillepop; + Individu **individus; + int *score; + + //implémentation du Quicksort pour les population. Ceci est utile pour la + //fonction de Sélection par défaut implémentée dans ce fichier. + friend void Trier(const Population *pop, const int &inf, const int &sup); + friend int Partition(const Population *pop, const int &inf, const int &sup); +}; + +#endif diff --git a/main.cpp b/main.cpp new file mode 100644 index 0000000..5b83ee6 --- /dev/null +++ b/main.cpp @@ -0,0 +1,79 @@ +#include "IExp.h" +#include "PopExp.h" +#include "framework/Individu.h" +#include "framework/Population.h" +#include "framework/Algogen.h" +#include "expression/Expression.h" +#include "expression/Variable.h" +#include "expression/Fonction.h" +#include "expression/VarExpr.h" +#include "expression/Constante.h" +#include "expression/Ou.h" +#include "expression/Et.h" +#include "expression/Non.h" + +#include +#include +using namespace std; + +//CETTE PARTIE NE SERT QUE DANS LE CAS D'UNE COMPILATION AVEC +//C++ BUILDER. DONC AVEC GCC ON RAJOUTE -D _NUNUX_ A LA COMPIL ! +#ifndef _NUNUX_ + + #include + + #pragma hdrstop + USEUNIT("\expression\Et.cpp"); + USEUNIT("\expression\Ou.cpp"); + USEUNIT("\expression\Non.cpp"); + USEUNIT("\expression\Constante.cpp"); + USEUNIT("\expression\Fonction.cpp"); + USEUNIT("\expression\VarExpr.cpp"); + USEUNIT("\expression\Expression.cpp"); + USEUNIT("\expression\Variable.cpp"); +#endif + +int main() +{ + Variable *a = new Variable("a"); + Variable *b = new Variable("b"); + Variable *c= new Variable("c"); + + Expression *va = new VarExpr(a); + Expression *vb = new VarExpr(b); + Expression *vc = new VarExpr(c); + + Expression *p = new Et(va,vb); + Expression *t = new Constante(true); + Expression *q = new Et(t,vb); + Expression *r = new Non(q); + Expression *s = new Ou(vc,r); + + Expression *expr = new Ou(p,s); + + expr->Afficher(); + cout << endl; + + TableVerite tab = expr->TabVerite(); + + tab.Afficher(); + + Population *pop = new PopExp(10,&tab); + Algogen *algo=new Algogen(pop, 0.1, 100); + + algo->Executer(); + cout << endl << "meilleur : "; + + algo->AfficherMeilleur(); + + cout << " score : " << pop->Score(pop->Meilleur()) << " génération : " << algo->Generation() << endl; + + cout << endl << "Population : " << endl; + for (int i=0 ; iTaillepop() ; i++) + { + pop->Ind(i)->Afficher(); + cout << " score : " << pop->Score(i) << endl; + } + + return 1; +}