gurobi约束条件使用大全(`model.addConstr()`添加单个约束和`model.addConstrs()`添加多个约束和强不等式约束）

文章目录

• • • gurobi约束条件
    • • `model.addConstr()`添加单个约束
      • `model.addConstrs()`添加多个约束
      • 强不等式约束

gurobi约束条件

model.addConstr()添加单个约束

约束可以是线性、不等式或等式。Gurobi支持添加单个约束和多重约束。

例子：

model.addConstr(x + y == 5, "eq_constr")  # 添加等式约束x + y = 5

model.addConstr(x - 2 * y >= 3, "ineq_constr")  # 添加不等式约束x - 2y >= 3

model.addConstrs()添加多个约束

使用 model.addConstrs() 方法同时添加多个约束。该方法通常与字典或列表推导式结合使用，以方便地定义多个约束.

示例 1：基于索引的约束

假设你有多个变量 x[i] 和 y[i]，你希望添加以下约束：

• x i + y i = 5 , i = 1 , 2 , . . . , n . xi + yi = 5,i=1,2,...,n. xi+yi=5,i=1,2,...,n.
• x i − 2 × y i ≥ 3 = 1 , 2 , . . . , n . xi - 2 \times yi \geq 3=1,2,...,n. xi−2×yi≥3=1,2,...,n.

以下是代码示例：

# 添加等式约束 x[i] + y[i] = 5
model.addConstrs((x[i] + y[i] == 5 for i in range(n)), "eq_constr")

# 添加不等式约束 x[i] - 2 * y[i] >= 3
model.addConstrs((x[i] - 2 * y[i] >= 3 for i in range(n)), "ineq_constr")

---

示例 2：基于条件的约束

如果约束是基于某种条件（例如，索引对 (i, j) 满足特定条件），你也可以这样写：

# 假设 m 和 n 是索引的范围
model.addConstrs((x[i, j] + y[i, j] == 5 for i in range(m) for j in range(n) if some_condition(i, j)), "eq_constr")

model.addConstrs((x[i, j] - 2 * y[i, j] >= 3 for i in range(m) for j in range(n) if some_condition(i, j)), "ineq_constr")

代码解释与对应的数学公式

model.addConstrs(
    (x[i, j] + y[i, j] == 5 for i in range(m) for j in range(n) if some_condition(i, j)), 
    "eq_constr"
)

model.addConstrs(
    (x[i, j] - 2 * y[i, j] >= 3 for i in range(m) for j in range(n) if some_condition(i, j)), 
    "ineq_constr"
)

这段代码用于在 Gurobi 优化模型中添加一组约束条件。代码通过 model.addConstrs() 方法，基于某个条件 some_condition(i, j) 对变量 x[i, j] 和 y[i, j] 添加约束。

【1】. model.addConstrs()：

• 含义 ：用于添加多个约束。model 是 Gurobi 模型对象，addConstrs 是其方法之一，用于同时添加多个约束。

【2】. (x[i, j] + y[i, j] == 5 for i in range(m) for j in range(n) if some_condition(i, j))：

• 含义 ：这个生成器表达式遍历所有可能的索引对 (i, j)，为每一对 (i, j) 添加约束，前提是 some_condition(i, j) 条件为真。
• 对应的数学公式：

如果 some_condition ( i , j ) 为真： x i , j + y i , j = 5 , ∀ i ∈ { 0 , 1 , ... , m − 1 } , ∀ j ∈ { 0 , 1 , ... , n − 1 } \text{如果 } \text{some\condition}(i, j) \text{ 为真：}x{i,j} + y_{i,j} = 5, \forall i \in \{0, 1, \dots, m-1\}, \forall j \in \{0, 1, \dots, n-1\} 如果 some_condition(i,j) 为真：xi,j+yi,j=5,∀i∈{0,1,...,m−1},∀j∈{0,1,...,n−1}

【3】. (x[i, j] - 2 \times y[i, j] \geq 3 for i in range(m) for j in range(n) if some_condition(i, j))：

• 含义 ：这个生成器表达式与上面的类似，只是约束条件不同，这里是 x[i, j] - 2 \times y[i, j] >= 3，且同样受 some_condition(i, j) 的限制。
• 对应的数学公式：

如果 some_condition ( i , j ) 为真： x i , j − 2 × y i , j ≥ 3 , ∀ i ∈ { 0 , 1 , ... , m − 1 } , ∀ j ∈ { 0 , 1 , ... , n − 1 } \text{如果 } \text{some\condition}(i, j) \text{ 为真：} x{i,j} - 2 \times y_{i,j} \geq 3, \forall i \in \{0, 1, \dots, m-1\}, \forall j \in \{0, 1, \dots, n-1\} 如果 some_condition(i,j) 为真：xi,j−2×yi,j≥3,∀i∈{0,1,...,m−1},∀j∈{0,1,...,n−1}

代码的每一部分解释

1. for i in range(m) for j in range(n)：

   • 含义 ：嵌套的 for 循环，用于遍历索引对 (i, j)，其中 i 从 0 到 m-1，j 从 0 到 n-1。
   • 对应的数学符号：( i \in {0, 1, \dots, m-1} ), ( j \in {0, 1, \dots, n-1} )。

2. if some_condition(i, j)：

   • 含义 ：在 for 循环后跟随一个 if 语句，用于过滤出满足特定条件 some_condition(i, j) 的索引对 (i, j)。
   • 对应的数学符号 ：这里对应的条件表示形式不唯一，但可以理解为附加的条件，只有当 some_condition(i, j) 为真时，才会添加对应的约束。

3. x[i, j] + y[i, j] == 5 和 x[i, j] - 2 * y[i, j] >= 3：

   • 含义：分别表示添加的等式约束和不等式约束。
   • 对应的数学公式 ：
     • 对应 x[i, j] + y[i, j] == 5 的数学公式：
       x i , j + y i , j = 5 x_{i,j} + y_{i,j} = 5 xi,j+yi,j=5
     • 对应 x[i, j] - 2 * y[i, j] >= 3 的数学公式：
       x i , j − 2 × y i , j ≥ 3 x_{i,j} - 2 \times y_{i,j} \geq 3 xi,j−2×yi,j≥3

4. "eq_constr" 和 "ineq_constr"：

   • 含义 ：这是对约束的命名标识符。"eq_constr" 表示等式约束，"ineq_constr" 表示不等式约束。命名主要用于调试或后续引用约束。
   • 无直接的数学符号对应，但在模型中作为标识符有助于理解和追踪不同约束。

总结

这段代码主要用于根据条件 some_condition(i, j)，对一组变量 x[i, j] 和 y[i, j] 添加多个约束，包含了等式和不等式两种约束形式。通过 model.addConstrs() 方法和生成器表达式，可以非常简洁地表达复杂的约束逻辑。

---

示例 3：字典推导式

如果你使用 gurobipy.Model.addVars 创建了变量的字典，通过键来添加多个约束：

# 假设 x 和 y 是带有索引对 (i, j) 的变量字典
model.addConstrs((x[i, j] + y[i, j] == 5 for i, j in x.keys()), "eq_constr")

model.addConstrs((x[i, j] - 2 * y[i, j] >= 3 for i, j in y.keys()), "ineq_constr")

【1.】 什么是"键"（Keys）？

在 Gurobi 中，变量通常是通过索引来定义的。这些索引的组合就构成了变量的"键"（keys）。一个"键"可以理解为变量的唯一标识符，通常是一个元组 (i, j)，它表示变量 x[i, j] 或 y[i, j] 中的特定索引对 (i, j)。

【2.】 举例说明

假设你有一个二维变量 x[i, j] 和 y[i, j]，i 和 j 是索引。例如：

• i 的取值范围是 {0, 1}
• j 的取值范围是 {0, 1, 2}

那么 x[i, j] 和 y[i, j] 的变量集可以写作：

• 对于 x[i, j]：你有变量 x[0, 0], x[0, 1], x[0, 2], x[1, 0], x[1, 1], x[1, 2]
• 对于 y[i, j]：你有变量 y[0, 0], y[0, 1], y[0, 2], y[1, 0], y[1, 1], y[1, 2]

这些变量的"键"就是这些变量的索引对 (i, j)：

• x 的"键"包括 {(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2)}
• y 的"键"也包括 {(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2)}

这些键就是变量的索引组合，用来唯一标识每个变量。

【 3.】具体代码解释

model.addConstrs(
    (x[i, j] + y[i, j] == 5 for i, j in x.keys()), 
    "eq_constr"
)

model.addConstrs(
    (x[i, j] - 2 * y[i, j] >= 3 for i, j in y.keys()), 
    "ineq_constr"
)

x.keys() 和 y.keys() 的含义

• x.keys() 返回的是变量 x 的所有键 (i, j)，即变量 x[i, j] 的所有索引对。
• y.keys() 返回的是变量 y 的所有键 (i, j)，即变量 y[i, j] 的所有索引对。

约束生成

• 第一个约束 ：model.addConstrs((x[i, j] + y[i, j] == 5 for i, j in x.keys()), "eq_constr")

  • 这个约束遍历 x 中的所有键 (i, j)，为每个 (i, j) 添加一个约束 x[i, j] + y[i, j] == 5。
  • 例如，如果 x 的键是 {(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2)}，那么这个生成器会为每个 (i, j) 添加如下的约束：
    • x[0, 0] + y[0, 0] == 5
    • x[0, 1] + y[0, 1] == 5
    • x[0, 2] + y[0, 2] == 5
    • x[1, 0] + y[1, 0] == 5
    • x[1, 1] + y[1, 1] == 5
    • x[1, 2] + y[1, 2] == 5

• 第二个约束 ：model.addConstrs((x[i, j] - 2 * y[i, j] >= 3 for i, j in y.keys()), "ineq_constr")

  • 这个约束遍历 y 中的所有键 (i, j)，为每个 (i, j) 添加一个约束 x[i, j] - 2 * y[i, j] >= 3。
  • 例如，如果 y 的键是 {(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2)}，那么这个生成器会为每个 (i, j) 添加如下的约束：
    • x[0, 0] - 2 * y[0, 0] >= 3
    • x[0, 1] - 2 * y[0, 1] >= 3
    • x[0, 2] - 2 * y[0, 2] >= 3
    • x[1, 0] - 2 * y[1, 0] >= 3
    • x[1, 1] - 2 * y[1, 1] >= 3
    • x[1, 2] - 2 * y[1, 2] >= 3

代码解释与对应的数学公式

model.addConstrs(
    (x[i, j] + y[i, j] == 5 for i, j in x.keys()), 
    "eq_constr"
)

model.addConstrs(
    (x[i, j] - 2 * y[i, j] >= 3 for i, j in y.keys()), 
    "ineq_constr"
)

1. model.addConstrs()

• 含义 ：model.addConstrs() 用于同时添加多个约束。model 是 Gurobi 模型对象，addConstrs 是其中的方法之一，专门用于批量添加约束。

2. (x[i, j] + y[i, j] == 5 for i, j in x.keys())

• 含义 ：这个生成器表达式用于遍历 x 变量的所有索引对 (i, j)，并为这些索引对添加约束 x[i, j] + y[i, j] == 5。
• 对应的数学公式：

x i , j + y i , j = 5 , ∀ ( i , j ) ∈ Keys ( x ) x_{i,j} + y_{i,j} = 5, \quad \forall (i,j) \in \text{Keys}(x) xi,j+yi,j=5,∀(i,j)∈Keys(x)

其中，Keys(x) 表示变量 x 中的所有键 (i, j) 的集合。

3. (x[i, j] - 2 \times y[i, j] \geq 3 for i, j in y.keys())

• 含义 ：这个生成器表达式与上面的类似，但它遍历的是 y 变量的所有索引对 (i, j)，并为这些索引对添加约束 x[i, j] - 2 * y[i, j] >= 3。
• 对应的数学公式 ：
  x i , j − 2 × y i , j ≥ 3 , ∀ ( i , j ) ∈ Keys ( y ) x_{i,j} - 2 \times y_{i,j} \geq 3, \quad \forall (i,j) \in \text{Keys}(y) xi,j−2×yi,j≥3,∀(i,j)∈Keys(y)
  其中，Keys(y) 表示变量 y 中的所有键 (i, j) 的集合。

代码的每一部分解释

1. for i, j in x.keys() 和 for i, j in y.keys()
   • 含义 ：x.keys() 和 y.keys() 返回变量 x 和 y 的所有键（即索引对 (i, j) 的集合）。for i, j in x.keys() 和 for i, j in y.keys() 表示遍历这些键 (i, j)。
   • 对应的数学符号 ：表示对集合中的每一个索引对 (i,j) 进行遍历：
     ∀ ( i , j ) ∈ Keys ( x ) 和 ∀ ( i , j ) ∈ Keys ( y ) \forall (i,j) \in \text{Keys}(x) \quad \text{和} \quad \forall (i,j) \in \text{Keys}(y) ∀(i,j)∈Keys(x)和∀(i,j)∈Keys(y)
2. x[i, j] + y[i, j] == 5 和 x[i, j] - 2 \times y[i, j] \geq 3
   • 含义 ：分别表示要添加的等式约束和不等式约束。对于 x 中的每一对 (i, j)，约束 x[i, j] + y[i, j] == 5 被添加。对于 y 中的每一对 (i, j)，约束 x[i, j] - 2 \times y[i, j] >= 3 被添加。
   • 对应的数学公式 ：
     • 对应 x[i, j] + y[i, j] == 5 的数学公式：
       x i , j + y i , j = 5 x_{i,j} + y_{i,j} = 5 xi,j+yi,j=5
     • 对应 x[i, j] - 2 \times y[i, j] \geq 3 的数学公式：
       x i , j − 2 × y i , j ≥ 3 x_{i,j} - 2 \times y_{i,j} \geq 3 xi,j−2×yi,j≥3
3. "eq_constr" 和 "ineq_constr"
   • 含义 ：这些是对约束的命名标识符，"eq_constr" 用于等式约束，"ineq_constr" 用于不等式约束。命名主要是为了调试或后续引用约束。
   • 无直接的数学符号对应，但在模型中作为标识符有助于理解和追踪不同约束。

总结

(1) 这段代码通过遍历变量 x 和 y 的所有键（索引对 (i, j)），为每个键 (i, j) 添加相应的约束。通过 model.addConstrs() 和生成器表达式，可以简洁地表达并添加多个约束。这对于处理大规模优化问题或约束较多的情况非常有用。

• 第一部分代码 用于添加等式约束 x[i, j] + y[i, j] == 5，遍历的是 x 的所有键 (i, j)。
• 第二部分代码 用于添加不等式约束 x[i, j] - 2 * y[i, j] >= 3，遍历的是 y 的所有键 (i, j)。

(2) "键"就是变量的索引，它表示了变量在多维数组中的位置。 例如 x[0, 1] 的键就是 (0, 1)，y[1, 2] 的键就是 (1, 2)。在代码中，x.keys() 和 y.keys() 是返回这些索引对的集合，然后通过 for i, j in x.keys() 来遍历所有的这些索引对，并为每一个组合添加约束。

强不等式约束

• 对于遇到强不等式约束解决方法见== python中使用gurobi遇到强不等式约束(只有大于或者小于而不是大于等于或者小于等于的形式)的解决办法