--- /dev/null
+#include "IExp.h"
+
+#include <stdlib.h>
+#include <math.h>
+
+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 ; i<but->Nbvars() ; 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 ; i<tab->Nbvars() ; 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 ; i<tab->Nbvars() ; i++)
+ vars[i] = new Variable(tab->Var(i));
+ }
+}
+
+IExp::~IExp()
+{
+ nbindividus--;
+ if (nbindividus ==0)
+ {
+ int i;
+ if (vars != NULL)
+ {
+ for (i=0 ; i<but->Nbvars() ; 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 ; i<nbvals ; i++)
+ if (but->IemeValeur(i) == tab.IemeValeur(i))
+ score++;
+
+ return score;
+}
+
+void IExp::Afficher() const
+{
+ genome->Afficher();
+}
--- /dev/null
+#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
--- /dev/null
+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
--- /dev/null
+#include "PopExp.h"
+#include <math.h>
+#include <iostream>
+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 ; i<this->Taillepop() ; 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 ; i<this->Taillepop() ; 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);
+}
--- /dev/null
+#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
--- /dev/null
+#include "Constante.h"
+
+#include <stdlib.h>
+#include <math.h>
+#include <iostream>
+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 <vcl\vcl.h>
+#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);
+}
--- /dev/null
+#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
--- /dev/null
+#include "Et.h"
+
+#include <stdlib.h>
+#include <math.h>
+#include <iostream>
+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 <vcl\vcl.h>
+#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]);
+}
--- /dev/null
+#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
--- /dev/null
+#include "Expression.h"
+
+#include <math.h>
+#include <iostream>
+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 <vcl\vcl.h>
+#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 ; i<nbpuiss ; i++)
+ {
+ jpuiss = 1;
+ for (j = 0 ; j < nbv ; j++)
+ {
+ if ((jpuiss & i) != 0)
+ nvars[nbv-j-1]->Affecter(true);
+ else
+ nvars[nbv-j-1]->Affecter(false);
+ jpuiss *= 2;
+ }
+ tab.SetVal(i,e->Evaluer());
+ }
+
+ //libération des nouvelles variables
+ for (i=0 ; i<nbv ; i++)
+ delete nvars[i];
+
+ //libération des deux tableaux
+ delete [] vars;
+ delete [] nvars;
+
+ //destruction de la l'expression copiée
+ delete e;
+
+ //on retourne la table de vérité de l'expression
+ return tab;
+}
--- /dev/null
+#ifndef _EXP_\r
+#define _EXP_\r
+\r
+#include "TableVerite.h"\r
+\r
+//! Classe Expression. \r
+/*!\r
+ Classe abstraite. Elle représente une expression au sens général du terme. Que ce soit une fonction ou une variable.\r
+*/\r
+class Expression\r
+{\r
+ public :\r
+ //! Constructeur par défaut.\r
+ /*!\r
+ Constructeur par défaut d'une expression.\r
+ */\r
+ Expression();\r
+\r
+ //! Destructeur.\r
+ /*!\r
+ Destructeur pour les expression, fonction virtuelle.\r
+ */\r
+ virtual ~Expression();\r
+\r
+ //! Fonction membre d'affichage.\r
+ /*!\r
+ Affiche l'expression, fonction virtuelle pure.\r
+ */\r
+ virtual void Afficher () const = 0;\r
+\r
+ //! Fonction membre d'évaluation.\r
+ /*!\r
+ Fonction virtuelle pure.\r
+ \return Valeur de l'expression.\r
+ */\r
+ virtual bool Evaluer() const = 0;\r
+ //! Fonction membre retournant une table de vérité.\r
+ /*!\r
+ \return La table de vérité de l'expression.\r
+ */\r
+ TableVerite TabVerite() const;\r
+\r
+ //! Fonction membre qui retourne un fils au hasard ou NULL.\r
+ /*!\r
+ Fonction virtuelle pure.\r
+ \return Un fils au hasard.\r
+ */\r
+ virtual Expression *Fils() const = 0;\r
+\r
+ //! Accesseur.\r
+ /*!\r
+ \return Le nombre de variables de l'expression.\r
+ */\r
+ int NbVars() const;\r
+\r
+ //! Fonction membre retournant une expression.\r
+ /*!\r
+ Fonction virtuelle pure.\r
+ \return Une copie de l'expression.\r
+ */\r
+ virtual Expression *Copie() const=0;\r
+\r
+\r
+ //! Fonction membre à 4 arguments.\r
+ /*!\r
+ fonction virtuelle pure\r
+ \param vars : tableau des variables de l'expression\r
+ \param nvars : tableau des nouvelles variables associées à l'expression copiée\r
+ \param nbv : nombre de variables de l'expression (chacune est comptée une seule fois)\r
+ \param nbvars : Le nombre de variables différentes de l'expression\r
+ */\r
+ virtual void Chercher_variables(Variable **vars, Variable **nvars, int &nbv, const int &nbvars)=0;\r
+\r
+\r
+ protected :\r
+ //! Donnée protégée.\r
+ /*!\r
+ Le nombre de variables de l'expression. Donnée protégée car elle doit etre accessible aux fonctions qui héritent de Expression.\r
+ Elle sert à créer la table de vérité. Et surtout à ne pas recalculer ce nombre lors de cette création.\r
+ */\r
+ int nbvars;\r
+\r
+ private :\r
+\r
+ //! Constructeur par Copie.\r
+ /*!\r
+ Constructeur par copie d'une expression : protégé pour ne pas qu'il soit utilisé.\r
+ */\r
+ Expression(const Expression &);\r
+\r
+};\r
+\r
+#endif\r
--- /dev/null
+#include "Fonction.h"
+#include <iostream>
+ 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 <vcl\vcl.h>
+#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 ; i<arite ; i++)
+ delete expr[i];
+
+ if (arite>0)
+ delete [] expr;
+}
+
+void Fonction::ChangerExpr(const int &i, const Expression *e)
+{
+ if ((i>=0) && (i<arite))
+ {
+ nbvars -= expr[i]->NbVars();
+ 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 ; i<arite ; i++)
+ expr[i]->Chercher_variables(vars, nvars, nbv, nbvars);
+}
+
+Expression *Fonction::Fils() const
+{
+ if (arite == 0)
+ return NULL;
+ return expr[random()%arite];
+}
+
--- /dev/null
+#ifndef _FCT_
+#define _FCT_
+
+#include "Expression.h"
+#include <stdlib.h>
+
+//! 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
--- /dev/null
+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
--- /dev/null
+#include "Non.h"
+
+#include <stdlib.h>
+#include <math.h>
+#include <iostream>
+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 <vcl\vcl.h>
+#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);
+}
--- /dev/null
+#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
--- /dev/null
+#include "Ou.h"
+
+#include <stdlib.h>
+#include <math.h>
+#include <iostream>
+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 <vcl\vcl.h>
+#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]);
+}
--- /dev/null
+#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
--- /dev/null
+#include "TableVerite.h"
+
+#include <math.h>
+#include <stdio.h>
+#include <string.h>
+#include <iostream>
+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 <vcl\vcl.h>
+#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 ; i<nbvals ; i++)
+ vals[i]=tab.vals[i];
+
+ for (i=0 ; i<nbvars ; i++)
+ vars[i]=tab.vars[i];
+}
+
+TableVerite::~TableVerite()
+{
+ delete []vals;
+ delete []vars;
+}
+
+//Accesseurs
+const bool TableVerite::IemeValeur(const int &i) const
+{
+ return vals[i];
+}
+
+const int TableVerite::Nbvars() const
+{
+ return nbvars;
+}
+
+char * TableVerite::Var(const int &i) const
+{
+ return vars[i];
+}
+
+void TableVerite::SetVal(const int &i, const bool &v)
+{
+ vals[i]=v;
+}
+
+void TableVerite::SetVars(Variable **v)
+{
+ int i;
+ for (i=0 ; i<nbvars ; i++)
+ vars[i]=strdup(v[i]->Nom());
+}
+
+//Affichage
+void TableVerite::Afficher() const
+{
+ int i, j, nbpuiss = (int)pow(2.,(double)nbvars);
+
+ for (i=0 ; i<nbvars ; i++)
+ cout << "--------";
+ cout <<"-----------" << endl;
+
+ for (i=0 ; i<nbvars ; i++)
+ printf("| %5s ",vars[i]);
+
+ cout <<"| Valeurs |" << endl;
+
+ for (i=0 ; i<nbvars ; i++)
+ cout << "--------";
+ cout <<"-----------" << endl;
+
+ for (i=0 ; i<nbpuiss ; i++)
+ {
+ for (j=0 ; j<nbvars ; j++)
+ cout << "| " << ((i & (nbvars-j)) != 0) << " ";
+
+ cout <<"| " << vals[i] << " |" << endl;
+ }
+
+ for (i=0 ; i<nbvars ; i++)
+ cout << "--------";
+ cout <<"-----------" << endl;
+
+}
--- /dev/null
+#ifndef _TV_
+#define _TV_
+
+#include "Variable.h"
+
+//! Classe TableVerite.
+/*!
+ Cette classe sert à stocker les valeurs d'une table de vérité. En effet lorsqu'on
+ construit une table de vérité à partir d'une expression, on désire enregistrer toutes les
+ valeurs de cette table de vérité. En plus pour l'affichage de celle ci on mémorise le nom
+ des variables. Car si on ne sait pas à quelles valeurs de l'expression correspond la valeur
+ de la table, ça sert à rien.
+*/
+class TableVerite
+{
+ public :
+ //! Constructeur standard.
+ /*!
+ Constructeur à partir d'un entier.
+ \param nbv : nombre de variables. le nombre de lignes de la table sera la puissance 2 de ce nombre.
+ En effet chaque variable peut prendre deux valeurs.
+ \sa Variable(const char *)
+ */
+ TableVerite(const int &nbv);
+
+ //! Constructeur par copie.
+ /*!
+ Constructeur par copie utilisé pour pouvoir faire des
+ Fonctions qui retournent de TableVerite
+ \param tab : table à copier
+ */
+ TableVerite(const TableVerite &tab);
+
+ //! Destructeur.
+ /*!
+ Destructeur pour les expression de variables.
+ */
+ ~TableVerite();
+
+ //! Accesseur.
+ /*!
+ \param i : indice de la case de la table que l'on veut consulter.
+ \return Contenu de la ieme case.
+ */
+ const bool IemeValeur(const int &i) const;
+
+ //! Accesseur.
+ /*!
+ \return Nombre de variables.
+ */
+ const int Nbvars() const;
+
+ //! Accesseur.
+ /*!
+ \param i : indice de la variable que l'on veut
+ \return Nombre de variables.
+ */
+ char * Var(const int &) const;
+
+ //! Fonction membre à 2 arguments.
+ /*!
+ \param i : indice de la case de la table que l'on veut modifier.
+ \param v : valeur a mettre dans la case.
+ */
+ void SetVal(const int &i, const bool &v);
+
+ //! Fonction membre à 1 argument.
+ /*!
+ \param v : tableau de variables dont le nom est à stocker.
+ */
+ void SetVars(Variable **v);
+
+ //! Fonction membre d'affichage.
+ /*!
+ Affiche la table de vérité.
+ */
+ void Afficher() const;
+
+ private :
+ //! Donnée privée.
+ /*!
+ Valeurs de la table de vérité variable.
+ */
+ bool *vals;
+
+ //! Donnée privée.
+ /*!
+ Tableau de nom de variables. Ceci est utilisé pour l'affichage de la table
+ */
+ char **vars;
+ //! Donnée privée.
+ /*!
+ Nombre de variables.
+ */
+ int nbvars;
+
+ //! Donnée privée.
+ /*!
+ Constructeur par défaut, privé pour ne qu'il ne soit pas utilisé
+ */
+ TableVerite();
+};
+
+#endif
--- /dev/null
+#include "VarExpr.h"
+
+#include <string.h>
+#include <math.h>
+#include <iostream>
+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 <vcl\vcl.h>
+#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;
+}
--- /dev/null
+#ifndef _VE_\r
+#define _VE_\r
+\r
+#include "Variable.h"\r
+#include "Expression.h"\r
+\r
+//! Classe VarExpr. \r
+/*!\r
+ Expression de variables, classe dérivée de Fonction.\r
+*/\r
+class VarExpr : public Expression\r
+{\r
+ public :\r
+ //! Constructeur standard.\r
+ /*!\r
+ Constructeur à partir d'une variable.\r
+ \param v : Variable a mettre dans l'expression.\r
+ */\r
+ VarExpr(Variable *v);\r
+ //! Constructeur par copie.\r
+ /*!\r
+ Constructeur par copie pour les expression de variables.\r
+ */\r
+ VarExpr(const VarExpr &);\r
+ //! Destructeur.\r
+ /*!\r
+ Destructeur pour les expression de variables.\r
+ */\r
+ ~VarExpr();\r
+\r
+ //! Fonction membre d'affichage.\r
+ /*!\r
+ Affiche l'expression de variables.\r
+ */\r
+ void Afficher () const;\r
+\r
+ //! Fonction membre d'évaluation.\r
+ /*!\r
+ \sa Valeur()\r
+ \return Resultat de l'expression.\r
+ */\r
+ bool Evaluer() const;\r
+\r
+ //! Fonction membre à 4 arguments.\r
+ /*!\r
+ \param vars : tableau des variables de l'expression\r
+ \param nvars : tableau des nouvelles variables associées à l'expression copiée\r
+ \param nbv : nombre de variables de l'expression (chacune est comptée une seule fois)\r
+ \param nbvars : Le nombre de variables différentes de l'expression\r
+ */\r
+ void Chercher_variables(Variable **vars, Variable **nvars, int &nbv, const int &nbvars);\r
+\r
+ //! Fonction membre retournant une expression.\r
+ /*!\r
+ \sa Variable (const char *).\r
+ \return Une copie de l'expression.\r
+ */\r
+ Expression *Copie() const;\r
+\r
+ //! Fonction membre qui retourne un fils au hasard ou NULL.\r
+ /*!\r
+ \return Un fils au hasard.\r
+ */\r
+ Expression * Fils() const;\r
+\r
+\r
+ private :\r
+ //! Donnée privée.\r
+ /*!\r
+ Une variable.\r
+ */\r
+ Variable *var;\r
+};\r
+\r
+#endif\r
--- /dev/null
+#include "Variable.h"
+
+#include <stdlib.h>
+#include <string.h>
+#include <iostream>
+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 <vcl\vcl.h>
+#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;
+}
--- /dev/null
+#ifndef _VAR_\r
+\r
+#define _VAR_\r
+\r
+//! Classe Variable. \r
+/*!\r
+ Gestion des variables.\r
+*/\r
+class Variable\r
+{\r
+ public :\r
+ //! Constructeur par défaut.\r
+ /*!\r
+ Constructeur par défaut pour une variable.\r
+ */\r
+ Variable();\r
+ //! Constructeur par copie.\r
+ /*!\r
+ Constructeur par copie pour une variable.\r
+ */\r
+ Variable(const Variable &);\r
+ //! Constructeur standard.\r
+ /*!\r
+ Constructeur à partir d'une chaine de caractères. La variable est initialisée à true\r
+ \param nm : nom de la variable. \r
+ */\r
+ Variable(const char *nm);\r
+ //! Constructeur standard.\r
+ /*!\r
+ Constructeur à partir d'une chaine de caractères et d'un booléen.\r
+ \param nm : nom de la variable\r
+ \param v : valeur de la variable\r
+ */\r
+ Variable(const char *nm, const bool &v);\r
+ //! Destructeur.\r
+ /*!\r
+ Destructeur pour les variables.\r
+ */\r
+ ~Variable();\r
+\r
+ //! Accesseur.\r
+ /*!\r
+ \return Le nom de la variable.\r
+ */\r
+ char *Nom() const;\r
+ //! Accesseur.\r
+ /*!\r
+ \return La valeur de la variable.\r
+ */\r
+ bool Valeur() const;\r
+\r
+ //! Fonction membre d'affichage.\r
+ /*!\r
+ Affiche la variable.\r
+ */\r
+ void Afficher() const;\r
+ //! Fonction membre d'affectation.\r
+ /*!\r
+ Modifie la valeur de la variable.\r
+ \param v : valeur à mettre dans la variable.\r
+ */\r
+ void Affecter(const bool &v);\r
+\r
+ private :\r
+ //! Donnée privée.\r
+ /*!\r
+ Le nom d'une variable.\r
+ */\r
+ char *N;\r
+ //! Donnée privée.\r
+ /*!\r
+ La valeur d'une variable.\r
+ */\r
+ bool val;\r
+};\r
+\r
+#endif\r
--- /dev/null
+#include "Algogen.h"
+#include <stdlib.h>
+#include <iostream>
+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();
+}
--- /dev/null
+#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
--- /dev/null
+#include "Individu.h"
+
+Individu::Individu()
+{
+}
+
+Individu::Individu(const Individu &i)
+{
+}
+
+Individu::~Individu()
+{
+}
--- /dev/null
+#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
--- /dev/null
+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
--- /dev/null
+#include "Population.h"
+
+#include <stdlib.h>
+#include <iostream>
+using namespace std;
+
+Population::Population()
+:taillepop(TAILLEPOP),individus(new Individu *[taillepop]),score(new int[taillepop])
+{
+ int i;
+ for (i=0 ; i<taillepop ; i++)
+ {
+ individus[i] = NULL;
+ score[i] = -1;
+ }
+}
+
+Population::Population(const Population &p)
+:taillepop(p.taillepop),individus(new Individu *[taillepop]),score(new int[taillepop])
+{
+ int i;
+ for (i=0 ; i<taillepop ; i++)
+ {
+ individus[i] = p.individus[i]->Copie();
+ 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 ; i<taillepop ; i++)
+ {
+ individus[i] = NULL;
+ score[i] = -1;
+ }
+}
+
+Population::~Population()
+{
+ int i;
+ delete []score;
+ for (i=0 ; i<taillepop ; i++)
+ if (individus[i] != NULL)
+ delete individus[i];
+ delete []individus;
+}
+
+Population *Population::ReproductionParCroisement()
+{
+ int i,j;
+ Individu *pere, *mere;
+
+ //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 nouvelle population
+ for (i=0 ; i<newpop->taillepop ; 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 ; i<newpop->taillepop ; 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 ; i<nbamuter ; i++)
+ {
+ j = random() % taillepop;
+ amuter = individus[j];
+ amuter->Muter();
+ }
+}
+
+void Population::Evaluation()
+{
+ int i;
+ for (i=0 ; i<taillepop ; i++)
+ score[i] = individus[i]->Evaluation();
+}
+
+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 ; i<taillepop ; i++)
+ {
+ if (individus[i] != NULL)
+ delete individus[i];
+ individus[i] = NULL;
+ score[i] = -1;
+ }
+ //on trie les individus selon leur score
+ Trier(newpop, 0, newpop->taillepop-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 (i<j)
+ {
+ // conserver les éléments plus petits ou
+ // égaux au pivot à gauche
+ do
+ {
+ i++;
+ } while (pop->score[i]<pivot);
+
+ // conserver les éléments plus grandoms ou
+ // égaux au pivot à droite
+ do
+ {
+ j--;
+ } while (pop->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<taillepop;i++)
+ if (score[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;
+}
--- /dev/null
+#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
--- /dev/null
+#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 <stdlib.h>
+#include <iostream>
+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 <vcl\condefs.h>
+
+ #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 ; i<pop->Taillepop() ; i++)
+ {
+ pop->Ind(i)->Afficher();
+ cout << " score : " << pop->Score(i) << endl;
+ }
+
+ return 1;
+}
projects / projetcpo.git / commitdiff