PROJET TO

METHODE DU SIMPLEXE

IAI2002/2003

INTRODUCTION
La mthode du simplexe est une mthode algbrique pour trouver la solution optimale
dun problme de programmation linnaire.
Ainsi il nous a t demand de concevoir un programme dans lenvirronnement Visual
C++6 qui permettrait de rsoudre un problme de programmation linaire avec la mthode du
simplexe dont la structure est la suivante :

PREREQUIS
Definition1 : On appelle solution, toutes valeurs spcifiques des variables
dcisionnelles (x1,x2,xn).
Definition2 : Une solution est appele une solution ralisable si elle satisfait
simultanment toutes les contraintes du problme.
Definition3 : Une contrainte redondante peut tre supprime du problme sans que sa
rgion ralisable soit modifie.
Definition4 : Une solution optimale est une solution ralisable ayant la valeur de la
fonction objective la plus favorable.
Definition5 : On appelle quation la limite dune contrainte ; lequation obtenue en
remplaant le signe <= ou >= de la contrainte par le signe =.
Definition6 : Une solution extrme est une solution qui ne peut pas scrire comme
une combinaison linaire de 2 autres solutions.
Definition7 : Une solution extrme est ralisable si elle satisfait simultanment toutes
les contraintes du problme.

PRINCIPES DE LA METHODE DU SIMPLEXE

Principe1 : On calcule une suite de sommets du polydre des contraintes (solutions de
base admissibles), chacune d'elles tant meilleure (pour la fonction conomique) que la
prcdente.
Principe2 : (a) Sil existe exactement une solution optimale, alors cest une solution
extrme ralisable.
(b) Sil existe plusieurs solutions optimales, alors au moins deux dentre
elles sont des solutions extrmes ralisables adjacentes.
Principe3 : Il existe un nombre fini de solution extrmes ralisables.

PROJET TO

METHODE DU SIMPLEXE

IAI2002/2003

PROJET TO

METHODE DU SIMPLEXE

IAI2002/2003

Principe4 : Si une solution extrme ralisable est meilleure que toutes les autres
solutions extrmes ralisables qui sont adjacentes, alors elle est meilleure que toute autre
solution extrme ralisabe.

DIFFERENTES ETAPES DE LA METHODE DU

SIMPLEXE
Pour dcrire les tapes de la mthode du simplexe,il faut dabord se poser les trois
questions suivantes :
(1) A ltape initiale, comment slectionner la solution ralisable de base initiale ?
(2) A ltape itrative :
Quels critres utiliser pour slectionner la variable hors-base entrer en base ?
Comment identifier la variable sortir de la base pour devenir hors-base ?
Comment identifier la nouvelle solution sans avoir rsoudre le nouveau systme
dquations linaires ainsi obtenu ?
(3) A ltape darrt, comment effectuer le test doptimalit ?
Pour rpondre toutes ces questions nous prsentons ici lalgorithme de la mthode du
simplexe :

Agorithme du simplexe
Etape initiale :
1. Introduire les variables dcart.
2. Choisir les variables originales (autres que les variables dcart) comme variables
hors-base(les fixer zero).
3. Choisir les variables decart comme variables de base(gale au nombre de droite
correspondant) dans la solution de base ralisable.
4. Aller ltape darrt.
Etape itrative :
Partie 1 : Determination de la variable de base entrant
Choisir la variable de hors-base dont laccroissement de la valeur augmenterait plus
rapidement celle de la fonction objective Z. Pour cela :
1. Vrifier les coefficients des variables hors-base dans la fonction objective
actuelle, recrite en termes exclusifs de ces variables. Cest--dire
lquation sous la forme Z-CX=0. Les variables hors-base candidates sont
celles ayant les coefficients ngatifs dans lquation.
2. Parmis ces candidates, slectionner la variable hors-base ayant le plus
grand coefficient en valeur absolue.
Partie 2 : Determination de la variable de base sortant
Choisir la variable de base qui sera la prmire atteidre la valeur zero
lorsquon crot la variable de base entrant. Pour cela :
1. Identifier les quations qui ont un coefficient de la variable de base
entrant. Seules ces quations sont telles que leurs variables de base
peuvent diminuer lorsque lon augmente la valeur de la variable de
base entrant. Ces variables sont les candidates de variables de base
sortant.
PROJET TO

METHODE DU SIMPLEXE

IAI2002/2003

PROJET TO

1.
2.
3.
4.

METHODE DU SIMPLEXE

IAI2002/2003

2. Determiner de combien la variable de base entrant peut tre

augmente sans que la valeur dune variable de base candidate ne
tombe zero.
Partie 3 : Cacul analytique de la nouvelle solution de base ralisable
Rajuster les quations de sorte que x soit de base dans lquation.
Poser les variable de hors-base gales zero.
Poser chaque varaible de base gale au membre de droite de lquation dans
laquelle elle est de base.
Aller ltape darrt.

Etape darrt :
Pour determiner si la solution actuelle est optimale, il faut verifier si la fonction
ojective Z peut tre augmente lorsquon fait crotre une des variables hors-bases.
Pour cela :
1. Recrire la fonction ojective uniquement en termes des variables horsbase et sous la forme Z-CX=a, a une constante.
2. Si les coefficients (-C) de ces variables sont tous non-ngatis, alors la
solution actuelle est optimale, arrter la procdure.
3. Sinon, retourner ltape itrative.

Algorithme Abrg.
On dmarre d'une solution de base admissible quelconque.
Etape courante:
Le programme linaire est sous la forme suivante:

choix, parmi les variables hors base, de x'k, variable entrant en base:

dtermination, parmi les variables de base, de x'n+l, variable sortant de base:

limination de x'k par pivotage (limination de Gauss):

1. diviser la contrainte l par le pivot
2. modifier la contrainte i, pour tout i l, en remultipliant la contrainte l par et en la
soustrayant de la contrainte i
3. modifier la fonction conomique en remultipliant la contrainte l par et en la
soustrayant de l'expression de z.
PROJET TO

METHODE DU SIMPLEXE

IAI2002/2003

PROJET TO

METHODE DU SIMPLEXE

IAI2002/2003

La solution optimale est atteinte lorsque tous les , coefficients de la fonction

conomique exprime par rapport aux variables hors base, sont >=0.

Exemple

PROJET TO

METHODE DU SIMPLEXE

IAI2002/2003

PROJET TO

METHODE DU SIMPLEXE

PROJET TO

METHODE DU SIMPLEXE

IAI2002/2003

IAI2002/2003

PROJET TO

METHODE DU SIMPLEXE

IAI2002/2003

PROGRAMME SIMPLEX
PREMIERE PARTIE : FICHIERS ENTETES
///////////////////////////////////////////////////////////////////
//
Paramtres.h
//
Dfinition des limites du Problme Linaire
//
///////////////////////////////////////////////////////////////////
//Nombre maximum de contraintes
#define N 3
//Nombre maximum de variables plus contraintes
#define M 7
//Cot fictif trs lev
#define MM (float)1000.0

PROJET TO

METHODE DU SIMPLEXE

IAI2002/2003

PROJET TO

METHODE DU SIMPLEXE

IAI2002/2003

///////////////////////////////////////////////////////////////////
//
Contraintes.h
//
Dfinition de la Classe Contraintes
//
///////////////////////////////////////////////////////////////////
#include<iostream.h>
enum TContrainte {zero,un,deux} ;
class Contraintes
{
public:
TContrainte Type_Contrainte;
float *Table_Contrainte;//Pointeurs sur les contraintes
public:
Contraintes();
Contraintes(TContrainte Type, float table[]);
float *lecture();
TContrainte Ret_Contrainte();
};

PROJET TO

METHODE DU SIMPLEXE

IAI2002/2003

PROJET TO

METHODE DU SIMPLEXE

IAI2002/2003

///////////////////////////////////////////////////////////////////
//
Equation.h
//
Dfinition de la classe Equation
//
///////////////////////////////////////////////////////////////////
#include<iostream.h>
enum TEquation {min, max};
class Equation
{
public:
TEquation Type_Equation;
float *Table_Equation;
public:
int Nbre_Variables,Nbre_Contraintes;
Equation(TEquation Type,float Table[],int Nbre_Contr,int Nbre_Var);
void Lecture_TypeEq(TEquation typ);
void Conversion_Min_Max(int Type);
float *Ret_Table_Equation();//Retoune la Table des Equations
int Ret_Nbre_Variables();
int Ret_Nbre_Contraintes();
TEquation TypeEquation();
};

PROJET TO

METHODE DU SIMPLEXE

IAI2002/2003

PROJET TO

METHODE DU SIMPLEXE

IAI2002/2003

//////////////////////////////////////////////////////////////////
//
Gnral.h
//
Variables Globales De base
//
//////////////////////////////////////////////////////////////////
char choix;
//Permet la validation d'une lecture
bool typeEquation=false;//Type de l'equation:true pour max,false pour min
int NbreContraites=0; //Nombres de Contraintes
int i=0;
int j=0;
float *T;
//Permet de lire une contrainte
int typeC;
//stock le type de la contrainte,0pour <=,1pour =,2pour >=
int NbreVariables=2; //NbreVariables = M-N
int NbreVarArtif=0;
//Nombres de Variables Artificielles, les Yj
int NbreVarEcart=0;
//Nombres de Variables d'Ecart, les +Xj
int typeEq=0;
//Type de l'quation: 0pour min, 1pour max
int NbreVArtifTmp=0;
//Nombres de Variables temporelles, les -Xj
float E[M-N];
//Coeffs de l'quation
float Tcout[M];
//Cots rduits
float * CDrt;
//Contient les valeurs du cot droit
float (*ValSimplex)[M];
//Pointe sur les valeurs du Tableau du simplex
Contraintes * Contr[N];

//N contraintes

///////////////////////////////////////////////////////////////////
//
//Affiche l'Equation de minimisation ou de maximisation du simplex
//
///////////////////////////////////////////////////////////////////
void AfficherE(float *E,int typ)
{
char Stmp[10]="\0";
switch(typeEq)
{
case 0:
strcpy(Stmp,"min Z=");
break;
case 1:
strcpy(Stmp,"max Z=");
break;
default: break;
}
cout<<"Voici votre Equation tel que vous l'avez entre: ";
i=1;
cout<<Stmp<< E[0]<<"X1";
while(i<NbreVariables)
{
if(E[i]>=0)
{
cout<<" + ";
}
cout<<E[i]<<"X"<<i+1<<" ";
i++;
}
cout<<endl;
}
///////////////////////////////////////////////////////////////////
//
//Affiche une Contrainte
//
///////////////////////////////////////////////////////////////////
void AfficherC(float *T,int typ)
{
cout<<T[0]<<"X1";
int i=1;
while(i<NbreVariables)
{
if(T[i]>=0)
{
cout<<" + ";
}
cout<<T[i]<<"X"<<i+1<<" ";
i++;
}

PROJET TO

METHODE DU SIMPLEXE

IAI2002/2003

PROJET TO

METHODE DU SIMPLEXE

IAI2002/2003

switch(typ)
{
case 0:cout<< " <= ";
break;
case 1:cout<<" = ";
break;
case 2:cout<<" >= ";
break;
}
cout<< T[NbreVariables]<<endl;
}

void Presentation()
{
cout<<"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"<<endl;
cout<<"xx
xx"<<endl;
cout<<"xx
TRAVAUX PRATIQUES DE TECHNIQUES D'OPTIMISATION
xx"<<endl;
cout<<"xx
RESOLUTION D''UN PROBLEME LINEAIRE
xx"<<endl;
cout<<"xx
PAR LA METHODE DU SIMPLEXE
xx"<<endl;
cout<<"xx
Realis par Tamgno K. James et Bitom Eddy
xx"<<endl;
cout<<"xx
Sous la Supervision de Mr Beidi Hamma
xx"<<endl;
cout<<"xx
xx"<<endl;
cout<<"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"<<endl;
getch();
system("cls");
}
///////////////////////////////////////////////////////////////////
//
//
Lecture de l'quation de minimisation ou de maximisation
//
///////////////////////////////////////////////////////////////////
void LireEquation()
{
do
{
system("cls");
cout<<"Nombre de variables de votre Equation ?_";
cin>>NbreVariables;
cout<<"Le type de l'equation( Zero=min et Un=max) ?_";
cin>>typeEq;
i=0;
while (i<NbreVariables)
{
cout<<"Donner le "<<i+1<<" eme coefficient: ";
cin>>E[i];
i++;
}
AfficherE(E,typeEq);
cout<<"Validez vous cette Equation(o/n): ";
cin>>choix;
}
while(choix=='n');
}

///////////////////////////////////////////////////////////////////
//
//
Lecture des Contraintes du Problme
//
///////////////////////////////////////////////////////////////////
void LireContraintes()
{
cout<<"Saisir le Nombre de contraintes du Probleme Lineaire: ";
cin>> NbreContraites;
for(j=0;j<NbreContraites;j++)
{
do
{
system("cls");
T=new float[NbreVariables+1];
cout<<"Donner les elements de la "<<j+1<<" eme contrainte dans l'ordre: "<<endl;
i=0;

PROJET TO

METHODE DU SIMPLEXE

IAI2002/2003

10

PROJET TO

METHODE DU SIMPLEXE

IAI2002/2003

while(i<NbreVariables +1)
{
cin>>T[i];
i++;
}
cout<<"Entrer le type de contrainte: 0 pour <=, 1 pour =, 2 pour >= : ";
cin>> typeC;
AfficherC(T,typeC);
cout<< "Validez vous cette contrainte(o/n): ";
cin>>choix;
}
while(choix=='n');
switch(typeC)
{
case 0: Contr[j] = new Contraintes(zero,T);
NbreVarEcart++;
NbreVArtifTmp++;
break;
case 1: Contr[j] = new Contraintes(un,T);
NbreVarArtif++;
break;
case 2: Contr[j] = new Contraintes(deux,T);
NbreVarEcart++;
NbreVarArtif++;
break;
}
}
if(NbreVarArtif!=0)
{
NbreVarArtif += NbreVArtifTmp;
}
system("cls");
AfficherE(E,typeEq);
cout<<"Vos contraintes telles que vous les avez entre: "<<endl;
for(i=0;i<NbreContraites;i++)
{
switch(Contr[i]->Type_Contrainte)
{
case zero: AfficherC(Contr[i]->Table_Contrainte,0);
break;
case un: AfficherC(Contr[i]->Table_Contrainte,1);
break;
case deux: AfficherC(Contr[i]->Table_Contrainte,2);
break;
}
}
};

///////////////////////////////////////////////////////////////////
//
//
Initialisation des valeurs des coefficients des variables
// initiales, Artificielles et Temporelles du Tableau du Simplex.
//
///////////////////////////////////////////////////////////////////
void Init()
{
CDrt= new float [NbreContraites];
for(j=0;j<NbreContraites;j++)
{
CDrt[j]=Contr[j]->Table_Contrainte[NbreVariables];
};
ValSimplex = new float [N][M];
if(NbreVarArtif==0)
{
for(i=0;i<NbreContraites;i++)
{
for(j=0;j<NbreContraites+NbreVariables;j++)
{
if(j<NbreVariables)
{

PROJET TO

METHODE DU SIMPLEXE

IAI2002/2003

11

PROJET TO

METHODE DU SIMPLEXE

IAI2002/2003

ValSimplex[i][j]=Contr[i]->Table_Contrainte[j];
}
else
{
if(j==i+NbreVariables)
{
ValSimplex[i][j]=1;
}
else
{
ValSimplex[i][j]=0;
}
}
}
}
}
else
{
int rang=-1;
for(i=0;i<NbreContraites;i++)
{
rang++;
for(j=0;j<NbreVariables+NbreVarArtif+NbreVarEcart;j++)
{
if(j<NbreVariables)
{
ValSimplex[i][j]=Contr[i]->Table_Contrainte[j];
}
else
{

if(((j>=NbreVariables)&&(j<NbreVariables+NbreVarEcart))&&(j==rang+NbreVariables))
{
switch(Contr[i]->Type_Contrainte)
{
case zero:ValSimplex[i][j]=1;
rang=i;
break;
case un: ValSimplex[i][j]=0;
rang=i-1;
break;
case deux: ValSimplex[i][j]=-1;
rang=i;
break;
}
}
else
{
if((j>=NbreVariables+NbreVarEcart)&&(j==i+NbreVariables+NbreVarEcart))
{
ValSimplex[i][j]=1;
}
else
{
ValSimplex[i][j]=0;
}
}
}
}
}
}
}

PROJET TO

METHODE DU SIMPLEXE

IAI2002/2003

12

PROJET TO

METHODE DU SIMPLEXE

IAI2002/2003

//////////////////////////////////////////////////////////////////
//
Gnral.h
//
Variables Globales De base
//
//////////////////////////////////////////////////////////////////
char choix;
//Permet la validation d'une lecture
bool typeEquation=false;//Type de l'equation:true pour max,false pour min
int NbreContraites=0; //Nombres de Contraintes
int i=0;
int j=0;
float *T;
//Permet de lire une contrainte
int typeC;
//stock le type de la contrainte,0pour <=,1pour =,2pour >=
int NbreVariables=2; //NbreVariables = M-N
int NbreVarArtif=0;
//Nombres de Variables Artificielles, les Yj
int NbreVarEcart=0;
//Nombres de Variables d'Ecart, les +Xj
int typeEq=0;
//Type de l'quation: 0pour min, 1pour max
int NbreVArtifTmp=0;
//Nombres de Variables temporelles, les -Xj
float E[M-N];
//Coeffs de l'quation
float Tcout[M];
//Cots rduits
float * CDrt;
//Contient les valeurs du cot droit
float (*ValSimplex)[M];
//Pointe sur les valeurs du Tableau du simplex
Contraintes * Contr[N];

//N contraintes

///////////////////////////////////////////////////////////////////
//
//Affiche l'Equation de minimisation ou de maximisation du simplex
//
///////////////////////////////////////////////////////////////////
void AfficherE(float *E,int typ)
{
char Stmp[10]="\0";
switch(typeEq)
{
case 0:
strcpy(Stmp,"min Z=");
break;
case 1:
strcpy(Stmp,"max Z=");
break;
default: break;
}
cout<<"Voici votre Equation tel que vous l'avez entre: ";
i=1;
cout<<Stmp<< E[0]<<"X1";
while(i<NbreVariables)
{
if(E[i]>=0)
{
cout<<" + ";
}
cout<<E[i]<<"X"<<i+1<<" ";
i++;
}
cout<<endl;
}
///////////////////////////////////////////////////////////////////
//
//Affiche une Contrainte
//
///////////////////////////////////////////////////////////////////
void AfficherC(float *T,int typ)
{
cout<<T[0]<<"X1";
int i=1;
while(i<NbreVariables)
{
if(T[i]>=0)
{
cout<<" + ";
}
cout<<T[i]<<"X"<<i+1<<" ";
i++;
}

PROJET TO

METHODE DU SIMPLEXE

IAI2002/2003

13

PROJET TO

METHODE DU SIMPLEXE

IAI2002/2003

switch(typ)
{
case 0:cout<< " <= ";
break;
case 1:cout<<" = ";
break;
case 2:cout<<" >= ";
break;
}
cout<< T[NbreVariables]<<endl;
}

void Presentation()
{
cout<<"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"<<endl;
cout<<"xx
xx"<<endl;
cout<<"xx
TRAVAUX PRATIQUES DE TECHNIQUES D'OPTIMISATION
xx"<<endl;
cout<<"xx
RESOLUTION D''UN PROBLEME LINEAIRE
xx"<<endl;
cout<<"xx
PAR LA METHODE DU SIMPLEXE
xx"<<endl;
cout<<"xx
Realis par Tamgno K. James et Bitom Eddy
xx"<<endl;
cout<<"xx
Sous la Supervision de Mr Beidi Hamma
xx"<<endl;
cout<<"xx
xx"<<endl;
cout<<"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"<<endl;
getch();
system("cls");
}
///////////////////////////////////////////////////////////////////
//
//
Lecture de l'quation de minimisation ou de maximisation
//
///////////////////////////////////////////////////////////////////
void LireEquation()
{
do
{
system("cls");
cout<<"Nombre de variables de votre Equation ?_";
cin>>NbreVariables;
cout<<"Le type de l'equation( Zero=min et Un=max) ?_";
cin>>typeEq;
i=0;
while (i<NbreVariables)
{
cout<<"Donner le "<<i+1<<" eme coefficient: ";
cin>>E[i];
i++;
}
AfficherE(E,typeEq);
cout<<"Validez vous cette Equation(o/n): ";
cin>>choix;
}
while(choix=='n');
}

///////////////////////////////////////////////////////////////////
//
//
Lecture des Contraintes du Problme
//
///////////////////////////////////////////////////////////////////
void LireContraintes()
{
cout<<"Saisir le Nombre de contraintes du Probleme Lineaire: ";
cin>> NbreContraites;
for(j=0;j<NbreContraites;j++)
{

PROJET TO

METHODE DU SIMPLEXE

IAI2002/2003

14

PROJET TO

METHODE DU SIMPLEXE

IAI2002/2003

do
{
system("cls");
T=new float[NbreVariables+1];
cout<<"Donner les elements de la "<<j+1<<" eme contrainte dans l'ordre: "<<endl;
i=0;
while(i<NbreVariables +1)
{
cin>>T[i];
i++;
}
cout<<"Entrer le type de contrainte: 0 pour <=, 1 pour =, 2 pour >= : ";
cin>> typeC;
AfficherC(T,typeC);
cout<< "Validez vous cette contrainte(o/n): ";
cin>>choix;
}
while(choix=='n');
switch(typeC)
{
case 0: Contr[j] = new Contraintes(zero,T);
NbreVarEcart++;
NbreVArtifTmp++;
break;
case 1: Contr[j] = new Contraintes(un,T);
NbreVarArtif++;
break;
case 2: Contr[j] = new Contraintes(deux,T);
NbreVarEcart++;
NbreVarArtif++;
break;
}
}
if(NbreVarArtif!=0)
{
NbreVarArtif += NbreVArtifTmp;
}
system("cls");
AfficherE(E,typeEq);
cout<<"Vos contraintes telles que vous les avez entre: "<<endl;
for(i=0;i<NbreContraites;i++)
{
switch(Contr[i]->Type_Contrainte)
{
case zero: AfficherC(Contr[i]->Table_Contrainte,0);
break;
case un: AfficherC(Contr[i]->Table_Contrainte,1);
break;
case deux: AfficherC(Contr[i]->Table_Contrainte,2);
break;
}
}
};

///////////////////////////////////////////////////////////////////
//
//
Initialisation des valeurs des coefficients des variables
// initiales, Artificielles et Temporelles du Tableau du Simplex.
//
///////////////////////////////////////////////////////////////////
void Init()
{
CDrt= new float [NbreContraites];
for(j=0;j<NbreContraites;j++)
{
CDrt[j]=Contr[j]->Table_Contrainte[NbreVariables];
};
ValSimplex = new float [N][M];
if(NbreVarArtif==0)
{

PROJET TO

METHODE DU SIMPLEXE

IAI2002/2003

15

PROJET TO

METHODE DU SIMPLEXE

IAI2002/2003

for(i=0;i<NbreContraites;i++)
{
for(j=0;j<NbreContraites+NbreVariables;j++)
{
if(j<NbreVariables)
{
ValSimplex[i][j]=Contr[i]->Table_Contrainte[j];
}
else
{
if(j==i+NbreVariables)
{
ValSimplex[i][j]=1;
}
else
{
ValSimplex[i][j]=0;
}
}
}
}
}
else
{
int rang=-1;
for(i=0;i<NbreContraites;i++)
{
rang++;
for(j=0;j<NbreVariables+NbreVarArtif+NbreVarEcart;j++)
{
if(j<NbreVariables)
{
ValSimplex[i][j]=Contr[i]->Table_Contrainte[j];
}
else
{

if(((j>=NbreVariables)&&(j<NbreVariables+NbreVarEcart))&&(j==rang+NbreVariables))
{
switch(Contr[i]->Type_Contrainte)
{
case zero:ValSimplex[i][j]=1;
rang=i;
break;
case un: ValSimplex[i][j]=0;
rang=i-1;
break;
case deux: ValSimplex[i][j]=-1;
rang=i;
break;
}
}
else
{
if((j>=NbreVariables+NbreVarEcart)&&(j==i+NbreVariables+NbreVarEcart))
{
ValSimplex[i][j]=1;
}
else
{
ValSimplex[i][j]=0;
}
}
}
}
}
}
}

PROJET TO

METHODE DU SIMPLEXE

IAI2002/2003

16

PROJET TO

METHODE DU SIMPLEXE

IAI2002/2003

//////////////////////////////////////////////////////////////////
//
Gnral.h
//
Variables Globales De base
//
//////////////////////////////////////////////////////////////////
char choix;
//Permet la validation d'une lecture
bool typeEquation=false;//Type de l'equation:true pour max,false pour min
int NbreContraites=0; //Nombres de Contraintes
int i=0;
int j=0;
float *T;
//Permet de lire une contrainte
int typeC;
//stock le type de la contrainte,0pour <=,1pour =,2pour >=
int NbreVariables=2; //NbreVariables = M-N
int NbreVarArtif=0;
//Nombres de Variables Artificielles, les Yj
int NbreVarEcart=0;
//Nombres de Variables d'Ecart, les +Xj
int typeEq=0;
//Type de l'quation: 0pour min, 1pour max
int NbreVArtifTmp=0;
//Nombres de Variables temporelles, les -Xj
float E[M-N];
//Coeffs de l'quation
float Tcout[M];
//Cots rduits
float * CDrt;
//Contient les valeurs du cot droit
float (*ValSimplex)[M];
//Pointe sur les valeurs du Tableau du simplex
Contraintes * Contr[N];

//N contraintes

///////////////////////////////////////////////////////////////////
//
//Affiche l'Equation de minimisation ou de maximisation du simplex
//
///////////////////////////////////////////////////////////////////
void AfficherE(float *E,int typ)
{
char Stmp[10]="\0";
switch(typeEq)
{
case 0:
strcpy(Stmp,"min Z=");
break;
case 1:
strcpy(Stmp,"max Z=");
break;
default: break;
}
cout<<"Voici votre Equation tel que vous l'avez entre: ";
i=1;
cout<<Stmp<< E[0]<<"X1";
while(i<NbreVariables)
{
if(E[i]>=0)
{
cout<<" + ";
}
cout<<E[i]<<"X"<<i+1<<" ";
i++;
}
cout<<endl;
}
///////////////////////////////////////////////////////////////////
//
//Affiche une Contrainte
//
///////////////////////////////////////////////////////////////////
void AfficherC(float *T,int typ)
{
cout<<T[0]<<"X1";
int i=1;
while(i<NbreVariables)
{
if(T[i]>=0)
{
cout<<" + ";

PROJET TO

METHODE DU SIMPLEXE

IAI2002/2003

17

PROJET TO

METHODE DU SIMPLEXE

IAI2002/2003

}
cout<<T[i]<<"X"<<i+1<<" ";
i++;
}
switch(typ)
{
case 0:cout<< " <= ";
break;
case 1:cout<<" = ";
break;
case 2:cout<<" >= ";
break;
}
cout<< T[NbreVariables]<<endl;
}

void Presentation()
{
cout<<"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"<<endl;
cout<<"xx
xx"<<endl;
cout<<"xx
TRAVAUX PRATIQUES DE TECHNIQUES D'OPTIMISATION
xx"<<endl;
cout<<"xx
RESOLUTION D''UN PROBLEME LINEAIRE
xx"<<endl;
cout<<"xx
PAR LA METHODE DU SIMPLEXE
xx"<<endl;
cout<<"xx
Realis par Tamgno K. James et Bitom Eddy
xx"<<endl;
cout<<"xx
Sous la Supervision de Mr Beidi Hamma
xx"<<endl;
cout<<"xx
xx"<<endl;
cout<<"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"<<endl;
getch();
system("cls");
}
///////////////////////////////////////////////////////////////////
//
//
Lecture de l'quation de minimisation ou de maximisation
//
///////////////////////////////////////////////////////////////////
void LireEquation()
{
do
{
system("cls");
cout<<"Nombre de variables de votre Equation ?_";
cin>>NbreVariables;
cout<<"Le type de l'equation( Zero=min et Un=max) ?_";
cin>>typeEq;
i=0;
while (i<NbreVariables)
{
cout<<"Donner le "<<i+1<<" eme coefficient: ";
cin>>E[i];
i++;
}
AfficherE(E,typeEq);
cout<<"Validez vous cette Equation(o/n): ";
cin>>choix;
}
while(choix=='n');
}

///////////////////////////////////////////////////////////////////
//
//
Lecture des Contraintes du Problme
//
///////////////////////////////////////////////////////////////////
void LireContraintes()
{
cout<<"Saisir le Nombre de contraintes du Probleme Lineaire: ";
cin>> NbreContraites;
for(j=0;j<NbreContraites;j++)
{
do
{

PROJET TO

METHODE DU SIMPLEXE

IAI2002/2003

18

PROJET TO

METHODE DU SIMPLEXE

IAI2002/2003

system("cls");
T=new float[NbreVariables+1];
cout<<"Donner les elements de la "<<j+1<<" eme contrainte dans l'ordre: "<<endl;
i=0;
while(i<NbreVariables +1)
{
cin>>T[i];
i++;
}
cout<<"Entrer le type de contrainte: 0 pour <=, 1 pour =, 2 pour >= : ";
cin>> typeC;
AfficherC(T,typeC);
cout<< "Validez vous cette contrainte(o/n): ";
cin>>choix;
}
while(choix=='n');
switch(typeC)
{
case 0: Contr[j] = new Contraintes(zero,T);
NbreVarEcart++;
NbreVArtifTmp++;
break;
case 1: Contr[j] = new Contraintes(un,T);
NbreVarArtif++;
break;
case 2: Contr[j] = new Contraintes(deux,T);
NbreVarEcart++;
NbreVarArtif++;
break;
}
}
if(NbreVarArtif!=0)
{
NbreVarArtif += NbreVArtifTmp;
}
system("cls");
AfficherE(E,typeEq);
cout<<"Vos contraintes telles que vous les avez entre: "<<endl;
for(i=0;i<NbreContraites;i++)
{
switch(Contr[i]->Type_Contrainte)
{
case zero: AfficherC(Contr[i]->Table_Contrainte,0);
break;
case un: AfficherC(Contr[i]->Table_Contrainte,1);
break;
case deux: AfficherC(Contr[i]->Table_Contrainte,2);
break;
}
}
};

///////////////////////////////////////////////////////////////////
//
//
Initialisation des valeurs des coefficients des variables
// initiales, Artificielles et Temporelles du Tableau du Simplex.
//
///////////////////////////////////////////////////////////////////
void Init()
{
CDrt= new float [NbreContraites];
for(j=0;j<NbreContraites;j++)
{
CDrt[j]=Contr[j]->Table_Contrainte[NbreVariables];
};
ValSimplex = new float [N][M];
if(NbreVarArtif==0)
{
for(i=0;i<NbreContraites;i++)
{

PROJET TO

METHODE DU SIMPLEXE

IAI2002/2003

19

PROJET TO

METHODE DU SIMPLEXE

IAI2002/2003

for(j=0;j<NbreContraites+NbreVariables;j++)
{
if(j<NbreVariables)
{
ValSimplex[i][j]=Contr[i]->Table_Contrainte[j];
}
else
{
if(j==i+NbreVariables)
{
ValSimplex[i][j]=1;
}
else
{
ValSimplex[i][j]=0;
}
}
}
}
}
else
{
int rang=-1;
for(i=0;i<NbreContraites;i++)
{
rang++;
for(j=0;j<NbreVariables+NbreVarArtif+NbreVarEcart;j++)
{
if(j<NbreVariables)
{
ValSimplex[i][j]=Contr[i]->Table_Contrainte[j];
}
else
{

if(((j>=NbreVariables)&&(j<NbreVariables+NbreVarEcart))&&(j==rang+NbreVariables))
{
switch(Contr[i]->Type_Contrainte)
{
case zero:ValSimplex[i][j]=1;
rang=i;
break;
case un: ValSimplex[i][j]=0;
rang=i-1;
break;
case deux: ValSimplex[i][j]=-1;
rang=i;
break;
}
}
else
{
if((j>=NbreVariables+NbreVarEcart)&&(j==i+NbreVariables+NbreVarEcart))
{
ValSimplex[i][j]=1;
}
else
{
ValSimplex[i][j]=0;
}
}
}
}
}
}
}

PROJET TO

METHODE DU SIMPLEXE

IAI2002/2003

20

PROJET TO

METHODE DU SIMPLEXE

IAI2002/2003

///////////////////////////////////////////////////////////////////
//
SimplexPhase1.h
//
Dfinition de la classe SimplexPlus
//
Hrite de Classe Simplex
//Mais tient compte des lments lis la Rsolvabilit du Problme
//
///////////////////////////////////////////////////////////////////
#include<iostream.h>
#include<string.h>
#include<stdlib.h>
#include "SimplexPhase2.h"

class SimplexPlus : public simplex

{
float * Table_M_Fictif;//Ligne des Coeffs fictifs
bool Etat_Artif;//vrai si variables artificielles en base la fin de la phase I
public:
SimplexPlus(int NBase,int NContr,int nVEcart,bool typE);
bool Realisable_Simplex();
void Lecture_Table_M_Fictif();
void Sortie_Resultats();
void LectureTableauSimplex(float Cout_Reduit[],float Cote_Droit[],float (*Val_simplex)[M]);
void Pivot(int entre,int sortie);
void Mise_A_Jour();
void pivot1();
};

PROJET TO

METHODE DU SIMPLEXE

IAI2002/2003

21

PROJET TO

METHODE DU SIMPLEXE

IAI2002/2003

///////////////////////////////////////////////////////////////////
//
SimplexPhase2.h
//
Dfinition de la Classe Simplex
//
///////////////////////////////////////////////////////////////////
#include<iostream.h>
#include<string.h>
#include<stdlib.h>
#include "Parametres.h"
class simplex
{
public:
int nC,nV,nE,nA;//nC=nombres de contraintes, nE= nbr variables ecart, nV = nbr variable, nA= nbr var artificielles
int LigneSortie,ColonneEntre;
int Variable_Base[N];
//rang de la variables de base
int Variable_Base_Ecart[M];
//rang de la variable
float *Cout_Reduit;
float *Cote_Droit;
float (* Val_Simplex)[M];
bool Etat_Optimalite;// vrai si il y a optimalt(tous les cots rduits sonts positifs
bool Etat_CReduit; // vrai si cot rduit de variables hors base =0;
bool Non_Borne; // vrai si impossible de faire 3); car aij<=0;
int Variable_Sortie_Base;
int Variable_Entrante_Base;
bool TypeEqu;//Pour rcuperer le type de l'quation
float * Resultats_Base;
float * LEquation;

public:
simplex(int NBase,int NContr,bool TypeEqu);
virtual void LectureTableauSimplex(float Cout_Reduit[],float Cote_Droit[],float (*Val_simplex)[M]);
virtual void Mise_A_Jour();
bool Test_Optimalite();
void Lecture_Cout_Reduit(float* Tab,int nC,int nV);
void Lecture_Cote_Droit(float* Tab,int nC);
void Lecture_Val_Simplex(float Tab[N][M],int nC,int nV);
void CalculResultat_Base();
void MAJ_Optimalite();
virtual void Sortie_Resultats();
void Election_Entree_Sortie(float * T,int taille);
virtual void Pivot(int entre,int sortie);
int Plus_Petit_Ratio(int entre);
int Plus_Petit_Cout_Negatif(float * T,int taille);
};

PROJET TO

METHODE DU SIMPLEXE

IAI2002/2003

22

PROJET TO

METHODE DU SIMPLEXE

IAI2002/2003

DEUXIEME PARTIE : FICHIERS SOURCES

///////////////////////////////////////////////////////////////////
//
//
Implmentation de la classe Contraintes
//
///////////////////////////////////////////////////////////////////
#include "Contraintes.h"

Contraintes.cpp

Contraintes::Contraintes(TContrainte Type, float Table[])

{
Type_Contrainte=Type;
Table_Contrainte=Table;
};
float * Contraintes::lecture()
{
return Table_Contrainte;
};
TContrainte Contraintes::Ret_Contrainte()
{
return Type_Contrainte;
};
///////////////////////////////////////////////////////////////////
//
//Implmentation de la classe Equation
//
///////////////////////////////////////////////////////////////////

Equation.cpp

#include"Equation.h"
Equation::Equation(TEquation Type,float Table[],int Nbre_Contr,int Nbre_Var)
{
Type_Equation=Type;
Table_Equation = Table;
Nbre_Variables=Nbre_Var;
Nbre_Contraintes=Nbre_Contr;
}
void Equation::Lecture_TypeEq(TEquation typ)
{
Type_Equation=typ;
}
void Equation::Conversion_Min_Max(int Type)
{
if(Type==1)//ie equation de type max
{
for (int i =0;i<Nbre_Variables;i++)
{
Table_Equation[i]=-Table_Equation[i];
}
}
}
float* Equation::Ret_Table_Equation()
{
return Table_Equation;
}
int Equation::Ret_Nbre_Variables()
{
return Nbre_Variables;
}
TEquation Equation::TypeEquation()
{
return Type_Equation;
};

PROJET TO

METHODE DU SIMPLEXE

IAI2002/2003

23

PROJET TO

METHODE DU SIMPLEXE

IAI2002/2003

int Equation::Ret_Nbre_Contraintes()
{
return Nbre_Contraintes;
};

PROJET TO

METHODE DU SIMPLEXE

IAI2002/2003

24

PROJET TO

METHODE DU SIMPLEXE

IAI2002/2003

///////////////////////////////////////////////////////////////////
//
SimplexPhase1.cpp
//
Implmentation de la classe Simplex1
//
///////////////////////////////////////////////////////////////////
#include "Equation.h"
#include "Contraintes.h"
#include "SimplexPhase1.h"

///////////////////////////////////////////////////////////////////
//Le Constructeur
//Recopie le constructeur de la classe simplex
//Puis met jour les var d'ecarts, les var artificielles
//et la ligne des cots fictifs
///////////////////////////////////////////////////////////////////
SimplexPlus::SimplexPlus(int NBase,int NContr,int nVEcart,bool typE):simplex(NBase,NContr,typE)
{
nE=nVEcart;
nA=nC;
Etat_Artif=true;
Table_M_Fictif=new float [M];
int i;
for(i=nV;i<nA+nV+nE;i++)
{
if(i<nV+nE)
{
Variable_Base_Ecart[i]=i+1;
}
else
{
Variable_Base[i-(nV+nE)]=i+1;
Variable_Base_Ecart[i]=i+1;
}
}

};
///////////////////////////////////////////////////////////////////
//Met jour les valeurs de la table du SimplexPlus par recopie
//de celle du simplex
//Puis ajoute les elts de la table des cots fictifs
///////////////////////////////////////////////////////////////////
void SimplexPlus::LectureTableauSimplex(float Cout_Reduit[],float Cote_Droit[],float (*Val_simplex)[M])
{
simplex::LectureTableauSimplex(Cout_Reduit, Cote_Droit,Val_simplex);
Lecture_Table_M_Fictif();
};
///////////////////////////////////////////////////////////////////
//
//mise jour de la ligne des cots fictifs
//
///////////////////////////////////////////////////////////////////
void SimplexPlus::Lecture_Table_M_Fictif()
{
for(int i=0;i<nV+nA+nE;i++)
{
if(i<nV+nE)
{
Table_M_Fictif[i]=0;
}
else
{
Table_M_Fictif[i]=MM;
}
}
}
///////////////////////////////////////////////////////////////////
//
//Annule les Cots rduits ds les deuxime range pour
//les var artificielles Yj

PROJET TO

METHODE DU SIMPLEXE

IAI2002/2003

25

PROJET TO

METHODE DU SIMPLEXE

IAI2002/2003

///////////////////////////////////////////////////////////////////
void SimplexPlus::pivot1()
{
int i,j;
for(i=0;i<nC;i++)
{
for(j=0;j<nV+nA+nE;j++)
{
Table_M_Fictif[j] -= MM*Val_Simplex[i][j];
}
}
}

///////////////////////////////////////////////////////////////////
//
////Pivot surcharg
//
///////////////////////////////////////////////////////////////////
void SimplexPlus::Pivot(int entre, int sortie)
{
int i=0;
float buf=Val_Simplex[sortie][entre];
for(i=0;i<nA+nV+nE;i++)
{
Val_Simplex[sortie][i] =Val_Simplex[sortie][i]/buf;
}
Cote_Droit[sortie]=Cote_Droit[sortie]/buf;
for(i=0;i<nC;i++)
{
if (i!=sortie)
Cote_Droit[i]=Cote_Droit[i] - (Val_Simplex[i][entre]*Cote_Droit[sortie]);
}
float bf=Table_M_Fictif[entre];
float bf2=Cout_Reduit[entre];
for(i=0;i<nV+nE;i++)//On ne met pas jour la partie variables artificielles donc nV+nE
{
Cout_Reduit[i] -=(bf2*Val_Simplex[sortie][i]);
Table_M_Fictif[i] -=(bf*Val_Simplex[sortie][i]);
};
float bf1=0;
for(i=0;i<nC;i++)
{
bf1=Val_Simplex[i][entre];
for(int j=0;j<nV+nE;j++)//On ne met pas jour la partie variables artificielles donc nV+nE
{
if (i!=sortie)
{
Val_Simplex[i][j]=Val_Simplex[i][j] -(Val_Simplex[sortie][j]*bf1);
}
}
};

if(Variable_Base[sortie]>nV+nE)
{
if(Variable_Base[sortie]!=nV+nE+nA)
{
for(int l=sortie;l<nV+nE+nA;l++)
{
for(i=0;i<nC;i++)
{
Val_Simplex[i][l]=Val_Simplex[i][l+1];
}
Table_M_Fictif[l]=Table_M_Fictif[l++];
Cout_Reduit[l]=Cout_Reduit[l++];
Variable_Base_Ecart[l]=Variable_Base_Ecart[l++];
}
}
nA--; // Pour liminer la colonne des y variable artificielle qui vient de sortir

PROJET TO

METHODE DU SIMPLEXE

IAI2002/2003

26

PROJET TO

METHODE DU SIMPLEXE

IAI2002/2003

}
Variable_Base[sortie]=Variable_Base_Ecart[entre];
}
///////////////////////////////////////////////////////////////////
//
//
//Sortie des rsultats du SimplexPlus
//
///////////////////////////////////////////////////////////////////
void SimplexPlus::Sortie_Resultats()
{
int i=0;
cout<<"-------------------------------------"<<endl;
cout<< "
Cote droit"<<endl;
cout<<"-------------------------------------"<<endl;
while(i<nC)
{
cout<<" "<<Cote_Droit[i]<<endl;
i++;
}
i=0;
cout<<"-------------------------------------"<<endl;
cout<<"
Cout Reduit"<<endl;
cout<<"-------------------------------------"<<endl;
while(i<nA+nV+nE)
{
cout<<Cout_Reduit[i]<<" ;";
i++;
}
cout<<endl;
cout<<"-------------------------------------"<<endl;
cout<<"
Tableau du simplex"<<endl;
cout<<"-------------------------------------"<<endl;
for(i=0;i<nC;i++)
{
for(int j=0;j<nA+nV+nE;j++)
{
cout<< Val_Simplex[i][j]<< " ;";
}
cout<<endl;
}
switch(Etat_Optimalite)
{
case false:
cout<<"---------------------------------"<<endl;
cout<<"
Optimum non atteint"<<endl;
cout<<"---------------------------------"<<endl;
break;
case true:
cout<<"---------------------------------"<<endl;
cout<<"
Solution optimale"<<endl;
cout<<"---------------------------------"<<endl;
break;
}
cout<<endl;
char C[4];
char C1[4];
for(i=0;i<nC;i++)
{
_itoa(Variable_Base[i],C,10);
strcpy(C1,"X");
strcat(C1,C);
cout<<C1<<"= "<<Cote_Droit[i]<<" ";
}
cout<<endl;
i=0;
int j=0;
bool trouve=false;
while(i<nC+nV)
{
while((j<nC)&&(trouve==false))
{
if(Variable_Base[j]==Variable_Base_Ecart[i])

PROJET TO

METHODE DU SIMPLEXE

IAI2002/2003

27

PROJET TO

METHODE DU SIMPLEXE

IAI2002/2003

{
trouve=true;
}
j++;
}
if((j==nC)&&(trouve==false))
{
_itoa(Variable_Base_Ecart[i],C,10);
strcpy(C1,"X");
strcat(C1,C);
cout<<C1<< "= 0 ";
}
trouve=false;
i++;
j=0;
}
cout<<endl;
float tmp1=0;
CalculResultat_Base();
if(Etat_CReduit==false)
{
for(int k=0;k<nV;k++)
{
tmp1=tmp1 + LEquation[k]*Resultats_Base[k];
}
cout<<"-------------------------------------"<<endl;
cout<<" L'objectif est z="<<tmp1<<endl;
cout<<"-------------------------------------"<<endl;
}
};
///////////////////////////////////////////////////////////////////
//
//Permet de savoir si on a atteint une base ralisable dans SimplexPlus
//
///////////////////////////////////////////////////////////////////
bool SimplexPlus::Realisable_Simplex()
{
return (nA==0);
}
void SimplexPlus::Mise_A_Jour()
{
if(!Realisable_Simplex())
{
pivot1();
}
while(!Realisable_Simplex())
{
int tm=Plus_Petit_Cout_Negatif(Table_M_Fictif,nA+nV+nE);
if (tm!=-1)
{
if(Plus_Petit_Ratio(tm)!=-1)
{
Election_Entree_Sortie(Table_M_Fictif,nA+nV+nE);
Pivot(ColonneEntre,LigneSortie);
}
else
{
nA=0;//Permet de rendre Realibale_simplex faux pour viter un second traitement
cout<<"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"<<endl;
cout<< "X Cette base n'est pas ralisable car les Couts rduits de la 2ime X "<<endl<<"range
sont positifs avec des variables artificeilles en bases"<<endl;
cout<<"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"<<endl;
exit(-1);
}
}
else
{
nA=0;//Permet de rendre Realibale_simplex faux pour viter un second traitement
cout<<"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"<<endl;

PROJET TO

METHODE DU SIMPLEXE

IAI2002/2003

28

PROJET TO

METHODE DU SIMPLEXE

IAI2002/2003

cout<< "X Cette base n'est pas ralisable car les Couts rduits de la 2ime X"<<endl<<"range sont positifs
avec des variables artificeilles en bases"<<endl;
cout<<"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"<<endl;
exit(-1)
;
}
}
simplex::Mise_A_Jour();
};

PROJET TO

METHODE DU SIMPLEXE

IAI2002/2003

29

PROJET TO

METHODE DU SIMPLEXE

IAI2002/2003

///////////////////////////////////////////////////////////////////
//
SimplexPhase2.cpp
//
Implmentation de la classe Simplex
//
///////////////////////////////////////////////////////////////////
#include "Equation.h"
#include "Contraintes.h"
#include "SimplexPhase2.h"
///////////////////////////////////////////////////////////////////
//
Le Constructeur,
//
Initialise le nombre de variable en Base, le nombre de contrainte
//
et le type de l'quation.
//
///////////////////////////////////////////////////////////////////
simplex::simplex(int NBase,int NContr,bool typE)
{
Val_Simplex = new float[N][M];
Resultats_Base= new float [M-N];
int i=0;
TypeEqu=typE;
Etat_Optimalite=false;
Etat_CReduit=false;
Non_Borne=false;
nC=NContr;
nV=NBase;
nE=0;
nA=0;
for(i=0;i<nC+nV;i++)
{
if(i<nV)
{
Variable_Base_Ecart[i]=i+1;
}
else
{
Variable_Base[i-nV]=i+1;
Variable_Base_Ecart[i]=i+1;
}
}
};
///////////////////////////////////////////////////////////////////
//
Calcul des valeurs des diffrentes variables
//
Celle en base sont gales aux valeurs du cot droit
//
celle hors base sont nulles
///////////////////////////////////////////////////////////////////
void simplex::CalculResultat_Base()
{
int i=0;
int j=0;
bool trouve = false;
for(i=0;i<nV;i++)
{
while((j<nC)&&(trouve==false))
{
if(Variable_Base[j]==Variable_Base_Ecart[i])
{
trouve=true;
}
j++;
}
if((j==nC)&&(trouve==false))
{
Resultats_Base[i]=0;
}
else
{
Resultats_Base[i]=Cote_Droit[j-1];
}
trouve=false;
j=0;

PROJET TO

METHODE DU SIMPLEXE

IAI2002/2003

30

PROJET TO

METHODE DU SIMPLEXE

IAI2002/2003

}
}
///////////////////////////////////////////////////////////////////
//
//
//Renvoie l'tat d'optimalit
//
///////////////////////////////////////////////////////////////////
bool simplex::Test_Optimalite()
{
return Etat_Optimalite;
};
///////////////////////////////////////////////////////////////////
//
//
//Initialise Le tableau de cot rduit
//
///////////////////////////////////////////////////////////////////
void simplex::Lecture_Cout_Reduit(float* Tab,int nC,int nV)
{
int n=nC+nV;
int i;
Cout_Reduit = new float[n];
Cout_Reduit = Tab;
LEquation= new float[M-N];
if(TypeEqu)
{
for(i=0;i<nV;i++)
{
LEquation[i]=-Tab[i];
}
}
else
{
for(i=0;i<nV;i++)
{
LEquation[i]=Tab[i];
}
}
};
///////////////////////////////////////////////////////////////////
//
//
//Initialise Le tableau du ct droit
//
///////////////////////////////////////////////////////////////////
void simplex::Lecture_Cote_Droit(float* Tab,int nC)
{
Cote_Droit=new float[nC];
Cote_Droit=
Tab;
};
///////////////////////////////////////////////////////////////////
//
//
Renseigne les valeurs aij du tableau du simplex
//
///////////////////////////////////////////////////////////////////
void simplex::Lecture_Val_Simplex(float (*Tab)[M],int nC,int nV)
{
Val_Simplex=Tab;
};
///////////////////////////////////////////////////////////////////
//
// Renseigne les tables: appel de toutes les fonctions de lectures
//
///////////////////////////////////////////////////////////////////
void simplex::LectureTableauSimplex(float Cout_Reduit[],float Cote_Droit[],float (*ValSimplex)[M])
{
Lecture_Cout_Reduit(Cout_Reduit,nC, nV);
Lecture_Cote_Droit(Cote_Droit,nC);
Lecture_Val_Simplex(ValSimplex,nC,nV);
};

PROJET TO

METHODE DU SIMPLEXE

IAI2002/2003

31

PROJET TO

METHODE DU SIMPLEXE

IAI2002/2003

///////////////////////////////////////////////////////////////////
//
//Nous permettra de retrouver la ligne de plus petit ratio pour sortie
//Si on ne retrouve pas on renvoie -1
//
///////////////////////////////////////////////////////////////////
int simplex::Plus_Petit_Ratio(int entre)
{
float tab[M];
int ligne=-1;
int i=0;
for(i=0;i<nC;i++)
{
tab[i]=Cote_Droit[i];
};
float tmp;
for(i=0;i<nC;i++)
{
if(Val_Simplex[i][entre]!=0)
{
tab[i] = tab[i]/Val_Simplex[i][entre];
}
else
{
tab[i]=-1.0;
}
};
i=0;
while((tab[i]<0)&&(i<nC))
i++;
if(i<nC)
{
tmp=tab[i];
ligne=i;
}
while(i<nC)
{
if((tab[i]<tmp)&&(tab[i]>0))
{
tmp=tab[i];
ligne=i;
}
i++;
};
return(ligne);
}

///////////////////////////////////////////////////////////////////
//
// Permet de choisir une colonne candidate pour entre
//
///////////////////////////////////////////////////////////////////
int simplex::Plus_Petit_Cout_Negatif(float *T, int taille)
{
int i=0;
int indice=0;
float T1[M];
for(i=0;i<taille;i++)
{
T1[i]=T[i];
}
float tmp;
tmp=T1[0];
indice=0;
for(i=1;i<taille;i++)
{
if(T1[i]<tmp)
{
tmp=T1[i];
indice=i;
}
}

PROJET TO

METHODE DU SIMPLEXE

IAI2002/2003

32

PROJET TO

METHODE DU SIMPLEXE

IAI2002/2003

if(tmp>=0)
{
return(-1);
}
return indice;
};

///////////////////////////////////////////////////////////////////
//
//Election proprement dite des variables entrante et sortante
//
///////////////////////////////////////////////////////////////////
void simplex::Election_Entree_Sortie(float * T,int taille)
{
int col=Plus_Petit_Cout_Negatif(T,taille);
int ligne=Plus_Petit_Ratio(col);
LigneSortie=ligne;
ColonneEntre=col;
Variable_Sortie_Base=Variable_Base[ligne] ;
Variable_Entrante_Base=Variable_Base_Ecart[col];
}

///////////////////////////////////////////////////////////////////
//
//
Permet de mettre jour toutes les structures aprs un tour
//
///////////////////////////////////////////////////////////////////
void simplex::Pivot(int entre,int sortie)
{
int i=0;
float buf=Val_Simplex[sortie][entre];
for(i=0;i<nC+nV;i++)
{
Val_Simplex[sortie][i] =Val_Simplex[sortie][i]/buf;
}
Cote_Droit[sortie]=Cote_Droit[sortie]/buf;
for(i=0;i<nC;i++)
{
if (i!=sortie)
Cote_Droit[i]=Cote_Droit[i] - (Val_Simplex[i][entre]*Cote_Droit[sortie]);
}
float bf=Cout_Reduit[entre];
for(i=0;i<nC+nV;i++)
{
Cout_Reduit[i]=Cout_Reduit[i] - (bf*Val_Simplex[sortie][i]);
};
float bf1=0;
for(i=0;i<nC;i++)
{
bf1=Val_Simplex[i][entre];
for(int j=0;j<nC+nV;j++)
{
if (i!=sortie)
{
Val_Simplex[i][j]=Val_Simplex[i][j] -(Val_Simplex[sortie][j]*bf1);
}
}
};
Variable_Base[sortie]=Variable_Base_Ecart[entre];
}
///////////////////////////////////////////////////////////////////
//
//
//Mise jour de l'optimalit
//
///////////////////////////////////////////////////////////////////
void simplex::MAJ_Optimalite()
{
int i=0;

PROJET TO

METHODE DU SIMPLEXE

IAI2002/2003

33

PROJET TO

METHODE DU SIMPLEXE

IAI2002/2003

for(i=0;i<nC+nV;i++)
{
if (Cout_Reduit[i]<0)
{
Etat_Optimalite=false;
return;
}
}
Etat_Optimalite=true;
for(i=0;i<nC+nV;i++)
{
if(Cout_Reduit[i]!=0)
{
return;
}
}
Etat_CReduit=true;
};
///////////////////////////////////////////////////////////////////
//
////Mise jour du simplex
//
///////////////////////////////////////////////////////////////////
void simplex::Mise_A_Jour()
{
if (!(Etat_Optimalite==true)&&(Plus_Petit_Cout_Negatif(Cout_Reduit,nC+nV)!=-1))
{
if(Plus_Petit_Ratio(Plus_Petit_Cout_Negatif(Cout_Reduit,nC+nV))!=-1)
{
Election_Entree_Sortie(Cout_Reduit,nC+nV);
Pivot(ColonneEntre,LigneSortie);
MAJ_Optimalite();
}
else
{
Non_Borne=true;
}
}
else
{
if((Plus_Petit_Cout_Negatif(Cout_Reduit,nC+nV)==-1))
{
Etat_Optimalite=true;
}
}
};

///////////////////////////////////////////////////////////////////
//
// Affichage des rsultats du simplex
//
///////////////////////////////////////////////////////////////////
void simplex::Sortie_Resultats()
{
int i=0;
cout<<"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"<<endl;
cout<<"X
Cote droit
X"<<endl;
cout<<"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"<<endl;
while(i<nC)
{
cout<<" "<<Cote_Droit[i]<<endl;
i++;
}
i=0;
cout<<"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"<<endl;
cout<<"X
Cout Reduit
X"<<endl;
cout<<"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"<<endl;
while(i<nC+nV+nE)
{

PROJET TO

METHODE DU SIMPLEXE

IAI2002/2003

34

PROJET TO

METHODE DU SIMPLEXE

IAI2002/2003

cout<<Cout_Reduit[i]<<" ;";
i++;
}
cout<<endl;
cout<<"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"<<endl;
cout<<"X
Tableau du simplex
X"<<endl;
cout<<"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"<<endl;
for(i=0;i<nC;i++)
{
for(int j=0;j<nC+nV+nE;j++)
{
cout<< Val_Simplex[i][j]<< " ;";
}
cout<<endl;
}
switch(Etat_Optimalite)
{
case false:
cout<<"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"<<endl;
cout<< "X Optimum non atteint
X"<<endl;
cout<<"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"<<endl;
break;
case true:
cout<<"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"<<endl;
cout<<"X Solution optimale
X"<<endl;
cout<<"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"<<endl;
break;
}
cout<<endl;
char C[4];
char C1[4];
for(i=0;i<nC;i++)
{
_itoa(Variable_Base[i],C,10);
strcpy(C1,"X");
strcat(C1,C);
cout<<C1<<"= "<<Cote_Droit[i]<<" ";
}
cout<<endl;
i=0;
int j=0;
bool trouve=false;
while(i<nC+nV)
{
while((j<nC)&&(trouve==false))
{
if(Variable_Base[j]==Variable_Base_Ecart[i])
{
trouve=true;
}
j++;
}
if((j==nC)&&(trouve==false))
{
_itoa(Variable_Base_Ecart[i],C,10);
strcpy(C1,"X");
strcat(C1,C);
cout<<C1<< "= 0 ";
}
trouve=false;
i++;
j=0;
}
cout<<endl;
float tmp1=0;
CalculResultat_Base();
if(Etat_CReduit==false)
{
for(int k=0;k<nV;k++)
{
tmp1=tmp1 + LEquation[k]*Resultats_Base[k];
}
cout<<"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"<<endl;

PROJET TO

METHODE DU SIMPLEXE

IAI2002/2003

35

PROJET TO

METHODE DU SIMPLEXE

IAI2002/2003

cout<<"X L'objectif est z="<<tmp1<<" X"<<endl;

cout<<"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"<<endl;
}
};

PROJET TO

METHODE DU SIMPLEXE

IAI2002/2003

36

PROJET TO

METHODE DU SIMPLEXE

IAI2002/2003

///////////////////////////////////////////////////////////////////
//
//
Principal.cpp
//
Programme Principal de Rsolution d'un Problme
//
Linaire par la mthode du simplexe.
//
///////////////////////////////////////////////////////////////////
// TPOptimisation.cpp : Defines the entry point for the console application.
//
#include<iostream.h>
#include "Contraintes.h"
#include "Equation.h"
#include "SimplexPhase1.h"
#include<conio.h>
#include <dos.h>
#include "General.h"

void main()
{
Presentation();
LireEquation();
Equation EquationPL(min,E,NbreContraites,NbreVariables);
if(typeEq==1)
{
typeEquation=true;
EquationPL.Lecture_TypeEq(max);
}
LireContraintes();
EquationPL.Conversion_Min_Max(typeEq);
for(j=0;j<NbreVariables+NbreVarEcart+NbreVarArtif;j++)
{
if(j<NbreVariables)
{
Tcout[j]=EquationPL.Table_Equation[j];
}
else
{
Tcout[j]=0;
}
}
Init();
simplex* PLSimplex;
if(NbreVarArtif==0)
{
PLSimplex= new simplex(NbreVariables,NbreContraites,typeEquation);
}
else
{
PLSimplex= new SimplexPlus(NbreVariables,NbreContraites,NbreVarEcart,typeEquation);
}

PLSimplex->LectureTableauSimplex(Tcout,CDrt,ValSimplex);
PLSimplex->Sortie_Resultats();
getch();
while (PLSimplex->Etat_Optimalite==false)
{
system("cls");
PLSimplex->Mise_A_Jour();
PLSimplex->Sortie_Resultats();
if(PLSimplex->Non_Borne)
{
cout<<"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"<<endl;
cout<<"X Nous avons un optimum non born X"<<endl;
cout<<"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"<<endl;
return;
}
if(PLSimplex->Etat_CReduit)
{

PROJET TO

METHODE DU SIMPLEXE

IAI2002/2003

37

PROJET TO

METHODE DU SIMPLEXE

IAI2002/2003

cout<<"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"<
<endl;
cout<<"X Solutions multiples dont celle dont l'objectif est ci-dessus X";
cout<<"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"<
<endl;
return;
}
cout<<endl;
getch();
}

};

PROJET TO

METHODE DU SIMPLEXE

IAI2002/2003

38