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]);
 }
Ejemplo n.º 6
0
        /// <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);
        }
Ejemplo n.º 7
0
        /// <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];
            }
        }
Ejemplo n.º 8
0
        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());
        }
Ejemplo n.º 9
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());
        }
Ejemplo n.º 10
0
        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));
        }
Ejemplo n.º 11
0
        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>);
        }
Ejemplo n.º 16
0
        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());
        }
Ejemplo n.º 17
0
        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);
        }
Ejemplo n.º 18
0
        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));
        }
Ejemplo n.º 19
0
    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);
        }
Ejemplo n.º 22
0
        public void DioganalMatrix_InputCorrectIsDioganal_Succed()
        {
            // Arrange
            DiagonalMatrix <int> dioganalMatrix = new DiagonalMatrix <int>(10);

            dioganalMatrix[0, 0] = 1;

            // Assert
            Assert.Pass();
        }
Ejemplo n.º 23
0
        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);
        }
Ejemplo n.º 24
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);
        }
Ejemplo n.º 25
0
        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]);
        }
Ejemplo n.º 26
0
        /// <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;
        }
Ejemplo n.º 27
0
 /// <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);
        }
Ejemplo n.º 29
0
        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);
        }
Ejemplo n.º 31
0
        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);
        }
Ejemplo n.º 32
0
        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);
        }
Ejemplo n.º 36
0
        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());
        }
Ejemplo n.º 37
0
        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);
        }
Ejemplo n.º 39
0
        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);
        }
Ejemplo n.º 40
0
        /// <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));
        }
Ejemplo n.º 41
0
        /// <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);
        }
Ejemplo n.º 42
0
        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);
        }
Ejemplo n.º 44
0
        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);
        }
Ejemplo n.º 48
0
        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();
        }
Ejemplo n.º 49
0
        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();
        }
Ejemplo n.º 50
0
        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 } });
 }
Ejemplo n.º 58
0
 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]);
 }
Ejemplo n.º 59
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);
        }