from pulp import *

# 医師と日付のリストを作成
doctors = ['A', 'B', 'C']
days = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri']

# 問題を定義
prob = LpProblem("Doctors_Scheduling", LpMinimize)

# 変数を定義（各医師が各日に働くかどうか）
x = LpVariable.dicts("x", (doctors, days), cat='Binary')

# 目的関数を定義（医師の働く日数を最小化）
prob += lpSum(x[doctor][day] for doctor in doctors for day in days)

# 制約を定義
for day in days:
    prob += lpSum(x[doctor][day] for doctor in doctors) >= 2  # 1日に最低2人の医師が必要

for doctor in doctors:
    prob += lpSum(x[doctor][day] for day in days) <= 4  # 各医師は1週間に最大4日しか働けない
    prob += lpSum(x[doctor][day] for day in days) >= 2  # 各医師は1週間に最低2日は働く必要があります

# 問題を解く
prob.solve()

# 結果を表示
for v in prob.variables():
    print(v.name, "=", v.varValue)

import matplotlib.pyplot as plt
import numpy as np

# 結果を配列に格納
result = np.zeros((len(doctors), len(days)))
for v in prob.variables():
    doctor, day = v.name.split("_")[1:]
    result[doctors.index(doctor)][days.index(day)] = v.varValue

# ヒートマップを表示
plt.imshow(result, cmap='hot', interpolation='nearest')
plt.colorbar(label='Shifts')
plt.xticks(np.arange(len(days)), days)
plt.yticks(np.arange(len(doctors)), doctors)
plt.show()

from pulp import LpProblem, LpMinimize, LpVariable

# 問題の定義
prob = LpProblem("MedicineOptimization", LpMinimize)

# 変数の定義
A = LpVariable("Medicine_A", 0, None)  # 薬剤Aの単位数
B = LpVariable("Medicine_B", 0, None)  # 薬剤Bの単位数

# 目的関数の定義 (薬剤AとBのコストの最小化)
prob += 5 * A + 7 * B

# 制約条件の定義
prob += 3 * A + 4 * B >= 12  # 栄養素Xの最低摂取量
prob += 2 * A + 3 * B >= 15  # 栄養素Yの最低摂取量

# 問題の解法
prob.solve()

print("Optimal Units of Medicine A: ", A.varValue)
print("Optimal Units of Medicine B: ", B.varValue)

import matplotlib.pyplot as plt
import numpy as np

# 栄養素XとYの最低摂取量
min_X = 12
min_Y = 15

# 薬剤AとBの単位数の範囲
range_A = np.linspace(0, 10, 100)
range_B = np.linspace(0, 10, 100)

# 栄養素XとYの摂取量
X = 3 * range_A + 4 * range_B
Y = 2 * range_A + 3 * range_B

plt.figure(figsize=(8, 6))
plt.plot(range_A, (min_X - 3 * range_A) / 4, label="Nutrient X")
plt.plot(range_A, (min_Y - 2 * range_A) / 3, label="Nutrient Y")
plt.xlim(0, 10)
plt.ylim(0, 10)
plt.xlabel("Units of Medicine A")
plt.ylabel("Units of Medicine B")
plt.legend()
plt.grid(True)
plt.show()

from pulp import LpMaximize, LpProblem, LpStatus, lpSum, LpVariable

# 問題の定義
model = LpProblem(name="small-shop-problem", sense=LpMaximize)

# 変数の定義
x = {i: LpVariable(name=f"x{i}", lowBound=0, upBound=10, cat="Integer") for i in range(1, 4)}

# 利益の定義
profit = {1: 100, 2: 200, 3: 300}

# 目的関数
model += lpSum(profit[i] * x[i] for i in range(1, 4))

# 制約条件
model += (lpSum(x[i] for i in range(1, 4)) <= 2000, "budget_constraint")

# 問題の解
status = model.solve()

for var in x.values():
    print(f"{var.name}: {var.value()}")

print(f"Optimal profit: {model.objective.value()}")

import matplotlib.pyplot as plt

# 商品名
items = ['Item A', 'Item B', 'Item C']

# 最適な在庫数
optimal_values = [x[i].value() for i in range(1, 4)]

plt.bar(items, optimal_values)
plt.xlabel('Items')
plt.ylabel('Optimal Stock')
plt.title('Optimal Stock Level for Each Item')
plt.show()

from pulp import *
import numpy as np
import matplotlib.pyplot as plt

# 各投資商品のリターンとリスク
returns = {'A': 0.1, 'B': 0.12, 'C': 0.10, 'D': 0.07}
risks = {'A': 0.05, 'B': 0.07, 'C': 0.06, 'D': 0.03}

# 投資商品のリスト
assets = list(returns.keys())

# リスクの上限
risk_limit = 0.05

# 問題の定義
prob = LpProblem("Efficient Frontier", LpMaximize)

# 変数の定義
x = LpVariable.dicts("x", assets, 0)

# 目的関数
prob += lpSum([returns[i]*x[i] for i in assets])

# 制約条件
prob += lpSum([risks[i]*x[i] for i in assets]) <= risk_limit
prob += lpSum([x[i] for i in assets]) == 1

# 問題の解
prob.solve()

# 結果の表示
for i in assets:
    print(f"Investment in asset {i}: {x[i].varValue}")

# リスクとリターンのリスト
risks_list = np.linspace(0.01, 0.1, 100)
returns_list = []

for risk_limit in risks_list:
    prob = LpProblem("Efficient Frontier", LpMaximize)
    x = LpVariable.dicts("x", assets, 0)
    prob += lpSum([returns[i]*x[i] for i in assets])
    prob += lpSum([risks[i]*x[i] for i in assets]) <= risk_limit
    prob += lpSum([x[i] for i in assets]) == 1
    prob.solve()
    returns_list.append(value(prob.objective))

# グラフの描画
plt.plot(risks_list, returns_list)
plt.xlabel('Risk')
plt.ylabel('Return')
plt.title('Efficient Frontier')
plt.show()

from pulp import LpProblem, LpMinimize, LpVariable, lpSum
import pandas as pd
import matplotlib.pyplot as plt

# データの設定
# 供給地点と供給量
supply_points = {'Factory1': 500, 'Factory2': 600}
# 需要地点と需要量
demand_points = {'Shop1': 300, 'Shop2': 400, 'Shop3': 400}
# 供給地点から需要地点への輸送コスト
costs = {
    'Factory1': {'Shop1': 2, 'Shop2': 4, 'Shop3': 5},
    'Factory2': {'Shop1': 3, 'Shop2': 1, 'Shop3': 3}
}

# 問題の定義
prob = LpProblem('Transportation', LpMinimize)

# 変数の定義
vars = {
    i: {
        j: LpVariable(f"x({i},{j})", lowBound=0)
        for j in demand_points
    }
    for i in supply_points
}

# 目的関数の定義
prob += lpSum(costs[i][j] * vars[i][j] for i in supply_points for j in demand_points)

# 制約条件の定義
for i in supply_points:
    prob += lpSum(vars[i][j] for j in demand_points) <= supply_points[i]
for j in demand_points:
    prob += lpSum(vars[i][j] for i in supply_points) >= demand_points[j]

# 問題の解法
prob.solve()

# 結果の表示
for v in prob.variables():
    print(v.name, "=", v.varValue)

# 結果のグラフ化
df = pd.DataFrame([(v.name, v.varValue) for v in prob.variables()], columns=['Variable', 'Value'])
df.plot(kind='bar', x='Variable', y='Value')
plt.show()

import matplotlib.pyplot as plt
import numpy as np

# メニュー項目の人気度と利益率
popularity = [5, 8, 3, 6, 9, 2]
profit = [7, 12, 4, 8, 15, 3]

# メニュー項目の最大数
max_items = 3

# メニュー項目の数
n = len(profit)

# メニュー最適化問題を解くための動的計画法
dp = np.zeros((n+1, max_items+1))

for i in range(n+1):
    for j in range(max_items+1):
        if i == 0 or j == 0:
            dp[i][j] = 0
        elif popularity[i-1] <= j:
            dp[i][j] = max(profit[i-1] + dp[i-1][j-popularity[i-1]], dp[i-1][j])
        else:
            dp[i][j] = dp[i-1][j]

# 最適なメニュー構成の利益
optimal_profit = dp[n][max_items]

print("最適なメニュー構成の利益: ", optimal_profit)

# グラフ化
plt.bar(range(1, n+1), profit)
plt.xlabel('menu')
plt.ylabel('profit')
plt.title('profit of menu')
plt.show()

import numpy as np
from scipy.optimize import minimize
import matplotlib.pyplot as plt

# 都市の位置
cities = np.array([2, 5, 11, 16, 20, 23, 27, 30])

# 目的関数（全ての都市から施設までの距離の合計）
def objective(x):
    return np.sum(np.abs(cities - x))

# 初期値
x0 = np.array([15])

# 最適化
result = minimize(objective, x0, method='Nelder-Mead')

# 結果の表示
print("Optimal location: ", result.x)

# グラフの描画
plt.figure(figsize=(8, 4))
plt.plot(cities, [1]*len(cities), 'ro')
plt.plot(result.x, [1], 'bo')
plt.yticks([])
plt.grid(True)
plt.show()

import numpy as np
from scipy.optimize import minimize
import matplotlib.pyplot as plt

# 都市の位置
cities = np.array([[2, 3], [5, 1], [1, 6], [8, 6], [7, 4], [4, 7], [6, 2], [3, 4]])

# 目的関数（全ての都市から施設までの距離の合計）
def objective(x):
    return np.sum(np.sqrt(np.sum((cities - x)**2, axis=1)))

# 初期値
x0 = np.array([5, 5])

# 最適化
result = minimize(objective, x0, method='Nelder-Mead')

# 結果の表示
print("Optimal location: ", result.x)

# グラフの描画
plt.figure(figsize=(8, 8))
plt.plot(cities[:, 0], cities[:, 1], 'ro')
plt.plot(result.x[0], result.x[1], 'bo')
plt.grid(True)
plt.show()

import numpy as np
from scipy.optimize import minimize
from mpl_toolkits.mplot3d import Axes3D
import matplotlib.pyplot as plt

# 都市の位置
cities = np.array([[2, 3, 1], [5, 1, 6], [1, 6, 4], [8, 6, 2], [7, 4, 5], [4, 7, 3], [6, 2, 7], [3, 4, 2]])

# 目的関数（全ての都市から施設までの距離の合計）
def objective(x):
    return np.sum(np.sqrt(np.sum((cities - x)**2, axis=1)))

# 初期値
x0 = np.array([5, 5, 5])

# 最適化
result = minimize(objective, x0, method='Nelder-Mead')

# 結果の表示
print("Optimal location: ", result.x)

# グラフの描画
fig = plt.figure(figsize=(8, 8))
ax = fig.add_subplot(111, projection='3d')
ax.scatter(cities[:, 0], cities[:, 1], cities[:, 2], c='r', marker='o')
ax.scatter(result.x[0], result.x[1], result.x[2], c='b', marker='x')
ax.set_xlabel('X')
ax.set_ylabel('Y')
ax.set_zlabel('Z')
plt.show()

from scipy.optimize import minimize
import numpy as np

# 各地域の最大人口
max_populations = np.array([1000, 2000, 1500, 500, 1200])

# 各地域の満足度関数（ここでは単純化のためにランダムな値を使用）
satisfaction = np.random.rand(5)

# 目的関数（最小化するために-1を掛ける）
def objective(populations):
    return -np.sum(satisfaction * populations)

# 制約（各地域の人口はその地域の最大人口を超えない）
constraints = [{'type': 'ineq', 'fun': lambda x: max_populations - x}]

# 初期値
x0 = np.array([500, 500, 500, 500, 500])

# 最適化
res = minimize(objective, x0, method='SLSQP', constraints=constraints)

print("Optimal population distribution:", res.x)

from scipy.optimize import minimize

# 目的関数
def objective(x):
    return x[0]**2 + x[1]**2  # 最小化したい関数（例: x^2 + y^2）

# 制約条件
def constraint(x):
    return x[0] + x[1] - 1  # 制約条件（例: x + y <= 1）

# 初期値
x0 = [0, 0]  # 初期値の設定

# 制約付き最小化問題を解く
result = minimize(objective, x0, constraints={'type': 'ineq', 'fun': constraint})

# 結果を表示
print("最適解:", result.x)
print("最適な目的関数値:", result.fun)

import numpy as np
import pandas as pd
from sklearn import datasets
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error

diabetes = datasets.load_diabetes()

X = diabetes.data
y = diabetes.target

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25, random_state=42)

model = LinearRegression()
model.fit(X_train, y_train)

y_pred = model.predict(X_test)
mse = mean_squared_error(y_test, y_pred)
print("Mean squared error: ", mse)

import matplotlib.pyplot as plt

plt.scatter(y_test, y_pred)
plt.xlabel("Actual Progression")
plt.ylabel("Predicted Progression")
plt.title("Actual vs Predicted Progression")

# 対角線を描画
diagonal_line = np.linspace(min(y_test), max(y_test), 100)
plt.plot(diagonal_line, diagonal_line, color='red', linestyle='--')

plt.show()