Parameter Examples#
Gurobi parameter handling is designed to be orthogonal, meaning that you only need to use a small number of routines to work with a large number of parameters. In particular:
The names and meanings of the various Gurobi parameters remain constant across the different programming language APIs, although some decoration is required in each language.
Given the type of a parameter (double, integer, etc.) and the programming language you wish to use it from, you simply need to identify the appropriate routine for that parameter type in that language in order to query or modify that parameter.
One important note about integer-valued parameters: while the maximum value that can be stored in a signed integer is \(2^{31}-1\), we use a MAXINT value of 2,000,000,000. Attempting to set an integer parameter to a value larger than this maximum will produce an error.
Refer to the following for detailed examples of how to work with parameters from our various APIs.
You can also browse our Examples to get a better sense of how to use our parameter interface.
The C interface defines a symbolic constant for each parameter. The
symbolic constant name is prefixed by GRB_type_PAR_, where
type is either INT, DBL, or STR. This is followed by
the capitalized parameter name. For example, the symbolic constant for
the integer Threads parameter (found in C header file
gurobi_c.h) is:
#define GRB_INT_PAR_THREADS "Threads"
The routine you use to modify a parameter value depends on the type of
the parameter. For a double-valued parameter, you would use
GRBsetdblparam.
Note that a model gets its own copy of the
environment when it is created. Changes to the original environment have
no effect on the copy, and vice versa. Use GRBgetenv to
retrieve the environment associated with a model if you would like to
change the parameter value for that model.
To set the TimeLimit parameter for a model, you’d do:
error = GRBsetdblparam(GRBgetenv(model), GRB_DBL_PAR_TIMELIMIT, 100.0);
If you’d prefer to use a string for the parameter name, you can also do:
error = GRBsetdblparam(GRBgetenv(model), "TimeLimit", 100.0);
The case of the string is ignored, as are underscores. Thus,
TimeLimit and TIME_LIMIT are equivalent.
Use GRBgetdblparam to query the current value of a (double)
parameter:
double currentvalue;
error = GRBgetdblparam(modelenv, "TimeLimit", ¤tvalue);
In the C++ interface, parameters are grouped by datatype into three
enums: GRB_DoubleParam, GRB_IntParam, and
GRB_StringParam. You refer to a specific parameter by appending the
parameter name to the enum name. For example, the
Threads parameter is GRB_IntParam_Threads.
To modify a parameter, you use GRBModel::set. Recall that
you can also set parameters on an environment, but changes to the
environment won’t affect models that have already been created using
that environment. It is generally simpler to set parameters on the model
itself.
To set the TimeLimit parameter for a model, you’d do:
GRBModel *m = ...;
m->set(GRB_DoubleParam_TimeLimit, 100.0);
You can also set the value of a parameter using strings for the parameter name and desired value. For example:
GRBModel *m = ...;
m->set("TimeLimit", "100.0");
Use GRBModel::get to query the current value of a parameter:
currentlimit = m.get(GRB_DoubleParam_TimeLimit);
In the C# interface, parameters are grouped by datatype into three
enums: GRB.DoubleParam, GRB.IntParam, and
GRB.StringParam. You would refer to the integer
Threads parameter as GRB.IntParam.Threads.
To modify a parameter, set the corresponding .NET property from
Model.Parameters. To set the TimeLimit parameter,
for example:
GRBModel m = ...;
m.Parameters.TimeLimit = 100.0;
You can also use GRBModel.Set:
m.Set(GRB.DoubleParam.TimeLimit, 100.0);
You can also set the value of a parameter using strings for the parameter name and desired value. For example:
GRBModel m = ...;
m.Set("TimeLimit", "100.0");
To query the current value of a parameter, use:
currentlimit = m.Parameters.TimeLimit;
You can also use GRBModel.Get:
currentlimit = m.Get(GRB.DoubleParam.TimeLimit);
In the Java interface, parameters are grouped by datatype into three
enums: GRB.DoubleParam, GRB.IntParam, and
GRB.StringParam. You would refer to the integer
Threads parameter as GRB.IntParam.Threads.
To modify a parameter, you use GRBModel.set. Recall that
you can also set parameters on an environment, but changes to the
environment won’t affect models that have already been created using
that environment. It is generally simpler to set parameters on the model
itself.
To set the TimeLimit parameter for a model, you’d do:
GRBModel m = ...;
m.set(GRB.DoubleParam.TimeLimit, 100.0);
You can also set the value of a parameter using strings for the parameter name and desired value. For example:
GRBModel m = ...;
m.set("TimeLimit", "100.0");
Use GRBModel.get to query the current value of a parameter:
currentlimit = m.get(GRB.DoubleParam.TimeLimit);
In the MATLAB interface, parameters are passed to Gurobi through a
struct. To modify a parameter, you create a field in the struct
with the appropriate name, and set it to the desired value. For example,
to set the TimeLimit parameter to 100 you’d do:
params.timelimit = 100;
The case of the parameter name is ignored, as are underscores. Thus, you could also do:
params.timeLimit = 100;
…or…
params.TIME_LIMIT = 100;
All desired parameter changes should be stored in a single struct,
which is passed as the second parameter to the gurobi
function.
In the Python interface, parameters are listed as constants within the
GRB.Param class. You would refer to the Threads
parameter as GRB.Param.Threads.
To modify a parameter, you can set the appropriate member of
Model.Params. To set the time limit for model m, you’d do:
m.Params.timeLimit = 100.0
The case of the parameter name is actually ignored, as are underscores, so you could also do:
m.Params.timelimit = 100.0
…or…
m.Params.TIME_LIMIT = 100.0
You can also use the Model.setParam method:
m.setParam(GRB.Param.TimeLimit, 100.0)
If you’d prefer to use a string for the parameter name, you can also do:
m.setParam("TimeLimit", 100.0);
To query the current value of a parameter, use:
currentlimit = m.Params.timeLimit
In the R interface, parameters are passed to Gurobi through a list.
To modify a parameter, you create a named component in the list
with the appropriate name, and set it to the desired value. For example,
to set the TimeLimit parameter to 100 you’d do:
params <- list(TimeLimit=100)
The case of the parameter name is ignored, as are underscores. Thus, you could also do:
params <- list(timeLimit = 100)
…or…
params <- list(TIME_LIMIT = 100)
All desired parameter changes should be stored in a single list,
which is passed as the second parameter to the gurobi
function.
In the Visual Basic interface, parameters are grouped by datatype into
three enums: GRB.DoubleParam, GRB.IntParam, and
GRB.StringParam. You would refer to the integer
Threads parameter as GRB.IntParam.Threads.
To modify a parameter, set the corresponding .NET property from
Model.Parameters. To set the TimeLimit parameter,
for example:
GRBModel m = ...
m.Parameters.TimeLimit = 100.0
You can also use GRBModel.Set:
m.Set(GRB.DoubleParam.TimeLimit, 100.0)
You can also set the value of a parameter using strings for the parameter name and desired value. For example:
GRBModel m = ...
m.Set("TimeLimit", "100.0")
To query the current value of a parameter, use:
currentlimit = m.Parameters.TimeLimit
You can also use GRBModel.Get:
currentlimit = m.Get(GRB.DoubleParam.TimeLimit)
Callback settable parameters#
Some parameters are callback settable. They can be modified from within a callback.
This is allowed when the where value on the callback routine is
PRESOLVED, SIMPLEX, MIP, MIPSOL, MIPNODE, BARRIER,
or MULTIOBJ (see the Callback Codes section
for more information).
Note
In case of a remote server, the change of a parameter from within a callback may not be taken into account immediately.
To modify a parameter from within a callback, you use
GRBcbsetdblparam, GRBcbsetintparam,
GRBcbsetstrparam, or GRBcbsetparam depending on
the parameter type.
To change the TimeLimit parameter within a MIPSOL
callback, you’d do:
int
mycallback(GRBmodel *model,
void *cbdata,
int where,
void *usrdata)
{
if (where == GRB_CB_MIPSOL) {
error = GRBcbsetdblparam(cbdata, GRB_DBL_PAR_TIMELIMIT, 10.0);
if (error) goto QUIT;
}
QUIT:
return 0;
}
To modify a parameter, you use GRBCallback::set method.
To change the TimeLimit parameter within a MIPSOL
callback, you’d do:
class mycallback: public GRBCallback
{
protected:
void callback () {
if (where == GRB_CB_MIPSOL)
set(GRB_DoubleParam_Timelimit, 10.0);
}
};
To modify a parameter, you use GRBCallback.Set method.
To change the TimeLimit parameter within a MIPSOL
callback, you’d do:
class MyCallback : GRBCallback {
protected override void Callback() {
if (where == GRB.Callback.MIPSOL)
Set(GRB.DoubleParam.TimeLimit, 10.0);
}
}
To modify a parameter, you use GRBCallback.set method.
To change the TimeLimit parameter within a MIPSOL
callback, you’d do:
class mycallback: public GRBCallback
{
protected:
void callback () {
if (where == GRB.CB_MIPSOL)
set(GRB.DoubleParam.TimeLimit, 10.0);
}
};
Callbacks are not supported in the Matlab API.
To modify a parameter, you use Model.cbSetParam method.
To change the TimeLimit parameter within a MIPSOL
callback, you’d do:
def mycallback(model, where):
if where == gp.GRB.Callback.MIPSOL:
model.cbSetParam("TimeLimit", 10)
Callbacks are not supported in the R API.
To modify a parameter, you use GRBCallback.Set method.
To change the TimeLimit parameter within a MIPSOL
callback, you’d do:
Class mycallback
Inherits GRBCallback
Protected Overloads Overrides MyCallback Callback()
If where = GRB.Callback.MIPSOL Then
Set(GRB.DoubleParam.TimeLimit, 10.0)
End If