GAMS is an acronym that stands for General Algebraic Modeling
System, a high level Computer programming language for modeling and
solving optimization problems – linear, nonlinear, and mixed integer.
It is especially useful for handling large, complex, “one of a kind”
problems, which may require many revisions of the model to get the
formulation right. GAMS enables you to model problems in a natural way,
so that you can easily change your formulation – even convert a model
from linear to nonlinear with little trouble.
GAMS was developed primarily by optimization experts Dr. Anthony
Brooke and Dr. Alexander Meeraus, formerly of The World Bank. Their
goal was to create a powerful but easy-to-use computer programming
language that would greatly simplify the modeler’s task of formulating
and solving complex optimization problems. Recogn izing the excellence
of GAMS, the Computer Science Technical Section of the Operations
Research Society of America awarded its 1987 prize to The World Bank’s
GAMS development team. Previous versions of GAMS are widely used by
academic institutions and in dustry around the world.
Documentation that accompanies the CD ROM containing the software
explains in detail with examples how to make best use of the several
algorithms available. Some of the well known codes are MINOS, CONOPT
(two versions), DICOPT (for mixed integer problems), OLS (an IBM code),
and MILES (for systems of nonlinear equations). CACHE provides a code
for PCs running under DOS, Windows 3.1, Windows 95, and Windows NT.
GAMS is designed to use machine resources in a flexible way, and
acquires memory as needed to store your data structures. Therefore, it
is not possible to specify precise limits for “what will fit”. There
are some fixed limits built into GAMS and the solvers, but they are
large and generally will not in terfere with the user.
GAMS software comes with a 286 page manual GAMS: A User’s Guide,
written by the principal authors of GAMS, along with GAMS – The Solver
Manuals that provides full documentation of the GAMS programming
language and solvers: 18 chapters, 6 appendices, glossary,
bibliography, and index.
Also included in the manual is an in-depth but easy-to-follow
tutorial, which covers the major features of GAMS, using examples from
an actual model that comes with the software.
General Features and Advantages of GAMS
GAMS offers many advantages over conventional computer optimization
systems. It enables you to:
- Describe your model to a computer nearly as easily as
you can describe it to a colleague.
In GAMS, you formulate your model using concise algebraic statements,
so your model is easy to read for computers and humans alike. This
feature makes GAMS a “natural” programming language – many of the
advantages described below derive from this key feature.
- Create whole sets of closely related constrains in one
Most other optimization software requires you to enter each individual
constraint explicitly into your model – which means you do a lot of
calculations and data entry yourself. In GAMS, however, the power of
algebraic expression relieves you from this task – GAMS automatically
generates each constraint equation, based on your input of general
algebraic formulae and specific data values. This significantly cuts
development time and reduces the potential for errors in data entry and
transformations. (NOTE: GAMS lets you make any exceptions in cases
where such generality isn’t desired).
- Enter data only once, in their most elemental
You need only enter your most basic data, in list and table form (i.e.
the way data most often come to you), and specify data transformations
algebraically. Not only does this save time and reduce the possibility
of making mistakes, but it allows any user of the model to readily
inspect all transformations made in constructing the model and in
- Reuse statements in your model when new instances of
the same or related problem arise.
This is another instance of how the use of general algebraic
descriptions saves you time and effort. You can enter new data into
your model without having to change the algebra. GAMS simply uses the
new data values to compute the new set of related constraints – an
especially useful feature if you are constantly updating or otherwise
changing data in your model.
- Build models independent of the
solution algorithms of specific solvers.
In GAMS, you formulate linear, nonlinear, and integer problems
following the same format whatever the solution algorithm. You can use
this feature to great advantage – for example, to develop and test
alternate versions of a model within one document: one formulation
might be linear, another nonlinear.
- Solve your model on different types of machines without
having to change your formulation.
GAMS models are fully portable from one computer environment to
another, and an entire model is contained in just a single document. A
model developed on a PC running DOS, for instance, can later be solved
on a VAX running the VMS operating system, without any need for
reformulation (assuming, of course, that GAMS is loaded onto both
- Create self-documenting models.
With GAMS, you develop and document your model simultaneously, because
GAMS allows you to include explanatory text as party of the definition
of any symbol or equation. So your documentation is accurate and
up-to-date, and it resides in the model itself. Furthermore, GAMS
automatically incorporates your comments into your output report,
making the results easy to understand for anyone who might need to
inspect your model.
- Avoid whole classes of errors common in many other
computer optimization systems.
Many of the typical errors made with conventional optimization
programming languages (e.g. FORTRAN) involve concepts that do not even
exist in GAMS. A GAMS user never has to worry about making errors in
things like address calculations, storage assignments, subroutine
linkages, and input-output and flow control. GAMS handles all these in
the background, completely out of the modeler’s way.
- Quickly pinpoint errors in your model – where they are,
and of what type – before a solution has been
As GAMS compiles your model, it searches exhaustively for errors. The
software “knows” optimization logic and mathematical programming. It
checks for errors in syntax, numerical operations (e.g. division by
zero), and mathematical consistency (e.g. a model designated as linear
but contains nonlinearities). If errors are detected, GAMS does not try
to solve the model. Instead, it tells you where the errors occur in
your model and what sort they are. You can then easily correct your
model and avoid wasting time and resources on a useless solution
- Perform sensitivity analysis on your model with
In GAMS, you can easily program your model to solve for different
values of an element and generate an output report listing the solution
characteristics for each case.
- Implement large-scale models
GAMS includes advanced features to handle large models. For example, it
allows you to: screen out unnecessary rows and columns to keep the size
of the problem within the range of solvability; build complex
summations and products, which can then be used in equations or
customized reports; and issue warning messages upon context-specific
- Construct dynamic model concisely.
Several built-in features of GAMS allow you to handle dynamic models
with a minimum of programming complexity. Problems involving time
sequences, lags, leads, and the treatment of temporal endpoints can be
concisely modeled in GAMS.
- Concentrate on the art of modeling rather than on the
cumbersome engineering requirements of a matrix generator or
By simplifying the task of computer formulation of your model, GAMS
frees you to focus on the conceptual aspects of modeling. You increase
your productivity – time spent on conceptualizing your problem, running
your models, and analyzing the results – and decrease the “downtime”
spent on making your model machine-readable.
The basic GAMS system is file-oriented, and no special editor or
graphical input and output routines exist. Rather than burden the user
with having to learn yet another set of editing commands, GAMS offers
an open architecture in which each user can use his word processor or
editor of choice. This basic user interface facilitates the integration
of GAMS with a variety of existing and future user environments.
These problems are modeled as linear, nonlinear and mixed-integer
optimization problems. This case study describes in detail the
formulation and solution of a total of 22 optimization problems that
cover the different areas cited above.
The new version of GAMS that is available on the CD-ROM can solve
problems with the following size limits: 300 rows (constraints), 300
columns (variables), 50 binary variables, 2,000 non zero elements
(1,000 nonlinear non zero elements).
The case study Volume 6 is supplied with the following:
- Binder with a brief introduction to GAMS, and description of the 22
- CD-ROM with new GAMS version, and GAMS input files for the 22
- GAMS User’s Guide
- GAMS Solver Manual
This new version of GAMS is now available from the CACHE office. The
cost for Process Design Case Study No. 6, along with GAMS: A User’s
Guide, and GAMS – The Solver Manuals, and a CD-ROM is $110 per CACHE
supporting departments, and $150 per non-CACHE supporting