GRBModel#

GRBModel#

Gurobi model object. Commonly used methods include AddVar (adds a new decision variable to the model), AddConstr (adds a new constraint to the model), Optimize (optimizes the current model), and Get (retrieves the value of an attribute).

Objects of this class have unmanaged resources associated with them. The class implements the IDisposable interface.

While the .NET garbage collector will eventually collect an unused GRBModel object, the vast majority of the memory associated with a model is stored outside of the .NET heap. As a result, the garbage collector can’t see this memory usage, and thus it can’t take this quantity into account when deciding whether collection is necessary. We recommend that you call GRBModel.Dispose when you are done using a model (or use the .NET using statement).

GRBModel GRBModel(GRBEnv env)#

Constructor for GRBModel that creates an empty model. You can then call AddVar and AddConstr to populate the model with variables and constraints.

Parameters:

env – Environment for new model.

Returns:

New model object. Model initially contains no variables or constraints.

Example:

// Create environment
GRBEnv env = new GRBEnv();
// Create model and attach it to environment
GRBModel model = new GRBModel(env);

' Create environment
Dim env As GRBEnv = New GRBEnv()
' Create model and attach it to environment
Dim model As GRBModel = New GRBModel(env)

GRBModel GRBModel(GRBEnv env, string filename)#

Constructor for GRBModel that reads a model from a file. Note that the type of the file is encoded in the file name suffix. Valid suffixes are .mps, .rew, .lp, .rlp, .dua, .dlp, .ilp, or .opb. The files can be compressed, so additional suffixes of .zip, .gz, .bz2, .7z or .xz are accepted.

Parameters:

env – Environment for new model.
modelname – Name of the file containing the model.

Returns:

New model object.

Example:

// Create environment
GRBEnv env = new GRBEnv();
// Create model from file myModel.mps and attach it to environment
GRBModel model = new GRBModel(env, "myModel.mps");

' Create environment
Dim env As GRBEnv = New GRBEnv()
' Create model from file myModel.mps and attach it to environment
Dim model As GRBModel = New GRBModel(env, "myModel.mps")

GRBModel GRBModel(GRBModel model)#

Constructor for GRBModel that creates a copy of an existing model. Note that due to the lazy update approach in Gurobi, you have to call Update before copying it.

Parameters:

model – Model to copy.

Returns:

New model object. Model is a clone of the original.

Example:

// Create environment
GRBEnv env = new GRBEnv();
// Create model1 and attach it to environment
GRBModel model1 = new GRBModel(env);
// ...
// Update model before copying
model1.Update();
// Copy model
GRBModel model2 = new GRBModel(model1);

' Create environment
Dim env As GRBEnv = New GRBEnv()
' Create model and attach it to environment
Dim model As GRBModel = New GRBModel(env)
' ...
' Update model before copying
model1.Update()
' Copy model
Dim model2 As GRBModel = New GRBModel(model1)

GRBModel GRBModel(GRBModel model, GRBEnv targetenv)#

Constructor for GRBModel.

Copy an existing model to a different environment. Multiple threads can not work simultaneously within the same environment. Copies of models must therefore reside in different environments for multiple threads to operate on them simultaneously.

Note that this method itself is not thread safe, so you should either call it from the main thread or protect access to it with a lock.

Note that pending updates will not be applied to the model, so you should call update before copying if you would like those to be included in the copy.

For Compute Server users, note that you can copy a model from a client to a Compute Server environment, but it is not possible to copy models from a Compute Server environment to another (client or Compute Server) environment.

Parameters:

model – Model to copy.
targetenv – Environment to copy model into.

Returns:

New model object. Model is a clone of the original.

Example:

// Create environment
GRBEnv env = new GRBEnv();
// Create model1 and attach it to environment
GRBModel model1 = new GRBModel(env);
// ...
// Update model before copying
model1.Update();
// Copy model and attach it to env
GRBModel model2 = new GRBModel(model1, env2);

' Create environment
Dim env As GRBEnv = New GRBEnv()
' Create model1 and attach it to environment
Dim model1 As GRBModel = New GRBModel(env)
' ...
' Update model before copying
model1.Update()
' Copy model and attach it to env
Dim model2 As GRBModel = New GRBModel(model1, env2)

GRBConstr AddConstr(GRBLinExpr lhsExpr, char sense, GRBLinExpr rhsExpr, string name)#

Add a single linear constraint to a model.

Parameters:

lhsExpr – Left-hand side expression for new linear constraint.
sense – Sense for new linear constraint (GRB.LESS_EQUAL, GRB.EQUAL, or GRB.GREATER_EQUAL).
rhsExpr – Right-hand side expression for new linear constraint.
name – Name for new constraint.

Returns:

New constraint object.

Example:

// Create variables
GRBVar x = model.AddVar(0.0, GRB.INFINITY, 0.0, GRB.CONTINUOUS, "x");
GRBVar y = model.AddVar(0.0, GRB.INFINITY, 0.0, GRB.CONTINUOUS, "y");
// Create linear expression x + y
GRBLinExpr lexpr = new GRBLinExpr(0);
lexpr.AddTerm(1.0, x);
lexpr.AddTerm(1.0, y);
// Add linear constraint x + y = 0 with name c1
GRBConstr constr = model.AddConstr(lexpr, GRB.EQUAL, 0.0, "c1");

' Create variables
Dim x As GRBVar = model.AddVar(0.0, GRB.INFINITY, 0.0, GRB.CONTINUOUS, "x")
Dim y As GRBVar = model.AddVar(0.0, GRB.INFINITY, 0.0, GRB.CONTINUOUS, "y")
' Create linear expression x + y
Dim lexpr As GRBLinExpr = New GRBLinExpr(0)
lexpr.AddTerm(1.0, x)
lexpr.AddTerm(1.0, y)
' Add linear constraint x + y = 0 with name c1
Dim constr As GRBConstr = model.AddConstr(lexpr, GRB.EQUAL, 0.0, "c1")

GRBConstr AddConstr(GRBTempConstr tempConstr, string name)#

Add a single linear constraint to a model.

Parameters:

tempConstr – Temporary constraint object, created by an overloaded comparison operator. See GRBTempConstr for more information.
name – Name for new constraint.

Returns:

New constraint object.

Example:

// Create variables
GRBVar x = model.AddVar(0.0, GRB.INFINITY, 0.0, GRB.CONTINUOUS, "x");
GRBVar y = model.AddVar(0.0, GRB.INFINITY, 0.0, GRB.CONTINUOUS, "y");
// Add linear constraint x + y = 0 with name c1
GRBConstr constr = model.AddConstr(x + y == 0, "c1");

' Create variables
Dim x As GRBVar = model.AddVar(0.0, GRB.INFINITY, 0.0, GRB.CONTINUOUS, "x")
Dim y As GRBVar = model.AddVar(0.0, GRB.INFINITY, 0.0, GRB.CONTINUOUS, "y")
' Add linear constraint x + y = 0 with name c1
Dim constr As GRBConstr = model.AddConstr(x + y == 0, "c1")

GRBConstr[] AddConstrs(int count)#

Add count new linear constraints to a model. The new constraints are all of the form 0 <= 0.

We recommend that you build your model one constraint at a time (using AddConstr), since it introduces no significant overhead and we find that it produces simpler code. Feel free to use these methods if you disagree, though.

Parameters:

count – Number of constraints to add.

Returns:

Array of new constraint objects.

Example:

// Add 10 trivial linear constraints to model
GRBConstr[] constrs = model.AddConstrs(10);

' Add 10 trivial linear constraints to model
Dim constrs As GRBConstr() = model.AddConstrs(10)

GRBConstr[] AddConstrs(GRBLinExpr[] lhsExprs, char[] senses, double[] rhsVals, string[] names)#

Add new linear constraints to a model. The number of added constraints is determined by the length of the input arrays (which must be consistent across all arguments).

Parameters:

lhsExprs – Left-hand side expressions for the new linear constraints.
senses – Senses for new linear constraints (GRB.LESS_EQUAL, GRB.EQUAL, or GRB.GREATER_EQUAL).
rhsVals – Right-hand side values for the new linear constraints.
names – Names for new constraints.

Returns:

Array of new constraint objects.

Example:

// Create variables
GRBVar x = model.AddVar(0.0, GRB.INFINITY, 0.0, GRB.CONTINUOUS, "x");
GRBVar y = model.AddVar(0.0, GRB.INFINITY, 0.0, GRB.CONTINUOUS, "y");
// Create linear expressions x + y and x - 2.0 * y
GRBLinExpr lexpr1 = new GRBLinExpr(0);
lexpr1.AddTerm(1.0, x);
lexpr1.AddTerm(1.0, y);
GRBLinExpr lexpr2 = new GRBLinExpr(0);
lexpr2.AddTerm(1.0, x);
lexpr2.AddTerm(-2.0, y);
// Create arrays holding constraint data
GRBLinExpr[] lexprs = {lexpr1, lexpr2};
char[] senses = {GRB.LESS_EQUAL, GRB.GREATER_EQUAL};
double[] rhsVals = {0.0, 1.0};
string[] names = {"c1", "c2"};
// Add constraints x + y <= 0.0 and x - 2.0 * y >= 1.0
GRBConstr[] constrs = model.AddConstrs(lexprs, senses, rhsVals, names);

' Create variables
Dim x As GRBVar = model.AddVar(0.0, GRB.INFINITY, 0.0, GRB.CONTINUOUS, "x")
Dim y As GRBVar = model.AddVar(0.0, GRB.INFINITY, 0.0, GRB.CONTINUOUS, "y")
' Create linear expressions x + y and x - 2.0 * y
Dim lexpr1 As GRBLinExpr = New GRBLinExpr(0)
lexpr1.AddTerm(1.0, x)
lexpr1.AddTerm(1.0, y)
Dim lexpr2 As GRBLinExpr = New GRBLinExpr(0)
lexpr2.AddTerm(1.0, x)
lexpr2.AddTerm(-2.0, y)
' Create arrays holding constraint data
Dim lexprs As GRBLinExpr() = New GRBLinExpr() {lexpr1, lexpr2}
Dim senes As Char() = New Char() {GRB.LESS_EQUAL, GRB.GREATER_EQUAL}
Dim rhsVals As Double() = New Double() {0.0, 1.0}
Dim names As String() = New String() {"c1", "c2"}
' Add constraints x + y <= 0.0 and x - 2.0 * y >= 1.0
Dim constrs As GRBConstr() = model.AddConstrs(lexprs, senses, rhsVals, names)

GRBConstr[] AddConstrs(GRBLinExpr[] lhsExprs, char[] senses, GRBLinExpr[] rhsExprs, int start, int len, string[] names)#

Add new linear constraints to a model. This signature allows you to use arrays to hold the various constraint attributes (left-hand side, sense, etc.), without forcing you to add one constraint for each entry in the array. The start and len arguments allow you to specify which constraints to add.

Parameters:

lhsExprs – Left-hand side expressions for the new linear constraints.
senses – Senses for new linear constraints (GRB.LESS_EQUAL, GRB.EQUAL, or GRB.GREATER_EQUAL).
rhs – Right-hand side expressions for the new linear constraints.
start – The first constraint in the list to add.
len – The number of constraints to add.
names – Names for new constraints.

Returns:

Array of new constraint objects.

Example:

// Create variables
GRBVar x = model.AddVar(0.0, GRB.INFINITY, 0.0, GRB.CONTINUOUS, "x");
GRBVar y = model.AddVar(0.0, GRB.INFINITY, 0.0, GRB.CONTINUOUS, "y");
// Create linear expressions x + y and x - 2.0 * y
GRBLinExpr lexpr1 = new GRBLinExpr(0);
lexpr1.AddTerm(1.0, x);
lexpr1.AddTerm(1.0, y);
GRBLinExpr lexpr2 = new GRBLinExpr(0);
lexpr2.AddTerm(1.0, x);
lexpr2.AddTerm(-2.0, y);
// Create arrays holding constraint data
GRBLinExpr[] lexprs = {lexpr1, lexpr2};
char[] senses = {GRB.LESS_EQUAL, GRB.GREATER_EQUAL};
double[] rhsVals = {0.0, 1.0};
string[] names = {"c1", "c2"};
// Add constraints x + y <= 0.0 and x - 2.0 * y >= 1.0
model.AddConstrs(lexprs, senses, rhsVals, 0, 2, names);

' Create variables
Dim x As GRBVar = model.AddVar(0.0, GRB.INFINITY, 0.0, GRB.CONTINUOUS, "x")
Dim y As GRBVar = model.AddVar(0.0, GRB.INFINITY, 0.0, GRB.CONTINUOUS, "y")
' Create linear expressions x + y and x - 2.0 * y
Dim lexpr1 As GRBLinExpr = New GRBLinExpr(0)
lexpr1.AddTerm(1.0, x)
lexpr1.AddTerm(1.0, y)
Dim lexpr2 As GRBLinExpr = New GRBLinExpr(0)
lexpr2.AddTerm(1.0, x)
lexpr2.AddTerm(-2.0, y)
' Create arrays holding constraint data
Dim lexprs As GRBLinExpr() = New GRBLinExpr() {lexpr1, lexpr2}
Dim senes As Char() = New Char() {GRB.LESS_EQUAL, GRB.GREATER_EQUAL}
Dim rhsVals As Double() = New Double() {0.0, 1.0}
Dim names As String() = New String() {"c1", "c2"}
' Add constraints x + y <= 0.0 and x - 2.0 * y >= 1.0
Dim constrs As GRBConstr() = model.AddConstrs(lexprs, senses, rhsVals, 0, 2 names)

GRBGenConstr AddGenConstrMax(GRBVar resvar, GRBVar[] vars, double constant, string name)#

Add a new general constraint of type GRB.GENCONSTR_MAX to a model.

A MAX constraint \(r = \max\{x_1,\ldots,x_n,c\}\) states that the resultant variable \(r\) should be equal to the maximum of the operand variables \(x_1,\ldots,x_n\) and the constant \(c\).

Parameters:

resvar – The resultant variable of the new constraint.
vars – Array of variables that are the operands of the new constraint.
constant – The additional constant operand of the new constraint.
name – Name for the new general constraint.

Returns:

New general constraint.

Example:

// Create variables
GRBVar resvar = model.AddVar(0.0, GRB.INFINITY, 0.0, GRB.CONTINUOUS, "resvar");
double[] ub = { 10.0, 10.0, 10.0 };
GRBVar[] x = model.AddVars(null, ub, null, null, null);
// Add constraint resvar = max{x[0], x[1], x[2], 2.0}
GRBGenConstr gc = model.AddGenConstrMax(resvar, x, 2.0, "maxconstr");

' Create variables
Dim resvar As GRBVar = model.AddVar(0.0, GRB.INFINITY, 0.0, GRB.CONTINUOUS, "resvar")
Dim ub As Double() = New Double() { 10.0, 10.0, 10.0 }
Dim x As GRBVar() = model.AddVars(Nothing, ub, Nothing, Nothing, Nothing)
' Add constraint resvar = max{x[0], x[1], x[2], 2.0}
Dim gc As GRBGenConstr = model.AddGenConstrMax(resvar, x, 2.0, "maxconstr")

GRBGenConstr AddGenConstrMin(GRBVar resvar, GRBVar[] vars, double constant, string name)#

Add a new general constraint of type GRB.GENCONSTR_MIN to a model.

A MIN constraint \(r = \min\{x_1,\ldots,x_n,c\}\) states that the resultant variable \(r\) should be equal to the minimum of the operand variables \(x_1,\ldots,x_n\) and the constant \(c\).

Parameters:

resvar – The resultant variable of the new constraint.
vars – Array of variables that are the operands of the new constraint.
constant – The additional constant operand of the new constraint.
name – Name for the new general constraint.

Returns:

New general constraint.

Example:

// Create variables
GRBVar resvar = model.AddVar(-GRB.INFINITY, GRB.INFINITY, 0.0, GRB.CONTINUOUS, "resvar");
double[] lb = { -10.0, -10.0, -10.0 };
double[] ub = { 0.0, 0.0, 0.0 };
GRBVar[] x = model.AddVars(lb, ub, null, null, null);
// Add constraint resvar = min{x[0], x[1], x[2], -2.0}
GRBGenConstr gc = model.AddGenConstrMin(resvar, x, -2.0, "minconstr");

' Create variables
Dim resvar As GRBVar = model.AddVar(0.0, GRB.INFINITY, 0.0, GRB.CONTINUOUS, "resvar")
Dim lb As Double() = New Double() { -10.0, -10.0, -10.0 }
Dim ub As Double() = New Double() { 0.0, 0.0, 0.0 }
Dim x As GRBVar() = model.AddVars(lb, ub, Nothing, Nothing, Nothing)
' Add constraint resvar = min{x[0], x[1], x[2], -2.0}
Dim gc As GRBGenConstr = model.AddGenConstrMin(resvar, x, -2.0, "minconstr")

GRBGenConstr AddGenConstrAbs(GRBVar resvar, GRBVar argvar, string name)#

Add a new general constraint of type GRB.GENCONSTR_ABS to a model.

An ABS constraint \(r = \mbox{abs}\{x\}\) states that the resultant variable \(r\) should be equal to the absolute value of the argument variable \(x\).

Parameters:

resvar – The resultant variable of the new constraint.
argvar – The argument variable of the new constraint.
name – Name for the new general constraint.

Returns:

New general constraint.

Example:

// Create variables
GRBVar resvar = model.AddVar(-GRB.INFINITY, GRB.INFINITY, 0.0, GRB.CONTINUOUS, "resvar");
GRBVar x = model.AddVar(-2.0, 2.0, 0.0, GRB.CONTINUOUS, "x");
// Add constraint resvar = |x|
GRBGenConstr gc = model.AddGenConstrAbs(resvar, x, "absconstr");

' Create variables
Dim resvar As GRBVar = model.AddVar(0.0, GRB.INFINITY, 0.0, GRB.CONTINUOUS, "resvar")
Dim x As GRBVar = model.AddVar(-2.0, 2.0, 0.0, GRB.CONTINUOUS, "x")
' Add constraint resvar = |x|
Dim gc As GRBGenConstr = model.AddGenConstrAbs(resvar, x, "absconstr")

GRBGenConstr AddGenConstrAnd(GRBVar resvar, GRBVar[] vars, string name)#

Add a new general constraint of type GRB.GENCONSTR_AND to a model.

An AND constraint \(r = \mbox{and}\{x_1,\ldots,x_n\}\) states that the binary resultant variable \(r\) should be \(1\) if and only if all of the operand variables \(x_1,\ldots,x_n\) are equal to \(1\). If any of the operand variables is \(0\), then the resultant should be \(0\) as well.

Note that all variables participating in such a constraint will be forced to be binary, independent of how they were created.

Parameters:

resvar – The resultant variable of the new constraint.
vars – Array of variables that are the operands of the new constraint.
name – Name for the new general constraint.

Returns:

New general constraint.

Example:

// Create binary variables
GRBVar resvar = model.AddVar(0.0, 1.0, 0.0, GRB.BINARY, "resvar");
GRBVar[] x = model.AddVars(3, GRB.BINARY);
// Add constraint resvar = AND{x[0], x[1], x[2]}
GRBGenConstr gc = model.AddGenConstrAnd(resvar, x, "andconstr");

' Create variables
Dim resvar As GRBVar = model.AddVar(0.0, GRB.INFINITY, 0.0, GRB.CONTINUOUS, "resvar")
Dim x As GRBVar() = model.AddVars(3, GRB.BINARY)
' Add constraint resvar = AND{x[0], x[1], x[2]}
Dim gc As GRBGenConstr = model.AddGenConstrAnd(resvar, x, "andconstr")

GRBGenConstr AddGenConstrOr(GRBVar resvar, GRBVar[] vars, string name)#

Add a new general constraint of type GRB.GENCONSTR_OR to a model.

An OR constraint \(r = \mbox{or}\{x_1,\ldots,x_n\}\) states that the binary resultant variable \(r\) should be \(1\) if and only if any of the operand variables \(x_1,\ldots,x_n\) is equal to \(1\). If all operand variables are \(0\), then the resultant should be \(0\) as well.

Note that all variables participating in such a constraint will be forced to be binary, independent of how they were created.

Parameters:

resvar – The resultant variable of the new constraint.
vars – Array of variables that are the operands of the new constraint.
name – Name for the new general constraint.

Returns:

New general constraint.

Example:

// Create binary variables
GRBVar resvar = model.AddVar(0.0, 1.0, 0.0, GRB.BINARY, "resvar");
GRBVar[] x = model.AddVars(3, GRB.BINARY);
// Add constraint resvar = OR{x[0], x[1], x[2]}
GRBGenConstr gc = model.AddGenConstrOr(resvar, x, "orconstr");

' Create variables
Dim resvar As GRBVar = model.AddVar(0.0, GRB.INFINITY, 0.0, GRB.CONTINUOUS, "resvar")
Dim x As GRBVar() = model.AddVars(3, GRB.BINARY)
' Add constraint resvar = OR{x[0], x[1], x[2]}
Dim gc As GRBGenConstr = model.AddGenConstrOr(resvar, x, "orconstr")

GRBGenConstr AddGenConstrNorm(GRBVar resvar, GRBVar[] vars, double which, string name)#

Add a new general constraint of type GRB.GENCONSTR_NORM to a model.

A NORM constraint \(r = \mbox{norm}\{x_1,\ldots,x_n\}\) states that the resultant variable \(r\) should be equal to the vector norm of the argument vector \(x_1,\ldots,x_n\).

Parameters:

resvar – The resultant variable of the new constraint.
vars – Array of variables that are the operands of the new constraint. Note that this array may not contain duplicates.
which – Which norm to use. Options are 0, 1, 2, and GRB.INFINITY.
name – Name for the new general constraint.

Returns:

New general constraint.

Example:

// Create variables
GRBVar resvar = model.AddVar(-GRB.INFINITY, GRB.INFINITY, 0.0, GRB.CONTINUOUS, "resvar");
double[] lb = { -10.0, -10.0, -10.0 };
double[] ub = { 10.0, 10.0, 10.0 };
GRBVar[] x = model.AddVars(lb, ub, null, null, null);
// Add constraint resvar = (x_0^2 + x_1^2 + x_2^2)^(0.5)
GRBGenConstr gc = model.AddGenConstrNorm(resvar, x, 2, "2normconstr");

' Create variables
Dim resvar As GRBVar = model.AddVar(0.0, GRB.INFINITY, 0.0, GRB.CONTINUOUS, "resvar")
Dim lb As Double() = New Double() { -10.0, -10.0, -10.0 }
Dim ub As Double() = New Double() { 0.0, 0.0, 0.0 }
Dim x As GRBVar() = model.AddVars(lb, ub, Nothing, Nothing, Nothing)
' Add constraint resvar = (x_0^2 + x_1^2 + x_2^2)^(0.5)
Dim gc As GRBGenConstr = model.AddGenConstrNorm(resvar, x, 2, "2normconstr")

GRBGenConstr AddGenConstrNL(GRBVar resvar, int[] opcode, double[] data, int[] parent, string name)#

Add a new general constraint of type GRB.GENCONSTR_NL to a model.

A NL constraint \(r = f(x)\) states that the resultant variable \(r\) should be equal to the function value \(f(x)\) of the given function \(f\), provided as an expression tree described in Nonlinear Constraints.

Parameters:

resvar – The resultant variable of the new constraint.
opcode – An array containing the operation codes for the nodes.
data – An array containing the auxiliary data for each node.
parent – An array providing the parent index of the nodes
name – Name for the new general constraint.

Returns:

New general constraint.

Example:

// Add nonlinear constraint x0 = sin(2.5 * x1) + x2 to the model
GRBVar x0 = model.AddVar(0.0, 1.0, 0.0, GRB.CONTINUOUS, "x0");
GRBVar x1 = model.AddVar(0.0, 1.0, 0.0, GRB.CONTINUOUS, "x1");
GRBVar x2 = model.AddVar(0.0, 1.0, 0.0, GRB.CONTINUOUS, "x2");
// Initialize data for expression tree
int[]    opcode = new int[] {GRB.OPCODE_PLUS, GRB.OPCODE_SIN,
                             GRB.OPCODE_MULTIPLY, GRB.OPCODE_CONSTANT,
                             GRB.OPCODE_VARIABLE, GRB.OPCODE_VARIABLE};
double[] data   = new double[] {-1.0, -1.0, -1.0, 2.5, 1.0, 2.0};
int[]    parent = new int[] {-1, 0, 1, 2, 2, 0};
// Add nonlinear constraint
model.AddGenConstrNL(x0, opcode, data, parent, "nlconstr");

' Add nonlinear constraint x0 = sin(2.5 * x1) + x2 to the model
Dim x0 As GRBVar = model.AddVar(0.0, 1.0, 0.0, GRB.CONTINUOUS, "x0")
Dim x1 As GRBVar = model.AddVar(0.0, 1.0, 0.0, GRB.CONTINUOUS, "x1")
Dim x2 As GRBVar = model.AddVar(0.0, 1.0, 0.0, GRB.CONTINUOUS, "x2")
' Initialize data for expression tree
Dim opcode As Integer() = New Integer() {GRB.OPCODE_PLUS, GRB.OPCODE_SIN,
                                         GRB.OPCODE_MULTIPLY, GRB.OPCODE_CONSTANT,
                                         GRB.OPCODE_VARIABLE, GRB.OPCODE_VARIABLE}
Dim data As Double() = New Double() {-1.0, -1.0, -1.0, 2.5, 1.0, 2.0}
Dim parent As Integer() = New Integer() {-1, 0, 1, 2, 2, 0}
' Add nonlinear constraint
model.AddGenConstrNL(x0, opcode, data, parent, "nlconstr")

GRBGenConstr AddGenConstrIndicator(GRBVar binvar, int binval, GRBLinExpr expr, char sense, double rhs, string name)#

Add a new general constraint of type GRB.GENCONSTR_INDICATOR to a model.

An INDICATOR constraint \(z = f \rightarrow a^Tx \leq b\) states that if the binary indicator variable \(z\) is equal to \(f\), where \(f \in \{0,1\}\), then the linear constraint \(a^Tx \leq b\) should hold. On the other hand, if \(z = 1-f\), the linear constraint may be violated. The sense of the linear constraint can also be specified to be \(=\) or \(\geq\).

Note that the indicator variable \(z\) of a constraint will be forced to be binary, independent of how it was created.

Parameters:

binvar – The binary indicator variable.
binval – The value for the binary indicator variable that would force the linear constraint to be satisfied (\(0\) or \(1\)).
expr – Left-hand side expression for the linear constraint triggered by the indicator.
sense – Sense for the linear constraint. Options are GRB.LESS_EQUAL, GRB.EQUAL, or GRB.GREATER_EQUAL.
rhs – Right-hand side value for the linear constraint.
name – Name for the new general constraint.

Returns:

New general constraint.

Example:

// Create binary indicator variable
GRBVar z = model.AddVar(0.0, 1.0, 0.0, GRB.BINARY, "z");
// Create variables
GRBVar x = model.AddVar(0.0, GRB.INFINITY, 0.0, GRB.CONTINUOUS, "x");
GRBVar y = model.AddVar(0.0, GRB.INFINITY, 0.0, GRB.CONTINUOUS, "y");
// Create linear expression x + y
GRBLinExpr lexpr1 = new GRBLinExpr(0);
lexpr1.AddTerm(1.0, x);
lexpr1.AddTerm(1.0, y);
// Add constraint if z = 1 then x + y <= 2
GRBGenConstr gc = model.AddGenConstrIndicator(z, 1, lexpr, GRB.LESS_EQUAL, 2.0, "indicatorconstr");

' Create binary indicator variable
Dim z As GRBVar = model.AddVar(0.0, 1.0, 0.0, GRB.BINARY, "z")
' Create variables
Dim x As GRBVar = model.AddVar(0.0, GRB.INFINITY, 0.0, GRB.CONTINUOUS, "x")
Dim y As GRBVar = model.AddVar(0.0, GRB.INFINITY, 0.0, GRB.CONTINUOUS, "y")
' Create linear expression x + y
Dim lexpr1 As GRBLinExpr = New GRBLinExpr(0)
lexpr1.AddTerm(1.0, x)
lexpr1.AddTerm(1.0, y)
' Add constraint if z = 1 then x + y <= 2
Dim gc As GRBGenConstr = model.AddGenConstrIndicator(z, 1, lexpr, GRB.LESS_EQUAL, 2.0, "indicatorconstr")

GRBGenConstr AddGenConstrIndicator(GRBVar binvar, int binval, GRBTempConstr constr, string name)#

Add a new general constraint of type GRB.GENCONSTR_INDICATOR to a model.

Note that the indicator variable \(z\) of a constraint will be forced to be binary, independent of how it was created.

Parameters:

binvar – The binary indicator variable.
binval – The value for the binary indicator variable that would force the linear constraint to be satisfied (\(0\) or \(1\)).
constr – Temporary constraint object defining the linear constraint that is triggered by the indicator. The temporary constraint object is created using an overloaded comparison operator. See GRBTempConstr for more information.
name – Name for the new general constraint.

Returns:

New general constraint.

Example:

// Create binary indicator variable
GRBVar z = model.AddVar(0.0, 1.0, 0.0, GRB.BINARY, "z");
// Create variables
GRBVar x = model.AddVar(0.0, GRB.INFINITY, 0.0, GRB.CONTINUOUS, "x");
GRBVar y = model.AddVar(0.0, GRB.INFINITY, 0.0, GRB.CONTINUOUS, "y");
// Add constraint if z = 1 then x + y <= 2
GRBGenConstr gc = model.AddGenConstrIndicator(z, 1, x + y <= 2.0, "indicatorconstr");

' Create binary indicator variable
Dim z As GRBVar = model.AddVar(0.0, 1.0, 0.0, GRB.BINARY, "z")
' Create variables
Dim x As GRBVar = model.AddVar(0.0, GRB.INFINITY, 0.0, GRB.CONTINUOUS, "x")
Dim y As GRBVar = model.AddVar(0.0, GRB.INFINITY, 0.0, GRB.CONTINUOUS, "y")
' Add constraint if z = 1 then x + y <= 2
Dim gc As GRBGenConstr = model.AddGenConstrIndicator(z, 1, lexpr, GRB.LESS_EQUAL, 2.0, "indicatorconstr")

GRBGenConstr AddGenConstrPWL(GRBVar xvar, GRBVar yvar, double[] xpts, double[] ypts, string name)#

Add a new general constraint of type GRB.GENCONSTR_PWL to a model.

A piecewise-linear (PWL) constraint states that the relationship \(y = f(x)\) must hold between variables \(x\) and \(y\), where \(f\) is a piecewise-linear function. The breakpoints for \(f\) are provided as arguments. Refer to the description of piecewise-linear objectives for details of how piecewise-linear functions are defined.

Parameters:

xvar – The \(x\) variable.
yvar – The \(y\) variable.
xpts – The \(x\) values for the points that define the piecewise-linear function. Must be in non-decreasing order.
ypts – The \(y\) values for the points that define the piecewise-linear function.
name – Name for the new general constraint.

Returns:

New general constraint.

Example:

// Create variables
GRBVar x = model.AddVar(-1.0, GRB.INFINITY, 0.0, GRB.CONTINUOUS, "x");
GRBVar y = model.AddVar(0.0, GRB.INFINITY, 0.0, GRB.CONTINUOUS, "y");
// Create point pairs for the PWL function
double[] xpts = {-1, 0, 0, 0, 1};
double[] ypts = {2, 1, 0, 1, 2};
// Add PWL constraint y = PWL(x)
GRBGenConstr gc = model.AddGenConstrPWL(x, y, xpts, ypts, "pwlconstr");

' Create variables
Dim x As GRBVar = model.AddVar(-1.0, GRB.INFINITY, 0.0, GRB.CONTINUOUS, "x")
Dim y As GRBVar = model.AddVar(0.0, GRB.INFINITY, 0.0, GRB.CONTINUOUS, "y")
' Create point pairs for the PWL function
Dim xpts As Double() = New Double() {-1, 0, 0, 0, 1}
Dim ypts As Double() = New Double() {2, 1, 0, 1, 2}
' Add PWL constraint y = PWL(x)
Dim gc As GRBGenConstr = model.AddGenConstrPWL(x, y, xpts, ypts, "pwlconstr")

GRBGenConstr AddGenConstrPoly(GRBVar xvar, GRBVar yvar, double[] p, string name, string options)#

A polynomial function constraint states that the relationship \(y = p_0 x^d + p_1 x^{d-1} + ... + p_{d-1} x + p_{d}\) should hold between variables \(x\) and \(y\).

A piecewise-linear approximation of the function is added to the model. The details of the approximation are controlled using the following four attributes (or using the parameters with the same names): FuncPieces, FuncPieceError, FuncPieceLength, and FuncPieceRatio. Alternatively, the function can be treated as a nonlinear constraint by setting the attribute FuncNonlinear. For details, consult the General Constraint discussion.

Parameters:

xvar – The \(x\) variable.
yvar – The \(y\) variable.
p – The coefficients for the polynomial function (starting with the coefficient for the highest power).
name – Name for the new general constraint.
options – A string that can be used to set the attributes that control the piecewise-linear approximation of this function constraint. To assign a value to an attribute, follow the attribute name with an equal sign and the desired value (with no spaces). Assignments for different attributes should be separated by spaces (e.g. “FuncPieces=-1 FuncPieceError=0.001”).

Returns:

New general constraint.

Example:

// Create argument variable
GRBVar x = model.AddVar(-5.0, 5.0, 0.0, GRB.CONTINUOUS, "x");
// Create resultant variable
GRBVar y = model.AddVar(-GRB.INFINITY, GRB.INFINITY, 0.0, GRB.CONTINUOUS, "y");
// Create array holding coefficients
double[] p = {3.0, 2.0, 0.0, 1.0};
// Add constraint y = 3.0 * x^3 + 2.0 * x^2 + 1.0
GRBGenConstr gc = model.AddGenConstrPoly(x, y, p, "polyconstr", "");

' Create argument variable
Dim x As GRBVar = model.AddVar(-5.0, 5.0, 0.0, GRB.CONTINUOUS, "x")
' Create resultant variable
Dim y As GRBVar = model.AddVar(-GRB.INFINITY, GRB.INFINITY, 0.0, GRB.CONTINUOUS, "y")
' Create array holding coefficients
Dim p As Double() = New Double() {3.0, 2.0, 0.0, 1.0}
' Add constraint y = 3.0 * x^3 + 2.0 * x^2 + 1.0
Dim gc As GRBGenConstr = model.AddGenConstrPoly(x, y, p, "polyconstr", "")

GRBGenConstr AddGenConstrExp(GRBVar xvar, GRBVar yvar, string name, string options)#

Add a new general constraint of type GRB.GENCONSTR_EXP to a model.

A natural exponential function constraint states that the relationship \(y = \exp(x)\) should hold for variables \(x\) and \(y\).

Parameters:

xvar – The \(x\) variable.
yvar – The \(y\) variable.
name – Name for the new general constraint.
options – A string that can be used to set the attributes that control the piecewise-linear approximation of this function constraint. To assign a value to an attribute, follow the attribute name with an equal sign and the desired value (with no spaces). Assignments for different attributes should be separated by spaces (e.g. “FuncPieces=-1 FuncPieceError=0.001”).

Returns:

New general constraint.

Example:

// Create argument variable
GRBVar x = model.AddVar(-5.0, 5.0, 0.0, GRB.CONTINUOUS, "x");
// Create resultant variable
GRBVar y = model.AddVar(-GRB.INFINITY, GRB.INFINITY, 0.0, GRB.CONTINUOUS, "y");
// Add constraint y = exp(x)
GRBGenConstr gc = model.AddGenConstrExp(x, y, "expconstr", "");

' Create argument variable
Dim x As GRBVar = model.AddVar(-5.0, 5.0, 0.0, GRB.CONTINUOUS, "x")
' Create resultant variable
Dim y As GRBVar = model.AddVar(-GRB.INFINITY, GRB.INFINITY, 0.0, GRB.CONTINUOUS, "y")
' Add constraint y = exp(x)
Dim gc As GRBGenConstr = model.AddGenConstrExp(x, y, "expconstr", "")

GRBGenConstr AddGenConstrExpA(GRBVar xvar, GRBVar yvar, double a, string name, string options)#

Add a new general constraint of type GRB.GENCONSTR_EXPA to a model.

An exponential function constraint states that the relationship \(y = a^x\) should hold for variables \(x\) and \(y\), where \(a > 0\) is the (constant) base.

Parameters:

xvar – The \(x\) variable.
yvar – The \(y\) variable.
a – The base of the function, \(a > 0\).
name – Name for the new general constraint.
options – A string that can be used to set the attributes that control the piecewise-linear approximation of this function constraint. To assign a value to an attribute, follow the attribute name with an equal sign and the desired value (with no spaces). Assignments for different attributes should be separated by spaces (e.g. “FuncPieces=-1 FuncPieceError=0.001”).

Returns:

New general constraint.

Example:

// Create argument variable
GRBVar x = model.AddVar(1.0, 5.0, 0.0, GRB.CONTINUOUS, "x");
// Create resultant variable
GRBVar y = model.AddVar(-GRB.INFINITY, GRB.INFINITY, 0.0, GRB.CONTINUOUS, "y");
// Add constraint y = 2.0^x
GRBGenConstr gc = model.AddGenConstrExpA(x, y, 2.0, "exp2constr", "");

' Create argument variable
Dim x As GRBVar = model.AddVar(1.0, 5.0, 0.0, GRB.CONTINUOUS, "x")
' Create resultant variable
Dim y As GRBVar = model.AddVar(-GRB.INFINITY, GRB.INFINITY, 0.0, GRB.CONTINUOUS, "y")
' Add constraint y = 2.0^x
Dim gc As GRBGenConstr = model.AddGenConstrExpA(x, y, 2.0, "exp2constr", "")

GRBGenConstr AddGenConstrLog(GRBVar xvar, GRBVar yvar, string name, string options)#

Add a new general constraint of type GRB.GENCONSTR_LOG to a model.

A natural logarithmic function constraint states that the relationship \(y = log(x)\) should hold for variables \(x\) and \(y\).

Parameters:

xvar – The \(x\) variable.
yvar – The \(y\) variable.
name – Name for the new general constraint.
options – A string that can be used to set the attributes that control the piecewise-linear approximation of this function constraint. To assign a value to an attribute, follow the attribute name with an equal sign and the desired value (with no spaces). Assignments for different attributes should be separated by spaces (e.g. “FuncPieces=-1 FuncPieceError=0.001”).

Returns:

New general constraint.

Example:

// Create argument variable
GRBVar x = model.AddVar(1.0, 5.0, 0.0, GRB.CONTINUOUS, "x");
// Create resultant variable
GRBVar y = model.AddVar(-GRB.INFINITY, GRB.INFINITY, 0.0, GRB.CONTINUOUS, "y");
// Add constraint y = log(x)
GRBGenConstr gc = model.AddGenConstrLog(x, y, "logconstr", "");

' Create argument variable
Dim x As GRBVar = model.AddVar(1.0, 5.0, 0.0, GRB.CONTINUOUS, "x")
' Create resultant variable
Dim y As GRBVar = model.AddVar(-GRB.INFINITY, GRB.INFINITY, 0.0, GRB.CONTINUOUS, "y")
' Add constraint y = log(x)
Dim gc As GRBGenConstr = model.AddGenConstrLog(x, y, "logconstr", "")

GRBGenConstr AddGenConstrLogA(GRBVar xvar, GRBVar yvar, double a, string name, string options)#

Add a new general constraint of type GRB.GENCONSTR_LOGA to a model.

A logarithmic function constraint states that the relationship \(y = log_a(x)\) should hold for variables \(x\) and \(y\), where \(a > 0\) is the (constant) base.

Parameters:

xvar – The \(x\) variable.
yvar – The \(y\) variable.
a – The base of the function, \(a > 0\).
name – Name for the new general constraint.
options – A string that can be used to set the attributes that control the piecewise-linear approximation of this function constraint. To assign a value to an attribute, follow the attribute name with an equal sign and the desired value (with no spaces). Assignments for different attributes should be separated by spaces (e.g. “FuncPieces=-1 FuncPieceError=0.001”).

Returns:

New general constraint.

Example:

// Create argument variable
GRBVar x = model.AddVar(1.0, 5.0, 0.0, GRB.CONTINUOUS, "x");
// Create resultant variable
GRBVar y = model.AddVar(-GRB.INFINITY, GRB.INFINITY, 0.0, GRB.CONTINUOUS, "y");
// Add constraint y = log_2(x)
GRBGenConstr gc = model.AddGenConstrLogA(x, y, 2.0, "log2constr", "");

' Create argument variable
Dim x As GRBVar = model.AddVar(1.0, 5.0, 0.0, GRB.CONTINUOUS, "x")
' Create resultant variable
Dim y As GRBVar = model.AddVar(-GRB.INFINITY, GRB.INFINITY, 0.0, GRB.CONTINUOUS, "y")
' Add constraint y = log_2(x)
Dim gc As GRBGenConstr = model.AddGenConstrLogA(x, y, 2.0, "log2constr", "")

GRBGenConstr AddGenConstrLogistic(GRBVar xvar, GRBVar yvar, string name, string options)#

Add a new general constraint of type GRB.GENCONSTR_LOGISTIC to a model.

A logistic function constraint states that the relationship \(y = \frac{1}{1 + e^{-x}}\) should hold for variables \(x\) and \(y\).

Parameters:

xvar – The \(x\) variable.
yvar – The \(y\) variable.
name – Name for the new general constraint.
options – A string that can be used to set the attributes that control the piecewise-linear approximation of this function constraint. To assign a value to an attribute, follow the attribute name with an equal sign and the desired value (with no spaces). Assignments for different attributes should be separated by spaces (e.g. “FuncPieces=-1 FuncPieceError=0.001”).

Returns:

New general constraint.

Example:

// Create argument variable
GRBVar x = model.AddVar(-5.0, 5.0, 0.0, GRB.CONTINUOUS, "x");
// Create resultant variable
GRBVar y = model.AddVar(-GRB.INFINITY, GRB.INFINITY, 0.0, GRB.CONTINUOUS, "y");
// Add constraint y = logistic(x) = 1.0 / (1.0 + exp(-x))
GRBGenConstr gc = model.AddGenConstrLogistic(x, y, "logisticconstr", "");

' Create argument variable
Dim x As GRBVar = model.AddVar(-5.0, 5.0, 0.0, GRB.CONTINUOUS, "x")
' Create resultant variable
Dim y As GRBVar = model.AddVar(-GRB.INFINITY, GRB.INFINITY, 0.0, GRB.CONTINUOUS, "y")
' Add constraint y = logistic(x) = 1.0 / (1.0 + exp(-x))
Dim gc As GRBGenConstr = model.AddGenConstrLogistic(x, y, "logisticconstr", "")

GRBGenConstr AddGenConstrPow(GRBVar xvar, GRBVar yvar, double a, string name, string options)#

Add a new general constraint of type GRB.GENCONSTR_POW to a model.

A power function constraint states that the relationship \(y = x^a\) should hold for variables \(x\) and \(y\), where \(a\) is the (constant) exponent.

If the exponent \(a\) is negative, the lower bound on \(x\) must be strictly positive. If the exponent isn’t an integer, the lower bound on \(x\) must be non-negative.

Parameters:

xvar – The \(x\) variable.
yvar – The \(y\) variable.
a – The exponent of the function.
name – Name for the new general constraint.
options – A string that can be used to set the attributes that control the piecewise-linear approximation of this function constraint. To assign a value to an attribute, follow the attribute name with an equal sign and the desired value (with no spaces). Assignments for different attributes should be separated by spaces (e.g. “FuncPieces=-1 FuncPieceError=0.001”).

Returns:

New general constraint.

Example:

// Create argument variable
GRBVar x = model.AddVar(-5.0, 5.0, 0.0, GRB.CONTINUOUS, "x");
// Create resultant variable
GRBVar y = model.AddVar(-GRB.INFINITY, GRB.INFINITY, 0.0, GRB.CONTINUOUS, "y");
// Add constraint y = x^3
GRBGenConstr gc = model.AddGenConstrPow(x, y, 3, "pow3constr", "");

' Create argument variable
Dim x As GRBVar = model.AddVar(-5.0, 5.0, 0.0, GRB.CONTINUOUS, "x")
' Create resultant variable
Dim y As GRBVar = model.AddVar(-GRB.INFINITY, GRB.INFINITY, 0.0, GRB.CONTINUOUS, "y")
' Add constraint y = x^3
Dim gc As GRBGenConstr = model.AddGenConstrPow(x, y, 3, "pow3constr", "")

GRBGenConstr AddGenConstrSin(GRBVar xvar, GRBVar yvar, string name, string options)#

Add a new general constraint of type GRB.GENCONSTR_SIN to a model.

A sine function constraint states that the relationship \(y = sin(x)\) should hold for variables \(x\) and \(y\).

Parameters:

xvar – The \(x\) variable.
yvar – The \(y\) variable.
name – Name for the new general constraint.
options – A string that can be used to set the attributes that control the piecewise-linear approximation of this function constraint. To assign a value to an attribute, follow the attribute name with an equal sign and the desired value (with no spaces). Assignments for different attributes should be separated by spaces (e.g. “FuncPieces=-1 FuncPieceError=0.001”).

Returns:

New general constraint.

Example:

// Create argument variable
GRBVar x = model.AddVar(-5.0, 5.0, 0.0, GRB.CONTINUOUS, "x");
// Create resultant variable
GRBVar y = model.AddVar(-GRB.INFINITY, GRB.INFINITY, 0.0, GRB.CONTINUOUS, "y");
// Add constraint y = sin(x)
GRBGenConstr gc = model.AddGenConstrSin(x, y, "sinconstr", "");

' Create argument variable
Dim x As GRBVar = model.AddVar(-5.0, 5.0, 0.0, GRB.CONTINUOUS, "x")
' Create resultant variable
Dim y As GRBVar = model.AddVar(-GRB.INFINITY, GRB.INFINITY, 0.0, GRB.CONTINUOUS, "y")
' Add constraint y = sin(x)
Dim gc As GRBGenConstr = model.AddGenConstrSin(x, y, "sinconstr", "")

GRBGenConstr AddGenConstrCos(GRBVar xvar, GRBVar yvar, string name, string options)#

Add a new general constraint of type GRB.GENCONSTR_COS to a model.

A cosine function constraint states that the relationship \(y = cos(x)\) should hold for variables \(x\) and \(y\).

Parameters:

xvar – The \(x\) variable.
yvar – The \(y\) variable.
name – Name for the new general constraint.
options – A string that can be used to set the attributes that control the piecewise-linear approximation of this function constraint. To assign a value to an attribute, follow the attribute name with an equal sign and the desired value (with no spaces). Assignments for different attributes should be separated by spaces (e.g. “FuncPieces=-1 FuncPieceError=0.001”).

Returns:

New general constraint.

Example:

// Create argument variable
GRBVar x = model.AddVar(-5.0, 5.0, 0.0, GRB.CONTINUOUS, "x");
// Create resultant variable
GRBVar y = model.AddVar(-GRB.INFINITY, GRB.INFINITY, 0.0, GRB.CONTINUOUS, "y");
// Add constraint y = cos(x)
GRBGenConstr gc = model.AddGenConstrCos(x, y, "cosconstr", "");

' Create argument variable
Dim x As GRBVar = model.AddVar(-5.0, 5.0, 0.0, GRB.CONTINUOUS, "x")
' Create resultant variable
Dim y As GRBVar = model.AddVar(-GRB.INFINITY, GRB.INFINITY, 0.0, GRB.CONTINUOUS, "y")
' Add constraint y = cos(x)
Dim gc As GRBGenConstr = model.AddGenConstrCos(x, y, "cosconstr", "")

GRBGenConstr AddGenConstrTan(GRBVar xvar, GRBVar yvar, string name, string options)#

Add a new general constraint of type GRB.GENCONSTR_TAN to a model.

A tangent function constraint states that the relationship \(y = tan(x)\) should hold for variables \(x\) and \(y\).

Parameters:

xvar – The \(x\) variable.
yvar – The \(y\) variable.
name – Name for the new general constraint.
options – A string that can be used to set the attributes that control the piecewise-linear approximation of this function constraint. To assign a value to an attribute, follow the attribute name with an equal sign and the desired value (with no spaces). Assignments for different attributes should be separated by spaces (e.g. “FuncPieces=-1 FuncPieceError=0.001”).

Returns:

New general constraint.

Example:

// Create argument variable
GRBVar x = model.AddVar(-1.0, 1.0, 0.0, GRB.CONTINUOUS, "x");
// Create resultant variable
GRBVar y = model.AddVar(-GRB.INFINITY, GRB.INFINITY, 0.0, GRB.CONTINUOUS, "y");
// Add constraint y = tan(x)
GRBGenConstr gc = model.AddGenConstrTan(x, y, "tanconstr", "");

' Create argument variable
Dim x As GRBVar = model.AddVar(-5.0, 5.0, 0.0, GRB.CONTINUOUS, "x")
' Create resultant variable
Dim y As GRBVar = model.AddVar(-GRB.INFINITY, GRB.INFINITY, 0.0, GRB.CONTINUOUS, "y")
' Add constraint y = tan(x)
Dim gc As GRBGenConstr = model.AddGenConstrTan(x, y, "tanconstr", "")

GRBQConstr AddQConstr(GRBQuadExpr lhsExpr, char sense, GRBQuadExpr rhsExpr, string name)#

Add a quadratic constraint to a model.

Important

Gurobi can handle both convex and non-convex quadratic constraints. The differences between them can be both important and subtle. Refer to this discussion for additional information.

Parameters:

lhsExpr – Left-hand side expression for new quadratic constraint.
sense – Sense for new quadratic constraint (GRB.LESS_EQUAL, GRB.EQUAL, or GRB.GREATER_EQUAL).
rhsExpr – Right-hand side expression for new quadratic constraint.
name – Name for new constraint.

Returns:

New quadratic constraint object.

Example:

// Create variables
GRBVar x = model.AddVar(-2.0, 2.0, 0.0, GRB.CONTINUOUS, "x");
GRBVar y = model.AddVar(0.0, 3.0, 0.0, GRB.CONTINUOUS, "y");
// Create quadratric expression x^2 + x*y + y
GRBQuadExpr qexpr = new GRBQuadExpr(0);
qexpr.AddTerm(1.0, x, x);
qexpr.AddTerm(1.0, x, y);
qexpr.AddTerm(1.0, y);
// Add quadratic constraint x^2 + x*y + y = 0 with name c1
GRBQConstr constr = model.AddQConstr(qexpr, GRB.EQUAL, 0.0, "c1");

' Create variables
Dim x As GRBVar = model.AddVar(-2.0, 2.0, 0.0, GRB.CONTINUOUS, "x")
Dim y As GRBVar = model.AddVar(0.0, 3.0, 0.0, GRB.CONTINUOUS, "y")
' Create quadratric expression x^2 + x*y + y
Dim qexpr As GRBQuadExpr = New GRBQuadExpr(0)
qexpr.AddTerm(1.0, x, x)
qexpr.AddTerm(1.0, x, y)
qexpr.AddTerm(1.0, y)
' Add quadratic constraint x^2 + x*y + y = 0 with name c1
Dim constr As GRBQConstr = model.AddQConstr(qexpr, GRB.EQUAL, 0.0, "c1")

GRBQConstr AddQConstr(GRBTempConstr tempConstr, string name)#

Add a quadratic constraint to a model.

Important

Gurobi can handle both convex and non-convex quadratic constraints. The differences between them can be both important and subtle. Refer to this discussion for additional information.

Parameters:

tempConstr – Temporary constraint object, created by an overloaded comparison operator. See GRBTempConstr for more information.
name – Name for new constraint.

Returns:

New quadratic constraint object.

Example:

// Create variables
GRBVar x = model.AddVar(-2.0, 2.0, 0.0, GRB.CONTINUOUS, "x");
GRBVar y = model.AddVar(0.0, 3.0, 0.0, GRB.CONTINUOUS, "y");
// Add quadratic constraint x^2 + x*y + y = 0 with name c1
GRBQConstr constr = model.AddQConstr(x*x + x*y + y == 0, "c1");

' Create variables
Dim x As GRBVar = model.AddVar(-2.0, 2.0, 0.0, GRB.CONTINUOUS, "x")
Dim y As GRBVar = model.AddVar(0.0, 3.0, 0.0, GRB.CONTINUOUS, "y")
' Add quadratic constraint x^2 + x*y + y = 0 with name c1
Dim constr As GRBQConstr = model.AddQConstr(x*x + x*y + y == 0, "c1")

GRBConstr AddRange(GRBLinExpr expr, double lower, double upper, string name)#

Add a single range constraint to a model. A range constraint states that the value of the input expression must be between the specified lower and upper bounds in any solution.

Note that range constraints are stored internally as equality constraints. We add an extra variable to the model to capture the range information. Thus, the Sense attribute on a range constraint will always be GRB.EQUAL. In particular introducing a range constraint

\[L \leq a^T x \leq U\]

is equivalent to adding a slack variable \(s\) and the following constraints

\[\begin{split}\begin{array}{rl} a^T x - s & = L \\ 0 \leq s & \leq U - L. \end{array}\end{split}\]

Parameters:

expr – Linear expression for new range constraint.
lower – Lower bound for linear expression.
upper – Upper bound for linear expression.
name – Name for new constraint.

Returns:

New constraint object.

Example:

// Create variables
GRBVar x = model.AddVar(0.0, 10.0, 0.0, GRB.CONTINUOUS, "x");
GRBVar y = model.AddVar(-10.0, 3.0, 0.0, GRB.CONTINUOUS, "y");
// Create linear expression x + y
GRBLinExpr lexpr = new GRBLinExpr(0);
lexpr.AddTerm(1.0, x);
lexpr.AddTerm(1.0, y);
// Add range constraints -3 <= x + y <= 2 with name c1
GRBConstr constr = model.AddRange(lexpr, -3.0, 2.0, "c1");

' Create variables
Dim x As GRBVar = model.AddVar(0.0, 10.0, 0.0, GRB.CONTINUOUS, "x")
Dim y As GRBVar = model.AddVar(-10.0, 3.0, 0.0, GRB.CONTINUOUS, "y")
' Create linear expression x + y
Dim lexpr As GRBLinExpr = new GRBLinExpr(0)
lexpr.AddTerm(1.0, x)
lexpr.AddTerm(1.0, y)
' Add range constraints -3 <= x + y <= 2 with name c1
Dim constr As GRBConstr = model.AddRange(lexpr, -3.0, 2.0, "c1")

GRBConstr[] AddRanges(GRBLinExpr[] exprs, double[] lower, double[] upper, string[] names)#

Add new range constraints to a model. A range constraint states that the value of the input expression must be between the specified lower and upper bounds in any solution.

Parameters:

exprs – Linear expressions for the new range constraints.
lower – Lower bounds for linear expressions.
upper – Upper bounds for linear expressions.
name – Names for new range constraints.
count – Number of range constraints to add.

Returns:

Array of new constraint objects.

Example:

// Create variables
GRBVar x = model.AddVar(0.0, GRB.INFINITY, 0.0, GRB.CONTINUOUS, "x");
GRBVar y = model.AddVar(0.0, GRB.INFINITY, 0.0, GRB.CONTINUOUS, "y");
// Create linear expressions x + y and x - 2.0 * y
GRBLinExpr lexpr1 = new GRBLinExpr(0);
lexpr1.AddTerm(1.0, x);
lexpr1.AddTerm(1.0, y);
GRBLinExpr lexpr2 = new GRBLinExpr(0);
lexpr2.AddTerm(1.0, x);
lexpr2.AddTerm(-2.0, y);
double[] lower = {-3.0, 2.0};
double[] upper = {-1.0, 5.0};
string[] names = {"c1", "c2"};
// Add constraints -3.0 <= x + y <= 2.0 and -1.0 <= x - 2.0 * y <= 5.0
GRBConstr[] constrs = model.AddRanges(lexprs, lower, upper, names);

' Create variables
Dim x As GRBVar = model.AddVar(0.0, GRB.INFINITY, 0.0, GRB.CONTINUOUS, "x")
Dim y As GRBVar = model.AddVar(0.0, GRB.INFINITY, 0.0, GRB.CONTINUOUS, "y")
' Create linear expressions x + y and x - 2.0 * y
Dim lexpr1 As GRBLinExpr = New GRBLinExpr(0)
lexpr1.AddTerm(1.0, x)
lexpr1.AddTerm(1.0, y)
Dim lexpr2 As GRBLinExpr = New GRBLinExpr(0)
lexpr2.AddTerm(1.0, x)
lexpr2.AddTerm(-2.0, y)
Dim lower As Double() = New Double() {-3.0, 2.0}
Dim upper As Double() = New Double() {-1.0, 5.0}
Dim names As String() = New String() {"c1", "c2"}
' Add constraints -3.0 <= x + y <= 2.0 and -1.0 <= x - 2.0 * y <= 5.0
Dim constrs As GRBConstr() = model.AddRanges(lexprs, lower, upper, names)

GRBSOS AddSOS(GRBVar[] vars, double[] weights, int type)#

Add an SOS constraint to the model. Please refer to this section for details on SOS constraints.

Parameters:

vars – Array of variables that participate in the SOS constraint.
weights – Weights for the variables in the SOS constraint.
type – SOS type (can be GRB.SOS_TYPE1 or GRB.SOS_TYPE2).

Returns:

New SOS constraint.

Example:

// Create variables
GRBVar x = model.AddVar(0.0, GRB.INFINITY, 0.0, GRB.CONTINUOUS, "x");
GRBVar y = model.AddVar(0.0, GRB.INFINITY, 0.0, GRB.CONTINUOUS, "y");
// Create helper arrays
GRBVar[] vars = {x, y};
double[] weights = {1.0, 2.0};
// Add SOS1 constraint over x and y
GRBSOS constr = model.AddSOS(vars, weights, GRB.SOS_TYPE1);

' Create variables
Dim x As GRBVar = model.AddVar(0.0, GRB.INFINITY, 0.0, GRB.CONTINUOUS, "x")
Dim y As GRBVar = model.AddVar(0.0, GRB.INFINITY, 0.0, GRB.CONTINUOUS, "y")
' Create helper arrays
Dim vars As GRBVar() = New GRBVar() {x, y}
Dim weights As Double() = New Double() {1.0, 2.0}
' Add SOS1 constraint over x and y
Dim constr As GRBSOS = model.AddSOS(vars, weights, GRB.SOS_TYPE1)

GRBVar AddVar(double lb, double ub, double obj, char type, string name)#

Add a single decision variable to a model; non-zero entries will be added later.

Parameters:

lb – Lower bound for new variable.
ub – Upper bound for new variable.
obj – Objective coefficient for new variable.
type – Variable type for new variable (GRB.CONTINUOUS, GRB.BINARY, GRB.INTEGER, GRB.SEMICONT, or GRB.SEMIINT).
name – Name for new variable.

Returns:

New variable object.

Example:

// Create variable
GRBVar x = model.AddVar(0.0, GRB.INFINITY, 0.0, GRB.CONTINUOUS, "x");

' Create variable
Dim x As GRBVar = model.AddVar(0.0, GRB.INFINITY, 0.0, GRB.CONTINUOUS, "x")

GRBVar AddVar(double lb, double ub, double obj, char type, GRBConstr[] constrs, double[] coeffs, string name)#

Add a single decision variable and the associated non-zero coefficients to a model.

Parameters:

lb – Lower bound for new variable.
ub – Upper bound for new variable.
obj – Objective coefficient for new variable.
type – Variable type for new variable (GRB.CONTINUOUS, GRB.BINARY, GRB.INTEGER, GRB.SEMICONT, or GRB.SEMIINT).
constrs – Array of constraints in which the variable participates.
coeffs – Array of coefficients for each constraint in which the variable participates. The lengths of the constrs and coeffs arrays must be identical.
name – Name for new variable.

Returns:

New variable object.

Example:

// Add 3 trivial linear constraints to model
GRBConstr[] constrs = model.AddConstrs(3);
// Constraint coefficients for variable x
double[] coeffs = {1.0, 2.0, 3.0};
// Add variable x with coeffs 1.0, 2.0, 3.0 to the newly created trivial constraints
GRBVar x = model.AddVar(0.0, GRB.INFINITY, 0.0, GRB.CONTINUOUS, constrs, coeffs, "x");

' Add 3 trivial linear constraints to model
Dim constrs As GRBConstr() = model.AddConstrs(3)
' Constraint coefficients for variable x
Dim coeffs As Double() = New Double() {1.0, 2.0, 3.0}
' Add variable x with coeffs 1.0, 2.0, 3.0 to the newly created trivial constraints
Dim x As GRBVar = model.AddVar(0.0, GRB.INFINITY, 0.0, GRB.CONTINUOUS, constrs, coeffs, "x")

GRBVar AddVar(double lb, double ub, double obj, char type, GRBColumn col, string name)#

Add a variable to a model. This signature allows you to specify the set of constraints to which the new variable belongs using a GRBColumn object.

Parameters:

lb – Lower bound for new variable.
ub – Upper bound for new variable.
obj – Objective coefficient for new variable.
type – Variable type for new variable (GRB.CONTINUOUS, GRB.BINARY, GRB.INTEGER, GRB.SEMICONT, or GRB.SEMIINT).
col – GRBColumn object for specifying a set of constraints to which new variable belongs.
name – Name for new variable.

Returns:

New variable object.

Example:

// Add 3 trivial linear constraints to model
GRBConstr[] constrs = model.AddConstrs(3);
// Constraint coefficients for variable x
double[] coeffs = {1.0, 2.0, 3.0};
// Create and fill GRBColumn object
GRBColumn col = new GRBColumn();
col.AddTerms(coeffs, constrs);
// Add variable x with coefs 1.0, 2.0, 3.0 to the newly created trivial constraints
GRBVar x = model.AddVar(0.0, GRB.INFINITY, 0.0, GRB.CONTINUOUS, col, "x");

' Add 3 trivial linear constraints to model
Dim constrs As GRBConstr() = model.AddConstrs(3)
' Constraint coefficients for variable x
Dim coeffs As Double() = {1.0, 2.0, 3.0}
' Create and fill GRBColumn object
Dim col As GRBColumn = New GRBColumn()
col.AddTerms(coeffs, constrs)
' Add variable x with coefs 1.0, 2.0, 3.0 to the newly created trivial constraints
Dim x As GRBVar = model.AddVar(0.0, GRB.INFINITY, 0.0, GRB.CONTINUOUS, col, "x")

GRBVar[] AddVars(int count, char type)#

Add count new decision variables to a model. All associated attributes take their default values, except the variable type, which is specified as an argument.

Parameters:

count – Number of variables to add.
type – Variable type for new variables (GRB.CONTINUOUS, GRB.BINARY, GRB.INTEGER, GRB.SEMICONT, or GRB.SEMIINT).

Returns:

Array of new variable objects.

Example:

// Add 3 binary variables
GRBVar[] x = model.AddVars(3, GRB.BINARY);

' Add 3 binary variables
Dim x As GRBVar() = model.AddVars(3, GRB.BINARY)

GRBVar[] AddVars(double[] lb, double[] ub, double[] obj, char[] type, string[] names)#

Add new decision variables to a model. The number of added variables is determined by the length of the input arrays (which must be consistent across all arguments).

Parameters:

lb – Lower bounds for new variables. Can be null, in which case the variables get lower bounds of 0.0.
ub – Upper bounds for new variables. Can be null, in which case the variables get infinite upper bounds.
obj – Objective coefficients for new variables. Can be null, in which case the variables get objective coefficients of 0.0.
type – Variable types for new variables (GRB.CONTINUOUS, GRB.BINARY, GRB.INTEGER, GRB.SEMICONT, or GRB.SEMIINT). Can be null, in which case the variables are assumed to be continuous.
names – Names for new variables. Can be null, in which case all variables are given default names.

Returns:

Array of new variable objects.

Example:

// Create 3 variables with default lower bound and default type
double[] ub    = {1, 1, 2};
double[] obj   = {-2, -1, -1};
string[] names = {"x0", "x1", "x2"};

GRBVar[] x = model.AddVars(null, ub, obj, null, names);

' Create 3 variables with default lower bound and default type
Dim ub As Double()    = New Double() {1, 1, 2}
Dim obj As Double()   = New Double() {-2, -1, -1}
Dim names As String() = New String() {"x0", "x1", "x2"}

Dim x As GRBVar() = model.AddVars(Nothing, ub, obj, Nothing, names)

GRBVar[] AddVars(double[] lb, double[] ub, double[] obj, char[] type, string[] names, int start, int len)#

Add new decision variables to a model. This signature allows you to use arrays to hold the various variable attributes (lower bound, upper bound, etc.), without forcing you to add a variable for each entry in the array. The start and len arguments allow you to specify which variables to add.

Parameters:

lb – Lower bounds for new variables. Can be null, in which case the variables get lower bounds of 0.0.
ub – Upper bounds for new variables. Can be null, in which case the variables get infinite upper bounds.
obj – Objective coefficients for new variables. Can be null, in which case the variables get objective coefficients of 0.0.
type – Variable types for new variables (GRB.CONTINUOUS, GRB.BINARY, GRB.INTEGER, GRB.SEMICONT, or GRB.SEMIINT). Can be null, in which case the variables are assumed to be continuous.
names – Names for new variables. Can be null, in which case all variables are given default names.
start – The first variable in the list to add.
len – The number of variables to add.

Returns:

Array of new variable objects.

Example:

// Create 2 variables with default lower bound and default type
double[] ub    = {1, 1, 2};
double[] obj   = {-2, -1, -1};
string[] names = {"x0", "x1", "x2"};

GRBVar[] x = model.AddVars(null, ub, obj, null, names, 0, 2);

' Create 3 variables with default lower bound and default type
Dim ub As Double()    = New Double() {1, 1, 2}
Dim obj As Double()   = New Double() {-2, -1, -1}
Dim names As String() = New String() {"x0", "x1", "x2"}

Dim x As GRBVar() = model.AddVars(Nothing, ub, obj, Nothing, names, 0, 3)

GRBVar[] AddVars(double[] lb, double[] ub, double[] obj, char[] type, string[] names, GRBColumn[] col)#

Add new decision variables to a model. This signature allows you to specify the list of constraints to which each new variable belongs using an array of GRBColumn objects.

Parameters:

lb – Lower bounds for new variables. Can be null, in which case the variables get lower bounds of 0.0.
ub – Upper bounds for new variables. Can be null, in which case the variables get infinite upper bounds.
obj – Objective coefficients for new variables. Can be null, in which case the variables get objective coefficients of 0.0.
type – Variable types for new variables (GRB.CONTINUOUS, GRB.BINARY, GRB.INTEGER, GRB.SEMICONT, or GRB.SEMIINT). Can be null, in which case the variables are assumed to be continuous.
names – Names for new variables. Can be null, in which case all variables are given default names.
cols – GRBColumn objects for specifying a set of constraints to which each new column belongs.

Returns:

Array of new variable objects.

Example:

// Create 3 variables with default lower bound and default type
double[] ub    = {1, 1, 2};
double[] obj   = {-2, -1, -1};
string[] names = {"x0", "x1", "x2"};
// Create an array of previously created GRBColumn objects
GRBColumn[] col = {col1, col2, col3};

GRBVar[] x = model.AddVars(null, ub, obj, null, names, col);

' Create 3 variables with default lower bound and default type
Dim ub As Double()    = New Double() {1, 1, 2}
Dim obj As Double()   = New Double() {-2, -1, -1}
Dim names As String() = New String() {"x0", "x1", "x2"}
' Create an array of previously created GRBColumn objects
Dim cols As GRBColumn() = New GRBColumn() {col1, col2, col3}

Dim x As GRBVar() = model.AddVars(Nothing, ub, obj, Nothing, names, col)

void ChgCoeff(GRBConstr constr, GRBVar var, double newvalue)#

Change one coefficient in the model. The desired change is captured using a GRBVar object, a GRBConstr object, and a desired coefficient for the specified variable in the specified constraint. If you make multiple changes to the same coefficient, the last one will be applied.

Note that, due to our lazy update approach, the change won’t actually take effect until you update the model (using GRBModel.Update), optimize the model (using GRBModel.Optimize), or write the model to disk (using GRBModel.Write).

Parameters:

constr – Constraint for coefficient to be changed.
var – Variable for coefficient to be changed.
newvalue – Desired new value for coefficient.

Example:

// Change coefficient of variable x in constraint c1 to 2.0
model.ChgCoeff(c1, x, 2.0);

' Change coefficient of variable x in constraint c1 to 2.0
model.ChgCoeff(c1, x, 2.0)

void ChgCoeffs(GRBConstr[] constrs, GRBVar[] vars, double[] vals)#

Change a list of coefficients in the model. Each desired change is captured using a GRBVar object, a GRBConstr object, and a desired coefficient for the specified variable in the specified constraint. The entries in the input arrays each correspond to a single desired coefficient change. The lengths of the input arrays must all be the same. If you make multiple changes to the same coefficient, the last one will be applied.

Parameters:

constrs – Constraints for coefficients to be changed.
vars – Variables for coefficients to be changed.
vals – Desired new values for coefficients.

Example:

// Create arrays using previously created constraints and variables
GRBConstr[] constrs = {c1, c2, c3};
GRBVar[] vars = {x, y, z};
double[] vals = {1.0, 2.0, 3.0};
// Change coefficients of variables x, y, z in constraints c1, c2, and c3, respectively
model.ChgCoeffs(constrs, vars, vals);

' Create arrays using previously created constraints and variables
Dim constrs As GRBConstr() = New GRBConstr() {c1, c2, c3}
Dim vars As GRBVar() = New GRBVar() {x, y, z}
Dim vals As Double() = New Double() {1.0, 2.0, 3.0}
' Change coefficients of variables x, y, z in constraints c1, c2, and c3, respectively
model.ChgCoeffs(constrs, vars, vals)

void ComputeIIS()#

Compute an Irreducible Inconsistent Subsystem (IIS).

An IIS is a subset of the constraints and variable bounds with the following properties:

It is still infeasible, and
If a single constraint or bound is removed, the subsystem becomes feasible.

Note that an infeasible model may have multiple IISs. The one returned by Gurobi is not necessarily the smallest one; there may exist others with fewer constraints or bounds.

IIS results are returned in a number of attributes: IISConstr, IISLB, IISUB, IISSOS, IISQConstr, and IISGenConstr. Each indicates whether the corresponding model element is a member of the computed IIS.

Note that for models with general function constraints, piecewise-linear approximation of the constraints may cause unreliable IIS results.

The IIS log provides information about the progress of the algorithm, including a guess at the eventual IIS size.

If an IIS computation is interrupted before completion, Gurobi will return the smallest infeasible subsystem found to that point.

The IISConstrForce, IISLBForce, IISUBForce, IISSOSForce, IISQConstrForce, and IISGenConstrForce attributes allow you mark model elements to either include or exclude from the computed IIS. Setting the attribute to 1 forces the corresponding element into the IIS, setting it to 0 forces it out of the IIS, and setting it to -1 allows the algorithm to decide.

To give an example of when these attributes might be useful, consider the case where an initial model is known to be feasible, but it becomes infeasible after adding constraints or tightening bounds. If you are only interested in knowing which of the changes caused the infeasibility, you can force the unmodified bounds and constraints into the IIS. That allows the IIS algorithm to focus exclusively on the new constraints, which will often be substantially faster.

Note that setting any of the Force attributes to 0 may make the resulting subsystem feasible, which would then make it impossible to construct an IIS. Trying anyway will result in a IIS_NOT_INFEASIBLE error. Similarly, setting this attribute to 1 may result in an IIS that is not irreducible. More precisely, the system would only be irreducible with respect to the model elements that have force values of -1 or 0.

This method populates the IISConstr, IISQConstr, and IISGenConstr constraint attributes, the IISSOS, SOS attribute, and the IISLB and IISUB variable attributes. You can also obtain information about the results of the IIS computation by writing a .ilp format file (see GRBModel.Write). This file contains only the IIS from the original model.

Use the IISMethod parameter to adjust the behavior of the IIS algorithm.

Note that this method can be used to compute IISs for both continuous and MIP models.

Example:

// Compute IIS for infeasible model
if (model.Status == GRB.Status.INFEASIBLE) {
  model.ComputeIIS();
}

' Compute IIS for infeasible model
If (model.Status = GRB.Status.INFEASIBLE) Then
  model.ComputeIIS()
End If

void DiscardConcurrentEnvs()#

Discard concurrent environments for a model.

The concurrent environments created by GetConcurrentEnv will be used by every subsequent call to the concurrent optimizer until the concurrent environments are discarded.

Example:

env0 = model.GetConcurrentEnv(0);
env1 = model.GetConcurrentEnv(1);

env0.Set(GRB.IntParam.Method, 0);
env1.Set(GRB.IntParam.Method, 1);

model.Optimize();
model.DiscardConcurrentEnvs();

env0 = model.GetConcurrentEnv(0)
env1 = model.GetConcurrentEnv(1)

env0.Set(GRB.IntParam.Method, 0)
env1.Set(GRB.IntParam.Method, 1)

model.Optimize()
model.DiscardConcurrentEnvs()

void DiscardMultiobjEnvs()#

Discard all multi-objective environments associated with the model, thus restoring multi objective optimization to its default behavior.

Please refer to the discussion of Multiple Objectives for information on how to specify multiple objective functions and control the trade-off between them.

Use GetMultiobjEnv to create a multi-objective environment.

Example:

env0 = model.GetMultiobjEnv(0);
env1 = model.GetMultiobjEnv(1);

env0.Set(GRB.IntParam.Method, 0);
env1.Set(GRB.IntParam.Method, 1);

model.Optimize();
model.DiscardMultiobjEnvs();

env0 = model.GetMultiobjEnv(0)
env1 = model.GetMultiobjEnv(1)

env0.Set(GRB.IntParam.Method, 0)
env1.Set(GRB.IntParam.Method, 1)

model.Optimize()
model.DiscardMultiobjEnvs()

void Dispose()#

Release the resources associated with a GRBModel object. While the .NET garbage collector will eventually reclaim these resources, we recommend that you call the Dispose method when you are done using a model.

You should not attempt to use a GRBModel object after calling Dispose on it.

Example:

GRBEnv env = new GRBEnv();
GRBModel model = new GRBModel(env);
// ...
model.Optimize();
model.Dispose();
env.Dispose();

Dim env As GRBEnv = New GRBEnv()
Dim model As GRBModel = New GRBModel(env)
' ...
model.Optimize()
model.Dispose()
env.Dispose()

double FeasRelax(int relaxobjtype, boolean minrelax, GRBVar[] vars, double[] lbpen, double[] ubpen, GRBConstr[] constrs, double[] rhspen)#

Modifies the GRBModel object to create a feasibility relaxation. Note that you need to call Optimize on the result to compute the actual relaxed solution.

The feasibility relaxation is a model that, when solved, minimizes the amount by which the solution violates the bounds and linear constraints of the original model. This method provides a number of options for specifying the relaxation.

If you specify relaxobjtype=0, the objective of the feasibility relaxation is to minimize the sum of the weighted magnitudes of the bound and constraint violations. The lbpen, ubpen, and rhspen arguments specify the cost per unit violation in the lower bounds, upper bounds, and linear constraints, respectively.

If you specify relaxobjtype=1, the objective of the feasibility relaxation is to minimize the weighted sum of the squares of the bound and constraint violations. The lbpen, ubpen, and rhspen arguments specify the coefficients on the squares of the lower bound, upper bound, and linear constraint violations, respectively.

If you specify relaxobjtype=2, the objective of the feasibility relaxation is to minimize the weighted count of bound and constraint violations. The lbpen, ubpen, and rhspen arguments specify the cost of violating a lower bound, upper bound, and linear constraint, respectively.

To give an example, if a constraint with rhspen value p is violated by 2.0, it would contribute 2*p to the feasibility relaxation objective for relaxobjtype=0, it would contribute 2*2*p for relaxobjtype=1, and it would contribute p for relaxobjtype=2.

The minrelax argument is a boolean that controls the type of feasibility relaxation that is created. If minrelax=false, optimizing the returned model gives a solution that minimizes the cost of the violation. If minrelax=true, optimizing the returned model finds a solution that minimizes the original objective, but only from among those solutions that minimize the cost of the violation. Note that feasRelax must solve an optimization problem to find the minimum possible relaxation when minrelax=true, which can be quite expensive.

There are two signatures for this method. The more complex one takes a list of variables and constraints, as well as penalties associated with relaxing the corresponding lower bounds, upper bounds, and constraints. If a variable or constraint is not included in one of these lists, the associated bounds or constraints may not be violated. The simpler signature takes a pair of boolean arguments, vrelax and crelax, that indicate whether variable bounds and/or constraints can be violated. If vrelax/crelax is true, then every bound/constraint is allowed to be violated, respectively, and the associated cost is 1.0.

For an example of how this routine transforms a model, and more details about the variables and constraints created, please see this section.

Note that this is a destructive method: it modifies the model on which it is invoked. If you don’t want to modify your original model, use the GRBModel constructor to create a copy before invoking this method.

Create a feasibility relaxation model.

Parameters:

relaxobjtype – The cost function used when finding the minimum cost relaxation.
minrelax – The type of feasibility relaxation to perform.
vars – Variables whose bounds are allowed to be violated.
lbpen – Penalty for violating a variable lower bound. One entry for each variable in argument vars.
ubpen – Penalty for violating a variable upper bound. One entry for each variable in argument vars.
constrs – Linear constraints that are allowed to be violated.
rhspen – Penalty for violating a linear constraint. One entry for each constraint in argument constrs.

Returns:

Zero if minrelax is false. If minrelax is true, the return value is the objective value for the relaxation performed. If the value is less than 0, it indicates that the method failed to create the feasibility relaxation.

Example:

// Compute feasibility relaxation for infeasible model
if (model.Status == GRB.Status.INFEASIBLE) {
  GRBVar[] vars = model.GetVars();
  double[] ubpen = new double[model.NumVars];
  for (int i = 0; i < model.NumVars; i++) {
    ubpen[i] = 1.0;
  }
  model.FeasRelax(0, false, vars, null, ubpen, null, null);
  model.Optimize();
}

' Compute feasibility relaxation for infeasible model
If model.Status = GRB.Status.INFEASIBLE Then
  Dim vars As GRBVar() = model.GetVars()
  Dim ubpen As Double() = New Double(model.NumVars)
  For i As Integer = 0 To model.NumVars
    ubpen(i) = 1.0
  Next
  model.FeasRelax(0, false, vars, Nothing, ubpen, Nothing, Nothing)
  model.Optimize()
End If

double FeasRelax(int relaxobjtype, boolean minrelax, boolean vrelax, boolean crelax)#

Modifies the GRBModel object to create a feasibility relaxation. Note that you need to call Optimize on the result to compute the actual relaxed solution.

For an example of how this routine transforms a model, and more details about the variables and constraints created, please see this section.

Simplified method for creating a feasibility relaxation model.

Parameters:

relaxobjtype – The cost function used when finding the minimum cost relaxation.
minrelax – The type of feasibility relaxation to perform.
vrelax – Indicates whether variable bounds can be relaxed (with a cost of 1.0 for any violations.
crelax – Indicates whether linear constraints can be relaxed (with a cost of 1.0 for any violations.

Returns:

Example:

// Compute feasibility relaxation for infeasible model
if (model.Status == GRB.Status.INFEASIBLE) {
  model.FeasRelax(1, false, false, true);
  model.Optimize();
}

' Compute feasibility relaxation for infeasible model
If model.Status = GRB.Status.INFEASIBLE Then
  model.FeasRelax(1, false, false, true)
  model.Optimize()
End If

GRBModel FixedModel()#

Create the fixed model associated with a MIP model. A solution (e.g. obtained through a call to the Optimize method) or a MIP start must be available in the MIP model. If no solution is available, the MIP start specified with StartNumber is used.

In the model, each integer variable is fixed to the value that variable takes in the MIP solution or MIP start. In addition, continuous variables may be fixed to satisfy SOS or general constraints. The result is that the model has neither integrality constraints, SOS constraints, nor general constraints any more.

Note

While the fixed problem is always a continuous model, it may contain a non-convex quadratic objective or non-convex quadratic constraints. As a result, it may still be solved using the MIP algorithm.

Note

On a multi-objective model, all but the first objectives are ignored. All scenarios are ignored as well, if any.

Returns:

Fixed model associated with calling object.

Example:

GRBModel fixedModel = model.FixedModel();

Dim fixedModel As GRBModel = model.FixedModel()

void ConvertToFixed()#

Turn the MIP model into a continuous one, in place. A solution (e.g. obtained through a call to the Optimize method) or a MIP start must be available in the MIP model. If no solution is available, the MIP start specified with StartNumber is used.

Note

While the fixed problem is always a continuous model, it may contain a non-convex quadratic objective or non-convex quadratic constraints. As a result, it may still be solved using the MIP algorithm.

Note

An error is raised if the converted model contains more than one objective or scenario, or if the model contains concurrent environments or tune environments.

Example:

model.ConvertToFixed();

model.ConvertToFixed()

double Get(GRB.DoubleParam param)#

Query the value of a double-valued parameter.

Parameters:

param – The parameter being queried.

Returns:

The current value of the requested parameter.

Example:

// Get value of TimeLimit parameter
double val = model.Get(GRB.DoubleParam.TimeLimit);

' Get value of TimeLimit parameter
Dim val As Double = model.Get(GRB.DoubleParam.TimeLimit)

int Get(GRB.IntParam param)#

Query the value of an int-valued parameter.

Parameters:

param – The parameter being queried.

Returns:

The current value of the requested parameter.

Example:

// Get value of PumpPasses parameter
int val = model.Get(GRB.IntParam.PumpPasses);

' Get value of PumpPasses parameter
Dim val As Integer = model.Get(GRB.IntParam.PumpPasses)

string Get(GRB.StringParam param)#

Query the value of a string-valued parameter.

Parameters:

param – The parameter being queried.

Returns:

The current value of the requested parameter.

Example:

// Get value of LogFile parameter
string val = model.Get(GRB.StringParam.LogFile);

' Get value of LogFile parameter
Dim val As String = model.Get(GRB.StringParam.LogFile)

char[] Get(GRB.CharAttr attr, GRBVar[] vars)#

Query a char-valued variable attribute for an array of variables.

Parameters:

attr – The attribute being queried.
vars – The variables whose attribute values are being queried.

Returns:

The current values of the requested attribute for each input variable.

Example:

// Get variable type attribute values
GRBVar[] vars = model.GetVars();
char[] vtype = model.Get(GRB.CharAttr.VType, vars);

' Get variable type attribute values
Dim vars As GRBVar() = model.GetVars()
Dim vtype As Char() = model.Get(GRB.CharAttr.VType, vars)

char[] Get(GRB.CharAttr attr, GRBVar[] vars, int start, int len)#

Query a char-valued variable attribute for a sub-array of variables.

Parameters:

attr – The attribute being queried.
vars – A one-dimensional array of variables whose attribute values are being queried.
start – The index of the first variable of interest in the list.
len – The number of variables.

Returns:

The current values of the requested attribute for each input variable.

Example:

// Get variable type attribute values for variables indexed from 0 to 2
GRBVar[] vars = model.GetVars();
char[] vtype = model.Get(GRB.CharAttr.VType, vars, 0, 3);

' Get variable type attribute values for variables indexed from 0 to 2
Dim vars As GRBVar() = model.GetVars()
Dim vtype As Char() = model.Get(GRB.CharAttr.VType, vars, 0, 3)

char[,] Get(GRB.CharAttr attr, GRBVar[,] vars)#

Query a char-valued variable attribute for a two-dimensional array of variables.

Parameters:

attr – The attribute being queried.
vars – A two-dimensional array of variables whose attribute values are being queried.

Returns:

The current values of the requested attribute for each input variable.

Example:

// Get variable type attribute values
GRBVar[,] vars = new GRBVar[10, 10];
// ...
char[,] vtype = model.Get(GRB.CharAttr.VType, vars);

' Get variable type attribute values
Dim vars As GRBVar(,) = New GRBVar(10, 10)
' ...
Dim vtype As Char(,) = model.Get(GRB.CharAttr.VType, vars)

char[,,] Get(GRB.CharAttr attr, GRBVar[,,] vars)#

Query a char-valued variable attribute for a three-dimensional array of variables.

Parameters:

attr – The attribute being queried.
vars – A three-dimensional array of variables whose attribute values are being queried.

Returns:

The current values of the requested attribute for each input variable.

Example:

// Get variable type attribute values
GRBVar[,,] vars = new GRBVar[10, 10, 10];
// ...
char[,,] vtype = model.Get(GRB.CharAttr.VType, vars);

' Get variable type attribute values
Dim vars As GRBVar(,,) = New GRBVar(10, 10, 10)
' ...
Dim vtype As Char(,,) = model.Get(GRB.CharAttr.VType, vars)

char[] Get(GRB.CharAttr attr, GRBConstr[] constrs)#

Query a char-valued constraint attribute for an array of constraints.

Parameters:

attr – The attribute being queried.
constrs – The constraints whose attribute values are being queried.

Returns:

The current values of the requested attribute for each input constraint.

Example:

// Get sense attribute values for all linear constraints
GRBConstr[] constrs = model.GetConstrs();
char[] sense = model.Get(GRB.CharAttr.Sense, constrs);

' Get sense attribute values for all linear constraints
Dim constrs As GRBConstr() = model.GetConstrs()
Dim sense As Char() = model.Get(GRB.CharAttr.Sense, constrs)

char[] Get(GRB.CharAttr attr, GRBConstr[] constrs, int start, int len)#

Query a char-valued constraint attribute for a sub-array of constraints.

Parameters:

attr – The attribute being queried.
constrs – A one-dimensional array of constraints whose attribute values are being queried.
start – The index of the first constraint of interest in the list.
len – The number of constraints.

Returns:

The current values of the requested attribute for each input constraint.

Example:

// Get linear constraint sense attribute values for constraints indexed from 0 to 2
GRBConstr[] constrs = model.GetConstrs();
char[] sense = model.Get(GRB.CharAttr.Sense, constrs, 0, 3);

' Get linear constraint sense attribute values for constraints indexed from 0 to 2
Dim constrs As GRBConstr() = model.GetConstrs()
Dim sense As Char() = model.Get(GRB.CharAttr.Sense, constrs, 0, 3)

char[,] Get(GRB.CharAttr attr, GRBConstr[,] constrs)#

Query a char-valued constraint attribute for a two-dimensional array of constraints.

Parameters:

attr – The attribute being queried.
constrs – A two-dimensional array of constraints whose attribute values are being queried.

Returns:

The current values of the requested attribute for each input constraint.

Example:

// Get linear constraint sense attribute values
GRBConstr[,] constrs = new GRBConstr[10, 10];
// ...
char[,] sense = model.Get(GRB.CharAttr.Sense, constrs);

' Get linear constraint sense attribute values
Dim constrs As GRBConstr(,) = New GRBConstr(10, 10)
' ...
Dim sense As Char(,) = model.Get(GRB.CharAttr.Sense, constrs)

char[,,] Get(GRB.CharAttr attr, GRBConstr[,,] constrs)#

Query a char-valued constraint attribute for a three-dimensional array of constraints.

Parameters:

attr – The attribute being queried.
constrs – A three-dimensional array of constraints whose attribute values are being queried.

Returns:

The current values of the requested attribute for each input constraint.

Example:

// Get linear constraint sense attribute values
GRBConstr[,,] constrs = new GRBConstr[10, 10, 10];
// ...
char[,,] sense = model.Get(GRB.CharAttr.Sense, constrs);

' Get linear constraint sense attribute values
Dim constrs As GRBConstr(,,) = New GRBConstr(10, 10, 10)
' ...
Dim sense As Char(,,) = model.Get(GRB.CharAttr.Sense, constrs)

char[] Get(GRB.CharAttr attr, GRBQConstr[] qconstrs)#

Query a char-valued quadratic constraint attribute for an array of quadratic constraints.

Parameters:

attr – The attribute being queried.
qconstrs – The quadratic constraints whose attribute values are being queried.

Returns:

The current values of the requested attribute for each input quadratic constraint.

Example:

// Get sense attribute values for all quadratic constraints
GRBQConstr[] constrs = model.GetQConstrs();
char[] qsense = model.Get(GRB.CharAttr.QCSense, constrs);

' Get sense attribute values for all quadratic constraints
Dim constrs As GRBQConstr() = model.GetQConstrs()
Dim qsense As Char() = model.Get(GRB.CharAttr.QCSense, constrs)

char[] Get(GRB.CharAttr attr, GRBQConstr[] qconstrs, int start, int len)#

Query a char-valued quadratic constraint attribute for a sub-array of quadratic constraints.

Parameters:

attr – The attribute being queried.
qconstrs – A one-dimensional array of quadratic constraints whose attribute values are being queried.
start – The index of the first quadratic constraint of interest in the list.
len – The number of quadratic constraints.

Returns:

The current values of the requested attribute for each input quadratic constraint.

Example:

// Get sense attribute values for quadratic constraints indexed from 0 to 2
GRBQConstr[] constrs = model.GetQConstrs();
char[] qsense = model.Get(GRB.CharAttr.QCSense, constrs, 0, 3);

' Get sense attribute values for quadratic constraints indexed from 0 to 2
Dim constrs As GRBQConstr() = model.GetQConstrs()
Dim qsense As Char() = model.Get(GRB.CharAttr.QCSense, constrs, 0, 3)

char[,] Get(GRB.CharAttr attr, GRBQConstr[,] qconstrs)#

Query a char-valued quadratic constraint attribute for a two-dimensional array of quadratic constraints.

Parameters:

attr – The attribute being queried.
qconstrs – A two-dimensional array of quadratic constraints whose attribute values are being queried.

Returns:

The current values of the requested attribute for each input quadratic constraint.

Example:

// Get sense attribute values
GRBQConstr[,] constrs = new GRBQConstr[10, 10];
// ...
char[,] qsense = model.Get(GRB.CharAttr.QCSense, constrs);

' Get sense attribute values
Dim constrs As GRBQConstr(,) = New GRBQConstr(10, 10)
' ...
Dim qsense As Char(,) = model.Get(GRB.CharAttr.QCSense, constrs)

char[,,] Get(GRB.CharAttr attr, GRBQConstr[,,] qconstrs)#

Query a char-valued quadratic constraint attribute for a three-dimensional array of quadratic constraints.

Parameters:

attr – The attribute being queried.
qconstrs – A three-dimensional array of quadratic constraints whose attribute values are being queried.

Returns:

The current values of the requested attribute for each input quadratic constraint.

Example:

// Get sense attribute values
GRBQConstr[,,] constrs = new GRBQConstr[10, 10, 10];
// ...
char[,,] qsense = model.Get(GRB.CharAttr.QCSense, constrs);

' Get sense attribute values
Dim constrs As GRBQConstr(,,) = New GRBQConstr(10, 10, 10)
' ...
Dim qsense As Char(,,) = model.Get(GRB.CharAttr.QCSense, constrs)

char[,,] Get(GRB.CharAttr attr, GRBQConstr[,,] qconstrs)#

double Get(GRB.DoubleAttr attr)#

Query the value of a double-valued model attribute.

Parameters:

attr – The attribute being queried.

Returns:

The current value of the requested attribute.

Example:

// Get value ObjVal attribute
double val = model.Get(GRB.DoubleAttr.ObjVal);

' Get value ObjVal attribute
Dim val As Double = model.Get(GRB.DoubleAttr.ObjVal)

double[] Get(GRB.DoubleAttr attr, GRBVar[] vars)#

Query a double-valued variable attribute for an array of variables.

Parameters:

attr – The attribute being queried.
vars – The variables whose attribute values are being queried.

Returns:

The current values of the requested attribute for each input variable.

Example:

// Get lower bound attribute values of all variables
GRBVar[] vars = model.GetVars();
double[] lb = model.Get(GRB.DoubleAttr.LB, vars);

' Get lower bound attribute values of all variables
Dim vars As GRBVar() = model.GetVars()
Dim lb As Double() = model.Get(GRB.DoubleAttr.LB, vars)

double[] Get(GRB.DoubleAttr attr, GRBVar[] vars, int start, int len)#

Query a double-valued variable attribute for a sub-array of variables.

Parameters:

attr – The attribute being queried.
vars – A one-dimensional array of variables whose attribute values are being queried.
start – The index of the first variable of interest in the list.
len – The number of variables.

Returns:

The current values of the requested attribute for each input variable.

Example:

// Get lower bound attribute values for variables indexed from 0 to 2
GRBVar[] vars = model.GetVars();
double[] lb = model.Get(GRB.DoubleAttr.LB, vars, 0, 3);

' Get lower bound attribute values for variables indexed from 0 to 2
Dim vars As GRBVar() = model.GetVars()
Dim lb As Double() = model.Get(GRB.DoubleAttr.LB, vars, 0, 3)

double[,] Get(GRB.DoubleAttr attr, GRBVar[,] vars)#

Query a double-valued variable attribute for a two-dimensional array of variables.

Parameters:

attr – The attribute being queried.
vars – A two-dimensional array of variables whose attribute values are being queried.

Returns:

The current values of the requested attribute for each input variable.

Example:

// Get lower bound attribute values
GRBVar[,] vars = new GRBVar[10, 10];
// ...
double[,] lb = model.Get(GRB.DoubleAttr.LB, vars);

' Get lower bound attribute values
Dim vars As GRBVar(,) = New GRBVar(10, 10)
' ...
Dim lb As Double(,) = model.Get(GRB.DoubleAttr.LB, vars)

double[,,] Get(GRB.DoubleAttr attr, GRBVar[,,] vars)#

Query a double-valued variable attribute for a three-dimensional array of variables.

Parameters:

attr – The attribute being queried.
vars – A three-dimensional array of variables whose attribute values are being queried.

Returns:

The current values of the requested attribute for each input variable.

Example:

// Get lower bound attribute values
GRBVar[,,] vars = new GRBVar[10, 10, 10];
// ...
double[,,] lb = model.Get(GRB.DoubleAttr.LB, vars);

' Get lower bound attribute values
Dim vars As GRBVar(,,) = New GRBVar(10, 10, 10)
' ...
Dim lb As Double(,,) = model.Get(GRB.DoubleAttr.LB, vars)

double[] Get(GRB.DoubleAttr attr, GRBConstr[] constrs)#

Query a double-valued constraint attribute for an array of constraints.

Parameters:

attr – The attribute being queried.
constrs – The constraints whose attribute values are being queried.

Returns:

The current values of the requested attribute for each input constraint.

Example:

// Get RHS attribute values of all linear constraints
GRBConstr[] constrs = model.GetConstrs();
double[] rhs = model.Get(GRB.DoubleAttr.RHS, constrs);

' Get RHS attribute values of all linear constraints
Dim constrs As GRBConstr() = model.GetConstrs()
Dim rhs As Double() = model.Get(GRB.DoubleAttr.RHS, constrs)

double[] Get(GRB.DoubleAttr attr, GRBConstr[] constrs, int start, int len)#

Query a double-valued constraint attribute for a sub-array of constraints.

Parameters:

attr – The attribute being queried.
constrs – A one-dimensional array of constraints whose attribute values are being queried.
start – The first constraint of interest in the list.
len – The number of constraints.

Returns:

The current values of the requested attribute for each input constraint.

Example:

// Get RHS attribute values for linear constraints indexed from 0 to 2
GRBConstr[] constrs = model.GetConstrs();
double[] rhs = model.Get(GRB.DoubleAttr.RHS, constrs, 0, 3);

' Get RHS attribute values for linear constraints indexed from 0 to 2
Dim constrs As GRBConstr() = model.GetConstrs()
Dim rhs As Double() = model.Get(GRB.DoubleAttr.RHS, constrs, 0, 3)

double[,] Get(GRB.DoubleAttr attr, GRBConstr[,] constrs)#

Query a double-valued constraint attribute for a two-dimensional array of constraints.

Parameters:

attr – The attribute being queried.
constrs – A two-dimensional array of constraints whose attribute values are being queried.

Returns:

The current values of the requested attribute for each input constraint.

Example:

// Get RHS attribute values
GRBConstr[,] constrs = new GRBConstr[10, 10];
// ...
double[,] rhs = model.Get(GRB.DoubleAttr.RHS, constrs);

' Get RHS attribute values
Dim constrs As GRBConstr(,) = New GRBConstr(10, 10)
' ...
Dim rhs As Double(,) = model.Get(GRB.DoubleAttr.RHS, constrs)

double[,,] Get(GRB.DoubleAttr attr, GRBConstr[,,] constrs)#

Query a double-valued constraint attribute for a three-dimensional array of constraints.

Parameters:

attr – The attribute being queried.
constrs – A three-dimensional array of constraints whose attribute values are being queried.

Returns:

The current values of the requested attribute for each input constraint.

Example:

// Get RHS attribute values
GRBConstr[,,] constrs = new GRBConstr[10, 10, 10];
// ...
double[,,] rhs = model.Get(GRB.DoubleAttr.RHS, constrs);

' Get RHS attribute values
Dim constrs As GRBConstr(,,) = New GRBConstr(10, 10, 10)
' ...
Dim rhs As Double(,,) = model.Get(GRB.DoubleAttr.RHS, constrs)

double[] Get(GRB.DoubleAttr attr, GRBQConstr[] qconstrs)#

Query a double-valued quadratic constraint attribute for an array of quadratic constraints.

Parameters:

attr – The attribute being queried.
qconstrs – The quadratic constraints whose attribute values are being queried.

Returns:

The current values of the requested attribute for each input quadratic constraint.

Example:

// Get RHS attribute values of all quadratic constraints
GRBQConstr[] constrs = model.GetQConstrs();
double[] qrhs = model.Get(GRB.DoubleAttr.QCRHS, constrs);

' Get RHS attribute values of all quadratic constraints
Dim constrs As GRBQConstr() = model.GetQConstrs()
Dim qcrs As Double() = model.Get(GRB.DoubleAttr.QCRHS, constrs)

double[] Get(GRB.DoubleAttr attr, GRBQConstr[] qconstrs, int start, int len)#

Query a double-valued quadratic constraint attribute for a sub-array of quadratic constraints.

Parameters:

attr – The attribute being queried.
qconstrs – A one-dimensional array of quadratic constraints whose attribute values are being queried.
start – The first quadratic constraint of interest in the list.
len – The number of quadratic constraints.

Returns:

The current values of the requested attribute for each input quadratic constraint.

Example:

// Get RHS attribute values for quadratic constraints indexed from 0 to 2
GRBQConstr[] constrs = model.GetQConstrs();
double[] qrhs = model.Get(GRB.DoubleAttr.QCRHS, constrs, 0, 3);

' Get RHS attribute values for quadratic constraints indexed from 0 to 2
Dim constrs As GRBQConstr() = model.GetQConstrs()
Dim qcrs As Double() = model.Get(GRB.DoubleAttr.QCRHS, constrs, 0, 3)

double[,] Get(GRB.DoubleAttr attr, GRBQConstr[,] qconstrs)#

Query a double-valued quadratic constraint attribute for a two-dimensional array of quadratic constraints.

Parameters:

attr – The attribute being queried.
qconstrs – A two-dimensional array of quadratic constraints whose attribute values are being queried.

Returns:

The current values of the requested attribute for each input quadratic constraint.

Example:

// Get RHS attribute values
GRBQConstr[,] constrs = new GRBQConstr[10, 10];
// ..
double[,] qrhs = model.Get(GRB.DoubleAttr.QCRHS, constrs);

' Get RHS attribute values
Dim constrs As GRBQConstr(,) = New GRBQConstr(10, 10)
' ..
Dim qrhs As Double(,) = model.Get(GRB.DoubleAttr.QCRHS, constrs)

double[,,] Get(GRB.DoubleAttr attr, GRBQConstr[,,] qconstrs)#

Query a double-valued quadratic constraint attribute for a three-dimensional array of quadratic constraints.

Parameters:

attr – The attribute being queried.
qconstrs – A three-dimensional array of quadratic constraints whose attribute values are being queried.

Returns:

The current values of the requested attribute for each input quadratic constraint.

Example:

// Get RHS attribute values
GRBQConstr[,,] constrs = new GRBQConstr[10, 10, 10];
// ..
double[,,] qrhs = model.Get(GRB.DoubleAttr.QCRHS, constrs);

' Get RHS attribute values
Dim constrs As GRBQConstr(,,) = New GRBQConstr(10, 10, 10)
' ..
Dim qrhs As Double(,,) = model.Get(GRB.DoubleAttr.QCRHS, constrs)

int Get(GRB.IntAttr attr)#

Query the value of an int-valued model attribute.

Parameters:

attr – The attribute being queried.

Returns:

The current value of the requested attribute.

Example:

// Get number of variables in the model
int numvars = model.Get(GRB.IntAttr.NumVars);

' Get number of variables in the model
Dim numvars As Integer = model.Get(GRB.IntAttr.NumVars)

int[] Get(GRB.IntAttr attr, GRBVar[] vars)#

Query an int-valued variable attribute for an array of variables.

Parameters:

attr – The attribute being queried.
vars – The variables whose attribute values are being queried.

Returns:

The current values of the requested attribute for each input variable.

Example:

// Get VBasis attribute values of all variables
GRBVar[] vars = model.GetVars();
int[] vbasis = model.Get(GRB.IntAttr.VBasis, vars);

' Get VBasis attribute values of all variables
Dim vars As GRBVar() = model.GetVars()
Dim vbasis As Integer() = model.Get(GRB.IntAttr.VBasis, vars)

int[] Get(GRB.IntAttr attr, GRBVar[] vars, int start, int len)#

Query an int-valued variable attribute for a sub-array of variables.

Parameters:

attr – The attribute being queried.
vars – A one-dimensional array of variables whose attribute values are being queried.
start – The index of the first variable of interest in the list.
len – The number of variables.

Returns:

The current values of the requested attribute for each input variable.

Example:

// Get VBasis attribute values for variables indexed from 0 to 2
GRBVar[] vars = model.GetVars();
int[] vbasis = model.Get(GRB.IntAttr.VBasis, vars, 0, 3);

' Get VBasis attribute values for variables indexed from 0 to 2
Dim vars As GRBVar() = model.GetVars()
Dim vbasis As Integer() = model.Get(GRB.IntAttr.VBasis, vars, 0, 3)

int[,] Get(GRB.IntAttr attr, GRBVar[,] vars)#

Query an int-valued variable attribute for a two-dimensional array of variables.

Parameters:

attr – The attribute being queried.
vars – A two-dimensional array of variables whose attribute values are being queried.

Returns:

The current values of the requested attribute for each input variable.

Example:

// Get VBasis attribute values
GRBVar[,] vars = new GRBVar[10, 10];
// ...
int[,] vbasis = model.Get(GRB.IntAttr.VBasis, vars);

' Get VBasis attribute values
Dim vars As GRBVar(,) = new GRBVar(10, 10)
' ...
Dim vbasis As Integer(,) = model.Get(GRB.IntAttr.VBasis, vars)

int[,,] Get(GRB.IntAttr attr, GRBVar[,,] vars)#

Query an int-valued variable attribute for a three-dimensional array of variables.

Parameters:

attr – The attribute being queried.
vars – A three-dimensional array of variables whose attribute values are being queried.

Returns:

The current values of the requested attribute for each input variable.

Example:

// Get VBasis attribute values
GRBVar[,,] vars = new GRBVar[10, 10, 10];
// ...
int[,,] vbasis = model.Get(GRB.IntAttr.VBasis, vars);

' Get VBasis attribute values
Dim vars As GRBVar(,,) = new GRBVar(10, 10, 10)
' ...
Dim vbasis As Integer(,,) = model.Get(GRB.IntAttr.VBasis, vars)

int[] Get(GRB.IntAttr attr, GRBConstr[] constrs)#

Query an int-valued constraint attribute for an array of constraints.

Parameters:

attr – The attribute being queried.
constrs – The constraints whose attribute values are being queried.

Returns:

The current values of the requested attribute for each input constraint.

Example:

// Get CBasis attribute values of all linear constraints
GRBConstr[] constrs = model.GetConstrs();
int[] cbasis = model.Get(GRB.IntAttr.CBasis, constrs);

' Get CBasis attribute values of all linear constraints
Dim constrs As GRBConstr() = model.GetConstrs()
Dim cbasis As Integer() = model.Get(GRB.IntAttr.CBasis, constrs)

int[] Get(GRB.IntAttr attr, GRBConstr[] constrs, int start, int len)#

Query an int-valued constraint attribute for a sub-array of constraints.

Parameters:

attr – The attribute being queried.
constrs – A one-dimensional array of constraints whose attribute values are being queried.
start – The index of the first constraint of interest in the list.
len – The number of constraints.

Returns:

The current values of the requested attribute for each input constraint.

Example:

// Get CBasis attribute values for linear constraints indexed from 0 to 2
GRBConstr[] constrs = model.GetConstrs();
int[] cbasis = model.Get(GRB.IntAttr.CBasis, constrs, 0, 3);

' Get CBasis attribute values for linear constraints indexed from 0 to 2
Dim constrs As GRBConstr() = model.GetConstrs()
Dim cbasis As Integer() = model.Get(GRB.IntAttr.CBasis, constrs, 0, 3)

int[,] Get(GRB.IntAttr attr, GRBConstr[,] constrs)#

Query an int-valued constraint attribute for a two-dimensional array of constraints.

Parameters:

attr – The attribute being queried.
constrs – A two-dimensional array of constraints whose attribute values are being queried.

Returns:

The current values of the requested attribute for each input constraint.

Example:

// Get CBasis attribute values
GRBConstr[,] constrs = new GRBConstr[10, 10];
// ...
int[,] cbasis = model.Get(GRB.IntAttr.CBasis, constrs);

' Get CBasis attribute values
Dim constrs As GRBConstr(,) = New GRBConstr(10, 10)
' ...
Dim cbasis As Integer(,) = model.Get(GRB.IntAttr.CBasis, constrs)

int[,,] Get(GRB.IntAttr attr, GRBConstr[,,] constrs)#

Query an int-valued constraint attribute for a three-dimensional array of constraints.

Parameters:

attr – The attribute being queried.
constrs – A three-dimensional array of constraints whose attribute values are being queried.

Returns:

The current values of the requested attribute for each input constraint.

Example:

// Get CBasis attribute values
GRBConstr[,,] constrs = new GRBConstr[10, 10, 10];
// ...
int[,,] cbasis = model.Get(GRB.IntAttr.CBasis, constrs);

' Get CBasis attribute values
Dim constrs As GRBConstr(,,) = New GRBConstr(10, 10, 10)
' ...
Dim cbasis As Integer(,,) = model.Get(GRB.IntAttr.CBasis, constrs)

string Get(GRB.StringAttr attr)#

Query the value of a string-valued model attribute.

Parameters:

attr – The attribute being queried.

Returns:

The current value of the requested attribute.

Example:

// Get ModelName attribute
string modelname = model.Get(GRB.StringAttr.ModelName);

' Get ModelName attribute
Dim modelname As String = model.Get(GRB.StringAttr.ModelName)

string[] Get(GRB.StringAttr attr, GRBVar[] vars)#

Query a string-valued variable attribute for an array of variables.

Parameters:

attr – The attribute being queried.
vars – The variables whose attribute values are being queried.

Returns:

The current values of the requested attribute for each input variable.

Example:

// Get variable name attribute values of all variables
GRBVar[] vars = model.GetVars();
string[] varNames = model.Get(GRB.StringAttr.VarName, vars);

' Get variable name attribute values of all variables
Dim vars As GRBVar() = model.GetVars()
Dim varNames As String() = model.Get(GRB.StringAttr.VarName, vars)

string[] Get(GRB.StringAttr attr, GRBVar[] vars, int start, int len)#

Query a string-valued variable attribute for a sub-array of variables.

Parameters:

attr – The attribute being queried.
vars – A one-dimensional array of variables whose attribute values are being queried.
start – The index of the first variable of interest in the list.
len – The number of variables.

Returns:

The current values of the requested attribute for each input variable.

Example:

// Get variable name attribute values for variables indexed from 0 to 2
GRBVar[] vars = model.GetVars();
string[] varNames = model.Get(GRB.StringAttr.VarName, vars, 0, 3);

' Get variable name attribute values for variables indexed from 0 to 2
Dim vars As GRBVar() = model.GetVars()
Dim varNames As String() = model.Get(GRB.StringAttr.VarName, vars, 0, 3)

string[,] Get(GRB.StringAttr attr, GRBVar[,] vars)#

Query a string-valued variable attribute for a two-dimensional array of variables.

Parameters:

attr – The attribute being queried.
vars – A two-dimensional array of variables whose attribute values are being queried.

Returns:

The current values of the requested attribute for each input variable.

Example:

// Get variable name attribute
GRBVar[,] vars = new GRBVar[10, 10];
// ...
string[,] varNames = model.Get(GRB.StringAttr.VarName, vars);

' Get variable name attribute
Dim vars As GRBVar(,) = new GRBVar(10, 10)
' ...
Dim varNames As String(,) = model.Get(GRB.StringAttr.VarName, vars)

string[,,] Get(GRB.StringAttr attr, GRBVar[,,] vars)#

Query a string-valued variable attribute for a three-dimensional array of variables.

Parameters:

attr – The attribute being queried.
vars – A three-dimensional array of variables whose attribute values are being queried.

Returns:

The current values of the requested attribute for each input variable.

Example:

// Get variable name attribute
GRBVar[,,] vars = new GRBVar[10, 10, 10];
// ...
string[,,] varNames = model.Get(GRB.StringAttr.VarName, vars);

' Get variable name attribute
Dim vars As GRBVar(,,) = new GRBVar(10, 10, 10)
' ...
Dim varNames As String(,,) = model.Get(GRB.StringAttr.VarName, vars)

string[] Get(GRB.StringAttr attr, GRBConstr[] constrs)#

Query a string-valued constraint attribute for an array of constraints.

Parameters:

attr – The attribute being queried.
constrs – The constraints whose attribute values are being queried.

Returns:

The current values of the requested attribute for each input constraint.

Example:

// Get constraint name attribute values of all linear constraints
GRBConstr[] constrs = model.GetConstrs();
string[] constrNames = model.Get(GRB.StringAttr.ConstrName, constrs);

' Get constraint name attribute values of all linear constraints
Dim constrs As GRBConstr() = model.GetConstrs()
Dim constrNames As String() = model.Get(GRB.StringAttr.ConstrName, constrs)

string[] Get(GRB.StringAttr attr, GRBConstr[] constrs, int start, int len)#

Query a string-valued constraint attribute for a sub-array of constraints.

Parameters:

attr – The attribute being queried.
constrs – A one-dimensional array of constraints whose attribute values are being queried.
start – The index of the first constraint of interest in the list.
len – The number of constraints.

Returns:

The current values of the requested attribute for each input constraint.

Example:

// Get constraint name attribute values for linear constraints indexed from 0 to 2
GRBConstr[] constrs = model.GetConstrs();
string[] constrNames = model.Get(GRB.StringAttr.ConstrName, constrs, 0, 3);

' Get constraint name attribute values for linear constraints indexed from 0 to 2
Dim constrs As GRBConstr() = model.GetConstrs()
Dim constrNames As String() = model.Get(GRB.StringAttr.ConstrName, constrs, 0, 3)

string[,] Get(GRB.StringAttr attr, GRBConstr[,] constrs)#

Query a string-valued constraint attribute for a two-dimensional array of constraints.

Parameters:

attr – The attribute being queried.
constrs – A two-dimensional array of constraints whose attribute values are being queried.

Returns:

The current values of the requested attribute for each input constraint.

Example:

// Get constraint name attribute values
GRBConstr[,] constrs = new GRBConstr[10, 10];
// ...
string[,] constrNames = model.Get(GRB.StringAttr.ConstrName, constrs);

' Get constraint name attribute values
Dim constrs As GRBConstr(,) = New GRBConstr(10, 10)
' ...
Dim constrNames As String(,) = model.Get(GRB.StringAttr.ConstrName, constrs)

string[,,] Get(GRB.StringAttr attr, GRBConstr[,,] constrs)#

Query a string-valued constraint attribute for a three-dimensional array of constraints.

Parameters:

attr – The attribute being queried.
constrs – A three-dimensional array of constraints whose attribute values are being queried.

Returns:

The current values of the requested attribute for each input constraint.

Example:

// Get constraint name attribute values
GRBConstr[,,] constrs = new GRBConstr[10, 10, 10];
// ...
string[,,] constrNames = model.Get(GRB.StringAttr.ConstrName, constrs);

' Get constraint name attribute values
Dim constrs As GRBConstr(,,) = New GRBConstr(10, 10, 10)
' ...
Dim constrNames As String(,,) = model.Get(GRB.StringAttr.ConstrName, constrs)

string[] Get(GRB.StringAttr attr, GRBQConstr[] qconstrs)#

Query a string-valued quadratic constraint attribute for an array of quadratic constraints.

Parameters:

attr – The attribute being queried.
qconstrs – The quadratic constraints whose attribute values are being queried.

Returns:

The current values of the requested attribute for each input quadratic constraint.

Example:

// Get constraint name values of all quadratic constraints
GRBQConstr[] constrs = model.GetQConstrs();
string[] constrNames = model.Get(GRB.StringAttr.QCName, constrs);

' Get constraint name values of all quadratic constraints
Dim constrs As GRBQConstr() = model.GetQConstrs()
Dim constrNames As String() = model.Get(GRB.StringAttr.QCName, constrs)

string[] Get(GRB.StringAttr attr, GRBQConstr[] qconstrs, int start, int len)#

Query a string-valued quadratic constraint attribute for a sub-array of quadratic constraints.

Parameters:

attr – The attribute being queried.
qconstrs – A one-dimensional array of quadratic constraints whose attribute values are being queried.
start – The index of the first quadratic constraint of interest in the list.
len – The number of quadratic constraints.

Returns:

The current values of the requested attribute for each input quadratic constraint.

Example:

// Get constraint name values for quadratic constraints indexed from 0 to 2
GRBQConstr[] constrs = model.GetQConstrs();
string[] constrNames = model.Get(GRB.StringAttr.QCName, constrs, 0, 3);

' Get constraint name values for quadratic constraints indexed from 0 to 2
Dim constrs As GRBQConstr() = model.GetQConstrs()
Dim constrNames As String() = model.Get(GRB.StringAttr.QCName, constrs, 0, 3)

string[,] Get(GRB.StringAttr attr, GRBQConstr[,] qconstrs)#

Query a string-valued quadratic constraint attribute for a two-dimensional array of quadratic constraints.

Parameters:

attr – The attribute being queried.
qconstrs – A two-dimensional array of quadratic constraints whose attribute values are being queried.

Returns:

The current values of the requested attribute for each input quadratic constraint.

Example:

// Get constraint name values
GRBQConstr[,] constrs = new GRBQConstr[10, 10];
// ...
string[,] constrNames = model.Get(GRB.StringAttr.QCName, constrs);

' Get constraint name values
Dim constrs As GRBQConstr(,) = New GRBQConstr(10, 10)
' ...
Dim constrNames As String(,) = model.Get(GRB.StringAttr.QCName, constrs)

string[,,] Get(GRB.StringAttr attr, GRBQConstr[,,] qconstrs)#

Query a string-valued quadratic constraint attribute for a three-dimensional array of quadratic constraints.

Parameters:

attr – The attribute being queried.
qconstrs – A three-dimensional array of quadratic constraints whose attribute values are being queried.

Returns:

The current values of the requested attribute for each input quadratic constraint.

Example:

// Get constraint name values
GRBQConstr[,,] constrs = new GRBQConstr[10, 10, 10];
// ...
string[,,] constrNames = model.Get(GRB.StringAttr.QCName, constrs);

' Get constraint name values
Dim constrs As GRBQConstr(,,) = New GRBQConstr(10, 10, 10)
' ...
Dim constrNames As String(,,) = model.Get(GRB.StringAttr.QCName, constrs)

string[,,] Get(GRB.StringAttr attr, GRBQConstr[,,] qconstrs)#

double GetCoeff(GRBConstr constr, GRBVar var)#

Query the coefficient of variable var in linear constraint constr (note that the result can be zero).

Parameters:

constr – The requested constraint.
var – The requested variable.

Returns:

The current value of the requested coefficient.

Example:

// Get coefficient of variable x in constraint c1
double coeff = model.GetCoeff(c1, x);

' Get coefficient of variable x in constraint c1
Dim coeff As Double = model.GetCoeff(c1, x)

GRBColumn GetCol(GRBVar var)#

Retrieve the list of constraints in which a variable participates, and the associated coefficients. The result is returned as a GRBColumn object.

Parameters:

var – The variable of interest.

Returns:

A GRBColumn object that captures the set of constraints in which the variable participates.

Example:

// Get column of coefficient and constraint pairs for variable x
GRBColumn col = model.GetCol(x);

' Get column of coefficient and constraint pairs for variable x
Dim col As GRBColumn = model.GetCol(x)

GRBEnv GetConcurrentEnv(int num)#

Create/retrieve a concurrent environment for a model.

This method provides fine-grained control over the concurrent optimizer. By creating your own concurrent environments and setting appropriate parameters on these environments (e.g., the Method parameter), you can control exactly which strategies the concurrent optimizer employs. For example, if you create two concurrent environments, and set Method to primal simplex for one and dual simplex for the other, subsequent concurrent optimizer runs will use the two simplex algorithms rather than the default choices.

Note that you must create contiguously numbered concurrent environments, starting with num=0. For example, if you want three concurrent environments, they must be numbered 0, 1, and 2.

Once you create concurrent environments, they will be used for every subsequent concurrent optimization on that model. Use DiscardConcurrentEnvs to revert back to default concurrent optimizer behavior.

Parameters:

num – The concurrent environment number.

Returns:

The concurrent environment for the model.

Example:

env0 = model.GetConcurrentEnv(0);
env1 = model.GetConcurrentEnv(1);

env0.Set(GRB.IntParam.Method, 0);
env1.Set(GRB.IntParam.Method, 1);

model.Optimize();
model.DiscardConcurrentEnvs();

env0 = model.GetConcurrentEnv(0)
env1 = model.GetConcurrentEnv(1)

env0.Set(GRB.IntParam.Method, 0)
env1.Set(GRB.IntParam.Method, 1)

model.Optimize()
model.DiscardConcurrentEnvs()

GRBConstr GetConstrByName(string name)#

Retrieve a linear constraint from its name. If multiple linear constraints have the same name, this method chooses one arbitrarily.

Parameters:

name – The name of the desired linear constraint.

Returns:

The requested linear constraint.

Example:

// Retrieve linear constraint named "constr1"
GRBConstr c1 = model.GetConstrByName("constr1");

' Retrieve linear constraint named "constr1"
Dim c1 As GRBConstr = model.GetConstrByName("constr1")

GRBConstr[] GetConstrs()#

Retrieve an array of all linear constraints in the model.

Returns:

All linear constraints in the model.

Example:

// Retrieve all linear constraints
GRBConstr[] constrs = model.GetConstrs();

' Retrieve all linear constraints
Dim constrs As GRBConstr() = model.GetConstrs()

void GetGenConstrMax(GRBGenConstr genc, out GRBVar resvar, out GRBVar[] vars, out double constant)#

Retrieve the data associated with a general constraint of type MAX. Calling this method for a general constraint of a different type leads to an exception. You can query the GenConstrType attribute to determine the type of the general constraint.

See also AddGenConstrMax for a description of the semantics of this general constraint type.

Parameters:

genc – The general constraint object.
resvar – Stores the resultant variable of the constraint.
vars – Stores the array of operand variables of the constraint.
constant – Stores the additional constant operand of the constraint.

Example:

GRBVar resvar;
GRBVar[] vars;
double constant;
// Retrieve general constraint type
int type = genc.Get(GRB.IntAttr.GenConstrType);

if (type == GRB.GENCONSTR_MAX) {
   // Retrieve data for given max constraint
   model.GetGenConstrMax(genc, out resvar, out vars, out constant);
}

Dim resvar As GRBVar
Dim vars As GRBVar()
Dim constant As Double = 0.0
' Retrieve general constraint type
Dim type as Integer = genc.Get(GRB.IntAttr.GenConstrType)

If type = GRB.GENCONSTR_MAX Then
   ' Retrieve data for given max constraint
   model.GetGenConstrMax(genc, resvar, vars, constant )
End If

void GetGenConstrMin(GRBGenConstr genc, out GRBVar resvar, out GRBVar[] vars, out double constant)#

Retrieve the data associated with a general constraint of type MIN. Calling this method for a general constraint of a different type leads to an exception. You can query the GenConstrType attribute to determine the type of the general constraint.

See also AddGenConstrMin for a description of the semantics of this general constraint type.

Parameters:

genc – The general constraint object.
resvar – Stores the resultant variable of the constraint.
vars – Stores the array of operand variables of the constraint.
constant – Stores the additional constant operand of the constraint.

Example:

GRBVar resvar;
GRBVar[] vars;
double constant;
// Retrieve general constraint type
int type = genc.Get(GRB.IntAttr.GenConstrType);

if (type == GRB.GENCONSTR_MIN) {
   // Retrieve data for given min constraint
   model.GetGenConstrMin(genc, out resvar, out vars, out constant);
}

Dim resvar As GRBVar
Dim vars As GRBVar()
Dim constant As Double = 0.0
' Retrieve general constraint type
Dim type as Integer = genc.Get(GRB.IntAttr.GenConstrType)

If type = GRB.GENCONSTR_MIN Then
   ' Retrieve data for given min constraint
   model.GetGenConstrMin(genc, resvar, vars, constant)
End If

void GetGenConstrAbs(GRBGenConstr genc, out GRBVar resvar, out GRBVar argvar)#

Retrieve the data associated with a general constraint of type ABS. Calling this method for a general constraint of a different type leads to an exception. You can query the GenConstrType attribute to determine the type of the general constraint.

See also AddGenConstrAbs for a description of the semantics of this general constraint type.

Parameters:

genc – The general constraint object.
resvar – Stores the resultant variable of the constraint.
argvar – Stores the argument variable of the constraint.

Example:

GRBVar resvar;
GRBVar argvar;
// Retrieve general constraint type
int type = genc.Get(GRB.IntAttr.GenConstrType);

if (type == GRB.GENCONSTR_ABS) {
// Retrieve data for given abs constraint
   model.GetGenConstrAbs(genc, out resvar, out argvar);
}

Dim resvar As GRBVar
Dim argvar As GRBVar
' Retrieve general constraint type
Dim type as Integer = genc.Get(GRB.IntAttr.GenConstrType)

If type = GRB.GENCONSTR_ABS Then
   ' Retrieve data for given abs constraint
   model.GetGenConstrAbs(genc, resvar, argvar)
End If

void GetGenConstrAnd(GRBGenConstr genc, out GRBVar resvar, out GRBVar[] vars)#

Retrieve the data associated with a general constraint of type AND. Calling this method for a general constraint of a different type leads to an exception. You can query the GenConstrType attribute to determine the type of the general constraint.

See also AddGenConstrAnd for a description of the semantics of this general constraint type.

Parameters:

genc – The general constraint object.
resvar – Stores the resultant variable of the constraint.
vars – Stores the array of operand variables of the constraint.

Example:

GRBVar resvar;
GRBVar[] vars;
// Retrieve general constraint type
int type = genc.Get(GRB.IntAttr.GenConstrType);

if (type == GRB.GENCONSTR_AND) {
   // Retrieve data for given AND constraint
   model.GetGenConstrAnd(genc, out resvar, out vars);
}

Dim resvar As GRBVar
Dim vars As GRBVar()
' Retrieve general constraint type
Dim type as Integer = genc.Get(GRB.IntAttr.GenConstrType)

If type = GRB.GENCONSTR_AND Then
   ' Retrieve data for given AND constraint
   model.GetGenConstrAnd(genc, resvar, vars)
End If

void GetGenConstrOr(GRBGenConstr genc, out GRBVar resvar, out GRBVar[] vars)#

Retrieve the data associated with a general constraint of type OR. Calling this method for a general constraint of a different type leads to an exception. You can query the GenConstrType attribute to determine the type of the general constraint.

See also AddGenConstrOr for a description of the semantics of this general constraint type.

Parameters:

genc – The general constraint object.
resvar – Stores the resultant variable of the constraint.
vars – Stores the array of operand variables of the constraint.

Example:

GRBVar resvar;
GRBVar[] vars;
// Retrieve general constraint type
int type = genc.Get(GRB.IntAttr.GenConstrType);

if (type == GRB.GENCONSTR_OR) {
   // Retrieve data for given OR constraint
   model.GetGenConstrOr(genc, out resvar, out vars);
}

Dim resvar As GRBVar
Dim vars As GRBVar()
' Retrieve general constraint type
Dim type as Integer = genc.Get(GRB.IntAttr.GenConstrType)

If type = GRB.GENCONSTR_OR Then
   ' Retrieve data for given OR constraint
   model.GetGenConstrOr(genc, resvar, vars)
End If

void GetGenConstrNorm(GRBGenConstr genc, out GRBVar resvar, out GRBVar[] vars, out double which)#

Retrieve the data associated with a general constraint of type NORM. Calling this method for a general constraint of a different type leads to an exception. You can query the GenConstrType attribute to determine the type of the general constraint.

See also AddGenConstrNorm for a description of the semantics of this general constraint type.

Parameters:

genc – The general constraint object.
resvar – Stores the resultant variable of the constraint.
vars – Stores the array of operand variables of the constraint.
which – Stores the norm type (possible values are 0, 1, 2, or GRB.INFINITY).

Example:

GRBVar resvar;
GRBVar[] vars;
double which;
// Retrieve general constraint type
int type = genc.Get(GRB.IntAttr.GenConstrType);

if (type == GRB.GENCONSTR_NORM) {
   // Retrieve data for given norm constraint
   model.GetGenConstrNorm(genc, out resvar, out vars, out which);
}

Dim resvar As GRBVar
Dim vars As GRBVar()
Dim which As Double = 0.0
' Retrieve general constraint type
Dim type as Integer = genc.Get(GRB.IntAttr.GenConstrType)

If type = GRB.GENCONSTR_NORM Then
   ' Retrieve data for given norm constraint
   model.GetGenConstrNorm(genc, resvar, vars, which)
End If

void GetGenConstrNL(GRBGenConstr genc, out GRBVar resvar, out int nnodes, int[] opcode, double[] data, int[] parent)#

Retrieve the data associated with a general constraint of type NL. Calling this method for a general constraint of a different type leads to an exception. You can query the GenConstrType attribute to determine the type of the general constraint.

Typical usage is to call this routine twice. In the first call, you specify the requested general constraint, with a null value for the opcode, data and parent arguments. The routine returns the total number of nodes that form the expression tree for the specified general constraint in nnodes. That allows you to make certain that the opcode, data and parent arrays are of sufficient size to hold the result of the second call.

See also AddGenConstrNL for a description of the semantics of this general constraint type.

Parameters:

genc – The general constraint object.
resvar – Stores the resultant variable of the constraint.
nnodes – Stores the number of nodes required to describe the nonlinear expression.
opcode – Stores the array containing the operation codes for the nodes.
data – Stores the array containing auxiliary data for each node.
parent – Stores the array providing the parent index of each node.

Example:

GRBVar   resvar;
int      nnodes;
int[]    opcode;
double[] data;
int[]    parent;
// Retrieve general constraint type
int type = genc.Get(GRB.IntAttr.GenConstrType);

if (type == GRB.GENCONSTR_NL) {
  // Get number of nodes
  model.GetGenConstrNL(genc, out resvar, out nnodes, null, null, null);
  // Initialize correct array sizes
  opcode = new int[nnodes];
  data   = new double[nnodes];
  parent = new int[nnodes];
  // Get array data
  model.GetGenConstrNL(genc, out resvar, out nnodes, opcode, data, parent);
}

 Dim resvar As GRBVar
 Dim nnodes As Integer
 Dim opcode As Integer()
 Dim data As Double()
 Dim parent As Integer()
 ' Retrieve general constraint type
 Dim type as Integer = genc.Get(GRB.IntAttr.GenConstrType)

If type = GRB.GENCONSTR_NL Then
  ' Get number of nodes
  model.GetGenConstrNL(genc, resvar, nnodes, Nothing, Nothing, Nothing)
  ' Initialize correct array sizes
  opcode = New Integer(nnodes)
  data   = New Double(nnodes)
  parent = New Integer(nnodes)
  ' Get array data
  model.GetGenConstrNL(genc, resvar, nnodes, opcode, data, parent)
End If

void GetGenConstrIndicator(GRBGenConstr genc, out GRBVar binvar, out int binval, out GRBLinExpr expr, out char sense, out double rhs)#

Retrieve the data associated with a general constraint of type INDICATOR. Calling this method for a general constraint of a different type leads to an exception. You can query the GenConstrType attribute to determine the type of the general constraint.

See also AddGenConstrIndicator for a description of the semantics of this general constraint type.

Parameters:

genc – The general constraint object.
binvar – Stores the binary indicator variable of the constraint.
binval – Stores the value that the indicator variable has to take in order to trigger the linear constraint.
expr – Stores the left-hand side expression of the linear constraint that is triggered by the indicator.
sense – Stores the sense for the linear constraint. Options are GRB.LESS_EQUAL, GRB.EQUAL, or GRB.GREATER_EQUAL.
rhs – Stores the right-hand side value for the linear constraint.

Example:

GRBVar binvar;
int binval;
GRBLinExpr expr;
char sense;
double rhs;
// Retrieve general constraint type
int type = genc.Get(GRB.IntAttr.GenConstrType);

if (type == GRB.GENCONSTR_INDICATOR) {
   // Retrieve data for given indicator constraint
   model.GetGenConstrIndicator(genc, out binvar, out binval, out expr, out sense, out rhs);
}

 Dim binvar As GRBVar
 Dim binval As Integer
 Dim expr As GRBLinExpr
 Dim sense As Char
 Dim rhs As Double
 ' Retrieve general constraint type
 Dim type as Integer = genc.Get(GRB.IntAttr.GenConstrType)

If type = GRB.GENCONSTR_INDICATOR Then
    ' Retrieve data for given indicator constraint
    model.GetGenConstrIndicator(genc, binvar, binval, expr, sense, rhs)
End If

void GetGenConstrPWL(GRBGenConstr genc, out GRBVar xvar, out GRBVar yvar, out int npts, double[] xpts, double[] ypts)#

Retrieve the data associated with a general constraint of type PWL. Calling this method for a general constraint of a different type leads to an exception. You can query the GenConstrType attribute to determine the type of the general constraint.

Typical usage is to call this routine twice. In the first call, you specify the requested general constraint, with a null value for the xpts and ypts arguments. The routine returns the length for the xpts and ypts arrays in npts. That allows you to make certain that the xpts and ypts arrays are of sufficient size to hold the result of the second call.

See also AddGenConstrPWL for a description of the semantics of this general constraint type.

Any of the following arguments can be null.

Parameters:

genc – The general constraint object.
xvar – Store the \(x\) variable.
yvar – Store the \(y\) variable.
npts – Store the number of points that define the piecewise-linear function.
xpts – The \(x\) values for the points that define the piecewise-linear function.
ypts – The \(y\) values for the points that define the piecewise-linear function.

Example:

GRBVar xvar;
GRBVar yvar;
int npts;
double[] xpts;
double[] ypts;
// Retrieve general constraint type
int type = genc.Get(GRB.IntAttr.GenConstrType);

if (type == GRB.GENCONSTR_PWL) {
   // Get number of points
   model.GetGenConstrPWL(genc, out xvar, out yvar, out npts, null, null);
   // Initialize correct array sizes
   xpts = new double[npts];
   ypts = new double[npts];
   // Retrieve data for given PWL constraint
   model.GetGenConstrPWL(genc, out xvar, out yvar, out npts, xpts, ypts);
}

 Dim xvar As GRBVar
 Dim yvar As GRBVar
 Dim npts As Integer
 Dim xpts As Double()
 Dim ypts As Double()
 ' Retrieve general constraint type
 Dim type as Integer = genc.Get(GRB.IntAttr.GenConstrType)

If type = GRB.GENCONSTR_PWL Then
    ' Get number of points
    model.GetGenConstrPWL(genc, xvar, yvar, npts, Nothing, Nothing)
    ' Initialize correct array sizes
    xpts = New double(npts)
    ypts = New double(npts)
    ' Retrieve data for given PWL constraint
    model.GetGenConstrPWL(genc, xvar, yvar, npts, xpts, ypts)
End If

void GetGenConstrPoly(GRBGenConstr genc, out GRBVar xvar, out GRBVar yvar, out int plen, double[] p)#

Retrieve the data associated with a general constraint of type POLY. Calling this method for a general constraint of a different type leads to an exception. You can query the GenConstrType attribute to determine the type of the general constraint.

Typical usage is to call this routine twice. In the first call, you specify the requested general constraint, with a null value for the p argument. The routine returns the length of the p array in plen. That allows you to make certain that the p array is of sufficient size to hold the result of the second call.

See also AddGenConstrPoly for a description of the semantics of this general constraint type.

Any of the following arguments can be null.

Parameters:

genc – The general constraint object.
xvar – Store the \(x\) variable.
yvar – Store the \(y\) variable.
plen – Store the array length for p. If \(x^d\) is the highest power term, then \(d+1\) will be returned.
p – The coefficients for polynomial function.

Example:

GRBVar xvar;
GRBVar yvar;
int plen;
double[] p;
// Retrieve general constraint type
int type = genc.Get(GRB.IntAttr.GenConstrType);

if (type == GRB.GENCONSTR_POLY) {
   // Get number of coefficients
   model.GetGenConstrPoly(genc, out xvar, out yvar, out plen, null);
   // Initialize correct array size
   p = new double[plen];
   // Retrieve data for given poly constraint
   model.GetGenConstrPoly(genc, out xvar, out yvar, out plen, p);
}

 Dim xvar As GRBVar
 Dim yvar As GRBVar
 Dim plen As Integer
 Dim p As Double()
 ' Retrieve general constraint type
 Dim type as Integer = genc.Get(GRB.IntAttr.GenConstrType)

If type = GRB.GENCONSTR_POLY Then
    ' Get number of coefficients
    model.GetGenConstrPoly(genc, xvar, yvar, plen, Nothing)
    ' Initialize correct array size
    p = New Double(plen)
    ' Retrieve data for given poly constraint
    model.GetGenConstrPoly(genc, xvar, yvar, plen , p)
End If

void GetGenConstrExp(GRBGenConstr genc, out GRBVar xvar, out GRBVar yvar)#

Retrieve the data associated with a general constraint of type EXP. Calling this method for a general constraint of a different type leads to an exception. You can query the GenConstrType attribute to determine the type of the general constraint.

See also AddGenConstrExp for a description of the semantics of this general constraint type.

Any of the following arguments can be null.

Parameters:

genc – The general constraint object.
xvar – Store the \(x\) variable.
yvar – Store the \(y\) variable.

Example:

GRBVar xvar;
GRBVar yvar;
// Retrieve general constraint type
int type = genc.Get(GRB.IntAttr.GenConstrType);

if (type == GRB.GENCONSTR_EXP) {
   // Retrieve data for given exp constraint
   model.GetGenConstrExp(genc, out xvar, out yvar);
}

 Dim xvar As GRBVar
 Dim yvar As GRBVar
 ' Retrieve general constraint type
 Dim type as Integer = genc.Get(GRB.IntAttr.GenConstrType)

If type = GRB.GENCONSTR_EXP Then
    ' Retrieve data for given exp constraint
    model.GetGenConstrExp(genc, xvar, yvar)
End If

void GetGenConstrExpA(GRBGenConstr genc, out GRBVar xvar, out GRBVar yvar, out double a)#

Retrieve the data associated with a general constraint of type EXPA. Calling this method for a general constraint of a different type leads to an exception. You can query the GenConstrType attribute to determine the type of the general constraint.

See also AddGenConstrExpA for a description of the semantics of this general constraint type.

Any of the following arguments can be null.

Parameters:

genc – The general constraint object.
xvar – Store the \(x\) variable.
yvar – Store the \(y\) variable.
a – Store the base of the function.

Example:

GRBVar xvar;
GRBVar yvar;
double a;
// Retrieve general constraint type
int type = genc.Get(GRB.IntAttr.GenConstrType);

if (type == GRB.GENCONSTR_EXPA) {
   // Retrieve data for given exp_a constraint
   model.GetGenConstrExpA(genc, out xvar, out yvar, out a);
}

 Dim xvar As GRBVar
 Dim yvar As GRBVar
 Dim a As Double
 ' Retrieve general constraint type
 Dim type as Integer = genc.Get(GRB.IntAttr.GenConstrType)

If type = GRB.GENCONSTR_EXPA Then
    ' Retrieve data for given exp_a constraint
    model.GetGenConstrExpA(genc, xvar, yvar, a)
End If

void GetGenConstrLog(GRBGenConstr genc, out GRBVar xvar, out GRBVar yvar)#

Retrieve the data associated with a general constraint of type LOG. Calling this method for a general constraint of a different type leads to an exception. You can query the GenConstrType attribute to determine the type of the general constraint.

See also AddGenConstrLog for a description of the semantics of this general constraint type.

Any of the following arguments can be null.

Parameters:

genc – The general constraint object.
xvar – Store the \(x\) variable.
yvar – Store the \(y\) variable.

Example:

GRBVar xvar;
GRBVar yvar;
// Retrieve general constraint type
int type = genc.Get(GRB.IntAttr.GenConstrType);

if (type == GRB.GENCONSTR_LOG) {
   // Retrieve data for given log constraint
   model.GetGenConstrLog(genc, out xvar, out yvar);
}

 Dim xvar As GRBVar
 Dim yvar As GRBVar
 ' Retrieve general constraint type
 Dim type as Integer = genc.Get(GRB.IntAttr.GenConstrType)

If type = GRB.GENCONSTR_LOG Then
    ' Retrieve data for given log constraint
    model.GetGenConstrLog(genc, xvar, yvar)
End If

void GetGenConstrLogA(GRBGenConstr genc, out GRBVar xvar, out GRBVar yvar, out double a)#

Retrieve the data associated with a general constraint of type LOGA. Calling this method for a general constraint of a different type leads to an exception. You can query the GenConstrType attribute to determine the type of the general constraint.

See also AddGenConstrLogA for a description of the semantics of this general constraint type.

Any of the following arguments can be null.

Parameters:

genc – The general constraint object.
xvar – Store the \(x\) variable.
yvar – Store the \(y\) variable.
a – Store the base of the function.

Example:

GRBVar xvar;
GRBVar yvar;
double a;
// Retrieve general constraint type
int type = genc.Get(GRB.IntAttr.GenConstrType);

if (type == GRB.GENCONSTR_LOGA) {
   // Retrieve data for given log_a constraint
   model.GetGenConstrLogA(genc, out xvar, out yvar, out a);
}

 Dim xvar As GRBVar
 Dim yvar As GRBVar
 Dim a As Double
 ' Retrieve general constraint type
 Dim type as Integer = genc.Get(GRB.IntAttr.GenConstrType)

If type = GRB.GENCONSTR_LOGA Then
    ' Retrieve data for given log_a constraint
    model.GetGenConstrLogA(genc, xvar, yvar, a)
End If

void GetGenConstrLogistic(GRBGenConstr genc, out GRBVar xvar, out GRBVar yvar)#

Retrieve the data associated with a general constraint of type LOGISTIC. Calling this method for a general constraint of a different type leads to an exception. You can query the GenConstrType attribute to determine the type of the general constraint.

See also AddGenConstrLogistic for a description of the semantics of this general constraint type.

Any of the following arguments can be null.

Parameters:

genc – The general constraint object.
xvar – Store the \(x\) variable.
yvar – Store the \(y\) variable.

Example:

GRBVar xvar;
GRBVar yvar;
// Retrieve general constraint type
int type = genc.Get(GRB.IntAttr.GenConstrType);

if (type == GRB.GENCONSTR_LOGISTIC) {
   // Retrieve data for given logistic constraint
   model.GetGenConstrLogistic(genc, out xvar, out yvar);
}

 Dim xvar As GRBVar
 Dim yvar As GRBVar
 ' Retrieve general constraint type
 Dim type as Integer = genc.Get(GRB.IntAttr.GenConstrType)

If type = GRB.GENCONSTR_LOGISTIC Then
    ' Retrieve data for given logistic constraint
    model.GetGenConstrLogistic(genc, xvar, yvar)
End If

void GetGenConstrPow(GRBGenConstr genc, out GRBVar xvar, out GRBVar yvar, out double a)#

Retrieve the data associated with a general constraint of type POW. Calling this method for a general constraint of a different type leads to an exception. You can query the GenConstrType attribute to determine the type of the general constraint.

See also AddGenConstrPow for a description of the semantics of this general constraint type.

Any of the following arguments can be null.

Parameters:

genc – The general constraint object.
xvar – Store the \(x\) variable.
yvar – Store the \(y\) variable.
a – Store the power of the function.

Example:

GRBVar xvar;
GRBVar yvar;
double a;
// Retrieve general constraint type
int type = genc.Get(GRB.IntAttr.GenConstrType);

if (type == GRB.GENCONSTR_POW) {
   // Retrieve data for given power constraint
   model.GetGenConstrPow(genc, out xvar, out yvar, out a);
}

 Dim xvar As GRBVar
 Dim yvar As GRBVar
 Dim a As Double
 ' Retrieve general constraint type
 Dim type as Integer = genc.Get(GRB.IntAttr.GenConstrType)

If type = GRB.GENCONSTR_POW Then
    ' Retrieve data for given power constraint
    model.GetGenConstrPow(genc, xvar, yvar, a)
End If

void GetGenConstrSin(GRBGenConstr genc, out GRBVar xvar, out GRBVar yvar)#

Retrieve the data associated with a general constraint of type SIN. Calling this method for a general constraint of a different type leads to an exception. You can query the GenConstrType attribute to determine the type of the general constraint.

See also AddGenConstrSin for a description of the semantics of this general constraint type.

Any of the following arguments can be null.

Parameters:

genc – The general constraint object.
xvar – Store the \(x\) variable.
yvar – Store the \(y\) variable.

Example:

GRBVar xvar;
GRBVar yvar;
// Retrieve general constraint type
int type = genc.Get(GRB.IntAttr.GenConstrType);

if (type == GRB.GENCONSTR_SIN) {
   // Retrieve data for given sin constraint
   model.GetGenConstrSin(genc, out xvar, out yvar);
}

 Dim xvar As GRBVar
 Dim yvar As GRBVar
 ' Retrieve general constraint type
 Dim type as Integer = genc.Get(GRB.IntAttr.GenConstrType)

If type = GRB.GENCONSTR_SIN Then
    ' Retrieve data for given sin constraint
    model.GetGenConstrSin(genc, xvar, yvar)
End If

void GetGenConstrCos(GRBGenConstr genc, out GRBVar xvar, out GRBVar yvar)#

Retrieve the data associated with a general constraint of type COS. Calling this method for a general constraint of a different type leads to an exception. You can query the GenConstrType attribute to determine the type of the general constraint.

See also AddGenConstrCos for a description of the semantics of this general constraint type.

Any of the following arguments can be null.

Parameters:

genc – The general constraint object.
xvar – Store the \(x\) variable.
yvar – Store the \(y\) variable.

Example:

GRBVar xvar;
GRBVar yvar;
// Retrieve general constraint type
int type = genc.Get(GRB.IntAttr.GenConstrType);

if (type == GRB.GENCONSTR_COS) {
   // Retrieve data for given cos constraint
   model.GetGenConstrCos(genc, out xvar, out yvar);
}

 Dim xvar As GRBVar
 Dim yvar As GRBVar
 ' Retrieve general constraint type
 Dim type as Integer = genc.Get(GRB.IntAttr.GenConstrType)

If type = GRB.GENCONSTR_COS Then
    ' Retrieve data for given cos constraint
    model.GetGenConstrCos(genc, xvar, yvar)
End If

void GetGenConstrTan(GRBGenConstr genc, out GRBVar xvar, out GRBVar yvar)#

Retrieve the data associated with a general constraint of type TAN. Calling this method for a general constraint of a different type leads to an exception. You can query the GenConstrType attribute to determine the type of the general constraint.

See also AddGenConstrTan for a description of the semantics of this general constraint type.

Any of the following arguments can be null.

Parameters:

genc – The general constraint object.
xvar – Store the \(x\) variable.
yvar – Store the \(y\) variable.

Example:

GRBVar xvar;
GRBVar yvar;
// Retrieve general constraint type
int type = genc.Get(GRB.IntAttr.GenConstrType);

if (type == GRB.GENCONSTR_TAN) {
   // Retrieve data for given tan constraint
   model.GetGenConstrTan(genc, out xvar, out yvar);
}

 Dim xvar As GRBVar
 Dim yvar As GRBVar
 ' Retrieve general constraint type
 Dim type as Integer = genc.Get(GRB.IntAttr.GenConstrType)

If type = GRB.GENCONSTR_TAN Then
    ' Retrieve data for given tan constraint
    model.GetGenConstrTan(genc, xvar, yvar)
End If

GRBGenConstr[] GetGenConstrs()#

Retrieve an array of all general constraints in the model.

Returns:

All general constraints in the model.

Example:

GRBGenConstr[] constrs = model.GetGenConstrs();

Dim constrs as GRBGenConstr() = model.GetGenConstrs()

string GetJSONSolution()#

After a call to Optimize, this method returns the resulting solution and related model attributes as a JSON string. Please refer to the JSON solution format section for details.

Returns:

A JSON string.

Example:

string solution = model.GetJSONSolution();

Dim solutions As String = model.GetJSONSolution()

GRBEnv GetMultiobjEnv(int index)#

Create/retrieve a multi-objective environment for the optimization pass with the given index. This environment enables fine-grained control over the multi-objective optimization process. Specifically, by changing parameters on this environment, you modify the behavior of the optimization that occurs during the corresponding pass of the multi-objective optimization.

Each multi-objective environment starts with a copy of the current model environment.

Please refer to the discussion of Multiple Objectives for information on how to specify multiple objective functions and control the trade-off between them.

Please refer to the discussion on Combining Blended and Hierarchical Objectives for information on the optimization passes to solve multi-objective models.

Use DiscardMultiobjEnvs to discard multi-objective environments and return to standard behavior.

Parameters:

index – The optimization pass index, starting from 0.

Returns:

The multi-objective environment for that optimization pass when solving the model.

Example:

env0 = model.GetMultiobjEnv(0);
env1 = model.GetMultiobjEnv(1);

env0.Set(GRB.IntParam.Method, 0);
env1.Set(GRB.IntParam.Method, 1);

model.Optimize();
model.DiscardMultiobjEnvs();

env0 = model.GetMultiobjEnv(0)
env1 = model.GetMultiobjEnv(1)

env0.Set(GRB.IntParam.Method, 0)
env1.Set(GRB.IntParam.Method, 1)

model.Optimize()
model.DiscardMultiobjEnvs()

GRBExpr GetObjective()#

Retrieve the optimization objective.

Note that the constant and linear portions of the objective can also be retrieved using the ObjCon and Obj attributes.

Returns:

The model objective.

Example:

// Get linear objective expression
GRBLinExpr obj = model.GetObjective();
double objval = obj.Value;

' Get linear objective expression
Dim obj As GRBLinExpr = model.GetObjective()
Dim objVal As Double = obj.Value

GRBLinExpr GetObjective(int index)#

Retrieve an alternative optimization objective. Alternative objectives will always be linear. You can also use this routine to retrieve the primary objective (using index = 0), but you will get an exception if the primary objective contains quadratic terms.

Please refer to the discussion of Multiple Objectives for more information on the use of alternative objectives.

Note that alternative objectives can also be retrieved using the ObjNCon and ObjN attributes.

Parameters:

index – The index for the requested alternative objective.

Returns:

The requested alternative objective.

Example:

// Get second linear objective
GRBLinExpr obj = model.GetObjective(1);
double objval = obj.Value;

' Get linear objective expression
Dim obj As GRBLinExpr = model.GetObjective(1)
Dim objVal As Double = obj.Value

int GetPWLObj(GRBVar var, double[] x, double[] y)#

Retrieve the piecewise-linear objective function for a variable. The return value gives the number of points that define the function, and the \(x\) and \(y\) arguments give the coordinates of the points, respectively. The \(x\) and \(y\) arguments must be large enough to hold the result. Call this method with null values for \(x\) and \(y\) if you just want the number of points.

Refer to this discussion for additional information on what the values in \(x\) and \(y\) mean.

Parameters:

var – The variable whose objective function is being retrieved.
x – The \(x\) values for the points that define the piecewise-linear function. These will always be in non-decreasing order.
y – The \(y\) values for the points that define the piecewise-linear function.

Returns:

The number of points that define the piecewise-linear objective function.

Example:

// Get PWL objective data
int npts = model.GetPWLObj(var, null, null);
double[] x = new double[npts];
double[] y = new double[npts];
model.GetPWLObj(var, x, y);

' Get PWL objective data
Dim npts As Integer = model.GetPWLObj(var, Nothing, Nothing)
Dim x as Double() = New Double(npts)
Dim y as Double() = New Double(npts)
model.GetPWLObj(var, x, y)

GRBQConstr[] GetQConstrs()#

Retrieve an array of all quadratic constraints in the model.

Returns:

All quadratic constraints in the model.

Example:

GRBQConstr[] constrs = model.GetQConstrs();

Dim constrs As GRBQConstr() = model.GetQConstrs()

GRBQuadExpr GetQCRow(GRBQConstr qc)#

Retrieve the left-hand side expression for a quadratic constraint. The result is returned as a GRBQuadExpr object.

Parameters:

qc – The quadratic constraint of interest.

Returns:

A GRBQuadExpr object that captures the left-hand side of the quadratic constraint.

Example:

// Get quadratic LHS expression of first quadratic constraint
GRBQConstr[] constrs = model.GetQConstrs();
GRBQuadExpr qexpr = model.GetQCRow(constrs[0]);

' Get quadratic LHS expression of first quadratic constraint
Dim constrs As GRBQConstr() = model.GetQConstrs()
Dim qexpr As GRBQuadExpr = model.GetQCRow(constrs(0))

GRBLinExpr GetRow(GRBConstr constr)#

Retrieve a list of variables that participate in a constraint, and the associated coefficients. The result is returned as a GRBLinExpr object.

Parameters:

constr – The constraint of interest. A GRBConstr object, typically obtained from AddConstr or GetConstrs.

Returns:

A GRBLinExpr object that captures the set of variables that participate in the constraint.

Example:

// Get linear LHS expression of first linear constraint
GRBConstr[] constrs = model.GetConstrs();
GRBLinExpr lexpr = model.GetRow(constrs[0]);

' Get linear LHS expression of first linear constraint
Dim constrs As GRBConstr() = model.GetConstrs()
Dim lexpr As GRBLinExpr = model.GetRow(constrs(0))

int GetSOS(GRBSOS sos, GRBVar[] vars, double[] weights, int[] type)#

Retrieve the list of variables that participate in an SOS constraint, and the associated coefficients. The return value is the length of this list. Note that the argument arrays must be long enough to accommodate the result. Call the method with null array arguments to determine the appropriate array lengths.

Parameters:

sos – The SOS set of interest.
vars – A list of variables that participate in sos. Can be null.
weights – The SOS weights for each participating variable. Can be null.
type – The type of the SOS set (either GRB.SOS_TYPE1 or GRB.SOS_TYPE2) is returned in type[0].

Returns:

The number of entries placed in the output arrays. Note that you should consult the return value to determine the length of the result; the arrays sizes won’t necessarily match the result size.

Example:

GRBSOS[] constrs = model.GetSOSs();
// Get data of first SOS constraint
int len = model.GetSOS(constrs[0], null, null, null);
GRBVar[] vars = new GRBVar[len];
double[] weights = new double[len];
int[] type = new int[len];
model.GetSOS(constrs[0], vars, weights, type);

Dim constrs As GRBSOS() = model.GetSOSs()
' Get data of first SOS constraint
Dim len As Integer = model.GetSOS(constrs(0), Nothing, Nothing, Nothing)
Dim vars As GRBVar() = New GRBVarlen
Dim weights As Double() = New Double(len)
Dim type As Integer() = New Integer(len)
model.GetSOS(constrs(0), vars, weights, type)

GRBSOS[] GetSOSs()#

Retrieve an array of all SOS constraints in the model.

Returns:

All SOS constraints in the model.

Example:

GRBSOS[] constrs = model.GetSOSs();

Dim constrs As GRBSOS() = model.GetSOSs()

void GetTuneResult(int n)#

Use this method to retrieve the results of a previous Tune call. Calling this method with argument n causes tuned parameter set n to be copied into the model. Parameter sets are stored in order of decreasing quality, with parameter set 0 being the best. The number of available sets is stored in attribute TuneResultCount.

Once you have retrieved a tuning result, you can call optimize to use these parameter settings to optimize the model, or write to write the changed parameters to a .prm file.

Please refer to the parameter tuning section for details on the tuning tool.

Parameters:

n – The index of the tuning result to retrieve. The best result is available as index 0. The number of stored results is available in attribute TuneResultCount.

Example:

model.Tune();
// Get best tuning result
model.GetTuneResult(0);
// Optimize model using the best found parameter set
model.Optimize();

model.Tune()
' Get best tuning result
model.GetTuneResult(0)
' Optimize model using the best found parameter set
model.Optimize()

GRBVar GetVarByName(string name)#

Retrieve a variable from its name. If multiple variable have the same name, this method chooses one arbitrarily.

Parameters:

name – The name of the desired variable.

Returns:

The requested variable.

Example:

// Get variable named "var1"
GRBVar var = model.GetVarByName("var1");

' Get variable named "var1"
Dim var As GRBVar = model.GetVarByName("var1")

GRBVar[] GetVars()#

Retrieve an array of all variables in the model.

Returns:

All variables in the model.

Example:

GRBVar[] vars = model.GetVars();

Dim vars As GRBVar() = model.GetVars()

void Optimize()#

Optimize the model. The algorithm used for the optimization depends on the model type (simplex or barrier for a continuous model; branch-and-cut for a MIP model). Upon successful completion, this method will populate the solution related attributes of the model. See the Attributes section for more information on attributes.

Please consult this section for a discussion of some of the practical issues associated with solving a precisely defined mathematical model using finite-precision floating-point arithmetic.

Note that this method will process all pending model modifications.

Example:

model.Optimize();

model.Optimize()

void OptimizeAsync()#

Optimize a model asynchronously. This routine returns immediately. Your program can perform other computations while optimization proceeds in the background. To check the state of the asynchronous optimization, query the Status attribute for the model. A value of IN_PROGRESS indicates that the optimization has not yet completed. When you are done with your foreground tasks, you must call Sync to sync your foreground program with the asynchronous optimization task.

Note that the set of Gurobi calls that you are allowed to make while optimization is running in the background is severely limited. Specifically, you can only perform attribute queries, and only for a few attributes (listed below). Any other calls on the running model, or on any other models that were built within the same Gurobi environment, will fail with error code OPTIMIZATION_IN_PROGRESS.

Note that there are no such restrictions on models built in other environments. Thus, for example, you could create multiple environments, and then have a single foreground program launch multiple simultaneous asynchronous optimizations, each in its own environment.

As already noted, you are allowed to query the value of the Status attribute while an asynchronous optimization is in progress. The other attributes that can be queried are: ObjVal, ObjBound, IterCount, NodeCount, and BarIterCount. In each case, the returned value reflects progress in the optimization to that point. Any attempt to query the value of an attribute not on this list will return an OPTIMIZATION_IN_PROGRESS error.

Example:

// Start asynchronous optimization
model.OptimizeAsync();

// Poll the status while optimization is in progress
while (model.Get(GRB.IntAttr.Status) == GRB.Status.INPROGRESS)
{
   Thread.Sleep(100); // Sleep for 100 ms

   Console.WriteLine($"ObjVal={model.Get(GRB.DoubleAttr.ObjVal)} ObjBound={model.Get(GRB.DoubleAttr.ObjBound)}");
}

// Synchronize model
model.Sync();

// Query solution and process results
// ...

' Start asynchronous optimization
model.OptimizeAsync()

' Poll the status while optimization is in progress
While model.Get(GRB.IntAttr.Status) = GRB.Status.INPROGRESS
   Thread.Sleep(100) ' Sleep for 100 ms

   Console.WriteLine("ObjVal=" & model.Get(GRB.DoubleAttr.ObjVal) & " ObjBound=" & model.Get(GRB.DoubleAttr.ObjBound))
End While

' Synchronize model
model.Sync()

' Query solution and process results
' ...

string OptimizeBatch()#

Submit a new batch request to the Cluster Manager. Returns the BatchID (a string), which uniquely identifies the job in the Cluster Manager and can be used to query the status of this request (from this program or from any other). Once the request has completed, the BatchID can also be used to retrieve the associated solution. To submit a batch request, you must tag at least one element of the model by setting one of the VTag, CTag or QCTag attributes. For more details on batch optimization, please refer to the Batch Optimization section.

Note that this routine will process all pending model modifications.

Example:

// Submit batch request
string batchID = model.OptimizeBatch();

' Submit batch request
Dim batchID As String = model.OptimizeBatch()

GRBModel Presolve()#

Perform presolve on a model.

Please note that the presolved model computed by this function may be different from the presolved model computed when optimizing the model.

Returns:

Presolved version of original model.

Example:

GRBModel presolved = model.Presolve();

Dim presolved As GRBModel = model.Presolve()

void Read(string filename)#

This method is the general entry point for importing data from a file into a model. It can be used to read basis files for continuous models, start vectors for MIP models, variable hints for MIP models, branching priorities for MIP models, or parameter settings. The type of data read is determined by the file suffix. File formats are described in the File Format section.

Note that reading a file does not process all pending model modifications. These modifications can be processed by calling GRBModel.Update.

Note also that this is not the method to use if you want to read a new model from a file. For that, use the GRBModel constructor. One variant of the constructor takes the name of the file that contains the new model as its argument.

Parameters:

filename – Name of the file to read. The suffix on the file must be either .bas (for an LP basis), .mst or .sol (for a MIP start), .hnt (for MIP hints), .ord (for a priority order), .attr (for a collection of attribute settings), or .prm (for a parameter file). The suffix may optionally be followed by .zip, .gz, .bz2, .7z or .xz.

Example:

model.Read("myModel.mps");

model.Read("myModel.mps")

void Remove(GRBConstr constr)#

Remove a constraint from the model. Note that, due to our lazy update approach, the change won’t actually take effect until you update the model (using GRBModel.Update), optimize the model (using GRBModel.Optimize), or write the model to disk (using GRBModel.Write).

Parameters:

constr – The constraint to remove.

Example:

GRBConstr[] constrs = model.GetConstrs();
// Remove first linear constraint
model.Remove(constrs[0]);

Dim constrs As GRBConstr() = model.GetConstrs()
' Remove first linear constraint
model.Remove(constrs(0))

void Remove(GRBGenConstr genconstr)#

Remove a general constraint from the model. Note that, due to our lazy update approach, the change won’t actually take effect until you update the model (using GRBModel.Update), optimize the model (using GRBModel.Optimize), or write the model to disk (using GRBModel.Write).

Parameters:

genconstr – The general constraint to remove.

Example:

GRBGenConstr[] constrs = model.GetGenConstrs();
// Remove first general constraint
model.Remove(constrs[0]);

Dim constrs As GRBGenConstr() = model.GetGenConstrs()
' Remove first general constraint
model.Remove(constrs(0))

void Remove(GRBQConstr qconstr)#

Remove a quadratic constraint from the model. Note that, due to our lazy update approach, the change won’t actually take effect until you update the model (using GRBModel.Update), optimize the model (using GRBModel.Optimize), or write the model to disk (using GRBModel.Write).

Parameters:

qconstr – The constraint to remove.

Example:

GRBQConstr[] constrs = model.GetQConstrs();
// Remove first quadratic constraint
model.Remove(constrs[0]);

Dim constrs As GRBQConstr = model.GetQConstrs()
' Remove first quadratic constraint
model.Remove(constrs(0))

void Remove(GRBSOS sos)#

Remove an SOS constraint from the model. Note that, due to our lazy update approach, the change won’t actually take effect until you update the model (using GRBModel.Update), optimize the model (using GRBModel.Optimize), or write the model to disk (using GRBModel.Write).

Parameters:

sos – The SOS constraint to remove.

Example:

GRBSOS[] constrs = model.GetSOSs();
// Remove first SOS constraint
model.Remove(constrs[0]);

Dim constrs As GRBSOS() = model.GetSOSs()
' Remove first SOS constraint
model.Remove(constrs(0))

void Remove(GRBVar var)#

Remove a variable from the model. Note that, due to our lazy update approach, the change won’t actually take effect until you update the model (using GRBModel.Update), optimize the model (using GRBModel.Optimize), or write the model to disk (using GRBModel.Write).

Parameters:

var – The variable to remove.

Example:

GRBVar[] vars = model.GetVars();
// Remove first variable
model.Remove(vars[0]);

Dim vars As GRBVar() = model.GetVars()
' Remove first variable
model.Remove(vars(0))

void Reset()#

Reset the model to an unsolved state, discarding any previously computed solution information.

Example:

model.Reset();

model.Reset()

void Reset(int clearall)#

Reset the model to an unsolved state, discarding any previously computed solution information.

Parameters:

clearall – A value of 1 discards additional information that affects the solution process but not the actual model (currently MIP starts, variable hints, branching priorities, lazy flags, and partition information). Pass 0 to just discard the solution.

Example:

model.Reset(1);

model.Reset(1)

void SetCallback(GRBCallback cb)#

Set the callback object for a model. The Callback() method on this object will be called periodically from the Gurobi solver. You will have the opportunity to obtain more detailed information about the state of the optimization from this callback. See the documentation for GRBCallback for additional information.

Note that a model can only have a single callback method, so this call will replace an existing callback. To disable a previously set callback, call this method with a null argument.

Example:

class MyCallback : GRBCallback {
   // ...
}

// ...
MyCallback CB = new MyCallback();
// ...
model.SetCallback(CB);

class MyCallback
   Inherits GRBCallback
   ' ...

' ...
model.SetCallback(New CB())

void Set(GRB.DoubleParam param, double newvalue)#

Set the value of a double-valued parameter.

The difference between setting a parameter on a model and setting it on an environment (i.e., through GRBEnv.Set) is that the former modifies the parameter for a single model, while the latter modifies the parameter for every model that is subsequently built using that environment (and leaves the parameter unchanged for models that were previously built using that environment).

Parameters:

param – The parameter being modified.
newvalue – The desired new value for the parameter.

Example:

// Set parameter TimeLimit to value 10.0
model.Set(GRB.DoubleParam.TimeLimit, 10.0);

' Set parameter TimeLimit to value 10.0
model.Set(GRB.DoubleParam.TimeLimit, 10.0)

void Set(GRB.IntParam param, int newvalue)#

Set the value of an int-valued parameter.

Parameters:

param – The parameter being modified.
newvalue – The desired new value for the parameter.

Example:

// Set parameter PumpPasses to value 10
model.Set(GRB.IntParam.PumpPasses, 10);

' Set parameter PumpPasses to value 10
model.Set(GRB.IntParam.PumpPasses, 10)

void Set(GRB.StringParam param, string newvalue)#

Set the value of a string-valued parameter.

Parameters:

param – The parameter being modified.
newvalue – The desired new value for the parameter.

Example:

// Set parameter LogFile to value "myLog.log"
model.Set(GRB.StringParam.LogFile, "myLog.log");

' Set parameter LogFile to value "myLog.log"
model.Set(GRB.StringParam.LogFile, "myLog.log")

void Set(GRB.CharAttr attr, GRBVar[] vars, char[] newvalues)#

Set a char-valued variable attribute for an array of variables.

Parameters:

attr – The attribute being modified.
vars – The variables whose attribute values are being modified.
newvalues – The desired new values for the attribute for each input variable.

Example:

// Add 3 binary variables
GRBVar[] x = model.AddVars(3, GRB.BINARY);
// Change the type of the 3 variable to CONTINUOUS
char[] newvalues = {"C", "C", "C"};
model.Set(GRB.CharAttr.VType, x, newvalues);

' Add 3 binary variables
Dim x As GRBVar() = model.AddVars(3, GRB.BINARY)
' Change the type of the 3 variable to CONTINUOUS
Dim newvalues As Char() = New Char() {"C", "C", "C"}
model.Set(GRB.CharAttr.VType, x, newvalues)

void Set(GRB.CharAttr attr, GRBVar[] vars, char[] newvalues, int start, int len)#

Set a char-valued variable attribute for a sub-array of variables.

Parameters:

attr – The attribute being modified.
vars – A one-dimensional array of variables whose attribute values are being modified.
newvalues – The desired new values for the attribute for each input variable.
start – The index of the first variable of interest in the list.
len – The number of variables.

Example:

// Add 3 binary variables
GRBVar[] x = model.AddVars(3, GRB.BINARY);
// Change the type of the first 2 variable to CONTINUOUS
char[] newvalues = {"C", "C"};
model.Set(GRB.CharAttr.VType, x, newvalues, 0, 2);

' Add 3 binary variables
Dim x As GRBVar() = model.AddVars(3, GRB.BINARY)
' Change the type of the first 2 variable to CONTINUOUS
Dim newvalues As Char() = New Char() {"C", "C"}
model.Set(GRB.CharAttr.VType, x, newvalues, 0, 2)

void Set(GRB.CharAttr attr, GRBVar[,] vars, char[,] newvalues)#

Set a char-valued variable attribute for a two-dimensional array of variables.

Parameters:

attr – The attribute being modified.
vars – A two-dimensional array of variables whose attribute values are being modified.
newvalues – The desired new values for the attribute for each input variable.

void Set(GRB.CharAttr attr, GRBVar[,,] vars, char[,,] newvalues)#

Set a char-valued variable attribute for a three-dimensional array of variables.

Parameters:

attr – The attribute being modified.
vars – A three-dimensional array of variables whose attribute values are being modified.
newvalues – The desired new values for the attribute for each input variable.

void Set(GRB.CharAttr attr, GRBConstr[] constrs, char[] newvalues)#

Set a char-valued constraint attribute for an array of constraints.

Parameters:

attr – The attribute being modified.
constrs – The constraints whose attribute values are being modified.
newvalues – The desired new values for the attribute for each input constraint.

Example:

// Add 3 trivial linear constraints to model
GRBConstrs[] constrs = model.AddConstrs(3);
// Change the sense of the 3 constraints
char[] newvalues = {'<', '=', '>'};
model.Set(GRB.CharAttr.Sense, constrs, newvalues);

' Add 3 trivial linear constraints to model
Dim constrs As GRBConstrs() = model.AddConstrs(3)
' Change the sense of the 3 constraints
Dim newvalues As Char() = New Char() {"<", "=", ">"}
model.Set(GRB.CharAttr.Sense, constrs, newvalues)

void Set(GRB.CharAttr attr, GRBConstr[] constrs, char[] newvalues, int start, int len)#

Set a char-valued constraint attribute for a sub-array of constraints.

Parameters:

attr – The attribute being modified.
constrs – A one-dimensional array of constraints whose attribute values are being modified.
newvalues – The desired new values for the attribute for each input constraint.
start – The index of the first constraint of interest in the list.
len – The number of constraints.

Example:

// Add 3 trivial linear constraints to model
GRBConstrs[] constrs = model.AddConstrs(3);
// Change the sense of the first 2 constraints
char[] newvalues = {'<', '='};
model.Set(GRB.CharAttr.Sense, constrs, newvalues, 0, 2);

' Add 3 trivial linear constraints to model
Dim constrs As GRBConstrs() = model.AddConstrs(3)
' Change the sense of the first 2 constraints
Dim newvalues As Char() = New Char() {"<", "="}
model.Set(GRB.CharAttr.Sense, constrs, newvalues, 0, 2)

void Set(GRB.CharAttr attr, GRBConstr[,] constrs, char[,] newvalues)#

Set a char-valued constraint attribute for a two-dimensional array of constraints.

Parameters:

attr – The attribute being modified.
constrs – A two-dimensional array of constraints whose attribute values are being modified.
newvalues – The desired new values for the attribute for each input constraint.

void Set(GRB.CharAttr attr, GRBConstr[,,] constrs, char[,,] newvalues)#

Set a char-valued constraint attribute for a three-dimensional array of constraints.

Parameters:

attr – The attribute being modified.
constrs – A three-dimensional array of constraints whose attribute values are being modified.
newvalues – The desired new values for the attribute for each input constraint.

void Set(GRB.CharAttr attr, GRBQConstr[] qconstrs, char[] newvalues)#

Set a char-valued quadratic constraint attribute for an array of quadratic constraints.

Parameters:

attr – The attribute being modified.
qconstrs – The quadratic constraints whose attribute values are being modified.
newvalues – The desired new values for the attribute for each input quadratic constraint.

Example:

// Add 3 quadratic constraints
GRBQConstr c1 = model.AddQConstr(x*x + y*y == 0, "c1");
GRBQConstr c2 = model.AddQConstr(x*y - y*y == 0, "c2");
GRBQConstr c3 = model.AddQConstr(x*x - x*y == 0, "c3");
GRBQConstr[] constrs = {c1, c2, c3};
// Change the sense of the 3 constraints
char[] newvalues = {"<", "=", ">"};
model.Set(GRB.CharAttr.QCSense, constrs, newvalues);

' Add 3 quadratic constraints
Dim c1 As GRBQConstr = model.AddQConstr(x*x + y*y == 0, "c1")
Dim c2 As GRBQConstr = model.AddQConstr(x*y - y*y == 0, "c2")
Dim c3 As GRBQConstr = model.AddQConstr(x*x - x*y == 0, "c3")
Dim constrs As GRBQConstr() = New GRBQConstr() {c1, c2, c3}
' Change the sense of the 3 constraints
Dim newvalues As Char() = {"<", "=", ">"}
model.Set(GRB.CharAttr.QCSense, constrs, newvalues)

void Set(GRB.CharAttr attr, GRBQConstr[] qconstrs, char[] newvalues, int start, int len)#

Set a char-valued quadratic constraint attribute for a sub-array of quadratic constraints.

Parameters:

attr – The attribute being modified.
qconstrs – A one-dimensional array of quadratic constraints whose attribute values are being modified.
newvalues – The desired new values for the attribute for each input quadratic constraint.
start – The index of the first quadratic constraint of interest in the list.
len – The number of quadratic constraints.

Example:

// Add 3 quadratic constraints
GRBQConstr c1 = model.AddQConstr(x*x + y*y == 0, "c1");
GRBQConstr c2 = model.AddQConstr(x*y - y*y == 0, "c2");
GRBQConstr c3 = model.AddQConstr(x*x - x*y == 0, "c3");
GRBQConstr[] constrs = {c1, c2, c3};
// Change the sense of the first 2 constraints
char[] newvalues = {"<", "="};
model.Set(GRB.CharAttr.QCSense, constrs, newvalues, 0, 2);

' Add 3 quadratic constraints
Dim c1 As GRBQConstr = model.AddQConstr(x*x + y*y == 0, "c1")
Dim c2 As GRBQConstr = model.AddQConstr(x*y - y*y == 0, "c2")
Dim c3 As GRBQConstr = model.AddQConstr(x*x - x*y == 0, "c3")
Dim constrs As GRBQConstr() = New GRBQConstr() {c1, c2, c3}
' Change the sense of the first 2 constraints
Dim newvalues As Char() = {"<", "="}
model.Set(GRB.CharAttr.QCSense, constrs, newvalues, 0, 2)

void Set(GRB.CharAttr attr, GRBQConstr[,] qconstrs, char[,] newvalues)#

Set a char-valued quadratic constraint attribute for a two-dimensional array of quadratic constraints.

Parameters:

attr – The attribute being modified.
qconstrs – A two-dimensional array of quadratic constraints whose attribute values are being modified.
newvalues – The desired new values for the attribute for each input quadratic constraint.

void Set(GRB.CharAttr attr, GRBQConstr[,,] qconstrs, char[,,] newvalues)#

Set a char-valued quadratic constraint attribute for a three-dimensional array of quadratic constraints.

Parameters:

attr – The attribute being modified.
qconstrs – A three-dimensional array of quadratic constraints whose attribute values are being modified.
newvalues – The desired new values for the attribute for each input quadratic constraint.

void Set(GRB.DoubleAttr attr, double newvalue)#

Set the value of a double-valued model attribute.

Parameters:

attr – The attribute being modified.
newvalue – The desired new value for the attribute.

Example:

// Adjust objective constant
model.Set(GRB.DoubleAttr.ObjCon, 2.0);

' Adjust objective constant
model.Set(GRB.DoubleAttr.ObjCon, 2.0)

void Set(GRB.DoubleAttr attr, GRBVar[] vars, double[] newvalues)#

Set a double-valued variable attribute for an array of variables.

Parameters:

attr – The attribute being modified.
vars – The variables whose attribute values are being modified.
newvalues – The desired new values for the attribute for each input variable.

Example:

// Add 3 continuous variables
GRBVar[] x = model.AddVars(3, GRB.CONTINUOUS);
// Change the lower bound of the 3 variables
double[] newvalues = {0.1, 0.2, 0.3};
model.Set(GRB.DoubleAttr.LB, x, newvalues);

' Add 3 continuous variables
Dim x As GRBVar() = model.AddVars(3, GRB.CONTINUOUS)
' Change the lower bound of the 3 variables
Dim newvalues As Double() = New Double() {0.1, 0.2, 0.3}
model.Set(GRB.DoubleAttr.LB, x, newvalues)

void Set(GRB.DoubleAttr attr, GRBVar[] vars, double[] newvalues, int start, int len)#

Set a double-valued variable attribute for a sub-array of variables.

Parameters:

attr – The attribute being modified.
vars – A one-dimensional array of variables whose attribute values are being modified.
newvalues – The desired new values for the attribute for each input variable.
start – The index of the first variable of interest in the list.
len – The number of variables.

Example:

// Add 3 continuous variables
GRBVar[] x = model.AddVars(3, GRB.CONTINUOUS);
// Change the lower bound of the first 2 variables
double[] newvalues = {0.1, 0.2};
model.Set(GRB.DoubleAttr.LB, x, newvalues, 0, 2);

' Add 3 continuous variables
Dim x As GRBVar() = model.AddVars(3, GRB.CONTINUOUS)
' Change the lower bound of the first 2 variables
Dim newvalues As Double() = New Double() {0.1, 0.2}
model.Set(GRB.DoubleAttr.LB, x, newvalues, 0, 2)

void Set(GRB.DoubleAttr attr, GRBVar[,] vars, double[,] newvalues)#

Set a double-valued variable attribute for a two-dimensional array of variables.

Parameters:

attr – The attribute being modified.
vars – A two-dimensional array of variables whose attribute values are being modified.
newvalues – The desired new values for the attribute for each input variable.

void Set(GRB.DoubleAttr attr, GRBVar[,,] vars, double[,,] newvalues)#

Set a double-valued variable attribute for a three-dimensional array of variables.

Parameters:

attr – The attribute being modified.
vars – A three-dimensional array of variables whose attribute values are being modified.
newvalues – The desired new values for the attribute for each input variable.

void Set(GRB.DoubleAttr attr, GRBConstr[] constrs, double[] newvalues)#

Set a double-valued constraint attribute for an array of constraints.

Parameters:

attr – The attribute being modified.
constrs – The constraints whose attribute values are being modified.
newvalues – The desired new values for the attribute for each input constraint.

Example:

// Add 3 trivial linear constraints to model
GRBConstrs[] constrs = model.AddConstrs(3);
// Change the RHS of the 3 constraints
double[] newvalues = {1.0, 2.0, 3.0};
model.Set(GRB.DoubleAttr.RHS, constrs, newvalues);

' Add 3 trivial linear constraints to model
Dim constrs As GRBConstrs() = model.AddConstrs(3)
' Change the RHS of the 3 constraints
Dim newvalues As Double() = New Double() {1.0, 2.0, 3.0}
model.Set(GRB.DoubleAttr.RHS, constrs, newvalues)

void Set(GRB.DoubleAttr attr, GRBConstr[] constrs, double[] newvalues, int start, int len)#

Set a double-valued constraint attribute for a sub-array of constraints.

Parameters:

attr – The attribute being modified.
constrs – A one-dimensional array of constraints whose attribute values are being modified.
newvalues – The desired new values for the attribute for each input constraint.
start – The first constraint of interest in the list.
len – The number of constraints.

Example:

// Add 3 trivial linear constraints to model
GRBConstrs[] constrs = model.AddConstrs(3);
// Change the RHS of the first 2 constraints
double[] newvalues = {1.0, 2.0};
model.Set(GRB.DoubleAttr.RHS, constrs, newvalues, 0, 2);

' Add 3 trivial linear constraints to model
Dim constrs As GRBConstrs() = model.AddConstrs(3)
' Change the RHS of the first 2 constraints
Dim newvalues As Double() = New Double() {1.0, 2.0}
model.Set(GRB.DoubleAttr.RHS, constrs, newvalues, 0, 2)

void Set(GRB.DoubleAttr attr, GRBConstr[,] constrs, double[,] newvalues)#

Set a double-valued constraint attribute for a two-dimensional array of constraints.

Parameters:

attr – The attribute being modified.
constrs – A two-dimensional array of constraints whose attribute values are being modified.
newvalues – The desired new values for the attribute for each input constraint.

void Set(GRB.DoubleAttr attr, GRBConstr[,,] constrs, double[,,] newvalues)#

Set a double-valued constraint attribute for a three-dimensional array of constraints.

Parameters:

attr – The attribute being modified.
constrs – A three-dimensional array of constraints whose attribute values are being modified.
newvalues – The desired new values for the attribute for each input constraint.

void Set(GRB.DoubleAttr attr, GRBQConstr[] qconstrs, double[] newvalues)#

Set a double-valued quadratic constraint attribute for an array of quadratic constraints.

Parameters:

attr – The attribute being modified.
qconstrs – The quadratic constraints whose attribute values are being modified.
newvalues – The desired new values for the attribute for each input quadratic constraint.

Example:

// Add 3 quadratic constraints
GRBQConstr c1 = model.AddQConstr(x*x + y*y == 0, "c1");
GRBQConstr c2 = model.AddQConstr(x*y - y*y == 0, "c2");
GRBQConstr c3 = model.AddQConstr(x*x - x*y == 0, "c3");
GRBQConstr[] constrs = {c1, c2, c3};
// Change the RHS of the 3 constraints
double[] newvalues = {1.0, 2.0, 3.0};
model.Set(GRB.DoubleAttr.QCRHS, constrs, newvalues);

' Add 3 quadratic constraints
Dim c1 As GRBQConstr = model.AddQConstr(x*x + y*y == 0, "c1")
Dim c2 As GRBQConstr = model.AddQConstr(x*y - y*y == 0, "c2")
Dim c3 As GRBQConstr = model.AddQConstr(x*x - x*y == 0, "c3")
Dim constrs As GRBQConstr() = New GRBQConstr() {c1, c2, c3}
' Change the RHS of the 3 constraints
Dim newvalues As Double() = New Double() {1.0, 2.0, 3.0}
model.Set(GRB.DoubleAttr.QCRHS, constrs, newvalues)

void Set(GRB.DoubleAttr attr, GRBQConstr[] qconstrs, double[] newvalues, int start, int len)#

Set a double-valued quadratic constraint attribute for a sub-array of quadratic constraints.

Parameters:

attr – The attribute being modified.
qconstrs – A one-dimensional array of quadratic constraints whose attribute values are being modified.
newvalues – The desired new values for the attribute for each input quadratic constraint.
start – The first quadratic constraint of interest in the list.
len – The number of quadratic constraints.

Example:

// Add 3 quadratic constraints
GRBQConstr c1 = model.AddQConstr(x*x + y*y == 0, "c1");
GRBQConstr c2 = model.AddQConstr(x*y - y*y == 0, "c2");
GRBQConstr c3 = model.AddQConstr(x*x - x*y == 0, "c3");
GRBQConstr[] constrs = {c1, c2, c3};
// Change the RHS of the first 2 constraints
double[] newvalues = {1.0, 2.0};
model.Set(GRB.DoubleAttr.QCRHS, constrs, newvalues, 0, 2);

' Add 3 quadratic constraints
Dim c1 As GRBQConstr = model.AddQConstr(x*x + y*y == 0, "c1")
Dim c2 As GRBQConstr = model.AddQConstr(x*y - y*y == 0, "c2")
Dim c3 As GRBQConstr = model.AddQConstr(x*x - x*y == 0, "c3")
Dim constrs As GRBQConstr() = New GRBQConstr() {c1, c2, c3}
' Change the RHS of the first 2 constraints
Dim newvalues As Double() = New Double() {1.0, 2.0}
model.Set(GRB.DoubleAttr.QCRHS, constrs, newvalues, 0, 2)

void Set(GRB.DoubleAttr attr, GRBQConstr[,] qconstrs, double[,] newvalues)#

Set a double-valued quadratic constraint attribute for a two-dimensional array of quadratic constraints.

Parameters:

attr – The attribute being modified.
qconstrs – A two-dimensional array of quadratic constraints whose attribute values are being modified.
newvalues – The desired new values for the attribute for each input quadratic constraint.

void Set(GRB.DoubleAttr attr, GRBQConstr[,,] qconstrs, double[,,] newvalues)#

Set a double-valued quadratic constraint attribute for a three-dimensional array of quadratic constraints.

Parameters:

attr – The attribute being modified.
qconstrs – A three-dimensional array of quadratic constraints whose attribute values are being modified.
newvalues – The desired new values for the attribute for each input quadratic constraint.

void Set(GRB.IntAttr attr, int newvalue)#

Set the value of an int-valued model attribute.

Parameters:

attr – The attribute being modified.
newvalue – The desired new value for the attribute.

Example:

// Adjust model sense
model.Set(GRB.IntAttr.ModelSense, GRB.MINIMIZE);

' Adjust model sense
model.Set(GRB.IntAttr.ModelSense, GRB.MINIMIZE)

void Set(GRB.IntAttr attr, GRBVar[] vars, int[] newvalues)#

Set an int-valued variable attribute for an array of variables.

Parameters:

attr – The attribute being modified.
vars – The variables whose attribute values are being modified.
newvalues – The desired new values for the attribute for each input variable.

Example:

// Add 3 continuous variables
GRBVar[] x = model.AddVars(3, GRB.CONTINUOUS);
// Change the VBasis value of the 3 variables
int[] newvalues = {0, -1, -2};
model.Set(GRB.IntAttr.VBasis, x, newvalues);

' Add 3 continuous variables
Dim x As GRBVar() = model.AddVars(3, GRB.CONTINUOUS)
' Change the VBasis value of the 3 variables
Dim newvalues As Integer = New Integer() {0, -1, -2}
model.Set(GRB.IntAttr.VBasis, x, newvalues)

void Set(GRB.IntAttr attr, GRBVar[] vars, int[] newvalues, int start, int len)#

Set an int-valued variable attribute for a sub-array of variables.

Parameters:

attr – The attribute being modified.
vars – A one-dimensional array of variables whose attribute values are being modified.
newvalues – The desired new values for the attribute for each input variable.
start – The index of the first variable of interest in the list.
len – The number of variables.

Example:

// Add 3 continuous variables
GRBVar[] x = model.AddVars(3, GRB.CONTINUOUS);
// Change the VBasis value of the first 2 variables
int[] newvalues = {0, -1};
model.Set(GRB.IntAttr.VBasis, x, newvalues, 0, 2);

' Add 3 continuous variables
Dim x As GRBVar() = model.AddVars(3, GRB.CONTINUOUS)
' Change the VBasis value of the first 2 variables
Dim newvalues As Integer = New Integer() {0, -1}
model.Set(GRB.IntAttr.VBasis, x, newvalues, 0, 2)

void Set(GRB.IntAttr attr, GRBVar[,] vars, int[,] newvalues)#

Set an int-valued variable attribute for a two-dimensional array of variables.

Parameters:

attr – The attribute being modified.
vars – A two-dimensional array of variables whose attribute values are being modified.
newvalues – The desired new values for the attribute for each input variable.

void Set(GRB.IntAttr attr, GRBVar[,,] vars, int[,,] newvalues)#

Set an int-valued variable attribute for a three-dimensional array of variables.

Parameters:

attr – The attribute being modified.
vars – A three-dimensional array of variables whose attribute values are being modified.
newvalues – The desired new values for the attribute for each input variable.

void Set(GRB.IntAttr attr, GRBConstr[] constrs, int[] newvalues)#

Set an int-valued constraint attribute for an array of constraints.

Parameters:

attr – The attribute being modified.
constrs – The constraints whose attribute values are being modified.
newvalues – The desired new values for the attribute for each input constraint.

Example:

// Add 3 trivial linear constraints to model
GRBConstrs[] constrs = model.AddConstrs(3);
// Change the CBasis value of the 3 constraints
int[] newvalues = {0, -1, -1};
model.Set(GRB.IntAttr.CBasis, constrs, newvalues);

' Add 3 trivial linear constraints to model
Dim constrs As GRBConstrs() = model.AddConstrs(3)
' Change the CBasis value of the 3 constraints
Dim newvalues As Integer() = New Integer() {0, -1, -1}
model.Set(GRB.IntAttr.CBasis, constrs, newvalues)

void Set(GRB.IntAttr attr, GRBConstr[] constrs, int[] newvalues, int start, int len)#

Set an int-valued constraint attribute for a sub-array of constraints.

Parameters:

attr – The attribute being modified.
constrs – A one-dimensional array of constraints whose attribute values are being modified.
newvalues – The desired new values for the attribute for each input constraint.
start – The index of the first constraint of interest in the list.
len – The number of constraints.

Example:

// Add 3 trivial linear constraints to model
GRBConstrs[] constrs = model.AddConstrs(3);
// Change the CBasis value of the first 2 constraints
int[] newvalues = {0, -1};
model.Set(GRB.IntAttr.CBasis, constrs, newvalues, 0, 2);

' Add 3 trivial linear constraints to model
Dim constrs As GRBConstrs() = model.AddConstrs(3)
' Change the CBasis value of the first 2 constraints
Dim newvalues As Integer() = New Integer() {0, -1}
model.Set(GRB.IntAttr.CBasis, constrs, newvalues, 0, 2)

void Set(GRB.IntAttr attr, GRBConstr[,] constrs, int[,] newvalues)#

Set an int-valued constraint attribute for a two-dimensional array of constraints.

Parameters:

attr – The attribute being modified.
constrs – A two-dimensional array of constraints whose attribute values are being modified.
newvalues – The desired new values for the attribute for each input constraint.

void Set(GRB.IntAttr attr, GRBConstr[,,] constrs, int[,,] newvalues)#

Set an int-valued constraint attribute for a three-dimensional array of constraints.

Parameters:

attr – The attribute being modified.
constrs – A three-dimensional array of constraints whose attribute values are being modified.
newvalues – The desired new values for the attribute for each input constraint.

void Set(GRB.StringAttr attr, string newvalue)#

Set the value of a string-valued model attribute.

Parameters:

attr – The attribute being modified.
newvalue – The desired new value for the attribute.

Example:

// Adjust model name
model.Set(GRB.StringAttr.ModelName, "myModel");

' Adjust model name
model.Set(GRB.StringAttr.ModelName, "myModel")

void Set(GRB.StringAttr attr, GRBVar[] vars, string[] newvalues)#

Set a string-valued variable attribute for an array of variables.

Parameters:

attr – The attribute being modified.
vars – The variables whose attribute values are being modified.
newvalues – The desired new values for the attribute for each input variable.

Example:

// Add 3 continuous variables
GRBVar[] x = model.AddVars(3, GRB.CONTINUOUS);
// Change names of the 3 variables
string[] newvalues = {"x1", "x2", "x3"};
model.Set(GRB.StringAttr.VarName, x, newvalues);

' Add 3 continuous variables
Dim x As GRBVar() = model.AddVars(3, GRB.CONTINUOUS)
' Change names of the 3 variables
Dim newvalues As String() = New String() {"x1", "x2", "x3"}
model.Set(GRB.StringAttr.VarName, x, newvalues)

void Set(GRB.StringAttr attr, GRBVar[] vars, string[] newvalues, int start, int len)#

Set a string-valued variable attribute for a sub-array of variables.

Parameters:

attr – The attribute being modified.
vars – A one-dimensional array of variables whose attribute values are being modified.
newvalues – The desired new values for the attribute for each input variable.
start – The index of the first variable of interest in the list.
len – The number of variables.

Example:

// Add 3 continuous variables
GRBVar[] x = model.AddVars(3, GRB.CONTINUOUS);
// Change names of the first 2 variables
string[] newvalues = {"x1", "x2"};
model.Set(GRB.StringAttr.VarName, x, newvalues, 0, 2);

' Add 3 continuous variables
Dim x As GRBVar() = model.AddVars(3, GRB.CONTINUOUS)
' Change names of the first 2 variables
Dim newvalues As String() = New String() {"x1", "x2", "x3"}
model.Set(GRB.StringAttr.VarName, x, newvalues, 0, 2)

void Set(GRB.StringAttr attr, GRBVar[,] vars, string[,] newvalues)#

Set a string-valued variable attribute for a two-dimensional array of variables.

Parameters:

attr – The attribute being modified.
vars – A two-dimensional array of variables whose attribute values are being modified.
newvalues – The desired new values for the attribute for each input variable.

void Set(GRB.StringAttr attr, GRBVar[,,] vars, string[,,] newvalues)#

Set a string-valued variable attribute for a three-dimensional array of variables.

Parameters:

attr – The attribute being modified.
vars – A three-dimensional array of variables whose attribute values are being modified.
newvalues – The desired new values for the attribute for each input variable.

void Set(GRB.StringAttr attr, GRBConstr[] constrs, string[] newvalues)#

Set a string-valued constraint attribute for an array of constraints.

Parameters:

attr – The attribute being modified.
constrs – The constraints whose attribute values are being modified.
newvalues – The desired new values for the attribute for each input constraint.

Example:

// Add 3 trivial linear constraints to model
GRBConstrs[] constrs = model.AddConstrs(3);
// Change the name of the 3 constraints
string[] newvalues = {"c1", "c2", "c3"};
model.Set(GRB.StringAttr.ConstrName, constrs, newvalues);

' Add 3 trivial linear constraints to model
Dim constrs As GRBConstrs() = model.AddConstrs(3)
' Change the name of the 3 constraints
Dim newvalues As String() = New Strin() {"c1", "c2", "c3"}
model.Set(GRB.StringAttr.ConstrName, constrs, newvalues)

void Set(GRB.StringAttr attr, GRBConstr[] constrs, string[] newvalues, int start, int len)#

Set a string-valued constraint attribute for a sub-array of constraints.

Parameters:

attr – The attribute being modified.
constrs – A one-dimensional array of constraints whose attribute values are being modified.
newvalues – The desired new values for the attribute for each input constraint.
start – The index of the first constraint of interest in the list.
len – The number of constraints.

Example:

// Add 3 trivial linear constraints to model
GRBConstrs[] constrs = model.AddConstrs(3);
// Change the name of the first 2 constraints
string[] newvalues = {"c1", "c2"};
model.Set(GRB.StringAttr.ConstrName, constrs, newvalues, 0, 2);

' Add 3 trivial linear constraints to model
Dim constrs As GRBConstrs() = model.AddConstrs(3)
' Change the name of the first 2 constraints
Dim newvalues As String() = New Strin() {"c1", "c2"}
model.Set(GRB.StringAttr.ConstrName, constrs, newvalues, 0, 2)

void Set(GRB.StringAttr attr, GRBConstr[,] constrs, string[,] newvalues)#

Set a string-valued constraint attribute for a two-dimensional array of constraints.

Parameters:

attr – The attribute being modified.
constrs – A two-dimensional array of constraints whose attribute values are being modified.
newvalues – The desired new values for the attribute for each input constraint.

void Set(GRB.StringAttr attr, GRBConstr[,,] constrs, string[,,] newvalues)#

Set a string-valued constraint attribute for a three-dimensional array of constraints.

Parameters:

attr – The attribute being modified.
constrs – A three-dimensional array of constraints whose attribute values are being modified.
newvalues – The desired new values for the attribute for each input constraint.

void Set(GRB.StringAttr attr, GRBQConstr[] qconstrs, string[] newvalues)#

Set a string-valued quadratic constraint attribute for an array of quadratic constraints.

Parameters:

attr – The attribute being modified.
qconstrs – The quadratic constraints whose attribute values are being modified.
newvalues – The desired new values for the attribute for each input quadratic constraint.

Example:

// Add 3 quadratic constraints
GRBQConstr c1 = model.AddQConstr(x*x + y*y == 0, "c1");
GRBQConstr c2 = model.AddQConstr(x*y - y*y == 0, "c2");
GRBQConstr c3 = model.AddQConstr(x*x - x*y == 0, "c3");
GRBQConstr[] constrs = {c1, c2, c3};
// Change the name of the 3 constraints
string[] newvalues = {"qc1", "qc2", "qc3"};
model.Set(GRB.StringAttr.QCName, constrs, newvalues);

' Add 3 quadratic constraints
Dim c1 As GRBQConstr = model.AddQConstr(x*x + y*y == 0, "c1")
Dim c2 As GRBQConstr = model.AddQConstr(x*y - y*y == 0, "c2")
Dim c3 As GRBQConstr = model.AddQConstr(x*x - x*y == 0, "c3")
Dim constrs As GRBQConstr() = New GRBQConstr() {c1, c2, c3}
' Change the name of the 3 constraints
Dim newvalues As String() = New String() {"qc1", "qc2", "qc3"}
model.Set(GRB.StringAttr.QCName, constrs, newvalues)

void Set(GRB.StringAttr attr, GRBQConstr[] qconstrs, string[] newvalues, int start, int len)#

Set a string-valued quadratic constraint attribute for a sub-array of quadratic constraints.

Parameters:

attr – The attribute being modified.
qconstrs – A one-dimensional array of quadratic constraints whose attribute values are being modified.
newvalues – The desired new values for the attribute for each input quadratic constraint.
start – The index of the first quadratic constraint of interest in the list.
len – The number of quadratic constraints.

Example:

// Add 3 quadratic constraints
GRBQConstr c1 = model.AddQConstr(x*x + y*y == 0, "c1");
GRBQConstr c2 = model.AddQConstr(x*y - y*y == 0, "c2");
GRBQConstr c3 = model.AddQConstr(x*x - x*y == 0, "c3");
GRBQConstr[] constrs = {c1, c2, c3};
// Change the name of the first 2 constraints
string[] newvalues = {"qc1", "qc2"};
model.Set(GRB.StringAttr.QCName, constrs, newvalues, 0, 2);

' Add 3 quadratic constraints
Dim c1 As GRBQConstr = model.AddQConstr(x*x + y*y == 0, "c1")
Dim c2 As GRBQConstr = model.AddQConstr(x*y - y*y == 0, "c2")
Dim c3 As GRBQConstr = model.AddQConstr(x*x - x*y == 0, "c3")
Dim constrs As GRBQConstr() = New GRBQConstr() {c1, c2, c3}
' Change the name of the first 2 constraints
Dim newvalues As String() = New String() {"qc1", "qc2", "qc3"}
model.Set(GRB.StringAttr.QCName, constrs, newvalues, 0, 2)

void Set(GRB.StringAttr attr, GRBQConstr[,] qconstrs, string[,] newvalues)#

Set a string-valued quadratic constraint attribute for a two-dimensional array of quadratic constraints.

Parameters:

attr – The attribute being modified.
qconstrs – A two-dimensional array of quadratic constraints whose attribute values are being modified.
newvalues – The desired new values for the attribute for each input quadratic constraint.

void Set(GRB.StringAttr attr, GRBQConstr[,,] qconstrs, string[,,] newvalues)#

Set a string-valued quadratic constraint attribute for a three-dimensional array of quadratic constraints.

Parameters:

attr – The attribute being modified.
qconstrs – A three-dimensional array of quadratic constraints whose attribute values are being modified.
newvalues – The desired new values for the attribute for each input quadratic constraint.

void SetObjective(GRBExpr expr, int sense)#

Set the model objective equal to a linear expression (for multi-objective optimization, see SetObjectiveN).

Note that you can also modify the linear portion of a model objective using the Obj variable attribute. If you wish to mix and match these two approaches, please note that this method replaces the entire existing objective, while the Obj attribute can be used to modify individual linear terms.

Parameters:

expr – New model objective.
sense – New optimization sense (GRB.MINIMIZE for minimization, GRB.MAXIMIZE for maximization).

Example:

model.SetObjective(x + y, GRB.MINIMIZE);

model.SetObjective(x + y, GRB.MINIMIZE)

void SetObjective(GRBExpr expr)#

Set the model objective equal to a quadratic expression (for multi-objective optimization, see SetObjectiveN). The sense of the objective is determined by the value of the ModelSense attribute.

Note that this method replaces the entire existing objective, while the Obj attribute can be used to modify individual linear terms.

Parameters:

expr – New model objective.

Example:

model.SetObjective(x + y);

model.SetObjective(x + y)

void SetObjectiveN(GRBLinExpr expr, int index, int priority, double weight, double abstol, double reltol, string name)#

Set an alternative optimization objective equal to a linear expression.

Please refer to the discussion of Multiple Objectives for more information on the use of alternative objectives.

Note that you can also modify an alternative objective using the ObjN variable attribute. If you wish to mix and match these two approaches, please note that this method replaces the entire existing objective, while the ObjN attribute can be used to modify individual terms.

Parameters:

expr – New alternative objective.
index – Index for new objective. If you use an index of 0, this routine will change the primary optimization objective.
priority – Priority for the alternative objective. This initializes the ObjNPriority attribute for this objective.
weight – Weight for the alternative objective. This initializes the ObjNWeight attribute for this objective.
abstol – Absolute tolerance for the alternative objective. This initializes the ObjNAbsTol attribute for this objective.
reltol – Relative tolerance for the alternative objective. This initializes the ObjNRelTol attribute for this objective.
name – Name of the alternative objective. This initializes the ObjNName attribute for this objective.

Example:

// Primary objective: x + 2 y
model.SetObjectiveN(x + 2*y, 0, 2, 1.0, 2.0, 0.1, "Primary Obj");
// Secondary objective: 3 y + z
model.SetObjectiveN(3*y + z, 1, 1, 1.0, 0.0, 0.0, "Secondary Obj");

' Primary objective: x + 2 y
model.SetObjectiveN(x + 2*y, 0, 2, 1.0, 2.0, 0.1, "Primary Obj")
' Secondary objective: 3 y + z
model.SetObjectiveN(3*y + z, 1, 1, 1.0, 0.0, 0.0, "Secondary Obj")

void SetPWLObj(GRBVar var, double[] x, double[] y)#

Set a piecewise-linear objective function for a variable.

The arguments to this method specify a list of points that define a piecewise-linear objective function for a single variable. Specifically, the \(x\) and \(y\) arguments give coordinates for the vertices of the function.

For additional details on piecewise-linear objective functions, refer to this discussion.

Parameters:

var – The variable whose objective function is being set.
x – The \(x\) values for the points that define the piecewise-linear function. Must be in non-decreasing order.
y – The \(y\) values for the points that define the piecewise-linear function.

Example:

GRBVar var = model.AddVar(0.0, 1.0, 0.0, GRB.CONTINUOUS, "var");
double[] x = {0.0, 0.5, 1.0};
double[] y = {0.5, 0.25, 0.75};
model.SetPWLObj(var, x, y);

Dim var As GRBVar = model.AddVar(0.0, 1.0, 0.0, GRB.CONTINUOUS, "var")
Dim x As Double() = New Double() {0.0, 0.5, 1.0}
Dim y As Double() = New Double() {0.5, 0.25, 0.75}
model.SetPWLObj(var, x, y)

GRBModel SingleScenarioModel()#

Capture a single scenario from a multi-scenario model. Use the ScenarioNumber parameter to indicate which scenario to capture.

The model on which this method is invoked must be a multi-scenario model, and the result will be a single-scenario model.

Returns:

Model for a single scenario.

Example:

model.Set(GRB.IntAttr.NumScenarios, 1);
model.Update();
GRBModel singlescenario = model.SingleScenarioModel();

model.Set(GRB.IntAttr.NumScenarios, 1)
model.Update()
Dim singlescenario As GRBModel = model.SingleScenarioModel()

void Sync()#

Wait for a previous asynchronous optimization call to complete.

Calling OptimizeAsync returns control to the calling routine immediately. The caller can perform other computations while optimization proceeds, and can check on the progress of the optimization by querying various model attributes. The sync call forces the calling program to wait until the asynchronous optimization call completes. You must call sync before the corresponding model object is deleted.

The sync call throws an exception if the optimization itself ran into any problems. In other words, exceptions thrown by this method are those that optimize itself would have thrown, had the original method not been asynchronous.

Note that you need to call sync even if you know that the asynchronous optimization has already completed.

Example:

model.OptimizeAsync();
// ...
model.Sync();

model.OptimizeAsync()
' ...
model.Sync()

void Terminate()#

Generate a request to terminate the current optimization. This method can be called at any time during an optimization (from a callback, from another thread, from an interrupt handler, etc.). Note that, in general, the request won’t be acted upon immediately.

When the optimization stops, the Status attribute will be equal to GRB_INTERRUPTED.

Example:

model.Terminate();

model.Terminate()

void Tune()#

Perform an automated search for parameter settings that improve performance. Upon completion, this method stores the best parameter sets it found. The number of stored parameter sets can be determined by querying the value of the TuneResultCount attribute. The actual settings can be retrieved using GetTuneResult

Please refer to the parameter tuning section for details on the tuning tool.

Example:

model.Tune();
// Get best tuning result
model.GetTuneResult(0);
// Optimize model using the best found parameter set
model.Optimize();

model.Tune()
' Get best tuning result
model.GetTuneResult(0)
' Optimize model using the best found parameter set
model.Optimize()

void Update()#

Process any pending model modifications.

Example:

model.Update();

model.Update()

void Write(string filename)#

This method is the general entry point for writing optimization data to a file. It can be used to write optimization models, solution vectors, basis vectors, start vectors, or parameter settings. The type of data written is determined by the file suffix. File formats are described in the File Format section.

Note that writing a model to a file will process all pending model modifications. This is also true when writing other model information such as solutions, bases, etc.

Note also that when you write a Gurobi parameter file (PRM), both integer or double parameters not at their default value will be saved, but no string parameter will be saved into the file.

Finally, note that when IgnoreNames=1, the names of variables and constraints are replaced with default names when writing a file.

Parameters:

filename – The name of the file to be written. The file type is encoded in the file name suffix. Valid suffixes are .mps, .rew, .lp, or .rlp for writing the model itself, .dua or .dlp for writing the dualized model (only pure LP), .ilp for writing just the IIS associated with an infeasible model (see GRBModel.ComputeIIS for further information), .sol for writing the solution selected by the SolutionNumber parameter, .mst for writing a start vector, .hnt for writing a hint file, .bas for writing an LP basis, .prm for writing modified parameter settings, .attr for writing model attributes, or .json for writing solution information in JSON format. If your system has compression utilities installed (e.g., 7z or zip for Windows, and gzip, bzip2, or unzip for Linux or macOS), then the files can be compressed, so additional suffixes of .zip, .gz, .bz2, .7z or .xz are accepted.

Example:

model.Write("myModel.lp");

model.Write("myModel.lp")

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