解析

• ベクトル

ベクトルクラスを紹介しています。ベクトル同士の演算などを定義しています。

		
public class Vector
{
　　/// <summary>エレメント値の配列</summary>
　　public double[] Values
　　{
　　　　get
　　　　{
　　　　　　return _elements;
　　　　}
　　　　set
　　　　{
　　　　　　_elements = value;
　　　　}
　　}
　　protected double[] _elements;

　　/// <summary>コンストラクタ</summary>
　　public Vector()
　　{
　　　　_elements = new double[ 0 ];
　　}
　　/// <summary>コンストラクタ</summary>
　　public Vector( params double[] data )
　　{
　　　　_elements = new double[ data.Length ];
　　　　for( int i = 0; i < data.Length; i++ )
　　　　{
　　　　　　_elements[ i ] = data[ i ];
　　　　}
　　}
　　/// <summary>コンストラクタ</summary>
　　/// <param name="nElementCount">次元数</param>
　　public Vector( int nElementCount )
　　{
　　　　_elements = new double[ nElementCount ];
　　}
　　/// <summary>次元数</summary>
　　public int Count
　　{
　　　　get
　　　　{
　　　　　　return _elements.Length;
　　　　}
　　}
　　/// <summary>インデクサ。次元に対応する値を取得、設定</summary>
　　public double this[ int nIndex ]
　　{
　　　　get
　　　　{
　　　　　　return _elements[ nIndex ];
　　　　}
　　　　set
　　　　{
　　　　　　_elements[ nIndex ] = value;
　　　　}
　　}

　　/// <summary>クローン作成</summary>
　　/// <returns>クローン</returns>
　　public virtual object Clone()
　　{
　　　　return this.MemberwiseClone();
　　}

　　/// <summary>本ベクトルの長さを返す。</summary>
　　/// <returns>距離</returns>
　　public double GetDistance()
　　{
　　　　// 本ベクトルとゼロベクトル間の距離を計算
　　　　return GetDistance( new Vector( this.Count ) );
　　}

　　/// <summary>本ベクトルから指定のベクトル間の距離を測定</summary>
　　/// <param name="dat">指定のベクトル</param>
　　/// <returns>距離</returns>
　　public double GetDistance( Vector dat )
　　{
　　　　if( this.Count != dat.Count ) return 0;

　　　　double dDistance = 0;
　　　　for( int i = 0; i < dat.Count; i++ )
　　　　{
　　　　　　dDistance += Math.Pow( _elements[ i ] - dat[ i ], 2 );
　　　　}
　　　　return Math.Sqrt( dDistance );
　　}
　　/// <summary>平均取得</summary>
　　/// <returns>平均</returns>
　　public double Average
　　{
　　　　get
　　　　{
　　　　　　double dAvrage = 0;
　　　　　　for( int i = 0; i < this.Count; i++ )
　　　　　　{
　　　　　　　　dAvrage += this[ i ];
　　　　　　}
　　　　　　return dAvrage / this.Count;
　　　　}
　　}
　　/// <summary>分散取得</summary>
　　/// <returns>分散</returns>
　　public double Variance
　　{
　　　　get
　　　　{
　　　　　　// 分散
　　　　　　double dAverage = this.Average;
　　　　　　double dVariance = 0.0;
　　　　　　foreach( double value in _elements )
　　　　　　{
　　　　　　　　dVariance += Math.Pow( ( value - dAverage ), 2 );
　　　　　　}
　　　　　　return dVariance / this.Count;
　　　　}
　　}
　　/// <summary>規格化</summary>
　　/// <returns><para>True: OK</para><para>False: NG</para></returns>
　　public bool Normalize()
　　{
　　　　double dAverage = this.Average;
　　　　double dDeviation = Math.Sqrt( this.Variance );
　　　　for( int i = 0; i < this.Count; i++ )
　　　　{
　　　　　　this[ i ] = ( this[ i ] - dAverage ) / dDeviation;
　　　　}
　　　　return true;
　　}
　　/// <summary>イテレータ取得</summary>
　　/// <returns>イテレータ</returns>
　　public IEnumerator<double> GetEnumerator()
　　{
　　　　for( int i = 0; i < _elements.Length; i++ )
　　　　{
　　　　　　yield return _elements[ i ];
　　　　}
　　}
　　/// <summary>文字列表現を取得</summary>
　　/// <returns>文字列表現</returns>
　　public override string ToString()
　　{
　　　　StringBuilder szText = new StringBuilder();
　　　　szText.Append( "(" );
　　　　for( int i = 0; i < this.Count; i++ )
　　　　{
　　　　　　szText.Append( this[ i ].ToString( "F" ) );
　　　　　　szText.Append( ',' );
　　　　}
　　　　szText = szText.Remove( szText.Length - 1, 1 );
　　　　szText.Append( ")" );
　　　　return szText.ToString();
　　}
　　#region Operator

　　/// <summary>ベクトルの和</summary>
　　/// <param name="dat1">指定のベクトル</param>
　　/// <param name="dat2">指定のベクトル</param>
　　/// <returns>結果ベクトル</returns>
　　public static Vector operator +( Vector dat1, Vector dat2 )
　　{
　　　　if( dat1.Count != dat2.Count ) return null;

　　　　Vector ret = ( Vector )dat1.Clone();
　　　　for( int i = 0; i < dat1.Count; i++ )
　　　　{
　　　　　　ret[ i ] = dat1[ i ] + dat2[ i ];
　　　　}
　　　　return ret;
　　}

　　/// <summary>ベクトルの和拡大</summary>
　　/// <param name="dat1">指定のベクトル</param>
　　/// <param name="dDat">拡大率</param>
　　/// <returns>結果ベクトル</returns>
　　public static Vector operator +( Vector dat1, double dDat )
　　{
　　　　Vector ret = ( Vector )dat1.Clone();
　　　　for( int i = 0; i < dat1.Count; i++ )
　　　　{
　　　　　　ret[ i ] = dat1[ i ] + dDat;
　　　　}
　　　　return ret;
　　}
　　/// <summary>ベクトルの差</summary>
　　/// <param name="dat1">指定のベクトル</param>
　　/// <param name="dat2">指定のベクトル</param>
　　/// <returns>結果ベクトル</returns>
　　public static Vector operator -( Vector dat1, Vector dat2 )
　　{
　　　　if( dat1.Count != dat2.Count ) return null;

　　　　Vector ret = ( Vector )dat1.Clone();
　　　　for( int i = 0; i < dat1.Count; i++ )
　　　　{
　　　　　　ret[ i ] = dat1[ i ] - dat2[ i ];
　　　　}
　　　　return ret;
　　}
　　/// <summary>ベクトルの差拡大</summary>
　　/// <param name="dat1">指定のベクトル</param>
　　/// <param name="dDat">拡大率</param>
　　/// <returns>結果ベクトル</returns>
　　public static Vector operator -( Vector dat1, double dDat )
　　{
　　　　Vector ret = ( Vector )dat1.Clone();
　　　　for( int i = 0; i < dat1.Count; i++ )
　　　　{
　　　　　　ret[ i ] = dat1[ i ] - dDat;
　　　　}
　　　　return ret;
　　}
　　/// <summary>内積</summary>
　　/// <param name="dat1">指定のベクトル</param>
　　/// <param name="dat2">指定のベクトル</param>
　　/// <returns>内積</returns>
　　public static double operator *( Vector dat1, Vector dat2 )
　　{
　　　　if( dat1.Count != dat2.Count ) return 0;

　　　　double dProduct = 0;
　　　　for( int i = 0; i < dat1.Count; i++ )
　　　　{
　　　　　　dProduct += dat1[ i ] * dat2[ i ];
　　　　}
　　　　return dProduct;
　　}
　　/// <summary>ベクトルの積拡大</summary>
　　/// <param name="dat1">指定のベクトル</param>
　　/// <param name="dDat">拡大率</param>
　　/// <returns>結果ベクトル</returns>
　　public static Vector operator *( Vector dat1, double dDat )
　　{
　　　　Vector ret = ( Vector )dat1.Clone();
　　　　for( int i = 0; i < dat1.Count; i++ )
　　　　{
　　　　　　ret[ i ] = dat1[ i ] * dDat;
　　　　}
　　　　return ret;
　　}
　　/// <summary>ベクトルの商拡大</summary>
　　/// <param name="dat1">指定のベクトル</param>
　　/// <param name="dDat">拡大率</param>
　　/// <returns>結果ベクトル</returns>
　　public static Vector operator /( Vector dat1, double dDat )
　　{
　　　　Vector ret = ( Vector )dat1.Clone();
　　　　for( int i = 0; i < dat1.Count; i++ )
　　　　{
　　　　　　ret[ i ] = dat1[ i ] / dDat;
　　　　}
　　　　return ret;
　　}
　　#endregion
}