/// <summary> /// Multiplying two matrices /// </summary> /// <param name="one">MatrixMB - first matrix</param> /// <param name="two">MatrixMB - second matrix</param> /// <returns>MatrixMB - new Matrix as a result of multiplication</returns> /// <remarks>tested according to https://www.youtube.com/watch?v=kuixY2bCc_0 </remarks> public static MatrixMB operator *(MatrixMB one, MatrixMB two) { var mat = new MatrixMB(one.Rows, two.Cols); if (one.Cols != two.Rows) { throw new MatrixException( "Cannot multiply two matrices. Matrix one cols number doesn't match matrix two rows size. " + System.String.Format("Matrix one: {0}x{1}, Matrix two: {2}x{3}", one.Cols, one.Rows, two.Cols, two.Rows)); } else { for (int i = 0; i < one.Rows; i++) { for (int j = 0; j < two.Cols; j++) { for (int k = 0; k < one.Cols; k++) { mat.Data[i][j] += one.Data[i][k] * two.Data[k][j]; } } } return(mat); } }
/// <summary> /// Creates matrix filled with zeros /// </summary> /// <param name="rows">int - matrix rows number</param> /// <param name="cols">int - matrix cols number</param> /// <returns>MatrixMB</returns> public static MatrixMB Zeros(int rows, int cols) { MatrixMB mat = new MatrixMB(rows, cols); mat.FillWithNumber(0); return(mat); }
/// <summary> /// Create matrix filled with ones /// </summary> /// <param name="rows">int - matrix rows number</param> /// <param name="cols">int - matrix cols number</param> /// <returns>MatrixMB</returns> public static MatrixMB Ones(int rows, int cols) { MatrixMB m = new MatrixMB(rows, cols); m.FillWithNumber(1); return(m); }
/// <summary> /// Gets specified row /// </summary> /// <param name="row">int - row index</param> /// <returns>MatrixMB</returns> public MatrixMB Row(int row) { MatrixMB mat = new MatrixMB(1, this.Cols); mat.Data[0] = Data[row]; return(mat); }
/// <summary> /// Set column /// </summary> /// <param name="v">MatrixMB - column vector</param> /// <param name="column">int - column index</param> public void SetCol(MatrixMB v, int column) { for (int i = 0; i < Rows; i++) { Data[i][column] = v.Data[i][0]; } }
public void CalculatingLowerUpperMatrices() { MatrixMB mat = new MatrixMB(2, 2); mat.Data[0][0] = 4; mat.Data[0][1] = 7; mat.Data[1][0] = 2; mat.Data[1][1] = 6; mat.MakeLU(); Assert.AreEqual(4, mat.Data[0][0]); Assert.AreEqual(7, mat.Data[0][1]); Assert.AreEqual(2, mat.Data[1][0]); Assert.AreEqual(6, mat.Data[1][1]); var L = mat.L; Assert.AreEqual(1, L.Data[0][0]); Assert.AreEqual(0, L.Data[0][1]); Assert.AreEqual(0.5, L.Data[1][0]); Assert.AreEqual(1, L.Data[1][1]); var U = mat.U; Assert.AreEqual(4, U.Data[0][0]); Assert.AreEqual(7, U.Data[0][1]); Assert.AreEqual(0, U.Data[1][0]); Assert.AreEqual(2.5, U.Data[1][1]); }
/// <summary> /// Substraction of two matrices /// </summary> /// <param name="one">MatrixMB - first matrix</param> /// <param name="two">MatrixMB - second matrix</param> /// <returns>MatrixMB - new MatrixMB as a result of substraction</returns> public static MatrixMB operator -(MatrixMB one, MatrixMB two) { try { if (one.Cols == two.Cols && one.Rows == two.Rows) { var matrix = new MatrixMB(one.Rows, one.Cols); int row, col; for (row = 0; row < one.Rows; row++) { for (col = 0; col < one.Cols; col++) { matrix.Data[row][col] = one.Data[row][col] - two.Data[row][col]; } } return(matrix); } else { throw new System.Exception(System.String.Format("Cannot substract two matrices. Matrix size doesn't match. Matrix one: {0}x{1}, Matrix two: {2}x{3}", one.Cols, one.Rows, two.Cols, two.Rows)); } } catch (System.Exception ex) { throw new MatrixException("Matrix addition error", ex); } }
/// <summary> /// Function resolves Ax = v in confirmity with solution vector /// </summary> /// <param name="vector">Matrix - solution vector</param> /// <returns>Matrix</returns> public MatrixMB SolveWith(MatrixMB vector) { if (Rows != Cols) { throw new MatrixException("Solve: Matrix is not square."); } if (Rows != vector.Rows) { throw new MatrixException("Solve: wrong number of results in solution vector."); } if (L == null) { MakeLU(); } MatrixMB b = new MatrixMB(Rows, 1); for (int i = 0; i < Rows; i++) { b[i, 0] = vector[PermutationVector[i], 0]; // switch two items in "v" due to permutation matrix } MatrixMB z = SubsForth(L, b); MatrixMB x = SubsBack(U, z); return(x); }
/// <summary> /// Default constructor /// </summary> /// <param name="result">LearnResult - learning result</param> /// <param name="chartFilename">string - char filename</param> /// <param name="includeDataTable">bool - true id learning data should be included</param> public HistoryPDF(LearnByErrorLibrary.LearnResult result, String chartFilename, bool includeDataTable = false) { this.result = result; this.chartFilename = chartFilename; document = new Document(); document.Info.Title = "NBN C# - wynik uczenia sieci neuronowej"; document.Info.Subject = "Uczenie sieci neuronowej za pomocą algorytmu NBN C#"; document.Info.Author = "Marek Bar 33808"; document.Info.Comment = "...ponieważ tylko dobry kod się liczy."; document.Info.Keywords = "C#, NBN, neuron, uczenie, sieć, nbn c#"; DefineStyles(document); DefineCover(document); DefineInfo(document, result); DefineChartArea(document, chartFilename, Path.GetFileNameWithoutExtension(result.Filename)); DefineWeightsSection(document, result); if (includeDataTable) { MatrixMB mat = MatrixMB.Load(result.Filename); AddMatrixTable(document, mat); } Section section = document.LastSection; section.AddPageBreak();//index of pages Paragraph paragraph = section.AddParagraph("Spis treści"); paragraph.Format.Font.Size = 14; paragraph.Format.Font.Bold = true; paragraph.Format.SpaceAfter = 24; paragraph.Format.OutlineLevel = OutlineLevel.Level1; paragraph = section.AddParagraph(); paragraph.Style = "TOC"; //first link Hyperlink hyperlink = paragraph.AddHyperlink("Informacje na temat sieci neuronowej"); hyperlink.AddText("\r\n" + "Informacje na temat sieci neuronowej" + "\t"); hyperlink.AddPageRefField("Informacje na temat sieci neuronowej"); hyperlink = paragraph.AddHyperlink("Wykres przebiegu uczenia"); hyperlink.AddText("\r\n" + "Wykres przebiegu uczenia" + "\t"); hyperlink.AddPageRefField("Wykres przebiegu uczenia"); hyperlink = paragraph.AddHyperlink("Wagi otrzymane w procesie uczenia"); hyperlink.AddText("\r\n" + "Wagi otrzymane w procesie uczenia" + "\t"); hyperlink.AddPageRefField("Wagi otrzymane w procesie uczenia"); if (includeDataTable) { hyperlink = paragraph.AddHyperlink("Dane wejściowe"); hyperlink.AddText("\r\n" + "Dane wejściowe" + "\t"); hyperlink.AddPageRefField("Dane wejściowe"); } }
/// <summary> /// Gets specified column /// </summary> /// <param name="column">int - column index</param> /// <returns>MatrixMB</returns> public MatrixMB Col(int column) { MatrixMB matrix = new MatrixMB(Rows, 1); for (int i = 0; i < Rows; i++) { matrix.Data[i][0] = Data[i][column]; } return(matrix); }
/// <summary> /// Convert MatrixMB to VectorVertical /// </summary> /// <param name="mat">MatrixMB</param> /// <returns>VectorVertical</returns> public static VectorVertical ToVectorVertical(this MatrixMB mat) { VectorVertical vv = new VectorVertical(mat.Rows); for (int row = 0; row < mat.Cols; row++) { vv.Data[row][0] = mat.Data[row][0]; } return(vv); }
/// <summary> /// Creates identity matrix /// </summary> /// <param name="rows">int - matrix rows number</param> /// <param name="cols">int - matrix cols number</param> /// <returns>MatrixMB</returns> public static MatrixMB Identity(int rows, int cols) { MatrixMB m = new MatrixMB(rows, cols); for (int i = 0; i < System.Math.Min(rows, cols); i++) { m.Data[i][i] = 1; } return(m); }
/// <summary> /// Convert MatrixMB to VectorHorizontal /// </summary> /// <param name="mat">MatrixMB</param> /// <returns>VectorHorizontal</returns> public static VectorHorizontal ToVectorHorizontal(this MatrixMB mat) { VectorHorizontal vh = new VectorHorizontal(mat.Cols); for (int col = 0; col < mat.Cols; col++) { vh.Data[0][col] = mat.Data[0][col]; } return(vh); }
/// <summary> /// Create new Matrix from specified set of rows /// </summary> /// <param name="start">int - position of first row in original Matrix</param> /// <param name="stop">int - position of last row in original Matrix</param> /// <returns>MatrixMB - new matrix from selected rows</returns> public MatrixMB CopyRows(int start, int stop) { MatrixMB m = new MatrixMB(stop - start + 1, this.Cols); for (int i = start, c = 0; i <= stop; i++, c++) { m.Data[c] = this.Data[i]; } return(m); }
/// <summary> /// Convert MatrixMB to Weights /// </summary> /// <param name="mat">MatrixMB</param> /// <returns>Weights</returns> public static Weights ToWeights(this MatrixMB mat) { Weights weights = new Weights(mat.Cols); for (int col = 0; col < mat.Cols; col++) { weights.Data[0][col] = mat.Data[0][col]; } return(weights); }
public MatrixMB SolveEquatation(MatrixMB other) { return(this.Inverted * other); /*Accord version - the most accurate*/ var m = Data.ToMultidimensionalArray(Rows, Cols).Solve(other.Data.ToMultidimensionalArray(other.Rows, other.Cols)); //var m = Data.ToMultidimensionalArray().Inverse().Multiply(other.Data.ToMultidimensionalArray()); MatrixMB tmp = new MatrixMB(m.GetLength(0), m.GetLength(1)); tmp.Data = m.ToJaggedArray(tmp.Rows, tmp.Cols); return(tmp); }
/// <summary> /// Matrix eye - with ones on diagonal /// </summary> /// <param name="size">int - matrix size</param> /// <returns>MatrixMB</returns> public static MatrixMB Eye(int size) { MatrixMB m = new MatrixMB(size, size); for (int i = 0; i < size; i++) { for (int j = 0; j < size; j++) { m.Data[i][j] = i == j ? 1 : 0; } } return(m); }
/// <summary> /// Convert MatrixMB to Output /// </summary> /// <param name="mat">MatrixMB</param> /// <returns>Output</returns> public static Output ToOutput(this MatrixMB mat) { Output output = new Output(mat.Rows, mat.Cols); for (int col = 0; col < mat.Cols; col++) { for (int row = 0; row < mat.Rows; row++) { output.Data[row][col] = mat.Data[row][col]; } } return(output); }
/// <summary> /// Convert MatrixMB to Input /// </summary> /// <param name="mat">MatrixMB</param> /// <returns>Input</returns> public static Input ToInput(this MatrixMB mat) { Input input = new Input(mat.Rows, mat.Cols); for (int col = 0; col < mat.Cols; col++) { for (int row = 0; row < mat.Rows; row++) { input.Data[row][col] = mat.Data[row][col]; } } return(input); }
/// <summary> /// Create new matrix from specified set of columns /// </summary> /// <param name="start">int - position of first column</param> /// <param name="stop">int - position of last column</param> /// <returns>MatrixMB</returns> public MatrixMB CopyColumns(int start, int stop) { MatrixMB m = new MatrixMB(this.Rows, stop - start + 1); for (int i = 0; i < m.Rows; i++) { for (int j = start, c = 0; j <= stop; j++, c++) { m.Data[i][c] = this.Data[i][j]; } } return(m); }
/// <summary> /// Get matrix data nice format /// </summary> /// <param name="mat">MatrixMB</param> /// <returns>string - matrix text representation</returns> public static String NiceMatrixFormat(this MatrixMB mat) { string s = ""; for (int i = 0; i < mat.Rows; i++) { for (int j = 0; j < mat.Cols; j++) { s += String.Format("{0,5:0.00}", mat.Data[i][j]) + " "; } s += "\r\n"; } return(s); }
/// <summary> /// Creates random filled matrix /// </summary> /// <param name="rows">int - matrix rows numer</param> /// <param name="cols">int - matrix cols number</param> /// <param name="dispersion">int - randomize range</param> /// <returns>MatrixMB</returns> public static MatrixMB Random(int rows, int cols, int dispersion) { System.Random random = new System.Random(); MatrixMB matrix = new MatrixMB(rows, cols); int max = dispersion; int min = -dispersion; for (int i = 0; i < rows; i++) { for (int j = 0; j < cols; j++) { matrix.Data[i][j] = random.NextDouble() * (max - min) + min; } } return(matrix); }
/// <summary> /// Convert Matrix to string representation /// </summary> /// <param name="mat">MatrixMB</param> /// <returns>String</returns> public static String MatrixToString(this MatrixMB mat) { System.Text.StringBuilder sb = new System.Text.StringBuilder(); for (var row = 0; row < mat.Rows; row++) { for (var col = 0; col < mat.Cols; col++) { sb.Append(mat.Data[row][col]); sb.Append(", "); } sb.AppendLine(); } return(sb.ToString()); }
/// <summary> /// Check if matrix is filled with zeros only /// </summary> /// <param name="mat">MatrixMB</param> /// <returns>bool</returns> public static bool IsZeroed(this MatrixMB mat) { int counter = mat.Rows * mat.Cols; for (int r = 0; r < mat.Rows; r++) { for (int c = 0; c < mat.Cols; c++) { if (mat.Data[r][c] == 0) { counter--; } } } return(counter == 0); }
public void DivideMatrixByMatrix() { MatrixMB mat = new MatrixMB(2, 2); mat.Data[0][0] = 4; mat.Data[0][1] = 7; mat.Data[1][0] = 2; mat.Data[1][1] = 6; MatrixMB b = new MatrixMB(2, 1); b[0, 0] = 1; b[1, 0] = 2; var divided = mat.Inverted * b; Assert.AreEqual(-0.8, Math.Round(divided[0, 0], 4)); Assert.AreEqual(0.6, Math.Round(divided[1, 0], 4)); }
/// <summary> /// Execute operation on each value in matrix /// </summary> /// <param name="operation">MatrixValueOperation - operation type</param> /// <param name="number">double - value</param> /// <returns>MatrixMB</returns> public MatrixMB OperationNew(MatrixAction operation, double number) { MatrixMB mat = this.Copy(); switch (operation) { case MatrixAction.Add: { mat.AddNumber(number); } break; case MatrixAction.Substract: { mat.SubNumber(number); } break; case MatrixAction.Multiply: { mat.MulByNumber(number); } break; case MatrixAction.Divide: { mat.DivByNumber(number); } break; case MatrixAction.Power: { mat.PowerByNumber(number); } break; case MatrixAction.Sqrt: { mat.SqrtFromNumber(); } break; case MatrixAction.Abs: { mat.AbsoluteNumber(); } break; } return(mat); }
/// <summary> /// Check if object is Matrix - equal are Matrix and its derivates /// </summary> /// <param name="obj">object - some object</param> /// <returns>bool - true - same, false - sth. else</returns> public override bool Equals(object obj) { if (obj is MatrixMB) { try { MatrixMB m = (MatrixMB)obj; return(this.Cols == m.Cols && this.Rows == m.Rows); } catch { return(false); } } else { return(false); } }
/// <summary> /// Function solves Ax = b for A as an upper triangular matrix /// </summary> /// <param name="A">MatrixMB - upper triangular matrix</param> /// <param name="b">MatrixMB</param> /// <returns>MatrixMB</returns> public static MatrixMB SubsBack(MatrixMB A, MatrixMB b) { if (A.L == null) { A.MakeLU(); } int n = A.Rows; MatrixMB x = new MatrixMB(n, 1); for (int i = n - 1; i > -1; i--) { x[i, 0] = b[i, 0]; for (int j = n - 1; j > i; j--) { x[i, 0] -= A[i, j] * x[j, 0]; } x[i, 0] = x[i, 0] / A[i, i]; } return(x); }
/// <summary> /// Function solves Ax = b for A as a lower triangular matrix /// </summary> /// <param name="A">MatrixMB - lower triangular matrix</param> /// <param name="b">MatrixMB</param> /// <returns>MatrixMB</returns> public static MatrixMB SubsForth(MatrixMB A, MatrixMB b) { if (A.L == null) { A.MakeLU(); } int n = A.Rows; MatrixMB x = new MatrixMB(n, 1); for (int i = 0; i < n; i++) { x[i, 0] = b[i, 0]; for (int j = 0; j < i; j++) { x[i, 0] -= A[i, j] * x[j, 0]; } x[i, 0] = x[i, 0] / A[i, i]; } return(x); }
/// <summary> /// Function resolves Ax = v in confirmity with solution vector /// </summary> /// <param name="vector">Matrix - solution vector</param> /// <returns>Matrix</returns> public MatrixMB SolveWith(MatrixMB vector) { if (Rows != Cols) throw new MatrixException("Solve: Matrix is not square."); if (Rows != vector.Rows) throw new MatrixException("Solve: wrong number of results in solution vector."); if (L == null) MakeLU(); MatrixMB b = new MatrixMB(Rows, 1); for (int i = 0; i < Rows; i++) b[i, 0] = vector[PermutationVector[i], 0]; // switch two items in "v" due to permutation matrix MatrixMB z = SubsForth(L, b); MatrixMB x = SubsBack(U, z); return x; }
/// <summary> /// Multiplying two matrices /// </summary> /// <param name="one">MatrixMB - first matrix</param> /// <param name="two">MatrixMB - second matrix</param> /// <returns>MatrixMB - new Matrix as a result of multiplication</returns> /// <remarks>tested according to https://www.youtube.com/watch?v=kuixY2bCc_0 </remarks> public static MatrixMB operator *(MatrixMB one, MatrixMB two) { var mat = new MatrixMB(one.Rows, two.Cols); if (one.Cols != two.Rows) { throw new MatrixException( "Cannot multiply two matrices. Matrix one cols number doesn't match matrix two rows size. " + System.String.Format("Matrix one: {0}x{1}, Matrix two: {2}x{3}", one.Cols, one.Rows, two.Cols, two.Rows)); } else { for (int i = 0; i < one.Rows; i++) { for (int j = 0; j < two.Cols; j++) { for (int k = 0; k < one.Cols; k++) { mat.Data[i][j] += one.Data[i][k] * two.Data[k][j]; } } } return mat; } }
public MatrixMB SolveEquatation(MatrixMB other) { return this.Inverted * other; /*Accord version - the most accurate*/ var m = Data.ToMultidimensionalArray(Rows,Cols).Solve(other.Data.ToMultidimensionalArray(other.Rows,other.Cols)); //var m = Data.ToMultidimensionalArray().Inverse().Multiply(other.Data.ToMultidimensionalArray()); MatrixMB tmp = new MatrixMB(m.GetLength(0), m.GetLength(1)); tmp.Data = m.ToJaggedArray(tmp.Rows, tmp.Cols); return tmp; }
/// <summary> /// Creates random filled matrix /// </summary> /// <param name="rows">int - matrix rows numer</param> /// <param name="cols">int - matrix cols number</param> /// <param name="dispersion">int - randomize range</param> /// <returns>MatrixMB</returns> public static MatrixMB Random(int rows, int cols, int dispersion) { System.Random random = new System.Random(); MatrixMB matrix = new MatrixMB(rows, cols); int max = dispersion; int min = -dispersion; for (int i = 0; i < rows; i++) { for (int j = 0; j < cols; j++) { matrix.Data[i][j] = random.NextDouble() * (max - min) + min; } } return matrix; }
/// <summary> /// Create new Matrix from specified set of rows /// </summary> /// <param name="start">int - position of first row in original Matrix</param> /// <param name="stop">int - position of last row in original Matrix</param> /// <returns>MatrixMB - new matrix from selected rows</returns> public MatrixMB CopyRows(int start, int stop) { MatrixMB m = new MatrixMB(stop - start + 1, this.Cols); for (int i = start, c = 0; i <= stop; i++, c++) { m.Data[c] = this.Data[i]; } return m; }
/// <summary> /// Creates identity matrix /// </summary> /// <param name="rows">int - matrix rows number</param> /// <param name="cols">int - matrix cols number</param> /// <returns>MatrixMB</returns> public static MatrixMB Identity(int rows, int cols) { MatrixMB m = new MatrixMB(rows, cols); for (int i = 0; i < System.Math.Min(rows, cols); i++) { m.Data[i][i] = 1; } return m; }
/// <summary> /// Loads matrix from file /// </summary> /// <param name="filename">String - filename</param> /// <returns>MatrixMB</returns> public static MatrixMB Load(System.String filename) { char splitter = ','; try { if (!System.IO.File.Exists(filename) || filename == "") { throw new System.Exception("Cannot find file: " + filename); } string text; using (System.IO.StreamReader streamReader = new System.IO.StreamReader(filename, System.Text.Encoding.UTF8)) { text = streamReader.ReadToEnd(); } var lines = text.Split(new char[] { '\r', '\n' }); var rows = lines.Length; foreach (var line in lines) { if (line == "") rows--; } string[] splitted = lines[0].Split(new char[] { splitter }); if (splitted.Length == 1) { splitter = ' '; splitted = lines[0].Split(new char[] { splitter }); } if (splitted.Length == 1) { splitter = ';'; splitted = lines[0].Split(new char[] { splitter }); } if (splitted.Length == 1) { splitter = '\t'; splitted = lines[0].Split(new char[] { splitter }); } var cols = splitted.Length; for (int i = 0; i < splitted.Length; i++) { if (splitted[i] == "") cols--; } MatrixMB m = new MatrixMB(rows, cols); var row = 0; foreach (var line in lines) { if (line != "") { var data = line.TrimEnd(new char[] { ',', ' ' }).Split(new char[] { splitter }); var col = 0; foreach (var number in data) { if (number != "") { m.Data[row][col] = double.Parse(number.Replace('.', ',').Trim()); col++; } } row++; } } m.Name = System.IO.Path.GetFileNameWithoutExtension(filename); return m; } catch (System.Exception ex) { throw new MatrixException("Loading matrix from file error (splitter: " + splitter.ToString() + "). File: " + filename, ex); } }
public void TransposeMatrix() { MatrixMB mat = new MatrixMB(3, 3); mat[0, 0] = 1; mat[0, 1] = 2; mat[0, 2] = 3; mat[1, 0] = 4; mat[1, 1] = 5; mat[1, 2] = 6; mat[2, 0] = 7; mat[2, 1] = 8; mat[2, 2] = 9; var t = mat.Transposed; Assert.AreEqual(1, t[0, 0]); Assert.AreEqual(2, t[1, 0]); Assert.AreEqual(3, t[2, 0]); Assert.AreEqual(4, t[0, 1]); Assert.AreEqual(5, t[1, 1]); Assert.AreEqual(6, t[2, 1]); Assert.AreEqual(7, t[0, 2]); Assert.AreEqual(8, t[1, 2]); Assert.AreEqual(9, t[2, 2]); }
/// <summary> /// Substraction of two matrices /// </summary> /// <param name="one">MatrixMB - first matrix</param> /// <param name="two">MatrixMB - second matrix</param> /// <returns>MatrixMB - new MatrixMB as a result of substraction</returns> public static MatrixMB operator -(MatrixMB one, MatrixMB two) { try { if (one.Cols == two.Cols && one.Rows == two.Rows) { var matrix = new MatrixMB(one.Rows, one.Cols); int row, col; for (row = 0; row < one.Rows; row++) { for (col = 0; col < one.Cols; col++) { matrix.Data[row][col] = one.Data[row][col] - two.Data[row][col]; } } return matrix; } else { throw new System.Exception(System.String.Format("Cannot substract two matrices. Matrix size doesn't match. Matrix one: {0}x{1}, Matrix two: {2}x{3}", one.Cols, one.Rows, two.Cols, two.Rows)); } } catch (System.Exception ex) { throw new MatrixException("Matrix addition error", ex); } }
public void SumTwoMatrices() { MatrixMB mat1 = new MatrixMB(5, 5); MatrixMB mat2 = new MatrixMB(5, 5); mat1.FillWithNumber(1); mat2.FillWithNumber(2); var mat = mat1 + mat2; Assert.AreEqual(75, mat.SumAllValues()); }
public void SubstractTwoMatrices() { MatrixMB mat1 = new MatrixMB(5, 5); MatrixMB mat2 = new MatrixMB(5, 5); mat1.FillWithNumber(4); mat2.FillWithNumber(2); var mat = mat1 - mat2; Assert.AreEqual(50, mat.SumAllValues()); }
/// <summary> /// Calculate lower and upper traingular matrix - this is LU decomposition of matrix /// </summary> public void MakeLU() { //try //{ // if (!IsSquare) throw new MatrixException("The matrix is not square!"); // var lu = new Accord.Math.Decompositions.LuDecomposition(this.Data.ToMultidimensionalArray(Rows, Cols)); // var l = lu.LowerTriangularFactor; // var u = lu.UpperTriangularFactor; // L = new MatrixMB(l.GetLength(0), l.GetLength(1), l.ToJaggedArray(l.GetLength(0), l.GetLength(1))); // U = new MatrixMB(u.GetLength(0), u.GetLength(1), u.ToJaggedArray(u.GetLength(0), u.GetLength(1))); // PermutationVector = lu.PivotPermutationVector; //} //catch (System.Exception ex) //{ // throw new System.Exception(ex.Message); //} //return; //-------------------------------------------------------------------- if (!IsSquare) { throw new MatrixException("The matrix is not square!"); } L = MatrixMB.Identity(Rows, Cols); U = this.Copy(); PermutationVector = new int[Rows]; for (int i = 0; i < Rows; i++) { PermutationVector[i] = i; } double p = 0; double pom2; int k0 = 0; int pom1 = 0; for (int k = 0; k < Rows - 1; k++) { p = 0; for (int i = k; i < Rows; i++) // find the row with the biggest pivot { if (System.Math.Abs(U.Data[i][k]) > p) { p = System.Math.Abs(U.Data[i][k]); k0 = i; } } if (p == 0) { throw new MatrixException("Making LU: matrix is singular!"); } pom1 = PermutationVector[k]; PermutationVector[k] = PermutationVector[k0]; PermutationVector[k0] = pom1; for (int i = 0; i < k; i++) { pom2 = L.Data[k][i]; L.Data[k][i] = L.Data[k0][i]; L.Data[k0][i] = pom2; } if (k != k0) { detOfP *= -1; } for (int i = 0; i < Rows; i++) { pom2 = U.Data[k][i]; U.Data[k][i] = U.Data[k0][i]; U.Data[k0][i] = pom2; } for (int i = k + 1; i < Rows; i++) { L.Data[i][k] = U.Data[i][k] / U.Data[k][k]; for (int j = k; j < Rows; j++) { U.Data[i][j] -= L.Data[i][k] * U.Data[k][j]; } } } }
/// <summary> /// Function solves Ax = b for A as a lower triangular matrix /// </summary> /// <param name="A">MatrixMB - lower triangular matrix</param> /// <param name="b">MatrixMB</param> /// <returns>MatrixMB</returns> public static MatrixMB SubsForth(MatrixMB A, MatrixMB b) { if (A.L == null) A.MakeLU(); int n = A.Rows; MatrixMB x = new MatrixMB(n, 1); for (int i = 0; i < n; i++) { x[i, 0] = b[i, 0]; for (int j = 0; j < i; j++) x[i, 0] -= A[i, j] * x[j, 0]; x[i, 0] = x[i, 0] / A[i, i]; } return x; }
/// <summary> /// Initialize NBN with data from specified file /// </summary> /// <param name="filename">String - filename</param> /// <returns>bool - success flag</returns> private bool loadInputData(String filename) { try { if (!File.Exists(filename)) { throw new NeuralNetworkError(String.Format(Properties.Settings.Default.NBN1, filename)); } try { var data = MatrixMB.Load(filename); if (MatLabCompareDataFolder.Length > 0) { //data from matlab are normalized string name = Path.GetFileNameWithoutExtension(Directory.GetFiles(MatLabCompareDataFolder, "*.dat")[0]); inputLearn = MatrixMB.Load(string.Format("{0}\\uczenie_wejscie_{1}.txt", MatLabCompareDataFolder, name)).ToInput(); inputTest = MatrixMB.Load(string.Format("{0}\\testowanie_wejscie_{1}.txt", MatLabCompareDataFolder, name)).ToInput(); outputLearn = MatrixMB.Load(string.Format("{0}\\uczenie_wyjscie_{1}.txt", MatLabCompareDataFolder, name)).ToOutput(); outputTest = MatrixMB.Load(string.Format("{0}\\testowanie_wyjscie_{1}.txt", MatLabCompareDataFolder, name)).ToOutput(); } else { input = data.CopyColumnsWithoutLast().ToInput(); input.Normalize(); output = data.LastColumn.ToOutput(); output.Normalize(); if (IsClassification) { int Tnp = data.Rows; inputLearn = input.CopyRows(Tnp - 1).ToInput(); inputTest = input.CopyRows(Tnp - 1).ToInput(); outputLearn = output.CopyRows(Tnp - 1).ToOutput(); outputTest = output.CopyRows(Tnp - 1).ToOutput(); } else { int[] ind = data.Rows.RandomPermutation(); int Tnp = Math.Round(data.Rows * 0.7).ToInt(); inputTest = input.CopyRows(Tnp, input.Rows - 1).ToInput(); inputLearn = input.CopyRows(Tnp - 1).ToInput(); outputTest = output.CopyRows(Tnp, input.Rows - 1).ToOutput(); outputLearn = output.CopyRows(Tnp - 1).ToOutput(); } } try { if (IsResearchMode)//export for matlab - out of use { string name = Path.GetFileNameWithoutExtension(filename); DateTime d = DateTime.Now; string dir = String.Format("{0}\\Executed research\\{1}\\{2}_{3}_{4}_{5}_{6}_{7}", Path.GetDirectoryName(filename), name, d.Year, d.Month, d.Day, d.Hour, d.Minute, d.Second); if (!Directory.Exists(dir)) { Directory.CreateDirectory(dir); } extractionFolder = dir; _reasearch_folder = dir; string learn_input = String.Format("{0}\\{1}_learn_input.dat", dir, name); string test_input = String.Format("{0}\\{1}_test_input.dat", dir, name); string learn_output = String.Format("{0}\\{1}_learn_output.dat", dir, name); string test_output = String.Format("{0}\\{1}_test_output.dat", dir, name); string initialWweights = String.Format("{0}\\{1}_initial_weights.dat", dir, name); inputTest.Store(test_input); inputLearn.Store(learn_input); outputTest.Store(test_output); outputLearn.Store(learn_output); } } catch (Exception) { } } catch (Exception iex) { throw new NeuralNetworkError(String.Format(Properties.Settings.Default.NBN2, filename), iex); } return(true); } catch (Exception ex) { updateErrorNBN(ex); return(false); } }
/// <summary> /// Matrix eye - with ones on diagonal /// </summary> /// <param name="size">int - matrix size</param> /// <returns>MatrixMB</returns> public static MatrixMB Eye(int size) { MatrixMB m = new MatrixMB(size, size); for (int i = 0; i < size; i++) { for (int j = 0; j < size; j++) { m.Data[i][j] = i == j ? 1 : 0; } } return m; }
public void Creation() { MatrixMB mat = new MatrixMB(5, 5); mat.FillWithNumber(1); Assert.AreEqual(25, mat.SumAllValues()); }
/// <summary> /// Left division /// </summary> /// <param name="one">MatrixMB - first matrix</param> /// <param name="two">MatrixMB - second matrix</param> /// <returns>MatrixMB - divided</returns> public static MatrixMB Left(ref MatrixMB one, ref MatrixMB two) { return one.Inverted * two; }
public void Test__WeightCorrectionCalculation() { //this is just check of calculation: ((hessian+mu*I)\gradient)' if is correct /* >> %((hessian+mu*I)\gradient)' >> hessian = [1 2; 3 4] hessian = 1 2 3 4 >> mu = 2 mu = 2 >> I = eye(2) I = 1 0 0 1 >> gradient=[1;2] gradient = 1 2 >> res=((hessian+mu*I)\gradient)' res = 0.1667 0.2500 */ var hessian = new MatrixMB(2, 2); //no matter if its hessian result or not hessian[0, 0] = 1; hessian[0, 1] = 2; hessian[1, 0] = 3; hessian[1, 1] = 4; double mu = 2; var I = MatrixMB.Eye(2); var gradient = new MatrixMB(2, 1); gradient[0, 0] = 1; gradient[1, 0] = 2; // var diff = ((hessian.HessianMat + (I * setting.MU)).Inverted * hessian.GradientMat).Transposed; var add = hessian + I * mu; var inv = add.Inverted; var div = inv * gradient; var res = div.Transposed; Assert.AreEqual(1, res.Rows); Assert.AreEqual(2, res.Cols); Assert.AreEqual(0.1667, Math.Round(res[0, 0],4)); Assert.AreEqual(0.25, Math.Round(res[0, 1],4)); }
/// <summary> /// Create matrix filled with ones /// </summary> /// <param name="rows">int - matrix rows number</param> /// <param name="cols">int - matrix cols number</param> /// <returns>MatrixMB</returns> public static MatrixMB Ones(int rows, int cols) { MatrixMB m = new MatrixMB(rows, cols); m.FillWithNumber(1); return m; }
/// <summary> /// Gets specified row /// </summary> /// <param name="row">int - row index</param> /// <returns>MatrixMB</returns> public MatrixMB Row(int row) { MatrixMB mat = new MatrixMB(1, this.Cols); mat.Data[0] = Data[row]; return mat; }
/// <summary> /// Function solves Ax = b for A as an upper triangular matrix /// </summary> /// <param name="A">MatrixMB - upper triangular matrix</param> /// <param name="b">MatrixMB</param> /// <returns>MatrixMB</returns> public static MatrixMB SubsBack(MatrixMB A, MatrixMB b) { if (A.L == null) A.MakeLU(); int n = A.Rows; MatrixMB x = new MatrixMB(n, 1); for (int i = n - 1; i > -1; i--) { x[i, 0] = b[i, 0]; for (int j = n - 1; j > i; j--) x[i, 0] -= A[i, j] * x[j, 0]; x[i, 0] = x[i, 0] / A[i, i]; } return x; }
/// <summary> /// Gets specified column /// </summary> /// <param name="column">int - column index</param> /// <returns>MatrixMB</returns> public MatrixMB Col(int column) { MatrixMB matrix = new MatrixMB(Rows, 1); for (int i = 0; i < Rows; i++) { matrix.Data[i][0] = Data[i][column]; } return matrix; }
/// <summary> /// Creates matrix filled with zeros /// </summary> /// <param name="rows">int - matrix rows number</param> /// <param name="cols">int - matrix cols number</param> /// <returns>MatrixMB</returns> public static MatrixMB Zeros(int rows, int cols) { MatrixMB mat = new MatrixMB(rows, cols); mat.FillWithNumber(0); return mat; }
public void MultiplyTwoMatrices() { MatrixMB mat1 = new MatrixMB(2, 3); mat1.Data[0][0] = 1; mat1.Data[0][1] = 2; mat1.Data[0][2] = 3; mat1.Data[1][0] = 4; mat1.Data[1][1] = 5; mat1.Data[1][2] = 6; MatrixMB mat2 = new MatrixMB(3, 2); mat2.Data[0][0] = 7; mat2.Data[0][1] = 8; mat2.Data[1][0] = 9; mat2.Data[1][1] = 10; mat2.Data[2][0] = 11; mat2.Data[2][1] = 12; var mat = mat1 * mat2; Assert.AreEqual(58, mat[0,0]); Assert.AreEqual(64, mat[0, 1]); Assert.AreEqual(139,mat[1, 0]); Assert.AreEqual(154, mat[1, 1]); }
/// <summary> /// Create new matrix from specified set of columns /// </summary> /// <param name="start">int - position of first column</param> /// <param name="stop">int - position of last column</param> /// <returns>MatrixMB</returns> public MatrixMB CopyColumns(int start, int stop) { MatrixMB m = new MatrixMB(this.Rows, stop - start + 1); for (int i = 0; i < m.Rows; i++) { for (int j = start, c = 0; j <= stop; j++, c++) { m.Data[i][c] = this.Data[i][j]; } } return m; }
public void FillMatrix() { MatrixMB mat = new MatrixMB(3, 3); mat.Data[0][0] = 1; mat.Data[0][1] = 2; mat.Data[0][2] = 3; mat.Data[1][0] = 4; mat.Data[1][1] = 5; mat.Data[1][2] = 6; mat.Data[2][0] = 7; mat.Data[2][1] = 8; mat.Data[2][2] = 9; Assert.AreEqual(1, mat[0, 0]); Assert.AreEqual(2, mat[0, 1]); Assert.AreEqual(3, mat[0, 2]); Assert.AreEqual(4, mat[1, 0]); Assert.AreEqual(5, mat[1, 1]); Assert.AreEqual(6, mat[1, 2]); Assert.AreEqual(7, mat[2, 0]); Assert.AreEqual(8, mat[2, 1]); Assert.AreEqual(9, mat[2, 2]); }
/// <summary> /// Calculate lower and upper traingular matrix - this is LU decomposition of matrix /// </summary> public void MakeLU() { //try //{ // if (!IsSquare) throw new MatrixException("The matrix is not square!"); // var lu = new Accord.Math.Decompositions.LuDecomposition(this.Data.ToMultidimensionalArray(Rows, Cols)); // var l = lu.LowerTriangularFactor; // var u = lu.UpperTriangularFactor; // L = new MatrixMB(l.GetLength(0), l.GetLength(1), l.ToJaggedArray(l.GetLength(0), l.GetLength(1))); // U = new MatrixMB(u.GetLength(0), u.GetLength(1), u.ToJaggedArray(u.GetLength(0), u.GetLength(1))); // PermutationVector = lu.PivotPermutationVector; //} //catch (System.Exception ex) //{ // throw new System.Exception(ex.Message); //} //return; //-------------------------------------------------------------------- if (!IsSquare) throw new MatrixException("The matrix is not square!"); L = MatrixMB.Identity(Rows, Cols); U = this.Copy(); PermutationVector = new int[Rows]; for (int i = 0; i < Rows; i++) PermutationVector[i] = i; double p = 0; double pom2; int k0 = 0; int pom1 = 0; for (int k = 0; k < Rows - 1; k++) { p = 0; for (int i = k; i < Rows; i++) // find the row with the biggest pivot { if (System.Math.Abs(U.Data[i][k]) > p) { p = System.Math.Abs(U.Data[i][k]); k0 = i; } } if (p == 0) { throw new MatrixException("Making LU: matrix is singular!"); } pom1 = PermutationVector[k]; PermutationVector[k] = PermutationVector[k0]; PermutationVector[k0] = pom1; for (int i = 0; i < k; i++) { pom2 = L.Data[k][i]; L.Data[k][i] = L.Data[k0][i]; L.Data[k0][i] = pom2; } if (k != k0) detOfP *= -1; for (int i = 0; i < Rows; i++) { pom2 = U.Data[k][i]; U.Data[k][i] = U.Data[k0][i]; U.Data[k0][i] = pom2; } for (int i = k + 1; i < Rows; i++) { L.Data[i][k] = U.Data[i][k] / U.Data[k][k]; for (int j = k; j < Rows; j++) { U.Data[i][j] -= L.Data[i][k] * U.Data[k][j]; } } } }
public void InvertMatrix() { Console.WriteLine("Testowanie odwracania macierzy"); //mat.Inverted * mat = mat.Identity //Jeśli A ma odwrotną A to odwrotna A jest równa A MatrixMB mat = new MatrixMB(2,2); mat.Data[0][0] = 4; mat.Data[0][1] = 7; mat.Data[1][0] = 2; mat.Data[1][1] = 6; Console.WriteLine("Macierz odwracana"); Console.WriteLine(mat.MatrixToString()); double det = mat.Determinant; Assert.AreNotEqual(0, det); Assert.AreEqual(10, det); var inv = mat.Inverted; Console.WriteLine("Macierz odwrócona"); Console.WriteLine(inv.MatrixToString()); Assert.AreEqual(0.6000, Math.Round(inv.Data[0][0],4)); Assert.AreEqual(-0.7000, Math.Round(inv.Data[0][1],4)); Assert.AreEqual(-0.2000, Math.Round(inv.Data[1][0],4)); Assert.AreEqual(0.4000, Math.Round(inv.Data[1][1],4)); var A = inv.Inverted; Console.WriteLine("Odwrócenie macierzy odwróconej"); Console.WriteLine(inv.MatrixToString()); int accuracy = 15; for (int i = 0; i < A.Rows; i++) { for (int j = 0; j < A.Cols; j++) { decimal o = Math.Round((decimal)mat[i, j], accuracy); decimal a = Math.Round((decimal)A[i, j], accuracy); Console.WriteLine(string.Format("Orginał: {0}\tPorównywana: {1}", o, a)); } } for (int i = 0; i < A.Rows; i++) { for (int j = 0; j < A.Cols; j++) { decimal o = Math.Round((decimal)mat[i, j], accuracy); decimal a = Math.Round((decimal)A[i, j], accuracy); Assert.AreEqual(o, a); } } var identity = inv * mat; Assert.AreEqual(1, Math.Round(identity.Data[0][0], accuracy)); Assert.AreEqual(0, Math.Round(identity.Data[0][1], accuracy)); Assert.AreEqual(0, Math.Round(identity.Data[1][0], accuracy)); Assert.AreEqual(1, Math.Round(identity.Data[1][1], accuracy)); }
/// <summary> /// Run NBN training and its test - this is the first version /// </summary> /// <param name="trials">int - number of learning trials</param> /// <returns>LearnResult</returns>R private LearnResult RunFirstVersion(int trials) { backupSettings = new NeuralNetworkSettings(); backupSettings.MaxError = settings.MaxError; backupSettings.MaxIterations = settings.MaxIterations; backupSettings.MU = settings.MU; backupSettings.MUH = settings.MUH; backupSettings.MUL = settings.MUL; backupSettings.Scale = settings.Scale; Trials = trials; LearnResult result = new LearnResult(); result.Filename = Filename; if (MatLabCompareDataFolder.Length > 0) { result.Filename = string.Format("{0}\\{1}.dat", MatLabCompareDataFolder, Path.GetFileNameWithoutExtension(Directory.GetFiles(MatLabCompareDataFolder, "*.dat")[0])); } if (!loadInputData(Filename)) { updateErrorNBN("Dane nie zostały wczytane."); return(result); } if (OnDebug != null) { debug("Data loaded from file: " + Filename); } var tmp = new System.Collections.Generic.List <int>(); tmp.Add(inputLearn.Cols); //setting number of hidden neurons for (int i = 0; i < Handle; i++) { tmp.Add(1); } tmp.Add(1); var vh = new VectorHorizontal(tmp.Count); for (int i = 0; i < vh.Length; i++) { vh[i] = tmp[i]; } switch (NBN_Topography) { case 0: { topo = Topography.Generate(TopographyType.BMLP, vh); } break; case 1: { topo = Topography.Generate(TopographyType.MLP, vh); } break; } result.Topo = topo.Data[0]; if (OnDebug != null) { debug(topo.ToString()); } if (topo == null) { updateErrorNBN("Topologia sieci nie została utworzona."); return(result); } info = this.checkInputs(ref inputLearn, ref outputLearn, ref topo, out indexes);//here are set indexes result.TopoIndex = indexes.Data[0]; result.Info = info; if (OnDebug != null) { debug(indexes.ToString()); debug(info.ToString()); } Activation act = new Activation(info.nn); act.FillWithNumber(NBN_Activation); act.setValue(info.nn - 1, 0); result.ActivationFunction = act.Data[0]; Gain gain = new Gain(info.nn); gain.FillWithNumber(NBN_Gain); result.GainValue = gain.Data[0]; result.Settings = this.settings; for (trial = 0; trial < trials; trial++) { Weights initialWeights = new Weights(info.nw); if (MatLabCompareDataFolder.Length > 0) { initialWeights = MatrixMB.Load(string.Format("{0}\\poczatkowe_wagi_proba_{1}.txt", MatLabCompareDataFolder, trial + 1)).ToWeights(); } else { initialWeights = Weights.Generate(info.nw); } if (IsResearchMode) { string initialWeightsFile = String.Format("{0}\\{1}{2}_initial_weights.dat", _reasearch_folder, trial, Path.GetFileNameWithoutExtension(result.Filename)); initialWeights.Store(initialWeightsFile); } initialWeights.Name = "Initial"; if (OnDebug != null) { debug(String.Format("\r\nTrial {0} from {1}\r\n", trial + 1, trials)); debug(initialWeights.ToString()); } settings = null; settings = NeuralNetworkSettings.Default(); settings.MaxError = backupSettings.MaxError; settings.MaxIterations = backupSettings.MaxIterations; settings.MU = backupSettings.MU; settings.MUH = backupSettings.MUH; settings.MUL = backupSettings.MUL; settings.Scale = backupSettings.Scale; I = MatrixMB.Eye(info.nw); tic();//learn time measure start var tr = Train(ref this.settings, ref this.info, ref this.inputLearn, ref this.outputLearn, ref this.topo, initialWeights, ref act, ref gain, ref indexes); String LearnExecutionTime = toc(); //learn time measure stop LearnTimeList = time.ElapsedTicks; //learn time measure save result.Add(tr.weights.Data[0], SSE.ToDoubleArray(), RMSE.ToDoubleArray()); result.LearnRMSE = (double)RMSE[RMSE.Count]; LearnRmseList = LastRMSE; if (OnDebug != null) { debug(tr.weights.ToString()); debug("\r\nLearn execution time: " + LearnExecutionTime + "(hours:minutes:seconds:miliseconds)\r\n"); debug("\r\nLearn SSE: " + tr.sse.ToString() + "\r\n"); debug("\r\nLearn RMSE: " + result.LearnRMSE.ToString() + "\r\n"); } updateError(result.LearnRMSE); NetworkInfo infoTest = info.Copy(); infoTest.np = inputTest.Rows; tic(); error.CalculateError(ref infoTest, ref inputTest, ref outputTest, ref topo, tr.weights, ref act, ref gain, ref indexes); var TestExecutionTime = toc(); TestTimeList = time.ElapsedTicks; result.TestRMSE = Math.Sqrt(error.Error / infoTest.np); TestRmseList = result.TestRMSE; result.TestingRmseList.Add(result.TestRMSE); if (OnDebug != null) { debug("\r\nTest execution time: " + TestExecutionTime + "(hours:minutes:seconds:miliseconds)\r\n"); debug("\r\nTest SSE: " + error.Error.ToString() + "\r\n"); debug("\r\nTest RMSE: " + result.TestRMSE.ToString() + "\r\n"); } //if (result.LearnRMSE < Threshold) IsTrainOK++; if (result.SSE[trial][result.SSE[trial].Length - 1] < Threshold) { IsTrainOK++; } } result.LearnRMSE = AverageLearnRMSE; result.TestRMSE = AverageTestRMSE; result.setStatisticsData(LearnRMSE, TestRMSE, LearnTime, TestTime, Trials); result.SuccessRate = (double)IsTrainOK / Trials; if (IsResearchMode)//save research { try { string filename = extractionFolder + "\\research result.pdf"; PDFGenerate data = new PDFGenerate(); data.Filename = filename; data.Result = result; data.ChartFilename = GeneratePlot(result.RMSE, Path.GetFileNameWithoutExtension(result.Filename)); HistoryPDF pdf = new HistoryPDF(data.Result, data.ChartFilename, true); pdf.Save(data.Filename); } catch { } } return(result); }
public void MatrixDeterminant() { MatrixMB mat = new MatrixMB(3, 3); mat.Data[0][0] = 1; mat.Data[0][1] = 9; mat.Data[0][2] = 1; mat.Data[1][0] = 9; mat.Data[1][1] = 1; mat.Data[1][2] = 9; mat.Data[2][0] = 1; mat.Data[2][1] = 9; mat.Data[2][2] = 1; double det = mat.Determinant; Assert.AreEqual(det, 0); Assert.AreEqual(1, mat.Data[0][0]); Assert.AreEqual(9, mat.Data[0][1]); Assert.AreEqual(1, mat.Data[0][2]); Assert.AreEqual(9, mat.Data[1][0]); Assert.AreEqual(1, mat.Data[1][1]); Assert.AreEqual(9, mat.Data[1][2]); Assert.AreEqual(1, mat.Data[2][0]); Assert.AreEqual(9, mat.Data[2][1]); Assert.AreEqual(1, mat.Data[2][2]); }