using System;

​

class Program

{

    // Función para hacer la eliminación Gaussiana:

    public static double[] SolEcLin(double[,] matriz)

    {

        int n = matriz.GetLength(0); // Cantidad de filas en la matriz

        int m = matriz.GetLength(1); // Cantidad de columnas en la matriz

        for (int paso = 0; paso < n; paso++)

        {

            // Buscar al primer elemento distinto de cero en esta columna:

            double noCero = matriz[paso, paso];

            int noCeroFila = paso;

            for (int fila = paso; fila < n; fila++)

            {

                if (matriz[fila, paso] != 0)

                {

                    noCero = matriz[fila, paso];

                    noCeroFila = fila;

                    break;

                }

            }

​

            // Intercambiar a la fila "noCeroFila" por la fila actual:

            for (int col = paso; col < m; col++)

            {

                double tmp; // Variable temporal para realizar el intercambio

                tmp = matriz[noCeroFila, col]; // Almacenamos en esta variable el valor de la fila "noCeroFila" para que no se pierda

                matriz[noCeroFila, col] = matriz[paso, col]; // Ponemos el valor de la fila actual en la "noCeroFila"

                matriz[paso, col] = tmp; // El valor almacenado lo ponemos ahora en la fila actual

            }

            // Hacer 1 al elemento de la diagonal en este paso:

            for (int col = paso; col < m; col++)

            {

                //Nota que el valor "noCero" es el de el elemento de la diagonal actualmente

                matriz[paso,col] /= noCero;

            }

​

            // Hacer cero a todos los valores (distintos de la diagonal) en esa columna.

            for (int fila = 0; fila < n; fila++)

            {

                double c = -matriz[fila, paso]; // Coeficiente por el que multiplicaremos a la fila paso para sumársela a la fila actual.

                for (int col = paso; col < m; col++)

                {

                    if (fila != paso)

                    {

                        matriz[fila, col] += c * matriz[paso, col];

                    }

                }

            }

            // Seguimos con el siguiente paso.

        }

​

        // Finalmente almacenamos a las soluciones en un vector.

        double[] solucion = new double[n];

        for (int i = 0; i < n; i++)

        {

            solucion[i] = matriz[i, m-1];

        }

        // Y se devuelve el vector.

        return solucion;

    }

​

    // Funciones a utilizar:

    static double f1(double x, double y)

    {

        return Math.Pow(x,3)+Math.Pow(y,3)-4;

    }

    static double f2(double x, double y)

    {

        return Math.Exp(x)+3*x*y-1;

    }

    static double f1_x(double x, double y)

    {

        return 3*x*x;

    }

    static double f1_y(double x, double y)

    {

        return 3*y*y;

    }

    static double f2_x(double x, double y)

    {

        return Math.Exp(x)+3*y;

    }

    static double f2_y(double x, double y)

    {

        return 3*x;

    }

    static void Main(string[] args)

    {

        double[,] m = new double[2,3];

        double[] s;

        double x0 = 3, y0 = -3;

        double error = 0.0001;

        while(!((f1(x0,y0)*f1(x0+error,y0+error)<0 & f2(x0,y0)*f2(x0+error,y0+error)<0) |

                (f1(x0,y0+error)*f1(x0+error,y0)<0 & f2(x0,y0+error)*f2(x0+error,y0)<0) |

                (f1(x0,y0)*f1(x0+error,y0+error)<0 & f2(x0,y0+error)*f2(x0+error,y0)<0) |

                (f1(x0,y0+error)*f1(x0+error,y0)<0 & f2(x0,y0)*f2(x0+error,y0+error)<0)) )

        {

            m = new double[,] {{f1_x(x0,y0), f1_y(x0,y0), -f1(x0,y0)},

                               {f2_x(x0,y0), f2_y(x0,y0), -f2(x0,y0)}};

            s = SolEcLin(m);

            x0 += s[0];

            y0 += s[1];

        }

        Console.WriteLine($"La solución es:\n x = {x0} -+ {error}\n y = {y0} +- {error}");

        Console.WriteLine("-----------------------------------");

        Console.WriteLine($" f1(x,y) = {f1(x0,y0)} \n f2(x,y) = {f2(x0,y0)}");

    }

}