混合整数最適化の概要とアルゴリズム及びpythonによる実装

from pulp import *

# 最大化問題を定義する
problem = LpProblem('example', LpMaximize)

# 変数を定義する
x = LpVariable('x', lowBound=0, cat='Integer')
y = LpVariable('y', lowBound=0, cat='Integer')

# 目的関数を定義する
problem += 5*x + 3*y

# 制約条件を定義する
problem += x + y <= 10
problem += x <= 4

# 混合整数最適化問題を解く
status = problem.solve()

# 結果を出力する
print(f'status: {LpStatus[status]}')
print(f'x: {value(x)}, y: {value(y)}, obj: {value(problem.objective)}')

import pulp

# ジョブと機械の数
num_jobs = 3
num_machines = 3

# ジョブの処理時間
processing_times = [
    [2, 3, 2],  # ジョブ1の処理時間
    [1, 2, 1],  # ジョブ2の処理時間
    [4, 2, 3]   # ジョブ3の処理時間
]

# PuLPの問題定義
prob = pulp.LpProblem("Job_Shop_Scheduling", pulp.LpMinimize)

# 変数定義
# 変数x[i][j][k]は、ジョブiを機械jでk番目に処理する場合に1となるバイナリ変数
x = [[[pulp.LpVariable(f"x_{i}_{j}_{k}", cat=pulp.LpBinary) for k in range(num_machines)] for j in range(num_machines)] for i in range(num_jobs)]

# 目的関数
prob += pulp.lpSum(x[i][j][k] * (k + processing_times[i][j]) for i in range(num_jobs) for j in range(num_machines) for k in range(num_machines))

# 制約条件
# 各ジョブは異なる機械で同時に実行されないように制約
for i in range(num_jobs):
    for j in range(num_machines):
        prob += pulp.lpSum(x[i][j][k] for k in range(num_machines)) == 1

# 各機械は同時に複数のジョブを実行しないように制約
for j in range(num_machines):
    for k in range(num_machines):
        prob += pulp.lpSum(x[i][j][k] for i in range(num_jobs)) <= 1

# 各ジョブは前の機械で処理が終了してから次の機械で実行されるように制約
for i in range(num_jobs):
    for j in range(num_machines - 1):
        prob += pulp.lpSum((k + processing_times[i][j]) * x[i][j][k] for k in range(num_machines)) <= pulp.lpSum(k * x[i][j+1][k] for k in range(num_machines))

# 求解
prob.solve()

# 結果表示
print("最適スケジュール:")
for i in range(num_jobs):
    for j in range(num_machines):
        for k in range(num_machines):
            if x[i][j][k].varValue == 1:
                print(f"ジョブ{i+1}を機械{j+1}で{processing_times[i][j]}時間から{processing_times[i][j]+k}時間にかけて処理します。")

import pulp

# 輸送経路とコストのデータ
# 輸送経路は辞書形式で示す (工場, 倉庫)
routes = {
    ('Factory1', 'Warehouse1'): 10,
    ('Factory1', 'Warehouse2'): 20,
    ('Factory2', 'Warehouse1'): 15,
    ('Factory2', 'Warehouse2'): 25,
}

# PuLPの問題定義
prob = pulp.LpProblem("Transportation_Problem", pulp.LpMinimize)

# 変数定義
# 変数x[i][j]は輸送経路(i, j)を利用する場合に運送量を表す変数
x = {(i, j): pulp.LpVariable(f"x_{i}_{j}", lowBound=0, cat=pulp.LpInteger) for i, j in routes}

# 目的関数
prob += pulp.lpSum(routes[i, j] * x[i, j] for i, j in routes)

# 制約条件
# 工場からの供給量が需要に等しい制約
demand = {
    'Warehouse1': 15,
    'Warehouse2': 20,
}
for j in demand:
    prob += pulp.lpSum(x[i, j] for i, _ in routes if j == _[1]) == demand[j]

# 倉庫への輸送量が供給に等しい制約
supply = {
    'Factory1': 25,
    'Factory2': 30,
}
for i in supply:
    prob += pulp.lpSum(x[i, j] for _, j in routes if i == _[0]) == supply[i]

# 求解
prob.solve()

# 結果表示
print("最適な輸送計画:")
for i, j in routes:
    print(f"輸送経路({i}, {j})を利用して {x[i, j].varValue} 単位輸送します。")

import pulp

# 需要
demand = 100

# 発電所の情報（発電コストと最大出力）
plants = {
    'Thermal': {'cost': 50, 'max_output': 80},
    'Wind': {'cost': 20, 'max_output': 60},
    'Solar': {'cost': 30, 'max_output': 40},
}

# PuLPの問題定義
prob = pulp.LpProblem("Power_System_Optimization", pulp.LpMinimize)

# 変数定義
# 変数x[plant]は発電所の出力を表す変数
x = {plant: pulp.LpVariable(f"x_{plant}", lowBound=0, upBound=plants[plant]['max_output'], cat=pulp.LpContinuous) for plant in plants}

# 目的関数
prob += pulp.lpSum(plants[plant]['cost'] * x[plant] for plant in plants)

# 制約条件
# 需要を満たす制約
prob += pulp.lpSum(x[plant] for plant in plants) >= demand

# 求解
prob.solve()

# 結果表示
print("最適な発電所の出力:")
for plant in plants:
    print(f"{plant}: {x[plant].varValue} MW")

import pulp

# 需要と初期在庫
demand = 30
initial_inventory = 10

# 製品の製造コストと在庫保持コスト
production_cost = 5
holding_cost = 2

# PuLPの問題定義
prob = pulp.LpProblem("Inventory_Optimization", pulp.LpMinimize)

# 変数定義
# 変数xは製造量と在庫量を表す変数
x = pulp.LpVariable("x", lowBound=0, cat=pulp.LpInteger)
inventory = pulp.LpVariable("inventory", lowBound=0, cat=pulp.LpContinuous)

# 目的関数
prob += production_cost * x + holding_cost * inventory

# 制約条件
# 需要を満たす制約
prob += inventory + x == demand + initial_inventory

# 求解
prob.solve()

# 結果表示
print("最適な製造量:", x.varValue)
print("最適な在庫レベル:", inventory.varValue)

import pulp

# ネットワークの情報（ノードとリンクのコスト）
nodes = ['A', 'B', 'C', 'D', 'E']
links = [('A', 'B', 10), ('A', 'C', 5), ('B', 'C', 2), ('B', 'D', 4), ('C', 'D', 8), ('C', 'E', 3), ('D', 'E', 6)]

# PuLPの問題定義
prob = pulp.LpProblem("Network_Design_Optimization", pulp.LpMinimize)

# 変数定義
# 変数x[e]はリンクeを使用するかどうかを表すバイナリ変数
x = {e: pulp.LpVariable(f"x_{e[0]}_{e[1]}", cat=pulp.LpBinary) for e in links}

# 目的関数
prob += pulp.lpSum(e[2] * x[e] for e in links)

# 制約条件
# 全てのノードが接続される制約
for node in nodes:
    prob += pulp.lpSum(x[e] for e in links if node in e) >= 1

# 求解
prob.solve()

# 結果表示
print("最適なリンク:")
for e in links:
    if x[e].varValue == 1:
        print(f"{e[0]} -> {e[1]}")

import pulp

# 資産の情報（収益率とリスク）
assets = {
    'Asset1': {'return': 0.05, 'risk': 0.1},
    'Asset2': {'return': 0.08, 'risk': 0.15},
}

# PuLPの問題定義
prob = pulp.LpProblem("Portfolio_Optimization", pulp.LpMaximize)

# 変数定義
# 変数x[asset]は資産の割合を表す変数
x = {asset: pulp.LpVariable(f"x_{asset}", lowBound=0, upBound=1, cat=pulp.LpContinuous) for asset in assets}

# 目的関数
expected_return = pulp.lpSum(assets[asset]['return'] * x[asset] for asset in assets)
prob += expected_return

# 制約条件
# ポートフォリオの割合の合計が1になる制約（100%を投資）
prob += pulp.lpSum(x[asset] for asset in assets) == 1

# リスクの制約（リスクを最小化する場合はこれをコメントアウトする）
target_risk = 0.12
portfolio_risk = pulp.lpSum(assets[asset]['risk'] * x[asset] for asset in assets)
prob += portfolio_risk <= target_risk

# 求解
prob.solve()

# 結果表示
print("最適なポートフォリオ割合:")
for asset in assets:
    print(f"{asset}: {x[asset].varValue:.2f}")

print("予想リターン:", pulp.value(prob.objective))
print("ポートフォリオのリスク:", pulp.value(portfolio_risk))