Introduction

In this chapter we explicitly cover only parameter manipulation, including all aspects of data handling. Much of this material is relevant elsewhere (e.g. to sets), but for specifics related to assignment to sets, to conditions, and to assignments within flow control constructs such as the loop statement, see chapters Dynamic Sets, Conditional Expressions, Assignments and Equations and Programming Flow Control Features respectively.

Once initialized, data often requires manipulation in order to bring it into a form most suitable for use in a model or an application. The assignment statement is the way to do this. All the possible components of the assignment statement except conditions are introduced and discussed in this chapter.

The Assignment Statement

The assignment statement is the fundamental data manipulation statement in GAMS. It may be used to define or alter values associated with sets, parameters, variables or equations.

A simple assignment is written in the style associated with many other computer languages. GAMS uses the traditional symbols for addition (+), subtraction (-), multiplication (*) and division (/). We will use them in the examples that follow, and give more details in section Expressions.

Scalar Assignments

Consider the following artificial sequence:

scalar x / 1.5 /;
x = 1.2;
x = x + 2;

The scalar x is initialized to be 1.5. The second statement changes the value to 1.2, and the third changes it to 3.2. The second and third statements are assignments: each replaces the current value of x with a new one.

Note that the same symbol can be used on the left and right of the = sign. The new value is not available until the calculation is complete, and the operation gives the expected result.

Note

An assignment cannot start with a reserved word. A semicolon is therefore required as a delimiter before all assignments.

Note that extended range identifiers (e.g. INF) and acronyms may also be used in assignment statements. For specific details, see sections Extended Range Arithmetic and Acronym Usage respectively.

Indexed Assignments

The GAMS syntax for performing indexed assignments is extremely powerful. This operation offers what may be thought of as simultaneous or parallel assignments and provides a concise way of specifying large amounts of data. Consider the mathematical statement \( DJ_d = 2.75 \cdot DA_d \) for all elements of \(d\). This means that for every member of the set \(d\), a value is assigned to \(DJ\). This can be written in GAMS as follows:

dj(d) = 2.75*da(d) ;

This assignment is known technically as an indexed assignment and set d as the controlling index or controlling set.

Attention

The index set(s) on the left hand side of an indexed assignment are referred to synonymously as the controlling indices, controlling sets, or controlling domain of the assignment.

The extension to two or more controlling indices should be obvious. There will be an assignment made for each label combination that can be constructed using the indices inside the parentheses. Consider the following example of an assignment to all 100 data elements of the parameter a.

sets  row            / r-1*r-10 /
      col            / c-1*c-10 /
      sro(row)       / r-7*r-10 / ;
parameters  r(row)   /r-1*r-7 4, r-8*r-10 5/
            c(col)   /c-1*c-5 3, c-6*c-10 2/;
parameters  a(row,col);
a(row,col)  =  13.2 + r(row)*c(col)  ;

The calculation in the last statement is carried out for each of the 100 unique two-label combinations that can be formed from the elements of row and col. An explicit formulation of the first of these assignments follows:

a('r-1','c-1') = 13.2 + r('r-1')*c('c-1');

Note that for indexed assignments a copy of the symbols on the right hand side is installed before the assignment is carried out. That means it does not work "in-place" or recursively. Consider the following example where we compute the first ten Fibonacci numbers and store them in parameter f using a loop. The example also illustrates how such a recursive calculation does not work with a parallel assignment statement for parameter g.

set i / i1*i10 /
parameter
    f(i) / i1 1 /
    g(i) / i1 1 /;
loop(i$(ord(i)>=2),
  f(i) = f(i-2) + f(i-1);
);
g(i)$(ord(i)>=2) = g(i-2) + g(i-1)
display f,g;

The display statement results in the following output.

----      9 PARAMETER f

i1   1.000,    i2   1.000,    i3   2.000,    i4   3.000,    i5   5.000
i6   8.000,    i7  13.000,    i8  21.000,    i9  34.000,    i10 55.000


----      9 PARAMETER g

i1 1.000,    i2 1.000,    i3 1.000

Restricting the Domain in Assignments

Sometimes it is necessary to make assignments over selected elements of a set instead of over the entire domain. There are several ways to accomplish this: using explicit labels, subsets, conditionals and tuples.

Restricting the Domain: Explicit Labels

The strongest restriction of the domain is assigning a value to just one element. Labels may be used explicitly in the context of assignments to accomplish this. The following example illustrates:

a('r-7','c-4') = -2.36 ;

This statement assigns a constant value to just one element of the parameter a. All other elements of a remain unchanged. Labels must be quoted when used in this way.

Restricting the Domain: Subsets

In general, wherever a set name may occur in an indexed assignment, a subset may be used instead.

Consider the following example:

a(sro,'col-10') = 2.44 -33*r(sro) ;

Since the set sro was declared as a subset of the set row, we can use sro as a controlling index in the assignment above to make the assignment only for the elements of sro.

Restricting the Domain: Conditionals

Conditional assignments are discussed in detail in section Conditional Assignments in chapter Conditional Expressions, Assignments and Equations. For details on the types of logical conditions, see section Logical Conditions. Here we present a simple example to illustrate:

a(row,col)$[a(row,col) >= 100] = INF ;

This assignment has the following effect: all elements of the parameter a whose value was at least 100 are assigned the value INF, while all other elements of a remain unchanged.

Restricting the Domain: Tuples

Tuples or multi-dimensional sets are introduced in section Many-to-Many Mapping. In this simple example we show how they may be used to restrict the domain. The example builds on the first example in this section. We repeat the whole code here for clarity.

sets  row            / r-1*r-10 /
      col            / c-1*c-10 /
      sro(row)       / r-7*r-10 / ;
set tuple(row,col)   /r-1.c-1, r-1.c-10, r-10.c-1, r-10.c-10/;
parameters  r(row)   /r-1*r-7 4, r-8*r-10 5/
            c(col)   /c-1*c-5 3, c-6*c-10 2/;
parameters  a(row,col), b(row,row);
a(row,col)  =  13.2 + r(row)*c(col)  ;
a(tuple(row,col)) = 7 + r(row)*c(col)  ;
a(tuple) = 0.25 * a(tuple)  ;

Note that we have introduced the new set tuple. It is two-dimensional and contains just four elements. As before, the parameter a is first assigned values for all its 100 elements. We then change some of these values using the set tuple as domain. The values of the elements of the parameter a that are not elements of the set tuple remain unchanged.

For a more elaborate example involving tuples, see section Filtering Sets in Assignments.

Issues with Controlling Indices

Attention

The number of controlling indices on the left of the = sign should be at least as large as the number of indices on the right. There should be no index on the right-hand side of the assignment that is not present on the left unless it is operated on by an indexed operator. For more on indexed operators, see section Indexed Operations.

Consider the following statement:

a(row,'col-2') = 22 - c(col) ;

GAMS will flag this statement as an error since col is an index on the right-hand side of the equation but not on the left.

Note that there would be no error here if col were a singleton set. Since there is only one element in a singleton set, the intent and behavior is well-defined even when col is not under control.

Attention

Each set is counted only once to determine the number of controlling indices. If the intent is for a set to appear independently more than once within the controlling domain, the second and subsequent occurrences of the set should be aliases of the original set, so that the number of controlling indices is equal to the number of indices. For details on aliases, see section The Alias Statement: Multiple Names for a Set.

Consider the following statement as an illustration:

b(row,row) = 7.7 - r(row) ;

This statement has only one controlling index, namely row. One element (on the diagonal of b) is assigned for each element of row, for a total of 10 assigned values. None of the off-diagonal elements of b will be changed!

If the intent is to assign values to each element of b, this can be done by introducing an alias rowp for row and using this alias in the second index position. There will then be two controlling indices and GAMS will make assignments over all 100 values of the full Cartesian product. The following example illustrates this method:

alias(row,rowp) ;
b(row,rowp) = 7.7 - (r(row) + r(rowp))/2 ;

Expressions

An expression is an arbitrarily complicated specification for a calculation, with parentheses nested as needed for clarity and intent. In this section the discussion of parameter assignments will continue by showing in more detail the expressions that may be used on the right of the = sign. We will cover standard arithmetic operations and indexed operations here, and functions and extended range arithmetic in the next two sections.

Standard Arithmetic Operations

The standard arithmetic symbols and operations and their order of precedence are given in Table 1. Note that 1 denotes the highest order of precedence and 3 denotes the lowest order of precedence. Parentheses can be used to override the default precedence order in the usual way. Operators (including exponentiation) on the same level are evaluated from left to right.

Table 1: Standard Arithmetic Operations

Note that the full GAMS operator precedence hierarchy also includes logical operators; it is given in section Mixed Logical Conditions. Note further that the symbols for addition, subtraction and multiplication have a different meaning if they are used in the context of sets. For details see sections Set Operations and Lag and Lead Operators.

Attention

The operation x**y is equivalent to the function rPower(x,y) and is calculated internally as \(e^{y \times \log(x)}\). This operation is not defined if \(x\) is negative; an error will result in this case. If the possibility of negative values for \(x\) is to be admitted and the exponent is known to be an integer, then the function power(x,n) may be used.

Like many GAMS intrinsic functions, the operation x**y is not defined for all possible input values. When evaluating nonlinear functions and operators GAMS guards against evaluating at or very near singular points and in such cases signals an error or returns an appropriate function value.

Note

As usual, operations within parentheses or brackets are evaluated before other numerical calculations, where the innermost parentheses are resolved first. Any of the pairs (), [] and {} are allowed.

Consider for example:

x = 5 + 4*3**2;

For clarity, this could have been written as follows:

x = 5 + (4*[3**2]) ;

In both cases the result is 41.

Note

It is often better to use parentheses than to rely on the order of precedence of operators, since this prevents errors and clarifies intentions.

Note that expressions may be freely continued over many lines: an end of line is permissible at any point where a blank may be used. Blanks may be used for readability around identifiers, parentheses and operation symbols. Blanks are not allowed within identifiers or numbers, and are significant inside the quotes used to delimit labels.

Indexed Operations

In addition to the simple operations in Table 1, GAMS also provides the following six indexed operations.

Table 2: Indexed Operations

These six operations are performed over one or more controlling indices. The syntax in GAMS for these operations is:

indexed_op( (index_list), expression);

Indexed_op is one of the four keywords for indexed operations, index_list is the list of the controlling indices and expression is the expression to be evaluated. If there is only one controlling index, the parentheses around it may be removed. Consider the following simple example adapted from [ANDEAN]:

sets i   plants  / cartagena, callao, moron /
     m   product / nitr-acid, sulf-acid, amm-sulf /;

parameter capacity(i,m) capacity in tons per day
          totcap(m)     total capacity by process ;

totcap(m) = sum(i, capacity(i,m));

The index over which the summation is done, i, is separated from the reserved word sum by a left parenthesis and from the data term capacity(i,m) by a comma. The set i is called the controlling index for this operation. The scope of the control is the pair of parentheses () that start immediately after the sum. Note that using normal mathematical representation the last line could be written as: \(totC_m = \sum_i C_{im}\).

It is also possible to sum simultaneously over the domain of two or more sets as in the first assignment that follows. The second assignment demonstrates the use of a less trivial expression than an identifier within the indexed operation.

count = sum((i,j), a(i,j)) ;
emp = sum(t, l(t)*m(t)) ;

The equivalent mathematical forms are:

\[ count = \sum_i\sum_j A_{ij} \quad \textrm{and} \quad emp = \sum_t L_t M_t. \]

Note that the following alternative notation may be used for the first assignment above:

count = sum(i, sum(j, a(i,j)));

In the context of sets the sum operator may be used to compute the number of elements in a set and for projections. For details see section Projection and Aggregation of Sets.

The smin and smax operations are used to find the largest and smallest values over the domain of the index set or sets. The index for the smin and smax operators is specified in the same manner as in the index for the sum operator. In the following example we want to find the largest capacity:

lrgunit = smax((i,m),capacity(i,m));

Attention

The indexed operations smin and smax may be used in equation definitions only if the corresponding model is of type DNLP. For more on GAMS model types, see GAMS Model Types.

Note

• In the context of assignment statements, the attributes of variables and equations (e.g. x.up(i,j)) may be used in indexed operations just as scalars and parameters are used. For more on variable and equations attributes, see sections Variable Attributes and Equation Attributes respectively.
• In the context of equation definitions, scalars, parameters and variables may appear freely in indexed operations. For more on equation definitions, see section Defining Equations.

Sometimes it is necessary to restrict the domain of indexed operations. This may be done with the same techniques as in indexed assignments, see section Restricting the Domain in Assignments for details. See also section Conditional Indexed Operations for more details on conditions in the context of indexed operations.

We now turn to two additional capabilities that are available in GAMS to add power and flexibility to expression calculations: functions and extended range arithmetic.

Functions

Functions play an important role in the GAMS language, especially for nonlinear models. Like other programming languages, GAMS provides a number of built-in or intrinsic functions. GAMS is used in an extremely diverse set of application areas and this creates frequent requests for the addition of new and quite sophisticated or specialized functions. There is a trade-off between satisfying these requests and avoiding a complexity not needed by most users. The GAMS Function Library Facility provides the means for managing this trade-off, see subsection Extrinsic Functions below.

Intrinsic Functions

GAMS provides many functions, ranging from commonly used standard functions like exponentiation, logarithms, and trigonometric functions to utility functions for controlling and querying the running GAMS job or process. The complete list of available functions is given in the following tables: Mathematical Functions, String Manipulation Functions, Logical Functions, Time and Calendar Functions, and GAMS Utility and Performance Functions. For details specific to using these functions in equations, see the section on Expressions in Equation Definitions.

Some of the tables that follow contain an endogenous classification column "End. Classif." that specifies in which models the function may legally appear. In order of least to most restrictive, the choices are DNLP, NLP, any, none. See section Classification of Models for details on model types in GAMS. Note well: functions classified as any are only permitted with exogenous (constant) arguments.

Functions are typically used in assignment statements and equations. In these cases, they are only evaluated at execution time. Some functions can also be used at compile time, e.g. to compute the factorial or square root of a scalar. Some of the tables below contain a column "Compile Time" indicating which functions can be used at compile time.

A word on the notation in the tables below: for function arguments, lower case indicates that an endogenous variable is allowed. For details on endogenous variables, see section Functions in Equation Definitions. Upper case function arguments indicate that a constant is required. Arguments in square brackets may be omitted: the default values used in such cases are specified in the function description provided.

Mathematical Functions

Mathematical functions may be used as expressions in assignment statements and in equation definitions. We start with some simple examples to illustrate. A list with all mathematical functions available in GAMS is given in Table 3.

Exp(x)

a = exp(t);
b = exp(t+2);

The GAMS function exp(x) returns the exponential \(e^x\) of its argument. The assignments above set \(a=e^t\) and \(b=e^{t+2}\) respectively.

Log(x)

z(j) = log(y(j));

The GAMS function log(x) returns the natural logarithm of its argument. The assignment above evaluates the logarithm once for each element of the controlling domain j.

Max(x1,x2,x3,...)

x = max(y+2, t, t*t);

The function max returns the maximum of a set of expressions or terms. In the assignment above, x will be assigned the maximum of \(y+2\), \(t\), and \(t \cdot t\).

Round(x[,DECPL])

The function round rounds its argument x to the specified number DECPL of places, where positive values of DECPL indicating rounding to the right of the decimal point. If the argument DECPL is not specified, it defaults to zero, and the function rounds its argument to the nearest integer value. For example,

x = round(q);
y = round(q,d);
z = round(12.432,2);
h = round(515.5,-1);

In the first assignment q is rounded to the nearest integer value, while in the second q is rounded to the number of decimals specified by d. The result of the third assignment is 12.43, while the final assignment results in a value of 520.

Table 3: Mathematical Functions

String Manipulation Functions

GAMS provides some string manipulation capability by extending the card and ord operators to work on strings as well as sets. In Table 4 the extended behavior is described. In this context, the functions take strings and places as arguments, and the numeric places argument must be a constant. This behavior only applies to execution-time usage of these functions.

Table 4: String Manipulation Functions

There are four types or sources of strings in this context. A string may be a string literal, i.e. a concatenation of letters and blanks as in "drink it" in the example that follows. It may be the symbol text (aka the explanatory text) associated with any symbol. Or it may be the labels or text associated with the elements of a set. The following table gives an overview:

Table 5: String Types

The string types are illustrated in the following example. Note that the directive in the first line activates the end-of-line comment option, see eolCom.

$oneolcom
variable z 'any symbol can have explanatory text';
set teas "teas available to order"  / black "English Breakfast",  green, peppermint /;
scalar p;

p = card("drink it");      !! result: p=8
p = card(z.ts);            !! result: p=36
p = card(teas.ts);         !! result: p=23

loop{teas,
    p = card(teas.tl)      !! length of set element label from the set "teas": "teas" is the controlling set
    display "length of set element label", p;
    p = card(teas.te)      !! length of set element explanatory text: "teas" is the controlling set
    display "length of set element explanatory text", p;
};

Note that the strings teas.tl and teas.te are used in the context of a loop statement (see section The Loop Statement). This is a typical usage pattern.

Logical Functions

Logical functions may be used as expressions in assignment statements as in the following example.

x = ifthen(tt=2, 3, 4+y);

Here \(x=3\) if \(tt=2\), otherwise \(x=4+y\).

The logical functions available in GAMS are given in Table 6. Note that logical functions may also be used in conditions and logic equations, see sections Logical Conditions and Logic Equations respectively. Most of the logical functions can also be indicated using the familiar operator notation, e.g. (x and y), (x >= y), etc. In such cases, the operator notation is allowed at compile time. The last column in Table 6 indicates if a logical function can be used at compile time (yes) or if only its alternative notation is available (alt). Further, note that the inputs and outputs of these functions are often logical/Boolean values, so GAMS does implicit conversions as necessary. As expected, false becomes 0 and true becomes 1 when converting logical values to numeric, and 0 becomes false and nonzero becomes true when numeric values are converted to logicals. For details on behavior when the inputs are special values, see sections Extended Range Arithmetic and Acronym Usage, but note that EPS, +INF, -INF, and acronyms become true when converted to logicals.

Table 6: Logical Functions

Time and Calendar Functions

GAMS offers several functions that relate to time and dates. The fundamental measurement of time in GAMS is the serial day number beginning with January 1, 1900. This serial day number is a real number whose integer part contains a unique number for each day and whose fractional part contains information about hours, minutes, and seconds. We can think of the serial day number as being a date.time pair. The day information extracted from serial day numbers is based on the Gregorian calendar.

Note

In all functions given in Table 7, serial day 1 is January 1, 1900.

All of the functions in Table 7 can be used at compile time.

Table 7: Time and Calendar Functions

GAMS Utility and Performance Functions

GAMS provides several functions that may be used to get (and in some cases set) GAMS system information, for example:

scalar o;
o = heapLimit;
heapLimit = 1024;

Table 8: GAMS Utility and Performance Functions

Extrinsic Functions

Using the GAMS Function Library Facility, functions may be imported from an external library into a GAMS model. Apart from the import syntax, the imported functions may be used in the same way as intrinsic functions. In particular, they may be used in equation definitions. Some function libraries are included with the standard GAMS software distribution, but GAMS users can also create their own libraries using an open programming interface. The GAMS Test Library instances [TRILIB01], [TRILIB02], [TRILIB03], and [CPPLIB00] are simple examples (in the programming languages C, Delphi, Fortran and C++, respectively) that come with every GAMS system.

For details on using and creating extrinsic function libraries, and on the extrinsic function libraries that are provided with GAMS, see the chapter on Extrinsic Functions.

Function Suffixes

Up to this point, this section has described and discussed functions without mentioning their derivatives. These derivatives are very important, though: most of the nonlinear solvers integrated with GAMS will require first derivatives to solve models, and many will also use or require second derivatives as well. It is sometimes useful (e.g. when testing an extrinsic function) to evaluate the derivatives of GAMS functions instead of the functions themselves. This can be done via function suffixes.

Function suffixes can specify the evaluation of a gradient (i.e. first derivative), a Hessian (i.e. second derivative), a minimum or maximum value of the function over a given range, or the minimum or maximum value of the gradient over a given range. A full list of function suffixes is given in Table 9. For functions whose arguments are constant, the derivatives are zero, so typically func is a mathematical function listed in Table 3 above. Note that function suffixes are not defined for functions without arguments (for example, pi), so specifying something like pi.grad results in a compilation error.

Table 9: Function Suffixes

Consider the following simple example:

scalars g, l, h, gl, gh;

g  = sin.grad(0);
l  = sin.low(pi/3:pi/2);
h  = sin.high(pi/3:pi/2);
gl = sin.gradL(pi/3:pi/2);
gh = sin.gradH(pi/3:pi/2);

display g, l, h, gl, gh;

For univariate functions like sine or cosine, there is no need to specify a variable index when evaluating derivatives. For multivariate functions, the default is to take partial derivatives w.r.t. the first variable. To specify other variables, the colon syntax in the example below is used.

scalars
  x   / 1 /
  ylo / -1 /
  yup / 2 /
  e0, e1, elo, ehi
  e_1, e_2
  e_11, e_22, e_21
  ;
e0 = edist(x,ylo);
e1 = edist(x,yup);
elo = edist.low (x,ylo:x,yup);
ehi = edist.high(x,ylo:x,yup);

e_1 = edist.grad(x,yup);
* e_1 = edist.grad(1:x,yup);  same as above
e_2 = edist.grad(2:x,yup);

e_11 = edist.hess(x,yup);
* e_11 = edist.hess(1:1:x,yup);  same as above
e_22 = edist.hess(2:2:x,yup);
e_21 = edist.hess(2:1:x,yup);

display x, ylo, yup, e0, e1, elo, ehi, e_1, e_2, e_11, e_22, e_21;

For more examples, see model [FUNCS4] in the GAMS Test Library.

Note

• The function suffixes value, grad, gradn, hess and hessn are also defined for extrinsic functions. When implementing an extrinsic function, be aware that missing derivatives will be computed numerically: see model [TRILIB01] for an example.

To compute derivatives numerically, GAMS uses finite difference approximations. This computation can be controlled with two options: the FDOpt option controls which variant of the finite difference method is used, while the FDDelta option controls the step size.

Extended Range Arithmetic and Error Handling

GAMS uses an extended range arithmetic to handle missing data, the results of undefined operations, infinite values, and zeros that are stored explicitly. The special values used in this arithmetic are listed and described in Table 10 below, along with the value of the mapVal function that corresponds to these values. We can think of special values as any value for which mapVal does not return 0.

Table 10: Special Values for Extended Range Arithmetic

Attention

Avoid creating or using numbers with very large (1.0e299 or above) or very small (1.0e-299 or below) magnitudes. Large numbers may be treated by GAMS as undefined (UNDF) or other special values, leading to unpredictable and unusable results. Always use INF (or -INF) explicitly for arbitrarily large (or small) numbers.

GAMS has defined the results of all arithmetic operations and all function evaluations that use these special values. The behavior is designed to both maximize utility and minimize surprise, and is illustrated in the library model [CRAZY]. For example: 1+INF evaluates to INF, 1-EPS to 1, NA * 2 to NA, and EPS*INF to UNDF.

The following table shows a selection of results for exponentiation and division for a variety of input parameters including NA and INF.

Table 11: Extended Range Arithmetic in Exponentiation and Division

Note that most extended range identifiers may be used in assignment statements, as illustrated below.

a(row,'col-3') =  NA;
a(row,'col-4') =  INF;
a(row,'col-5') = -INF;

The values most often used in assignments are NA in incomplete tables and INF for variable bounds.

The special value EPS is numerically equal to zero, so when used in the context of numerical comparisons, it behaves as zero. For example, the logical expressions x > 0 and x > EPS have the same result. However, EPS is a stored zero, so setting a parameter to zero (e.g. a(row,col)=0) results in no values being stored for a, while setting a parameter to EPS (e.g. a(row,col)=EPS) results in the value EPS being stored for every (row,col) tuple. This is sometimes useful, especially if a is used later in loops (see Programming Flow Control Features) or dollar conditions (see Conditional Expressions, Assignments and Equations). For example, consider the statement

a(row,col)$[a(row,col)] = INF ;

In the case where a was originally assigned to be zero, the dollar-condition is always false so no infinities are assigned. If a was originally assigned the value EPS, the dollar-condition is always true and every tuple in a will be set to infinity.

When an attempted arithmetic operation is illegal or has undefined results because of the value of arguments (division by zero is the normal example), an error is reported and the result is set to undefined (UNDF). The error is marked on the output file with a row of four asterisks '****' making this sequence a good search target in the editor. GAMS will also report the line number of the offending statement and give as much detail as possible about the cause. From there on, the resulting UNDF is treated as a proper data value and does not trigger additional error messages. For more on error messages, see chapter GAMS Output.

Note

GAMS will not solve a model if an error has been detected, and it will terminate with an error condition.

It is therefore wise to anticipate and avoid operations like division by zero that will cause errors. This is most easily done with the dollar control, and is discussed in section The Dollar Condition.

Predefined Symbols

GAMS offers several predefined symbols including: sameAs, diag, sortedUels, solvers, licenseCodes, and solverCapabilities. With the exception of sameAs, diag, and sortedUels these predefined symbols are for very special (and mostly internal) purposes, but the way they work is identical.

These symbols can be used in a GAMS program without being declared but work in an idiosyncratic way. For example, the complete program

display solvers, sameAs;

compiles and executes without error and produces the following result in the listing file:

----      1 SET Solvers  Available Solvers
                                                      ( EMPTY )

----      1 SET SameAs  Set Element Comparison Without Checking
                                                      ( EMPTY )

However, if labels have been declared (in any set) that corresponds to a solver name, then set solvers will contain this label. Consider the following example:

Set titles / Lord, Baron, Duke /;
Set greeks / Euclid, Pythagoras, Antigone /;
display solvers, sameAs;

Note that Antigone and Baron are the names of solvers in GAMS and therefore they will be displayed as a member of the set solvers. Also note that the set sameAs contains the diagonal elements for both sets:

----      3 SET Solvers  Available Solvers
Baron   ,    Antigone

----      3 SET SameAs  Set Element Comparison Without Checking
                  Lord       Baron        Duke      Euclid  Pythagoras    Antigone
Lord               YES
Baron                          YES
Duke                                       YES
Euclid                                                 YES
Pythagoras                                                         YES
Antigone                                                                       YES

User defined symbols can have the same name as a predefined symbol. In this case the user symbol hides the predefined symbols as demonstrated in the following example:

Set diag / 1*3 /;
$if setType diag $log diag is a set
$if preType diag $log diag is a predefined type

The log will only contain the line diag is a set. The test $if preType diag fails.

The list of all predefined symbols can be retrieved by declaring and displaying a set using some system data set pre /system.predefinedSymbols/; display pre; which results in

----      1 SET pre
SameAs                 ,    Diag                   ,    Solvers
LicenseCodes           ,    SolverCapabilities     ,    SortedUels

Summary

GAMS provides powerful facilities for data manipulation with parallel assignment statements, built-in functions and extended range arithmetic.