/// <summary> /// 要素indexの配列で指定された要素を抽出する. /// </summary> /// <param name="indexes">抽出したい要素の<c>index</c>配列</param> /// <returns>抽出した要素にアクセス可能な<see cref="IVector"/>インタフェース</returns> /// <exception cref="Exception.IllegalArgumentException"> /// 引数が不正の場合にthrowされる. /// </exception> /// <exception cref="Exception.ZeroSizeException"> /// ベクトルサイズが0の場合にthrowされる. /// </exception> public IVector this[params int[] indexes] { get { if (indexes == null) { throw new Exception.IllegalArgumentException("\"indexes\" is null."); } VectorChecker.ZeroSize(this); if (this.Size < indexes.Length) { throw new Exception.IllegalArgumentException("indexes.Length is greater than this.Size"); } foreach (int i in indexes) { if (i < 0 || this.Size <= i) { throw new Exception.IllegalArgumentException( "Index=" + i + " (which is included in the indexes) is out of range."); } } return(new SubVector(this, indexes)); } }
/// <summary> /// 指定されたベクトルから新しい行列を作成する. /// 指定された各ベクトルは,新しい行列において<see cref="VectorType"/>で /// 指定されたベクトルとして解釈され,コピーされる. /// </summary> /// <param name="type">指定されたベクトルの種類</param> /// <param name="vectors"></param> public Matrix(VectorType type, params IVector[] vectors) { VectorChecker.ZeroSize(vectors[0]); int size = vectors[0].Size; foreach (IVector vec in vectors) { if (size != vec.Size) { throw new Exception.MismatchSizeException(); } } int count = vectors.Length; if (type == VectorType.RowVector) { Resize(count, size); for (int r = 0; r < count; ++r) { this.Rows[r] = vectors[r]; } } else { Resize(size, count); for (int c = 0; c < count; ++c) { this.Columns[c] = vectors[c]; } } }
/// <summary> /// law を利用したスケーリング /// </summary> protected static double[] scala(double d, Vector v) { VectorChecker.IsNotZeroSize(v); double[] ret = null; krdlab.law.func.dscal_r(ref ret, v._body, d); return(ret); }
/// <summary> /// law を利用した加算 /// </summary> protected static double[] plus(Vector l, Vector r) { VectorChecker.SizeEquals(l, r); double[] ret = null; krdlab.law.func.daxpy_r(ref ret, 1, l._body, r._body); return(ret); }
/// <summary> /// law を利用した減算 /// </summary> protected static double[] sub(Vector l, Vector r) { VectorChecker.SizeEquals(l, r); double[] ret = null; // ret := -r + l krdlab.law.func.daxpy_r(ref ret, -1, r._body, l._body); return(ret); }
internal static IVector SubEq(IVector v1, IVector v2) { VectorChecker.MismatchSize(v1, v2); for (int i = 0; i < v1.Size; ++i) { v1[i] -= v2[i]; } return(v1); }
internal static IVector MulEq(IVector v1, double val) { VectorChecker.ZeroSize(v1); for (int i = 0; i < v1.Size; ++i) { v1[i] *= val; } return(v1); }
internal static IVector DivEq(IVector v1, double val) { VectorChecker.ValueIsLessThanLimit(val); VectorChecker.ZeroSize(v1); for (int i = 0; i < v1.Size; ++i) { v1[i] /= val; } return(v1); }
internal static void Setter(IVectorCollection collection, int index, IVector value) { IVector dst = collection[index]; IVector src = value; VectorChecker.MismatchSize(src, dst); for (int i = 0; i < src.Size; ++i) { dst[i] = src[i]; } }
/// <summary> /// <see cref="IVector"/>の値を対角要素に持つ対角行列を新しく作成する. /// </summary> /// <param name="v">対角行列の対角要素を格納している<see cref="IVector"/></param> /// <returns>対角行列</returns> /// <exception cref="Exception.ZeroSizeException"> /// ベクトルサイズが0の場合にthrowされる. /// </exception> public static Matrix CreateDiagonalMatrix(IVector v) { VectorChecker.ZeroSize(v); Matrix m = new Matrix(v.Size, v.Size); m.Zero(); v.ForEach(delegate(int i, double e) { m[i, i] = e; }); return(m); }
internal static V DivEq <V>(V v1, double val) where V : IRandomAccessible <double> { VectorChecker.IsNotZeroSize(v1); int size = v1.Size; for (int i = 0; i < v1.Size; ++i) { v1[i] /= val; } return(v1); }
internal static V SubEq <V>(V v1, V v2) where V : IRandomAccessible <double> { VectorChecker.SizeEquals(v1, v2); int size = v1.Size; for (int i = 0; i < size; ++i) { v1[i] -= v2[i]; } return(v1); }
/// <summary> /// 2つのベクトルの相関を求める. /// </summary> /// <param name="vx">ベクトル</param> /// <param name="vy">ベクトル</param> /// <returns>相関</returns> /// <exception cref="System.ArgumentException"> /// ベクトルのサイズが一致しないときにthrowされる. /// </exception> public static double Correlate(IVector vx, IVector vy) { VectorChecker.SizeEquals(vx, vy); double sxy = 0.0; double avg_x = vx.Average; double avg_y = vy.Average; for (int i = 0; i < vx.Size; ++i) { sxy += ((vx[i] - avg_x) * (vy[i] - avg_y)); } return(sxy / Math.Sqrt(vx.Scatter * vy.Scatter)); }
/// <summary> /// /// </summary> /// <param name="cv"></param> /// <param name="rv"></param> /// <returns></returns> public static Matrix operator *(ColumnVector cv, RowVector rv) { VectorChecker.ZeroSize(cv); VectorChecker.ZeroSize(rv); Matrix ret = new Matrix(cv.Size, rv.Size); for (int r = 0; r < cv.Size; ++r) { for (int c = 0; c < rv.Size; ++c) { ret[r, c] = cv[r] * rv[c]; } } return(ret); }
/// <summary> /// 指定されたベクトルから新しい行列を作成する. /// 指定された各ベクトルは,新しい行列の各列にコピーされる. /// </summary> /// <param name="arr"></param> public Matrix(params ColumnVector[] arr) { // 入力の検証 VectorChecker.IsNotZeroSize(arr[0]); int rsize = arr[0].Size; MatrixChecker.EqualAllSizes(rsize, arr); // 構築 int csize = arr.Length; Resize(rsize, csize); for (int c = 0; c < csize; ++c) { this.Columns[c] = arr[c]; } }
/// <summary> /// ベクトル配列から新しい行列を作成する. /// 指定された各ベクトルは,新しい行列の各行にコピーされる. /// </summary> /// <param name="arr"></param> public Matrix(params RowVector[] arr) { // 入力の検証 VectorChecker.IsNotZeroSize(arr[0]); int csize = arr[0].Size; MatrixChecker.EqualAllSizes(csize, arr); // 構築 int rsize = arr.Length; Resize(rsize, csize); for (int r = 0; r < rsize; ++r) { this.Rows[r] = arr[r]; } }
/// <summary> /// </summary> public static Matrix operator *(ColumnVector cv, RowVector rv) { VectorChecker.IsNotZeroSize(cv); VectorChecker.IsNotZeroSize(rv); int rowSize = cv.Size; int colSize = rv.Size; Matrix ret = new Matrix(rowSize, colSize); for (int r = 0; r < rowSize; ++r) { for (int c = 0; c < colSize; ++c) { ret[r, c] = cv._body[r] * rv._body[c]; } } return(ret); }
public static Matrix CreateAsColumns(params IVector[] vs) { VectorChecker.IsNotZeroSize(vs[0]); int size = vs[0].Size; if (vs.Any(v => v.Size != size)) { throw new ArgumentException("jugged vectors"); } int count = vs.Length; Matrix m = new Matrix(size, count); for (int c = 0; c < count; ++c) { m.Columns[c] = vs[c]; } return(m); }
public static Matrix CreateAsRows(params IVector[] vs) { VectorChecker.IsNotZeroSize(vs[0]); int size = vs[0].Size; if (vs.Any(v => v.Size != size)) { throw new ArgumentException("jugged vectors"); } int count = vs.Length; Matrix m = new Matrix(count, size); for (int r = 0; r < count; ++r) { m.Rows[r] = vs[r]; } return(m); }
private static T _Standardize_T <T>(T vector, VarianceType varType) where T : IVector { VectorChecker.ZeroSize(vector); double avg = vector.Average; double std = Math.Sqrt(varType == VarianceType.DivN ? vector.Scatter / vector.Size : vector.Variance); if (clapack.CalculationChecker.IsLessThanLimit(std)) { throw new Exception.ValueIsLessThanLimitException( "The standard variation is less than \"Calculation Limit\".\n" + "Values = " + vector.ToString()); } for (int i = 0; i < vector.Size; ++i) { vector[i] = (vector[i] - avg) / std; } return(vector); }
/// <summary> /// 指定されたベクトルから新しい行列を作成する. /// 指定された各ベクトルは,新しい行列の各列にコピーされる. /// </summary> /// <param name="arr"></param> public Matrix(params ColumnVector[] arr) { // 入力の検証 VectorChecker.ZeroSize(arr[0]); int rsize = arr[0].Size; foreach (ColumnVector cv in arr) { if (rsize != cv.Size) { throw new Exception.MismatchSizeException(); } } // 構築 int csize = arr.Length; Resize(rsize, csize); for (int c = 0; c < csize; ++c) { this.Columns[c] = arr[c]; } }
/// <summary> /// 指定されたベクトルから新しい行列を作成する. /// 指定された各ベクトルは,新しい行列の各行にコピーされる. /// </summary> /// <param name="arr"></param> public Matrix(params RowVector[] arr) { // 入力の検証 VectorChecker.ZeroSize(arr[0]); int csize = arr[0].Size; foreach (RowVector rv in arr) { if (csize != rv.Size) { throw new Exception.MismatchSizeException(); } } // 構築 int rsize = arr.Length; Resize(rsize, csize); for (int r = 0; r < rsize; ++r) { this.Rows[r] = arr[r]; } }
/// <summary> /// /// </summary> /// <param name="v"></param> /// <param name="d"></param> /// <returns></returns> public static new ColumnVector Mul(IVector v, double d) { VectorChecker.ZeroSize(v); return(VectorImpl.Mul(new ColumnVector(v.Size), d, v)); }
/// <summary> /// /// </summary> /// <param name="v1"></param> /// <param name="v2"></param> /// <returns></returns> public static RowVector operator +(RowVector v1, Vector v2) { VectorChecker.MismatchSize(v1, v2); return(VectorImpl.Add(new RowVector(v1.Size), v1, v2)); }
/// <summary> /// /// </summary> /// <param name="v1"></param> /// <param name="v2"></param> /// <returns></returns> public static double operator *(IVector v1, ColumnVector v2) { VectorChecker.MismatchSize(v1, v2); return(VectorImpl.Dot(v1, v2)); }
/// <summary> /// /// </summary> /// <param name="d"></param> /// <param name="v"></param> /// <returns></returns> public static ColumnVector operator *(double d, ColumnVector v) { VectorChecker.ZeroSize(v); return(VectorImpl.Mul(new ColumnVector(v.Size), d, v)); }
/// <summary> /// /// </summary> /// <param name="rv"></param> /// <param name="cv"></param> /// <returns></returns> public static double operator *(RowVector rv, ColumnVector cv) { VectorChecker.MismatchSize(rv, cv); return(VectorImpl.Dot(rv, cv)); }
/// <summary> /// /// </summary> /// <param name="v1"></param> /// <param name="v2"></param> /// <returns></returns> public static new ColumnVector Sub(IVector v1, IVector v2) { VectorChecker.MismatchSize(v1, v2); return(VectorImpl.Sub(new ColumnVector(v1.Size), v1, v2)); }
/// <summary> /// /// </summary> /// <param name="v"></param> /// <param name="d"></param> /// <returns></returns> public static new ColumnVector Div(IVector v, double d) { VectorChecker.ZeroSize(v); return(VectorImpl.Div(new ColumnVector(v.Size), v, d)); }
/// <summary> /// /// </summary> /// <param name="v1"></param> /// <param name="v2"></param> /// <returns></returns> public static ColumnVector operator +(Vector v1, ColumnVector v2) { VectorChecker.MismatchSize(v1, v2); return(VectorImpl.Add(new ColumnVector(v1.Size), v1, v2)); }