/// <summary> /// Gets vector direct cosines /// </summary> /// <param name="va">vector A</param> /// <typeparam name="T">unmanaged type</typeparam> /// <returns>direct cos's</returns> /// <exception cref="MatrixDotNetException"> /// throw if data type is not floating type /// </exception> public static T[] GetDirectCos <T>(Vector <T> va) where T : unmanaged { if (!MathGeneric.IsFloatingPoint <T>()) { throw new NotSupportedException(); } int length = va.Length; T[] cos = new T[length]; T mod = va.GetLengthVec(); Array.Fill(cos, mod); int i = 0; int size = System.Numerics.Vector <T> .Count; int lastIndexBlock = length - length % size; for (; i < lastIndexBlock; i += size) { var vt = new System.Numerics.Vector <T>(va.Array, i); var vf = new System.Numerics.Vector <T>(cos); var vc = Vector.Divide(vt, vf); vc.CopyTo(cos, i); } for (; i < length; i++) { cos[i] = MathUnsafe <T> .Div(va[i], cos[i]); } return(cos); }
public static T GetKleinSum <T>(this Matrix <T> matrix, int dimension, State state = State.Row) where T : unmanaged { if (!MathGeneric.IsFloatingPoint <T>()) { throw new MatrixDotNetException($"{typeof(T)} is not supported type must be floating type"); } return(state == State.Row ? GetKleinSumByRows(matrix, dimension) : GetKleinSumByColumns(matrix, dimension)); }
/// <summary> /// Gets mean value by column. /// </summary> /// <param name="matrix">the matrix.</param> /// <param name="index">the column index.</param> /// <typeparam name="T">unmanaged type.</typeparam> /// <returns>mean value by column.</returns> public static T MeanByColumn <T>(this Matrix <T> matrix, int index) where T : unmanaged { if (!MathGeneric.IsFloatingPoint <T>()) { throw new NotSupportedTypeException(ExceptionArgument.NotSupportedTypeFloatType); } return(MathGeneric <T, int, T> .Divide(matrix.SumByColumn(index), matrix.Rows)); }
/// <summary> /// Initialize /// </summary> /// <param name="matrix">the matrix.</param> /// <exception cref="ArgumentException"></exception> protected Setup(Matrix <T> matrix) { if (!MathGeneric.IsFloatingPoint <T>()) { throw new ArgumentException("Matrix must be floating type."); } ColumnNames = new string[matrix.Columns]; ColumnNumber = new int[matrix.Columns]; Matrix = matrix; }
public static T GetKleinSum <T>(this Matrix <T> matrix) where T : unmanaged { if (!MathGeneric.IsFloatingPoint <T>()) { throw new MatrixDotNetException($"{typeof(T)} is not supported type must be floating type"); } T sum = default; T cs = default; T ccs = default; var comparer = Comparer <T> .Default; for (int i = 0; i < matrix.Rows; i++) { for (int j = 0; j < matrix.Columns; j++) { T t = MathUnsafe <T> .Add(sum, matrix[i, j]); T error; if (comparer.Compare(MathGeneric <T> .Abs(sum), matrix[i, j]) >= 0) { error = MathUnsafe <T> .Add(MathUnsafe <T> .Sub(sum, t), matrix[i, j]); } else { error = MathUnsafe <T> .Add(MathUnsafe <T> .Sub(matrix[i, j], t), sum); } sum = t; t = MathUnsafe <T> .Add(cs, cs); T error2; if (comparer.Compare(MathGeneric <T> .Abs(cs), error) >= 0) { error2 = MathUnsafe <T> .Add(MathUnsafe <T> .Sub(error, t), cs); } else { error2 = MathUnsafe <T> .Add(MathUnsafe <T> .Sub(cs, t), error); } cs = t; ccs = MathUnsafe <T> .Add(ccs, error2); } } return(MathUnsafe <T> .Add(MathUnsafe <T> .Add(sum, cs), ccs)); }
public static Matrix <T> ProcessGrammShmidtByColumns <T>(this Matrix <T> matrix) where T : unmanaged { if (!MathGeneric.IsFloatingPoint <T>()) { throw new NotSupportedTypeException(ExceptionArgument.NotSupportedTypeFloatType); } if (!matrix.IsSquare) { throw new MatrixNotSquareException(); } int m = matrix.Rows; int n = matrix.Columns; Matrix <T> b = new Matrix <T>(m, n) {
/// <summary> /// Gets mean value by each row. /// </summary> /// <param name="matrix">the matrix.</param> /// <typeparam name="T">unmanaged type.</typeparam> /// <returns>mean value by each row.</returns> public static T[] MeanByColumns <T>(this Matrix <T> matrix) where T : unmanaged { if (!MathGeneric.IsFloatingPoint <T>()) { throw new NotSupportedTypeException(ExceptionArgument.NotSupportedTypeFloatType); } var rows = matrix.Rows; var columns = matrix.Columns; var arr = new T[columns]; for (int i = 0; i < columns; i++) { arr[i] = MathGeneric <T, int, T> .Divide(matrix.SumByColumn(i), rows); } return(arr); }
/// <summary> /// Gets mean value by each row. /// </summary> /// <param name="matrix">the matrix.</param> /// <typeparam name="T">unmanaged type.</typeparam> /// <returns>mean value by each row.</returns> public static T[] MeanByRows <T>(this Matrix <T> matrix) where T : unmanaged { if (!MathGeneric.IsFloatingPoint <T>()) { throw new NotSupportedException(); } var rows = matrix.Rows; var columns = matrix.Columns; var arr = new T[rows]; for (int i = 0; i < rows; i++) { arr[i] = MathGeneric <T, int, T> .Divide(matrix.SumByRow(i), columns); } return(arr); }
public static Matrix <T> ProcessGrammShmidtByRows <T>(this Matrix <T> matrix) where T : unmanaged { if (!MathGeneric.IsFloatingPoint <T>()) { throw new NotSupportedTypeException(ExceptionArgument.NotSupportedTypeFloatType); } if (!matrix.IsSquare) { throw new MatrixDotNetException("matrix is not square"); } int m = matrix.Rows; Matrix <T> b = new Matrix <T>(m, matrix.Columns) { [0] = matrix[0] }; for (int i = 1; i < m; i++) { Vectorization.Vector <T> ai = matrix[i]; Vectorization.Vector <T> sum = new T[m]; for (int j = 0; j < i; j++) { Vectorization.Vector <T> bi = b[j]; T scalarProduct = ai * bi; T biMul = bi * bi; T ci = MathGeneric <T> .Divide(scalarProduct, biMul); sum += ci * bi; } var res = ai - sum; b[i] = res.Array; } return(b); }