GRB模型

GRBModel

Gurobi 模型对象。常用的方法包括 addVar（向模型添加一个新的决策变量）， addConstr（向模型添加一个新的约束）， optimize（优化当前模型），以及 get（检索属性的值）。

虽然Java垃圾收集器最终会收集未使用的GRBModel对象，但与模型相关的大部分内存存储在Java堆之外。因此，垃圾收集器无法看到这种内存使用情况，因此在决定是否需要收集时无法考虑这一数量。我们建议您在使用完模型后调用GRBModel.dispose。

GRBModel GRBModel(GRBEnv env)

GRBModel的构造函数，用于创建一个空模型。然后您可以调用addVar和addConstr来向模型中添加变量和约束。

Arguments:

env – 新模型的环境。

Return value:

新模型对象。模型最初不包含任何变量或约束。

Example:

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

GRBModel GRBModel(GRBEnv env, String filename)

用于从文件中读取模型的GRBModel构造函数。 请注意，文件类型由文件名后缀编码。有效的后缀包括 .mps, .rew, .lp, .rlp, .dua, .dlp, .ilp, 或 .opb。文件可以被压缩，因此还接受 .zip, .gz, .bz2, .7z 或 .xz 作为附加后缀。

Arguments:

• env – 新模型的环境。

• filename – 包含模型的文件名。

Return value:

新模型对象。

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");

GRBModel GRBModel(GRBModel model)

GRBModel的构造函数，用于创建现有模型的副本。 请注意，由于Gurobi中的延迟更新方法，在复制之前必须调用update。

Arguments:

model – 要复制的模型。

Return value:

新模型对象。模型是原始模型的克隆。

Example:

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

GRBModel GRBModel(GRBModel model, GRBEnv targetenv)

将现有模型复制到不同的环境。多个线程不能在同一环境中同时工作。因此，模型的副本必须位于不同的环境中，以便多个线程可以同时操作它们。

请注意，此方法本身不是线程安全的，因此您应该从主线程调用它或使用锁保护对其的访问。

请注意，待处理的更新不会应用于模型，因此如果您希望这些更新包含在副本中，应在复制之前调用update。

对于Compute Server用户，请注意您可以将模型从客户端复制到Compute Server环境，但无法将模型从一个Compute Server环境复制到另一个（客户端或Compute Server）环境。

Arguments:

• model – 要复制的模型。

• targetenv – 将模型复制到的环境。

Return value:

新模型对象。模型是原始模型的克隆。

Example:

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

GRBConstr addConstr(GRBLinExpr lhsExpr, char sense, GRBLinExpr rhsExpr, String name)

向模型添加单个线性约束。

Arguments:

• lhsExpr – 新线性约束的左侧表达式。

• sense – 新线性约束的意义（GRB.LESS_EQUAL， GRB.EQUAL，或 GRB.GREATER_EQUAL）。

• rhsExpr – 新线性约束的右侧表达式。

• name – 新约束的名称。

Return value:

新的约束对象。

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");
GRBVar z = model.addVar(0.0, GRB.INFINITY, 0.0, GRB.CONTINUOUS, "z");
// Create linear expression x + y
GRBLinExpr lexpr = new GRBLinExpr();
lexpr.addTerm(1.0, x);
lexpr.addTerm(1.0, y);
// Create linear expression 2*z
GRBLinExpr rexpr = new GRBLinExpr();
rexpr.addTerm(2.0, z);

// Add linear constraint x + y = 2*z with name c1
GRBConstr constr = model.addConstr(lexpr, GRB.EQUAL, rexpr, "c1");

GRBConstr addConstr(GRBLinExpr lhsExpr, char sense, GRBVar rhsVar, String name)

向模型添加单个线性约束。

Arguments:

• lhsExpr – 新线性约束的左侧表达式。

• sense – 新线性约束的意义（GRB.LESS_EQUAL， GRB.EQUAL，或 GRB.GREATER_EQUAL）。

• rhsVar – 新线性约束的右侧变量。

• name – 新约束的名称。

Return value:

新的约束对象。

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");
GRBVar z = model.addVar(0.0, GRB.INFINITY, 0.0, GRB.CONTINUOUS, "z");
// Create linear expression x + y
GRBLinExpr lexpr = new GRBLinExpr();
lexpr.addTerm(1.0, x);
lexpr.addTerm(1.0, y);

// Add linear constraint x + y = z with name c1
GRBConstr constr = model.addConstr(lexpr, GRB.EQUAL, z, "c1");

GRBConstr addConstr(GRBLinExpr lhsExpr, char sense, double rhs, String name)

向模型添加单个线性约束。

Arguments:

• lhsExpr – 新线性约束的左侧表达式。

• sense – 新线性约束的意义（GRB.LESS_EQUAL， GRB.EQUAL，或 GRB.GREATER_EQUAL）。

• rhs – 新线性约束的右侧值。

• name – 新约束的名称。

Return value:

新的约束对象。

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();
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");

GRBConstr addConstr(GRBVar lhsVar, char sense, GRBLinExpr rhsExpr, String name)

向模型添加单个线性约束。

Arguments:

• lhsVar – 新线性约束的左侧变量。

• sense – 新线性约束的意义（GRB.LESS_EQUAL， GRB.EQUAL，或 GRB.GREATER_EQUAL）。

• rhsExpr – 新线性约束的右侧表达式。

• name – 新约束的名称。

Return value:

新的约束对象。

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");
GRBVar z = model.addVar(0.0, GRB.INFINITY, 0.0, GRB.CONTINUOUS, "z");
// Create linear expression x + y
GRBLinExpr rexpr = new GRBLinExpr();
rexpr.addTerm(1.0, x);
rexpr.addTerm(1.0, y);

// Add linear constraint z >= x + y with name c1
GRBConstr constr = model.addConstr(z, GRB.GREATER_EQUAL, rexpr, "c1");

GRBConstr addConstr(GRBVar lhsVar, char sense, GRBVar rhsVar, String name)

向模型添加单个线性约束。

Arguments:

• lhsVar – 新线性约束的左侧变量。

• sense – 新线性约束的意义（GRB.LESS_EQUAL， GRB.EQUAL，或 GRB.GREATER_EQUAL）。

• rhsVar – 新线性约束的右侧变量。

• name – 新约束的名称。

Return value:

新的约束对象。

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 with name c1
GRBConstr constr = model.addConstr(x, GRB.LESS_EQUAL, y, "c1");

GRBConstr addConstr(GRBVar lhsVar, char sense, double rhs, String name)

向模型添加单个线性约束。

Arguments:

• lhsVar – 新线性约束的左侧变量。

• sense – 新线性约束的意义（GRB.LESS_EQUAL， GRB.EQUAL，或 GRB.GREATER_EQUAL）。

• rhs – 新线性约束的右侧值。

• name – 新约束的名称。

Return value:

新的约束对象。

Example:

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

// Add linear constraint x <= 2 with name c1
GRBConstr constr = model.addConstr(x, GRB.LESS_EQUAL, 2.0, "c1");

GRBConstr addConstr(double lhs, char sense, GRBVar rhsVar, String name)

向模型添加单个线性约束。

Arguments:

• lhs – 新线性约束的左侧值。

• sense – 新线性约束的意义（GRB.LESS_EQUAL， GRB.EQUAL，或 GRB.GREATER_EQUAL）。

• rhsVar – 新线性约束的右侧变量。

• name – 新约束的名称。

Return value:

新的约束对象。

Example:

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

// Add linear constraint 1 <= x with name c1
GRBConstr constr = model.addConstr(1.0, GRB.LESS_EQUAL, x, "c1");

GRBConstr addConstr(double lhs, char sense, GRBLinExpr rhsExpr, String name)

向模型添加单个线性约束。

Arguments:

• lhs – 新线性约束的左侧值。

• sense – 新线性约束的意义（GRB.LESS_EQUAL， GRB.EQUAL，或 GRB.GREATER_EQUAL）。

• rhsExpr – 新线性约束的右侧表达式。

• name – 新约束的名称。

Return value:

新的约束对象。

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 rexpr = new GRBLinExpr();
rexpr.addTerm(1.0, x);
rexpr.addTerm(1.0, y);

// Add linear constraint 1 >= x + y with name c1
GRBConstr constr = model.addConstr(1.0, GRB.GREATER_EQUAL, rexpr, "c1");

GRBConstr[] addConstrs(int count)

向模型添加count个新的线性约束。新约束的形式均为0 <= 0。

我们建议您一次构建一个约束的模型（使用 addConstr），因为它不会引入显著的额外开销，并且我们发现这样可以生成更简单的代码。如果您不同意，尽管使用这些方法。

Arguments:

count – 要添加的约束数量。

Return value:

新的约束对象数组。

Example:

// Add 5 empty constraints (0 <= 0)
GRBConstr[] constrs = model.addConstrs(5)

GRBConstr[] addConstrs(GRBLinExpr[] lhsExprs, char[] senses, double[] rhss, String[] names)

向模型添加新的线性约束。添加的约束数量由输入数组的长度决定（所有参数必须一致）。

我们建议您一次构建一个约束的模型（使用 addConstr），因为它不会引入显著的额外开销，并且我们发现这样可以生成更简单的代码。不过，如果您不同意，可以随意使用这些方法。

Arguments:

• lhsExprs – 新线性约束的左侧表达式。

• senses – 新线性约束的感知类型 (GRB.LESS_EQUAL, GRB.EQUAL, 或 GRB.GREATER_EQUAL).

• rhss – 新线性约束的右侧值。

• names – 新约束的名称。

Return value:

新的约束对象数组。

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 expr1 = new GRBLinExpr();
expr1.addTerm(1.0, x);
expr1.addTerm(1.0, y);
GRBLinExpr expr2 = new GRBLinExpr();
expr2.addTerm(1.0, x);
expr2.addTerm(-2.0, y);

GRBLinExpr[] lhsExprs = {expr1, expr2};
char[] senses = {GRB.LESS_EQUAL, GRB.GREATER_EQUAL};
double[] rhss = {1.0, 2.0};
String[] names = {"c1", "c2"};

// Add two linear constraints:
// x + y <= 1.0 with name c1
// x - 2*y >= 2.0 with name c2
GRBConstr[] constrs = model.addConstrs(lhsExprs, senses, rhss, names);

GRBConstr[] addConstrs(GRBLinExpr[] lhsExprs, char[] senses, double[] rhss, String[] names, int start, int len)

向模型添加新的线性约束。此签名允许您使用数组来保存各种约束属性（左侧、方向等），而不强制您为数组中的每个条目添加一个约束。start 和 len 参数允许您指定要添加的约束。

我们建议您一次构建一个约束的模型（使用 addConstr），因为它不会引入显著的额外开销，并且我们发现这样可以生成更简单的代码。不过，如果您不同意，可以随意使用这些方法。

Arguments:

• lhsExprs – 新线性约束的左侧表达式。

• senses – 新线性约束的感知类型 (GRB.LESS_EQUAL, GRB.EQUAL, 或 GRB.GREATER_EQUAL).

• rhss – 新线性约束的右侧值。

• names – 新约束的名称。

• start – 要添加的列表中的第一个约束。

• len – 要添加的约束数量。

Return value:

新的约束对象数组。

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 expr1 = new GRBLinExpr();
expr1.addTerm(1.0, x);
expr1.addTerm(1.0, y);
GRBLinExpr expr2 = new GRBLinExpr();
expr2.addTerm(1.0, x);
expr2.addTerm(-2.0, y);

GRBLinExpr[] lhsExprs = {expr1, expr2};
char[] senses = {GRB.LESS_EQUAL, GRB.GREATER_EQUAL};
double[] rhss = {1.0, 2.0};
String[] names = {"c1", "c2"};

// Add two linear constraints:
// x + y <= 1.0 with name c1
// x - 2*y >= 2.0 with name c2
GRBConstr[] constrs = model.addConstrs(lhsExprs, senses, rhss, names, 0, 2);

GRBGenConstr addGenConstrMax(GRBVar resvar, GRBVar[] vars, double constant, String name)

向模型添加一个新的一般约束，类型为GRB.GENCONSTR_MAX。

一个MAX约束\(r = \max\{x_1,\ldots,x_n,c\}\)表示结果变量\(r\)应等于操作变量\(x_1,\ldots,x_n\)和常数\(c\)的最大值。

Arguments:

• resvar – 新约束的结果变量。

• vars – 作为新约束操作数的变量数组。

• constant – 新约束的附加常量操作数。

• name – 新的一般约束的名称。

Return value:

新的通用约束。

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");

GRBGenConstr addGenConstrMin(GRBVar resvar, GRBVar[] vars, double constant, String name)

向模型添加一个类型为GRB.GENCONSTR_MIN的新一般约束。

一个MIN约束 \(r = \min\{x_1,\ldots,x_n,c\}\) 表示结果变量 \(r\) 应该等于操作变量 \(x_1,\ldots,x_n\) 和常数 \(c\) 的最小值。

Arguments:

• resvar – 新约束的结果变量。

• vars – 作为新约束操作数的变量数组。

• constant – 新约束的附加常数操作数。

• name – 新的一般约束的名称。

Return value:

新的通用约束。

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");

GRBGenConstr addGenConstrAbs(GRBVar resvar, GRBVar argvar, String name)

向模型添加一个类型为GRB.GENCONSTR_ABS的新一般约束。

一个ABS约束 \(r = \mbox{abs}\{x\}\) 表示结果变量 \(r\) 应该等于参数变量 \(x\) 的绝对值。

Arguments:

• resvar – 新约束的结果变量。

• argvar – 新约束的参数变量。

• name – 新的一般约束的名称。

Return value:

新的通用约束。

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");

GRBGenConstr addGenConstrAnd(GRBVar resvar, GRBVar[] vars, String name)

向模型添加一个新的通用约束，类型为GRB.GENCONSTR_AND。

一个AND约束\(r = \mbox{and}\{x_1,\ldots,x_n\}\)表示 二进制结果变量\(r\)应该为\(1\)当且仅当 所有操作数变量\(x_1,\ldots,x_n\)都等于 \(1\)。如果任何一个操作数变量是\(0\)，那么 结果也应该是\(0\)。

请注意，参与此类约束的所有变量将被强制为二进制，无论它们是如何创建的。

Arguments:

• resvar – 新约束的结果变量。

• vars – 作为新约束操作数的变量数组。

• name – 新的一般约束的名称。

Return value:

新的通用约束。

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");

GRBGenConstr addGenConstrOr(GRBVar resvar, GRBVar[] vars, String name)

向模型添加一个新的一般约束，类型为GRB.GENCONSTR_OR。

一个OR约束\(r = \mbox{or}\{x_1,\ldots,x_n\}\)表示，当且仅当任何一个操作数变量\(x_1,\ldots,x_n\)等于\(1\)时，二进制结果变量\(r\)应为\(1\)。如果所有操作数变量都是\(0\)，那么结果也应为\(0\)。

请注意，参与此类约束的所有变量将被强制为二进制，无论它们是如何创建的。

Arguments:

• resvar – 新约束的结果变量。

• vars – 作为新约束操作数的变量数组。

• name – 新的一般约束的名称。

Return value:

新的通用约束。

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");

GRBGenConstr addGenConstrNorm(GRBVar resvar, GRBVar[] vars, double which, String name)

向模型添加一个类型为GRB.GENCONSTR_NORM的新一般约束。

一个NORM约束\(r = \mbox{norm}\{x_1,\ldots,x_n\}\)表示 结果变量\(r\)应该等于参数向量\(x_1,\ldots,x_n\)的向量范数。

Arguments:

• resvar – 新约束的结果变量。

• vars – 作为新约束操作数的变量数组。请注意，此数组不能包含重复项。

• which – 使用哪种范数。选项有 0、1、2 和 GRB.INFINITY。

• name – 新的一般约束的名称。

Return value:

新的通用约束。

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");

GRBGenConstr addGenConstrNL(GRBVar resvar, int[] opcode, double[] data, int[] parent, String name)

向模型添加一个新的一般约束，类型为GRB.GENCONSTR_NL。

一个非线性约束 \(r = f(x)\) 表示结果变量 \(r\) 应等于给定函数 \(f\) 的函数值 \(f(x)\)，该函数以表达式树的形式描述在 非线性约束 中。

Arguments:

• resvar – 新约束的结果变量。

• opcode – 一个包含节点操作码的数组。

• data – 包含每个节点辅助数据的数组。

• parent – 一个提供节点父索引的数组

• name – 新的一般约束的名称。

Return value:

新的通用约束。

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");

int[]    opcode = {GRB.OPCODE_PLUS, GRB.OPCODE_SIN,
                   GRB.OPCODE_MULTIPLY, GRB.OPCODE_CONSTANT,
                   GRB.OPCODE_VARIABLE, GRB.OPCODE_VARIABLE};
double[] data   = {-1.0, -1.0, -1.0, 2.5, 1.0, 2.0};
int[]    parent = {-1, 0, 1, 2, 2, 0};

GRBGenConstr nlgc = model.addGenConstrNL(x0, opcode, data, parent, "nlconstr");

GRBGenConstr addGenConstrIndicator(GRBVar binvar, int binval, GRBLinExpr expr, char sense, double rhs, String name)

向模型添加一个类型为GRB.GENCONSTR_INDICATOR的新一般约束。

一个INDICATOR约束\(z = f \rightarrow a^Tx \leq b\)表示如果二进制指示变量\(z\)等于\(f\)，其中\(f \in \{0,1\}\)，那么线性约束\(a^Tx \leq b\)应该成立。另一方面，如果\(z = 1-f\)，线性约束可能被违反。线性约束的方向也可以指定为\(=\)或\(\geq\)。

请注意，约束的指示变量 \(z\) 将被强制为二进制，无论它是如何创建的。

Arguments:

• binvar – 二进制指示变量。

• binval – 二进制指示变量的值，该值将强制满足线性约束条件（\(0\) 或 \(1\)）。

• expr – 由指示器触发的线性约束的左侧表达式。

• sense – 线性约束的意义。选项是 GRB.LESS_EQUAL, GRB.EQUAL, 或 GRB.GREATER_EQUAL。

• rhs – 线性约束的右侧值。

• name – 新的一般约束的名称。

Return value:

新的通用约束。

Example:

// Create binary indicator variable
GRBVar z = model.addVar(0.0, 1.0, 0.0, GRB.BINARY, "resvar");
// 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();
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");

GRBGenConstr addGenConstrPWL(GRBVar xvar, GRBVar yvar, double[] xpts, double[] ypts, String name)

向模型添加一个新的一般约束，类型为GRB.GENCONSTR_PWL。

分段线性（PWL）约束规定变量 \(x\) 和 \(y\) 之间的关系必须满足 \(y = f(x)\)，其中 \(f\) 是一个分段线性函数。\(f\) 的断点作为参数提供。有关分段线性函数如何定义的详细信息，请参阅分段线性目标的描述。

Arguments:

• xvar – \(x\) 变量。

• yvar – \(y\) 变量。

• xpts – 定义分段线性函数的点的\(x\)值。必须按非递减顺序排列。

• ypts – 定义分段线性函数的点的 \(y\) 值。

• name – 新的一般约束的名称。

Return value:

新的通用约束。

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");

GRBGenConstr addGenConstrPoly(GRBVar xvar, GRBVar yvar, double[] p, String name, String options)

向模型添加一个类型为GRB.GENCONSTR_POLY的新一般约束。

多项式函数约束声明了变量\(x\)和\(y\)之间的关系应满足 \(y = p_0 x^d + p_1 x^{d-1} + ... + p_{d-1} x + p_{d}\)。

函数的分段线性近似被添加到模型中。近似的细节通过以下四个属性（或使用相同名称的参数）控制：FuncPieces、FuncPieceError、FuncPieceLength 和 FuncPieceRatio。或者，通过设置属性 FuncNonlinear，可以将函数视为非线性约束。详情请参阅 一般约束 讨论。

Arguments:

• xvar – \(x\) 变量。

• yvar – \(y\) 变量。

• p – 多项式函数的系数（从最高次幂的系数开始）。

• name – 新的一般约束的名称。

• options – 一个字符串，可用于设置控制此函数约束的分段线性近似的属性。要为属性赋值，请在属性名称后加上等号和所需的值（无空格）。不同属性的赋值应通过空格分隔（例如“FuncPieces=-1 FuncPieceError=0.001”）。

Return value:

新的通用约束。

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

GRBGenConstr addGenConstrExp(GRBVar xvar, GRBVar yvar, String name, String options)

向模型添加一个新的一般约束，类型为GRB.GENCONSTR_EXP。

自然指数函数约束表明，变量 \(x\) 和 \(y\) 之间的关系应满足 \(y = \exp(x)\)。

函数的分段线性近似被添加到模型中。近似的细节通过以下四个属性（或使用相同名称的参数）控制：FuncPieces、FuncPieceError、FuncPieceLength 和 FuncPieceRatio。或者，通过设置属性 FuncNonlinear，可以将函数视为非线性约束。详情请参阅 一般约束 讨论。

Arguments:

• xvar – \(x\) 变量。

• yvar – \(y\) 变量。

• name – 新的一般约束的名称。

• options – 一个字符串，可用于设置控制此函数约束的分段线性近似的属性。要为属性赋值，请在属性名称后加上等号和所需的值（无空格）。不同属性的赋值应以空格分隔（例如“FuncPieces=-1 FuncPieceError=0.001”）。

Return value:

新的通用约束。

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

GRBGenConstr addGenConstrExpA(GRBVar xvar, GRBVar yvar, double a, String name, String options)

向模型添加一个类型为GRB.GENCONSTR_EXPA的新一般约束。

指数函数约束表明，变量\(x\)和\(y\)之间的关系应满足\(y = a^x\)，其中\(a > 0\)

是（常数）基数。

函数的分段线性近似被添加到模型中。近似的细节通过以下四个属性（或使用相同名称的参数）控制：FuncPieces、FuncPieceError、FuncPieceLength 和 FuncPieceRatio。或者，通过设置属性 FuncNonlinear，可以将函数视为非线性约束。详情请参阅 一般约束 讨论。

Arguments:

• xvar – \(x\) 变量。

• yvar – \(y\) 变量。

• a – 函数的基数，\(a > 0\) 。

• name – 新的一般约束的名称。

• options – 一个字符串，可用于设置控制此函数约束的分段线性近似的属性。要为属性赋值，请在属性名称后加上等号和所需的值（无空格）。不同属性的赋值应通过空格分隔（例如“FuncPieces=-1 FuncPieceError=0.001”）。

Return value:

新的通用约束。

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

GRBGenConstr addGenConstrLog(GRBVar xvar, GRBVar yvar, String name, String options)

向模型添加一个新的一般约束，类型为GRB.GENCONSTR_LOG。

自然对数函数约束表明，变量 \(x\) 和 \(y\) 之间的关系应满足 \(y = \log(x)\)。

函数的分段线性近似被添加到模型中。近似的细节通过以下四个属性（或使用相同名称的参数）控制：FuncPieces、FuncPieceError、FuncPieceLength 和 FuncPieceRatio。或者，通过设置属性 FuncNonlinear，可以将函数视为非线性约束。详情请参阅 一般约束 讨论。

Arguments:

• xvar – \(x\) 变量。

• yvar – \(y\) 变量。

• name – 新的一般约束的名称。

• options – 一个字符串，可用于设置控制此函数约束的分段线性近似的属性。要为属性赋值，请在属性名称后加上等号和所需的值（无空格）。不同属性的赋值应通过空格分隔（例如“FuncPieces=-1 FuncPieceError=0.001”）。

Return value:

新的通用约束。

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

GRBGenConstr addGenConstrLogA(GRBVar xvar, GRBVar yvar, double a, String name, String options)

向模型添加一个新的一般约束，类型为GRB.GENCONSTR_LOGA。

对数函数约束表明，变量 \(x\) 和 \(y\) 之间的关系应满足 \(y = \log_a(x)\)，其中 \(a > 0\)

是（常数）基数。

函数的分段线性近似被添加到模型中。近似的细节通过以下四个属性（或使用相同名称的参数）控制：FuncPieces、FuncPieceError、FuncPieceLength 和 FuncPieceRatio。或者，通过设置属性 FuncNonlinear，可以将函数视为非线性约束。详情请参阅 一般约束 讨论。

Arguments:

• xvar – \(x\) 变量。

• yvar – \(y\) 变量。

• a – 函数的基数，\(a > 0\) 。

• name – 新的一般约束的名称。

• options – 一个字符串，可用于设置控制此函数约束的分段线性近似的属性。要为属性赋值，请在属性名称后加上等号和所需的值（无空格）。不同属性的赋值应通过空格分隔（例如“FuncPieces=-1 FuncPieceError=0.001”）。

Return value:

新的通用约束。

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

GRBGenConstr addGenConstrLogistic(GRBVar xvar, GRBVar yvar, String name, String options)

向模型添加一个新的一般约束，类型为GRB.GENCONSTR_LOGISTIC。

逻辑函数约束表明，变量 \(x\) 和 \(y\) 之间的关系 \(y = \frac{1}{1 + e^{-x}}\) 应该成立。

函数的分段线性近似被添加到模型中。近似的细节通过以下四个属性（或使用相同名称的参数）控制：FuncPieces、FuncPieceError、FuncPieceLength 和 FuncPieceRatio。或者，通过设置属性 FuncNonlinear，可以将函数视为非线性约束。详情请参阅 一般约束 讨论。

Arguments:

• xvar – \(x\) 变量。

• yvar – \(y\) 变量。

• name – 新的一般约束的名称。

• options – 一个字符串，可用于设置控制此函数约束的分段线性近似的属性。要为属性赋值，请在属性名称后加上等号和所需的值（无空格）。不同属性的赋值应以空格分隔（例如“FuncPieces=-1 FuncPieceError=0.001”）。

Return value:

新的通用约束。

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

GRBGenConstr addGenConstrPow(GRBVar xvar, GRBVar yvar, double a, String name, String options)

向模型添加一个新的一般约束，类型为GRB.GENCONSTR_POW。

幂函数约束表明，变量 \(x\) 和 \(y\) 之间的关系 \(y = x^a\) 应该成立，其中 \(a\) 是（常数）指数。

如果指数 \(a\) 是负数，\(x\) 的下界必须严格为正。如果指数不是整数，\(x\) 的下界必须为非负数。

函数的分段线性近似被添加到模型中。近似的细节通过以下四个属性（或使用相同名称的参数）控制：FuncPieces、FuncPieceError、FuncPieceLength 和 FuncPieceRatio。或者，通过设置属性 FuncNonlinear，可以将函数视为非线性约束。详情请参阅 一般约束 讨论。

Arguments:

• xvar – \(x\) 变量。

• yvar – \(y\) 变量。

• a – 函数的指数。

• name – 新的一般约束的名称。

• options – 一个字符串，可用于设置控制此函数约束的分段线性近似的属性。要为属性赋值，请在属性名称后加上等号和所需的值（无空格）。不同属性的赋值应以空格分隔（例如“FuncPieces=-1 FuncPieceError=0.001”）。

Return value:

新的通用约束。

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

GRBGenConstr addGenConstrSin(GRBVar xvar, GRBVar yvar, String name, String options)

向模型添加一个新的一般约束，类型为GRB.GENCONSTR_SIN。

正弦函数约束表明，变量 \(x\) 和 \(y\) 之间的关系应满足 \(y = \sin(x)\)。

函数的分段线性近似被添加到模型中。近似的细节通过以下四个属性（或使用相同名称的参数）控制：FuncPieces、FuncPieceError、FuncPieceLength 和 FuncPieceRatio。或者，通过设置属性 FuncNonlinear，可以将函数视为非线性约束。详情请参阅 一般约束 讨论。

Arguments:

• xvar – \(x\) 变量。

• yvar – \(y\) 变量。

• name – 新的一般约束的名称。

• options – 一个字符串，可用于设置控制此函数约束的分段线性近似的属性。要为属性赋值，请在属性名称后加上等号和所需的值（无空格）。不同属性的赋值应以空格分隔（例如“FuncPieces=-1 FuncPieceError=0.001”）。

Return value:

新的通用约束。

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

GRBGenConstr addGenConstrCos(GRBVar xvar, GRBVar yvar, String name, String options)

向模型添加一个新的一般约束，类型为GRB.GENCONSTR_COS。

余弦函数约束规定变量 \(x\) 和 \(y\) 之间的关系应满足 \(y = \cos(x)\)。

函数的分段线性近似被添加到模型中。近似的细节通过以下四个属性（或使用相同名称的参数）控制：FuncPieces、FuncPieceError、FuncPieceLength 和 FuncPieceRatio。或者，通过设置属性 FuncNonlinear，可以将函数视为非线性约束。详情请参阅 一般约束 讨论。

Arguments:

• xvar – \(x\) 变量。

• yvar – \(y\) 变量。

• name – 新的一般约束的名称。

• options – 一个字符串，可用于设置控制此函数约束的分段线性近似的属性。要为属性赋值，请在属性名称后加上等号和所需的值（无空格）。不同属性的赋值应通过空格分隔（例如“FuncPieces=-1 FuncPieceError=0.001”）。

Return value:

新的通用约束。

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

GRBGenConstr addGenConstrTan(GRBVar xvar, GRBVar yvar, String name, String options)

向模型添加一个新的一般约束，类型为GRB.GENCONSTR_TAN。

正切函数约束表明，变量 \(x\) 和 \(y\) 之间的关系应满足 \(y = \tan(x)\)。

函数的分段线性近似被添加到模型中。近似的细节通过以下四个属性（或使用相同名称的参数）控制：FuncPieces、FuncPieceError、FuncPieceLength 和 FuncPieceRatio。或者，通过设置属性 FuncNonlinear，可以将函数视为非线性约束。详情请参阅 一般约束 讨论。

Arguments:

• xvar – \(x\) 变量。

• yvar – \(y\) 变量。

• name – 新的一般约束的名称。

• options – 一个字符串，可用于设置控制此函数约束的分段线性近似的属性。要为属性赋值，请在属性名称后加上等号和所需的值（无空格）。不同属性的赋值应通过空格分隔（例如“FuncPieces=-1 FuncPieceError=0.001”）。

Return value:

新的通用约束。

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

GRBQConstr addQConstr(GRBQuadExpr lhsExpr, char sense, GRBQuadExpr rhsExpr, String name)

向模型添加一个二次约束。

重要

Gurobi 可以处理凸和非凸二次约束。它们之间的差异可能既重要又微妙。有关更多信息，请参阅此讨论。

Arguments:

• lhsExpr – 新二次约束的左侧二次表达式。

• sense – 新二次约束的意义（GRB.LESS_EQUAL， GRB.EQUAL，或 GRB.GREATER_EQUAL）。

• rhsExpr – 新二次约束的右侧二次表达式。

• name – 新约束的名称。

Return value:

新的二次约束对象。

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 quadratic expression x^2 + x*y + y
GRBQuadExpr lhsExpr = new GRBQuadExpr();
lhsExpr.addTerm(1.0, x, x);
lhsExpr.addTerm(1.0, x, y);
lhsExpr.addTerm(1.0, y);
// Create quadratic expression y^2
GRBQuadExpr rhsExpr = new GRBQuadExpr();
rhsExpr.addTerm(1.0, y, y);

// Add quadratic constraint x^2 + x*y + y = y^2 with name c1
GRBQConstr constr = model.addQConstr(lhsExpr, GRB.EQUAL, rhsExpr, "c1");

GRBQConstr addQConstr(GRBQuadExpr lhsExpr, char sense, GRBVar rhsVar, String name)

向模型添加一个二次约束。

重要

Gurobi 可以处理凸和非凸二次约束。它们之间的差异可能既重要又微妙。有关更多信息，请参阅此讨论。

Arguments:

• lhsExpr – 新二次约束的左侧二次表达式。

• sense – 新二次约束的意义（GRB.LESS_EQUAL， GRB.EQUAL，或 GRB.GREATER_EQUAL）。

• rhsVar – 新二次约束的右侧变量。

• name – 新约束的名称。

Return value:

新的二次约束对象。

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 quadratic expression x^2 + x*y + y
GRBQuadExpr lhsExpr = new GRBQuadExpr();
lhsExpr.addTerm(1.0, x, x);
lhsExpr.addTerm(1.0, x, y);
lhsExpr.addTerm(1.0, y);

// Add quadratic constraint x^2 + x*y + y = y with name c1
GRBQConstr constr = model.addQConstr(lhsExpr, GRB.EQUAL, y, "c1");

GRBQConstr addQConstr(GRBQuadExpr lhsExpr, char sense, GRBLinExpr rhsExpr, String name)

向模型添加一个二次约束。

重要

Gurobi 可以处理凸和非凸二次约束。它们之间的差异可能既重要又微妙。有关更多信息，请参阅此讨论。

Arguments:

• lhsExpr – 新二次约束的左侧二次表达式。

• sense – 新二次约束的意义（GRB.LESS_EQUAL， GRB.EQUAL，或 GRB.GREATER_EQUAL）。

• rhsExpr – 新二次约束的右侧线性表达式。

• name – 新约束的名称。

Return value:

新的二次约束对象。

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 quadratic expression x^2 + x*y + y
GRBQuadExpr lhsExpr = new GRBQuadExpr();
lhsExpr.addTerm(1.0, x, x);
lhsExpr.addTerm(1.0, x, y);
lhsExpr.addTerm(1.0, y);
// Create linear expression 2*x - y
GRBLinExpr rhsExpr = new GRBLinExpr();
rhsExpr.addTerm(2.0, x);
rhsExpr.addTerm(-1.0, y);

// Add quadratic constraint x^2 + x*y + y = 2*x - y with name c1
GRBQConstr constr = model.addQConstr(lhsExpr, GRB.EQUAL, rhsExpr, "c1");

GRBQConstr addQConstr(GRBQuadExpr lhsExpr, char sense, double rhs, String name)

向模型添加一个二次约束。

重要

Gurobi 可以处理凸和非凸二次约束。它们之间的差异可能既重要又微妙。有关更多信息，请参阅此讨论。

Arguments:

• lhsExpr – 新二次约束的左侧二次表达式。

• sense – 新二次约束的意义（GRB.LESS_EQUAL， GRB.EQUAL，或 GRB.GREATER_EQUAL）。

• rhs – 新二次约束的右侧值。

• name – 新约束的名称。

Return value:

新的二次约束对象。

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 quadratic expression x^2 + x*y + y
GRBQuadExpr lhsExpr = new GRBQuadExpr();
lhsExpr.addTerm(1.0, x, x);
lhsExpr.addTerm(1.0, x, y);
lhsExpr.addTerm(1.0, y);

// Add quadratic constraint x^2 + x*y + y = 0 with name c1
GRBQConstr constr = model.addQConstr(lhsExpr, GRB.EQUAL, 0, "c1");

GRBQConstr addQConstr(GRBLinExpr lhsExpr, char sense, GRBQuadExpr rhsExpr, String name)

向模型添加一个二次约束。

重要

Gurobi 可以处理凸和非凸二次约束。它们之间的差异可能既重要又微妙。有关更多信息，请参阅此讨论。

Arguments:

• lhsExpr – 新二次约束的左侧线性表达式。

• sense – 新二次约束的意义（GRB.LESS_EQUAL， GRB.EQUAL，或 GRB.GREATER_EQUAL）。

• rhsExpr – 新二次约束的右侧二次表达式。

• name – 新约束的名称。

Return value:

新的二次约束对象。

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 linear expression 2*x - y
 GRBLinExpr lhsExpr = new GRBLinExpr();
 lhsExpr.addTerm(2.0, x);
 lhsExpr.addTerm(-1.0, y);
// Create quadratic expression x^2 + x*y + y
 GRBQuadExpr rhsExpr = new GRBQuadExpr();
 rhsExpr.addTerm(1.0, x, x);
 rhsExpr.addTerm(1.0, x, y);
 rhsExpr.addTerm(1.0, y);

 // Add quadratic constraint 2*x - y = x^2 + x*y + y with name c1
 GRBQConstr constr = model.addQConstr(lhsExpr, GRB.EQUAL, rhsExpr, "c1");

GRBQConstr addQConstr(GRBVar lhsVar, char sense, GRBQuadExpr rhsExpr, String name)

向模型添加一个二次约束。

重要

Gurobi 可以处理凸和非凸二次约束。它们之间的差异可能既重要又微妙。有关更多信息，请参阅此讨论。

Arguments:

• lhsVar – 新二次约束的左侧变量。

• sense – 新二次约束的意义（GRB.LESS_EQUAL， GRB.EQUAL，或 GRB.GREATER_EQUAL）。

• rhsExpr – 新二次约束的右侧二次表达式。

• name – 新约束的名称。

Return value:

新的二次约束对象。

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 quadratic expression x^2 + x*y + y
GRBQuadExpr rhsExpr = new GRBQuadExpr();
rhsExpr.addTerm(1.0, x, x);
rhsExpr.addTerm(1.0, x, y);
rhsExpr.addTerm(1.0, y);

// Add quadratic constraint x <= x^2 + x*y + y with name c1
GRBQConstr constr = model.addQConstr(x, GRB.LESS_EQUAL, rhsExpr, "c1");

GRBQConstr addQConstr(double lhs, char sense, GRBQuadExpr rhsExpr, String name)

向模型添加一个二次约束。

重要

Gurobi 可以处理凸和非凸二次约束。它们之间的差异可能既重要又微妙。有关更多信息，请参阅此讨论。

Arguments:

• lhs – 新二次约束的左侧值。

• sense – 新二次约束的意义（GRB.LESS_EQUAL， GRB.EQUAL，或 GRB.GREATER_EQUAL）。

• rhsExpr – 新二次约束的右侧二次表达式。

• name – 新约束的名称。

Return value:

新的二次约束对象。

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 quadratic expression x^2 + x*y + y
GRBQuadExpr rhsExpr = new GRBQuadExpr();
rhsExpr.addTerm(1.0, x, x);
rhsExpr.addTerm(1.0, x, y);
rhsExpr.addTerm(1.0, y);

// Add quadratic constraint 0 <= x^2 + x*y + y with name c1
GRBQConstr constr = model.addQConstr(0.0, GRB.LESS_EQUAL, rhsExpr, "c1");

GRBConstr addRange(GRBLinExpr expr, double lower, double upper, String name)

向模型添加单个范围约束。范围约束规定输入表达式的值必须在任何解决方案中位于指定的lower和upper界限之间。

请注意，范围约束在内部存储为等式约束。我们向模型添加一个额外的变量来捕获范围信息。因此，范围约束上的感知属性将始终为GRB.EQUAL。特别是引入一个范围约束

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

等同于添加一个松弛变量 \(s\) 和以下约束条件

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

Arguments:

• expr – 新范围约束的线性表达式。

• lower – 线性表达式的下限。

• upper – 线性表达式的上限。

• name – 新约束的名称。

Return value:

新的约束对象。

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();
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");

GRBConstr[] addRanges(GRBLinExpr[] exprs, double[] lower, double[] upper, String[] names)

向模型添加新的范围约束。范围约束声明输入表达式的值必须在任何解决方案中位于指定的lower和upper界限之间。

Arguments:

• exprs – 新范围约束的线性表达式。

• lower – 线性表达式的下界。

• upper – 线性表达式的上界。

• names – 新范围约束的名称。

Return value:

新的约束对象数组。

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();
lexpr1.addTerm(1.0, x);
lexpr1.addTerm(1.0, y);
GRBLinExpr lexpr2 = new GRBLinExpr();
lexpr2.addTerm(1.0, x);
lexpr2.addTerm(-2.0, y);

GRBLinExpr[] lexprs = {lexpr1, lexpr2};
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);

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

向模型添加一个SOS约束。请参阅参考手册中的SOS约束部分以获取更多详细信息。

Arguments:

• vars – 参与SOS约束的变量数组。

• weights – SOS约束中变量的权重。

• type – SOS类型（可以是GRB.SOS_TYPE1或GRB.SOS_TYPE2）。

Return value:

新的SOS约束。

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);

GRBVar addVar(double lb, double ub, double obj, char type, String name)

向模型添加一个单一的决策变量；非零条目将在稍后添加。

Arguments:

• lb – 新变量的下界。

• ub – 新变量的上限。

• obj – 新变量的目标系数。

• type – 新变量的变量类型 (GRB.CONTINUOUS, GRB.BINARY, GRB.INTEGER, GRB.SEMICONT, 或 GRB.SEMIINT).

• name – 新变量的名称。

Return value:

新变量对象。

Example:

// Create variable
GRBVar x = 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)

向模型添加单个决策变量和相关的非零系数。

Arguments:

• lb – 新变量的下界。

• ub – 新变量的上限。

• obj – 新变量的目标系数。

• type – 新变量的变量类型 (GRB.CONTINUOUS, GRB.BINARY, GRB.INTEGER, GRB.SEMICONT, 或 GRB.SEMIINT).

• constrs – 变量参与的约束数组。

• coeffs – 变量参与的每个约束的系数数组。constrs 和 coeffs 数组的长度必须相同。

• name – 新变量的名称。

Return value:

新变量对象。

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");

GRBVar addVar(double lb, double ub, double obj, char type, GRBColumn col, String name)

向模型添加单个决策变量。此签名允许您使用GRBColumn对象指定新变量所属的约束集。

Arguments:

• lb – 新变量的下界。

• ub – 新变量的上限。

• obj – 新变量的目标系数。

• type – 新变量的变量类型 (GRB.CONTINUOUS, GRB.BINARY, GRB.INTEGER, GRB.SEMICONT, 或 GRB.SEMIINT).

• col – GRBColumn 对象，用于指定新变量所属的一组约束。

• name – 新变量的名称。

Return value:

新变量对象。

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");

GRBVar[] addVars(int count, char type)

向模型添加count个新的决策变量。所有相关的属性都采用其默认值，除了变量type，它被指定为参数。

Arguments:

• count – 要添加的变量数量。

• type – 新变量的变量类型 (GRB.CONTINUOUS, GRB.BINARY, GRB.INTEGER, GRB.SEMICONT, 或 GRB.SEMIINT).

Return value:

新变量对象的数组。

Example:

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

GRBVar[] addVars(double[] lb, double[] ub, double[] obj, char[] type, String[] names)

向模型添加新的决策变量。添加的变量数量由输入数组的长度决定（所有参数必须一致）。

Arguments:

• lb – 新变量的下界。可以是null，在这种情况下，变量的下界为0.0。

• ub – 新变量的上界。可以是null，在这种情况下，变量将获得无限的上界。

• obj – 新变量的目标系数。可以是null，在这种情况下，变量的目标系数为0.0。

• type – 新变量的变量类型（GRB.CONTINUOUS, GRB.BINARY, GRB.INTEGER, GRB.SEMICONT, 或 GRB.SEMIINT）。 可以为 null，在这种情况下，变量被假定为连续型。

• names – 新变量的名称。可以是null，在这种情况下，所有变量都会被赋予默认名称。

Return value:

新变量对象的数组。

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);

GRBVar[] addVars(double[] lb, double[] ub, double[] obj, char[] type, String[] names, int start, int len)

向模型添加新的决策变量。此签名允许您使用数组来保存各种变量属性（下限、上限等），而无需强制您为数组中的每个条目添加变量。start 和 len 参数允许您指定要添加的变量。

Arguments:

• lb – 新变量的下界。可以是null，在这种情况下，变量的下界为0.0。

• ub – 新变量的上界。可以是null，在这种情况下，变量将获得无限的上界。

• obj – 新变量的目标系数。可以是null，在这种情况下，变量的目标系数为0.0。

• type – 新变量的变量类型（GRB.CONTINUOUS, GRB.BINARY, GRB.INTEGER, GRB.SEMICONT, 或 GRB.SEMIINT）。 可以为 null，在这种情况下，变量被假定为连续型。

• names – 新变量的名称。可以是null，在这种情况下，所有变量都会被赋予默认名称。

• start – 列表中要添加的第一个变量。

• len – 要添加的变量数量。

Return value:

新变量对象的数组。

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"};
// Add only the first two variables
GRBVar[] x = model.addVars(null, ub, obj, null, names, 0, 2);

GRBVar[] addVars(double[] lb, double[] ub, double[] obj, char[] type, String[] names, GRBColumn[] cols)

向模型添加新的决策变量。此签名允许您使用GRBColumn对象的数组来指定每个新变量所属的约束列表。

Arguments:

• lb – 新变量的下界。可以是null，在这种情况下，变量的下界为0.0。

• ub – 新变量的上界。可以是null，在这种情况下，变量将获得无限的上界。

• obj – 新变量的目标系数。可以是null，在这种情况下，变量的目标系数为0.0。

• type – 新变量的变量类型 (GRB.CONTINUOUS, GRB.BINARY, GRB.INTEGER, GRB.SEMICONT, 或 GRB.SEMIINT)。 可以为 null，在这种情况下，变量被假定为连续型。

• names – 新变量的名称。可以是null，在这种情况下，所有变量都会被赋予默认名称。

• cols – GRBColumn 对象，用于指定每个新列所属的一组约束。

Return value:

新变量对象的数组。

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);

void chgCoeff(GRBConstr constr, GRBVar var, double newval)

更改模型中的一个系数。所需的更改通过使用一个GRBVar对象、一个GRBConstr对象以及指定约束中指定变量的所需系数来捕获。如果您对同一系数进行多次更改，将应用最后一次更改。

请注意，由于我们采用了延迟更新的方法，更改实际上不会生效，直到您更新模型（使用GRBModel.update）、优化模型（使用GRBModel.optimize）或将模型写入磁盘（使用GRBModel.write）。

Arguments:

• constr – 要更改的系数的约束。

• var – 要更改系数的变量。

• newval – 系数的期望新值。

Example:

// Change coefficient of variable x in constraint c1
model.chgCoeff(c1, x, 1.0);

void chgCoeffs(GRBConstr[] constrs, GRBVar[] vars, double[] newvals)

更改模型中的系数列表。每个所需的更改都使用一个GRBVar对象、一个GRBConstr对象以及指定约束中指定变量的所需系数来捕获。输入数组中的每个条目都对应于一个所需的系数更改。输入数组的长度必须全部相同。如果对同一系数进行多次更改，将应用最后一个更改。

请注意，由于我们采用了延迟更新的方法，更改实际上不会生效，直到您更新模型（使用GRBModel.update）、优化模型（使用GRBModel.optimize）或将模型写入磁盘（使用GRBModel.write）。

Arguments:

• constrs – 要更改的系数的约束条件。

• vars – 需要更改系数的变量。

• newvals – 系数的期望新值。

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);

void computeIIS()

计算一个不可约不一致子系统（IIS）。

IIS 是具有以下属性的约束和变量边界的子集：

• 这仍然是不可行的，并且

• 如果移除单个约束或边界，子系统将变得可行。

请注意，一个不可行的模型可能有多个IIS。Gurobi返回的不一定是最小的一个；可能存在其他具有更少约束或边界的IIS。

IIS 结果以多个属性返回： IISConstr, IISLB, IISUB, IISSOS, IISQConstr, 和 IISGenConstr. 每个属性指示相应的模型元素是否是计算出的 IIS 的成员。

请注意，对于具有一般函数约束的模型，约束的分段线性近似可能会导致不可靠的IIS结果。

IIS日志提供了关于算法进度的信息，包括对最终IIS大小的猜测。

如果IIS计算在完成之前被中断，Gurobi将返回到目前为止找到的最小不可行子系统。

IISConstrForce、IISLBForce、IISUBForce、IISSOSForce、IISQConstrForce和IISGenConstrForce属性允许您标记模型元素以包含或排除在计算的IIS中。将属性设置为1会强制将相应元素包含在IIS中，将其设置为0会强制将其排除在IIS之外，将其设置为-1则允许算法决定。

为了举例说明这些属性何时可能有用，考虑一种情况，即已知初始模型是可行的，但在添加约束或收紧边界后变得不可行。如果你只对了解哪些更改导致了不可行性感兴趣，你可以强制将未修改的边界和约束纳入IIS。这使得IIS算法能够专注于新的约束，这通常会显著加快速度。

请注意，将任何Force属性设置为0可能会使生成的子系统变得可行，这将使得无法构建IIS。无论如何尝试都会导致IIS_NOT_INFEASIBLE错误。同样，将此属性设置为1可能会导致IIS不可约。更准确地说，系统仅在具有-1或0的强制值的模型元素方面才是不可约的。

此方法填充了IISConstr、IISQConstr和IISGenConstr约束属性，IISSOS、SOS属性，以及IISLB和IISUB变量属性。您还可以通过写入.ilp格式文件（参见GRBModel.write）来获取有关IIS计算结果的信息。此文件仅包含原始模型中的IIS。

使用 IISMethod 参数来调整 IIS 算法的行为。

请注意，此方法可用于计算连续和MIP模型的IIS。

Example:

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

void discardConcurrentEnvs()

丢弃模型的并发环境。

由getConcurrentEnv创建的并发环境将被每个后续调用并发优化器使用，直到并发环境被丢弃。

使用 getMultiobjEnv 创建一个多目标环境。

Example:

GRBEnv env0 = model.getConcurrentEnv(0);
GRBEnv env1 = model.getConcurrentEnv(1);

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

model.optimize();
model.discardConcurrentEnvs();

void discardMultiobjEnvs()

丢弃与模型关联的所有多目标环境，从而将多目标优化恢复为其默认行为。

请参考关于 多目标的讨论，了解如何指定多个目标函数并控制它们之间的权衡。

使用getMultiobjEnv来创建一个多目标环境。

Example:

GRBEnv env0 = model.getMultiobjEnv(0);
GRBEnv env1 = model.getMultiobjEnv(1);

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

model.optimize();
model.discardMultiobjEnvs();

void dispose()

释放与GRBModel对象关联的资源。虽然Java垃圾收集器最终会回收这些资源，但我们建议您在使用完模型后调用dispose方法。

在调用dispose之后，您不应尝试使用GRBModel对象。

Example:

GRBEnv env = new GRBEnv();
GRBModel model = 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)

修改GRBModel对象以创建可行性松弛。 请注意，您需要在结果上调用optimize来计算实际的松弛解。

可行性松弛是一种模型，当解决时，它最小化解违反原始模型的边界和线性约束的量。该方法提供了多种指定松弛的选项。

如果您指定relaxobjtype=0，可行性松弛的目标是最小化边界和约束违规的加权幅度之和。lbpen、ubpen和rhspen参数分别指定了下界、上界和线性约束中每单位违规的成本。

如果您指定relaxobjtype=1，可行性松弛的目标是最小化边界和约束违反的加权平方和。lbpen、ubpen和rhspen参数分别指定了下界、上界和线性约束违反的平方系数。

如果您指定relaxobjtype=2，可行性松弛的目标是最小化边界和约束违规的加权计数。lbpen、ubpen和rhspen参数分别指定违反下界、上界和线性约束的成本。

举个例子，如果一个带有rhspen值p的约束被违反了2.0，它将为relaxobjtype=0的可行性松弛目标贡献2*p，为relaxobjtype=1贡献2*2*p，为relaxobjtype=2贡献p。

minrelax 参数是一个布尔值，用于控制创建的可行性松弛类型。如果 minrelax=false，优化返回的模型会给出一个最小化违规成本的解决方案。如果 minrelax=true，优化返回的模型会找到一个最小化原始目标的解决方案，但仅限于那些最小化违规成本的解决方案。请注意，当 minrelax=true 时，feasRelax 必须解决一个优化问题以找到最小可能的松弛，这可能会非常耗时。

此方法有两个签名。较复杂的一个接受变量和约束的列表，以及与放松相应的下限、上限和约束相关的惩罚。如果变量或约束未包含在这些列表中，则相关的界限或约束可能不会被违反。较简单的签名接受一对布尔参数，vrelax 和 crelax，它们指示变量界限和/或约束是否可以被违反。如果 vrelax/crelax 是 true，则每个界限/约束分别允许被违反，并且相关成本为1.0。

有关此例程如何转换模型的示例，以及有关创建的变量和约束的更多详细信息，请参阅本节。

请注意，这是一个破坏性方法：它会修改调用它的模型。如果您不想修改原始模型，请使用GRBModel constructor在调用此方法之前创建一个副本。

创建一个可行性松弛模型。

Arguments:

• relaxobjtype – 用于寻找最小成本松弛的成本函数。

• minrelax – 执行可行性松弛的类型。

• vars – 允许违反其界限的变量。

• lbpen – 违反变量下界的惩罚。对于参数 vars 中的每个变量都有一个条目。

• ubpen – 违反变量上限的惩罚。参数 vars 中的每个变量都有一个条目。

• constrs – 允许被违反的线性约束。

• rhspen – 违反线性约束的惩罚。对于参数 constrs 中的每个约束，都有一个条目。

Return value:

如果minrelax为false，则返回0。如果minrelax为true，返回值是执行的松弛的目标值。如果该值小于0，表示该方法未能创建可行性松弛。

Example:

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

double feasRelax(int relaxobjtype, boolean minrelax, boolean vrelax, boolean crelax)

修改GRBModel对象以创建可行性松弛。 请注意，您需要在结果上调用optimize来计算实际的松弛解。

可行性松弛是一种模型，当解决时，它最小化解违反原始模型的边界和线性约束的量。该方法提供了多种指定松弛的选项。

如果您指定relaxobjtype=0，可行性松弛的目标是最小化边界和约束违规的加权幅度之和。lbpen、ubpen和rhspen参数分别指定了下界、上界和线性约束中每单位违规的成本。

如果您指定relaxobjtype=1，可行性松弛的目标是最小化边界和约束违反的加权平方和。lbpen、ubpen和rhspen参数分别指定了下界、上界和线性约束违反的平方系数。

如果您指定relaxobjtype=2，可行性松弛的目标是最小化边界和约束违规的加权计数。lbpen、ubpen和rhspen参数分别指定违反下界、上界和线性约束的成本。

举个例子，如果一个带有rhspen值p的约束被违反了2.0，它将为relaxobjtype=0的可行性松弛目标贡献2*p，为relaxobjtype=1贡献2*2*p，为relaxobjtype=2贡献p。

minrelax 参数是一个布尔值，用于控制创建的可行性松弛类型。如果 minrelax=false，优化返回的模型会得到一个最小化违规成本的解。如果 minrelax=true，优化返回的模型会找到一个最小化原始目标的解，但仅从那些最小化违规成本的解中选择。请注意，当 minrelax=true 时，feasRelax 必须解决一个优化问题以找到最小可能的松弛，这可能会非常耗时。

此方法有两个签名。较复杂的一个接受变量和约束的列表，以及与放松相应的下限、上限和约束相关的惩罚。如果变量或约束未包含在这些列表中，则相关的界限或约束可能不会被违反。较简单的签名接受一对布尔参数，vrelax 和 crelax，它们指示变量界限和/或约束是否可以被违反。如果 vrelax/crelax 是 true，则每个界限/约束分别允许被违反，并且相关的成本为1.0。

有关此例程如何转换模型的示例，以及有关创建的变量和约束的更多详细信息，请参阅本节。

请注意，这是一个破坏性方法：它会修改调用它的模型。如果您不想修改原始模型，请使用GRBModel constructor在调用此方法之前创建一个副本。

创建可行性松弛模型的简化方法。

Arguments:

• relaxobjtype – 用于寻找最小成本松弛的成本函数。

• minrelax – 执行可行性松弛的类型。

• vrelax – 表示是否可以放宽变量边界（对于任何违规行为，成本为1.0）。

• crelax – 表示线性约束是否可以放宽（对于任何违规行为，成本为1.0）。

Return value:

如果minrelax为false，则返回0。如果minrelax为true，返回值是执行的松弛的目标值。如果该值小于0，则表示该方法未能创建可行性松弛。

Example:

// Compute feasibility relaxation for infeasible model
if (model.get(GRB.IntAttr.Status) == GRB.Status.INFEASIBLE) {
   model.feasRelax(1, false, false, true);
   model.optimize();
}

GRBModel fixedModel()

创建与MIP模型关联的固定模型。 MIP模型中必须有一个解决方案（例如通过调用optimize方法获得）或MIP起始点。如果没有可用的解决方案，则使用StartNumber指定的MIP起始点。

在模型中，每个整数变量都被固定为该变量在MIP解或MIP起始值中取的值。此外，连续变量可能会被固定以满足SOS或一般约束。结果是模型不再具有整数约束、SOS约束或一般约束。

注意

虽然固定问题始终是一个连续模型，但它可能包含非凸二次目标或非凸二次约束。因此，它仍然可以使用MIP算法来解决。

注意

在多目标模型中，除了第一个目标外，所有其他目标都被忽略。所有场景（如果有的话）也同样被忽略。

Return value:

修复了与调用对象关联的模型。

Example:

GRBModel fixedModel = model.fixedModel();

void convertToFixed()

将MIP模型转换为连续的模型，就地转换。 必须在MIP模型中提供解决方案（例如通过调用optimize方法获得）或MIP起始点。如果没有可用的解决方案，则使用通过StartNumber指定的MIP起始点。

在模型中，每个整数变量都被固定为该变量在MIP解或MIP起始值中取的值。此外，连续变量可能会被固定以满足SOS或一般约束。结果是模型不再具有整数约束、SOS约束或一般约束。

注意

虽然固定问题始终是一个连续模型，但它可能包含非凸二次目标或非凸二次约束。因此，它仍然可以使用MIP算法来解决。

注意

如果转换后的模型包含多个目标或场景，或者模型包含并发环境或调优环境，则会引发错误。

将当前模型转换为固定模型。

Example:

model.convertToFixed();

double get(GRB.DoubleParam param)

查询一个双精度值参数的值。

Arguments:

param – 正在查询的参数。

Return value:

请求参数的当前值。

Example:

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

int get(GRB.IntParam param)

查询一个整数值参数的值。

Arguments:

param – 正在查询的参数。

Return value:

请求参数的当前值。

Example:

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

String get(GRB.StringParam param)

查询字符串值参数的值。

Arguments:

param – 正在查询的参数。

Return value:

请求参数的当前值。

Example:

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

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

查询一组变量的字符值变量属性。

Arguments:

• attr – 被查询的属性。

• vars – 正在查询其属性值的变量。

Return value:

每个输入变量的请求属性的当前值。

Example:

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

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

查询一个字符型变量属性的子数组变量。

Arguments:

• attr – 被查询的属性。

• vars – 一个一维数组，包含正在查询其属性值的变量。

• start – 列表中第一个感兴趣的变量的索引。

• len – 变量的数量。

Return value:

每个输入变量的请求属性的当前值。

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);

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

查询一个二维变量数组的字符值变量属性。

Arguments:

• attr – 被查询的属性。

• vars – 一个二维变量数组，其属性值正在被查询。

Return value:

每个输入变量的请求属性的当前值。

Example:

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

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

查询一个三维变量数组的字符型变量属性。

Arguments:

• attr – 被查询的属性。

• vars – 一个三维变量数组，其属性值正在被查询。

Return value:

每个输入变量的请求属性的当前值。

Example:

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

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

查询一组约束的字符值约束属性。

Arguments:

• attr – 被查询的属性。

• constrs – 正在查询其属性值的约束。

Return value:

每个输入约束的请求属性的当前值。

Example:

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

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

查询约束子数组的字符值约束属性。

Arguments:

• attr – 被查询的属性。

• constrs – 一个一维的约束数组，其属性值正在被查询。

• start – 列表中感兴趣的第一个约束的索引。

• len – 约束的数量。

Return value:

每个输入约束所请求属性的当前值。

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);

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

查询一个二维约束数组的字符值约束属性。

Arguments:

• attr – 被查询的属性。

• constrs – 一个二维数组的约束条件，其属性值正在被查询。

Return value:

每个输入约束所请求属性的当前值。

Example:

// Get sense attribute values for a 2d array of linear constraints
GRBConstr[][] constrs = new GRBConstr[10][10];
// ...
char[][] sense = model.get(GRB.CharAttr.Sense, constrs);

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

查询一个三维约束数组的字符值约束属性。

Arguments:

• attr – 被查询的属性。

• constrs – 一个三维约束数组，其属性值正在被查询。

Return value:

每个输入约束的请求属性的当前值。

Example:

// Get sense attribute values for a 3d array of linear constraints
GRBConstr[][][] constrs = new GRBConstr[10][10][10];
// ...
char[][][] sense = model.get(GRB.CharAttr.Sense, constrs);

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

查询一组二次约束的字符值二次约束属性。

Arguments:

• attr – 被查询的属性。

• qconstrs – 正在查询其属性值的二次约束。

Return value:

每个输入二次约束的请求属性的当前值。

Example:

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

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

查询一个字符值的二次约束属性，用于二次约束的子数组。

Arguments:

• attr – 被查询的属性。

• qconstrs – 一个一维数组，包含正在查询其属性值的二次约束。

• start – 列表中感兴趣的第一个二次约束的索引。

• len – 二次约束的数量。

Return value:

每个输入二次约束的请求属性的当前值。

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);

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

查询一个二维二次约束数组的字符值二次约束属性。

Arguments:

• attr – 被查询的属性。

• qconstrs – 一个二维数组，包含正在查询其属性值的二次约束。

Return value:

每个输入二次约束的请求属性的当前值。

Example:

// Get sense attribute values for a 2d array of quadratic constraints
GRBQConstr[][] constrs = new GRBConstr[10][10];
// ...
char[][] qsense = model.get(GRB.CharAttr.QCSense, constrs);

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

查询一个字符值的二次约束属性，用于一个三维的二次约束数组。

Arguments:

• attr – 被查询的属性。

• qconstrs – 一个三维数组，表示正在查询其属性值的二次约束。

Return value:

每个输入二次约束的请求属性的当前值。

Example:

// Get sense attribute values for a 3d array of quadratic constraints
GRBQConstr[][][] constrs = new GRBConstr[10][10][10];
// ...
char[][][] qsense = model.get(GRB.CharAttr.QCSense, constrs);

double get(GRB.DoubleAttr attr)

查询双精度模型属性的值。

Arguments:

attr – 被查询的属性。

Return value:

请求属性的当前值。

Example:

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

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

查询一组变量的双精度值变量属性。

Arguments:

• attr – 被查询的属性。

• vars – 正在查询其属性值的变量。

Return value:

每个输入变量的请求属性的当前值。

Example:

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

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

查询变量子数组的双精度值变量属性。

Arguments:

• attr – 被查询的属性。

• vars – 一个一维数组，包含正在查询其属性值的变量。

• start – 列表中第一个感兴趣的变量的索引。

• len – 变量的数量。

Return value:

每个输入变量的请求属性的当前值。

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);

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

查询一个二维数组变量的双值变量属性。

Arguments:

• attr – 被查询的属性。

• vars – 一个二维变量数组，其属性值正在被查询。

Return value:

每个输入变量的请求属性的当前值。

Example:

// Get lower bound attribute values for a 2d array of variables
GRBVar[][] vars = new GRBVar[10][10];
// ...
double[][] lb = model.get(GRB.DoubleAttr.LB, vars);

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

查询一个三维变量数组的双值变量属性。

Arguments:

• attr – 被查询的属性。

• vars – 一个三维变量数组，其属性值正在被查询。

Return value:

每个输入变量的请求属性的当前值。

Example:

// Get lower bound attribute values for a 3d array of variables
GRBVar[][][] vars = new GRBVar[10][10][10];
// ...
double[][][] lb = model.get(GRB.DoubleAttr.LB, vars);

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

查询一组约束的双值约束属性。

Arguments:

• attr – 被查询的属性。

• constrs – 正在查询其属性值的约束。

Return value:

每个输入约束的请求属性的当前值。

Example:

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

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

查询约束子数组的双值约束属性。

Arguments:

• attr – 被查询的属性。

• constrs – 一个一维的约束数组，其属性值正在被查询。

• start – 列表中感兴趣的第一个约束。

• len – 约束的数量。

Return value:

每个输入约束的请求属性的当前值。

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);

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

查询一个二维约束数组的双值约束属性。

Arguments:

• attr – 被查询的属性。

• constrs – 一个二维数组的约束条件，其属性值正在被查询。

Return value:

每个输入约束的请求属性的当前值。

Example:

// Get RHS attribute values for a 2d array of constraints
GRBConstr[][] constrs = new GRBConstr[10][10];
// ...
double[][] rhs = model.get(GRB.DoubleAttr.RHS, constrs);

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

查询一个三维约束数组的双值约束属性。

Arguments:

• attr – 被查询的属性。

• constrs – 一个三维约束数组，其属性值正在被查询。

Return value:

每个输入约束的请求属性的当前值。

Example:

// Get RHS attribute values for a 3d array of constraints
GRBConstr[][][] constrs = new GRBConstr[10][10][10];
// ...
double[][][] rhs = model.get(GRB.DoubleAttr.RHS, constrs);

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

查询一组二次约束的双值二次约束属性。

Arguments:

• attr – 被查询的属性。

• qconstrs – 正在查询其属性值的二次约束。

Return value:

每个输入二次约束的请求属性的当前值。

Example:

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

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

查询二次约束子数组的双值二次约束属性。

Arguments:

• attr – 被查询的属性。

• qconstrs – 一个一维数组，包含正在查询其属性值的二次约束。

• start – 列表中感兴趣的第一个二次约束。

• len – 二次约束的数量。

Return value:

每个输入二次约束的请求属性的当前值。

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);

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

查询一个二维二次约束数组的双值二次约束属性。

Arguments:

• attr – 被查询的属性。

• qconstrs – 一个二维数组，包含正在查询其属性值的二次约束。

Return value:

每个输入二次约束的请求属性的当前值。

Example:

// Get RHS attribute values for a 2d array of quadratic constraints
GRBQConstr[][] constrs = new GRBQConstr[10][10];
// ...
double[][] qrhs = model.get(GRB.DoubleAttr.QCRHS, constrs);

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

查询一个三维二次约束数组的双值二次约束属性。

Arguments:

• attr – 被查询的属性。

• qconstrs – 一个三维数组，包含正在查询其属性值的二次约束。

Return value:

每个输入二次约束的请求属性的当前值。

Example:

// Get RHS attribute values for a 3d array of quadratic constraints
GRBQConstr[][][] constrs = new GRBQConstr[10][10][10];
// ...
double[][][] qrhs = model.get(GRB.DoubleAttr.QCRHS, constrs);

int get(GRB.IntAttr attr)

查询一个整数值模型属性的值。

Arguments:

attr – 被查询的属性。

Return value:

请求属性的当前值。

Example:

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

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

查询一组变量的整数值变量属性。

Arguments:

• attr – 被查询的属性。

• vars – 正在查询其属性值的变量。

Return value:

每个输入变量的请求属性的当前值。

Example:

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

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

查询一个子数组变量的整数值属性。

Arguments:

• attr – 被查询的属性。

• vars – 一个一维数组，包含正在查询其属性值的变量。

• start – 列表中第一个感兴趣的变量的索引。

• len – 变量的数量。

Return value:

每个输入变量的请求属性的当前值。

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);

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

查询一个二维变量数组的整数值变量属性。

Arguments:

• attr – 被查询的属性。

• vars – 一个二维变量数组，其属性值正在被查询。

Return value:

每个输入变量的请求属性的当前值。

Example:

// Get VBasis attribute values for a 2d array of variables
GRBVar[][] vars = new GRBVar[10][10];
// ...
int[][] vbasis = model.get(GRB.IntAttr.VBasis, vars);

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

查询一个三维变量数组的整数值变量属性。

Arguments:

• attr – 被查询的属性。

• vars – 一个三维变量数组，其属性值正在被查询。

Return value:

每个输入变量的请求属性的当前值。

Example:

// Get VBasis attribute values for a 3d array of variables
GRBVar[][][] vars = new GRBVar[10][10][10];
// ...
int[][][] vbasis = model.get(GRB.IntAttr.VBasis, vars);

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

查询一组约束的整数值约束属性。

Arguments:

• attr – 被查询的属性。

• constrs – 正在查询其属性值的约束。

Return value:

每个输入约束的请求属性的当前值。

Example:

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

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

查询约束子数组的整数值约束属性。

Arguments:

• attr – 被查询的属性。

• constrs – 一个一维的约束数组，其属性值正在被查询。

• start – 列表中感兴趣的第一个约束的索引。

• len – 约束的数量。

Return value:

每个输入约束的请求属性的当前值。

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);

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

查询一个二维约束数组的整数值约束属性。

Arguments:

• attr – 被查询的属性。

• constrs – 一个二维数组的约束条件，其属性值正在被查询。

Return value:

每个输入约束的请求属性的当前值。

Example:

// Get CBasis attribute values for a 2d array of constraints
GRBConstr[][] constrs = new GRBConstr[10][10];
// ...
int[][] cbasis = model.get(GRB.IntAttr.CBasis, constrs);

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

查询一个三维约束数组的整数值约束属性。

Arguments:

• attr – 被查询的属性。

• constrs – 一个三维约束数组，其属性值正在被查询。

Return value:

每个输入约束的请求属性的当前值。

Example:

// Get CBasis attribute values for a 3d array of constraints
GRBConstr[][][] constrs = new GRBConstr[10][10][10];
// ...
int[][][] cbasis = model.get(GRB.IntAttr.CBasis, constrs);

int[] get(GRB.IntAttr attr, GRBQConstr[] qconstrs)

查询一组二次约束的整数值二次约束属性。

Arguments:

• attr – 被查询的属性。

• qconstrs – 正在查询其属性值的二次约束。

Return value:

每个输入二次约束的请求属性的当前值。

Example:

// Get IISQConstr attribute values of all quadratic constraints
GRBQConstr[] qconstrs = model.getQConstrs();
int[] iisconstrs = model.get(GRB.IntAttr.IISQConstr, qconstrs);

int[] get(GRB.IntAttr attr, GRBQConstr[] qconstrs, int start, int len)

查询二次约束子数组的整数值二次约束属性。

Arguments:

• attr – 被查询的属性。

• qconstrs – 一个一维数组，包含正在查询其属性值的二次约束。

• start – 列表中感兴趣的第一个二次约束的索引。

• len – 二次约束的数量。

Return value:

每个输入二次约束的请求属性的当前值。

Example:

// Get IISQConstr attribute values for quadratic constraints indexed from 0 to 2
GRBQConstr[] qconstrs = model.getQConstrs();
int[] iisconstrs = model.get(GRB.IntAttr.IISQConstr, qconstrs, 0, 3);

int[][] get(GRB.IntAttr attr, GRBQConstr[][] qconstrs)

查询一个二维二次约束数组的整数值二次约束属性。

Arguments:

• attr – 被查询的属性。

• qconstrs – 一个二维数组，包含正在查询其属性值的二次约束。

Return value:

每个输入二次约束的请求属性的当前值。

Example:

// Get IISQConstr attribute values for a 2d array of quadratic constraints
GRBQConstr[][] qconstrs = new GRBQConstr[10][10];
// ...
int[][] iisconstr = model.get(GRB.IntAttr.IISQConstr, qconstrs);

int[][][] get(GRB.IntAttr attr, GRBQConstr[][][] qconstrs)

查询一个整数值的二次约束属性，用于一个三维数组的二次约束。

Arguments:

• attr – 被查询的属性。

• qconstrs – 一个三维数组，包含正在查询其属性值的二次约束。

Return value:

每个输入二次约束的请求属性的当前值。

Example:

// Get IISQConstr attribute values for a 3d array of quadratic constraints
GRBQConstr[][][] qconstrs = new GRBQConstr[10][10][10];
// ...
int[][][] iisconstrs = model.get(GRB.IntAttr.IISQConstr, qconstrs);

int[] get(GRB.IntAttr attr, GRBGenConstr[] genconstrs)

查询一组通用约束的整数值通用约束属性。

Arguments:

• attr – 被查询的属性。

• genconstrs – 正在查询其属性值的一般约束。

Return value:

每个输入通用约束的请求属性的当前值。

Example:

// Get GenConstrType attribute values for all general constraints
GRBGenConstr[] genconstrs = model.getGenConstrs();
// ...
int[] types = model.get(GRB.IntAttr.GenConstrType, genconstrs);

int[] get(GRB.IntAttr attr, GRBGenConstr[] genconstrs, int start, int len)

查询一个整数值的通用约束属性，用于通用约束的子数组。

Arguments:

• attr – 被查询的属性。

• genconstrs – 一个一维数组，包含正在查询其属性值的一般约束。

• start – 列表中感兴趣的第一个一般约束的索引。

• len – 一般约束的数量。

Return value:

每个输入通用约束的请求属性的当前值。

Example:

// Get GenConstrType attribute values for general constraints indexed from 0 to 2
GRBGenConstr[] genconstrs = model.getGenConstrs();
// ...
int[] types = model.get(GRB.IntAttr.GenConstrType, genconstrs, 0, 3);

int[][] get(GRB.IntAttr attr, GRBGenConstr[][] genconstrs)

查询一个二维通用约束数组的整数值通用约束属性。

Arguments:

• attr – 被查询的属性。

• genconstrs – 一个二维数组，包含正在查询其属性值的一般约束。

Return value:

每个输入通用约束的请求属性的当前值。

Example:

// Get GenConstrType attribute values a 2d array of general constraints
GRBGenConstr[][] genconstrs = new GRBGenConstr[10][10];
// ...
int[][] types = model.get(GRB.IntAttr.GenConstrType, genconstrs);

int[][][] get(GRB.IntAttr attr, GRBGenConstr[][][] genconstrs)

查询一个三维通用约束数组的整数值通用约束属性。

Arguments:

• attr – 被查询的属性。

• genconstrs – 一个三维数组，包含正在查询其属性值的一般约束。

Return value:

每个输入通用约束的请求属性的当前值。

Example:

// Get GenConstrType attribute values a 3d array of general constraints
GRBGenConstr[][][] genconstrs = new GRBGenConstr[10][10][10];
// ...
int[][][] types = model.get(GRB.IntAttr.GenConstrType, genconstrs);

String get(GRB.StringAttr attr)

查询字符串值模型属性的值。

Arguments:

attr – 被查询的属性。

Return value:

请求属性的当前值。

Example:

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

String[] get(GRB.StringAttr attr, GRBVar[] vars)

查询一个字符串值变量属性的变量数组。

Arguments:

• attr – 被查询的属性。

• vars – 正在查询其属性值的变量。

Return value:

每个输入变量的请求属性的当前值。

Example:

// Get variable name attribute values of all variables
GRBVar[] vars = model.getVars();
String[] varnames = model.get(GRB.StringAttr.VarName, vars);

String[] get(GRB.StringAttr attr, GRBVar[] vars, int start, int len)

查询一个字符串值变量属性的子数组变量。

Arguments:

• attr – 被查询的属性。

• vars – 一个一维数组，包含正在查询其属性值的变量。

• start – 列表中第一个感兴趣的变量的索引。

• len – 变量的数量。

Return value:

每个输入变量的请求属性的当前值。

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);

String[][] get(GRB.StringAttr attr, GRBVar[][] vars)

查询一个二维数组变量的字符串值属性。

Arguments:

• attr – 被查询的属性。

• vars – 一个二维变量数组，其属性值正在被查询。

Return value:

每个输入变量的请求属性的当前值。

Example:

// Get variable name attribute values
GRBVar[][] vars = new GRBVar[10][10];
// ...
String[][] varnames = model.get(GRB.StringAttr.VarName, vars);

String[][][] get(GRB.StringAttr attr, GRBVar[][][] vars)

查询一个三维变量数组的字符串值变量属性。

Arguments:

• attr – 被查询的属性。

• vars – 一个三维变量数组，其属性值正在被查询。

Return value:

每个输入变量的请求属性的当前值。

Example:

// Get variable name attribute values
GRBVar[][][] vars = new GRBVar[10][10][10];
// ...
String[][][] varnames = model.get(GRB.StringAttr.VarName, vars);

String[] get(GRB.StringAttr attr, GRBConstr[] constrs)

查询一组约束的字符串值约束属性。

Arguments:

• attr – 被查询的属性。

• constrs – 正在查询其属性值的约束。

Return value:

每个输入约束的请求属性的当前值。

Example:

// Get constraint name attribute values of all linear constraints
GRBConstr[] constrs = model.getConstrs();
String[] constrnames = model.get(GRB.StringAttr.ConstrName, constrs);

String[] get(GRB.StringAttr attr, GRBConstr[] constrs, int start, int len)

查询约束子数组的字符串值约束属性。

Arguments:

• attr – 被查询的属性。

• constrs – 一个一维的约束数组，其属性值正在被查询。

• start – 列表中感兴趣的第一个约束的索引。

• len – 约束的数量。

Return value:

每个输入约束的请求属性的当前值。

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);

String[][] get(GRB.StringAttr attr, GRBConstr[][] constrs)

查询一个二维约束数组的字符串值约束属性。

Arguments:

• attr – 被查询的属性。

• constrs – 一个二维数组的约束条件，其属性值正在被查询。

Return value:

每个输入约束的请求属性的当前值。

Example:

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

String[][][] get(GRB.StringAttr attr, GRBConstr[][][] constrs)

查询一个三维约束数组的字符串值约束属性。

Arguments:

• attr – 被查询的属性。

• constrs – 一个三维约束数组，其属性值正在被查询。

Return value:

每个输入约束的请求属性的当前值。

Example:

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

String[] get(GRB.StringAttr attr, GRBQConstr[] qconstrs)

查询一组二次约束的字符串值二次约束属性。

Arguments:

• attr – 被查询的属性。

• qconstrs – 正在查询其属性值的二次约束。

Return value:

每个输入二次约束的请求属性的当前值。

Example:

// Get constraint name values of all quadratic constraints
GRBQConstr[] qconstrs = model.getQConstrs();
String[] qconstrnames = model.get(GRB.StringAttr.QCName, qconstrs);

String[] get(GRB.StringAttr attr, GRBQConstr[] qconstrs, int start, int len)

查询一个字符串值的二次约束属性，用于二次约束的子数组。

Arguments:

• attr – 被查询的属性。

• qconstrs – 一个一维数组，包含正在查询其属性值的二次约束。

• start – 列表中感兴趣的第一个二次约束的索引。

• len – 二次约束的数量。

Return value:

每个输入二次约束的请求属性的当前值。

Example:

// Get constraint name values for quadratic constraints indexed from 0 to 2
GRBQConstr[] qconstrs = model.getQConstrs();
String[] qconstrnames = model.get(GRB.StringAttr.QCName, qconstrs, 0, 3);

String[][] get(GRB.StringAttr attr, GRBQConstr[][] qconstrs)

查询一个二维二次约束数组的字符串值二次约束属性。

Arguments:

• attr – 被查询的属性。

• qconstrs – 一个二维数组，包含正在查询其属性值的二次约束。

Return value:

每个输入二次约束的请求属性的当前值。

Example:

// Get constraint name values for a 2d array of quadratic constraints
GRBQConstr[][] qconstrs = new GRBQConstr[10][10];
// ...
String[][] qconstrnames = model.get(GRB.StringAttr.QCName, qconstrs);

String[][][] get(GRB.StringAttr attr, GRBQConstr[][][] qconstrs)

查询一个三维二次约束数组的字符串值二次约束属性。

Arguments:

• attr – 被查询的属性。

• qconstrs – 一个三维数组，包含正在查询其属性值的二次约束。

Return value:

每个输入二次约束的请求属性的当前值。

Example:

// Get constraint name values for a 3d array of quadratic constraints
GRBQConstr[][][] qconstrs = new GRBQConstr[10][10][10];
// ...
String[][][] qconstrnames = model.get(GRB.StringAttr.QCName, qconstrs);

String[] get(GRB.StringAttr attr, GRBGenConstr[] genconstrs)

查询一个字符串值的一般约束属性，用于一组一般约束。

Arguments:

• attr – 被查询的属性。

• genconstrs – 正在查询其属性值的一般约束。

Return value:

每个输入通用约束的请求属性的当前值。

Example:

// Get general constraint name attribute values
GRBGenConstr[] genconstrs = model.getGenConstrs();
String[] genconstrnames = model.get(GRB.StringAttr.GenConstrName, genconstrs);

String[] get(GRB.StringAttr attr, GRBGenConstr[] genconstrs, int start, int len)

查询一个字符串值的一般约束属性，用于一般约束的子数组。

Arguments:

• attr – 被查询的属性。

• genconstrs – 一个一维数组，包含正在查询其属性值的一般约束。

• start – 列表中感兴趣的第一个一般约束的索引。

• len – 一般约束的数量。

Return value:

每个输入通用约束的请求属性的当前值。

Example:

// Get general constraint name attribute values for constraints indexed from 0 to 2
GRBGenConstr[] genconstrs = model.getGenConstrs();
String[] genconstrnames = model.get(GRB.StringAttr.GenConstrName, genconstrs, 0, 3);

String[][] get(GRB.StringAttr attr, GRBGenConstr[][] genconstrs)

查询一个二维通用约束数组的字符串值约束属性。

Arguments:

• attr – 被查询的属性。

• genconstrs – 一个二维数组，包含正在查询其属性值的一般约束。

Return value:

每个输入通用约束的请求属性的当前值。

Example:

// Get general constraint name attribute values for a 2d array of general constraints
GRBGenConstr[][] genconstrs = new GRBGenConstr[10][10];
// ...
String[][] genconstrnames = model.get(GRB.StringAttr.GenConstrName, genconstrs);

String[][][] get(GRB.StringAttr attr, GRBGenConstr[][][] genconstrs)

查询一个三维通用约束数组的字符串值约束属性。

Arguments:

• attr – 被查询的属性。

• genconstrs – 一个三维数组，包含正在查询其属性值的一般约束。

Return value:

每个输入通用约束的请求属性的当前值。

Example:

// Get general constraint name attribute values for a 3d array of general constraints
GRBGenConstr[][][] genconstrs = new GRBGenConstr[10][10][10];
// ...
String[][][] genconstrnames = model.get(GRB.StringAttr.GenConstrName, genconstrs);

double getCoeff(GRBConstr constr, GRBVar var)

查询线性约束constr中变量var的系数（注意结果可能为零）。

Arguments:

• constr – 请求的约束条件。

• var – 请求的变量。

Return value:

请求系数的当前值。

Example:

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

GRBColumn getCol(GRBVar var)

检索变量参与的约束列表及其相关系数。结果以GRBColumn对象的形式返回。

Arguments:

var – 感兴趣的变量。

Return value:

一个GRBColumn对象，用于捕获变量参与的约束集。

Example:

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

GRBEnv getConcurrentEnv(int num)

为模型创建/检索并发环境。

此方法提供了对并发优化器的细粒度控制。 通过创建您自己的并发环境并在这些环境上设置适当的参数（例如，方法参数），您可以精确控制并发优化器采用的策略。例如，如果您创建两个并发环境，并将方法设置为一个使用原始单纯形法，另一个使用对偶单纯形法，后续的并发优化器运行将使用这两种单纯形算法，而不是默认选择。

请注意，您必须创建连续编号的并发环境，从num=0开始。例如，如果您想要三个并发环境，它们必须编号为0、1和2。

一旦你创建了并发环境，它们将用于该模型上的所有后续并发优化。使用discardConcurrentEnvs来恢复到默认的并发优化器行为。

Arguments:

num – 并发环境数量。

Return value:

模型的并发环境。

Example:

GRBEnv env0 = model.getConcurrentEnv(0);
GRBEnv env1 = model.getConcurrentEnv(1);

env0.set(GRB.IntParam.Method, 0); // primal simplex
env1.set(GRB.IntParam.Method, 1); // dual simplex

model.optimize();
model.discardConcurrentEnvs();

GRBConstr getConstrByName(String name)

根据名称检索线性约束。如果多个线性约束具有相同的名称，则此方法会任意选择一个。如果没有约束具有该名称，则返回null。

Arguments:

name – 所需线性约束的名称。

Return value:

请求的线性约束。

Example:

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

GRBConstr[] getConstrs()

检索模型中的所有线性约束的数组。

Return value:

模型中的所有线性约束。

Example:

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

void getGenConstrMax(GRBGenConstr genc, GRBVar[] resvar, GRBVar[] vars, int[] len, double[] constant)

检索与类型为MAX的一般约束相关的数据。 对不同类型的通用约束调用此方法会导致异常。您可以查询 GenConstrType属性来确定通用约束的类型。

典型用法是调用此例程两次。在第一次调用中，您指定请求的一般约束，并将vars参数的值设置为null。例程在len中返回指定一般约束中的操作数变量的总数。这使您可以确保vars数组的大小足以容纳第二次调用的结果。

另请参阅addGenConstrMax以了解此通用约束类型的语义描述。

以下任何参数都可以是null。

Arguments:

• genc – 通用约束对象。

• resvar – 在resvar[0]处存储约束的结果变量。

• vars – 用于存储约束的操作数变量的数组。

• len – 在len[0]处存储约束的操作数变量的数量。

• constant – 将约束的额外常数操作数存储在 constant[0] 中。

Example:

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

if (type == GRB.GENCONSTR_MAX) {
  model.getGenConstrMax(genc, resvar, null, len, null);
  // Initialize correct array size
  vars = new GRBVar[len[0]];
  model.getGenConstrMax(genc, resvar, vars, len, constant);
}

void getGenConstrMin(GRBGenConstr genc, GRBVar[] resvar, GRBVar[] vars, int[] len, double[] constant)

检索与MIN类型的通用约束相关联的数据。 对不同类型的通用约束调用此方法会导致异常。您可以查询 GenConstrType属性以确定通用约束的类型。

典型用法是调用此例程两次。在第一次调用中，您指定请求的一般约束，并将vars参数的值设置为null。例程返回指定一般约束中操作数变量的总数，存储在len中。这使您可以确保vars数组的大小足以容纳第二次调用的结果。

另请参阅addGenConstrMin以了解此通用约束类型的语义描述。

以下任何参数都可以是null。

Arguments:

• genc – 通用约束对象。

• resvar – 在resvar[0]处存储约束的结果变量。

• vars – 用于存储约束的操作数变量的数组。

• len – 在len[0]处存储约束的操作数变量的数量。

• constant – 将约束的额外常量操作数存储在 constant[0] 中。

Example:

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

if (type == GRB.GENCONSTR_MIN) {
  model.getGenConstrMin(genc, resvar, null, len, null);
  // Initialize correct array size
  vars = new GRBVar[len[0]];
  model.getGenConstrMin(genc, resvar, vars, len, constant);
}

void getGenConstrAbs(GRBGenConstr genc, GRBVar[] resvar, GRBVar[] argvar)

检索与类型为ABS的一般约束相关的数据。 对不同类型的通用约束调用此方法会导致异常。您可以查询 GenConstrType属性以确定通用约束的类型。

另请参阅addGenConstrAbs以了解此通用约束类型的语义描述。

以下任何参数都可以是null。

Arguments:

• genc – 通用约束对象。

• resvar – 在resvar[0]处存储约束的结果变量。

• argvar – 将约束的参数变量存储在 argvar[0]。

Example:

GRBVar[] resvar = new GRBVar[1];
GRBVar[] argvar = new GRBVar[1];
// Retrieve general constraint type
int type = genc.get(GRB.IntAttr.GenConstrType);

if (type == GRB.GENCONSTR_ABS) {
  model.getGenConstrAbs(genc, resvar, argvar);
}

void getGenConstrAnd(GRBGenConstr genc, GRBVar[] resvar, GRBVar[] vars, int[] len)

检索与类型为AND的通用约束相关联的数据。 为不同类型的通用约束调用此方法会导致异常。您可以查询 GenConstrType属性以确定通用约束的类型。

典型用法是调用此例程两次。在第一次调用中，您指定请求的一般约束，并将vars参数的值设置为null。例程在len中返回指定一般约束中的操作数变量的总数。这使您可以确保vars数组的大小足以容纳第二次调用的结果。

另请参阅addGenConstrAnd以了解此通用约束类型的语义描述。

以下任何参数都可以是null。

Arguments:

• genc – 通用约束对象。

• resvar – 在resvar[0]处存储约束的结果变量。

• vars – 用于存储约束的操作数变量的数组。

• len – 在len[0]处存储约束的操作数变量的数量。

Example:

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

if (type == GRB.GENCONSTR_AND) {
  model.getGenConstrAnd(genc, resvar, null, len);
  // Initialize correct array size
  vars = new GRBVar[len[0]];
  model.getGenConstrAnd(genc, resvar, vars, len);
}

void getGenConstrOr(GRBGenConstr genc, GRBVar[] resvar, GRBVar[] vars, int[] len)

检索与OR类型的一般约束相关联的数据。 对不同类型的通用约束调用此方法会导致异常。您可以查询 GenConstrType属性以确定通用约束的类型。

典型用法是调用此例程两次。在第一次调用中，您指定请求的一般约束，并将vars参数的值设置为null。例程返回指定一般约束中操作数变量的总数，存储在len中。这使您可以确保vars数组的大小足以容纳第二次调用的结果。

另请参阅addGenConstrOr以了解此通用约束类型的语义描述。

以下任何参数都可以是null。

Arguments:

• genc – 通用约束对象。

• resvar – 在resvar[0]处存储约束的结果变量。

• vars – 用于存储约束的操作数变量的数组。

• len – 在len[0]处存储约束的操作数变量的数量。

Example:

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

if (type == GRB.GENCONSTR_OR) {
  model.getGenConstrOr(genc, resvar, null, len);
  // Initialize correct array size
  vars = new GRBVar[len[0]];
  model.getGenConstrOr(genc, resvar, vars, len);
}

void getGenConstrNorm(GRBGenConstr genc, GRBVar[] resvar, GRBVar[] vars, int[] len, double[] which)

检索与类型为NORM的一般约束相关联的数据。 对不同类型的通用约束调用此方法会导致异常。您可以查询 GenConstrType属性来确定通用约束的类型。

典型用法是调用此例程两次。在第一次调用中，您指定请求的一般约束，并将vars参数的值设置为null。例程返回指定一般约束中操作数变量的总数，存储在len中。这使您可以确保vars数组的大小足以容纳第二次调用的结果。

另请参阅addGenConstrNorm以了解此通用约束类型的语义描述。

以下任何参数都可以是null。

Arguments:

• genc – 通用约束对象。

• resvar – 在resvar[0]处存储约束的结果变量。

• vars – 用于存储约束的操作数变量的数组。

• len – 在len[0]处存储约束的操作数变量的数量。

• which – 存储范数类型（可能的值为0、1、2或GRB.INFINITY）。

Example:

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

if (type == GRB.GENCONSTR_NORM) {
  model.getGenConstrNorm(genc, resvar, null, len, null);
  // Initialize correct array size
  vars = new GRBVar[len[0]];
  model.getGenConstrNorm(genc, resvar, vars, len, which);
}

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

检索与类型为NL的一般约束相关的数据。 对不同类型的通用约束调用此方法会导致异常。您可以查询 GenConstrType属性以确定通用约束的类型。

典型用法是调用此例程两次。在第一次调用中，您指定请求的一般约束，opcode、data和parent参数的值为null。例程返回在nnodes中形成指定一般约束的表达式树的总节点数。这使您可以确保opcode、data和parent数组的大小足以容纳第二次调用的结果。

另请参阅addGenConstrNL以了解此通用约束类型的语义描述。

以下任何参数都可以是null。

Arguments:

• genc – 通用约束对象。

• resvar – 存储约束的结果变量在 resvar[0]。

• nnodes – 存储在nnodes[0]处描述非线性表达式所需的节点数。

• opcode – 存储包含节点操作码的数组。

• data – 存储包含每个节点辅助数据的数组。

• parent – 存储提供每个节点的父索引的数组。

Example:

GRBVar   resvar = new GRBVar[1];
int      nnodes = new int[1];
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, resvar, nnodes, null, null, null);
  // Initialize correct array sizes
  opcode = new int[nnodes[0]];
  data   = new double[nnodes[0]];
  parent = new int[nnodes[0]];
  // Get array data
  model.getGenConstrNL(genc, resvar, nnodes, opcode, data, parent);
}

void getGenConstrIndicator(GRBGenConstr genc, GRBVar[] binvar, int[] binval, GRBLinExpr[] expr, char[] sense, double[] rhs)

检索与类型为INDICATOR的通用约束相关联的数据。 对不同类型的通用约束调用此方法会导致异常。您可以查询 GenConstrType属性以确定通用约束的类型。

另请参阅 addGenConstrIndicator 以了解此通用约束类型的语义描述。

以下任何参数都可以是null。

Arguments:

• genc – 通用约束对象。

• binvar – 将约束的二进制指示变量存储在 binvar[0] 中。

• binval – 存储指示变量必须取的值，以便在binval[0]处触发线性约束。

• expr – 创建一个GRBLinExpr对象，用于存储由指示器在expr[0]处触发的线性约束的左侧表达式。

• sense – 将线性约束的sense存储在sense[0]中。 选项为GRB.LESS_EQUAL、GRB.EQUAL或GRB.GREATER_EQUAL。

• rhs – 在线性约束的右侧值存储在 rhs[0] 中。

Example:

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

if (type == GRB.GENCONSTR_INDICATOR) {
  model.getGenConstrIndicator(genc, binvar, binval, expr, sense, rhs);
}

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

检索与PWL类型的一般约束相关的数据。 对不同类型的通用约束调用此方法会导致异常。您可以查询 GenConstrType属性以确定通用约束的类型。

典型用法是调用此例程两次。在第一次调用中，您指定请求的一般约束，xpts 和 ypts 参数的值为 null。例程返回 xpts 和 ypts 数组的长度，存储在 npts 中。这使您能够确保 xpts 和 ypts 数组的大小足以容纳第二次调用的结果。

另请参阅addGenConstrPWL以了解此通用约束类型的语义描述。

以下任何参数都可以是null。

Arguments:

• genc – 通用约束对象。

• xvar – 存储 \(x\) 变量。

• yvar – 存储 \(y\) 变量。

• npts – 存储定义分段线性函数的点数。

• xpts – 定义分段线性函数的点的 \(x\) 值。

• ypts – 定义分段线性函数的点的 \(y\) 值。

Example:

GRBVar[] xvar = new GRBVar[1];
GRBVar[] yvar = new GRBVar[1];
int[]    npts = new int[1];
double[] xpts, ypts;

// Retrieve general constraint type
int type = genc.get(GRB.IntAttr.GenConstrType);

if (type == GRB.GENCONSTR_PWL) {
  model.getGenConstrPWL(genc, xvar, yvar, npts, null, null);
  // Initialize correct array sizes
  xpts = new double[npts[0]];
  ypts = new double[npts[0]];
  model.getGenConstrPWL(genc, xvar, yvar, npts, xpts, ypts);
}

void getGenConstrPoly(GRBGenConstr genc, GRBVar[] xvar, GRBVar[] yvar, int[] plen, double[] p)

检索与类型为POLY的一般约束相关联的数据。 对不同类型的通用约束调用此方法会导致异常。您可以查询 GenConstrType属性以确定通用约束的类型。

典型用法是调用此例程两次。在第一次调用中，您指定请求的一般约束，p参数的值设为null。例程返回p数组的长度在plen中。这使您能够确保p数组的大小足以容纳第二次调用的结果。

另请参阅addGenConstrPoly以了解此通用约束类型的语义描述。

以下任何参数都可以是null。

Arguments:

• genc – 通用约束对象。

• xvar – 存储 \(x\) 变量。

• yvar – 存储 \(y\) 变量。

• plen – 存储数组 p 的长度。如果 \(x^d\) 是最高次项，则返回 \(d+1\)。

• p – 多项式函数的系数。

Example:

GRBVar[] xvar = new GRBVar[1];
GRBVar[] yvar = new GRBVar[1];
int[]    plen = new int[1];
double[] p;

// Retrieve general constraint type
int type = genc.get(GRB.IntAttr.GenConstrType);

if (type == GRB.GENCONSTR_POLY) {
  model.getGenConstrPoly(genc, xvar, yvar, plen, null);
  // Initialize correct array sizes
  p = new double[plen[0]];
  model.getGenConstrPoly(genc, xvar, yvar, plen, p);
}

void getGenConstrExp(GRBGenConstr genc, GRBVar[] xvar, GRBVar[] yvar)

检索与类型为EXP的一般约束相关联的数据。 对不同类型的通用约束调用此方法会导致异常。您可以查询 GenConstrType属性来确定通用约束的类型。

另请参阅addGenConstrExp以了解此通用约束类型的语义描述。

以下任何参数都可以是null。

Arguments:

• genc – 通用约束对象。

• xvar – 存储 \(x\) 变量。

• yvar – 存储 \(y\) 变量。

Example:

GRBVar[] xvar = new GRBVar[1];
GRBVar[] yvar = new GRBVar[1];

// Retrieve general constraint type
int type = genc.get(GRB.IntAttr.GenConstrType);

if (type == GRB.GENCONSTR_EXP) {
  model.getGenConstrExp(genc, xvar, yvar);
}

void getGenConstrExpA(GRBGenConstr genc, GRBVar[] xvar, GRBVar[] yvar, double[] a)

检索与类型为EXPA的通用约束相关联的数据。 对不同类型的通用约束调用此方法会导致异常。您可以查询 GenConstrType属性来确定通用约束的类型。

另请参阅addGenConstrExpA以了解此通用约束类型的语义描述。

以下任何参数都可以是null。

Arguments:

• genc – 通用约束对象。

• xvar – 存储 \(x\) 变量。

• yvar – 存储 \(y\) 变量。

• a – 存储函数的基数。

Example:

GRBVar[] xvar = new GRBVar[1];
GRBVar[] yvar = new GRBVar[1];
double[] a    = new double[1];

// Retrieve general constraint type
int type = genc.get(GRB.IntAttr.GenConstrType);

if (type == GRB.GENCONSTR_EXPA) {
  model.getGenConstrExpA(genc, xvar, yvar, a);
}

void getGenConstrLog(GRBGenConstr genc, GRBVar[] xvar, GRBVar[] yvar)

检索与类型为LOG的一般约束相关的数据。 对不同类型的通用约束调用此方法会导致异常。您可以查询 GenConstrType属性来确定通用约束的类型。

另请参阅addGenConstrLog以了解此通用约束类型的语义描述。

以下任何参数都可以是null。

Arguments:

• genc – 通用约束对象。

• xvar – 存储 \(x\) 变量。

• yvar – 存储 \(y\) 变量。

Example:

GRBVar[] xvar = new GRBVar[1];
GRBVar[] yvar = new GRBVar[1];

// Retrieve general constraint type
int type = genc.get(GRB.IntAttr.GenConstrType);

if (type == GRB.GENCONSTR_LOG) {
  model.getGenConstrLog(genc, xvar, yvar);
}

void getGenConstrLogA(GRBGenConstr genc, GRBVar[] xvar, GRBVar[] yvar, double[] a)

检索与类型为LOGA的一般约束相关的数据。 对不同类型的通用约束调用此方法会导致异常。您可以查询 GenConstrType属性来确定通用约束的类型。

另请参阅addGenConstrLogA以了解此通用约束类型的语义描述。

以下任何参数都可以是null。

Arguments:

• genc – 通用约束对象。

• xvar – 存储 \(x\) 变量。

• yvar – 存储 \(y\) 变量。

• a – 存储函数的基数。

Example:

GRBVar[] xvar = new GRBVar[1];
GRBVar[] yvar = new GRBVar[1];
double[] a    = new double[1];

// Retrieve general constraint type
int type = genc.get(GRB.IntAttr.GenConstrType);

if (type == GRB.GENCONSTR_LOGA) {
  model.getGenConstrLogA(genc, xvar, yvar, a);
}

void getGenConstrLogistic(GRBGenConstr genc, GRBVar[] xvar, GRBVar[] yvar)

检索与类型为LOGISTIC的通用约束相关联的数据。 对不同类型的通用约束调用此方法会导致异常。您可以查询 GenConstrType属性以确定通用约束的类型。

另请参阅 addGenConstrLogistic 了解 此通用约束类型的语义描述。

以下任何参数都可以是null。

Arguments:

• genc – 通用约束对象。

• xvar – 存储 \(x\) 变量。

• yvar – 存储 \(y\) 变量。

Example:

GRBVar[] xvar = new GRBVar[1];
GRBVar[] yvar = new GRBVar[1];

// Retrieve general constraint type
int type = genc.get(GRB.IntAttr.GenConstrType);

if (type == GRB.GENCONSTR_LOGISTIC) {
  model.getGenConstrLogistic(genc, xvar, yvar);
}

void getGenConstrPow(GRBGenConstr genc, GRBVar[] xvar, GRBVar[] yvar, double[] a)

检索与类型为POW的一般约束相关的数据。 对此方法调用不同类型的一般约束会导致异常。您可以查询 GenConstrType属性来确定一般约束的类型。

另请参阅addGenConstrPow以了解此通用约束类型的语义描述。

以下任何参数都可以是null。

Arguments:

• genc – 通用约束对象。

• xvar – 存储 \(x\) 变量。

• yvar – 存储 \(y\) 变量。

• a – 存储函数的指数。

Example:

GRBVar[] xvar = new GRBVar[1];
GRBVar[] yvar = new GRBVar[1];
double[] a    = new double[1];

// Retrieve general constraint type
int type = genc.get(GRB.IntAttr.GenConstrType);

if (type == GRB.GENCONSTR_POW) {
  model.getGenConstrPow(genc, xvar, yvar, a);
}

void getGenConstrSin(GRBGenConstr genc, GRBVar[] xvar, GRBVar[] yvar)

检索与类型为SIN的一般约束相关的数据。 对不同类型的通用约束调用此方法会导致异常。您可以查询 GenConstrType属性来确定通用约束的类型。

另请参阅addGenConstrSin以了解此通用约束类型的语义描述。

以下任何参数都可以是null。

Arguments:

• genc – 通用约束对象。

• xvar – 存储 \(x\) 变量。

• yvar – 存储 \(y\) 变量。

Example:

GRBVar[] xvar = new GRBVar[1];
GRBVar[] yvar = new GRBVar[1];

// Retrieve general constraint type
int type = genc.get(GRB.IntAttr.GenConstrType);

if (type == GRB.GENCONSTR_SIN) {
  model.getGenConstrSin(genc, xvar, yvar);
}

void getGenConstrCos(GRBGenConstr genc, GRBVar[] xvar, GRBVar[] yvar)

检索与类型为COS的一般约束相关联的数据。 对不同类型的通用约束调用此方法会导致异常。您可以查询 GenConstrType属性以确定通用约束的类型。

另请参阅addGenConstrCos以了解此通用约束类型的语义描述。

以下任何参数都可以是null。

Arguments:

• genc – 通用约束对象。

• xvar – 存储 \(x\) 变量。

• yvar – 存储 \(y\) 变量。

Example:

GRBVar[] xvar = new GRBVar[1];
GRBVar[] yvar = new GRBVar[1];

// Retrieve general constraint type
int type = genc.get(GRB.IntAttr.GenConstrType);

if (type == GRB.GENCONSTR_COS) {
  model.getGenConstrCos(genc, xvar, yvar);
}

void getGenConstrTan(GRBGenConstr genc, GRBVar[] xvar, GRBVar[] yvar)

检索与类型为TAN的通用约束相关联的数据。 为不同类型的通用约束调用此方法会导致异常。您可以查询 GenConstrType属性来确定通用约束的类型。

另请参阅addGenConstrTan以了解此通用约束类型的语义描述。

以下任何参数都可以是null。

Arguments:

• genc – 通用约束对象。

• xvar – 存储 \(x\) 变量。

• yvar – 存储 \(y\) 变量。

Example:

GRBVar[] xvar = new GRBVar[1];
GRBVar[] yvar = new GRBVar[1];

// Retrieve general constraint type
int type = genc.get(GRB.IntAttr.GenConstrType);

if (type == GRB.GENCONSTR_TAN) {
  model.getGenConstrTan(genc, xvar, yvar);
}

GRBGenConstr[] getGenConstrs()

检索模型中所有通用约束的数组。

Return value:

模型中的所有一般约束。

Example:

GRBGenConstr[] constrs = model.getGenConstrs();

String getJSONSolution()

在调用optimize之后，此方法返回结果解决方案和相关的模型属性作为JSON字符串。详情请参阅JSON解决方案格式部分。

Return value:

一个JSON字符串。

Example:

String solution = model.getJSONSolution();

GRBEnv getMultiobjEnv(int index)

创建/检索具有给定索引的多目标环境以进行优化传递。此环境允许对多目标优化过程进行细粒度控制。具体来说，通过更改此环境上的参数，您可以修改在多目标优化相应传递期间发生的优化行为。

每个多目标环境都从当前模型环境的副本开始。

请参考关于 多目标的讨论，了解如何指定多个目标函数并控制它们之间的权衡。

请参考关于 结合混合和分层目标 的讨论，以获取有关解决多目标模型的优化过程的信息。

使用discardMultiobjEnvs来 丢弃多目标环境并返回标准行为。

Arguments:

index – 优化过程的索引，从0开始。

Return value:

解决模型时的多目标环境优化过程。

Example:

GRBEnv env0 = model.getMultiobjEnv(0);
GRBEnv env1 = model.getMultiobjEnv(1);

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

model.optimize();
model.discardMultiobjEnvs();

GRBExpr getObjective()

检索优化目标。

请注意，目标函数的常数部分和线性部分也可以使用ObjCon和Obj属性来获取。

Return value:

模型目标。

Example:

GRBExpr obj = model.getObjective();
double objVal = obj.getValue();

GRBLinExpr getObjective(int index)

检索一个替代的优化目标。替代目标将始终是线性的。你也可以使用这个例程来检索主要目标（使用index = 0），但如果主要目标包含二次项，你将得到一个异常。

请参考关于 多目标的讨论，以获取更多关于使用替代目标的信息。

请注意，也可以使用ObjNCon和ObjN属性来检索替代目标。

Arguments:

index – 请求的替代目标的索引。

Return value:

请求的替代目标。

Example:

// Get objective with index 1
GRBLinExpr obj = model.getObjective(1);
double objVal = obj.getValue();

int getPWLObj(GRBVar var, double[] x, double[] y)

检索变量的分段线性目标函数。返回值给出了定义函数的点的数量，\(x\) 和 \(y\) 参数分别给出了这些点的坐标。\(x\) 和 \(y\) 参数必须足够大以容纳结果。如果你只想要点的数量，可以使用 null 值调用此方法。

请参考此讨论以获取关于\(x\)和\(y\)中值的更多信息。

Arguments:

• var – 正在检索其目标函数的变量。

• x – 定义分段线性函数的点的 \(x\) 值。这些值将始终按非递减顺序排列。

• y – 定义分段线性函数的点的 \(y\) 值。

Return value:

定义分段线性目标函数的点数。

Example:

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

GRBQuadExpr getQCRow(GRBQConstr qc)

从二次约束中检索左侧表达式。结果以GRBQuadExpr对象的形式返回。

Arguments:

qc – 感兴趣的二次约束。

Return value:

一个GRBQuadExpr对象，用于捕获二次约束的左侧。

Example:

GRBQConstr[] constrs = model.getQConstrs();
// Get left-hand side of first quadratic constraint
GRBQuadExpr qexpr = model.getQCRow(constrs[0]);

GRBQConstr[] getQConstrs()

检索模型中所有二次约束的数组。

Return value:

模型中的所有二次约束。

Example:

// Get all quadratic constraints
GRBQConstr[] constrs = model.getQConstrs();

GRBLinExpr getRow(GRBConstr constr)

检索参与约束的变量列表及其相关系数。结果以GRBLinExpr对象的形式返回。

Arguments:

constr – 感兴趣的约束。一个 GRBConstr 对象，通常从 addConstr 或 getConstrs 获得。

Return value:

一个GRBLinExpr对象，用于捕获参与约束的变量集。

Example:

GRBConstr[] constrs = model.getConstrs();
// Get left-hand side of first linear constraint
GRBLinExpr lexpr = model.getRow(constrs[0]);

int getSOS(GRBSOS sos, GRBVar[] vars, double[] weights, int[] type)

检索参与SOS约束的变量列表及其相关系数。返回值是该列表的长度。请注意，参数数组必须足够长以容纳结果。使用null数组参数调用该方法以确定适当的数组长度。

Arguments:

• sos – 感兴趣的SOS集合。

• vars – 参与 sos 的变量列表。可以为 null。

• weights – 每个参与变量的SOS权重。可以为null。

• type – SOS集的类型（GRB.SOS_TYPE1 或 GRB.SOS_TYPE2）将在 type[0] 中返回。

Return value:

输出数组中放置的条目数。请注意，您应查阅返回值以确定结果的长度；数组大小不一定与结果大小匹配。

Example:

GRBSOS[] constrs = model.getSOSs();
// Get variables in 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);

GRBSOS[] getSOSs()

检索模型中所有SOS约束的数组。

Return value:

模型中的所有SOS约束。

Example:

// Get all SOS constraints
GRBSOS[] constrs = model.getSOSs();

void getTuneResult(int i)

使用此方法检索先前tune调用的结果。使用参数n调用此方法会将调优参数集n复制到模型中。参数集按质量递减顺序存储，参数集0为最佳。可用集的数量存储在属性TuneResultCount中。

一旦你获取了调优结果，你可以调用 optimize 来使用这些参数 设置来优化模型，或者 write 将更改后的参数写入一个 .prm 文件。

请参阅参考手册中的参数调优部分，了解调优工具的详细信息。

Arguments:

i – 要检索的调优结果的索引。最佳结果作为索引0可用。存储结果的数量可在属性TuneResultCount中获取。

Example:

model.tune();
model.getTuneResult(0);

GRBVar getVarByName(String name)

根据名称检索变量。如果有多个变量具有相同的名称，此方法会任意选择一个。如果没有变量具有该名称，则返回null。

Arguments:

name – 所需变量的名称。

Return value:

请求的变量。

Example:

// Get variable with name "var1"
GRBVar v = model.getVarByName("var1");

GRBVar[] getVars()

检索模型中的所有变量的数组。

Return value:

模型中的所有变量。

Example:

// Get all variables
GRBVar[] vars = model.getVars();

void optimize()

优化模型。用于优化的算法取决于模型类型（连续模型的单纯形法或障碍法；MIP模型的分支定界法）。成功完成后，此方法将填充模型的解决方案相关属性。有关属性的更多信息，请参阅参考手册中的属性部分。

请查阅本节在参考手册中，以讨论一些与使用有限精度浮点算术解决精确定义的数学模型相关的实际问题。

请注意，此方法将处理所有待处理的模型修改。

Example:

model.optimize();

void optimizeasync()

异步优化模型。此例程立即返回。您的程序可以在优化在后台进行时执行其他计算。要检查异步优化的状态，请查询模型的状态属性。值为IN_PROGRESS表示优化尚未完成。当您完成前台任务时，必须调用sync以使您的前台程序与异步优化任务同步。

请注意，在后台运行优化时，您可以进行的Gurobi调用集合非常有限。具体来说，您只能执行属性查询，并且只能查询一些属性（如下所列）。对正在运行的模型或在同一Gurobi环境中构建的任何其他模型的任何其他调用都将失败，并返回错误代码OPTIMIZATION_IN_PROGRESS。

请注意，在其他环境中构建的模型没有这样的限制。因此，例如，您可以创建多个环境，然后让一个前台程序启动多个同时进行的异步优化，每个优化都在其自己的环境中进行。

如前所述，您可以在异步优化进行时查询状态属性的值。其他可以查询的属性包括：ObjVal、ObjBound、IterCount、NodeCount和BarIterCount。在每种情况下，返回的值反映了优化到该点的进度。任何尝试查询不在此列表中的属性值都将返回优化进行中错误。

Example:

// Start asynchronous optimization
model.optimizeasync();

// Poll the status while optimization is in progress
while (model.get(GRB.IntAttr.Status) == GRB.INPROGRESS) {
    Thread.sleep(100);  // 100 ms sleep
    System.out.println("ObjVal=" + model.get(GRB.DoubleAttr.ObjVal) +
                       " ObjBound=" + model.get(GRB.DoubleAttr.ObjBound));
}

// Synchronize model
model.sync();

// Query solution and process results
// ...

String optimizeBatch()

向集群管理器提交一个新的批处理请求。返回BatchID（一个字符串），它唯一地标识集群管理器中的作业，并可用于查询此请求的状态（从此程序或任何其他程序）。一旦请求完成，BatchID也可以用于检索相关的解决方案。要提交批处理请求，您必须通过设置VTag、CTag或QCTag属性之一来标记模型的至少一个元素。有关批处理优化的更多详细信息，请参阅批处理优化部分。

请注意，此例程将处理所有待处理的模型修改。

Return value:

批处理请求的唯一字符串标识符。

Example:

String batchID = model.optimizeBatch();

GRBModel presolve()

对模型执行预求解。

请注意，此函数计算的预解模型可能与优化模型时计算的预解模型不同。

Return value:

原始模型的预解版本。

Example:

GRBModel presolved = model.presolve();

void read(String filename)

此方法是从文件导入数据到模型的通用入口点。它可以用于读取连续模型的基础文件、MIP模型的起始向量、MIP模型的变量提示、MIP模型的分支优先级或参数设置。读取的数据类型由文件后缀决定。文件格式在文件格式部分中描述。

请注意，读取文件不会处理所有待处理的模型修改。这些修改可以通过调用GRBModel.update来处理。

还要注意，如果你想从文件中读取一个新模型，这不是要使用的方法。为此，请使用GRBModel 构造函数。构造函数的一个变体将包含新模型的文件名作为其参数。

Arguments:

• filename – 要读取的文件名。文件的后缀必须是 .bas（用于LP基础），.mst 或 .sol（用于MIP 启动），.hnt（用于MIP提示），.ord（用于优先级顺序）， .attr（用于一组属性设置），或 .prm（用于参数文件）。后缀可以选择性地跟随 .zip，.gz，.bz2，.7z 或 .xz。

• filename – 要读取的文件名。

Example:

model.read("myModel.mps");

void remove(GRBConstr constr)

从模型中移除一个线性约束。请注意，由于我们采用延迟更新的方法，更改实际上不会生效，直到您更新模型（使用GRBModel.update）、优化模型（使用GRBModel.optimize）或将模型写入磁盘（使用GRBModel.write）。

Arguments:

constr – 要移除的线性约束。

Example:

GRBConstr[] constrs = model.getConstrs();
// Remove first linear constraint
model.remove(constrs[0]);

void remove(GRBGenConstr genconstr)

从模型中移除一个通用约束。请注意，由于我们采用延迟更新的方法，更改实际上不会生效，直到您更新模型（使用GRBModel.update）、优化模型（使用GRBModel.optimize）或将模型写入磁盘（使用GRBModel.write）。

Arguments:

genconstr – 要移除的通用约束。

Example:

GRBGenConstr[] constrs = model.getGenConstrs();
// Remove first general constraint
model.remove(constrs[0]);

void remove(GRBQConstr qconstr)

从模型中移除一个二次约束。请注意，由于我们采用延迟更新的方法，更改实际上不会生效，直到您更新模型（使用GRBModel.update）、优化模型（使用GRBModel.optimize）或将模型写入磁盘（使用GRBModel.write）。

Arguments:

qconstr – 要移除的二次约束。

Example:

GRBQConstr[] constrs = model.getQConstrs();
// Remove first quadratic constraint
model.remove(constrs[0]);

void remove(GRBSOS sos)

从模型中移除一个SOS约束。请注意，由于我们采用延迟更新方法，更改实际上不会生效，直到您更新模型（使用GRBModel.update）、优化模型（使用GRBModel.optimize）或将模型写入磁盘（使用GRBModel.write）。

Arguments:

sos – 要移除的SOS约束。

Example:

GRBSOS[] constrs = model.getSOSs();
// Remove first SOS constraint
model.remove(constrs[0]);

void remove(GRBVar var)

从模型中移除一个变量。请注意，由于我们采用延迟更新的方法，更改实际上不会生效，直到您更新模型（使用GRBModel.update）、优化模型（使用GRBModel.optimize）或将模型写入磁盘（使用GRBModel.write）。

Arguments:

var – 要移除的变量。

Example:

GRBVar[] vars = model.getVars();
// Remove first variable
model.remove(vars[0]);

void reset()

将模型重置为未解决状态，丢弃任何先前计算的解决方案信息。

Example:

model.reset();

void reset(int clearall)

将模型重置为未解决状态，丢弃任何先前计算的解决方案信息。

Arguments:

clearall – 值为1时，丢弃影响求解过程但不影响实际模型的额外信息（目前包括MIP起始点、变量提示、分支优先级、惰性标志和分区信息）。传递0仅丢弃解决方案。

Example:

model.reset(1);

void setCallback(GRBCallback cb)

为模型设置回调对象。Gurobi求解器将定期调用此对象上的callback()方法。您将有机会从此回调中获取有关优化状态的更详细信息。有关更多信息，请参阅GRBCallback的文档。

请注意，一个模型只能有一个回调方法，因此此调用将替换现有的回调。

Arguments:

cb – 新的回调对象。要禁用先前设置的回调，请使用null参数调用此方法。

Example:

class MyCallback extends GRBCallback {
    // ...
}

MyCallback cb = new MyCallback();
model.setCallback(cb);

void set(GRB.DoubleParam param, double newval)

设置一个双精度值参数的值。

在模型上设置参数和在环境上设置参数（即通过GRBEnv.set）的区别在于，前者修改的是单个模型的参数，而后者修改的是随后使用该环境构建的每个模型的参数（并且对于之前使用该环境构建的模型，参数保持不变）。

Arguments:

• param – 正在修改的参数。

• newval – 参数所需的新值。

Example:

model.set(GRB.DoubleParam.TimeLimit, 10.0);

void set(GRB.IntParam param, int newval)

设置一个整型参数的值。

在模型上设置参数和在环境上设置参数（即通过GRBEnv.set）的区别在于，前者修改的是单个模型的参数，而后者修改的是随后使用该环境构建的每个模型的参数（并且对于之前使用该环境构建的模型，参数保持不变）。

Arguments:

• param – 正在修改的参数。

• newval – 参数的新期望值。

Example:

model.set(GRB.IntParam.PumpPasses, 10);

void set(GRB.StringParam param, String newval)

设置字符串类型参数的值。

在模型上设置参数和在环境上设置参数（即通过GRBEnv.set）的区别在于，前者修改的是单个模型的参数，而后者修改的是随后使用该环境构建的每个模型的参数（并且对于之前使用该环境构建的模型，参数保持不变）。

Arguments:

• param – 正在修改的参数。

• newval – 参数所需的新值。

Example:

model.set(GRB.StringParam.LogFile, "myLog.log");

void set(String param, String newval)

仅使用字符串设置任何参数的值。

在模型上设置参数和在环境上设置参数（即通过GRBEnv.set）的区别在于，前者修改的是单个模型的参数，而后者修改的是随后使用该环境构建的每个模型的参数（并且对于之前使用该环境构建的模型，参数保持不变）。

Arguments:

• param – 正在修改的参数的名称。

• newval – 参数的新期望值。

Example:

// Set the TimeLimit parameter via strings
model.set("TimeLimit", "10.0");

void set(GRB.CharAttr attr, GRBVar[] vars, char[] newvals)

为变量数组设置一个字符型变量属性。

Arguments:

• attr – 正在修改的属性。

• vars – 正在修改其属性值的变量。

• newvals – 每个输入变量的属性的期望新值。

Example:

// Add 3 binary variables
GRBVar[] x = model.addVars(3, GRB.BINARY);
// Change the type of the 3 variables to CONTINUOUS
char[] newvals = {'C', 'C', 'C'};
model.set(GRB.CharAttr.VType, x, newvals);

void set(GRB.CharAttr attr, GRBVar[] vars, char[] newvals, int start, int len)

为变量的子数组设置一个字符型变量属性。

Arguments:

• attr – 正在修改的属性。

• vars – 一个一维数组，包含正在修改属性值的变量。

• newvals – 每个输入变量的属性的期望新值。

• start – 列表中第一个感兴趣的变量的索引。

• len – 变量的数量。

Example:

// Add 3 binary variables
GRBVar[] x = model.addVars(3, GRB.BINARY);
// Change the type of the first 2 variables to CONTINUOUS
char[] newvals = {'C', 'C'};
model.set(GRB.CharAttr.VType, x, newvals, 0, 2);

void set(GRB.CharAttr attr, GRBVar[][] vars, char[][] newvals)

为二维变量数组设置一个字符型变量属性。

Arguments:

• attr – 正在修改的属性。

• vars – 一个二维变量数组，其属性值正在被修改。

• newvals – 每个输入变量的属性所需的新值。

Example:

// Change the type of a 2x2 array of variables to BINARY
GRBVar[][] x = new GRBVar[2][2];
// ...
char[][] newvals = {{'B', 'B'},{'B', 'B'}};
model.set(GRB.CharAttr.VType, x, newvals);

void set(GRB.CharAttr attr, GRBVar[][][] vars, char[][][] newvals)

为三维变量数组设置一个字符型变量属性。

Arguments:

• attr – 正在修改的属性。

• vars – 一个三维变量数组，其属性值正在被修改。

• newvals – 每个输入变量的属性的期望新值。

Example:

// Change the type of a 2x2x2 array of variables to BINARY
GRBVar[][][] x = new GRBVar[2][2][2];
// ...
char[][][] newvals = {{{'B', 'B'},{'B', 'B'}}, {{'B', 'B'},{'B', 'B'}}};
model.set(GRB.CharAttr.VType, x, newvals);

void set(GRB.CharAttr attr, GRBConstr[] constrs, char[] newvals)

为约束数组设置一个字符值约束属性。

Arguments:

• attr – 正在修改的属性。

• constrs – 正在修改其属性值的约束。

• newvals – 每个输入约束的属性的期望新值。

Example:

// Add 3 trivial linear constraints to model
GRBConstr[] constrs = model.addConstrs(3);
// Change the sense of the 3 constraints
char[] newvals = {'<', '=', '>'};
model.set(GRB.CharAttr.Sense, constrs, newvals);

void set(GRB.CharAttr attr, GRBConstr[] constrs, char[] newvals, int start, int len)

为约束的子数组设置一个字符值的约束属性。

Arguments:

• attr – 正在修改的属性。

• constrs – 一个一维的约束数组，其属性值正在被修改。

• newvals – 每个输入约束的属性的期望新值。

• start – 列表中感兴趣的第一个约束的索引。

• len – 约束的数量。

Example:

// Add 3 trivial linear constraints to model
GRBConstr[] constrs = model.addConstrs(3);
// Change the sense of the first 2 constraints
char[] newvals = {'<', '='};
model.set(GRB.CharAttr.Sense, constrs, newvals, 0, 2);

void set(GRB.CharAttr attr, GRBConstr[][] constrs, char[][] newvals)

为二维约束数组设置一个字符值约束属性。

Arguments:

• attr – 正在修改的属性。

• constrs – 一个二维的约束数组，其属性值正在被修改。

• newvals – 每个输入约束的属性的期望新值。

Example:

// Change the sense of a 2x2 array of constraints
GRBConstr[][] constrs = new GRBConstr[2][2];
// ...
char[][] newvals = {{'<', '='}, {'<', '='}};
model.set(GRB.CharAttr.Sense, constrs, newvals);

void set(GRB.CharAttr attr, GRBConstr[][][] constrs, char[][][] newvals)

为约束的三维数组设置一个字符值的约束属性。

Arguments:

• attr – 正在修改的属性。

• constrs – 一个三维约束数组，其属性值正在被修改。

• newvals – 每个输入约束的属性的期望新值。

Example:

// Change the sense of a 2x2x2 array of constraints
GRBConstr[][][] constrs = new GRBConstr[2][2][2];
// ...
char[][][] newvals = {{{'<', '='}, {'<', '='}},{{'<', '='}, {'<', '='}}};
model.set(GRB.CharAttr.Sense, constrs, newvals);

void set(GRB.CharAttr attr, GRBQConstr[] qconstrs, char[] newvals)

为二次约束数组设置一个字符值的二次约束属性。

Arguments:

• attr – 正在修改的属性。

• qconstrs – 正在修改其属性值的二次约束。

• newvals – 每个输入二次约束属性的期望新值。

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[] newvals = {'<', '=', '>'};
model.set(GRB.CharAttr.QCSense, constrs, newvals);

void set(GRB.CharAttr attr, GRBQConstr[] qconstrs, char[] newvals, int start, int len)

为二次约束的子数组设置一个字符值的二次约束属性。

Arguments:

• attr – 正在修改的属性。

• qconstrs – 一个一维数组，包含正在修改属性值的二次约束。

• newvals – 每个输入二次约束属性的期望新值。

• start – 列表中感兴趣的第一个二次约束的索引。

• len – 二次约束的数量。

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[] newvals = {'<', '='};
model.set(GRB.CharAttr.QCSense, constrs, newvals, 0, 2);

void set(GRB.CharAttr attr, GRBQConstr[][] qconstrs, char[][] newvals)

为二维二次约束数组设置一个字符值的二次约束属性。

Arguments:

• attr – 正在修改的属性。

• qconstrs – 一个二维数组，包含正在修改属性值的二次约束。

• newvals – 每个输入二次约束属性的期望新值。

Example:

// Change the sense of a 2x2 array of quadratic constraints
GRBQConstr[][] qconstrs = new GRBQConstr[2][2];
// ...
char[][] newvals = {{'<', '='}, {'<', '='}};
model.set(GRB.CharAttr.QCSense, qconstrs, newvals);

void set(GRB.CharAttr attr, GRBQConstr[][][] qconstrs, char[][][] newvals)

为三维二次约束数组设置一个字符值的二次约束属性。

Arguments:

• attr – 正在修改的属性。

• qconstrs – 一个三维的二次约束数组，其属性值正在被修改。

• newvals – 每个输入二次约束属性的期望新值。

Example:

// Change the sense of a 2x2x2 array of quadratic constraints
char[][][] newvals = {{{'<', '='}, {'<', '='}},{{'<', '='}, {'<', '='}}};
model.set(GRB.CharAttr.QCSense, qconstrs, newvals);

void set(GRB.DoubleAttr attr, double newval)

设置一个双精度值的模型属性。

Arguments:

• attr – 正在修改的属性。

• newval – 属性的期望新值。

Example:

// Adjust objective constant
model.set(GRB.DoubleAttr.ObjCon, 2.0);

void set(GRB.DoubleAttr attr, GRBVar[] vars, double[] newvals)

为变量数组设置一个双精度值的变量属性。

Arguments:

• attr – 正在修改的属性。

• vars – 正在修改其属性值的变量。

• newvals – 每个输入变量的属性的期望新值。

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);

void set(GRB.DoubleAttr attr, GRBVar[] vars, double[] newvals, int start, int len)

为变量的子数组设置一个双精度值的变量属性。

Arguments:

• attr – 正在修改的属性。

• vars – 一个一维数组，包含正在修改属性值的变量。

• newvals – 每个输入变量的属性的期望新值。

• start – 列表中第一个感兴趣的变量的索引。

• len – 变量的数量。

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);

void set(GRB.DoubleAttr attr, GRBVar[][] vars, double[][] newvals)

为二维变量数组设置一个双精度值的变量属性。

Arguments:

• attr – 正在修改的属性。

• vars – 一个二维变量数组，其属性值正在被修改。

• newvals – 每个输入变量的属性的期望新值。

Example:

// Change the lower bound of a 2x2 array of variables
GRBVar[][] x = new GRBVar[2][2];
// ...
double[][] newvals = {{0.1, 0.2}, {0.3, 0.4}};
model.set(GRB.DoubleAttr.LB, x, newvals);

void set(GRB.DoubleAttr attr, GRBVar[][][] vars, double[][][] newvals)

为三维变量数组设置一个双精度值的变量属性。

Arguments:

• attr – 正在修改的属性。

• vars – 一个三维变量数组，其属性值正在被修改。

• newvals – 每个输入变量的属性的期望新值。

Example:

// Change the lower bound of a 2x2x2 array of variables
GRBVar[][][] x = new GRBVar[2][2][2];
// ...
double[][][] newvals = {{{0.1, 0.2}, {0.3, 0.4}}, {{0.5, 0.6}, {0.7, 0.8}}};
model.set(GRB.DoubleAttr.LB, x, newvals);

void set(GRB.DoubleAttr attr, GRBConstr[] constrs, double[] newvals)

为约束数组设置一个双值约束属性。

Arguments:

• attr – 正在修改的属性。

• constrs – 正在修改其属性值的约束。

• newvals – 每个输入约束的属性的期望新值。

Example:

// Add 3 linear constraints to the model
GRBConstr[] constrs = model.addConstrs(3);
// Change the right-hand sides of the constraints
double[] newvals = {1.0, 2.0, 3.0};
model.set(GRB.DoubleAttr.RHS, constrs, newvals);

void set(GRB.DoubleAttr attr, GRBConstr[] constrs, double[] newvals, int start, int len)

为约束的子数组设置一个双值约束属性。

Arguments:

• attr – 正在修改的属性。

• constrs – 一个一维的约束数组，其属性值正在被修改。

• newvals – 每个输入约束的属性的期望新值。

• start – 列表中感兴趣的第一个约束。

• len – 约束的数量。

Example:

// Add 3 linear constraints to the model
GRBConstr[] constrs = model.addConstrs(3);
// Change the right-hand sides of the first 2 constraints
double[] newvals = {1.0, 2.0};
model.set(GRB.DoubleAttr.RHS, constrs, newvals, 0, 2);

void set(GRB.DoubleAttr attr, GRBConstr[][] constrs, double[][] newvals)

为二维约束数组设置一个双值约束属性。

Arguments:

• attr – 正在修改的属性。

• constrs – 一个二维的约束数组，其属性值正在被修改。

• newvals – 每个输入约束的属性的期望新值。

Example:

// Change the RHS of a 2x2 array of constraints
GRBConstr[][] constrs = new GRBConstr[2][2];
// ...
double[][] newvals = {{1.0, 2.0}, {3.0, 4.0}};
model.set(GRB.DoubleAttr.RHS, constrs, newvals);

void set(GRB.DoubleAttr attr, GRBConstr[][][] constrs, double[][][] newvals)

为三维约束数组设置一个双值约束属性。

Arguments:

• attr – 正在修改的属性。

• constrs – 一个三维约束数组，其属性值正在被修改。

• newvals – 每个输入约束的属性的期望新值。

Example:

// Change the RHS of a 2x2x2 array of constraints
GRBConstr[][][] constrs = new GRBConstr[2][2][2];
// ...
double[][][] newvals = {{{1.0, 2.0}, {3.0, 4.0}}, {{5.0, 6.0}, {7.0, 8.0}}};
model.set(GRB.DoubleAttr.RHS, constrs, newvals);

void set(GRB.DoubleAttr attr, GRBQConstr[] qconstrs, double[] newvals)

为一系列二次约束设置一个双值二次约束属性。

Arguments:

• attr – 正在修改的属性。

• qconstrs – 正在修改其属性值的二次约束。

• newvals – 每个输入二次约束属性的期望新值。

Example:

// Add 3 quadratic constraints
GRBQConstr c1 = model.addQConstr(x*x + y*y == 0, "qc1");
GRBQConstr c2 = model.addQConstr(x*y - y*y == 0, "qc2");
GRBQConstr c3 = model.addQConstr(x*x - x*y == 0, "qc3");
GRBQConstr[] qconstrs = {c1, c2, c3};
// Change the RHS values of the quadratic constraints
double[] newvals = {1.0, 2.0, 3.0};
model.set(GRB.DoubleAttr.QCRHS, qconstrs, newvals);

void set(GRB.DoubleAttr attr, GRBQConstr[] qconstrs, double[] newvals, int start, int len)

为二次约束的子数组设置一个双值二次约束属性。

Arguments:

• attr – 正在修改的属性。

• qconstrs – 一个一维数组，包含正在修改属性值的二次约束。

• newvals – 每个输入二次约束属性的期望新值。

• start – 列表中感兴趣的第一个二次约束。

• len – 二次约束的数量。

Example:

// Add 3 quadratic constraints
GRBQConstr c1 = model.addQConstr(x*x + y*y == 0, "qc1");
GRBQConstr c2 = model.addQConstr(x*y - y*y == 0, "qc2");
GRBQConstr c3 = model.addQConstr(x*x - x*y == 0, "qc3");
GRBQConstr[] qconstrs = {c1, c2, c3};
// Change the RHS values of the first 2 quadratic constraints
double[] newvals = {1.0, 2.0};
model.set(GRB.DoubleAttr.QCRHS, qconstrs, newvals, 0, 2);

void set(GRB.DoubleAttr attr, GRBQConstr[][] qconstrs, double[][] newvals)

为二维二次约束数组设置一个双值二次约束属性。

Arguments:

• attr – 正在修改的属性。

• qconstrs – 一个二维数组，包含正在修改属性值的二次约束。

• newvals – 每个输入二次约束属性的期望新值。

Example:

// Change the RHS of a 2x2 array of quadratic constraints
GRBQConstr[][] qconstrs = new GRBQConstr[2][2];
// ...
double[][] newvals = {{1.0, 2.0}, {3.0, 4.0}};
model.set(GRB.DoubleAttr.QCRHS, qconstrs, newvals);

void set(GRB.DoubleAttr attr, GRBQConstr[][][] qconstrs, double[][][] newvals)

为三维二次约束数组设置一个双值二次约束属性。

Arguments:

• attr – 正在修改的属性。

• qconstrs – 一个三维的二次约束数组，其属性值正在被修改。

• newvals – 每个输入二次约束属性的期望新值。

Example:

// Change the RHS of a 2x2x2 array of quadratic constraints
GRBQConstr[][][] qconstrs = new GRBQConstr[2][2][2];
// ...
double[][][] newvals = {{{1.0, 2.0}, {3.0, 4.0}}, {{5.0, 6.0}, {7.0, 8.0}}};
model.set(GRB.DoubleAttr.QCRHS, qconstrs, newvals);

void set(GRB.IntAttr attr, int newval)

设置一个整数值模型属性的值。

Arguments:

• attr – 正在修改的属性。

• newval – 属性的期望新值。

Example:

// Set the model's sense
model.set(GRB.IntAttr.ModelSense, -1);

void set(GRB.IntAttr attr, GRBVar[] vars, int[] newvals)

为变量数组设置一个整数值的变量属性。

Arguments:

• attr – 正在修改的属性。

• vars – 正在修改其属性值的变量。

• newvals – 每个输入变量的属性的期望新值。

Example:

// Add 3 binary variables
GRBVar[] x = model.addVars(3, GRB.BINARY);
// Change the VBasis of the variables
int[] newvals = {0, -1, -2};
model.set(GRB.IntAttr.VBasis, x, newvals);

void set(GRB.IntAttr attr, GRBVar[] vars, int[] newvals, int start, int len)

为变量的子数组设置一个整数值的变量属性。

Arguments:

• attr – 正在修改的属性。

• vars – 一个一维数组，包含正在修改属性值的变量。

• newvals – 每个输入变量的属性的期望新值。

• start – 列表中第一个感兴趣的变量的索引。

• len – 变量的数量。

Example:

// Add 3 binary variables
GRBVar[] x = model.addVars(3, GRB.BINARY);
// Change the VBasis of the first 2 variables
int[] newvals = {0, -1};
model.set(GRB.IntAttr.VBasis, x, newvals, 0, 2);

void set(GRB.IntAttr attr, GRBVar[][] vars, int[][] newvals)

为二维变量数组设置一个整型变量属性。

Arguments:

• attr – 正在修改的属性。

• vars – 一个二维变量数组，其属性值正在被修改。

• newvals – 每个输入变量的属性的期望新值。

Example:

// Set the VBasis for a 2x2 array of variables
GRBVar[][] x = new GRBVar[2][2];
// ...
int[][] newvals = {{0, -1}, {-2, -3}};
model.set(GRB.IntAttr.VBasis, x, newvals);

void set(GRB.IntAttr attr, GRBVar[][][] vars, int[][][] newvals)

为三维变量数组设置一个整数值变量属性。

Arguments:

• attr – 正在修改的属性。

• vars – 一个三维变量数组，其属性值正在被修改。

• newvals – 每个输入变量的属性的期望新值。

Example:

// Set the VBasis for a 2x2x2 array of variables
GRBVar[][][] x = new GRBVar[2][2][2];
// ...
int[][][] newvals = {{{0, -1}, {0, -1}}, {{0, -1}, {0, -1}}};
model.set(GRB.IntAttr.VBasis, x, newvals);

void set(GRB.IntAttr attr, GRBConstr[] constrs, int[] newvals)

为约束数组设置一个整数值的约束属性。

Arguments:

• attr – 正在修改的属性。

• constrs – 正在修改其属性值的约束。

• newvals – 每个输入约束的属性的期望新值。

Example:

// Add 3 constraints
GRBConstr[] constrs = model.addConstrs(3);
// Set the CBasis of the constraints
int[] newvals = {0, 0, 0};
model.set(GRB.IntAttr.CBasis, constrs, newvals);

void set(GRB.IntAttr attr, GRBConstr[] constrs, int[] newvals, int start, int len)

为约束的子数组设置一个整数值的约束属性。

Arguments:

• attr – 正在修改的属性。

• constrs – 一个一维的约束数组，其属性值正在被修改。

• newvals – 每个输入约束的属性的期望新值。

• start – 列表中感兴趣的第一个约束的索引。

• len – 约束的数量。

Example:

// Add 3 constraints
GRBConstr[] constrs = model.addConstrs(3);
// Set the CBasis of the first 2 constraints
int[] newvals = {0, -1};
model.set(GRB.IntAttr.CBasis, constrs, newvals, 0, 2);

void set(GRB.IntAttr attr, GRBConstr[][] constrs, int[][] newvals)

为二维约束数组设置一个整数值的约束属性。

Arguments:

• attr – 正在修改的属性。

• constrs – 一个二维的约束数组，其属性值正在被修改。

• newvals – 每个输入约束的属性的期望新值。

Example:

// Set the CBasis of a 2x2 array of constraints
GRBConstr[][] constrs = new GRBConstr[2][2];
// ...
int[][] newvals = {{0, -1}, {-1, 0}};
model.set(GRB.IntAttr.CBasis, constrs, newvals);

void set(GRB.IntAttr attr, GRBConstr[][][] constrs, int[][][] newvals)

为三维约束数组设置一个整数值的约束属性。

Arguments:

• attr – 正在修改的属性。

• constrs – 一个三维约束数组，其属性值正在被修改。

• newvals – 每个输入约束的属性的期望新值。

Example:

// Set the CBasis of a 2x2x2 array of constraints
GRBConstr[][][] constrs = new GRBConstr[2][2][2];
// ...
int[][][] newvals = {{{0, -1}, {-1, 0}}, {{0, -1}, {-1, 0}}};
model.set(GRB.IntAttr.CBasis, constrs, newvals);

void set(GRB.StringAttr attr, String newval)

设置一个字符串类型模型属性的值。

Arguments:

• attr – 正在修改的属性。

• newval – 属性的期望新值。

Example:

// Set model name
model.set(GRB.StringAttr.ModelName, "myModel");

void set(GRB.StringAttr attr, GRBVar[] vars, String[] newvals)

为变量数组设置一个字符串类型的变量属性。

Arguments:

• attr – 正在修改的属性。

• vars – 正在修改其属性值的变量。

• newvals – 每个输入变量的属性的期望新值。

Example:

// Add 3 binary variables
GRBVar[] x = model.addVars(3, GRB.BINARY);
// Set the variable name attribute
String[] newvals = {"x1", "x2", "x3"};
model.set(GRB.StringAttr.VarName, x, newvals);

void set(GRB.StringAttr attr, GRBVar[] vars, String[] newvals, int start, int len)

为变量的子数组设置一个字符串值的变量属性。

Arguments:

• attr – 正在修改的属性。

• vars – 一个一维数组，包含正在修改属性值的变量。

• newvals – 每个输入变量的属性的期望新值。

• start – 列表中第一个感兴趣的变量的索引。

• len – 变量的数量。

Example:

// Add 3 binary variables
GRBVar[] x = model.addVars(3, GRB.BINARY);
// Set the name of the first 2 variables
String[] newvals = {"x1", "x2"};
model.set(GRB.StringAttr.VarName, x, newvals, 0, 2);

void set(GRB.StringAttr attr, GRBVar[][] vars, String[][] newvals)

为二维变量数组设置一个字符串类型的变量属性。

Arguments:

• attr – 正在修改的属性。

• vars – 一个二维变量数组，其属性值正在被修改。

• newvals – 每个输入变量的属性的期望新值。

Example:

// Set the variable names for a 2x2 array of variables
GRBVar[][] x = new GRBVar[2][2];
// ...
String[][] newvals = {{"x1", "x2"}, {"x3", "x4"}};
model.set(GRB.StringAttr.VarName, x, newvals);

void set(GRB.StringAttr attr, GRBVar[][][] vars, String[][][] newvals)

为三维变量数组设置一个字符串类型的变量属性。

Arguments:

• attr – 正在修改的属性。

• vars – 一个三维变量数组，其属性值正在被修改。

• newvals – 每个输入变量的属性的期望新值。

Example:

// Set the variable names for the 2x2x2 array of variables
GRBVar[][][] x = new GRBVar[2][2][2];
// ...
String[][][] newvals = {{{"x1", "x2"}, {"x3", "x4"}}, {{"x5", "x6"}, {"x7", "x8"}}};
model.set(GRB.StringAttr.VarName, x, newvals);

void set(GRB.StringAttr attr, GRBConstr[] constrs, String[] newvals)

为约束数组设置一个字符串值的约束属性。

Arguments:

• attr – 正在修改的属性。

• constrs – 正在修改其属性值的约束。

• newvals – 每个输入约束的属性的期望新值。

Example:

// Add 3 constraints
GRBConstr[] constrs = model.addConstrs(3);
// Set the names of the constraints
String[] newvals = {"c1", "c2", "c3"};
model.set(GRB.StringAttr.ConstrName, constrs, newvals);

void set(GRB.StringAttr attr, GRBConstr[] constrs, String[] newvals, int start, int len)

为约束的子数组设置一个字符串值的约束属性。

Arguments:

• attr – 正在修改的属性。

• constrs – 一个一维的约束数组，其属性值正在被修改。

• newvals – 每个输入约束的属性的期望新值。

• start – 列表中感兴趣的第一个约束的索引。

• len – 约束的数量。

Example:

// Add 3 constraints
GRBConstr[] constrs = model.addConstrs(3);
// Set the names of the first 2 constraints
String[] newvals = {"c1", "c2"};
model.set(GRB.StringAttr.ConstrName, constrs, newvals, 0, 2);

void set(GRB.StringAttr attr, GRBConstr[][] constrs, String[][] newvals)

为二维约束数组设置一个字符串值的约束属性。

Arguments:

• attr – 正在修改的属性。

• constrs – 一个二维的约束数组，其属性值正在被修改。

• newvals – 每个输入约束的属性的期望新值。

Example:

// Set the names of a 2x2 array of constraints
GRBConstr[][] constrs = new GRBConstr[2][2];
// ...
String[][] newvals = {{"c1", "c2"}, {"c3", "c4"}};
model.set(GRB.StringAttr.ConstrName, constrs, newvals);

void set(GRB.StringAttr attr, GRBConstr[][][] constrs, String[][][] newvals)

为三维约束数组设置一个字符串值的约束属性。

Arguments:

• attr – 正在修改的属性。

• constrs – 一个三维约束数组，其属性值正在被修改。

• newvals – 每个输入约束的属性的期望新值。

Example:

// Set the names of a 2x2x2 array of constraints
GRBConstr[][][] constrs = new GRBConstr[2][2][2];
// ...
String[][][] newvals = {{{"c1", "c2"}, {"c3", "c4"}}, {{"c5", "c6"}, {"c7", "c8"}}};
model.set(GRB.StringAttr.ConstrName, constrs, newvals);

void set(GRB.StringAttr attr, GRBQConstr[] qconstrs, String[] newvals)

为二次约束数组设置一个字符串值的二次约束属性。

Arguments:

• attr – 正在修改的属性。

• qconstrs – 正在修改其属性值的二次约束。

• newvals – 每个输入二次约束属性的期望新值。

Example:

// Add 3 quadratic constraints
GRBQConstr c1 = model.addQConstr(x*x + y*y == 0, "qc1");
GRBQConstr c2 = model.addQConstr(x*y - y*y == 0, "qc2");
GRBQConstr c3 = model.addQConstr(x*x - x*y == 0, "qc3");
GRBQConstr[] qconstrs = {c1, c2, c3};
// Set the names of the quadratic constraints
String[] newvals = {"qc1", "qc2", "qc3"};
model.set(GRB.StringAttr.QCName, qconstrs, newvals);

void set(GRB.StringAttr attr, GRBQConstr[] qconstrs, String[] newvals, int start, int len)

为二次约束的子数组设置一个字符串值的二次约束属性。

Arguments:

• attr – 正在修改的属性。

• qconstrs – 一个一维数组，包含正在修改属性值的二次约束。

• newvals – 每个输入二次约束属性的期望新值。

• start – 列表中感兴趣的第一个二次约束的索引。

• len – 二次约束的数量。

Example:

// Add 3 quadratic constraints
GRBQConstr c1 = model.addQConstr(x*x + y*y == 0, "qc1");
GRBQConstr c2 = model.addQConstr(x*y - y*y == 0, "qc2");
GRBQConstr c3 = model.addQConstr(x*x - x*y == 0, "qc3");
GRBQConstr[] qconstrs = {c1, c2, c3};
// Set the names of the first 2 quadratic constraints
String[] newvals = {"qc1", "qc2"};
model.set(GRB.StringAttr.QCName, qconstrs, newvals, 0, 2);

void set(GRB.StringAttr attr, GRBQConstr[][] qconstrs, String[][] newvals)

为二维二次约束数组设置一个字符串值的二次约束属性。

Arguments:

• attr – 正在修改的属性。

• qconstrs – 一个二维数组，包含正在修改属性值的二次约束。

• newvals – 每个输入二次约束属性的期望新值。

Example:

// Set the names of a 2x2 array of quadratic constraints
GRBQConstr[][] qconstrs = new GRBQConstr[2][2];
// ...
String[][] newvals = {{"qc1", "qc2"}, {"qc3", "qc4"}};
model.set(GRB.StringAttr.QCName, qconstrs, newvals);

void set(GRB.StringAttr attr, GRBQConstr[][][] qconstrs, String[][][] newvals)

为三维二次约束数组设置一个字符串值的二次约束属性。

Arguments:

• attr – 正在修改的属性。

• qconstrs – 一个三维的二次约束数组，其属性值正在被修改。

• newvals – 每个输入二次约束属性的期望新值。

Example:

// Set the names of a 2x2x2 array of quadratic constraints
GRBQConstr[][][] qconstrs = new GRBQConstr[2][2][2];
// ...
String[][][] newvals = {{{"qc1", "qc2"}, {"qc3", "qc4"}}, {{"qc5", "qc6"}, {"qc7", "qc8"}}};
model.set(GRB.StringAttr.QCName, qconstrs, newvals);

void set(GRB.StringAttr attr, GRBGenConstr[] genconstrs, String[] newvals)

为一般约束数组设置一个字符串值的一般约束属性。

Arguments:

• attr – 正在修改的属性。

• genconstrs – 正在修改属性值的一般约束。

• newvals – 每个输入通用约束属性的期望新值。

Example:

// Add 3 general constraints
GRBGenConstr[] genconstrs = model.addGenConstrs(3);
// Set the names of the general constraints
String[] newvals = {"gc1", "gc2", "gc3"};
model.set(GRB.StringAttr.GenConstrName, genconstrs, newvals);

void set(GRB.StringAttr attr, GRBGenConstr[] genconstrs, String[] newvals, int start, int len)

为一般约束的子数组设置一个字符串值的一般约束属性。

Arguments:

• attr – 正在修改的属性。

• genconstrs – 一个一维数组，包含正在修改属性值的一般约束。

• newvals – 每个输入通用约束的属性的期望新值。

• start – 列表中感兴趣的第一个一般约束的索引。

• len – 一般约束的数量。

Example:

// Add 3 general constraints
GRBGenConstr[] genconstrs = model.addGenConstrs(3);
// Set the names of the first 2 general constraints
String[] newvals = {"gc1", "gc2"};
model.set(GRB.StringAttr.GenConstrName, genconstrs, newvals, 0, 2);

void set(GRB.StringAttr attr, GRBGenConstr[][] genconstrs, String[][] newvals)

为二维通用约束数组设置一个字符串类型的通用约束属性。

Arguments:

• attr – 正在修改的属性。

• genconstrs – 一个二维数组，包含正在修改属性值的一般约束。

• newvals – 每个输入通用约束的属性的期望新值。

Example:

// Set the names of a 2x2 array of general constraints
GRBGenConstr[][] genconstrs = new GRBGenConstr[2][2];
// ...
String[][] newvals = {{"gc1", "gc2"}, {"gc3", "gc4"}};
model.set(GRB.StringAttr.GenConstrName, genconstrs, newvals);

void set(GRB.StringAttr attr, GRBGenConstr[][][] genconstrs, String[][][] newvals)

为三维通用约束数组设置一个字符串类型的通用约束属性。

Arguments:

• attr – 正在修改的属性。

• genconstrs – 一个三维数组，包含正在修改属性值的一般约束。

• newvals – 每个输入通用约束属性的期望新值。

Example:

// Set the names of a 2x2x2 array (genconstrs) of general constraints
GRBGenConstr[][][] genconstrs = new GRBGenConstr[2][2][2];
// ...
String[][][] newvals = {{{"gc1", "gc2"}, {"gc3", "gc4"}}, {{"gc5", "gc6"}, {"gc7", "gc8"}}};
model.set(GRB.StringAttr.GenConstrName, genconstrs, newvals);

void setLogCallback(java.util.function.Consumer<String> logCallback)

设置一个日志回调函数，用于查询模型对象发布的所有输出。可以在模型创建后设置。

Arguments:

logCallback – 日志回调函数。

Example:

// Set a simple logging callback that prints logs
model.setLogCallback(log -> System.out.println("Log: " + log));

void setObjective(GRBExpr expr, int sense)

将模型目标设置为线性表达式（对于多目标优化，请参见 setObjectiveN）。

请注意，您也可以使用Obj变量属性来修改模型目标的线性部分。如果您希望混合使用这两种方法，请注意此方法会替换整个现有目标，而Obj属性可用于修改单个线性项。

Arguments:

• expr – 新模型目标。

• sense – 新的优化方向 (GRB.MINIMIZE 用于最小化, GRB.MAXIMIZE 用于最大化).

Example:

// Set objective and sense
model.setObjective(expression, GRB.MINIMIZE);

void setObjective(GRBExpr expr)

将模型目标设置为等于二次表达式（对于多目标优化，请参见 setObjectiveN）。 目标的方向由 ModelSense 属性的值决定。

请注意，此方法会替换整个现有的目标，而Obj属性可用于修改单个线性项。

Arguments:

expr – 新模型目标。

Example:

// Set objective without specifying sense (use default)
model.setObjective(expr);

void setObjectiveN(GRBLinExpr expr, int index, int priority, double weight, double abstol, double reltol, String name)

将替代优化目标设置为等于线性表达式。

请参考关于 多目标的讨论，以获取更多关于使用替代目标的信息。

请注意，你也可以使用ObjN变量属性来修改替代目标。如果你希望混合使用这两种方法，请注意此方法会替换整个现有目标，而ObjN属性可用于修改单个项。

Arguments:

• expr – 新的替代目标。

• index – 新目标的索引。如果使用索引0，此例程将更改主要优化目标。

• priority – 替代目标的优先级。这将初始化此目标的ObjNPriority属性。

• weight – 替代目标的权重。这将初始化此目标的ObjNWeight属性。

• abstol – 替代目标的绝对容差。这将初始化此目标的ObjNAbsTol属性。

• reltol – 替代目标的相对容差。这将初始化此目标的ObjNRelTol属性。

• name – 替代目标的名称。这将初始化此目标的ObjNName属性。

Example:

// Primary objective: expr1
model.setObjectiveN(expr1, 0, 2, 1.0, 2.0, 0.1, "PrimaryObj");
// Secondary objective: expr2
model.setObjectiveN(expr2, 1, 1, 1.0, 0.0, 0.0, "SecondaryObj");

void setPWLObj(GRBVar var, double[] x, double[] y)

为变量设置分段线性目标函数。

此方法的参数指定了一个定义单变量分段线性目标函数的点列表。具体来说，\(x\) 和 \(y\) 参数给出了函数顶点的坐标。

有关分段线性目标函数的更多详细信息，请参阅 此讨论。

为变量设置分段线性目标函数。

Arguments:

• var – 正在设置目标函数的变量。

• x – 定义分段线性函数的点的\(x\)值。必须按非递减顺序排列。

• y – 定义分段线性函数的点的 \(y\) 值。

Example:

GRBVar v = model.addVar(0.0, 1.0, 0.0, GRB.CONTINUOUS, "var");
double[] xVals = {0.0, 0.5, 1.0};
double[] yVals = {0.5, 0.25, 0.75};
model.setPWLObj(v, xVals, yVals);

GRBModel singleScenarioModel()

从多场景模型中捕获单个场景。使用 ScenarioNumber 参数来指示要捕获的场景。

调用此方法的模型必须是多场景模型，结果将是一个单场景模型。

Return value:

单一场景的模型。

Example:

model.set(GRB.IntAttr.NumScenarios, 1);
model.update();
GRBModel singleScenario = model.singleScenarioModel();

void sync()

等待之前的异步优化调用完成。

调用 optimizeasync 会立即将控制权返回给调用程序。调用者可以在优化进行时执行其他计算，并通过查询各种模型属性来检查优化的进度。sync 调用会强制调用程序等待，直到异步优化调用完成。在删除相应的模型对象之前，您必须调用 sync。

如果优化本身遇到任何问题，sync 调用会抛出异常。换句话说，此方法抛出的异常是 optimize 本身在原始方法不是异步的情况下会抛出的异常。

请注意，即使您知道异步优化已经完成，您也需要调用sync。

Example:

model.optimizeasync();
// ...
model.sync();

void terminate()

生成一个请求以终止当前的优化。此方法可以在优化过程中的任何时间调用（从回调、另一个线程、中断处理程序等）。请注意，通常情况下，请求不会立即被执行。

当优化停止时，状态 属性将等于 GRB_INTERRUPTED。

Example:

model.terminate();

void tune()

执行自动搜索以改进性能的参数设置。完成后，此方法会存储找到的最佳参数集。可以通过查询TuneResultCount属性的值来确定存储的参数集数量。可以使用getTuneResult来检索实际设置。

请参阅参考手册中的参数调优部分，了解调优工具的详细信息。

Example:

model.tune();
// Get best tuning result
model.getTuneResult(0);

void update()

处理任何待处理的模型修改。

Example:

model.update();

void write(String filename)

此方法是用于将优化数据写入文件的通用入口点。它可以用于写入优化模型、解向量、基向量、起始向量或参数设置。写入的数据类型由文件后缀决定。文件格式在文件格式部分中描述。

请注意，将模型写入文件将处理所有待处理的模型修改。在写入其他模型信息（如解决方案、基础等）时也是如此。

还要注意的是，当你编写一个Gurobi参数文件（PRM）时，所有未设置为默认值的整数或双精度参数都会被保存，但不会将任何字符串参数保存到文件中。

最后，请注意，当IgnoreNames=1时，在写入文件时，变量和约束的名称将被替换为默认名称。

Arguments:

filename – 要写入的文件名。文件类型编码在文件名的后缀中。有效的后缀包括 .mps、.rew、.lp 或 .rlp 用于写入模型本身，.dua 或 .dlp 用于写入对偶化模型（仅限纯 LP），.ilp 用于写入与不可行模型相关的 IIS（参见 GRBModel.computeIIS 获取更多信息），.sol 用于写入由 SolutionNumber 参数选择的解决方案，.mst 用于写入起始向量，.hnt 用于写入提示文件，.bas 用于写入 LP 基础，.prm 用于写入修改后的参数设置，.attr 用于写入模型属性，或 .json 用于以 JSON 格式写入解决方案信息。如果您的系统安装了压缩工具（例如，Windows 上的 7z 或 zip，以及 Linux 或 macOS 上的 gzip、bzip2 或 unzip），则文件可以被压缩，因此还接受 .zip、.gz、.bz2、.7z 或 .xz 等附加后缀。

Example:

model.write("myModel.lp");