CursosEmpresasBlogLiveConfPrecios

Comparación de Métodos: Runge-Kutta 4 vs Euler en Ecuaciones Diferenciales

Clase 8 de 12 • Taller de Aplicación de Modelos Numéricos

Contenido del curso

Modelos matemáticos

  • 1
    Modelos Matemáticos: Conceptos Básicos y Aplicaciones

    Modelos Matemáticos: Conceptos Básicos y Aplicaciones

    04:24 min
  • 2
    Modelado de Sistemas Dinámicos con Funciones Matemáticas y Python

    Modelado de Sistemas Dinámicos con Funciones Matemáticas y Python

    04:29 min
  • 3
    Ecuaciones Diferenciales Ordinarias: Modelos de Epidemias

    Ecuaciones Diferenciales Ordinarias: Modelos de Epidemias

    05:09 min
  • 4
    Resolución de EDOs para Modelar Epidemias con Python

    Resolución de EDOs para Modelar Epidemias con Python

    03:24 min
  • 5
    Convección y Sistemas Dinámicos: El Modelo de Lorenz

    Convección y Sistemas Dinámicos: El Modelo de Lorenz

    04:05 min

Modelos númericos

  • 6
    Método de Euler: Solución Numérica de Ecuaciones Diferenciales

    Método de Euler: Solución Numérica de Ecuaciones Diferenciales

    03:19 min
  • 7
    Solución Numérica y Exacta de Ecuaciones Diferenciales

    Solución Numérica y Exacta de Ecuaciones Diferenciales

    03:54 min

Sistemas caóticos

  • 8
    Comparación de Métodos: Runge-Kutta 4 vs Euler en Ecuaciones Diferenciales

    Comparación de Métodos: Runge-Kutta 4 vs Euler en Ecuaciones Diferenciales

    Viendo ahora
  • 9
    Resolución del Sistema de Lorenz con Método RK4

    Resolución del Sistema de Lorenz con Método RK4

    03:32 min

Modelos epidemiológicos

  • 10
    Modelo SIR: Simulación Numérica de Epidemias con RK4

    Modelo SIR: Simulación Numérica de Epidemias con RK4

    03:39 min
  • 11
    Modelos SIR y el Número Básico de Reproducción (R₀)

    Modelos SIR y el Número Básico de Reproducción (R₀)

    02:42 min
  • 12
    Modelado Epidemiológico con SIRD y Algoritmo de Evolución Diferencial

    Modelado Epidemiológico con SIRD y Algoritmo de Evolución Diferencial

    04:41 min
Tomar examen

Escuelas

  • Desarrollo Web
    • Fundamentos del Desarrollo Web Profesional
    • Diseño y Desarrollo Frontend
    • Desarrollo Frontend con JavaScript
    • Desarrollo Frontend con Vue.js
    • Desarrollo Frontend con Angular
    • Desarrollo Frontend con React.js
    • Desarrollo Backend con Node.js
    • Desarrollo Backend con Python
    • Desarrollo Backend con Java
    • Desarrollo Backend con PHP
    • Desarrollo Backend con Ruby
    • Bases de Datos para Web
    • Seguridad Web & API
    • Testing Automatizado y QA para Web
    • Arquitecturas Web Modernas y Escalabilidad
    • DevOps y Cloud para Desarrolladores Web
  • English Academy
    • Inglés Básico A1
    • Inglés Básico A2
    • Inglés Intermedio B1
    • Inglés Intermedio Alto B2
    • Inglés Avanzado C1
    • Inglés para Propósitos Específicos
    • Inglés de Negocios
  • Marketing Digital
    • Fundamentos de Marketing Digital
    • Marketing de Contenidos y Redacción Persuasiva
    • SEO y Posicionamiento Web
    • Social Media Marketing y Community Management
    • Publicidad Digital y Paid Media
    • Analítica Digital y Optimización (CRO)
    • Estrategia de Marketing y Growth
    • Marketing de Marca y Comunicación Estratégica
    • Marketing para E-commerce
    • Marketing B2B
    • Inteligencia Artificial Aplicada al Marketing
    • Automatización del Marketing
    • Marca Personal y Marketing Freelance
    • Ventas y Experiencia del Cliente
    • Creación de Contenido para Redes Sociales
  • Inteligencia Artificial y Data Science
    • Fundamentos de Data Science y AI
    • Análisis y Visualización de Datos
    • Machine Learning y Deep Learning
    • Data Engineer
    • Inteligencia Artificial para la Productividad
    • Desarrollo de Aplicaciones con IA
    • AI Software Engineer
  • Ciberseguridad
    • Fundamentos de Ciberseguridad
    • Hacking Ético y Pentesting (Red Team)
    • Análisis de Malware e Ingeniería Forense
    • Seguridad Defensiva y Cumplimiento (Blue Team)
    • Ciberseguridad Estratégica
  • Liderazgo y Habilidades Blandas
    • Fundamentos de Habilidades Profesionales
    • Liderazgo y Gestión de Equipos
    • Comunicación Avanzada y Oratoria
    • Negociación y Resolución de Conflictos
    • Inteligencia Emocional y Autogestión
    • Productividad y Herramientas Digitales
    • Gestión de Proyectos y Metodologías Ágiles
    • Desarrollo de Carrera y Marca Personal
    • Diversidad, Inclusión y Entorno Laboral Saludable
    • Filosofía y Estrategia para Líderes
  • Diseño de Producto y UX
    • Fundamentos de Diseño UX/UI
    • Investigación de Usuarios (UX Research)
    • Arquitectura de Información y Usabilidad
    • Diseño de Interfaces y Prototipado (UI Design)
    • Sistemas de Diseño y DesignOps
    • Redacción UX (UX Writing)
    • Creatividad e Innovación en Diseño
    • Diseño Accesible e Inclusivo
    • Diseño Asistido por Inteligencia Artificial
    • Gestión de Producto y Liderazgo en Diseño
    • Diseño de Interacciones Emergentes (VUI/VR)
    • Desarrollo Web para Diseñadores
    • Diseño y Prototipado No-Code
  • Contenido Audiovisual
    • Fundamentos de Producción Audiovisual
    • Producción de Video para Plataformas Digitales
    • Producción de Audio y Podcast
    • Fotografía y Diseño Gráfico para Contenido Digital
    • Motion Graphics y Animación
    • Contenido Interactivo y Realidad Aumentada
    • Estrategia, Marketing y Monetización de Contenidos
  • Desarrollo Móvil
    • Fundamentos de Desarrollo Móvil
    • Desarrollo Nativo Android con Kotlin
    • Desarrollo Nativo iOS con Swift
    • Desarrollo Multiplataforma con React Native
    • Desarrollo Multiplataforma con Flutter
    • Arquitectura y Patrones de Diseño Móvil
    • Integración de APIs y Persistencia Móvil
    • Testing y Despliegue en Móvil
    • Diseño UX/UI para Móviles
  • Diseño Gráfico y Arte Digital
    • Fundamentos del Diseño Gráfico y Digital
    • Diseño de Identidad Visual y Branding
    • Ilustración Digital y Arte Conceptual
    • Diseño Editorial y de Empaques
    • Motion Graphics y Animación 3D
    • Diseño Gráfico Asistido por Inteligencia Artificial
    • Creatividad e Innovación en Diseño
  • Programación
    • Fundamentos de Programación e Ingeniería de Software
    • Herramientas de IA para el trabajo
    • Matemáticas para Programación
    • Programación con Python
    • Programación con JavaScript
    • Programación con TypeScript
    • Programación Orientada a Objetos con Java
    • Desarrollo con C# y .NET
    • Programación con PHP
    • Programación con Go y Rust
    • Programación Móvil con Swift y Kotlin
    • Programación con C y C++
    • Administración Básica de Servidores Linux
  • Negocios
    • Fundamentos de Negocios y Emprendimiento
    • Estrategia y Crecimiento Empresarial
    • Finanzas Personales y Corporativas
    • Inversión en Mercados Financieros
    • Ventas, CRM y Experiencia del Cliente
    • Operaciones, Logística y E-commerce
    • Gestión de Proyectos y Metodologías Ágiles
    • Aspectos Legales y Cumplimiento
    • Habilidades Directivas y Crecimiento Profesional
    • Diversidad e Inclusión en el Entorno Laboral
    • Herramientas Digitales y Automatización para Negocios
  • Blockchain y Web3
    • Fundamentos de Blockchain y Web3
    • Desarrollo de Smart Contracts y dApps
    • Finanzas Descentralizadas (DeFi)
    • NFTs y Economía de Creadores
    • Seguridad Blockchain
    • Ecosistemas Blockchain Alternativos (No-EVM)
    • Producto, Marketing y Legal en Web3
  • Recursos Humanos
    • Fundamentos y Cultura Organizacional en RRHH
    • Atracción y Selección de Talento
    • Cultura y Employee Experience
    • Gestión y Desarrollo de Talento
    • Desarrollo y Evaluación de Liderazgo
    • Diversidad, Equidad e Inclusión
    • AI y Automatización en Recursos Humanos
    • Tecnología y Automatización en RRHH
  • Finanzas e Inversiones
    • Fundamentos de Finanzas Personales y Corporativas
    • Análisis y Valoración Financiera
    • Inversión y Mercados de Capitales
    • Finanzas Descentralizadas (DeFi) y Criptoactivos
    • Finanzas y Estrategia para Startups
    • Inteligencia Artificial Aplicada a Finanzas
    • Domina Excel
    • Financial Analyst
    • Conseguir trabajo en Finanzas e Inversiones
  • Startups
    • Fundamentos y Validación de Ideas
    • Estrategia de Negocio y Product-Market Fit
    • Desarrollo de Producto y Operaciones Lean
    • Finanzas, Legal y Fundraising
    • Marketing, Ventas y Growth para Startups
    • Cultura, Talento y Liderazgo
    • Finanzas y Operaciones en Ecommerce
    • Startups Web3 y Blockchain
    • Startups con Impacto Social
    • Expansión y Ecosistema Startup
  • Cloud Computing y DevOps
    • Fundamentos de Cloud y DevOps
    • Administración de Servidores Linux
    • Contenerización y Orquestación
    • Infraestructura como Código (IaC) y CI/CD
    • Amazon Web Services
    • Microsoft Azure
    • Serverless y Observabilidad
    • Certificaciones Cloud (Preparación)
    • Plataforma Cloud GCP

Platzi y comunidad

  • Platzi Business
  • Live Classes
  • Lanzamientos
  • Executive Program
  • Trabaja con nosotros
  • Podcast

Recursos

  • Manual de Marca

Soporte

  • Preguntas Frecuentes
  • Contáctanos

Legal

  • Términos y Condiciones
  • Privacidad
  • Tyc promociones
Reconocimientos
Reconocimientos
Logo reconocimientoTop 40 Mejores EdTech del mundo · 2024
Logo reconocimientoPrimera Startup Latina admitida en YC · 2014
Logo reconocimientoPrimera Startup EdTech · 2018
Logo reconocimientoCEO Ganador Medalla por la Educación T4 & HP · 2024
Logo reconocimientoCEO Mejor Emprendedor del año · 2024
De LATAM conpara el mundo
YoutubeInstagramLinkedInTikTokFacebookX (Twitter)Threads

      El ejemplo de ecuación diferencial que usamos en la clase pasada es muy sencillo, pero lo empleamos porque necesitábamos un ejemplo donde conociéramos la solución exacta para calcular el error real del cálculo numérico. Esta clase está dividida en dos partes:

      1. En la primera parte, veremos un método que es mucho más eficiente que Euler y que además es uno de los más usados en la vida real.
      2. Luego en la segunda parte, resolveremos el sistema de Lorenz que vimos en clases pasadas el cual representa un modelo de la convección. También discutiremos porque la convección es un claro ejemplo de caos a la luz de una definición apropiada que daremos en esta sección.

      Métodos predictor-corrector

      El método de Euler es la forma más sencilla de resolver numéricamente una ecuación diferencial de la forma:

      CleanShot 2020-07-23 at 02.02.25.png

      Donde recordemos que se ejecuta con la fórmula iterativa:

      CleanShot 2020-07-23 at 03.29.43.png

      A partir de este método surgen varias mejoras, incluyendo los métodos predictor-corrector que ejecutan un paso inicial “predictor” y posteriormente ejecutan pasos adicionales “corrector” o correctivos. En este curso no profundizaremos en la justificación detallada detrás de estos métodos, solamente haremos una comparación con uno de los métodos más eficientes que es el Runge-Kutta de orden 4, cuya fórmula iterativa está dada en cuatro pasos así:

      Screenshot_51.png

      Haremos una comparación entre los métodos Runge-Kutta de orden 4 o RK4 y el método de Euler para ver cómo mejora la precisión numérica de un método a otro. Para ello implementaremos funciones que ejecuten paso a paso ambos algoritmos de una forma diferente a lo que hemos hecho antes (esto con el fin de ser más transparentes a la hora de comparar con las fórmulas matemáticas):

      pasted image 0 (7).png

      Observa que en el código:

      1. Dejé por fuera de todos los pasos “predictor-corrector” el 𝚫t, y lo puse al final en la fórmula iterativa que calcula yₙ₊₁. Matemáticamente son cosas equivalentes en virtud de la propiedad de factorización algebraica, así que el resultado es el mismo.
      2. Lo que en las fórmulas se llama yₙ, en el código es y₀. Así mismo yₙ se corresponde con y.
      3. Cada función ejecuta un solo paso de cada algoritmo, lo que quiere decir que debemos usarlas dentro de una estructura tipo for() o while() para ejecutar varios pasos sucesivamente.

      Ahora, para comparar ambos métodos tomaremos como ejemplo el caso de la clase pasada donde f (t, y) = y cuya solución con el valor inicial y(0) = 1 es:

      CleanShot 2020-07-23 at 03.37.32.png

      Vamos a calcular la solución numérica por ambos métodos, para varios intervalos de tiempo y compararemos con la solución exacta, así:

      pasted image 0 (8).png

      El final del código son líneas que tienen que ver solamente con la visualización de las soluciones numéricas y la exacta, cuyo resultado se ve así:

      Unknown-2.png

      Y de esta visualización notamos inmediatamente que para un mismo 𝚫t el rendimiento de RK4 es superior al método de Euler (compara las curvas en color rojo que representan ambas soluciones para 𝚫t = 0.556. Así como hicimos en la clase pasada aquí también podemos calcular el error acumulado, ahora para ambos métodos dándonos como resultado lo siguiente:

      image20.png
      image22.png

      El gráfico resultante nos muestra claramente que el error para RK4, es al menos dos órdenes de magnitud más pequeño que el de Euler, y esto refleja la evidente superioridad de RK4 incluso para intervalos 𝚫t relativamente grandes.

      En nuestra próxima clase, veremos cómo usar RK4 para resolver sistemas complejos que presentan comportamiento caótico y el notebook de esta clases lo encuentras en este link.

      Comentarios

        Lorena Mondragón

        Lorena Mondragón

        student•
        hace 5 años
        214418817_318240583304918_3815727049941008001_n.jpg
          Eduardo Monzón

          Eduardo Monzón

          student•
          hace 3 años

          Gracias por el resumen.

        Roger Christian Cansaya Olazabal

        Roger Christian Cansaya Olazabal

        student•
        hace 5 años

        Codigo.

        import numpy as np import matplotlib.pyplot as plt def f(t,y): return y def rk4(t0,y0,dt,f): k1 = f(t0, y0) k2 = f(t0 + dt / 2.0, y0 + dt * k1 / 2.0) k3 = f(t0 + dt / 2.0, y0 + dt * k2 / 2.0) k4 = f(t0 + dt, y0 + dt * k2) y = y0 + (dt / 6.0) * (k1 + 2.0 * k2 + 2.0 * k3 + k4) return y def euler(t0, y0, dt, f): f0 = f(t0, y0) y = y0 + dt * f0 return y def exact_sol(t): return np.exp(t) if __name__=='__main__': tmax = 5 plt.figure(figsize=(10,10)) for n, c in zip([10,100], ['red','blue']): ys_rk4 = [1] ys_euler = [1] ts = np.linspace(0,tmax,n) dt = ts[1] - ts [0] for i in range(n-1): u_rk4 = rk4(ts[i], ys_rk4[i], dt,f) u_euler = euler(ts[i], ys_euler[i], dt, f) ys_rk4.append(u_rk4) ys_euler.append(u_euler) plt.plot(ts, ys_euler, '--', color=c, label='Euler dt = {}'.format(round(dt,3))) plt.plot(ts, ys_rk4, color=c, label='RK4 dt = {}'.format(round(dt,3))) plot_text_size = 20 plt.plot(ts, exact_sol(ts), '-k', label='exact') plt.xticks(fontsize=plot_text_size) plt.yticks(fontsize=plot_text_size) plt.legend(fontsize = plot_text_size) plt.show() tmax = 100 dt_arr = np.arange(0.0001, 0.5, 0.0001) error_rk4 = [] error_euler = [] for dt in dt_arr: ys_rk4 = [1] ys_euler = [1] ts = np.arange(0, tmax, dt) for i in range(len(ts)): u_rk4 = rk4(ts[i], ys_rk4[i], dt, f) u_euler = euler(ts[i], ys_euler[i], dt, f) ys_rk4.append(u_rk4) ys_euler.append(u_euler) ys_exact = exact_sol(ts) error_rk4.append(np.abs(ys_rk4[-1]-ys_exact[-1])) error_euler.append(np.abs(ys_euler[-1]-ys_exact[-1])) plt. figure(figsize=(10,8)) plot_text_size = 20 plt.plot(dt_arr, error_rk4, label='RK4') plt.plot(dt_arr, error_euler, label='Euler') plt.plot(dt_arr[:-4900],error_rk4[:-4900], '-*r') plt.xticks(fontsize=plot_text_size) plt.yticks(fontsize=plot_text_size) plt.legend(fontsize=plot_text_size) plt.yscale('log') plt.xscale('log') plt.show()
        Euler vs Kutta_Figure_1.png
        error euler_kuttta.png
        Arturo Barrios

        Arturo Barrios

        student•
        hace 6 años

        Admito que estoy confundido y tengo que trabajar en esta parte del contenido. ¿Hay algún libro o taller, video o alternativa para profundizar? Estaría muy agradecido, me parece muy interesante

          Carlos Perilla

          Carlos Perilla

          student•
          hace 6 años

          Para extender la parte teoríca: https://web.archive.org/web/20151123033428/http://ocw.um.es/ingenierias/ampliacion-de-calculo-numerico/material-de-clase-1/ivp-ode.pdf https://sites.google.com/site/metodosnumericosmecanica/home/unidad-i

          Un poco más practico: https://www.myphysicslab.com/explain/runge-kutta-en.html

          Juan Nuñez

          Juan Nuñez

          student•
          hace 5 años

          El código se vuelve extenso porque el profesor hace una comparativa entre 2 métodos y la solución exacta y cada método lo corre con 2 diferentes dt con el fin de hacer el versus entre Euler y RK. Dejo el código solo con la parte de RK4

          import numpy as np import matplotlib.pyplot as plt def f(t, y): return y #la funcion de retorno cambia dependiendo de la ecuacion diferencial #esta ecuación es dy/dt = y por lo que f(dt, y) es la ecuacion diferencial a resolver def rk4(t0, y0, dt): #la funcion f no es necesario pasarsela como parámetro ya que es función global kuta1 = f( t0, y0 ) kuta2 = f( t0 + dt/2 , y0 + dt*kuta1/2 ) kuta3 = f( t0 + dt/2 , y0 + dt*kuta2/2 ) kuta4 = f( t0 + dt , y0 + dt*kuta3 ) y = y0 + (dt/6)*(kuta1 + 2*kuta2 + 2*kuta3 + kuta4) return y if __name__=="__main__": tmax=50 #es el intervalo en eje X máximo al que queremos llegar ya que #al ser método numérico no podemos obtener valores para todo t n=100 #este valor se puede cambiar dependiendo del numero de pasos que querramos dar #de este valor depende el intervalo discreto dt ys=[1] # aqui se pone las condiciónes de frontera o iniciales de la ED ts=np.linspace(0, tmax, n) #esta función regresa un arreglo de n valores entre 0 y tmax espaciados equitativamente dt=ts[1]-ts[0] #dado que ts esta equitativamente espaciado se puede hacer la resta entre cualesquiera valores contiguos #cada valor generado por rk4 será almacenado en el arreglo de resultados for i in range(n-1): ys.append(rk4(ts[i], ys[i], dt)) plt.figure(figsize=(10,8)) plt.plot(ts, ys, 'o') # plot del arreglo resultado rk4 plt.plot(ts, np.exp(ts), '--') #plot del arreglo de la solución exacta plt.show()
        Arturo Barrios

        Arturo Barrios

        student•
        hace 6 años

        ¿qué significa o qué implica los valores ki en el ajuste Runge-Kutta de orden 4?

          Carlos Perilla

          Carlos Perilla

          student•
          hace 6 años

          Son pendientes, y al final se realiza un promedio ponderado de las pendientes. Aquí hay más info: https://es.wikipedia.org/wiki/M%C3%A9todo_de_Runge-Kutta#M%C3%A9todos_de_Runge-Kutta_de_cuarto_orden