gurobipy.Model#

class Model#

Gurobi 模型对象。模型对象上常用的方法包括 optimize（优化模型）、 printStats（打印模型的统计信息）、 printAttr（打印属性的值）和 write（将模型的信息写入文件）。 构建模型时常用的方法包括 addVar （添加一个新变量）、addVars（添加多个新变量）、 addMVar（添加一个 Gurobi 变量的 NumPy ndarray）、 addConstr（添加一个新约束）和 addConstrs （添加多个新约束）。

Model(name='', env=None)#

模型构造函数。

Parameters:

  • name – 新模型的名称。请注意，name 将存储为 ASCII 字符串。因此，像 ‘A\({\rightarrow}\)B’ 这样的名称会产生错误，因为 ‘\({\rightarrow}\)‘ 不能表示为 ASCII 字符。还请注意，强烈不建议使用包含空格的名称，因为它们无法写入 LP 格式文件。

  • env – 创建模型的环境。创建自己的环境（使用Env constructor）可以给你更多的控制权（例如，在特定的计算服务器上解决你的模型）。然而，这可能会使你的程序更加冗长，所以我们建议你使用默认环境，除非你知道你需要控制自己的环境。

Returns:

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

Example:
m = gp.Model("NewModel")
x0 = m.addVar()

env = gp.Env("my.log")
m2 = gp.Model("NewModel2", env)
addConstr(constr, name='')#

向模型添加约束。

此方法接受一个TempConstr作为其第一个参数，并将约束名称作为其可选的第二个参数。您使用运算符重载来创建参数（详见this section）。此方法允许您添加线性约束、矩阵约束、二次约束和一般约束。

Parameters:

  • constr – TempConstr 参数。

  • name – 新约束的名称。请注意，name 将存储为 ASCII 字符串。因此，像 ‘A\({\rightarrow}\)B’ 这样的名称会产生错误，因为 ‘\({\rightarrow}\)‘ 不能表示为 ASCII 字符。还请注意，强烈不建议使用包含空格的名称，因为它们无法写入 LP 格式文件。

Returns:

新的约束对象。这可以是Constr、MConstr、QConstr或MQConstr，具体取决于参数的类型。

Example:
model.addConstr(x + y <= 2.0, "c1")
model.addConstr(x*x + y*y <= 4.0, "qc0")
model.addConstr(x + y + z == [1, 2], "rgc0")
model.addConstr(A @ t >= b)
model.addConstr(z == and_(x, y, w), "gc0")
model.addConstr(z == min_(x, y), "gc1")
model.addConstr((w == 1) >> (x + y <= 1), "ic0")

警告

一个约束只能有一个比较运算符。虽然 1 <= x + y <= 2 看起来像是一个有效的约束，但 addConstr 不会接受它。

addConstrs(generator, name='')#

使用Python生成器表达式向模型添加多个约束。 返回一个包含新创建约束的Gurobi tupledict，这些约束由生成器表达式生成的值索引。

addConstrs的第一个参数是一个Python生成器表达式，这是Python语言的一个特殊功能，允许你遍历一个Python表达式。在这种情况下，Python表达式将是一个Gurobi约束，而生成器表达式提供值以插入该约束。对于生成器表达式的每次迭代，都会向模型添加一个新的Gurobi约束。

举个例子，如果 x 是一个 Gurobi 变量，那么

m.addConstr(x <= 1, name='c0')

将添加一个涉及此变量的单一线性约束。相反，如果 x 是 Gurobi 变量的列表，那么

m.addConstrs((x[i] <= 1 for i in range(4)), name='c')

将向模型添加四个约束。整个第一个参数是一个生成器表达式，其中索引由语句for i in range(4)控制，由此表达式生成的第一个约束将命名为c[0]，并涉及变量x[0]。第二个将命名为c[1]，并涉及变量x[1]。

生成器表达式可以比这复杂得多。它们可以涉及多个变量和条件测试。例如，你可以这样做：

m.addConstrs((x[i,j] == 0 for i in range(4)
                          for j in range(4)
                          if i != j), name='c')

addConstrs 对生成器表达式的一个限制是，每个变量必须始终取标量值（int、float、string，…）。因此，for i in [1, 2.0, 'a', 'bc'] 是可以的，但 for i in [(1, 2), [1, 2, 3]] 则不行。

此方法可用于向模型添加线性约束、二次约束或一般约束。有关可以添加的所有不同约束类型的更多信息，请参阅TempConstr文档。

请注意，如果您提供了name参数，生成器表达式必须用括号括起来。这个要求来自Python语言解释器。

Parameters:

  • generator – 一个生成器表达式，每次迭代都会产生一个约束。

  • name – 新约束的名称模式。给定的名称将通过生成器表达式的索引进行下标，因此如果索引是整数，c 将变为 c[0]，c[1]，等等。请注意，生成的名称将存储为ASCII字符串，因此应避免使用包含非ASCII字符的名称。此外，强烈不建议使用包含空格的名称，因为它们无法写入LP格式文件。

Returns:

一个由Constr对象组成的字典，通过生成器表达式指定的值进行索引。

Example:
model.addConstrs(x.sum(i, '*') <= capacity[i] for i in range(5))
model.addConstrs(x[i] + x[j] <= 1 for i in range(5) for j in range(5))
model.addConstrs(x[i]*x[i] + y[i]*y[i] <= 1 for i in range(5))
model.addConstrs(x.sum(i, '*') == [0, 2] for i in [1, 2, 4])
model.addConstrs(z[i] == max_(x[i], y[i]) for i in range(5))
model.addConstrs((x[i] == 1) >> (y[i] + z[i] <= 5) for i in range(5))

警告

一个约束只能有一个比较运算符。虽然 1 <= x + y <= 2 看起来像是一个有效的约束，但 addConstrs 不会接受它。

addGenConstrMax(resvar, vars, constant=None, name='')#

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

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

你也可以使用max_函数添加一个MAX约束。

Parameters:

  • resvar – (Var) 该变量的值将等于其他变量的最大值。

  • vars – (列表或可迭代的Var) 将对其进行MAX操作的变量。

  • constant – (float, 可选) 包含在MAX操作参数中的常量。

  • name – (字符串, 可选) 新的一般约束的名称。 请注意，name 将存储为 ASCII 字符串。因此，像 ‘A\({\rightarrow}\)B’ 这样的名称会产生 错误，因为 ‘\({\rightarrow}\)‘ 不能表示为 ASCII 字符。还请注意，强烈不建议使用包含空格的名称，因为它们无法写入 LP 格式文件。

Example:
# x5 = max(x1, x3, x4, 2.0)
model.addGenConstrMax(x5, [x1, x3, x4], 2.0, "maxconstr")

# overloaded forms
model.addConstr(x5 == max_([x1, x3, x4], constant=2.0), name="maxconstr")
model.addConstr(x5 == max_(x1, x3, x4, constant=2.0), name="maxconstr")

自版本12.0起已弃用：将tupledict作为vars参数传递已被弃用。 要在td中的所有变量上取最大值，请传递 td.values()。

addGenConstrMin(resvar, vars, constant=None, name='')#

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

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

你也可以使用min_函数添加一个MIN约束。

Parameters:

  • resvar – (Var) 该变量的值将等于其他变量的最小值。

  • vars – (Var的列表或可迭代对象) 将在此变量上取最小值。

  • constant – (float, optional) 包含在MIN操作参数中的常量。

  • name – (字符串, 可选) 新的一般约束的名称。 请注意，name 将存储为 ASCII 字符串。因此，像 ‘A\({\rightarrow}\)B’ 这样的名称会产生 错误，因为 ‘\({\rightarrow}\)‘ 不能表示为 ASCII 字符。还请注意，强烈不建议使用包含空格的名称，因为它们无法写入 LP 格式文件。

Example:
# x5 = min(x1, x3, x4, 2.0)
model.addGenConstrMin(x5, [x1, x3, x4], 2.0, "minconstr")

# overloaded forms
model.addConstr(x5 == min_([x1, x3, x4], constant=2.0), name="minconstr")
model.addConstr(x5 == min_(x1, x3, x4, constant=2.0), name="minconstr")

自版本12.0起已弃用：将tupledict作为vars参数传递已被弃用。 要对td中的所有变量取最小值，请传递 td.values()。

addGenConstrAbs(resvar, argvar, name='')#

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

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

你也可以使用abs_函数添加一个ABS约束。

Parameters:

  • resvar – (Var) 该变量的值将等于参数变量的绝对值。

  • argvar – (Var) 将取其绝对值的变量。

  • name – (字符串, 可选) 新的一般约束的名称。 请注意，name 将存储为 ASCII 字符串。因此，像 ‘A\({\rightarrow}\)B’ 这样的名称会产生 错误，因为 ‘\({\rightarrow}\)‘ 不能表示为 ASCII 字符。还请注意，强烈不建议使用包含空格的名称，因为它们无法写入 LP 格式文件。

Example:
# x5 = abs(x1)
model.addGenConstrAbs(x5, x1, "absconstr")

# overloaded form
model.addConstr(x5 == abs_(x1), name="absconstr")
addGenConstrAnd(resvar, vars, name='')#

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

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

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

你也可以使用and_函数添加一个AND约束。

Parameters:

  • resvar – (Var) 该变量的值将等于其他变量的 AND 连接。

  • vars – (列表或可迭代的 Var) 将对其进行 AND 连接的变量。

  • name – (字符串, 可选) 新的一般约束的名称。 请注意，name 将存储为 ASCII 字符串。因此，像 ‘A\({\rightarrow}\)B’ 这样的名称会产生 错误，因为 ‘\({\rightarrow}\)‘ 不能表示为 ASCII 字符。还请注意，强烈不建议使用包含空格的名称，因为它们无法写入 LP 格式文件。

Example:
# x5 = and(x1, x3, x4)
model.addGenConstrAnd(x5, [x1, x3, x4], "andconstr")

# overloaded forms
model.addConstr(x5 == and_([x1, x3, x4]), "andconstr")
model.addConstr(x5 == and_(x1, x3, x4), "andconstr")

自版本12.0起已弃用：将tupledict作为vars参数传递已被弃用。 要对td中的所有变量进行AND连接，请传递td.values()。

addGenConstrOr(resvar, vars, name='')#

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

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

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

你也可以使用or_函数添加一个OR约束。

Parameters:

  • resvar – (Var) 该变量的值将等于其他变量的OR连接。

  • vars – (列表或可迭代的Var) 将对其进行OR连接的变量。

  • name – (字符串, 可选) 新的一般约束的名称。 请注意，name 将存储为 ASCII 字符串。因此，像 ‘A\({\rightarrow}\)B’ 这样的名称会产生 错误，因为 ‘\({\rightarrow}\)‘ 不能表示为 ASCII 字符。还请注意，强烈不建议使用包含空格的名称，因为它们无法写入 LP 格式文件。

Example:
# x5 = or(x1, x3, x4)
model.addGenConstrOr(x5, [x1, x3, x4], "orconstr")

# overloaded forms
model.addConstr(x5 == or_([x1, x3, x4]), "orconstr")
model.addConstr(x5 == or_(x1, x3, x4), "orconstr")

自版本12.0起已弃用：将tupledict作为vars参数传递已被弃用。 要对tupledict td中的所有变量进行OR连接， 请传递td.values()。

addGenConstrNorm(resvar, vars, which, name='')#

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

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

Parameters:

  • resvar – (Var) 该变量的值将等于其他变量的向量范数。

  • vars – (列表或可迭代的Var，或一维MVar) 将计算向量范数的变量。注意，这些变量不能包含重复项。

  • which – (float) 使用哪种范数。选项为0、1、2，以及任何大于或等于GRB.INFINITY的值。

  • name – (字符串, 可选) 新的一般约束的名称。 请注意，name 将存储为 ASCII 字符串。因此，像 ‘A\({\rightarrow}\)B’ 这样的名称会产生 错误，因为 ‘\({\rightarrow}\)‘ 不能表示为 ASCII 字符。还请注意，强烈不建议使用包含空格的名称，因为它们无法写入 LP 格式文件。

Example:
# x5 = 2-norm(x1, x3, x4)
model.addGenConstrNorm(x5, [x1, x3, x4], 2.0, "normconstr")

自版本12.0起已弃用：将tupledict作为vars参数传递已被弃用。 要对td中的所有变量取NORM，请传递 td.values()。

addGenConstrIndicator(binvar, binval, lhs, sense=None, rhs=None, 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\) 将被强制为二进制，无论它是如何创建的。

您还可以使用特殊的重载语法添加INDICATOR约束。详情请参见以下示例。

可以通过使用矩阵友好的建模对象在单个addGenConstrIndicator调用中添加多个INDICATOR约束。在这种情况下，将返回一个MGenConstr对象。输入参数遵循NumPy的广播规则，但有一些限制：

  • binvar 无法在 binval 上进行广播，并且

  • 由(lhs, sense, rhs)定义的线性约束不能在指示变量上进行广播。

这意味着通过广播，您可以使用单个指示变量来控制是否应保持多个线性约束。我们建议您参考NumPy文档以获取有关广播行为的更多信息。

Parameters:

  • binvar – (Var 或 MVar) 二进制指示变量或矩阵变量。

  • binval – (布尔值或ndarray) 用于强制满足线性约束的二进制指示变量的值。如果binvar是一个MVar，则可以提供不同值的ndarray。

  • lhs – (float, Var, LinExpr, MVar, MLinExpr, 或 TempConstr) 由指示器触发的线性约束的左侧表达式。可以是一个常数、Var、LinExpr、 MVar 或 MLinExpr。或者，可以使用临时约束对象来定义由指示器触发的线性约束。 临时约束对象是通过重载的比较运算符创建的。有关更多信息，请参见 TempConstr。在这种情况下，“sense”和“rhs”参数必须保持其默认值 None。

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

  • rhs – (浮点数或ndarray) 线性约束的右侧值。如果lhs是MVar或MLinExpr，则可以提供为不同值的ndarray。

  • name – (字符串, 可选) 新的一般约束的名称。 请注意，name 将存储为 ASCII 字符串。因此，像 ‘A\({\rightarrow}\)B’ 这样的名称会产生 错误，因为 ‘\({\rightarrow}\)‘ 不能表示为 ASCII 字符。还请注意，强烈不建议使用包含空格的名称，因为它们无法写入 LP 格式文件。

Returns:

新的通用约束对象。根据输入参数的类型，这可以是 GenConstr 或 MGenConstr。

Example:
# x7 = 1 -> x1 + 2 x3 + x4 = 1
model.addGenConstrIndicator(x7, True, x1 + 2*x3 + x4, GRB.EQUAL, 1.0)

# alternative form
model.addGenConstrIndicator(x7, True, x1 + 2*x3 + x4 == 1.0)

# overloaded form
model.addConstr((x7 == 1) >> (x1 + 2*x3 + x4 == 1.0))

# Matrix-friendly form where Z is an MVar. Creates multiple
# indicator constraints, each specifying
#   z_i = 1 -> sum a_ij x_j = b_i.
model.addGenConstrIndicator(z, 1.0, A @ x == b)

# Matrix-friendly form where z is an Var. Creates multiple
# indicator constraints, each specifying
#   z = 1 -> sum a_ij x_j = b_i
# (the indicator variable is broadcasted).
model.addGenConstrIndicator(z, 1.0, A @ x == b)
addGenConstrPWL(xvar, yvar, xpts, ypts, name='')#

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

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

Parameters:

  • xvar – (Var) \(x\) 变量。

  • yvar – (Var) \(y\) 变量。

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

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

  • name – (字符串, 可选) 新的一般约束的名称。

Returns:

新的通用约束。

Example:
gc = model.addGenConstrPWL(x, y, [0, 1, 2], [1.5, 0, 3], "myPWLConstr")
addGenConstrPoly(xvar, yvar, p, name='', 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，可以将函数视为非线性约束。有关详细信息，请参阅一般约束讨论。

Parameters:

  • xvar – (Var) \(x\) 变量。

  • yvar – (Var) \(y\) 变量。

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

  • name – (字符串, 可选) 新的一般约束的名称。

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

Returns:

新的通用约束。

Example:
# y = 2 x^3 + 1.5 x^2 + 1
gc = model.addGenConstrPoly(x, y, [2, 1.5, 0, 1])
addGenConstrExp(xvar, yvar, name='', options='')#

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

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

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

Parameters:

  • xvar – (Var) \(x\) 变量。

  • yvar – (Var) \(y\) 变量。

  • name – (字符串, 可选) 新的一般约束的名称。

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

Returns:

新的通用约束。

Example:
# y = exp(x)
gc = model.addGenConstrExp(x, y)
addGenConstrExpA(xvar, yvar, a, name='', options='')#

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

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

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

Parameters:

  • xvar – (Var) \(x\) 变量。

  • yvar – (Var) \(y\) 变量。

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

  • name – (字符串, 可选) 新的一般约束的名称。

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

Returns:

新的通用约束。

Example:
# y = 3^x
gc = model.addGenConstrExpA(x, y, 3.0, "expa")
addGenConstrLog(xvar, yvar, name='', options='')#

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

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

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

Parameters:

  • xvar – (Var) \(x\) 变量。

  • yvar – (Var) \(y\) 变量。

  • name – (字符串, 可选) 新的一般约束的名称。

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

Returns:

新的通用约束。

Example:
# y = ln(x)
gc = model.addGenConstrLog(x, y)
addGenConstrLogA(xvar, yvar, a, name='', options='')#

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

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

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

Parameters:

  • xvar – (Var) \(x\) 变量。

  • yvar – (Var) \(y\) 变量。

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

  • name – (字符串, 可选) 新的一般约束的名称。

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

Returns:

新的通用约束。

Example:
# y = log10(x)
gc = model.addGenConstrLogA(x, y, 10.0, "log10", "FuncPieces=-1 FuncPieceError=1e-5")
addGenConstrLogistic(xvar, yvar, name='', options='')#

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

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

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

Parameters:

  • xvar – (Var) \(x\) 变量。

  • yvar – (Var) \(y\) 变量。

  • name – (字符串, 可选) 新的一般约束的名称。

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

Returns:

新的通用约束。

Example:
# y = 1 / (1 + exp(-x))
gc = model.addGenConstrLogistic(x, y)
addGenConstrPow(xvar, yvar, a, name='', options='')#

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

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

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

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

Parameters:

  • xvar – (Var) \(x\) 变量。

  • yvar – (Var) \(y\) 变量。

  • a – (float) 函数的指数。

  • name – (字符串, 可选) 新的一般约束的名称。

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

Returns:

新的通用约束。

Example:
# y = x^3.5
gc = model.addGenConstrPow(x, y, 3.5, "gf", "FuncPieces=1000")
addGenConstrSin(xvar, yvar, name='', options='')#

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

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

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

Parameters:

  • xvar – (Var) \(x\) 变量。

  • yvar – (Var) \(y\) 变量。

  • name – (字符串, 可选) 新的一般约束的名称。

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

Returns:

新的通用约束。

Example:
# y = sin(x)
gc = model.addGenConstrSin(x, y)
addGenConstrCos(xvar, yvar, name='', options='')#

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

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

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

Parameters:

  • xvar – (Var) \(x\) 变量。

  • yvar – (Var) \(y\) 变量。

  • name – (字符串, 可选) 新的一般约束的名称。

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

Returns:

新的通用约束。

Example:
# y = cos(x)
gc = model.addGenConstrCos(x, y)
addGenConstrTan(xvar, yvar, name='', options='')#

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

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

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

Parameters:

  • xvar – (Var) \(x\) 变量。

  • yvar – (Var) \(y\) 变量。

  • name – (字符串, 可选) 新的一般约束的名称。

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

Returns:

新的通用约束。

Example:
# y = tan(x)
gc = model.addGenConstrTan(x, y)
addGenConstrNL(resvar, expr, name='')#

向模型添加一个类型为GRB.GENCONSTR_NL的新通用约束。非线性约束的形式为\(y = f(x)\)，其中多元表达式\(f(x)\)由NLExpr对象给出。在这种形式中，\(y\)被称为约束的结果变量。

Parameters:

  • resvar (Var) – 约束的结果变量。

  • expr – 一个表达式对象。将向模型添加一个非线性约束，指定resvar等于expr的值。

  • name – (字符串, 可选) 新约束的名称。请注意，name 将存储为 ASCII 字符串。因此，像 ‘A\({\rightarrow}\)B’ 这样的名称会产生错误，因为 ‘\({\rightarrow}\)‘ 不能表示为 ASCII 字符。还请注意，强烈不建议使用包含空格的名称，因为它们无法写入 LP 格式文件。

Returns:

新的一般约束

Return type:

GenConstr

Example:
from gurobipy import nlfunc

...

x1 = model.addVar()
x2 = model.addVar()
y = model.addVar()
z = model.addVar()

genconstr_sin = model.addGenConstrNL(
    y,
    nlfunc.sin(x1 + x2),
    name="nl_constraint_sin",
)

genconstr_div = model.addGenConstrNL(
    z, x1 / x2, name="nl_constraint_div"
)
addGenConstrNLAdv(resvar, opcode, data, parent, name='')#

向模型添加一个类型为GRB.GENCONSTR_NL的新通用约束。非线性约束的形式为\(y = f(x)\)，其中多元表达式\(f(x)\)由NLExpr对象给出。在这种形式中，\(y\)被称为约束的结果变量。

这是一个高级方法，要求表达式 \(f(x)\) 被编码为在三个列表 opcode、data 和 parent 中指定的表达式树。大多数用户 应该使用 addGenConstrNL 或 addConstr 来 向模型添加非线性约束。

Parameters:

  • resvar (Var) – NL约束的结果变量

  • opcode (列表 of int) – 非线性操作码的列表

  • data (列表 of float or Var) – 一个与 opcode 长度相同的列表。对应于 OPCODE_CONSTANT 的条目应包含常量的值。对应于 OPCODE_VARIABLE 的条目应包含一个 Var 对象。对应于任何其他操作码的条目应包含 -1.0。

  • parent (list of int) – 父索引，指定表达式树的拓扑结构。

  • name – (string, optional) 新的一般约束的名称。注意 name 将存储为 ASCII 字符串。因此，像 ‘A\({\rightarrow}\)B’ 这样的名称会产生错误，因为 ‘\({\rightarrow}\)‘ 不能表示为 ASCII 字符。还请注意，强烈不建议使用包含空格的名称，因为它们无法写入 LP 格式文件。

Returns:

新的一般约束

Return type:

GenConstr

Example:
x = model.addVar()
y = model.addVar()

# This models y = log(x + 1)
genconstr = model.addGenConstrNLAdv(
    y,
    [GRB.OPCODE_LOG, GRB.OPCODE_PLUS, GRB.OPCODE_VARIABLE, GRB.OPCODE_CONSTANT],
    [-1, -1, x, 1],
    [-1, 0, 1, 1],
    name="nl_constraint",
)
addLConstr(lhs, sense=None, rhs=None, name='')#

向模型添加线性约束。此方法比addConstr()更快（对于非常稀疏的约束，速度可提高多达50%），但只能用于添加线性约束。

请注意，此方法还接受一个TempConstr作为其第一个参数（名称作为第二个参数）。这允许您使用运算符重载来创建约束。有关更多信息，请参见TempConstr。

Parameters:

  • lhs – 新约束的左侧。可以是一个常数、一个 Var、一个 LinExpr，或者一个 TempConstr （而 TempConstr 只能是线性形式）。

  • sense – 新约束的意义 (GRB.LESS_EQUAL, GRB.EQUAL, 或 GRB.GREATER_EQUAL).

  • rhs – 新约束的右侧。可以是一个常数、一个Var，或者一个LinExpr。

  • name – 新约束的名称。请注意，name 将存储为 ASCII 字符串。因此，像 ‘A\({\rightarrow}\)B’ 这样的名称会产生错误，因为 ‘\({\rightarrow}\)‘ 不能表示为 ASCII 字符。还请注意，强烈不建议使用包含空格的名称，因为它们无法写入 LP 格式文件。

Returns:

新的约束对象。

Example:
model.addLConstr(x + 2*y, GRB.EQUAL, 3*z, "c0")
model.addLConstr(x + y <= 2.0, "c1")
model.addLConstr(LinExpr([1.0,1.0], [x,y]), GRB.LESS_EQUAL, 1)
addMConstr(A, x, sense, b, name='')#

使用矩阵语义向模型添加一组线性约束。添加的约束是\(A x = b\)（除了约束方向由sense参数决定）。A参数必须是NumPy密集ndarray或SciPy稀疏矩阵。

请注意，您通常会使用重载运算符来构建和添加使用矩阵语义的约束。重载的@运算符可用于构建linear matrix expression，然后可以与重载的比较运算符一起使用来构建TempConstr对象。然后可以将其传递给addConstr。

Parameters:

  • A – 约束矩阵 - 一个 NumPy 2-D 密集 ndarray 或 SciPy 稀疏矩阵。

  • x – 决策变量。参数可以是MVar对象， Var对象的列表，或None（None使用模型中的所有变量）。参数的长度必须与A的第二维度的大小匹配。

  • sense – 约束条件的方向，以NumPy一维数组或单个字符形式提供。有效值为'<'、'>'或'='。数组的长度必须等于A的第一维的大小。单个字符将被提升为适当长度的数组。

  • b – 右侧向量，存储为NumPy一维ndarray。数组的长度必须等于A的第一维的大小。

  • name – 新约束的名称。如果提供的是单个字符串，它将被矩阵中每个约束的索引下标化。如果提供的是字符串列表或NumPy一维ndarray，则其长度必须等于A的第一维大小，并且第\(i^{th}\)个约束的名称将由name[i]给出。

Returns:

MConstr 对象。

Example:
A = np.full((5, 10), 1)
x = model.addMVar(10)
b = np.full(5, 1)

model.addMConstr(A, x, '=', b)
addMQConstr(Q, c, sense, rhs, xQ_L=None, xQ_R=None, xc=None, name='')#

使用矩阵语义向模型添加一个二次约束。添加的约束是 \(x_{Q_L}' Q x_{Q_R} + c' x_c = \mbox{rhs}\)（除了约束的方向由 sense 参数决定）。Q 参数必须是一个 NumPy ndarray 或 SciPy 稀疏矩阵。

请注意，您通常会使用重载运算符来构建和添加使用矩阵语义的约束。重载的@运算符可用于构建线性 矩阵 表达式或二次 矩阵 表达式。然后可以使用重载的比较运算符来构建TempConstr对象，然后将其传递给addConstr。

Parameters:

  • Q – 二次约束矩阵 - 一个 NumPy 2-D ndarray 或 SciPy 稀疏矩阵。

  • c – 线性约束向量 - 一个 NumPy 1-D ndarray。如果没有线性项，可以为 None。

  • sense – 约束条件。有效值为 '<', '>', 或 '='。

  • rhs – 右侧值。

  • xQ_L – 二次项的决策变量；Q的左乘数。参数可以是MVar对象、Var对象的列表或None（None使用模型中的所有变量）。参数的长度必须与Q的第一维度的大小匹配。

  • xQ_R – 二次项的决策变量；Q的右乘数。参数的长度必须与Q的第二维度的大小匹配。

  • xc – 线性项的决策变量。参数可以是 MVar 对象、Var 对象的列表，或 None （None 使用模型中的所有变量）。参数的长度 必须与 c 的长度匹配。

  • name – 新约束的名称。

Returns:

QConstr 对象。

Example:
Q = np.full((2, 3), 1)
xL = model.addMVar(2)
xR = model.addMVar(3)
model.addMQConstr(Q, None, '<', 1.0, xL, xR)
addMVar(shape, lb=0.0, ub=float('inf'), obj=0.0, vtype=GRB.CONTINUOUS, name='')#

向模型添加一个MVar对象。MVar类似于Gurobi决策变量的NumPy ndarray。MVar可以具有任意数量的维度，由shape参数定义。

你可以使用MVar对象进行算术运算来创建 linear matrix expressions或 二次 矩阵 表达式，然后可以用它们来构建线性或二次目标或约束。

返回的MVar对象支持标准的NumPy索引和切片。大小为\(1\)的MVar可以在所有接受Var对象的地方传递。

Parameters:

  • shape – 一个整数或整数元组。数组的shape。

  • lb – (可选) 新变量的下界。

  • ub – (可选) 新变量的上界。

  • obj – （可选）新变量的目标系数。

  • vtype – （可选）新变量的变量类型。

  • name – （可选）新变量的名称。给定的名称将通过生成器表达式的索引进行下标，因此如果索引是整数，c 将变为 c[0]，c[1] 等。请注意，生成的名称将存储为ASCII字符串，因此应避免使用包含非ASCII字符的名称。此外，强烈不建议使用包含空格的名称，因为它们无法写入LP格式文件。

lb、ub、obj 和 vtype 参数的值可以是标量、列表或 ndarrays。它们的形状应与新的 MVar 对象的形状匹配，或者可以广播到给定的形状。

name 参数可以是一个单独的字符串，用作一个共同的基础名称，该名称将通过其索引为每个变量添加后缀，或者是一个与新的 MVar 对象形状匹配的字符串 ndarray。

Returns:

新的 MVar 对象。

Example:
# Add a 4-by-2 matrix binary variable
x = model.addMVar((4,2), vtype=GRB.BINARY)
# Add a vector of three variables with non-default lower bounds
y = model.addMVar((3,), lb=[-1, -2, -1])
addQConstr(lhs, sense=None, rhs=None, name='')#

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

重要

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

Parameters:

  • lhs – 新二次约束的左侧。可以是一个常数、一个Var、一个LinExpr，或者一个QuadExpr。

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

  • rhs – 新二次约束的右侧。可以是一个常数、一个Var、一个LinExpr，或者一个QuadExpr。

  • name – 新约束的名称。请注意，name 将存储为 ASCII 字符串。因此，像 ‘A\({\rightarrow}\)B’ 这样的名称会产生错误，因为 ‘\({\rightarrow}\)‘ 不能表示为 ASCII 字符。还请注意，强烈不建议使用包含空格的名称，因为它们无法写入 LP 格式文件。

Returns:

新的二次约束对象。

Example:
model.addQConstr(x*x + y*y, GRB.LESS_EQUAL, z*z, "c0")
model.addQConstr(x*x + y*y <= 2.0, "c1")
addRange(expr, lower, upper, 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}\]
Parameters:

  • expr – 新范围约束的线性表达式。可以是 Var 或 LinExpr。

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

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

  • name – 新约束的名称。请注意，name 将存储为 ASCII 字符串。因此，像 ‘A\({\rightarrow}\)B’ 这样的名称会产生错误，因为 ‘\({\rightarrow}\)‘ 不能表示为 ASCII 字符。还请注意，强烈不建议使用包含空格的名称，因为它们无法写入 LP 格式文件。

Returns:

新的约束对象。

Example:
# 1 <= x + y <= 2
model.addRange(x + y, 1.0, 2.0, "range0")

# overloaded forms
model.addConstr(x + y == [1.0, 2.0], name="range0")
addSOS(type, vars, wts=None)#

向模型添加一个SOS约束。有关SOS约束的详细信息，请参阅 本节。

Parameters:

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

  • vars – 参与SOS约束的变量列表。

  • weights – （可选）SOS约束中变量的权重。默认权重为1, 2, …

Returns:

新的 SOS 对象。

Example:
model.addSOS(GRB.SOS_TYPE1, [x, y, z], [1, 2, 4])
addVar(lb=0.0, ub=float('inf'), obj=0.0, vtype=GRB.CONTINUOUS, name='', column=None)#

向模型添加一个决策变量。

Parameters:

  • lb – （可选）新变量的下限。

  • ub – （可选）新变量的上限。

  • obj – （可选）新变量的目标系数。

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

  • name – （可选）新变量的名称。请注意，name 将存储为 ASCII 字符串。因此，像 ‘A\({\rightarrow}\)B’ 这样的名称会产生错误，因为 ‘\({\rightarrow}\)‘ 不能表示为 ASCII 字符。还请注意，强烈不建议使用包含空格的名称，因为它们无法写入 LP 格式文件。

  • column – （可选）表示新变量参与的约束集及其相关系数的列对象。

Returns:

新变量对象。

Example:
x = model.addVar()                                     # all default arguments
y = model.addVar(vtype=GRB.INTEGER, obj=1.0, name="y") # arguments by name
z = model.addVar(0.0, 1.0, 1.0, GRB.BINARY, "z")       # arguments by position
addVars(*indices, lb=0.0, ub=float('inf'), obj=0.0, vtype=GRB.CONTINUOUS, name='')#

向模型添加多个决策变量。

返回一个包含新创建变量的Gurobi tupledict对象。tupledict的键是从indices参数派生的。此方法的参数可以采用几种不同的形式，现在将进行描述。

第一个参数提供了将用作键的索引，用于访问返回的tupledict中的变量。在最简单的版本中，您可以指定一个或多个整数值，此方法将创建相当于多维数组的变量。例如，x = model.addVars(2, 3)将创建六个变量，可以通过x[0,0]、x[0,1]、x[0,2]、x[1,0]、x[1,1]和x[1,2]访问。

在更复杂的版本中，您可以指定任意不可变对象的列表，此方法将为这些列表的笛卡尔积的每个成员创建变量。例如， x = model.addVars([3, 7], ['a', 'b', 'c']) 将创建六个变量，访问方式为 x[3,'a'], x[7,'c'], 等等。

你也可以提供自己的元组列表作为索引。例如， x = model.addVars([(3,'a'), (3,'b'), (7,'b'), (7,'c')]) 将以与前面的示例相同的方式访问（x[3,'a']， x[7,'c']，等等），只是并非所有组合都会存在。 这通常是处理稀疏索引的方式。

请注意，虽然索引可以作为多个对象列表或元组列表提供，但特定索引的成员值必须始终是标量（int、float、string，…）。例如，x = model.addVars([(1, 3), 7], ['a']) 是不允许的，因为第一个成员的第一个参数将是 (1, 3)。同样，x = model.addVars([((1, 3),'a'), (7,'a')]) 也是不允许的。

命名参数（lb、obj等）可以采取多种形式。如果你提供一个标量值（或使用默认值），那么每个变量都将使用该值。因此，例如，lb=1.0将为每个创建的变量提供一个1.0的下界。请注意，命名参数的标量值具有特殊含义，将单独讨论。

你也可以提供一个Python dict 作为参数。在这种情况下， 每个变量的值将从字典中提取，使用 索引参数来构建键。例如，如果由该方法创建的变量 被索引为 x[i,j]，那么为参数提供的 dict 应该为每个可能的 (i,j) 值都有一个条目。

最后，如果你的indices参数是一个单独的列表，你可以为命名参数提供一个相同长度的Pythonlist。对于每个变量，它将从列表中的相应位置提取值。

如前所述，name 参数是特殊的。如果你为名称提供一个标量参数，该参数将被转换为具有与相关变量的索引对应的下标。例如，如果你执行 x = model.addVars(2,3,name="x")，变量将获得名称 x[0,0], x[0,1] 等。

Parameters:

  • indices – 用于访问新变量的索引。

  • lb – (可选) 新变量的下界。

  • ub – (可选) 新变量的上界。

  • obj – （可选）新变量的目标系数。

  • vtype – （可选）新变量的变量类型。

  • name – （可选）新变量的名称。给定的名称将通过生成器表达式的索引进行下标，因此如果索引是整数，c 将变为 c[0]，c[1] 等。请注意，生成的名称将存储为ASCII字符串，因此应避免使用包含非ASCII字符的名称。此外，强烈不建议使用包含空格的名称，因为它们无法写入LP格式文件。

Returns:

新的tupledict对象，包含作为值的新变量，使用提供的索引作为键。

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

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

# variables with predetermined names
z = model.addVars(3, name=["a","b","c"])
cbCut(lhs, sense, rhs)#

在回调函数中向MIP模型添加一个新的切割平面。 请注意，此方法只能在回调函数的where值等于GRB.Callback.MIPNODE时调用（更多信息请参见回调代码部分）。

切割平面可以在分支切割树的任何节点添加。 然而，应该谨慎添加，因为它们会增加在每个节点求解的松弛模型的大小，并可能显著降低节点处理速度。

切割平面通常用于切断当前的松弛解。要检索当前节点的松弛解，您应首先调用cbGetNodeRel。

在添加自己的切割时，您应考虑将参数预粉碎设置为值1。此设置会关闭一些预求解缩减，这些缩减有时会阻止您的切割应用于预求解模型（这会导致您的切割被静默忽略）。

一个非常重要的注意事项：你应该只添加由模型中的约束所暗示的切割。如果你切断了根据原始模型约束是可行的整数解，你很可能会得到MIP问题的错误解。

请注意，此方法还接受TempConstr作为其第一个参数。这允许您使用运算符重载来创建约束。有关更多信息，请参阅TempConstr。

Parameters:

  • lhs – 新切割的左侧。可以是一个常数、一个Var，或者一个LinExpr。

  • sense – 新切割的意义（GRB.LESS_EQUAL, GRB.EQUAL, 或 GRB.GREATER_EQUAL）。

  • rhs – 新约束的右侧。可以是一个常数、一个Var，或者一个LinExpr。

Example:
def mycallback(model, where):
  if where == GRB.Callback.MIPNODE:
    status = model.cbGet(GRB.Callback.MIPNODE_STATUS)
    if status == GRB.OPTIMAL:
      rel = model.cbGetNodeRel([model._vars[0], model._vars[1]])
      if rel[0] + rel[1] > 1.1:
        model.cbCut(model._vars[0] + model._vars[1] <= 1)

model._vars = model.getVars()
model.optimize(mycallback)
cbGet(what)#

从用户回调中查询优化器。

Parameters:

what – 表示回调请求的信息类型的整数代码。有效代码集取决于传递给用户回调函数的where值。请参考回调代码部分以获取可能的where和what值列表。

Example:
def mycallback(model, where):
  if where == GRB.Callback.SIMPLEX:
    print(model.cbGet(GRB.Callback.SPX_OBJVAL))

model.optimize(mycallback)
cbGetNodeRel(vars)#

从当前节点的节点松弛解中检索值。 仅在回调函数的where值等于 GRB.Callback.MIPNODE，且GRB.Callback.MIPNODE_STATUS等于 GRB.OPTIMAL时可用（更多信息请参见回调代码 部分）。

请注意，在节点处检索到的松弛解不一定对用户模型是可行的。

Parameters:

vars – 需要获取松弛值的变量。可以是一个变量、矩阵变量、变量或矩阵变量的列表，或者变量的字典。

Returns:

当前节点中指定变量的节点松弛值。格式将取决于输入参数（标量、ndarray、值或ndarrays的列表，或字典）。

Example:
def mycallback(model, where):
  if where == GRB.Callback.MIPNODE:
    status = model.cbGet(GRB.Callback.MIPNODE_STATUS)
    if status == GRB.OPTIMAL:
      print(model.cbGetNodeRel(model._vars))

model._vars = model.getVars()
model.optimize(mycallback)
cbGetSolution(vars)#

从新的MIP解决方案中检索值。请注意，此方法只能在回调函数上的where值等于GRB.Callback.MIPSOL或GRB.Callback.MULTIOBJ时调用（更多信息请参见回调代码部分）。

Parameters:

vars – 需要求解的变量。可以是一个变量、矩阵变量、变量或矩阵变量的列表，或者变量的字典。

Returns:

解决方案中指定变量的值。格式将取决于输入参数（标量、ndarray、值或ndarrays的列表，或字典）。

Example:
def mycallback(model, where):
  if where == GRB.Callback.MIPSOL:
    print(model.cbGetSolution(model._vars))

model._vars = model.getVars()
model.optimize(mycallback)
cbLazy(lhs, sense, rhs)#

在回调函数中向MIP模型添加一个新的惰性约束。请注意，此方法只能在回调函数的where值为GRB.Callback.MIPNODE或GRB.Callback.MIPSOL时调用（更多信息请参见回调代码部分）。

惰性约束通常用于当MIP模型的完整约束集太大而无法显式表示时。通过仅包含在分支切割搜索期间找到的解决方案实际违反的约束，有时可以在仅添加完整约束集的一小部分的情况下找到经过验证的最优解。

通常，您会通过首先查询当前节点解决方案（通过从GRB.Callback.MIPSOL回调中调用cbGetSolution，或从GRB.Callback.MIPNODE回调中调用cbGetNodeRel），然后调用cbLazy()来添加一个约束以切断该解决方案。Gurobi保证您将有机会切断任何原本会被视为可行的解决方案。

MIP 解决方案可能在 MIP 节点之外生成。因此，当回调函数中的 where 值等于 GRB.Callback.MIPNODE 时，生成惰性约束是可选的。为了避免这种情况，我们建议始终检查 where 值是否等于 GRB.Callback.MIPSOL。

您的回调函数应准备好切断违反任何惰性约束的解决方案，包括那些已经添加的约束。节点解决方案通常会尊重先前添加的惰性约束，但并非总是如此。

请注意，如果您想使用惰性约束，必须设置LazyConstraints参数。

请注意，此方法还接受TempConstr作为其第一个参数。这允许您使用运算符重载来创建约束。有关更多信息，请参阅TempConstr。

Parameters:

  • lhs – 新惰性约束的左侧。可以是一个常数、一个Var，或者一个LinExpr。

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

  • rhs – 新惰性约束的右侧。可以是一个常数、一个Var，或者一个LinExpr。

Example:
def mycallback(model, where):
  if where == GRB.Callback.MIPSOL:
    sol = model.cbGetSolution([model._vars[0], model._vars[1]])
    if sol[0] + sol[1] > 1.1:
      model.cbLazy(model._vars[0] + model._vars[1] <= 1)

model._vars = model.getVars()
model.optimize(mycallback)
cbProceed()#

生成一个请求以继续计算的下一个阶段。此例程可以从任何回调中调用。请注意，请求仅在算法的几个阶段被接受，并且不会立即执行。

在当前Gurobi版本中，此回调允许您从NoRel启发式算法过渡到标准MIP搜索。您可以使用回调中的MIP_PHASE、MIPNODE_PHASE或MIPSOL_PHASE查询来确定当前算法阶段。

Example:
def mycallback(model, where):
  if where == GRB.Callback.MIPSOL:
    phase = model.cbGet(GRB.Callback.MIPSOL_PHASE)
    obj = model.cbGet(GRB.Callback.MIPSOL_OBJ)
    if phase == GRB.PHASE_MIP_NOREL and obj < target_obj:
      model.cbProceed()

model.optimize(mycallback)
cbSetParam(paramname, newvalue)#

允许在确定性回调期间修改可设置的回调参数。

也就是说，当where的值为GRB.Callback.PRESOLVED、 GRB.Callback.SIMPLEX、GRB.Callback.MIP、GRB.Callback.MIPSOL、 GRB.Callback.MIPNODE、GRB.Callback.BARRIER或GRB.Callback.MULTIOBJ时（更多信息请参见 回调代码部分）

在远程服务器的情况下，从回调函数内部更改参数可能不会立即生效。

Parameters:

  • paramname – 包含您想要修改的参数名称的字符串。

  • newvalue – 参数的期望新值。

Example:
def mycallback(model, where):
  if where == GRB.Callback.MIPNODE:
     model.cbSetParam("TimeLimit", 10)

model.optimize(mycallback)
cbSetSolution(vars, solution)#

导入启发式解决方案的值。仅在回调函数中的where值等于GRB.Callback.MIP、GRB.Callback.MIPNODE或GRB.Callback.MIPSOL时可用（更多信息请参见回调代码部分）。

当您从回调中指定启发式解决方案时，变量最初会取未定义的值。您应该使用此方法来指定变量值。您可以从一次回调调用中多次调用cbSetSolution来为多组变量指定值。回调之后，如果已为任何变量指定了值，Gurobi优化器将尝试从指定的值计算可行解，可能会为未定义值的变量填充值。您还可以选择在回调函数中调用cbUseSolution，以尝试立即从指定的值计算可行解。

在计算服务器环境中，出于性能考虑，通过cbSetSolution发送的解决方案不一定立即由计算服务器处理。它们可能在客户端回调发送后稍晚一些出现在解决过程中。在极端情况下，甚至可能计算服务器优化作业在处理用户解决方案之前就终止了。

Parameters:

  • vars – 正在设置值的变量。这可以是一个变量列表或单个变量。

  • solution – 新解决方案中指定变量的期望值。

Example:
def mycallback(model, where):
  if where == GRB.Callback.MIPNODE:
    model.cbSetSolution(vars, newsolution)

model.optimize(mycallback)
cbStopOneMultiObj(objcnt)#

在多目标MIP问题中，中断其中一个优化步骤的优化过程，而不停止分层优化过程。仅适用于多目标MIP模型，并且当where成员变量不等于GRB.Callback.MULTIOBJ时（有关更多信息，请参见回调代码部分）。

通常，您会通过查询最后完成的多目标优化步骤的数量来停止多目标优化步骤，并使用该数量来停止当前步骤并继续下一个层次目标（如果有的话），如下例所示：

import time

def mycallback(model, where):
  if where == GRB.Callback.MULTIOBJ:
    # get current objective number
    model._objcnt = model.cbGet(GRB.Callback.MULTIOBJ_OBJCNT)

    # reset start time to current time
    model._starttime = time.time()

  # See if we want to stop current multiobjective step
  else if time.time() - model._starttime > 1000:  # or solution is good enough
    # stop only this optimization step
    model.cbStopOneMultiObj(model._objcnt)

model._objcnt = 0
model._starttime = time.time()
model.optimize(mycallback)

您应该参考 多目标部分，了解如何指定多个目标函数并控制它们之间的权衡。

Parameters:

objnum – 多目标优化步骤的编号，用于中断。对于本地运行的进程，此参数可以具有特殊值-1，表示停止当前步骤。

cbUseSolution()#

一旦你使用cbSetSolution导入了解决方案值， 你可以选择在GRB.Callback.MIPNODE回调中调用cbUseSolution， 以立即使用这些值尝试计算启发式解决方案。或者，你可以在GRB.Callback.MIP或GRB.Callback.MIPSOL回调中调用cbUseSolution， 这将存储解决方案，直到可以在内部处理。

Returns:

从您的解值中获得的解的目标值。如果没有找到改进的解或者方法是从GRB.Callback.MIPNODE以外的回调中调用的，则等于GRB.INFINITY，因为在这些上下文中，解是存储的而不是立即处理的。

Example:
def mycallback(model, where):
  if where == GRB.Callback.MIPNODE:
    model.cbSetSolution(vars, newsolution)
    objval = model.cbUseSolution()

model.optimize(mycallback)
chgCoeff(constr, var, newvalue)#

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

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

Parameters:

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

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

  • newvalue – 系数的期望新值。

Example:
model.chgCoeff(c0, x, 2.0)
close()#

释放与此Model对象关联的所有资源。此方法是dispose的同义词。

调用此方法后，此Model对象不能再使用。

Example:
env = Env()
model = read("misc07.mps", env)
model.optimize()
model.close()
env.close()
computeIIS(callback=None)#

计算一个不可约不一致子系统（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格式文件（参见Model.write）来获取有关IIS计算结果的信息。此文件仅包含原始模型中的IIS。

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

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

Parameters:

callback – 回调函数。回调函数应接受两个参数，model 和 where。在IIS算法运行时，该函数将定期被调用，model 设置为正在优化的模型，where 指示回调是从优化的哪个部分调用的。有关更多信息，请参阅 回调 部分。

Example:
model.computeIIS()
model.write("model.ilp")
copy(targetenv=None)#

复制一个模型。

如果没有参数，副本将与原始模型存在于相同的环境中。提供一个参数可以将现有模型复制到不同的环境中，通常是为了使不同的线程能够在同一模型的不同版本上操作，因为多个线程不能同时在同一个环境中工作。

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

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

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

Parameters:

targetenv – (可选) 将模型复制到的环境。

Returns:

模型的副本。

Example:
model.update() # If you have unstaged changes in the model
copy = model.copy()
discardConcurrentEnvs()#

丢弃模型的并发环境。

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

Example:
env0 = model.getConcurrentEnv(0)
env1 = model.getConcurrentEnv(1)

env0.setParam('Method', 0)
env1.setParam('Method', 1)

model.optimize()

model.discardConcurrentEnvs()
discardMultiobjEnvs()#

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

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

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

Example:
env0 = model.getMultiobjEnv(0)
env1 = model.getMultiobjEnv(1)

env0.setParam('Method', 2)
env1.setParam('Method', 1)

model.optimize()

model.discardMultiobjEnvs()
dispose()#

释放与此Model对象关联的所有资源。此方法是close的同义词。

调用此方法后，此Model对象不能再使用。

Example:
env = gp.Env()
model = gp.read("misc07.mps", env)
model.optimize()
model.dispose()
env.dispose()
feasRelaxS(relaxobjtype, minrelax, vrelax, crelax)#

修改Model对象以创建可行性松弛。注意 你需要对结果调用optimize来计算 实际的松弛解。还要注意这是此方法的简化版本 - 使用feasRelax以获得对执行的松弛的更多控制。

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

如果您指定relaxobjtype=0，可行性松弛的目标是最小化边界和约束违规的总和。

如果您指定relaxobjtype=1，可行性松弛的目标是最小化边界和约束违规的平方和。

如果您指定relaxobjtype=2，可行性松弛的目标是最小化边界和约束违规的总数。

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

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

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

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

Parameters:

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

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

  • vrelax – 表示是否可以放宽变量边界。

  • crelax – 表示是否可以放宽约束。

Returns:

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

Example:
if model.status == GRB.INFEASIBLE:
  model.feasRelaxS(1, False, False, True)
  model.optimize()
feasRelax(relaxobjtype, minrelax, vars, lbpen, ubpen, constrs, rhspen)#

修改Model对象以创建可行性松弛。注意 你需要对结果调用optimize来计算 实际的松弛解。还要注意，这是该方法的一个更复杂的版本 - 使用feasRelaxS来获取简化版本。

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

如果您指定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 必须解决一个优化问题以找到最小可能的松弛，这可能会非常耗时。

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

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

Parameters:

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

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

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

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

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

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

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

Returns:

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

Example:
if model.status == GRB.INFEASIBLE:
  vars = model.getVars()
  ubpen = [1.0]*model.numVars
  model.feasRelax(1, False, vars, None, ubpen, None, None)
  model.optimize()
fixed()#

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

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

注意

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

注意

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

Returns:

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

Example:
fixed = model.fixed()
convertToFixed()#

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

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

注意

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

注意

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

getA()#

查询模型的线性约束矩阵。你需要安装scipy才能使此函数正常工作。

Returns:

矩阵作为scipy.sparse矩阵的CSR格式。

Example:
A     = model.getA()
sense = numpy.array(model.getAttr("Sense",model.getConstrs()))
# extract sub matrices of (in)equality constraints
Aeq = A[sense == '=', :]
Ale = A[sense == '<', :]
Age = A[sense == '>', :]
getAttr(attrname, objs=None)#

查询属性的值。当使用单个参数调用时，它返回模型属性的值。当使用两个参数调用时，它返回包含变量或约束的列表或字典的属性的值。如果使用列表调用，结果是一个列表。如果使用字典调用，结果是一个使用相同键的字典，但填充了请求的属性值。可用属性的完整列表可以在属性部分找到。

如果请求的属性不存在或无法查询，则引发AttributeError。如果Model对象有问题，则引发GurobiError。

Parameters:

  • attrname – 属性的名称。

  • objs – （可选）包含约束或变量的列表或字典

Example:
print(model.numintvars)
print(model.getAttr("numIntVars"))
print(model.getAttr(GRB.Attr.NumIntVars))
print(model.getAttr("X", model.getVars()))
print(model.getAttr("Pi", model.getConstrs()))
getCoeff(constr, var)#

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

Parameters:

  • constr – 请求的约束条件。

  • var – 请求的变量。

Returns:

请求系数的当前值。

Example:
print(model.getCoeff(constr, var))
getCol(var)#

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

Parameters:

var – 感兴趣的变量。

Returns:

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

Example:
print(model.getCol(model.getVars()[0]))
getConcurrentEnv(num)#

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

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

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

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

Parameters:

num – (int) 并发环境数量。

Returns:

模型的并发环境。

Example:
env0 = model.getConcurrentEnv(0)
env1 = model.getConcurrentEnv(1)

env0.setParam('Method', 0)
env1.setParam('Method', 1)

model.optimize()

model.discardConcurrentEnvs()
getConstrByName(name)#

根据名称检索线性约束。如果多个线性约束具有相同的名称，此方法将任意选择一个。

Parameters:

name – 所需约束的名称。

Returns:

具有指定名称的约束。

Example:
c0 = model.getConstrByName("c0")
getConstrs()#

检索模型中所有线性约束的列表。

Returns:

模型中的所有线性约束。

Example:
constrs = model.getConstrs()
c0 = constrs[0]
getGenConstrMax(genconstr)#

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

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

Parameters:

  • genconstr – 感兴趣的一般约束对象。

  • resvar – (Var) MAX约束的结果变量。

  • vars – (Var 列表) MAX 约束的操作数变量。

  • constant – (float) MAX约束的附加常数操作数。

Returns:

一个包含与一般约束相关的数据的元组 (resvar, vars, constant)：

Example:
# x5 = max(x1, x3, x4, 2.0)
maxconstr = model.addGenConstrMax(x5, [x1, x3, x4], 2.0, "maxconstr")
model.update()
(resvar, vars, constant) = model.getGenConstrMax(maxconstr)
getGenConstrMin(genconstr)#

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

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

Parameters:

  • genconstr – 感兴趣的一般约束对象。

  • resvar – (Var) MIN 约束的结果变量。

  • vars – (Var 列表) MIN 约束的操作变量。

  • constant – (float) MIN 约束的附加常数操作数。

Returns:

一个包含与一般约束相关的数据的元组 (resvar, vars, constant)：

Example:
# x5 = min(x1, x3, x4, 2.0)
minconstr = model.addGenConstrMin(x5, [x1, x3, x4], 2.0, "minconstr")
model.update()
(resvar, vars, constant) = model.getGenConstrMin(minconstr)
getGenConstrAbs(genconstr)#

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

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

Parameters:

  • genconstr – 感兴趣的一般约束对象。

  • resvar – (Var) ABS约束的结果变量。

  • argvar – (Var) ABS约束的参数变量。

Returns:

一个包含与一般约束相关的数据的元组 (resvar, argvar)：

Example:
# x5 = abs(x1)
absconstr = model.addGenConstrAbs(x5, x1, "absconstr")
model.update()
(resvar, argvar) = model.getGenConstrAbs(absconstr)
getGenConstrAnd(genconstr)#

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

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

Parameters:

  • genconstr – 感兴趣的一般约束对象。

  • resvar – (Var) AND 约束的结果变量。

  • vars – (Var 列表) AND 约束的操作变量。

Returns:

一个包含与一般约束相关的数据的元组 (resvar, vars)：

Example:
# x5 = and(x1, x3, x4)
andconstr = model.addGenConstrAnd(x5, [x1, x3, x4], "andconstr")
model.update()
(resvar, vars) = model.getGenConstrAnd(andconstr)
getGenConstrOr(genconstr)#

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

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

Parameters:

  • genconstr – 感兴趣的一般约束对象。

  • resvar – (Var) OR 约束的结果变量。

  • vars – (Var 列表) OR 约束的操作变量。

Returns:

一个包含与一般约束相关的数据的元组 (resvar, vars)：

Example:
# x5 = or(x1, x3, x4)
orconstr = model.addGenConstrOr(x5, [x1, x3, x4], "orconstr")
model.update()
(resvar, vars) = model.getGenConstrOr(orconstr)
getGenConstrNorm(genconstr)#

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

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

Parameters:

  • genconstr – 感兴趣的一般约束对象。

  • resvar – (Var) NORM约束的结果变量。

  • vars – (Var 列表) NORM 约束的操作变量。

  • which – (float) 哪种范数（可能的值为0、1、2或GRB.INFINITY）。

Returns:

一个包含与一般约束相关的数据的元组 (resvar, vars, which)：

Example:
# x5 = norm2(x1, x3, x4)
normconstr = model.addGenConstrNorm(x5, [x1, x3, x4], 2.0, "normconstr")
model.update()
(resvar, vars, which) = model.getGenConstrNorm(normconstr)
getGenConstrIndicator(genconstr)#

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

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

Parameters:

  • genconstr – 感兴趣的一般约束对象。

  • binvar – (Var) 指标约束的前件变量。

  • binval – (布尔值) 激活线性约束的前置变量的值。

  • expr – (LinExpr) 包含由指示器触发的约束左侧的LinExpr对象。

  • sense – (char) 由指示器触发的线性约束的意义（例如，GRB.LESS_EQUAL）。

  • rhs – (float) 由指示器触发的线性约束的右侧。

Returns:

一个包含与一般约束相关的数据的元组 (binvar, binval, expr, sense, rhs)：

Example:
# x7 = 1 -> x1 + 2 x3 + x4 = 1
indconstr = model.addGenConstrIndicator(x7, True, x1 + 2*x3 + x4, GRB.EQUAL, 1.0)
model.update()
(binvar, binval, expr, sense, rhs) = model.getGenConstrIndicator(indconstr)
getGenConstrPWL(genconstr)#

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

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

Parameters:

  • genc – 通用约束对象。

  • xvar – (Var) \(x\) 变量。

  • yvar – (Var) \(y\) 变量。

  • xpts – (浮点数列表) 定义分段线性函数的点的 \(x\) 值。

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

Returns:

一个包含与一般约束相关的数据的元组 (xvar, yvar, xpts, ypts)：

Example:
pwlconstr = model.addGenConstrPWL(x, y, [0, 1, 2], [1.5, 0, 3], "myPWLConstr")
model.update()
(xvar, yvar, xpts, ypts) = model.getGenConstrPWL(pwlconstr)
getGenConstrPoly(genconstr)#

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

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

Parameters:

  • genc – 通用约束对象。

  • xvar – (Var) \(x\) 变量。

  • yvar – (Var) \(y\) 变量。

  • p – (浮点数列表) 多项式函数的系数。

Returns:

一个包含与一般约束相关的数据的元组 (xvar, yvar, p)：

Example:
# y = 2 x^3 + 1.5 x^2 + 1
polyconstr = model.addGenConstrPoly(x, y, [2, 1.5, 0, 1])
model.update()
(xvar, yvar, p) = model.getGenConstrPoly(polyconstr)
getGenConstrExp(genconstr)#

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

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

Parameters:

  • genc – 通用约束对象。

  • xvar – (Var) \(x\) 变量。

  • yvar – (Var) \(y\) 变量。

Returns:

一个包含与一般约束相关的数据的元组 (xvar, yvar)：

Example:
# y = exp(x)
expconstr = model.addGenConstrExp(x, y)
model.update()
(xvar, yvar) = model.getGenConstrExp(expconstr)
getGenConstrExpA(genconstr)#

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

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

Parameters:

  • genc – 通用约束对象。

  • xvar – (Var) \(x\) 变量。

  • yvar – (Var) \(y\) 变量。

  • a – (float) 函数的基数。

Returns:

一个包含与一般约束相关的数据的元组 (xvar, yvar, a)：

Example:
# y = 3^x
expaconstr = model.addGenConstrExpA(x, y, 3.0, "expa")
model.update()
(xvar, yvar, a) = model.getGenConstrExpA(expaconstr)
getGenConstrLog(genconstr)#

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

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

Parameters:

  • genc – 通用约束对象。

  • xvar – (Var) \(x\) 变量。

  • yvar – (Var) \(y\) 变量。

Returns:

一个包含与一般约束相关的数据的元组 (xvar, yvar)：

Example:
# y = ln(x)
lnconstr = model.addGenConstrLog(x, y)
model.update()
(xvar, yvar) = model.getGenConstrLog(lnconstr)
getGenConstrLogA(genconstr)#

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

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

Parameters:

  • genc – 通用约束对象。

  • xvar – (Var) \(x\) 变量。

  • yvar – (Var) \(y\) 变量。

  • a – (float) 函数的基数。

Returns:

一个包含与一般约束相关的数据的元组 (xvar, yvar, a)：

Example:
# y = log10(x)
log10constr = model.addGenConstrLogA(x, y, 10.0, "log10")
model.update()
(xvar, yvar, a) = model.getGenConstrLogA(log10constr)
getGenConstrLogistic(genconstr)#

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

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

Parameters:

  • genc – 通用约束对象。

  • xvar – (Var) \(x\) 变量。

  • yvar – (Var) \(y\) 变量。

Returns:

一个包含与一般约束相关的数据的元组 (xvar, yvar)：

Example:
# y = 1 / (1 + exp(-x))
expconstr = model.addGenConstrLogistic(x, y)
model.update()
(xvar, yvar) = model.getGenConstrLogistic(expconstr)
getGenConstrPow(genconstr)#

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

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

Parameters:

  • genc – 通用约束对象。

  • xvar – (Var) \(x\) 变量。

  • yvar – (Var) \(y\) 变量。

  • a – (float) 函数的指数。

Returns:

一个包含与一般约束相关的数据的元组 (xvar, yvar, a)：

Example:
# y = x^3.5
powconstr = model.addGenConstrPow(x, y, 3.5, "gf")
model.update()
(xvar, yvar, a) = model.getGenConstrPow(powconstr)
getGenConstrSin(genconstr)#

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

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

Parameters:

  • genc – 通用约束对象。

  • xvar – (Var) \(x\) 变量。

  • yvar – (Var) \(y\) 变量。

Returns:

一个包含与一般约束相关的数据的元组 (xvar, yvar)：

Example:
# y = sin(x)
sinconstr = model.addGenConstrSin(x, y)
model.update()
(xvar, yvar) = model.getGenConstrSin(sinconstr)
getGenConstrCos(genconstr)#

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

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

Parameters:

  • genc – 通用约束对象。

  • xvar – (Var) \(x\) 变量。

  • yvar – (Var) \(y\) 变量。

Returns:

一个包含与一般约束相关的数据的元组 (xvar, yvar)：

Example:
# y = cos(x)
cosconstr = model.addGenConstrCos(x, y)
model.update()
(xvar, yvar) = model.getGenConstrCos(cosconstr)
getGenConstrTan(genconstr)#

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

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

Parameters:

  • genc – 通用约束对象。

  • xvar – (Var) \(x\) 变量。

  • yvar – (Var) \(y\) 变量。

Returns:

一个包含与一般约束相关的数据的元组 (xvar, yvar)：

Example:
# y = tan(x)
tanconstr = model.addGenConstrTan(x, y)
model.update()
(xvar, yvar) = model.getGenConstrTan(tanconstr)
getGenConstrNL(genconstr)#

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

Parameters:

genc (GenConstr) – 通用约束对象。

Returns:

一个元组 (resvar, expr)，其中包含与一般约束相关的数据。

Example:
nlconstr = model.addGenConstrNL(y, nlfunc.exp(x - 1))
model.update()
(resvar, expr) = model.getGenConstrNL(nlconstr)
getGenConstrNLAdv(genconstr)#

另请参阅addGenConstrNLAdv以了解此通用约束类型的语义。这是一个高级方法，它返回一个非线性表达式\(f(x)\)作为在三个列表opcode、data和parent中指定的表达式树。大多数用户应使用getGenConstrNL来检查模型中的非线性约束。

Parameters:

genc (GenConstr) – 通用约束对象。

Returns:

一个元组 (resvar, opcode, data, parent) 包含与一般约束相关的数据。

Example:
nlconstr = model.addGenConstrNLAdv(
    y,
    [GRB.OPCODE_LOG, GRB.OPCODE_PLUS, GRB.OPCODE_VARIABLE, GRB.OPCODE_CONSTANT],
    [-1, -1, x, 1],
    [-1, 0, 1, 1],
    name="nl_constraint",
)
model.update()
resvar, opcode, data, parent = model.getGenConstrNLAdv(nlconstr)
getGenConstrs()#

检索模型中所有通用约束的列表。

Returns:

模型中的所有一般约束。

Example:
gencons = model.getGenConstrs()
for gc in gencons:
    if gc.GenConstrType == GRB.GENCONSTR_INDICATOR:
        (binvar, binval, expr, sense, rhs) = model.getGenConstrIndicator(gc)
    elif gc.GenConstrType == GRB.GENCONSTR_MAX:
        (resvar, vars, constant) = model.getGenConstrMax(gc)
    ...
getJSONSolution()#

在调用optimize之后，此方法返回结果解决方案和相关的模型属性作为JSON字符串。详情请参阅JSON解决方案格式部分。

Returns:

一个JSON字符串。

Example:
model = gp.read('p0033.mps')
model.optimize()
print(model.getJSONSolution())
getMultiobjEnv(index)#

创建/检索具有给定索引的多目标环境以进行优化传递。此环境允许对多目标优化过程进行细粒度控制。具体来说，通过更改此环境上的参数，您可以修改在多目标优化相应传递期间发生的优化行为。

每个多目标环境都从当前模型环境的副本开始。

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

请参考关于 结合混合和分层目标 的讨论，以获取有关解决多目标模型的优化过程的信息。

使用discardMultiobjEnvs来丢弃多目标环境并返回标准行为。

Parameters:

index – (int) 优化过程的索引，从0开始。

Returns:

解决模型时的多目标环境优化过程。

Example:
env0 = model.getMultiobjEnv(0)
env1 = model.getMultiobjEnv(1)

env0.setParam('TimeLimit', 100)
env1.setParam('TimeLimit', 10)

model.optimize()

model.discardMultiobjEnvs()
getObjective(index=None)#

检索模型目标。

调用此函数时不带参数以检索主要目标，或带一个整数参数以检索相应的替代目标。

Parameters:

index – (int, 可选) 请求的替代目标的索引。

Returns:

模型目标。线性目标使用LinExpr对象，二次目标使用QuadExpr对象。请注意，替代目标始终是线性的。

Example:
obj = model.getObjective()
print(obj.getValue())
getParamInfo(paramname)#

检索有关Gurobi参数的信息，包括类型、当前值、允许的最小值和最大值以及默认值。

请参考 参数部分以获取Gurobi参数的完整列表，包括它们的用途描述及其最小值、最大值和默认值。

Parameters:

paramname – 包含感兴趣参数名称的字符串。paramname的大小写和下划线将被忽略。

Returns:

返回一个包含6个元素的元组，其中包括：参数名称、参数类型、当前值、最小值、最大值和默认值。

Example:
print(model.getParamInfo('Heuristics'))

自版本12.0起已弃用：在paramname中使用'*'和'?'进行通配符名称匹配已被弃用。

getPWLObj(var)#

检索变量的分段线性目标函数。该函数返回一个元组列表，其中每个元组提供定义分段线性目标函数的点的\(x\)和\(y\)坐标。

请参考此讨论以获取关于\(x\)和\(y\)中值的更多信息。

Parameters:

var – 一个Var对象，用于指定要获取目标函数的变量。

Returns:

定义分段线性目标函数的点。

Example:
> print(model.getPWLObj(var))
[(1, 1), (2, 2), (3, 4)]
getQConstrs()#

检索模型中所有二次约束的列表。

Returns:

模型中的所有二次约束。

Example:
qconstrs = model.getQConstrs()
qc0 = qconstrs[0]
getQCRow(qconstr)#

从二次约束中检索左侧表达式。结果以QuadExpr对象的形式返回。

Parameters:

qconstr – 感兴趣的约束。一个QConstr对象， 通常从addQConstr或 getQConstrs获得。

Returns:

一个QuadExpr对象，用于捕获二次约束的左侧。

Example:
print(model.getQCRow(model.getQConstrs()[0]))
getRow(constr)#

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

Parameters:

constr – 感兴趣的约束。一个Constr对象， 通常从addConstr或 getConstrs获得。

Returns:

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

Example:
constrs = model.getConstrs()
print(model.getRow(constrs[0]))
getSOS(sos)#

检索有关SOS约束的信息。结果是一个元组，包含SOS类型（1或2）、参与的Var对象列表以及相关的SOS权重列表。

Parameters:

sos – 感兴趣的SOS约束。一个SOS对象， 通常从addSOS或 getSOSs获得。

Returns:

一个包含SOS类型（1或2）、参与的Var对象列表以及相关SOS权重列表的元组。

Example:
(sostype, vars, weights) = model.getSOS(model.getSOSs()[0])
getSOSs()#

检索模型中所有SOS约束的列表。

Returns:

模型中的所有SOS约束。

Example:
sos = model.getSOSs()
for s in sos:
  print(model.getSOS(s))
getTuneResult()#

使用此例程来检索之前tune调用的结果。使用参数n调用此方法会导致调整后的参数集n被复制到模型中。参数集按质量递减的顺序存储，参数集0为最佳。可用集的数量存储在属性TuneResultCount中。

一旦你获取了调优结果，你可以调用 optimize 来使用这些参数设置来优化模型，或者调用 write 将更改后的参数写入一个 .prm 文件。

请参考参数调优部分了解调优工具的详细信息。

Parameters:

n – 要检索的调优结果的索引。最佳结果作为索引0可用。存储结果的数量可在属性TuneResultCount中获取。

Example:
model.tune()
for i in range(model.tuneResultCount):
  model.getTuneResult(i)
  model.write('tune'+str(i)+'.prm')
getVarByName(name)#

根据名称检索变量。如果多个变量具有相同的名称，此方法将任意选择一个。

Parameters:

name – 所需变量的名称。

Returns:

具有指定名称的变量。

Example:
x0 = model.getVarByName("x0")
getVars()#

检索模型中所有变量的列表。

Returns:

模型中的所有变量。

Example:
vars = model.getVars()
x0 = vars[0]
message(msg)#

将字符串附加到控制台和Gurobi日志文件中。

Parameters:

msg – 要追加的字符串。

注意

除非设置了OutputFlag参数，否则此调用无效。此外，在MESSAGE回调（参见WHERE 值）和日志回调中，它会被忽略。控制台日志可以通过LogToConsole进行控制。

Example:
model.message('New message')
optimize(callback=None)#

优化模型。用于优化的算法取决于模型类型（连续模型的单纯形法或障碍法；MIP模型的分支定界法）。成功完成后，此方法将填充模型的解决方案相关属性。有关属性的更多信息，请参见属性部分。

请参考本节，了解与使用有限精度浮点算术解决精确定义的数学模型相关的一些实际问题。

请注意，此方法将处理所有待处理的模型修改。

Parameters:

callback – 回调函数。回调函数应接受两个参数，model 和 where。在优化过程中，该函数将定期被调用，model 设置为正在优化的模型，where 指示回调是从优化的哪个部分调用的。有关更多信息，请参阅 回调 部分。

Example:
model.optimize()
optimizeAsync(callback=None)#

异步优化模型。此方法立即返回，因此您的代码可以在优化在后台进行的同时继续运行其他任务。要检查异步优化的状态，请查询模型的状态属性。值为GRB.INPROGRESS表示优化尚未完成。当您完成前台任务时，必须调用sync以使您的前台程序与异步优化任务同步。

请注意，在后台运行优化时，您可以进行的Gurobi调用集合受到严格限制。具体来说，您只能对有限的属性集（如下所列）执行属性查询或调用terminate。对正在运行的模型或在同一Gurobi环境中构建的任何其他模型进行的任何其他调用都将引发异常。

请注意，在其他环境中构建的模型没有这样的限制。因此，例如，您可以创建多个环境，然后让一个前台程序启动多个同时进行的异步优化，每个优化都在其自己的环境中进行。

如前所述，您可以在异步优化进行时查询状态属性的值。其他可以查询的属性包括：ObjVal、ObjBound、IterCount、NodeCount和BarIterCount。在每种情况下，返回的值反映了优化到该点的进度。任何尝试查询不在此列表中的属性值都将引发异常。

在尝试查询其他任何内容（包括解决方案）或对模型执行任何其他操作之前，您必须调用sync。 如果在调用sync之前，Model对象被垃圾回收、释放或由上下文管理器关闭，后台优化任务将立即终止，并且模型将被释放。

请注意，此方法将在开始优化之前处理所有待处理的模型修改。

Parameters:

callback – 回调函数。回调函数应接受两个参数，model 和 where。在优化过程中，该函数将定期被调用，model 设置为正在优化的模型，where 指示回调是从优化的哪个位置调用的。有关更多信息，请参阅 回调 部分。

Example:
import time

import gurobipy as gp
from gurobipy import GRB

with gp.Env() as env, gp.Model(env=env) as model:
    # Formulate model ...
    model.optimizeAsync()
    while model.Status == GRB.INPROGRESS:
        time.sleep(0.1)
        print(f"{model.ObjVal=} {model.ObjBound=}")
    model.sync()
    # Query solution, process results
optimizeBatch()#

向集群管理器提交一个新的批处理请求。返回BatchID（一个字符串），它唯一地标识集群管理器中的作业，并可用于查询此请求的状态（从此程序或任何其他程序）。一旦请求完成，BatchID也可以用于检索相关的解决方案。要提交批处理请求，您必须通过设置VTag、CTag或QCTag属性之一来标记模型的至少一个元素。有关批处理优化的更多详细信息，请参阅批处理优化部分。

请注意，此例程将处理所有待处理的模型修改。

Example:
# Submit batch request
batchID = model.optimizeBatch()
Returns:

批处理请求的唯一字符串标识符。

Params#

获取或设置参数值。

Example:
# Print the current value of the MIPFocus parameter
print(model.Params.MIPFocus)

# Set a 10 second time limit for the next optimize() call
model.Params.TimeLimit = 10.0
presolve()#

对模型执行预求解。

请注意，此函数计算的预解模型可能与优化模型时计算的预解模型不同。

Returns:

原始模型的预解版本。

Example:
p = model.presolve()
p.printStats()
printAttr(attrs, filter='*')#

打印一个或多个属性的值。如果attrs是约束或变量属性，则打印该属性的所有非零值，以及相关的约束或变量名称。如果attrs是属性列表，则打印所有列出属性的属性值。该方法接受一个可选的filter参数，允许您选择要打印的特定属性值（通过过滤约束或变量名称）。

请参阅属性部分以获取所有可用属性的列表。

Parameters:

  • attrs – 要打印的属性或属性名称。值可以是单个属性或属性列表。如果给出的是列表，则所有列出的属性必须属于同一类型（模型、变量或约束）。

  • filter – (可选) 用于筛选要打印的值的过滤器 – constr/var 的名称必须与过滤器匹配才能被打印。

Example:
model.printAttr('x')          # all non-zero solution values
model.printAttr('lb', 'x*')   # bounds for vars whose names begin with 'x'
model.printAttr(['lb', 'ub']) # lower and upper bounds
printQuality()#

打印关于计算解的质量的统计信息（约束违反、完整性违反等）。

对于连续模型，输出将包括最大未缩放和缩放违规，以及与最严重未缩放违规相关的变量或约束名称。对于MIP模型，输出将包括最大未缩放违规和相关的变量或约束名称。

Example:
model.optimize()
model.printQuality()
printStats()#

打印模型的统计信息（约束和变量的数量，约束矩阵中的非零元素数量，最小和最大系数等）。

Example:
model.printStats()
read(filename)#

此方法是从文件导入数据到模型的通用入口点。它可以用于读取连续模型的基础文件、MIP模型的起始向量、MIP模型的变量提示、MIP模型的分支优先级或参数设置。读取的数据类型由文件后缀决定。文件格式在文件格式部分中描述。

请注意，读取文件不会处理所有待处理的模型修改。这些修改可以通过调用Model.update来处理。

还要注意，如果你想从文件中读取一个新模型，这不是要使用的方法。为此，请使用read命令。

Parameters:

filename – 要读取的文件名。文件的后缀必须是 .bas（用于LP基础）、.mst 或 .sol（用于MIP启动）、.hnt（用于MIP提示）、.ord（用于优先级顺序）、.attr（用于属性设置集合）或 .prm（用于参数文件）。后缀可以选择性地跟随 .zip、.gz、.bz2、.7z 或 .xz。文件名可以包含 * 或 ? 通配符。如果未找到匹配的通配符，则不读取任何文件。如果找到多个匹配项，此方法将尝试读取第一个匹配的文件。

Example:
model.read('input.bas')
model.read('input.mst')
relax()#

创建MIP模型的松弛。将整数变量转换为连续变量，并移除SOS和一般约束。

Returns:

模型的宽松版本。

Example:
r = model.relax()
remove(items)#

从模型中移除变量、线性约束、二次约束、SOS约束或一般约束。

Parameters:

items – 要从模型中移除的项目。参数可以是单个Var、MVar、Constr、MConstr、QConstr、MQConstr、SOS或GenConstr，或者是包含这些对象的list、tuple或dict。如果参数是dict，则移除的是值，而不是键。

Example:
model.remove(model.getVars()[0])
model.remove(model.getVars()[0:10])
model.remove(model.getConstrs()[0])
model.remove(model.getConstrs()[1:3])
model.remove(model.getQConstrs()[0])
model.remove(model.getSOSs()[0])
model.remove(model.getGenConstrs()[0])
reset(clearall=0)#

将模型重置为未解决状态，丢弃任何先前计算的解决方案信息。

Parameters:

clearall – (int, 可选) 值为1时，丢弃影响求解过程但不影响实际模型的附加信息（目前包括MIP起始点、变量提示、分支优先级、惰性标志和分区信息）。默认值仅丢弃解。

Example:
model.reset(0)
resetParams()#

将所有参数重置为其默认值。

Example:
model.resetParams()
setAttr(attrname, objects, newvalues)#

更改属性的值。

使用两个参数调用此方法（即， setAttr(attrname, newvalue)）来设置模型属性。

使用三个参数调用它（即， setAttr(attrname, objects, newvalues)）来为模型对象的列表或字典（Var 对象，Constr 对象等）设置属性值。要为第二个参数中的所有对象设置相同的值，可以在第三个参数中传递一个标量值。如果第二个参数是列表，则第三个参数应该是相同长度的列表。如果第二个参数是字典，则第三个参数应该是为第二个参数中的每个键提供值的字典。

可用属性的完整列表可以在 属性 部分找到。

如果指定的属性不存在或无法设置，则引发AttributeError。如果Model对象有问题，则引发GurobiError。

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

Parameters:

  • attrname – 要设置的属性名称。

  • objs – 模型对象列表（Var 或 Constr 或 …）

  • newvalue – 属性的期望新值。

Example:
model.setAttr("objCon", 0)
model.setAttr(GRB.Attr.ObjCon, 0)
model.setAttr("LB", model.getVars(), [0]*model.numVars)
model.setAttr("RHS", model.getConstrs(), [1.0]*model.numConstrs)
model.setAttr("vType", model.getVars(), GRB.CONTINUOUS)
model.objcon = 0
setMObjective(Q, c, constant, xQ_L=None, xQ_R=None, xc=None, sense=None)#

将模型目标设置为使用矩阵语义的二次（或线性）表达式。

请注意，您通常会使用重载运算符来设置目标使用矩阵对象。重载的@运算符可以用于构建linear matrix expression或二次 矩阵 表达式，然后将其传递给setObjective。

Parameters:

  • Q – 二次目标矩阵 - 一个 NumPy 2-D 密集 ndarray 或 SciPy 稀疏矩阵。如果没有二次项，这可以是 None。

  • c – 线性约束向量 - 一个 NumPy 1-D ndarray。如果没有线性项，这可以是 None。

  • constant – 目标常数。

  • xQ_L – （可选）二次目标项的决策变量；Q的左乘数。参数可以是MVar对象、Var对象列表或None（None使用模型中的所有变量）。参数的长度必须与Q的第一维度大小匹配。

  • xQ_R – （可选）二次目标项的决策变量；Q 的右乘数。参数的长度必须与 Q 的第二维度大小匹配。

  • xc – （可选）线性目标项的决策变量。 参数可以是MVar对象、Var对象列表，或None（None使用模型中的所有变量）。参数的长度必须与c的长度匹配。

  • sense – （可选）优化方向（GRB.MINIMIZE 用于最小化，GRB.MAXIMIZE 用于最大化）。省略此参数以使用 ModelSense 属性值来确定方向。

Example:
c = np.full(10, 1.0)
xc = model.addMVar(10)

model.setMObjective(None, c, 0.0, None, None, xc, GRB.MAXIMIZE)

Q = np.full((2, 3), 1.0)
xL = model.addMVar(2)
xR = model.addMVar(3)

model.setMObjective(Q, None, 0.0, xL, xR, None, GRB.MINIMIZE)
setObjective(expr, sense=None)#

将模型目标设置为线性或二次表达式（对于多目标优化，请参见setObjectiveN）。

请注意，你也可以使用Obj变量属性来修改线性模型的目标。如果你希望混合使用这两种方法，请注意此方法将替换现有的目标。

Parameters:

  • expr – 新的目标表达式。参数可以是线性或二次表达式（类型为 LinExpr 或 QuadExpr 的目标）。

  • sense – （可选）优化方向（GRB.MINIMIZE 表示最小化，GRB.MAXIMIZE 表示最大化）。省略此参数以使用 ModelSense 属性值来确定方向。

Example:
model.setObjective(x + y, GRB.MAXIMIZE)
model.setObjective(x*x + y*y)
setObjectiveN(expr, index, priority=0, weight=1, abstol=1e-6, reltol=0, name='')#

将替代优化目标设置为等于线性表达式。

请参考关于 多目标的讨论，以获取更多关于使用替代目标的信息。

请注意，你也可以使用ObjN变量属性来修改替代目标。如果你希望混合使用这两种方法，请注意此方法会替换整个现有目标，而ObjN属性可用于修改单个项。

Parameters:

  • expr – (LinExpr) 新的替代目标。

  • index – (int) 新目标的索引。如果使用索引0，此例程将更改主要优化目标。

  • priority – (int, 可选) 替代目标的优先级。 这将初始化此目标的 ObjNPriority 属性。

  • weight – (float, 可选) 替代目标的权重。 这将初始化此目标的 ObjNWeight 属性。

  • abstol – (float, 可选) 替代目标的绝对容差。这将初始化此目标的 ObjNAbsTol 属性。

  • reltol – (float, 可选) 替代目标的相对容差。这将初始化此目标的 ObjNRelTol 属性。

  • name – (string, optional) 替代目标的名称。这将初始化此目标的ObjNName属性。请注意，name将存储为ASCII字符串。因此，像‘A\({\rightarrow}\)B’这样的名称会产生错误，因为‘\({\rightarrow}\)‘不能表示为ASCII字符。还请注意，强烈不建议使用包含空格的名称，因为它们无法写入LP格式文件。

Example:
# Primary objective: x + 2 y
model.setObjectiveN(x + 2*y, 0, 2)
# Alternative, lower priority objectives: 3 y + z and x + z
model.setObjectiveN(3*y + z, 1, 1)
model.setObjectiveN(x + z, 2, 0)
setPWLObj(var, x, y)#

为变量设置分段线性目标函数。

此方法的参数指定了一个定义单变量分段线性目标函数的点列表。具体来说，\(x\) 和 \(y\) 参数给出了函数顶点的坐标。

有关分段线性目标函数的更多详细信息，请参阅 此讨论。

Parameters:

  • var – 一个 Var 对象，表示正在设置目标函数的变量。

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

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

Example:
model.setPWLObj(var, [1, 3, 5], [1, 2, 4])
setParam(paramname, newvalue)#

将参数的值设置为新值。请注意，此方法仅影响此模型的参数设置。使用全局函数setParam来更改所有模型的参数。

你也可以使用Model.Params类来设置参数。例如，要将模型m的参数MIPGap设置为0，你可以执行m.setParam('MIPGap', 0)或m.Params.MIPGap=0。

请参考 参数部分以获取Gurobi参数的完整列表，包括它们的用途描述及其最小值、最大值和默认值。

Parameters:

  • paramname – 包含您想要修改的参数名称的字符串。paramname的大小写和下划线将被忽略。

  • newvalue – 参数的期望新值。

Example:
model.setParam("Heuristics", 0.5)
model.setParam(GRB.Param.Heuristics, 0.5)

自版本12.0起已弃用：在paramname中使用'*'和'?'进行通配符名称匹配已弃用。将'default'作为newvalue传递已弃用。

singleScenarioModel()#

从多场景模型中捕获单个场景。使用 ScenarioNumber 参数来指示要捕获的场景。

调用此方法的模型必须是多场景模型，结果将是一个单场景模型。

Returns:

单一场景的模型。

Example:
model.params.ScenarioNumber = 0
s = model.singleScenarioModel()
sync()#

等待之前的异步优化调用完成。

调用optimizeAsync会立即将控制权返回给调用者。调用者可以在优化进行的同时执行其他计算，并且可以通过查询一组有限的模型属性来检查优化的进度。

sync 调用会阻塞，直到异步优化完成。 请注意，sync 是不可中断的。为了保持调用代码的控制权，您应该在调用 sync 之前通过检查 模型状态 来验证优化是否已完成。

sync 调用会引发一个 GurobiError，如果优化本身遇到任何问题。换句话说，此方法引发的异常是如果同步运行求解时 optimize 本身会引发的异常。

请注意，即使您知道异步优化已经完成，您也需要调用sync。只有在调用sync之后，您才能对模型执行其他操作，例如查询解决方案。在释放相应的模型之前，您必须调用sync。

如果在此模型未运行异步优化时调用sync，它将无效并立即返回。

Example:
import time

import gurobipy as gp
from gurobipy import GRB

with gp.Env() as env, gp.Model(env=env) as model:
    # Formulate model ...
    model.optimizeAsync()
    while model.Status == GRB.INPROGRESS:
        time.sleep(0.1)
        print(f"{model.ObjVal=} {model.ObjBound=}")
    model.sync()
    # Query solution, process results
terminate()#

生成一个请求以终止当前的优化。此方法可以在优化过程中的任何时间调用（从回调、另一个线程、中断处理程序等）。请注意，通常情况下，请求不会立即被执行。

当优化停止时，状态 属性将等于 GRB_INTERRUPTED。

Example:
model.terminate()
tune()#

执行自动搜索以改进性能的参数设置。完成后，此方法会存储找到的最佳参数集。可以通过查询TuneResultCount属性的值来确定存储的参数集数量。可以使用getTuneResult来检索实际设置。

请参考参数调优部分了解调优工具的详细信息。

Example:
model.tune()
update()#

处理任何待处理的模型修改。

Example:
model.update()
write(filename)#

此方法是用于将优化数据写入文件的通用入口点。它可以用于写入优化模型、解向量、基向量、起始向量或参数设置。写入的数据类型由文件后缀决定。文件格式在文件格式部分中描述。

请注意，将模型写入文件将处理所有待处理的模型修改。在写入其他模型信息（如解决方案、基础等）时也是如此。

还要注意的是，当你编写一个Gurobi参数文件（PRM）时，所有未设置为默认值的整数或双精度参数都会被保存，但不会将任何字符串参数保存到文件中。

最后，请注意，当IgnoreNames=1时，在写入文件时，变量和约束的名称将被替换为默认名称。

Parameters:

filename – 要写入的文件名。文件类型编码在文件名的后缀中。有效的后缀包括 .mps、.rew、.lp 或 .rlp 用于写入模型本身，.dua 或 .dlp 用于写入对偶模型（仅限纯 LP），.ilp 用于写入与不可行模型相关的 IIS（参见 Model.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("out.mst")
model.write("out.sol")