INTRODUCCIÓN
El método de disparo es una técnica utilizada para encontrar soluciones de ecuaciones diferenciales ordinarias con valores en la frontera y se efectúa realizando disparos a ciertas velocidades hasta alcanzar el blanco que se sitúa en la frontera. El problema de valores en la frontera (PVF), estudiado por Bailey & Shampine (), está dado de la forma
Este tipo de ecuaciones tiene soluciones analíticas en algunos casos y en otras se hace más tedioso como en el caso no lineal, pero se puede garantizar soluciones únicas implícitas bajo las condiciones suficientes planteadas y demostradas por Schrader (), Ha () y Keller (). Por su parte, () consideran para análisis del problema (1), el problema de valor inicial (PVI) dada por
con η velocidad de disparo y η
0 = (β-α )/(b-a) velocidad de disparo inicial para la parte numérica. La solución exacta x = x(t, η ) de (2) está garantizada por las condiciones mencionadas anteriormente, que son fundamentales para formular la solución numérica del problema (1). En la formulación, la aproximación numérica busca la velocidad de disparo η de mayor precisión, que satisface la ecuación x(b, η ) -β = 0, y esto garantiza una buena aproximación a la solución exacta de (1) en la frontera t = b. Para encontrar velocidades se puede utilizar técnicas iterativas como: bisección, secante, punto fijo, Newton y otros. El rendimiento de estos métodos es diferente, sin embargo la iteración de Newton clásico (NW) es utilizada por muchos investigadores por su rendimiento y ciertas modificaciones como el de (1969). Para sistema diferencial, () aplicaron la técnica de descomposición adomiana y NW en ambos casos en el método de disparo y obtuvieron buenos resultados. Las iteraciones de Runge Kutta de orden 4 (RK4) y de NW pueden ser acopladas al método disparo en la solución de diferentes problemas como de Dirichlet, Sturm-Liouville, Robin y rotación del eje motor (, ; , ; , ; , ).
En los problemas, es difícil obtener en forma explícita la solución del PVF, por lo que se recurre a métodos numéricos como el de Euler, Diferencias finitas, Runge Kutta y entre otros para aproximar a la solución exacta con alta precisión y también se utiliza para describir el comportamiento cualitativo de ciertos modelos relacionados con las ecuaciones diferenciales. El método RK4, propuesto por (), e iteración de Newton clásico serán aplicados a la ecuación (1), en el estudio conjuntamente con Newton modificadas de orden 3. En la presente investigación, se realizó un experimento numérico con método de disparo utilizando RK4 e iteraciones adaptadas de Newton del mismo orden 3, y es aplicado al PVF no lineal () orden 2, con el propósito de determinar la eficiencia de iteraciones adaptadas en la aproximación del PVF. Para obtener resultados numéricos esperados, se utilizó Python 3 por su mayor uso en la actualidad.
MÉTODOS
En la ecuación (2), se deriva con respecto a η y se evalúa en η = η
k
con (k = 0, . . . , n), se obtiene un nuevo PVI:
donde x
′, denota la derivada con respecto a t.
Considerando
en las ecuaciones 2 y 3 se obtienes las siguientes nuevas ecuaciones
Para obtener solución numérica U
j
= (u
1(t
j
, η
k
), u
2(t
j
, η
k
)), para j≥1, en tiempo t
j
con velocidad de disparo η
k
, se aplicó la tabla moderna de RK4 utilizada por () al sistema (4), como sigue
para F (t,U ) = (u
2, f (t, u
1, u
2)), U = (u
1, u
2) y U
0 = (α, η
0). Utilizando
Con V = (v
1, v
2) y V
0 = (0, 1), se obtiene de forma análoga V
j
= (v
1(t
j
, η
k
), v
2(t
j
, η
k
)) por RK4 aplicado a G(t,V ,U
j
).
Los resultados obtenidos por RK4 permite obtener las siguientes aproximaciones x(t
j
, η
k
) ≈ u
1(t
j
, η
k
), x
′(t
j
, η
k
) ≈ u
2(t
j
, η
k
) y ∂ x ∂η (t
j
, η
k
) ≈ v1(t
j
, η
k
), y estos son utilizados en NW, para determinar una nueva velocidad de disparo s
k
y reformulando nuevamente las ecuaciones (4) y (5) para η
k
= s
k
, se obtiene nuevas aproximaciones u1(b, s
k
) y v1(b, s
k
) para velocidad de disparo s
k
, así sucesivamente hasta lograr aproximación eficiente. Estos valores numéricos obtenidos son asociados a velocidad de disparo η
k
, y el siguiente paso es buscar velocidades de disparo por iteraciones adaptadas propuestas en la investigación. A continuación, presentamos iteraciones adaptadas de orden 3, de dos pasos con el propósito de construir η1, . . . , η
n
, a partir de η0.
La iteración Newton orden 3 (NWO3-1), propuesta por (), y al sustituir por u1(b, η
k
) y u1(b, s
k
) (aproximaciones de x en t = b asociados a las velocidades η
k
y s
k
, respectivamente) y, v1(b, η
k
) y v1(b, s
k
) (son aproximación a ∂ x ∂η (b, η
k
) y ∂ x ∂η (b, s
k
), respectivamente) quedan adaptadas de la siguiente manera:
donde s
k
y η
k+1
son velocidades de disparo de primer y segundo paso, respectivamente.
La otra perspectiva iteración Newton orden 3 (NWO3-2), dada por (), y utilizando las aproximaciones mencionadas en la iteración anterior, tiene la forma adaptada dada por:
donde s
k
y η
k+1
son velocidades de disparo de primer y segundo paso, respectivamente.
() usan la técnica iteración de orden 3 (NWO3-3), y manera similar como los casos anteriores quedan adaptadas las velocidades de disparo de la siguiente manera:
donde s
k
y η
k+1
son velocidades de disparo de primer y segundo paso, respectivamente.
Estas iteraciones son diferentes pero del mismo orden 3, y fueron demostradas con rigurosidad por los autores mencionados y dichas adaptaciones fueron utilizadas para verificar si las velocidades de disparos encontrados son efectivos. Para la presente investigación, se realizó el experimento con las siguientes iteraciones adaptada de NW, NWO3-1, NWO3-2, NWO3-3 y RK4, en la determinación de velocidades de disparo óptimo con la condición de pare
donde tol denota la tolerancia, además se pretende estimar los errores de aproximación a la solución exacta. Asimismo, para la implementación del script del método de disparo se utilizó el diagrama de flujo de la Figura 1 , los paquetes () y (), y se realizó en Python 3, con interfaz Jupyter Notebook.
RESULTADOS Y DISCUSIÓN
El experimento se realizó con la implementación de class Method_diaparo() (ver, apéndices A y B) y los ejemplos:
Ejemplo 1
Considere el problema de valores en la frontera (Filipov et al., 2017):
donde
es solución exacta.
Observe la Tabla 1, los errores de aproximación a la solución exacta en la frontera
generados a diferentes velocidades obtenidas por iteraciones adaptadas. Las iteraciones NWO3-1, NWO3-2 y NWO3-3 se desempeñan con alta precisión que NW. Además, estas iteraciones requieren un promedio 4 o 3 procesos en la estimación; las velocidades finales obtenidas por iteraciones NWO3-2 y NWO3-3 tienen excelentes aproximaciones en la frontera que los demás, como se puede ver en la Figura 2, 1.a), 1.b), 1.c) y 1.d).
Tabla 1 Velocidades de disparo determinados por
, NW, NWO3-1, NWO3-2 y NWO3-3 con velocidad inicial η
0 = 0.18732041, en el Ejemplo 1
Las iteraciones utilizadas en el Ejemplo 1, a diferentes pasos se obtuvieron de forma satisfactoria las velocidades de disparo y así como sus aproximaciones a la solución exacta. Estos resultados pueden ser replicados a pasos más refinados.
3.2 Ejemplo 2
Sea el problema de valores en la frontera que considera Ha (2001):
cuya solución exacta es x(t) = (t
2
+1)/t.
La iteración NWO3-1 no determina velocidades de disparo para 30 y 40 pasos, debido a la divergencia de la velocidad de disparo y los demás, lo cual permitió alcanzar aproximaciones en la frontera con t = 2.5, ver Tablas 2 y 3.
Tabla 2 Velocidades de disparo determinado por |u1(2,ηk)−2.5| < 10−6, NW y NWO3-1, iniciando η0 = 0.5 en el Ejemplo 2
Tabla 3 Velocidades de disparo determinado por |u1(2,ηk)−2.5| < 10−6, NWO3-2 y NWO3-3,, iniciando η0 = 0.5 en el Ejemplo 2
El error mínimo en la frontera para velocidad estimada es 1.01954090×10−9 y se realizó con NWO3-2 y NWO3-3, para N = 40 en el Ejemplo 2 y los demás resultados también son eficaces, pero en menor cantidad de dígitos de precisión ver en las Tablas 2 y 3. Los errores obtenidos por NWO3-1, NWO3-2 y NWO3-3 son menores al resultado obtenido por Ha (2001) y estas iteraciones requieren realizar menor cantidad de operaciones. En la Figura 2, 2.a), 2.b), 2.c) y 2.d), se observan los errores de aproximación a la solución exacta con velocidades estimadas por iteraciones adaptadas. Dentro de los cuales, NWO3-2 y NWO3-3 son precisas en 8 dígitos a la solución exacta en la frontera para N = 20 y N = 40, y en 7 dígitos para N = 10 y N = 30. Sin embargo, las iteraciones NWO3-2 y NWO3-3 son excelentes para aproximar para cualquier paso refinado.
CONCLUSIONES
Las iteraciones NWO3-2, NWO3-3 y RK4 aplicadas al método de disparo son eficientes para aproximar a las soluciones exactas de problemas de valores en la frontera de orden 2. Además, NWO3-1 y NW desempeñan en forma similar y requieren mayor cantidad de procesos que las iteraciones NWO3-2 y NWO3-3.
REFERENCIAS
Ahsan, M., & Farrukh, S. (2013). A new type of shoo- ting method for nonlinear boundary value problems. Alexandria Engineering Journal, 52(4), 801-805. 10.1016/j.aej.2013.07.001
[ Links ]
Attili, B., & Syam, M. (2008). Efficient shooting method for solving two point boundary value problems. Chaos, Solitons and Fractals, 35(5), 895-903. https://doi.org/10.1016/j.chaos.2006.05.094
[ Links ]
Bailey, P., & Shampine, L. (1968). On shooting methods for two-point boundary value problems. Journal of Mathematical Analysis and Applications, 23(2), 235-249. https://doi.org/10.1016/0022-247X(68)90064-4
[ Links ]
Burden, R., Faires, J., & Burden, A. (2017). Análisis Numérico (10th ed.). Cengage Learning.
[ Links ]
Butcher, J. (1996). History of Runge-Kutta methods. Appllied Numerical Mathematics, 20(3), 247-260. https://doi.org/10.1016/0168-9274(95)00108-5
[ Links ]
Darvishi, M., & Barati, A. (2007). A third-order Newton- type method to solve systems of nonlinear equations. Applied Mathematics and Computation, 187(2), 630-635. https://doi.org/10.1016/j.amc.2006.08.080
[ Links ]
Filipov, S., Gospodinov, I., & Faragó, I. (2017). Shooting- projection method for two-point boundary value problems. Applied Mathematics Letters, 72, 10-15. https://doi.org/10.1016/j.aml.2017.04.002
[ Links ]
Granas, A., Guenther, R., & Lee, J. (1979). The Shooting Method for the Numerical Solution of a Class of Nonlinear Boundary Value Problems. SIAM Journal on Numerical Analysis, 16(5), 828-836. https://doi.org/10.1137/0716062
[ Links ]
Ha, S. N. (2001). A nonlinear shooting method for two-point boundary value problems. Computers and Mathematics with Applications, 42(10-11), 1411-1420. https://doi.org/10.1016/S0898-1221(01)00250-4
[ Links ]
Keller, H. B. (2018). Numerical Methods for Two-Point Boundary- Value Problems. Dover Publications.
[ Links ]
Kutta, W. (1901). Beitrag zur näherungsweisen Integration otaler Differentialgleichungen. Zeit. Math. Phys., 46, 435-453.
[ Links ]
Liu, C. (2006). The Lie-group shooting method for non- linear two-point boundary value problems exhibiting multiple solutions. CMES - Computer Modeling in Engineering and Sciences, 13(2), 149-163. https://doi.org/10.3970/cmes.2006.013.149
[ Links ]
Magreñán Ruiz, Á., & Argyros, I. (2014). Two-step Newton methods. Journal of Complexity, 30(4), 533-553. https://doi.org/10.1016/j.jco.2013.10.002
[ Links ]
Mataušek, M. (1974). Direct shooting method, linearization, and nonlinear algebraic equations. Journal of Optimization Theory and Applications, 14(2), 199-212. https://doi.org/10.1007/BF00932940
[ Links ]
NumPy. (2022). NumPy User Guide v1.3. https://numpy.org/doc/1.23/numpy-ref.pdf
[ Links ]
Osborne, M. (1969). On shooting methods for boundary value problems. Journal of Mathematical Analysis and Applications , 27(2), 417-433. https://doi.org/10.1016/0022-247X(69)90059-6
[ Links ]
Schrader, K. (1969). Existence theorems for second order boundary value problems. Journal of Differential Equations, 5(3), 572-584. https://doi.org/10.1016/0022-0396(69)90094-1
[ Links ]
SymPy. (2022). SymPy Documentation. https://github.com/sympy/sympy/releases
[ Links ]
Weerakoon, S., & Fernando, T. (2000). A variant of Newton’s method with accelerated third-order convergence. Applied Mathematics Letters , 13(8), 87-93. https://doi.org/10.1016/S0893-9659(00)00100-2
[ Links ]
BIOGRAFÍAS
/
Alex Youn, Aro Huanacuni
es Magíster en Matemáticas por la Universidad Federal de Río de Janeiro (UFRJ-Brasil) y Licenciado en Ciencias Físico Matemáticas de la Universidad Nacional del Altiplano, Puno. Sus áreas de investigación son la geometría simpléctica, geometría compleja y análisis numérico. Desde 2017, es profesor a tiempo completo en la Universidad Nacional del Altiplano
.
/
Oscar, Santander Mamani
es Licenciado en Ciencias Físico Matemáticas e Ingeniero de Minas de la Universidad Nacional del Altiplano, Puno. Cuenta con el grado de Magíster en Informática con mención en Matemática y Simulación Computacional. Sus áreas de investigación son el análisis complejo, métodos numéricos, geomecánica y SSOMA
.
Apéndice A. Implementación del método de disparo en Python 3:
class Method_disparo(): def init (self,f): self.f=f def RungeKutta_4(self,a,b,u1,u2,N): f_np=lambdify([t,[x,x1]],self.f,modules="numpy") F=lambda t,u:np.array([u[1],f_np(t,[u[0],u[1]])]) f_x=lambdify([t,[x,x1]],f.diff(x),modules="numpy") f_x1=lambdify([t,[x,x1]],f.diff(x1),modules="numpy") G=lambda t,v,u:np.array([v[1],f_x(t,u)*v[0]+f_x1(t,u)*v[1]]) h=(b-a)/N tam=2 u=np.zeros((tam,N+1)) v=np.zeros((tam,N+1)) t1=a+np.arange(N+1)*h k=1 u[0:tam,0]=np.array([u1,u2]) v[0:tam,0]=np.array([0,1]) for i in range(N): K1=h*F(t1[i],u[0:tam,i]) K2=h*F(t1[i]+(1/2)*h,u[0:tam,i]+(1/2)*K1) K3=h*F(t1[i]+(1/2)*h,u[0:tam,i]+(1/2)*K2) K4=h*F(t1[i]+h,u[0:tam,i]+K3) u[0:tam,i+1]=u[0:tam,i]+(1/6)*(K1+2*K2+2*K3+K4) K_1=h*G(t1[i],v[0:tam,i],u[0:tam,i]) K_2=h*G(t1[i]+(1/2)*h,v[0:tam,i]+(1/2)*K_1,u[0:tam,i]) K_3=h*G(t1[i]+(1/2)*h,v[0:tam,i]+(1/2)*K_2,u[0:tam,i]) K_4=h*G(t1[i]+h,v[0:tam,i]+K_3,u[0:tam,i]) v[0:tam,i+1]=v[0:tam,i]+(1/6)*(K_1+2*K_2+2*K_3+K_4) return t1,u,v def Aprox_numeric(self,method,a,b,alpha,beta,N,M,tol): k=1 u1=alpha u2=(beta-alpha)/(b-a) Vacio=np.empty((0, N+1), float) print("="*60) while k<=M: t1,u,v=Method_disparo.RungeKutta_4(self,a,b,u1,u2,N) u_result=np.array([u[0,:]]) X=np.append(Vacio,u_result,axis=0) Vacio=X print("Velocidad %s:{:^15.8f}".format(u2)%(k-1)) if abs(u[0,N]-beta)<=tol: return t1,u[0,:] break else: if method=="Newthon": u2+=-(u[0,N]-beta)/(v[0,N]) elif method=="Newthon3_1": u11=u2-(u[0,N]-beta)/(v[0,N]) t1,u10,v10=Method_disparo.RungeKutta_4(self,a,b,u1,u11,N) u2=u2-2*(u[0,N]-beta)/(v[0,N]+v10[0,N]) elif method=="Newthon3_2": u11=u2-(u[0,N]-beta)/(v[0,N]) t1,u10,v10=Method_disparo.RungeKutta_4(self,a,b,u1,u11,N) u2=u2-(u[0,N]+u10[0,N]-2*beta)/(v[0,N]) elif method=="Newthon3_3": u11=u2-(u[0,N]-beta)/(v[0,N]) t1,u10,v10=Method_disparo.RungeKutta_4(self,a,b,u1,u11,N) u2=u11-(u10[0,N]-beta)/(v[0,N]) k+=1 else: print("No es suficiente",M) class Error(Method_disparo): def init (self,f,g): super(). init (f) self.g=g def error_aprox(self,method,a,b,alpha,beta,N,M,tol): t1,x_1=Method_disparo(f).Aprox_numeric(method,a,b,alpha,beta,N,M,tol) g_np=lambdify(t,g,modules="numpy") x_exact=g_np(t1) return t1,abs(x_1-x_exact)
Apéndice B. Declaración de sentencias.
Ejemplo 1:
import numpy as np from sympy import* t,x,x1=symbols("t x x1") f=-3*(x**2)*x1/t Aprox=Method_disparo(f) Result1=[Aprox.Aprox_numeric("Newthon",1,2,1/np.sqrt(2),2/np.sqrt(5),i,400,1e-6) for i in (10,20,30,40)] Result2=[Aprox.Aprox_numeric("Newthon3_1",1,2,1/np.sqrt(2),2/np.sqrt(5),i,400,1e-6) for i in (10,20,30,40)] Result3=[Aprox.Aprox_numeric("Newthon3_2",1,2,1/np.sqrt(2),2/np.sqrt(5),i,400,1e-6) for i in (10,20,30,40)] Result4=[Aprox.Aprox_numeric("Newthon3_3",1,2,1/np.sqrt(2),2/np.sqrt(5),i,400,1e-6) for i in (10,20,30,40)] Result1, Result2, Result3, Result4 ====================================== t,x,x1=symbols("t x x1") f=-3*(x**2)*x1/t g=t/(t**2+1)**0.5 Result=Error(f,g) Error1=Result.error_aprox("Newthon",1,2,1/np.sqrt(2),2/np.sqrt(5),i,400,1e-6) for i in (10,20,30,40) ] Error2=[Result.error_aprox("Newthon3_1",1,2,1/np.sqrt(2),2/np.sqrt(5),i,400,1e-6) for i in (10,20,30,40) ] Error3=[Result.error_aprox("Newthon3_2",1,2,1/np.sqrt(2),2/np.sqrt(5),i,400,1e-6) for i in (10,20,30,40) ] Error4=[Result.error_aprox("Newthon3_3",1,2,1/np.sqrt(2),2/np.sqrt(5),i,400,1e-6) for i in (10,20,30,40) ] Error1, Error2, Error3, Error4
Ejemplo 2:
from sympy import* import numpy as np t,x,x1=symbols("t x x1") f=2*x**3-6*x-2*t**3 Aprox=Method_disparo(f) Resultado1=[Aprox.Aprox_numeric("Newthon",1,2,2,2.5,k,400e+9,1e-6) for k in (10,20,30,40)] Resultado2=[Aprox.Aprox_numeric("Newthon3_1",1,2,2,2.5,k,400e+9,1e-6) for k in (10,20)] Resultado3=[Aprox.Aprox_numeric("Newthon3_2",1,2,2,2.5,k,400,1e-6) for k in (10,20,30,40)] Resultado4=[Aprox.Aprox_numeric("Newthon3_3",1,2,2,2.5,k,400,1e-6) for k in (10,20,30,40)] ==================================== g=(t**2+1)/t Result=Error(f,g) Errorej1=[Result.error_aprox("Newthon",1,2,2,2.5,k,40000,1e-6) for k in (10,20,30,40)] Errorej2=[Result.error_aprox("Newthon3_1",1,2,2,2.5,k,40000,1e-6) for k in (10,20)] Errorej3=[Result.error_aprox("Newthon3_2",1,2,2,2.5,k,40000,1e-6) for k in (10,20,30,40)] Errorej4=[Result.error_aprox("Newthon3_3",1,2,2,2.5,k,40000,1e-6) for k in (10,20,30,40)] Errorej1,Errorej2,Errorej3, Errorej4