from sklearn import datasets
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score
import matplotlib.pyplot as plt
import seaborn as sns

heart = datasets.load_breast_cancer()
X = heart.data
y = heart.target

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

clf = RandomForestClassifier(random_state=42)
clf.fit(X_train, y_train)

y_pred = clf.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)
print(f'Accuracy: {accuracy}')

correlation_matrix = np.corrcoef(X.T)
sns.heatmap(correlation_matrix, annot=True)
plt.show()

import numpy as np
from scipy.integrate import odeint
import matplotlib.pyplot as plt

# ロトカ＝ヴォルテラ方程式
def predator_prey_equations(xy, t, alpha, beta, delta, gamma):
    x, y = xy
    dxdt = alpha * x - beta * x * y
    dydt = delta * x * y - gamma * y
    return [dxdt, dydt]

# 初期条件とパラメータ
x0 = 10  # 初期被食者の個体数
y0 = 5   # 初期捕食者の個体数
alpha = 1.1
beta = 0.4
delta = 0.1
gamma = 0.4

# 時間
t = np.linspace(0, 30, 1000)

# 微分方程式を解く
solution = odeint(predator_prey_equations, [x0, y0], t, args=(alpha, beta, delta, gamma))
x, y = solution[:, 0], solution[:, 1]

# 結果をグラフ化
plt.figure(figsize=(8, 6))
plt.plot(t, x, label='被食者 (Prey)')
plt.plot(t, y, label='捕食者 (Predator)')
plt.xlabel('時間')
plt.ylabel('個体数')
plt.title('ロトカ＝ヴォルテラ方程式の解')
plt.legend()
plt.grid(True)
plt.show()

import numpy as np
from scipy.integrate import odeint
import matplotlib.pyplot as plt

def predator_prey_equations(xy, t, alpha, beta, delta, gamma):
    x, y = xy
    dxdt = alpha * x - beta * x * y
    dydt = delta * x * y - gamma * y
    return [dxdt, dydt]

x0 = 10  # 初期被食者の個体数
y0 = 5   # 初期捕食者の個体数
alpha = 1.1
beta = 0.4
delta = 0.1
gamma = 0.4

t = np.linspace(0, 30, 1000)

solution = odeint(predator_prey_equations, [x0, y0], t, args=(alpha, beta, delta, gamma))
x, y = solution[:, 0], solution[:, 1]

plt.figure(figsize=(8, 6))
plt.plot(t, x, label='被食者 (Prey)')
plt.plot(t, y, label='捕食者 (Predator)')
plt.xlabel('時間')
plt.ylabel('個体数')
plt.title('ロトカ＝ヴォルテラ方程式の解')
plt.legend()
plt.grid(True)
plt.show()

import networkx as nx
import matplotlib.pyplot as plt

# Watts-Strogatzモデルによるグラフの生成
n = 100  # ノード数
k = 4    # 各ノードの近傍ノード数
p = 0.1  # エッジの再接続確率

G = nx.watts_strogatz_graph(n, k, p)

# 次数分布の取得
degrees = [G.degree(node) for node in G.nodes()]

# 次数分布のグラフ化
plt.hist(degrees, bins='auto', alpha=0.7, color='skyblue', edgecolor='black')
plt.xlabel('Degree')
plt.ylabel('Frequency')
plt.title('Degree Distribution of a Watts-Strogatz Graph')
plt.show()

import networkx as nx
import matplotlib.pyplot as plt

n = 100  # ノード数
k = 4    # 各ノードの近傍ノード数
p = 0.1  # エッジの再接続確率

G = nx.watts_strogatz_graph(n, k, p)

degrees = [G.degree(node) for node in G.nodes()]

plt.hist(degrees, bins='auto', alpha=0.7, color='skyblue', edgecolor='black')
plt.xlabel('Degree')
plt.ylabel('Frequency')
plt.title('Degree Distribution of a Watts-Strogatz Graph')
plt.show()

from pulp import LpMaximize, LpProblem, LpVariable

# 問題の定義
model = LpProblem(name="product_production", sense=LpMaximize)

# 変数の定義
prod_A = LpVariable(name="product_A", lowBound=0, cat="Integer")
prod_B = LpVariable(name="product_B", lowBound=0, cat="Integer")
prod_C = LpVariable(name="product_C", lowBound=0, cat="Integer")

# 利益と制約条件の設定
model += 300 * prod_A + 200 * prod_B + 500 * prod_C, "total_profit"

model += 2 * prod_A + 3 * prod_B + 4 * prod_C <= 100  # 生産時間の制約
model += prod_A + prod_B <= 40  # 製品Aと製品Bの同時生産の制約

# 問題の解決
model.solve()

# 結果の出力
print(f"Product A: {prod_A.varValue}")
print(f"Product B: {prod_B.varValue}")
print(f"Product C: {prod_C.varValue}")
print(f"Total Profit: {model.objective.value()}")

# グラフ化
import matplotlib.pyplot as plt

products = ['Product A', 'Product B', 'Product C']
production_quantities = [prod_A.varValue, prod_B.varValue, prod_C.varValue]

plt.figure(figsize=(8, 5))
plt.bar(products, production_quantities, color='skyblue')
plt.xlabel('Products')
plt.ylabel('Production Quantity')
plt.title('Optimal Production Quantities')
plt.show()

from ortools.linear_solver import pywraplp
import matplotlib.pyplot as plt

# データ
families = [0, 1, 2, 3, 4]  # 表現の一部として家族を表すインデックス
food_required = [3, 7, 2, 5, 4]  # 各家族が必要とする食糧の量
transport_costs = [10, 20, 5, 15, 10]  # 各家族への食糧配達のコスト

# ベクトル全体で最小化するためのスカラー乗数
scalar_multiplier = 10

# 問題を作成
solver = pywraplp.Solver.CreateSolver('SCIP')

# 変数を作成
x = []
for i in families:
    x.append(solver.IntVar(0, 1, 'x[%i]' % i))  # x[i] = 家族iに食糧を配達するかどうか (0 または 1)

# 制約を定義
budget = 30  # 予算
solver.Add(sum(transport_costs[i] * x[i] for i in families) <= budget)

# 目的関数を定義
solver.Maximize(scalar_multiplier * sum(food_required[i] * x[i] for i in families) - sum(transport_costs[i] * x[i] for i in families))

# 問題を解く
solver.Solve()

# 結果を出力
print("Total food delivered = ", sum(food_required[i] * x[i].solution_value() for i in families))
delivered = [x[i].solution_value() for i in families]
plt.figure(figsize=(10,5))
plt.bar(range(len(families)), delivered)
plt.title("Food delivered to each family")
plt.xlabel("Family")
plt.ylabel("Food quantity")
plt.xticks(range(len(families)), families)
plt.show()

from ortools.linear_solver import pywraplp
import matplotlib.pyplot as plt

families = [0, 1, 2, 3, 4]  # 家族を表すインデックス
food_required = [3, 7, 2, 5, 4]  # 各家族の食糧必要量
transport_costs = [10, 20, 5, 15, 10]  # 各家族への食糧配達コスト
scalar_multiplier = 10  # 最小化するためのスカラー乗数

solver = pywraplp.Solver.CreateSolver('SCIP')

x = []
for i in families:
   x.append(solver.IntVar(0, 1, 'x[%i]' % i))  # 家族iに食糧を配達するかどうか (0 または 1)

budget = 30
solver.Add(sum(transport_costs[i] * x[i] for i in families) <= budget)

solver.Maximize(scalar_multiplier * sum(food_required[i] * x[i] for i in families) - sum(transport_costs[i] * x[i] for i in families))
solver.Solve()

print("Total food delivered = ", sum(food_required[i] * x[i].solution_value() for i in families))
delivered = [x[i].solution_value() for i in families]
plt.figure(figsize=(10,5))
plt.bar(range(len(families)), delivered)
plt.title("Food delivered to each family")
plt.xlabel("Family")
plt.ylabel("Food quantity")
plt.xticks(range(len(families)), families)
plt.show()

from scipy.spatial.distance import cdist
import matplotlib.pyplot as plt

# 緯度経度のデータを定義
# 例: Tokyo, New York, London, Sydney
cities = {
    'Tokyo': (35.6895, 139.6917),
    'New York': (40.7128, -74.0060),
    'London': (51.5074, -0.1278),
    'Sydney': (-33.8688, 151.2093)
}

# 緯度経度をnumpy配列に変換
locations = list(cities.values())

# 距離を計算（ここではユークリッド距離を使用）
distances = cdist(locations, locations)

# 結果のグラフ化
plt.imshow(distances, cmap='viridis', interpolation='nearest')
plt.colorbar(label='Distance (degrees)')
plt.xticks(ticks=range(len(cities)), labels=cities.keys())
plt.yticks(ticks=range(len(cities)), labels=cities.keys())
plt.title('Distance between Cities')
plt.show()

from scipy.spatial.distance import cdist
import matplotlib.pyplot as plt

cities = {
    'Tokyo': (35.6895, 139.6917),
    'New York': (40.7128, -74.0060),
    'London': (51.5074, -0.1278),
    'Sydney': (-33.8688, 151.2093)
}

locations = list(cities.values())

distances = cdist(locations, locations)

plt.imshow(distances, cmap='viridis', interpolation='nearest')
plt.colorbar(label='Distance (degrees)')
plt.xticks(ticks=range(len(cities)), labels=cities.keys())
plt.yticks(ticks=range(len(cities)), labels=cities.keys())
plt.title('Distance between Cities')
plt.show()

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

# Rosenbrock関数を定義
def rosenbrock(x):
   return (1 - x[0])**2 + 100 * (x[1] - x[0]**2)**2

# Rosenbrock関数の勾配を定義
def rosenbrock_der(x):
   return np.array([-2 * (1 - x[0]) - 400 * x[0] * (x[1] - x[0]**2), 200 * (x[1] - x[0]**2)])

# Rosenbrock関数のHessianを定義
def rosenbrock_hess(x):
   return np.array([[2 + 1200 * x[0]**2 - 400 * x[1], -400 * x[0]],
                   [-400 * x[0], 200]])

# 初期値を設定
x0 = np.array([0.5, 0])

# 最適化問題を解く
res = minimize(rosenbrock, x0, method='trust-constr', jac=rosenbrock_der, hess=rosenbrock_hess)

# 結果を表示
print(res.x)

# 結果をグラフ化
x = np.linspace(-1, 2, 100)
y = np.linspace(-1, 3, 100)
X, Y = np.meshgrid(x, y)
Z = rosenbrock([X, Y])

plt.contour(X, Y, Z, levels=np.logspace(-2, 2, 20))
plt.xlabel('x')
plt.ylabel('y')
plt.title('Rosenbrock function')
plt.show()

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

def rosenbrock(x):
   return (1 - x[0])**2 + 100 * (x[1] - x[0]**2)**2

def rosenbrock_der(x):
   return np.array([-2 * (1 - x[0]) - 400 * x[0] * (x[1] - x[0]**2), 200 * (x[1] - x[0]**2)])

def rosenbrock_hess(x):
   return np.array([[2 + 1200 * x[0]**2 - 400 * x[1], -400 * x[0]],
                   [-400 * x[0], 200]])

x0 = np.array([0.5, 0])
res = minimize(rosenbrock, x0, method='trust-constr', jac=rosenbrock_der, hess=rosenbrock_hess)

print(res.x)

x = np.linspace(-1, 2, 100)
y = np.linspace(-1, 3, 100)
X, Y = np.meshgrid(x, y)
Z = rosenbrock([X, Y])

plt.contour(X, Y, Z, levels=np.logspace(-2, 2, 20))
plt.xlabel('x')
plt.ylabel('y')
plt.title('Rosenbrock function')
plt.show()

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

# 定数定義
G = 6.67430e-11  # 万有引力定数
m1 = 5.972e24  # 地球の質量(kg)
m2 = 7.35e22  # 月の質量(kg)
r = 384400000  # 地球から月までの距離(m)
v1 = 0  # 地球の初期速度(m/s)
v2 = 1022  # 月の初期速度(m/s)
timestep = 1000  # タイムステップ
num_steps = 10000  # ステップ数

# 初期条件
x1, y1, z1 = 0, 0, 0  # 地球の初期位置
x2, y2, z2 = r, 0, 0  # 月の初期位置

# 速度成分
vx1, vy1, vz1 = v1, 0, 0
vx2, vy2, vz2 = 0, v2, 0

# 位置、速度の更新
x1_values, y1_values, z1_values = [], [], []
x2_values, y2_values, z2_values = [], [], []

for _ in range(num_steps):
    # 地球と月の距離
    dx = x2 - x1
    dy = y2 - y1
    dz = z2 - z1
    r = np.sqrt(dx ** 2 + dy ** 2 + dz ** 2)

    # 万有引力の計算
    F = G * m1 * m2 / r ** 2

    # 重力の影響による加速度
    ax1 = F * dx / r / m1
    ay1 = F * dy / r / m1
    az1 = F * dz / r / m1
    ax2 = -F * dx / r / m2
    ay2 = -F * dy / r / m2
    az2 = -F * dz / r / m2

    # 速度の更新
    vx1 += ax1 * timestep
    vy1 += ay1 * timestep
    vz1 += az1 * timestep
    vx2 += ax2 * timestep
    vy2 += ay2 * timestep
    vz2 += az2 * timestep

    # 位置の更新
    x1 += vx1 * timestep
    y1 += vy1 * timestep
    z1 += vz1 * timestep
    x2 += vx2 * timestep
    y2 += vy2 * timestep
    z2 += vz2 * timestep

    # 位置を保存
    x1_values.append(x1)
    y1_values.append(y1)
    z1_values.append(z1)
    x2_values.append(x2)
    y2_values.append(y2)
    z2_values.append(z2)

# 3D軌道のプロット
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
ax.plot(x2_values, y2_values, z2_values, label='Moon')
ax.plot([0], [0], [0], marker='o', markersize=8, color='blue', label='Earth')
ax.set_xlabel('X coordinate (m)')
ax.set_ylabel('Y coordinate (m)')
ax.set_zlabel('Z coordinate (m)')
ax.set_title('Moon Orbit around Earth')
ax.legend()
plt.show()

import plotly.graph_objects as go
import numpy as np

# ヘリックスの方程式
t = np.linspace(0, 10, 50)
x, y, z = np.cos(t), np.sin(t), t

fig = go.Figure(data=[go.Scatter3d(x=x, y=y, z=z, mode='markers')])
fig.show()

x = np.outer(np.linspace(-2, 2, 30), np.ones(30))
y = x.copy().T
z = np.cos(x ** 2 + y ** 2)

fig = go.Figure(data=[go.Surface(x=x, y=y, z=z)])
fig.show()

import plotly.graph_objects as go
import numpy as np

# ヘリックスの方程式
t = np.linspace(0, 10, 50)
x, y, z = np.cos(t), np.sin(t), t

fig = go.Figure(data=[go.Scatter3d(x=x, y=y, z=z, mode='markers')])
fig.show()

x = np.outer(np.linspace(-2, 2, 30), np.ones(30))
y = x.copy().T
z = np.cos(x ** 2 + y ** 2)

fig = go.Figure(data=[go.Surface(x=x, y=y, z=z)])
fig.show()

import numpy as np
import matplotlib.pyplot as plt

def kernel(x, y):
 return np.exp(-0.5*(x - y)**2 / 2)

def f(x):
 return 2 * x + 5 * np.cos(x)

np.random.seed(seed=4)
n = 13
m = 100
X = np.linspace(0, 10, m)
y_truth = f(X)
x = 0.5 + 8.5 * np.random.rand(n)
y = f(x)

K = np.array([[kernel(x[i], x[j]) for j in range(n)] for i in range(n)])

c = np.linalg.inv(K) @ y
y_pred = []
for i in range(m):
 sum = 0
 for j in range(n):
   sum += c[j] * kernel(x[j], X[i])
 y_pred.append(sum)
y_pred = np.array(y_pred)

fig, ax = plt.subplots()
ax.scatter(x, y, label="data")
ax.plot(X, y_pred, color="red", label="predict")
ax.plot(X, y_truth, label="ground truth")
ax.legend()
plt.show()