import pandas as pd
from sklearn.linear_model import LinearRegression
import matplotlib.pyplot as plt

# データの読み込み
url = "http://archive.ics.uci.edu/ml/machine-learning-databases/auto-mpg/auto-mpg.data"
column_names = ['MPG', 'Cylinders', 'Displacement', 'Horsepower', 'Weight', 'Acceleration', 'Model Year', 'Origin']
data = pd.read_csv(url, sep='\s+', names=column_names, na_values='?')

# 欠損値を削除
data = data.dropna()

# 特徴量とターゲットの選択
X = data[['Cylinders', 'Displacement', 'Horsepower', 'Weight', 'Acceleration']]
y = data['MPG']

# モデルの訓練
model = LinearRegression()
model.fit(X, y)

# 予測と実際の値の比較
predictions = model.predict(X)

# グラフ化
plt.figure(figsize=(10, 6))
plt.scatter(y, predictions)
plt.xlabel('実際のMPG')
plt.ylabel('予測されたMPG')
plt.title('実際のMPGと予測されたMPGの比較')
plt.grid(True)
plt.show()

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

# 解きたい方程式の関数
def equation(x):
    return x**3 + 2*x**2 - 5*x + 6

# 初期値を設定
initial_guess = 0

# 方程式の解を求める
solution = root(equation, initial_guess)

# 解を表示
print("解:", solution.x)

# グラフ化
x_vals = np.linspace(-5, 3, 1000)
y_vals = equation(x_vals)

plt.figure(figsize=(8, 6))
plt.plot(x_vals, y_vals, label='y = x^3 + 2x^2 - 5x + 6')
plt.scatter(solution.x, equation(solution.x), color='red', label='Solution', s=100)
plt.xlabel('x')
plt.ylabel('y')
plt.title('Graph of the Equation')
plt.legend()
plt.grid(True)
plt.show()

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

def equation(x):
    return x**3 + 2*x**2 - 5*x + 6

initial_guess = 0

solution = root(equation, initial_guess)

print("解:", solution.x)

x_vals = np.linspace(-5, 3, 1000)
y_vals = equation(x_vals)

plt.figure(figsize=(8, 6))
plt.plot(x_vals, y_vals, label='y = x^3 + 2x^2 - 5x + 6')
plt.scatter(solution.x, equation(solution.x), color='red', label='Solution', s=100)
plt.xlabel('x')
plt.ylabel('y')
plt.title('Graph of the Equation')
plt.legend()
plt.grid(True)
plt.show()

import numpy as np
from scipy.stats import norm
import matplotlib.pyplot as plt

# サンプルデータ生成
np.random.seed(0)
data = np.random.normal(loc=5, scale=2, size=1000)  # 平均=5, 標準偏差=2の正規分布からのサンプルデータ

# データの基本的な統計量計算
mean = np.mean(data)
std_dev = np.std(data)
median = np.median(data)

# 正規分布の確率密度関数の作成
x = np.linspace(np.min(data), np.max(data), 100)
pdf = norm.pdf(x, mean, std_dev)

# グラフ化
plt.figure(figsize=(10, 6))

# ヒストグラム
plt.hist(data, bins=30, density=True, alpha=0.5, label='Histogram')

# 正規分布の確率密度関数
plt.plot(x, pdf, 'r', label='Normal Distribution')

# 平均と中央値の縦線
plt.axvline(mean, color='green', linestyle='dashed', linewidth=2, label='Mean')
plt.axvline(median, color='orange', linestyle='dashed', linewidth=2, label='Median')

plt.title('Histogram and Normal Distribution of Data')
plt.xlabel('Values')
plt.ylabel('Density')
plt.legend()
plt.grid(True)
plt.show()

# 統計量の表示
print(f"平均: {mean}")
print(f"標準偏差: {std_dev}")
print(f"中央値: {median}")

import numpy as np
from scipy.stats import norm
import matplotlib.pyplot as plt

np.random.seed(0)
data = np.random.normal(loc=5, scale=2, size=1000)

mean = np.mean(data)
std_dev = np.std(data)
median = np.median(data)

x = np.linspace(np.min(data), np.max(data), 100)
pdf = norm.pdf(x, mean, std_dev)

plt.figure(figsize=(10, 6))
plt.hist(data, bins=30, density=True, alpha=0.5, label='Histogram')
plt.plot(x, pdf, 'r', label='Normal Distribution')
plt.axvline(mean, color='green', linestyle='dashed', linewidth=2, label='Mean')
plt.axvline(median, color='orange', linestyle='dashed', linewidth=2, label='Median')
plt.title('Histogram and Normal Distribution of Data')
plt.xlabel('Values')
plt.ylabel('Density')
plt.legend()
plt.grid(True)
plt.show()

print(f"平均: {mean}")
print(f"標準偏差: {std_dev}")
print(f"中央値: {median}")

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

# データ生成
np.random.seed(42)
n = 5  # 資産の数
mean_returns = np.random.randn(n) / 100  # 平均収益率
cov_matrix = np.random.randn(n, n)
cov_matrix = np.dot(cov_matrix.T, cov_matrix) / 100  # 共分散行列

# ポートフォリオ最適化問題の定義
weights = cp.Variable(n)
expected_return = mean_returns.T @ weights
risk = cp.quad_form(weights, cov_matrix)
constraints = [
    cp.sum(weights) == 1,  # 資産の割合の合計は1
    weights >= 0  # 資産の割合は0以上
]
problem = cp.Problem(cp.Maximize(expected_return - 0.5 * risk), constraints)  # 目的関数

# 最適化
result = problem.solve()

# 結果を表示
print("最適化されたポートフォリオの割合:")
print(weights.value)
print("期待収益率:", expected_return.value)
print("リスク:", np.sqrt(risk.value))

# グラフ化
plt.figure(figsize=(8, 6))
plt.bar(range(n), weights.value, tick_label=[f"Asset {i+1}" for i in range(n)])
plt.xlabel('Assets')
plt.ylabel('Portfolio Weights')
plt.title('Optimized Portfolio Allocation')
plt.show()

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

np.random.seed(42)
n = 5  # 資産の数
mean_returns = np.random.randn(n) / 100  # 平均収益率
cov_matrix = np.random.randn(n, n)
cov_matrix = np.dot(cov_matrix.T, cov_matrix) / 100  # 共分散行列

weights = cp.Variable(n)
expected_return = mean_returns.T @ weights
risk = cp.quad_form(weights, cov_matrix)
constraints = [
    cp.sum(weights) == 1,  # 資産の割合の合計は1
    weights >= 0  # 資産の割合は0以上
]
problem = cp.Problem(cp.Maximize(expected_return - 0.5 * risk), constraints)  # 目的関数

result = problem.solve()

print("最適化されたポートフォリオの割合:")
print(weights.value)
print("期待収益率:", expected_return.value)
print("リスク:", np.sqrt(risk.value))

plt.figure(figsize=(8, 6))
plt.bar(range(n), weights.value, tick_label=[f"Asset {i+1}" for i in range(n)])
plt.xlabel('Assets')
plt.ylabel('Portfolio Weights')
plt.title('Optimized Portfolio Allocation')
plt.show()

import numpy as np
import matplotlib.pyplot as plt

theta = np.linspace(0, 2*np.pi, 100)
r = np.random.uniform(0, 1, 100)

fig, axes = plt.subplots(2, 2, subplot_kw=dict(polar=True), figsize=(16, 8))

# 第1象限
axes[0, 0].plot(theta, r)

# 第2象限
axes[0, 1].plot(theta, r)
axes[0, 1].set_theta_offset(np.pi)

# 第3象限
axes[1, 0].plot(theta, r)
axes[1, 0].set_theta_direction(-1)

# 第4象限
axes[1, 1].plot(theta, r)
axes[1, 1].set_theta_offset(np.pi)
axes[1, 1].set_theta_direction(-1)

plt.show()

import numpy as np
import matplotlib.pyplot as plt

theta = np.linspace(0, 2*np.pi, 100)
r = np.random.uniform(0, 1, 100)

fig, axes = plt.subplots(2, 2, subplot_kw=dict(polar=True), figsize=(16, 8))

axes[0, 0].plot(theta, r)

axes[0, 1].plot(theta, r)
axes[0, 1].set_theta_offset(np.pi)

axes[1, 0].plot(theta, r)
axes[1, 0].set_theta_direction(-1)

axes[1, 1].plot(theta, r)
axes[1, 1].set_theta_offset(np.pi)
axes[1, 1].set_theta_direction(-1)

plt.show()

import plotly.graph_objs as go
import plotly.subplots as subplots
import numpy as np

# サンプルデータの生成
x = np.linspace(-5, 5, 100)
y = np.linspace(-5, 5, 100)
x, y = np.meshgrid(x, y)
z1 = np.sin(np.sqrt(x**2 + y**2))
z2 = np.cos(np.sqrt(x**2 + y**2))
z3 = x**2 - y**2

# 3Dサブプロットの作成
fig = subplots.make_subplots(rows=1, cols=3,
                             subplot_titles=('sin(sqrt(x^2 + y^2))', 'cos(sqrt(x^2 + y^2))', 'x^2 - y^2'),
                             specs=[[{'type': 'surface'}, {'type': 'surface'}, {'type': 'surface'}]])

# 3つの3Dサブプロットを追加
fig.add_trace(go.Surface(x=x, y=y, z=z1, colorscale='Viridis'), row=1, col=1)
fig.add_trace(go.Surface(x=x, y=y, z=z2, colorscale='Rainbow'), row=1, col=2)
fig.add_trace(go.Surface(x=x, y=y, z=z3, colorscale='Jet'), row=1, col=3)

# レイアウトの設定
fig.update_layout(title_text='複数の3Dサブプロット', height=600, width=1000)
fig.show()

import plotly.graph_objs as go
import plotly.subplots as subplots
import numpy as np

x = np.linspace(-5, 5, 100)
y = np.linspace(-5, 5, 100)
x, y = np.meshgrid(x, y)
z1 = np.sin(np.sqrt(x**2 + y**2))
z2 = np.cos(np.sqrt(x**2 + y**2))
z3 = x**2 - y**2

fig = subplots.make_subplots(rows=1, cols=3,
                             subplot_titles=('sin(sqrt(x^2 + y^2))', 'cos(sqrt(x^2 + y^2))', 'x^2 - y^2'),
                             specs=[[{'type': 'surface'}, {'type': 'surface'}, {'type': 'surface'}]])

fig.add_trace(go.Surface(x=x, y=y, z=z1, colorscale='Viridis'), row=1, col=1)
fig.add_trace(go.Surface(x=x, y=y, z=z2, colorscale='Rainbow'), row=1, col=2)
fig.add_trace(go.Surface(x=x, y=y, z=z3, colorscale='Jet'), row=1, col=3)

fig.update_layout(title_text='複数の3Dサブプロット', height=600, width=1000)
fig.show()

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

# 最小化する非線形関数
def objective_function(x):
    return x**2 + 5 * np.sin(x)

# 初期値
x0 = 0

# 最適化の実行
result = minimize(objective_function, x0, method='BFGS')

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

# グラフ化
x_vals = np.linspace(-10, 10, 100)
y_vals = objective_function(x_vals)

plt.plot(x_vals, y_vals, label='Objective Function')
plt.scatter(result.x, objective_function(result.x), color='red', label='Optimal Solution')
plt.xlabel('x')
plt.ylabel('f(x)')
plt.title('Nonlinear Optimization')
plt.legend()
plt.grid(True)
plt.show()

from pulp import LpProblem, LpVariable, lpSum, LpMaximize

def solve_resource_allocation_problem():
    # 問題の設定
    problem = LpProblem("Resource_Allocation", LpMaximize)

    # 従業員とタスクの数
    num_employees = 5
    num_tasks = 3

    # 従業員のスキル
    skills = [
        [3, 1, 4],  # 従業員1のスキル
        [2, 0, 5],  # 従業員2のスキル
        [1, 4, 2],  # 従業員3のスキル
        [4, 3, 1],  # 従業員4のスキル
        [0, 2, 3]   # 従業員5のスキル
    ]

    # タスクごとの予算
    budgets = [3000, 5000, 2000]

    # 従業員ごとの変数（0または1のバイナリ変数）
    employees = [LpVariable(f"Employee_{i}", cat='Binary') for i in range(num_employees)]

    # 目的関数（最大化する対象：全体のプロジェクト効率）
    problem += lpSum([employees[i] * skills[i][j] for i in range(num_employees) for j in range(num_tasks)]), "Total_Efficiency"

    # 制約条件
    for j in range(num_tasks):
        problem += lpSum([employees[i] * skills[i][j] for i in range(num_employees)]) >= 1, f"Task_{j + 1}_Requirement"

    problem += lpSum([employees[i] for i in range(num_employees)]) == 3, "Total_Employees"
    
    # 最適化の実行
    problem.solve()

    # 結果の表示
    print("Status:", LpProblem.status[problem.status])
    print("Optimal Resource Allocation:")
    for i, employee in enumerate(employees):
        if employee.varValue == 1:
            print(f"Employee {i + 1} is assigned to the project.")
    print(f"Total Project Efficiency: {problem.objective.value()}")

# 最適化の実行
solve_resource_allocation_problem()

from pulp import LpProblem, LpVariable, lpSum, LpMaximize

def solve_resource_allocation_problem():
    # 問題の設定
    problem = LpProblem("Resource_Allocation", LpMaximize)

# 従業員とタスクの数
num_employees = 5
num_tasks = 3

# 従業員のスキル
skills = [
    [3, 1, 4],  # 従業員1のスキル
    [2, 0, 5],  # 従業員2のスキル
    [1, 4, 2],  # 従業員3のスキル
    [4, 3, 1],  # 従業員4のスキル
    [0, 2, 3]   # 従業員5のスキル
]

# タスクごとの予算
budgets = [3000, 5000, 2000]

# 従業員ごとの変数（0または1のバイナリ変数）
employees = [LpVariable(f"Employee_{i}", cat='Binary') for i in range(num_employees)]

# 目的関数（最大化する対象：全体のプロジェクト効率）
problem += lpSum([employees[i] * skills[i][j] for i in range(num_employees) for j in range(num_tasks)]), "Total_Efficiency"

# 制約条件
for j in range(num_tasks):
    problem += lpSum([employees[i] * skills[i][j] for i in range(num_employees)]) >= 1, f"Task_{j + 1}_Requirement"

problem += lpSum([employees[i] for i in range(num_employees)]) == 3, "Total_Employees"

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

    # 結果の表示
    print("Status:", LpProblem.status[problem.status])
    print("Optimal Resource Allocation:")
    for i, employee in enumerate(employees):
        if employee.varValue == 1:
            print(f"Employee {i + 1} is assigned to the project.")
    print(f"Total Project Efficiency: {problem.objective.value()}")

# 最適化の実行
solve_resource_allocation_problem()

from ortools.constraint_solver import routing_enums_pb2
from ortools.constraint_solver import pywrapcp
import matplotlib.pyplot as plt
import networkx as nx

# 顧客の座標と需要を定義
locations = [(35, 10), (15, 15), (25, 25), (30, 40), (45, 35), (10, 20), (50, 25)]

# デポの座標
depot = (0, 0)

def create_data_model():
    data = {}
    data['distance_matrix'] = [
        [0, 10, 15, 20, 25, 30, 35],
        [10, 0, 10, 15, 20, 25, 30],
        [15, 10, 0, 10, 15, 20, 25],
        [20, 15, 10, 0, 10, 15, 20],
        [25, 20, 15, 10, 0, 10, 15],
        [30, 25, 20, 15, 10, 0, 10],
        [35, 30, 25, 20, 15, 10, 0]
    ]
    data['num_vehicles'] = 1
    data['depot'] = 0
    return data

def plot_solution(manager, routing, solution):
    index = routing.Start(0)
    plan_output = 'Route for vehicle 0:\n'
    route_distance = 0
    while not routing.IsEnd(index):
        plan_output += f'{manager.IndexToNode(index)} -> '
        previous_index = index
        index = solution.Value(routing.NextVar(index))
        route_distance += routing.GetArcCostForVehicle(previous_index, index, 0)
    plan_output += f'{manager.IndexToNode(index)}\n'
    route_distance += routing.GetArcCostForVehicle(previous_index, index, 0)
    print(plan_output)
    print(f'Distance of the route: {route_distance} units')

    # グラフの描画
    G = nx.Graph()
    for i in range(len(locations)):
        G.add_node(i, pos=locations[i])
    for i in range(manager.GetNumberOfVehicles()):
        index = routing.Start(i)
        while not routing.IsEnd(index):
            next_index = solution.Value(routing.NextVar(index))
            G.add_edge(manager.IndexToNode(index), manager.IndexToNode(next_index))
            index = next_index

    pos = nx.get_node_attributes(G, 'pos')
    nx.draw(G, pos, with_labels=True, font_weight='bold', node_size=700, node_color='skyblue', font_size=8, font_color='black')
    plt.show()

def main():
    data = create_data_model()

    # マネージャーの作成
    manager = pywrapcp.RoutingIndexManager(len(data['distance_matrix']), data['num_vehicles'], data['depot'])

    # モデルの作成
    routing = pywrapcp.RoutingModel(manager)

    # 距離のコスト関数の作成
    def distance_callback(from_index, to_index):
        from_node = manager.IndexToNode(from_index)
        to_node = manager.IndexToNode(to_index)
        return data['distance_matrix'][from_node][to_node]

    transit_callback_index = routing.RegisterTransitCallback(distance_callback)

    # 距離のコストをセット
    routing.SetArcCostEvaluatorOfAllVehicles(transit_callback_index)

    # ソルバーの設定
    search_parameters = pywrapcp.DefaultRoutingSearchParameters()
    search_parameters.local_search_metaheuristic = (routing_enums_pb2.LocalSearchMetaheuristic.GUIDED_LOCAL_SEARCH)
    search_parameters.time_limit.seconds = 30

    # ルートの構築
    solution = routing.SolveWithParameters(search_parameters)

    # 結果の表示
    if solution:
        plot_solution(manager, routing, solution)

if __name__ == '__main__':
    main()

from ortools.constraint_solver import routing_enums_pb2
from ortools.constraint_solver import pywrapcp
import matplotlib.pyplot as plt
import networkx as nx

locations = [(35, 10), (15, 15), (25, 25), (30, 40), (45, 35), (10, 20), (50, 25)]
depot = (0, 0)

def create_data_model():
    data = {}
    data['distance_matrix'] = [
        [0, 10, 15, 20, 25, 30, 35],
        [10, 0, 10, 15, 20, 25, 30],
        [15, 10, 0, 10, 15, 20, 25],
        [20, 15, 10, 0, 10, 15, 20],
        [25, 20, 15, 10, 0, 10, 15],
        [30, 25, 20, 15, 10, 0, 10],
        [35, 30, 25, 20, 15, 10, 0]
    ]
    data['num_vehicles'] = 1
    data['depot'] = 0
    return data

def plot_solution(manager, routing, solution):
    # ...（省略）...

def main():
    data = create_data_model()
    manager = pywrapcp.RoutingIndexManager(len(data['distance_matrix']), data['num_vehicles'], data['depot'])
    routing = pywrapcp.RoutingModel(manager)
    # ...（省略）...

def distance_callback(from_index, to_index):
    # ...（省略）...
transit_callback_index = routing.RegisterTransitCallback(distance_callback)
routing.SetArcCostEvaluatorOfAllVehicles(transit_callback_index)

search_parameters = pywrapcp.DefaultRoutingSearchParameters()
search_parameters.local_search_metaheuristic = (routing_enums_pb2.LocalSearchMetaheuristic.GUIDED_LOCAL_SEARCH)
search_parameters.time_limit.seconds = 30
solution = routing.SolveWithParameters(search_parameters)

if __name__ == '__main__':
    main()

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

# 非線形関数の定義
def nonlinear_function(x, a, b):
    return a * np.exp(b * x)

# データ生成
np.random.seed(42)
x_data = np.linspace(0, 2, 100)
y_data = 2.5 * np.exp(1.2 * x_data) + 0.2 * np.random.normal(size=len(x_data))

# 非線形最小二乗法でパラメータ推定
params, covariance = curve_fit(nonlinear_function, x_data, y_data)

# 推定されたパラメータ
a_fit, b_fit = params

# 推定した関数をプロット
y_fit = nonlinear_function(x_data, a_fit, b_fit)

# グラフ化
plt.scatter(x_data, y_data, label='実際のデータ')
plt.plot(x_data, y_fit, 'r', label='非線形最小二乗法によるフィット')
plt.title('非線形最小二乗法によるフィット')
plt.xlabel('x')
plt.ylabel('y')
plt.legend()
plt.show()