init

diff --git a/Exemple b/Exemple
new file mode 100644 (file)
index 0000000..8d9285d
Binary files /dev/null and b/Exemple differ

diff --git a/IExp.cpp b/IExp.cpp
new file mode 100644 (file)
index 0000000..f094063
--- /dev/null
+++ b/IExp.cpp
@@ -0,0 +1,249 @@
+#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();
+}

diff --git a/IExp.h b/IExp.h
new file mode 100644 (file)
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 (file)
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 (file)
index 0000000..547aa79
--- /dev/null
+++ b/PopExp.cpp
@@ -0,0 +1,51 @@
+#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);
+}

diff --git a/PopExp.h b/PopExp.h
new file mode 100644 (file)
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 (file)
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 (file)
index 0000000..0fca9f3
--- /dev/null
+++ b/expression/Constante.cpp
@@ -0,0 +1,51 @@
+#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);
+}

diff --git a/expression/Constante.h b/expression/Constante.h
new file mode 100644 (file)
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 (file)
index 0000000..5e68a0f
--- /dev/null
+++ b/expression/Et.cpp
@@ -0,0 +1,50 @@
+#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]);
+}

diff --git a/expression/Et.h b/expression/Et.h
new file mode 100644 (file)
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 (file)
index 0000000..00aabf5
--- /dev/null
+++ b/expression/Expression.cpp
@@ -0,0 +1,88 @@
+#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;
+}

diff --git a/expression/Expression.h b/expression/Expression.h
new file mode 100644 (file)
index 0000000..539f7ee
--- /dev/null
+++ b/expression/Expression.h
@@ -0,0 +1,93 @@
+#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

diff --git a/expression/Fonction.cpp b/expression/Fonction.cpp
new file mode 100644 (file)
index 0000000..009193b
--- /dev/null
+++ b/expression/Fonction.cpp
@@ -0,0 +1,66 @@
+#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];
+}
+

diff --git a/expression/Fonction.h b/expression/Fonction.h
new file mode 100644 (file)
index 0000000..18fd8d8
--- /dev/null
+++ b/expression/Fonction.h
@@ -0,0 +1,81 @@
+#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

diff --git a/expression/Makefile b/expression/Makefile
new file mode 100644 (file)
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 (file)
index 0000000..69cf9e3
--- /dev/null
+++ b/expression/Non.cpp
@@ -0,0 +1,52 @@
+#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);
+}

diff --git a/expression/Non.h b/expression/Non.h
new file mode 100644 (file)
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 (file)
index 0000000..0c6798a
--- /dev/null
+++ b/expression/Ou.cpp
@@ -0,0 +1,51 @@
+#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]);
+}

diff --git a/expression/Ou.h b/expression/Ou.h
new file mode 100644 (file)
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 (file)
index 0000000..6085907
--- /dev/null
+++ b/expression/TableVerite.cpp
@@ -0,0 +1,113 @@
+#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;
+
+}

diff --git a/expression/TableVerite.h b/expression/TableVerite.h
new file mode 100644 (file)
index 0000000..b2e9a8f
--- /dev/null
+++ b/expression/TableVerite.h
@@ -0,0 +1,104 @@
+#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

diff --git a/expression/VarExpr.cpp b/expression/VarExpr.cpp
new file mode 100644 (file)
index 0000000..d798728
--- /dev/null
+++ b/expression/VarExpr.cpp
@@ -0,0 +1,87 @@
+#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;
+}

diff --git a/expression/VarExpr.h b/expression/VarExpr.h
new file mode 100644 (file)
index 0000000..2c37266
--- /dev/null
+++ b/expression/VarExpr.h
@@ -0,0 +1,75 @@
+#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

diff --git a/expression/Variable.cpp b/expression/Variable.cpp
new file mode 100644 (file)
index 0000000..56c8d09
--- /dev/null
+++ b/expression/Variable.cpp
@@ -0,0 +1,63 @@
+#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;
+}

diff --git a/expression/Variable.h b/expression/Variable.h
new file mode 100644 (file)
index 0000000..c3b16bf
--- /dev/null
+++ b/expression/Variable.h
@@ -0,0 +1,77 @@
+#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

diff --git a/framework/Algogen.cpp b/framework/Algogen.cpp
new file mode 100644 (file)
index 0000000..5353fa3
--- /dev/null
+++ b/framework/Algogen.cpp
@@ -0,0 +1,78 @@
+#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();
+}

diff --git a/framework/Algogen.h b/framework/Algogen.h
new file mode 100644 (file)
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 (file)
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 (file)
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 (file)
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 (file)
index 0000000..45ee8a3
--- /dev/null
+++ b/framework/Population.cpp
@@ -0,0 +1,233 @@
+#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;
+}

diff --git a/framework/Population.h b/framework/Population.h
new file mode 100644 (file)
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 (file)
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 <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;
+}