演算子のオーバーロードを使用した複素数クラスComplex（C#による実装）

Ads by Google

-- / -- / -- ( -- )

上記の広告は１ヶ月以上更新のないブログに表示されています。
新しい記事を書く事で広告が消せます。

スポンサードリンク

-- : -- : -- | スポンサー広告 | page top↑

演算子のオーバーロードを使用した複素数クラスComplex（C#による実装）

2008 / 08 / 18 ( Mon )

Javaで書いた複素数クラスComplexは四則演算をメソッドによって行うため、これを利用したプログラムのソースコードが読みづらくなる問題があります。

（例）

Complex c1 = new Complex(1, 2);
Complex c2 = new Complex(3, 4);
Complex c3 = new Complex(5, 6);
Complex c4 = c3.mul(c1.add(c2));

これをもっと直感的に次のように書くことはできないのでしょうか？

（省略）
Complex c4 = (c1+c2)*c3;

残念ながら、Javaでは不可能です。しかし、C#やC++では演算子をオーバーロードすることにより、これが実現可能です！ここでは、Javaにより近い言語仕様を持つC#で実装してみました。

コンストラクタ

Complex(double re, double im) /* 引数に実部(real part)と虚部(imaginary part)の値を取るコンストラクタです。 */

演算子のオーバーロード

C#ではいくつかの演算子(operator)をオーバーロード(overload)することができます。これにより、オブジェクト同士の演算をメソッドを通じてではなく、二項演算子でもって行うことができます。Complexクラスを利用するプログラムのソースコードが読みやすくなる利点があります。

c1.add(c2); /* メソッドによる演算 */
c1 + c2; /* オーバーロードした演算子による演算 */

プロパティ

C#ではアクセサ(accesor)を「プロパティ(property)」と呼ばれる機構によって宣言することができます。プロパティはクラスのメンバですが、あたかもフィールドであるかのように振る舞います。

Complexクラスは不変クラスとして設計されているため、すべてのプロパティはgetアクセサのみを持ち、setアクセサは持ちません。

Re: double /* 実部の値を返します。 */
Im: double /* 虚部の値を返します。 */
Abs: double /* 絶対値(absolute value)を計算して、その値を返します。 */
Arg: double /* 偏角(argument)を計算して、その値を返します。 */
Con: Complex /* 引数に取った複素数の複素共役(complex conjugate)を計算して、その結果を保持するインスタンスを返します。 */

メソッド

ToString(): String /* 複素数を表す文字列を(a+bi)の形式で返します。 */

using System;

public struct Complex
{
    private readonly double re;
    private readonly double im;

    public Complex(double re, double im)
    {
        this.re = re;
        this.im = im;
    }

    public double Re
    {
        get { return re; }
    }

    public double Im
    {
        get { return im; }
    }
    
    public static Complex operator
        +(Complex c1, Complex c2)
    {
        return
            new Complex(c1.re + c2.re, c1.im + c2.im);
    }

    public static Complex operator
        -(Complex c1, Complex c2)
    {
        return
            new Complex(c1.re - c2.re, c1.im - c2.im);
    }

    public static Complex operator
        *(Complex c1, Complex c2)
    {
        return new Complex(
            c1.re * c2.re - c1.im * c2.im,
            c1.re * c2.im + c1.im * c2.re);
    }

    public static Complex operator
        /(Complex c1, Complex c2)
    {
        var denominator = c2.re * c2.re + c2.im * c2.im;
        return new Complex(
            (c1.re * c2.re + c1.im * c2.im) / denominator,
            (c1.im * c2.re - c1.re * c2.im) / denominator);
    }

    public double Abs
    {
        get { return Math.Sqrt(re * re + im * im); }
    }

    public double Arg
    {
        get { return Math.Atan(im / re); }
    }

    public Complex Con
    {
        get { return new Complex(re, -im); }
    }

    public override string ToString()
    {
        if (im >= 0)
            return String.Format("({0} + {1}i)", re, im);
        else
            return String.Format("({0} - {1}i)", re, -im);
    }
}

class TestComplex
{
    static void Main()
    {
        var c1 = new Complex(1, 2);
        var c2 = new Complex(3, 4);

        Console.WriteLine("{0} + {1} = {2}",
            c1, c2, (c1 + c2));
        Console.WriteLine("{0} - {1} = {2}",
            c1, c2, (c1 - c2));
        Console.WriteLine("{0} * {1} = {2}",
            c1, c2, (c1 * c2));
        Console.WriteLine("{0} / {1} = {2}",
            c1, c2, (c1 / c2));

        Console.WriteLine("|{0}| = {1}", c1, c1.Abs);
        Console.WriteLine("arg{0} = {1}", c1, c1.Arg);
        Console.WriteLine("con{0} = {1}", c1, c1.Con);
    }
}

(1 + 2i) + (3 + 4i) = (4 + 6i)
(1 + 2i) - (3 + 4i) = (-2 - 2i)
(1 + 2i) * (3 + 4i) = (-5 + 10i)
(1 + 2i) / (3 + 4i) = (0.44 + 0.08i)
|(1 + 2i)| = 2.23606797749979
arg(1 + 2i) = 1.10714871779409
con(1 + 2i) = (1 - 2i)

関連記事