L`utilisation du langage de modélisation OPL

L’utilisation du langage de
modélisation OPL
Virginie Gabrel
Master ID
OPL =

OPL est intégré dans un outil de
développement OPL Studio qui permet
d’accéder à 3 solveurs
–
–
–

Optimization Programming
Language
CPLEX
ILOG Solveur (programmation par contraintes)
ILOG Scheduler (ordonnancement)
OPL script : langage de commandes qui
permet résoudre une séquence de plusieurs
modèles en les faisant collaborer
Objectifs



Fournir à l’utilisateur un moyen simple pour
décrire/modifier un modèle
Manipuler des types de données standard :
string, {string}, float, float+, int, boolean,
tuple, range…
Manipuler des notations algébrique
–

Sum (j in 1..n) c[j]*x[j]
Séparer le modèle des données.
La notion de Projet OPL

Projet OPL = Dossier contenant des fichiers :
–
–
–
–
un ou plusieurs fichiers modèles .mod,
une ou plusieurs configurations d’exécution (chaque
config contient exactement un et un seul .mod, une
config permet de référencer un .mod et associe un
.mod à un ou plusieurs .dat),
un ou plusieurs fichiers de données .dat (il peut
n’exister aucun fichier .dat),
un ou plusieurs fichiers de paramétrages d’OPL .ops
(il peut n’exister aucun fichier .ops)
Exemple raffinerie : modèle 1
Défini
{string} Essence={"EA","EB"};
{string} Constituant={"C1","C2","C3"};
dvar float+ x[Essence,Constituant];
maximize 2.5*x["EA"]["C1"] - 0.5*x["EA"]["C2"] + 1.5*x["EA"]["C3"] +
1.5*x["EB"]["C1"] - 1.5*x["EB"]["C2"] + 0.5*x["EB"]["C3"];
subject to {
0.7*x["EA"]["C1"] - 0.3*x["EA"]["C2"] - 0.3*x["EA"]["C3"] <= 0;
0.4*x["EA"]["C1"] - 0.6*x["EA"]["C2"] + 0.4*x["EA"]["C3"] <= 0;
-0.5*x["EA"]["C1"] - 0.5*x["EA"]["C2"] + 0.5*x["EA"]["C3"] <= 0;
0.5*x["EB"]["C1"] - 0.5*x["EB"]["C2"] - 0.5*x["EB"]["C3"] <= 0;
0.1*x["EB"]["C1"] - 0.9*x["EB"]["C2"] + 0.5*x["EB"]["C3"] <=0;
x["EA"]["C1"] + x["EB"]["C1"] <= 3000;
x["EA"]["C2"] + x["EB"]["C2"] <= 2000;
x["EA"]["C3"] + x["EB"]["C3"] <= 4000;
};
Exemple raffinerie : solution
solution (optimal) with objective
7166.66666666667
x = [[366.67 1466.7 1833.3]
[2633.3 533.33 2166.7]];
Exemple raffinerie : modèle 2
{string} Essence=...;
{string} Constituant=...;
int nbCont=...;
range Cont=1..nbCont;
float coefObj[Essence][Constituant]=...;
float coefCont[Cont][Essence][Constituant]=...;
float Dispo[Constituant]=...;
dvar float+ x[Essence][Constituant];
maximize sum (i in Essence, j in Constituant) coefObj[i][j]*x[i][j];
subject to {
forall (i in Cont) contProportion:
sum (j in Essence, k in Constituant) coefCont[i][j][k]*x[j][k]<=0;
forall (j in Constituant) contDispo:
sum (i in Essence) x[i][j] <= Dispo[j];
};
Exemple raffinerie : données associées
au modèle 2
Essence={"EA","EB"};
Constituant={"C1","C2","C3"};
nbCont=5;
coefObj=[[2.5,-0.5,1.5],[1.5,-1.5,0.5]];
coefCont=[
[[0.7,-0.3,-0.3],[0,0,0]],
[[0.4,-0.6,0.4],[0,0,0]],
[[-0.5,-0.5,0.5],[0,0,0]],
[[0,0,0],[0.5,-0.5,-0.5]],
[[0,0,0],[0.1,-0.9,0.1]]];
Dispo=[3000,2000,4000];
Obtenir l’analyse de sensibilité
execute {
var i,j;
for(i in Essence)
for(j in Constituant)
writeln("x[",i,",",j,"].reducedCost=", x[i][j].reducedCost);
for(i in Cont)
writeln("ContProportion[",i,"].dual=",contProportion[i].dual);
for(i in Constituant) {
writeln("Constituant[",i,"].dual = ", contDispo[i].dual);
writeln("Constituant[",i,"].LB = ", contDispo[i].LB);
writeln("Constituant[",i,"].UB = ", contDispo[i].UB);
}
}
Obtenir l’analyse de sensibilité
Constituant[C1].dual
Constituant[C1].LB =
Constituant[C1].UB =
Constituant[C2].dual
Constituant[C2].LB =
Constituant[C2].UB =
Constituant[C3].dual
Constituant[C3].LB =
Constituant[C3].UB =
= 1.166666666666667
-Infinity
3000
= 1.5
-Infinity
2000
= 0.1666666666666667
-Infinity
4000
Le problème d’affectation sous OPL
Le fichier .mod
//Paramètres
{string} machine = ...;
{string} tache = ...;
{string} tacheMachine[tache]= ...;
int nbConflit=...;
range rgConflit=1..nbConflit;
tuple Conflit{
string tache1;
string tache2;
string machine;
}
Conflit conf[rgConflit]=...;
//Variables
dvar boolean tacheToMachine[tache][machine];
Le problème d’affectation sous OPL
Le fichier .mod
//Fonction Objectif
dexpr int NbreTache=sum(t in tache, m in tacheMachine[t])
tacheToMachine[t][m];
maximize NbreTache;
//Constraints
subject to {
forall(t in tache) //Une machine par tache
ctTache:
sum( m in tacheMachine[t])
tacheToMachine[t][m] == 1;
forall(t in rgConflit) //Conflit
ctConlit:
tacheToMachine[conf[t].tache1][conf[t].machine] +
tacheToMachine[conf[t].tache2][conf[t].machine] <= 1;
}
Le problème d’affectation sous OPL
Le fichier .dat
machine = {"M1","M2","M3"};
tache = {"T1","T2","T3","T4","T5"};
tacheMachine=[
{"M1","M2","M3"},
{"M1","M2"},
{"M1","M2","M3"},
{"M1","M2"},
{"M2"}];
nbConflit=9;
conf=[<T2,T3,M2>,<T2,T3,M3>,<T2,T4,M2>,<T2,T4,M3>,
<T2,T5,M2>,<T3,T4,M2>,<T3,T4,M3>,<T3,T5,M2>,
<T4,T5,M2>];