虚数は、実数部と虚数部から構成される数学の概念で、虚数単位 $ (i) $は$ (\sqrt{-1}) $と表現されます。

複素数は通常$ (a + bi) $の形で表され、$ (a) $が実数部、$ (b) $が虚数部です。

虚数は様々な科学や工学の分野で利用され、波動解析や制御理論、量子力学などで重要な役割を果たします。

以下に、$ [f(z) = \sin(z) + \cos(2z) + e^{0.5z} = 0] $という方程式の3DグラフをPythonで描画します。

この例は虚数を含む関数を視覚的に理解するのに役立つものです。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

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

# 方程式の例: f(z) = sin(z) + cos(2z) + e^(0.5z)
def complex_equation(z):
    return np.sin(z) + np.cos(2*z) + np.exp(0.5*z)

# 複素数を生成
real_part = np.linspace(-4, 4, 400)
imaginary_part = np.linspace(-4, 4, 400)
real, imag = np.meshgrid(real_part, imaginary_part)
z = real + 1j * imag

# 方程式の値を計算
result = complex_equation(z)

# 3Dグラフ化
fig = plt.figure(figsize=(10, 8))
ax = fig.add_subplot(111, projection='3d')
ax.plot_surface(real, imag, np.abs(result), cmap='viridis', alpha=0.8)

ax.set_title('Complex Equation: $f(z) = \sin(z) + \cos(2z) + e^{0.5z} = 0$')
ax.set_xlabel('Real Part')
ax.set_ylabel('Imaginary Part')
ax.set_zlabel('|f(z)|')
plt.show()

この例では、虚数を含む関数の3Dプロットを通じて、虚数部の変化が方程式に与える影響を視覚化しています。

[実行結果]

ソースコード解説

以下に、ソースコードの各部分の説明を示します。

1. 必要なライブラリのインポート:

1
2
3

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

• numpy: 数学的な計算を行うための便利なツールを提供するライブラリ。
• matplotlib.pyplot: グラフの描画に使用されるライブラリ。
• mpl_toolkits.mplot3d.Axes3D: 3Dグラフを描画するための追加のツールキット。

2. 複雑な方程式の定義:

1
2

def complex_equation(z):
    return np.sin(z) + np.cos(2*z) + np.exp(0.5*z)

• complex_equation:$ (f(z) = \sin(z) + \cos(2z) + e^{0.5z}) $という複雑な方程式を計算する関数。

3. 複素数の生成:

1
2
3
4

real_part = np.linspace(-4, 4, 400)
imaginary_part = np.linspace(-4, 4, 400)
real, imag = np.meshgrid(real_part, imaginary_part)
z = real + 1j * imag

• np.linspace(): 指定された範囲で等間隔の数値を生成。
• np.meshgrid(): 2Dグリッド座標の生成。
• z: 生成された複素数。

4. 方程式の値の計算:

1

result = complex_equation(z)

• result: 生成された複素数に対して方程式を計算し、その結果を格納。

5. 3Dグラフの作成:

1
2
3

fig = plt.figure(figsize=(10, 8))
ax = fig.add_subplot(111, projection='3d')
ax.plot_surface(real, imag, np.abs(result), cmap='viridis', alpha=0.8)

• plt.figure(): 新しい図を作成。
• fig.add_subplot(): サブプロットを追加。
• ax.plot_surface(): 3Dサーフェスプロットを描画。
• cmap='viridis': カラーマップを ‘viridis’ に設定。
• alpha=0.8: 透明度を設定。

6. グラフのラベルと表示:

1
2
3
4
5

ax.set_title('Complex Equation: $f(z) = \sin(z) + \cos(2z) + e^{0.5z} = 0$')
ax.set_xlabel('Real Part')
ax.set_ylabel('Imaginary Part')
ax.set_zlabel('|f(z)|')
plt.show()

• グラフにタイトルと軸ラベルを追加。
• plt.show(): グラフを表示。

このコードは、複雑な方程式の複素平面上での振る舞いを3Dグラフで可視化する例です。

結果解説

[実行結果]

上記の3Dグラフは、$ [f(z) = \sin(z) + \cos(2z) + e^{0.5z}] $という方程式の絶対値を視覚化しています。

この方程式は虚数$ (z) $を含んでおり、その絶対値（モジュラス）を求めています。

• x軸は実数部を、y軸は虚数部を表しています。
  z軸は方程式の絶対値 $ (|f(z)|) $を示しています。
• グラフ上の点は、複素平面上の異なる$ (z) $の値に対応しています。
• グラフの色は、絶対値の大小を示しており、色が濃いほど絶対値が大きいことを表しています。

このグラフは、複素数$ (z) $を方程式に代入したときの絶対値の変化を表しています。

虚数部の変化が方程式に与える影響を理解するのに役立ちます。

グラフを観察することで、特定の領域で方程式がどのように振る舞うかを視覚的に捉えることができます。

3次元グラフ

3次元グラフ化*するためのPythonコードを提供します。

この例では、方程式として$ z = \sin(\sqrt{x^2 + y^2}) $を使用します。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

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

# 3Dグラフを作成するためのデータ生成
x = np.linspace(-5, 5, 100)
y = np.linspace(-5, 5, 100)
x, y = np.meshgrid(x, y)
z = np.sin(np.sqrt(x**2 + y**2))

# 3Dプロット
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
ax.plot_surface(x, y, z, cmap='viridis')

# 軸ラベルの追加
ax.set_xlabel('X軸')
ax.set_ylabel('Y軸')
ax.set_zlabel('Z軸')

# グラフの表示
plt.show()

この例では、numpyを使用して$ (x) $および$ (y) $の値を生成し、それに基づいて$ (z) $を計算しています。

matplotlibライブラリの plot_surface メソッドを使用して、3Dグラフを描画しています。

方程式やプロットのカスタマイズは必要に応じて変更できます。

[実行結果]

ソースコード解説

以下はソースコードの詳しい説明です。

1. NumPyとMatplotlibのインポート:

   1 2 3

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

• numpyは数値計算用のライブラリで、このコードでは数値データを生成するために使用されます。
• matplotlib.pyplotはグラフ描画用のライブラリで、Axes3Dは3Dグラフを描画するための特殊な軸クラスです。

2. データの生成:

   1 2 3 4

   x = np.linspace(-5, 5, 100) y = np.linspace(-5, 5, 100) x, y = np.meshgrid(x, y) z = np.sin(np.sqrt(x**2 + y**2))

• np.linspace(-5, 5, 100)は、$-5$から$5$の範囲を$100$個の等間隔な点で生成します。
• np.meshgrid(x, y)は、これらの1次元配列を基に2次元グリッドを生成します。
• z = np.sin(np.sqrt(x**2 + y**2))は、与えられた$ (x) $および$ (y) $に対して、$ z = \sin(\sqrt{x^2 + y^2}) $の値を計算します。

3. 3Dプロットの作成:

   1 2 3

   fig = plt.figure() ax = fig.add_subplot(111, projection='3d') ax.plot_surface(x, y, z, cmap='viridis')

• plt.figure()で新しい図を作成し、add_subplot(111, projection='3d')で3Dのサブプロットを作成します。
• ax.plot_surface(x, y, z, cmap='viridis')は、3D曲面を描画します。
  cmapはカラーマップを指定します。

4. 軸ラベルの追加:

   1 2 3

   ax.set_xlabel('X軸') ax.set_ylabel('Y軸') ax.set_zlabel('Z軸')

• ax.set_xlabel、ax.set_ylabel、ax.set_zlabelで、それぞれX軸、Y軸、Z軸にラベルを追加します。

5. グラフの表示:

   1	plt.show()

• plt.show()でグラフを表示します。

このコードは、$ z = \sin(\sqrt{x^2 + y^2}) $の関数を用いて3Dグラフを作成し、その可視化を行っています。

グラフ解説

[実行結果]

上記のグラフは、方程式$ z = \sin(\sqrt{x^2 + y^2}) $をグラフ化したものです。

• $ (x) $および$ (y) $の値は、それぞれ -5 から 5 までの範囲で、100 の等間隔な点で生成されています。
• numpy.meshgrid を使用して、これらの$ (x) $および$ (y) $の値からグリッドを形成しています。
• 方程式に基づいて、各$ (x, y) $の組み合わせに対する$ (z) $の値を計算しています。
  この場合、$ z = \sin(\sqrt{x^2 + y^2}) $です。
• 3Dプロットでは、matplotlibの plot_surface メソッドを使用して、計算された$ (x, y, z) $の値に基づいて曲面を描画しています。
• 軸ラベル（X軸、Y軸、Z軸）が追加されています。

このグラフは、曲面が$ z = \sin(\sqrt{x^2 + y^2}) $の形状になっており、$ (x) $と$ (y) $の変動に応じて波打つような特徴があります。

視覚的には、中心から外側に向かって波の振動が広がっていくような形状が確認できます。

交差する正弦波

2つの正弦波が交差するような3次元の方程式を取り上げて、Pythonでグラフ化することを考えてみましょう。

この例では、以下の方程式を考えます。

$$
z = \sin(x) + \cos(y)
$$

この方程式では、$ (x)軸$と$ (y)軸$に対してそれぞれ正弦波と余弦波が影響を与え、3次元グラフでその交差を見ることができます。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

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

# 3次元グラフの範囲を指定
x_range = np.linspace(-5, 5, 100)
y_range = np.linspace(-5, 5, 100)

# メッシュグリッドを作成
x, y = np.meshgrid(x_range, y_range)
z = np.sin(x) + np.cos(y)

# 3Dプロット
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
ax.plot_surface(x, y, z, cmap='viridis')

# ラベルとタイトルの設定
ax.set_xlabel('X')
ax.set_ylabel('Y')
ax.set_zlabel('Z')
ax.set_title('$z = \\sin(x) + \\cos(y)$')

plt.show()

このコードでは、matplotlibとnumpyを使用して3Dプロットを行っています。

方程式には正弦波と余弦波が含まれており、これによって独特の波形が3次元グラフ上に現れます。

[実行結果]

ソースコード解説

以下に、コードの詳細な説明を示します。

1. ライブラリのインポート:

1
2
3

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

• matplotlib.pyplotはグラフのプロットに使用されるライブラリです。
• numpyは数学的な計算に使用され、ここでは特にメッシュグリッドを作成するために利用されます。
• mpl_toolkits.mplot3dモジュールは、3Dプロットのためのツールキットを提供します。

2. 3次元グラフの範囲の指定:

1
2

x_range = np.linspace(-5, 5, 100)
y_range = np.linspace(-5, 5, 100)

• np.linspaceは指定された範囲内で等間隔の数値を生成します。ここでは、$ (x) $および$ (y) $軸の範囲を$ ([-5, 5]) $で100点に設定しています。

3. メッシュグリッドの作成:

1

x, y = np.meshgrid(x_range, y_range)

• np.meshgridは、$ (x) $および$ (y) $の範囲を元に2次元のメッシュグリッドを作成します。
  これにより、各点における$ (x) $と$ (y) $の組み合わせが得られます。

4. 3Dプロットの計算:

1

z = np.sin(x) + np.cos(y)

• ここでは、計算されたメッシュグリッド上の各座標における$ (z) $の値を、正弦波$ (\sin(x)) $と余弦波$ (\cos(y)) $の和として計算しています。

5. 3Dプロットの作成:

1
2
3

fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
ax.plot_surface(x, y, z, cmap='viridis')

• plt.figure()は新しい図を作成します。
• fig.add_subplot(111, projection='3d')は3Dのサブプロットを作成します。
• ax.plot_surfaceは3Dの曲面プロットを行います。
  ここではメッシュグリッド上の各座標における$ (x) $,$ (y) $,$ (z) $の値に基づいて表面をプロットしています。
  カラーマップは ‘viridis’ を使用しています。

6. ラベルとタイトルの設定:

1
2
3
4

ax.set_xlabel('X')
ax.set_ylabel('Y')
ax.set_zlabel('Z')
ax.set_title('$z = \\sin(x) + \\cos(y)$')

• ax.set_xlabel, ax.set_ylabel, ax.set_zlabel はそれぞれX軸、Y軸、Z軸に対するラベルを設定します。
• ax.set_title はプロット全体にタイトルを設定します。

7. グラフの表示:

1

plt.show()

• plt.show()は、作成した図を表示します。

このコード全体で、正弦波と余弦波の和によってできる波の形状を3Dグラフとして視覚化しています。

結果解説

[実行結果]

この3Dグラフは、以下の方程式に基づいて作成されました。

$$
z = \sin(x) + \cos(y)
$$

この方程式では、$ (x)軸$方向には正弦波$ (\sin(x)) $が影響を与え、$ (y)軸$方向には余弦波 $ (\cos(y)) $が影響を与えています。

これらの波が交差するところで、$ (z) $の値が計算されます。

以下はグラフの詳細な説明です：

軸の範囲:

$ (x)軸$と$ (y)軸$はそれぞれ$ ([-5, 5]) $の範囲で設定されています。
これは、波の周期や振幅を適切に表示するための範囲です。

メッシュグリッド:

np.meshgrid を使用して、指定した範囲のメッシュグリッドを生成しています。
これにより、$ (x) $と$ (y) $の各座標の組み合わせに対する$ (z) $の値が計算されます。

波の形状:

$ (z = \sin(x) + \cos(y)) $の計算結果により、各座標における$ (z) $の値が求められます。
正弦波と余弦波が合成され、波の交差や波の振幅が視覚的に表現されます。

3Dプロット:

ax.plot_surface を使用して、メッシュグリッド上の$ (x) $,$ (y) $,$ (z) $の値に基づいて表面プロットを行っています。
カラーマップは ‘viridis’ を使用しています。

軸のラベルとタイトル:

ax.set_xlabel, ax.set_ylabel, ax.set_zlabel を使用して、それぞれの軸にラベルを付け、ax.set_title でグラフ全体にタイトルを付けています。

このグラフは、正弦波と余弦波が複雑に絡み合ってできる特徴的な波形を視覚的に表現しています。

単純な虚数を含む3D方程式の例を示します。

この例では、複素数 z = x + yi を考え、その絶対値がある閾値より小さい範囲を3Dでプロットします。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

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

# 3Dプロットの設定
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')

# x, y座標の範囲設定
x = np.linspace(-5, 5, 100)
y = np.linspace(-5, 5, 100)

# x, y座標の組み合わせ生成
X, Y = np.meshgrid(x, y)

# 複素数の表現: Z = X + Yi
Z = X + 1j*Y

# 方程式: |Z| < threshold
threshold = 2

# 絶対値が閾値未満の場合をTrueにする条件
condition = np.abs(Z) < threshold

# 3Dプロット
ax.scatter(X[condition], Y[condition], np.abs(Z)[condition], c='b', marker='.')

# プロットの設定
ax.set_xlabel('Re(X)')
ax.set_ylabel('Im(Y)')
ax.set_zlabel('|Z|')
ax.set_title('Complex Equation: |Z| < {}'.format(threshold))

# 表示
plt.show()

この例では、Z = X + Yi という複素数を使って、絶対値が閾値未満の範囲を3Dでプロットしています。

np.abs(Z) は複素数の絶対値を計算しています。

閾値より小さい範囲が青い点でプロットされています。

この例を実行すると、虚数に関する3Dプロットが表示されます。

[実行結果]

ソースコード解説

以下にソースコードの詳細な説明を示します：

1. ライブラリのインポート

1
2
3

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

• numpy: 数値計算を行うためのライブラリ。
• matplotlib.pyplot: プロット作成のためのライブラリ。
• mpl_toolkits.mplot3d.Axes3D: 3Dプロットを行うためのモジュール。

2. 3Dプロットの設定

1
2

fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')

• plt.figure(): 新しいプロット用の図を作成。
• fig.add_subplot(111, projection='3d'): 3Dプロット用のサブプロットを作成。

3. x, y座標の範囲設定

1
2

x = np.linspace(-5, 5, 100)
y = np.linspace(-5, 5, 100)

• np.linspace(-5, 5, 100): -5 から 5 までの範囲を 100 等分した値を生成。

4. x, y座標の組み合わせ生成

1

X, Y = np.meshgrid(x, y)

• np.meshgrid(x, y): x と y の座標点を組み合わせて2次元グリッドを生成。

5. 複素数の表現

1

Z = X + 1j*Y

• Z = X + 1j*Y: 複素数の表現。1j は虚数単位。

6. 方程式と閾値の設定

1

threshold = 2

• threshold = 2: 方程式 |Z| < threshold の閾値を設定。

7. 条件の設定

1

condition = np.abs(Z) < threshold

• np.abs(Z) < threshold: 絶対値が閾値未満の場合をTrueにする条件を設定。

8. 3Dプロット

1

ax.scatter(X[condition], Y[condition], np.abs(Z)[condition], c='b', marker='.')

• ax.scatter(): 3D散布図をプロット。条件を満たす座標点に対応する複素数の絶対値を青い点としてプロット。

9. プロットの設定

1
2
3
4

ax.set_xlabel('Re(X)')
ax.set_ylabel('Im(Y)')
ax.set_zlabel('|Z|')
ax.set_title('Complex Equation: |Z| < {}'.format(threshold))

• 軸ラベルおよびタイトルの設定。

10. 表示

1

plt.show()

• plt.show(): プロットの表示。

このプログラムは、虚数平面上の条件を可視化するために3Dプロットを使用しています。

閾値 threshold 未満の複素数領域が、複素平面上で青い点として表示されます。

結果解説

[実行結果]

上記のコードは、複素数を用いた方程式 |Z| < threshold の解を3Dプロットしています。

ここで、Z は複素数で、Z = X + Yi と表されます。この方程式は、複素平面上で絶対値がある閾値 threshold 未満の領域を表します。

以下はプロットの詳細な説明です：

1. X および Y 座標は、それぞれ -5 から 5 までの範囲で 100 等分された値を取ります。これにより、複素平面上の座標点を生成します。

2. X と Y の座標点を組み合わせて、Z = X + Yi の複素数の表現を生成します。

3. 方程式 |Z| < threshold を満たす条件を condition として設定します。

4. condition を満たす座標点に対応する複素数の絶対値 |Z| をプロットします。これにより、|Z| < threshold の範囲が3D空間に青い点として可視化されます。

5. プロットには Re(X)（実部）、Im(Y)（虚部）、および |Z|（絶対値）の軸が使用されています。

このプロットでは、閾値 threshold 未満の領域が複素平面上で青い点として浮かび上がります。

これは、複素数がこの条件を満たす領域を示しています。

バケーション最適化

バケーションに関する最適化問題の一例として、「与えられた旅行先のリストと各場所の観光ポイント数と交通手段のコストが与えられたとき、特定の日数内で最も多くの観光ポイントを訪れるための最適な旅程を見つける」という問題を考えてみましょう。

これを解くための単純な贅沢な旅行計画をPythonで実装してみます。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

from itertools import permutations

def optimize_vacation(destinations, days):
    # 各目的地の観光ポイント数と交通手段のコストを設定
    attractions = {
        'Tokyo': {'points': 10, 'cost': 50},
        'Kyoto': {'points': 8, 'cost': 40},
        'Osaka': {'points': 6, 'cost': 30},
        'Hiroshima': {'points': 7, 'cost': 35},
        'Sapporo': {'points': 5, 'cost': 25}
        # 他の目的地も必要に応じて追加
    }

    best_itinerary = None
    max_points = 0

    # 目的地の順列を生成
    for perm in permutations(destinations):
        total_days = min(len(destinations), days)
        current_points = 0
        current_cost = 0

        # 旅程を評価
        for i in range(total_days):
            current_points += attractions[perm[i]]['points']
            current_cost += attractions[perm[i]]['cost']

        # 予算内で最大のポイントを持つ旅程を更新
        if current_cost <= 150 and current_points > max_points:
            max_points = current_points
            best_itinerary = perm

    return best_itinerary, max_points

# 旅行先のリストと旅行日数を設定
destinations = ['Tokyo', 'Kyoto', 'Osaka', 'Hiroshima', 'Sapporo']
days = 3

# 最適な旅程を計算
best_itinerary, max_points = optimize_vacation(destinations, days)

# 結果の表示
print(f"最適な旅程: {best_itinerary}")
print(f"獲得ポイント: {max_points}")

このサンプルコードでは、destinationsに旅行先のリストを、daysに旅行日数を指定しています。

各目的地の観光ポイント数と交通手段のコストが与えられ、予算内で最も多くのポイントを獲得する最適な旅程を見つけます。

[実行結果]

最適な旅程: ('Tokyo', 'Kyoto', 'Hiroshima', 'Osaka', 'Sapporo')
獲得ポイント: 25

ソースコード解説

以下にソースコードの章立てと詳細な説明を示します。

1. ライブラリのインポート

1

from itertools import permutations

• itertoolsモジュールからpermutations関数をインポートしています。
• permutations関数は、与えられたリストの順列を生成するために使用されます。

2. 旅行最適化関数の定義

1
2

def optimize_vacation(destinations, days):
    # ...（後続のコードが続く）

• 与えられた旅行先と旅行日数に対して、最適な旅行プランを見つけるための関数 optimize_vacation を定義しています。

3. 目的地の情報と初期化

1
2
3
4
5
6
7
8

attractions = {
    'Tokyo': {'points': 10, 'cost': 50},
    'Kyoto': {'points': 8, 'cost': 40},
    'Osaka': {'points': 6, 'cost': 30},
    'Hiroshima': {'points': 7, 'cost': 35},
    'Sapporo': {'points': 5, 'cost': 25}
    # 他の目的地も必要に応じて追加
}

• attractionsという辞書型の変数に、各目的地の観光ポイント数と交通手段のコストを定義しています。
• 各目的地は都市名をキーに持ち、その値は観光ポイント数とコストの辞書です。

4. 結果を格納する変数の初期化

1
2

best_itinerary = None
max_points = 0

• 最適な旅程と最大のポイントを格納する変数を初期化しています。

5. 目的地の順列生成と旅程評価

1
2
3
4
5
6
7
8

for perm in permutations(destinations):
    total_days = min(len(destinations), days)
    current_points = 0
    current_cost = 0

    for i in range(total_days):
        current_points += attractions[perm[i]]['points']
        current_cost += attractions[perm[i]]['cost']

• permutations(destinations) によって、目的地のリストから順列を生成します。
• 各順列に対して、与えられた旅行日数内での旅程を評価しています。
• current_points は現在の旅程で獲得できる観光ポイント数を、current_cost はその旅程の総コストを表します。

6. 予算内で最大のポイントを持つ旅程の更新

1
2
3

if current_cost <= 150 and current_points > max_points:
    max_points = current_points
    best_itinerary = perm

• 予算内で最大のポイントを持つ旅程を見つけた場合、best_itinerary と max_points を更新します。

7. 結果を返す

1

return best_itinerary, max_points

• 最適な旅程とその際の獲得ポイントを返します。

8. 旅程の計算と結果の表示

1
2
3
4
5
6
7

destinations = ['Tokyo', 'Kyoto', 'Osaka', 'Hiroshima', 'Sapporo']
days = 3

best_itinerary, max_points = optimize_vacation(destinations, days)

print(f"最適な旅程: {best_itinerary}")
print(f"獲得ポイント: {max_points}")

• 旅行先のリストと旅行日数を指定して、optimize_vacation 関数を呼び出し、最適な旅程と獲得ポイントを計算します。
• 結果をコンソールに表示します。

結果解説

[実行結果]

最適な旅程: ('Tokyo', 'Kyoto', 'Hiroshima', 'Osaka', 'Sapporo')
獲得ポイント: 25

この結果は、与えられた旅行先のリストと旅行日数に対して、予算内で最も多くのポイントを獲得するための最適な旅程が次のようになることを示しています：

• 最適な旅程: (‘Tokyo’, ‘Kyoto’, ‘Hiroshima’, ‘Osaka’, ‘Sapporo’)
• 獲得ポイント: 25

各目的地には観光ポイント数が割り当てられており、この目的地の順列を生成していくつかの旅行プランを試しました。
予算は総コストが150以下である制約があり、それを満たしながら最も多くの観光ポイントを獲得できる旅程を見つけることが目的です。

解析結果に基づいて、最適な旅程は(‘Tokyo’, ‘Kyoto’, ‘Hiroshima’, ‘Osaka’, ‘Sapporo’)で、この旅程で訪れた各都市の観光ポイント数を合算すると25ポイントになります。

獲得ポイントが最大であるため、この旅程が与えられた条件下で最適な選択となります。

虚数に関する方程式を3Dグラフ化するためには、matplotlibやmpl_toolkits.mplot3dを使用します。

以下に、虚数を含む方程式の例と、それをPythonで3Dグラフ化するためのコードを示します。

この例では、複素数 z = x + yi を使用します。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

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

# 虚数を含む方程式の例: z^2 = x + yi
def complex_equation(x, y):
    z = x + 1j*y
    return z**2

# 3Dグラフの生成
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')

# x, yの値の範囲を設定
x_vals = np.linspace(-5, 5, 100)
y_vals = np.linspace(-5, 5, 100)

# x, yの組み合わせで方程式の値を計算
X, Y = np.meshgrid(x_vals, y_vals)
Z = complex_equation(X, Y)

# 3Dプロット
ax.plot_surface(X, Y, np.real(Z), cmap='viridis', alpha=0.8)
ax.set_xlabel('Real')
ax.set_ylabel('Imaginary')
ax.set_zlabel('Result')

plt.show()

この例では、方程式として $ z^2 = x + yi $ を採用しています。

complex_equation関数は、与えられた複素数 z に対する方程式の値を計算します。

そして、numpyを使用してxとyの範囲を設定し、それに対応する方程式の値を計算しています。

最後に、mpl_toolkits.mplot3dを使って3Dグラフを作成しています。

このコードを実行すると、xおよびyが実数、zが虚数の方程式の3Dグラフが表示されます。

[実行結果]

ソースコード解説

このPythonソースコードは、複素数に関する方程式 $ z^2 = x + yi $ を3Dグラフで可視化するものです。

以下に、ソースコードの詳細な説明を行います。

1. ライブラリのインポート

1
2
3

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

• numpy: 数値計算を支援するライブラリ。
  このコードでは、数値の配列や範囲生成に使用されます。
• matplotlib.pyplot: グラフ描画のためのライブラリ。
• mpl_toolkits.mplot3d: 3Dグラフ描画のためのツールキット。

2. 複素数を含む方程式の定義

1
2
3

def complex_equation(x, y):
    z = x + 1j*y
    return z**2

• complex_equation 関数は、実数 x と虚数 y を引数に取り、それらを用いて z^2 の計算を行います。
  ここで 1j は虚数単位を表します。

3. 3Dグラフの生成

1
2

fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')

• matplotlibを使用して、新しい3Dグラフを生成します。

4. x, yの値の範囲を設定

1
2

x_vals = np.linspace(-5, 5, 100)
y_vals = np.linspace(-5, 5, 100)

• np.linspace を使用して、-5 から 5 までの範囲を 100 分割した数値を生成し、それを x_vals および y_vals に格納します。

5. x, yの組み合わせで方程式の値を計算

1
2

X, Y = np.meshgrid(x_vals, y_vals)
Z = complex_equation(X, Y)

• np.meshgrid を使用して x_vals と y_vals の組み合わせを生成し、それぞれの組み合わせにおける方程式の値を Z に格納します。

6. 3Dプロット

1

ax.plot_surface(X, Y, np.real(Z), cmap='viridis', alpha=0.8)

• ax.plot_surface を使用して、計算された方程式の結果を3Dプロットします。
  実数部 (np.real(Z)) を X および Y に対応させています。
  cmap='viridis' で viridis カラーマップを指定し、alpha=0.8 で透明度を設定しています。

7. 軸ラベルの設定

1
2
3

ax.set_xlabel('Real')
ax.set_ylabel('Imaginary')
ax.set_zlabel('Result')

• それぞれの軸にラベルを設定しています。

8. グラフの表示

1

plt.show()

• 最後に、生成したグラフを表示します。

このコードは、複素数の方程式が3Dグラフ上でどのように変化するかを直感的に理解できるようにしたものです。

結果解説

[実行結果]

このグラフは、複素数に関する方程式$ z^2 = x + yi $の3Dプロットを示しています。

以下に、グラフに表示される内容の詳細な説明を提供します。

1. 座標軸:

• x軸: 実数部 (x) を表します。
• y軸: 虚数部 (y) を表します。
• z軸: 方程式の結果を表します。

2. 方程式の形:

• 方程式$ z^2 = x + yi $は、複素数$ (z) $の2乗が、実数部$ (x) $と虚数部$ (y) $の合計に等しいことを表しています。

3. 色の変化:

• グラフの色は viridis カラーマップに基づいています。
  色の濃さが高いほど、方程式の結果が大きいことを示しています。

4. 曲面の形状:

• グラフ上の曲面は、実数部$ (x) $と虚数部$ (y) $の組み合わせに対する方程式の結果を表しています。
  曲面の形状は、複素平面内でどのように方程式が変化するかを視覚的に示しています。

5. 曲面の交点や転換点:

• グラフ上での曲面の交点や転換点は、方程式がゼロになる条件や変化する条件を示しています。
  これらの点において、方程式$ z^2 = x + yi $の結果が特に注目される可能性があります。

このグラフは、複素数の方程式が実数部と虚数部に依存する様子を3Dで表現しています。

視覚的な表現を通じて、方程式の挙動や特徴を把握するのに役立ちます。

生産計画問題

PuLP は Python の線形計画問題を解くためのライブラリです。

ここで示す一例として、生産計画問題を解いてみましょう。

生産計画の最適化はビジネスの現場でよく見る問題の一つで、リソースが限られている中で利益を最大化する生産量を決定します。

問題設定:

• 2つの製品（AとB）を生産します。
• 製品Aと製品Bの利益はそれぞれ20ドル、30ドルです。
• 製品Aを作るのには1時間の作業が、製品Bを作るのには2時間の作業が必要です。
• 製造機械が一週間に稼働できるのは100時間です。
• 市場の需要は製品Aが40個、製品Bが30個までです。
• 製品ごとの生産上限は製品Aは30個、製品Bは20個です。

この情報に基づいて、週の利益を最大化する生産計画を立ててみましょう。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

import pulp
import matplotlib.pyplot as plt

# 問題のインスタンスを作成します。最大化問題として定義します。
model = pulp.LpProblem("最大利益問題", pulp.LpMaximize)

# 変数を定義します。生産量は0個以上、上限まで可能です。
x1 = pulp.LpVariable('x1', lowBound=0, upBound=30, cat='Continuous')
x2 = pulp.LpVariable('x2', lowBound=0, upBound=20, cat='Continuous')

# 目的関数を定義します。利益を最大化したいので、製品ごとの利益に生産量を掛けたものの和です。
model += 20 * x1 + 30 * x2

# 制約を定義します。
model += x1 + 2 * x2 <= 100  # 機械の作業時間の制限
model += x1 <= 40  # 製品Aの市場需要
model += x2 <= 30  # 製品Bの市場需要

# 問題を解きます。
model.solve()

このコードは PuLP を使用して問題をモデル化し、解を求めます。

そして解（生産量の最適値）を出力します。

1
2
3
4

# 結果の出力
print(f"製品Aの生産量: {x1.value()}")
print(f"製品Bの生産量: {x2.value()}")
print(f"総利益: {pulp.value(model.objective)}")

[実行結果]

製品Aの生産量: 30.0
製品Bの生産量: 20.0
総利益: 1200.0

結果は、与えられた条件と制約のもとで、利益を最大化する生産量の組み合わせを表しています。

ソースコード解説

このソースコードは、線形計画法（Linear Programming）を用いて最大利益を達成する製造計画を最適化する問題を解いています。

以下はコードの章立てと説明です：

1. ライブラリのインポート

1
2

import pulp
import matplotlib.pyplot as plt

必要なライブラリ（PuLPとMatplotlib）をインポートします。

2. 問題のインスタンス作成

1

model = pulp.LpProblem("最大利益問題", pulp.LpMaximize)

PuLPを使用して最大利益を求める最適化問題のインスタンスを作成します。

3. 変数の定義

1
2

x1 = pulp.LpVariable('x1', lowBound=0, upBound=30, cat='Continuous')
x2 = pulp.LpVariable('x2', lowBound=0, upBound=20, cat='Continuous')

変数 x1 と x2 を定義し、それぞれが0以上30以下、0以上20以下の実数であることを指定します。

4. 目的関数の定義

1

model += 20 * x1 + 30 * x2

最大化したい目的関数を定義します。

この場合、製品Aと製品Bの単位あたりの利益を最大化します。

5. 制約条件の定義

1
2
3

model += x1 + 2 * x2 <= 100  # 機械の作業時間の制限
model += x1 <= 40  # 製品Aの市場需要
model += x2 <= 30  # 製品Bの市場需要

最適化の際に考慮する制約条件を定義します。

これらは機械の作業時間、製品Aおよび製品Bの市場需要です。

6. 最適化の実行

1

model.solve()

PuLPを使用して最適化問題を解きます。

7. 結果の出力

1
2
3

print(f"製品Aの生産量: {x1.value()}")
print(f"製品Bの生産量: {x2.value()}")
print(f"総利益: {pulp.value(model.objective)}")

最適な製造計画が見つかった後、生産量と総利益を表示します。

ロジスティック回帰モデル

scikit-learnは、Pythonで機械学習モデルを作成するための人気のあるライブラリです。

以下に、scikit-learnを使用してロジスティック回帰モデルを作成し、結果をグラフ化する基本的な手順を示します。

まず、必要なライブラリをインポートします：

1
2
3
4
5
6

from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score, confusion_matrix
import matplotlib.pyplot as plt
import seaborn as sns

次に、データセットをロードし、トレーニングセットとテストセットに分割します：

1
2

dataset = load_breast_cancer()
X_train, X_test, y_train, y_test = train_test_split(dataset.data, dataset.target, test_size=0.2, random_state=42)

次に、ロジスティック回帰モデルを作成し、トレーニングデータに対してフィットします：

1
2

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

モデルを使用して予測を行い、予測の精度を計算します：

1
2
3

y_pred = model.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)
print("Accuracy: ", accuracy)

最後に、混同行列を作成し、ヒートマップを使用して視覚化します：

1
2
3
4
5
6

cm = confusion_matrix(y_test, y_pred)
plt.figure(figsize=(10,7))
sns.heatmap(cm, annot=True, fmt='d')
plt.xlabel('Predicted')
plt.ylabel('Truth')
plt.show()

このコードは、scikit-learnの基本的な使用方法を示しています。

まず、データセットをロードし、トレーニングセットとテストセットに分割します。

次に、ロジスティック回帰モデルを作成し、トレーニングデータに対してフィットします。

モデルを使用して予測を行い、予測の精度を計算します。

最後に、混同行列を作成し、ヒートマップを使用して視覚化します。

[実行結果]

ソースコード解説

このソースコードは、乳がんデータセットを用いてロジスティック回帰モデルを構築し、その性能を評価するプログラムです。

以下に、詳細な説明を示します。

1. ライブラリのインポート

1
2
3
4
5
6

from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score, confusion_matrix
import matplotlib.pyplot as plt
import seaborn as sns

必要なライブラリをインポートしています。

• load_breast_cancer: scikit-learnに含まれる乳がんデータセットをロードするための関数。
• train_test_split: データをトレーニングセットとテストセットに分割する関数。
• LogisticRegression: ロジスティック回帰モデルを構築するためのクラス。
• accuracy_score: 分類モデルの精度を計算するための関数。
• confusion_matrix: 混同行列を計算するための関数。
• matplotlib.pyplot: プロットのためのMatplotlibのモジュール。
• seaborn: データ可視化のためのSeabornライブラリ。

2. データセットの読み込みと分割

1
2

dataset = load_breast_cancer()
X_train, X_test, y_train, y_test = train_test_split(dataset.data, dataset.target, test_size=0.2, random_state=42)

乳がんデータセットを読み込み、説明変数 X と目的変数 y に分割します。
トレーニングセットとテストセットは train_test_split 関数を使用して分割されます。

3. ロジスティック回帰モデルの構築と訓練

1
2

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

LogisticRegression クラスを用いてロジスティック回帰モデルを構築し、トレーニングデータを使用してモデルを訓練します。

4. テストデータでの予測と精度の計算

1
2
3

y_pred = model.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)
print("Accuracy: ", accuracy)

構築したモデルを用いてテストデータで予測を行い、その予測精度を accuracy_score 関数で計算し、表示しています。

5. 混同行列の可視化

1
2
3
4
5
6

cm = confusion_matrix(y_test, y_pred)
plt.figure(figsize=(10,7))
sns.heatmap(cm, annot=True, fmt='d')
plt.xlabel('Predicted')
plt.ylabel('Truth')
plt.show()

confusion_matrix 関数を使用して混同行列を計算し、SeabornとMatplotlibを使用して混同行列をヒートマップとして可視化しています。

混同行列はモデルの性能を評価するために用いられます。

結果解説

[実行結果]

混同行列（Confusion Matrix）は、分類モデルのパフォーマンスを評価するための重要なツールです。

混同行列は、モデルの予測結果と実際のラベルを比較し、正確な予測（True Positive, True Negative）と誤った予測（False Positive, False Negative）の数を表示します。

以下に、混同行列の各要素の意味を示します：

True Positive (TP):

モデルが正しく正のクラスを予測したインスタンスの数。

True Negative (TN):

モデルが正しく負のクラスを予測したインスタンスの数。

False Positive (FP):

モデルが正しく負のクラスを予測したが、実際には正のクラスであったインスタンスの数。

False Negative (FN):

モデルが正しく正のクラスを予測したが、実際には負のクラスであったインスタンスの数。

これらの要素を使用して、モデルの精度（Accuracy）や精度（Precision）、再現率（Recall）、F1スコアなどのメトリクスを計算することができます。

また、混同行列はヒートマップとして視覚化することも可能です。

ヒートマップは、各要素の値が色で表現され、高い値を赤色で、低い値を青色で表示します。

これにより、モデルのパフォーマンスを直感的に理解することができます。

非線形／多変数方程式

以下のような関数を考えてみましょう。

この関数は非線形で多変数の方程式であり、解析的な解法は難しいとされています。

$$
f(x, y) = \sin(\sqrt{x^2 + y^2}) - \frac{x}{2} - \frac{y}{3}
$$

この方程式の解を求め、結果を3Dグラフ化します。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

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

# 非線形方程式の定義
def equation(vars):
    x, y = vars
    return [np.sin(np.sqrt(x**2 + y**2)) - x/2 - y/3, x + y]

# 初期値の設定
initial_guess = [1, 1]

# 非線形方程式の数値解を求める
solution = fsolve(equation, initial_guess)

print("Numerical Solution:", solution)

# 3Dグラフの描画
fig = plt.figure(figsize=(10, 8))
ax = fig.add_subplot(111, projection='3d')

# 関数の値を計算してプロット
x_vals = np.linspace(-5, 5, 100)
y_vals = np.linspace(-5, 5, 100)
X, Y = np.meshgrid(x_vals, y_vals)
Z = np.sin(np.sqrt(X**2 + Y**2)) - X/2 - Y/3

ax.plot_surface(X, Y, Z, cmap='viridis', alpha=0.8)
ax.scatter(solution[0], solution[1], np.sin(np.sqrt(solution[0]**2 + solution[1]**2)) - solution[0]/2 - solution[1]/3, color='red', marker='o', s=100, label='Solution')

# グラフの設定
ax.set_title('3D Plot of a Nonlinear Equation')
ax.set_xlabel('X-axis')
ax.set_ylabel('Y-axis')
ax.set_zlabel('Z-axis')
ax.legend()

# グラフの表示
plt.show()

この例では、Scipyのfsolveを使用して非線形方程式の数値解を求め、得られた解を3Dグラフ上にプロットしています。

[実行結果]

ソースコード解説

以下に、ソースコードの詳細な説明を示します。

1. ライブラリのインポート

1
2
3
4

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

必要なライブラリをインポートしています。

• numpyは数値計算を行うために使用されます。
• matplotlib.pyplotはグラフ描画のために使用されます。
• scipy.optimize.fsolveは非線形方程式の数値解を求めるために使用されます。
• mpl_toolkits.mplot3dは3Dグラフ描画のために使用されます。

2. 非線形方程式の定義

1
2
3

def equation(vars):
    x, y = vars
    return [np.sin(np.sqrt(x**2 + y**2)) - x/2 - y/3, x + y]

equation関数では、2つの変数$ (x) $と$ (y) $に対する非線形方程式が定義されています。
この例では、$ [ \sin(\sqrt{x^2 + y^2}) - \frac{x}{2} - \frac{y}{3} ] $および$ (x + y) $という2つの方程式が組み合わさっています。

3. 初期値の設定

1

initial_guess = [1, 1]

非線形方程式の数値解を求める際に使用する初期の予測値を設定しています。

4. 非線形方程式の数値解を求める

1
2

solution = fsolve(equation, initial_guess)
print("Numerical Solution:", solution)

fsolve関数を用いて、equation関数に定義された非線形方程式の数値解を求めます。
解は solution に格納され、その値が表示されます。

5. 3Dグラフの描画

1
2

fig = plt.figure(figsize=(10, 8))
ax = fig.add_subplot(111, projection='3d')

Matplotlibを使用して3Dグラフを描画するための準備を行います。

6. 関数の値を計算してプロット

1
2
3
4
5

x_vals = np.linspace(-5, 5, 100)
y_vals = np.linspace(-5, 5, 100)
X, Y = np.meshgrid(x_vals, y_vals)
Z = np.sin(np.sqrt(X**2 + Y**2)) - X/2 - Y/3
ax.plot_surface(X, Y, Z, cmap='viridis', alpha=0.8)

指定された範囲内の$ (x) $と$ (y) $の値を生成し、それに対応する関数の値を計算して3Dプロットします。

7. 解の点をプロット

1

ax.scatter(solution[0], solution[1], np.sin(np.sqrt(solution[0]**2 + solution[1]**2)) - solution[0]/2 - solution[1]/3, color='red', marker='o', s=100, label='Solution')

先ほど求めた数値解を3Dプロットに赤い点として追加します。

8. グラフの設定

1
2
3
4
5

ax.set_title('3D Plot of a Nonlinear Equation')
ax.set_xlabel('X-axis')
ax.set_ylabel('Y-axis')
ax.set_zlabel('Z-axis')
ax.legend()

グラフのタイトルや軸のラベルを設定し、凡例を表示します。

9. グラフの表示

1

plt.show()

最後に、Matplotlibを使用して描画したグラフを表示します。

これにより、非線形方程式の数値解とそのグラフが視覚的に確認できます。

結果解説

[実行結果]

表示されたNumerical Solution ([5.17944401, -5.17944401]) は、非線形方程式

$$
f(x, y) = \sin(\sqrt{x^2 + y^2}) - \frac{x}{2} - \frac{y}{3}
$$

の数値解です。

この解は、関数$ (f(x, y)) $がゼロになる点を表しています。
具体的には、$ (x = 5.17944401) $および$ (y = -5.17944401) $で、この点で方程式が満たされています。

グラフの3Dプロットでは、関数$ (f(x, y)) $の曲面を表示しています。
この曲面上で、赤い点が数値解を表しています。
赤い点が曲面と交差する点が方程式の解であり、その座標が表示された数値解と一致しています。

数値解を求めるプロセスは、初期の予測値（initial_guess）から始まり、Scipyのfsolveが方程式に対して最適な値を見つけるために反復的な手法を使用します。
このプロセスは非線形方程式に対して一般的に使用され、数値的に解を見つけることができます。

この例では、与えられた非線形方程式を解くためにScipyを利用し、得られた数値解を3Dグラフ上に視覚化しました。

自由落下

物体の自由落下を考えたシミュレーションを考えます。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

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

# 物体の自由落下を表す微分方程式
def free_fall(y, t):
    g = 9.8  # 重力加速度 (m/s^2)
    dydt = [y[1], -g]  # [速度, 加速度]
    return dydt

# 初期条件
y0 = [0, 0]  # 初期位置と初速度

# 時間の範囲
t = np.linspace(0, 5, 100)

# 微分方程式を解く
sol = odeint(free_fall, y0, t)

# 結果をグラフ化
plt.plot(t, sol[:, 0], label='Position (m)')
plt.plot(t, sol[:, 1], label='Velocity (m/s)')
plt.xlabel('Time (s)')
plt.legend()
plt.title('Free Fall Simulation')
plt.show()

この例では、物体の自由落下を表す微分方程式をSciPyのodeint関数を使用して数値的に解き、その結果をグラフ化しています。

[実行結果]

ソースコード解説

このソースコードは、SciPyを使用して物体の自由落下をシミュレーションし、結果をグラフで視覚化するプログラムです。

以下に、ソースコードの詳細な説明を示します。

ライブラリのインポート:

1
2
3

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

• numpy: 数値計算を行うためのライブラリ。
  数学的な演算や配列操作などに使用されます。
• matplotlib.pyplot: グラフの描画に使用されるライブラリ。
• scipy.integrate.odeint: 常微分方程式を数値的に解くためのSciPyライブラリの関数。

自由落下の微分方程式:

1
2
3
4

def free_fall(y, t):
    g = 9.8  # 重力加速度 (m/s^2)
    dydt = [y[1], -g]  # [速度, 加速度]
    return dydt

• free_fall関数: 物体の自由落下を表す微分方程式を定義します。
  • y: 状態ベクトル（位置と速度の組み合わせ）
  • t: 時間
  • g: 重力加速度
  • dydt: 速度と加速度の変化を表すベクトル

初期条件:

1

y0 = [0, 0]  # 初期位置と初速度

• y0: 物体の初期位置と初速度を示す状態ベクトル。

時間の範囲:

1

t = np.linspace(0, 5, 100)

• t: シミュレーションの時間範囲を示す配列。
  $0$から$5$までの時間を$100$等分した配列。

微分方程式の解法:

1

sol = odeint(free_fall, y0, t)

• odeint: SciPyの関数で、常微分方程式を数値的に解く。
  free_fall関数に対して初期条件y0と時間範囲tを与えて解を計算し、solに格納。

結果のグラフ化:

1
2
3
4
5
6

plt.plot(t, sol[:, 0], label='Position (m)')
plt.plot(t, sol[:, 1], label='Velocity (m/s)')
plt.xlabel('Time (s)')
plt.legend()
plt.title('Free Fall Simulation')
plt.show()

• グラフ描画: 解かれた結果をグラフとして描画。
  • sol[:, 0]: 位置の時間変化を表す曲線。
  • sol[:, 1]: 速度の時間変化を表す曲線。
  • xlabel: x軸のラベル（時間）。
  • legend: 曲線の説明を表示。
  • title: グラフのタイトル。
  • show: グラフの表示。

このプログラムは、物体の自由落下を数値的にシミュレーションし、その結果を位置と速度のグラフで視覚化します。

結果解説

[実行結果]

上記のグラフは、物体の自由落下を表すシミュレーションの結果を示しています。

以下はグラフの詳細な説明です。

1. Position vs. Time (位置と時間の関係)

• x軸（横軸）: 時間（秒）
• y軸（縦軸）: 物体の位置（メートル）
• 線: 時間に対する物体の位置の変化を表現しています。

グラフは時間の経過に伴って物体がどれだけ下方向に移動するかを示しています。
最初はゼロから始まり、時間が進むにつれて増加します。
自由落下の影響で、物体は加速して地面に向かっています。

2. Velocity vs. Time (速度と時間の関係)

• x軸: 時間（秒）
• y軸: 物体の速度（メートル/秒）
• 線: 時間に対する物体の速度の変化を表現しています。

グラフは時間が経つにつれて速度が増加し、これもまた自由落下の影響を反映しています。
最初はゼロから始まり、時間が進むにつれて減速せずに増加していきます。
物体が地面に向かって自由落下するためです。

このシミュレーションでは、物体が重力に従って自由落下する様子を可視化しています。
物体の位置は時間とともに変化し、速度も時間に応じて変動します。

この例は物理学的な現象を数値的にモデリングし、SciPyを使用して微分方程式を解くことで、結果をグラフとして視覚化しています。