Programmation linéniaire

Réalisé par :

Mohamed ZAOUI

Encadré par :

Prof. Ahmed ASIMI

Étude théorique de certains logiciels de la programmation linéaire

Université Ibn Zohr, Faculté des Sciences, Agadir

Master Informatique des Systèmes Répartis

Mini-Projet ETUDE THEORIQUE DE CERTAINS LOGICIELS DE LA PROGRAMMATION LINEAIRE

1 MISR-fsa-Agadir Mohamed ZAOUI

Tables des matières :

I. Introduction :……………………………………………………………………………………..2

II. Les logiciels actuels :…………………………………….…………………………………..3

1. Principes de fonctionnement : ……………………………………………....3

2. Les principaux solveurs :……………………………………………………...4

3. Les principaux modeleurs :…………………………………………………..4

4. Les environnements de développement intégrés (EDI) :………………5

5. Sites web des éditeurs de logiciels:………………………………………..5

III. Étude théorique de certains logiciels de la programmation linéaire :

Excel……………………………………………………...…………………………6

Lindo…………………………………………..…………………………………..12

Cplex………………………...…………………………………………………....25

Opl Studio……………………………….……………………………………...27

Matlab…………………………………………………………………………….29

Ampl……………………………………………………………………………….33

MPL for windows………………………..…………………………………...36

GAMS………………………………………….…………………………………..37

Maple……………………………………………………………………………..42

IV. Conclusion :……………………………………...…………………………….……………48



I. Introduction :

L’importance de l’optimisation et la nécessité d’un outil simple pour modéliser des

problèmes de décision que soit économique, militaire ou autres on fait de la programmation

linéaire un des champs de recherche les plus actifs au milieu du siècle précédent. Les

premiers travaux (1947) sont celle de George B. Dantzig et ses associés du département des

forces de l’air des Etats Unis d’Amérique.

Les problèmes de programmations linéaires sont généralement liés à des problèmes

d’allocations de ressources limitées, de la meilleure façon possible, afin de maximiser un profit

ou de minimiser un coût. Le terme meilleur fait référence à la possibilité d’avoir un ensemble

de décisions possibles qui réalisent la même satisfaction ou le même profit. Ces décisions sont

en général le résultat d’un problème mathématique.

Généralement il y a trois étapes à suivre pour pouvoir construire le modèle d'un programme

linéaire :

1. Identifier les variables du problème à valeur non connues (variable de décision) et les

représenter sous forme symbolique (exp. x1, y1 ).

2. Identifier les restrictions (les contraintes) du problème et les exprimer par un système

d’équations linéaires.

3. Identifier l’objectif ou le critère de sélection et le représenter sous une forme linéaire en

fonction des variables de décision. Spécifier si le critère de sélection est à maximiser ou à

minimiser.



II. Étude théorique de certains logiciels de la programmation linéaire :

Grâce aux progrès de l’informatique, l’offre de logiciels commerciaux permettant de

résoudre des PL de plus en plus gros a considérablement augmenté. On peut maintenant

résoudre en routine des PL à 100 000 variables et contraintes et des PLNE à 1 000 variables et

contraintes avec les codes les plus performants. Les prix de ces logiciels autrefois réservés à

une petite communauté ont fortement diminué et deviennent très abordables.

1. Principes de fonctionnement :

La résolution d’un problème de programmation linéaire s’effectue en deux grandes phases :

La modélisation, puis la résolution (on pourrait aussi ajouter une troisième phase d’analyse

des résultats). Historiquement, les premiers logiciels ne servaient qu’à résoudre des

programmes linéaires déjà modélisés et donnés sous forme numérique. Il s’agissait donc de

codes algorithmiques de résolution, appelés aussi solveurs. Par la suite sont venus se greffer

les langages de modélisation ou modeleurs.

Les solveurs sont distribués sous forme de logiciels autonomes, ou encore de bibliothèques de

sous-programmes à inclure dans des programmes d’application. Le programme linéaire doit

être au préalable préparé en mémoire, sous forme de matrices ou de listes de valeurs

numériques. La plupart des solveurs offrent cependant une fonction permettant de charger

un PL saisi au préalable dans un fichier texte.

Selon les produits, les PL sont stockés dans des fichiers sous forme matricielle ou sous

forme d’équations proches de l’écriture mathématique, par exemple “3*X1+2*X2 = 3”. Le

format matriciel MPS a été popularisé par le premier solveur célèbre, MPSX d’IBM. Il

permet de découper la matrice d’un grand PL en lignes de longueur fixe, de définir des

portions de lignes et de colonnes, etc. Ce format est encore utilisé comme moyen

d’échanger des données entre les logiciels actuels.

Les modeleurs aident l’utilisateur à formuler son problème correctement et à analyser les

solutions obtenues après résolution par un solveur. Un modeleur s’appuie sur un langage de

description du problème et lie cette modélisation symbolique (le modèle) à un jeu de

données. Typiquement, un modeleur permet de définir des paramètres (par exemple un

nombre de produits à fabriquer), des variables indicées, des tableaux de données, des

sommations de variables indicées, etc. L’utilisateur peut ainsi formuler son problème de

façon compacte, dans une syntaxe proche de l’écriture mathématique.

Avec un solveur, l’ajout d’un produit supplémentaire dans un problème de planification de

production oblige à insérer des nouvelles colonnes ou lignes de valeurs numériques dans la

matrice du programme linéaire. Un modeleur permet de définir un modèle générique,

paramétré par le nombre n de produits. Ce modèle peut être rendu complètement

indépendant des valeurs numériques, stockées dans des fichiers séparés. Pour ajouter un

nouveau produit, il suffira de préciser la nouvelle valeur de n et de modifier les fichiers de

données.

Le modèle ne sera pas changé. Cette souplesse accélère les développements, diminue les

risques d’erreurs et donne des modèles faciles à documenter et à relire.

Comment marche un modeleur ? Il commence par compiler le modèle pour détecter

d’éventuelles erreurs de syntaxe. Si la syntaxe est correcte, il ouvre les fichiers de données

et se charge de la tâche fastidieuse de générer le programme linéaire sous forme matricielle.

La matrice des valeurs numériques, qui peut être énorme par rapport au modèle sous forme

symbolique, sera traitée par un solveur.

Aujourd’hui, certains modeleurs peuvent être achetés seuls puis interfacés avec divers

solveurs d’autres éditeurs de logiciels, par exemple grâce au format d’échange matriciel

MPS. D’autres modeleurs sont étroitement imbriqués avec un solveur propriétaire, c’est une

des raisons pour laquelle l’amalgame entre modeleur et solveur est très vite fait. Il est tout

de même important de bien faire la distinction.



2. Les principaux solveurs :

En tête de liste on retrouve deux concurrents : OSL, renommé Optimization Solutions

(d’IBM) et Cplex Callable Library (d’ILOG), qui ont été les premiers à proposer des codes

commerciaux robustes et rapides. OSL a été le premier solveur commercial comprenant un

algorithme de point intérieur. Il n’est pas proposé avec un modeleur particulier. Robuste et

rapide, il est interfaçable avec la plupart des langages de modélisation. Depuis une récente

acquisition de Cplex Inc. par ILOG, l’offre du solveur Cplex s’est beaucoup développée.

On le retrouve par exemple comme solveur interne dans des logiciels d’optimisation

comme ILOG Planner.

A côté de ces deux grands, on trouve d’autres codes très robustes et qui ont su se faire une

place sur le marché des logiciels d’optimisation. Citons C-Whiz de Ketron Management

Science qui tourne sur mainframe et PC, HS/LP, le solveur de Harvely System Inc. qui

s’interface très bien avec le modeleur OMNI de la même société, LAMPS d’Advanced

Mathematical Software Ltd., LINDO de Lindo Systems Inc., GAUSS d’Aptech Systems

Inc., LOQO de l’université de Princeton qui propose des versions gratuites pour le monde

académique, MINOS de Stanford Business Software Inc., et bien d’autres encore. Des

produits plus connus comme Maple, Matlab ou Excel proposent aussi des extensions

permettant de résoudre des PL. Enfin, il existe même un solveur simple du domaine public,

LPSolve, diffusé avec son source en C.

3. Les principaux modeleurs :

Parmi les modeleurs, AMPL est le plus connu et le plus célèbre. Sa particularité est de

pouvoir appeler pratiquement tous les solveurs existants. Les éditeurs de codes

algorithmiques en ont fait une référence et se servent de la popularité d’AMPL pour

promouvoir leur solveur. C’est sans doute ce qui a rendu AMPL plus célèbre encore. Ce

type de langage, qui est très utile aux décideurs d’entreprise en simplifiant la modélisation

et la résolution de problèmes d’optimisation, est en pleine expansion. L’offre s’est

considérablement étoffée ces cinq dernières années.

Les autres langages de modélisation les plus connus, et qui seront brièvement décrits au

paragraphe 3.3, sont GAMS (de Gams Developpement Corp.), qui permet des modèles non

linéaires, OPL Studio (d’ILOG), qui peut appeler des solveurs de propagation de

contraintes en parallèle avec la programmation linéaire, Lingo (de Lindo Systems), très

employé dans le monde académique pour les enseignements outre-Atlantique, et MPL for

Windows (de Maximal Software). On ne peut pas dire qu’un langage est définitivement



supérieur à un autre. En fait, pour choisir un langage, la meilleure façon est de tester les

versions limitées qui sont proposées sur les sites web des éditeurs de logiciels.

4. Les environnements de développement intégrés (EDI) :

Pour satisfaire une clientèle de plus en plus exigeante, les interfaces de développement

(EDI) sont apparues et proposent des menus, des fenêtres et d’autres fonctionnalités pour

aider l’utilisateur à rédiger et déboguer son modèle. Pour les PC, la plupart des éditeurs

fournissent un EDI agréable à utiliser. Cette interface est souvent la version disponible

gratuitement sur le web. Parmi les éditeurs déjà cités, ceux qui proposent une interface sont

GAMS, OPL Studio, Lingo, MPL for Windows et, bien sûr, Visual Xpress, qui sera utilisé

dans ce livre. La nouvelle version Xpress-IVE propose elle aussi un EDI très proche de

celui de Visual Xpress.

5. Sites web des éditeurs de logiciels :

Un article de R. Fourer [Fourer 1999] très complet reprend les caractéristiques des différents

logiciels et montre tous les liens que l’on peut trouver entre les langages de modélisation, les

solveurs utilisés et les environnements de développement intégrés. La liste suivante donne les

sites web des éditeurs de logiciels dont nous avons parlé. D’autres sites sont indiqués dans

l’article de Fourer. Il existe aussi des versions gratuites de ce type de logiciel :

AMPL http://www.ampl.com

Cplex http://www.ilog.fr

C-Whizz http://www.keytronms.com

GAMS http://www.gams.com

GAUSS http://www.aptech.com

HS/LP http://www.harvely.com

LAMPS [email protected]

Lindo et Lingo http://www.lindo.com

LOQO http://www.princetn.edu/~rvdb

MINOS http://www.SBSI-SOL-Optimize.com

MPL for Windows http://www.maximal-usa.com

OPL Studio http://www.ilog.fr

OSL http://www6.software.ibm.com/es/oslv2/startme.html

Xpress http://www.dash.co.uk

Xpress http://www.artelys.fr (distributeur Français de Dash)



Excel

1. Introduction :

Le Solveur permet de rechercher la valeur optimale d'une formule dans une cellule, appelée

cellule cible ou fonction objectif, de la feuille de calcul. Il fonctionne avec un groupe de

cellules associées (directement ou indirectement) à la formule de la cellule cible. Il adapte

les valeurs des cellules qu'on souhaite modifier, appelées cellules variables, pour fournir le

résultat spécifié à partir de la formule de la cellule cible. On peut spécifier des contraintes

pour limiter les valeurs susceptibles d'être utilisées par le Solveur, et ces contraintes peuvent

faire référence à d'autres cellules qui ont une incidence sur la formule de la cellule cible.

On utilise également le Solveur pour déterminer la valeur minimale ou maximale d'une

cellule en modifiant d'autres cellules. Les cellules sélectionnées doivent être associées par

des formules dans la feuille de calcul.

Le solveur agit par itérations successives sur une ou plusieurs variables jusqu'à obtenir une

valeur définie pour la valeur cible, en tenant compte des contraintes imposées.

2. Installation :

Pour utiliser le solveur, il faut:

Choisir : OUTILS /MACROS COMPLEMENTAIRES…

Dans la boîte de dialogue " Macro complémentaire ", activer la case à cocher "

Solveur ".

Si l'option " Solveur " n'est pas répertoriée dans la boîte de dialogue " Macro

complémentaire ", cliquer sur " Parcourir " et rechercher le lecteur, le dossier et le nom

de fichier de la macro complémentaire " Solver.xla ", qui se trouve habituellement

dans le dossier Macrolib\Solveur, ou ré-exécuter le programme d'installation.



Remarque : Les macros complémentaires sélectionnées demeurent actives jusqu'à ce qu'on

les supprime.

3. Contraintes

Limites imposées à un problème du Solveur. On peut appliquer des contraintes à des cellules

ajustables (modifiables), à la cellule cible ou à d'autres cellules liées directement ou

indirectement à la cellule cible :

pour les problèmes linéaires, il n'existe aucune limite sur le nombre de contraintes;

pour les problèmes non linéaires, chacune des cellules modifiables peut avoir les

contraintes suivantes : une contrainte binaire, une contrainte de nombre entier avec

limite supérieure et / ou inférieure. On peut spécifier une limite supérieure ou inférieure

pour 100 autres cellules au maximum.

Les opérateurs suivants peuvent être utilisés dans les contraintes :

Opérateur Signification

<=

>=

=

int

bin

Inférieur ou égal à

Supérieur ou égal à

Égal à

Nombre entier (applicable uniquement aux cellules modifiables)

Binaire (applicable uniquement aux cellules modifiables)

Exemple :

Calcul d'un budget loisirs

Je voudrais me rendre 20 fois au spectacle (Cinéma, Théâtre et Concert) et

je veux voir au moins 5 films et assister à au moins 3 concerts,

il ne faut pas que le nombre de films dépasse le double du nombre de pièces de

théâtre,

le prix d'une place de cinéma est de 200 F, d'une place de théâtre est de 350 F et

d'une place de concert est de 500 F.

Entre quelles valeurs minimale et maximale mon budget loisirs peut-il varier ?

Création de la feuille de calcul :

o Dans cet exemple, on réserve les cellules B11 à F11 pour créer le modèle. Ces

cellules sont nommées respectivement x, y, z, BUDGET et N.

o On initialise le nombre de places de cinéma, de théâtre et de concert en B11,

C11 et D11 (x, y, z) à 0.



o Ensuite, on entre la formule de la fonction objectif en E11 (BUDGET) :

=200*X+350*Y+500*Z

(le prix d'une place de cinéma est de 200 F …).

o Enfin, on indique en F11 (N) la formule : =X+Y+Z

(Je voudrais me rendre 20 fois au spectacle …).

Les contraintes :

Je voudrais me rendre 20 fois au spectacle … N=20

je veux voir au moins 5 films et

assister à au moins 3 concerts

x >= 5

z >= 3

il ne faut pas que le nombre de films dépasse

le double du nombre de pièces de théâtre, x <= 2y

les nombres de places doivent des nombres entiers x = entier

y = entier

Pour utiliser le solveur, il faut :

o Sélectionner la cellule qui contient la fonction objectif : E11 ou BUDGET

o Utiliser la commande : SOLVEUR…/OUTILS

o Indiquer les paramètres du solveur à l'aide de la boîte de dialogue suivante :

la cellule cible à définir, c'est la cellule qui contient la fonction objectif,

ici : E11 ou BUDGET ;

cette fonction doit atteindre le minimum, choisir MIN ;

les cellules variables sont les nombres de séances de cinéma, théâtre

et concert, ici : B11 à D11 ;

ajouter la contrainte suivante N = 20 : bouton " Ajouter ", " Cellules " :

F11, " Signe " =, " Contrainte " : 20 et valider avec OK ou AJOUTER ;

de la même manière, ajouter les autres contraintes ;



valider ces paramètres à l'aide du bouton : " Résoudre ".

On ré-exécute une deuxième fois le solveur en remplaçant MIN par

MAX.

Voici les résultats obtenus :

Budgets loisirs

Nombres de places de

cinéma théâtre concert

Minmum 5 800

Maximum 8 050

11 6 3

5 3 12

4. Résultats du Solveur :

Garder la solution du solveur : Cliquer sur cette option pour accepter la solution et

placer les valeurs obtenues dans les cellules variables.

Rétablir les valeurs d'origine : Cliquer sur cette option pour rétablir les valeurs d'origine

dans les cellules variables.

Rapports : Crée le type de rapport spécifié et place chaque rapport dans une feuille

distincte du classeur.

o Réponses : Répertorie la cellule cible et les cellules variables accompagnées

de leurs valeurs d'origine et finale, des contraintes ainsi que des informations

sur ces dernières.

o Sensibilité : Fournit des informations sur le niveau de sensibilité de la solution

aux modifications mineures apportées à la formule figurant dans la zone

Cellule cible à définir de la boîte de dialogue Paramètres du solveur ou aux

contraintes. Ce rapport n'est pas généré pour les modèles imposant des

contraintes sur les nombres entiers. Pour les modèles non linéaires, le rapport

fournit des valeurs pour les gradients réduits et les multiplicateurs Lagrange.

Pour les modèles linéaires, le rapport inclut des coûts réduits, des prix fictifs, un



coefficient objectif (augmentation et réduction autorisées) et des contraintes

sur les plages de droite.

o Limites : Répertorie la cellule cible ainsi que les cellules variables

accompagnées de leurs valeurs respectives, de leurs limites inférieure et

supérieure et de leurs valeurs cibles. Ce rapport n'est pas généré pour les

modèles n'imposant aucune contrainte sur des nombres entiers. La limite

inférieure correspond à la plus petite valeur qu'une cellule variable peut

accepter tout en maintenant les autres cellules variables inchangées et en

respectant les contraintes. La limite supérieure est la valeur la plus élevée.

Options du solveur :

Vous pouvez contrôler les fonctionnalités avancées du processus de résolution, charger ou

enregistrer des définitions de problèmes, ainsi que définir des paramètres pour des problèmes

linéaires et non linéaires. Chaque option est associée à un paramètre par défaut qui est

adapté à la plupart des problèmes.

Temps max : Limite la durée du processus de résolution. Bien que vous puissiez

introduire toute valeur inférieure ou égale à 32 767, la valeur par défaut, 100

(secondes), convient à la plupart des problèmes mineurs.

Itérations : Limite la durée du processus de résolution en limitant le nombre de calculs

intermédiaires. Bien que vous puissiez introduire toute valeur inférieure ou égale à 32

767, la valeur par défaut, 100, convient à la plupart des problèmes mineurs.

Précision : Contrôle le niveau de précision des solutions en utilisant le nombre que

vous introduisez pour déterminer si la valeur d'une cellule soumise à une contrainte

atteint une cible ou correspond à une limite inférieure ou supérieure. Vous devez

indiquer le niveau de précision sous la forme d'un nombre décimal compris entre 0

(zéro) et 1. Plus le nombre tapé comporte de décimales, plus le niveau de précision

est élevé : par exemple, 0,0001 correspond à une précision plus élevée que 0,01.

Toutefois, plus le niveau de précision est élevé, plus le processus de résolution est long.

Tolérance : Représente le pourcentage dans la mesure duquel la cellule cible d'une

solution qui satisfait aux contraintes de nombre entier peut différer de la valeur

optimale vraie tout en demeurant acceptable. Cette option s'applique uniquement

aux problèmes imposant des contraintes sur les nombres entiers. Un niveau de

tolérance plus élevé tend à accélérer le processus de résolution.

Convergence : Lorsque la modification relative de la valeur de la cellule cible est

inférieure au nombre spécifié dans la zone Convergence, le Solveur s'arrête. La

convergence s'applique uniquement aux problèmes non linéaires et doit être

indiquée par un nombre décimal compris entre 0 (zéro) et 1. Plus le nombre tapé

comporte de décimales, plus la convergence est faible : par exemple, 0,0001

correspond à une modification relative inférieure à 0,01. Toutefois, plus la valeur de

convergence est faible, plus le processus de résolution par le Solveur est long.



Modèle supposé linéaire : Activer cette case à cocher pour accélérer le processus de

résolution lorsque toutes les relations du modèle sont linéaires et que vous souhaitez

résoudre un problème d'optimisation linéaire ou une approximation linéaire à un

problème non linéaire.

Afficher le résultat des itérations : Activer cette case à cocher pour interrompre le

Solveur et afficher les résultats de chaque itération.

Échelle automatique : Activer cette case à cocher pour appliquer la mise à l'échelle

automatique lorsque l'écart est important entre les entrées et les sorties, par exemple,

en cas de maximisation du pourcentage du bénéfice obtenu à la suite

d'investissements exprimés en millions.

Supposé non-négatif : Impose au Solveur une limite inférieure égale à 0 (zéro) sur

toutes les cellules variables pour lesquelles vous n'avez pas défini une limite inférieure

dans la zone Contrainte de la boîte de dialogue Ajouter une contrainte.

Estimations : Spécifie l'approche utilisée pour obtenir les estimations d'origine des

variables de base dans le cadre de chaque recherche unidimensionnelle.

Tangente : Utilise l'extrapolation linéaire à partir d'un vecteur tangentiel.

Quadratique : Utilise l'extrapolation quadratique, qui permet d'améliorer les résultats

pour les problèmes hautement non linéaires.

Dérivées : Spécifie la différenciation utilisée pour estimer les dérivées partielles des

fonctions d'objectif et de contrainte.

À droite : Utiliser cette option pour la plupart des problèmes dans lesquels les valeurs

de contrainte changent relativement lentement.

Centrée : Utiliser cette option pour les problèmes dans lesquels les contraintes

changent rapidement, particulièrement près des limites. Bien que cette option

nécessite davantage de calculs, elle peut s'avérer utile lorsque le Solveur renvoie un

message indiquant qu'il n'est pas en mesure d'améliorer la solution.

Recherche : Spécifie l'algorithme utilisé pour chaque itération afin de déterminer le

sens de la recherche.

Newton : Fait appel à une méthode de type Newton qui nécessite généralement

davantage de mémoire, mais moins d'itérations que la méthode de recherche par

gradient conjugué.

Gradient conjugué : Nécessite moins de mémoire que la méthode Newton, mais

requiert généralement un plus grand nombre d'itérations pour atteindre un niveau de

précision particulier. Utiliser cette option pour résoudre un problème important avec

une quantité de mémoire limitée ou lorsque l'examen des itérations révèle une

progression lente entre chaque étape.

Charger un modèle : Affiche la boîte de dialogue Charger un modèle, dans laquelle

vous pouvez indiquer la référence du modèle à charger.

Enregistrer le modèle : Affiche la boîte de dialogue Enregistrement du modèle, dans

laquelle vous pouvez indiquer l'emplacement où le modèle doit être enregistré.

Utilisez cette option uniquement lorsque vous souhaitez enregistrer plusieurs modèles

avec une feuille de calcul, dans la mesure où le premier modèle est

automatiquement enregistré.

.



Lindo

I. Introduction :

Lindo (Linear INteractive and Discrete Optimizer) est un logiciel utilisé pour résoudre les

modèles d’optimisation linéaires, entiers et quadratiques. Une des caractéristiques de Lindo

c’est qu’il offre des outils qui peuvent aider à l’analyse des modèles en utilisant la méthode de

Simplexe.

Caractéristiques de LINDO:

II. Installation du Logiciel

Pour utiliser cette version de Lindo il est conseillé d’avoir au moins un processeur 486 et 8Mo

de mémoire RAM. Il faut aussi prévoir un espace disque dur de 2Mo pour pouvoir l’installer.

Les étapes de l’installation sont :

1. Démarrer Windows.

2. Insérer le CD-ROM ou la disquette.

3. Cliquer sur l’icône Setup (install) dans votre explorateur de Windows

4. Suivre les instructions sur l’écran

Pour plus d’information sur ce logiciel visiter l’adresse web : www.lindo.com

III. Résolution d’un exemple

Dans cette section, et sur la base de l’exemple de l’agriculteur, on va focaliser notre

attention sur les opérations suivantes : introduire les données, résoudre le problème, et

analyser les résultats que donne LINDO.

a. Le problème de l’agriculteur

Le programme linéaire qui modélise le problème de l’agriculture est :

02 ,01

90 1

480 241

4402214

150 21 ..

22001100

xx

x

xx

xx

xxcs

xxMax

http://www.lindo.com/



b. Introduction des données

Double cliquer sur l’icône «lindo 6.0 for Windows » de votre menu démarrer/programmes. Le

logiciel va s’exécuter et vous aurez cette fenêtre qui s’affiche sur votre écran :

Dans tous les modèles de Lindo la fonction objectif est définie en première ligne. Dans notre

exemple la fonction objectif est :

2_200__1_100 _ xxMax

Les tirés bas indique la présence d’un espace obligatoire entre les entrées pour pouvoir les

différentiées.

Il faut noter qu’on peut remplacer x1 et x2 par n’importe quel mot qui indique ces deux

variables, par exemple, on peut remplacer x1 par "tomates" et x2 par "piments". Une autre

caractéristique est que Lindo ne fait pas de différence entre majuscule et minuscule. Pour lui

la variable « TOMATE » est la même que la variable « tomAtE ».

Pour commencer à écrire les contraintes, il faut introduire la mention « subject to » ou tout

simplement son abréviation « st ».

Dans notre exemple les contraintes sont :

90 _ _ 1 bureau)

480 _ _2_4__1 Mo)

440 _ _2_2__1_4 eau)

150 _ _2__1 terrain)

_

x

xx

xx

xx

tosubject

On remarque qu’on peut appeler chaque contrainte par un nom nominatif que Lindo va

utiliser pour afficher les résultats.

L’écran qu’on obtient après avoir introduit les différents paramètres est le suivant :

On n’a pas à ajouter les contraintes de non-négativité, Lindo suppose par défaut que les

variables de décision sont de types nonnégative.

c. Résolution du problème

Après avoir écrit convenablement le programme linéaire, on passe maintenant à la

résolution.

Pour résoudre notre programme il faut cliquer sur le bouton « » dans la barre d’outils.

Lindo va commencer ainsi à compiler le modèle. Si un message d’erreur s’affiche c’est que

le programme, par exemple, est non borné ou bien non réalisable...



Lors de la compilation, on voit une barre qui montre le pourcentage de travail effectué.

d. Interprétation des résultats

S’il n’y a pas d’erreur de formulation, Lindo va commencer à résoudre le problème. Par

défaut, il va vous demander si vous voulez faire une analyse de sensibilité. Pour le moment on

va répondre « Non ».

Avant que Lindo nous propose un premier rapport sur la solution optimale, il nous donne

l’état du problème exprimé par cette fenêtre :

Ce rapport préliminaire nous indique que :

a) Status : Optimal ; Il nous informe sur l’état de la solution actuelle. Elle peut être Optimal

(optimale), Feasible (réalisable), Infeasible (non réalisable) ou Unbounded (non bornée).

b) Iterations : 2 ; Il indique le nombre d’itérations nécessaire pour résoudre le problème (en

utilisant la version révisée de la méthode de Simplexe).

c) Infeasibility : 0 ; Ceci indique la quantité de violation dans les contraintes.

d) Objective : 26000 ; C’est la valeur de fonction objectif relative à la solution actuelle.

e) Best IP : N/A ; C’est la meilleure valeur de la fonction objectif. Ceci n’est vrai que pour les

problèmes de type entier.

f) IP Bound : N/A ; C’est la borne de la fonction objectif pour cette solution. Ceci n’est vrai

que pour les problèmes de type entier.

g) Branches : N/A ; C’est le nombre de variables entiers « branched on » par Lindo. Ceci

n’est vrai que pour les programmes de type entier.

h) Elapsed Time : 00 :06 :45 ; C’est le temps écoulé avant que le résolveur ne soit invoqué

(ce temps est variable même pour le même exemple).

Si on ferme cette fenêtre, on remarque qu’un autre rapport s’affiche. Ce rapport contient

des informations sur la solution optimale.



Dans le tableau ci-dessus s’affichent dans la première colonne les différentes variables de

décision et aussi les variables d’écart relatives à chaque contrainte du programme. Leurs

valeurs sont données dans la deuxième colonne. On vérifie bien que la solution optimale

coïncide avec la solution déjà retrouvée dans les précédants chapitres. La troisième colonne

représente les valeurs nettes, i.e. jj zc . Pour les variable d’ecart c’est les prix duals.

III. Les commandes de Lindo

Dans cette section, on décrit brièvement les différentes commandes présentes dans le

logiciel Lindo.

Dans l’environnement Windows, Lindo divise ces commandes en six catégories.

1. File

a) New : Créer un nouveau document.

b) Open : Ouvrir un document existant et le placer dans une fenêtre d’édition (cette fenêtre

a une capacité maximale de 64000 caractères).

c) View : Ouvrir un document existant dans une fenêtre de vision (view window). Ce genre

de fenêtre permet d’importer des programmes à plus de 64000 caractères de votre

éditeur (tels que Word). Quelques opérations ne sont pas autorisées dans un view window

tels que : couper, copier, coller, effacer…

d) Save : Enregistrer. Le format par défaut est le *.ltx, et c’est le format texte de Lindo.

e) Save as : Enregistrer sous. D’autres formats sont présents tels que le *.lpk (c’est un format

compressé qui ne peut être lu par aucun autre éditeur autre que celui de Lindo) ou le

*.mps (malgré qu’il n’accepte pas les commentaires dans le rapport, ce format est utilisé

par d’autres logiciels)

f) Close : fermé.

g) Print : Imprimé.

h) Priter setup : propriétés de l’imprimante.

i) Log Output : Pour ouvrir ou fermer des log file utilisés pour enregistrer les résultats de votre

session.



j) Take Commands : Pour exécuter des macros.

k) Basis Read : Pour charger du disque une solution de base pour le modèle actif.

l) Basis Save : Enregistrer sur le disque la solution de base du modèle actif.

m) Title : Afficher le nom pour le modèle actif.

n) Date : Afficher la date.

o) Elapsed Time : Afficher le temps écoulé depuis le commencement de la session.

p) Exit : Quitter Lindo.

2. Edition

a) Undo :Annuler la dernière opération.

b) Cut : Couper

c) Copy : Copier

d) Paste : Coller

e) Clear : Effacer

f) Find /Replace : Rechercher/Remplacer

g) Options : Utiliser pour modifier les paramètres par défaut du système.

h) Go to Line : aller à la ligne numéro .. de la fenêtre active.

i) Paste Symbol : Elle affiche une fenêtre de dialogue qui contient les syntaxes, les variables

et les noms des lignes réservés par Lindo. On peut utiliser cette commande pour ajouter

des contraintes supplémentaires au modèle.



j) Select All : Sélectionner Tout

k) Clear All : Effacer tout

l) Choose New Font : Choisir les polices dans la fenêtre active.

3. Solve

a) Solve : Résoudre le modèle dont la fenêtre est active

b) Compile Model : Compiler (sans résoudre) le modèle dont la fenêtre est active

c) Debug : Débugger le modèle dont la fenêtre est active, s’il est non réalisable ou non

borné. Dans le cas d’un problème non réalisable, la commande Debug détecte

l’ensemble des contraintes (sufficient set), dont l’élimination est suffisante pour garantir

une solution optimale. Et il détermine aussi un ensemble de contraintes (necessary set),

dont la modification entraîne nécessairement un modèle réalisable. Dans le cas d’un

problème non borné, la commande Debug détecte l’ensemble des variables de

décision (sufficient set), dont la fixation de leurs valeurs est suffisante pour garantir une

solution optimale. Et il détermine aussi un ensemble de variables de décision (necessary

set), dont la modification entraîne nécessairement un modèle borné.

d) Pivot : Une des opérations fondamentales dans la méthode de Simplexe est l’opération

pivot, qui correspond à une itération du simplexe. Lindo nous donne la possibilité de

choisir nous même les variables entrantes et sortantes et nous permet ainsi de résoudre le

programme itération par itération.

Exemple : Essayons de résoudre le problème de l’agriculteur en utilisant la commande

« Pivot ».

La variable entrante dans le premier tableau de Simplexe est X2 et la variable sortante est la

variable d’écart de la contrainte dans la 4ième ligne.



Le rapport suivant s’affiche :

Donc cette itération a fait passer la valeur de la fonction objectif à 24000.

Pour pouvoir choisir les variables entrantes et sortantes on peut afficher le tableau de

Simplexe relatif à la dernière itération en utilisant la commande « Tableau » dans le menu

« Reports ». On obtient :

D’après le tableau ci-dessus, la variable entrante est X1 et la variable sortante est SLK 2.

On obtient ainsi le résultat suivant :

La valeur de la fonction objectif est optimale et on peut vérifier que le tableau de simplexe

relatif à cette dernière itération est optimal :

e) Preemptive Goal : Cette commande peut résoudre un problème à objectif multiples en

adoptant une manière lexicographique. Ainsi on optimise le premier objectif puis le

second sous une contrainte supplémentaire que le premier est égale à la valeur optimale

déjà trouvée. Plus précisément, supposons que l’agriculteur peut acheter des ressources

supplémentaires avec un prix de 40 dinars pour un hectare de terrain(Y1), 10 dinars le m3

d’eau (Y2) et 8 dinars l’heure supplémentaire de main d’œuvre (Y3). Les quantités

disponibles sur le marché respectivement pour Y1, Y2 et Y3 sont de 10 hectares de terrain,

5 m3 d’eau et 4 heures de main d’œuvre. On appelle G le gain issu de la culture et D les

dépenses d’achat des ressources supplémentaires. Le programme peut s’écrire sous

cette forme :



La résolution avec la commande « Preemptive Goal » nous donne les résultats suivants :

4. Reports

a) Solution : Elle donne un rapport de résolution standard avec ou sans les variables non

nulles.

b) Range : Cette commande donne la marge de variation des coefficients de la fonction

objectif et du second membre sans que la base dans la solution optimale ne change. Pour

l’exemple de l’agriculteur, cette commande donne les résultats suivants :



c) Parametrics : Cette commande permet de faire une analyse paramétrique du second

membre des contraintes. Par exemple, après avoir résolu le problème de l’agriculteur, on

aimerait avoir une idée sur la variation de la valeur de la fonction objectif suite à une

variation entre 150 à 300 hectares de la surface de terrain disponible. En utilisant cette

commande, une fenêtre de dialogue s’ouvre. On fait entrer le numéro de la contrainte à

étudier (2) ainsi que la variation du second membre (300). On peut aussi choisir le type de

rapport de résultat. Dans notre cas, le choix s'est porté sur un graphique à deux dimensions.

Le rapport qu’on obtient est le suivant :

d) Statistics : Cette commande affiche des statistiques relatives au problème actif dans la

fenêtre du rapport tel que le nombre de variables de décision, le nombre de lignes…

e) Pereuse : Cette commande est utilisée pour générer un rapport sous forme de texte ou de

graphique (en 2D ou en 3D) relatif aux résultats du problème actif. Le menu associé à cette

commande est le suivant :



On a choisi ici d’avoir un rapport graphique sur les valeurs des variables de décision ainsi sur

les variables duales qui leurs sont associées dans le problème de l’agriculteur. Le résultat est

le tableau suivant :

f) Picture : Cette commande permet de créer un texte ou une figure qui illustre les différents

paramètres du problème. La fenêtre de dialogue associée à cette commande est la

suivante :

Le résultat obtenu pour le problème de l’agriculteur est le suivant :

g) Basis Picture : Cette commande affiche dans la fenêtre rapport une figure qui représente

la matrice de base actuelle (relatif à la solution trouvée en exécutant la commande

solve du même menu). Le rapport qu’on obtient en exécutant cette commande pour le

problème de l’agriculteur est :



h) Tableau : Cette commande affiche le tableau de Simplexe relatif à la solution en cours. Si

la solution est optimale, cette commande permet d’avoir le tableau de Simplexe

optimal. Dans le problème de l’agriculteur le tableau de Simplexe optimal obtenu en

utilisant cette commande est :

i) Formulation : Elle permet de visualiser un élément sélectionné (des lignes) ou tout le

problème dans la fenêtre rapport.

j) Show Column : Cette commande vient s’ajouter à la commande formulation, elle nous

permet de visualiser des colonnes (choix relatifs aux variables de décision) dans la fenêtre

du rapport.

k) Positive Definite : Cette commande est utilisée pour les problèmes quadratiques pour

s’assurer que la valeur optimale est globale.

5. Window

a) Open Command Window : Cette commande ouvre une fenêtre de dialogue qui sert à

éditer des macros pour Lindo.

b) Open Status Window : Cette commande ouvre la fenêtre de dialogue qui affiche l’état

du programme Lindo (Lindo Solver Status).

c) Send to Back : Cette commande est utilisée pour balancer les fenêtres en arrière plan.

d) Cascade : Cette commande arrange les fenêtres qui s’affichent sur l’écran sous une

forme dite cascade.

e) Title : Cette commande arrange les fenêtres de manière à redimensionner ces fenêtres et

les afficher horizontalement ou verticalement selon votre choix.



f) Close All : Cette commande permet de fermer toutes les fenêtres actives.

g) Arrange Icons : Cette commande permet d’arranger les fenêtres réduites sous forme

d’icône.

6. Help

a) Contents : Cette commande ouvre la fenêtre d’aide de Lindo

b) Search for Help On… : Cette commande permet la recherche rapide par mots clés.

c) How to Use Help : Cette commande affiche un menu qui informe sur la manière dont on

peut utiliser le menu Help.

d) About LINDO… : Cette commande affiche quelques informations concernant la version

du logiciel Lindo utilisé.

VI. Programmation à nombres entiers

On peut utiliser Lindo pour résoudre des problèmes en nombres entiers. Il suffit de mentionner

que les variables du problème sont de type entier.

On va supposer ici que dans le problème de l’agriculteur les variables de décision X1 et X2

sont de type entier. On sait déjà que la solution optimale va demeurer inchangée puisque les

valeurs de ces variables à l’optimum sont des entiers.

Pour utiliser Lindo, il faut procéder comme avant :

1/ On fait entrer la fonction objectif

2/ Commencer à écrire les contraintes après avoir introduit la mention « Subject to »

Après avoir terminer l’édition des contraintes il faut ajouter la commande « END », qui indique

que l’édition des contraintes est terminée. Ainsi on peut définir la nature des variables de

décision.

Pour dire qu’une variable X est de type

a) Entiers (XIN), on écrit : « GIN _ X »

b) Binaire (X={0,1}), on écrit : « INT _ X »

c) Non bornée (XIR), on écrit : « FREE _ X »

Pour le problème de l’agriculteur à variables entiers on écrit :



La résolution de ce problème donne le résultat suivant :



CPLEX

Introduction :

CPLEX (édité par la société ILOG) est un solveur de programmation linéaire, c’est-à-dire un

logiciel permettant de résoudre des problèmes d’optimisation linéaire. Plusieurs types

d’algorithmes de résolution sont disponibles, en particulier l’algorithme du simplexe et un

algorithme de points intérieurs.

Deux modes d’utilisation sont disponibles : via une API, permettant d’interfacer CPLEX à l’aide

d’un langage de programmation (de type Java ou C++), et un mode interactif, en lignes de

commande.

Principales commandes du mode interactif :

Sous Windows, on peut lancer CPLEX à partir du menu Démarrer (dans le répertoire ILOG, ou

un de ses sous-répertoires). Une fois que CPLEX est lancé, un prompt apparaît et on peut

entrer l’ensemble des commandes du mode interactif. Dans ce mode, un seul PL peut être

chargé à la fois dans CPLEX (un nouveau PL “chassant” l’ancien). Nous allons lister ici

les principales commandes utilisables dans ce mode. Commençons par les commandes de

base :

La commande help fournit la liste de toutes les commandes disponibles. La

commande help nom_commande fournit des informations sur la commande

nom_commande.

La commande xecute ligne_commande exécute, sans quitter CPLEX, la commande

Windows ligne_commande (par exemple dir ).

La commande quit permet de quitter CPLEX.

La commande set affiche la liste des paramètres de CPLEX modifiables. On peut

ensuite modifier n’importe lequel de ces paramètres en entrant son nom (on peut

aussi le faire directement avec la commande set nom_parametre).

La commande optimize lance la résolution du PL actuellement chargé dans CPLEX.

Par défaut, c’est l’algorithme du simplexe qui est utilisé.

Deux remarques :

1. Pour la plupart des commandes qui attendent un argument (comme help

nom_commande ou set nom_parametre, par exemple), entrer le nom de la

commande uniquement (sans argument) a pour effet d’afficher la liste de tous

les arguments possibles.

2. CPLEX est capable de compléter automatiquement les noms de commandes,

lorsqu’ils ne sont pas ambigus. Par exemple, CPLEX comprendra que h signifie help

(car aucune autre commande ne commence par la lettre “h”).

Détaillons à présent les autres commandes.

La commande enter nom_pb permet d’entrer un nouveau PL, qui s’appellera

nom_pb. On peut alors commencer la saisie de ce PL, au format LP, détaillé plus loin.

La commande display argument permet d’afficher toutes les informations dont

dispose CPLEX concernant l’option argument. L’option argument a cinq valeurs

possibles : iis, problem, sensitivity, settings, solution.

La commande write mon_fichier.lp écrit le PL actuellement chargé dans CPLEX (au

format LP) dans le fichier texte mon_fichier.lp. La commande write mon_fichier.bas



écrit la solution optimale du PL qui vient d’être résolu par CPLEX dans le fichier texte

mon_fichier.bas.

La commande read mon_fichier.lp charge dans CPLEX le PL contenu dans le fichier

mon_fichier.lp (au format LP).

La commande add permet d’entrer de nouvelles contraintes au PL courant (comme

après le mot-clé st, cf la description du format LP), au format LP. Si elle est suivie du

mot-clé bounds, elle permet d’entrer de nouvelles bornes pour une ou plusieurs

variables (cf encore la description du format LP). Il faut terminer la saisie par le mot-

clé end.

La commande change affiche la liste des modifications possibles à appliquer au PL

courant (effacer un élément, changer les bornes d’une variable, un coefficient, un

nom, etc.). La modification désirée peut alors être effectuée.

Le format de fichier LP

Tous les PL que l’on veut résoudre avec le mode interactif de CPLEX doivent être entrés au

format LP, que ce soit dans un fichier texte (qui sera chargé dans CPLEX à l’aide de la

commande read) ou après la commande enter nom_pb. Le nom d’un fichier texte

contenant un PL au format LP doit finir par “.lp”. Voici une description d’un PL au format LP :

Ce fichier LP correspond au PL suivant :

Quelques remarques :

Le mot-clé maximize peut être remplacé par minimize (si on minimise la fonction de

coût).

Le mot-clé st peut être remplacé par subject to.

La section commencée par le mot-clé bounds contient uniquement des contraintes

de bornes (du type a _ x _ b). Par défaut, si on ne précise pas de borne inférieure pour

une variable x, on a x _ 0. Si on ne précise pas de borne supérieure, il n’y en a aucune

par défaut.

Le mot-clé end est obligatoire à la fin.

Le nom de la fonction objectif (“Nom_objectif” ici) et les noms des contraintes

(“Nom_contrainte1”, “Nom_contrainte2”, “Nom_contraintei” ici) sont facultatifs. Par

défaut (c’est-à-dire, si on ne les redéfinit pas), le nom de la fonction objectif est “obj”

et les noms des contraintes sont “c1”, “c2”, etc. (dans l’ordre d’apparition). Dans ce

cas, on n’écrit pas “:” devant la contrainte.



OPL Studio

1) Introduction :

Ilog OPL Studio est un produit de la société Ilog. C’est un outil de modélisation et de

résolution des problèmes en :

Programmation mathématique

1. Programmation linéaire,

2. Programmation linéaire en nombres entiers,

3. Programmation mixte

Programmation par contraintes

OPL studio est caractérisé essentiellement par la simplicité de son langage et par la

puissance de ses méthodes de résolution des problèmes en programmation par contraintes.

2) Manipulation de OPL Studio

En lançant OPL studio, la fenêtre principale de OPL s’affiche comme suit :

Figure : Menu principal de OPL Studio



Commencer par créer un nouveau projet, en cliquant sur File new Project. Le projet

s’affiche par défaut sous le nom noname dans la fenêtre gauche de l’espace de travail.

Pour insérer un nouveau modèle au projet, cliquer avec le bouton droit, sur le projet puis

choisir Add New Model File comme le montre la figure ci-dessus. Dans la fenêtre droite de

l’espace de travail, saisir le programme à exécuter et lancer l’exécution.

Pour lancer l’exécution du programme, Cliquer sur Execution Run. Sinon, cliquer

directement sur l’icône dans la barre d’outils. Pour arrêter l’exécution ou lancer une autre

exécution cliquer sur Execution Abort, ou bien cliquer directement sur dans la barre

d’outils.

3) Syntaxe du langage OPL

Présentation de la syntaxe

Un programme OPL se présente sous la forme suivante :

Pour écrire un message sur plusieurs lignes, utiliser /*………………*/. Par ailleurs, quand

il s’agit d’un message sur une seule ligne, il suffit d’écrire / / au début de la ligne.

Quand on utilise le type int pour une variable, il faut préciser l’intervalle dans lequel

l’entier peut se trouver.

Exemple : var int X[1..3] in 0..10000;

4) Exemple de modèle OPL



Matlab

1. Introduction :

Matlab est en même temps un langage de programmation et un environnement permettant

d'utiliser ce langage. Ce langage fut développé dans les années 70 pour des applications

impliquant des matrices, l'algèbre linéaire et l'analyse numérique. Le mot "Matlab" est en fait

la forme courte de "Matrix Laboratory".

2. ENVIRONNEMENT MATLAB :

L’environnement MATLAB se présente sous la forme d’un espace de travail (Workspace), où

un interpréteur de commandes exécute des opérations et fonctions MATLAB. Les sources de

celles-ci sont disponibles, écrites en “ langage ”

MATLAB, voire en C ou en Fortran. L’utilisateur peut à sa guise les modifier, mais en s’en

inspirant, il peut surtout créer et rajouter ses propres fonctions.

">>" symbole/prompt apparaissant à gauche et indiquant que l'interpréteur est prêt à

recevoir une commande.

3. Variables :

Les variables définies par l'utilisateur sont rangées

dans l'espace mémoire de Matlab, ces variables sont

dites globales.

Le "Workspace browser" permet d'observer les

variables existantes. Les commandes who ou whos

permettent d'obtenir les mêmes informations.

Pour lancer le Workspace browser, icône:

4. Répertoires de travail :

Matlab permet d'ouvrir, de créer, de modifier etc…

des fichiers. Matlab sauvegarde tous les fichiers

créés dans le répertoire par défaut qu'il est possible

de modifier à l'aide de la commande "cd" ou en

lançant le "path browser" à l'aide de l'icône suivant :

La fenêtre suivante apparaît, il est alors possible de

changer le répertoire courant.



Quand une commande est tapé, matlab recherche celle-ci dans l'ensemble des répertoires

dont la liste apparaît dans la fenêtre "path", on peut ajouter ou supprimer un répertoire de

son choix.

5. Editeur :

On l’appelle soit par son icône à partir du gestionnaire de programmes, soit directement à

partir de MATLAB en sélectionnant FileNew-Mfile.

6. Aide en ligne :

En plus de l’aide de Windows, une aide en ligne est disponible pour chaque

commande de MATLAB. Il suffit d’introduire : help nom de commande

helpwin ouvre une fenêtre contenant la liste des commandes Matlab ainsi que leurs

documentations

help donne la liste de toutes les commandes par th_emes

lookfor nom recherche une instruction _a partir du mot cl_e nom

Commentaires

Le symbole % introduit un commentaire, celui-ci n'est pas évalué par l'interpréteur.



7. Données :

Vecteurs :

Vecteur ligne

>> v=[1 2 3 4 5] ; % vecteur 1*5

>> v=[1:5]; % résultat identique à la ligne précédente (incrément de 1 par défaut)

>> v= [1:1:5]; % idem incrément spécifié

Vecteur transposé

>> v=[1 2 3 4 5] '; % vecteur 5*1

>> v=[1:5]';

>> v= [1:1:5]';

>> w=v';

>> v1 =[borne inf:increment:borne sup];

>> v1(i) ; %ième élément ATTENTION le premier est à i=1

>> length(v) %dimension du vecteur

Matrices :

>>A=[1 2 3; 4 5 6;7 8 9; 10 11 12]; %matrice rectangle 4*3

>>B=[1

2

3] %matrice 3*1

>> size(A); %dimension de la matrice

>>A(i,j); % élément ligne i colonne j

>>A(:,n); % nième colonne

>>A(p,:); % pième ligne

>>A(i:j,:); % sous matrice des lignes i à j

>>A(i:j,k:l); % sous matrice des lignes i à j colonnes k à l

Suppression des données :

>> clear % supprime toutes les variables

>> clear A % supprime la variable A

Remarque : Dans MATLAB, les indices des vecteurs et matrices doivent être des

entiers positifs. L’indice zéro n’est donc pas plus admis que les indices négatifs.

8. GRAPHISME :

Tout tracé avec Matlab, s'effectue dans une fenêtre graphique que l'on crée par la

commande figure ou quand on exécute une commande de dessin (plot …). On peut créer

autant de fenêtres graphiques que l'on veut celles-ci étant numérotées de 1 à N au fur et à

mesure de leur création. La fenêtre graphique par défaut et la dernière qui a été créée par

figure ou la dernière activée par une commande de dessin ou sélectionnée avec la souris.

figure % crée une fenêtre graphique qui devient la figure par défaut,

figure(n) % crée une fenêtre graphique numéro n qui devient la fenêtre active.

Fonctions plot

t = 0:0.1:5;

x = 2*sin(2*pi*t);

plot(t,x); % dessin de x en fonction de t, interpolation linéaire entre les points.

plot(t,x,'-') % idem avec style - - -

plot(t,x,'b-') % idem style --- couleur bleue

plot(t,x,'o') % idem pas d'interpolation, chaque point marqué par o

Un plot provoque l'effacement du dessin précédent (par défaut) on peut superposer des

dessins en mettant le commutateur hold à on



hold on % désactivation par hold off

title('Titre de la figure');

xlabel('commentaire sur l'axe x');

ylabel('idem axe y');

axis([xmin,xmax,ymin,ymax]); % définit l'échelle des axes

egend('tracé 1','tracé 2',….) ; %chaque tracé est associé à une légende

grid % affiche une grille

text(x,y,'texte') % place texte à la position x y dans la fenêtre

gtext('texte") % place texte à la position définie avec la souris

Une fenêtre graphique peut être subdivisée en plusieurs tracés,

subplot(n,p,q) % subdivision en n*q dessin et sélectionne à qième

9. SIMULINK:

Dans la fenêtre de commande de Matlab:

La fenêtre suivante contenant les librairies de simulink, apparaît ainsi qu'une fenêtre de

travail.



AMPL

1. Introduction

AMPL est un logiciel qui permet de formuler mathématiquement des problèmes

d’optimisation. Le modèle est décrit par l’utilisateur dans un langage humainement

compréhensible. Le rôle d’AMPL est de générer une autre représentation équivalente mais

facilement compréhensible par l’algorithme qui résoudra le problème. Cette dernière

représentation est typiquement extensive (par exemple la matrice pour un problème

linéaire).

2. Constantes :

Les constantes numériques s’écrivent de la manière habituelle :

Exemple : 0.0123, 1.23D-2, 1.23e-2, 1.23E-2 sont toutes des déclarations valides et

équivalentes.

Les littéraux sont délimités par ’ ou par ”.

Exemple : ’abc’,’x’,’y’.

Note la constante 1 est différente du littéral ’1’.

Les commentaires commencent par # jusqu’à la fin de la ligne ou peuvent commencer par

/* et finir par */ en utilisant plusieurs lignes.

3. Déclaration de set :

La déclaration d’un ensemble se fait selon le format général suivant :

set nom [ alias ] [ index ] [ attribs ] ;

où attribs est une liste des attributs de l’ensemble :

attribs :

dimen n, dimension de l’ensemble.

within sexpr, l’ensemble defini est un sousensemble de sexpr

:= sexpr, definition de l’ensemble

default sexpr ; definition par défault de l’ensemble.

Note : default et := sont mutuellement exclusifs. default est utilisé seulement si l’ensemble

n’est pas défini par les déclaration des éléments de l’ensemble a la même ligne.

Exemple :

set nodes ; # il doit être défini dans la section data.

set step {s in 1..maxiter } dimen 2 :=

if s == 1 then arcs

else step[s-1] union setof {k in nodes,

(i,k) in step[s-1], (k,j) in step[s-1]} (i,j) ;

set A := 1..n ;

set C := A union B ; # A et B sont deux ensembles.

set C := A diff B ;

set C := A symdiff B ;

4. Déclaration de paramètre :

On déclare un paramètre selon le format général suivant :

param nom [ alias ] [ index ] [ attribs ] ;

attribs :

binary, le paramètre doit être binaire,

integer, le paramètre doit être entier,



symbolic, le paramètre peut prendre une valeur alphanumérique (par exemple

le nom d’un élément d’un autre ensemble).

relop expr, où relop peut être < <= = == ! = <> > >=.

in setxpr, vérifie si le paramètre appartient àun

ensemble donné.

:= expr, définition du paramètre.

default expr même chose que pour la déclaration d’un ensemble.

Exemple :

param units {raw,prd} >= 0; # units[i,j] is the quantity of raw material i

# needed to manufacture one unit of product j

param profit {prd,1..T}; # profit[j,t] is the estimated value (if >= 0)

# or disposal cost (if <= 0) of

# a unit of product j in period t

param comb ’n choose k’ \{n in 0..N, k in 0..N \}

:= if k = 0 or k = N then 1 else comb[n-1,k-1] + comb[n-1,k];

param dem ’demand’ {prd,first..last+1} >= 0;

# Requirements (in 1000s) to be met from current production and inventory

5. Déclaration des variables :

Le format général de déclaration des variables est le suivant :

var nom [ alias ] [ index ] [ attribs ] ;

attribs :

binary, la variable est binaire

integer, la variable est entière

>= expr, si la variable est inférieurement bornée

<= expr, si la variable est supérieurement bornée

:= expr, valeur d’une solution initiale (information utilisé

6. Déclaration de contraintes :

déclaration de une contrainte :

[subject to] name [alias] [index]

[ := initial dual ] [default initial dual] [ : contraint expression ] ;

Exemple :

subject to limit {t in 1..T}: sum {j in prd} Make[j,t] <= max_prd;

7. Déclaration de l’objectif :

déclaration de l’objectif :

maximize name [alias] [index] : expression ; minimize name [alias] [index] : expression ;

expression :

vexpr

to come + vexpr

vexpr + to come

to come

Exemple :

maximize total_profit: sum {p in PROD} profit[p] * Make[p];

8. Exemple:

Problème : trois étudiants doivent choisir un projet parmi trois proposés. Pour satisfaire

tout le monde, le professeur demande à chacun de donner une note de préférence à

chaque projet (de 3 à 1 : 3 pour le projet préféré, 1 pour le moins préféré). Le premier

étudiant donne les notes 1, 2 et 3 aux projets 1, 2 et 3 (il voudrait le projet 3 en priorité), le

deuxième, les notes 3, 2, 1, le troisième les notes 3, 1, 2. Pour choisir à qui attribuer quel



projet, le professeur écrit un modèle de programmation linéaire maximisant la satisfaction

totale des étudiants. Soit n le nombre d’étudiants et de projets, pij la note donnée par

l’étudiant i au projet j et xij, une variable binaire valant 1 si l’étudiant i récupère le projet j.

Le programme linéaire s’écrit de la manière suivante :

La fonction objectif (1) maximise la somme des préférences pour les affectations choisies,

la contrainte (2) spécifie qu’un seul étudiant est affecté par projet, la contrainte (3) que

chaque projet est pris par un étudiant. La contrainte (4) donne le domaine de variation des

variables. Ce modèle a automatiquement des variables entières à l’optimum (voir

chapitre 2), c’est pourquoi la contrainte (4) ne sera pas reprise dans les modèles ci-dessous,

mais remplacée par la contrainte (4’).

Le fichier de données est écrit de la manière suivante :



MPL for Windows

1. Introduction:

Le dernier langage présenté ici est MPL for Windows de Maximal Software. Encore une

fois, sa syntaxe est très proche des autres langages de modélisation. Les commentaires sont

placés entre accolades.

2. Exemple :

Problème : trois étudiants doivent choisir un projet parmi trois proposés. Pour satisfaire

tout le monde, le professeur demande à chacun de donner une note de préférence à

chaque projet (de 3 à 1 : 3 pour le projet préféré, 1 pour le moins préféré). Le premier

étudiant donne les notes 1, 2 et 3 aux projets 1, 2 et 3 (il voudrait le projet 3 en priorité), le

deuxième, les notes 3, 2, 1, le troisième les notes 3, 1, 2. Pour choisir à qui attribuer quel

projet, le professeur écrit un modèle de programmation linéaire maximisant la satisfaction

totale des étudiants. Soit n le nombre d’étudiants et de projets, pij la note donnée par

l’étudiant i au projet j et xij, une variable binaire valant 1 si l’étudiant i récupère le projet j.

Le programme linéaire s’écrit de la manière suivante :

La fonction objectif (1) maximise la somme des préférences pour les affectations choisies,

la contrainte (2) spécifie qu’un seul étudiant est affecté par projet, la contrainte (3) que

chaque projet est pris par un étudiant. La contrainte (4) donne le domaine de variation des

variables. Ce modèle a automatiquement des variables entières à l’optimum (voir

chapitre 2), c’est pourquoi la contrainte (4) ne sera pas reprise dans les modèles ci-dessous,

mais remplacée par la contrainte (4’).



GAMS

1. Introduction :

GAMS est l’acronyme de Generalized Algebric Modeling System (Système modelant

algébrique général). Il s’agit avant tout d’un langage servant à la formulation et à la

résolution de modèle de programmation mathématique. En pratique, il s’agit d’un

paquetage intégré qui permet de :

spécifier la structure du modèle d’optimisation ;

spécifier et calculer les données qui entrent dans le modèle ;

résoudre ce modèle ;

produire un rapport sur un modèle ;

conduire une analyse comparative.

GAMS peut être téléchargé à l’adresse http://www.gams.com. La licence de GAMS et des

solveurs académique est passablement élevés, toutefois il est utilisable de manière gratuite

en version de démonstration, ce qui permettra d’illustrer certains concepts de base du cours.

Sous des environnements de type UNIX (incluant Mac OS X et la majorité des distributions

Linux), GAMS s’utilise uniquement en ligne de commande. Sous Microsoft Windows, il dispose

d’une interface graphique.

2. Formulation d’un problème simple :

Considérons le problème d’optimisation linéaire

Max 109x1 + 90x2 + 115x3

x

s.c. x1 + x2 + x3 <100;

6x1 + 4x2 + 8x3 <500;

x1; x2; x3 >0:

Le fichier GAMS décrivant se problème est constitué des parties suivantes:

1. spécification des variables ;

2. spécification des équations:

déclaration ;

spécification de la structure algébrique ;

3. définition du modèle ;

4. définition de la méthode de résolution.

Ce problème peut être formulé sous GAMS comme suit:



Remarquons d’ores et déjà que chaque instruction se termine par un point-virgule. Leur

omission produit une erreur de compilation. Détaillons les instructions.

3. Spécification des variables :

GAMS exige que les variables soient identifiées. Dans l’exemple précédent, nous avons les

variables Z, X1, X2, X3:

VARIABLES

Z Variable Z;

POSITIVE VARIABLES

X1 Variable X1 (Optional Text)

X2 Variable X2

X3 Variable X3;

4. Dénomination des équations :

La spécification d’une équation consiste en deux parties. Il convient tout d’abord de

déclarer ces équations:

GAMS exige du modélisateur de nommer chaque équation à l’oeuvre dans le modèle. Dans

l’exemple, les équations sont déclarées après le mot-clé EQUATIONS



EQUATIONS

Equation1 Equation 1

Equation2 Equation 2

Equation3 Equation 3;

Comme pour les variables, le nom d’une équation peut prendre jusqu’à 31 caractères. A

droite du nom de l’équation figure un (bref) texte d’explications.

Il nous faut de plus spécifier la structure algébrique: après avoir nommé les équations, la

structure algébrique exacte doit être spécifiée en utilisant la notation ..:

Equation1..

Z =E= 109*X1 + 90*X2 + 115*X3;

Equation2..

X1 + X2 + X3 =L= 100;

Equation3..

6*X1 + 4*X2 + 8*X3 =L= 500;

La forme algébrique exige l’utilisation d’une syntaxe speciale afin de définir la forme exacte

de l’équation:

=E= contrainte d’égalité

=L= inférieur ou égal

=G= supérieur ou égal

5. Spécification du modèle :

Le mot-clé MODEL est utilisé pour identifier les modèles à résoudre. Il convient de

1. donner un nom au modèle (par exemple Example1) ;

2. spécifier les équations à inclure, entre des barres italiques / /.

Ceci donne pour notre exemple

MODEL Example1 /ALL/;

Nous pourrions aussi avoir

MODEL Example1 /Equation1, Equation2/;

6. Spécification du solveur :

Le mot-clé SOLVE indique à GAMS d’appliquer un solveur au modèle nommé, en utilisant les

données définies juste avant l’instruction SOLVE. Ainsi, dans notre exemple, nous avions:

SOLVE Example1 USING LP MAXIMIZING Z;

Si nous avions affaire à un problème linéaire de minimisation, nous pourrions écrire

SOLVE Example1 USING LP MINIMIZING Z;

En place de LP, nous devrions écrire MIP pour traiter un problème de programmation entière

mixte:

SOLVE Example1 USING MIP MAXIMIZING Z;

De même, nous spécifierons un problème non-linéaire avec le mot-clé NLP:

SOLVE Example1 USING NLP MAXIMIZING Z;

7. Rapport de solution :

A la fin de l’exécution, GAMS produit un rapport indiquant la solution trouvée, la valeur de la

fonction objectif en cette solution, ainsi que différentes informations permettant d’analyser le

comportement de l’algorithme d’optimisation, et diverses propriétés du problème en cours

d’étude. En particulier, le résumé de rapport donne le nombre total de cas non optimaux,

non réalisables et non bornés rencontrés.

**** REPORT SUMMARY : 0 NONOPT

0 INFEASIBLE



0 UNBOUNDED

L’information sur les solutions peut être affichée de différentes manières:

1. sortie standard de GAMS ;

2. utilisation des commandes DISPLAY ;

3. rappports additionels sur base des valeurs des solutions.

La sortie standard de GAMS présente la solution sous forme d’un tableau, qui dans le cas de

l’exemple est:

Le point simple “.” représente un zéro, tandis que INF représente l’infini.

8. Sommations :

La notation mathématique ∑j xj se traduira par

SUM(j,x(j))

En d’autres termes, nous avons la syntaxe SUM( index of summation, names(index))

Il est possible d’imbriquer les sommations. Ainsi,∑j∑i xji donnera SUM(j,SUM(i,x(j,i))

ou encore SUM((j,i),x(j,i))

9. Définition d’ensemble :

Spécifier les variables une à une est vite fastidieux, pour ne pas dire irréaliste (par exemple si

nous avons un million de variables), c’est pourquoi en modélisation algébrique, nous utilisons

des indices. GAMS met à disposition le mot clé SET pour définir des ensembles, parcouru par

un indice spécifié juste avant:

SET ItemName optional explanatory text for item

/ element1 optional explanatory text for element,

element2 optional explanatory text for element /

Par exemple,

SET i index /1*10/

défini l’ensemble f1; 2; : : : ; 10g, qui peut être parcouru avec l’indice i. Il est possible

d’associer un autre indice au même ensemble au moyen de la commande ALIAS, par

exemple

ALIAS (i,j) ;

permet d’utiliser j au lieu de i. Cette commande est utile par exemple pour traduire une

contrainte de la forme

xij + xji = 1; i = 1; : : : ; n; j = 1; : : : ; n;

j et i doivent indicer le même ensemble, mais écrire

SET i / 1*10 /



j / 1*10 /

mènerait GAMS à considérer i et j comme indexant deux ensembles.

Entrée de données Les données sont entrées au moyen de quatre différents types de

commandes GAMS:

SCALAR , pour les éléments ne dépendant pas d’ensembles ;

PARAMETERS , pour les éléments qui sont des vecteurs ;

TABLES , pour des éléments de deux dimensions ou plus ;

PARAMETERS , en affectation directe.

La manière la plus simple d’entrée des données est l’emploi de la commande SCALAR, qui

prend la syntaxe suivante

dans le format basique:

SCALAR ItemName optional text / value /;

Dans le cas de vecteurs, nous utiliserons la syntaxe

PARAMETER ItemName(Set) optional text;

/ element1 value,

element2 value /;

Pour les entrées multidimensionnelles, nous aurons

TABLE ItemName(set1dep,set2dep) optional text

set2elem1 set2elem2

set1element1 value11 value12

set1element2 value12 value22 ;

Plutôt que d’utiliser des constantes, nous pouvons affecter les valeurs au moyen d’expressions

mathématiques:

PARAMETER ItemName(set1dep,set2dep) optional text;

ItemName(set1dep,set2dep) = some expression;

L’indice set2dep est optionnel.

L’exemple peut ainsi se reformuler comme



Maple

1. Découverte du logiciel : Principes de base :

Maple est un logiciel de calcul formel, qui permet de faire du calcul exact et de la

programmation. L’écran de votre logiciel ressemble à ceci :

Un principe de base simple est la suivant :

Une commande Maple se termine par le symbole ;

Exemple :

Les opérateurs de bases sont les suivants :

+ addition − soustraction

∗ multiplication / division

ôu ∗∗ exponentiation ! factorielle

Les fonctions élémentaires :

ln exp cos sin tan

sqrt (square root), la racine carrée

cot la cotangente

abs valeur absolue

Les constantes réservées :

Pi Le nombre π

I une solution de X2 = −1



2 - Expressions et variables :

2.1 – Affectation

L’opération consistant à stocker une expression dans une variable est l’affectation et utilise le

symbole « := ». On écrira par exemple

[ > x:=2;

pour donner la valeur 2 à la variable x.

2.2 – Réinitialisation

On peut ensuite « vider » la variable de sa valeur en la réinitialisant par l’une des deux

commandes :

> unassign('x'); ou bien [ > x:='x';

Pourquoi les apostrophes ? La raison est importante à comprendre : il faut bien distinguer une

variable (que l’on peut considérer comme une case mémoire) de sa valeur. Tant qu’une

variable n’est pas affectée, elle représente un symbole, une variable abstraite.Sa valeur est

alors simplement son nom. Mais dès qu’une variable contient une valeur (par exemple un

nombre entier), Maple remplace toute occurrence de celle-ci par son contenu. Ainsi si on

désire parler de la variable x et non pas de l’expression stockée dans la variable x, on «

protège » celle-ci en entourant son nom par des apostrophes.

Pour réinitialiser toutes les variables on utilise la commande restart. Il est préférable de l’utiliser

quand on commence un nouveau travail, indépendant de ce qui précède (par exemple

une nouvelle feuille de calcul).

2.3 – Nom d’une variable

Notons pour commencer que Maple fait la différence entre majuscules et minuscules. Un

nom de variable commence en général par une lettre et peut contenir des chiffres et des

lettres (non accentuées). Il peut aussi contenir le caractère de soulignement « _ ».

Par exemple :

[ > Nombre_de_solutions:=2;

En fait un nom de variable peut contenir des caractères plus exotiques (et même des

espaces) à condition de « protéger » celui-ci par des accents graves (AltGr+7). Par exemple :

> 'Nombre de solutions de l'équation (*)':=2;

Mais cet usage n’est pas recommandé pour des raisons de lisibilité.

Pour terminer précisons qu’un nom ne peut pas dépasser 499 caractères et que l’on ne peut

pas utiliser comme nom de variable un mot déjà utilisé en interne parMaple (par exemple Pi,

infinity, sqrt, ...).

3 - Types de données numériques et symboliques :

La plupart des expression Maple ont un type qui caractérise leur nature. Il y a, par exemple,

plusieurs types numériques (entier, rationnels, flottant, ...) ainsi que le type symbolique.

On peut demander àMaple le type d’une expression par la commande :

> whattype(3); whattype(3.0);

integer

float

Pour chaque type de données présenté ici nous donnons en plus de sa description, quelques

fonctions qui lui sont spécifiques.

Pour tous les types numériques et symboliques, les opérations arithmétiques élémentaires sont

notées +, -, *, / et ^(ou **) pour la fonction puissance.

3.1 - Nombres entiers

Le type integer est celui des entiers relatifs.Maple peutmanipuler de très grands entiers et fait

avec ceux-ci des calculs exacts.



> 50!-2_27;

30414093201713378043612608166064768844377641568960511999865782272

3.2 - Nombres rationnels

Le type fraction désigne les nombres rationnels non-entiers. Le type rational regroupe les

types integer et fraction. Notons que Maple réduit automatiquement les fractions.

3.3 - Nombres réels

En ce qui concerne les nombres réels il faut faire très attention. Le point essentiel est qu’un

ordinateur ne peut pas stocker une quantité infinie d’informations. Le nombres réels sont en

fait de deux catégories. Il y a d’abord le type float pour les approximations en virgule

flottante. Ces nombres sont codés par mantisse m (généralement entre 0 et 1) et exposant e

(généralement 10) sous la forme mbe. Ces nombres réels sont donc tronqués avec une

précision que l’on peut modifier en changeant la valeur de la variable Digits. Il faut donc

absolument avoir à l’esprit que les calculs et résultats avec des nombres de type float sont

approchés.

Mais il existe une autre catégorie de nombres réels : ceux obtenus à partir de fonctions

classiques (par exemple racine carrée, fonctions trigonométriques et hyperboliques, fonctions

logarithme et exponentielle, ...). Ces nombres ne sont pas évalués sauf si leur

argument est déjà de type float. Leur résultat reste donc sous forme symbolique (comme

sin(1) ou p2), et les calculs sont dans ce cas exacts.

Mais on peut « forcer » l’évaluation sous forme de float à l’aide de la commande evalf (eval

to float). Pour obtenir une approximation de sin(3) avec 20 chiffres significatifs on tape par

exemple :

> evalf(sin(3),20);

0.14112000805986722210

Il est bien sur possible lors d’un calcul de mélanger les types integer, fraction et float. Dans ce

cas le résultat est de type float (donc approché).

3.4 - Nombres complexes

Le nombre complexe de module 1 et d’argument ¼ 2 est noté I en Maple (attention à la

majuscule). Un nombre complexe est une expression a+b*I, où a et b sont rationnels ou réels

(dans ce dernier cas les calculs seront donc approchés). Notons que Maple remplace

directement I2 par −1.

Pour obtenir l’écriture cartésienne (a+b*I) d’une expression on utilise evalc. Les fonctions Re,

Im, abs donnent respectivement la partie réelle, la partie imaginaire et le module d’un

nombre complexe. La fonction argument(z) permet d’obtenir l’argument de z situé dans

]−¼,¼].

On peut appliquer la fonction evalf a un nombre complexe afin d’obtenir une valeur

approchée de sa partie réelle et de sa partie imaginaire.

3.5 – Constantes

Maple utilise un certain nombre de constantes symboliques. Par exemple Pi désigne le

nombre ¼, gamma désigne la constante ° d’Euler (limite de Pnk=11k −ln(n), quand n!1) et

infinity désigne la notion abstraite d’infinie (utile pour l’écriture des limites).

On peut par exemple obtenir la limite précédente par :

> limit(sum(1/k,k=1..n)-ln(n),n=infinity);

°

Notons que l’utilisateur peut définir de nouvelles constantes symboliques en modifiant la

variable constants (voir l’aide en ligne).

3.6 – Booléens

Le type boolean est celui des expressions logiques. Les valeurs possibles sont true (vrai), false

(faux) et FAIL (pour représenter une expression dont on ne connait pas la véracité).

On peut demander l’évaluation booléenne d’une expression contenant des opérateurs de

relations (< strictement inférieur, > strictement supérieur, <= inférieur ou égal, >= supérieur ou

égal, = égal, <> différent) en utilisant la fonction evalb :

> evalb(I_2=-1);



true

On dispose bien sûr des opérateurs logiques classiques : not (négation), and (et) et or (ou non

exclusif )

3.8 - Chaînes de caractères

Depuis la version VR5 Maple fait la différence entre les variables symboliques (type symbol) et

les chaînes de caractères (type string). Il s’agit tout simplement d’une suite de caractères

quelconques encadrée par le symbole « " ». Il ne s’agit plus d’un nom destiné à représenter

une variable mais d’un mot au sens usuel. Les principales opérations sont les suivantes :

• la concaténation à l’aide de l’opérateur « . » ;

• la conversion d’une chaîne s en symbole par convert(s,symbol);

• la conversion d’un symbole s en chaîne par convert(s,string);

• l’extraction d’une sous-chaîne à l’aide de substring;

> s:="Puissante est la force dans sa famille": substring(s,3..12);

"issante es"

• la recherche d’un motif par la fonction Searchtext;

> SearchText("force",s);

4-Tableaux, vecteurs et matrices :

Tableaux, vecteurs et matrices sont des tables particulières. Mais contrairement au cas d’une

table générale, les indices ne peuvent plus être quelconques.

Un tableau (type array) de dimension n est une table dont les indices sont des n-uplets

constitués d’entiers consécutifs. Par array(1..3,-10..10,0..5) crée un tableau à 3 dimensions, le

premier indice variant de 1 à 3, le deuxième de −10 à 10 et le dernier de 0 à 5.

Une fois qu’un tableau a été créé, on peut définir la valeur des ses éléments de la même

façon que pour une table générale.

> tab:=array(1..2,0..1): tab[1,0]:=1: tab[2,0]:=2: tab[2,1]:=3:

Et on peut ensuite utiliser ces éléments dans un calcul :

> tab[1,0]-tab[1,1]+2*tab[2,1];

7−tab1,1

Il faut bien comprendre qu’un tableau (contrairement à une table) est un objet de taille fixée

: une fois les dimensions définies, on ne peut pas rajouter ou supprimer d’éléments. Par

contre, on peut bien sûr modifier les éléments déjà existants.

Une matrice (type matrix) de taille n ×p est un tableau de dimension 2, le premier indice

(indice de ligne) variant de 1 à n, et le second (indice de colonne) variant de 1 à p. On peut

créer une matrice soit comme on le ferait pour un tableau, soit en donnant la liste de ses

lignes. On utilise pour cela le constructeur matrix (array marche aussi) :

> A:=matrix([[1,2],[2,1]]); B:=array([[1,2,x],[3],[6,y],[0,0,0]]);

Dans ce cas le nombre de colonnes est la taille de la première liste, et les suivantes doivent

être de taille inférieure ou égale (certains éléments pouvant rester indéfinis).

De même un vecteur (type vector) de taille n est un tableau de dimension 1, l’indice variant

de 1 à n et comme précédemment il existe un constructeur spécifique nommé vector.

> V:=vector([a, b, c]);

V := [a,b, c]

Les opérations classiques concernant les vecteurs et les matrices seront abordées dans la

deuxième partie de ce cours.



5- Graphiques :

Maple dispose de nombreuses commandes et fonctions pour tracer des graphiques des

fonctions en deux ou trois dimensions.

La syntaxe générale pour tracer un graphe avec Maple est la suivante :

Plottype(Expression,Intervalle,Options)

Plottype : est le type de graphique que l’on veut tracer, qui est plot en deux dimensions et

plot2d en trois dimensions.

Expression : est une expression mathématique, où un ensemble d’expressions définissant la

ou les fonction(s) à tracer

Intervalle : est de la forme x=a..b avec a et b des nombres réels et a<b.

Option : correspond à une ou plusieurs spécifications optionnelles qui déterminent

l’apparence du graphe (tels que le titre, les échelles,…)

4.1. Graphiques en deux dimensions

Le type le plus simple de graphiques en deux dimensions est obtenu par une

expression de la forme : plot(f(x),x=a..b,y=c..d,opt1,opt2,…) où les termes en italiques

sont optionnels. La fonction F(x) dépendante de la variable réelle x et le domaine où

l’on va tracer la fonction est dénoté par x=a..b.

On peut tracer plusieurs graphiques à la fois en utilisant la commande plot avec

differentes options tels que la couleur, le style etc pour chacune des courbes. La

syntaxe générale est alors :

plot([expr1,…,exprn],intervalle(s),color=[c1,…,cn],style=[s1,…,sn],…)

Exemple :

> plot(cos(x)+2*x^3,x=-Pi..Pi);

4.2. Graphisme 3D :

Forme explicite

Soit a dessiner une surface dont l’equation de cette surface est donnee sous forme z=f(x,y).

La syntaxe de la commande est :

>plot3d ( f(x,y), x = a .. b, y = c .. d) ;

Exemple : soit a dessiner la surface x2 + y2 = z pour -1 < x < 1 et -2 < y < 2

>plot3d( x^2 + y^2, x= -1..1, y=-2..2) ;

Forme implicite

Soit a dessiner la surface S lorsque l’equation de cette surface est donnee sous forme :

f(x,y,z)=0.

Les commandes sont :

>with(plots) ;



implicitplot3d ( f(x,y,z), x=a..b, y=c..d, z=e..f) ;

forme paramétrique

Soit a dessiner une courbe dans l’espace dont on connait les equations parametriques

suivantes :

x = f(t)

y = g(t) b < t < a

z = h(t)

les commandes sont :

>with(plots) ;

spacecurve([f(t),g(t),h(t)], t=a..b) ;

Exemple : soit a tracer dans l’espace l’helice circulaire dont les equations parametriques

sont :

x = cos(t)

y = sin(t) 0 < t < 2π

z = t

les commandes sont :

>with(plots) ;

spacecurve([cos(t),sin(t),t], t = 0..2*Pi) ;

soit a dessiner une surface dont on connait les equations parametriques suivantes :

x = f(t,s)

y = g(t,s) a < t < b et c < s < d

z = h(t,s)

la commande est :

>plot3d([f(t,s),g(t,s),h(t,s)], t = a..b, s = c..d) ;



Conclusion:

La programmation linéaire est appliquée dans plusieurs domaines comme les

réseaux, télécommunications, transports, finance… Grâce aux progrès de

l’informatique, l’offre de logiciels commerciaux permettant de résoudre des PL de

plus en plus gros a considérablement augmenté comme Maple, LP solve, visual

Xpress, GLPK, Scilab, Maxima,Cplex,Matlab,…

Références:

Livre : Programmation Linéaire - 65 Problèmes d’Optimisation Modélisés Et Résolus

Avec Visual Xpress, de Christian Prins

www.google.com

Documents

Programmation linéniaire