C# Online Compiler | .NET Fiddle

<no name> by Anonymous

using System;
//using static System.Console;
namespace MatrixOperations
{
    public class Program
    {
        public static void Main()
        {
            Matrix X = new Matrix(new double[3, 3] { { 1,2,0}, { 0,2,3 }, { 1,0,3} });
            X.Print();
            Matrix kovar = new Matrix(~X);
            Console.WriteLine("Коваріантна база:");
            matrixE(kovar, new string[] { "e1", "e2", "e3" });
           Console.WriteLine();
            Matrix kontravar = new Matrix(Matrix.SLAR(new Matrix(kovar), new Vector(1, 0, 0)), Matrix.SLAR(new Matrix(kovar), new Vector(0, 1, 0)), Matrix.SLAR(new Matrix(kovar), new Vector(0, 0, 1)));
          Console.  WriteLine("контраваріантна база:");
            matrixE(kontravar, new string[] { "e1", "e2", "e3" });
         Console.   WriteLine();
         Console.   WriteLine("метричні елементи:");
            metriktenzor(kovar, new string[] { "e1", "e2", "e3" });
         Console.   WriteLine();
            //matrixE(Matrix.SLAR(X, new Vector(1, 0, 0)), new string[] { "e1", "e2", "e3" });
            //matrixE(Matrix.SLAR(X, new Vector(0, 1, 0)), new string[] { "e1", "e2", "e3" });
            //matrixE(Matrix.SLAR(X, new Vector(0, 0, 1)), new string[] { "e1", "e2", "e3" });
            //MatrixLD LD = new MatrixLD("matrixLD.txt");
            //Console.WriteLine(LD * LD);

            //int n, N, M;
            //Random rnd = new Random();
            //Console.Write("Enter n=");
            //n = int.Parse(Console.ReadLine());
            //Matrix[] arrayMatrix = new Matrix[n];

            //Console.Write("Enter matrix1.N =");
            //N = int.Parse(Console.ReadLine());
            //for (int i=0; i<n; i++)
            //{
            //    Console.Write("Enter matrix" + (i+1) + ".M =");
            //    M = int.Parse(Console.ReadLine());
            //    arrayMatrix[i] = new Matrix(N, M, rnd);
            //    N = M;
            //}

            //Console.WriteLine();
            //for (int i = 0; i < n; i++)
            //{
            //    //File.WriteAllLines("matrixStrassen" + (i + 1) + ".txt", arrayMatrix[i].ToString().Split('\n'));
            //    Console.WriteLine("Matrix" + (i + 1) + "\n" + arrayMatrix[i] + "\n");
            //}

            //int operations = 0;
            //Matrix matrix = arrayMatrix[0];
            //for (int i = 1; i < n; i++)
            //{
            //    operations += matrix.N * matrix.M * arrayMatrix[i].M;
            //    matrix *= arrayMatrix[i];
            //}
            //Console.WriteLine(new string('-', 70));
            //Console.WriteLine("Result multiplying all matrices (in order):\n\n" + matrix + "\n");
            //Console.WriteLine("Count operations : " + operations + "\n");
            //Console.WriteLine(new string('-', 70));
            //Console.WriteLine("Result multiplying all matrices (Strassen algorithm):\n");
            //Console.WriteLine(Strassen.AlgorithmStrassen(arrayMatrix) + "\n");
            ////Strassen.AlgorithmStrassen(arrayMatrix);
            
        }
        static void matrixE(Matrix matrix, string [] str)
        {
            for (int i = 0; i < matrix.N; i++)
            {
                for (int j = 0; j < matrix.M; j++)
                {
                    if (matrix[i,j] > 0)
                    {
                        if (matrix[i, j] == 1)
                        {
                            Console.Write("+{1}", matrix[i, j], str[j]);
                        }
                        else
                        {
                            Console.Write("+{0}*{1}", matrix[i, j], str[j]);
                        }

                    }
                    else if (matrix[i, j] < 0)
                    {
                        if (matrix[i, j] == -1)
                        {
                            Console.Write("-{1}", matrix[i, j], str[j]);
                        }
                        else
                        {
                            Console.Write("{0}*{1}", matrix[i, j], str[j]);
                        }
                    }

                }
                Console.WriteLine();
            }
            Console.WriteLine();
        }
        static void matrixE(Vector vector, string[] str)
        {
            for (int i = 0; i < vector.N; i++)
            {
                if (vector[i] > 0)
                {
                    if (vector[i] == 1)
                    {
                        Console.Write("+{1}", vector[i], str[i]);
                    }
                    else
                    {

                    }
                    Console.Write("+{0}*{1}", vector[i], str[i]);
                }
                else if (vector[i] < 0)
                {
                    if (vector[i] == -1)
                    {
                        Console.Write("{1}", vector[i], str[i]);
                    }
                    else
                    {

                    }
                    Console.Write("{0}*{1}", vector[i], str[i]);
                }

            }
            Console.WriteLine();
        }
        static void metriktenzor(Matrix kovar, string[] str)
        {
            //gij=Ri*R^j
            for (int i = 0; i < kovar.N; i++)
            {
                for (int j = 0; j < kovar.M; j++)
                {
              Console.Write("g{0}{1}=R{0}*R{1}=(", i+1, j+1);
                    for (int k = 0; k < kovar.M; k++)
                    {
                        if (kovar[i, k] > 0)
                        {
                            if (kovar[i, k] == 1)
                            {
                                Console.Write("+{1}", kovar[i, k], str[k]);
                            }
                            else
                            {
                                Console.Write("+{0}*{1}", kovar[i, k], str[k]);
                            }

                        }
                        else if (kovar[i, k] < 0)
                        {
                            if (kovar[i, k] == -1)
                            {
                                Console.Write("-{1}", kovar[i, k], str[k]);
                            }
                            else
                            {
                                Console.Write("{0}*{1}", kovar[i, k], str[k]);
                            }
                        }

                    }
             Console.Write(")*(");
                    for (int k = 0; k < kovar.M; k++)
                    {
                        if (kovar[j, k] > 0)
                        {
                            if(kovar[j, k]==1)
                            {
                                Console.Write("+{1}", kovar[j, k], str[k]);
                            }
                            else
                            {
                                Console.Write("+{0}*{1}", kovar[j, k], str[k]);
                            }
                            
                        }
                        else if (kovar[j, k] < 0)
                        {
                            if (kovar[j, k] == -1)
                            {
                                Console.Write("-{1}", kovar[j, k], str[k]);
                            }
                            else
                            {
                                Console.Write("{0}*{1}", kovar[j, k], str[k]);
                            }
                        }

                    }
                Console.WriteLine(")={0}", (new Vector(kovar[i])) * (new Vector(kovar[j])));
                }
            }
        }
    }

    class Matrix
    {
        private double[][] matrix;

        public int N { get; private set; }

        public int M { get; private set; }

        public Matrix D
        {
            get
            {
                Matrix D = new Matrix(N, M);
                for (int i = 0; i < D.N; i++)
                {
                    for (int j = 0; j < D.M; j++)
                    {
                        if (i == j) D[i, j] = this[i, j];
                    }
                }

return D;
            }
        }
        public Matrix E
        {
            get
            {
                Matrix E = new Matrix(N, M);
                E.Fill(0, 1, 0);
                return E;
            }
        }
        public Matrix L
        {
            get
            {
                Matrix L = new Matrix(N, M);
                for (int i = 0; i < L.N; i++)
                {
                    for (int j = 0; j < L.M; j++)
                    {
                        if (i > j) L[i, j] = this[i, j];
                    }
                }
                return L;
            }
        }
        public Matrix R
        {
            get
            {
                Matrix R = new Matrix(N, M);
                for (int i = 0; i < R.N; i++)
                {
                    for (int j = 0; j < R.M; j++)
                    {
                        if (i < j) R[i, j] = this[i, j];
                    }
                }
                return R;
            }
        }
        public Matrix()
        {
            NEW(1, 1);
        }
        public Matrix(double[,] matr)
        {
            NEW(matr.GetLength(0), matr.Length / matr.GetLength(0));
            for (int i = 0; i < N; i++)
            {
                for (int j = 0; j < M; j++)
                {
                    this[i, j] = matr[i, j];
                }
            }
        }
        public Matrix(int n, int m, Random rnd) : this(n, m)
        {
            for (int i = 0; i < N; i++)
            {
                for (int j = 0; j < M; j++)
                {
                    this[i, j] = rnd.Next(0, 9);
                }
            }
        }
        public Matrix(int n, int m)
        {
            NEW(n, m);
            Fill(0, 0, 0);
        }
        public Matrix(string way)
        {
           // matrix = File.ReadAllLines(way).Select(I => I.Split(' ').Select(i => double.Parse(i)).ToArray()).ToArray();
            N = matrix.Length;
            M = matrix[0].Length;
        }
        public Matrix(Matrix obj) : this(obj.N, obj.M)
        {
            for (int i = 0; i < N; i++)
            {
                for (int j = 0; j < M; j++)
                {
                    this[i, j] = obj[i, j];
                }
            }
        }
        public Matrix(params Vector[] obj) : this(obj.Length, obj[0].N)
        {
            for (int i = 0; i < N; i++)
            {
                for (int j = 0; j < M; j++)
                {
                    this[i, j] = obj[i][j];
                }
            }
            //for (int i = 0; i < matrix[0].Length; i++)
            //{
            //    this[0 , i] = obj[i];
            //}
        }
        public static Matrix operator +(Matrix A, Matrix B)
        {
            Matrix _matrix = new Matrix(A.N, A.M);

            for (int i = 0; i < _matrix.N; i++)
            {
                for (int j = 0; j < _matrix.M; j++)
                {
                    _matrix[i, j] = A[i, j] + B[i, j];
                }
            }

            return _matrix;

        }
        public static Matrix operator +(Matrix A, double scalar)
        {
            Matrix _matrix = new Matrix(A.N, A.M);

            for (int i = 0; i < _matrix.N; i++)
            {
                for (int j = 0; j < _matrix.M; j++)
                {
                    _matrix[i, j] = A[i, j] + scalar;
                }
            }
            return _matrix;
        }
        public static Matrix operator ++(Matrix A)
        {

            for (int i = 0; i < A.N; i++)
            {
                for (int j = 0; j < A.M; j++)
                {
                    A[i, j]++;
                }
            }
            return A;
        }
        public static Matrix operator --(Matrix A)
        {

            for (int i = 0; i < A.N; i++)
            {
                for (int j = 0; j < A.M; j++)
                {
                    A[i, j]--;
                }
            }
            return A;
        }
        public static Matrix operator -(Matrix A, Matrix B)

{
            Matrix _matrix = new Matrix(A.N, A.M);
            for (int i = 0; i < _matrix.N; i++)
            {
                for (int j = 0; j < _matrix.M; j++)
                {
                    _matrix[i, j] = A[i, j] - B[i, j];
                }
            }
            return _matrix;
        }
        public static Matrix operator -(Matrix A, double scalar)
        {
            Matrix _matrix = new Matrix(A.N, A.M);

            for (int i = 0; i < _matrix.N; i++)
            {
                for (int j = 0; j < _matrix.M; j++)
                {
                    _matrix[i, j] = A[i, j] - scalar;
                }
            }
            return _matrix;
        }
        public static Matrix operator -(Matrix A)
        {
            Matrix _matrix = new Matrix(A.N, A.M);

            for (int i = 0; i < _matrix.N; i++)
            {
                for (int j = 0; j < _matrix.M; j++)
                {
                    _matrix[i, j] = -A[i, j];
                }
            }
            return _matrix;
        }
        public static Matrix operator *(Matrix A, Matrix B)
        {
            Matrix _matrix = new Matrix(A.N, B.M);

            for (int i = 0; i < _matrix.N; i++)
            {
                for (int j = 0; j < _matrix.M; j++)
                {
                    for (int k = 0; k < B.N; k++)
                    {
                        _matrix[i, j] += A[i, k] * B[k, j];
                    }
                }
            }
            return _matrix;
        }
        public static Matrix operator *(Matrix A, double scalar)
        {
            Matrix _matrix = new Matrix(A.N, A.M);

            for (int i = 0; i < _matrix.N; i++)
            {
                for (int j = 0; j < _matrix.M; j++)
                {
                    _matrix[i, j] = A[i, j] * scalar;
                }
            }
            return _matrix;
        }
        public static Matrix operator /(Matrix A, double scalar)
        {
            Matrix _matrix = new Matrix(A.N, A.M);

            for (int i = 0; i < _matrix.N; i++)
            {
                for (int j = 0; j < _matrix.M; j++)
                {
                    _matrix[i, j] = A[i, j] / scalar;
                }
            }
            return _matrix;
        }
        public static Matrix operator ^(Matrix A, double pow)
        {
            if (pow == -1)
            {

            }
            Matrix _matrix = new Matrix(A.N, A.M);
            _matrix = A;
            for (int i = 1; i < pow; i++)
            {
                _matrix *= A;
            }
            return _matrix;
        }
        public static Matrix operator ~(Matrix A)
        {
            Matrix _matrix = new Matrix(A.M, A.N);
            for (int i = 0; i < _matrix.N; i++)
            {
                for (int j = 0; j < _matrix.M; j++)
                {
                    _matrix[i, j] = A[j, i];
                }
            }
            return _matrix;
        }
        public static bool operator <(Matrix A, Matrix B)
        {
            return A.NormMax() < B.NormMax();
        }
        public static bool operator >(Matrix A, Matrix B)
        {
            return A.NormMax() > B.NormMax();
        }
        public static implicit operator Vector(Matrix matrix)
        {
            Vector vector = new Vector(matrix);
            return vector;
        }
        public static implicit operator Matrix(Vector vector)
        {
            Matrix matrix = new Matrix(vector);
            return matrix;
        }
        public double this[int i, int j]
        {
            get
            {
                if (i >= 0 && i < N && j >= 0 && j < M) return matrix[i][j];
                else return 0;
            }
            set
            {
                if (i >= 0 && i < N && j >= 0 && j < M) matrix[i][j] = value;
            }
        }
        public double[] this[int i]
        {
            get
            {
                if (i >= 0 && i < N) return matrix[i];
                else
                {
                    return new double[0];
                }
            }
            set
            {
                if (i >= 0 && i < N) matrix[i] = value;
            }
        }
        public double NormMax()
        {
            double norm = 0; //використано норму нескінченність Max(сума модулів елементів у рядку)
            double suma = 0;
            for (int i = 0; i < N; i++)
            {
                suma = 0;
                for (int j = 0; j < M; j++)
                {
                    suma += this[i, j];
                }
                if (suma > norm)
                {
                    norm = suma;
                }

            }
            return norm;
        }
        public void Read()
        {
            Console.Write("Enter n= ");
            N = Convert.ToInt32(Console.ReadLine());
            Console.Write("Enter m= ");
            M = Convert.ToInt32(Console.ReadLine());
            Console.WriteLine("Enter matrix: ");
            NEW(N, M);

            
        }
        public void Fill(double lower, double diagonal, double upper)
        {
            for (int i = 0; i < this.N; i++)
            {
                for (int j = 0; j < this.M; j++)
                {
                    if (i > j) this[i, j] = lower;
                    else if (i == j) this[i, j] = diagonal;
                    else if (i < j) this[i, j] = upper;
                    else Console.WriteLine("Error!!!");
                }
            }
        }
        public void NEW(int n, int m)
        {
            N = n;
            M = m;
            matrix = new double[n][];
            for (int i = 0; i < n; i++) matrix[i] = new double[m];
        }
        public override string ToString()
        {
            string result = "";
            for (int i = 0; i < N; i++)
            {
                for (int j = 0; j < M - 1; j++)
                {
                   // result += $"{this[i, j],-8} ";
                }
              //  result += $"{this[i, M - 1]}";
                if (i < N - 1) result += "\n";
            }
            return result;
        }
        public void Print()
        {
            for (int i = 0; i < N; i++)
            {
                for (int j = 0; j < M; j++)
                {
                    Console.Write("{0,-8}", matrix[i][j]);
                }
                Console.WriteLine();
            }
            Console.WriteLine();
        }
        public void Print(Vector A)
        {
            for (int i = 0; i < N; i++)
            {
                for (int j = 0; j < M; j++)
                {
                    Console.Write("{0,-8}", matrix[i][j]);
                }
           //     Console.WriteLine($"{"|",-8}{ A[i],-8}");
            }
            Console.WriteLine();
        }
        public static Vector SLAR(Matrix A, Vector b)
        {

            double c = 0;
            int n = b.N;

            double C;
            int Imax;

            for (int k = 0; k < n - 1; k++)   //лічильник рядків
            {
                Imax = k;    //максимальний елемент в стовпці
                for (int i = k + 1; i < n; i++)           //пошук 
                {
                    if (Math.Abs(A[Imax, k]) < Math.Abs(A[i, k]))
                    {
                        Imax = i;
                    }
                }
                if (A[Imax, k] != 0)
                {
                    if (Imax != k)
                    {
                        for (int i = 0; i < n; i++)
                        {
                            c = A[Imax, i];
                            A[Imax, i] = A[k, i];
                            A[k, i] = c;
                        }
                        c = b[Imax];
                        b[Imax] = b[k];
                        b[k] = c;
                    }
                    for (int i = k + 1; i < n; i++)
                    {
                        C = A[i, k] / A[k, k];

for (int j = 0; j < n; j++)
                        {
                            A[i, j] = A[i, j] - (C * A[k, j]);
                        }
                        b[i] = b[i] - (C * b[k]);
                        A[i, k] = 0;
                    }
                }
            }
            //l.Items.Add(A.Print(b));
            return X(A, b);
        }
        public static Vector X(Matrix A, Vector b)
        {
            int n = b.N;
            Vector X = new Vector(n);

            for (int j = n - 1; j >= 0; j--)
            {
                X[j] = b[j];
                for (int k = n - 1; k > j; k--)
                {
                    X[j] -= A[j, k] * X[k];
                }
                X[j] /= A[j, j];
            }
            //else
            //{
            //    for (int j = 0; j < n; j++)
            //    {
            //        X[j] = b[j];
            //        for (int k = 0; k < j; k++)
            //        {
            //            X[j] -= A[j,k] * X[k];
            //        }
            //        X[j] /= A[j,j];
            //    }
            //}
            return X;
        }
        public static void Swap(ref double a, ref double b)
        {
            double c = a;
            a = b;
            b = c;
        }
    }

    class Vector
    {
        private double[] vector;

        public int N { get; private set; }

        public Vector()
        {
            Console.Write("Enter n= ");
            N = Convert.ToInt32(Console.ReadLine());
            Console.WriteLine("Enter vector: ");
            NEW(N);
           // vector = Console.ReadLine().Split(' ').Select(I => double.Parse(I)).ToArray();
        }
        public Vector(params double[] vect)
        {
            NEW(vect.Length);
            for (int i = 0; i < N; i++)
            {
                this[i] = vect[i];
            }
        }
        public Vector(int n)
        {
            NEW(n);
            Fill(0);
        }
        public Vector(string way)
        {
           // vector = File.ReadAllLines(way)[0].Split(' ').Select(i => double.Parse(i)).ToArray();
            N = vector.Length;
        }
        public Vector(Vector obj) : this(obj.N)
        {
            for (int i = 0; i < N; i++)
            {
                this[i] = obj.vector[i];
            }
        }
        public Vector(Matrix obj) : this(obj.N)
        {
            for (int i = 0; i < vector.Length; i++)
            {
                this[i] = obj[0, i];
            }
        }
        public static Vector operator +(Vector A, Vector B)
        {
            Vector _vector = new Vector(A.N);

            for (int i = 0; i < _vector.N; i++)
            {
                _vector[i] = A[i] + B[i];
            }

            return _vector;

        }
        public static Vector operator +(Vector A, double scalar)
        {
            Vector _vector = new Vector(A.N);

            for (int i = 0; i < _vector.N; i++)
            {
                _vector[i] = A[i] + scalar;
            }

            return _vector;

        }
        public static Vector operator +(Vector A)
        {
            Vector _vector = new Vector(A.N);

            for (int i = 0; i < _vector.N; i++)
            {
                _vector[i] = A[i];
            }
            return _vector;
        }
        public static Vector operator ++(Vector A)
        {
            for (int i = 0; i < A.vector.Length; i++)
            {
                A.vector[i]++;
            }
            return A;
        }
        public static Vector operator --(Vector A)
        {

            for (int i = 0; i < A.N; i++)
            {
                A[i]--;
            }
            return A;
        }
        public static Vector operator -(Vector A, Vector B)
        {
            Vector _vector = new Vector(A.N);

            for (int i = 0; i < _vector.N; i++)
            {
                _vector[i] = A[i] - B[i];
            }
            return _vector;
        }
        
        public static Vector operator -(Vector A)
        {
            Vector _vector = new Vector(A.N);

            for (int i = 0; i < _vector.N; i++)
            {
                _vector[i] = -A[i];
            }
            return _vector;
        }
        public static Vector operator *(Vector A, Matrix B)
        {
            Vector _vector = new Vector(B.N);
            for (int i = 0; i < B.N; i++)
            {
                for (int k = 0; k < A.N; k++)
                {
                    _vector[i] += A[k] * B[i, k];
                }
            }
            return _vector;
        }
        public static double operator *(Vector A, Vector B)
        {
            double scalar = 0;
            for (int i = 0; i < A.N; i++)
            {
                scalar += A[i] * B[i];
            }
            return scalar;
        }
        public static Vector operator *(Vector A, double scalar)
        {
            Vector _vector = new Vector(A.N);

            for (int i = 0; i < _vector.N; i++)
            {
                _vector[i] = A[i] * scalar;
            }
            return _vector;
        }
        public static Vector operator /(Vector A, double scalar)
        {
            Vector _vector = new Vector(A.N);

            for (int i = 0; i < _vector.N; i++)
            {
                _vector[i] = A[i] / scalar;
            }
            return _vector;
        }
        public static Matrix operator ^(Vector A, double pow)
        {
            Matrix _matrix = new Matrix(A.N, 1);
            if (pow == -1)
            {
                for (int i = 0; i < A.N; i++)
                {
                    _matrix[i, 0] = A[i];
                }
            }
            return _matrix;
        }
        public double this[int i]
        {
            get { return vector[i]; }
            set
            {
                vector[i] = value;
            }
        }
        public double Length()
        {
            double length = 0;
            for (int i = 0; i < N; i++)
            {
                length += this[i];
            }
            return Math.Sqrt(length);
        }
        public void Fill(double value)
        {
            for (int i = 0; i < N; i++)
            {
                this[i] = value;
            }
        }
        public void NEW(int n)
        {
            N = n;
            vector = new double[n];
        }
        public void Print()
        {
            for (int i = 0; i < N; i++)
            {
                Console.Write("{0,-8}", this[i]);
            }
            Console.WriteLine("\n");
        }
        public void Print(Matrix A)
        {
            for (int i = 0; i < N; i++)
            {
               // Console.Write($"{ this[i],-8} {"|",-8}");
                for (int j = 0; j < A.N; j++)
                {
             //       Console.Write($"{ A[i, j],-8 }");
                }
                Console.WriteLine();
            }
            Console.WriteLine();
        }
    }
}

​x
 
using System;
//using static System.Console;
namespace MatrixOperations
{
    public class Program
    {
        public static void Main()
        {
            Matrix X = new Matrix(new double[3, 3] { { 1,2,0}, { 0,2,3 }, { 1,0,3} });
            X.Print();
            Matrix kovar = new Matrix(~X);
            Console.WriteLine("Коваріантна база:");
            matrixE(kovar, new string[] { "e1", "e2", "e3" });
           Console.WriteLine();
            Matrix kontravar = new Matrix(Matrix.SLAR(new Matrix(kovar), new Vector(1, 0, 0)), Matrix.SLAR(new Matrix(kovar), new Vector(0, 1, 0)), Matrix.SLAR(new Matrix(kovar), new Vector(0, 0, 1)));
          Console.  WriteLine("контраваріантна база:");
            matrixE(kontravar, new string[] { "e1", "e2", "e3" });
         Console.   WriteLine();
         Console.   WriteLine("метричні елементи:");
            metriktenzor(kovar, new string[] { "e1", "e2", "e3" });
         Console.   WriteLine();
            //matrixE(Matrix.SLAR(X, new Vector(1, 0, 0)), new string[] { "e1", "e2", "e3" });
            //matrixE(Matrix.SLAR(X, new Vector(0, 1, 0)), new string[] { "e1", "e2", "e3" });
            //matrixE(Matrix.SLAR(X, new Vector(0, 0, 1)), new string[] { "e1", "e2", "e3" });
            //MatrixLD LD = new MatrixLD("matrixLD.txt");
            //Console.WriteLine(LD * LD);
​
            //int n, N, M;
            //Random rnd = new Random();
            //Console.Write("Enter n=");
            //n = int.Parse(Console.ReadLine());
            //Matrix[] arrayMatrix = new Matrix[n];
​
            //Console.Write("Enter matrix1.N =");
            //N = int.Parse(Console.ReadLine());
            //for (int i=0; i<n; i++)
            //{
            //    Console.Write("Enter matrix" + (i+1) + ".M =");
            //    M = int.Parse(Console.ReadLine());
            //    arrayMatrix[i] = new Matrix(N, M, rnd);
            //    N = M;
            //}
​
            //Console.WriteLine();
            //for (int i = 0; i < n; i++)
            //{
            //    //File.WriteAllLines("matrixStrassen" + (i + 1) + ".txt", arrayMatrix[i].ToString().Split('\n'));
            //    Console.WriteLine("Matrix" + (i + 1) + "\n" + arrayMatrix[i] + "\n");
            //}
​
            //int operations = 0;
            //Matrix matrix = arrayMatrix[0];
            //for (int i = 1; i < n; i++)
            //{
            //    operations += matrix.N * matrix.M * arrayMatrix[i].M;
            //    matrix *= arrayMatrix[i];
            //}
            //Console.WriteLine(new string('-', 70));
            //Console.WriteLine("Result multiplying all matrices (in order):\n\n" + matrix + "\n");
            //Console.WriteLine("Count operations : " + operations + "\n");
            //Console.WriteLine(new string('-', 70));
            //Console.WriteLine("Result multiplying all matrices (Strassen algorithm):\n");
            //Console.WriteLine(Strassen.AlgorithmStrassen(arrayMatrix) + "\n");
            ////Strassen.AlgorithmStrassen(arrayMatrix);
            
        }
        static void matrixE(Matrix matrix, string [] str)
        {
            for (int i = 0; i < matrix.N; i++)
            {
                for (int j = 0; j < matrix.M; j++)
                {
                    if (matrix[i,j] > 0)
                    {
                        if (matrix[i, j] == 1)
                        {
                            Console.Write("+{1}", matrix[i, j], str[j]);
                        }
                        else
                        {
                            Console.Write("+{0}*{1}", matrix[i, j], str[j]);
                        }
​
                    }
                    else if (matrix[i, j] < 0)
                    {
                        if (matrix[i, j] == -1)
                        {
                            Console.Write("-{1}", matrix[i, j], str[j]);
                        }
                        else
                        {
                            Console.Write("{0}*{1}", matrix[i, j], str[j]);
                        }
                    }
​
                }
                Console.WriteLine();
            }
            Console.WriteLine();
        }
        static void matrixE(Vector vector, string[] str)
        {
            for (int i = 0; i < vector.N; i++)
            {
                if (vector[i] > 0)
                {
                    if (vector[i] == 1)
                    {
                        Console.Write("+{1}", vector[i], str[i]);
                    }
                    else
                    {
​
                    }
                    Console.Write("+{0}*{1}", vector[i], str[i]);
                }
                else if (vector[i] < 0)
                {
                    if (vector[i] == -1)
                    {
                        Console.Write("{1}", vector[i], str[i]);
                    }
                    else
                    {
​
                    }
                    Console.Write("{0}*{1}", vector[i], str[i]);
                }
​
            }
            Console.WriteLine();
        }
        static void metriktenzor(Matrix kovar, string[] str)
        {
            //gij=Ri*R^j
            for (int i = 0; i < kovar.N; i++)
            {
                for (int j = 0; j < kovar.M; j++)
                {
              Console.Write("g{0}{1}=R{0}*R{1}=(", i+1, j+1);
                    for (int k = 0; k < kovar.M; k++)
                    {
                        if (kovar[i, k] > 0)
                        {
                            if (kovar[i, k] == 1)
                            {
                                Console.Write("+{1}", kovar[i, k], str[k]);
                            }
                            else
                            {
                                Console.Write("+{0}*{1}", kovar[i, k], str[k]);
                            }
​
                        }
                        else if (kovar[i, k] < 0)
                        {
                            if (kovar[i, k] == -1)
                            {
                                Console.Write("-{1}", kovar[i, k], str[k]);
                            }
                            else
                            {
                                Console.Write("{0}*{1}", kovar[i, k], str[k]);
                            }
                        }
​
                    }
             Console.Write(")*(");
                    for (int k = 0; k < kovar.M; k++)
                    {
                        if (kovar[j, k] > 0)
                        {
                            if(kovar[j, k]==1)
                            {
                                Console.Write("+{1}", kovar[j, k], str[k]);
                            }
                            else
                            {
                                Console.Write("+{0}*{1}", kovar[j, k], str[k]);
                            }
                            
                        }
                        else if (kovar[j, k] < 0)
                        {
                            if (kovar[j, k] == -1)
                            {
                                Console.Write("-{1}", kovar[j, k], str[k]);
                            }
                            else
                            {
                                Console.Write("{0}*{1}", kovar[j, k], str[k]);
                            }
                        }
​
                    }
                Console.WriteLine(")={0}", (new Vector(kovar[i])) * (new Vector(kovar[j])));
                }
            }
        }
    }
​
    class Matrix
    {
        private double[][] matrix;
​
        public int N { get; private set; }
​
        public int M { get; private set; }
​
        public Matrix D
        {
            get
            {
                Matrix D = new Matrix(N, M);
                for (int i = 0; i < D.N; i++)
                {
                    for (int j = 0; j < D.M; j++)
                    {
                        if (i == j) D[i, j] = this[i, j];
                    }
                }
​
return D;
            }
        }
        public Matrix E
        {
            get
            {
                Matrix E = new Matrix(N, M);
                E.Fill(0, 1, 0);
                return E;
            }
        }
        public Matrix L
        {
            get
            {
                Matrix L = new Matrix(N, M);
                for (int i = 0; i < L.N; i++)
                {
                    for (int j = 0; j < L.M; j++)
                    {
                        if (i > j) L[i, j] = this[i, j];
                    }
                }
                return L;
            }
        }
        public Matrix R
        {
            get
            {
                Matrix R = new Matrix(N, M);
                for (int i = 0; i < R.N; i++)
                {
                    for (int j = 0; j < R.M; j++)
                    {
                        if (i < j) R[i, j] = this[i, j];
                    }
                }
                return R;
            }
        }
        public Matrix()
        {
            NEW(1, 1);
        }
        public Matrix(double[,] matr)
        {
            NEW(matr.GetLength(0), matr.Length / matr.GetLength(0));
            for (int i = 0; i < N; i++)
            {
                for (int j = 0; j < M; j++)
                {
                    this[i, j] = matr[i, j];
                }
            }
        }
        public Matrix(int n, int m, Random rnd) : this(n, m)
        {
            for (int i = 0; i < N; i++)
            {
                for (int j = 0; j < M; j++)
                {
                    this[i, j] = rnd.Next(0, 9);
                }
            }
        }
        public Matrix(int n, int m)
        {
            NEW(n, m);
            Fill(0, 0, 0);
        }
        public Matrix(string way)
        {
           // matrix = File.ReadAllLines(way).Select(I => I.Split(' ').Select(i => double.Parse(i)).ToArray()).ToArray();
            N = matrix.Length;
            M = matrix[0].Length;
        }
        public Matrix(Matrix obj) : this(obj.N, obj.M)
        {
            for (int i = 0; i < N; i++)
            {
                for (int j = 0; j < M; j++)
                {
                    this[i, j] = obj[i, j];
                }
            }
        }
        public Matrix(params Vector[] obj) : this(obj.Length, obj[0].N)
        {
            for (int i = 0; i < N; i++)
            {
                for (int j = 0; j < M; j++)
                {
                    this[i, j] = obj[i][j];
                }
            }
            //for (int i = 0; i < matrix[0].Length; i++)
            //{
            //    this[0 , i] = obj[i];
            //}
        }
        public static Matrix operator +(Matrix A, Matrix B)
        {
            Matrix _matrix = new Matrix(A.N, A.M);
​
            for (int i = 0; i < _matrix.N; i++)
            {
                for (int j = 0; j < _matrix.M; j++)
                {
                    _matrix[i, j] = A[i, j] + B[i, j];
                }
            }
​
            return _matrix;
​
        }
        public static Matrix operator +(Matrix A, double scalar)
        {
            Matrix _matrix = new Matrix(A.N, A.M);
​
            for (int i = 0; i < _matrix.N; i++)
            {
                for (int j = 0; j < _matrix.M; j++)
                {
                    _matrix[i, j] = A[i, j] + scalar;
                }
            }
            return _matrix;
        }
        public static Matrix operator ++(Matrix A)
        {
​
            for (int i = 0; i < A.N; i++)
            {
                for (int j = 0; j < A.M; j++)
                {
                    A[i, j]++;
                }
            }
            return A;
        }
        public static Matrix operator --(Matrix A)
        {
​
            for (int i = 0; i < A.N; i++)
            {
                for (int j = 0; j < A.M; j++)
                {
                    A[i, j]--;
                }
            }
            return A;
        }
        public static Matrix operator -(Matrix A, Matrix B)
​
{
            Matrix _matrix = new Matrix(A.N, A.M);
            for (int i = 0; i < _matrix.N; i++)
            {
                for (int j = 0; j < _matrix.M; j++)
                {
                    _matrix[i, j] = A[i, j] - B[i, j];
                }
            }
            return _matrix;
        }
        public static Matrix operator -(Matrix A, double scalar)
        {
            Matrix _matrix = new Matrix(A.N, A.M);
​
            for (int i = 0; i < _matrix.N; i++)
            {
                for (int j = 0; j < _matrix.M; j++)
                {
                    _matrix[i, j] = A[i, j] - scalar;
                }
            }
            return _matrix;
        }
        public static Matrix operator -(Matrix A)
        {
            Matrix _matrix = new Matrix(A.N, A.M);
​
            for (int i = 0; i < _matrix.N; i++)
            {
                for (int j = 0; j < _matrix.M; j++)
                {
                    _matrix[i, j] = -A[i, j];
                }
            }
            return _matrix;
        }
        public static Matrix operator *(Matrix A, Matrix B)
        {
            Matrix _matrix = new Matrix(A.N, B.M);
​
            for (int i = 0; i < _matrix.N; i++)
            {
                for (int j = 0; j < _matrix.M; j++)
                {
                    for (int k = 0; k < B.N; k++)
                    {
                        _matrix[i, j] += A[i, k] * B[k, j];
                    }
                }
            }
            return _matrix;
        }
        public static Matrix operator *(Matrix A, double scalar)
        {
            Matrix _matrix = new Matrix(A.N, A.M);
​
            for (int i = 0; i < _matrix.N; i++)
            {
                for (int j = 0; j < _matrix.M; j++)
                {
                    _matrix[i, j] = A[i, j] * scalar;
                }
            }
            return _matrix;
        }
        public static Matrix operator /(Matrix A, double scalar)
        {
            Matrix _matrix = new Matrix(A.N, A.M);
​
            for (int i = 0; i < _matrix.N; i++)
            {
                for (int j = 0; j < _matrix.M; j++)
                {
                    _matrix[i, j] = A[i, j] / scalar;
                }
            }
            return _matrix;
        }
        public static Matrix operator ^(Matrix A, double pow)
        {
            if (pow == -1)
            {
​
            }
            Matrix _matrix = new Matrix(A.N, A.M);
            _matrix = A;
            for (int i = 1; i < pow; i++)
            {
                _matrix *= A;
            }
            return _matrix;
        }
        public static Matrix operator ~(Matrix A)
        {
            Matrix _matrix = new Matrix(A.M, A.N);
            for (int i = 0; i < _matrix.N; i++)
            {
                for (int j = 0; j < _matrix.M; j++)
                {
                    _matrix[i, j] = A[j, i];
                }
            }
            return _matrix;
        }
        public static bool operator <(Matrix A, Matrix B)
        {
            return A.NormMax() < B.NormMax();
        }
        public static bool operator >(Matrix A, Matrix B)
        {
            return A.NormMax() > B.NormMax();
        }
        public static implicit operator Vector(Matrix matrix)
        {
            Vector vector = new Vector(matrix);
            return vector;
        }
        public static implicit operator Matrix(Vector vector)
        {
            Matrix matrix = new Matrix(vector);
            return matrix;
        }
        public double this[int i, int j]
        {
            get
            {
                if (i >= 0 && i < N && j >= 0 && j < M) return matrix[i][j];
                else return 0;
            }
            set
            {
                if (i >= 0 && i < N && j >= 0 && j < M) matrix[i][j] = value;
            }
        }
        public double[] this[int i]
        {
            get
            {
                if (i >= 0 && i < N) return matrix[i];
                else
                {
                    return new double[0];
                }
            }
            set
            {
                if (i >= 0 && i < N) matrix[i] = value;
            }
        }
        public double NormMax()
        {
            double norm = 0; //використано норму нескінченність Max(сума модулів елементів у рядку)
            double suma = 0;
            for (int i = 0; i < N; i++)
            {
                suma = 0;
                for (int j = 0; j < M; j++)
                {
                    suma += this[i, j];
                }
                if (suma > norm)
                {
                    norm = suma;
                }
​
            }
            return norm;
        }
        public void Read()
        {
            Console.Write("Enter n= ");
            N = Convert.ToInt32(Console.ReadLine());
            Console.Write("Enter m= ");
            M = Convert.ToInt32(Console.ReadLine());
            Console.WriteLine("Enter matrix: ");
            NEW(N, M);
​
            
        }
        public void Fill(double lower, double diagonal, double upper)
        {
            for (int i = 0; i < this.N; i++)
            {
                for (int j = 0; j < this.M; j++)
                {
                    if (i > j) this[i, j] = lower;
                    else if (i == j) this[i, j] = diagonal;
                    else if (i < j) this[i, j] = upper;
                    else Console.WriteLine("Error!!!");
                }
            }
        }
        public void NEW(int n, int m)
        {
            N = n;
            M = m;
            matrix = new double[n][];
            for (int i = 0; i < n; i++) matrix[i] = new double[m];
        }
        public override string ToString()
        {
            string result = "";
            for (int i = 0; i < N; i++)
            {
                for (int j = 0; j < M - 1; j++)
                {
                   // result += $"{this[i, j],-8} ";
                }
              //  result += $"{this[i, M - 1]}";
                if (i < N - 1) result += "\n";
            }
            return result;
        }
        public void Print()
        {
            for (int i = 0; i < N; i++)
            {
                for (int j = 0; j < M; j++)
                {
                    Console.Write("{0,-8}", matrix[i][j]);
                }
                Console.WriteLine();
            }
            Console.WriteLine();
        }
        public void Print(Vector A)
        {
            for (int i = 0; i < N; i++)
            {
                for (int j = 0; j < M; j++)
                {
                    Console.Write("{0,-8}", matrix[i][j]);
                }
           //     Console.WriteLine($"{"|",-8}{ A[i],-8}");
            }
            Console.WriteLine();
        }
        public static Vector SLAR(Matrix A, Vector b)
        {
​
            double c = 0;
            int n = b.N;
​
            double C;
            int Imax;
​
            for (int k = 0; k < n - 1; k++)   //лічильник рядків
            {
                Imax = k;    //максимальний елемент в стовпці
                for (int i = k + 1; i < n; i++)           //пошук 
                {
                    if (Math.Abs(A[Imax, k]) < Math.Abs(A[i, k]))
                    {
                        Imax = i;
                    }
                }
                if (A[Imax, k] != 0)
                {
                    if (Imax != k)
                    {
                        for (int i = 0; i < n; i++)
                        {
                            c = A[Imax, i];
                            A[Imax, i] = A[k, i];
                            A[k, i] = c;
                        }
                        c = b[Imax];
                        b[Imax] = b[k];
                        b[k] = c;
                    }
                    for (int i = k + 1; i < n; i++)
                    {
                        C = A[i, k] / A[k, k];
​
for (int j = 0; j < n; j++)
                        {
                            A[i, j] = A[i, j] - (C * A[k, j]);
                        }
                        b[i] = b[i] - (C * b[k]);
                        A[i, k] = 0;
                    }
                }
            }
            //l.Items.Add(A.Print(b));
            return X(A, b);
        }
        public static Vector X(Matrix A, Vector b)
        {
            int n = b.N;
            Vector X = new Vector(n);
​
            for (int j = n - 1; j >= 0; j--)
            {
                X[j] = b[j];
                for (int k = n - 1; k > j; k--)
                {
                    X[j] -= A[j, k] * X[k];
                }
                X[j] /= A[j, j];
            }
            //else
            //{
            //    for (int j = 0; j < n; j++)
            //    {
            //        X[j] = b[j];
            //        for (int k = 0; k < j; k++)
            //        {
            //            X[j] -= A[j,k] * X[k];
            //        }
            //        X[j] /= A[j,j];
            //    }
            //}
            return X;
        }
        public static void Swap(ref double a, ref double b)
        {
            double c = a;
            a = b;
            b = c;
        }
    }
​
    class Vector
    {
        private double[] vector;
​
        public int N { get; private set; }
​
        public Vector()
        {
            Console.Write("Enter n= ");
            N = Convert.ToInt32(Console.ReadLine());
            Console.WriteLine("Enter vector: ");
            NEW(N);
           // vector = Console.ReadLine().Split(' ').Select(I => double.Parse(I)).ToArray();
        }
        public Vector(params double[] vect)
        {
            NEW(vect.Length);
            for (int i = 0; i < N; i++)
            {
                this[i] = vect[i];
            }
        }
        public Vector(int n)
        {
            NEW(n);
            Fill(0);
        }
        public Vector(string way)
        {
           // vector = File.ReadAllLines(way)[0].Split(' ').Select(i => double.Parse(i)).ToArray();
            N = vector.Length;
        }
        public Vector(Vector obj) : this(obj.N)
        {
            for (int i = 0; i < N; i++)
            {
                this[i] = obj.vector[i];
            }
        }
        public Vector(Matrix obj) : this(obj.N)
        {
            for (int i = 0; i < vector.Length; i++)
            {
                this[i] = obj[0, i];
            }
        }
        public static Vector operator +(Vector A, Vector B)
        {
            Vector _vector = new Vector(A.N);
​
            for (int i = 0; i < _vector.N; i++)
            {
                _vector[i] = A[i] + B[i];
            }
​
            return _vector;
​
        }
        public static Vector operator +(Vector A, double scalar)
        {
            Vector _vector = new Vector(A.N);
​
            for (int i = 0; i < _vector.N; i++)
            {
                _vector[i] = A[i] + scalar;
            }
​
            return _vector;
​
        }
        public static Vector operator +(Vector A)
        {
            Vector _vector = new Vector(A.N);
​
            for (int i = 0; i < _vector.N; i++)
            {
                _vector[i] = A[i];
            }
            return _vector;
        }
        public static Vector operator ++(Vector A)
        {
            for (int i = 0; i < A.vector.Length; i++)
            {
                A.vector[i]++;
            }
            return A;
        }
        public static Vector operator --(Vector A)
        {
​
            for (int i = 0; i < A.N; i++)
            {
                A[i]--;
            }
            return A;
        }
        public static Vector operator -(Vector A, Vector B)
        {
            Vector _vector = new Vector(A.N);
​
            for (int i = 0; i < _vector.N; i++)
            {
                _vector[i] = A[i] - B[i];
            }
            return _vector;
        }
        
        public static Vector operator -(Vector A)
        {
            Vector _vector = new Vector(A.N);
​
            for (int i = 0; i < _vector.N; i++)
            {
                _vector[i] = -A[i];
            }
            return _vector;
        }
        public static Vector operator *(Vector A, Matrix B)
        {
            Vector _vector = new Vector(B.N);
            for (int i = 0; i < B.N; i++)
            {
                for (int k = 0; k < A.N; k++)
                {
                    _vector[i] += A[k] * B[i, k];
                }
            }
            return _vector;
        }
        public static double operator *(Vector A, Vector B)
        {
            double scalar = 0;
            for (int i = 0; i < A.N; i++)
            {
                scalar += A[i] * B[i];
            }
            return scalar;
        }
        public static Vector operator *(Vector A, double scalar)
        {
            Vector _vector = new Vector(A.N);
​
            for (int i = 0; i < _vector.N; i++)
            {
                _vector[i] = A[i] * scalar;
            }
            return _vector;
        }
        public static Vector operator /(Vector A, double scalar)
        {
            Vector _vector = new Vector(A.N);
​
            for (int i = 0; i < _vector.N; i++)
            {
                _vector[i] = A[i] / scalar;
            }
            return _vector;
        }
        public static Matrix operator ^(Vector A, double pow)
        {
            Matrix _matrix = new Matrix(A.N, 1);
            if (pow == -1)
            {
                for (int i = 0; i < A.N; i++)
                {
                    _matrix[i, 0] = A[i];
                }
            }
            return _matrix;
        }
        public double this[int i]
        {
            get { return vector[i]; }
            set
            {
                vector[i] = value;
            }
        }
        public double Length()
        {
            double length = 0;
            for (int i = 0; i < N; i++)
            {
                length += this[i];
            }
            return Math.Sqrt(length);
        }
        public void Fill(double value)
        {
            for (int i = 0; i < N; i++)
            {
                this[i] = value;
            }
        }
        public void NEW(int n)
        {
            N = n;
            vector = new double[n];
        }
        public void Print()
        {
            for (int i = 0; i < N; i++)
            {
                Console.Write("{0,-8}", this[i]);
            }
            Console.WriteLine("\n");
        }
        public void Print(Matrix A)
        {
            for (int i = 0; i < N; i++)
            {
               // Console.Write($"{ this[i],-8} {"|",-8}");
                for (int j = 0; j < A.N; j++)
                {
             //       Console.Write($"{ A[i, j],-8 }");
                }
                Console.WriteLine();
            }
            Console.WriteLine();
        }
    }
}

Leslie
Celine
Jeong
Paulo
Kimberly

Last Run:	11:01:53 am
Compile:	0.158s
Execute:	0s
Memory:	8kb
CPU:	0.016s

View IL Code