using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Newton
{
    class Method
    {

        // Единичная матрица
        public double[,] _Fmatrix = new double[,]
            {
                { 1, 0, 0 },
                { 0, 1, 0 },
                { 0, 0, 1 }
            };

        // Копия исходной матрицы
        public double[,] _Smatrix;

        public double[,] _Omatrix;

        public double[,] Amatrix = new double[,]
        {
            { 1,  1,  1 },
            { 2,  1, -4 },
            { 3, -4,  1 }
        };

        public double[] Bmatrix = new double[] 
        {
            1, 0, 0 
        };

        public double[] Tmatrix = new double[]
        {
            0.5, 0.5, 0.5
        };

        public double[,] degree = new double[,] 
        {
            { 2, 2, 2 },
            { 2, 2, 1 },
            { 2, 1, 2 }
        };

        public double[] F_X;
        public double[,] W_X;
        public double[,] n_W_X;

        public double determinant = 0;
        public double E = 0.005;
        public int iteration = 0;

        // Приближенное решение
        public void F_x()
        {
            F_X = new double[Amatrix.GetLength(1)];
            // Заполнить нулями, при ошибке присвоения

            for (int i = 0; i < Amatrix.GetLength(0); i++)
            {
                for (int j = 0; j < Amatrix.GetLength(1); j++)
                {
                    F_X[i] += Amatrix[i, j] * Math.Pow(Tmatrix[j], degree[i, j]);
                }

                F_X[i] -= Bmatrix[i];
            }
        }

        // Получение матрицы Якоби
        public void W_x()
        {
            W_X = new double[Amatrix.GetLength(0), Amatrix.GetLength(1)];

            for (int i = 0; i < Amatrix.GetLength(0); i++)
            {
                for (int j = 0; j < Amatrix.GetLength(1); j++)
                {
                    W_X[i, j] = Amatrix[i, j] * degree[i, j];
                }
            }
        }

        // Получение матрицы Якоби (x2,x3,...,n)
        public void n_W_x()
        {
            n_W_X = new double[W_X.GetLength(0), W_X.GetLength(1)];
            for (int i = 0; i < Amatrix.GetLength(0); i++)
            {
                for (int j = 0; j < Amatrix.GetLength(1); j++)
                {
                    n_W_X[i, j] = W_X[i, j] * Tmatrix[j];
                }
            }
        }

        // Отображение результата
        public void showResult()
        {
            Console.WriteLine("Первоначальная матрица:");
            for (int i = 0; i < Amatrix.GetLength(0); i++)
            {
                for (int j = 0; j < Amatrix.GetLength(1); j++)
                {
                    Console.Write("{0}  ", Amatrix[i, j]);
                }
                Console.WriteLine();
            }

            Console.WriteLine("\n");

            Console.WriteLine("Показатели:");
            foreach (double _data in Bmatrix)
            {
                Console.Write("{0}  ", _data);
            }

            Console.WriteLine();
        }

        // Функция реверса
        public void Swap(int row1, int row2)
        {
            double s = 0;

            for (int i = 0; i < Amatrix.GetLength(0); i++)
            {
                s = Amatrix[row1, i];
                Amatrix[row1, i] = Amatrix[row2, i];
                Amatrix[row2, i] = s;
            }
        }

        // Определение детерминанта
        public void det()
        {
            determinant = 1; // Хранит определитель, который вернёт функция
            int k = 0;
            double E = 1E-9; // Погрешность вычислений

            for (int i = 0; i < Amatrix.GetLength(0); i++)
            {
                k = i;
                for (int j = i + 1; j < Amatrix.GetLength(1); j++)
                    if (Math.Abs(Amatrix[j, i]) > Math.Abs(Amatrix[k, i]))
                        k = j;

                if (Math.Abs(Amatrix[k, i]) < E)
                {
                    determinant = 0;
                    break;
                }
                Swap(i, k);

                if (i != k) determinant *= -1;

                determinant *= Amatrix[i, i];

                for (int j = i + 1; j < Amatrix.GetLength(1); j++)
                    Amatrix[i, j] /= Amatrix[i, i];

                for (int j = 0; j < Amatrix.GetLength(0); j++)
                    if ((j != i) && (Math.Abs(Amatrix[j, i]) > E))
                        for (k = i + 1; k < Amatrix.GetLength(1); k++)
                            Amatrix[j, k] -= Amatrix[i, k] * Amatrix[j, i];
            }
        }

        // Получение копии иходной матрицы для дальнейшей работы с ней
        public void cloneMatrix()
        {
            _Omatrix = new double[Amatrix.GetLength(0), Amatrix.GetLength(1)];

            for (int i = 0; i < Amatrix.GetLength(0); i++)
            {
                for (int j = 0; j < Amatrix.GetLength(1); j++)
                {
                    _Omatrix[i, j] = Amatrix[i, j];
                }
            }

            _Smatrix = new double[_Omatrix.GetLength(0), _Omatrix.GetLength(0)];

            _Smatrix = (double[,])_Omatrix.Clone();
        }

        // Преобразование в нормальный вид
        public void conversion()
        {

            double[] Ostr = new double[_Omatrix.GetLength(0)];
            double[] Fstr = new double[_Omatrix.GetLength(0)];

            try
            {
                for (int p = _Omatrix.GetLength(0) - 1; p >= 0; p--)
                {
                    for (int i = _Omatrix.GetLength(0) - 1; i >= 0; i--)
                    {
                        if (_Omatrix[i, i] == 0)
                        {
                            int k;

                            for (k = _Omatrix.GetLength(0) - 1; k >= 0; k--)
                            {
                                if (_Omatrix[k, i] != 0)
                                {
                                    break;
                                }
                            }

                            for (int j = _Omatrix.GetLength(0) - 1; j >= 0; j--)
                            {
                                Ostr[j] = _Omatrix[i, j];
                                _Omatrix[i, j] = _Omatrix[k, j];
                                _Omatrix[k, j] = Ostr[j];

                                Fstr[j] = _Fmatrix[i, j];
                                _Fmatrix[i, j] = _Fmatrix[k, j];
                                _Fmatrix[k, j] = Fstr[j];
                            }
                        }
                    }
                }
            }
            catch { }
        }

        // Получение обратной матрицы
        public void zeroing()
        {
            for (int j = 0; j < _Omatrix.GetLength(0); j++)
            {
                for (int i = 0; i < _Omatrix.GetLength(0); i++)
                {
                    if (_Omatrix[j, j] != 0)
                    {
                        for (int k = 0; k < _Omatrix.GetLength(0); k++)
                        {
                            _Fmatrix[j, k] /= _Omatrix[j, j];
                        }
                        for (int k = _Omatrix.GetLength(0) - 1; k >= j; k--)
                        {
                            _Omatrix[j, k] /= _Omatrix[j, j];
                        }
                    }

                    if (i != j)
                    {
                        for (int k = 0; k < _Omatrix.GetLength(0); k++)
                        {
                            _Fmatrix[i, k] -= _Omatrix[i, j] * _Fmatrix[j, k];
                        }

                        for (int k = _Omatrix.GetLength(0) - 1; k >= j; k--)
                        {
                            _Omatrix[i, k] -= _Omatrix[i, j] * _Omatrix[j, k];
                        }
                    }
                }
            }

            for (int j = 0; j < _Omatrix.GetLength(0); j++)
            {
                for (int i = 0; i < _Omatrix.GetLength(0); i++)
                {
                    _Fmatrix[i, j] /= determinant;
                }
            }
        }
        
        // Вывод обратной матрицы
        public void showRevers()
        {
            Console.WriteLine("Обратная матрица:");
            for (int i = 0; i < _Fmatrix.GetLength(0); i++)
            {
                for (int j = 0; j < _Fmatrix.GetLength(1); j++)
                {
                    Console.Write(" {0:f6}\t", _Fmatrix[i, j]);
                }
                Console.WriteLine();
            }
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Method method = new Method();
            method.cloneMatrix();

            method.showResult();
            method.F_x();
            method.W_x();
            method.n_W_x();
            
            method.det();

            method.conversion();
            method.zeroing();
            method.showRevers();
            
            Console.WriteLine();

            Console.WriteLine("Determinant: {0} \n", method.determinant);

            Console.WriteLine("F(x):");
            for (int i = 0; i < method.F_X.Length; i++)
            {
                Console.WriteLine("{0}", method.F_X[i]);
            }


            for (int i = 0; i < method.Amatrix.GetLength(0); i++)
            {
                for (int j = 0; j < method.Amatrix.GetLength(1); j++)
                {
                    Console.Write("{0}  ", method.n_W_X[i, j]);
                }
                Console.WriteLine();
            }

            Console.ReadKey();
        }
    }
}