import numpy as np
from scipy.fftpack import fft, ifft, fftshift
import matplotlib.pyplot as plt

# サンプルデータ生成
fs = 500  # サンプリング周波数
t = np.linspace(0, 1, fs, endpoint=False)
x = np.sin(1.2 * 2 * np.pi * t) + 1.5 * np.cos(9 * 2 * np.pi * t) + 0.5 * np.sin(12.0 * 2 * np.pi * t)

# フーリエ変換
X = fft(x)

# 周波数軸の生成
freqs = np.fft.fftfreq(len(X)) * fs

# フーリエ変換結果のシフト
X_shifted = fftshift(X)
freqs_shifted = fftshift(freqs)

# 結果のプロット
plt.figure(figsize=(12, 6))

plt.subplot(2, 1, 1)
plt.plot(t, x)
plt.title("Time Domain Signal")

plt.subplot(2, 1, 2)
plt.plot(freqs_shifted, np.abs(X_shifted))
plt.title("Frequency Domain Signal")
plt.xlim(-50, 50)

plt.tight_layout()
plt.show()

import numpy as np
from scipy.fftpack import fft, ifft, fftshift
import matplotlib.pyplot as plt

fs = 500  # サンプリング周波数
t = np.linspace(0, 1, fs, endpoint=False)
x = np.sin(1.2 * 2 * np.pi * t) + 1.5 * np.cos(9 * 2 * np.pi * t) + 0.5 * np.sin(12.0 * 2 * np.pi * t)

X = fft(x)

freqs = np.fft.fftfreq(len(X)) * fs

X_shifted = fftshift(X)
freqs_shifted = fftshift(freqs)

plt.figure(figsize=(12, 6))

plt.subplot(2, 1, 1)
plt.plot(t, x)
plt.title("Time Domain Signal")

plt.subplot(2, 1, 2)
plt.plot(freqs_shifted, np.abs(X_shifted))
plt.title("Frequency Domain Signal")
plt.xlim(-50, 50)

plt.tight_layout()
plt.show()

import networkx as nx
import matplotlib.pyplot as plt

# 完全グラフの生成
n = 5  # ノード数
K = nx.complete_graph(n)

# 完全グラフの描画
plt.figure(figsize=(8, 8))
pos = nx.spring_layout(K)
nx.draw(K, pos, with_labels=True, node_color='lightblue', node_size=500, font_size=16, font_color='black')
plt.title("Complete Graph")
plt.show()

import networkx as nx
import matplotlib.pyplot as plt

# スケールフリーグラフの生成
SF = nx.scale_free_graph(100)

# スケールフリーグラフの描画
plt.figure(figsize=(10, 10))
pos = nx.spring_layout(SF)
nx.draw(SF, pos, with_labels=False, node_color='lightgreen', node_size=30, font_size=10, font_color='black')
plt.title("Scale-Free Graph")
plt.show()

import networkx as nx
import matplotlib.pyplot as plt

# ランダムグラフの生成
p = 0.1  # エッジが存在する確率
RG = nx.erdos_renyi_graph(100, p)

# ランダムグラフの描画
plt.figure(figsize=(10, 10))
pos = nx.spring_layout(RG)
nx.draw(RG, pos, with_labels=False, node_color='lightcoral', node_size=30, font_size=10, font_color='black')
plt.title("Random Graph")
plt.show()

import networkx as nx
import matplotlib.pyplot as plt

# 小世界グラフの生成
k = 4  # 各ノードの近傍ノード数
p = 0.1  # 再配線確率
WS = nx.watts_strogatz_graph(100, k, p)

# 小世界グラフの描画
plt.figure(figsize=(10, 10))
pos = nx.spring_layout(WS)
nx.draw(WS, pos, with_labels=False, node_color='lightpink', node_size=30, font_size=10, font_color='black')
plt.title("Small-World Graph")
plt.show()

import networkx as nx

# グラフの作成
G = nx.Graph()

# ノードとエッジの追加（エッジに重みを持たせる）
G.add_edge('A', 'B', weight=4.2)
G.add_edge('B', 'C', weight=6.3)
G.add_edge('C', 'A', weight=5.1)

# エッジの重みを表示
for (u, v, wt) in G.edges(data='weight'):
    print(f"({u}, {v}, {wt})")

# ノードに属性を追加
G.nodes['A']['color'] = 'red'
G.nodes['B']['color'] = 'blue'
G.nodes['C']['color'] = 'green'

# エッジに属性を追加
G['A']['B']['capacity'] = 15
G['B']['C']['capacity'] = 10

# 属性を取得
print(G.nodes['A'])
print(G['A']['B'])

# 最短経路を見つける
path = nx.shortest_path(G, source='A', target='C', weight='weight')
print("Shortest path from A to C:", path)

# 最小全域木を見つける
mst = nx.minimum_spanning_tree(G)
print("Minimum Spanning Tree edges:", list(mst.edges(data=True)))

import matplotlib.pyplot as plt

# ノードの色を指定
node_colors = [G.nodes[node]['color'] for node in G.nodes]

# エッジの重みを取得
edge_weights = nx.get_edge_attributes(G, 'weight')

# グラフの描画
pos = nx.spring_layout(G)  # レイアウトを指定
nx.draw(G, pos, with_labels=True, node_color=node_colors, node_size=700, font_size=15)
nx.draw_networkx_edge_labels(G, pos, edge_labels=edge_weights)
plt.show()

# 各ノードのクラスタリング係数
clustering = nx.clustering(G)
print("Clustering Coefficients:", clustering)

from networkx.algorithms import community

# コミュニティを検出（Girvan-Newman法を使用）
comp = community.girvan_newman(G)
first_level_communities = next(comp)
print("Communities:", first_level_communities)

# グラフをファイルに保存
nx.write_gml(G, 'graph.gml')

# ファイルからグラフを読み込む
H = nx.read_gml('graph.gml')
print("Loaded graph:", H.nodes(data=True), H.edges(data=True))

# 多重グラフの作成
MG = nx.MultiGraph()

# ノードとエッジの追加（エッジに重みを持たせる）
MG.add_edge('A', 'B', weight=4.2)
MG.add_edge('A', 'B', weight=6.5)  # 複数のエッジを同じノード間に追加可能

# 多重グラフのエッジを表示
for (u, v, wt) in MG.edges(data='weight'):
    print(f"({u}, {v}, {wt})")

# 完全グラフ
K = nx.complete_graph(5)
print("Complete graph:", K.edges())

# スケールフリーグラフ
SF = nx.scale_free_graph(100)
print("Scale-free graph:", SF.edges())

import random
import multiprocessing
from deap import base, creator, tools, algorithms

# 適応度と個体の定義
creator.create("FitnessMax", base.Fitness, weights=(1.0,))
creator.create("Individual", list, fitness=creator.FitnessMax)

# 個体生成関数
def create_individual():
    return [random.uniform(-10, 10) for _ in range(3)]

# 適応度関数
def evaluate(individual):
    return sum(ind ** 2 for ind in individual),

# カスタムクロスオーバー
def custom_crossover(ind1, ind2):
    size = len(ind1)
    cxpoint = random.randint(1, size - 1)
    ind1[cxpoint:], ind2[cxpoint:] = ind2[cxpoint:], ind1[cxpoint:]
    return ind1, ind2

# カスタム突然変異
def custom_mutation(individual, indpb):
    for i in range(len(individual)):
        if random.random() < indpb:
            individual[i] = random.uniform(-10, 10)
    return individual,

# 登録
toolbox = base.Toolbox()
toolbox.register("individual", tools.initIterate, creator.Individual, create_individual)
toolbox.register("population", tools.initRepeat, list, toolbox.individual)
toolbox.register("mate", custom_crossover)
toolbox.register("mutate", custom_mutation, indpb=0.2)
toolbox.register("select", tools.selTournament, tournsize=3)
toolbox.register("evaluate", evaluate)

# 並列化の設定
pool = multiprocessing.Pool()
toolbox.register("map", pool.map)

# メイン実行ループ
population = toolbox.population(n=300)
NGEN = 40
for gen in range(NGEN):
    offspring = toolbox.select(population, len(population))
    offspring = list(map(toolbox.clone, offspring))

    for child1, child2 in zip(offspring[::2], offspring[1::2]):
        if random.random() < 0.5:
            toolbox.mate(child1, child2)
            del child1.fitness.values
            del child2.fitness.values

    for mutant in offspring:
        if random.random() < 0.2:
            toolbox.mutate(mutant)
            del mutant.fitness.values

    invalid_ind = [ind for ind in offspring if not ind.fitness.valid]
    fitnesses = toolbox.map(toolbox.evaluate, invalid_ind)
    for ind, fit in zip(invalid_ind, fitnesses):
        ind.fitness.values = fit

    population[:] = offspring

pool.close()
pool.join()

best_ind = tools.selBest(population, 1)[0]
print(f"Best individual is {best_ind}, {best_ind.fitness.values}")

import random
import multiprocessing
from deap import base, creator, tools, algorithms

creator.create("FitnessMax", base.Fitness, weights=(1.0,))
creator.create("Individual", list, fitness=creator.FitnessMax)

def create_individual():
    return [random.uniform(-10, 10) for _ in range(3)]

def evaluate(individual):
    return sum(ind ** 2 for ind in individual),

def custom_crossover(ind1, ind2):
    size = len(ind1)
    cxpoint = random.randint(1, size - 1)
    ind1[cxpoint:], ind2[cxpoint:] = ind2[cxpoint:], ind1[cxpoint:]
    return ind1, ind2

def custom_mutation(individual, indpb):
    for i in range(len(individual)):
        if random.random() < indpb:
            individual[i] = random.uniform(-10, 10)
    return individual,

toolbox = base.Toolbox()
toolbox.register("individual", tools.initIterate, creator.Individual, create_individual)
toolbox.register("population", tools.initRepeat, list, toolbox.individual)
toolbox.register("mate", custom_crossover)
toolbox.register("mutate", custom_mutation, indpb=0.2)
toolbox.register("select", tools.selTournament, tournsize=3)
toolbox.register("evaluate", evaluate)

pool = multiprocessing.Pool()
toolbox.register("map", pool.map)

population = toolbox.population(n=300)
NGEN = 40
for gen in range(NGEN):
    offspring = toolbox.select(population, len(population))
    offspring = list(map(toolbox.clone, offspring))

    for child1, child2 in zip(offspring[::2], offspring[1::2]):
        if random.random() < 0.5:
            toolbox.mate(child1, child2)
            del child1.fitness.values
            del child2.fitness.values

    for mutant in offspring:
        if random.random() < 0.2:
            toolbox.mutate(mutant)
            del mutant.fitness.values

    invalid_ind = [ind for ind in offspring if not ind.fitness.valid]
    fitnesses = toolbox.map(toolbox.evaluate, invalid_ind)
    for ind, fit in zip(invalid_ind, fitnesses):
        ind.fitness.values = fit

    population[:] = offspring

pool.close()
pool.join()

best_ind = tools.selBest(population, 1)[0]
print(f"Best individual is {best_ind}, {best_ind.fitness.values}")

import random
import multiprocessing
from deap import base, creator, tools, algorithms

# 適応度と個体の定義
creator.create("FitnessMax", base.Fitness, weights=(1.0,))
creator.create("Individual", list, fitness=creator.FitnessMax)

# 個体生成関数
def create_individual():
    return [random.uniform(-10, 10) for _ in range(3)]

# 適応度関数
def evaluate(individual):
    return sum(ind ** 2 for ind in individual),

# 登録
toolbox = base.Toolbox()
toolbox.register("individual", tools.initIterate, creator.Individual, create_individual)
toolbox.register("population", tools.initRepeat, list, toolbox.individual)
toolbox.register("mate", tools.cxBlend, alpha=0.5)
toolbox.register("mutate", tools.mutGaussian, mu=0, sigma=1, indpb=0.2)
toolbox.register("select", tools.selTournament, tournsize=3)
toolbox.register("evaluate", evaluate)

# 並列化の設定
pool = multiprocessing.Pool()
toolbox.register("map", pool.map)

# メイン実行ループ
population = toolbox.population(n=300)
NGEN = 40
for gen in range(NGEN):
    offspring = toolbox.select(population, len(population))
    offspring = list(map(toolbox.clone, offspring))

    for child1, child2 in zip(offspring[::2], offspring[1::2]):
        if random.random() < 0.5:
            toolbox.mate(child1, child2)
            del child1.fitness.values
            del child2.fitness.values

    for mutant in offspring:
        if random.random() < 0.2:
            toolbox.mutate(mutant)
            del mutant.fitness.values

    invalid_ind = [ind for ind in offspring if not ind.fitness.valid]
    fitnesses = toolbox.map(toolbox.evaluate, invalid_ind)
    for ind, fit in zip(invalid_ind, fitnesses):
        ind.fitness.values = fit

    population[:] = offspring

pool.close()
pool.join()

best_ind = tools.selBest(population, 1)[0]
print(f"Best individual is {best_ind}, {best_ind.fitness.values}")

import random
import multiprocessing
from deap import base, creator, tools, algorithms

creator.create("FitnessMax", base.Fitness, weights=(1.0,))
creator.create("Individual", list, fitness=creator.FitnessMax)

def create_individual():
    return [random.uniform(-10, 10) for _ in range(3)]

def evaluate(individual):
    return sum(ind ** 2 for ind in individual),

toolbox = base.Toolbox()
toolbox.register("individual", tools.initIterate, creator.Individual, create_individual)
toolbox.register("population", tools.initRepeat, list, toolbox.individual)
toolbox.register("mate", tools.cxBlend, alpha=0.5)
toolbox.register("mutate", tools.mutGaussian, mu=0, sigma=1, indpb=0.2)
toolbox.register("select", tools.selTournament, tournsize=3)
toolbox.register("evaluate", evaluate)

pool = multiprocessing.Pool()
toolbox.register("map", pool.map)

population = toolbox.population(n=300)
NGEN = 40
for gen in range(NGEN):
    offspring = toolbox.select(population, len(population))
    offspring = list(map(toolbox.clone, offspring))

    for child1, child2 in zip(offspring[::2], offspring[1::2]):
        if random.random() < 0.5:
            toolbox.mate(child1, child2)
            del child1.fitness.values
            del child2.fitness.values

    for mutant in offspring:
        if random.random() < 0.2:
            toolbox.mutate(mutant)
            del mutant.fitness.values

    invalid_ind = [ind for ind in offspring if not ind.fitness.valid]
    fitnesses = toolbox.map(toolbox.evaluate, invalid_ind)
    for ind, fit in zip(invalid_ind, fitnesses):
        ind.fitness.values = fit

    population[:] = offspring

pool.close()
pool.join()

best_ind = tools.selBest(population, 1)[0]
print(f"Best individual is {best_ind}, {best_ind.fitness.values}")

import random
from deap import base, creator, tools, algorithms

# 適応度と個体の定義
creator.create("FitnessMax", base.Fitness, weights=(1.0,))
creator.create("Individual", list, fitness=creator.FitnessMax)

# 個体生成関数
def create_individual():
    return [random.uniform(-10, 10) for _ in range(3)]

# 適応度関数
def evaluate(individual):
    return sum(ind ** 2 for ind in individual),

# 登録
toolbox = base.Toolbox()
toolbox.register("individual", tools.initIterate, creator.Individual, create_individual)
toolbox.register("population", tools.initRepeat, list, toolbox.individual)
toolbox.register("mate", tools.cxBlend, alpha=0.5)
toolbox.register("mutate", tools.mutGaussian, mu=0, sigma=1, indpb=0.2)
toolbox.register("select", tools.selTournament, tournsize=3)
toolbox.register("evaluate", evaluate)

# メイン実行ループ
population = toolbox.population(n=300)
NGEN = 40
for gen in range(NGEN):
    offspring = toolbox.select(population, len(population))
    offspring = list(map(toolbox.clone, offspring))

    for child1, child2 in zip(offspring[::2], offspring[1::2]):
        if random.random() < 0.5:
            toolbox.mate(child1, child2)
            del child1.fitness.values
            del child2.fitness.values

    for mutant in offspring:
        if random.random() < 0.2:
            toolbox.mutate(mutant)
            del mutant.fitness.values

    invalid_ind = [ind for ind in offspring if not ind.fitness.valid]
    fitnesses = map(toolbox.evaluate, invalid_ind)
    for ind, fit in zip(invalid_ind, fitnesses):
        ind.fitness.values = fit

    population[:] = offspring

best_ind = tools.selBest(population, 1)[0]
print(f"Best individual is {best_ind}, {best_ind.fitness.values}")

import random
from deap import base, creator, tools, algorithms

creator.create("FitnessMax", base.Fitness, weights=(1.0,))
creator.create("Individual", list, fitness=creator.FitnessMax)

def create_individual():
    return [random.uniform(-10, 10) for _ in range(3)]

def evaluate(individual):
    return sum(ind ** 2 for ind in individual),

toolbox = base.Toolbox()
toolbox.register("individual", tools.initIterate, creator.Individual, create_individual)
toolbox.register("population", tools.initRepeat, list, toolbox.individual)
toolbox.register("mate", tools.cxBlend, alpha=0.5)
toolbox.register("mutate", tools.mutGaussian, mu=0, sigma=1, indpb=0.2)
toolbox.register("select", tools.selTournament, tournsize=3)
toolbox.register("evaluate", evaluate)

population = toolbox.population(n=300)
NGEN = 40
for gen in range(NGEN):
    offspring = toolbox.select(population, len(population))
    offspring = list(map(toolbox.clone, offspring))

    for child1, child2 in zip(offspring[::2], offspring[1::2]):
        if random.random() < 0.5:
            toolbox.mate(child1, child2)
            del child1.fitness.values
            del child2.fitness.values

    for mutant in offspring:
        if random.random() < 0.2:
            toolbox.mutate(mutant)
            del mutant.fitness.values

    invalid_ind = [ind for ind in offspring if not ind.fitness.valid]
    fitnesses = map(toolbox.evaluate, invalid_ind)
    for ind, fit in zip(invalid_ind, fitnesses):
        ind.fitness.values = fit

    population[:] = offspring

best_ind = tools.selBest(population, 1)[0]
print(f"Best individual is {best_ind}, {best_ind.fitness.values}")

import seaborn as sns
import matplotlib.pyplot as plt

# サンプルデータセットのロード
tips = sns.load_dataset("tips")

sns.scatterplot(x="total_bill", y="tip", data=tips)
plt.show()

sns.lmplot(x="total_bill", y="tip", data=tips)
plt.show()

sns.barplot(x="day", y="total_bill", data=tips)
plt.show()

sns.boxplot(x="day", y="total_bill", data=tips)
plt.show()

sns.violinplot(x="day", y="total_bill", data=tips)
plt.show()

sns.histplot(tips["total_bill"], bins=20, kde=True)
plt.show()

sns.kdeplot(tips["total_bill"], shade=True)
plt.show()

# 数値データのみを抽出
numeric_tips = tips.select_dtypes(include=['float64', 'int64'])

# 相関行列の計算
corr = numeric_tips.corr()

# ヒートマップのプロット
sns.heatmap(corr, annot=True, cmap="coolwarm")
plt.show()

sns.pairplot(tips)
plt.show()

g = sns.FacetGrid(tips, col="sex", hue="smoker")
g.map(sns.scatterplot, "total_bill", "tip").add_legend()
plt.show()

ax = sns.barplot(x="day", y="total_bill", data=tips)
ax.set_title("Total Bill per Day")
ax.set_xlabel("Day of the Week")
ax.set_ylabel("Total Bill")
plt.show()

sns.set_style("whitegrid")
sns.scatterplot(x="total_bill", y="tip", data=tips)
plt.show()

sns.set_context("talk")
sns.set_palette("muted")
sns.set_style("whitegrid")

sns.violinplot(x="day", y="total_bill", data=tips)
plt.show()

from scipy.optimize import minimize

# 目的関数を定義
def objective(x):
    return x[0]**2 + x[1]**2

# 制約を定義
def constraint1(x):
    return x[0] - 2 * x[1] + 2

def constraint2(x):
    return -x[0] - 2 * x[1] + 6

# 制約条件を辞書形式で指定
con1 = {'type': 'ineq', 'fun': constraint1}
con2 = {'type': 'ineq', 'fun': constraint2}
cons = [con1, con2]

# 初期値
x0 = [0.5, 0]

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

print("最適化結果:", solution.x)

from scipy.optimize import fsolve

# 方程式を定義
def equations(vars):
    x, y = vars
    eq1 = x**2 + y**2 - 4
    eq2 = x * y - 1
    return [eq1, eq2]

# 初期値
initial_guess = [1, 1]

# 方程式を解く
solution = fsolve(equations, initial_guess)

print("解:", solution)

from scipy import integrate
import numpy as np
from multiprocessing import Pool

# 積分する関数を定義
def f(x):
    return np.sin(x)

# 積分範囲のリスト
ranges = [(0, np.pi/2), (0, np.pi), (0, 2*np.pi)]

# 並列計算のためのラッパー関数
def integrate_range(r):
    return integrate.quad(f, r[0], r[1])[0]

# プロセスプールを作成
with Pool(processes=3) as pool:
    results = pool.map(integrate_range, ranges)

print("積分結果:", results)

from scipy.sparse import csr_matrix
from scipy.sparse.linalg import spsolve

# 疎行列を作成
A = csr_matrix([[3, 1], [1, 2]])
b = np.array([9, 8])

# 疎行列を使って線形方程式を解く
x = spsolve(A, b)

print("解:", x)

from scipy.linalg import svd
import numpy as np

# 行列を作成
A = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

# 特異値分解を実行
U, s, Vt = svd(A)

print("U行列:", U)
print("特異値:", s)
print("V転置行列:", Vt)

import numpy as np
from scipy import stats

# ランダムな時間系列データを生成
np.random.seed(0)
data = np.random.normal(loc=0, scale=1, size=100)

# 移動平均を計算
moving_avg = np.convolve(data, np.ones(10)/10, mode='valid')

# 自己相関関数を計算
autocorrelation = np.correlate(data, data, mode='full')[len(data)-1:]

print("移動平均:", moving_avg)
print("自己相関関数:", autocorrelation)

import numpy as np
from scipy.stats import beta

# 事前分布を設定
a, b = 2, 2
x = np.linspace(0, 1, 100)

# ベータ分布の事前分布をプロット
prior = beta.pdf(x, a, b)

# 観測データを設定
observed_successes = 8
observed_failures = 2

# 事後分布を計算
posterior = beta.pdf(x, a + observed_successes, b + observed_failures)

# 結果をプロット
import matplotlib.pyplot as plt
plt.plot(x, prior, label='Prior')
plt.plot(x, posterior, label='Posterior')
plt.legend()
plt.show()

import pandas as pd

# サンプルデータの作成
data = {'A': [10, 20, 30, 40], 'B': [100, 200, 300, 400]}
df = pd.DataFrame(data)

# A列の値が20以上かつB列の値が300以下の行をフィルタリング
df_filtered = df[(df['A'] >= 20) & (df['B'] <= 300)]
print(df_filtered)

import numpy as np

# カスタム関数を定義
def custom_function(x):
    return x ** 2

# A列にカスタム関数を適用
df['A_squared'] = df['A'].apply(custom_function)

# B列にlambda関数を適用
df['B_log'] = df['B'].apply(lambda x: x if x == 0 else np.log(x))

print(df)

# サンプルの時系列データの作成
date_rng = pd.date_range(start='2023-01-01', end='2023-01-10', freq='D')
df_time = pd.DataFrame(date_rng, columns=['date'])
df_time['data'] = np.random.randint(0, 100, size=(len(date_rng)))

# date列をインデックスに設定
df_time.set_index('date', inplace=True)

# リサンプリングして月ごとの平均を計算
df_monthly_mean = df_time.resample('M').mean()

print(df_monthly_mean)

# サンプルデータの作成
data = {'A': ['foo', 'bar', 'foo', 'bar'], 'B': [1, 2, 3, 4], 'C': [10, 20, 30, 40]}
df = pd.DataFrame(data)

# グループごとの平均を計算してB列を標準化
df['B_normalized'] = df.groupby('A')['B'].transform(lambda x: (x - x.mean()) / x.std())

print(df)

# サンプルデータの作成
df1 = pd.DataFrame({'key1': ['A', 'B', 'C'], 'key2': [1, 2, 3], 'value': [10, 20, 30]})
df2 = pd.DataFrame({'key1': ['A', 'B', 'D'], 'key2': [1, 2, 4], 'value': [100, 200, 400]})

# 複数のキーを使った内部結合
df_merged = pd.merge(df1, df2, on=['key1', 'key2'], how='inner', suffixes=('_left', '_right'))

print(df_merged)

# サンプルデータの作成
arrays = [['A', 'A', 'B', 'B'], [1, 2, 1, 2]]
index = pd.MultiIndex.from_arrays(arrays, names=('letter', 'number'))
df_multi = pd.DataFrame({'value': [10, 20, 30, 40]}, index=index)

# 特定のレベルでデータを取得
print(df_multi.xs('A', level='letter'))

# サンプルデータの作成
df = pd.DataFrame({'A': [1, 2, 3], 'B': [10, 20, 30]})

# パイプラインを使って操作を連鎖
df_transformed = (df
                  .assign(C=lambda x: x['A'] + x['B'])
                  .query('C > 15')
                  .rename(columns={'A': 'alpha', 'B': 'beta'}))

print(df_transformed)

# サンプルデータの作成
df = pd.DataFrame({'A': range(10)})

# 移動平均の計算
df['moving_average'] = df['A'].rolling(window=3).mean()

print(df)

from ortools.linear_solver import pywraplp

def linear_programming_example():
    # Solverを作成
    solver = pywraplp.Solver.CreateSolver('GLOP')
    if not solver:
        return

    # 変数の作成
    x = solver.NumVar(0, 1, 'x')
    y = solver.NumVar(0, 2, 'y')

    # 制約の設定
    solver.Add(x + y <= 2)

    # 目的関数の設定
    solver.Maximize(x + y)

    # 解を求める
    status = solver.Solve()

    if status == pywraplp.Solver.OPTIMAL:
        print('解が見つかりました:')
        print('x =', x.solution_value())
        print('y =', y.solution_value())
        print('最適値 =', solver.Objective().Value())
    else:
        print('最適解が見つかりませんでした')

linear_programming_example()

from ortools.linear_solver import pywraplp

def integer_programming_example():
    # Solverを作成
    solver = pywraplp.Solver.CreateSolver('SCIP')
    if not solver:
        return

    # 変数の作成
    x = solver.IntVar(0, 10, 'x')
    y = solver.IntVar(0, 10, 'y')

    # 制約の設定
    solver.Add(x + y <= 5)

    # 目的関数の設定
    solver.Maximize(2 * x + 3 * y)

    # 解を求める
    status = solver.Solve()

    if status == pywraplp.Solver.OPTIMAL:
        print('解が見つかりました:')
        print('x =', x.solution_value())
        print('y =', y.solution_value())
        print('最適値 =', solver.Objective().Value())
    else:
        print('最適解が見つかりませんでした')

integer_programming_example()

from ortools.constraint_solver import routing_enums_pb2
from ortools.constraint_solver import pywrapcp

def create_data_model():
    """データを作成"""
    data = {}
    data['distance_matrix'] = [
        [0, 9, 2, 7],
        [9, 0, 6, 3],
        [2, 6, 0, 4],
        [7, 3, 4, 0],
    ]
    data['num_vehicles'] = 1
    data['depot'] = 0
    return data

def print_solution(manager, routing, solution):
    """解を表示"""
    print('Objective: {} miles'.format(solution.ObjectiveValue()))
    index = routing.Start(0)
    plan_output = 'Route:\n'
    route_distance = 0
    while not routing.IsEnd(index):
        plan_output += ' {} ->'.format(manager.IndexToNode(index))
        previous_index = index
        index = solution.Value(routing.NextVar(index))
        route_distance += routing.GetArcCostForVehicle(previous_index, index, 0)
    plan_output += ' {}\n'.format(manager.IndexToNode(index))
    print(plan_output)
    print('Route distance: {} miles'.format(route_distance))

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.first_solution_strategy = (routing_enums_pb2.FirstSolutionStrategy.PATH_CHEAPEST_ARC)

    # 解を求める
    solution = routing.SolveWithParameters(search_parameters)

    # 解を表示
    if solution:
        print_solution(manager, routing, solution)

if __name__ == '__main__':
    main()

from ortools.sat.python import cp_model

def constraint_programming_example():
    # モデルを作成
    model = cp_model.CpModel()

    # 変数の作成
    x = model.NewIntVar(0, 10, 'x')
    y = model.NewIntVar(0, 10, 'y')
    z = model.NewIntVar(0, 10, 'z')

    # 制約の設定
    model.Add(x + y + z == 15)
    model.Add(x > y)
    model.Add(z < x + 2)

    # 目的関数の設定
    model.Maximize(x + 2 * y + 3 * z)

    # ソルバーを作成して解を求める
    solver = cp_model.CpSolver()
    status = solver.Solve(model)

    if status == cp_model.OPTIMAL:
        print('解が見つかりました:')
        print('x =', solver.Value(x))
        print('y =', solver.Value(y))
        print('z =', solver.Value(z))
        print('最適値 =', solver.ObjectiveValue())
    else:
        print('最適解が見つかりませんでした')

constraint_programming_example()