Go/complex128

Goのcomplex128について

Goにおける complex128 は、複素数を表す事前宣言された型であり、実部と虚部に float64 を使用することで、高精度な複素数演算を可能にします。数値解析、信号処理、量子計算、フーリエ変換など、実数だけでは表現しきれない複雑な計算に利用されます。

基本情報

  • complex128 は64ビット浮動小数点数×2（実部・虚部）で構成される複素数型（合計128ビット = 16バイト）
  • 実部・虚部ともに IEEE 754 に準拠した float64
  • 精度: 実部・虚部それぞれ約15〜17桁の有効数字
  • メモリ表現: 実部64ビット + 虚部64ビット
  • 複素平面上の演算、スペクトル解析、制御工学、物理シミュレーションに適する

他のキーワードとの組み合わせ

変数宣言との組み合わせ

var z complex128 = complex(3.0, 4.0) // 実部3, 虚部4の複素数
value := 1 + 2i                      // 型推論でcomplex128
zero := complex128(0)               // 零の複素数

// 特殊値
inf := complex(math.Inf(1), 0)         // 実部が+Inf
nan := complex(math.NaN(), math.NaN()) // 実部・虚部ともにNaN

定数定義との組み合わせ

const I complex128 = 1i                    // 虚数単位
const UNIT complex128 = 1 + 0i             // 単位複素数
const PURE_IMAG complex128 = 0 + 2.5i      // 純虚数
const ROOT_OF_MINUS1 complex128 = 0 + 1i   // √(-1)

関数パラメータと戻り値

func Conjugate(z complex128) complex128 {
    return complex(real(z), -imag(z))
}

func Magnitude(z complex128) float64 {
    return math.Hypot(real(z), imag(z))
}

func Phase(z complex128) float64 {
    return math.Atan2(imag(z), real(z))
}

func AddComplex(a, b complex128) complex128 {
    return a + b
}

型変換

f := 3.14159265359
z := complex(f, 0)                  // float64 → complex128（実数部のみ）
x := real(z)                        // complex128 → float64（実部の抽出）
y := imag(z)                        // complex128 → float64（虚部の抽出）

s := "1+2i"
c, err := strconv.ParseComplex(s, 128) // 文字列からcomplex128へ
if err == nil {
    value := complex128(c)
}

zValue := complex(1.5, -2.3)
sValue := strconv.FormatComplex(zValue, 'f', 2, 128) // "1.50-2.30i"

配列とスライス

var roots [2]complex128 = [2]complex128{
    complex(1, 1),
    complex(1, -1),
}

signals := []complex128{1 + 0i, 0 + 1i, -1 + 0i, 0 - 1i} // 単位円上の点
zeros := make([]complex128, 10)                         // 初期化されたゼロ複素数配列

マップ

impedances := map[string]complex128{
    "R1": 100 + 0i,
    "C1": 0 - 1.0/50.0i,
}

frequencies := map[float64]complex128{
    60.0: complex(1.2, -0.4),
    120.0: complex(0.8, 0.2),
}

構造体のフィールド

type ComplexSignal struct {
    Amplitude complex128 // 信号の振幅（複素数）
    Time      float64    // 時刻（秒）
}

type QuantumState struct {
    Coefficient complex128
    Label       string
}

type Polar struct {
    R     float64
    Theta float64
}

func RectToPolar(z complex128) Polar {
    return Polar{
        R:     math.Hypot(real(z), imag(z)),
        Theta: math.Atan2(imag(z), real(z)),
    }
}

スライスとバイナリ処理

import (
    "encoding/binary"
    "bytes"
    "math"
)

// complex128をバイト列に変換（LittleEndian）
func Complex128ToBytes(c complex128) []byte {
    buf := new(bytes.Buffer)
    binary.Write(buf, binary.LittleEndian, real(c))
    binary.Write(buf, binary.LittleEndian, imag(c))
    return buf.Bytes()
}

// バイト列からcomplex128に変換
func BytesToComplex128(b []byte) complex128 {
    r := math.Float64frombits(binary.LittleEndian.Uint64(b[0:8]))
    i := math.Float64frombits(binary.LittleEndian.Uint64(b[8:16]))
    return complex(r, i)
}

一般的なユースケース

  1. フーリエ変換やスペクトル解析 
       import "math/cmplx"

   func DFT(input []complex128) []complex128 {
       N := len(input)
       output := make([]complex128, N)
       for k := 0; k < N; k++ {
           var sum complex128
           for n := 0; n < N; n++ {
               angle := -2 * math.Pi * float64(k*n) / float64(N)
               sum += input[n] * cmplx.Exp(complex(0, angle))
           }
           output[k] = sum
       }
       return output
   }
  2. 量子振幅の表現（量子計算） 
       type Qubit struct {
       Alpha complex128 // |0⟩の振幅
       Beta  complex128 // |1⟩の振幅
   }

   func (q Qubit) Normalize() Qubit {
       norm := cmplx.Abs(q.Alpha)*cmplx.Abs(q.Alpha) + cmplx.Abs(q.Beta)*cmplx.Abs(q.Beta)
       factor := 1 / math.Sqrt(norm)
       return Qubit{
           Alpha: q.Alpha * complex(factor, 0),
           Beta:  q.Beta * complex(factor, 0),
       }
   }
  3. 複素行列計算（例: 2x2行列） 
       type Matrix2x2 [2][2]complex128

   func Multiply2x2(a, b Matrix2x2) Matrix2x2 {
       var result Matrix2x2
       for i := 0; i < 2; i++ {
           for j := 0; j < 2; j++ {
               result[i][j] = 0
               for k := 0; k < 2; k++ {
                   result[i][j] += a[i][k] * b[k][j]
               }
           }
       }
       return result
   }

complex128型は、複雑な数値演算や信号処理、フーリエ解析、量子計算などの高度な数学的処理において重要な役割を果たします。float64に基づく高精度な実部・虚部の演算により、精度の要求される応用にも対応可能です。一方で、メモリ使用量や計算コストも大きいため、用途に応じた適切な選択が求められます。複素数特有の演算（共役、絶対値、偏角など）やライブラリ（math/cmplx）の使い方を正しく理解し、堅牢な数値計算を実装することが重要です。

カテゴリ:Go
カテゴリ:Go