解析

• 複素数

複素数クラスの実装です。複素数同士の演算も定義しています。

		
/// <summary>複素数クラス</summary>
public class Complex
{
　　/// <summary>実部</summary>
　　public double Real
　　{
　　　　get
　　　　{
　　　　　　return _dReal;
　　　　}
　　　　set
　　　　{
　　　　　　_dReal = value;
　　　　}
　　}
　　/// <summary>虚部</summary>
　　public double Imaginary
　　{
　　　　get
　　　　{
　　　　　　return _dImaginary;
　　　　}
　　　　set
　　　　{
　　　　　　_dImaginary = value;
　　　　}
　　}
　　private double _dReal;
　　private double _dImaginary;

　　/// <summary>コンストラクタ（原点）</summary>
　　public Complex()
　　{
　　　　_dReal = 0.0;
　　　　_dImaginary = 0.0;
　　}

　　/// <summary>コンストラクタ</summary>
　　/// <param name="dReal">実部</param>
　　/// <param name="dImaginary">虚部</param>
　　public Complex( double dReal, double dImaginary )
　　{
　　　　_dReal = dReal;
　　　　_dImaginary = dImaginary;
　　}

　　/// <summary>クローン作成</summary>
　　/// <returns>クローン</returns>
　　public virtual Complex Clone()
　　{
　　　　return ( Complex )this.MemberwiseClone();
　　}
　　/// <summary>
　　/// ハッシュコード取得
　　/// </summary>
　　/// <returns>ハッシュコード</returns>
　　public override int GetHashCode()
　　{
　　　　return ( _dReal.GetHashCode() ^ _dImaginary.GetHashCode() );
　　}
　　/// <summary>ToString</summary>
　　public override string ToString()
　　{
　　　　if( _dImaginary >= 0 )
　　　　{
　　　　　　return "(" + _dReal.ToString() + ", i" + _dImaginary.ToString() + ")";
　　　　}
　　　　else
　　　　{
　　　　　　return "(" + _dReal.ToString() + ", -i" + ( ( -1 ) * _dImaginary ).ToString() + ")";
　　　　}
　　}
　　public override bool Equals( object o )
　　{
　　　　if( o is Complex )
　　　　{
　　　　　　Complex c = ( Complex )o;
　　　　　　return ( this == c );
　　　　}
　　　　return false;
　　}


　　/// <summary>Argument</summary>
　　/// <returns></returns>
　　public double GetArgument()
　　{
　　　　return ( double )Math.Atan2( _dReal, _dImaginary );
　　}
　　/// <summary>共役</summary>
　　/// <returns></returns>
　　public Complex GetConjugate()
　　{
　　　　return new Complex( _dReal, - _dImaginary );
　　}
　　/// <summary>2乗</summary>
　　/// <returns></returns>
　　public Complex GetSquare()
　　{
　　　　return new Complex( _dReal * _dReal - _dImaginary * _dImaginary, 2 * _dReal * _dImaginary );
　　}
　　/// <summary>モジュラス（絶対値）（大きさ）</summary>
　　/// <returns></returns>
　　public double GetModulus()
　　{
　　　　return Math.Sqrt( GetSquareModulus() );
　　}

　　/// <summary>絶対値の乗（大きさ）</summary>
　　/// <returns></returns>
　　public double GetSquareModulus()
　　{
　　　　return _dReal * _dReal + _dImaginary * _dImaginary;
　　}
　　/// <summary>規格化値取得</summary>
　　public Complex GetNormalize()
　　{
　　　　double dModulus = this.GetModulus();
　　　　if( dModulus == 0 )
　　　　{
　　　　　　// ０レングスのため規格化不可能
　　　　　　return null;
　　　　}
　　　　return new Complex( _dReal / dModulus, _dImaginary / dModulus );
　　}
　　/// <summary>規格化</summary>
　　public bool Normalize()
　　{
　　　　double dModulus = this.GetModulus();
　　　　if( dModulus == 0 )
　　　　{
　　　　　　// ０レングスのため規格化不可能
　　　　　　return false;
　　　　}
　　　　_dReal /= dModulus;
　　　　_dImaginary /= dModulus;
　　　　return true;
　　}

　　/// <summary>加算</summary>
　　/// <param name="dat1"></param>
　　/// <param name="dat2"></param>
　　/// <returns></returns>
　　public static Complex operator +( Complex dat1, Complex dat2 )
　　{
　　　　Complex ret = ( Complex )dat1.Clone();
　　　　ret.Real += dat2.Real;
　　　　ret.Imaginary += dat2.Imaginary;
　　　　return ret;
　　}
　　/// <summary>加算</summary>
　　/// <param name="dat1"></param>
　　/// <param name="dat2"></param>
　　/// <returns></returns>
　　public static Complex operator +( Complex dat1, double dat2 )
　　{
　　　　Complex ret = ( Complex )dat1.Clone();
　　　　ret.Real += dat2;
　　　　ret.Imaginary += dat2;
　　　　return ret;
　　}
　　/// <summary>減算</summary>
　　/// <param name="dat1"></param>
　　/// <param name="dat2"></param>
　　/// <returns></returns>
　　public static Complex operator -( Complex dat1, Complex dat2 )
　　{
　　　　Complex ret = ( Complex )dat1.Clone();
　　　　ret.Real -= dat2.Real;
　　　　ret.Imaginary -= dat2.Imaginary;
　　　　return ret;
　　}
　　/// <summary>減算</summary>
　　/// <param name="dat1"></param>
　　/// <param name="dat2"></param>
　　/// <returns></returns>
　　public static Complex operator -( Complex dat1, double dat2 )
　　{
　　　　Complex ret = ( Complex )dat1.Clone();
　　　　ret.Real -= dat2;
　　　　ret.Imaginary -= dat2;
　　　　return ret;
　　}
　　/// <summary>乗算</summary>
　　/// <param name="dat1"></param>
　　/// <param name="dat2"></param>
　　/// <returns></returns>
　　public static Complex operator *( Complex dat1, Complex dat2 )
　　{
　　　　double dReal = dat1.Real * dat2.Real - dat1.Imaginary * dat2.Imaginary;
　　　　double dImaginary = dat1.Real * dat2.Imaginary + dat1.Imaginary * dat2.Real;
　　　　return new Complex( dReal, dImaginary );
　　}
　　/// <summary>乗算</summary>
　　/// <param name="dat1"></param>
　　/// <param name="dat2"></param>
　　/// <returns></returns>
　　public static Complex operator *( Complex dat1, double dat2 )
　　{
　　　　Complex ret = ( Complex )dat1.Clone();
　　　　ret.Real *= dat2;
　　　　ret.Imaginary *= dat2;
　　　　return ret;
　　}
　　/// <summary>除算</summary>
　　/// <param name="dat1"></param>
　　/// <param name="dat2"></param>
　　/// <returns></returns>
　　public static Complex operator /( Complex dat1, double dat2 )
　　{
　　　　Complex ret = ( Complex )dat1.Clone();
　　　　ret.Real /= dat2;
　　　　ret.Imaginary /= dat2;
　　　　return ret;
　　}
　　/// <summary>比較</summary>
　　/// <param name="dat1"></param>
　　/// <param name="dat2"></param>
　　/// <returns></returns>
　　public static bool operator ==( Complex dat1, Complex dat2 )
　　{
　　　　return ( dat1.Real == dat2.Real ) && ( dat1.Imaginary == dat2.Imaginary );
　　}
　　public static bool operator !=( Complex dat1, Complex dat2 )
　　{
　　　　return !( dat1 == dat2 );
　　}

}