Hide navigation sidebar
Hide table of contents sidebar
Back to top
Toggle table of contents sidebar

# 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", &currentvalue);

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

Help and Feedback

Press `/` or click to search this documentation | Gurobi website | Gurobi community forum
Go to other Gurobi documentation | Gurobi download | Contact support