Explicación de ecuaciones diferenciales de segundo grado para su aplicación en métodos numéricos.

1. Dr. Ángel Arturo Rendón Castro
Abril 2024
Métodos Numéricos
Solución de
Ecuaciones
Diferenciales de
2º Orden

3. Las ecuaciones diferenciales
aparecieron por primera vez
en los trabajos de cálculo de
Newton y Leibniz. En 1671, en
el Capítulo 2 de su trabajo
Método de las fluxiones y
series infinitas, Isaac Newton
hizo una lista de tres clases de
ecuaciones diferenciales:

7. T
O
L
y=x
f(x)=x
y=f(x)

8. T
O
L

9. T
O
L
y=f(x)
y´=f(x)=d
y/dx=Dxy

10. T
O
L

11. T
O
L

15. Soluciones de
ecuaciones
diferenciales

17. y´+ y - x² - 2x = 0
Sol.: y = x²
y´ =

18. y´+ y - x² - 2x = 0
Sol.: y = x²
y´ =2x
2x+x²-x²-2x=0
0=0

20. Desarrollado de forma independiente por los
matemáticos alemanes Carl Runge en 1895 y Martin
Wilhelm Kutta en 1901. Su trabajo conjunto culminó en
lo que hoy conocemos como el método de Runge-Kutta,
una técnica que mejora significativamente la precisión
de las soluciones numéricas de las EDOs en
comparación con métodos más antiguos, como el
método de Euler.

24. Ecuaciones Diferenciales de Segundo Orden

31. static void Main(string[] args)
{
double y, yy, yyy, k1, k2, k3, k4, ky1, ky2, ky3, ky4;
double x = 0, paso = 0.01;
y = 1;
yy = 1;
while (x < 2)
{
yyy = -3*yy+10*y+Math.Sin(x);
ky1 = paso*(-3*yy+10*y+Math.Sin(x));
k1 = paso*yy;
ky2 = paso * (-3 * (yy + ky1 / 2) + 10 * (y + k1 / 2)
+ Math.Sin(x + paso / 2));
k2 = paso * (yy + ky1 / 2);
ky3 = paso * (-3 * (yy + ky2 / 2) + 10 * (y + k2 / 2)
+ Math.Sin(x + paso / 2));
k3 = paso*(yy + ky2 / 2);
ky4 = paso * (-3 * (yy + ky3) + 10 * (y + k3) + Math.Sin(x + paso));
k4 = paso * (yy + k3);
y = y + (k1 + 2 * k2 + 2 * k3 + k4)/ 6;
yy = yy + (ky1 + 2 * ky2 + 2 * ky3 + ky4) / 6;
x = x + paso;
}
Console.WriteLine("El valor de y cuando x es " + x + " es " + y);
Console.ReadLine();
}

32. A diferencia de otros métodos este se desarrolló
más como una evolución de ideas en el campo
de la matemática aplicada y la física.
Este enfoque comenzó a ganar popularidad en
la mitad del siglo XX, como una solución
práctica para problemas de valor en la frontera
que eran difíciles de manejar con los métodos
existentes en ese momento.

33. El método del disparo es particularmente útil
para resolver EDOs lineales y no lineales de
segundo orden, pero puede adaptarse para
ordenes superiores. Es ampliamente aplicado
en ingeniería y física, especialmente en
problemas donde las condiciones de la solución
son conocidas en dos o más puntos distintos,
como en el caso de la dinámica de fluidos, la
termodinámica, y en la modelización de
estructuras y materiales.

36. static void Main(string[] args)
{
double y, yy, yyy, k1, k2, k3, k4, ky1, ky2, ky3, ky4;
double criterio, criterio_1, criterio_2;
double yy_1, yy_2, yy_inicial;
double x = 0, paso = 0.001;
double x_final = 10, y_final = 3;
//Valor propuesto
yy_inicial = -10;
yy_1 = yy_inicial;
yy_2 = yy_inicial;
//Runge-Kuta para inicializar los valores
y = 1;
yy = yy_inicial;
x = 0;
while (x < x_final)
{
yyy = -3 * yy + 10 * y + Math.Sin(x);
ky1 = paso * (-3 * yy + 10 * y + Math.Sin(x));
k1 = paso * yy;
ky2 = paso * (-3 * (yy + ky1 / 2) + 10 * (y + k1 / 2)
+ Math.Sin(x + paso / 2));
k2 = paso * (yy + ky1 / 2);
ky3 = paso * (-3 * (yy + ky2 / 2) + 10 * (y + k2 / 2)
+ Math.Sin(x + paso / 2));
k3 = paso * (yy + ky2 / 2);
ky4 = paso * (-3 * (yy + ky3) + 10 * (y + k3) + Math.Sin(x + paso));
k4 = paso * (yy + k3);
y = y + (k1 + 2 * k2 + 2 * k3 + k4) / 6;
yy = yy + (ky1 + 2 * ky2 + 2 * ky3 + ky4) / 6;
x = x + paso;
}
criterio = y_final - y;
criterio_2 = criterio;
//Busqueda de el rango en donde está la raíz
while (criterio*criterio_2 > 0)
{
yy_2 = yy_inicial;
yy_inicial = yy_inicial + 1;
criterio_2 = criterio;
//Runge-Kutta
y = 1;
yy = yy_inicial;
x = 0;
while (x < x_final)
{
yyy = -3 * yy + 10 * y + Math.Sin(x);
ky1 = paso * (-3 * yy + 10 * y + Math.Sin(x));
k1 = paso * yy;
ky2 = paso * (-3 * (yy + ky1 / 2) + 10 * (y + k1 / 2)
+ Math.Sin(x + paso / 2));
k2 = paso * (yy + ky1 / 2);
ky3 = paso * (-3 * (yy + ky2 / 2) + 10 * (y + k2 / 2)
+ Math.Sin(x + paso / 2));
k3 = paso * (yy + ky2 / 2);
ky4 = paso * (-3 * (yy + ky3) + 10 * (y + k3) + Math.Sin(x + paso));
k4 = paso * (yy + k3);
y = y + (k1 + 2 * k2 + 2 * k3 + k4) / 6;
yy = yy + (ky1 + 2 * ky2 + 2 * ky3 + ky4) / 6;
x = x + paso;
}
}
criterio = y_final - y;
}
if (criterio == 0)
{
Console.WriteLine("El valor de la derivada en x=0 es " + yy);
}
yy_1 = yy_inicial;
criterio_1 = criterio;
//Método de bisección
while (Math.Abs(criterio) > 0.00001)
{
yy_inicial = (yy_1 + yy_2) / 2;
//Runge-Kutta
y = 1;
yy = yy_inicial;
x = 0;
while (x < x_final)
{
yyy = -3 * yy + 10 * y + Math.Sin(x);
ky1 = paso * (-3 * yy + 10 * y + Math.Sin(x));
k1 = paso * yy;
ky2 = paso * (-3 * (yy + ky1 / 2) + 10 * (y + k1 / 2)
+ Math.Sin(x + paso / 2));
k2 = paso * (yy + ky1 / 2);
ky3 = paso * (-3 * (yy + ky2 / 2) + 10 * (y + k2 / 2)
+ Math.Sin(x + paso / 2));
k3 = paso * (yy + ky2 / 2);
ky4 = paso * (-3 * (yy + ky3) + 10 * (y + k3) + Math.Sin(x + paso));
k4 = paso * (yy + k3);
y = y + (k1 + 2 * k2 + 2 * k3 + k4) / 6;
yy = yy + (ky1 + 2 * ky2 + 2 * ky3 + ky4) / 6;
x = x + paso;
}
criterio = y_final - y;
if (criterio *criterio_2 < 0)
{
yy_1 = yy_inicial;
criterio_1= criterio;
}
else
{
yy_2 = yy_inicial;
criterio_2 = criterio;
}
}
Console.WriteLine("El valor de la derivada en el inicio es de " + yy_inicial);
Console.ReadLine();
}