import scipy.integrate as integrate

# 定義する関数
def f(x):
    return x ** 2

# 数値積分
result, error = integrate.quad(f, 0, 1)
print("積分の結果:", result)

import numpy as np
import scipy.optimize as optimize

# 定義する関数
def f(x):
    return x ** 2 + 10 * np.sin(x)

# 最小化
result = optimize.minimize(f, x0=0)
print("最適化の結果:", result.x)

# 定義する方程式
def equation(x):
    return x ** 2 - 2

# 解を求める
solution = optimize.root(equation, x0=1)
print("方程式の解:", solution.x)

import scipy.linalg as linalg
import numpy as np

# 行列の定義
A = np.array([[3, 2], [1, 4]])
B = np.array([1, 2])

# 線形方程式の解を求める
x = linalg.solve(A, B)
print("方程式の解:", x)

# 行列の逆行列を求める
A_inv = linalg.inv(A)
print("逆行列:", A_inv)

from scipy.signal import butter, filtfilt
import numpy as np

# バターワースフィルタの設計
b, a = butter(N=4, Wn=0.2)

# 信号の定義（繰り返し）
signal = np.tile([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 3)  # 繰り返して長さを増やす

# フィルタリング
filtered_signal = filtfilt(b, a, signal)
print("フィルタリング後の信号:", filtered_signal)

from scipy import stats

# データの定義
data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# 平均と標準偏差
mean = np.mean(data)
std_dev = np.std(data)
print("平均:", mean, "標準偏差:", std_dev)

# 正規分布のフィッティング
param = stats.norm.fit(data)
print("正規分布のパラメータ:", param)

from scipy.interpolate import interp1d
import matplotlib.pyplot as plt

# データの定義
x = np.linspace(0, 10, 10)
y = np.sin(x)

# 線形補間
f = interp1d(x, y, kind='linear')

# 新しいデータ点の生成
x_new = np.linspace(0, 10, 100)
y_new = f(x_new)

# プロット
plt.plot(x, y, 'o', label='Original data')
plt.plot(x_new, y_new, '-', label='Interpolated data')
plt.legend()
plt.show()

import pulp

# 問題の定義
model = pulp.LpProblem("Maximize_Profit", pulp.LpMaximize)

# 変数の定義
x = pulp.LpVariable("x", lowBound=0, cat='Continuous')
y = pulp.LpVariable("y", lowBound=0, cat='Continuous')

# 目的関数の定義
model += 40 * x + 30 * y, "Total Profit"

# 制約条件の定義
model += 2 * x + y <= 20, "Constraint 1"
model += 4 * x + 3 * y <= 45, "Constraint 2"

# 問題を解く
model.solve()

# 結果の表示
print(f"Status: {pulp.LpStatus[model.status]}")
print(f"x: {pulp.value(x)}")
print(f"y: {pulp.value(y)}")
print(f"Total Profit: {pulp.value(model.objective)}")

# 変数の定義 (整数)
x = pulp.LpVariable("x", lowBound=0, cat='Integer')
y = pulp.LpVariable("y", lowBound=0, cat='Integer')

# 問題の定義、目的関数、制約条件は前述の通り

# 目的関数の定義 (例: 50% の重みを持つ2つの目的関数)
model += 0.5 * (40 * x + 30 * y) + 0.5 * (30 * x + 20 * y), "Combined Objective"

constraints = [
    (2 * x + y <= 20, "Raw Material Constraint"),
    (4 * x + 3 * y <= 45, "Labor Constraint")
]

for constraint, name in constraints:
    model += constraint, name

# CBCソルバーを使用
solver = pulp.PULP_CBC_CMD()
model.solve(solver)

import pulp

# 問題の定義
model = pulp.LpProblem("Minimize_Transportation_Cost", pulp.LpMinimize)

# サプライチェーンの定義
warehouses = ["A", "B"]
stores = ["X", "Y", "Z"]
supply = {"A": 300, "B": 400}
demand = {"X": 250, "Y": 350, "Z": 100}

# 輸送コストの定義
costs = {"A": {"X": 2, "Y": 4, "Z": 5}, "B": {"X": 3, "Y": 1, "Z": 3}}

# 変数の定義
vars = pulp.LpVariable.dicts("Route", (warehouses, stores), lowBound=0, cat='Continuous')

# 目的関数の定義
model += pulp.lpSum([vars[w][s] * costs[w][s] for w in warehouses for s in stores]), "Total Cost"

# 制約条件の定義
for w in warehouses:
    model += pulp.lpSum([vars[w][s] for s in stores]) <= supply[w], f"Supply_{w}"

for s in stores:
    model += pulp.lpSum([vars[w][s] for w in warehouses]) >= demand[s], f"Demand_{s}"

# 問題を解く
model.solve()

# 結果の表示
print(f"Status: {pulp.LpStatus[model.status]}")
for w in warehouses:
    for s in stores:
        print(f"Route {w} to {s}: {pulp.value(vars[w][s])} units")
print(f"Total Cost: {pulp.value(model.objective)}")

import polars as pl

data = {
    "name": ["Alice", "Bob", "Charlie"],
    "age": [25, 30, 35],
    "city": ["New York", "Los Angeles", "Chicago"]
}

df = pl.DataFrame(data)
print(df)

df = pl.read_csv("your_file.csv")
print(df)

# 列の選択
df = df.select(["name", "age"])

# フィルタリング
df = df.filter(pl.col("age") > 30)

# 列の追加
df = df.with_column((pl.col("age") * 2).alias("age_doubled"))

print(df)

# 欠損値の処理
df = df.fill_null("unknown")

# 重複の削除
df = df.unique(subset=["name"])

print(df)

# グループ化して集計
df = df.groupby("city").agg([
    pl.sum("age").alias("total_age"),
    pl.mean("age").alias("average_age")
])

print(df)

data1 = {"name": ["Alice", "Bob"], "age": [25, 30]}
data2 = {"name": ["Charlie", "David"], "city": ["Chicago", "San Francisco"]}

df1 = pl.DataFrame(data1)
df2 = pl.DataFrame(data2)

df = df1.join(df2, on="name", how="left")
print(df)

import time
import pandas as pd

data = {
    "a": range(100000000),
    "b": range(100000000, 0, -1)
}

# Pandasでの処理
start = time.time()
pdf = pd.DataFrame(data)
pdf["c"] = pdf["a"] + pdf["b"]
print("Pandas処理時間:", time.time() - start)

# Polarsでの処理
start = time.time()
pldf = pl.DataFrame(data)
pldf = pldf.with_column((pl.col("a") + pl.col("b")).alias("c"))
print("Polars処理時間:", time.time() - start)

from constraint import *

# 問題を定義
problem = Problem()

# 変数の追加
problem.addVariable('x', range(10))  # xは0から9までの値をとる
problem.addVariable('y', range(10))  # yは0から9までの値をとる

# 制約条件の追加
def constraint_func(x, y):
    return x + y == 5

problem.addConstraint(constraint_func, ['x', 'y'])

# 解を取得
solutions = problem.getSolutions()

# 解の表示
for solution in solutions:
    print(solution)

problem.addVariable('z', [1, 2, 4, 8, 16])

# 全ての変数の値が異なるように制約を追加
problem.addConstraint(AllDifferentConstraint(), ['x', 'y', 'z'])

# すべての変数が異なる値を持つ
problem.addConstraint(AllDifferentConstraint(), ['x', 'y', 'z'])

# 変数の合計が10になるように制約する
problem.addConstraint(ExactSumConstraint(10), ['x', 'y', 'z'])

def custom_constraint(a, b):
    return a * b <= 20

problem.addConstraint(custom_constraint, ['x', 'y'])

problem.addConstraint(lambda x: x != 5, ['x'])  # xは5を取らない

from constraint import *

# 問題を定義
problem = Problem()

# 変数の追加
rows = range(1, 10)
cols = range(1, 10)

# 各セルに1から9の値を割り当てる
for row in rows:
    for col in cols:
        problem.addVariable((row, col), range(1, 10))

# 各行に対して全ての数が異なるように制約
for row in rows:
    problem.addConstraint(AllDifferentConstraint(), [(row, col) for col in cols])

# 各列に対して全ての数が異なるように制約
for col in cols:
    problem.addConstraint(AllDifferentConstraint(), [(row, col) for row in rows])

# 各3x3のボックスに対して全ての数が異なるように制約
for box_row in range(3):
    for box_col in range(3):
        cells = [(row, col) for row in range(box_row*3+1, box_row*3+4) for col in range(box_col*3+1, box_col*3+4)]
        problem.addConstraint(AllDifferentConstraint(), cells)

# 解を取得
solutions = problem.getSolutions()

# 解の表示（最初の解のみ）
if solutions:
    solution = solutions[0]
    for row in rows:
        print([solution[(row, col)] for col in cols])
else:
    print("No solution found.")

from ortools.sat.python import cp_model

def job_shop_scheduling():
    # Create the model.
    model = cp_model.CpModel()

    jobs_data = [  # (machine_id, processing_time).
        [(0, 3), (1, 2), (2, 2)],
        [(0, 2), (2, 1), (1, 4)],
        [(1, 4), (2, 3)]
    ]

    machines_count = 3
    all_tasks = {}
    machine_to_intervals = [[] for _ in range(machines_count)]
    horizon = sum(task[1] for job in jobs_data for task in job)

    # Create job variables and constraints.
    for job_id, job in enumerate(jobs_data):
        for task_id, task in enumerate(job):
            machine = task[0]
            duration = task[1]
            suffix = '_%i_%i' % (job_id, task_id)
            start_var = model.NewIntVar(0, horizon, 'start' + suffix)
            end_var = model.NewIntVar(0, horizon, 'end' + suffix)
            interval_var = model.NewIntervalVar(start_var, duration, end_var, 'interval' + suffix)
            all_tasks[job_id, task_id] = (start_var, end_var, interval_var)
            machine_to_intervals[machine].append(interval_var)

    # Create and add disjunctive constraints.
    for machine_intervals in machine_to_intervals:
        model.AddNoOverlap(machine_intervals)

    # Precedences inside a job.
    for job_id, job in enumerate(jobs_data):
        for task_id in range(len(job) - 1):
            model.Add(all_tasks[job_id, task_id + 1][0] >= all_tasks[job_id, task_id][1])

    # Makespan objective.
    obj_var = model.NewIntVar(0, horizon, 'makespan')
    model.AddMaxEquality(obj_var, [all_tasks[job_id, len(job) - 1][1] for job_id, job in enumerate(jobs_data)])
    model.Minimize(obj_var)

    # Solve the model.
    solver = cp_model.CpSolver()
    status = solver.Solve(model)

    # Print solution.
    if status == cp_model.OPTIMAL or status == cp_model.FEASIBLE:
        print('Optimal Schedule Length: %i' % solver.ObjectiveValue())
        print()
        for job_id, job in enumerate(jobs_data):
            print('Job %i:' % job_id)
            for task_id, task in enumerate(job):
                start_var, end_var, _ = all_tasks[job_id, task_id]
                print('Task %i starts at %i and ends at %i' % (
                    task_id, solver.Value(start_var), solver.Value(end_var)))
    else:
        print('No solution found.')

job_shop_scheduling()

from ortools.sat.python import cp_model

def job_shop_scheduling():
    # Create the model.
    model = cp_model.CpModel()

jobs_data = [  # (machine_id, processing_time).
    [(0, 3), (1, 2), (2, 2)],
    [(0, 2), (2, 1), (1, 4)],
    [(1, 4), (2, 3)]
]

machines_count = 3
all_tasks = {}
machine_to_intervals = [[] for _ in range(machines_count)]
horizon = sum(task[1] for job in jobs_data for task in job)

# Create job variables and constraints.
for job_id, job in enumerate(jobs_data):
    for task_id, task in enumerate(job):
        machine = task[0]
        duration = task[1]
        suffix = '_%i_%i' % (job_id, task_id)
        start_var = model.NewIntVar(0, horizon, 'start' + suffix)
        end_var = model.NewIntVar(0, horizon, 'end' + suffix)
        interval_var = model.NewIntervalVar(start_var, duration, end_var, 'interval' + suffix)
        all_tasks[job_id, task_id] = (start_var, end_var, interval_var)
        machine_to_intervals[machine].append(interval_var)

# Create and add disjunctive constraints.
for machine_intervals in machine_to_intervals:
    model.AddNoOverlap(machine_intervals)

# Precedences inside a job.
for job_id, job in enumerate(jobs_data):
    for task_id in range(len(job) - 1):
        model.Add(all_tasks[job_id, task_id + 1][0] >= all_tasks[job_id, task_id][1])

# Makespan objective.
obj_var = model.NewIntVar(0, horizon, 'makespan')
model.AddMaxEquality(obj_var, [all_tasks[job_id, len(job) - 1][1] for job_id, job in enumerate(jobs_data)])
model.Minimize(obj_var)

# Solve the model.
solver = cp_model.CpSolver()
status = solver.Solve(model)

    # Print solution.
    if status == cp_model.OPTIMAL or status == cp_model.FEASIBLE:
        print('Optimal Schedule Length: %i' % solver.ObjectiveValue())
        print()
        for job_id, job in enumerate(jobs_data):
            print('Job %i:' % job_id)
            for task_id, task in enumerate(job):
                start_var, end_var, _ = all_tasks[job_id, task_id]
                print('Task %i starts at %i and ends at %i' % (
                    task_id, solver.Value(start_var), solver.Value(end_var)))
    else:
        print('No solution found.')

job_shop_scheduling()

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

def create_data_model():
    data = {}
    data['distance_matrix'] = [
        [0, 2, 9, 10],
        [1, 0, 6, 4],
        [15, 7, 0, 8],
        [6, 3, 12, 0],
    ]
    data['num_vehicles'] = 1
    data['depot'] = 0
    return data

def print_solution(manager, routing, solution):
    print('Objective: {}'.format(solution.ObjectiveValue()))
    index = routing.Start(0)
    plan_output = 'Route for vehicle 0:\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))
    plan_output += 'Distance of the route: {}m\n'.format(route_distance)
    print(plan_output)

def vehicle_routing_problem():
    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)

vehicle_routing_problem()

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

def create_data_model():
    data = {}
    data['distance_matrix'] = [
        [0, 2, 9, 10],
        [1, 0, 6, 4],
        [15, 7, 0, 8],
        [6, 3, 12, 0],
    ]
    data['num_vehicles'] = 1
    data['depot'] = 0
    return data

def print_solution(manager, routing, solution):
    print('Objective: {}'.format(solution.ObjectiveValue()))
    index = routing.Start(0)
    plan_output = 'Route for vehicle 0:\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))
    plan_output += 'Distance of the route: {}m\n'.format(route_distance)
    print(plan_output)

def vehicle_routing_problem():
    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)

vehicle_routing_problem()

from ortools.linear_solver import pywraplp

def integer_optimization_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(2 * x + 3 * y <= 12)

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

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

    # 結果を表示
    if status == pywraplp.Solver.OPTIMAL:
        print('Objective value =', solver.Objective().Value())
        print('x =', x.solution_value())
        print('y =', y.solution_value())
    else:
        print('The problem does not have an optimal solution.')

integer_optimization_example()

from ortools.linear_solver import pywraplp

solver = pywraplp.Solver.CreateSolver('SCIP')
if not solver:
    return

x = solver.IntVar(0, 10, 'x')
y = solver.IntVar(0, 10, 'y')

solver.Add(2 * x + 3 * y <= 12)

solver.Maximize(3 * x + 4 * y)

status = solver.Solve()

if status == pywraplp.Solver.OPTIMAL:
    print('Objective value =', solver.Objective().Value())
    print('x =', x.solution_value())
    print('y =', y.solution_value())
else:
    print('The problem does not have an optimal solution.')

integer_optimization_example()

!pip install ortools
from ortools.linear_solver import pywraplp

def linear_optimization_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('Objective value =', solver.Objective().Value())
        print('x =', x.solution_value())
        print('y =', y.solution_value())
    else:
        print('The problem does not have an optimal solution.')

linear_optimization_example()

from ortools.linear_solver import pywraplp

def linear_optimization_example():

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('Objective value =', solver.Objective().Value())
    print('x =', x.solution_value())
    print('y =', y.solution_value())
else:
    print('The problem does not have an optimal solution.')

linear_optimization_example()

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

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

toolbox = base.Toolbox()
toolbox.register("attr_float", random.uniform, -10, 10)
toolbox.register("individual", tools.initRepeat, creator.Individual, toolbox.attr_float, n=10)
toolbox.register("population", tools.initRepeat, list, toolbox.individual)

def eval_function(individual):
    return sum(individual),

toolbox.register("evaluate", eval_function)

toolbox.register("mate", tools.cxTwoPoint)
toolbox.register("mutate", tools.mutGaussian, mu=0, sigma=1, indpb=0.2)
toolbox.register("select", tools.selTournament, tournsize=3)

def main():
    random.seed(42)
    population = toolbox.population(n=300)
    ngen = 40
    cxpb = 0.5
    mutpb = 0.2

    # 適応度の計算
    fitnesses = list(map(toolbox.evaluate, population))
    for ind, fit in zip(population, fitnesses):
        ind.fitness.values = fit

    # 進化のループ
    for g in range(ngen):
        print(f"-- Generation {g} --")

        # 選択
        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() < cxpb:
                toolbox.mate(child1, child2)
                del child1.fitness.values
                del child2.fitness.values

        for mutant in offspring:
            if random.random() < mutpb:
                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

        # 統計の表示
        fits = [ind.fitness.values[0] for ind in population]
        length = len(population)
        mean = sum(fits) / length
        sum2 = sum(x*x for x in fits)
        std = abs(sum2 / length - mean**2)**0.5

        print(f"Min: {min(fits)}, Max: {max(fits)}, Avg: {mean}, Std: {std}")

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

if __name__ == "__main__":
    main()

random.seed(42)
population = toolbox.population(n=300)
ngen = 40
cxpb = 0.5
mutpb = 0.2

fitnesses = list(map(toolbox.evaluate, population))
for ind, fit in zip(population, fitnesses):
    ind.fitness.values = fit

for g in range(ngen):
    print(f"-- Generation {g} --")

    # 選択
    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() < cxpb:
        toolbox.mate(child1, child2)
        del child1.fitness.values
        del child2.fitness.values

for mutant in offspring:
    if random.random() < mutpb:
        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

fits = [ind.fitness.values[0] for ind in population]
length = len(population)
mean = sum(fits) / length
sum2 = sum(x*x for x in fits)
std = abs(sum2 / length - mean**2)**0.5

print(f"Min: {min(fits)}, Max: {max(fits)}, Avg: {mean}, Std: {std}")

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

import networkx as nx

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

# 有向グラフの作成
D = nx.DiGraph()

# ノードの追加
G.add_node(1)
G.add_nodes_from([2, 3])

# エッジの追加
G.add_edge(1, 2)
G.add_edges_from([(2, 3), (3, 1)])

# ノード属性の設定
G.nodes[1]['color'] = 'red'

# エッジ属性の設定
G.edges[1, 2]['weight'] = 4.7

import matplotlib.pyplot as plt

nx.draw(G, with_labels=True)
plt.show()

# ノードの色を属性に基づいて設定
colors = [G.nodes[n]['color'] if 'color' in G.nodes[n] else 'blue' for n in G.nodes]
nx.draw(G, node_color=colors, with_labels=True)
plt.show()

# 最短経路の計算
shortest_path = nx.shortest_path(G, source=1, target=3)
print(shortest_path)

# クラスタリング係数の計算
clustering = nx.clustering(G)
print(clustering)

# 連結成分の計算
components = list(nx.connected_components(G))
print(components)

# 完全グラフ
K = nx.complete_graph(5)

# エルデシュ・レーニィランダムグラフ
ER = nx.erdos_renyi_graph(100, 0.15)

# バラバシ・アルバートモデルのスケールフリーネットワーク
BA = nx.barabasi_albert_graph(100, 5)

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

# ファイルからグラフを読み込み
G = nx.read_gml("graph.gml")

# Karate Club Graphの読み込み
G = nx.karate_club_graph()

# 基本情報の表示
print(f"Number of nodes: {G.number_of_nodes()}")
print(f"Number of edges: {G.number_of_edges()}")
print(f"Nodes: {list(G.nodes(data=True))}")
print(f"Edges: {list(G.edges(data=True))}")

# 描画
nx.draw(G, with_labels=True)
plt.show()