Esempio n. 1
0
        public void Add_SquareAndSymmetrical_ReturnSquareMatrix()
        {
            var matrix = new int[, ]
            {
                { 1, 2 },
                { 4, 5 }
            };
            var square = new SquareMatrix <int>(matrix);

            int[,] symmetrical = new int[, ] {
                { 1, 5 }, { 5, 7 }
            };
            var diagonalMatrix = new SymmetricalMatrix <int>(symmetrical);
            var result         = square.Add(diagonalMatrix);

            int[,] expectedValues =
            {
                { 2,  7 },
                { 9, 12 }
            };
            for (int i = 0; i < result.Size; i++)
            {
                for (int j = 0; j < result.Size; j++)
                {
                    Assert.AreEqual(expectedValues[i, j], result[i, j]);
                }
            }
        }
Esempio n. 2
0
        static void Main(string[] args)
        {
            SymmetricalMatrix <string> symMatrix = new SymmetricalMatrix <string>(3);

            symMatrix.MatrixEvent += Handler2;

            symMatrix[1, 2] = "abc";

            symMatrix[0, 1] = "aaa";

            int[] values = new int[] { 10, 20, 30, 40 };

            DiagonalMatrix <int> diagMatrix = new DiagonalMatrix <int>(values);

            SquareMatrix <int> .MatrixDelegate del = diagMatrix.Method;

            diagMatrix.MatrixEvent += Handler1;

            diagMatrix[3, 3] = 17;

            SquareMatrix <int> sqMatrix = new SquareMatrix <int>(4);

            sqMatrix[0, 1] = 12;
            sqMatrix[3, 0] = 78;

            SquareMatrix <int> newMatrix = ExtendedMatrix <int> .GetSum(sqMatrix, diagMatrix);

            Console.ReadLine();
        }
Esempio n. 3
0
        public void SetUp()
        {
            int[,] arrayA =
            {
                { 4, 6, 3 },
                { 4, 6, 3 },
                { 4, 6, 3 }
            };

            int[,] arrayB =
            {
                { 5, 2, 7 },
                { 5, 2, 7 },
                { 5, 2, 7 }
            };

            string[,] arrayStr =
            {
                { "asd",   "aqwe" },
                { "sakjd", "qwrb" }
            };

            // All of them have integer values
            this.square    = new SquareMatrix <int>(arrayA);
            this.symmetric = new SymmetricalMatrix <int>(arrayB);

            this.squareString   = new SquareMatrix <string>(arrayStr);
            this.diagonalString = new DiagonalMatrix <string>(2); // Full of nulls

            this.diagonal     = new DiagonalMatrix <int>(arrayB); // Length is 3
            this.diagonalDiff = new DiagonalMatrix <int>(5);
        }
Esempio n. 4
0
        public void TestAdd2()
        {
            int[][] matrix = new int[][]
            {
                new [] { 1, 0, 0 },
                new [] { 0, 1, 0 },
                new [] { 0, 0, 1 }
            };

            var matrix1 = new SymmetricalMatrix <int>(matrix);

            int[][] matrixx = new int[][]
            {
                new [] { 1, 0, 0 },
                new [] { 0, 1, 0 },
                new [] { 0, 0, 1 }
            };

            var matrix2 = new DiagonalMatrix <int>(matrixx);

            int[][] expected = new int[][]
            {
                new [] { 2, 0, 0 },
                new [] { 0, 2, 0 },
                new [] { 0, 0, 2 }
            };


            var actual = new MatrixVisitor <int>().Add(matrix1, matrix2);

            CollectionAssert.AreEqual(expected, actual.ToArray());
        }
        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();
            }
           
        }
Esempio n. 6
0
        public void EqualityTestInt(int[,] elements)
        {
            var lhs = new SymmetricalMatrix <int>(elements);
            var rhs = new SymmetricalMatrix <int>(elements);

            Assert.IsTrue(lhs.Equals(rhs));
        }
Esempio n. 7
0
        public void EqualityTestString(string[,] elements)
        {
            var lhs = new SymmetricalMatrix <string>(elements);
            var rhs = new SymmetricalMatrix <string>(elements);

            Assert.IsTrue(lhs.Equals(rhs));
        }
Esempio n. 8
0
        public void Add_TwoSymmetricalMatrices_ReturnSymmetricalMatrix()
        {
            var matrix = new int[, ]
            {
                { 11, 2, -8 },
                { 2, 2, 10 },
                { -8, 10, 5 }
            };
            var first          = new SymmetricalMatrix <int>(matrix);
            var second         = new SymmetricalMatrix <int>(matrix);
            var result         = first.Add(second);
            var expectedValues = new int[, ]
            {
                { 22, 4, -16 },
                { 4, 4, 20 },
                { -16, 20, 10 }
            };

            for (int i = 0; i < result.Size; i++)
            {
                for (int j = 0; j < result.Size; j++)
                {
                    Assert.AreEqual(expectedValues[i, j], result[i, j]);
                }
            }
        }
Esempio n. 9
0
        public void Add_DiagonalAndSymmetricalMatrices_ReturnSymmetricalMatrix()
        {
            var valuesForSymmetrical = new int[, ]
            {
                { 11, 2, -8 },
                { 2, 2, 10 },
                { -8, 10, 5 }
            };
            var valuesForDiagonal = new int[, ]
            {
                { 1, 0, 0 },
                { 0, 1, 0 },
                { 0, 0, 1 }
            };
            var diagonalMatrix    = new DiagonalMatrix <int>(valuesForDiagonal);
            var symmetricalMatrix = new SymmetricalMatrix <int>(valuesForSymmetrical);
            var expectedValues    = new int[, ]
            {
                { 12, 2, -8 },
                { 2, 3, 10 },
                { -8, 10, 6 }
            };
            var result = diagonalMatrix.Add(symmetricalMatrix);

            for (int i = 0; i < result.Size; i++)
            {
                for (int j = 0; j < result.Size; j++)
                {
                    Assert.AreEqual(expectedValues[i, j], result[i, j]);
                }
            }
        }
Esempio n. 10
0
        public void SumOfTest1()
        {
            int[][] arr = new int[][]
            {
                new int[] { 1, 0, 0 },
                new int[] { 0, 3, 0 },
                new int[] { 0, 0, 6 }
            };

            int[][] arr1 = new int[][]
            {
                new int[] { 1, 1 },
                new int[] { 1, 3 }
            };

            DiagonalMatrix <int>    diagMatrix = new DiagonalMatrix <int>(arr);
            SymmetricalMatrix <int> symmMatrix = new SymmetricalMatrix <int>(arr1);

            int[][] expected = new int[][]
            {
                new int[] { 2, 1, 0 },
                new int[] { 1, 6, 0 },
                new int[] { 0, 0, 6 }
            };

            SquareMatrix <int> actual = diagMatrix + symmMatrix;

            Assert.AreEqual(actual.Array, expected);
        }
        public void CtorSymmetricalMatrix_CheckCreation()
        {
            // arrange
            int[,] expected =
            {
                { 2, 5, 3 },
                { 5, 2, 1 },
                { 3, 1, 2 }
            };

            int[] array = new int[]
            {
                2, 5, 3,
                2, 1,
                2
            };
            int length = 3;
            Func <int, int, int> func = (firstElement, secondElement) => firstElement + secondElement;

            // act
            SquareMatrix <int> symmetric = new SymmetricalMatrix <int>(array, length, func);

            // assert
            for (int i = 0; i < length; i++)
            {
                for (int j = 0; j < length; j++)
                {
                    Assert.AreEqual(expected[i, j], symmetric[i, j]);
                }
            }
        }
Esempio n. 12
0
        public void PlustOperator_SymmetricalAndSymmetrical_SymmetricalMatrix()
        {
            SymmetricalMatrix <int> inMatrix  = new SymmetricalMatrix <int>(symmetricalArray, new IntSum());
            SymmetricalMatrix <int> outMatrix = inMatrix + inMatrix;

            Assert.AreEqual(symmetricalResult, outMatrix.Array);
        }
        public void Create_SizePassed()
        {
            var size   = 3;
            var matrix = new SymmetricalMatrix <int>(size);

            Assert.AreEqual(size, matrix.Size);
        }
Esempio n. 14
0
        public void CtorSymmMatrix_ThowsArgumentException()
        {
            SymmetricalMatrix <int> matr;

            Assert.Catch <ArgumentException>(() => matr = new SymmetricalMatrix <int>(new int[, ] {
                { 1, 4, 0 }, { 3, 2, 6 }, { 0, 6, 5 }
            }));
        }
Esempio n. 15
0
        public void PlustOperator_SymmetricalAndDiagonal_SquareMatrix()
        {
            SymmetricalMatrix <int> inMatrix1 = new SymmetricalMatrix <int>(symmetricalArray, new IntSum());
            DiagonalMatrix <int>    inMatrix2 = new DiagonalMatrix <int> (diagonalArray, new IntSum());
            SquareMatrix <int>      outMatrix = inMatrix1 + inMatrix2;

            Assert.AreEqual(symDiagResult, outMatrix.Array);
        }
Esempio n. 16
0
        public void CtorSymmMatrix_Successully()
        {
            SymmetricalMatrix <int> matr;

            Assert.DoesNotThrow(() => matr = new SymmetricalMatrix <int>(new int[, ] {
                { 1, 3, 0 }, { 3, 2, 6 }, { 0, 6, 5 }
            }));
        }
Esempio n. 17
0
        public void SymmetricalMatrixTest_ValueChange_Event_Succed()
        {
            SymmetricalMatrix <int> symmetricalMatrix = new SymmetricalMatrix <int>(5);

            symmetricalMatrix.ChangeValue += (s, e) => {
                Assert.Pass($"{e.i}.{e.j}, old - {e.OldValue} , new - {e.NewValue}");
            };
            symmetricalMatrix[0, 0] = 10;
        }
Esempio n. 18
0
        public string[,] AddTestString(string[,] elements)
        {
            var lhs = new SymmetricalMatrix <string>(elements);
            var rhs = new SymmetricalMatrix <string>(elements);

            lhs = lhs.Add(rhs) as SymmetricalMatrix <string>;

            return(lhs?.ToArray());
        }
Esempio n. 19
0
        public int[,] AddTestInt(int[,] elements)
        {
            var lhs = new SymmetricalMatrix <int>(elements);
            var rhs = new SymmetricalMatrix <int>(elements);

            lhs = lhs.Add(rhs) as SymmetricalMatrix <int>;

            return(lhs?.ToArray());
        }
Esempio n. 20
0
        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 SymmetricalMatrixChangeEventTest()
        {
            GeneralMatrix<int> matrix = new SymmetricalMatrix<int>(new int[3, 3] { { 1, 2, 3 }, { 2, 1, 2 }, { 3, 2, 1 } });
            Subscribe(matrix);
            matrix[0, 1] = 5;
            Assert.AreEqual<string>("SymmetricalMatrix: changed both symmetric and request elements.", message);

            matrix[1, 1] = 5;
            Assert.AreEqual<string>("SymmetricalMatrix: changed element on main diagonal.", message);
            Unsubscribe(matrix);
        }
Esempio n. 22
0
        public void SymmetricalMatrix_Event_ValueChange_NUnit()
        {
            // Arrange
            SymmetricalMatrix <int> symmetricalMatrix = new SymmetricalMatrix <int>(10);

            // Act
            symmetricalMatrix.Change += (s, e) => {
                Assert.Pass("The elements have been changed");
            };
            symmetricalMatrix[0, 0] = 20;
        }
        public void Indexer_SetValue_ValuesAreSetted()
        {
            int[,] values = new int[, ] {
                { 1, 5 }, { 5, 7 }
            };
            var matrix = new SymmetricalMatrix <int>(values);

            matrix[0, 1] = 222;
            Assert.AreEqual(222, matrix[0, 1]);
            Assert.AreEqual(222, matrix[1, 0]);
        }
Esempio n. 24
0
        public void Add_SquareAddToSymmetricalMatrixTests(SquareMatrix <int> firstMatrix, SymmetricalMatrix <int> secondMatrix, SymmetricalMatrix <int> expectedMatrix)
        {
            SymmetricalMatrix <int> result = firstMatrix.Add(secondMatrix);

            for (int i = 0; i < result.Order; i++)
            {
                for (int j = 0; j < result.Order; j++)
                {
                    Assert.AreEqual(expectedMatrix[i, j], result[i, j]);
                }
            }
        }
Esempio n. 25
0
        public void SymmetricalMatrixTest_Pass_SymmetricalMatrix_Succed()
        {
            int[,] paramMatrix = new int[, ]
            {
                { 3, 5, 4 },
                { 5, 6, 8 },
                { 4, 8, 7 }
            };
            SymmetricalMatrix <int> symmetricalMatrix = new SymmetricalMatrix <int>(paramMatrix);

            Assert.Pass();
        }
        public void MatrixHierarchyAdditionTest2()
        {
            var array1      = new string[][] { new string[] { "-3" }, new string[] { "6", "-5" }, new string[] { "5", "7", "4" } };
            var array2      = new string[] { "ab", "cd", "ef" };
            var resultArray = new string[, ] {
                { "-3ab", "6", "5" }, { "6", "-5cd", "7" }, { "5", "7", "4ef" }
            };
            var matrixA = new SymmetricalMatrix <string>(array1);
            var matrixB = new DiagonalMatrix <string>(array2);
            var sum     = MatrixExtension <string> .Add(matrixA, matrixB);

            CollectionAssert.AreEqual(resultArray, sum.ToArray());
        }
        public void Equals_SymmetricalMatrixEqualSquareMatrix_TrueReturned()
        {
            var a = new SymmetricalMatrix<int>(new int[,]{
                {1,1},
                {1,2}});
            var b = new SquareMatrix<int>(new int[,]{
                {1,1},
                {1,2}});

            bool result = a.Equals(b);

            Assert.AreEqual(true, result);
        }
Esempio n. 28
0
        public void Test_SettingObjectOutsideTheDiagonal()
        {
            DiagonalMatrix <int> matrix = new DiagonalMatrix <int>(4);

            matrix[3, 1] = 169;

            Assert.AreEqual(0, matrix[3, 1]);

            SymmetricalMatrix <int> second = new SymmetricalMatrix <int>(10);

            second[1, 5] = 184;

            Assert.AreEqual(184, second[1, 5]);
            Assert.AreEqual(184, second[5, 1]);
        }
Esempio n. 29
0
        public void SymmetricalMatrix_InputCorrectSymMatrix_CheckIsMatrix_NUnit()
        {
            // Arrange
            int[,] matrix = new int[, ]
            {
                { 3, 5, 4 },
                { 5, 6, 8 },
                { 4, 8, 7 }
            };

            SymmetricalMatrix <int> symmetricalMatrix = new SymmetricalMatrix <int>(matrix);

            // Assert
            Assert.Pass();
        }
Esempio n. 30
0
        protected override SymmetricalMatrix <T> Visit(SymmetricalMatrix <T> lhs, SymmetricalMatrix <T> rhs)
        {
            this.Validate(lhs, rhs);
            SymmetricalMatrix <T> symmetricalMatrix = new SymmetricalMatrix <T>(rhs.Size);

            for (int i = 0; i < rhs.Size; i++)
            {
                for (int j = 0; j < rhs.Size; j++)
                {
                    symmetricalMatrix[i, j] = AddViaDynamic(lhs[i, j], rhs[i, j]);
                }
            }

            return(symmetricalMatrix);
        }
        public void Create_SymmetricalMatrixPassed_Created()
        {
            int[,] values = new int[, ] {
                { 1, 5 }, { 5, 7 }
            };
            var matrix = new SymmetricalMatrix <int>(values);

            for (int i = 0; i < matrix.Size; i++)
            {
                for (int j = 0; j < matrix.Size; j++)
                {
                    Assert.AreEqual(values[i, j], matrix[i, j]);
                }
            }
        }
Esempio n. 32
0
        public void OperationMatrixTest_Add_ArgumentNullException()
        {
            int[,] paramMatrix = new int[, ]
            {
                { 3, 5, 4 },
                { 5, 6, 8 },
                { 4, 8, 7 }
            };

            SquareMatrix <int>      squareMatrix      = new SquareMatrix <int>(paramMatrix);
            SymmetricalMatrix <int> symmetricalMatrix = null;

            Assert.Throws <ArgumentNullException>(
                () => squareMatrix.Add(symmetricalMatrix));
        }
Esempio n. 33
0
        public void Indexer_AddNewElementToMatrixTests(int element, int indexI, int indexJ, int order)
        {
            SymmetricalMatrix <int> matrix = new SymmetricalMatrix <int>(order);
            Handler handler = new Handler();

            matrix.ValueChanged += handler.Message;

            int oldElement = matrix[indexI, indexJ];

            matrix[indexI, indexJ] = element;

            Assert.AreEqual(
                string.Format("The element of the matrix was changed!\nRow index: {0}\nColumn index: {1}\nOld value: {2}\nNew value: {3}",
                              indexI, indexJ, oldElement, element), handler.Result);
            Assert.AreEqual(matrix[indexI, indexJ], matrix[indexJ, indexI]);
        }
Esempio n. 34
0
        static void Main(string[] args)
        {
            int[] ints = new int[4] { 1, 2, 3, 4 };
            SquareMatrix<int> m = new SquareMatrix<int>();
            m.ElementChanged += m_ElementChanged;
            Console.WriteLine(m.ToString());
            m[1, 1] = 5;
            Console.WriteLine(m.ToString());

            SymmetricalMatrix<int> s = new SymmetricalMatrix<int>(new int[] {1, 2, 3, 4, 5, 6}, 3);
            Console.WriteLine(s.ToString());
            s.ElementChanged += m_ElementChanged;
            s[1, 2] = 60;
            Console.WriteLine(s.ToString());

            SquareMatrix<int> m1 = new SquareMatrix<int>(new int[] { 1, 4, 5, 7 }, 2);
            SquareMatrix<int> m2 = new SquareMatrix<int>(new int[] { 1, 4, 5, 8 }, 2);
            Console.WriteLine(m1.CalculateOperation(m2, (a, b) => a + b));

            Console.ReadLine();
        }
 public void SymmetricalMatrixConstructor_NullInputMatrixExceptionTest()
 {
     GeneralMatrix<int> matrix1 = new SymmetricalMatrix<int>(null);
 }
        public int IndexatorTest_Int_SymmetricalMatrix(int[] array, int length, int i, int j)
        {
            SymmetricalMatrix<int> m = new SymmetricalMatrix<int>(array, length);

            return m[i, j];
        }
 public void SymmetricalMatrixSetterTest()
 {
     GeneralMatrix<int> matrix = new SymmetricalMatrix<int>(new int[3, 3] { { 1, 2, 3 }, { 2, 1, 2 }, { 3, 2, 1 } });
     matrix[0, 1] = 5;
     matrix[1, 1] = 10;
     Assert.AreEqual<int>(5, matrix[0, 1]);
     Assert.AreEqual<int>(5, matrix[1, 0]);
     Assert.AreEqual<int>(10, matrix[1, 1]);
 }
 public void SymmetricalMatrixConstructor_NotSymmetricalInputMatrixExceptionTest()
 {
     GeneralMatrix<int> matrix = new SymmetricalMatrix<int>(new int[3, 3] { { 1, 2, 1 }, { 2, 1, 2 }, { 3, 2, 1 } });
 }
        public void SymmetricMatrixAdditionTest()
        {
            GeneralMatrix<int> matrix1 = new SymmetricalMatrix<int>(new int[3, 3] { { 1, 2, 3 }, { 2, 1, 2 }, { 3, 2, 1 } });
            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>(13, matrix1[0, 1]);
            Assert.AreEqual<int>(9, matrix1[0, 2]);
            Assert.AreEqual<int>(13, matrix1[1, 0]);
            Assert.AreEqual<int>(1, matrix1[1, 1]);
            Assert.AreEqual<int>(10, matrix1[1, 2]);
            Assert.AreEqual<int>(9, matrix1[2, 0]);
            Assert.AreEqual<int>(10, matrix1[2, 1]);
            Assert.AreEqual<int>(3, matrix1[2, 2]);
        }