# Parameter#

## Introduction#

One very important principle will motivate all our discussions on data:

Note

Data should be entered in its most basic form and each data item should be entered only once.

There are two reasons for adopting this principle. Numbers are almost certain to change, and when they do, we want to be able to make the process of changing them as easy and safe as possible. We also want to make our model easy for others to read and understand. Keeping the amount of data as small as possible will certainly help. The reader should always be kept aware of all the assumptions made during data manipulation in order to be able to reproduce the results of a study.

This chapter deals with the data type parameter. Data for parameters can be enetered in scalar and in list oriented format.

## Scalars#

A GAMSPy parameter of dimensionality zero is called scalar. This means that there are no associated sets, so there is exactly one number associated with the parameter:

from gamspy import Container, Parameter

m = Container()

rho = Parameter(m, "rho", records = 0.15)
irr = Parameter(m, "irr")
life = Parameter(m, "life", records = 20)


The statement above initializes rho and life, but not irr. Later on an assignment statement could be used to provide the value:

irr[...] = 0.07


Note

When assigning values to scalar parameters, one needs to provide the ellipsis literal [...].

## Parameters#

The parameter format is used to enter list oriented data which can be indexed over one or several sets.

### The Syntax#

The following example illustrates the parameter statement

from gamspy import Container, Set, Parameter

m = Container()

j = Set(m, "j", records = ["mexico-df", "monterrey", "guadalaja"],
description = "markets")

dd = Parameter(m, name = "dd", domain = j, description = "distribution of demand",
records = [["mexico-df", 55],


The class gamspy.Parameter() indicates that this is a parameter statement and name = "dd" is the internal name of the parameter in GAMSPy, it is an identifier. A parameter may be defined over one or more sets that may be specified in the domain list. The domain specification for the parameter dd means that there will be a vector of data associated with it, one number corresponding to every member of the set j. The optional description is used to describe the parameter.

The Parameter initialization requires a list of data elements, each consisting of a label or label-tuple and a value. The label is an element of the defining set or - if there is more than one defining set - a combination of the elements of the defining sets. The referenced set elements must belong to the set that the parameter is indexed over. Finally, the value assigned to the record defined by the set element or element tuple.

Besides using the gamspy.Parameter() class directly, one can also facilitate the addParameter() method of the gamspy.Container() class:

dd = AddParameter("dd", domain = j, description = "distribution of demand",
records = [["mexico-df", 55],


### Parameter Data for Higher Dimensions#

A parameter may have several dimensions. For the current maximum number of permitted dimensions, see Dimensions in the GAMS documentation. The list oriented data initialization through the parameter statement can be easily extended to data of higher dimensionality. The label that appears in the one-dimensional case is replaced by a label tuple for higher dimensions. Just like in the case of Multi-Dimensional Sets, the elements in the $$n$$-tuple can be created using simple data frames or tuples in a pandas MultiIndex object.

from gamspy import Container, Set, Parameter
import pandas as pd

dist = pd.DataFrame(
[
("seattle", "new-york", 2.5),
("seattle", "chicago", 1.7),
("seattle", "topeka", 1.8),
("san-diego", "new-york", 2.5),
("san-diego", "chicago", 1.8),
("san-diego", "topeka", 1.4),
],
columns=["from", "to", "thousand_miles"],
)

m = Container()

i = Set(m, "i", ["*"], records = dist["from"].unique())
j = Set(m, "j", ["*"], records = dist["to"].unique())
a = Parameter(m, "a", [i, j], records = dist)

In : a.records
Out:
from             to        value
0     seattle       new-york          2.5
1     seattle        chicago          1.7
2     seattle         topeka          1.8
3   san-diego       new-york          2.5
4   san-diego        chicago          1.8
5   san-diego         topeka          1.4


It is also possible to define an empty parameter at declaration and fill it with data (e.g. from other sources like databases or spreadsheets) later on using the setRecords() method of the gamspy.Parameter() class:

from gamspy import Container

m = Container()

a = Parameter(m, "a", [i, j])
a.setRecords(dist)


Example with a pandas MultiIndex object:

from gamspy import Container, Parameter
import pandas as pd

dim1 = ["a", "b", "c"]
dim2 = ["z", "y", "x"]

s = pd.Series(
index=pd.MultiIndex.from_product([dim1, dim2]),
data=[i + 1 for i in range(len(dim1) * len(dim2))],
)

m = Container()
i = Parameter(m, "i", ["*", "*"], records = s, uels_on_axes=True)


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.

Out:
uni_0 uni_1  value
0     a     z    1.0
1     a     y    2.0
2     a     x    3.0
3     b     z    4.0
4     b     y    5.0
5     b     x    6.0
6     c     z    7.0
7     c     y    8.0
8     c     x    9.0


## The Assignment Statement#

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

### Scalar Assignments#

Consider the following artificial sequence:

x = Parameter(m, "x", records = 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, as mentioned above, when assigning values to scalar parameters, one needs to provide the ellipsis literal [...]. This is not necessary for non-scalar parameters.

Note also 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.

### Indexed Assignments#

Performing indexed assignments 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 * 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 GAMSPy 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.

Note

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.

from gamspy import Container, Set, Parameter

m = Container()

row = Set(m, "row", records = [("r-" + str(i), i) for i in range(1,11)])
col = Set(m, "col", records = [("c-" + str(i), i) for i in range(1,11)])
sro = Set(m, "sro", records = row.records[-4:])

r = Parameter(m, "r", domain = row,
records = [[record, 4]
if record in row.records["uni"][:7].values
else [record, 5]
for record in row.records["uni"]])
c = Parameter(m, "c", domain = col,
records = [[record, 3]
if record in col.records["uni"][:5].values
else [record, 2]
for record in col.records["uni"]])

a = Parameter(m, "a", domain = [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"] = 100 + r["r-1"]*c["c-1"]

In : a.records.pivot(index="row",columns="col", values="value")
Out:
col     c-1     c-2     c-3     c-4         c-5     c-6     c-7     c-8     c-9     c-10
row
r-1     112.0       25.2    25.2    25.2    25.2    21.2    21.2    21.2    21.2    21.2
r-2     25.2        25.2    25.2    25.2    25.2    21.2    21.2    21.2    21.2    21.2
r-3     25.2        25.2    25.2    25.2    25.2    21.2    21.2    21.2    21.2    21.2
r-4     25.2        25.2    25.2    25.2    25.2    21.2    21.2    21.2    21.2    21.2
r-5     25.2        25.2    25.2    25.2    25.2    21.2    21.2    21.2    21.2    21.2
r-6     25.2        25.2    25.2    25.2    25.2    21.2    21.2    21.2    21.2    21.2
r-7     25.2        25.2    25.2    25.2    25.2    21.2    21.2    21.2    21.2    21.2
r-8     28.2        28.2    28.2    28.2    28.2    23.2    23.2    23.2    23.2    23.2
r-9     28.2        28.2    28.2    28.2    28.2    23.2    23.2    23.2    23.2    23.2
r-10    28.2        28.2    28.2    28.2    28.2    23.2    23.2    23.2    23.2    23.2


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.

from gamspy import Container, Set, Parameter, Ord

m = Container()
i = Set(m, "i", records = [("i" + str(i), i) for i in range(1,11)])

f = Parameter(m, "f", domain = i, records = [["i1",1]])
g = Parameter(m, "g", domain = i, records = [["i1",1]])

for idx, elem in enumerate(i):
if idx >= 2:
f[elem["uni"]] = (f[i.records.iloc[idx - 1]["uni"]] +
f[i.records.iloc[idx - 2]["uni"]])

g[i].where[Ord(i)>=2] = g[i.records.iloc[idx - 2]["uni"]] + g[i.records.iloc[idx - 1]["uni"]]


Resulting in the following output

In : f.records
Out:
i     value
0    i1       1.0
1    i3       1.0
2    i4       1.0
3    i5       2.0
4    i6       3.0
5    i7       5.0
6    i8       8.0
7    i9      13.0
8   i10      21.0

In : g.records
Out:
i      value
0   i1        1.0


#### 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. Before we look at each method in more detail, below is an introductory example:

from gamspy import Container, Set, Parameter

m = Container()

# Set with element range from "i1" to "i100"
i = Set(m, "i", records = [("i" + str(i), i) for i in range(1,101)])

k = Parameter(m, "k", domain = i)

# Assign all values of k[i] to 4
k[i] = 4

# Assign to specific set elements of k[i]
k["i77"] = 15

# Assign to a part of a Set
j = Set(m, "j", domain = i, records = i.records[0:8])
k[j] = 10


The parameter k is declared over the set i but not assigned any values at first. In the first assignment statement k[i] = 4 all elements of the set i are assigned the value 4. k["i77"] refers to a specific set elements and is assigned the value 15. The third assignment assignes the value 10 to the first 8 elements of the set i by using a subset j. Read more about Set and Set Element Referencing here: Set and Set Element Referencing.

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

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

#### Conditionals#

a[row,col].where[a[row,col] >= 100] = float("inf")


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

#### Tuples#

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

from gamspy import Container, Set, Parameter
import pandas as pd

m = Container()
row = Set(m, "row", records = [("r-" + str(i), i) for i in range(1,11)])
col = Set(m, "col", records = [("c-" + str(i), i) for i in range(1,11)])
sro = Set(m, "sro", records = row.records[-4:])

r = Parameter(m, "r", domain = row,
records = [[record, 4]
if record in row.records["uni"][:7].values
else [record, 5]
for record in row.records["uni"]])

c = Parameter(m, "c", domain = col,
records = [[record, 3]
if record in col.records["uni"][:5].values
else [record, 2]
for record in col.records["uni"]])

s = pd.Series(
index=pd.MultiIndex.from_tuples([("r-1", "c-1"),
("r-1", "c-10"),
("r-10", "c-1"),
("r-10", "c-10")])
)

tuples = Set(m, name = "tuples", domain = [row, col],
uels_on_axes=True, records = s)

a = Parameter(m, "a", domain = [row, col])
a[row,col]  =  13.2 + r[row]*c[col]
a[tuples[row,col]] = 7 + r[row]*c[col]
a[tuples] = 0.25 * a[tuples]


Note that we have introduced the new set tuples. 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 tuples as domain. The values of the elements of the parameter a that are not elements of the set tuples remain unchanged.

#### Issues with Controlling Indices#

Warning

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]


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

Warning

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 Alias: 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 GAMSPy will make assignments over all 100 values of the full Cartesian product. The following example illustrates this method:

rowp = Alias(m, name = "rowp", alias_with = row)
b[row,rowp] = 7.7 - [r[row] + r[rowp]]/2


#### Indexed Operations#

GAMSPy provides the following four indexed operations: gamspy.Sum(), gamspy.Product(), gamspy.Smax(), gamspy.Smin(). These operations are performed over one or more controlling indices. Consider the following simple example:

from gamspy import Container, Set, Parameter, Sum

m = Container()

i = Set(m, "i", records = ["cartagena", "callao", "moron"], description = "plants")
p = Set(m, "p", records = ["nitr-acid", "sulf-acid", "amm-sulf"], description = "product")

capacity = Parameter(m, "capacity", domain = [i, p], description = "capacity in tons per day",
records = [["cartagena","nitr-acid",10], ["cartagena","sulf-acid",20], ["cartagena","amm-sulf",30],
["callao","nitr-acid",20], ["callao","sulf-acid",30], ["callao","amm-sulf",40],
["moron","nitr-acid",30], ["moron","sulf-acid",40], ["moron","amm-sulf",50]])

totcap = Parameter(m, "totcap", domain = p, description = "total capacity by process")

totcap[p] = Sum(i, capacity[i,p]);


The index over which the summation is done, i, is separated from the word Sum by a left bracket 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 brackets [] that start immediately after the Sum. Note that using normal mathematical representation the last line could be written as: $$totC_p = \sum_{i}C_{ip}$$.

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]*p[t])


The equivalent mathematical forms are:

$$count = \sum_{i}\sum_{j}A_{ij}$$ and $$emp = \sum_{t}L_tP_t$$

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

count[...] = Sum(i, Sum(j, a[i,j]))


Note

In the context of sets the gamspy.Sum() operator may be used to compute the number of elements in a set.

The gamspy.Smin() and gamspy.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 gamspy.Sum() operator. In the following example we want to find the largest capacity:

from gamspy import Smax

max_cap[...] = Smax((i,m),capacity[i,m])


Note

• In the context of assignment statements, the attributes of variables and equations (e.g. gamspy.Variable.up()) 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.