Pythonにおける虚数の基本的な扱い方と活用例10選

●Pythonで虚数を扱う基礎知識とは？
●Pythonで虚数を活用する10の実践例
●Pythonで虚数を扱う際のよくあるエラーと対処法
●Pythonの虚数機能を最大限に活用するためのTips
まとめ

●Pythonで虚数を扱う基礎知識とは？

虚数という概念は非常に興味深いものです。

数学や物理学、工学などの分野で重要な役割を果たす虚数ですが、Pythonを使えば簡単に扱うことができます。

虚数の基礎から、Pythonでの表現方法、そして複素数型の特徴まで、順を追って理解していきましょう。

○虚数とは何か？Pythonでの表現方法

虚数は、二乗すると負の数になる数のことを指します。

実数の世界では存在しない概念ですが、数学的に非常に重要な役割を果たします。

虚数単位iは、i^2 = -1と定義されます。

Pythonでは、虚数を表現するために「j」を使用します。

数学の表記では「i」を使うことが多いですが、Pythonでは電気工学の慣習に従って「j」を採用しています。

Pythonで虚数を表現する方法は次の通りです。

# 虚数の表現
z1 = 3 + 4j  # 複素数 3 + 4i
z2 = 2j      # 純虚数 2i
z3 = 5 - 2j  # 複素数 5 - 2i

print(z1)
print(z2)
print(z3)

このコードを実行すると、次のような結果が得られます。

(3+4j)
2j
(5-2j)

Pythonは虚数を自然に扱えるため、複素数の計算も直感的に行うことができます。

例えば、複素数の加減乗除は次のように行います。

# 複素数の四則演算
a = 2 + 3j
b = 1 - 2j

print("加算:", a + b)
print("減算:", a - b)
print("乗算:", a * b)
print("除算:", a / b)

実行結果

加算: (3+1j)
減算: (1+5j)
乗算: (8+1j)
除算: (-0.2+1.6j)

○複素数型の特徴と基本的な演算

Pythonの複素数型（complex型）は、実部と虚部を持つ数を表現するためのデータ型です。

複素数型の特徴として、実部と虚部を個別に取り出したり、絶対値や共役複素数を求めたりすることができます。

複素数の基本的な演算や属性にアクセスする方法を見てみましょう。

z = 3 + 4j

# 実部と虚部の取得
print("実部:", z.real)
print("虚部:", z.imag)

# 絶対値（大きさ）の計算
print("絶対値:", abs(z))

# 共役複素数の取得
print("共役複素数:", z.conjugate())

# 極形式（極座標）への変換
import cmath
r, theta = cmath.polar(z)
print("極形式 (r, θ):", (r, theta))

実行結果

実部: 3.0
虚部: 4.0
絶対値: 5.0
共役複素数: (3-4j)
極形式 (r, θ): (5.0, 0.9272952180016122)

複素数型の特徴を活かすことで、様々な数学的操作を簡単に行うことができます。

例えば、極形式への変換は信号処理や電気工学の分野でよく使われます。

○cmathモジュールとnumpyモジュールの違い

Pythonで複素数を扱う際、標準ライブラリのcmathモジュールと、科学技術計算ライブラリのNumPyモジュールという2つの選択肢があります。

両者には使用目的や機能に違いがあります。

cmathモジュールは、複素数に対する数学関数を提供する標準ライブラリです。

基本的な複素数演算に適しています。

import cmath

z = 1 + 1j

# cmathモジュールの関数を使用
print("平方根:", cmath.sqrt(z))
print("指数関数:", cmath.exp(z))
print("対数:", cmath.log(z))

実行結果

平方根: (1.0986841134678098+0.45508986056222733j)
指数関数: (1.4686939399158851+2.2873552871788423j)
対数: (0.34657359027997264+0.7853981633974483j)

一方、NumPyモジュールは大規模な数値計算や科学技術計算に特化したライブラリです。

配列操作や高度な数学関数を提供し、大量のデータを効率的に処理できます。

import numpy as np

# 複素数配列の作成
z_array = np.array([1+1j, 2+2j, 3+3j])

# NumPy関数を使用した配列演算
print("平方根:", np.sqrt(z_array))
print("指数関数:", np.exp(z_array))
print("絶対値:", np.abs(z_array))

実行結果

平方根: [1.09868411+0.45508986j 1.55377397+0.64350111j 1.90211303+0.78867513j]
指数関数: [ 1.46869394+2.28735529j -3.07493233+6.71884969j -19.22833652+2.83622403j]
絶対値: [1.41421356 2.82842712 4.24264069]

cmathモジュールは単一の複素数に対する操作に適しているのに対し、NumPyは複素数の配列や行列演算、高度な数値計算に威力を発揮します。

プロジェクトの規模や目的に応じて、適切なモジュールを選択することが重要です。

●Pythonで虚数を活用する10の実践例

Pythonで虚数を扱う基礎知識を学んだ後は、実際の応用例を通じて理解を深めていくのが効果的です。

虚数は数学の世界だけでなく、工学や物理学など様々な分野で活用されています。

ここでは、Pythonを使って虚数を活用する10個の実践例を紹介します。

初心者の方でも理解しやすいよう、順を追って解説していきますので、ゆっくりと進めていきましょう。

○サンプルコード1：基本的な虚数の生成と演算

まずは、虚数の基本的な生成方法と四則演算を見ていきます。

Pythonでは虚数単位を「j」で表現します。

# 虚数の生成
z1 = 3 + 4j
z2 = 2 - 1j

print("z1 =", z1)
print("z2 =", z2)

# 四則演算
print("加算:", z1 + z2)
print("減算:", z1 - z2)
print("乗算:", z1 * z2)
print("除算:", z1 / z2)

実行結果

z1 = (3+4j)
z2 = (2-1j)
加算: (5+3j)
減算: (1+5j)
乗算: (10+5j)
除算: (0.4+2.2j)

虚数の生成は非常に簡単です。実部と虚部を足し合わせるだけで複素数を作ることができます。

四則演算も通常の数と同じように行えます。

Pythonが自動的に複素数の計算を処理してくれるので、難しい計算も簡単に行えるのが特徴です。

○サンプルコード2：複素平面上の点の表現と操作

複素数は複素平面上の点として表現することができます。

実部をx座標、虚部をy座標と考えると、複素数の幾何学的な解釈が可能になります。

import matplotlib.pyplot as plt

# 複素数の生成
z1 = 3 + 4j
z2 = -2 + 1j

# 複素平面上にプロット
plt.figure(figsize=(8, 8))
plt.scatter(z1.real, z1.imag, color='red', s=100, label='z1')
plt.scatter(z2.real, z2.imag, color='blue', s=100, label='z2')
plt.axhline(y=0, color='k', linestyle='--')
plt.axvline(x=0, color='k', linestyle='--')
plt.xlim(-5, 5)
plt.ylim(-5, 5)
plt.xlabel('Real')
plt.ylabel('Imaginary')
plt.title('Complex Numbers on Complex Plane')
plt.legend()
plt.grid(True)
plt.show()

コードを実行すると、複素平面上に2つの点がプロットされた図が表示されます。赤い点がz1、青い点がz2を表しています。

複素平面を視覚化することで、複素数の幾何学的な意味がより理解しやすくなります。

○サンプルコード3：ド・モアブルの定理を用いた計算

ド・モアブルの定理は、複素数の累乗を計算する際に非常に便利です。

極形式で表された複素数の累乗を簡単に計算できます。

import cmath

def de_moivre(r, theta, n):
    """ド・モアブルの定理を用いて (r * e^(i*theta))^n を計算"""
    return r**n * cmath.exp(1j * theta * n)

# 例: (1 + i)^5 を計算
z = 1 + 1j
r = abs(z)
theta = cmath.phase(z)

result = de_moivre(r, theta, 5)
print(f"(1 + i)^5 = {result}")

# 直接計算した結果と比較
direct_result = z**5
print(f"直接計算: (1 + i)^5 = {direct_result}")

実行結果

(1 + i)^5 = (-4-4j)
直接計算: (1 + i)^5 = (-4-4j)

ド・モアブルの定理を使うと、複素数の累乗を極形式で簡単に計算できます。

直接計算した結果と一致することを確認できました。

高次の累乗を計算する際には、ド・モアブルの定理を使うと効率的です。

○サンプルコード4：極形式と直交形式の変換

複素数は直交形式（a + bi）と極形式（r * e^(iθ)）の2つの形式で表現できます。

両者の変換は、複素数を扱う上で重要な操作です。

import cmath
import math

# 直交形式から極形式への変換
z = 3 + 4j
r = abs(z)
theta = cmath.phase(z)

print(f"直交形式: {z}")
print(f"極形式: {r} * e^({theta}j)")

# 極形式から直交形式への変換
r = 5
theta = math.pi / 4  # 45度

z_converted = r * cmath.exp(1j * theta)
print(f"極形式: {r} * e^({theta}j)")
print(f"直交形式: {z_converted}")

# 極座標でのプロット
import matplotlib.pyplot as plt

fig, ax = plt.subplots(subplot_kw={'projection': 'polar'})
ax.scatter(theta, r)
ax.set_rmax(6)
ax.set_rticks([1, 2, 3, 4, 5])
ax.set_rlabel_position(-22.5)
ax.grid(True)
ax.set_title("Complex Number in Polar Form")
plt.show()

実行結果

直交形式: (3+4j)
極形式: 5.0 * e^(0.9272952180016122j)
極形式: 5 * e^(0.7853981633974483j)
直交形式: (3.5355339059327378+3.5355339059327373j)

コードを実行すると、直交形式と極形式の変換結果が表示され、さらに極座標上にプロットした図が表示されます。

複素数を極形式で表現することで、大きさと角度の情報が直感的に理解できます。

また、極座標でのプロットにより、複素数の幾何学的な意味がより明確になります。

○サンプルコード5：複素数の絶対値と偏角の計算

複素数の絶対値（大きさ）と偏角（位相）は、複素数を理解する上で重要な概念です。

Pythonでは、簡単にこれらの値を計算することができます。

import cmath
import math

z = 3 + 4j

# 絶対値の計算
abs_z = abs(z)
print(f"複素数 {z} の絶対値: {abs_z}")

# 偏角の計算
phase_z = cmath.phase(z)
print(f"複素数 {z} の偏角（ラジアン）: {phase_z}")
print(f"複素数 {z} の偏角（度）: {math.degrees(phase_z)}")

# 極形式での表現
r = abs_z
theta = phase_z
print(f"極形式: {r} * e^({theta}j)")

# 極座標でのプロット
import matplotlib.pyplot as plt

fig, ax = plt.subplots(subplot_kw={'projection': 'polar'})
ax.scatter(theta, r)
ax.set_rmax(6)
ax.set_rticks([1, 2, 3, 4, 5])
ax.set_rlabel_position(-22.5)
ax.grid(True)
ax.set_title("Complex Number: Magnitude and Phase")
plt.show()

実行結果

複素数 (3+4j) の絶対値: 5.0
複素数 (3+4j) の偏角（ラジアン）: 0.9272952180016122
複素数 (3+4j) の偏角（度）: 53.13010235415598
極形式: 5.0 * e^(0.9272952180016122j)

このコードでは、複素数の絶対値と偏角を計算し、極形式での表現も行っています。

さらに、極座標上にプロットすることで、複素数の大きさと角度を視覚的に理解することができます。

絶対値と偏角は、信号処理や電気工学など、多くの分野で重要な役割を果たします。

○サンプルコード6：フーリエ変換への応用

フーリエ変換は、時間領域の信号を周波数領域に変換する重要な数学的手法です。

Pythonの虚数機能を活用することで、フーリエ変換を簡単に実装できます。

音声処理や画像処理など、多くの分野で応用されているフーリエ変換を、Pythonで実践してみましょう。

import numpy as np
import matplotlib.pyplot as plt

# サンプル信号の生成
t = np.linspace(0, 1, 1000, endpoint=False)
signal = np.sin(2 * np.pi * 10 * t) + 0.5 * np.sin(2 * np.pi * 20 * t)

# フーリエ変換の実行
fft_result = np.fft.fft(signal)
freqs = np.fft.fftfreq(len(t), t[1] - t[0])

# 結果のプロット
plt.figure(figsize=(12, 6))
plt.subplot(211)
plt.plot(t, signal)
plt.title('Original Signal')
plt.xlabel('Time')
plt.ylabel('Amplitude')

plt.subplot(212)
plt.plot(freqs, np.abs(fft_result))
plt.title('Frequency Spectrum')
plt.xlabel('Frequency')
plt.ylabel('Magnitude')
plt.xlim(0, 30)

plt.tight_layout()
plt.show()

このコードでは、まず2つの正弦波を合成した信号を生成しています。

10 Hzと20 Hzの正弦波を組み合わせることで、複合的な波形を作り出しています。

次に、NumPyのFFT（高速フーリエ変換）関数を使用して、時間領域の信号を周波数領域に変換します。

実行結果として、2つのグラフが表示されます。

上のグラフは元の信号を、下のグラフはフーリエ変換後の周波数スペクトルを表しています。

周波数スペクトルを見ると、10 Hzと20 Hzにピークがあることがわかります。

フーリエ変換により、元の信号に含まれる周波数成分を明確に識別できるようになりました。

フーリエ変換は、複素数を扱う能力がなければ実現できない強力な数学的ツールです。

Pythonの虚数機能を使うことで、簡単にフーリエ変換を実装し、信号の周波数成分を分析できるようになります。

音声認識や画像処理、さらには量子力学の計算にも応用できる、非常に有用な技術です。

○サンプルコード7：量子力学の波動関数の表現

量子力学は現代物理学の基礎となる理論ですが、その数学的表現には複素数が欠かせません。

波動関数は量子状態を表す複素関数で、Pythonの虚数機能を使って簡単に表現できます。

ここでは、1次元の無限井戸型ポテンシャル中の粒子の波動関数を表現してみましょう。

import numpy as np
import matplotlib.pyplot as plt

def psi(n, x, L):
    """n番目の固有状態の波動関数"""
    return np.sqrt(2/L) * np.sin(n * np.pi * x / L)

def complex_psi(n, x, L, t):
    """時間依存の波動関数"""
    return psi(n, x, L) * np.exp(-1j * (n**2 * np.pi**2 * t) / (2 * L**2))

# パラメータ設定
L = 1  # 井戸の幅
n = 3  # 量子数
x = np.linspace(0, L, 1000)
t = 0  # 時刻

# 波動関数の計算
wave_function = complex_psi(n, x, L, t)

# プロット
plt.figure(figsize=(10, 6))
plt.plot(x, wave_function.real, label='Real part')
plt.plot(x, wave_function.imag, label='Imaginary part')
plt.plot(x, np.abs(wave_function)**2, label='Probability density')
plt.title(f'Wave Function for n={n} at t={t}')
plt.xlabel('Position')
plt.ylabel('Amplitude')
plt.legend()
plt.grid(True)
plt.show()

このコードでは、1次元の無限井戸型ポテンシャル中の粒子の波動関数を表現しています。

psi関数は空間依存の波動関数を、complex_psi関数は時間依存の波動関数を表します。

時間依存の波動関数は、空間依存の部分と時間依存の部分（複素指数関数）の積で表されます。

実行結果として、波動関数の実部、虚部、および確率密度（波動関数の絶対値の2乗）がグラフ化されます。

量子数nを変更することで、異なる固有状態の波動関数を観察できます。

量子力学の波動関数は本質的に複素関数であり、Pythonの虚数機能なしではその完全な表現が困難です。

このように、Pythonを使うことで、高度な物理学の概念を視覚化し、理解を深めることができます。

量子コンピューティングや材料科学など、最先端の分野でも複素数の扱いは重要になってきています。

○サンプルコード8：電気回路解析での活用

電気工学では、交流回路の解析に複素数が広く使用されます。

インピーダンスや電圧、電流などを複素数で表現することで、回路の振る舞いを効率的に解析できます。

ここでは、RLC直列回路の周波数応答を計算し、グラフ化するプログラムを作成してみましょう。

import numpy as np
import matplotlib.pyplot as plt

def impedance(f, R, L, C):
    """RLC直列回路のインピーダンスを計算"""
    omega = 2 * np.pi * f
    return R + 1j * (omega * L - 1 / (omega * C))

# 回路パラメータ
R = 100  # 抵抗 [Ω]
L = 0.1  # インダクタンス [H]
C = 1e-6  # キャパシタンス [F]

# 周波数範囲
f = np.logspace(2, 5, 1000)

# インピーダンスの計算
Z = impedance(f, R, L, C)

# プロット
plt.figure(figsize=(12, 6))
plt.subplot(211)
plt.semilogx(f, np.abs(Z))
plt.title('Magnitude of Impedance')
plt.ylabel('|Z| [Ω]')
plt.grid(True)

plt.subplot(212)
plt.semilogx(f, np.angle(Z, deg=True))
plt.title('Phase of Impedance')
plt.xlabel('Frequency [Hz]')
plt.ylabel('Phase [degrees]')
plt.grid(True)

plt.tight_layout()
plt.show()

このプログラムでは、RLC直列回路のインピーダンスを周波数の関数として計算しています。

impedance関数は、抵抗R、インダクタンスL、キャパシタンスC、および周波数fを入力として受け取り、複素インピーダンスを返します。

実行結果として、2つのグラフが表示されます。

上のグラフはインピーダンスの大きさ、下のグラフは位相を示しています。横軸は対数スケールで周波数を表しています。

インピーダンスの大きさのグラフでは、低周波域ではキャパシタのインピーダンスが支配的で、高周波域ではインダクタのインピーダンスが支配的になっていることがわかります。

また、特定の周波数で共振が起こり、インピーダンスが最小になる点も観察できます。

位相のグラフでは、低周波域で負の位相（キャパシタの影響）、高周波域で正の位相（インダクタの影響）が見られ、共振周波数付近で急激な位相の変化が起こっています。

複素数を使用することで、電気回路の振る舞いを周波数領域で簡潔に表現し、解析することができます。

この手法は、フィルタ設計や信号処理、電力系統の解析など、多くの電気工学の分野で活用されています。

○サンプルコード9：フラクタル図形の生成

フラクタル図形は、部分と全体が自己相似的な構造を持つ幾何学的図形です。

複素平面上で定義される反復計算を用いて、美しいフラクタル図形を生成できます。

ここでは、最も有名なフラクタル図形の一つであるマンデルブロ集合を、Pythonの複素数機能を使って描画してみましょう。

import numpy as np
import matplotlib.pyplot as plt

def mandelbrot(h, w, max_iter):
    """マンデルブロ集合を計算"""
    y, x = np.ogrid[-1.4:1.4:h*1j, -2:0.8:w*1j]
    c = x + y*1j
    z = c
    divtime = max_iter + np.zeros(z.shape, dtype=int)

    for i in range(max_iter):
        z = z**2 + c
        diverge = z*np.conj(z) > 2**2
        div_now = diverge & (divtime == max_iter)
        divtime[div_now] = i
        z[diverge] = 2

    return divtime

# パラメータ設定
h, w = 1000, 1500
max_iter = 100

# マンデルブロ集合の計算
mandelbrot_set = mandelbrot(h, w, max_iter)

# プロット
plt.figure(figsize=(12, 8))
plt.imshow(mandelbrot_set, cmap='hot', extent=[-2, 0.8, -1.4, 1.4])
plt.title('Mandelbrot Set')
plt.xlabel('Re(c)')
plt.ylabel('Im(c)')
plt.colorbar(label='Iteration count')
plt.show()

このプログラムでは、複素平面上の各点cに対して、z_{n+1} = z_n^2 + cという漸化式を繰り返し適用します。

この式が発散するまでの反復回数を計算し、その値に基づいて色を割り当てることで、マンデルブロ集合を可視化しています。

実行結果として、カラフルなマンデルブロ集合の図が表示されます。

中心部分の黒い領域がマンデルブロ集合そのものであり、周囲の色とりどりの部分は発散するまでの速さを表しています。

フラクタル図形の生成は、複素数の反復計算の美しい応用例です。

単純な数学的規則から、驚くほど複雑で美しい構造が生まれる様子を観察できます。

フラクタル図形は、自然界の複雑な形状のモデル化や、コンピュータグラフィックスの分野で広く活用されています。

●Pythonで虚数を扱う際のよくあるエラーと対処法

Pythonで虚数を扱う際、初心者の方々がつまずきやすいポイントがいくつかあります。

エラーに遭遇したときの対処法を知っておくことで、スムーズにプログラミングを進められるようになります。

よくあるエラーとその解決策を見ていきましょう。

○TypeError: can’t convert complex to float

虚数を扱う際によく遭遇するエラーの一つが「TypeError: can’t convert complex to float」です。

プログラムが複素数を実数として扱おうとしたときに発生します。

例えば、複素数の絶対値を計算しようとして、間違った関数を使用した場合に起こりがちです。

誤った例

z = 3 + 4j
abs_value = float(z)  # TypeError: can't convert complex to float

正しい例

z = 3 + 4j
abs_value = abs(z)  # 正しい方法
print(abs_value)  # 出力: 5.0

複素数の絶対値を求める場合は、float()関数ではなくabs()関数を使用します。

abs()関数は複素数の大きさ（絶対値）を返してくれます。

複素数から実数部分だけを取り出したい場合は、z.real属性を使用します。

z = 3 + 4j
real_part = z.real
print(real_part)  # 出力: 3.0

○OverflowError: complex exponentiation

複素数の指数計算を行う際に「OverflowError: complex exponentiation」というエラーに遭遇することがあります。

通常、大きな数値を扱う際に発生しますが、複素数の場合は予想外に小さな数値でも起こることがあります。

誤った例

z = 10 + 10j
result = z ** 1000  # OverflowError: complex exponentiation

対処法として、代わりにcmath.exp()関数と対数を組み合わせる方法があります。

import cmath

z = 10 + 10j
n = 1000
result = cmath.exp(cmath.log(z) * n)
print(result)  # 出力: (-6.949414233701569e+299-6.949414233701569e+299j)

cmath.exp()とcmath.log()を使用することで、大きな指数の計算でもエラーを回避できます。

ただし、非常に大きな数値を扱う場合は、結果が無限大になる可能性があるので注意が必要です。

○AttributeError: ‘complex’ object has no attribute ‘conjugate’

複素数の共役を求めようとして「AttributeError: ‘complex’ object has no attribute ‘conjugate’」というエラーが発生することがあります。

実は、Pythonの複素数オブジェクトにはconjugateメソッドが存在します。

このエラーが発生する主な原因は、変数名の衝突です。

誤った例

conjugate = 3 + 4j
result = conjugate.conjugate()  # AttributeError: 'complex' object has no attribute 'conjugate'

正しい例

z = 3 + 4j
result = z.conjugate()
print(result)  # 出力: (3-4j)

変数名にconjugateを使用してしまうと、組み込みのconjugateメソッドがオーバーライドされてしまいます。

変数名にはconjugate以外の名前を使用しましょう。

●Pythonの虚数機能を最大限に活用するためのTips

Pythonの虚数機能を最大限に活用するためには、いくつかのライブラリやテクニックを知っておくと便利です。

ここでは、効率的な計算や視覚化のためのTipsを紹介します。

○NumPyを使った高速な複素数計算

NumPyライブラリを使用すると、複素数の配列演算を高速に行うことができます。

特に大規模なデータを扱う場合に威力を発揮します。

import numpy as np

# 複素数配列の生成
z = np.array([1+1j, 2+2j, 3+3j])

# 配列演算
result = z**2 + 2*z + 1

print(result)  # 出力: [1.+3.j 3.+9.j 7.+19.j]

NumPyの配列演算を使用することで、for文を使わずに効率的に計算を行えます。

大量のデータを扱う科学技術計算や信号処理などで重宝します。

○SciPyを活用した高度な数学演算

SciPyライブラリを使用すると、より高度な数学演算を簡単に行えます。

例えば、複素関数の積分や微分などが可能です。

import numpy as np
from scipy import integrate

def complex_function(x):
    return np.exp(1j * x)

# 複素関数の積分
result, _ = integrate.quad(lambda x: complex_function(x).real, 0, np.pi)
result = result + 1j * integrate.quad(lambda x: complex_function(x).imag, 0, np.pi)[0]

print(f"積分結果: {result}")  # 出力: 積分結果: (1.9999999999999998+0j)

SciPyのintegrateモジュールを使用することで、複雑な複素関数の積分も簡単に計算できます。

数値解析や信号処理の分野で非常に役立ちます。

○Matplotlibで複素平面上のデータを可視化する方法

Matplotlibを使用すると、複素数データを視覚的に表現できます。

複素平面上のプロットや、複素関数のグラフ化が可能です。

import numpy as np
import matplotlib.pyplot as plt

# データの生成
x = np.linspace(-2, 2, 100)
y = np.linspace(-2, 2, 100)
X, Y = np.meshgrid(x, y)
Z = X + Y*1j

# 複素関数の定義
def complex_function(z):
    return z**2

# 関数の値を計算
W = complex_function(Z)

# プロット
plt.figure(figsize=(12, 5))
plt.subplot(121)
plt.contourf(X, Y, np.abs(W), levels=20)
plt.colorbar(label='Magnitude')
plt.title('Magnitude of f(z) = z^2')
plt.xlabel('Re(z)')
plt.ylabel('Im(z)')

plt.subplot(122)
plt.contourf(X, Y, np.angle(W), levels=20)
plt.colorbar(label='Phase')
plt.title('Phase of f(z) = z^2')
plt.xlabel('Re(z)')
plt.ylabel('Im(z)')

plt.tight_layout()
plt.show()

このコードを実行すると、複素関数 f(z) = z^2 の大きさと位相を表す2つのグラフが表示されます。

複素関数の振る舞いを視覚的に理解するのに役立ちます。