Filter Content By
Version
Languages

addVars ( *indices, lb=0.0, ub=GRB.INFINITY, obj=0.0, vtype=GRB.CONTINUOUS, name="" )

Add multiple decision variables to a model.

Returns a Gurobi tupledict object that contains the newly created variables. The keys for the tupledict are derived from the indices argument(s). The arguments for this method can take several different forms, which will be described now.

The first arguments provide the indices that will be used as keys to access the variables in the returned tupledict. In its simplest version, you would specify one or more integer values, and this method would create the equivalent of a multi-dimensional array of variables. For example, x = model.addVars(2, 3) would create six variables, accessed as x[0,0], x[0,1], x[0,2], x[1,0], x[1,1], and x[1,2].

In a more complex version, you can specify arbitrary lists of immutable objects, and this method will create variables for each member of the cross product of these lists. For example, x = model.addVars([3, 7], ['a', 'b', 'c']) would create six variables, accessed as x[3,'a'], x[7,'c'], etc.

You can also provide your own list of tuples as indices. For example, x = model.addVars([(3,'a'), (3,'b'), (7,'b'), (7,'c')]) would be accessed in the same way as the previous example (x[3,'a'], x[7,'c'], etc.), except that not all combinations will be present. This is typically how sparse indexing is handled.

Note that while the indices can be provided as multiple lists of objects, or as a list of tuples, the member values for a specific index must always be scalars (int, float, string, ...). For example, x = model.addVars([(1, 3), 7], ['a']) is not allowed, since the first argument for the first member would be (1, 3). Similarly, x = model.addVars([((1, 3),'a'), (7,'a')]) is also not allowed.

The named arguments (lb, obj, etc.) can take several forms. If you provide a scalar value (or use the default), then every variable will use that value. Thus, for example, lb=1.0 will give every created variable a lower bound of 1.0. Note that a scalar value for the name argument has a special meaning, which will be discussed separately.

You can also provide a Python dict as the argument. In that case, the value for each variable will be pulled from the dict, using the indices argument to build the keys. For example, if the variables created by this method are indexed as x[i,j], then the dict provided for the argument should have an entry for each possible (i,j) value.

Finally, if your indices argument is a single list, you can provide a Python list of the same length for the named arguments. For each variable, it will pull the value from the corresponding position in the list.

As noted earlier, the name argument is special. If you provide a scalar argument for the name, that argument will be transformed to have a subscript that corresponds to the index of the associated variable. For example, if you do x = model.addVars(2,3,name="x"), the variables will get names x[0,0], x[0,1], etc.

Arguments:

indices: Indices for accessing the new variables.

lb (optional): Lower bound(s) for new variables.

ub (optional): Upper bound(s) for new variables.

obj (optional): Objective coefficient(s) for new variables.

vtype (optional): Variable type(s) for new variables.

name (optional): Names for new variables. The given name will be subscripted by the index of the generator expression, so if the index is an integer, c would become c[0], c[1], etc. Note that the generated names will be stored as ASCII strings, so you should avoid using names that contain non-ASCII characters. In addition, names that contain spaces are strongly discouraged, because they can't be written to LP format files.

Return value:

New tupledict object that contains the new variables as values, using the provided indices as keys.

Example usage:

  # 3-D array of binary variables
x = model.addVars(3, 4, 5, vtype=GRB.BINARY)

# variables index by tuplelist
l = tuplelist([(1, 2), (1, 3), (2, 3)])
y = model.addVars(l, ub=[1, 2, 3])