Blox - Donde la lógica se vuelve natural

Nombre

ode_rk4_tabla - Aproxima una ecuacion diferencial ordinaria con RK4 y devuelve toda la trayectoria.

Sinopsis

tray = numericos.ode_rk4_tabla(expr, x0, y0, h, n)

Descripcion

Resuelve numericamente un problema de valor inicial del tipo y' = f(x,y) usando Runge-Kutta de orden 4.

A diferencia de ode_rk4(), esta variante retorna los vectores completos de x e y.

Formula principal:

$k_1 = f(x_n, y_n)$

$k_2 = f(x_n+\frac{h}{2}, y_n+\frac{h}{2}k_1)$

$k_3 = f(x_n+\frac{h}{2}, y_n+\frac{h}{2}k_2)$

$k_4 = f(x_n+h, y_n+h*k_3)$

$y_{n+1} = y_n + \frac{h}{6}(k_1+2k_2+2k_3+k_4)$

Validaciones y casos borde

Valida que h no sea cero.
Valida que n sea entero y no negativo.
Si n == 0, retorna una tabla con el unico punto inicial (x0, y0).
Admite h negativo para integrar hacia valores decrecientes de x.
Si una validacion falla, emite ERROR().

Comportamiento

Calcula cuatro pendientes intermedias por cada paso.
Combina las pendientes con la formula clasica de RK4.
Guarda el punto inicial y cada punto nuevo calculado.
Retorna una TABLA con dos vectores: x e y.

Funciones API relacionadas

numericos.ode_rk4()
numericos.ode_euler_tabla()
numericos.ode_heun_tabla()
numericos.ode_exacta_tabla()

Parámetros

Parámetro	Tipo	Descripción
expr	STRING	Expresion matematica en texto evaluada por RESOLVER().
x0	NUMERICO	Posicion inicial en x; en formulas se representa como $x_{0}$ .
y0	NUMERICO	Posicion inicial en y; en formulas se representa como $y_{0}$ .
h	NUMERICO	Paso numerico usado en derivacion, integracion o EDO.
n	NUMERICO	Cantidad de pasos; debe ser un entero no negativo.

Valor de retorno

TABLA - Tabla con los vectores x e y calculados por Runge-Kutta de orden 4.

Ejemplo

ejemplo.blox

Solo lectura

INCLUIR "numericos.api"
INCLUIR "tablas.api"
INCLUIR "vectores.api"
INCLUIR "graficos.api"

FUNCION PRINCIPAL
INICIO "Comparacion Euler vs RK4 para dy/dx = f(x,y)"

    STRING f_edo
    NUMERICO x0, y0, h, n
    NUMERICO y_exacta, y_euler, y_rk4
    TABLA tray_exacta, tray_euler, tray_rk4

    // Definimos la EDO: dy/dx = f(x, y)
    // En este caso dy/dx = (x^2 - 1)/y^2
    // cuya solucion analitica es: y = (x^3 - 3*x + 8)^(1/3)
    //
    f_edo = "(x^2 - 1)/y^2"          

    x0 = 0
    y0 = 2          // y(0) = 2
    h  = 0.2
    n  = 25


    y_exacta = numericos.ode_exacta("(x^3 - 3*x + 8)^(1/3)", x0, y0, h, n)
    y_euler = numericos.ode_euler(f_edo, x0, y0, h, n)
    y_rk4   = numericos.ode_rk4(f_edo, x0, y0, h, n)

    IMPRIMIR("\nSoluc. exacta: y(5) = ", y_exacta)
    IMPRIMIR("\n        Euler: y(5) ≈ ", y_euler)
    IMPRIMIR("\n        RK4  : y(5) ≈ ", y_rk4)
    IMPRIMIR("\n")

    tray_exacta = numericos.ode_exacta_tabla("(x^3 - 3*x + 8)^(1/3)", x0, y0, h, n)
    VECTOR X_exacta, Y_exacta
    X_exacta = tray_exacta.x
    Y_exacta = tray_exacta.y

    tray_euler = numericos.ode_euler_tabla(f_edo, x0, y0, h, n)
    VECTOR X_euler, Y_euler
    X_euler = tray_euler.x
    Y_euler = tray_euler.y

    // No se usa ahora
    //
    tray_rk4   = numericos.ode_rk4_tabla(f_edo, x0, y0, h, n)
    VECTOR X_rk4, Y_rk4
    X_rk4 = tray_rk4.x
    Y_rk4 = tray_rk4.y


    // Esta funcion ya fue reemplazada por:
    // graficar_trayectorias_n(curvas, titulo, archivo)
    // Se deja para ver otras opciones
    //
    graficos.graficar_trayectorias2(X_euler, Y_euler, "Euler",
                                    X_exacta, Y_exacta,   "Exacta",
                                    "dy/dx = (x^2 - 1)/y^2 (Exacta vs Euler)",
                                    "PROG900 - API - NUMERICOS - 4.3 Grafico = Comparacion Euler y Rk4.png")




FINAL

Restringido: este ejemplo no puede ejecutarse en el Playground web porque la API requerida no está disponible en el sandbox.

ode_rk4_tabla(expr,x0,y0,h,n)\texttt{ode\_rk4\_tabla}(expr, x_{0}, y_{0}, h, n)ode_rk4_tabla(expr,x0​,y0​,h,n)

Parámetros

Valor de retorno

Ejemplo

$\texttt{ode\_rk4\_tabla}(expr, x_{0}, y_{0}, h, n)$