UNIVERSIDAD ESTATAL DE MILAGRO

FACULTAD CIENCIAS DE LA INGENIERIA

CARRERA: TICS EN LINEA
4to SEMESTRE
TAREA DE INVESTIGACIÓN 2

INTEGRANTES:
PABLO QUIMI TOALA
LAURO RODRÍGUEZ ENRÍQUEZ
CHRISTIAN XAVIER HURTADO GUNCAY
CARMEN YESSENIA MEDINA AVILA

ASIGNATURA:
MÉTODOS NUMÉRICOS

DOCENTE:
CASTILLO HEREDIA LUIS JAVIER

PERÍODO:
Mayo 2022 a Septiembre 2022

MILAGRO – ECUADOR
RESUMEN
La presente investigación busca la aplicación de los métodos numéricos en cualquier rama
de la ingeniería, específicamente haciendo énfasis en la solución de raíces de ecuaciones
e integración numérica, tomando en consideración que son aproximaciones que brindan
una solución matemática por ejemplo para calcular el área de un integral, de la misma
manera se busca la solución de ecuaciones diferenciales ordinarias, tomando en
consideración los procesos matemáticos de diferenciación numérica.
Se tomó en consideración los métodos de punto fijo, bisección, trapecio, reglas de
1 3
Simpson 3 𝑦 para los procesos de integración, el método de Euler para la solución de
8
ecuaciones diferenciales ordinarias de primer orden y el proceso de Richardson para la
diferenciación numérica.
INTRODUCCIÓN Cada de los procesos utilizados serán
aproximaciones que buscan encontrar la
Los métodos numéricos son aplicaciones
solución del valor del área de un integral,
de algoritmos por las cuales es posible
así el valor de un punto en una función
formular y solucionar problemas
derivable, se plantea igualmente la
matemáticos usando operaciones
solución de ecuaciones diferenciales.
aritméticas menos complejas. Ellos
también se conocen como métodos
indirectos. El análisis numérico idealiza
I. MODELAMIENTO
y concibe métodos para «aprobar» de
MATEMÁTICO
forma eficiente las soluciones de
problemas expresados
matemáticamente. El objetivo principal
del análisis numérico es encontrar Uno de los problemas más antiguos, y
soluciones «aproximadas» para que con mayor frecuencia se debe
problemas complejos. resolver en

Aunque el análisis numérico se haya matemáticas puras y aplicadas, consiste

concebido antes de las computadoras, en encontrar ceros de funciones, es decir,
comúnmente el tema está relacionado a para
una interdisciplinariedad entre la una función f(x) dada, encontrar un valor
matemática y la información. También c tal que f(c) = 0. En los cursos de cálculo
es muy citado en la disciplina de cálculo el
numérico.
procedimiento estándar para resolver
(Eduardo Araujo, 2017) esta situación es despejar la incógnita.
Los Métodos Numéricos nos vuelven (Diego Arévalo Ovalle, 2021)
aptos para entender esquemas numéricos
a fin de resolver problemas matemáticos,
de ingeniería y científicos en una Por ejemplo:
computadora, reducir esquemas
numéricos básicos, escribir programas y 𝑓(𝑥)
resolverlos en una computadora, usar = 3𝑥 − 3 𝑖𝑔𝑢𝑎𝑙𝑎𝑚𝑜𝑠 𝑎 0
correctamente el software existente para 3𝑥 − 3
dichos métodos y no solo aumenta =0 𝑑𝑒𝑠𝑝𝑒𝑗𝑎𝑚𝑜𝑠
nuestra habilidad para el uso de
computadoras sino que también amplia 3𝑥
la pericia matemática y la comprensión =3 𝑑𝑒𝑠𝑝𝑒𝑗𝑎𝑚𝑜𝑠
de los principios científicos básicos,
3
indican como los Métodos Numéricos 𝑥=
3
producen aproximaciones lo
suficientemente exactas con un mínimo 𝒙=𝟏
de esfuerzo.
El valor de 1 satisface la función para
(Ospina, 2015) obtener como resultado el valor de 0.
𝑓(𝑥) Encuentre una aproximación a una raíz
= 𝑥2 − 𝑥 real de la ecuación
−6 𝑖𝑔𝑢𝑎𝑙𝑎𝑚𝑜𝑠 𝑎 0
𝑒 𝑥 – 2𝑥 2 = 0
𝑥2 − 𝑥 − 6
Programa hecho en Pyhton con el
=0 𝑚𝑢𝑙𝑡𝑖𝑝𝑙𝑖𝑐𝑎𝑑𝑜𝑠
compilador Cuaderno de Jupyter.
− 6 𝑦 𝑠𝑢𝑚𝑎𝑑𝑜𝑠 − 1
import numpy as np
(𝑥 − 3)(𝑥 + 2) =
0 𝑙𝑜𝑠 𝑣𝑎𝑙𝑜𝑟𝑒𝑠 𝑑𝑒 − import matplotlib.pyplot as plt
3 𝑦 2 𝑠𝑎𝑡𝑖𝑠𝑓𝑎𝑐𝑒𝑛 𝑙𝑎𝑠 𝑜𝑝𝑒𝑟𝑎𝑐𝑖𝑜𝑛𝑒𝑠
𝑥1 − 3 = 0
def puntofijo(gx,a,tolera, iteramax = 15):
𝒙𝟏 = 𝟑 i = 1 # iteración
𝑥2 + 2 = 0 b = gx(a)
𝒙𝟐 = −𝟐 tramo = abs(b-a)
3 y -2, satisfacen la función para obtener while(tramo>=tolera and i<=iteramax
como resultado el valor de 0. ):
Método de punto fijo a=b
Una de las aplicaciones importantes del b = gx(a)
teorema de punto fijo de Banach es la de
resolver sistemas de ecuaciones lineales tramo = abs(b-a)
algebraicas proporcionando condiciones
i=i+1
suficientes para la convergencia.
(Cárdenas, 2008) respuesta = b
𝑓(𝑥) = 𝑥 – 𝑔(𝑥)
El proceso es muy sencillo, el resultado # Validar respuesta
se usa en la siguiente iteración.
if (i>=iteramax ):
respuesta = np.nan
return(respuesta)

# PROGRAMA ---------

# INGRESO
fx = lambda x: np.exp(-x) - 2*x**2
gx = lambda x: np.exp(-x)
(Cárdenas, 2008)

a=0 # intervalo
b=1
tolera = 0.001
iteramax = 15 # itera máximo
muestras = 51 # gráfico
tramos = 50

# PROCEDIMIENTO
respuesta = puntofijo(gx,a,tolera)

# SALIDA
print("La aproximación es: ",respuesta) La aproximación es: 0.56691

# GRAFICA
# calcula los puntos para fx y gx
xi = np.linspace(a,b,muestras)
fi = fx(xi)
gi = gx(xi)
yi = xi

import matplotlib.pyplot as plt

plt.plot(xi,fi, label='f(x)')
plt.plot(xi,gi, label='g(x)')
plt.plot(xi,yi, label='y=x')
(Edison del Rosario, 2017)
 𝑆𝑒 𝑟𝑒𝑒𝑚𝑝𝑙𝑎𝑧𝑎 𝑒𝑛 𝑙𝑎 𝑓𝑢𝑛𝑐𝑖ó𝑛 𝑓(1,5)
= −2,42
Método de Bisección
(Nieves Hurtado, 2014)
Dependiendo de la función que se tenga
en particular, el método de la bisección Por el método de bisección obtenga su
puede converger ligeramente más rápido raíz de la función f(x) =x3 + 4x2 − 10
o más lento que el método de posición
Programa fuente en Python usando
falsa. Su gran ventaja sobre el de
compilador Cuaderno de Jupyter.
posición falsa es que proporciona el
tamaño exacto del intervalo en cada import sympy as sp
iteración (en ausencia de errores de
redondeo). import pandas as pd

(Nieves Hurtado, 2014) import numpy as np

El método de la bisección es muy similar import matplotlib.pyplot as plt

al de posición falsa, aunque algo más
simple. Como en el de posición falsa, en
este método también se requieren dos x=sp.symbols('x') #declaramos que x es
valores iniciales para ambos lados de la un simbolo
raíz, y que sus valores funcionales func=x**3+4*x**2-10 #funcion que
correspondientes sean de signos evaluaremos
opuestos.
def Bisec(func,xl,xu,es):
En este caso, el valor de xM se obtiene
como el punto medio entre xI y xD itera=0

(𝑥𝑙 + 𝑥𝐷 ) m_itera=np.array([]) #matriz q

𝑥𝑀 = almacena valores de itera
2
Para saber el número de iteraciones se m_xl=np.array([]) #matriz q
usa: alamacena valores de xl

ln(𝑎) − ln(𝑒) m_xu=np.array([]) #matriz q

𝑛= alamcena valores de xu
ln(2)
Se tiene la función xr=0

𝑓 (𝑥) = 𝑥 3 + 2𝑥 2 m_xr=np.array([]) #matriz q

+ 10𝑥 – 20 𝑒𝑛𝑡𝑟𝑒 1 𝑦 2 almacena valroes de xr

n = 10, buscamos cada punto intermedio ea=100

1+2 m_ea=np.array([]) #matriz q

𝑥𝑀 = = 1,5 alamcena valore s de ea
2
𝑆𝑒 𝑟𝑒𝑒𝑚𝑝𝑙𝑎𝑧𝑎 𝑒𝑛 𝑙𝑎 𝑓𝑢𝑛𝑐𝑖ó𝑛 𝑓(1,5) fl=func.evalf(subs={x: xl})
= 2,88 #reamplazmos x por xl y evaluamos la
funcion
Siguiente iteración
while ea>es :
1 + 1,5
𝑥𝑀 = = 1,25
2
 xanterior=xr print("\nEl resultado es:
",round(xr[12],5))
xr=(xl+xu)/2
plt.plot(xd, xr, c='r', lw = 2)
fr=func.evalf(subs={x:xr})
plt.show()
itera=itera+1
return tabla
if xr != 0:
a=Bisec(func,1,2,0.01)
ea=abs((xr-xanterior)/xr)*100
x = np.linspace(1, 2, 12)
test=fl*fr
(Diego Arévalo Ovalle, 2021)
m_itera=np.append(m_itera,itera)
m_xl=np.append(m_xl,xl)
m_xu=np.append(m_xu,xu)
m_xr=np.append(m_xr,xr)
m_ea=np.append(m_ea,ea)

if test < 0 :
xu=xr
elif test >0:
xl=xr
fl=fr
else:
ea=0

iteracion=pd.Series(m_itera,name="Iter
acion")
xl=pd.Series(m_xl,name="xl")
xu=pd.Series(m_xu,name="xu")
xr=pd.Series(m_xr,name="xr")
ea=pd.Series(m_ea,name="ea%")

tabla=pd.concat([iteracion,xl,xu,xr,ea],a
xis=1) #unimos en columnas
xd = np.linspace(1, 2, 13)
Método del trapecio o regla del Programa en Python usando el
trapecio compilador Cuaderno de Jupyter.
La regla del trapecio o regla trapezoidal # Integración: Regla de los trapecios
es una de las fórmulas cerradas de
# Usando una función fx()
Newton-Cotes.
import os
Por lo tanto, tenemos que:
𝒃 import numpy as np
𝒇(𝒂) + 𝒇(𝒃)
∫ 𝒇(𝒙) 𝒅𝒙 = (𝒃 − 𝒂) [ ] import matplotlib.pyplot as plt
𝟐
𝒂
# INGRESO
(Vasquez, 2009)
fx = lambda x: np.sin(x)*np.cos(x)
Tanto la regla de Simpson como la regla
# intervalo de integración
del trapecio pueden usarse si sólo
conocemos f(a), f(a+h), etc.; no tenemos a=1
que conocer f.
b=3
(Haeussler, 2003)
tramos = 4
El resultado de la integración:
# Regla del Trapecio
𝑓(𝑎) + 2𝑓(ℎ) + 𝑓(𝑏)
𝐼 = (𝑏 − 𝑎) h = (b-a)/tramos
2
(Chapra, 2007) xi = a

Por ejemplo: suma = fx(xi)

f(x) = 0.2 + 25x – 200x2 + 675x3 – 900x4 print("interaciciones"," ","valor")

+ 400x5 entre 0 y 0.8, h = 0.4 for i in range(0,tramos-1,1):
𝑓(0) = 0.2 xi = xi + h
𝑓(0.4) = 2.456 suma = suma + 2*fx(xi)
𝑓(0.8) = 0.232 print(i+1," ",h*(suma+fx(b))/2)
𝑓(𝑎) + 2𝑓(ℎ) + 𝑓(𝑏)
𝐼 = (𝑏 − 𝑎)
2
suma = suma + fx(b)
0.2 + 2(2.456) + 0.232
𝐼 = (0.8 − 0) area = h*(suma/2)
2
𝑰 = 𝟏. 𝟎𝟔𝟖𝟖
(Chapra, 2007) # SALIDA
print('tramos: ', tramos)

Obtenga el área de la integral print('Integral: ', round(area,5))

𝟑
∫𝟏 𝒔𝒆𝒏(𝒙)𝒄𝒐𝒔(𝒙) 𝒅𝒙 os.system("pause")
 𝑓(0.4) = 2.456
𝑓(0.8) = 0.232
0.2 + 2(2.456) + 0.232
𝐼 = (0.8 − 0)
6
𝑰 = 𝟏. 𝟑𝟔𝟕𝟒𝟔𝟕
(Chapra, 2007)

Programa hecho en Python usando el

compilador Cuaderno de Jupyter
import os
import numpy as np
import matplotlib.pyplot as plt
from math import *

def simpson13(n, a, b, f):

h = (b - a) / n
𝟏
Regla de Simpson 𝟑 suma = 0.0
La Regla de Simpson de 1/3 proporciona for i in range(1, n):
una aproximación más precisa, ya que
x=a+i*h
consiste en conectar grupos sucesivos de
tres puntos sobre la curva mediante if(i % 2 == 0):
parábolas de segundo grado, y sumar las
suma = suma + 2 * fx(x, f)
áreas bajo las parábolas para obtener el
área aproximada bajo la curva. else:
(Vasquez, 2009) suma = suma + 4 * fx(x, f)
print(i," ",(suma + fx(a, f) +
fx(b, f))* (h / 3))

Ilustración 1 vy[i-1]=(suma + fx(a, f) + fx(b, f))*

Tomado de: (h / 3)
https://sites.google.com/site/tasksnumericalmethods/_/rsrc/14687
44336782/unidad-4---diferenciacion-e-integracion-
numericas/metodo-de-simpson-1-3/21.png

suma = suma + fx(a, f) + fx(b, f)

Por ejemplo:
rest = suma * (h / 3)
f(x) = 0.2 + 25x – 200x2 + 675x3 – 900x4
+ 400x5 entre 0 y 0.8 return (rest)

𝑓(0) = 0.2
def fx(x, f):
return eval(f)

n = 20
a = -1.0
b = 3.0
f = 'sin(x)*e*e'

vx = np.linspace(-1, 3, 20)
vy = np.zeros(20)
print("iteracciones"," ","valores")
res=simpson13(n, a, b, f)
print("El resultado es: ",round(res,5))
plt.plot(vx, vy, c='r', lw = 2)
plt.show()
os.system("pause")
(Rodrigo Gómez, 2014)

𝟑
Regla de Simpson 𝟖

La regla de 3/8 de Simpson se obtiene a!

integrar una fórmula de interpolación
polinomial de tercer grado. Para un
dominio [a, b] dividido en tres intervalos,
se escribe como:

Ilustración 2
Tomado de:
https://sites.google.com/site/tasksnumericalmethods/_/rsrc/1468744337009/unid
ad-4---diferenciacion-e-integracion-numericas/metodo-de-simpson-3-8/25.png
 for i in range(1, interval_limit ):
f(x) = 0.2 + 25x – 200x2 + 675x3 – 900x4 if (i % 3 == 0):
+ 400x5
sum = sum + 2 *
𝑑𝑒𝑠𝑑𝑒 𝑎 = 0 ℎ𝑎𝑠𝑡𝑎 𝑏 = 0.8. func(lower_limit + i * interval_size)
𝑛 = 4 (ℎ = 0.2) else:
𝑓(0) = 0.2 sum = sum + 3 *
func(lower_limit + i * interval_size)
𝑓(0.2) = 1.288
vy[i-1] = ((float( 3 * interval_size) /
𝑓(0.4) = 2.456 8 ) * sum )
𝑓(0.6) = 3.464 print(i," ",(float( 3 *
𝑓(0.8) = 0.232 interval_size) / 8 ) * sum )

𝐼
= (0.8 return ((float( 3 * interval_size) / 8 ) *
0.2 + 4(1.288 + 3.464) + 2(3.464) + 0.232
sum )
− 0)
12
𝑰 = 𝟏. 𝟔𝟐𝟑𝟒𝟔𝟕
interval_limit = 20
(Chapra, 2007)
lower_limit = 1
Obtenga la integral de la función 𝑓(𝑥) =
cos(𝑥) upper_limit = 5
1+𝑥 2

Programa hecho en Python usando el

compilador Cuaderno de Jupyter vx = np.linspace(1, 5, 20)

import os vy = np.zeros(50)

import matplotlib.pyplot as plt print("iteraciones"," ","valor")

import numpy as np integral_res = calculate(lower_limit,

upper_limit, interval_limit)
import math
def func(x):
print ("El área es: ",round(integral_res,
return (float(math.cos(x)) / ( 1 + x * x 5))
))

plt.plot(vx, vy, c='r', lw = 2)

def calculate(lower_limit, upper_limit,
interval_limit ): plt.show()

interval_size = (float(upper_limit -
lower_limit) / interval_limit)
os.system("pause")
sum = func(lower_limit) +
(Edison del Rosario, 2017)
func(upper_limit);
El resultado es: -0.139899 Calcule la raíz de f(x) =e–x – x. Comience
con los valores iniciales x–1 = 0 y x0 =
1.0.
Primera iteración:
x–1 = 0
f (x–1) = 1.00000
x0 = 1
f (x0) = –0.63212
−0.63212(0 − 1)
𝑥1 = 1 −
1 − (−0.63212)
= 𝟎. 𝟔𝟏𝟐𝟕𝟎
Segunda iteración:
x0 = 1
f (x0) = –0.63212
x1 = 0.61270
f (x1) = –0.07081
𝑥2
−0.07081(1 − 0.61270)
= 0.61270 −
−0.63212 − (0.07081)
= 𝟎. 𝟓𝟔𝟑𝟖𝟒
(Chapra, 2007)
Programa hecho en Python usando el
compilador Cuaderno de Jupyter
import numpy as np
El método de la secante
import matplotlib.pyplot as plt
En el método de la secante el modelo
aproximado análogo al miembro derecho
de la ecuación igualado a cero es def secante_tabla(fx,xa,tolera):
donde m es la pendiente de la línea que dx = 4*tolera
conecta el punto xk y un segundo punto
xq, dada por: xb = xa + dx
tramo = dx
tabla = []

(Hammelbaul, 1997) while (tramo>=tolera):

fa = fx(xa)
 fb = fx(xb)
xc = xa - fa*(xb-xa)/(fb-fa)
tramo = abs(xc-xa) # Calcula los puntos a graficar
xi = np.linspace(a,b,tramos+1)
tabla.append([xa,xb,xc,tramo]) fi = fx(xi)
xb = xa dx = (b-xa)/2
xa = xc pendiente = (fx(xa+dx)-fx(xa))/(xa+dx-
xa)
b0 = fx(xa) - pendiente*xa
tabla = np.array(tabla)
tangentei = pendiente*xi+b0
return(tabla)

fxa = fx(xa)
fx = lambda x: 6*x**3 / (x**3 + 1)
xb = xa + dx
fxb = fx(xb)
a =1
b =2
plt.plot(xi,fi, label='f(x)')
xa = 1.5
tolera = 0.001
plt.plot(xi,tangentei, label='secante')
tramos = 100
plt.plot(xa,fx(xa),'go', label='xa')
plt.plot(xa+dx,fx(xa+dx),'ro', label='xb')
# PROCEDIMIENTO
plt.plot((-b0/pendiente),0,'yo',
tabla = secante_tabla(fx,xa,tolera)
label='xc')
n = len(tabla)
raiz = tabla[n-1,2]
plt.plot([xa,xa],[0,fxa],'m')
plt.plot([xb,xb],[0,fxb],'m')
# SALIDA
np.set_printoptions(precision=4)
plt.axhline(0, color='k')
print('[xa ,\t xb , \t xc , \t tramo]')
plt.title('Método de la Secante')
for i in range(0,n,1):
plt.legend()
print(tabla[i])
plt.grid()
print('raiz en: ', raiz)
plt.show()
(Edison del Rosario, 2017)

El resultado es: 0,002989

Diferenciación numérica de funciones
Una vez que se ha determinado un
polinomio pn(x)* de manera que
aproxime satisfactoriamente una función
dada f (x) sobre un intervalo de interés,
puede esperarse que al diferenciar pn(x)
o integrarla en forma definida, también
aproxime satisfactoriamente la derivada
o la integral definida correspondientes a
f (x). No obstante, si se observa la figura
6.2 —donde aparece la gráfica de un
polinomio pn(x) que aproxima la curva
que representa la función f (x)— puede
anticiparse que, aunque la desviación de
pn(x) y f (x) en el intervalo [x0, xn] es
pequeña, las pendientes de las curvas que
las representan pueden diferir
considerablemente; esto es, la
diferenciación numérica tiende a ampliar
pequeñas discrepancias o errores del
polinomio de aproximación.
(Nieves Hurtado, 2014)
Métodos de Newton-Cotes
𝑏
Para estimar 𝐼 = ∫𝑎 𝑓(𝑥), los métodos
de Newton-Cotes funcionan, en general,
en dos pasos:
1. Se divide el intervalo [a, b] en n def dercentrada(f, x, h):
intervalos de igual amplitud, cuyos
return (f(x + h) - f(x - h))/(2*h)
valores extremos son sucesivamente
𝑏−𝑎
𝑥𝑖 = 𝑥0 + 𝑖 ( )
𝑛 def richardson(f, x, h):
Para quedar en la nueva notación x0 = a d = (4/3)*dercentrada(f, x, h/2)-
y xn = b. (1/3)*dercentrada(f, x, h)
2. Se aproxima f (x) por un polinomio return d
pn(x) de grado n, y se integra para
obtener la aproximación de I.
Método trapezoidal x = 1.4

En el caso de n = 1, el intervalo de h = 0.4

integración [a, b] queda tal cual y x0 = a, print("Valor de la Derivada función
x1 = b; la aproximación polinomial de f es:","{0:.6f}".format(richardson(pol, x,
(x) es una línea recta (un polinomio de h)),"en el punto 1.4")
primer grado p1(x)) y la aproximación a
la integral es el área de trapezoide bajo dato=richardson(pol, x, h)
esta línea recta. os.system("pause")

(Nieves Hurtado, 2014)

Por Richardson aproxime la función
1
𝑓(𝑥) = 2 𝑥 3 + 6𝑥 2

Programa hecho en Python compilador

Cuaderno de Jupyter
from math import *
Valor de la Derivada función es:
import sympy as sp
19.740000 en el punto 1.4, es similar a la
import os calculadora symbolab.

def pol(x):
return (1/2)*pow(x,3) + 6*pow(x,2)
 En cualquier proceso natural, las
variables incluidas y sus velocidades de
cambio se relacionan entre sí mediante
los principios científicos que gobiernan
el proceso. El resultado de expresar en
símbolos matemáticos estas relaciones
es a menudo una ecuación diferencial.
(Nieves Hurtado, 2014)
Programa en Python compilador
Cuaderno de Jupyter
from math import *

def test1(t, y):

return y - t**2 + 1 # y0 = y − t2 + 1

def test2(t, y):

return 2 - exp(-4*t) - 2*y # y0 = 2 −
e−4t − 2y

def Euler(a, b, y0, f, N):

Ecuaciones diferenciales ordinarias h = (b - a)/N
Se da el nombre de ecuación diferencial t=a
a la ecuación que contiene una variable
dependiente y sus derivadas respecto de w = y0
una o más variables independientes. print("t0 = {0:.2f}, w0 =
Muchas de las leyes generales de la {1:.12f}".format(t, w))
naturaleza se expresan en el lenguaje de
las ecuaciones diferenciales; abundan for i in range(1, N+1):
también las aplicaciones del mismo en
w = w + h*f(t, w)
ingeniería, economía, en las mismas
matemáticas y en muchos otros campos t = a + i*h
de la ciencia aplicada.
print("t{0:<2} = {1:.2f}, w{0:<2} =
Esta utilidad de las ecuaciones {2:.12f}".format(i, t, w))
diferenciales es fácil de explicar;
return w
recuérdese que si se tiene la función y =
f (x), su derivada dy/dx puede
interpretarse como la velocidad de
cambio de y respecto a x.
#dt = y - t2 + 1, a = 0, b = 2, y0 = 0.5, N
= 10
print("Método de Euler:")
Euler(0, 2, 0.5, test1, 10)
#dt = 2 - e−4t - 2y, a = 0, b = 1, y0 = 1,
N = 20
print("Método de Euler:")
Euler(0, 1, 1, test2, 20)
(Kiseliov, 1997)

Encontrar la solución por método de

Euler de la ecuación diferencial
Programa en Python compilador
Cuaderno de Jupyter
import numpy as np
import matplotlib.pyplot as plt

#metodo de euler para la aproximacion

de 1er orden de y dado y' = f(x, y)

#Funcion ecuacion diferencial de primer

orden f(x,y)
def f1(x, y):
dvy1 = -2*x + y*x #para
modificar o incluir la funcion de tu
problema
return (dvy1)

#Solucion analitica
def y(x, y): print(round(x[i],5),"
",round(yf[i],5))
fx = 0 #El problema no
tiene solucion analitica plt.plot(x, yf, 'r') #Grafica
return (fx) plt.show() #Mostrar
Grafica
(Angel Castaño, 2021)
#Valores iniciales
xi = 1 #Valor inicial de
'x'
yi = -3 #Valor inicial de
'y'
xf = 2 #Valor final de 'x'
h = 0.1 #Tamaño de paso

n = (xf - xi)/h
#Cantidad de pasos o iteraciones de la
aproximacion de la funcion
x = np.linspace(xi, xf, int(n+1))
#fx = y(x) #Solucion
analitica de la integral de f'x
yf=[]
#aproximacion de la integral de f'x
yf.append(yi)
fi = []
fi.append(f1(xi, yi))
#derivada f'x

for i in range (int(n)):

fi.append(f1(x[i], yf[i]))
yf.append(yi + fi[i]*h)
#Formula del metodo de Euler
yi = yf[i+1]
print("x"," yf")
print("-----------------------")
for i in range (0,int(n)+1):
 II. RESULTADOS
Modelo de punto fijo

La solución es: -13.82823

Método de Bisección

𝟑
Simpson 𝟖

Regla del trapecio

𝟏
Simpson 𝟑
Método de la Secante

La solución por Euler:

El resultado es: 0,002989

Diferenciación Numérica

La solución es: -13.82823

 http://blog.espol.edu.ec/analisisnumeric
o/regla-del-trapecio/
III. CONCLUSIONES
(Edison del Rosario, 2017)
Cada uno de los resultados obtenidos son
aproximaciones que tiene semejanza con
los procesos de integración y derivación,
http://rodrigogr.com/blog/metodo-de-
se determina que los cálculos obtenidos
integracion-simpson-13/
son correctos
(Rodrigo Gómez, 2014)

Cada uno de los procedimientos

planteados pueden ser utilizados para https://ingangelocastano.blogspot.com/2
procesos de ingeniera orientados a varias 021/09/metodo-de-euler-para-solucion-
áreas por ejemplo Ingeniería Química. de-edos.html
(Angel Castaño, 2021)
La herramienta Python permite realizar
un proceso de cálculo eficiente y
creación de gráficas a partir de la Revistas
solución

Granados Ospina, Adriana (2015). Las

Los métodos numéricos son complejos TIC en la enseñanza de los métodos
numéricos, 147-148.
en realidad, pero sencillos al momento
de su resolución cambian ciertos (Ospina, 2015)
aspectos en formulas dando relaciones
de solución por ejemplo en el método de
1 3
trapecio, 𝑆𝑖𝑚𝑝𝑠𝑜𝑛 3 y 𝑆𝑖𝑚𝑝𝑠𝑜𝑛 8 GUTIÉRREZ G., ALEXANDER , &
CÁRDENAS A., PEDRO PABLO
(2008). Una nota sobre el teorema de
Para las comprobaciones se utilizó la punto fijo de Banach en la solución de
calculadora en línea Symbolab cuyos sistemas de ecuaciones lineales
resultados se asemejan mucho a los algebraicas. Scientia Et Technica,
obtenidos por la herramienta Python XIV(40),203-205.[fecha de Consulta 24
de Agosto de 2022]. ISSN: 0122-1701.
Disponible en:
BIBLIOGRAFÍA https://www.redalyc.org/articulo.oa?id=
https://www.esss.co/es/blog/metodos- 84920454038
numericos-para-simulacion-en-la- (Cárdenas, 2008)
ingenieria/
Libros
(Eduardo Araujo, 2017)
Recuperado de:

Fuentes de programas
https://journal.poligran.edu.co/index.ph A. Kiseliov, M. Krasnov & G.
p/libros/article/download/2842/2997/69 Makarenko, Problemas de Ecuaciones
89 Diferenciales Ordinarias, Ed. Mir,
Moscú, 1997
(Diego Arévalo Ovalle, 2021)
(Kiseliov, 1997)

Nieves Hurtado, A. (2014). Métodos

Numéricos Aplicados a la Ingeniería (1.ª C. Chapra, S. (2007). Métodos
ed., pp. 30–40). México: Patria. numéricos para ingenieros (5.ª ed., pp.
154-157, 600–631). México: McGraw-
(Nieves Hurtado, 2014)
Hill
(Chapra, 2007)
Seminario Vasquez, R. (2009). Métodos
numéricos para ingeniería (1.ª ed., pp.
53–69). España: Eumed.net. España:
Eumed.net.
(Vasquez, 2009)
Haeussler. (2003). Matemáticas para
administración y economía (4.ª ed., pp.
700–715). México: Pearson. México:
Pearson.
(Haeussler, 2003)

Himmelblau, D. (1997). Principios

básicos y cálculos en ingeniera química
(6.ª ed., pp. 680–710). México: Prentice
Hall. México: Prentice Hall.
(Hammelbaul, 1997)

C. Fernández & J. M. Vegas, Ecuaciones

Diferenciales II, Ecuaciones no Lineales,
Pirámide, Madrid, 1996
(Fernández, 1996)

M. de Guzman, I. Peral & M. Walias,

Problemas de ecuaciones diferenciales
ordinarias, Ed.Alhambra, Madrid, 1980
(Guzman, 1980)
Enlace del video
https://youtu.be/RW2d__E1sCY