static void Main(string[] args) { int[,] first = { {1, 2, 3}, {4, 5, 6}, {7, 8, 9} }; int[,] second = { {1, 2, 3}, {2, 5, 6}, {3, 6, 9} }; int[,] third = { {1, 0, 0}, {0, 5, 0}, {0, 0, 9} }; SquareMatrix<int> matrix = new SquareMatrix<int>(3); SquareMatrix<int> lol1 = new SquareMatrix<int>(first); SymmetricMatrix<int> lol2 = new SymmetricMatrix<int>(second); DiagonalMatrix<int> lol3 = new DiagonalMatrix<int>(third); matrix.MatrixChange += ShowChanges; for (int i = 0; i < 3; i++) for (int j = 0; j < 3; j++) matrix[i, j] = i*j; var lol4 = lol3.Add(lol1); System.Console.ReadLine(); }
static void Main(string[] args) { int[,] matr1 = { { 1, 2, 3 }, { 1, 2, 3 }, { 1, 2, 3 } }; SquareMatrix<int> matrix1 = new SquareMatrix<int>(matr1); int[,] matr2 = { { 1, 0, 0 }, { 0, 2, 0 }, { 0, 0, 3 } }; DiagonalMatrix<int> matrix2 = new DiagonalMatrix<int>(matr2); int[,] matr3 = { { 1, 5, 3 }, { 5, 2, 7 }, { 3, 7, 3 } }; SymmetricMatrix<int> matrix3 = new SymmetricMatrix<int>(matr3); var squar = new Listeners<int>(); squar.Register(matrix1); squar.Register(matrix2); squar.Register(matrix3); matrix1[1, 2] = 3; matrix2[2, 2] = 3; matrix3[1, 0] = 3; SquareMatrix<int> output = matrix1.Sum(matrix2, (x, y) => x + y); SquareMatrix<int> output2 = matrix1.Sum(matrix2); Console.WriteLine(); }
static void Main(string[] args) { try { SquareMatrix<int> squareMatrix1 = new SquareMatrix<int>(new int[,] { { 1, 2 }, { 3, 4 } }); SquareMatrix<int> squareMatrix2 = new SquareMatrix<int>(new int[,] { { 1, 2 }, { 3, 4 } }); //SquareMatrix<int> squareMatrix2 = new SquareMatrix<int>(new int[,]{{1,2,3},{4,5,6}}); SymmetricalMatrix<int> symmetricalMatrix1 = new SymmetricalMatrix<int>((new int[,] { { 1, 1 }, { 1, 4 } })); //SymmetricalMatrix<int> symmetricalMatrix2 = new SymmetricalMatrix<int>((new int[,] { { 1, 2 }, { 1, 4 } })); SquareMatrix<int> squareMatrix3 = new SymmetricalMatrix<int>((new int[,] { { 1, 1 }, { 1, 4 } })); SymmetricalMatrix<int> symmetricalMatrix3 = (SymmetricalMatrix<int>)squareMatrix3; DiagonalMatrix<int> diagonalMatrix1 = new DiagonalMatrix<int>(new int[,] { { 1, 0 }, { 0, 1 } }); var client = new Client1<int>(squareMatrix1); var client2 = new Client1<int>(symmetricalMatrix1); squareMatrix1[0, 0] = 2; symmetricalMatrix1[1, 0] = 2; Console.ReadKey(); } catch (Exception e) { Console.WriteLine(e.Message); Console.ReadKey(); } }
static void Main(string[] args) { int[,] array = new int[3, 3] { { 1, 4, 5 }, { 52, 34, 3 }, { 6, 734, 8 } }; SquareMatrix<int> m = new SquareMatrix<int>(array); Console.WriteLine(m.ToString()); m.Change += IsChange; m[1, 2] = 100; Thread.Sleep(1000); Console.WriteLine(); Console.WriteLine(m.ToString()); int[,] arrayM = new int[3, 3] { { 1, 1, 1 }, { 1, 1, 1 }, { 1, 1, 1 } }; Matrix<int> firstM = new SquareMatrix<int>(array); Console.WriteLine(firstM.ToString()); Matrix<int> secondM = new SymmetricMatrix<int>(arrayM); Console.WriteLine(secondM.ToString()); var result = WorkWithMatrix.Add( firstM,secondM, (a, b) => a + b); System.Console.WriteLine(result.ToString()); int [,] arD1 = new int[3,3]{{1,0,0},{0,1,0},{0,0,1}}; int[,] arD2 = new int[3, 3] { { 2, 0, 0 }, { 0, 2, 0 }, { 0, 0, 2 } }; var fisrtDM = new DiagonalMatrix<int>(arD1); Console.WriteLine(fisrtDM.ToString()); var secondDM = new DiagonalMatrix<int>(arD2); Console.WriteLine(secondDM.ToString()); result = WorkWithMatrix.Add(fisrtDM, secondDM, (a, b) => a + b); System.Console.WriteLine(result.ToString()); Console.ReadKey(); }
public void DiagonalMatrix_Create_Test() { int[,] matr = { { 1, 0, 0 }, { 0, 2, 0 }, { 0, 0, 3 } }; DiagonalMatrix<int> matrix = new DiagonalMatrix<int>(matr); Assert.AreEqual(3, matrix[2, 2]); }
/// <summary> /// Visits the specified matrix. /// </summary> /// <param name="matrix">The matrix.</param> /// <returns></returns> public DiagonalMatrix <T> Visit(DiagonalMatrix <T> matrix) { for (int i = 0; i < matrix.Size; i++) { matrix[i, 0] += (dynamic)temp[i, 0]; } return(matrix); }
/// <summary> /// Copy values from array to diagonal matrix /// </summary> /// <typeparam name="T"> Type of elements </typeparam> /// <param name="matrix"> Matrix for copying in </param> /// <param name="values"> Values for copying out </param> /// <exception cref="ArgumentNullException"> If values is null </exception> /// <exception cref="ArgumentException"> If values lenght is more than lenght of matrix </exception> public static void Copy <T>(this DiagonalMatrix <T> matrix, T[] values) { Validate(matrix, values); for (int i = 0; i < matrix.Order; i++) { matrix[i, i] = values[i]; } }
public string[,] AddTestString(string[,] elements) { var lhs = new DiagonalMatrix <string>(elements); var rhs = new DiagonalMatrix <string>(elements); lhs = lhs.Add(rhs, (x, y) => x + y) as DiagonalMatrix <string>; return(lhs?.ToArray()); }
public int[,] AddDiagonalAndSymmetricalTestInt(int[,] elements) { var lhs = new DiagonalMatrix <int>(elements); var rhs = new SymmetricalMatrix <int>(elements); rhs = rhs.Add(lhs) as SymmetricalMatrix <int>; return(rhs?.ToArray()); }
public void DiagonalMatrixSumTest() { int[] array = new int[] { 1, 2 }; int[] ex = new int[] { 2, 4 }; DiagonalMatrix <int> expected = new DiagonalMatrix <int>(ex); DiagonalMatrix <int> actual = new DiagonalMatrix <int>(array); Assert.AreEqual(expected, actual.Sum(actual)); }
private static SquareMatrix <T> Add <T>(SquareMatrix <T> firstMatrix, DiagonalMatrix <T> secondMatrix) { CheckMatrixes <T>(firstMatrix, secondMatrix); SquareMatrix <T> result = new SquareMatrix <T>(firstMatrix.Size); SumEachElement <T>(firstMatrix, secondMatrix, result); return(result); }
public void AddingDiagonalMatrix() { Matrix<int> m = new DiagonalMatrix<int>(new int[2][] { new int[2] { 1, 0 }, new int[2] { 0, 3 } }); Matrix<int> m1 = new DiagonalMatrix<int>(new int[2][] { new int[2] { 1, 0 }, new int[2] { 0, 3 } }); Matrix<int> m2 = m.Add(m1); Matrix<int> m3 = new SquareMatrix<int>(new int[2][] { new int[2] { 2, 0 }, new int[2] { 0, 6 } }); Assert.IsTrue(m2.Equals(m3)); }
public void DiagonalDenseMatrixMultiplication_IssueCP5706() { Matrix <double> diagonal = DiagonalMatrix.Identity(3); Matrix <double> dense = DenseMatrix.OfArray(new double[, ] { { 1, 2, 3 }, { 1, 2, 3 }, { 1, 2, 3 } }); var test = diagonal * dense; var test2 = dense * diagonal; }
public void CanCreateMatrixWithUniformValues() { var matrix = new DiagonalMatrix(10, 10, 10.0f); for (var i = 0; i < matrix.RowCount; i++) { Assert.AreEqual(matrix[i, i], 10.0f); } }
public void Add_IntDiagonalAndSymmetricMatrixes_ReturnesSymmetricMatrix() { var m1 = new DiagonalMatrix<int>(new int[][] { new int[] { 1, 0, 0 }, new int[] { 0, 1, 0 }, new int[] { 0, 0, 1 } }); var m2 = new SymmetricMatrix<int>(new int[][] { new int[] { 1, 4, 5 }, new int[] { 4, 2, 6 }, new int[] { 5, 6, 3 } }); dynamic actual = m1.Add(m2); Assert.IsTrue(actual is SymmetricMatrix<int>); }
public int[,] AddTestInt(int[,] elements) { var lhs = new DiagonalMatrix <int>(elements); var rhs = new DiagonalMatrix <int>(elements); lhs = lhs.Add(rhs) as DiagonalMatrix <int>; return(lhs?.ToArray()); }
public void IndexExceptionDiagonalMatrixTest() { int size = 3; int i = 1; int j = 2; var matrix = new DiagonalMatrix <int>(size, 1, 3); Assert.Throws <ArgumentException>(() => matrix[i, j] = 1); }
public static void TestDiagonalMatrix(TestData <double> testData) { Matrix <double> matrix = new DiagonalMatrix <double>(testData.DiagonalArray); matrix.ElementChange += testData.GetEvent; matrix[testData.IndexI, testData.IndexJ] = testData.Value; Assert.That(testData.EventMessage, Is.EqualTo(testData.ExpectedEventMessageDiagonal)); Assert.That(matrix[testData.IndexI, testData.IndexJ], Is.EqualTo(testData.Value)); }
public DenseMatrix getInversedJacobiFromSVD(DenseVector angles) { DenseMatrix jacobi = this.getJacobi(angles); var svd = jacobi.Svd(true); var s = new DiagonalMatrix(jacobi.RowCount, jacobi.ColumnCount, (1 / svd.S).ToArray()); // 疑似逆行列を計算する var m = svd.VT.Transpose() * s.Transpose() * svd.U.Transpose(); return((DenseMatrix)m); }
public void Indexer_jLess0_ArgumentOutOfRangeException() { int[,] sourceArray = new int[2, 2] { {1, 0}, {0, 4} }; DiagonalMatrix<int> matrix = new DiagonalMatrix<int>(sourceArray); int a = matrix[0, -1]; }
public void Add_IntDiagonalAndSymmetricMatrixes_GivesCorrectValue() { var m1 = new DiagonalMatrix<int>(new int[][] { new int[] { 1, 0, 0 }, new int[] { 0, 1, 0 }, new int[] { 0, 0, 1 } }); var m2 = new SymmetricMatrix<int>(new int[][] { new int[] { 1, 4, 5 }, new int[] { 4, 2, 6 }, new int[] { 5, 6, 3 } }); dynamic actual = m1.Add(m2); var expected = new SymmetricMatrix<int>(new int[][] { new int[] { 2, 4, 5 }, new int[] { 4, 3, 6 }, new int[] { 5, 6, 4 } }); Assert.AreEqual(expected, actual); }
public void DioganalMatrix_InputCorrectIsDioganal_Succed() { // Arrange DiagonalMatrix <int> dioganalMatrix = new DiagonalMatrix <int>(10); dioganalMatrix[0, 0] = 1; // Assert Assert.Pass(); }
public void DiagonalMatrixManipulations() { DiagonalMatrix D = new DiagonalMatrix(3.0, 2.0, 1.0); Assert.IsTrue(D.Dimension == 3); Assert.IsTrue(D[0, 0] == 3.0); Assert.IsTrue(D[1, 2] == 0.0); D[1, 1] -= 1.0; Assert.IsTrue(D[1, 1] == 1.0); }
public void DiagonalMatrixCtor_InputArrayAsParameter() { int[] testArray = { 11, 11, 11 }; var matrix = new DiagonalMatrix <int>(testArray); int[,] expectedResult = { { 11, 0, 0 }, { 0, 11, 0 }, { 0, 0, 11 } }; CollectionAssert.AreEqual(expectedResult, matrix); }
public void TestOfActions() { DiagonalMatrix <int> matrix = new DiagonalMatrix <int>(4); matrix.AddActionWhenElementChanged(3, 3, () => { Console.WriteLine("Test Works!!!"); matrix[2, 2] = 140; }); matrix[3, 3] = 169; Assert.AreEqual(140, matrix[2, 2]); }
/// <summary> /// Returns the decomposed matrix diagonal. /// </summary> /// <returns>The matrix diagonal.</returns> internal DiagonalMatrix DiagonalEntries() { var result = new DiagonalMatrix(_inverseDiagonals.Length); for (var i = 0; i < _inverseDiagonals.Length; i++) { result[i, i] = 1 / _inverseDiagonals[i]; } return result; }
/// <summary> /// If the matrices stored in this object have already been calculated, they will be reused even if the original /// free-free stiffness matrix has changed. To avoid that, this method must be called. /// </summary> public void Clear() { inverseKff = null; RigidBodyModes = null; inverseKii = null; inverseKiiDiagonal = null; Kbb = null; Kbi = null; //linearSystem.Matrix = null; // DO NOT DO THAT!!! The analyzer manages that. }
protected override DiagonalMatrix <T> Visit(DiagonalMatrix <T> lhs, DiagonalMatrix <T> rhs) { ValidateLengths(lhs.Size, rhs.Size); DiagonalMatrix <T> result = new DiagonalMatrix <T>(lhs.Size); Summarize(lhs, rhs, result); return(result); }
public void Sum() { var matrix = new DiagonalMatrix <int>(1, 0, 0, 0, 5, 0, 0, 0, 9); var actual = matrix.Sum(matrix); foreach (var variable in actual) { Console.WriteLine(variable); } }
private Matrix BuildGGT() { var siteCount = SiteCount; int size = siteCount * 3; DiagonalMatrix diagonal = new DiagonalMatrix(size, 1); var factor = 1.0 / Math.Sqrt(siteCount); Matrix G = factor * new Matrix(diagonal); var GGT = G * G.Trans; return(GGT); }
public void SetCell_Callback_ValueType() { DiagonalMatrix <int> matrix = new DiagonalMatrix <int>(IntArray); matrix.CellChange += CellChange; int value = 7; matrix[1, 1] = value; Assert.AreEqual(value, matrix[1, 1]); Assert.IsTrue(_wasCallback); }
public void SetCell_Callback_RefType() { DiagonalMatrix <string> matrix = new DiagonalMatrix <string>(StringArray); matrix.CellChange += CellChange; string value = "F"; matrix[1, 1] = value; Assert.AreEqual(value, matrix[1, 1]); Assert.IsTrue(_wasCallback); }
public void CanCreateMatrixFrom2DArray(string name) { var matrix = new DiagonalMatrix(TestData2D[name]); for (var i = 0; i < TestData2D[name].GetLength(0); i++) { for (var j = 0; j < TestData2D[name].GetLength(1); j++) { Assert.AreEqual(TestData2D[name][i, j], matrix[i, j]); } } }
public void Equals_DiagonalMatrixEqualSquareMatrix_TrueReturned() { var a = new DiagonalMatrix<double>(new double[] {1,2}); var b = new SquareMatrix<double>(new double[,]{ {1,0}, {0,2}}); bool resul = a.Equals(b); Assert.AreEqual(true, resul); }
public int[] Indexator_SequenceOfElements_CorrectResult(int order, int[] values) { var matrix = new DiagonalMatrix <int>(order); matrix.Copy(values); int[] actual = new int[matrix.Lenght]; matrix.CopyTo(actual, 0, 0, matrix.Lenght); return(actual); }
public void TestSum_Matrix_Type() { var squareMatrix = new SquareMatrix <int>(new int[] { 2, 4, 1, 4, 5, 5, 6, 3, 2 }); var diagonalMatrix = new DiagonalMatrix <int>(new int[] { 2, 4, 1 }); var symmetricMatrix = new SymmetricMatrix <int>(new int[3][] { new int[] { 1, 2, 3 }, new int[] { 2, 4, 5 }, new int[] { 3, 5, 6 } }); Assert.AreEqual(typeof(SquareMatrix <int>), MatrixSum.Sum(squareMatrix, diagonalMatrix).GetType()); Assert.AreEqual(typeof(DiagonalMatrix <int>), MatrixSum.Sum(diagonalMatrix, diagonalMatrix).GetType()); Assert.AreEqual(typeof(SymmetricMatrix <int>), MatrixSum.Sum(symmetricMatrix, symmetricMatrix).GetType()); Assert.AreEqual(typeof(SquareMatrix <int>), MatrixSum.Sum(diagonalMatrix, symmetricMatrix).GetType()); }
public void DiagonalMatrix_Event_ValueChange_NUnit() { // Arrange DiagonalMatrix <int> symmetricalMatrix = new DiagonalMatrix <int>(10); // Act symmetricalMatrix.Change += (s, e) => { Assert.Pass("The elements have been changed"); }; symmetricalMatrix[0, 0] = 20; }
public void IndexViewModelNotNull() { SquareMatrix <double> square = new SquareMatrix <double>(3); Calculater <double> visitor = new Calculater <double>(square); Mock <SquareMatrix <double> > mock = new Mock <SquareMatrix <double> >(); mock.Setup(m => m.Accept(visitor)); DiagonalMatrix <double> matrix = new DiagonalMatrix <double>(mock.Object.Size); }
public void Event() { var matrix = new DiagonalMatrix <int>(1, 0, 0, 0, 5, 0, 0, 0, 9); matrix[1, 1] = 32; Console.WriteLine(matrix.EventInfo.IndexI); Console.WriteLine(matrix.EventInfo.IndexJ); Console.WriteLine(matrix.EventInfo.PreviousValue); Console.WriteLine(matrix.EventInfo.NewValue); }
/// <summary> /// add a diagonal matrix to a diagal /// </summary> /// <typeparam name="T"></typeparam> /// <param name="matrixFirst"></param> /// <param name="matrixSecond"></param> /// <returns>diagonal matrix</returns> public static DiagonalMatrix <T> Add <T>(DiagonalMatrix <T> mFirst, DiagonalMatrix <T> mSecond) { var resultArray = new T[mFirst.Order, mFirst.Order]; for (int i = 0; i < mFirst.Order; i++) { resultArray[i, i] = (dynamic)mFirst[i, i] + (dynamic)mFirst[i, i]; } return(new DiagonalMatrix <T>(resultArray)); }
/// <summary> /// Returns the decomposed matrix diagonal. /// </summary> /// <returns>The matrix diagonal.</returns> internal DiagonalMatrix DiagonalEntries() { var result = new DiagonalMatrix(_inverseDiagonals.Length); for (var i = 0; i < _inverseDiagonals.Length; i++) { result[i, i] = 1 / _inverseDiagonals[i]; } return(result); }
public void Test_ExceprionFromDiagonalMatrix() { TestDelegate test = () => { DiagonalMatrix <int> diagonal = new DiagonalMatrix <int>(2); diagonal[0, 1] = 3; }; Assert.Throws(typeof(ArgumentException), test); }
static void Main(string[] args) { int[][] dm ={ new int[] {1,0,0}, new int[] {0,6,0}, new int[] {0,0,1} }; var diagonalMatrix = new DiagonalMatrix<int>(dm); var u1 = new User("Alex"); var u2 = new User("John"); diagonalMatrix.ElementChanged += u1.Subscribed; diagonalMatrix.ElementChanged += u2.Subscribed; diagonalMatrix.SetElement(1,1,8); }
static void Main(string[] args) { int[,] iarray= new int[10,5]; Random r = new Random(10); for (int i = 0; i < 10; i++) for (int j = 0; j < 5; j++) iarray[i,j]=r.Next(10); Matrix<int> m = new Matrix<int>(10,5,iarray); Console.WriteLine(m); m.Register(); m.ChangeSingleCell(4, 2,777); Console.WriteLine(); double[,] darray = new double[3, 3]; for (int i = 0; i < 3; i++) for (int j = 0; j < 3; j++) darray[i, j] =r.Next(10); SquereMatrix<double> sqm = new SquereMatrix<double>(3,darray); Console.WriteLine(sqm); sqm.ChangeSingleCell(2, 2, 77.7); Console.WriteLine(); //конструктор отзеркалит нижнюю половину string[,] strarray = new string[3, 3]; for (int i = 0; i < 3; i++) for (int j = 0; j < 3; j++) strarray[i, j] = r.Next(10).ToString(); SymmetricMatrix<string> smm = new SymmetricMatrix<string>(3, strarray); smm.ChangeSingleCell(2, 2, "777"); Console.WriteLine(smm); DateTime[] dtarray = new DateTime[3]; for (int i = 0; i < 3; i++) dtarray[i] = new DateTime((long)(i+1)*1000000000000000000); DiagonalMatrix<DateTime> dm = new DiagonalMatrix<DateTime>(3, dtarray); dm.ChangeSingleCell(2, 2, new DateTime((long)7770000000000000)); Console.WriteLine(dm); for (int i = 0; i < 10; i++) for (int j = 0; j < 5; j++) iarray[i, j] = r.Next(10); Matrix<int> m2 = new Matrix<int>(10, 5, iarray); Console.WriteLine(m2); Console.WriteLine(); Console.WriteLine(MatrixExtentor.Addition<int>(m,m2)); Console.WriteLine(); Console.Read(); }
public void Extension_Matrix_Test() { int[,] matr1 = { { 1, 2, 3 }, { 1, 2, 3 }, { 1, 2, 3 } }; SquareMatrix<int> matrix1 = new SquareMatrix<int>(matr1); int[,] matr2 = { { 1, 0, 0 }, { 0, 2, 0 }, { 0, 0, 3 } }; DiagonalMatrix<int> matrix2 = new DiagonalMatrix<int>(matr2); SquareMatrix<int> output = matrix1.Sum(matrix2); Assert.AreEqual(4, output[1, 1]); }
public void AddTest() { DiagonalMatrix<int> m1 = new DiagonalMatrix<int>(new int[] { 1, 5, 7 }, 3); DiagonalMatrix<int> m2 = new DiagonalMatrix<int>(new int[] { 9, 5, 3 }, 3); DiagonalMatrix<int> m3 = new DiagonalMatrix<int>(new int[] { 10, 10, 10 }, 3); m2.Add(m1); for (int i = 1; i <= m1.Size; i++) { for (int j = 1; j <= m1.Size; j++) { Assert.AreEqual(m2[i, j], m3[i, j]); } } }
public void Add_DiagonalMatrices_DoubleSourceArray() { int[,] sourceArray = new int[,] { {1, 0}, {0, 4} }; DiagonalMatrix<int> lhs = new DiagonalMatrix<int>(sourceArray); DiagonalMatrix<int> rhs = new DiagonalMatrix<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); }
static void Main(string[] args) { int[,] sqareArray = GenerateSquareArray(4); Print(sqareArray); int[,] simmetricArray = GenerateSimmetricArray(4); Print(simmetricArray); int[,] diagonalArray = GenerateDiagonalArray(4); Print(diagonalArray); SquareMatrix<int> squareMatrix = new SquareMatrix<int>(sqareArray); SimmetricMatrix<int> simmetricMatrix = new SimmetricMatrix<int>(simmetricArray); DiagonalMatrix<int> diagonalMatrix = new DiagonalMatrix<int>(diagonalArray); squareMatrix.Add(simmetricMatrix); Console.ReadLine(); }
static void Main(string[] args) { Console.WriteLine("Диагональная матрица"); DiagonalMatrix<int> diagonalInt = new DiagonalMatrix<int>(new int[] { 1, 2, 3, 4 }); diagonalInt.Print(); diagonalInt.amendEvent.amendIMatrixItem += (s, e) => Console.WriteLine(e.massage); diagonalInt[2, 2] = 5; diagonalInt.Print(); Console.WriteLine("Симметрическая матрица"); SymmetricMatrix<int> symmetricInt = new SymmetricMatrix<int>(new int[][] { new int[] {1,2,3,4}, new int[] { 2,3,4}, new int[] { 3,4}, new int[] { 4} }); symmetricInt.Print(); symmetricInt.amendEvent.amendIMatrixItem += (s, e) => Console.WriteLine(e.massage); symmetricInt[1, 3] = 9; symmetricInt.Print(); Console.WriteLine("Квадратная матрица"); SquareMatrix<int> square = new SquareMatrix<int>(new int[,] { {1,1,1,1}, {2,2,2,2}, {3,3,3,3}, {4,4,4,4} }); square.Print(); square.amendEvent.amendIMatrixItem += (s, e) => Console.WriteLine(e.massage); square[2, 2] = 10; square.Print(); Console.WriteLine("Квадратная + Симметрическая"); square.Add(symmetricInt); square.Print(); Console.ReadKey(); }
static void Main(string[] args) { int[,] symm = { {11, 2, -8}, {2, 2, 10}, {-8, 10, 5} }; int[,] diag = { {1, 0, 0}, {0, 1, 0}, {0, 0, 1} }; try { DiagonalMatrix<int> d = new DiagonalMatrix<int>(diag); Message<int> m = new Message<int>(d); d[0, 0] = 10; SymmetricMatrix<int> s = new SymmetricMatrix<int>(diag); SquareMatrix<int> sq = new SquareMatrix<int>(symm); for (int i = 0; i < s.Size; i++) { for (int j = 0; j < s.Size; j++) { Console.Write(s[i, j] + " "); } Console.WriteLine(); } d = sq.Sum(sq); } catch (ArgumentException ex) { Console.WriteLine(ex.Message); } }
static void Main(string[] args) { var v = new int[3][]; v[0] = new[] { 1, 2, 3 }; v[1] = new[] { 1, 2, 3 }; v[2] = new[] { 1, 2, 3 }; var a = new DiagonalMatrix<int>(v); var b = new DiagonalMatrix<int>(v); var c = MatrixExtension<int>.Add(a, b); Console.WriteLine(c); c.Change = OnChange; c[1, 1] = 17; var array = new int[2][]; array[0]= new[]{2,2}; array[1] = new[]{2,1}; var sm = new SymmetricMatrix<int>(array); sm.Change = OnChange; Console.WriteLine(sm); sm[0, 1] = 17; Console.ReadKey(); }
static void Main(string[] args) { int[,] squareArray = { { 1, 2, 3 }, { 1, 2, 9 }, { 2, 4, 1 } }; int[,] diagonalArray = { { 1, 0, 0 }, { 0, 1, 0 }, { 0, 0, 1 } }; int[,] semetricalArray = { { 1, 3, 5 }, { 3, 2, 4 }, { 5, 4, 6 } }; try { var squareMatrix = new SquareMatrix<int>(squareArray); var diagonalMatrix = new DiagonalMatrix<int>(diagonalArray); var semetricalMatrix = new SymmetricMatrix<int>(semetricalArray); Console.WriteLine(diagonalMatrix.ToString()); Console.WriteLine(semetricalMatrix.ToString()); var resultSum=semetricalMatrix.SumMatrix(diagonalMatrix, (a, b) => a + b); Console.WriteLine(resultSum.ToString()); diagonalMatrix.Changes+= Change; diagonalMatrix[2, 2] = 123; diagonalMatrix[2, 2] = 0; } catch (ArgumentNullException e) { Console.WriteLine(e.Message); } catch (ArgumentException e) { Console.WriteLine(e.Message); } catch (IndexOutOfRangeException e) { Console.WriteLine(e.Message); } finally { Console.ReadKey(); } }
public void DiagonalMatrixConstructor_NullInputMatrixExceptionTest() { GeneralMatrix<int> matrix1 = new DiagonalMatrix<int>(null); }
public void DiagonalMatrix_SetValue_Test() { DiagonalMatrix<int> matrix = new DiagonalMatrix<int>(3); matrix[2, 2] = 3; Assert.AreEqual(3, matrix[2, 2]); }
public void DiagonalMatrixSetterTest() { GeneralMatrix<int> matrix = new DiagonalMatrix<int>(new int[3, 3] { { 1, 0, 0}, { 0, 2, 0 }, { 0, 0, 3 } }); matrix[0, 1] = 5; matrix[1, 1] = 10; Assert.AreEqual<int>(0, matrix[0, 1]); Assert.AreEqual<int>(0, matrix[1, 0]); Assert.AreEqual<int>(10, matrix[1, 1]); }
public void DiagonalMatrixAdditionTest() { GeneralMatrix<int> matrix1 = new DiagonalMatrix<int>(new int[3, 3] { { 1, 0, 0 }, { 0, 2, 0 }, { 0, 0, 3 } }); GeneralMatrix<int> matrix2 = new SquareMatrix<int>(new int[3, 3] { { 2, 7, 3 }, { 4, 0, 2 }, { 3, 6, 2 } }); matrix1.SumWith(matrix2, AdditionMethod); Assert.AreEqual<int>(3, matrix1[0, 0]); Assert.AreEqual<int>(0, matrix1[0, 1]); Assert.AreEqual<int>(0, matrix1[0, 2]); Assert.AreEqual<int>(0, matrix1[1, 0]); Assert.AreEqual<int>(2, matrix1[1, 1]); Assert.AreEqual<int>(0, matrix1[1, 2]); Assert.AreEqual<int>(0, matrix1[2, 0]); Assert.AreEqual<int>(0, matrix1[2, 1]); Assert.AreEqual<int>(5, matrix1[2, 2]); }
public void DiagonalMatrixConstructor_NotDiagonalInputMatrixExceptionTest() { GeneralMatrix<int> matrix = new DiagonalMatrix<int>(new int[3, 3] { { 1, 2, 3 }, { 2, 1, 2 }, { 3, 2, 1 } }); }
public void MatrixFrom1DArrayIsReference() { var data = new[] { new Complex(1.0, 1), new Complex(2.0, 1), new Complex(3.0, 1), new Complex(4.0, 1), new Complex(5.0, 1) }; var matrix = new DiagonalMatrix(5, 5, data); matrix[0, 0] = new Complex(10.0, 1); Assert.AreEqual(new Complex(10.0, 1), data[0]); }
public void CanCreateMatrixWithUniformValues() { var matrix = new DiagonalMatrix(10, 10, new Complex(10.0, 1)); for (var i = 0; i < matrix.RowCount; i++) { Assert.AreEqual(matrix[i, i], new Complex(10.0, 1)); } }
public void DiagonalMatrixChangeEventTest() { GeneralMatrix<int> matrix = new DiagonalMatrix<int>(new int[3, 3] { { 1, 0, 0 }, { 0, 2, 0 }, { 0, 0, 3 } }); Subscribe(matrix); matrix[0, 1] = 5; Assert.AreEqual<string>("DiagonalMatrix: can't change non main diagonal element.", message); matrix[1, 1] = 5; Assert.AreEqual<string>("DiagonalMatrix: changed element on main diagonal.", message); Unsubscribe(matrix); }