couco

GAMS
(General A
Algebraic
braic Modeling System)

M. Hervé GUENE
Ingénieur Statisticien-Economiste
conomiste
hguene@[Link]

Juin 2009
Support de Cours GAMS 2009

AVANT – PROPOS
Voici une compilation d’astuces qui permettent de balayer un peu les fonctionnalités de GAMS avec en
marge le langage de programmation de ce logiciel. Ce support, qui est le premier tom d’une trilogie
comprenant trois volumes a pour but de familiariser les utilisateurs à l’environnement du logiciel et à
appliquer tout ce qui est programmation statique sous GAMS. C’est le tom 1 de trois supports techniques
destinés à enseigner aux cadres de la prévision et des analyses macroéconomiques, la modélisation en
Equilibre général calculable.

Ici on adopte une approche thématique qui dit qu’avec GAMS on peut faire ceci, on peut faire cela.
L’accent n’a pas été fortement mis sur les MEGC ou les programmes d’optimisation en finance ou
scientifique, mais plutôt sur les paramètres de programmation. Et ce car très souvent, le modélisateur a
déjà son modèle théorique (variables, équations, paramètres, fonctions, types de bouclage…) et ce qu’il
lui reste c’est de trouver un environnement numérique qui lui permettra d’implémenter son travail et
quantifier les impacts de scénarios, …

On veut juste expliquer que GAMS est un outil très puissant qui permet de résoudre beaucoup de
problèmes que nous rencontrons dans notre quotidien professionnel et/ou didactique. Ce document est
accompagné d’un support sur les modélisations dynamique et stochastique en GAMS, et d’un support
consacré' à la modélisation en Equilibre Général Calculable et de plusieurs codes GAMS qui permettent
d’appliquer concrètement ce dont il s’agit quand ces codes ne sont pas directement insérés dans le support.

Il balaie graduellement les résolutions de problèmes en allant des plus simples aux plus complexes. La
dynamique n’a pas été profondément exposée ici, un autre document s’y consacre exclusivement.

Loin de toute prétention, nous voulons indiquer au lecteur où se trouve telle commande de GAMS qui
permet de faire ceci ou cela. Consulter les codes sources accompagnants nous permettrons d’accroitre le
niveau d’apprentissage. Il existe bien sûr une bibliographie très variée avec en marge une petite barrière
linguistique car tous les documents ci référencés sont d’obédience scientifique certes, mais rédigés en
anglais, et c’est ce qui fait l’originalité du présent support.

C’est le lieu pour nous de remercier tous les cadres statisticiens de l’Institut National de la Statistique et de
la Démographie du Burkina-Faso qui ont bien voulu lire et apporter des remarques sur le contenu de ce
travail qui, nous l’espérons connaitra des améliorations significatives dans le futur.

Page 2 sur 86 M. Hervé GUENE, Ingénieur Statisticien-Economiste; E-mail: hguene@[Link]

 Support de Cours GAMS 2009

TOME I : introduction à l’environnement du logiciel et prémisses

Objectifs

o Connaître les règles générales d'utilisation du logiciel GAMS (approche thématique)

o Pour un autodidacte, contrôler et mettre à niveau ses connaissances sur l'usage
o Se familiariser avec l’environnement du logiciel
o Maitriser le menu de GAMS, les fenêtres et le principe de fonctionnement
o Savoir résoudre les problèmes de programmation linéaire
o Savoir résoudre des problèmes économiques simples, exécuter des modèles élémentaires
o Savoir effectuer des simulations
o Savoir utiliser les commandes loop, gdx et les différents types de gdx (viewer, diff, merge,…)
o Savoir faire des graphiques sous GAMS
o Savoir interfacer GAMS avec les autres logiciels

Compléments nécessaires

 Des fichiers d'exemple (voir le cours ou le consultant,)

 Un vidéoprojecteur
 Une machine pour chaque impétrant

Niveau de compétences en pré-requis

Connaissance de l'environnement Windows et/ou du FORTRAN ou PASCAL

Novice en optimisation ou usager sans formation spécifique

Page 3 sur 86 M. Hervé GUENE, Ingénieur Statisticien-Economiste; E-mail: hguene@[Link]

Support de Cours GAMS 2009

PRESENTATION DU LOGICIEL .................................................................................................................................. 6

I-1 STRUCTURE.................................................................................................................................................... 6
L’installation, l’utilisation des licences et les dossiers systèmes ....................................................................... 6
Le design de GAMS.......................................................................................................................................... 7
Les fenêtres et la logique de fonctionnement............................................................................................ 10
Les notations générales de programmation GAMS ........................................................................................ 11
Les mots réservés...................................................................................................................................... 11
Insertion de commentaires dans un code GAMS........................................................................................ 12
I-2 Utilité........................................................................................................................................................... 12
a- Résolution de systèmes d’équations simples ......................................................................................... 12
Résolution de problèmes d’optimisation (programmation linéaire) ............................................................... 14
Un problème contraint de maximisation ................................................................................................... 15
Un problème contraint de minimisation .................................................................................................... 16
Les fonctions dans GAMS .............................................................................................................................. 16
PROGRAMMATION CONIQUE ............................................................................................................................... 22
II-1 Introduction................................................................................................................................................ 22
II-2 Implémentation des Contraintes Coniques dans GAMS ............................................................................... 23
Exemple de programmation conique......................................................................................................... 23
II-3 Modélisations faisant appel à des Programmes Convexes ........................................................................... 25
Deux Exemples De Programmation Quadratique ....................................................................................... 26
PROGRAMMES D’OPTIMISATION FINANCIERE ET D’EQUILIBRE GENERAL CALCULABLE ......................................... 29
III-1 Les éléments de la modélisation ................................................................................................................ 29
III-2 Mais comment déclarer les éléments? ....................................................................................................... 30
SET............................................................................................................................................................ 30
VARIABLE .................................................................................................................................................. 32
SCALAR...................................................................................................................................................... 34
PARAMETER .............................................................................................................................................. 34
TABLE........................................................................................................................................................ 34
EQUATIONS............................................................................................................................................... 35
 declaration ........................................................................................................................................ 35
 definition........................................................................................................................................... 35
MODEL...................................................................................................................................................... 36
SOLVE ....................................................................................................................................................... 36
III-3 Ossature du modèle Standard IFPRI D’EGC dans GAMS .............................................................................. 38
Page 4 sur 86 M. Hervé GUENE, Ingénieur Statisticien-Economiste; E-mail: hguene@[Link]
Support de Cours GAMS 2009

III-4 QUELQUES INSTRUCTIONS FREQUENTES.................................................................................................... 42

a- L’instruction LOOP................................................................................................................................. 42
b- L’instruction PUT ................................................................................................................................... 44
III-5 Introduction de la dynamique dans un code GAMS .................................................................................... 47
QUELQUES EQUATIONS EN LANGAGE GAMS ........................................................................................................ 50
IV-2 LES MENAGES ............................................................................................................................................ 50
IV-2 LES PRODUCTEURS .................................................................................................................................... 52
IV-3 COMMERCE ............................................................................................................................................... 53
IV-4 INVESTISSEMENT ....................................................................................................................................... 54
IV-4 OFFRE DE TRAVAIL..................................................................................................................................... 55
IV-6 TAXATION.................................................................................................................................................. 55
IV-7 ETAT .......................................................................................................................................................... 56
V- INTERFAÇAGE DE GAMS AVEC LES AUTRES LOGICIELS : LA COMMANDE GDX ET LES FICHIERS GDX .................. 57
V-1 Le GDX et les divers GDX............................................................................................................................. 57
a- Créer un fichier gdx ............................................................................................................................... 57
b- Exporter en format des autres logiciels.................................................................................................. 58
V-2 Importer des données dans GAMS depuis les autres logiciels...................................................................... 60
a- Conversion de données Excel en GAMS ..................................................................................................... 60
- Utiliser l’exécutable [Link] ............................................................................................................... 60
- Importer seulement certaines colonnes d’une feuille de calcul Excel dans GAMS ...................................... 61
b- De Matlab à GAMS .................................................................................................................................... 63
VI- QUELQUES ASTUCES DE PROGRAMMATION GAMS ......................................................................................... 64
VI-1 Les Macros................................................................................................................................................. 64
VI-2 ASTUCES DIVERSES .................................................................................................................................... 68
VI-3 Le GAMS Tips and Tricks de Rob Dellink ..................................................................................................... 75

Page 5 sur 86 M. Hervé GUENE, Ingénieur Statisticien-Economiste; E-mail: hguene@[Link]

Support de Cours GAMS 2009

PRESENTATION DU LOGICIEL

I-1 STRUCTURE

L’installation,
ion, l’utilisation des licences et les dossiers systèmes

GAMS est l’acronyme de General Algebraic Modeling System en anglais,

anglais, un logiciel conçu par un groupe
1
d’économistes de la Banque
anque Mondiale pour faciliter la résolution de modèles économiques complexes et
l’évaluation en temps réel de politiques diverses. Une version démo de GAMS est disponible sur le site du
constructeur ([Link]). Cettee version est régulièrement mise à jour et est gratuitement
téléchargeable sur le site précédemment référencé. Chaque numéro de version diffère des autres et
présente des améliorationss comme on peut le voir sur le haut de la page
[Link]\download\[Link]
[Link];cette page est obtenue par un simple clic sur l’onglet download de
la page d’accueil de GAMS:

Sur le haut de cette page, on peut donc lire la version démo à jour et gratuitement téléchargeable de
GAMS du moment. Ici, référence est faite à la version 22.9, disponible depuisuis le 1er décembre 2008, avec
juste en dessous des offres de téléchargement compatibles aux systèmes d’exploitation dont dispose le
futur utilisateur. Sur le bas de cette page on peut constater le petit cadran ci-dessous :

1
Réunis dans le GAMS development corporation
Page 6 sur 86 M. Hervé GUENE, Ingénieur Statisticien
Statisticien-Economiste; E-mail: hguene@[Link]
Support de Cours GAMS 2009

Il nous présente
nte les caractéristiques de la dernière version démo de GAMS. En l’occurrence, la présente
version peut accepter compiler un modèle
m contenant jusqu’à:
300 contraintes et variables
2000 éléments (paramètres
paramètres, scalaires, vecteurs…) non nuls
50 variables discrètes (y compris les variables
v semi-continues,
continues, les variables binaires et les variables
définies sur des ensembles) ;

Le solveur global quant à lui ne peut excéder une contrainte de 10 variables et contraintes. Les versions
antérieures de la démo offrent des possibilités inferieures à la version récente.
récente Tout utilisateur disposant
d’une version démo et qui modélise au-delà delà d’une des contraintes sus exposées, verra s’afficher à la
compilation de son modèle,, le message suivant: « License error ».
La version complète de GAMS offre quant à elle des capacitésités incomparablement supplémentaires à celles
de la version démo (de l’ordre de 10000 itérations pour une compilation). Et pour obtenir une version
complète, il faut télécharger la version démo puis s’acheter une License à utiliser avec la démo.

Après avoir téléchargé le logiciel, GAMS peut être installé dans n’importe quel répertoire de votre choix.
Il suffit tout simplement de double cliquer sur l’icône du fichier téléchargé et suivre les instructions
d’installation jusqu’à obtenir lee message suivant : « do You have a License file? », si vous avez une
License2, alors copiez la dans le répertoire d’installation de GAMS qui est par défaut C:\Program
Files\GAMS23.0,, puis indiquez le chemin d’accès à cette License dans
ans la boite de dialogue qui se présente
à vous. Au cas où vous ne disposez pas de License, cliquer sur « no » et sur « continue unregistred ».

Mais, au cours de l’installation, GAMS crée automatiquement plusieurs dossiers dont le dossier
« gamsdir » dans « mes documents ». Ce dossier enregistre par défaut tous les programmes et codes
GAMS qui seront exécutés.

Le design de GAMS

- Les différents menus et barres

GAMS présente une fenêtre majeure pour tout travail. Elle est nommée gamside (gams Integrated
Development
velopment environment, pour dire l’environnement de développement Intégré de GAMS). Elle contient
2
Une License GAMS est un fichier texte (format Txt) léger dont la taille n’excède généralement pas 10 ko
Page 7 sur 86 M. Hervé GUENE, Ingénieur Statisticien
Statisticien-Economiste; E-mail: hguene@[Link]
Support de Cours GAMS 2009

une seule barre contenant 7 menus : File, Edit, Search, Windows, Utilities, Model libraries, et Help ; en
français : Fichier, Edition, Recherche, Utilitaires, Bibliothèque de modèles et Aide.

La bibliothèque de modèles est en fait un dossier contenant une gamme variée de modèles compilés par
les concepteurs et contributeurs de GAMS et qui pourraient éventuellement servir de guide à l’utilisateur.
Cette gamme de modèles couvre tous les champs d’application des sciences décisionnelles (de la finance à
la recherche mathématique pure, aux modèles microéconomiques, les problèmes de suivi de réactions
nucléaire en chimie, en physique en électronique,…).

La fenêtre GAMS se présente comme suit :

Une seule barre de menus comprend

Le File : Le new pour créer une nouvelle page vierge de

programmation d’un nouveau programme

Open permet d’ouvrir un fichier GAMS3 déjà existant.

Un clic sur cette option ouvre une fenêtre demandant le
répertoire où se trouve le fichier que l’on souhaite ouvrir. Il
suffit de l’atteindre pour ouvrir le fichier voulu.

La clé de model library permet d’accéder à la bibliothèque

de fichiers, et programmes fournis par GAMS pour
servir de guide d’exemples aux utilisateurs lorsqu’on clic sur
open GAMS Model library. Un clic sur open GAMS
Model library permet d’accéder aux modèles et fichiers
que l’utilisateur a écrit et enregistré dans la bibliothèque.

3
Ça peut être un code gms, gdx, opt, txt, gch, pas ou autre
Page 8 sur 86 M. Hervé GUENE, Ingénieur Statisticien-Economiste; E-mail: hguene@[Link]
Support de Cours GAMS 2009

Les commandes new et open sont

identiques à celles de Word.

Project permet d’accéder aux projets déjà existants (en cliquant sur open Project), de créer de nouveaux
projets (en cliquant sur new Project) et aussi d’accéder aux projets récemment ouverts.

Qu’est ce qu’un projet GAMS ?

Un projet GAMS peut être défini comme un programme ou un ensemble de programmes écrits en langage
GAMS pour réaliser un objectif bien précis. L’onglet project permet donc de mieux organiser les projets
dans le dossier gamsdir/projdir.

La proposition la plus importante est option du point de vue de la configuration. Un clic sur cette offre
présente la fenêtre suivante :

Page 9 sur 86 M. Hervé GUENE, Ingénieur Statisticien-Economiste; E-mail: hguene@[Link]

Support de Cours GAMS 2009

COMMENTAIRES A FAIRE ORALEMENT

Les fenêtres et la logique de fonctionnement

Il est important de préciser au passage que GAMS n’est pas un logiciel économétrique. Il ne faudrait donc en
attendre des modélisations de séries temporelles ou des modélisations économétriques semblables au
fonctionnement des logiciels comme E-views, STATA... En revanche il utilise les résultats d’estimations
économétriques pour des travaux qui s’inscrivent dans un cadre plus large incluant à la fois modélisation
économétrique, cohérence comptable et combinaison de pouvoirs explicatif et prédictif.

Page 10 sur 86 M. Hervé GUENE, Ingénieur Statisticien-Economiste; E-mail: hguene@[Link]

Support de Cours GAMS 2009

Main window /input window (Ecrire un code .gms : les différentes extensions)
Active process windows
Log windows
Output window (fichier lst, gdx: lecture des résultats)

Comment lire les résultats ? Comment interpréter ? Détails sur les fenêtres de lecture des résultats (à faire
oralement).

Lorsqu’on exécute un modèle (à partir du [Link]), ‘la fenêtre no active process ‘ apparait. En double-
cliquant sur n’importe quelle ligne cela renvoie au résultat du programme (i-e le fichier .lst). Les lignes
rouges indiquent les erreurs, et un double clique sur une ligne rouge nous renvoie à l’endroit du code où se
trouve le code. Les lignes deviennent lorsqu’il n’ya pas d’erreur de compilation. Par contre il peut
persister des erreurs d’exécution. Lorsqu’on exécute un programme (en tapant la touche f9 du clavier ou
en cliquant sur le bouton run (matérialisé par une flèche horizontale rouge dans le gamside), le logiciel
compile d’abord le programme pour voir s’il n’ya pas d’erreur ni dans la syntaxe, ni dans l’écriture du
code. Ensuite il exécute le programme, c'est-à-dire il effectue les calculs et commandes exigées dans le
programme. Donc c’est à cette étape qu’il calcule les valeurs des variables, des paramètres, qu’il appelle
tel ou tel fichier en input ou en output,… si bien qu’à l’exécution on peut avoir des erreurs de ‘division par
zéro’ pour dire que GAMS en effectuant les calculs s’est rendu compte qu’il doit diviser une valeur par
zéro, ce qui n’est pas permis. Cette erreur sera donc marquée en bleu plutôt qu’en rouge. Un autre type
d’erreur de compilation est celui de licence non adaptée. Il arrive souvent que les calculs l’on demande à
GAMS sont si nombreux et exigent un nombre si important d’itérations que la License est incapable
d’exécuter. Ces erreurs d’exécution ne sont pas marquées au rouge.

Les notations générales de programmation GAMS

Les mots réservés

Abort Acronym Alias All And Assign Binary Card Display
Eps Eq Equation Equations Ge Gt Inf Integer Le
Loop Lt Maximising Minimising Model Models Na Ne Negative
Not Options Or Ord parameter Parameters Positive Prod Scalar
Scalars Set Sets Smax Smin Sos1 Sos2 Sum System
Table Using until While If Then Else Yes Repeat
Variable Variables Semicont Semiint File Files Putpage Puttl Put
Loop Free No Option Solve for Sameas Execute Unload

Page 11 sur 86 M. Hervé GUENE, Ingénieur Statisticien-Economiste; E-mail: hguene@[Link]

Support de Cours GAMS 2009

Les caractères
De a à z Alphabet De A à Z Alphabet De 0 à 9 numérique & ampersand ’’ guillemets
# Signe du pound * Multiplier = Egal ? Pt interro @ A
> Supérieur ou égal < Inférieur à ‘ Apostrophe : Deux points - moins
/ Slash , Virgule ( ) Parenthèse Espace $ Dollar
[ ] Crochet _ Underscore . Point {} Accolades ! exclamation
+ Plus % Pourcent ^ exposant

Les symboles
Operateur Exemple Signification mathématique
** x**y (x>0) ࢞࢟
* x*y ࢞x ࢟
࢞
/ x/y
࢟
+ x+y ࢞+ ࢟
- x-y ࢞− ࢟

Insertion de commentaires dans un code GAMS

Il ya deux grandes méthodes d’insertion de commentaires :

- Une ligne qui commence par le symbole * sera traitée comme un commentaire; exemple:

* le présent modèle est construit sur une dynamique récursive

- Une portion de texte ou une section/paragraphe de code comprise entre les commandes $ontext et $offtext
sera considérée comme commentaire et non come un programme de calcul ; exemple :

$ontext

Après avoir importé les données, il faut maintenant calibrer le modèle. Celles provenant de la douane seront
considérées ad valorem, tandis que celles provenant des enquêtes ménage sera normalisées çà l’indice des prix à la
consommation. C’est pourquoi vous verrez l’équation normal apparaitre dans la suite.

$offtext

I-2 Utilité
On ne peut dresser de manière exhaustive tous les types de travaux qui pourraient être effectués avec
GAMS; on peut dire qu’il résous tout ce qui est programme numérique d’optimisation depuis le control
optimal au calcul des variations, les problèmes quadratiques les problèmes coniques, les programmes
d’optimisation linéaire… bref divers types de problème qui couvrent pratiquement tous les champs des
sciences contemporaines (changement climatiques, chimie, sciences environnementales, économie,
mathématiques…). C’est un logiciel qui évolue par contributions de ses utilisateurs.

a- Résolution de systèmes d’équations simples

Résolution d’un système simple de trois équations à trois inconnues

Page 12 sur 86 M. Hervé GUENE, Ingénieur Statisticien-Economiste; E-mail: hguene@[Link]

Support de Cours GAMS 2009

Soit à résoudre dans ℝ le système suivant :

3‫ ݔ‬+ 2‫ ݕ‬+ ‫ = ݖ‬15

2‫ ݔ‬+ ‫ ݕ‬− ‫ = ݖ‬4

‫ ݔ‬− 6‫ ݕ‬+ 20‫ = ݖ‬0

Modèle mathématique Expression sous GAMS Symboles mathématiques

* multiplication

3‫ ݔ‬+ 2‫ ݕ‬+ ‫ = ݖ‬15 3 ∗ ‫ ݔ‬+ 2 ∗ ‫ ݕ‬+ ‫ = ݁ = ݖ‬15 -, / et + représentent respectivement les signes
de la soustraction, la division et l’addition
2‫ ݔ‬+ ‫ ݕ‬− ‫ = ݖ‬4 2 ∗ ‫ݔ‬+ ‫ݕ‬− ‫ =݁ =ݖ‬4
** est utilisé pour exprimer l’élévation à une
‫ ݔ‬− 6‫ ݕ‬+ 20‫ = ݖ‬0 ‫ ݔ‬− 6 ∗ ‫ ݕ‬+ 20 ∗ ‫ = ݁ = ݖ‬0 puissance réelle ; par exemple ‫ݔ‬ଶ s’écrit x**2

Le code GAMS complet pour résoudre ce système solutions

variable

x, y, z; Déclaration des variables

equation

eq1 première équation

eq2 deuxième équation LOWER LEVEL UPPER MARGINAL

eq3 troisième équation; Déclaration des équations

---- VAR x -INF -0.491 +INF .

---- VAR y -INF 7.151 +INF .

eq1.. 3*x+2*y+z=e=15;
---- VAR z -INF 2.170 +INF .
eq2.. 2*x+y-z=e=4 ;

Ecriture d’équations
eq3.. x-6*y+20*z=e=0 ;

model salade /all/;

solve salade using mcp;

Nomination du modèle

Résolution du modèle avec mcp

Page 13 sur 86 M. Hervé GUENE, Ingénieur Statisticien-Economiste; E-mail: hguene@[Link]

Support de Cours GAMS 2009

Généralisation à la résolution d’un système simple de n équations et n inconnues

Soit le système généralisé d’équations suivant :

x1, x2,…... xn sont des réels

a11x1 +a12x2+………+a1n xn = b1
a21x1 +a22x2+………+a2n xn = b2
……………………………………
an1x1 +an2x2+………+ann xn = bn

Où x1, x2, …, xn sont des inconnues que l’on appellera désormais variables d’état. Ici, l’on cherche pour bi
(i=1,…, n) les valeurs des Xi (i=1,n) qui vérifient les conditions imposées par les équations ci-dessus.
Voici la méthode générale de résolution des systèmes de ce genre sous GAMS :

variables Déclaration des variables Symbole Traduction sous

x1, x2,…... xn ; mathematique GAMS
equation Déclaration des équations ≥ =g= ou ge,
cont1 ≤ =l= ou le,
= =e= ou eq,
cont2 Expression des équations lt,
. <
> gt
. Ecriture des équations en code
Contn ; GAMS
≠ et enfin
Cont1.. a11*x1 +a12*x2+………+a1n* xn =e= b1 ne
Cont2.. a21*x1 +a22*x2+………+a2n *xn =e= b2
……………………………………
Contn.. an1*x1 +an2*x2+………+ann *xn =e= bn ;
model nomdemonmodel /all/ Nomination du modèle
Résolution du modèle avec
solve nomdemonmodele using mcp choix du type

De même, GAMS peut résoudre tout ce qui est système d’équations ou d’inéquations simple, pourvu que
le système soit carré (i-e x équations/inéquations pour x inconnues) et que l’on utilise les notations
spécifiées dans les deux dernières colonnes de droite. Mais pour ce qui est des inéquations GAMS ne peut
pas sortir de résultat sous forme d’ensembles. Alors il ne peut que maximiser ou minimiser une fonction
objectif avec des contraintes d’égalité ou d’inégalité comme suit.

Résolution de problèmes d’optimisation (programmation linéaire)

Page 14 sur 86 M. Hervé GUENE, Ingénieur Statisticien-Economiste; E-mail: hguene@[Link]

Support de Cours GAMS 2009

Un problème de maximisation sous contrainte

Exemple 1

Programme de production d’une unité de savonnerie

Une PME fabrique sur une machine donnée, travaillant 45 heures par semaine, trois produits différents P 1, P2
et P3. L’article P1 laisse un profit net de 4 F, P2 12 F et P3 3 F. Les rendements de la machine sont,
respectivement pour les trois produits 50, 25, et 75 articles par heure. On sait d’autre part que les
possibilités de vente sur le marché ne dépassent pas 1000 objets P1, 500 objets P2 et 1500 objets P3 par
semaine.
Comment répartir la capacité de production de la machine entre les trois produits, de manière à maximiser le
profit ?
L’écriture mathématique de ce problème est la suivante :
Maximiser
z = 4 x1 +12 x2+3 x3
sous x1  0 ; x2  0 ; x3  0 Ici x1, x2 et x3 représentent respectivement
x1  1000 le nombre d’objets P1, P2 et P3 à produire de
x2  500 sorte à maximiser le profit global Z de la PME.
x3  1500
3 x1 +6 x2+2 x3  6750

Le code GAMS Les résultats

Page 15 sur 86 M. Hervé GUENE, Ingénieur Statisticien-Economiste; E-mail: hguene@[Link]

Support de Cours GAMS 2009

Un problème de minimisation sous contrainte

Exemple 2
Ceci est un exemple fictif créé à partir du programme de gestion de savonnerie ci-dessus.
Minimiser
z = 4 x1 +2 x2+3 x3
sous
x1  1000
x2 = 500
x3  1500
3 x1 +6 x2+2 x3  6750

Les fonctions dans GAMS

Il existe une panoplie de fonctions programmées sous GAMS et pouvant être directement appelées dans
nos différents codes. Le tableau suivant n’est qu’une présentation non exhaustive de ces dites fonctions.

Fonction Description Statut

Abs(x) Valeur absolue de x où x est un nombre réel disponible

ArcCos (x) Arc cosinus de l’argument x où x doit être en radians nécessite des solveurs pouvant gérer des
fonctions non linéaires
ArcSin (x) Arc sinus de l’argument x où x doit être en radians nécessite des solveurs pouvant gérer des
fonctions non linéaires
ArcTan (x) Arc tangente de l’argument x où x doit être en radians nécessite des solveurs pouvant gérer des

Page 16 sur 86 M. Hervé GUENE, Ingénieur Statisticien-Economiste; E-mail: hguene@[Link]

Support de Cours GAMS 2009

fonctions non linéaires

Beta(a,b) fonction Beta nécessite des solveurs pouvant gérer des
fonctions non linéaires dynamiques ou
des fonctions discontinues
Betareg(x,a,b) fonction Beta régularisée nécessite des solveurs pouvant gérer des
fonctions non linéaires dynamiques ou
des fonctions discontinues
Binomial[x,y] fonction binomiale généralisée de paramètres x et y nécessite des solveurs pouvant gérer des
fonctions non linéaires mais c’est une
version de binomiale continue
Ceil (x) Le plus petit nombre entier supérieur ou égal à x (i-e ≥x) disponible
Cos (x) cosinus de l’argument x où x doit être en radians nécessite des solveurs pouvant gérer des
fonctions non linéaires ou des fonctions
discontinues
Cosh (x) cosinus hyperbolique de l’argument x où x doit être en nécessite des solveurs pouvant gérer des
radians fonctions non linéaires dynamiques ou
des fonctions discontinues
Edist (x,y,z,…) Somme des carrés des arguments= ‫ݔ‬ଶ + ‫ݕ‬ଶ + ‫ݖ‬ଶ + ⋯ nécessite des solveurs pouvant gérer des
fonctions non linéaires dynamiques
Entropy(x) Entropie de x = -x log(x) nécessite des solveurs pouvant gérer des
fonctions non linéaires dynamiques
Errorf(x) Intégrale de la loi normale centrée réduite sur −∞ à x, i-e la nécessite des solveurs pouvant gérer des
௫
valeur de ∫ିஶ ࣨ (0; 1) fonctions non linéaires dynamiques

Exp (x) Exponentielle de x où x est un nombre réel disponible

Fact(x) Factoriel de x où est un entier naturel disponible

Floor (x) Le plus grand nombre entier inférieur ou égal à x (i-e ≤x) disponible
Frac (x) Part Fractionnelle de x disponible
Gamma(x) fonction Gamma nécessite DNLP ou autre solveur
pouvant gérer des fonctions non
linéaires et/ou de lissage
Gammareg(x,a) fonction gamma régularisée de paramètres a, 0, x nécessite DNLP ou autre solveur
pouvant gérer des fonctions non
linéaires et/ou de lissage
Log (x) C’est le logarithme népérien de x où x est un réel positif Disponible

Log10(x) Logarithme base 10 de x où x est un réel positif Disponible

Page 17 sur 86 M. Hervé GUENE, Ingénieur Statisticien-Economiste; E-mail: hguene@[Link]

Support de Cours GAMS 2009

Logbeta(a,b) Logarithme de la fonction beta nécessite DNLP ou autre solveur

pouvant gérer des fonctions non
linéaires et/ou de lissage
Loggamma(x) fonction Log Gamma nécessite DNLP ou autre solveur
pouvant gérer des fonctions non
linéaires et/ou de lissage
Mapval(x) Fonction qui renvoie une valeur entière associée à un disponible
résultat numérique contenant des valeurs spéciales (zéro
pour un nombre, une valeur non nulle pour les autres
résultats)
Max(x,y,…) La plus grande valeur parmi les arguments écrits
Min(x,y,…) La plus grande valeur parmi les arguments écrits

Mod(x,y) x est congru à y modulo (Mod (x,y)). C’est le reste de la disponible

division euclidienne de x par y (mod (x,y)= x-y*trunc(x/y))
Ncpcm(x,y,z) ) Fonction à utiliser dans les modèles MPEC qui calcule un disponible
filtre de Fisher égal à x – z ln(1+exp((x-y)/z)
Ncpf(x,y,z) ) Fonction à utiliser dans les modèles MPEC qui calcule un disponible
filtre de Fisher égal à sqrt(sqr(x) + sqr(y) + 2*z), c’est à
dire ඥ‫ݔ‬ଶ + ‫ݕ‬ଶ + 2‫ݖ‬
Normal(x,y) Nombre aléatoire réel généré selon une loi normale de Disponible
moyenne x et d’écart-type y
Pi Valeur de Pi := 3.141716… Disponible
Poly(x,a0,a1,a2,..) Calcule pour le scalaire x le polynôme nécessite des solveurs pouvant gérer des
=ܽ଴ + ܽଵ‫ ݔ‬+ ܽଶ‫ݔ‬ଶ + ܽଷ‫ݔ‬ଷ + ⋯ fonctions non linéaires
Power(x,y) x élevé à la puissance entière y. c'est-à-dire‫ݔ‬௬ , ici y doit être nécessite des solveurs pouvant gérer des
un nombre entier fonctions non linéaires
Prod C’est la fonction produit exactement à l’image du sigma (∑).
Il permet de calculer le produit d’un certain nombre
d’éléments indexés sur un ensemble.

Round(x) Arrondi le nombre x à l’entier le plus proche Disponible

Round(x,y) Arrondi x à y chiffres après la virgule(+) ou à y chiffres avant Disponible

la virgule (-) ;

Sigmoid(x) Sigmoid (x) = 1/ (1+exp(-x)) nécessite des solveurs pouvant gérer des
fonctions non linéaires

Page 18 sur 86 M. Hervé GUENE, Ingénieur Statisticien-Economiste; E-mail: hguene@[Link]

Support de Cours GAMS 2009

Sign(x) Signe de x. Renvoie 1 si x > 0, -1 si x < 0, et 0 si x = 0 Disponible

Sin(x) Sinus de l’argument x où x doit être en radians nécessite des solveurs pouvant gérer des
fonctions non linéaires ou des fonctions
discontinues
Sinh(x) Sinus hyperbolique de l’argument x où x doit être en radians nécessite des solveurs pouvant gérer des
fonctions non linéaires ou des fonctions
discontinues
Smin C’est une fonction qui calcule le plus petit élément d’un
ensemble d’expressions ou des termes indexés sur un
ensemble

Smax C’est une fonction qui calcule le plus grand élément d’un
ensemble d’expressions ou de termes indexés sur un
ensemble

Sqr(x) C’est le carré de x i-e ‫ݔ‬ଶ Disponible

Sqrt(x) c’est la racine carrée de l’argument x, i-e √‫ݔ‬ Disponible

Sum C’est le symbole mathématique sigma (∑) traduit en langage Disponible

GAMS. Il permet de calculer la somme d’un certain nombre
d’éléments indexés sur un ensemble

Tan(x) Tangente de l’argument x où x doit être en radians nécessite des solveurs pouvant gérer des
fonctions non linéaires dynamiques ou
des fonctions discontinues
Tanh(x) Tangente Hyperbolique de l’argument x où x doit être en nécessite des solveurs pouvant gérer des
radians fonctions non linéaires
Trunc(x) Troncature de x (i-e trunc(x)=sign(x)*floor(abs(x))) Disponible
Uniform(x,y) Nombre aléatoire réel compris entre x et y généré selon une Disponible
loi de probabilité uniforme
Uniformint(x,y) Nombre aléatoire entier compris entre x et y généré selon Disponible
une loi de probabilité uniforme

Operateur
GAMS Eq ou = Ne ou <> GT ou > GE ou >= LT ou < LE ou <=
expression a=b a ne b ou a<>b a gt b ou a>b a ge b ou a>=b a lt b ou a<b a le b ou a<=b
explication terme a = terme b terme a ≠ terme b terme a > terme b terme a > terme b terme a < terme b terme a < terme b

Page 19 sur 86 M. Hervé GUENE, Ingénieur Statisticien-Economiste; E-mail: hguene@[Link]

Support de Cours GAMS 2009

Pour effectuer des opérations sur les premier, deuxième, troisième, intermédiaire, …,
dernier élément d’un ensemble ordonné, on peut utiliser un code du genre

PREMIERBAL(period)$(ord(period) eq 1).

SELL(period) + STORE(period) =L= INVENTORY;

INTERBAL(PERIOD) $(ORD(period) GT 1 and ORD(period) lt CARD(period))..

SELL(PERIOD) =L= STORE(PERIOD-1) - STORE(PERIOD);

DERNIERBAL(PERIOD)$(ORD(period) eq CARD(period))

SELL(PERIOD) =L= STORE(PERIOD-1);

Ou bien

loop(period $(ORD(period) GT 1 and ORD(period) lt CARD(period)),

Z=z+1;);
Quand on veut effectuer une action lorsqu’une condition n’est pas vérifiée, il faut la préfixer d’un
opérateur not. Cela fait appel à une syntaxe du type :
not
Action$(not condition logique1) ou bien If (not condition logique1, Action); ou encore While
(not condition logique1), Action);
Quand on effectue une action et qu’on veut que une ou plusieurs conditions soient simultanément
satisfaites, il faut les joindre (lier) avec un opérateur and. Cela se fait à l’aide d’une syntaxe de
type:
and
Action$(condition logique1 and condition logique2 and condition logique3) ou encore If
((condition logique 1 and condition logique2 and condition logique3), Action); ou bien While
((condition logique1 and condition logique2 and condition logique3), Action);
Quand on effectue une action et conditionnée par au moins une ou 2 ou plusieurs conditions, il
faut les joindre (lier) avec un opérateur or. Cette commande invoque l’inclusion; C’est un ou
inclusif. Cela se fait à l’aide d’une syntaxe de type:
or
Action$(condition logique1 or condition logique2 or condition logique3) ou bien If
((condition logique 1 or condition logique2 or condition logique3), Action); ou encore
While((condition logique1 or condition logique2 or condition logique3),Action);

Quand on veut effectuer une action si et seulement si une seule et condition est vérifiée parmi 2
ou plusieurs conditions, il faut les joindre (lier) avec un opérateur xor. C’est la matérialisation du
ou exclusif, et donc la différence symétrique au sens ensembliste(‫ܣ‬. ‫ܤ‬ത + ‫)ܤ ̅ܣ‬. X appartient à A ou
B mais nullement à aux deux à la fois. Cela se fait à l’aide d’une syntaxe de type:
xor
Action$(condition logique1 xor condition logique2 xor condition logique3) ou bien If
((condition logique 1 xor condition logique2 xor condition logique3), Action); ou encore
While((condition logique1 xor condition logique2 xor condition logique3),Action);

Page 20 sur 86 M. Hervé GUENE, Ingénieur Statisticien-Economiste; E-mail: hguene@[Link]

Support de Cours GAMS 2009

Les operateurs logiques

Opérandes résultats
a a a and b a or b a xor b Not a
0 0 0 0 0 1
0 Non nul 0 1 1 1
Non nul 0 0 1 1 0
Non nul Non nul 1 1 0 0

Combinaisons de conditions logiques

Condition logique Valeur numérique Valeur logique

(1<2) + (3<4) 2 Vraie
(2<1) and (3<4) 0 Fausse
(4*5-3) + (10/8) 7.125 Vraie
(4*5-3) or (10/8) 1 Vraie
(4 and 5) + (2*3<=6) 2 Vraie
(4 and 0) + (2*3<6) 0 Fausse

Opérations sur les ensembles

Relation Expression Opérandes Ecriture GAMS

Union + C=A∪B C=A+B ou encore C=no; C(A)=yes; C(B)=yes;
Intersection * C=A∩B C=A*B ou encore C(i)=yes$(A(i) and B(i)) ;
Différence - C=A∖B C=A-B ou encore C(i)=yes$(A(i)); C(B)=no;
complément not A=B ഥ A(i) = not B(i) ; ou encore A(i)=yes; A(B)=no;
inclusion () A⊂B A (B(i))

Présentation des limites des différentes versions de GAMS (oralement). GAMS sur internet (comment
obtenir le logiciel? Présentation de la page [Link] et importance de gamsworld, le forum en ligne
des utilisateurs de GAMS).

Page 21 sur 86 M. Hervé GUENE, Ingénieur Statisticien-Economiste; E-mail: hguene@[Link]

Support de Cours GAMS 2009

PROGRAMMATION CONIQUE
II-1 Introduction
La programmation conique peut être conçue comme étant une généralisation de la programmation linéaire
avec pour contrainte additionnelle ‫ܥ߳ݔ‬, où C est un cône convexe. La classe de problème
problèmes qui en résulte
est connue sous le label de programmation conique et s’exprime en général sous la forme suivante:

Minimiser ்ܿ‫ݔ‬

‫ݎ ≤ ݔܣ‬௖
Sous la contrainte ൝‫݈[߳ݔ‬௫, ‫ݑ‬௫]

‫ܥ߳ݔ‬

Où ‫߳ܣ‬ℝ௠ ୶ ௡ est la matrice de contrainte, ‫߳ݔ‬ℝ௡ la variable de décision, et c߳ℝ

ℝ௡ les coefficients de couts de
la fonction objectif. Le vecteur ‫ݎ‬௖߳ℝ௡ est un vecteur qui représente le membre de droite ݈௫, ‫ ݑ‬௫߳ℝ௡ sont les
bornes inférieures et supérieures de la variable de décision x.

A présent partitionnons le vecteur de décision en plusieurs ensembles ܵ௧, ‫ = ݐ‬1, … , ݇, de sorte que
chaque variable de décision xi soit membre d’un et un seul ensemble ܵ௧. Par exemple on peut avoir :

‫଺ݔ‬
‫ݔ‬ଵ
‫ݔ‬ହ
ܵଵ = ൥‫ݔ‬ସ൩ ݁‫ܵݐ‬ଶ = ൦‫ ݔ‬൪ (1)
ଷ
‫଻ݔ‬
‫ݔ‬ଶ

Soit ‫ݔ‬ௌ೟ les variables de qui appartiennent à l’ensemble . Alors définissons

(2)

Où ‫ܥ‬௧ doit être d’une des formes suivantes:

Cône quadratique: (appelé aussi cône de Lorentz ou glace conique)

೟ ೟
‫ܥ‬௧ = ቊ‫߳ݔ‬ℝ௡ : ‫ݔ‬ଵ ≥ ට∑௡௝ୀଶ ‫ݔ‬௝ଶቋ (3)

Cône quadratique orienté: (considéré comme des contraintes hyperboliques)

೟ ೟
‫ܥ‬௧ = ቊ‫߳ݔ‬ℝ௡ : 2‫ݔ‬ଵ‫ݔ‬ଶ ≥ ට∑௡௝ୀଶ ‫ݔ‬௝ଶ , ‫ݔ‬ଵ, ‫ݔ‬ଶ ≥ 0ቋ (4)

Ces deux types de cônes sont utilisés pour formuler les problèmes quadratiques, les problèmes
quadratiquement contraints ainsi que d’autres classes de problèmes d’optimisation convexe non linéaire.

Page 22 sur 86 M. Hervé GUENE, Ingénieur Statisticien

Statisticien-Economiste; E-mail: hguene@[Link]
Support de Cours GAMS 2009

II-2 Implémentation des Contraintes Coniques dans GAMS

GAMS exprime les équations coniques à l’aide de =C=. Et cela s’écrit:

Cône quadratique:

(5)

Cône quadratique orienté:

(6)

A noter que ces contraintes coniques non liné

linéaires
aires sont considérées comme linéaires dans GAMS. On
pouvait aussi formuler ces problèmes coniques comme des problèmes NLP contraint:

Cône quadratique:

(7)

Cône quadratique orienté: ‫'(ݔ‬1') et ‫'(ݔ‬2')sont des variables positives

(8)

L’exemple ci dessus illustre les différentes formulations de problèmes de programmation conique.

L’optimiseur conique de GAMS qu’est MOSEK l’emporte généralement sur les méthodes NLP.

Exemple de programmation
ogrammation conique

Soit l’exemple suivant ([Link]

[Link])) qui explicite et implémente un peu l’utilisation des contraintes de type
cône quadratique orienté. On va reformuler le problème NLP à contraintes coniques original en un
problème conique.

ௗ ܽ௧‫ܾ ≤ ݔ‬

Le problème original est: minimiser ∑௜ ೔ sous la contrainte: ൜
௫೔ ‫ݔ‬௜߳[݈௜, ‫ݑ‬௜], ݈௜ > 0,
0 ݀௜ ≥ 0, ݅= 1,2, … , ݊
(9)

Où ‫߳ݔ‬ℝ௡ est la variable de décision,

décision ݀, ܽ, ݈, ‫߳ ݑ‬ℝ௡ sont des paramètres, et ‫߳ݔ‬ℝ
ℝ une constante réelle. Le
modèle original (9) peut être écrit en GAMS en utilisant les équations:
defobj.. sum(n, d(n)/x(n)) =E= obj;
e1.. sum(n, a(n)*x(n)) =L= b;
Model orig /defobj,
defobj, e1/;
[Link](n) = l(n);
[Link](n) = u(n);

Page 23 sur 86 M. Hervé GUENE, Ingénieur Statisticien

Statisticien-Economiste; E-mail: hguene@[Link]
Support de Cours GAMS 2009

On peut écrire une formulation NLP, en remplaçant la fonction objectif et en ajoutant une autre contrainte:
ܽ௧‫ܾ ≤ ݔ‬
2‫ݖ ≥ ݔ ݐ‬௜ଶ, ݅= 1, … , ݊

minimiser ∑௜݀௜‫ݐ‬௜ sous la contrainte ൞ ௜ ௜ (10)
‫݈[߳ݔ‬, ‫]ݑ‬, ݈ > 0, ݀௜ ≥ 0

Où ‫߳ݐ‬ℝ௡ est une nouvelle variable de décision. La formulation GAMS de ce NLP (model cnlp) est:
defobjc.. sum(n, d(n)*t(n)) =E= obj;
e1.. sum(n, a(n)*x(n)) =L= b;
conenlp(n).. 2*t(n)*x(n) =G= 2;

Model cnlp /defobjc, e1, conenlp/;

[Link](n) = l(n);
[Link](n) = u(n);

On peut transformer l’égalité en une inégalité parce que le paramètre ݀௜ ≥ 0 et nous sommes en présence
d’un problème de minimisation. Aussi, la contrainte conenlp(n) est une forme de cône quadratique
orienté. Si l’on introduit la variable ‫߳ݔ‬ℝ௡ , ‫ݖ‬௜ = √2, alors on peut reformuler le problème en utilisant une
contrainte conique:

⎧ܽ௧‫ܾ ≤ ݔ‬
⎪‫ݖ‬௜ = √2
Minimiser ∑௜݀௜‫ݐ‬௜ Sous la contrainte
(11)
ଶ
2‫ݐ‬
⎨ ௜௜ ‫ݔ‬ ≥ ‫ݖ‬௜ , ݅= 1, … , ݊
⎪‫݈[߳ݔ‬, ‫]ݑ‬, ݈ > 0, ݀ ≥ 0
⎩ ௜

La formulation GAMS utilisant des équations coniques =C= est:

defobjc.. sum(n, d(n)*t(n)) =E= obj;
e1.. sum(n, a(n)*x(n)) =L= b;
e2(n).. z(n) =E= sqrt(2);
cone(n).. x(n) + t(n) =C= z(n);

Model clp /defobjc, e1, e2, cone/;

[Link](n) = l(n);
[Link](n) = u(n);

Cette formulation est un programme linéaire GAMS, tel que les contraintes cone(n)... représentent la
contrainte conique non linéaire orientée.

Le code complet du modèle [Link] est:

Set n / n1*n10 /;
Parameter d(n), a(n), l(n), u(n);
Scalar b;

d(n) = uniform(1,2);
a(n) = uniform (10,50);
Page 24 sur 86 M. Hervé GUENE, Ingénieur Statisticien-Economiste; E-mail: hguene@[Link]
Support de Cours GAMS 2009

l(n) = uniform(0.1,10);
u(n) = l(n) + uniform(0,12-l(n));
uniform(0,12

Variables x(n);
x.l(n) = uniform(l(n), u(n));
b = sum(n, x.l(n)*a(n));

Variables
ariables t(n), z(n), obj;
Equations defobjc, defobj, e1, e2(n), cone(n), conenlp(n);

defobjc.. sum(n, d(n)*t(n)) =E= obj;

defobj.. sum(n, d(n)/x(n)) =E= obj;
e1.. sum(n, a(n)*x(n)) =L= b;
e2(n).. z(n) =E= sqrt(2);
cone(n).. x(n) + t(n) =C= z(n);
conenlp(n).. 2*t(n)*x(n) =G= 2;

Model clp /defobjc, e1, e2, cone/;

Model cnlp /defobjc, e1, conenlp/;
Model orig /defobj, e1/;

[Link](n) = l(n);
[Link](n) = u(n);

Solve clp min obj using lp;

Solve cnlp min obj using nlp;
Solve orig min obj using nlp;

II-3 Modélisations faisant appel à des Programmes Convexes

Il est souvent préférable de modéliser les programmes convexes dans une forme séparée dans la mesure du
possible. Considérons
ons le problème suivant de minimisation d’une fonction objectif.

݂(‫)ݔ‬: ݂(‫ = )ݔ‬log (ܽᇱ ∗ ‫)ݔ‬

Où ܽ߳ℝ௡ est un paramètre et ‫߳ ݔ‬ℝ௡ est la variable de décision. L’équation entraine une contrainte
implicite a' ∗ ‫ > ݔ‬0. Malheureusement des erreurs de types domain violations peuvent apparaitre parce
qu’on n’a pas mis de restriction sur a' ∗ ‫ݔ‬.. Une approche meilleure consisterait à introduire une variable
intermédiaire y :

݂(‫ = )ݔ‬log(‫)ݕ‬
‫ = ݕ‬aᇱ ∗ ‫ݔ‬
‫ ≥ݕ‬0

Cela permet de gérer deux choses. ça permet de borner implicitement , et donc de réduire le risque
d’occurrence de domain violations. Secundo, ça accélère la compilation puisque le calcul des gradients et
hessiens dans la première forme est expansive. Finalement cela n’occupe pas une grande mémoire.

Page 25 sur 86 M. Hervé GUENE, Ingénieur Statisticien

Statisticien-Economiste; E-mail: hguene@[Link]
Support de Cours GAMS 2009

Deux Exemples De Programmation Quadratique

Exemple 1 :

$TITLE un programme quadratique

$ontext
Dans ce modèle je veux résoudre un problème de programmation quadratique :

Minimiser 1/2 x'Qx + c'x

s.c Ax <= b
où Q et A son t des matrices et x, c et b sont des vecteurs de ℝ௡ . Si Q est semi définie positive, alors on a
une solution au problème s’il existe deux vecteurs u et x satisfaisants les conditions suivantes:

trouver x, u tels que: ‫߳ ݔ‬ℝ௡ , u >= 0,

/ Q A’ \ / x \ = -c
\ -A / \ u / >= -b

$offtext

SET K cons / 1 * 2/,

J vars / 1 * 2/ ;

Alias (I,J);

PARAMETER
Q(I,J) matrice des contraintes
C(J) vecteur de cout
A(K,J) matrice de contraintes
B(K) coefficients rhs;

C(J) = 0;

PARAMETER B(K) coefficients rhs

/1 1
2 2/;

table Q(I,J)
1 2
1 2
2 2;

table A(K,J)
1 2
1 1 1
2 3 -4;

Page 26 sur 86 M. Hervé GUENE, Ingénieur Statisticien-Economiste; E-mail: hguene@[Link]

Support de Cours GAMS 2009

VARIABLE
x(J) variables primales
u(K) variables duales;

EQUATION
ps(J)
ds(K);

ps(I) .. sum(J,Q(I,J)*x(J)) + sum(K,A(K,I)*u(K)) + C(I) =e= 0.0 ;

ds(K) .. b(K) =g= sum(J,A(K,J)*x(J)) ;

MODEL quadrat / ps.x, ds.u /;

solve quadrat us mcp;

display u.l, x.l ;

Exemple 2

Soit à résoudre le problème suivant :

‫ݔ( = ݕ ݊݅ ܯ‬ଵ − 1)ଶ + (‫ݔ‬ଵ − ‫ݔ‬ଶ)ଶ + (‫ݔ‬ଶ − ‫ݔ‬ଷ)ଷ + (‫ݔ‬ଷ − ‫ݔ‬ସ)ସ + (‫ݔ‬ସ − ‫ݔ‬ହ)ସ
‫ݔ‬ଵ + ‫ݔ‬ଶଶ + ‫ݔ‬ଷଷ = 2 + 3√2
Sous la contrainte ቐ‫ݔ‬ଶ − ‫ݔ‬ଷଶ + ‫ݔ‬ଵ = 2√2 − 2

‫ݔ‬ଵ. ‫ݔ‬ହ = 2

Ici on cherche les valeurs de x1, x2, x3, x4 et x5 qui vérifient les conditions et minimisent y. Voici le code
GAMS de ce problème:

Variable y, x1, x2, x3, x4, x5;

equation

fonc, eq1, eq2, eq3;

fonc.. y=e=sqr(x1-1)+sqr(x1-x2)+power(x2-x3,3)+power(x3-x4,4)+power(x4-x5,4);
eq1.. x1+sqr(x2)+power(x3,3)=e=3*sqrt(2)+2;
eq2.. x2-sqr(x3)+x4=e=2*sqrt(2)-2;
eq3.. x1*x5=e=2;
model salade /all/;
solve salade us nlp min y; display
y.L, x1.L, x2.L, x3.L, x4.L, x5.L;

le nom du code GAMS est quadratique_gdxxrw15.gms, et voici comment il se présente sous GAMS
Page 27 sur 86 M. Hervé GUENE, Ingénieur Statisticien-Economiste; E-mail: hguene@[Link]
Support de Cours GAMS 2009

Page 28 sur 86 M. Hervé GUENE, Ingénieur Statisticien-Economiste; E-mail: hguene@[Link]

Support de Cours GAMS 2009

PROGRAMMES D’OPTIMISATION FINANCIERE ET

D’EQUILIBRE GENERAL CALCULABLE
GAMS, depuis sa version 23.3, a scindé tout ce qui est programme d’optimisation financière des autres
types de programmes dans sa bibliothèque intégrée. Pour consulter les programmes d’optimisation
financière faire comme suit et cliquer la dernière option (Pratical Financial Optimization Models).

III-1 Les éléments de la modélisation

Comme on a pu le constater avec les sections précédentes, la première étape de toute modélisation GAMS
(y compris en EGC) consiste à écrire un fichier portant l’[Link] encore appelé fichier input.
Ensuite on lance le modèle et on consulte le fichier output qui porte l’extension lst.

Page 29 sur 86 M. Hervé GUENE, Ingénieur Statisticien-Economiste; E-mail: hguene@[Link]

Support de Cours GAMS 2009

La structure générale d’un fichier input GAMS contient les éléments suivants:

SET
{Pour exprimer et déclarer les ensembles et sous ensembles que l’on va utiliser dans le modèle}

VARIABLES
{Indique les variables qui seront calculées par le modèle}

SCALAR

{Indique les constantes exogènes à déclarer dans le modèle}

PARAMETERS
{Exprime les données et quelquefois les constantes calculées par le modèle; ces valeurs sont fixées}

TABLE

{pour insérer les matrices de données, les tableaux de type input output, les MCS, …}

EQUATIONS
{D’abord on déclare les équations, c’est à dire on les nomme; ensuite on les définit, c’est à dire on écrit
leur forme mathématique en langage GAMS}

MODEL
{on donne un nom au modèle}

SOLVE
{le mode de résolution est spécifié si l’optimande doit être maximisé ou minimisé et on précise le type de
modèle dont il s’agit (nlp, mcp,…)}

DISPLAY

{Ici on choisit de présenter les variables qu’on souhaite mettre en exergue, celles dont on veut voir
l’évolution}

Chacun de ces éléments sont des mots réservés qui peuvent apparaitre plusieurs dans un code GAMS; ils
constituent l’ossature d’un GAMS.

III-2 Mais comment déclarer les éléments?

SET
Chaque ensemble a un nom. La déclaration d’un ensemble contient :
- Le nom que l’on choisit de donner à l’ensemble
- La liste des éléments que cet ensemble
- Un commentaire (facultatif) sur une ligne pour expliquer ce que désigne l’ensemble
- Un commentaire (facultatif) sur une ligne pour définir individuellement les éléments de l’ensemble
Le format général de déclaration d’un ensemble se fait comme suit:

Page 30 sur 86 M. Hervé GUENE, Ingénieur Statisticien-Economiste; E-mail: hguene@[Link]

Support de Cours GAMS 2009

SET nomdel’ensemble commentaire facultatif pour définir l’ensemble

/ nomdupremierélément commentaire facultatif pour définir
nomdudeuxièmeélément commentaire facultatif pour définir
... /;
Exemple1 :

Ici l’ensemble factors désigne les facteurs de production. Il, est constitué de deux éléments labour et
capital. Les textes (le travail et le capital) sont des commentaires qui expliquent respectivement ce que
signifient labour et capital.
Exemple2 :

Dans l’exemple ci-dessus on vient de définir 4 ensembles :

- T qui est l’horizon temporel est : t= {1900, 1991, 1992, …….2060}
- Décade qui désigne les décennies de t (i-e ࢊࢋࢉࢇࢊࢋ ⊂ ࢚) ; decade est un sous ensemble de t
- Tinit est un singleton qui désigne le premier élément de t, i-e l’année initiale tinit= {1990} (tinit⊂ ࢚)
- Tfinal est un singleton qui désigne le dernier élément de t, i-e l’année finale tfinal= {2060} (tfinal⊂ ࢚)
Il arrive quelque fois qu’on invoque un ensemble plusieurs fois dans une équation. Si l’on ne donne à cet
ensemble des noms différents cela peut créer des erreurs de compilation. Pour ce faire, on utilise la
commande alias. Par exemple :

Ici ac, a, c, ins, insd, insdng, h, cp, insp, ap et insdngp sont des ensembles, certains étant inclus dans
d’autres (࡭ ⊂ ࡭࡯, ࡯ ⊂ ࡭࡯, ࡵࡺ ࡿ ⊂ ࡭࡯, ࡵࡺ ࡿࡰ ⊂ ࡵࡺ ࡿ, ࡵࡺ ࡿࡰࡺ ࡳ ⊂ ࡵࡺ ࡿࡰ , ࡴ ⊂ ࡵࡺ ࡿࡰࡺ ࡳ). Mais cp, insp,
ap et insdngp ont été crées par la commande alias. L’ensemble ap contient exactement les mêmes
éléments que a ; de même cp contient exactement les mêmes éléments que c, insp contient exactement les
mêmes éléments que ins,…

Page 31 sur 86 M. Hervé GUENE, Ingénieur Statisticien-Economiste; E-mail: hguene@[Link]

Support de Cours GAMS 2009

Un exemple concret d’inclusion et son expression dans GAMS

Operations sur les ensembles

Elles s’effectuent en utilisant les symboles +, -, *, et Not.
Soit un grand ensemble E contenant les ensembles E1, E2, E3, E4, E5 et E6.
+ matérialise l’union de 2 ou plusieurs ensembles: E3=E1+E2 ; signifie que ࡱ૜ = ࡱ૚ ∪ ࡱ૛
* matérialise l’intersection de 2 ou plusieurs ensembles: E4=E1*E2 ; signifie que ࡱ૜ = ࡱ૚ ∩ ࡱ૛ le
symbole * est aussi noté and i-e dans GAMS, E4=E1*E2 ; équivaut à E4=E1 and E2 ;
- matérialise la différence de 2 ou plusieurs ensembles: E5=E1- E2 ; signifie que ࡱ૞ = ࡱ૚ − (ࡱ૚ ∩ ࡱ૛)
Not matérialise le complémentaire d’un ensemble: E6= not E1; signifie que ࡱ૟ = ࡱ ∖ ࡱ૚ i-e ࡱ૟ = ࡱ૚തതതത

VARIABLE

Les variables représentent ce sui nous intéresse réellement dans le modèle. Leurs valeurs sont
déterminées de manière endogène par le modèle. Elles doivent être déclarées en utilisant la commande
variable. Le code GAMS de déclaration et calcul des variables est:
VARIABLE
X1 commentaire en une ligne pour expliquer la signification de X1
X2 commentaire en une ligne pour expliquer la signification de X2
Y commentaire en une ligne pour expliquer la signification de Y

……ainsi de suite on écrit le nom de toutes les variables puis pour

passer à la section suivante du modèle on met un point virgule pour
dire qu’on a fini de déclarer les variables et on passe à autre chose ;

On écrit donc le nom de la variable, ensuite on écrit en une ligne un commentaire pour expliquer ce
qu’elle désigne. On réplique la même chose pour toutes les autres variables. Et lorsqu’on a finit de définir
un type de données (VARIABLES, PARAMETER, EQUATION, MODEL, SOLVE, DISPLAY), le
passage au type suivant de donnée se fait par un point virgule.
Exemple :

Page 32 sur 86 M. Hervé GUENE, Ingénieur Statisticien-Economiste; E-mail: hguene@[Link]

Support de Cours GAMS 2009

Les types de variables

Type de la Variable Nature des restrictions sur les on numériques valeurs de la variable
Variable Pas de restriction, les valeurs de la variable sont réelles et vont de moins l’infini à
plus l’infini. (de -∞ à +∞)
Free Variable Même chose que ci-dessus. (valeur comprise entre -∞ et +∞)
Positive Variable les valeurs de la variable vont de zéro à plus l’infini. Même chose que pour
nonnegative ci-dessous. (0 à +∞)
Nonnegative variable les valeurs de la variable vont de zéro à plus l’infini. Même chose que pour
positive variable ci-dessus.
Negative Variable Valeurs non positives uniquement, les valeurs de la variable vont de moins l’infini
à zéro. (-∞ à 0)
Binary Variable Peut prendre seulement la valeur 0 ou 1 dans une programmation d’entiers. (0 ou1)
Integer Variable Valeurs entières uniquement; par défaut rangées de 0 à 100. (0, 1, 2, …)
SOS1 Variable Groupe de variables dont une seule peut être non nulle, mais qui par défaut sont
positives.
SOS2 Variable Groupe de variables dont deux adjacentes seulement peuvent être non nulles, mais
qui par défaut sont positives.
Semicont Variable Variable Semi-continue, peut prendre la valeur zéro ou une valeur réelle supérieure
à un nombre donné.
Semiint Variable Variable Semi - entière, peut prendre la valeur zéro ou une valeur supérieure à un
nombre entier fixé.

Les variables objectifs ainsi que celles à minimiser et/ou maximiser ne doivent pas contenir de restriction.
Elles doivent être des free variable.

Les suffixes utilisés pour les variables

Suffixe description
.L Valeur calculée
.lo Borne inférieure, c’est la plus petite valeur que peut prendre la variable
.up Borne supérieure, c’est la plus grande valeur que peut prendre la variable
.fx C’est la valeur qu’on fixe/impose à la variable. Elle ramène de ce fait toutes les
valeurs (.l, .lo et .up) à une seule et même valeur (.fx), i-e celle qu’on vient de fixer
.m La valeur duale de la variable

A présent voyons comment insérer des données dans notre code GAMS:
Les données sont des constantes, des vecteurs, ou des matrices/tableaux.
Pour déclarer une donnée in utilise :
SCALAR (pour les constantes: dimension zéro)
PARAMETER (pour les vecteurs: dimension 1)
TABLE (pour les matrices, les tableaux (du genre TES, MCS) : multidimensionnel)
Page 33 sur 86 M. Hervé GUENE, Ingénieur Statisticien-Economiste; E-mail: hguene@[Link]
Support de Cours GAMS 2009

SCALAR
La constante n’a aucun lien avec un ensemble quelconque. Elle ne contient donc pas d’indice. Dès qu’on
défini une constante on doit écrire sa valeur juste en face. Cette valeur est exogène au modèle.
Voici comment on déclare une constante :
SCALAR
nomdelaconstante commentaire explicatif en une ligne /valeur numérique de la constante/
Exemple :

Cela signifie que output_level=2

PARAMETER

Supposons que j’ai un paramètre A dont la valeur est 3. Alors le code GAMS est

PARAMETERS
A commentaire sur une ligne pour expliquer la signification de A;
A = 3;
Ou alors on pouvait procéder comme suit:

PARAMETERS
A commentaire sur une ligne pour expliquer la signification de A /3/;
et cela apparait comme suit:

Les constantes peuvent aussi être spécifiées comme étant des scalaires (SCALAR). GAMS est indifférent
en ce qui concerne la manière dont les paramètres et constantes sont définis (que ce soit à l’aide de
SCALAR ou PARAMETER). Pour la commande paramètre, lorsqu’on définit un paramètre, très souvent
les paramètres ont des liens avec les ensembles, et on écrit une formule pour calculer la valeur du
paramètre dans la suite du code. Si aucune valeur n’a été assignée au paramètre et aucune formule ne
permet de le calculer, alors GAMS lui donne la valeur zéro par défaut.

TABLE

Les tableaux de données concernant les paramètres ou tout autre type de données peuvent être déclarés
séparément par la commande table. En réalité ce sont des paramètres sauf qu’ils sont multidimensionnels.
Pour ce faire, il faut d’abord écrire table et déclarer. Ils sont le croisement de deux ensembles au moins, u
n dont les éléments sont en lignes et un ensemble dont les ensembles sont en colonnes. Par défaut il donne
la valeur zéro aux différentes intersections ligne/colonne. Par exemple: la déclaration d’une matrice de
comptabilité sociale en abrégé MCS ou encore SAM en anglais.

Page 34 sur 86 M. Hervé GUENE, Ingénieur Statisticien-Economiste; E-mail: hguene@[Link]

Support de Cours GAMS 2009

Ici, SAM (agrc-c, agr-a)=66.

EQUATIONS

 DECLARATION

La gestion des équations est un peu plus complexe que celle des autres types en GAMS, parce qu’après
avoir déclaré les équations exactement comme on le fait avec les variables et les paramètres, on définit les
équations c’est à dire on écrit leur forme mathématique en langage GAMS.

EQUATIONS
QX1 Explanatory text on the meaning of the equation for X1
QX2 Explanatory text on the meaning of the equation for X2
QY Explanatory text on the meaning of the equation for Y;
 DEFINITION

Mais pendant la définition des équations, chaque équation est séparée de l’autre par un point virgule.

QX1.. X1 =L= A;
QX2.. X2 =E= 5;
QY.. Y =E= X1 + X2;

Page 35 sur 86 M. Hervé GUENE, Ingénieur Statisticien-Economiste; E-mail: hguene@[Link]

Support de Cours GAMS 2009

Dans l’exemple ci dessus, la première équation détermine la valeur de X1. Elle est nommée QX1, et nous
dit que la valeur de x1 est inférieure ou égale à A. La seconde équation nous dit que X2 est égal à 5. Dans
la troisième équation, on lit que y est la somme de X1 et X2.

On peut utiliser 4 types d’équations:

 Le membre de gauche est inférieur ou égale à (=L=) membre de droite

 Le membre de gauche est supérieur ou égal à (=G=) membre de droite
 Le membre de gauche est égal à (=E=) membre de droite.
 Pour les équations coniques (=C=)

MODEL

Pour déclarer un modèle, on écrit MODEL nom que je veux donner à mon modèle /liste
des équations définissant mon modèle séparées les unes des autres par
une virgule/ ;

Si les équations préalablement écrites déterminent toutes mon modèle, alors j’écris

MODEL nom que je veux donner à mon modèle /all/ ;

Exemple:

SOLVE

le SOLVE permet de dire à GAMS de résoudre le modèle. Les modèles sont des objets que GAMS résout.
Ils sont des concentrés d’équations, de variables, de conditions logiques comportant des attributs. On écrit
donc SOLVE ensuite le nom du modèle puis le mode de solution de l’optimande (i-e si c’est une
maximisation ou une minimisation ou un problème mixte) nom de l’opérande using type de modèle.

SOLVE TEST USING DNLP MAXIMIZING Y;

Exemple:

Page 36 sur 86 M. Hervé GUENE, Ingénieur Statisticien-Economiste; E-mail: hguene@[Link]

Support de Cours GAMS 2009

Quelques procedures de résolution

Procédure Description
LP Linear programming. Le modèle ne doit pas contenir des variables/équations non linéaires ou
discrètes (binary et integer).
NLP Nonlinear programming. Dans le modèle, les formes non linéaires doivent être des fonctions
continues et le modèle ne doit pas comporter de variable discrète.
MIP Mixed integer programming. Similaire à RMIP, mais il doit rigoureusement contenir des variables et
équations discrètes. Les variables discrètes doivent prendre des valeurs discrètes bornées.
MINLP Mixed integer nonlinear programming. Les mêmes caractéristiques que MINLP, mais rigueur est faite
sur le fait qu’il doive contenir des variables et équations discrètes.
DNLP Pour les programmes non linéaires avec des dérivées discontinues

Page 37 sur 86 M. Hervé GUENE, Ingénieur Statisticien-Economiste; E-mail: hguene@[Link]

Support de Cours GAMS 2009

III-3 Ossature du modèle Standard IFPRI D’EGC dans GAMS

Le modèle IFPRI standard d’GEC a été dynamisé et écrit en langage GAMS dont voici les grandes lignes. Le code
complet et fonctionnel de ce modèle ainsi que tous les fichiers appelés est disponible dans le dossier « IFPRI» qui
accompagne le présent fichier.

*--------------------------------------------------------------------------------------------

*1. DECLARATIONS DES ENSEMBLES------------------------------------------

*--------------------------------------------------------------------------------------------

$ontext

Dans cette section, tous les ensembles sont déclarés. Ils sont divisés en 4 sous ensembles:

a. les ensembles du modèle (ceux qui apparaissent dans les équations du modèle)

b. les ensembles de calibration (utilisés pour initialiser les variables et définir les paramètres du modèle)

c. les ensembles de rapport, c’est à dire on va regrouper les résultats

d. les ensembles de mapping (ils apparaissent dans les fichiers de sortie)

Toutes les * que vous voyez au début de chaque ligne permettent de faire des commentaires. Ces lignes ne seront
pas lues lorsque GAMS va compiler et exécuter le modèle

$offtext

* Et cela se fait comme suit:

SETS

*a. ensembles du modèle

*b. ensembles de calibration

*c. ensembles de rapport

*d. les mappings

*--------------------------------------------------------------------------------------------

*2. LES DONNEES DE BASE----------------------------------------------------------

*--------------------------------------------------------------------------------------------

*INSERER LES DONNEES DU MODELE

On peut appeler la MCS ou tout ce qui est donnée comptable à partir d’un fichier externe pour ne pas que le
modèle soit long ou encore pour ne pas s’encombrer, ou alors l’écrire simplement ici.
Page 38 sur 86 M. Hervé GUENE, Ingénieur Statisticien-Economiste; E-mail: hguene@[Link]
Support de Cours GAMS 2009

Par exemple:

$INCLUDE [Link]

DISPLAY

Utiliser la commande display pour faire apparaitre certaines valeurs qu’on pourrait calculer à partir de la MCS
pour vérifier la cohérence de base (le PIB par exemple, les exportations, certains rapports, …, à noter que dans une
MCS on ne peut pas calculer de prix. La MCS représente les échanges qui ont eu lieu entre les acteurs d’une
économie durant une année).

*--------------------------------------------------------------------------------------------

*3. DECLARATION DES PARAMETRES---------------------------------------------

*--------------------------------------------------------------------------------------------

$ontext

Cette section est divisée en 2 sous sections:

a. les ensembles du modèle (ceux qui apparaissent dans les équations du modèle)

b. les ensembles de calibration (utilisés pour initialiser les variables et définir les paramètres du modèle)

Dans chaque groupe, les paramètres sont déclarés par ordre alphabétique. Ici il s’agit seulement d’écrire le nom
de chaque paramètre et d’écrire en face un commentaire qui nous dit à quoi sert le paramètre. On n’écrit donc
pas de formule de calcul ici.

$offtext

Les paramètres sont déclarés à l’aide de la commande Parameter

*--------------------------------------------------------------------------------------------

*4. DEFINITION DES PARAMETRES -----------------------------------------------

*--------------------------------------------------------------------------------------------

* Ici on va écrire les relations et formules qui permettent de calibrer et calculer chacun des *paramètres. Tous les
paramètres sont définis et listés, en les scindant selon la typologie suivante:

* Bloc des Prix ----------------------------------------------

* Bloc de la Production et du commerce -------------------------------

* Bloc des secteurs Institutionnels ----------------------------------------

*-----------------------------------------------------

Page 39 sur 86 M. Hervé GUENE, Ingénieur Statisticien-Economiste; E-mail: hguene@[Link]

Support de Cours GAMS 2009

*5. DECLARATION DES VARIABLES------------------------------------------------

*--------------------------------------------------------------------------------------------

*cette section concerne uniquement les variables qui appariassent dans le modèle.

*Elles sont déclarés par ordre alphabétique.

*--------------------------------------------------------------------------------------------

*6. DEFINITION DES VARIABLES --------------------------------------------------------------------

*--------------------------------------------------------------------------------------------

*Initialisation des valeurs des variables.

*On peut le faire directement dans notre code GAMS, ou alors le faire séparément dans un autre *fichier gms, txt
ou inc puis l’inclure comme suit:

$INCLUDE [Link]

*$INCLUDE [Link]

*--------------------------------------------------------------------------------------------

*7. DECLARATION DES EQUATIONS -------------------------------------------------------------------

*--------------------------------------------------------------------------------------------

EQUATIONS

* Bloc des Prix (10) ----------------------------------------------

* Bloc de la Production et du commerce (17) -------------------------------

* Bloc des secteurs Institutionnels (12) ----------------------------------------

* Bloc des contraintes Système (9) ----------------------------------

*--------------------------------------------------------------------------------------------

*8. DEFINITION DES EQUATIONS --------------------------------------------------------------------

*--------------------------------------------------------------------------------------------

* Bloc des Prix (10) ----------------------------------------------

* Bloc de la Production et du commerce (17) -------------------------------

* Bloc des secteurs Institutionnels (12) ----------------------------------------

Page 40 sur 86 M. Hervé GUENE, Ingénieur Statisticien-Economiste; E-mail: hguene@[Link]

Support de Cours GAMS 2009

* Bloc des contraintes Système (9) ----------------------------------

*--------------------------------------------------------------------------------------------

*9. DEFINITION DU MODEL ------------------------------------------------------------------------

*--------------------------------------------------------------------------------------------

MODEL STANDCGE standard CGE model /

* Bloc des Prix (10) ----------------------------------------------

* Bloc de la Production et du commerce (17) -------------------------------

* Bloc des secteurs Institutionnels (12) ----------------------------------------

* Bloc des contraintes Système (9) ----------------------------------

*--------------------------------------------------------------------------------------------

*10. ANNULATION DES VALEURS DES VARIABLES QUI NE SONT PAS DANS LE MODELE---------

*--------------------------------------------------------------------------------------------

*--------------------------------------------------------------------------------------------

*11. BOUCLAGE DU MODEL --------------------------------------------------------

*--------------------------------------------------------------------------------------------

$ontext

Dans le fichier de simulation, [Link], l’utilisateur choisit antre plusieurs types de bouclages. Les conditions de
bouclage portent sur:

$offtext

*marché des facteurs ----------------

* facteurs Désagrégés:

* facteurs Agrégés:

*compte de la balance courante ----------

Page 41 sur 86 M. Hervé GUENE, Ingénieur Statisticien-Economiste; E-mail: hguene@[Link]

Support de Cours GAMS 2009

*fixation des prix des importations et exportations en devise étrangères

*specificier si ces prix sont endogènes ou exogènes.

*balance courante de l’état ------

* [Link] = GSAV0;

*balance épargne-investissement------

*Indice de Prix Numéraire -----------

*--------------------------------------------------------------------------------------------

*12. PRESENTER LES VALEURS DES PARAMETRES ET VARIABLES DU MODELE---------------------

*--------------------------------------------------------------------------------------------

Utiliser le mot display

SOLVE STANDCGE USING MCP;

III-4 QUELQUES INSTRUCTIONS FREQUENTES

a- L’instruction LOOP

La commande Loop permet d’exécuter un certain nombre d’actions pour chaque élément d’un ensemble.
En fait c’est une boucle comme on en connait dans le langage informatique; du genre ‘faire tant que’. La
syntaxe du Loop est du type:

Loop ((ensemble dont les éléments sont concernés),

Action (s) à exécuter);

Ou loop((ensemble1, sensemble2,…) $condition, actions à effectuer ;) ;

Ou encore If balayer les éléments concernés de l’ensemble, alors effectuer l’action

Loop(ensemble dont les éléments sont concernés,

Action (s) à exécuter);

Le Loop permet à GAMS d’exécuter les actions pour chaque élément de l’ensemble concerné.

Exemples de loop
Page 42 sur 86 M. Hervé GUENE, Ingénieur Statisticien-Economiste; E-mail: hguene@[Link]
Support de Cours GAMS 2009

Exemple1: Le loop suivant est tiré de notre modèle 221. Il permet de compiler des scénarios. Pour chaque
scénario, il nous maximise la variable util et présente les résultats que sont les valeurs de pk, pd, pl, k, l,
xd, c, y et alphaF. Et les scénarios simulent une augmentation du paramètre var (sc) de 0,6.
loop(sc,

alphaF("sec1")=0.6 + Var(sc) ;
Solve le221 using NLP maximizing util ;
Display
PK.L, PL.L, PD.L, K.L, L.L, XD.L, C.L, Y.L
alphaF
) ;
Cela signifie en symboles mathématique que :
Résoudre le modèle le221 en maximisant la variable util (qui est l’utilité du consommateur) pour toutes les valeurs
de sc., ߙி,௦௘௖ଵ = 0,6 + ‫ݎܽݒ‬௦௖ . Après avoir résolu le modèle pour chacune des valeurs de sc, présenter les valeurs de
PK (le prix du capital) PL(le prix du travail), PD (le prix de la demande des biens consommés), XD (la demande des
biens), K (la quantité de capital), L(la quantité de capital), C (la consommation), et Y(le revenu)

Exemple2 : A partir du taux de croissance de la population chaque année (de 1985 à 1990) et connaissant la taille
de la population en 1985, on va insérer une boucle qui permettra de calculer la taille de la population annuelle sur
l’horizon 1985-1990 de manière récursive.

Exemple3 :

଴,ଶ
C'est-à-dire si ‫ ≤ݐ‬21, ݁݀௧ = 1,4 − ቀ ቁ(‫ݐ‬− 1); ‫ >ݐ݅ݏ‬21, ݁݀௧=0.
ଷ

Page 43 sur 86 M. Hervé GUENE, Ingénieur Statisticien-Economiste; E-mail: hguene@[Link]

Support de Cours GAMS 2009

b- L’instruction PUT

La structure basique de l’instruction put dans sa forme la plus simple est:

put item;

où item peut être n’importe quel type d’output, tel que du texte explicatif, un label, un paramètre, les
attributs d’une variable, les attributs d’une équation ou les attributs d’un modèle. Cependant, pour que
GAMS mette l’output dans le chemin approprié, l’utilisateur doit d’abord spécifier le nom du fichier et le
chemin, puis écrire une commande pour activer ce fichier.

Ainsi, une séquence générale de fichier put est:

file identifiantfichierlocal /chemindufichierexterne/;

put identifiantfichierlocal ;

put item1;

put item2;

put item3;

Dans cette configuration basique, les lignes

 Définissent le fichier qui recevra l’output en provenance de l’instruction put en donnant

l’identifiant local d’un fichier (qui est un le nom d’un item interne) et le nom d’un fichier externe
contenant si possible le chemin d’accès.
 Fournissent une expression put avec l’identifiantfichierlocal et rien d’autre sur la ligne, qui définit
de ce fait le fichier courant comme étant celui qui recevra tous les put subséquents jusqu’à ce
qu’un autre fichier interne soit référencé.
 Enfin les lignes subséquentes contenant chacune les commandes put écrivent sur le fichier courant.
 Un texte peut être inclus à partir d’un fichier put avec la syntaxe de l’utilitaire Put_utility 'inc'put
 Les lignes multiples de texte peuvent être introduites dans un fichier put avec la syntaxe $onput

Exemple de put

Ici, on a un graphique nommé [Link] ; il est bon de préciser au passage que les graphiques crées par
GAMS portent l’extension ’.gch’. Et dans notre cas, ce graphique est créé à partir du fichier [Link],

Page 44 sur 86 M. Hervé GUENE, Ingénieur Statisticien-Economiste; E-mail: hguene@[Link]

Support de Cours GAMS 2009

il est de type multi line, il est titré stockData et l’ensemble de données dont il présente l’évolution est
nommé StockData.

Pour l’obtenir, il suffit de cliquer sur la ligne bleue putfile: f C:\Documents and Settings\GUENE\Mes
documents\gamsdir\projdir\[Link] de la fenêtre ‘no actve process’

file f /[Link]/; put f;

$onput

[CHART]

GDXFILE=[Link]

TITLE=StockData

[SERIES1]

SYMBOL=StockData

TYPE=multi-linex

$offput

c- Le while

Cette commande permet de répéter un ensemble d’actions tant qu’une certaine condition logique est
satisfaite.

Exemple1

Exemple2

ou bien

d- Le if… else…

Page 45 sur 86 M. Hervé GUENE, Ingénieur Statisticien-Economiste; E-mail: hguene@[Link]

Support de Cours GAMS 2009

e- Le for

Il permet de répéter un certain nombre d’actions pour les valeurs successives d’une constante. Voici la
syntaxe générale du for :

For (constanteq=valeur initiale à (downto) valeur finale by incrément, actions à effectuer ;) ;

Exemple1

Ou encore

Exemple2

f- Le if-elseif-else

Cette commande utilisée pour transférer des des conditions d’un opérateur à un autre. Dans
certain cas il peut faire intervenir des conditions utilisant $. En voici la syntaxe usuelle:
If (condition, actions à effectuer ;
Elseif (condition), actions à effectuer ;
Else actions à effectuer ;
);

exemple

Page 46 sur 86 M. Hervé GUENE, Ingénieur Statisticien-Economiste; E-mail: hguene@[Link]

Support de Cours GAMS 2009

g- Le repeat

IL est utilisé pour exécuter un ensemble d’actions sur une condition logique et tant que cette
condition est satisfaite. La syntaxe générale du repeat est : repeat (actions a effectuer ; until condition
logique est vraie) ;

Exemple

III-5 Introduction de la dynamique dans un code GAMS

D’abord pour introduire la dynamique dans un code GAMS, il faut définir l’horizon temporel à l’aide d’un
ensemble ordonné, ensuite spécifier les périodes initiales et finales pour permettre à GAMS de savoir où il
commence et ou il doit s’arrêter pendant l’exécution. Par exemple dans le fichier [Link] on a la
déclaration suivante:

C’est la première chose à faire dans un modèle qu’on veut dynamique, qu’il soit d’EGC ou autre. Ici on
voulait mettre en relief les effets transitoires à chaque décennie, donc un autre sous ensemble a été défini
sur les décennies. L’horizon temporel va de 1990 à 2060 et les conditions qui définissent les années
initiales et finales sont effectuées par l’usage des dollars (symboles). GAMS ne travaille pas avec les
valeurs des constituants de l’ensemble même si cet ensemble est ordonné et sensé. Ce que GAMS utilise,
c’est l’ordre de précédence. Donc pour lui, l’année initiale est celle qui correspond au premier élément de
l’ensemble t (ce qui s’écrit donc tinit (t) est l’élément pour lequel ordre de t
est égale à 1). Ensuite, l’année finale, c'est-à-dire la dernière année est celle qui correspond au dernier
élément de l’ensemble t, c’est à dire l’élément dont l’ordre est égal au cardinal de t additionné de 1990,
car on commence par 1990 (ce qui s’écrit , donc tfinal est égal au nombre
d’éléments de t additionné de 1990 car on commence à compter à partir de 1990. Si on commençait à
partir de zéro, par exemple si on avait set /0*60/, alors tfinal serait égal à (cardinal de t)-1). Dans notre
exemple, card(t)=71 c'est-à-dire 2060-1990+1 ; or le dernier élément de set n’est pas 70; c’est plutôt
Page 47 sur 86 M. Hervé GUENE, Ingénieur Statisticien-Economiste; E-mail: hguene@[Link]
Support de Cours GAMS 2009

2060, qui est égal à 1990+70 = 1990+card(t). ici ord(1990)=1, ord(1991)=2, …

et ord(2060)=71.
Cette précision a été apportée car dans nombre d’exemples, les instants initiaux et finaux sont
systématiquement notés ord(t) eq 1 et ord(t) eq card(t), alors que pour des simulations plus
réalistes prenant en compte les années et données réelles l’on est amené à raisonner en temps concret.
C’est d’ailleurs l’étape la plus importante car après cette étape on peut définir nos variables et équations
dynamiques en respectant toutefois les règles de base de GAMS :
 Il ne faut pas faire trop d’itérations en dehors des limites disponibles pour la License dont on
dispose (en général pour des calculs en horizon infini, on implémente le modèle sur 100 à 120 ans
si les performances du logiciel le permettent) ; dans bien des cas on est obligé de réduire l’horizon
temporel pour diminuer le nombre d’itérations et permettre au logiciel de travailler et produire des
résultats.
 Il faut s’assurer qu’on a un système carré, ou du moins surdéterminé. GAMS est un logiciel
d’optimisation qui résous des systèmes d’équations, donc il ne faut pas qu’on ait plus de variables
que d’équations libres4, donc s’assurer que les variables que l’on a définies sur le temps ainsi que
les autres respectent cette condition d’exécution. Un accent a été mis sur l’aspect dynamique car en
général on passe d’un modèle statique à un modèle dynamique, et c’est ce passage qui doit aussi
astucieux que possible

Pour une introduction réussie, voir le fichier [Link], ou le tome 2 spécifiquement consacré à la
programmation dynamique et les codes GAMS rattachés.

Opérateurs des ensembles ordonnés

a- Le SAMEAS

Il arrive souvent qu’on veuille effectuer des calculs conditionnés par des ensemblistes, souvent pour des
relations particulières (exemple ∑௜ஷ௝ ‫ݔ‬௜௝s’écrit sum (i $[not sameas (i,’j’)], x(i,j)). La syntaxe générale de
sameas est du type suivant : sameas (élément considéré de l’ensemble, autre élément de l’ensemble) ou
alors sameas(élément considéré de l’ensemble, ’texte’). Et cette expression renvoie une valeur qui est
vraie si le texte d’écriture de élément considéré de l’ensemble est identique à celui de autre élément de
l’ensemble et fausse sinon.

4
Equation qui ne peut être obtenue par une combinaison linéaire des autres
Page 48 sur 86 M. Hervé GUENE, Ingénieur Statisticien-Economiste; E-mail: hguene@[Link]
Support de Cours GAMS 2009

Exemple

Alors ici on compte le nombre

d’éléments que les ensembles cityI et cityJ ont en commun (car on a donné la valeur 1).

b- Le DIAG

DIAG(élément considéré de l’ensemble, autre élément de l’ensemble) ou encore DAIG(élément

considéré de l’ensemble, ‘texte’) renvoie la valeur 1 si le texte d’écriture de élément considéré de
l’ensemble est identique à celui de autre élément de l’ensemble et 0 sinon.

Exemple

alors ici encore c’est une autre

manière de compter le nombre d’éléments que les ensembles cityI et cityJ ont en commun.

c- Les operateurs lag et lead

En français ces operateurs sont appelés respectivement opérateurs retard et avance. Ils sont utilisés
pour lier chaque élément d’un ensemble ordonné avec celui qui le précède ou celui qui le devance.
GAMS a deux variantes d’opérateurs avance et retard :

- Les lag et lead linéaires notés (+, -)

- Les lag et lead circulaires (++, --)

La différence entre ces deux types de retard et avance réside dans la procédure d’étapes initiale et
finale. Dans le cas des opérateurs lag et lead circulaires, après le dernier le dernier élément de
l’ensemble alors suit le premier élément, et le comptage recommence, il est infini ; alors qu’avec
l’opérateur lag/lead linéaire, après le dernier, le comptage est fini, il s’arrête donc.

Page 49 sur 86 M. Hervé GUENE, Ingénieur Statisticien-Economiste; E-mail: hguene@[Link]

Support de Cours GAMS 2009

QUELQUES EQUATIONS EN LANGAGE GAMS

Ce qui suit est un ramassis d’équations quelque complexes, tout juste pour établir une analogie entre la
transcription d’écritures des équations mathématiques et le langage GAMS. Les caractères entre
parenthèses sont des indices. Par exemple la consommation du ménage qu’on peut noter Ci s’écrit c(i) où
l’ensemble i a été précédemment spécifié dans le code GAMS.

IV-2 LES MENAGES

- Indices des prix à la consommation

 
 p i 1    cgi  c ih
i I  gGS 
ph   h H
 
 p i 1 
 
 qgi  c ih

i I  gGS 
GAMS: P(H) =E= SUM(I, P(I) * ( 1 + SUM(GS, TAUC(GS,I) ) ) * CH(I,H) ) / SUM(I, P0(I) * ( 1 +
SUM(GS, TAUQ(GS,I) ) ) * CH(I,H) );
Description: Les indices de prix à la consommation pour chaque type de ménage (l’ensemble H qui
contient le ménage h) sont calculés en prenant la valeur 100 pour l’année de base. H et
l’ensemble des ménages.

revenu global des ménages

 hf a w  
y h=  h
y f 1  
h 
 gf h  H
Ff   hf a wh 
 gGF 

hH

GAMS: Y(H) =E= SUM(F, A(H,F) * HW(H) / SUM(H1, A(H1,F) * HW(H1) ) * Y(F) * ( 1 - SUM(G,
TAUFH(G,F) ) ) );

Page 50 sur 86 M. Hervé GUENE, Ingénieur Statisticien-Economiste; E-mail: hguene@[Link]

Support de Cours GAMS 2009

Description: le revenu global du ménage est fonction de la rémunération des facteurs (la force de travail
offerte par chaque groupe de ménage) repartie aux ménages selon une distribution tenant
compte des types de ménages, c'est-à-dire les groupes socio-économiques.

Revenu disponible des ménages

y dh =y h   t gh a wh    ghh a h   w hg a nh  pchg h  H
gG gG gG

GAMS: YD(H) =E= Y(H) - SUM(GI, PIT(GI,H) ) * HW(H) - SUM(G, TAUH(G,H) * HH(H) ) + SUM(G,
TP(H,G) * HN(H) * TPC(H,G) );
Description: Le revenu disponible des ménages est fonction du revenue global net des impôts et taxes et
des transferts reçus.

Consommation privée des ménages

 i i
  

 yd p 
 ih 
 p i 1   cgi  
  gGS  
c ih  c ih  hd  h 
 yh ph 
 
  


i I,h  H
i I

 p i 1   qgi  
  gGS  
 
GAMS: CH(I,H) =E= CH0(I,H) * ( ( YD(H) / YD0(H) ) / ( CPI(H) / CPI0(H) ) ) ** BETA(I,H) * PROD(J,
( ( P(J) * ( 1 + SUM(GS, TAUC(GS,J) ) ) ) / ( P0(J) * ( 1 + SUM(GS, TAUQ(GS,J) ) ) ) ) **
LAMBDA(J,I) );
Description: Cette fonction de demande est dérivée des fonctions de types AIDS (Almost Ideal Demand
System) qui est une forme fonctionnelle complète. Le seul inconvénient est que bon
nombre de paramètres sont difficiles à calculer. On assigne donc des valeurs arbitraires à
ces paramètres en fonction d’un jugement basé sur l’expérience. Très souvent on attribue
des élasticités revenu unitaires, on donne la valeur zéro aux élasticités prix croisé de la
demande et aux autres élasticités de la demande.

Epargne des ménages

 
s h  y dh   c ih p i 1    cgi  h  H
i I  gGS 
GAMS: S(H) =E= YD(H) - SUM(I, P(I) * CH(I,H) * ( 1 + SUM(GS, TAUC(GS,I) ) ));
Description: c’est une fonction très simple d’épargne qu’on présente ici. Pour chaque ménage, l’épargne
est égale à la différence entre le revenu disponible et les dépenses du ménage. De ce fait il
n’existe aucune motivation à l’épargne pour les ménages, car le taux d’intérêt bancaire (qui
rémunère l’épargne) n’intervient pas dans cette fonction. Certains économistes préfèrent
intégrer la consommation inter temporelle dans la fonction d’épargne. Cette configuration
est appropriée pour un modèle national surtout si l’on veut ignorer les effets de
rémunération du capital et établir une relation entre l’épargne et l’investissement (et
Page 51 sur 86 M. Hervé GUENE, Ingénieur Statisticien-Economiste; E-mail: hguene@[Link]
Support de Cours GAMS 2009

inversement le niveau d’investissement dépendrait aussi de celui de l’épargne). Dans un

modèle régional, la modélisation de l’épargne est complètement différente de celle du
modèle national. L’investissement d’un pays ne dépendrait donc pas forcément de son
épargne uniquement.

IV-2 LES PRODUCTEURS

Calcul de la valeur ajoutée

 
p iva  p di    ii p i 1    giv   i I
i I  g GS 
GAMS: PVA(I) =E= PD(I) - SUM(J, AD(J,I) * P(J) * ( 1 + SUM(GS, TAUV(GS,J) ) ) );
Description: cette équation et son membre de gauche est un calcul commode. Le prix domestique de la
valeur ajoutée, considéré comme rémunération des facteurs est calculé comme étant la
différence entre le prix de vente des outputs net des prix des consommations intermédiaires
(y compris les taxes à la vente et les taxes prélevées sur ces consommations
intermédiaires). Cela permet de simplifier la forme des équations de demande des facteurs.
Même si les consommations intermédiaires sont des parts fixes de l’output, leur cout
respectif n’entre pas directement dans le calcul du profit. Les consommations
intermédiaires ne sont pas substituables. De même elles ne sont pas substituables aux
facteurs.

Fonction de production
-1
  i
  
 i
q i   i   i u dfi   i I
 f F 
GAMS: DS(I) =E= GAMMA(I) * SUM(F, ALPHA(F,I) * FD(F,I) ** ( - RHO(I) ) ) ** ( -1 / RHO(I) DS(I)
=E= GAMMA(I) * SUM(F, ALPHA(F,I) * FD(F,I) ** ( - RHO(I) ) ) ** ( -1 / RHO(I) );
Description: une fonction de production à élasticité de substitution constante est utilisée pour chaque
branche industrielle. Dans cette fonction, la quantité utilisée de chaque facteur et élevée à
une puissance et multipliée par un paramètre d’échelle. L’ensemble F est l’ensemble des
facteurs de productions ‘f’ est un membre de cet ensemble qui peut prendre la valeur ‘L’
pour le travail, ou ‘K’ pour le capital. Le total de ces produits est élevé à l’inverse de
l’exposant de substitution. Le premier paramètre est l’échelle de production. Très souvent
les valeurs de ces paramètres d’échelle sont imposées à partir d’informations sur la
littérature
Demande de facteurs

 
rfi rfa  1+
   xfgi  u dfi  p iva q i  if  t i

 i I, f  F
 gGF 

Page 52 sur 86 M. Hervé GUENE, Ingénieur Statisticien-Economiste; E-mail: hguene@[Link]

Support de Cours GAMS 2009

GAMS: R(F,I) * RA(F) * ( 1 + SUM(GF,TAUFX(GF,F,I) ) ) * FD(F,I) =E= PVA(I) * DS(I) * ALPHA(F,I)

+ SUM(G, FITC(F,G) * ITC(I)
Description: Les fonctions de demande de Facteurs sont calculées en prenant la dérivée première de la
fonction de profit par rapport aux variables de demande de facteurs (les prix et autres
facteurs demeurant constants). L’expression de gauche entre parenthèses prend en compte
les taxes sur les facteurs de production. Les taxes sur le travail représentent les portions de
la sécurité sociale, l’aide au chômage, la compensation des travailleurs et les taxes
similaires. Les taxes sur le capital représentent le revenu mixte et les franchises.
L’expression de droite représente le bénéfice marginal d’une unité de facteur, incluant le
revenu net de la valeur ajoutée plus la taxe sur l’investissement et les crédits reçus.
Demande intermédiaire

vi=   ii q i  i I
i I

GAMS: V(I) =E= SUM(J, AD(I,J) * DS(J) );

Description: Dans toutes les industries, les biens intermédiaires sont des parts fixes de la production. Il
en résulte que: la demande intermédiaire n’est pas calculée comme étant une variable
séparée pour chaque industrie, mais seulement comme une demande totale pour les biens
intermédiaires de chaque industrie. C’est le poids de la production de chaque industrie dans
la somme des parts totales.

Revenu des facteurs

yf   rfi ria u dfi   rf u dgi f  F

i I gG

GAMS: Y(F) =E= SUM(Z, R(F,Z) * RA(F) * FD(F,Z) );

Description: ce calcul simple cumule toutes les rémunérations de facteurs en provenance des secteurs de
production et de l’Etat.

IV-3 COMMERCE
Demande d’exportation

ei
  
e i  e i  p di  p iw   1 
   m
 gi

i  I
  gG  

GAMS: CX(I) =E= CX0(I) * ( PD(I) / PW0(I) / ( 1 + SUM(G, TAUM(G,I) ) ) ) ** ETAE(I);

Description: La demande d’exportation en biens est une fonction simple des exportations observées et
des relations entre les prix domestiques et les prix mondiaux. Si les prix domestiques
augmentent par rapport aux prix domestiques, les exportations vont baisser. Cependant, le
volume des exportations ne baisse pas jusqu’à zéro lorsque les prix domestiques
augmentent au-delà des prix mondiaux. Quel que soit le rapport de prix entre prix

Page 53 sur 86 M. Hervé GUENE, Ingénieur Statisticien-Economiste; E-mail: hguene@[Link]

Support de Cours GAMS 2009

domestique et mondiaux, il existe toujours un niveau d’exportation non nul qu’on pourrait
qualifier d’autonome.

Demande d’importation

mi  1  d i xi i  I
GAMS: M(I) =E= ( 1 - D(I) ) * DD(I);
Description: Les Importations sont une proportion (1-di) de la consommation domestique et représentent
dans cette consommation domestique la part qui n’est pas produite par les entreprises
domestiques.

IV-4 INVESTISSEMENT
Investissement global brut par secteur de destination

i
   
 rKi  1 
  gG

 xKgi  u Ki  t i 
 

n i  ni    i I
   
 rKi  1 
  gG

 Kgi  u Ki  t i 
 
  
GAMS: N(I) =E= N0(I) * ( ( R('K',I) * ( 1 - SUM(GK, TAUFX(GK,'K',I) ) ) * KS(I) + SUM(G,
FITC('K',G) * ITC(I) ) ) / ( R0('K',I) * ( 1 - SUM(GK, TAUF(GK,'K',I) ) ) * KS(I) + SUM(G,
FITC('K',G) * ITC0(I) ) ) ) ** ETAIX ;
Description: les décisions d’investissement se prennent secteur par secteur en fonction des changements
nominaux, après les rémunérations de la taxe sur le capital dans chaque secteur.

Investissement global brut par secteur source

 
p i 1 
  n 
 gi c 
 in   ij n i i  I
 gGS  jI

GAMS: P(I) * ( 1 + SUM(GS, TAUN(GS,I) ) ) * CN(I) =E= SUM(J, B(I,J) * N(J) );

STOCK DE CAPITAL

u sKi  u sKi 1   i  +n i i I
GAMS: KS(I) =E= KS0(I) * ( 1 - DEPR ) + N(I) ;
Description: le stock de Capital est égal au stock courant de capital déprécié, plus l’investissement brut.

Taux de crédit à l’investissement

Page 54 sur 86 M. Hervé GUENE, Ingénieur Statisticien-Economiste; E-mail: hguene@[Link]

Support de Cours GAMS 2009

 in'i
ti   n i  i 'i 1  i  I
i 'I   gin'
gGS

GAMS: ITC(I) =E= SUM(J, N(I) * B(J,I) / ( 1 + SUM(GS, TAUN(GS,J) ) ) * ITCE(J,I) );

IV-4 OFFRE DE TRAVAIL

L’offre de travail
wh
h 
PIT w h g 
LS

  t gh 

  
aw aw  ra   gG p h 
h
h
 h  La   gGI    h H
w hg 
ah a h  rL  
  t gh 
 

 gGI   
 gG p h 
GAMS: HW(H) / HH(H) =E= HW0(H) / HH0(H) * ( ( RA('L') / RA0('L') ) / ( CPI(H) / CPI0(H) ) ) **
ETARA(H) * ( SUM(GI, PIT(GI,H) ) / SUM(GI, PIT0(GI,H) ) ) ** ETAPIT(H) * ( SUM(G,
TP(H,G) / CPI(H) ) / SUM(G, TP0(H,G) / CPI0(H) ) ) ** ETATP(H);
Description: L’offre de travail est exprimée en termes de taux de participation: le nombre de ménages
travailleurs divisé par le nombre total de ménages dans une classe de ménages possédant un certain
revenu. C’est une fonction du taux de participation initial multiplié par trois facteurs: la variation
du taux de salaire, la variation du revenu moyen des ménages et les variations du transfert moyen
reçus par les ménages non travailleurs. On suppose que chaque ménage est lié à un ensemble
d’élasticités constantes qui varie d’un ménage à l’autre. Les ménages qui possèdent de grands
revenus ont des élasticités plus grandes relativement aux salaires et aux taxes, mais faibles en
termes de transferts reçus (car ces ménages reçoivent très peu ou pas de transferts). Les ménages à
faibles revenus ont des élasticités plus faibles relativement aux salaires et aux taxes, mais élevées
en termes de transferts reçus (car ces ménages reçoivent beaucoup de transferts).

Nombre de ménages sans travail

a nh  a h  a w
h h H
GAMS: HN(H) =E= HH(H) - HW(H);
Description: Le nombre de ménages sans emploi est simplement égale au nombre total de ménages dans la
population moins celui de ménages travailleurs.

IV-6 TAXATION
Taxes sur les ménages

 y    
 b i  m  c
t gh   gh   wh   dgh   sgh    ogh 
a h   
 gg 
 gh  gh  gh  gh g  GI, h  H
t 
 
   g'   

Page 55 sur 86 M. Hervé GUENE, Ingénieur Statisticien-Economiste; E-mail: hguene@[Link]

Support de Cours GAMS 2009

GAMS: PIT(GI,H) =E= ( TAXBASE(GI,H) + ( Y(H) / HW(H) - TAXBM(GI,H) - TAXSD(GI,H) - (

TAXOD(GI,H) + SUM(GI1, ATAX(GI1,GI) * PIT(GI1,H) ) ) * TAXPI(GI,H) ) * MTR(GI,H) ) *
TAXCVC(GI,H);
Description: Les ménages paient les taxes sur le revenu, sur les produits et sur la propriété à l’Etat. Les taxes sur
produits sont incorporées dans les prix des produits vendus sur le marché de biens et services, et
sont collectées par les entreprises. Les taxes directes, par ménage (revenu et propriété) sont fonction
du revenu moyen des ménages.

IV-7 ETAT
Revenu de l’état

yg=  qgi
x
vi pi    gi
m
mi piw     qgi
x
cih pi    qgi
x
cin pi +    qgi
x
cig  pi
iI iI i I h H i I i I g G

   gi
x
rfi rfa udfi    gi
x
rfg rfa udfg  +   hf yf
iI f F g G f F h H

 
   hhga h   t gha wh  gn  - t i  g  G
h H h H iI CABAC

GAMS: Y(G) =E= SUM(I, TAUV(G,I) * V(I) * P(I) ) + SUM(I, TAUM(G,I) * M(I) * PW0(I) ) +
SUM((H,I), TAUC(G,I) * CH(I,H) * P(I) ) + SUM(I, TAUN(G,I) * CN(I) * P(I) ) + SUM((G1,I),
TAUG(G,I) * CG(I,G1) * P(I) ) + SUM((F,I), TAUFX(G,F,I) * RA(F) * R(F,I) * FD(F,I) ) +
SUM((F,G1), TAUFX(G,F,G1) * RA(F) * R(F,G1) * FD(F,G1) ) + SUM(F, TAUFH(G,F) * Y(F) )
+ SUM(H, PIT(G,H) * HW(H) ) + SUM(H, TAUH(G,H) * HH(H) ) + SAM(G,'INVES') -
SUM((I,F), FITC(F,G) * ITC(I) );
Description: le revenu de l’état est la somme des taxes sur les ventes collectées sur la consommation domestique
(intermédiaires, importations, consommation des ménages, investissement), plus les taxes sur la
rémunération des facteurs, plus les taxes collectées sur les ménages (taxes sur le revenu,
domaniales), moins les taux de crédit à l’investissement.

Épargne de l’état

   
sg  yg  cig pi 1  gig   u dfg rfg rfa 1  xfgi   whg ahg hg  bg'g + bgg'
n pc
g G
iI  gGS  f F  gGF  hH g 'G g 'G

GAMS: S(G) =E= Y(G) - SUM(I, CG(I,G) * P(I) * ( 1 + SUM(GS, TAUG(GS,I) ) ) ) - SUM(F, FD(F,G) *
R(F,G) * RA(F) * ( 1 + SUM(GF, TAUFX(GF,F,G))) ) - SUM(H, TP(H,G) * HN(H) * TPC(H,G) )
- SUM(G1, IGT(G1,G) ) + SUM(G1, IGT(G,G1) );

exogeneisation des dépenses du gouvernement en biens et services

c ig  c ig i  I,g GX

GAMS: [Link](I,GX) = CG0(I,GX);

exogeneisation de la rentabilité des facteurs au gouvernement

u dfg  u fg
d
f  F,g GX

Page 56 sur 86 M. Hervé GUENE, Ingénieur Statisticien-Economiste; E-mail: hguene@[Link]

Support de Cours GAMS 2009

GAMS: [Link](F,GX) = FD0(F,GX);

Fixation de la rentabilité du capital pour toute l’économie

rfa  rfa f  F
GAMS: [Link]('K') = RA0('K');
Description: Comme les entreprises prennent leurs décisions d’investissement sur la base des variations de la
rentabilité du capital, alors l’on va fixer la valeur de cette rentabilité du capital pour l’économie
entière.
exogeneisation du montant des transferts

w hg  w hg h  H,g GWX

GAMS: [Link](H,GWX) = TP0(H,GWX);

Description: Les transferts sont modélisés comme étant des variables exogènes pour chaque ménage inactif ou
chômeur.
whg  0  h  H,g  GWX où whg  0
GAMS: [Link](H,G)$(NOT TP0(H,G)) = 0;

V- INTERFAÇAGE DE GAMS AVEC LES AUTRES LOGICIELS : LA

COMMANDE GDX ET LES FICHIERS GDX

Sous GAMS, il ce qu’on appelle l’appel des fichiers externes et la sortie de fichiers externes en d’autres
formats (xls, mdb,…) qui se fiat avec les commandes $include, $batinclude, $sysinclude, $call, gdxi, gdxo
… que nous n’exposerons pas ici. On va se limiter à l’utilisation de la puissante commande gdx qui est
largement suffisante, car les autres commandes précédemment citées sont bonnes pour des étapes
supérieures ; et comme nous sommes en intro, allons donc à l’essentiel.

V-1 Le GDX et les divers GDX.

a- Créer un fichier gdx

Pour créer un fichier gdx, taper à la fin du code GAMS:

Execute_unload ‘nom que je veux donner à mon fichier [Link]’ variables à mettre en relief séparées
d’une virgule et point virgule à la fin.

Exemple: execute_unload '[Link]' consum, compare, c, k, u, t;

Ou bien taper dans la ligne de commande GAMS :

Gdx= nom que je veux [Link] et on tape F9 ou entrée, exemple : Gdx= [Link]

Page 57 sur 86 M. Hervé GUENE, Ingénieur Statisticien-Economiste; E-mail: hguene@[Link]

Support de Cours GAMS 2009

Le fichier gdx de mon modèle est ainsi créé automatique dans gamsdir/projdir et je peux le récupérer
pour le convertir en d’autres formats (Excel, Access, html, sql,…) ou faire des graphiques directement
sous GAMS pour comparer des scénarios, des effets de politique, l’évolution des variables dynamiques,…

Après avoir crée le fichier gdx, on peut lister les variables dans le gdxviewer, i-e le visualiseur de fichiers
gdx, en tapant toujours dans le code GAMS à la fin execute '= nom que je veux [Link] ' ;

Exemple: execute '=gdxviewer [Link]';

Pour faire un graphique sous gams, il suffit de charger les résultats dans un fichier gdx en écrivant la
commande execute_unload et créer le fichier gdx qu’on veut.

Ensuite, ouvrir le fichier gdx créé dans le Gmasdir/projdir puis faire un clic droit sur l’item que l’on veut
représenter graphiquement. Ensuite faire un cliquer sur ‘chart’ + ‘one dimension’ + ‘line chart’. (Pour une
application concrète évoquer et présenter les codes [Link], dyn1_mcp.gms, [Link],
[Link] et ressource_renouvelables.gms)

Question: je voudrais créer un fichier gdx qui fasse apparaitre tous les ensembles, les paramètres et
scalaires de mon modèle, mais je ne veux voir apparaitre aucune équation ni variable dans ce fichier gdx.

Si vous avez tapé 'execute_unload “nom que je choisis de [Link]”;' comme étant la dernière ligne de
votre programme, GAMS va tout exporter (y compris les variables et les équations) dans le fichier gdx
nom que je choisis de [Link] (exactement comme la ligne de commande parameter
'gdx=…').

Alors pour éviter les variables/équations, ajoutez l’option 'option clear=var1, clear=var2, …, clear=equ1,
clear=equ2,…;' comme dernière ligne de votre programme. C’est concis et précis.

Evoquer oralement et expliquer GDXDIFF, GDXMERGE, à l’aide des exemples concrets…

b- Exporter en format des autres logiciels

Pour exporter des données au format des autres logiciels, créez d’abord votre fichier gdx (qui signifie
GAMS data exchange pour échange de données GAMS; on peut l’utiliser pour échanger des données
entre GAMS et les autres logiciels et langages tels que Access, Excel, SQL,…). Après avoir crée le fichier
on peut l’ouvrir à partir de GAMS. La seule infirmation utile est qu’il porte l’extension .gdx et non .gms.
En ouvrant le fichier. gdx on peut faire des graphiques directement sous GAMS pour comparer des
scénarios précédemment écrits dans le code gms et transcrits en format gdx, ou observer l’évolution des
variables dans le temps. Ces graphiques sont crées sous GAMS. Mais avec le gdxviewer, c'est-à-dire si
vous avez tapé la commande concernant le gdxviewer dans votre code GAMS, le gdxviewer apparait
automatiquement, et on peut faire les observations et comparaisons directement. Par exemple pour ce qui
est du fichier [Link], pour visualiser l’évolution du stock de capital dans le temps et observer l’écart
entre la solution analytique et la solution numérique, ouvrir le fichier gdx associé (en l’occurrence
[Link]) ensuite faire un clique droit sur compare qui est un paramètre défini dans le code GAMS pour
comparer les solutions analytique et numérique d’évolution de la consommation (c) et du stock de
Page 58 sur 86 M. Hervé GUENE, Ingénieur Statisticien-Economiste; E-mail: hguene@[Link]
Support de Cours GAMS 2009

capital (k); puis clique gauche sur chart, puis sur 2dimnesions, puis sur 2d chart et enfin sur multi line et
on obtient le graphique suivant :

Pour utiliser ces résultats avec d’autres logiciels on utilisera toujours le fichier gdx créé. Pour ceux qui ont
utilisé le gdxviewer, cliquer droit sur l’item que l’on veut exporter (ça peut être un paramètre, une
variable, un ensemble, un ensemble de variables, d’ensembles…) puis sur export, puis choisissez le format
de sortie du fichier comme le montre la figure suivante :

Au stade actuel, le seul logiciel statistique formel avec lequel GAMS interface sans moins de difficultés
est Matlab et un peu STATA. Pour interfacer GAMS avec SPSS ou SAS, il faut exporter les données en
format Excel et ensuite les envoyer sous SPSS, SAS ou STATA, ou même Matlab pourquoi pas.

Page 59 sur 86 M. Hervé GUENE, Ingénieur Statisticien-Economiste; E-mail: hguene@[Link]

Support de Cours GAMS 2009

V-2 Importer des données dans GAMS depuis les autres logiciels
C’est ce qu’on appelle l’appel des fichiers externes. Très souvent on doit manipuler de grands ensembles
de données, par exemple des données contenues dans des feuilles calcul Excel ou dans de grosses bases de
données. Avec GAMS, il est possible d’utiliser ces fichiers sans les coller dans le code GAMS. Il suffit
d’écrire une commande simple dans le code pour appeler ces fichiers et GAMS fera le travail en arrière
plan. L’objectif de cette astuce est de simplifier le code qu’on écrit pour qu’il soit très facile à comprendre
et lisible. Faire des présentations guidées à l’aide d’exemples concrets : on ne peut pas tout écrire.
Détailler l’utilisation du dollar ($).

a- Conversion de données Excel en GAMS

- Utiliser l’exécutable [Link]
On procède ainsi lorsqu’on veut importer entièrement le contenu d’une feuille de calcul. Pour ce faire aller
dans le dossier d’installation de GAMS, (C:\program files\GAMS…) et vous verrez l’exécutable xls2gms
(entouré dans la figure ci-dessous :

Double-cliquer dessus et la boite de dialogue suivante apparaitra :

Ensuite remplir les champs :

 input file cliquer sur browse pour sélectionner la feuille de calcul Excel que vous voulez importer
 range pour préciser la plage de données qui vous concerne, ça peut être toute la feuille, ou une
portion de feuille de calcul tout dépend de la plage dont vous avez besoin pour travailler.
 Output file pour dire comment vous voulez que GAMS l’incluse dans le modèle. Ça peut être un
fichier text (.txt) ou .inc par défaut.
Puis cliquer sur ok. Alors cette feuille de calcul que l’on vient d’importer est partie intégrante du modèle
sauf qu’on ne se fatigue plus pour faire du copier coller ou encore pour saisir les données et allonger
inutilement le code GAMS.

Page 60 sur 86 M. Hervé GUENE, Ingénieur Statisticien-Economiste; E-mail: hguene@[Link]

Support de Cours GAMS 2009

Autrement, on peut aussi taper la commande suivante dans notre code GAMS pour appeler directement
xls2gms directement dans GAMS plutôt que de double cliquer sur [Link]. Dans ce cas on spécifiera
tous les paramètres (input file sera écrit i=, range s’écrit r= et output s’écrit o=) en une ligne de commande
comme suit : $call = xls2gms I=“C:\[Link]” R=feuil1!B1:E10 O=“C:\[Link]” .
Autre exemple: $call =xls2gms r=a3:a4 i=[Link] o=[Link]. Ensuite, après avoir converti donc le
fichier externe en un format exploitable par GAMS il faut l’inclure comme partie intégrante du code en
écrivant simplement : $include [Link]
On peut donc utiliser tous les ensembles, sous ensembles et éléments de [Link].
Récapitulons donc a travers le graphique suivant :

- Importer seulement certaines colonnes d’une feuille de calcul Excel dans GAMS

Page 61 sur 86 M. Hervé GUENE, Ingénieur Statisticien-Economiste; E-mail: hguene@[Link]

Support de Cours GAMS 2009

Quelques fois l’on a besoin d’importer certaines colonnes d’une feuille de calcul dans GAMS. Pour cela il
faut écrire un code GAMS pour le faire. En voici un exemple:

- Le moyen le plus simple d’importer des données sous GAMS est de l’importer de manière brute et
de faire tout le reste du travail dans GAMS.
- set p /'p=1'*'p=50'/;
- parameter rawdata(p,*) 'la feuille de calcul entière'
- $call"=gdxxrw i=testdaten_GAMS.xls o=[Link] par=A rng=Tabelle1!a2"
- $gdxin data
- $load rawdata=A
- display rawdata

Page 62 sur 86 M. Hervé GUENE, Ingénieur Statisticien-Economiste; E-mail: hguene@[Link]

Support de Cours GAMS 2009

b- De Matlab à GAMS
D’abord vous devez avoir déjà installé GAMS et MATLAB sur votre ordinateur. On suppose que les
répertoires d’installation des deux logiciels sont respectivement C:\MATLAB et C\GAMS.
Il vous faut ensuite une application (c’est un petit dossier contenant des fichiers, me rappeler pour que
je vous le donne). Il se nomme [Link].
1. Copier [Link] dans C : \ gams\inclib\[Link]
2. Copier [Link] dans C : \ matlab\toolbox\local\[Link]
3. Fixer le chemin d’accès à gamside
Pour vérifier que vous avez réussi l’installation, effectuer les étapes suivantes:
1. lancer matlab
2. dans la fenêtre de commande matlab, envoyer les répertoires dans le répertoire des exemples
fournis par matlab. Ce dernier répertoire contient deux fichiers testint.m et [Link] qui requis
pour ce test
3. lancer le ‘testint’ que vous verrez dans le répertoire des exemples de la distribution (i-e c’est déjà
incorporé dans matlab). Pour ce faire, saisir seulement dans matlab :

le résultat obtenu contiendra les output suivants :

Remarque

Pour lancer le même modèle dans matlab et renvoyer les valeurs du vecteur solution x(i) et du paramètre
d(i,j) dans l’environnement de travail de matlab, l’on doit opérer un changement dans le fichier GAMS,
consistant à ajouter les lignes ci-dessous en dessous du solve:

Cette dernière commande permet juste d’écrire la valeur de la solution dans un fichier que matlab peut
lire. Ensuite dans Matlab on exécute simplement la ligne suivante :
[x d]=gams(‘nom du fichier gams’) ;

Page 63 sur 86 M. Hervé GUENE, Ingénieur Statisticien-Economiste; E-mail: hguene@[Link]

Support de Cours GAMS 2009

VI- QUELQUES ASTUCES DE PROGRAMMATION GAMS

VI-1 Les Macros

GAMS, depuis sa version 22.9 permet de définir et d’utiliser des macros. Les macros sont utilisées pour
automatiser certains calculs et raccourcir les syntaxes.

a- Définition Basique

Pour crée une macro, voici l’approche basique à faire dans GAMS

$macro nom que je veux donner à la macro corps de la macro

$macro nom (arg1, arg3, arg2,..) corps de la macro et ce que c’est que arg1,..

Le nom de la macro doit être unique, de façon similaire aux autres types de données GAMS telles que set
et parameter. Exemple:

$macro unsur(y) 1/y

On peut appeler cette macro doublement en l’utilisant avec deux arguments différents.

z = unsur (x1) + unsur (x2);

qui veut dire:

z = 1/x1 +1/x2;

Puisque GAMS reconnait unsur(x1) comme étant une macro et remplace x1 (l’argument dans
unsur(x1)) pour y (dans la définition originale de la macro unsur (y)) et fais la même chose pour x2.
En rappel l’argument utilise dans la macro(y) n’est qu’un symbole et peut dupliquer le nom pour d’autres
items dans le code. Par exemple la macro pourrait être définie comme suit :

$macro unsur(x1) 1/x1

Même si x1 est un scalaire, c'est-à-dire nommé dans la commande scalar dans le code.

Les multiples arguments

Les macros peuvent avoir plusieurs arguments. Dans ces cas, il faut séparer ces arguments par des
virgules. Par exemple créons une macro qu’on nommera ‘ratio’ qui calcule le rapport entre deux nombres.
Cela se fait comme suit :

Page 64 sur 86 M. Hervé GUENE, Ingénieur Statisticien-Economiste; E-mail: hguene@[Link]

Support de Cours GAMS 2009

$ macro ratio(a,b) a/b

*Et on peut appeler cette macro avec

z = ratio(x1, x2) ; ce qui signifie: z = x1/x2;

Les macros Multi-line

La macro ratio précédemment définie a été écrite sur une seule ligne. Mais on peut concevoir une macro
sur plusieurs lignes. Exemple :

$macro equ2(z,d,q) equation equ2_&z&d; \

equ2_&z&d.. z*q =e= 0;

Macros définies à l’intérieur d’une Macro

Certaines Macros peuvent être incluses dans d’autres macros ([Link])

$ macro produit(a,b) a*b

$ macro addition(i,x,z) sum(i,produit(x(i),z))

Qui peut être appelée avec z = addition(j,a1,x1); et qui signifie que: z = sum(j,a1(j)*x1);

Les multiples paires de parenthèses et les guillemets peuvent être utilisés librement de sorte à protéger la
virgule séparatrice.

D’une manière générale voici comment on peut écrire une macro multi line

$macro myMacro
if (a = 1) then
faire ce que je veux;
else
faire autre chose;
endif;

Expansion plus prudente

La reconnaissance des macros et l’expansion des arguments peuvent être encore mieux contrôlées par
l’utilisation des ampersands (&) dans le corps de la macro. Ordinairement La macro va seulement
substituer les mots entiers

$ macro f(i) sum(j, x(i,j))

$ macro equh(q) equation equ_q(i); equ_q(i).. q =e= 0;

Page 65 sur 86 M. Hervé GUENE, Ingénieur Statisticien-Economiste; E-mail: hguene@[Link]

Support de Cours GAMS 2009

equh(f(i))

ce qui va s’épandre pour devenir equation equ_q(i); equ_q(i).. sum(j, x(i,j)) =e= 0;

Cela contient q dans un nombre d’autres positions. Celui qui veut remplacer certains d’entre eux pourrait
le faire.

$macro f2(r,i) sum(j, r(i,j))

$ macro equ2(z,d,q) equation equ2_&z&d; equ2_&z&d.. z*q =e= 0;

equ2(1,(i),f2(x,i))

equ2(2,(k),f2(r,k))

ce qui va s’épandre pour devenir

equation equ2_1(i); equ2_1(i).. 1*sum(j, x(i,j)) =e= 0;

equation equ2_2(k); equ2_2(k).. 2*sum(j, r(k,j)) =e= 0;

où le &z le $d sont remplacés.

On peut aussi inclure l’expression avec des espaces, virgules et parenthèses en utilisant && qui inclus une
expression et enlève les ensembles des guillemets.
$macro d(q) display &&q;

$macro ss(q) &&q)

d('"hereit is" , i,k')

d('"(zz"')

z=ss('sum(j,a1(j)');

z=ss('prod(j,a1(j)');

où les expressions d contiennent des guillemets, des espaces et virgules et l’expression ss a des
parenthèses non closes entre les guillemets.
Lorsqu’on développe, on obtient

display "hereit is" , i,k;

display "(zz";

z=sum(j,a1(j));

z=prod(j,a1(j));

Page 66 sur 86 M. Hervé GUENE, Ingénieur Statisticien-Economiste; E-mail: hguene@[Link]

Support de Cours GAMS 2009

les Infinite nested macros

Le résultat de Nested macro peut être étendu jusqu’à longueur infinie. Par exemple:

$ macro a b,a

display a;

qui va se développer en:

display b,b,b,b,b,b,b,b,b,b,b,b,b,b,b,b,b,……

GAMS éventuellement refusera de faire plus de substitutions que possible et présentera une erreur de
compilation.

Utilisation des macros dans l’écriture d’un rapport

Une autre astuce des macros est l’utilisation implicite du suffixe .L dans l’écriture d’un rapport ainsi que
les autres types de déclarations de manipulation des données. Cela permet d’utiliser la même algèbre dans
la définition des modèles et la déclaration des variables, des ensembles et paramètres. Le code suivant en
est une illustration ([Link])

$ macro sumit(i,term) sum(i,term)

cost .. z =e= sumit((i,j), (c(i,j)*x(i,j))) ;

supply(i) .. sumit(j, x(i,j)) =l= a(i) ;

demand(j) .. sumit(i, x(i,j)) =g= b(j) ;

Model transport /all/ ;

Solve transport using lp minimizing z ;

$onDotL

parameter tsupply(i) total demand for report

tdemand(j) total demand for report;

tsupply(i)=sumit(j, x(i,j));

tdemand(j)=sumit(i, x(i,j));

ce qui deviendra:

cost .. z =e= sum((i,j),(c(i,j)*x(i,j))) ;

supply(i) .. sum(j,x(i,j)) =l= a(i) ;

Page 67 sur 86 M. Hervé GUENE, Ingénieur Statisticien-Economiste; E-mail: hguene@[Link]
Support de Cours GAMS 2009

demand(j) .. sum(i,x(i,j)) =g= b(j) ;

Model transport /all/ ;

Solve transport using lp minimizing z ;

parameter tsupply(i) total demand for report

tdemand(j) total demand for report;

tsupply(i)=sum(j,x.L(i,j));

tdemand(j)=sum(i,x.L(i,j));

Le $ondotl choisit implicitement le suffixe .L pour les variables. Cette astuce a été introduite pour rendre
les macros utiles et ne se limite pas à être utilisée dans le corps de la macro. Comme c’est une nouvelle
balise, elle doit être activée. Le $offdotl permet de la désactiver.
Autres notes

Trois commandes sont pertinentes pour les macros.

$show va lister toutes les macros GAMS définies dans le programme.
$onmacro/$offmacro va activer ou désactiver les macros; la valeur par défaut est $onmacro.
$on/offexpand change l’apparition des macros dans les arguments d’un call dans une macro.
Le $onexpand active la reconnaissance et l’expansion des macros dans la liste des arguments de macro.
$offexpand restaure les valeurs par défaut.
La définition des Macros est préservée même quand on utilise Save/restart dans les fichiers et elles sont
toujours disponibles quand on améliore les compilations continues.

VI-2 ASTUCES DIVERSES

a- comment exprimer la contrainte suivante: la somme des 4 éléments consécutifs

d’un vecteur doit être inferieure ou égale a 10?

Q: si un vecteur A a 10 valeurs (variables de décision) Objectif: Maximiser la somme de éléments de A. et

je veux que la somme des 4 éléments consécutifs d’un vecteur doit être inferieure ou égale a 10.

L’on peut utiliser les opérateurs avance et retard (lag and lead operator du chapitre 13.4 dans le GAMS
User's Guide) comme suit:

set i /1*10/; alias (i,j);

set iconseq(i,j);
scalar cnt;

loop(i, for(cnt=0 to 3, iconseq(i,i+cnt) = yes));

Page 68 sur 86 M. Hervé GUENE, Ingénieur Statisticien-Economiste; E-mail: hguene@[Link]

Support de Cours GAMS 2009

display iconseq;

variable x(i);
equation e(i);
e(i).. sum(iconseq(i,j), x(i)) =l= 10;

Si vous voulez faire une somme circulaire dans le terme “consécutif” de la contrainte, il faudra remplacer
le + qui est dans l’expression loop par ++.

Exogénéisation d’une variable endogène

Ce genre de gymnastique arrive souvent lorsqu’on écrit un MEGC. Je suis en train d’implémenter un modèle .gms
de sorte que :
- Etape1 : une variable x est endogène. J’exécute le modèle et j’obtiens la valeur optimale de x
- Etape2: la valeur optimale de x est exogène de sorte à ce que je puisse l’utiliser pour calculer la valeur
optimale d’un variable y.
Donc après le solve qui permet de calculer la valeur optimale de la variable X, on ajoute la ligne suivante:
[Link] = X.l ;
et x est donc fixé à sa valeur d’optimum. On peut l’utiliser pour faire ce qu’on veut. C’est le suffixe .fx qui permet
de l’exogénéiser. Et le .l qui signifie level permet de fixer cette valeur de x à sa valeur calculée. Si je veux la libérer
encore, je dois ramener les bornes supérieures et inférieures à leurs valeurs de départ.
Par exemple :
[Link]=-inf ; [Link]=+inf;

Comment définir plusieurs modèles indépendants dans un code GAMS?

Q: je voudrais diviser mon modèle en trois parties indépendantes sans toutefois écrire chaque variable et
chaque équation trois fois.

La Section 9 du GAMS User's Guide explique la syntaxe de déclaration d’un model. Si vous voulez
déclarer plusieurs modèles indépendants vous pouvez aussi utiliser la syntaxe étendue suivante:

Supposons que vous ayez déclaré les équations comme suit:

* équations communes à tous les modèles:

c_eq1..
c_eq2..
c_eq3..

* équations non communes à tous les modèles:

nc_eq1..
nc_eq2..
nc_eq3..

Maintenant on déclare un modèle basique qui ne contient que les équations communes:

Page 69 sur 86 M. Hervé GUENE, Ingénieur Statisticien-Economiste; E-mail: hguene@[Link]

Support de Cours GAMS 2009

model basic /c_eq1, c_eq2, c_eq3/;

Pour chaque modèle Independent, on déclare tout juste un nom différent, et qui contient le modèle basique
et le(s) équation(s) additionnelle(s):

model nc1 /basic, nc_eq1/;

model nc2 /basic, nc_eq2/;
model nc3 /basic, nc_eq3/;

Comment unir deux ensembles différents

Voici un exemple qui permet de le faire:

set i / i1*i10 /,
j / j1*j10 /,
i_u_j / set.i, set.j /;

display i_u_j;

Le problème est que i et j doivent être disjoints. Autrement on aura une erreur de compilation de type
redefined element si on définit i_u_j. De plus, i et j ne sont pas des sous ensembles de i_u_j. le code
suivant va rencontrer une compilation error:

set i / i1*i10 /,
j / j1*j10, i5 /,
i_u_j / set.i, set.j /;

display i_u_j;

Comment spécifier une condition de sorte à éviter une 'division by zero' error ou encore
erreur de division par zéro?

Q: // soit les paramètres a(i), b(i). je veux spécifier:

parameter c(i) = b(i) / a(i) if a(i) ~= 0

c(i) = 0 if a(i) = 0

Il y a des subtilités à gérer lorsqu’on utilise EPS (epsilon) et zéro tolérance, mais une syntaxe comme celle
ci devrait marcher

c(i) = 0;
c(i)$a(i) = b(i)/a(i);

Vous pourrez faire ceci si vous ne voulez pas annuler entièrement c:

c(i)$[not a(i)] = 0;

Page 70 sur 86 M. Hervé GUENE, Ingénieur Statisticien-Economiste; E-mail: hguene@[Link]

Support de Cours GAMS 2009

il serait plus clair d’annuler c d’abord. Ensuite, en fonction de la manière dont c est déclare, ce serait plus
rapide aussi, si vous faites

c(i)$[a(i) <> 0] = b(i)/a(i)

Cette dernière méthode ressemble un peu à celle d’en haut à l’excepté là où a(i) a la valeur epsilon (EPS).
EPS est une valeur insérée (donc $a(i) est vraie) mais a la valeur 0, si bien qu’on aura une erreur de
division par zéro si on n’explicite pas que c’est pour a(i) <> 0.

Comment protéger mon modèle GAMS?

GAMS, n’insère pas votre dans une base de données interne, mais plutôt en tant que fichier ASCII ou
binaire par défaut. Ce fichier peu être protégé en utilisant les options de sécurité offertes par votre système
d’exploitation.

Supposons que plusieurs utilisateurs aient accès à une même machine, et donc à votre modèle, et font des
compilations et en utilisent les résultats. Si vous ne voulez pas que ces derniers puissant observer ou
modifier la structure ou l’algèbre du modèle, vous pouvez le faire avec les commandes “Save et Restart”.
L’information la plus importante à savoir est que ce modèle sera précompilé et ne sera ré exécuté qu’à
partir de sa forme précompilée.

Voici un exemple, qui explique comment on peut appliquer cela. On a deux modèles privé.gms et
[Link], où [Link] contient la partie secrète de votre modèle et [Link] contient les données
qu’on peut accepter aux autre de voir:

* [Link]
$phantom foo
$onempty
set i / foo /;
parameter c(i) / foo 0 /, w(i) / foo 0 /;
scalar rhs /0/;

binary variable x(i); variable z;

equation obj, e;

obj.. z =e= sum(i, c(i)*x(i));

e.. sum(i, w(i)*x(i)) =l= rhs;

model kn /all/;
set s / foo /;
loop(s,
c(i) = uniform(0.9,1.1)*c(i);
solve kn max z using mip;
);
* [Link]
$onmulti
set i / i1*i5 /;
parameter c(i) / i1 1, i2 2, i3 3, i4 4, i5 5 /
w(i) / i1 5, i2 4, i3 3, i4 2, i5 1 /
scalar rhs /8/;
set s /s1*s2/;

Page 71 sur 86 M. Hervé GUENE, Ingénieur Statisticien-Economiste; E-mail: hguene@[Link]

Support de Cours GAMS 2009

à present exécutez [Link] comme suit: gams [Link] a=c s=0. L’output sera un fichier
précompilé 0.g00, humainement illisible. A présent on peut supprimer [Link] (revenir en arrière
d’abord) et exécuter [Link] ensemble avec 0.g00 en utilisant: gams public r=0.

Jetez un coup d’œil dans l’annexe F (The Save and Restart Feature) du GAMS User's Guide pour de plus
amples informations.

Les versions de GAMS à partir de la 22.4 permettent de faire cela. Jetez un coup d’œil dans l’annexe I
(Compressed and Encrypted Input Files) du GAMS User's Guide pour de plus amples informations.

Comment obtenir un ensemble ordonné à partir d’un ensemble non ordonné?

Seul l’opérateur Ord() permet de travailler sur les ensembles ordonnés. Les ensembles introduits bien
avant l’avènement de cette commande ne sont pas ordonnés. Voici un exemple qui permet d’obtenir un
ensemble ordonne a partir d’un ensemble non ordonné.

Note: les fonctions sameas, .pos, et .val seront aussi utiles si l’ensemble n’est pas ordonné.

set i ordonné / 1*10 /

j non ordonné / 0*9 /;

* j n'est pas ordonné puisque UEL (unique élément) '0' qui est le premier élément de

* j est en dehors de l'ordre universel (ensuite 1 - 9).

parameter ordj(j) faked ord(j);

* ça ça ne fonctionne pas

* ordj(j) = ord(j);

* cela fonctionne toujours

scalar cnt /0/; loop(j, cnt=cnt+1; ordj(j) = cnt);

set premier_j(j) premier élément de j

dernier_j(j) dernier élément de j;

premier_j(j) = ordj(j) = 1;

dernier_j(j) = ordj(j) = card(j);

* celui ci a 1 comme premier élément et 0 comme dernier élément.

* si l'ordre actuel n'est pas important, alors c'est propre

Page 72 sur 86 M. Hervé GUENE, Ingénieur Statisticien-Economiste; E-mail: hguene@[Link]

Support de Cours GAMS 2009

display premier_j, dernier_j;

alias (*,u);

* Au cas où vous voulez obtenir l'ordre actuel, la syntaxe suivante vous le donne

cnt=0; loop((u,j)$sorteduels(u,j), cnt=cnt+1; ordj(j) = cnt);

premier_j(j) = ordj(j) = 1;

dernier_j(j) = ordj(j) = card(j);

* Donc on a maintenant 0 comme premier et 9 comme dernier élément.

display premier_j, dernier_j;

Output:

...
---- 21 SET premier_j premier element de j

---- 21 SET dernier_j dernier element de j

---- 32 SET premier_j premier element de j

---- 32 SET dernier_j dernier element de j

Multiplicateur de Lagrange pour les contraintes

Q: pendant une programmation non linéaire, on a besoin du multiplicateur de Lagrange des Contraintes.
Il est possible d’obtenir la valeur de ce multiplicateur.

Le multiplicateur de Lagrange, connu souvent sous le nom de marginals dans GAMS, peut être obtenu
après un solve de la manière suivante: Supposons que la contrainte d’intérêt est CON(j,k) et on veut fixer
lamda(j,k)à sa valeur marginale après le solve. Donc, écrire quelque part après le solve:

lamda(j,k) = CON.M(j,k) ;

Linéarisation d’un paramètre multi dimensionnel

J’ai rencontré un problème d’indice sur un paramètre. Je voudrais calculer B(m)= A(i,j,k) + C(i,j,k) où
m = i+4*(j-1)+ 8*(k-1) donne une valeur unique pour chaque (i,j,k) à m.

Page 73 sur 86 M. Hervé GUENE, Ingénieur Statisticien-Economiste; E-mail: hguene@[Link]

Support de Cours GAMS 2009

si i,j,k, et m sont des ensembles ordonnés de sorte que l’opérateur ord() puisse être utilisé, une
possibilité de 'linéarisation' des matrices A et C peut être formulée à l’aide d’une somme (SUM) pour
contrôler les ensembles i,j,k. Le SUM est effectué sur un seul opérande. Voici les détails:

sets i /1*5/
j /1*4/
k /1*8/
m /1*160/;

parameter
A(i,j,k)
B(m)
C(i,j,k);

A(i,j,k) = ord(i) + 10 * ord(j) + 100 * ord(k);

C(i,j,k) = 1000*ord(i) + 10000 * ord(j) + 100000 * ord(k);

B(m) = sum((i,j,k)$(ord(m)=(ord(i)+4*(ord(j)-1)+8*(ord(k)-1))),
A(i,j,k) + C(i,j,k));

display A,C,B;

Comment énumérer tous les sous ensembles possibles d’un ensemble?

Jetez un coup d’œil sur l’exemple de programme suivant:

* Exemple qui nous montre comment énumérer tous les sous ensembles possibles d’un
* ensemble

sets
I / i1 * i3 /,
J / j1 * j2/,
IJ(I,J),
cnt / 1 * 9999 /;

scalars M, N, pMN, k, l;
M = card(I);
N = card(J);
pMN = power(2,(M*N));
abort$(card(cnt) lt pMN) "cnt set is too small";

loop {cnt$(ord(cnt) le pMN),

k = ord(cnt) - 1;
l = M*N;
IJ(I,J) = NO;
loop {(I,J),
IJ(I,J) = mod(k, 2);
k = floor(k / 2);
}
display IJ;
}

Page 74 sur 86 M. Hervé GUENE, Ingénieur Statisticien-Economiste; E-mail: hguene@[Link]

Support de Cours GAMS 2009

VI-3 Le GAMS Tips and Tricks de Rob Dellink

1. Explorer le GAMS mailing list archive; il contient beaucoup d’astuces utiles (y compris celles que nous
exposerons ci-bas): [Link] fournit un résumé des
principaux thèmes abordés, et le fichier complet peut être visité et/ou téléchargé à l’adresse suivante :
[Link]

{Contribution de Rob Dellink}

2. GAMS est fourni avec une bibliothèque de plus de 160 modèles comme précédemment spécifié; jeter un
coup d’œil dans cette bibliothèque lorsque vous écrivez votre propre modèle (pour accéder à la
bibliothèque, cliquer sur l’onglet model libraries du gamside ou dans dossier MODLIB ou encore sur la
page d’accueil de GAMS).

{Contribution de Rob Dellink}

3. D’abord résolvez un modèle qui ne fait aucune itération dans le but de savoir si le paquet (i.e. la base de
données que vous avez inséré) est répliqué par le modèle. Cela permet de s’assurer qu’on n’a pas d’erreur
de compilation/calibrage dans le modèle.

<nom du modèle>.iterlim = 0;

solve <nom du modèle> using <solver> maximising <optimande>;

<nom du modèle>.iterlim = 2000;

{Contribution de Rob Dellink}

4. Utilisez l’instruction abort si votre spécification du modèle est incorrecte; ce genre de situation apparait
lorsqu’on finit avec une solution qui ne satisfait pas indument certaines conditions; par exemple, si la
référence ne se réplique pas, l’on peut utiliser:

ABORT$(<nom du modèle>.OBJVAL GT 1E-6) "DATA CALIBRATION ERROR! LARGEST ERROR:

", <nom du modèle>.OBJVAL;

Ou alors au cas où l’on sait (par la loi de Walras) que la valeur de la variable C2 doit égaler celle de X2:

ABORT$((C2.L-X2.L)**2 gt 1E-20) "loi de Walras non vérifiée!";

{Contribution de Rob Dellink}

5. S’assurer toujours que votre modèle a été normalement compilé et a pu calculer une solution optimale:
Page 75 sur 86 M. Hervé GUENE, Ingénieur Statisticien-Economiste; E-mail: hguene@[Link]
Support de Cours GAMS 2009

DISPLAY <nom du modèle>.MODELSTAT, <nom du modèle>.SOLVESTAT;

Les deux prendront la valeur 1 si le modèle est linéaire; et solvestat prendra la valeur 2 pour les
modèles non linéaires. On peut utiliser l’instruction abort si une ou deux des deux propositions est
incorrecte:

ABORT$(<nom du modèle>.MODELSTAT <> 1) "Modèle non complété normalement",

<nom du modè[Link];

ABORT$(<nom du modèle>.SOLVESTAT <> 2) "pas d’optimum local trouvé",

<nom du modè[Link];

{Contribution de Rob Dellink}

6. Donner des valeurs arbitraires de départ si vous avez des indices sur les ‘bonnes’ ou vraies valeurs d’une
variable. Entrez donc ces valeurs dans le programme GAMS. Cela permettra d’éviter des often-found
‘zero-solution’, ce qui signifie qu’un optimum est obtenu lorsque toutes les variables ont une valeur nulle.
Mieux, cela évite des infeasibilities, souvent abrégées sous GAMS (INFEAS ou INFEASIBLE).
Pour donner des valeurs initiales aux variables, écrire le nom de la variable, ajouter le suffixe ".L" et
ensuite spécifier les indices de cette variable (en rappel, ".L" doit être écrit avant ces indices5!):

VARIABLE X(J);

X.L(J) = 1;

X.L("1") = 2;

< … insert model declaration etcetera here … >

{Contribution de Rob Dellink}

7. Si l’on veut insérer dans le code des commentaires qui prendront plusieurs lignes, utiliser les commandes
$ontext et $offtext. Il faut avoir pour habitude de résumer ce dont il est question dans notre code dès
le début de l’écriture du code comme suit:

$TITLE le nom de mon modèle, version xx

$ontext

version: xx

date: dd-mm-yy

auteur de cette version: initiales

base sur: version précédente x

5
Ces indices peuvent être le temps t ou tout autre ensemble, exemple ct s’écrit c(t) et le niveau de consommation en l’an t s’écrira c.l(t)
Page 76 sur 86 M. Hervé GUENE, Ingénieur Statisticien-Economiste; E-mail: hguene@[Link]
Support de Cours GAMS 2009

caractéristiques: …

qu’y a t-il de nouveau dans cette version: comparer à la version x

probleme1: aucun?!

note1: l’aspect y ne doit pas être inclus

note2: l’aspect y doit être inclus

$offtext

Par exemple dans le modèle 2x2x1 on a :

$ontext

En résumé

Ici on construit un MEGC 2x2x1 sous GAMS pour une économie simple avec les
caractéristiques suivantes:

-la préférence du ménage (consommateur) est modélisée par une Cobb-Douglas

-deux biens utilisés seulement comme biens de consommation

-deux facteurs de production: capital et travail

-deux firmes utilisant une technologie de type Cobb-Douglas

-travail et capital sont mobiles entre les secteurs et sont fixés de manière exogène

-pas d'épargne ni investissement

-pas de gouvernement

-économie fermée

Notation conventionnelle:

-scalaires, paramètres et données sont imprimées

-VARIABLES (et leur valeur initiale) et les noms des équations sont en lettre
majuscules

-Les noms des équations commencent toujours par EQ

-les initiations des valeurs des variables et des paramètres sont indiqués par zéro
en plus de leurs noms

$offtext

{Contribution de Rob Dellink}

Page 77 sur 86 M. Hervé GUENE, Ingénieur Statisticien-Economiste; E-mail: hguene@[Link]

Support de Cours GAMS 2009

8. On peut limiter la taille du listing (fichier .lst) en insérant les instructions suivantes:

$offsymxref

{stoppe l’impression de la liste complète des symboles }

$offlisting

{stoppe le echo print d’un fichier input}

option limcol = 0;

{stoppe l’impression de la colonne listing}

option limrow = 0;

{stoppe l’impression du listing équation}

{Contribution de Rob Dellink}

9. Lorsque vous fixez la valeur d’une variable ([Link] = …), n’oubliez pas de la libérer à nouveau:

[Link] = -inf;

[Link] = inf;

{Contribution de Rob Dellink}

10. Lorsqu’on débogue un modèle, si on tape $exit sur une ligne, alors toutes les lignes en dessous
de ligne où $exit est tapé sont ignorées pendant les phases de compilation et d’exécution du modèle

{Contribution de Rob Dellink}

11. En cas d’infeasibilities, il ya (au moins) trios choses que vous pouvez faire pour y pallier:
[Link] toutes les bornes supérieures (.up) et inferieures (.lo) et fixations (.fx) encombrantes du code;
2.Vérifier les valeurs de départ assignées aux variables et leur donner de meilleures valeurs;
[Link] les égalités en inégalités (il est toujours bon d’utiliser des inégalités au lieu d’égalités).

{Contribution de Judit Szonyi et Rob Dellink}

12. Apprendre à utiliser la notation vector au lieu de scalar; cela rend les modèles encore plus
compact:

SETS J Sectors /1,2/;

Page 78 sur 86 M. Hervé GUENE, Ingénieur Statisticien-Economiste; E-mail: hguene@[Link]
Support de Cours GAMS 2009

VARIABLES Y(J) Production;

Au lieu de:

VARIABLES Y1 Producer 1

Y2 Producer 2;

Pour deux secteurs, la différence n’est pas nette. Mais imaginons qu’on ait 60 secteurs ou plus. Il
est encore plus facile d’utiliser la notation vector dès le début, plutôt que scalar, car plus le nombre
d’écritures du modèle est petit, moins on a à écrire si l’on veut l’agrandir.

{Contribution de Rob Dellink}

13. On peut utiliser des identifiants d’ensembles dans une instruction put:

set label de l’élément: <nom de l’ensemble>.tl (très utile dans les loop)
set texte de l’élément associé: <nom de l’ensemble>.te(index)
set texte associé: t: <nom de l’ensemble>.ts

Exemple:

file out /"[Link]"/; put out;

set i commentaire sur l’ensemble i/i1 premier element, i2 second element, i3/;

put [Link] /;

loop(i, put [Link], [Link](i) /);

le fichier qui en résulte ([Link]) ressemble à:

Commentaire sur l’ensemble i

i1 premier élément

i2 second élément

i3 I3

{Contribution de Rob Dellink}

14. Pour avoir un bon aperçu des impacts des valeurs d’un paramètre sur les résultats du modèle (i.e.
une analyse de sensitivité), construire un loop de solves pour des valeurs différentes du paramètre; par
exemple:

SET chaine /iter0*iter10/;

Page 79 sur 86 M. Hervé GUENE, Ingénieur Statisticien-Economiste; E-mail: hguene@[Link]

Support de Cours GAMS 2009

SCALAR

Compte

faible /0.1/

forte /0.9/;

PARAMETER VALEURX (CHAINE) Paramètre sujet à l’analyse de sensitivité

RESULTS(CHAINE) résultats du Modèle;

< … insérer les autres déclarations du modele etcetera ici … >

LOOP(CHAINE,

COMPTE = (ORD(CHAINE)-1)/(CARD(CHAINE)-1);

XVALUE(CHAINE) = (1-COMPTE)*FAIBLE + COMPTE*FORTE;

SOLVE <nom du modèle> USING <solver> MAXIMISING <optimand>;

RESULTS(CHAINE) = …;

); DISPLAY RESULTS;

{Contribution de Rob Dellink}

15. Comment obtenir des informations périodiques sur l’état d’avancement du travail et les valeurs
des paramètres/variables en temps réel sur votre écran pendant que GAMS exécute un modèle? Si vous
exécutez plusieurs simulations (ce qui signifie que vous faites un loop de plusieurs solves) vous pouvez:

display "%[Link]%/";

file screen /'con'/;

LOOP(t,

< … insérez vos commandes ici … >

putclose screen la valeur actuelle de l’indice t est ',[Link]/;

);

NB: ceci ne fonctionne pas correctement sur une plateforme Unix ou Windows NT.

Si vous utilisez le GAMS-IDE, rassurez vous que la fenêtre DOS est visible (en faisant d’abord
File / Options / Execute et choisir ‘Normal’ pour DOS window).

{Contribution de Rob Dellink}

Page 80 sur 86 M. Hervé GUENE, Ingénieur Statisticien-Economiste; E-mail: hguene@[Link]

Support de Cours GAMS 2009

16. Si vous voulez présenter graphiquement les résultats d’un modèle tout juste après l’avoir résolu,
jetez un coup d’œil sur l’utilitaire gnuplot qui est disponible sur internet (on peut y accéder à partir de la
page d’accueil de GAMS) ; vous aurez à installer séparément cet utilitaire libre.

{Contribution de Rob Dellink}

17. Bon nombre d’utilisateurs de GAMS connaissent la commande $include pour insérer des
morceaux de code GAMS, mais si l’on veut mettre un paramètre dans le fichier à inclure, utiliser la
commande $batinclude.

$BATINCLUDE [Link] "versionX"

Et [Link] ressemblera à:

$CALL 'MD %1'

FILE results /"%1\[Link]"/;

SET Version /%1/;

Pendant l’exécution du programme, "%1" sera automatiquement substitué par la "versionX". Dans
cet exemple un sous-répertoire ‘versionx’ sera crée et l’output en direction du fichier results sera
écrit dans le fichier ‘[Link]’ de ce sous-répertoire; finalement un ensemble contenant un seul
élément "versionx" est déclaré.

{Contribution de Rob Dellink}

18. Si vous avez un model dont le calcul prend beaucoup de temps, alors songez à utiliser les
commandes save et restart. C’est très pratique quand on a résolu le modèle et qu’on cherche à bien
organiser l’output. Vous pouvez exécuter votre modèle, ensuite enregistrer (commande save) les fichiers
de travail puis relancer (commande restart) des simulations à partir de ces fichiers de travaux pour
manipuler les résultats plus facilement. Par exemple, si vous avez un fichier GAMS (nommé,
[Link]) dans lequel les données sont lues, les variables et équations sont spécifiées et votre
modèle est résolu, alors enregistrer les fichiers sous le nom model1. Pour ce faire, taper dans la ligne de
commande s=model1 puis entrée pendant que le fichier [Link] est ouvert. Ensuite, écrire le
code de manipulation du fichier output dans un autre fichier (disons, [Link]), en utilisant l’option
restart. Pour effectuer tout type de changement dans [Link], on n’a plus besoin de résoudre le
modèle à nouveau, il suffit d’inclure les fichiers de travail. Ceci peut être enregistré plusieurs fois (surtout
pour les grands modèles) et l’on peut simuler tout ce qu’on veut. Ces commandes de save et restart
peuvent être aussi utilisées dans d’autres circonstances, telles que l’enregistrement des résultats d’un
scenario de base, et l’enregistrement de plusieurs autres scénarios distincts dans d’autres fichiers output,
pourvu qu’à chaque fois on tape dans la ligne de commande r=model1 puis entrée pendant que le
fichier scénario_x.gms est ouvert; pour chaque fichier scénario_x.gms relatif à un scénario x
précis. Le code de l’exemple ci dessus ressemble à quelque chose du genre:

Page 81 sur 86 M. Hervé GUENE, Ingénieur Statisticien-Economiste; E-mail: hguene@[Link]

Support de Cours GAMS 2009

GAMS partie1 s=model1

GAMS partie2 r=model1

{Contribution de Rob Dellink}

19. Depuis la version GAMS 2.50, on peut directement écrire dans un fichier Excel via les routines
XLimport, XLexport et XLdump; voir [Link] pour de plus
amples détails. Alternativement, l’on peut utiliser la commande put pour créer manuellement un fichier
output (voir le GAMS user guide pour de plus amples détails).

{contribution de Erik Schmieman et Rob Dellink}

20. Quand on utilise les ensembles de données multidimensionnels dont un nombre restreints
d’éléments sont autorisés, on peut utiliser les ensembles dynamiques (dynamic set) ou cartographier les
ensembles (set mapping) pour limiter les éléments de l’ensemble. Le code suivant est un programme
GAMS complet qui présente le dynamic sets and mapping.

$title une simple illustration de l’utilisation des ensembles dynamiques

$ontext
Ce petit exemple illustre comment on peut limiter le nombre d’éléments utilisés
comme paramètres en utilisant les ‘dynamic sets or set mapping’.
Dans ce cas ci les deux procédures produisent le même résultats.
L’exemple montre aussi comment les dynamic sets peuvent être utilises.

$offtext
sets
x /x1*x3/
y /y1*y4/
xx(x)
yy(y)
xy(x,y);
parameter
a(x,y) la base à partir de laquelle on récupère les éléments non nuls;
*Supposons qu’on connaisse les valeurs de a
a(x,y) = 1;
a('x1',y) = 0;
a('x2','y2') = 0;
a('x2','y3') = 0;
a('x2','y4') = 0;
a('x3','y2') = 0;
*Determination des ensembles dynamiques
xx(x) = yes$(sum(y, a(x,y)) ne 0);
yy(y) = yes$(sum(x, a(x,y)) ne 0);
xy(x,y) = yes$(a(x,y) ne 0);
* Le même ensemble dont les seuls éléments non nuls seront récupérés à travers
*le mapping
set yx(x,y) /x2.y1, x3.(y1,y3*y4)/;
display x,y,a,xx,yy,xy,yx;
parameter
b(x,y) l’ensemble entier y compris les zéros de a
c(x,y) paramètre b corrigé des éléments non-existants dans x
d(x,y) paramètre b corrigé des éléments non-existants dans y
Page 82 sur 86 M. Hervé GUENE, Ingénieur Statisticien-Economiste; E-mail: hguene@[Link]
Support de Cours GAMS 2009

e(x,y) paramètre b corrigé des éléments non-existants dans x et y

f(x,y) paramètre b seulmt pour les élts existants basé sur l’ensble dynamique xy
g(x,y) paramètre b seulement pour les élts existants basé sur l’ensble mappé yx
h(*,*) paramètre b utilisant l’ensemble dynamique xy
sumx(y) paramètre h sommé sur x;
b(x,y) = 1;
c(xx,y) = 1;
d(x,yy) = 1;
e(xx,yy) = 1;
f(x,y)$xy(x,y) = 1;
g(x,y)$yx(x,y) = 1;
h(xy) = 1;
sumx(y) = sum(x, h(x,y));
display b,c,d,e,f,g,h,sumx;

{Contribution de Rob Dellink et Erik Schmieman}

21. Si l’on veut écrire une équation dans laquelle on divise le membre de droite par une autre
variable, on peut rencontrer des ‘division by zero’ errors. Par exemple, pour l’équation

vv1(x,y).. v1(x,y) =e= a(x,y);

vv2(x,y)$(a(x,y) ne 0).. v2(x,y) =e= rhs/v1(x,y);

Notons que la deuxième équation peut être seulement conditionnée par le paramètre a et non la
variable v1.

Dans ce cas ci, l’on peut résoudre cette erreur comme suit:

vv1(x,y).. v1(x,y) =e= a(x,y);

vv2(x,y)$(a(x,y) ne 0).. v2(x,y)*v1(x,y) =e= rhs;

{Contribution de Rob Dellink}

22. Si l’on veut construire un modèle multisectoriel d’Equilibre General Calculable, il faut penser à
utiliser le sous-système MPSGE de GAMS. Pour de plus amples détails consulter la page d’accueil de
GAMS, ou la page du ‘gourou de MPSGE’ Tom Rutherford, ou contacter Rob Dellink.

{Contribution de Rob Dellink}

23. Un utilisateur de GAMS n’a pas correctement spécifié l’équation du capital le modèle néo-classique de
croissance comme suit :

Page 83 sur 86 M. Hervé GUENE, Ingénieur Statisticien-Economiste; E-mail: hguene@[Link]

Support de Cours GAMS 2009

Il a écrit K(t) =E= ((K0$ord(t)=1) + K(t-1)*(1-delta) + I(t);

au lieu de K(t) =E= (K0$(ord(t)=1) + K(t-1)*(1-delta) + I(t);

Quelle est la différence entre ces deux scripts? L’impact est énorme. J’ai été surpris que la
première spécification n’ait pas donné un message d’erreur. La leçon à apprendre: faire toujours
attention aux parenthèses. Je les aime parce qu’elles obligent le modélisateur à penser de manière
précise à ce qu’il veut modéliser réellement.

{Contribution de Rob Dellink}

24. Lorsqu’on modélise une équation contenant des opérateurs avance et retard par exemple
EQ1(t).. A(t+1) =E= A(t)+B(t);, et qu’on ne restreint pas cette équation, on calculera aussi
A(t+1) pour la dernière période t. Dès lors, la période suivant la dernière t n’est plus dans l’horizon du
modèle, et sa valeur ne nous intéresse guère. Pour donner donc la condition terminale de cette équation,
pour ne pas qu’elle nous calcule les valeurs au-delà de l’horizon temporel, il suffit de taper:
EQ1(t)$(ord(t) le card(t)-1).. A(t+1) =E= A(t)+B(t);

Utiliser la contrainte (t)$(ord(t) le card(t)-1) à la fois dans la définition6 et la déclaration de

l’équation! Cette contrainte signifie, pour t tel que l’ordre de t est inférieur ou égal à (cardinal de t)-1.

Ce type de notation est pertinent, surtout lorsque le modèle contient beaucoup d’item (ensembles,
equations, parameters,…) et les équations sont difficiles à écrire.

{Contribution de Muhammad Al-Salamah}

[Link] APPROXIMATIONS FOR MAX(X,0) AND MIN(X,0)

Q: Connaissez-vous une approximation de max(x,0), et min(x,0)?

Utiliser l’approximation

(sqrt( sqr(x) + sqr(epsilon) ) + x ) / 2 pour max(x,0).

Ici sqrt est la racine carrée et sqr est le carré.

L’erreur err(x) dans l’approximation ci-dessus est maximisée à 0 (le point de non différentiabilité), où
err(0) = epsilon. Comme x va de -∞ à +∞, alors, err(x) devient 0. On peut aussi reduire l’erreur maximale
à epsilon/2 en utilisant l’approximation ci-dessous. Elle fournit une meilleure approximation même si
l’égalité n’est plus juste au voisinage du point.

( sqrt( sqr(x) + sqr(epsilon) ) + x - epsilon ) / 2

Comme min(x,0) = -max(-x,0), on peut utiliser l’approximation ci-dessus pour approximer min(x,0).
Epsilon est une petite constante positive.

6
En rappel, avec GAMS, il faut d’abord définir une équation, i-e lui donner un nom avant de la déclarer, i-e transcrire son expression
mathématique en langage GAMS. Voir exemple1 page 10
Page 84 sur 86 M. Hervé GUENE, Ingénieur Statisticien-Economiste; E-mail: hguene@[Link]
Support de Cours GAMS 2009

Modèle GAMS et codes d'état du Solver

Code du statut MODÈLE DESCRIPTION

1 Optimal
2 Localement optimale
3 Illimité
4 Irréalisables
5 Localement irréalisables
6 Intermédiaire irréalisables
7 Intermédiaire non optimale
8 Solution Entier
9 Intermédiaire non entier
10 Entier irréalisables
11 Problèmes de licences - Pas de solution
12 Erreur inconnue
13 Erreur No Solution
14 Aucune solution retournée
15 Résolu uniques
16 Résolu
17 Résolu Singulier
18 Unbounded - Pas de solution
19 Irréalisables - Pas de solution

Code du statut SOLVER DESCRIPTION

1 Achèvement normale
2 Interruption d'itération
3 Interruption des ressources
4 Terminé par Solveur
5 Limite d'erreur d'évaluation
6 Problèmes de capacité
7 Problèmes de licence
8 Interruption utilisateur
9 Échec Erreur d'installation
10 Le non Solver erreur
11 Erreur Erreur interne Solver
12 Résoudre traitement Skipped
13 Défaillance du système d'erreur

Page 85 sur 86 M. Hervé GUENE, Ingénieur Statisticien-Economiste; E-mail: hguene@[Link]

Support de Cours GAMS 2009

BIBLIOGRAPHIE

Arrow, K. J., et al. “Capital-Labor Substitution and Economic Efficiency.” Review of Economics and Statistics
63(1961): 225-250.

Berndt, E., and D. Wood. “Technology, prices and the Derived Demand for Energy.” Review of Economics and
Statistics 57(1975): 655-676.

Chung, J. “On the Estimation of Factor Substitution in the Translog Model.” Review of Economics and Statistics 64,
no. 3(1987): 409-417.

Dhrymes, P., and P. Zarembka. “Elasticities of Substitution for Two-Digit Manufacturing Industries: A
Correction.” Review of Economics and Statistics 52, no. 1(1970): 115-117.

Erwin Kalvelagen new special functions in GAMS (2006)

Field, B. C., and C. Grebenstein. “Capital-Energy Substitution in U.S. Manufacturing.” Review of Economics and
Statistics 62(1980): 207-212.

Fishelson, G. “The Elasticity of Factor Substitution in Cross-Section Production Functions.” Review of Economics
and Statistics 61, no. 3(1979): 432-436.

Griliches, Z. (1967) Production Functions in Manufacturing: Some Preliminary Results, in The Theory of Empirical
Analysis of Production, ed. M. Brown. New York, National Bureau of Economic Research and
Columbia University Press.

Hazilla, M., and R. Kopp. “Industrial Energy Substitution: Econometric Analysis of U.S. Data, 1958-1974.” Final
Report. Electric Power Research Institute, Palo Alto, CA, 1984.

Richard E. Rosenthal GAMS — A User’s Guide (2008)

Rob Dellink Juan-Carlos Altamirano-Cabrera, Kelly de Bruin, Ekko van Ierland, Carol Phua, Arjan Ruijs,
Erik Schmieman, Judit Szõnyi, Frank Vöhringer and Xueqin Zhu GAMS for
environmental-economic modelling (2009)

Rutherford Thomas and Laurent Cretegny(2004) Worked exammples with dynamic optimization:
Analytic and Numeric method

Zarembka, P. “On the Empirical Relevance of the CES Production Function.” Review of Economics and Statistics
52, no. 1(1970): 47-53.

Page 86 sur 86 M. Hervé GUENE, Ingénieur Statisticien-Economiste; E-mail: hguene@[Link]