import cvxpy as cp
import numpy as np

# ネットワークの構造を定義
nodes = 5
edges = [(0, 1), (0, 2), (1, 3), (2, 3), (2, 4), (3, 4)]
capacities = np.array([10, 10, 10, 10, 10, 10])
costs = np.array([1, 2, 3, 4, 5, 6])

# 最適化問題を定義
flow = cp.Variable(len(edges), nonneg=True)
objective = cp.Minimize(cp.sum(costs * flow))
constraints = [
    flow <= capacities,
    cp.sum(flow[[0, 1]]) == cp.sum(flow[[4, 5]]),  # source node
    cp.sum(flow[[2, 3]]) == cp.sum(flow[[0, 2]]),  # intermediate node 1
    cp.sum(flow[[4]]) == cp.sum(flow[[1, 3]]),    # intermediate node 2
    cp.sum(flow[[5]]) == cp.sum(flow[[4, 5]]),    # sink node
]

# 最適化問題を解く
problem = cp.Problem(objective, constraints)
problem.solve()

# 結果を表示
print("最適なフロー:", flow.value)
print("最小コスト:", problem.value)

import networkx as nx
import matplotlib.pyplot as plt

# グラフを作成
G = nx.DiGraph()
G.add_nodes_from(range(nodes))
for i, edge in enumerate(edges):
    G.add_edge(edge[0], edge[1], capacity=capacities[i], cost=costs[i], flow=flow.value[i])

# グラフを描画
pos = nx.spring_layout(G, seed=42)
nx.draw(G, pos, with_labels=True, node_color="skyblue", node_size=2000, font_size=20, font_weight="bold")
edge_labels = {(u, v): f"{d['flow']:.1f}/{d['capacity']} (cost: {d['cost']})" for u, v, d in G.edges(data=True)}
nx.draw_networkx_edge_labels(G, pos, edge_labels=edge_labels, font_size=12)

plt.title("Optimized Network Routing")
plt.axis("off")
plt.show()

import numpy as np
import matplotlib.pyplot as plt

np.random.seed(0)

# クラス1のデータ生成
mean1 = np.array([0, 2])
cov1 = np.array([[1, 0.8], [0.8, 1]])
class1_data = np.random.multivariate_normal(mean1, cov1, 50)

# クラス2のデータ生成
mean2 = np.array([2, 0])
cov2 = np.array([[1, 0.8], [0.8, 1]])
class2_data = np.random.multivariate_normal(mean2, cov2, 50)

# データのプロット
plt.scatter(class1_data[:, 0], class1_data[:, 1], label='Class 1')
plt.scatter(class2_data[:, 0], class2_data[:, 1], label='Class 2')
plt.legend()
plt.show()

import cvxpy as cp

# データの準備
X = np.vstack((class1_data, class2_data))
y = np.hstack((np.ones(50), -np.ones(50)))

# 変数の定義
w = cp.Variable(2)
b = cp.Variable()
xi = cp.Variable(100)

# パラメータの設定
C = 1

# 目的関数の定義
objective = cp.Minimize(cp.sum_squares(w) / 2 + C * cp.sum(xi))

# 制約条件の定義
constraints = [cp.multiply(y, (X @ w + b)) >= 1 - xi, xi >= 0]

# 最適化問題の定義と解決
prob = cp.Problem(objective, constraints)
prob.solve()

# 最適解の取得
w_opt = w.value
b_opt = b.value

print("Optimal w:", w_opt)
print("Optimal b:", b_opt)

# 分類境界線のプロット
x_line = np.linspace(-2, 4, 100)
y_line = -(w_opt[0] * x_line + b_opt) / w_opt[1]

plt.scatter(class1_data[:, 0], class1_data[:, 1], label='Class 1')
plt.scatter(class2_data[:, 0], class2_data[:, 1], label='Class 2')
plt.plot(x_line, y_line, color='red', label='Decision boundary')
plt.legend()
plt.show()

import cvxpy as cp

# パラメータ
demand = [50, 100, 150]  # 各バスの電力需要
gen_cost = [10, 20, 30]  # 各発電機の発電コスト
capacity = [100, 200, 300]  # 各発電機の容量

# 変数
power_gen = cp.Variable(3)  # 各発電機の発電量

# 制約
constraints = [
    power_gen >= 0,  # 発電量は非負
    power_gen <= capacity,  # 発電量は容量以下
    cp.sum(power_gen) == sum(demand),  # 電力需要を満たす
]

# 目的関数
objective = cp.Minimize(cp.sum(power_gen * gen_cost))

# 最適化問題
prob = cp.Problem(objective, constraints)

# 最適化問題を解く
result = prob.solve()

# 結果を表示
print("最適発電量:", power_gen.value)
print("最小発電コスト:", result)

import cvxpy as cp

x = cp.Variable()
y = cp.Variable()

objective = cp.Minimize((x-1)**2 + 4*(y+2)**2)
constraints = [x + y >= 3]

problem = cp.Problem(objective, constraints)
problem.solve()

optimal_value = problem.value

optimal_x = x.value
optimal_y = y.value

import cvxpy as cp

x = cp.Variable()
y = cp.Variable()

objective = cp.Minimize((x-1)**2 + 4*(y+2)**2)
constraints = [x + y >= 3]

problem = cp.Problem(objective, constraints)
problem.solve()

optimal_value = problem.value
optimal_x = x.value
optimal_y = y.value

print("Optimal value:", optimal_value)
print("Optimal x:", optimal_x)
print("Optimal y:", optimal_y)

import cvxpy as cp
import numpy as np

# パラメータ
T = 100  # 時間ステップ数
dt = 0.1  # 時間ステップの長さ
v_max = 5.0  # 最大速度
a_max = 2.0  # 最大加速度

# 変数
x = cp.Variable((T, 2))  # 位置
v = cp.Variable((T, 2))  # 速度
a = cp.Variable((T - 1, 2))  # 加速度

# 制約
constraints = []

# 初期条件
constraints += [x[0] == np.array([0, 0])]
constraints += [v[0] == np.array([0, 0])]

# 最終条件
constraints += [x[-1] == np.array([10, 10])]

# 動力学制約
for t in range(T - 1):
    constraints += [x[t + 1] == x[t] + dt * v[t]]
    constraints += [v[t + 1] == v[t] + dt * a[t]]

# 速度制約
constraints += [cp.norm(v, axis=1) <= v_max]

# 加速度制約
constraints += [cp.norm(a, axis=1) <= a_max]

# 目的関数
objective = cp.Minimize(dt * cp.sum(cp.norm(v, axis=1)))

# 問題
problem = cp.Problem(objective, constraints)

# 最適化
result = problem.solve()

print("Optimal total travel time:", result)

import matplotlib.pyplot as plt

x_values = x.value[:, 0]
y_values = x.value[:, 1]

plt.plot(x_values, y_values, marker='o')
plt.xlabel('x')
plt.ylabel('y')
plt.title('Optimal Trajectory')
plt.grid(True)
plt.show()

time_steps = np.arange(T) * dt

plt.plot(time_steps, np.linalg.norm(v.value, axis=1))
plt.xlabel('Time (s)')
plt.ylabel('Speed (m/s)')
plt.title('Optimal Speed Profile')
plt.grid(True)
plt.show()

import numpy as np
import cvxpy as cp
import matplotlib.pyplot as plt

# データ生成
np.random.seed(1)
n = 50
x = np.linspace(0, 10, n)
y = 3 * x + 5 + np.random.normal(0, 2, n)

plt.scatter(x, y)
plt.xlabel('x')
plt.ylabel('y')
plt.show()

# 変数の定義
a = cp.Variable()
b = cp.Variable()

# 目的関数の定義（最小二乗誤差の最小化）
objective = cp.Minimize(cp.sum_squares(a * x + b - y))

# 問題の定義
problem = cp.Problem(objective)

# 最適化問題を解く
result = problem.solve()

# 結果を表示
print("a:", a.value)
print("b:", b.value)

plt.scatter(x, y)
plt.plot(x, a.value * x + b.value, color='red')
plt.xlabel('x')
plt.ylabel('y')
plt.show()

import numpy as np

# 期待リターン
expected_returns = np.array([0.07, 0.12, 0.15, 0.10])

# 共分散行列
cov_matrix = np.array([
    [0.0064, 0.00408, 0.00192, 0.0016],
    [0.00408, 0.0289, 0.0204, 0.0119],
    [0.00192, 0.0204, 0.0576, 0.0336],
    [0.0016, 0.0119, 0.0336, 0.0400]
])

import cvxpy as cp

# 変数の定義
x = cp.Variable(4)

# 目的関数
objective = cp.Maximize(expected_returns @ x)

# 制約条件
constraints = [
    cp.sum(x) == 1,  # 合計投資比率は1
    cp.quad_form(x, cov_matrix) <= 0.02,  # リスク（分散）の上限
    x >= 0,  # 投資比率は0以上
    x <= 1  # 投資比率は1以下
]

# 問題の定義
prob = cp.Problem(objective, constraints)

# 最適化
prob.solve()

# 結果の表示
for i in range(4):
    print(f"銘柄 {i}: 投資比率 {x.value[i]:.2f}")

import pulp

# 問題を定義
problem = pulp.LpProblem("三国志戦略最適化", pulp.LpMaximize)

# 変数を作成
strategy_vars = pulp.LpVariable.dicts("Strategy", ["A", "B", "C"], lowBound=0, cat="Integer")

# 目的関数を設定
problem += 100 * strategy_vars["A"] + 300 * strategy_vars["B"] + 200 * strategy_vars["C"], "利益"

# 制約条件を追加
problem += 3000 * strategy_vars["A"] + 2000 * strategy_vars["B"] + 4000 * strategy_vars["C"] <= 5000, "兵士の制約"
problem += 4000 * strategy_vars["A"] + 5000 * strategy_vars["B"] + 3000 * strategy_vars["C"] <= 6000, "食料の制約"
problem += 5000 * strategy_vars["A"] + 2000 * strategy_vars["B"] + 6000 * strategy_vars["C"] <= 7000, "お金の制約"

# 問題を解くためのソルバーを指定
solver = pulp.PULP_CBC_CMD()

# 最適化問題を解く
problem.solve(solver)

# 結果を表示
print("最適化結果:")
for var in problem.variables():
    print(f"{var.name} = {var.value()}")

print("最大利益 =", pulp.value(problem.objective))

from pulp import *

# ①問題の定義
prob = LpProblem("Food Distribution", LpMinimize)

# ②供給地域と需要地域のリスト
供給地域のリスト = ["地域A", "地域B", "地域C"]
需要地域のリスト = ["地域X", "地域Y", "地域Z"]

# ③供給量と需要量のデータ
供給量 = {
    "地域A": 100,
    "地域B": 200,
    "地域C": 150
}

需要量 = {
    "地域X": 120,
    "地域Y": 180,
    "地域Z": 150
}

# ④変数の設定
x = LpVariable.dicts("x", (供給地域のリスト, 需要地域のリスト), lowBound=0, cat="Continuous")

# ⑤目的関数の定義
prob += lpSum(x[i][j] for i in 供給地域のリスト for j in 需要地域のリスト)

# ⑥制約条件の定義
for i in 供給地域のリスト:
    prob += lpSum(x[i][j] for j in 需要地域のリスト) <= 供給量[i]

for j in 需要地域のリスト:
    prob += lpSum(x[i][j] for i in 供給地域のリスト) >= 需要量[j]

# ⑦最適化の実行
prob.solve()

# ⑧結果の表示
print("Status:", LpStatus[prob.status])

for v in prob.variables():
    print(v.name, "=", v.varValue)

print("Optimal Cost:", value(prob.objective))

import pulp

# 問題を初期化
problem = pulp.LpProblem("WeatherForecastOptimization", pulp.LpMinimize)

# 地域の数
N = 5

# 観測ステーションの数
K = 2

# 地域の座標
coordinates = [(0, 0), (1, 2), (3, 1), (4, 3), (5, 0)]

# 予測エラーの係数
error_coefficients = [1.0, 0.8, 1.2, 0.9, 1.1]

# 予測エラーの変数
errors = [pulp.LpVariable(f"error_{i}", lowBound=0) for i in range(N)]

# 観測ステーションの設置変数
stations = [pulp.LpVariable(f"station_{i}", cat=pulp.LpBinary) for i in range(K)]

# 目的関数を定義
problem += pulp.lpSum(errors[i] * error_coefficients[i] for i in range(N))

# 各地域の予測エラーを計算
for i in range(N):
    # 地域の予測エラーを観測ステーションの影響で制約
    for j in range(K):
        problem += errors[i] >= pulp.lpSum(stations[j] * distance(coordinates[i], coordinates[k]) for k in range(N))

# 観測ステーションの数制約
problem += pulp.lpSum(stations) == K

# 問題を解く
problem.solve()

# 最適解を表示
print("Optimization Status:", pulp.LpStatus[problem.status])
print("Minimum Prediction Error:", pulp.value(problem.objective))

# 観測ステーションの配置を表示
for j in range(K):
    if stations[j].value() == 1:
        print("Station", j+1, "is located at", coordinates[j])

import pulp

# 地点間の距離を計算する関数
def distance(coord1, coord2):
    return ((coord1[0] - coord2[0]) ** 2 + (coord1[1] - coord2[1]) ** 2) ** 0.5

# 問題を初期化
problem = pulp.LpProblem("WeatherForecastOptimization", pulp.LpMinimize)

# 地域の数
N = 5

# 観測ステーションの数
K = 2

# 地域の座標
coordinates = [(0, 0), (1, 2), (3, 1), (4, 3), (5, 0)]

# 予測エラーの係数
error_coefficients = [1.0, 0.8, 1.2, 0.9, 1.1]

# 予測エラーの変数
errors = [pulp.LpVariable(f"error_{i}", lowBound=0) for i in range(N)]

# 観測ステーションの設置変数
stations = [pulp.LpVariable(f"station_{i}", cat=pulp.LpBinary) for i in range(K)]

# 目的関数を定義
problem += pulp.lpSum(errors[i] * error_coefficients[i] for i in range(N))

# 各地域の予測エラーを計算するための制約条件
for i in range(N):
    for j in range(K):
        problem += errors[i] >= pulp.lpSum(stations[j] * distance(coordinates[i], coordinates[k]) for k in range(N))

# 観測ステーションの数制約
problem += pulp.lpSum(stations) == K

# 問題を解く
problem.solve()

# 最適解を表示
print("Optimization Status:", pulp.LpStatus[problem.status])
print("Minimum Prediction Error:", pulp.value(problem.objective))

# 観測ステーションの配置を表示
for j in range(K):
    if stations[j].value() == 1:
        print("Station", j+1, "is located at", coordinates[j])