Rapport projet

Recherche opérationnelle
Méthode Simplex

ZOUITNI Akram Berik

GI19

Rapport 1

 INTRODUCTION

Le projet d'implémentation de la méthode Simplex a pour objectif de

mettre en œuvre cet algorithme en utilisant le langage de programmation C.
L'algorithme du Simplex est d'une importance primordiale dans le domaine de
la programmation linéaire car il permet de résoudre ef cacement des
problèmes d'optimisation linéaire.

L'objectif principal de l'algorithme Simplex est de trouver la solution

optimale d'un problème de programmation linéaire en maximisant ou en
minimisant une fonction linéaire objective, tout en respectant un ensemble de
contraintes linéaires. Cet algorithme est largement utilisé dans de nombreux
domaines tels que la logistique, l'économie, la plani cation de la production, la
gestion des ressources et bien d'autres.

L'algorithme Simplex offre une approche systématique pour résoudre des

problèmes de programmation linéaire de grande envergure. Il est capable de
traiter des problèmes comportant des milliers de variables et de contraintes,
fournissant ainsi des solutions optimales ou proches de l'optimalité.

En mettant en œuvre l'algorithme Simplex en utilisant le langage de

programmation C, ce projet vise à développer une solution informatique
ef cace et précise pour résoudre des problèmes de programmation linéaire.
L'implémentation du Simplex en C permettra d'automatiser le processus de
résolution de problèmes, offrant ainsi une approche plus rapide et plus able
que les méthodes manuelles traditionnelles.

En conclusion, l'implémentation de l'algorithme Simplex dans ce projet

présente des objectifs clés : résoudre des problèmes de programmation
linéaire, automatiser le processus de résolution, fournir des solutions optimales
et améliorer l'ef cacité globale de la programmation linéaire.

Rapport 2
fi
fi

fi
fi



fi
 ÉTAT DE L’ART
L'algorithme Simplex est une méthode de résolution utilisée pour résoudre
des problèmes d'optimisation linéaire. Il se base sur la notion de
programmation linéaire, qui consiste à maximiser ou minimiser une fonction
linéaire, appelée fonction objective, sous certaines contraintes linéaires.

Voici les principaux concepts et étapes de l'algorithme Simplex :

1. Formulation du problème :
- Le problème est formulé sous la forme d'un ensemble de contraintes
linéaires et d'une fonction objective linéaire.
- Les contraintes linéaires sont généralement exprimées sous la forme
d'équations ou d'inéquations linéaires.

2. Introduction de variables d'écart :

- L'algorithme Simplex utilise des variables d'écart pour transformer les
inégalités en équations.
- Ces variables d'écart permettent de passer d'un espace de contraintes à
un espace de solutions réalisables.

3. Construction du tableau Simplex :

- Le tableau Simplex est une représentation matricielle du problème
linéaire.
- Il est composé de variables d'écart, de coef cients de contraintes, de
coef cients de la fonction objective et de valeurs des contraintes.

4. Sélection de la variable pivot :

- La variable pivot est choisie selon une règle de sélection, telle que la
règle du rapport minimal ou la règle du coût réduit minimal.
- La variable pivot est celle qui va entrer dans la base du tableau Simplex.

5. Mise à jour du tableau Simplex :

- Les calculs sont effectués pour mettre à jour les valeurs du tableau
Simplex en utilisant la variable pivot sélectionnée.
- Ces mises à jour sont réalisées en utilisant des opérations élémentaires
sur les lignes du tableau.

6. Test d'optimalité et itération :

- Un test d'optimalité est effectué pour déterminer si la solution courante
est optimale ou s'il est nécessaire de continuer l'itération.

Rapport 3
fi

fi

 - Si la solution n'est pas optimale, une nouvelle variable pivot est

sélectionnée et le processus se répète jusqu'à atteindre une solution optimale.

7. Solution optimale :
- Une fois que la solution optimale est atteinte, les valeurs des variables et
la valeur de la fonction objective sont obtenues à partir du tableau Simplex.

L'algorithme Simplex peut être illustré par des exemples concrets de

problèmes de programmation linéaire. Par exemple, considérons un problème
de plani cation de production où l'objectif est de maximiser les béné ces sous
des contraintes de ressources limitées. L'algorithme Simplex peut être utilisé
pour trouver la quantité optimale à produire de chaque produit, en tenant
compte des contraintes de ressources telles que la main-d'œuvre et les
matières premières.

Un autre exemple est le problème du transport où l'objectif est de

minimiser les coûts de transport de marchandises entre différentes sources et
destinations, tout en respectant les capacités de transport disponibles.
L'algorithme Simplex peut être utilisé pour déterminer les quantités à
transporter entre les différents points a n de minimiser les coûts totaux de
transport.

Ces exemples montrent comment l'algorithme Simplex peut être appliqué

pour résoudre des problèmes de programmation linéaire réels, en trouvant des
solutions optimales qui respectent les contraintes spéci ques du problème.

Rapport 4
fi

fi
fi
fi

 Implémentation du code

Pour implémenter le code , on va l’initialiser par la dé nition de plusieurs

fonctions :

1. La fonction `displayTable` permet d'af cher le contenu d'un tableau

Simplex, donné en entrée sous forme d'une matrice à deux dimensions. Elle
parcourt les lignes et les colonnes du tableau et af che chaque élément avec la
fonction `printf`.

2. La fonction ` ndPivotColumn` recherche la colonne pivot, c'est-à-dire

la colonne avec le plus petit coef cient dans la première ligne du tableau. Elle
initialise une variable `smallestValue` avec la valeur du premier coef cient de la
première ligne, puis la compare aux autres coef cients pour trouver le plus
petit. La fonction renvoie l'indice de la colonne pivot.

3. La fonction ` ndPivotRow` recherche la ligne pivot, c'est-à-dire la ligne

avec le rapport minimum entre la colonne du terme constant et la colonne
pivot. Elle initialise une variable `minRatio` avec le rapport de la première ligne,
puis la compare aux autres rapports pour trouver le plus petit. La fonction
renvoie l'indice de la ligne pivot.

4. La fonction `performPivotOperation` effectue l'opération pivot sur le

tableau Simplex. Elle divise la ligne pivot par l'élément pivot, puis met à jour les
autres lignes en utilisant des opérations élémentaires pour les rendre nulles
dans la colonne pivot.

5. La fonction `isOptimal` véri e si la solution actuelle est optimale en

parcourant la première ligne du tableau Simplex. Si tous les coef cients sont
positifs ou nuls, la solution est considérée comme optimale et la fonction
renvoie 1. Sinon, elle renvoie 0.

6. La fonction `addSlackVariables` ajoute des variables d'écart au tableau

Simplex en parcourant les lignes et les colonnes et en remplissant les valeurs
appropriées. Cela permet de transformer les contraintes d'inégalité en
équations d'égalité.

7. La fonction `simplexMethod` met en œuvre l'algorithme Simplex. Elle

appelle d'abord `addSlackVariables` pour ajouter les variables d'écart, puis elle

Rapport 5

fi
fi

fi

fi
fi
fi
fi

fi

fi
fi
 effectue une boucle tant que la solution n'est pas optimale. À chaque itération,
elle recherche la colonne pivot et la ligne pivot, puis effectue l'opération pivot.
Elle af che ensuite le nouveau tableau, l'élément pivot, la colonne pivot et la
ligne pivot. Une fois la solution optimale atteinte, elle af che le tableau nal, la
valeur de Z (la fonction objectif) et les valeurs des variables de décision.

Dans la fonction `main`, les dimensions du problème (nombre de variables

de décision et de contraintes) sont d'abord lues depuis l'entrée utilisateur.
Ensuite, les coef cients de la fonction objective et des contraintes sont lus à
partir de l'entrée et stockés dans le tableau `table`. Le tableau initial est af ché,
puis la fonction `simplexMethod` est appelée avec le tableau, les dimensions et
les colonnes.

La fonction « displayTable »

La fonction `displayTable` permet d'af cher le contenu d'un tableau `table`

de dimensions `rows` (lignes) par `columns` (colonnes). Voici son
fonctionnement détaillé :

1. La fonction utilise deux variables d'itération, `i` et `j`, pour parcourir les
lignes et les colonnes du tableau.
2. À chaque itération de la boucle externe (pour `i`), la boucle interne (pour
`j`) est exécutée pour parcourir les colonnes de la ligne `i`.
3. À chaque itération de la boucle interne, la fonction `printf` est utilisée
pour af cher la valeur de `table[i][j]`, c'est-à-dire l'élément du tableau
correspondant à la ligne `i` et à la colonne `j`. Le format `%lf` est utilisé pour
af cher la valeur en notation décimale.
4. Après avoir parcouru toutes les colonnes d'une ligne, la fonction
`printf("\n")` est utilisée pour passer à la ligne suivante.

Rapport 6
fi
fi
fi

fi

fi

fi

fi

fi
 5. Ce processus se répète jusqu'à ce que toutes les lignes et colonnes du
tableau aient été parcourues.

Ainsi, lorsque la fonction `displayTable` est appelée avec un tableau `table`,

le nombre de lignes `rows` et le nombre de colonnes `columns`, elle af che le
contenu du tableau en af chant chaque élément dans une grille, où chaque
élément est séparé par une tabulation et chaque ligne est séparée par un saut
de ligne. Cela permet d'af cher clairement le contenu du tableau à des ns de
débogage ou de visualisation.

La fonction «  ndPivotColumn »

La fonction ` ndPivotColumn` recherche la colonne pivot dans le tableau

`table` de taille maximale `MAX_SIZE` avec `columns` colonnes. La colonne pivot
est la colonne avec la valeur la plus petite dans la première ligne du tableau.

1. La fonction initialise les variables `i` et `pivotColumn` à 1, car nous

commençons la recherche à partir de la deuxième colonne.
2. La variable `smallestValue` est initialisée avec la valeur de la première
cellule de la première ligne (`table[0][1]`).
3. La boucle `for` itère sur les colonnes, en commençant par la deuxième
colonne (indice 2) et en allant jusqu'à la colonne avant la dernière (`columns -
1`).
4. À chaque itération, la fonction véri e si la valeur de la cellule dans la
première ligne (`table[0][i]`) est inférieure à la valeur actuellement la plus petite
(`smallestValue`).
5. Si la valeur de la cellule est effectivement plus petite, la variable
`smallestValue` est mise à jour avec cette nouvelle valeur, et la variable
`pivotColumn` est mise à jour avec l'indice de la colonne correspondante (`i`).

Rapport 7

fi

fi
fi
fi

fi

fi
fi

 6. Après avoir parcouru toutes les colonnes, la fonction renvoie la valeur de

`pivotColumn`, qui représente l'indice de la colonne pivot contenant la valeur la
plus petite dans la première ligne du tableau.

La fonction «  ndPivotRow »

La fonction ` ndPivotRow` recherche la ligne pivot dans le tableau `table`

de taille maximale `MAX_SIZE` avec `rows` lignes et `columns` colonnes, en
utilisant la colonne pivot spéci ée par `pivotColumn`. La ligne pivot est
déterminée en calculant le rapport entre la valeur de chaque cellule de la
dernière colonne (`columns - 1`) et la valeur correspondante dans la colonne
pivot, puis en trouvant le rapport minimum parmi toutes les lignes.

1. La fonction initialise les variables `i` et `pivotRow` à 1, car nous

commençons la recherche à partir de la deuxième ligne.
2. La variable `minRatio` est initialisée avec le rapport entre la valeur de la
cellule dans la deuxième ligne de la dernière colonne (`table[1][columns - 1]`) et
la valeur correspondante dans la colonne pivot (`table[1][pivotColumn]`).
3. La boucle `for` itère sur les lignes, en commençant par la deuxième ligne
(indice 2) et en allant jusqu'à la dernière (`rows`).
4. À chaque itération, la fonction calcule le rapport entre la valeur de la
cellule dans la dernière colonne de la ligne (`table[i][columns - 1]`) et la valeur
correspondante dans la colonne pivot (`table[i][pivotColumn]`), et stocke ce
rapport dans la variable `ratio`.
5. La fonction véri e si le rapport `ratio` est inférieur au rapport minimum
actuel (`minRatio`).
6. Si le rapport `ratio` est effectivement plus petit, la variable `minRatio` est
mise à jour avec cette nouvelle valeur, et la variable `pivotRow` est mise à jour
avec l'indice de la ligne correspondante (`i`).

Rapport 8
fi
fi

fi
fi

 7. Après avoir parcouru toutes les lignes, la fonction renvoie la valeur de

`pivotRow`, qui représente l'indice de la ligne pivot ayant le rapport minimum
avec la colonne pivot spéci ée.

La fonction « performPivotOperation »

La fonction `performPivotOperation` effectue l'opération pivot sur le

tableau `table` de taille maximale `MAX_SIZE` avec `rows` lignes et `columns`
colonnes, en utilisant la ligne pivot spéci ée par `pivotRow` et la colonne pivot
spéci ée par `pivotColumn`.

1. La fonction commence par déclarer les variables locales `i`, `j` et

`pivotElement`, où `pivotElement` est initialisé avec la valeur de la cellule
correspondant à la ligne pivot et la colonne pivot dans le tableau `table`.
2. La première boucle `for` itère sur toutes les colonnes du tableau, à
l'exception de la première colonne (indice 0), car la première colonne
correspond aux coef cients des variables de décision dans le tableau simplex.
3. À chaque itération de la boucle, la fonction divise la valeur de la cellule
dans la ligne pivot (`table[pivotRow][j]`) par l'élément pivot (`pivotElement`).
Cela garantit que l'élément pivot devient égal à 1, en normalisant la ligne pivot.
4. Ensuite, la deuxième boucle `for` itère sur toutes les lignes du tableau.
5. À chaque itération de la boucle, la fonction véri e si l'indice de ligne (`i`)
correspond à la ligne pivot. Si ce n'est pas le cas, cela signi e que nous
sommes sur une autre ligne et nous devons mettre à jour cette ligne en utilisant
des opérations de ligne.

Rapport 9
fi
fi

fi

fi
fi
fi

 6. La fonction calcule le rapport entre la valeur de la cellule dans la ligne

actuelle (`table[i][pivotColumn]`) et la valeur correspondante dans la ligne pivot
(`table[pivotRow][pivotColumn]`), et stocke ce rapport dans la variable `ratio`.
7. Ensuite, une autre boucle `for` itère sur toutes les colonnes du tableau, à
l'exception de la première colonne.
8. À chaque itération de cette boucle, la fonction met à jour la valeur de la
cellule dans la ligne actuelle en soustrayant le produit du rapport `ratio` et la
valeur de la cellule correspondante dans la ligne pivot (`table[pivotRow][j]`) de
la valeur de la cellule dans la ligne actuelle (`table[i][j]`). Cela garantit que la
valeur de la cellule dans la ligne actuelle est mise à jour en utilisant les
opérations de ligne appropriées.
9. Après avoir parcouru toutes les lignes et toutes les colonnes du tableau,
l'opération pivot est terminée et le tableau `table` est mis à jour avec les
nouvelles valeurs résultant de l'opération pivot.

La fonction « isOptimal »

La fonction `isOptimal` véri e si le tableau `table` de taille maximale

`MAX_SIZE` est optimal pour le problème de programmation linéaire en cours.
Elle prend en compte le nombre de colonnes dans le tableau avec le
paramètre `columns`.

1. La fonction commence par déclarer la variable locale `i`.

2. Ensuite, elle itère sur les colonnes du tableau à l'aide d'une boucle `for`
qui commence à l'indice 1 (la première colonne contenant les coef cients de
l'objectif n'est pas prise en compte) et se termine à `columns - 1`. Cela exclut la
dernière colonne qui contient la valeur de la fonction objectif.
3. À chaque itération de la boucle, la fonction véri e si la valeur de la
cellule dans la première ligne et la colonne actuelle (`table[0][i]`) est inférieure à
zéro. Si c'est le cas, cela signi e que la solution n'est pas optimale, car il existe

Rapport 10

fi
fi

fi

fi

 encore des variables de décision dont la valeur doit être améliorée pour
atteindre l'optimalité.
4. Si la condition `table[0][i] < 0` est satisfaite, la fonction retourne la valeur
0, indiquant que le tableau n'est pas optimal.
5. Si la boucle se termine sans retourner 0, cela signi e que toutes les
valeurs des cellules dans la première ligne du tableau sont supérieures ou
égales à zéro, ce qui indique que le tableau est optimal.
6. Dans ce cas, la fonction retourne la valeur 1, indiquant que le tableau est
optimal.

La fonction « addSlackVariables »

La fonction `addSlackVariables` ajoute des variables d'écart (slack

variables) au tableau `table` de taille maximale `MAX_SIZE` a n de transformer
les contraintes en équations linéaires pour le problème de programmation
linéaire. Elle prend en compte le nombre de lignes dans le tableau avec le
paramètre `rows` et le nombre de colonnes avec le paramètre `columns`.

1. La fonction commence par déclarer les variables locales `i`, `j` et

`slackVar`. `slackVar` est initialisée à 1, représentant le numéro de la première
variable d'écart.
2. Ensuite, elle effectue une double boucle `for` pour parcourir les lignes et
les colonnes du tableau `table`.
3. La boucle extérieure itère sur les lignes du tableau, en commençant par
la deuxième ligne (l'indice 1) jusqu'à la dernière ligne (`rows - 1`). Cela
correspond aux lignes qui représentent les contraintes du problème.

Rapport 11

fi

fi

 4. La boucle intérieure itère également sur les lignes du tableau, en

commençant par la première ligne (l'indice 1) jusqu'à la dernière ligne (`rows -
1`). Cela permet de parcourir les cellules de chaque ligne et d'ajouter les
variables d'écart.
5. À chaque itération de la boucle intérieure, la fonction véri e si l'indice
de la ligne (`i`) est égal à l'indice de la colonne (`j`). Si c'est le cas, cela signi e
que la cellule actuelle est sur la diagonale principale du tableau.
6. Si la condition `i == j` est satisfaite, cela indique que la cellule est sur la
diagonale principale et correspond à l'ajout d'une variable d'écart. Dans ce cas,
la fonction attribue la valeur 1 à cette cellule (`table[i][columns - slackVar] = 1`)
et incrémente `slackVar` pour passer à la prochaine variable d'écart.
7. Sinon, si la condition `i == j` n'est pas satisfaite, cela signi e que la
cellule n'est pas sur la diagonale principale et ne correspond pas à une variable
d'écart. Dans ce cas, la fonction attribue la valeur 0 à cette cellule (`table[i]
[columns - slackVar] = 0`) et incrémente `slackVar` pour passer à la prochaine
variable d'écart.
8. La double boucle continue jusqu'à ce que toutes les cellules des lignes
et des colonnes appropriées du tableau aient été parcourues et que toutes les
variables d'écart aient été ajoutées.
9. Une fois que la double boucle est terminée, le tableau `table` a été mis à
jour avec les variables d'écart ajoutées aux bonnes positions.

La fonction « simplexMethod »

Rapport 12

fi
fi

fi
 La fonction `simplexMethod` implémente l'algorithme du Simplex pour
résoudre un problème de programmation linéaire. Elle prend en paramètres le
tableau `table` représentant le tableau initial du Simplex, ainsi que le nombre
de lignes `rows` et de colonnes `columns` de ce tableau.

1. La première étape de la fonction est d'appeler la fonction

`addSlackVariables` pour ajouter les variables d'écart au tableau `table`. Cela
permet de transformer les contraintes en équations linéaires sous forme
canonique.
2. Ensuite, la fonction entre dans une boucle `while` qui continue tant que
la solution n'est pas optimale. La condition pour sortir de la boucle est véri ée
à l'aide de la fonction `isOptimal`. Si la fonction renvoie 1, cela signi e que la
solution est optimale et la boucle est terminée.
3. À chaque itération de la boucle, la fonction détermine la colonne pivot
en appelant la fonction ` ndPivotColumn`, qui recherche la colonne avec la plus
petite valeur dans la ligne d'objectif.
4. Ensuite, la fonction détermine la ligne pivot en appelant la fonction
` ndPivotRow`, qui recherche la ligne avec le rapport minimal entre la colonne
des constantes et la colonne pivot.
5. La fonction af che le tableau mis à jour avec les colonnes et lignes pivot,
ainsi que l'élément pivot correspondant.
6. Ensuite, la fonction effectue l'opération de pivot en appelant la fonction
`performPivotOperation`, qui met à jour le tableau en divisant la ligne pivot par
l'élément pivot et en appliquant des opérations de ligne pour mettre à zéro les
autres éléments de la colonne pivot.
7. Après avoir effectué l'opération de pivot, la boucle `while` reprend, et le
processus se répète jusqu'à ce que la solution soit optimale.
8. Une fois que la solution est optimale, la fonction af che le tableau nal à
l'aide de la fonction `displayTable`.
9. La valeur optimale de la fonction objectif (Z) est af chée en accédant à la
cellule correspondante dans le tableau (`table[0][columns - 1]`).
10. En n, la fonction af che les valeurs des variables de décision en
parcourant les colonnes correspondantes du tableau (`table[i][columns - 1]`), en

Rapport 13

fi
fi

fi
fi
fi

fi
fi

fi
fi
fi
 commençant par la deuxième colonne (indice 1) jusqu'à l'avant-dernière
colonne.

La fonction principale «  main()  »

Rapport 14

 Le code présenté est la fonction principale `main` qui orchestre l'exécution

du programme. Voici une explication de son fonctionnement :

1. Les variables `i`, `j`, `rows` et `columns` sont déclarées. Elles seront
utilisées pour stocker des informations sur le problème de programmation
linéaire à résoudre.
2. La première instruction `printf` demande à l'utilisateur d'entrer le
nombre de variables de décision. La valeur saisie est stockée dans la variable
`columns`.
3. La ligne `columns += 2;` est utilisée pour augmenter le nombre de
colonnes du tableau `table` pour inclure les variables d'écart (slack variables) et
la ligne de l'objectif.
4. Ensuite, l'utilisateur est invité à entrer le nombre de contraintes. La
valeur saisie est stockée dans la variable `rows`.
5. La ligne `rows += 1;` est utilisée pour augmenter le nombre de lignes du
tableau `table` pour inclure la ligne de l'objectif.
6. Le tableau bidimensionnel `table` est déclaré avec une taille maximale
`MAX_SIZE`.
7. L'utilisateur est invité à entrer les coef cients de la fonction objectif. Une
boucle `for` est utilisée pour parcourir les colonnes correspondantes (deuxième
colonne jusqu'à l'avant-dernière) et stocker les coef cients dans `table[0][j]`. La
valeur est multipliée par -1 pour convertir une maximisation en minimisation.
8. La valeur de la fonction objectif (`table[0][columns - 1]`) est initialisée à
zéro.
9. Ensuite, l'utilisateur est invité à entrer les coef cients des contraintes.
Une boucle `for` est utilisée pour parcourir les lignes (à partir de la deuxième) et
les colonnes correspondantes (deuxième colonne jusqu'à l'avant-dernière). Les
coef cients sont stockés dans `table[i][j]`.
10. L'utilisateur est également invité à entrer les valeurs du membre de
droite (RHS) des contraintes, qui sont stockées dans `table[i][columns - 1]`.
11. Une fois que toutes les entrées sont effectuées, la fonction
`displayTable` est appelée pour af cher le tableau initial.
12. Ensuite, la fonction `simplexMethod` est appelée avec le tableau `table`,
le nombre de lignes et de colonnes.
13. En n, la fonction `main` se termine et renvoie 0 pour indiquer une
exécution réussie du programme.

Rapport 15
fi

fi

fi

fi

fi
fi

 Simulation

Rapport 16

 Rapport 17

 CONCLUSION
Le projet consiste en l'implémentation de l'algorithme Simplex en langage
C pour résoudre des problèmes de programmation linéaire. L'algorithme
Simplex est l'un des algorithmes les plus couramment utilisés pour résoudre
des problèmes d'optimisation linéaire.
L'importance de ce projet réside dans sa capacité à résoudre ef cacement
des problèmes de programmation linéaire en fournissant une solution optimale
ou en indiquant l'absence de solution réalisable. L'algorithme Simplex est un
outil précieux dans de nombreux domaines tels que l'économie, la gestion des
opérations, la logistique, la recherche opérationnelle et bien d'autres.
L'implémentation de l'algorithme Simplex en C a permis de réaliser les
étapes clés de l'algorithme, notamment l'initialisation du tableau, l'ajout des
variables d'écart, la recherche des colonnes et lignes pivots, les opérations
pivotantes et la véri cation de l'optimalité. Le projet a également fourni des
fonctions auxiliaires pour af cher les tableaux et les résultats.
Tout au long du projet, l'apprentissage et les idées acquises comprennent :

1. Compréhension de l'algorithme Simplex : L'implémentation de

l'algorithme a nécessité une compréhension approfondie de ses étapes et de
son fonctionnement global.

2. Maîtrise du langage C : La mise en œuvre de l'algorithme Simplex en C

a permis d'améliorer les compétences en programmation et la compréhension
des concepts clés du langage.

3. Analyse des problèmes de programmation linéaire : Le projet a

permis d'acquérir une expérience pratique dans l'analyse de problèmes de
programmation linéaire, notamment la formulation des contraintes et de la
fonction objectif.

4. Visualisation des résultats : Les fonctions d'af chage ont facilité la

visualisation des tableaux et des résultats intermédiaires, ce qui a permis de
mieux comprendre les étapes de l'algorithme et les changements apportés aux
variables.

En ce qui concerne les domaines potentiels d'amélioration ou

d'exploration futures, voici quelques idées :

Rapport 18

fi
fi

fi

fi

 1. Gestion des erreurs : Ajouter une gestion des erreurs plus robuste pour
gérer les entrées incorrectes de l'utilisateur ou les situations où le problème n'a
pas de solution réalisable.

2. Améliorations de performance : Optimiser l'algorithme Simplex pour

des problèmes de grande taille en utilisant des techniques telles que le
pivotage partiel ou l'utilisation de structures de données plus ef caces.

3. Interface utilisateur améliorée : Développer une interface utilisateur

conviviale pour faciliter l'entrée des problèmes et af cher les résultats de
manière plus intuitive.

4. Extension à d'autres variantes d'algorithmes : Explorer d'autres

variantes de l'algorithme Simplex, telles que le Simplex révisé ou le Simplex
dual, et les implémenter pour résoudre une gamme plus large de problèmes.

En conclusion, le projet d'implémentation de l'algorithme Simplex en C a

permis de mieux comprendre cet algorithme d'optimisation linéaire et ses
applications pratiques.

Rapport 19

fi
fi