数値処理

C言語で扱う複素数構造体：リアル部とイマジナリ部の管理と演算ライブラリ作成について解説

2025-01-17更新日: 2025-01-17

このライブラリでは、C言語で複素数を構造体として定義し、リアル部とイマジナリ部を管理する方法を解説します。

基本的な演算(加算、減算、乗算、除算など)を関数群として実装し、複素数の計算処理をシンプルかつ効率的に行うことを目指します。

目次から探す

複素数構造体の定義
演算ライブラリの設計
- 関数群の全体構成
各種演算関数の実装例
サンプルコードと利用例
- 複素数構造体の宣言と利用方法
- 演算関数実行時の流れ解説
まとめ

複素数構造体の定義

構造体宣言の基本構文

C言語では、複素数を扱うために構造体を用いてリアル部とイマジナリ部を管理します。

構造体の宣言は以下のように行います。

例えば、Complexという構造体を定義し、double型のrealとimagというメンバを持たせる方法が一般的です。

この基本的な構造体宣言により、複素数を1つの変数としてまとめて管理することが可能になります。

以下は、構造体宣言の例です。

#include <stdio.h>
// 複素数を表す構造体の宣言
typedef struct {
    double real;  // 実部
    double imag;  // 虚部
} Complex;
int main(void) {
    // 初期値を設定して複素数を宣言
    Complex c = { 3.0, 4.0 };
    printf("Real: %f, Imag: %f\n", c.real, c.imag);
    return 0;
}

Real: 3.000000, Imag: 4.000000

リアル部とイマジナリ部のメンバ指定

Complex構造体において、realは複素数の実部、imagは虚部を表しています。

各メンバはdouble型で宣言するため、実数部および虚数部を高い精度で扱うことができるようになります。

また、開発時には各メンバの役割を明確にコメントとして記述することで、コードの可読性や保守性を向上させる工夫が有効です。

メモリ確保と初期化方法

複素数構造体は、スタック上に静的に確保する場合と、ヒープ上に動的に確保する場合があります。

静的確保では宣言と同時に初期化する方法が一般的です。

たとえば、上記の例のように初期値を直接設定します。

動的確保する場合、malloc関数を利用してメモリを割り当て、必要に応じて初期化を行います。

以下は、動的確保のサンプルコードです。

#include <stdio.h>
#include <stdlib.h>
// 複素数を表す構造体の宣言
typedef struct {
    double real;
    double imag;
} Complex;
int main(void) {
    // ヒープから複素数用のメモリを確保
    Complex *pComplex = (Complex *)malloc(sizeof(Complex));
    if (pComplex == NULL) {
        printf("Memory allocation error.\n");
        return 1;
    }
    // メンバの初期化
    pComplex->real = 5.0;
    pComplex->imag = -2.0;
    printf("Real: %f, Imag: %f\n", pComplex->real, pComplex->imag);
    // メモリの解放
    free(pComplex);
    return 0;
}

Real: 5.000000, Imag: -2.000000

演算ライブラリの設計

関数群の全体構成

複素数演算ライブラリでは、基本的な演算として加算、減算、乗算、除算などの関数群を用意します。

各関数は基本的にComplex型の引数を受け取り、演算結果をComplex型で返す形にすることで、統一したインターフェースが実現できます。

たとえば、(

f(z) = a + bi

) という形式の複素数に対して、加算では各実部と虚部を単純に足し合わせる設計方針となります。

インターフェースの統一方法

すべての演算関数は、引数として2つのComplex型を取り、返り値もComplex型に統一します。

この方法により、関数呼び出し時の混乱を避け、ライブラリ全体の利用時に一貫性を持たせることができます。

また、エラーチェックや入出力の形式も統一することで、開発者が使いやすいライブラリを実現します。

モジュール分割の設計方針

ライブラリ機能を複数のソースファイルに分割することで、以下のようなメリットがあります。

保守性の向上：機能ごとにファイルを分けることで、各モジュールの責任範囲が明確になります。
再利用性の向上：必要な機能だけをインクルードすることが可能になります。
コンパイル時間の短縮：変更があったモジュールのみ再コンパイルすればよいので、全体のビルド効率が向上します。

たとえば、complex.hに構造体定義および関数プロトタイプを置き、complex.cに実際の関数実装を行い、利用側はmain.cでこれらを#includeして使用する設計が考えられます。

各種演算関数の実装例

加算処理の実装

加算処理では、2つの複素数の実部と虚部を個別に足し合わせます。

式で表すと、 $(a + b i) + (c + d i) = (a + c) + (b + d) i$

以下のサンプルコードは、加算関数addComplexの実装例です。

#include <stdio.h>
// 複素数を表す構造体の宣言
typedef struct {
    double real;
    double imag;
} Complex;
// 複素数の加算関数
Complex addComplex(Complex a, Complex b) {
    Complex result;
    result.real = a.real + b.real; // 実部の加算
    result.imag = a.imag + b.imag; // 虚部の加算
    return result;
}
int main(void) {
    Complex x = {2.0, 3.0};
    Complex y = {4.0, -1.0};
    Complex sum = addComplex(x, y);
    printf("Sum -> Real: %f, Imag: %f\n", sum.real, sum.imag);
    return 0;
}

Sum -> Real: 6.000000, Imag: 2.000000

減算処理の実装

減算処理もまた、各複素数の実部と虚部を個別に引き算します。

式で表すと、 $(a + b i) - (c + d i) = (a - c) + (b - d) i$

以下のコードは、減算関数subComplexの実装例です。

#include <stdio.h>
// 複素数を表す構造体の宣言
typedef struct {
    double real;
    double imag;
} Complex;
// 複素数の減算関数
Complex subComplex(Complex a, Complex b) {
    Complex result;
    result.real = a.real - b.real; // 実部の減算
    result.imag = a.imag - b.imag; // 虚部の減算
    return result;
}
int main(void) {
    Complex x = {7.0, 5.0};
    Complex y = {2.0, 3.0};
    Complex diff = subComplex(x, y);
    printf("Difference -> Real: %f, Imag: %f\n", diff.real, diff.imag);
    return 0;
}

Difference -> Real: 5.000000, Imag: 2.000000

乗算処理の実装

乗算処理では、複素数同士の積を求めるため、以下の式を利用します。

$(a + b i) \times (c + d i) = (a c - b d) + (a d + b c) i$

multiplyComplex関数では、実部と虚部の計算をそれぞれ行います。

#include <stdio.h>
// 複素数を表す構造体の宣言
typedef struct {
    double real;
    double imag;
} Complex;
// 複素数の乗算関数
Complex multiplyComplex(Complex a, Complex b) {
    Complex result;
    result.real = a.real * b.real - a.imag * b.imag; // 実部の計算
    result.imag = a.real * b.imag + a.imag * b.real; // 虚部の計算
    return result;
}
int main(void) {
    Complex x = {1.0, 2.0};
    Complex y = {3.0, 4.0};
    Complex product = multiplyComplex(x, y);
    printf("Product -> Real: %f, Imag: %f\n", product.real, product.imag);
    return 0;
}

Product -> Real: -5.000000, Imag: 10.000000

除算処理の実装

除算処理は、分母の複素数の大きさを考慮して以下の式で実装されます。

$\frac{a + b i}{c + d i} = \frac{(a c + b d) + (b c - a d) i}{c^{2} + d^{2}}$

この計算では、分母の値が0に近くなる可能性があるため、エラー検出が必要です。

エラー検出とハンドリング

除算関数divideComplexでは、分母の実部と虚部の二乗和がゼロの場合、エラーとして処理を行います。

関数内でエラーチェックを行い、安全に演算できるかどうかを確認します。

以下は、除算処理とエラーチェックを含むサンプルコードです。

#include <stdio.h>
#include <math.h>
// 複素数を表す構造体の宣言
typedef struct {
    double real;
    double imag;
} Complex;
// 複素数の除算関数
// 分母がゼロに近い場合は、エラーメッセージを出力して{0, 0}を返す
Complex divideComplex(Complex a, Complex b) {
    Complex result;
    double denominator = b.real * b.real + b.imag * b.imag; // 分母の計算
    if (fabs(denominator) < 1e-10) {
        printf("Error: Division by zero magnitude complex number.\n");
        result.real = 0.0;
        result.imag = 0.0;
    } else {
        result.real = (a.real * b.real + a.imag * b.imag) / denominator;
        result.imag = (a.imag * b.real - a.real * b.imag) / denominator;
    }
    return result;
}
int main(void) {
    Complex x = {5.0, 3.0};
    Complex y = {2.0, -1.0};
    Complex quotient = divideComplex(x, y);
    printf("Quotient -> Real: %f, Imag: %f\n", quotient.real, quotient.imag);
    return 0;
}

Quotient -> Real: 1.000000, Imag: 2.000000

サンプルコードと利用例

複素数構造体の宣言と利用方法

複素数構造体の宣言と各演算関数の利用例を統合したサンプルコードを以下に示します。

このコードでは、Complex型の変数を宣言し、加算、減算、乗算、除算それぞれの関数を呼び出して、その結果を表示します。

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
// 複素数を表す構造体の宣言
typedef struct {
    double real;
    double imag;
} Complex;
// 複素数の加算
Complex addComplex(Complex a, Complex b) {
    Complex result;
    result.real = a.real + b.real;
    result.imag = a.imag + b.imag;
    return result;
}
// 複素数の減算
Complex subComplex(Complex a, Complex b) {
    Complex result;
    result.real = a.real - b.real;
    result.imag = a.imag - b.imag;
    return result;
}
// 複素数の乗算
Complex multiplyComplex(Complex a, Complex b) {
    Complex result;
    result.real = a.real * b.real - a.imag * b.imag;
    result.imag = a.real * b.imag + a.imag * b.real;
    return result;
}
// 複素数の除算(エラーチェック付き)
Complex divideComplex(Complex a, Complex b) {
    Complex result;
    double denominator = b.real * b.real + b.imag * b.imag;
    if (fabs(denominator) < 1e-10) {
        printf("Error: Division by zero magnitude complex number.\n");
        result.real = 0.0;
        result.imag = 0.0;
    } else {
        result.real = (a.real * b.real + a.imag * b.imag) / denominator;
        result.imag = (a.imag * b.real - a.real * b.imag) / denominator;
    }
    return result;
}
int main(void) {
    // サンプルの複素数を複数設定
    Complex x = {3.0, 2.0};
    Complex y = {1.0, -4.0};
    // 加算の実行
    Complex sum = addComplex(x, y);
    // 減算の実行
    Complex diff = subComplex(x, y);
    // 乗算の実行
    Complex prod = multiplyComplex(x, y);
    // 除算の実行
    Complex quot = divideComplex(x, y);
    // 結果の出力
    printf("x = (%f) + (%f)i\n", x.real, x.imag);
    printf("y = (%f) + (%f)i\n", y.real, y.imag);
    printf("Sum: (%f) + (%f)i\n", sum.real, sum.imag);
    printf("Difference: (%f) + (%f)i\n", diff.real, diff.imag);
    printf("Product: (%f) + (%f)i\n", prod.real, prod.imag);
    printf("Quotient: (%f) + (%f)i\n", quot.real, quot.imag);
    return 0;
}

x = (3.000000) + (2.000000)i
y = (1.000000) + (-4.000000)i
Sum: (4.000000) + (-2.000000)i
Difference: (2.000000) + (6.000000)i
Product: (11.000000) + (-10.000000)i
Quotient: (-0.411765) + (0.647059)i