Cplex Callable Library

Déclaration et Initialisation de l’environnement Cplex
Gestion de l’erreur
Déclaration et initialisation du problème linéaire
Construction du problème linéaire
Résolution d’un problème
Récupération de la solution
Sauvegarde des informations
Libérer l’environnement
Université des Sciences et de la Technologie Houari Boumediene

FACULTÉ DE MATHÉMATIQUES
Solveur Cplex pour l’optimisation:

Création d’une application de
bibliothèque Callable Library
1/27
January 30,
DAHMANI Isma — 2021
Solveur Cplex pour l’optimisation: Création d’une appli
Introduction
Les applications de Callable Library sont créées pour résoudre une grande
variété de problèmes. Chaque application partage certaines caractéristiques
communes, indépendamment de son unicité apparente.
La lecture d’un fichier MPS ou LP peut réduire les efforts de codage, mais
peut également augmenter les besoins en exécution et en espace disque du
programme.
Construire le problème en mémoire, puis appeler CPXcopylp () évite des
lectures fastidieuses de fichiers de disque.
L’utilisation des routines CPXnewcols (), CPXnewrows (), CPXaddcols (),
CPXaddrows () et CPXchgcoeflist () peut conduire à un code modulaire
plus facile à gérer que si vous assemblez toutes les données de modèle en une
seule étape.
Une autre considération est que si l’application Callable Library lit un
fichier au format MPS ou LP, une autre application est généralement
nécessaire pour générer ce fichier.
2/27
DAHMANI Isma — Solveur Cplex pour l’optimisation: Création d’une appli
Introduction
Les structures de données utilisées pour générer le fichier pourraient très

certainement être utilisées pour construire directement les tableaux de
définition de problèmes pour CPXcopylp (). Le résultat serait moins de
codage et une application plus rapide et plus efficace.
Une fois qu’un objet problématique a été instancié et rempli, il peut être
résolu à l’aide de l’un des optimiseurs fournis par ILOG CPLEX Callable
Library.
Le choix de l’optimiseur dépend du type de problème (l’optimiseur de
simplexe primal; l’optimiseur dual simplex; et l’optimiseur de barrière).
Il existe également de nombreux réglages de différents paramètres pour
chaque optimiseur.
3/27
Introduction
Cplex inclut une bibliothèque, développée en plusieurs langages (C :

libcplex.a, C++ : libilocplex.a, Java : cplex.jar,...etc.), et qui contient un
certain nombre de fonctions qu’il est possible d’appeler dans un programme
(C, C++, Java,...etc.).
Dans ce qui suit, nous travaillerons en langage C et nous donnerons une
description générale de cette librairie en présentant les principales fonctions
(déclarer, construire et résoudre un programme linéaire / accéder à la
solution).
4/27
La première étape à faire est d’inclure les fichiers d’entête qui contiennent les
déclarations des différentes variables et fonctions Cplex :
# include <ilcplex/cplex.h>
Ensuite, il faut initialiser l’environnement Cplex par l’utilisation d’une variable

pointant sur l’environnement Cplex dont le type est CPXENVptr. Cette
variable sera passée en paramètre de toutes les fonctions de la librairie. La routine
CPXopenCplex() permet cette initialisation et retourne un pointeur vers
l’environnement créé.
Le mode d’emploi de CPXopenCplex() est le suivant :
CPXENVptr env= NULL ; /* déclaration d’un pointeur de type
l’environnement Cplex */
int status=0; /* contient le type d’erreur rencontré en cas de problème (0
en cas de succès)*/
env = CPXopenCPLEX (&status); /* ouvre un environnement Cplex */
Remarque : le caractère ” /∗ ” en début de ligne indique que le reste de la ligne
sera un commentaire.
5/27
En général les fonctions qui gèrent les erreurs retournent un entier : 0 en cas de
succès, une certaine constante symbolique en cas d’erreur.
Pour retrouver la description associée à un code numérique donné, il faut déclarer
une chaı̂ne de caractères de taille suffisante, puis faire appel à la fonction
CPXgeterrorstring ; le message correspondant à l’entier statut est écrit dans
une chaı̂ne (errmsg dans l’exemple ci-dessous) :
Exemple:
if ( !env ) {/*en cas d’erreur...*/
char errmsg[1024];
CPXgeterrorstring (env, status, errmsg);
fprintf (stderr, "%s", errmsg);
}
6/27
Une fois un environnement ouvert, il faut initialiser une structure de donnée dans
laquelle un problème à résoudre sera stocké.
Une autre variable qui sera présente c’est la variable qui pointe sur le programme
linéaire que l’on souhaite résoudre. Cette initialisation se fait par appel à la
routine CPXcreateprob(), qui retourne un pointeur vers un PL.
On désigne par:
CPXLPptr : type Cplex qui désigne un pointeur vers une structure PL;
CPXLPptr lp = CPXcreateprob (env, &status, ”nomDuProb”); /*crée un
PL vide*/
Ou nomDuProb représente le nom donné au problème.
/* traiter l’erreur...*/
if ( !lp )
char errmsg[1024];
CPXgeterrorstring (env, status, errmsg);
fprintf (stderr, "% s", errmsg);
7/27
Construction du problème linéaire: Par lecture de fichier
Il est possible de définir un problème de plusieurs manières : par structures

informatiques, par appels successifs à des fonctions de modification de PL, ou par
lecture de fichier. Dans ce qui suit, nous présentons deux façons à savoir: lecture
de fichier et appels successifs à des fonctions.
Par lecture de fichier
Si les données sont déjà rangées dans un fichier aux formats lp ou mps, la routine
CPXreadcopyprob() permet de lire le fichier et d’en copier les données dans la
structure PL :
int CPXreadcopyprob(CPXENVptr env, CPXLPptr lp, char *nomFichier, char
*typeFichier); tel que :
env, lp : les deux pointeurs définis précédemment
nomFichier : nombre de fichier
typeFichier: spécifié le type du fichier.
Lorsque l’argument typeFichier est NULL, le nom de fichier est vérifié pour
suffixes .lp.
Exemple:
status = CPXreadcopyprob (env, lp, nomLP, NULL); 8/27
Cplex minimise la fonction objectif par défaut, pour maximiser il faut appeler la
fonction CPXchgobjsen avec le paramètre CPX MAX :
CPXchgobjsen(env, lp, CPX MAX);
La résolution du problème se fait à l’aide d’une des fonctions d’optimisation
suivantes :
CPXlpopt (CPXCENVptr env, CPXLPptr lp) équivalente à optimize;
CPXprimopt(CPXCENVptr env, CPXLPptr lp) équivalente à primopt;
CPXdualopt(CPXCENVptr env, CPXLPptr lp) équivalente à tranopt;
CPXmipopt(CPXCENVptr env, CPXLPptr lp) équivalente à mipopt;
Par exemple la fonction CPXmipopt lance la résolution du PL en nombres
entiers et retourne un entier qui indique si l’optimisation c’est bien passée :
status = CPXmipopt (env, lp); /*résolution d’un PL mixte*/
if ( status )
printf (” echec lors de l’optimisation ”);
9/27
Il existe deux méthode pour récupérer la solution :

1) Première méthode
Nous pouvons récupérer la valeur des différentes variables ainsi que la valeur de la
fonction objectif selon le type du programme linéaire :
Les fonctions utilisées pour le programme linaire :

- Récupérer la valeur des variables:
double * x = (double*)malloc( nbVar * sizeof(double) ); /* valeur des
variables */
CPXgetx (CPXENVptr env, CPXLPptr lp, double *x, int debut, int fin);
Exemple: CPXgetx(env, lp, x, 0, nbVar-1);
10/27
Il existe deux méthode pour récupérer la solution :

1) Première méthode
Nous pouvons récupérer la valeur des différentes variables ainsi que la valeur de la
fonction objectif selon le type du programme linéaire :
Les fonctions utilisées pour le programme linaire :

variables */
CPXgetx (CPXENVptr env, CPXLPptr lp, double *x, int debut, int fin);
Exemple: CPXgetx(env, lp, x, 0, nbVar-1);
- Récupérer la valeur de la fonction objectif :
double objval; /* valeur de la fonction objectif */
CPXgetobjval (CPXENVptr env CPXLPptr lp, double *objval);
Exemple: CPXgetobjval(env, lp, & objval);
10/27
Les fonctions utilisées pour le programme linaire mixte :

variables */
CPXgetmipx (CPXENVptr env, CPXLPptr lp, double *x, int debut, int
fin);
Exemple: CPXgetmipx (env, lp, x, 0, nbVar-1);
11/27
Les fonctions utilisées pour le programme linaire mixte :

variables */
CPXgetmipx (CPXENVptr env, CPXLPptr lp, double *x, int debut, int
fin);
Exemple: CPXgetmipx (env, lp, x, 0, nbVar-1);
- Récupérer la valeur de la fonction objectif :
double objval; /* valeur de la fonction objectif */
int CPXgetmipobjval (CPXENVptr env CPXLPptr lp, double *objval);
Exemple: CPXgetmipobjval(env, lp, &objval);
11/27
2) Deuxième méthode
De manière générale (PL mixte ou fractionnaire) on peut utiliser CPXsolution
pour récupérer la solution.
int CPXsolution (CPXCENVptr env, CPXCLPptr lp, int *lpstatp, double

*objvalp, double *x, double *pi, double *slack, double *dj)
- *lpstatp : statut de l’optimisation

- *objvalp : valeur fonction objectif
- *x : valeur des variables (variables primales)
- *pi : valeur des variables duales pour chaque contrainte
- *slack :valeur des variables d’écart
- *dj : valeur de coûts réduits pour chaque variable
Exemple: status = CPXsolution (env, lp, &lpstat, &objval, x, pi, slack, dj);
Les paramètres pi , slack et dj sont facultatifs, on peut passer le pointeur NULL
si on ne souhaite pas récupérer les valeurs associées. 12/27
De manière analogue à l’écriture du problème dans un fichier, la fonction

CPXwritesol permet d’écrire la solution d’un problème dans un fichier :
int CPXwritesol (CPXCENVptr env, CPXCLPptr lp, const char * filenamestr,
const char * filetypestr)
filenamestr : nom du fichier
filetypestr : type du fichier (nulle si l’extension est donnée dans le nom du
fichier)
13/27
Il faut commencer par désallouer le problème avec la fonction CPXfreeprob puis

quitter l’environnement avec la fonction CPXcloseCPLEX :
if ( lp )
{
CPXfreeprob (env, &lp);
}
if ( env )
{
CPXcloseCPLEX (&env);
}
14/27
Construction du problème linéaire: Par fonctions
On peut appeler successivement les routines CPXnewcols(), CPXnewrows(),

CPXaddcols(), CPXaddrows() :
1 soit l’on définit le problème par ses variables (CPXnewcols()) puis on

remplit la matrice en décrivant totalement les contraintes (CPXaddrows()),
2 soit l’on définit le problème par ses contraintes (CPXnewrows()) puis on
remplit la matrice en décrivant totalement les variables (CPXaddcols()).
15/27
Construction du problème linéaire:Par fonctions
I- Dans ce qui suit, nous procédons à une représentation en matrice creuse

orientée colonne
a) Création des variables (ou colonnes)
On note nbVar le nombre de variables de notre problème, qui correspond aussi au
nombre de colonnes de la matrice des contraintes.
La création des colonnes se fait par de la fonction CPXnewcols :
int CPXnewcols (CPXENVptr env, CPXLPptr lp, int nbVar, double *coeff,
double *lb, double *ub, char *ctype, char **colname)
de paramètre :
nbVar : nombre de variables
coeff : tableau (vecteur) de dimension nbVar qui contient les coefficients
des variables dans la fonction objectif
16/27
lb : tableau (vecteur) de dimension nbVar qui contient la borne inférieure

des variables
ub : tableau (vecteur) de dimension nbVar qui contient la borne supérieure
des variables
ctype : type des variables (’B’ pour binaire, ’I’ pour entier, et ’C’ pour réel)
colname : tableau de char de dimension nbVar qui contient le nom des
variables.
17/27
Les vecteurs lb, ub et colname sont optionnels : si on passe NULL à la place de

ces vecteurs, Cplex accorde les valeurs par défaut.
b) Création des contraintes (remplissage de la matrice)
La création des contraintes est effectuée par la fonction CPXaddrows :
int CPXaddrows (CPXENVptr env, CPXLPptr lp, int ccnt, int nbRow, int
nbVarNonNul, double *rhs, char *sense, int *rmatbeg, int *rmatind, double
*rmatval, char **colname, char **rowname)
tel que:
ccnt: nombre de nouvelles variables (toujours 0 dans notre cas car on a déjà
toutes nos colonnes grâce à CPXnewcols)
nbRow : nombre de lignes ( nombre de contraintes)
nbVarNonNul : nombre de variables avec un coefficient non nul dans la

matrice des contraintes
18/27
rhs : tableau (vecteur) de dimension nbRow, rhs[i] contient le membre de

droite de la contrainte i
sense : tableau (vecteur) de dimension nbRow, sense[i] contient le sens de la

contrainte i : ’L’ pour <=, ’E’ pour = et ’G’ pour >=
rmatbeg : tableau (vecteur) de dimension nbRow, rmatbeg contient les

indices dans matval qui correspondent à des débuts de ligne
rmatind : tableau (vecteur) de dimension nbVarNonNul, rmatind [i]

contient le numéro de colonne de la variable dont le coefficient dans la
matrice des contraintes est donné par rmatval [i]
rmatval : tableau (vecteur) de dimension nbVarNonNul qui contient tous

les coefficients non nuls de la matrice des contraintes
colname : nom des nouvelles colonnes s’il y en a
rowname : un tableau de char qui contient le nom des contraintes

(optionnel) 19/27
Remarque
La matrice des contraintes est gérée comme une matrice creuse, i.e. matrice
contenant un grand nombre de 0. Afin de gagner de l’espace mémoire on ne stocke
pas les 0. En conséquence, les matrices sont représentées par trois vecteurs
- Le vecteur rmatval contient les coefficients non nuls (dans l’ordre :

coefficients de la première ligne de gauche à droite, puis de la seconde, etc...),
- Le vecteur rmatind contient les numéros de colonnes des coefficients non

nuls (dans le même ordre que précédemment),
- Le vecteur rmatbeg contient les indices dans rmatval des coefficients qui
sont les premiers de leur ligne.
20/27
Exemple d’application:
Nous allons construire le PL suivant :
Min 4x1 + 5x2 − 2x3

Sous
2x1 − 6x3 = 1
3x1 + 2x2 − x3 = 5
x1 , x 2 , x 3 ∈ N
La matrice des contraintes associée est :

2 0 −6
A=
3 2 −1
Dans cet exemple, le nombre de variable nbVar = 3.

21/27
1- Création des variables

double * coeff = (double *)malloc(nbVar*sizeof(double)); /*coeff des
variables dans la fonction objectif*/
char * ctype = (char*)malloc(nbVar *sizeof(char)); /* type des
variables */
double * lb = (double*)malloc(nbVar *sizeof(double)); /* borne
inférieure */
Remarque : Les lignes et colonnes commencent à l’indice 0.
/* chaque variable a un coefficient dans la fonction objectif */
coeff = [4 5 -2]
for (i = 0; i ¡ nbVar; ++i)
{
ctype[i] = ’I’; /* chaque variable est entière */
lb[i] = 0; /* chaque variable a une borne inf = 0 */
}
status = CPXnewcols (env, lp, nbVar, coeff, lb, NULL, ctype, NULL);
if (status)
printf(”echec lors de la création des variables”); 22/27
2- Création des contraintes

double * rhs = (double*) malloc( NBROW * sizeof(double) );
char * sens = (char*) malloc( NBROW * sizeof(char) );
double * rmatval = (double*) malloc( NBNONNUL * sizeof(double) );
int * rmatbeg = (int*) malloc( NBROW * sizeof(int) );
int * rmatind = (int*) malloc( NBNONNUL * sizeof(int) );
rmatval = [2 -6 3 2 -1] ; /* les valeurs non nulles */
rmatind = [0 2 0 1 2] ; /* les numéros de colonnes correspondant aux valeurs non
nulles*/
rmatbeg = [0 2] ; /* les indices correspondant à des débuts de lignes dans rmatval
*/
status = CPXaddrows (env, lp, 0, NBROW, NBNONNUL, rhs, sens, rmatbeg,
rmatind, rmatval, NULL, NULL);
23/27
2- Dans cette partie, nous procédons à une représentation en matrice creuse

orientée ligne
On définit le problème par ses contraintes (CPXnewrows()) puis on remplit la
matrice en décrivant totalement les variables (CPXaddcols()).
a) Création des contraintes (ou lignes)
La création des contraintes est effectuée par la fonction CPXnewrows :
int CPXPUBLIC CPXnewrows (CPXCENVptr env, CPXLPptr lp, int
nb, const double *rhs, const char *sense, const double *rngval, char
**rowname );
nb: nombre de contraintes
rhs: vecteur (de dimension nb) des membres droits
sense: vecteur (de dimension nb) des sens des contraintes
rngval: NULL
rowname: Un tableau de longueur égale à nb, contenant les noms des
nouvelles lignes (contraintes). Si les lignes reçoivent des noms par défaut,
rowname =NULL.
Exemple:
status = CPXnewrows (env, lp, nb, rhs, sense, NULL, NULL); 24/27
b) Création des variables (remplissage de la matrice)

La création des colonnes se fait par de la fonction CPXnewcols :
int CPXaddcols( CPXCENVptr env, CPXLPptr lp, int ccnt, int nzcnt,
const double *obj const int *cmatbeg, const int *cmatind, const double
*cmatval, const double *lb, const double *ub, char **colname );
ccnt: nombre de colonnes ajoutées
nzcnt: nombre de coefficients non nuls à insérer dans la matrice
obj: Un tableau de longueur égale à ccnt, contenant les coefficients de
fonction objectif des nouvelles variables. Il peut être NULL, auquel cas les
coefficients d’objectif des nouvelles colonnes sont mis à 0.
cmatval: un tableau (vecteur) de dimension nzcnt contient les éléments non
nuls de la matrice des contraintes,
25/27
cmatind: tableau (vecteur) de dimension nzcnt, cmatind[i] contient le numéro de ligne

de la variable dont le coefficient dans la matrice des contraintes est donné par cmatval[i].
cmatbeg: tableau (vecteur) de dimension ccnt contient les indices dans cmatval qui
correspondent à des débuts de colonne.
lb: Un tableau de longueur égale à ccnt, contenant la borne inférieure de chaque
nouvelle variable. Toute borne inférieure fixée à une valeur inférieure ou égale à celle de
la constante -CPXINFBOUND est traitée comme moins l’infini. Si les bornes inférieures
des nouvelles colonnes sont définies à 0, lb= NULL.
ub: Un tableau de longueur égale à ccnt, contenant la borne supérieure de chaque
nouvelle variable. Toute borne supérieure fixée à une valeur supérieure ou égale à celle
de la constante CPXINFBOUND est traitée comme plus l’infini. Si les bornes
supérieures des nouvelles colonnes sont définies à CPXINFBOUND (plus l’infini),
ub=NULL.
colname: Un tableau de longueur égale à ccnt, contenant des pointeurs vers des chaı̂nes
de caractères spécifiant les noms des nouvelles variables ajoutées à l’objet problème
CPLEX. Si les colonnes reçoivent des noms par défaut, colname =NULL.
Exemple: status = CPXaddcols (env, lp, ccnt, nzcnt, obj, cmatbeg, cmatind, cmatval, lb, ub,
NULL);
26/27
Exemple d’application:
Nous allons construire le PL suivant :
Min 4x1 + 5x2 − 2x3

Sous
2x1 − 6x3 = 1
3x1 + 2x2 − x3 = 5
x1 , x 2 , x 3 ∈ N
La matrice des contraintes associée est :

2 0 −6
A=
3 2 −1
Dans cet exemple, le nombre de colonne ccnt = 3 et le nombre de coefficients non

nuls nzcnt=5
cmatval=[2 3 2 -6 -1]
cmatind=[0 1 1 0 1]
cmatbeg=[0 2 3] 27/27

Cplex Callable Library

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Cplex Callable Library

Transféré par

Droits d'auteur :

Formats disponibles

Déclaration et Initialisation de l’environnement Cplex

Université des Sciences et de la Technologie Houari Boumediene

Solveur Cplex pour l’optimisation:

Les structures de données utilisées pour générer le fichier pourraient très

Cplex inclut une bibliothèque, développée en plusieurs langages (C :

Déclaration et Initialisation de l’environnement Cplex

Ensuite, il faut initialiser l’environnement Cplex par l’utilisation d’une variable

Déclaration et initialisation du problème linéaire

Construction du problème linéaire: Par lecture de fichier

Il est possible de définir un problème de plusieurs manières : par structures

Résolution d’un problème

Il existe deux méthode pour récupérer la solution :

Les fonctions utilisées pour le programme linaire :

Il existe deux méthode pour récupérer la solution :

Les fonctions utilisées pour le programme linaire :

Les fonctions utilisées pour le programme linaire mixte :

Les fonctions utilisées pour le programme linaire mixte :

int CPXsolution (CPXCENVptr env, CPXCLPptr lp, int *lpstatp, double

- *lpstatp : statut de l’optimisation

Sauvegarde des informations

De manière analogue à l’écriture du problème dans un fichier, la fonction

Il faut commencer par désallouer le problème avec la fonction CPXfreeprob puis

Construction du problème linéaire: Par fonctions

On peut appeler successivement les routines CPXnewcols(), CPXnewrows(),

1 soit l’on définit le problème par ses variables (CPXnewcols()) puis on

Construction du problème linéaire:Par fonctions

I- Dans ce qui suit, nous procédons à une représentation en matrice creuse

Construction du problème linéaire:Par fonctions

lb : tableau (vecteur) de dimension nbVar qui contient la borne inférieure

Construction du problème linéaire:Par fonctions

Les vecteurs lb, ub et colname sont optionnels : si on passe NULL à la place de

nbRow : nombre de lignes ( nombre de contraintes)

nbVarNonNul : nombre de variables avec un coefficient non nul dans la

Construction du problème linéaire:Par fonctions

rhs : tableau (vecteur) de dimension nbRow, rhs[i] contient le membre de

sense : tableau (vecteur) de dimension nbRow, sense[i] contient le sens de la

rmatbeg : tableau (vecteur) de dimension nbRow, rmatbeg contient les

rmatind : tableau (vecteur) de dimension nbVarNonNul, rmatind [i]

rmatval : tableau (vecteur) de dimension nbVarNonNul qui contient tous

colname : nom des nouvelles colonnes s’il y en a

rowname : un tableau de char qui contient le nom des contraintes

Construction du problème linéaire:Par fonctions

- Le vecteur rmatval contient les coefficients non nuls (dans l’ordre :

- Le vecteur rmatind contient les numéros de colonnes des coefficients non

Construction du problème linéaire:Par fonctions

Min 4x1 + 5x2 − 2x3

La matrice des contraintes associée est :

Dans cet exemple, le nombre de variable nbVar = 3.

Construction du problème linéaire:Par fonctions

1- Création des variables

Construction du problème linéaire:Par fonctions

2- Création des contraintes

Construction du problème linéaire:Par fonctions

2- Dans cette partie, nous procédons à une représentation en matrice creuse

Construction du problème linéaire:Par fonctions

b) Création des variables (remplissage de la matrice)

Construction du problème linéaire:Par fonctions

cmatind: tableau (vecteur) de dimension nzcnt, cmatind[i] contient le numéro de ligne

Construction du problème linéaire:Par fonctions

Min 4x1 + 5x2 − 2x3

La matrice des contraintes associée est :

Dans cet exemple, le nombre de colonne ccnt = 3 et le nombre de coefficients non

Vous aimerez peut-être aussi