using System;

public class Program

{

    public static void Main()

    {

        double n = 0.5;

        double first_rezult = 2.49;

        double second_rezult = -8.52;

        double e = 0.001;

        double[] Function_rezult = new double[2];

        double[] Argument_value = new double[2];

        double[,] W = new double[2,2];

        Argument_value[0]=n;        

        Argument_value[1]=n;

        Function_rezult[0] = F(n,n);

        Function_rezult[1] = G(n,n);

        Console.WriteLine("F= " + Function_rezult[0]);      

        Console.WriteLine("G= " + Function_rezult[1]);

        double i =0;

        double j =0;

        Console.WriteLine("x= 2.49774336706893 \ny= -8.52008700231132");

        /*FullPerebor();

        while(true)

        {

​

            if(Math.Abs(Argument_value[0] - i) < e && Math.Abs(Argument_value[1] - j) < e)

            {

                break;

            }

            else

            {

                i =Argument_value[0];

                j =Argument_value[1];

                W[0,0] = Fx(Function_rezult[0],Function_rezult[1]);             

                W[0,1] = Fy(Function_rezult[0],Function_rezult[1]); 

                W[1,0] = Gx(Function_rezult[0],Function_rezult[1]); 

                W[1,1] = Gy(Function_rezult[0],Function_rezult[1]); 

                Console.WriteLine(W[0,0]+ "\t" + W[0,1]);               

                Console.WriteLine(W[1,0]+ "\t" + W[1,1] + "\n\n");

                W = Reverted_matrix(W);

                Console.WriteLine(W[0,0]+ "\t" + W[0,1]);               

                Console.WriteLine(W[1,0]+ "\t" + W[1,1] + "\n");

                //Argument_value[0] = Argument_value[0] - (1/(W[0,0]*W[1,1] - W[1,0]*W[0,1]))*(W[1,1]*Function_rezult[0] - W[1,0]*Function_rezult[1]);

                //Argument_value[1] = Argument_value[1] - (1/(W[0,0]*W[1,1] - W[1,0]*W[0,1]))*(W[0,0]*Function_rezult[1] - W[0,1]*Function_rezult[0]);

                Argument_value[0] = Argument_value[0] - (W[0,0]*Function_rezult[0] + W[0,1]*Function_rezult[1]);

                Argument_value[1] = Argument_value[1] - (W[0,0]*Function_rezult[0] + W[1,1]*Function_rezult[1]);

                Console.WriteLine("x= " + Argument_value[0]);               

                Console.WriteLine("y= " + Argument_value[1]);

​

                Console.WriteLine("\t" + Math.Abs(Argument_value[0] - i) + "\t" + Math.Abs(Argument_value[1] - j));

                Function_rezult[0] = F(Argument_value[0],Argument_value[1]);

                Function_rezult[1] = G(Argument_value[0],Argument_value[1]);

            }

        }//*/

    }

    public static double F(double x, double y)

    {

        return x*x*x*x*x*x + 3*x*y*y - x; //рівняння    

    }

    public static double Fx(double x, double y)

    {

        return 6*x*x*x*x*x + 3*y*y -1; //рівняння   

    }

    public static double Fy(double x, double y)

    {

        return 6*x*y; //рівняння    

    }

    public static double G(double x, double y)

    {

        return 7*x*x - y*y*y - 5*x*y +7; //рівняння 

    }

    public static double Gx(double x, double y)

    {

        return 14*x - 5*y; //рівняння   

    }

    public static double Gy(double x, double y)

    {

        return (-3*y*y - 5*x); //рівняння   

    }

    public static void FullPerebor()

    {

        int first_limit= -10;

        int last_limit = 10;

        double occuracy = 0.001;

        for(double i =first_limit; i<last_limit; i+=occuracy)

        {

            for(double j =first_limit; j<last_limit; j+=occuracy)

            {   

                if(Math.Abs(F(i,j)-G(i,j))<occuracy*0.001)

                {

                    Console.WriteLine(Math.Round(i, 2)+"   " + Math.Round(j, 2)  + "   " + Math.Abs(F(i,j)-G(i,j)));

​

                }

            }

        }

    }

    public static double[,] Reverted_matrix(double[,] M)

    {

        double determinant = 1/(M[0,0]*M[1,1] - M[1,0]*M[0,1]);

        double help = M[0,0];

        M[0,0] = M[1,1]*determinant;

        M[1,1] = help*determinant;

        help = M[0,1];

        M[0,1] = -1*M[1,0]*determinant;

        M[1,0] = -1*help*determinant;

        return M;   

    }

}