MatrixFull

static class MatrixMath
    {
        public static void PrintMatrix(int[,] matrix)
        {
            int n = matrix.GetLength(0);
            int m = matrix.GetLength(1);
            for (int i = 0; i < n; i++)
            {
                for (int j = 0; j < m; j++)
                {
                    Console.Write($"{matrix[i, j]} ");
                }
                Console.WriteLine();
            }
        }

        public static void RandomElements(int[,] matrix)
        {
            Random rand = new Random();
            int n = matrix.GetLength(0);
            int m = matrix.GetLength(1);
            for (int i = 0; i < n; i++)
            {
                for (int j = 0; j < m; j++)
                {
                    matrix[i, j] = rand.Next(10);
                }
            }
        }

        public static void ChangeRows(int[,] matrix, int row1, int row2)
        {
            int n = matrix.GetLength(0);
            int m = matrix.GetLength(1);
            if (row1 < 0 || row2 < 0 || row1 >= n || row2 >= n)
            {
                throw new ArgumentException("Rows problem");
            }
            for (int i = 0; i < m; i++)
            {
                // matrix[row1, i] <=> matrix[row2, i]
                int temp = matrix[row1, i];
                matrix[row1, i] = matrix[row2, i];
                matrix[row2, i] = temp;
            }
        }

        public static int[,] ScalarMult(int[,] matrix, int num)
        {
            int n = matrix.GetLength(0);
            int m = matrix.GetLength(1);
            int[,] result = new int[n, m];
            for (int i = 0; i < n; i++)
            {
                for (int j = 0; j < m; j++)
                {
                    result[i, j] = matrix[i, j] * num;
                }
            }
            return result;
        }

        public static int[,] AddMatrix(int[,] matrix1, int[,] matrix2)
        {
            int n1 = matrix1.GetLength(0);
            int m1 = matrix1.GetLength(1);
            int n2 = matrix1.GetLength(0);
            int m2 = matrix1.GetLength(1);
            if (n1 != n2 || m1 != m2)
            {
                throw new ArgumentException("Matrix dimensions problem!");
            }
            int[,] result = new int[n1, m1];
            for (int i = 0; i < n1; i++)
            {
                for (int j = 0; j < m1; j++)
                {
                    result[i, j] = matrix1[i, j] + matrix2[i, j];
                }
            }
            return result;
        }

        public static int[,] Identity(int n)
        {
            int[,] result = new int[n, n];
            for (int i = 0; i < n; i++)
            {
                result[i, i] = 1;
            }
            return result;
        }

        public static int[,] Scalar(int size, int num)
        {
            return ScalarMult(Identity(size), num);
        }

        public static int[,] Transponate(int[,] matrix)
        {
            int n = matrix.GetLength(0);
            int m = matrix.GetLength(1);
            int[,] result = new int[m, n];
            for (int row = 0; row < n; row++)
            {
                for (int col = 0; col < m; col++)
                {
                    result[col, row] = matrix[row, col];
                }
            }
            return result;
        }

        public static int[,] Multiply(int[,] A, int[,] B)
        {
            int rowa = A.GetLength(0);
            int cola = A.GetLength(1);
            int rowb = B.GetLength(0);
            int colb = B.GetLength(1);

            if (cola != rowb)
            {
                throw new ArithmeticException("Matrix dimensions problem!");
            }

            int[,] mult = new int[rowa, colb];
            int n = rowa;
            int m = colb;

            for (int i = 0; i < n; i++)
            {
                for (int j = 0; j < m; j++)
                {
                    mult[i, j] = 0;
                    for (int k = 0; k < m; k++)
                    {
                        mult[i, j] += A[i, k] * B[k, j];
                    }
                }
            }
            return mult;

        }
    }