import cvxpy as cp
import numpy as np

# チャンネル数
n_channels = 3

# 各チャンネルの広告効果 (売上増加率)
ad_effects = np.array([0.05, 0.1, 0.15])

# 広告予算の上限
budget = 10000

# 各チャンネルに投資する金額の変数
ad_spend = cp.Variable(n_channels)

# 制約条件
constraints = [
    ad_spend >= 0,  # 各チャンネルの広告費は0以上
    cp.sum(ad_spend) <= budget  # 広告費の合計が予算を超えない
]

# 目的関数 (売上増加額の最大化)
objective = cp.Maximize(ad_effects @ ad_spend)

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

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

# 結果を表示
print("Optimal ad spend:", ad_spend.value)
print("Maximum sales increase:", result)

import matplotlib.pyplot as plt

# 最適化された広告費配分
optimal_ad_spend = ad_spend.value

# チャンネル名
channel_names = ['Channel 1', 'Channel 2', 'Channel 3']

# 棒グラフを描画
plt.bar(channel_names, optimal_ad_spend)
plt.xlabel('Channels')
plt.ylabel('Ad Spend')
plt.title('Optimal Ad Spend Allocation')

# グラフを表示
plt.show()

import cvxpy as cp
import numpy as np

# パラメータ設定
N = 100  # 時間ステップ数
dt = 0.1  # 時間ステップの間隔
start_pos = np.array([0, 0])  # 始点
end_pos = np.array([1, 1])  # 終点

# 変数の定義
pos = cp.Variable((N, 2))
vel = cp.Variable((N, 2))
acc = cp.Variable((N, 2))
jerk = cp.Variable((N - 1, 2))

# 制約条件の設定
constraints = [
    pos[0] == start_pos,
    pos[-1] == end_pos,
    vel[0] == 0,
    vel[-1] == 0,
    acc[0] == 0,
    acc[-1] == 0,
]

for i in range(N - 1):
    constraints += [
        pos[i + 1] == pos[i] + vel[i] * dt + 0.5 * acc[i] * dt ** 2,
        vel[i + 1] == vel[i] + acc[i] * dt,
        acc[i + 1] == acc[i] + jerk[i] * dt,
    ]

# 目的関数の定義
objective = cp.Minimize(cp.sum_squares(jerk))

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

# 最適化問題の解決
prob.solve()

# 結果の表示
print("最適な軌道の位置:\n", pos.value)
print("最適な軌道の速度:\n", vel.value)
print("最適な軌道の加速度:\n", acc.value)
print("最適な軌道の急加速度:\n", jerk.value)

import matplotlib.pyplot as plt

# グラフの描画
fig, axes = plt.subplots(4, 1, figsize=(10, 20))

# 位置グラフ
axes[0].plot(pos.value[:, 0], pos.value[:, 1], marker='o', markersize=3)
axes[0].set_title('Position')
axes[0].set_xlabel('X')
axes[0].set_ylabel('Y')

# 速度グラフ
axes[1].plot(np.arange(N), vel.value[:, 0], label='X')
axes[1].plot(np.arange(N), vel.value[:, 1], label='Y')
axes[1].set_title('Velocity')
axes[1].set_xlabel('Time step')
axes[1].set_ylabel('Velocity')
axes[1].legend()

# 加速度グラフ
axes[2].plot(np.arange(N), acc.value[:, 0], label='X')
axes[2].plot(np.arange(N), acc.value[:, 1], label='Y')
axes[2].set_title('Acceleration')
axes[2].set_xlabel('Time step')
axes[2].set_ylabel('Acceleration')
axes[2].legend()

# 急加速度グラフ
axes[3].plot(np.arange(N - 1), jerk.value[:, 0], label='X')
axes[3].plot(np.arange(N - 1), jerk.value[:, 1], label='Y')
axes[3].set_title('Jerk')
axes[3].set_xlabel('Time step')
axes[3].set_ylabel('Jerk')
axes[3].legend()

plt.tight_layout()
plt.show()

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))