using System;
namespace NewtonMethod
{
    class Program
    {
        static double phi1DerivByX(double x, double y)
        {
            // return Math.Sin(x);
            double top, bottom;
            top = (2 - Math.Log(y)) * Math.Cos(x * y) * y;
            bottom = Math.Pow(Math.Sin(x * y), 2);
            return -top / bottom;
        }
        static double phi1DerivByY(double x, double y)
        {
            double top, bottom;
            top = Math.Sin(x * y) + x * y * (-2 + Math.Log(y)) * Math.Cos(x * y);
            bottom = y * Math.Pow(Math.Sin(x * y), 2);
            return -top / bottom;
        }
        static double phi2DerivByX(double x, double y)
        {
            return -Math.Pow(Math.E, x - 3 * y) - x * Math.Pow(Math.E, x - 3 * y);
        }
        static double phi2DerivByY(double x, double y)
        {
            //return Math.Cos(y - 0.5) / 2;
            return 3 * x * Math.Pow(Math.E, x - 3 * y) - 45.0 / (Math.Pow(Math.E, Math.E * y));
        }
        static double func1DerivByX(double x, double y)
        {
            //
            return Math.Sin(x * y) + x * y * Math.Cos(x * y);
        }
        static double func1DerivByY(double x, double y)
        {
            //
            return x * x * Math.Cos(x * y) - 1 / y;
        }
        static double func2DerivByX(double x, double y)
        {
            return Math.Pow(Math.E, x) + x * Math.Pow(Math.E, x);
        }
        static double func2DerivByY(double x, double y)
        {
            return Math.Pow(Math.E, 3*y) + 3 * y * Math.Pow(Math.E, 3*y);
        }
        static double func1(double x, double y)
        {
            // return Math.Cos(x) + y - 1.5;
            return x * Math.Sin(x * y) - Math.Log(y) - 2;
        }
        static double func2(double x, double y)
        {
            //return 2 * x - Math.Sin(y - 0.5) - 1;
            return x * Math.Pow(Math.E, x) + y * Math.Pow(Math.E, 3 * y) - 15;
        }
        static double jacobian(double x, double y)
        {
            double jacobian = 0;
            jacobian += func1DerivByX(x, y) * func2DerivByY(x, y);
            jacobian -= func2DerivByX(x, y) * func1DerivByY(x, y);

            return jacobian;
        }
        static double deltaX(double x, double y)
        {
            double deltaX = 0;
            if (jacobian(x, y) != 0)
            {
                deltaX += func1(x, y) * func2DerivByY(x, y);
                deltaX -= func2(x, y) * func1DerivByY(x, y);
                deltaX /= -jacobian(x, y);
            }
            else
            {
                Console.WriteLine("Jacobian = 0. Delta x can not be calculated!");
                Environment.Exit(1);
            }
            return deltaX;
        }
        static double deltaY(double x, double y)
        {
            double deltaY = 0;
            if (jacobian(x, y) != 0)
            {
                deltaY += func2(x, y) * func1DerivByX(x, y);
                deltaY -= func1(x, y) * func2DerivByX(x, y);
                deltaY /= -jacobian(x, y);
            }
            else
            {
                Console.WriteLine("Jacobian = 0. Delta y can not be calculated!");
                Environment.Exit(1);
            }
            return deltaY;
        }
        static void findRoots()
        {
            double Xn = 1.5;
            double Yn = 0.5;

            double xDif = Math.Abs(phi1DerivByX(Xn, Yn)) + Math.Abs(phi2DerivByX(Xn, Yn));
            double yDif = Math.Abs(phi1DerivByY(Xn, Yn)) + Math.Abs(phi2DerivByY(Xn, Yn));

            if (xDif < 1 && yDif < 1)
            {
                Console.WriteLine("Процес не збіжний");
            }

            double xPrev;
            double yPrev;

            int iteration = 0;
            do
            {
                Console.WriteLine($"Iteration: {iteration:D2} X = {Xn:F4} Y = {Yn:F4}");
                xPrev = Xn;
                yPrev = Yn;

                Xn = xPrev + deltaX(xPrev, yPrev);
                Yn = yPrev + deltaY(xPrev, yPrev);
                iteration++;
            } while (Math.Abs(Xn - xPrev) + Math.Abs(Yn - yPrev) > 0.001);

            Console.WriteLine("\nКоренi:");
            Console.WriteLine($"X = {Xn}");
            Console.WriteLine($"Y = {Yn}");
        }
        static void Main(string[] args)
        {
            findRoots();
        }
    }
}