GAMS

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
    statement.

    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
    form.

    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
    reporting.

  • 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
    machines).

  • 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
    attempted.

    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
    attempt.

  • Perform sensitivity analysis on your model with
    ease.

    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
    efficiently.

    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
    data edits.

  • 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
    conversational solver.

    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.

 

Portability

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
    application problems.
  • CD-ROM with new GAMS version, and GAMS input files for the 22
    problems
  • GAMS User’s Guide
  • GAMS Solver Manual

 

Prices

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
departments.