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

from pulp import *

# ①問題の初期化
prob = LpProblem("MetaVerse Store Placement", LpMaximize)

# ②変数の定義
store_locations = ['Location1', 'Location2', 'Location3']  # M個の配置可能な場所
stores = ['Store1', 'Store2', 'Store3']  # N個の店舗

# ③各店舗の配置場所の収益データ
revenues = {
    'Store1': {
        'Location1': 10,
        'Location2': 5,
        'Location3': 8
    },
    'Store2': {
        'Location1': 6,
        'Location2': 9,
        'Location3': 3
    },
    'Store3': {
        'Location1': 7,
        'Location2': 4,
        'Location3': 2
    }
}

# ④各配置場所間の距離データ
distances = {
    'Location1': {
        'Location1': 0,
        'Location2': 10,
        'Location3': 5
    },
    'Location2': {
        'Location1': 10,
        'Location2': 0,
        'Location3': 7
    },
    'Location3': {
        'Location1': 5,
        'Location2': 7,
        'Location3': 0
    }
}

# ⑤変数の作成
store_vars = LpVariable.dicts("StoreLocation", (stores, store_locations), cat='Binary')

# ⑥目的関数の定義
prob += lpSum([revenues[store][location] * store_vars[store][location] for store in stores for location in store_locations])

# ⑦制約条件の追加
# 各店舗は1つの場所に配置される
for store in stores:
    prob += lpSum([store_vars[store][location] for location in store_locations]) == 1

# ⑧各場所には1つの店舗しか配置されない
for location in store_locations:
    prob += lpSum([store_vars[store][location] for store in stores]) <= 1

# ⑨PuLPで最適化問題を解く
prob.solve()

# ⑩結果の出力
print("Status:", LpStatus[prob.status])
print("Optimal Solution:")
for store in stores:
    for location in store_locations:
        if store_vars[store][location].value() == 1:
            print(f"{store} is placed at {location}")

from pulp import *

# 問題の定義
problem = LpProblem("MiningOptimization", LpMaximize)

# マイナーのハッシュレートとマイニング時間
miners = {
    "Miner1": {"hashrate": 10, "max_time": 60},
    "Miner2": {"hashrate": 15, "max_time": 90},
    "Miner3": {"hashrate": 20, "max_time": 120}
}

# 変数の定義
mining_times = LpVariable.dicts("MiningTime", miners.keys(), lowBound=0, upBound=180)

# 目的関数の定義
total_reward = lpSum(mining_times[miner] * miners[miner]["hashrate"] for miner in miners)
problem += total_reward

# 制約条件の定義
problem += lpSum(mining_times.values()) == 180

for miner in miners:
    problem += mining_times[miner] <= miners[miner]["max_time"]

# 問題の解決
problem.solve()

# 結果の表示
print("Optimization Status:", LpStatus[problem.status])
for miner in miners:
    print(f"{miner}: Mining Time = {mining_times[miner].varValue:.2f} seconds")

# 各マイナーの報酬
rewards = {miner: mining_times[miner].varValue * miners[miner]["hashrate"] for miner in miners}
print("Rewards:")
for miner, reward in rewards.items():
    print(f"{miner}: {reward:.2f}")

from pulp import *

# ①従業員の数と曜日のリスト
employees = range(5)
weekdays = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']

# ②テレワーク希望日の設定
telework_preferences = [
    [1, 1, 0, 0, 1],  # 従業員0の希望日
    [0, 1, 0, 1, 0],  # 従業員1の希望日
    [1, 0, 1, 0, 1],  # 従業員2の希望日
    [1, 0, 1, 1, 0],  # 従業員3の希望日
    [0, 1, 0, 0, 1]   # 従業員4の希望日
]

# ③問題の定義
prob = LpProblem("Telework Optimization", LpMinimize)

# ④変数の定義
# telework[(i, j)] = 1 の場合、従業員 i は曜日 j にテレワークを行う
telework = LpVariable.dicts("telework", (employees, weekdays), 0, 1, LpInteger)

# ⑤目的関数の定義
# テレワークを行う日数を最小化する
prob += lpSum([telework[i][j] for i in employees for j in weekdays])

# ⑥制約条件の定義
# 各従業員は週に1日オフィス勤務を行う
for i in employees:
    prob += lpSum([telework[i][j] for j in weekdays]) == 4

# ⑦各従業員の希望日にテレワークを行う
for i in employees:
    for j in weekdays:
        prob += telework[i][j] >= telework_preferences[i][weekdays.index(j)]

# ⑧問題の解決
prob.solve()

# ⑨結果の出力
print("Status:", LpStatus[prob.status])
print("Optimal Schedule:")
for i in employees:
    print("Employee", i)
    for j in weekdays:
        if value(telework[i][j]) == 1:
            print(j, "- Telework")
        else:
            print(j, "- Office")
    print()

from pulp import *

# 顧客の情報
customers = [
    {"name": "顧客A", "time": 2, "cost": 200, "image": 8},
    {"name": "顧客B", "time": 3, "cost": 150, "image": 7},
    {"name": "顧客C", "time": 1, "cost": 50, "image": 3},
    {"name": "顧客D", "time": 4, "cost": 100, "image": 5},
    {"name": "顧客E", "time": 2, "cost": 120, "image": 6}
]

# インデックスのリスト
indices = range(len(customers))

# 最適化問題の定義
prob = LpProblem("Apology Optimization Problem", LpMaximize)

# 変数の定義
selections = LpVariable.dicts("Selection", indices, cat='Binary')

# 目的関数の定義
prob += lpSum([customers[i]["image"] * selections[i] for i in indices])

# 制約条件の定義
prob += lpSum([customers[i]["time"] * selections[i] for i in indices]) <= 6  # 時間制約
prob += lpSum([customers[i]["cost"] * selections[i] for i in indices]) <= 300  # コスト制約

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

# 結果の表示
print("最適化結果:")
for i in indices:
    if selections[i].varValue == 1:
        print(f"{customers[i]['name']}: 送る")

# 目的関数値の表示
print("目的関数値:", value(prob.objective))