using System;

​

public class Program

{

    public static void Main()

    {

        // Condiciones de frontera

        double x0 = 0.0; // Inicio del intervalo

        double y0 = -3.0; // g(0) = -3

        double xFinal = 5.0; // Final del intervalo

        double yTarget = 10.0; // g(5) = 10

        double h = 0.1; // Tamaño del paso

​

        // Resolver utilizando el método de disparo

        double z0 = ShootingMethod(x0, y0, xFinal, yTarget, h);

​

        if (!double.IsNaN(z0))

        {

            Console.WriteLine("El valor inicial necesario para g'(0) es:" + z0);

        }

        else

        {

            Console.WriteLine("No se encontró una solución dentro del límite de iteraciones.");

        }

    }

​

    // Método de disparo para ajustar z0 (g'(0))

    public static double ShootingMethod(double x0, double y0, double xFinal, double yTarget, double h)

    {

        double zLow = -5.0; // Primer estimado para z(0)

        double zHigh = 5.0; // Segundo estimado para z(0)

        double tolerance = 1e-3; // Tolerancia relajada

        int maxIterations = 100; // Límite de iteraciones

        int iteration = 0;

​

        double yLow = SolveWithRungeKutta(x0, y0, zLow, xFinal, h);

        double yHigh = SolveWithRungeKutta(x0, y0, zHigh, xFinal, h);

​

        // Búsqueda iterativa usando método de bisección

        while (Math.Abs(yHigh - yTarget) > tolerance && iteration < maxIterations)

        {

            double zMid = (zLow + zHigh) / 2.0;

            double yMid = SolveWithRungeKutta(x0, y0, zMid, xFinal, h);

​

            if ((yMid - yTarget) * (yLow - yTarget) < 0)

            {

                zHigh = zMid;

                yHigh = yMid;

            }

            else

            {

                zLow = zMid;

                yLow = yMid;

            }

​

            iteration++;

        }

​

        if (iteration == maxIterations)

        {

            return double.NaN; // No se encontró solución

        }

​

        return (zLow + zHigh) / 2.0;

    }

​

    // Resolver usando Runge-Kutta

    public static double SolveWithRungeKutta(double x0, double y0, double z0, double xFinal, double h)

    {

        double x = x0;

        double y = y0;

        double z = z0;

​

        while (x < xFinal)

        {

            double k1_y = h * FunctionY(x, y, z);

            double k1_z = h * FunctionZ(x, y, z);

​

            double k2_y = h * FunctionY(x + h / 2, y + k1_y / 2, z + k1_z / 2);

            double k2_z = h * FunctionZ(x + h / 2, y + k1_y / 2, z + k1_z / 2);

​

            double k3_y = h * FunctionY(x + h / 2, y + k2_y / 2, z + k2_z / 2);

            double k3_z = h * FunctionZ(x + h / 2, y + k2_y / 2, z + k2_z / 2);

​

            double k4_y = h * FunctionY(x + h, y + k3_y, z + k3_z);

            double k4_z = h * FunctionZ(x + h, y + k3_y, z + k3_z);

​

            y += (k1_y + 2 * k2_y + 2 * k3_y + k4_y) / 6;

            z += (k1_z + 2 * k2_z + 2 * k3_z + k4_z) / 6;

​

            x += h;

        }

​

        return y;

    }

​

    // Función que representa dy/dx = z

    public static double FunctionY(double x, double y, double z)

    {

        return z;

    }

​

    // Función que representa dz/dx = 10 - 4g(x)

    public static double FunctionZ(double x, double y, double z)

    {

        return 10 - 4 * y;

    }

}