public void ValidationTest_SymmetricPlusDiagonal_InvalidOperationException() { var matrix1 = new SymmetricMatrix <int>(2); var matrix2 = new DiagonalMatrix <int>(3); Assert.Throws <InvalidOperationException>(() => matrix1.Add(matrix2)); }
public void AdditionMatriciesWithDifferentOrderTestMethod() { var symMatrix = new SymmetricMatrix <int>(3); var diagonalMatrix = new DiagonalMatrix <int>(4); symMatrix.Add(diagonalMatrix); }
public void AdditionTest() { matrix = new SymmetricMatrix <string>("sym1", "sym3", "sym3", "sym1"); var square = new SquareMatrix <string>(new string[2, 2] { { "sq1", "sq2" }, { "sq3", "sq4" } }); var sq1 = matrix.Add(square); var sq2 = square.Add(matrix); Assert.IsInstanceOf(typeof(SquareMatrix <string>), sq1); Assert.IsInstanceOf(typeof(SquareMatrix <string>), sq2); CollectionAssert.AreEqual(new string[4] { "sym1sq1", "sym3sq2", "sym3sq3", "sym1sq4" }, sq1.GetElements()); CollectionAssert.AreEqual(new string[4] { "sq1sym1", "sq2sym3", "sq3sym3", "sq4sym1" }, sq2.GetElements()); var symmetric = new SymmetricMatrix <string>(new string[2, 2] { { "1sym", "3sym" }, { "3sym", "1sym" } }); var sum1 = matrix.Add(symmetric); var sum2 = symmetric.Add(matrix); Assert.IsInstanceOf(typeof(SymmetricMatrix <string>), sum1); Assert.IsInstanceOf(typeof(SymmetricMatrix <string>), sum2); CollectionAssert.AreEqual(new string[4] { "sym11sym", "sym33sym", "sym33sym", "sym11sym" }, sum1.GetElements()); CollectionAssert.AreEqual(new string[4] { "1symsym1", "3symsym3", "3symsym3", "1symsym1" }, sum2.GetElements()); var diagonal = new DiagonalMatrix <string>(2, "DIAGONAL"); sum1 = sum1.Add(diagonal); sum2 = diagonal.Add(sum2); Assert.IsInstanceOf(typeof(SymmetricMatrix <string>), sum1); Assert.IsInstanceOf(typeof(SymmetricMatrix <string>), sum2); CollectionAssert.AreEqual(new string[4] { "sym11symDIAGONAL", "sym33sym", "sym33sym", "sym11symDIAGONAL" }, sum1.GetElements()); CollectionAssert.AreEqual(new string[4] { "DIAGONAL1symsym1", "3symsym3", "3symsym3", "DIAGONAL1symsym1" }, sum2.GetElements()); }
public void Add_Symmetric_Tests() { SymmetricMatrix <int> lhs = new SymmetricMatrix <int>(symm); SquareMatrix <int> rhs1 = new SquareMatrix <int>(diag); DiagonalMatrix <int> rhs2 = new DiagonalMatrix <int>(diag); SymmetricMatrix <int> rhs3 = new SymmetricMatrix <int>(diag); int[,] expected = new int[, ] { { 2, 7, 3 }, { 7, 5, -5 }, { 3, -5, 7 } }; CollectionAssert.AreEqual(new SquareMatrix <int>(expected), lhs.Add(rhs1)); CollectionAssert.AreEqual(new SymmetricMatrix <int>(expected), lhs.Add(rhs2)); CollectionAssert.AreEqual(new SymmetricMatrix <int>(expected), lhs.Add(rhs3)); }
public void Add_SymmetricMatrices_DoubleSourceArray() { int[,] sourceArray = new int[,] { {1, 5}, {5, 4} }; SymmetricMatrix<int> lhs = new SymmetricMatrix<int>(sourceArray); SymmetricMatrix<int> rhs = new SymmetricMatrix<int>(sourceArray); lhs.Add(rhs); int[,] actual = lhs.Add(rhs).ToArray(); bool areDouble = true; for (int i = 0; i < sourceArray.GetLength(0); i++) for (int j = 0; j < sourceArray.GetLength(1); j++) areDouble &= (sourceArray[i, j] * 2) == actual[i, j]; Assert.IsTrue(areDouble); }
public void AddTestResultMatrixType() { var array = new[, ] { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } }; AbstractSquareMatrix <int> matrix1 = new SquareMatrix <int>(array); AbstractSquareMatrix <int> matrix2 = new SquareMatrix <int>(array); var result = matrix1.Add(matrix2); Assert.AreEqual(typeof(SquareMatrix <int>), result.GetType()); matrix1 = new SquareMatrix <int>(array); matrix2 = new DiagonalMatrix <int>(array); result = matrix1.Add(matrix2); Assert.AreEqual(typeof(SquareMatrix <int>), result.GetType()); matrix1 = new SquareMatrix <int>(array); matrix2 = new SymmetricMatrix <int>(array); result = matrix1.Add(matrix2); Assert.AreEqual(typeof(SquareMatrix <int>), result.GetType()); matrix1 = new DiagonalMatrix <int>(array); matrix2 = new SquareMatrix <int>(array); result = matrix1.Add(matrix2); Assert.AreEqual(typeof(SquareMatrix <int>), result.GetType()); matrix1 = new DiagonalMatrix <int>(array); matrix2 = new DiagonalMatrix <int>(array); result = matrix1.Add(matrix2); Assert.AreEqual(typeof(DiagonalMatrix <int>), result.GetType()); matrix1 = new DiagonalMatrix <int>(array); matrix2 = new SymmetricMatrix <int>(array); result = matrix1.Add(matrix2); Assert.AreEqual(typeof(SymmetricMatrix <int>), result.GetType()); matrix1 = new SymmetricMatrix <int>(array); matrix2 = new SymmetricMatrix <int>(array); result = matrix1.Add(matrix2); Assert.AreEqual(typeof(SymmetricMatrix <int>), result.GetType()); matrix1 = new SymmetricMatrix <int>(array); matrix2 = new DiagonalMatrix <int>(array); result = matrix1.Add(matrix2); Assert.AreEqual(typeof(SymmetricMatrix <int>), result.GetType()); matrix1 = new SymmetricMatrix <int>(array); matrix2 = new SquareMatrix <int>(array); result = matrix1.Add(matrix2); Assert.AreEqual(typeof(SquareMatrix <int>), result.GetType()); }
public void SumOfSymmetricMatrixes() { var fsm = new SymmetricMatrix <int>(firstSymmetricMatrix); var ssm = new SymmetricMatrix <int>(secondSymmetricMatrix); var result = fsm.Add(ssm); CollectionAssert.AreEqual(new int[, ] { { 0, 5, 6 }, { 5, 0, 7 }, { 6, 7, 0 } }, new int[, ] { { result[0, 0], result[0, 1], result[0, 2] }, { result[1, 0], result[1, 1], result[1, 2] }, { result[2, 0], result[2, 1], result[2, 2] } }); }
public void SumTest_SymmetricPlusSymmetric_Symmetric() { var matrix1 = new SymmetricMatrix <int>(new int[, ] { { 1, 2 }, { 2, 1 } }); var matrix2 = new SymmetricMatrix <int>(new int[, ] { { 1, 2 }, { 2, 1 } }); matrix1.Add(matrix2); int[] array = { 2, 4, 4, 2 }; Assert.IsTrue(IsEqual(matrix1, array)); }
public void Matrix_Add_SymmetricMatrix() { var array = new[, ] { { 1, 0, 0 }, { 0, 5, 0 }, { 0, 0, 9 } }; var arrayExpected = new[, ] { { 2, 0, 0 }, { 0, 10, 0 }, { 0, 0, 18 } }; Matrix <int> lhs = new SquareMatrix <int>(array); Matrix <int> rhs = new SymmetricMatrix <int>(array); var result = rhs.Add(lhs); Matrix <int> expected = new SquareMatrix <int>(arrayExpected); CollectionAssert.AreEqual(expected, result); result = rhs.Add(rhs); expected = new SymmetricMatrix <int>(arrayExpected); CollectionAssert.AreEqual(expected, result); lhs = new DiagonaleMatrix <int>(array); result = rhs.Add(lhs); expected = new DiagonaleMatrix <int>(arrayExpected); CollectionAssert.AreEqual(expected, result); }
public void AdditionMatricesTests2() { SymmetricMatrix <int> lhs = new SymmetricMatrix <int>(_intArr3); DiagonalMatrix <int> rhs = new DiagonalMatrix <int>(_intArr2); int[,] expected = new int[, ] { { 1, 1, 1, 0 }, { 0, 2, 1, 0 }, { 0, 0, 2, 0 }, { 0, 0, 0, 1 } }; CollectionAssert.AreEqual(new SquareMatrix <int>(expected), lhs.Add(rhs)); }
public void SumMatrixesTest_InputSymmetricMatrixAndDiagonal_AssertExpectedAndActualResult() { int[,] firstArray = { { 1, 3, 0 }, { 3, 2, 6 }, { 0, 6, 5 } }; Martix <int> firstMatrix = new SymmetricMatrix <int>(3, firstArray); int[] secondArray = { 1, 2, 5 }; Martix <int> secondMatrix = new DiagonalMatrix <int>(3, secondArray); int[,] expectedArray = { { 2, 3, 0 }, { 3, 4, 6 }, { 0, 6, 10 } }; var expectedMatrix = new SymmetricMatrix <int>(3, expectedArray); Martix <int> actualMatrix; actualMatrix = firstMatrix.Add <int>(secondMatrix); CollectionAssert.AreEqual(expectedMatrix, actualMatrix); }
public void AdditionTestMethod() { var symMatrix = new SymmetricMatrix <int>(3); var diagonalMatrix = new DiagonalMatrix <int>(3); var expectedMatrix = new[, ] { { 1, 1, 2 }, { 1, 3, 3 }, { 2, 3, 5 } }; /* * 0 1 2 * 1 2 3 * 2 3 4 */ for (int i = 0; i < symMatrix.Order; i++) { for (int j = i; j < symMatrix.Order; j++) { symMatrix[i, j] = i + j; } } for (int i = 0; i < diagonalMatrix.Order; i++) { diagonalMatrix[i, i] = 1; } var actualMatrix = symMatrix.Add(diagonalMatrix); bool result = true; for (int i = 0; i < symMatrix.Order; i++) { for (int j = 0; j < symMatrix.Order; j++) { if (actualMatrix[i, j] != expectedMatrix[i, j]) { result = false; break; } } } Assert.AreEqual(true, result); }
public void SumTest_SymmetricPlusDiagonal_Symmetric() { var matrix1 = new SymmetricMatrix <int>(new int[, ] { { 1, 2 }, { 2, 1 } }); var matrix2 = new DiagonalMatrix <int>(2); matrix2[0, 0] = 1; matrix2[1, 1] = 1; matrix1.Add(matrix2); int[] array = { 2, 2, 2, 2 }; Assert.IsTrue(IsEqual(matrix1, array)); }
public void SquareMatrixTest() { int[] elems = new int[] { 1, 2, 3 }; SymmetricMatrix <int> sm1 = new SymmetricMatrix <int>(elems, 4, 5, 6); SymmetricMatrix <int> sm2 = new SymmetricMatrix <int>(elems, 7, 8, 9); BaseMatrix <int> sm3 = sm1.Add(sm2); int[,] matrix = sm3.Matrix; for (int i = 0; i < matrix.GetLength(0); i++) { for (int j = 0; j < matrix.GetLength(1); j++) { Console.Write(matrix[i, j] + " "); } Console.WriteLine(); } }
public void AddTest() { // Arrange int[,] array1 = new int[4, 4] { { 1, 1, 1, 4 }, { 1, 1, 1, 3 }, { 1, 1, 1, 2 }, { 4, 3, 2, 1 } }; int[,] array2 = new int[4, 4] { { 1, 0, 0, 0 }, { 0, 3, 0, 0 }, { 0, 0, 2, 0 }, { 0, 0, 0, 4 } }; int[,] expectedArray = new int[4, 4] { { 2, 1, 1, 4 }, { 1, 4, 1, 3 }, { 1, 1, 3, 2 }, { 4, 3, 2, 5 } }; SymmetricMatrix <int> matrix1 = new SymmetricMatrix <int>(array1); DiagonalMatrix <int> matrix2 = new DiagonalMatrix <int>(array2); SquareMatrix <int> expectedMatrix = new SquareMatrix <int>(expectedArray); // Act var result = matrix1.Add(matrix2); // Assert for (int i = 0; i < result.Order; i++) { for (int j = 0; j < result.Order; j++) { Assert.AreEqual(expectedMatrix[i, j], result[i, j]); } } }
public void AddingSymmetricMatrix() { Matrix<int> m = new SymmetricMatrix<int>(new int[3][] { new int[3] {1, 2, 3}, new int[3] {2, 3, 4}, new int[3] {3, 4, 5} }); Matrix<int> m2 = new SymmetricMatrix<int>(new int[3][] { new int[3] {1, 2, 3}, new int[3] {2, 3, 4}, new int[3] {3, 4, 5} }); Matrix<int> m1 = m.Add(m2); Assert.IsTrue(new SquareMatrix<int>(new int[3][] { new int[3] {2, 4, 6}, new int[3] {4, 6, 8}, new int[3] {6, 8, 10} }).Equals(m1)); }
public void AdditionTest() { testMatrix = new SquareMatrix <int>(9, 8, 7, 6, 0, 4, 3, 2, 1); var square = new SquareMatrix <int>(1, 2, 3, 4, 10, 6, 7, 8, 9); var sum1 = testMatrix.Add(square); var sum2 = square.Add(testMatrix); Assert.IsInstanceOf(typeof(SquareMatrix <int>), sum1); Assert.IsInstanceOf(typeof(SquareMatrix <int>), sum2); CollectionAssert.AreEqual(sum1.GetElements(), sum2.GetElements()); CollectionAssert.AreEqual(Enumerable.Repeat(10, 9), sum1.GetElements()); var symmetric = new SymmetricMatrix <int>(new int[3, 3] { { 3, 3, 3 }, { 3, 2, 2, }, { 3, 2, 1 } }); sum1 = sum1.Add(symmetric); sum2 = symmetric.Add(sum2); Assert.IsInstanceOf(typeof(SquareMatrix <int>), sum1); Assert.IsInstanceOf(typeof(SquareMatrix <int>), sum2); CollectionAssert.AreEqual(sum1.GetElements(), sum2.GetElements()); CollectionAssert.AreEqual(new int[9] { 13, 13, 13, 13, 12, 12, 13, 12, 11 }, sum1.GetElements()); var diagonal = new DiagonalMatrix <int>(-13, -12, -11); sum1 = sum1.Add(diagonal); sum2 = diagonal.Add(sum2); Assert.IsInstanceOf(typeof(SquareMatrix <int>), sum1); Assert.IsInstanceOf(typeof(SquareMatrix <int>), sum2); CollectionAssert.AreEqual(sum1.GetElements(), sum2.GetElements()); CollectionAssert.AreEqual(new int[9] { 0, 13, 13, 13, 0, 12, 13, 12, 0 }, sum1.GetElements()); var matrix1 = new SquareMatrix <bool>(true); var matrix2 = new SquareMatrix <bool>(false); Assert.Throws <NotSupportedException>(() => matrix1.Add(matrix2)); }
// Error for one edge private double CalculateError(int id_v1, int id_v2, ref Vector3d result, ref Vector3d vbuff, ref SymmetricMatrix smbuff) { // compute interpolated vertex SymmetricMatrix.Add(ref vertices.Data[id_v1].q, ref vertices.Data[id_v2].q, ref smbuff); double error = 0; double det = smbuff.Determinant1(); if (Math.Abs(det) > 1.0e-10) { // q_delta is invertible result.X = -1.0 / det * smbuff.Determinant2(); // vx = A41/det(q_delta) result.Y = +1.0 / det * smbuff.Determinant3(); // vy = A42/det(q_delta) result.Z = -1.0 / det * smbuff.Determinant4(); // vz = A43/det(q_delta) error = VertexError(ref smbuff, ref result); } else { // det = 0 -> try to find best result Vector3d p1 = vertices.Data[id_v1].p; Vector3d p2 = vertices.Data[id_v2].p; Vector3d.Average(ref p1, ref p2, ref vbuff); double error1 = VertexError(ref smbuff, ref p1); double error2 = VertexError(ref smbuff, ref p2); double error3 = VertexError(ref smbuff, ref vbuff); error = Math.Min(error1, Math.Min(error2, error3)); if (error1 == error) { result = p1; } else if (error2 == error) { result = p2; } else { result = vbuff; vbuff = new Vector3d(); } } return(error); }
public void AdditionTest() { testMatrix = new DiagonalMatrix <float>(1, 2, 9); var square = new SquareMatrix <float>(3u, 5); var sum1 = testMatrix.Add(square); var sum2 = square.Add(testMatrix); Assert.IsInstanceOf(typeof(SquareMatrix <float>), sum1); Assert.IsInstanceOf(typeof(SquareMatrix <float>), sum2); CollectionAssert.AreEqual(sum1.GetElements(), sum2.GetElements()); CollectionAssert.AreEqual(new float[9] { 6, 5, 5, 5, 7, 5, 5, 5, 14 }, sum1.GetElements()); var symmetric = new SymmetricMatrix <float>(new float[3, 3] { { 3, 3, 3 }, { 3, 2, 2, }, { 3, 2, 1 } }); sum1 = testMatrix.Add(symmetric); sum2 = symmetric.Add(testMatrix); Assert.IsInstanceOf(typeof(SymmetricMatrix <float>), sum1); Assert.IsInstanceOf(typeof(SymmetricMatrix <float>), sum2); CollectionAssert.AreEqual(sum1.GetElements(), sum2.GetElements()); CollectionAssert.AreEqual(new float[9] { 4, 3, 3, 3, 4, 2, 3, 2, 10 }, sum1.GetElements()); var diagonal = new DiagonalMatrix <float>(3, 7); sum1 = testMatrix.Add(diagonal); sum2 = diagonal.Add(testMatrix); Assert.IsInstanceOf(typeof(DiagonalMatrix <float>), sum1); Assert.IsInstanceOf(typeof(DiagonalMatrix <float>), sum2); CollectionAssert.AreEqual(sum1.GetElements(), sum2.GetElements()); CollectionAssert.AreEqual(new float[9] { 8, 0, 0, 0, 9, 0, 0, 0, 16 }, sum1.GetElements()); Assert.Throws <InvalidOperationException>(() => diagonal.Add(new DiagonalMatrix <float>(2))); }
public void AddMatrixTests() { Assert.AreEqual(resultSquareSymmetricMatrices, squareMatrix.Add(symmetricMatrix)); Assert.AreEqual(new SquareMatrix <int>(resultSquareDiagonal), squareMatrix.Add(diagonalMatrix)); Assert.AreEqual(new SymmetricMatrix <int>(resultSymmetricDiagonal), symmetricMatrix.Add(diagonalMatrix)); }
public void SymmetricMatrixIntegersSumTests(SymmetricMatrix <int> source1, SymmetricMatrix <int> source2, SymmetricMatrix <int> expected) => Assert.AreEqual(source1.Add(source2, new SumIntegers()), expected);
public void MatrixStringsSumTests(SymmetricMatrix <string> source1, SymmetricMatrix <string> source2, SymmetricMatrix <string> expected) => Assert.AreEqual(source1.Add(source2, new SumStrings()), expected);
/// <summary> /// Remove vertices and mark deleted triangles /// </summary> private int RemoveVertexPass( int startTrisCount, int targetTrisCount, double threshold, ref Vector3d vbuff, ref Vector3d vbuff2, ref SymmetricMatrix smbuff) { int deletedTriangles = 0; Vector3d p = new Vector3d(); for (int tid = 0; tid < triangles.Length; tid++) { var t = triangles.Data[tid]; if (t.dirty || t.deleted || t.err3 > threshold) { continue; } if (vertices.Data[t.v0].IsEdge || vertices.Data[t.v1].IsEdge || vertices.Data[t.v2].IsEdge) { // Don't mess with triangles that touch edges continue; } t.GetErrors(errArr); for (int j = 0; j < 3; j++) { if (errArr[j] > threshold) { continue; } int i0 = t[j]; int i1 = t[(j + 1) % 3]; // Compute vertex to collapse to CalculateError(i0, i1, ref p, ref vbuff, ref smbuff); deleted0.Resize(vertices.Data[i0].tcount); deleted1.Resize(vertices.Data[i1].tcount); // Don't remove if flipped if (Flipped(ref p, i0, i1, ref vertices.Data[i0], deleted0.Data)) { continue; } if (Flipped(ref p, i1, i0, ref vertices.Data[i1], deleted1.Data)) { continue; } // Not flipped, so remove edge vertices.Data[i0].p = p; p = new Vector3d(); SymmetricMatrix.Add(ref vertices.Data[i1].q, ref vertices.Data[i0].q, ref vertices.Data[i0].q); UpdateTriangles(i0, ref vertices.Data[i0], deleted0.Data, ref deletedTriangles, ref vbuff, ref vbuff2, ref smbuff); UpdateTriangles(i0, ref vertices.Data[i1], deleted1.Data, ref deletedTriangles, ref vbuff, ref vbuff2, ref smbuff); int tstart = refs.Length; int tcount = refs.Length - tstart; if (tcount <= vertices.Data[i0].tcount) { // Compact if (tcount > 0) { Array.Copy(refs.Data, tstart, refs.Data, vertices.Data[i0].tstart, tcount); } } else { // append vertices.Data[i0].tstart = tstart; } vertices.Data[i0].tcount = tcount; break; } } return(deletedTriangles); }
static void Main(string[] args) { BinarySearchTree <int> intTree = new BinarySearchTree <int>(5); intTree.Add(new[] { 8, 10, 3, 2, 7, 6 }); foreach (var item in intTree.Inorder()) { Console.Write(item + " "); } Console.WriteLine(); BinarySearchTree <int> intTree2 = new BinarySearchTree <int>(5, new IntComparer()); intTree2.Add(new[] { 8, 10, 3, 2, 7, 6 }); foreach (var item in intTree2.Inorder()) { Console.Write(item + " "); } Console.WriteLine(); BinarySearchTree <string> stringTree = new BinarySearchTree <string>("5"); stringTree.Add(new[] { "8", "9", "3", "2", "7", "6" }); foreach (var item in stringTree.Inorder()) { Console.Write(item + " "); } Console.WriteLine(); BinarySearchTree <string> stringTree2 = new BinarySearchTree <string>("5", new Logic.Comparers.StringComparer()); stringTree2.Add(new[] { "8", "9", "3", "2", "7", "6" }); foreach (var item in stringTree2.Inorder()) { Console.Write(item + " "); } Console.WriteLine(); BinarySearchTree <Book> bookTree = new BinarySearchTree <Book>(new Book("Aaa", "Bbb", 102)); bookTree.Add(new [] { new Book("Ccc", "Aaa", 1356), new Book("Zzz", "Qqq", 803), new Book("Lll", "Bbb", 1234) }); foreach (var item in bookTree.Inorder()) { Console.Write("\"{0}\", {1}, {2}. ", item.Title, item.Author, item.Pages); } Console.WriteLine(); BinarySearchTree <Book> bookTree2 = new BinarySearchTree <Book>(new Book("Aaa", "Bbb", 102), new BookComparer()); bookTree2.Add(new[] { new Book("Ccc", "Aaa", 1356), new Book("Zzz", "Qqq", 803), new Book("Lll", "Bbb", 1234) }); foreach (var item in bookTree2.Inorder()) { Console.Write("\"{0}\", {1}, {2}. ", item.Title, item.Author, item.Pages); } Console.WriteLine(); BinarySearchTree <Point> pointTree = new BinarySearchTree <Point>(new Point(10, 12), new PointComparer()); pointTree.Add(new[] { new Point(10, 6), new Point(11, 2), new Point(94, 1), new Point(5, 11), new Point(99, 0) }); foreach (var item in pointTree.Inorder()) { Console.Write("X:{0}; Y:{1}. ", item.X, item.Y); } Console.WriteLine(); Console.WriteLine(); Console.WriteLine(); Console.WriteLine(); Console.WriteLine(); Console.WriteLine(); SymmetricMatrix <int> symmatr1 = new SymmetricMatrix <int>(new int[, ] { { 0, 1, 2 }, { 1, 0, 3 }, { 2, 3, 0 } }); SymmetricMatrix <int> symmatr2 = new SymmetricMatrix <int>(new int[, ] { { 0, 1, 2 }, { 1, 0, 3 }, { 2, 3, 0 } }); Console.WriteLine(symmatr1.Add(symmatr2, (a, b) => a + b)); SquareMatrix <int> sqmatr = new SquareMatrix <int>(new int[, ] { { 2, 1, 7 }, { 1, 0, 3 }, { 2, 3, 8 } }); Console.WriteLine(sqmatr.Add(symmatr2, (a, b) => a + b)); DiagonalMatrix <int> dmatr = new DiagonalMatrix <int>(new int[, ] { { 0, 1, 7 }, { 1, 0, 3 }, { 2, 3, 0 } }); Console.WriteLine(dmatr.Add(symmatr2, (a, b) => a + b)); }