基于其他变量值触发二元变量的采购成本脚本技术问询

Got it, let's tackle this step by step. Since you already have the minimum cost calculation up and running, tying binary variables to other values in your procurement model is all about defining clear logical links between those binary flags and your order quantities, supplier parameters, or cost triggers.

First, let's clarify: the binary variables you're referring to are almost certainly flags like "did we place an order with supplier X?" (to trigger their fixed shipping cost) or "did we meet the minimum order threshold for supplier Y's product Z?" (to unlock a discount, for example). Here's how to implement these triggers:

1. Triggering Binary Variables for Supplier Shipping Costs #

The most common use case here is a binary variable y_j (1 = we use supplier j, 0 = we don't) that activates only if we order any quantity of any product from supplier j. This ensures we only pay the fixed shipping cost once per supplier we use.

Key Constraints to Link Variables: #

If q_i_j = quantity of product i ordered from supplier j, and D_i = total demand for product i, add these linear constraints to your model:

• For each supplier j: sum(q_i_j for all products i) ≤ (sum(D_i for all i)) * y_j
  • This ensures that if any q_i_j > 0, y_j must equal 1 (since the left side is positive, the right side can't be 0). If no orders are placed with j, y_j can be 0.
• Optional: To enforce that y_j is 1 only if orders exist, you can add a lower-bound constraint: sum(q_i_j for all i) ≥ ε * y_j where ε is a tiny positive number (like 0.001) to handle floating-point precision.

Example Code Snippet (using PuLP for linear programming): #

from pulp import LpProblem, LpVariable, lpSum, LpMinimize

# Assume you already have these defined:
products = ["prod1", "prod2", "prod3", "prod4"]
suppliers = ["supp1", "supp2", "supp3", "supp4"]
demand = {"prod1": 100, "prod2": 150, "prod3": 80, "prod4": 200}
q = LpVariable.dicts("order_qty", [(p, s) for p in products for s in suppliers], lowBound=0, cat='Continuous')

# Define binary variable for supplier usage
y = LpVariable.dicts("supplier_used", suppliers, cat='Binary')

# Initialize the problem
prob = LpProblem("Procurement_Cost_Optimization", LpMinimize)

# Add the trigger constraint for each supplier
for s in suppliers:
    total_ordered_from_supplier = lpSum(q[(p, s)] for p in products)
    max_possible_order = sum(demand.values())
    prob += total_ordered_from_supplier <= max_possible_order * y[s], f"Trigger_Supplier_{s}"

# Add your existing cost objective (including shipping costs tied to y)
shipping_cost = {"supp1": 50, "supp2": 40, "supp3": 60, "supp4": 45}
unit_cost = {("prod1", "supp1"): 10, ("prod1", "supp2"): 12, 
             ("prod2", "supp1"): 8, ("prod2", "supp2"): 9}  # Extend to all product-supplier pairs
prob += lpSum(q[(p, s)] * unit_cost[(p, s)] for p in products for s in suppliers) + lpSum(y[s] * shipping_cost[s] for s in suppliers)

2. Triggering Binary Variables for Threshold-Based Conditions #

If you need binary variables tied to specific thresholds (e.g., "order ≥ 100 units of product X from supplier Y to get a discount"), define a binary variable z_i_j (1 = threshold met, 0 = not met) and link it to q_i_j with these constraints:

• q_i_j ≥ threshold_i_j * z_i_j: Ensures that if z_i_j = 1, the order quantity must be at least the threshold.
• q_i_j ≤ demand[i] * z_i_j: Ensures that if z_i_j = 0, the order quantity must be 0 (adjust if partial orders are allowed without the threshold benefit).

Example for Discount Triggers: #

# Define thresholds and discounted pricing
threshold = {("prod1", "supp1"): 100, ("prod2", "supp3"): 120}
discount_unit_cost = {("prod1", "supp1"): 8, ("prod2", "supp3"): 15}

# Binary variable for threshold eligibility
z = LpVariable.dicts("threshold_met", threshold.keys(), cat='Binary')

# Add constraints to link z to order quantities
for (p, s) in threshold:
    prob += q[(p, s)] >= threshold[(p, s)] * z[(p, s)], f"Threshold_Low_{p}_{s}"
    prob += q[(p, s)] <= demand[p] * z[(p, s)], f"Threshold_High_{p}_{s}"

# Update cost objective to apply discounts when thresholds are met
prob += lpSum(
    # Use discounted price if threshold is met, else regular price
    q[(p, s)] * (discount_unit_cost[(p, s)] if (p, s) in threshold else unit_cost[(p, s)]) * z[(p, s)]
    + q[(p, s)] * unit_cost[(p, s)] * (1 - z[(p, s)])
    for p in products for s in suppliers
) + lpSum(y[s] * shipping_cost[s] for s in suppliers)

Core Takeaway #

The key is to translate your business rules into linear constraints that force the binary variable to switch between 0 and 1 based on the values of your continuous variables (order quantities). This keeps your model solvable with standard linear or mixed-integer programming solvers.

内容的提问来源于stack exchange，提问作者Michifus