TP N° 04 Optimisation FMP

UNIVERSITE KASDI MERBAH OUARGLA

FACULTE DES SCIENCES APPLIQUEES
DEPARTEMENT DE GENIE MECANIQUE
Master I Fabrication Mécanique et Productique

TP N° 04
Résolution d’un problème d’optimisation linéaire

INTRODUCTION
La forme générale d’un programme linéaire est la suivante :

x
 
Max Min f  x 
x

 A .x  b

sous  Aeq .x  beq
lb  x  ub

f, x, b, beq, lb et ub sont des vecteurs, et A et Aeq sont des matrices.
Pour la résolution de ce type de problème en utilise la fonction de référence linprog

SYNTAXE
x = linprog(f,A,b)
x = linprog(f,A,b,Aeq,beq)
x = linprog(f,A,b,Aeq,beq,lb,ub)
x = linprog(f,A,b,Aeq,beq,lb,ub,x0)
x = linprog(f,A,b,Aeq,beq,lb,ub,x0,options)
x = linprog(problem)
[x,fval] = linprog(...)
[x,fval,exitflag] = linprog(...)
[x,fval,exitflag,output] = linprog(...)
[x,fval,exitflag,output,lambda] = linprog(...)

DESCRIPTION
Linprog résout des problèmes de programmation linéaire.
 x = linprog(f,A,b) résout min f sous A*x ≤ b.
 x = linprog(f,A,b,Aeq,beq) Résout le problème précédent, en respectant les contraintes
d'égalité Aeq*x = beq. Ecrire A = [] et b = []si aucune inégalité n'existe.
 x = linprog(f,A,b,Aeq,beq,lb,ub) Définit un ensemble de limites inférieures et supérieures sur
les variables de décision, x, de sorte que la solution soit toujours dans l’intervalle lb ≤ x ≤ ub.
Ecrire Aeq = [ ] et beq = [ ] si aucune égalité n'existe.
 x = linprog(f,A,b,Aeq,beq,lb,ub,x0) Définit le point de départ sur x0. Cette option n'est
disponible qu'avec l'algorithme de taille moyenne (l'option LargeScale est réglée sur 'off' en
utilisant optimset). L'algorithme à grande échelle par défaut et l'algorithme simplex ignorent
tout point de départ.

Mise à jour 2018 1/5 Dr. BELLOUFI

TP N° 04 Optimisation FMP

 x = linprog(f,A,b,Aeq,beq,lb,ub,x0,options) Minimise, avec les options d'optimisation

spécifiées dans la structure des options. Utilisez optimset pour définir ces options (options =
optimset('param1',value1,'param2',value2,...))
 x = linprog(problem) Trouve le minimum pour problem
 [x,fval] = linprog(...)renvoie la valeur de la fonction objectif à la solution
 [x,fval,exitflag] = linprog(...)Renvoie une valeur exitflag qui décrit la condition de sortie.
 [x,fval,exitflag,output] = linprog(...) Renvoie une sortie de structure qui contient des
informations sur l'optimisation.
 [x,fval,exitflag,output,lambda] = linprog(...)Renvoie une structure lambda dont les champs
contiennent les multiplicateurs Lagrange à la solution x.

ARGUMENTS D'ENTREE
Arguments de fonction contient des descriptions générales d'arguments passés dans linprog. Options
fournit les détails spécifiques à la fonction pour les valeurs des options.
Problem f Vector de fonction objectif linéaire f
Aineq Matrice pour les contraintes d'inégalité linéaire
bineq Vector pour les contraintes d'inégalité linéaire
Aeq Matrice pour contraintes d'égalité linéaire
beq Vector pour les contraintes d'égalité linéaire
lb, ub Vector des limites inférieures, Vecteur des limites supérieures
x0 Point initial pour x
solver 'linprog'
options Structure d'options créée avec optimset

ARGUMENTS DE SORTIE
Arguments de fonctions contient des descriptions générales des arguments renvoyés par linprog.
Cette section fournit des détails spécifiques à la fonction pour exitflag, lambda et output
Entier identifiant la raison pour laquelle l'algorithme s'est terminé. Ce qui suit
exitflag répertorie les valeurs de exitflag et les raisons correspondantes pour lesquelles
l'algorithme s'est terminé.
1 La fonction converge vers une solution x.
0 Nombre d'itérations dépassé options.MaxIter.
-2 Aucun point possible n'a été trouvé.
-3 Le problème est non borné
-4 La valeur NaN a été rencontrée lors de l'exécution de l'algorithme.
-5 Les deux problèmes primal et dual sont infaisables.
La direction de la recherche est devenue trop petite. Aucun autre
-7
progrès ne pourrait être réalisé.

Mise à jour 2018 2/5 Dr. BELLOUFI

TP N° 04 Optimisation FMP

Structure contenant les multiplicateurs Lagrange à la solution x(séparée par type de

lambda
contrainte). Les champs de la structure sont:
lower Limites inférieures lb
upper Limites supérieures ub
ineqlin Inégalités linéaires
eqlin Égalités linéaires
Structure contenant des informations sur l'optimisation. Les champs de la structure
output
sont:
iterations Nombre d'itérations
algorithm Algorithme d'optimisation utilisé
0 (algorithme à grande échelle uniquement, inclus pour la
cgiterations
compatibilité ascendante)
constrviolation Maximum de fonctions de contrainte
message Message de sortie

OPTIONS
Diagnostics Afficher les informations de diagnostic sur la fonction à minimiser ou à résoudre. Les
choix sont 'on' ou 'off' par défaut.
Display Niveau d'affichage.
'off' affiche aucune sortie.
'iter' Affiche la sortie à chaque itération
'final' (Par défaut) affiche uniquement la sortie finale.
LargeScale Utilisez un algorithme à grande échelle lorsqu'il est défini sur 'on' (par défaut). Utilisez un
algorithme de taille moyenne lorsque vous sélectionnez "off" (voir Simplex dans
Algorithme à petite échelle seulement).
MaxIter Nombre maximal d'itérations autorisé, un nombre entier positif. La valeur par défaut est:
85 pour l'algorithme à grande échelle
10 * nombre de variables pour l'algorithme simplex
10 * max (nombre de variables, nombre d'inégalités + nombre de limites) pour
l'algorithme de l'ensemble actif à moyenne échelle
TolFun Tolérance de terminaison sur la valeur de fonction, un scalaire positif. La valeur par
défaut est:
1e-8 pour l'algorithme à grande échelle
1e-6 pour l'algorithme simplex
L'option n'est pas utilisée pour l'algorithme d'ensemble actif à moyenne échelle
Les algorithmes de taille moyenne utilisent l'option suivante:
Simplex Si 'on', linprog utilise l'algorithme simplex. L'algorithme simplex utilise un point de départ
intégré, en ignorant le point de départ x0 s'il est fourni. La valeur par défaut est 'off'

EXAMPLE
Trouver x qui minimise
f  x   5x 1  4x 2  6x 3
x 1  x 2  x 3  20

3x 1  2x 2  4x 3  42
sous 
3x 1  2x 2  30
0  x 1 , 0  x 2 , 0  x 3
Mise à jour 2018 3/5 Dr. BELLOUFI
TP N° 04 Optimisation FMP

1. Écrire dans la barre de commande :

f = [-5; -4; -6];
A = [1 -1 1
3 2 4
3 2 0];
b = [20; 42; 30];
lb = zeros(3,1);

2. Appeler la subroutine de programmation linéaire :

[x,fval,exitflag,output] = linprog(f,A,b,[],[],lb)

3. Résultats:
Optimization terminated.
x =
0.0000
15.0000
3.0000
fval =
-78.0000
exitflag =
1
output =
iterations: 6
algorithm: 'large-scale: interior point'
cgiterations: 0
message: 'Optimization terminated.'
constrviolation: 0
pour affiche la sortie à chaque itération on utilise la fonction optimset
pour créer la structure des options d’optimisation
Écrire dans la barre de commande :
f = [-5; -4; -6];
A = [1 -1 1
3 2 4
3 2 0];
b = [20; 42; 30];
lb = zeros(3,1);
Aeq=[];
beq=[];
Appeler la subroutine de programmation linéaire comme suit:
[x,fval,exitflag,output] =
linprog(f,A,b,Aeq,beq,lb,[],[],optimset('Display','iter'))

Résultats:
Residuals: Primal Dual Duality Total
Optimization terminated. Infeas Infeas Gap Rel
A*x-b A'*y+z-f x'*z Error
x = ---------------------------------------------------
0.0000 Iter 0: 1.13e+003 1.87e+001 2.62e+003 1.50e+003
15.0000 Iter 1: 1.64e+002 2.05e-015 4.34e+002 2.96e+000
3.0000 Iter 2: 2.95e-014 2.00e-015 7.92e+001 5.41e-001
fval = Iter 3: 5.02e-015 8.24e-015 7.70e+000 9.50e-002
-78.0000 Iter 4: 7.79e-012 2.19e-015 7.74e-001 9.84e-003
exitflag = Iter 5: 4.16e-014 1.56e-015 2.01e-004 2.57e-006
1 Iter 6: 1.00e-014 1.78e-015 2.01e-009 2.57e-011
output =
iterations: 6
algorithm: 'large-scale: interior point'
cgiterations: 0
message: 'Optimization terminated.'
constrviolation: 0

Mise à jour 2018 4/5 Dr. BELLOUFI

TP N° 04 Optimisation FMP

COMPTE RENDU (A REMETTRE SUR PLACE)

En utilisant la fonction de référence linprog (l'algorithme simplex), trouver la solution du problème

d’optimisation suivant :
Maximiser Z  f  x , y   3x  2 y

2x  y  18
2x  3 y  42

Sous les contraintes 
3x  y  24
x  0; y  0

SOLUTION COMPTE RENDU

Le problème de minimiser Z est équivalent au problème de maximisation  -1·Z . Une fois la solution
obtenue, il faudra aussi la multiplier par  -1 .
Donc Maximiser Z  f  x , y   3x  2 y  Minimiser  Z  f  x , y   3x  2 y
f = [-3; -2];
A = [2 1; 2 3; 3 1];
b = [18; 42; 24];
lb = zeros(2,1);
Aeq=[];
beq=[];
[x,fval,exitflag,output] = ...
linprog(f,A,b,Aeq,beq,lb,[],[],optimset('LargeScale','off','Simplex','on'))

Résultats:
Optimization terminated.
x =
3
12
fval =
-33
exitflag =
1
output =
iterations: 3
algorithm: 'medium scale: simplex'
cgiterations: []
message: 'Optimization terminated.'
constrviolation: 0

Mise à jour 2018 5/5 Dr. BELLOUFI