Complex — 複素数

概要

Complex<T> は、任意のスカラー型 T に対する複素数クラスである。 T は double, float, Int, Float, Rational など、 ComplexScalar コンセプトを満たす型であれば何でもよい。

• 多倍長対応 — std::complex とは異なる独自実装で、多倍長数値型もテンプレート引数に取れる
• Strassen 3乗算法 — 乗算を 3 回の実数乗算で行い、多倍長演算で高速化を実現する
• Smith 除算 — T = double/float ではオーバーフローを回避する Smith の方法を使用する
• std::complex 互換 — 変換コンストラクタ・暗黙変換演算子を備え、相互変換が可能である
• SIMD 互換レイアウト — static_assert により re, im の連続配置を保証する。reinterpret_cast で std::complex<T> と同一メモリとして扱える

ComplexScalar コンセプトは以下の演算を要求する:

template<typename T>
concept ComplexScalar = requires(T a, T b) {
    { a + b } -> std::convertible_to<T>;
    { a - b } -> std::convertible_to<T>;
    { a * b } -> std::convertible_to<T>;
    { a / b } -> std::convertible_to<T>;
    { -a }    -> std::convertible_to<T>;
    { T(0) };
    { T(1) };
};

ビルド

#include <math/core/Complex.hpp>

ヘッダオンリーである。CMake やリンクライブラリは不要。 Complex.hpp は <complex>, <cmath>, <concepts> 等の標準ヘッダのみに依存する。

コンストラクタ

アクセサ

re / im メンバは public であり、直接アクセスが可能である。 .real() / .imag() メソッドは std::complex との API 互換のために提供している。

算術演算子

Complex 同士の演算

スカラー混合演算

Complex<T> と T の間の四則演算をサポートする。左辺・右辺いずれにスカラーが来ても動作する。

複合代入演算子

+=, -=, *=, /= を Complex 同士およびスカラーとの間でサポートする。

比較演算子

順序比較 (<, > 等) は複素数では数学的に定義されないため、提供しない。

数学関数

すべて sangi 名前空間の自由関数として提供する。ADL (Argument Dependent Lookup) により、名前空間を明示せずに呼び出せる。

基本関数

極形式

指数・対数・冪乗

三角関数

双曲線関数

逆三角関数

逆双曲線関数

ユーザー定義リテラル

using sangi::literals; を宣言すると、以下のリテラルが使用可能になる。

using sangi::literals;

auto z = 2.0 + 3.0_i;   // Complex<double>(2, 3)
auto w = 1.0 - 0.5_i;   // Complex<double>(1, -0.5)
auto f = 1.0_if + 2.0_if; // Complex<float>(0, 3)

std::complex との互換性

変換

T が浮動小数点型 (float, double, long double) の場合、以下の変換が暗黙的に行われる。

// std::complex → Complex
std::complex<double> sc(1.0, 2.0);
Complex<double> z = sc;     // 暗黙変換

// Complex → std::complex
Complex<double> w(3.0, 4.0);
std::complex<double> sw = w; // 暗黙変換

メモリレイアウト互換

Complex<T> は re, im がメモリ上で連続的に配置されることを static_assert で保証している。 したがって、Complex<double> の配列を std::complex<double> の配列として reinterpret_cast で再解釈できる。

// 配列の相互変換
std::vector<Complex<double>> data(1024);
auto* std_ptr = reinterpret_cast<std::complex<double>*>(data.data());
// FFTW 等の C ライブラリにそのまま渡せる

以下の static_assert により、レイアウトの正しさがコンパイル時に検証される:

• sizeof(Complex<T>) == 2 * sizeof(T)
• offsetof(Complex<T>, re) == 0
• offsetof(Complex<T>, im) == sizeof(T)

auto と式テンプレート

Complex<T> 自体は式テンプレートを使用しない。 すべての演算子は Complex<T> を直接返すため、auto で受け取っても問題ない。

auto z = a + b * c;  // OK: Complex<T> 型

ただし、Matrix<Complex<T>> のように式テンプレートを使用するコンテナの内部で Complex<T> を要素型として使う場合は、 行列演算の結果を auto で受け取ると式テンプレートのプロキシ型になる可能性がある。 その場合は .eval() を呼ぶか、明示的に型を指定すること。

Matrix<Complex<double>> A, B;
auto expr = A * B;                           // プロキシ型の可能性あり
Matrix<Complex<double>> C = A * B;          // 確実に評価される
auto D = (A * B).eval();                     // eval() で明示的に評価

コード例

#include <math/core/Complex.hpp>
#include <iostream>
using namespace sangi;
using namespace sangi::literals;

int main() {
    // 基本的な構築
    Complex<double> z1(3.0, 4.0);   // 3 + 4i
    Complex<double> z2 = 2.0 + 1.0_i; // 2 + i

    // 四則演算
    auto sum  = z1 + z2;   // 5 + 5i
    auto prod = z1 * z2;   // (3*2 - 4*1) + (3*1 + 4*2)i = 2 + 11i
    auto quot = z1 / z2;   // Smith の方法で計算

    // 数学関数
    std::cout << "abs(z1)  = " << abs(z1)  << std::endl;  // 5
    std::cout << "arg(z1)  = " << arg(z1)  << std::endl;  // atan2(4,3)
    std::cout << "conj(z1) = " << conj(z1) << std::endl;  // 3-4i

    // 極形式
    auto w = polar(5.0, 0.9273);  // ≈ 3 + 4i

    // 指数・対数
    auto e_iz = exp(Complex<double>(0.0, M_PI));  // ≈ -1 + 0i (Euler の公式)
    std::cout << "e^(i*pi) = " << e_iz << std::endl;

    // std::complex との相互変換
    std::complex<double> sc(1.0, 2.0);
    Complex<double> from_std = sc;
    std::complex<double> to_std = from_std;

    // expI: FFT 回転因子
    int N = 8;
    for (int k = 0; k < N; ++k) {
        auto twiddle = expI(-2.0 * M_PI * k / N);
        std::cout << "W_" << N << "^" << k << " = " << twiddle << std::endl;
    }
}