# Solver numérico por método de Euler (EDO de primer orden)

Resuelve el problema de valor inicial dy/dx = f(x,y), y(x₀)=y₀ con el método de Euler explícito: y_{n+1} = y_n + h·f(x_n, y_n), con tabla por pasos y estimación final. La solución exacta y(x) es opcional y añade una columna de error que muestra el error global O(h) del método de primer orden. Ejemplo: dy/dx = y, y(0)=1, h=0,1 → y(1) ≈ 1,1¹⁰ = 2,593742 frente a e = 2,718282 (error 0,124539).

> Página canónica: https://elysiatools.com/es/tools/euler-method-solver

- **Categoría:** Math & Numbers

- **Palabras clave:** método de euler, euler explícito, edo numérica, integración numérica, problema de valor inicial, tamaño de paso, método de primer orden, aproximación, cálculo

## Descripción general

El solver numérico por método de Euler calcula aproximaciones paso a paso para problemas de valor inicial en ecuaciones diferenciales ordinarias (EDO) de primer orden de la forma dy/dx = f(x, y). Mediante la fórmula del método explícito y_{n+1} = y_n + h·f(x_n, y_n), genera una tabla iterativa detallada, la estimación final y una comparativa opcional frente a la solución analítica exacta.

## Entradas

- **f(x, y) en dy/dx = f(x, y)** (text): Right-hand side in terms of x and y (functions: sin, cos, exp, ln, sqrt, …). Write products with *, e.g. x*y.
- **x₀ (x inicial)** (number): e.g. 0
- **y₀ = y(x₀)** (number): e.g. 1
- **x objetivo** (number): Must be greater than x₀.
- **Número de pasos n** (number): h = (target x − x₀)/n. More steps → smaller error, O(h) globally.
- **Solución exacta y(x) (opcional)** (text): Exact solution in x, used to add an error column. Leave empty to skip.
- **Decimales** (number)

## Cuándo usarlo

- Al resolver numéricamente ecuaciones diferenciales ordinarias de primer orden donde no se dispone de una solución analítica directa.
- Al verificar ejercicios académicos de cálculo y métodos numéricos comparando las iteraciones manuales con la tabla generada.
- Al analizar el impacto del tamaño de paso h y el error de truncamiento global O(h) frente a la solución exacta de una EDO.

## Cómo funciona

- Ingresa la función f(x, y), los valores iniciales (x₀, y₀) y el valor final objetivo de x.
- Define la cantidad de pasos n para determinar automáticamente el tamaño de paso h = (xEnd - x₀) / n.
- Opcionalmente, introduce la expresión analítica exacta y(x) y ajusta los decimales deseados para evaluar el error absoluto en cada iteración.
- El solver evalúa la pendiente en cada punto y proyecta el valor sucesivo y_{n+1} hasta alcanzar el x objetivo.

## Casos de uso

- Estudiantes de ingeniería y ciencias que necesitan comprobar el desarrollo de tareas de métodos numéricos paso a paso.
- Docentes que diseñan ejercicios de integración numérica y requieren comparar rápidamente la aproximación frente a la curva exacta.
- Modelado preliminar de tasas de cambio y dinámicas poblacionales simples descritas por ecuaciones diferenciales de primer orden.

## Preguntas frecuentes

### ¿Qué tipo de ecuaciones diferenciales puede resolver esta herramienta?

Resuelve problemas de valor inicial para ecuaciones diferenciales ordinarias (EDO) de primer orden expresadas como dy/dx = f(x, y).

### ¿Cómo se calcula el tamaño de paso h?

El tamaño de paso se calcula dividiendo la diferencia entre el x objetivo y el x inicial entre el número total de pasos: h = (xEnd - x₀) / n.

### ¿Es obligatorio ingresar la solución exacta y(x)?

No, es un campo opcional. Si se introduce, la tabla añade el valor analítico y calcula el error absoluto en cada iteración.

### ¿Qué funciones matemáticas se admiten en la expresión f(x, y)?

Se admiten operaciones estándar y funciones comunes como sin, cos, exp, ln y sqrt, utilizando * para multiplicaciones explícitas.

### ¿Por qué aumenta o disminuye el error numérico al cambiar los pasos?

El método de Euler explícito es de primer orden, por lo que el error global es proporcional a O(h); al aumentar los pasos, h se reduce y la aproximación mejora.

## Herramientas relacionadas

- [Calculadora de integral de convolución (numérica)](https://elysiatools.com/es/tools/convolution-integral-calculator): Calcula numéricamente la convolución de dos señales (f*g)(t) = ∫ f(τ)g(t−τ)dτ: modo causal (ambas señales son cero para t<0, integral en \[max(τmin,0), min(τmax,t)\], ideal para productos del dominio de Laplace) y modo de ventana directa (integral en todo \[τmin, τmax\], ideal para señales bilaterales como las gaussianas), mediante la regla compuesta de Simpson (2000 intervalos por defecto). Clásicos: e^(−t)*e^(−2t) = e^(−t)−e^(−2t), 0.2325 en t=1; dos gaussianas se convolucionan en √(π/2)·e^(−t²/2).
- [Calculadora de derivación numérica (diferencias forward/backward/central)](https://elysiatools.com/es/tools/numerical-differentiation): Aproxima f′(x₀) con tres diferencias finitas: progresiva (f(x₀+h)−f(x₀))/h, retrograda (f(x₀)−f(x₀−h))/h y central (f(x₀+h)−f(x₀−h))/(2h), más la segunda derivada central. La derivada exacta opcional añade el error absoluto de cada método y muestra el contraste O(h) frente a O(h²). Ejemplo: f=x², x₀=1, h=0,1 → progresiva 2,1; retrograda 1,9; central exactamente 2,0.
- [Solver de EDO de primer orden (variables separables)](https://elysiatools.com/es/tools/first-order-ode-solver): Resuelve dy/dx = g(x)·h(y) por separación de variables: se separa, se integra término a término para obtener H(y) = G(x) + C y, cuando es posible, se despeja y = f(x). Admite h(y) de un término (y, y^n, e^(ky), ky+m) y polinomios cuadráticos descomponibles por fracciones parciales (como la logística y(1−y)); con la condición inicial y(x₀)=y₀ calcula C y detecta soluciones de equilibrio. Ejemplo: dy/dx = 2x·y → y = e^(x²+C).
- [Constructor de Simulación Monte Carlo](https://elysiatools.com/es/tools/monte-carlo-simulation-builder): Define distribuciones de entrada (normal/uniforme/lognormal/triangular), escribe una fórmula, ejecuta miles de pruebas y obtén el histograma con intervalos de confianza.
- [Calculadora de raíces por Newton-Raphson](https://elysiatools.com/es/tools/newton-raphson-root-finder): Resuelve f(x) = 0 con la iteración de Newton-Raphson x_{k+1} = x_k − f(x_k)/f'(x_k): la derivada puede darse analíticamente (si se deja vacía se usa una diferencia central numérica), y se muestran la tabla de iteraciones (x_k y f(x_k)), el criterio de parada (|f| < tolerancia o |Δx| < tolerancia·max(1,|x|)), el número de iteraciones y el |f(raíz)| final. Clásicos: x²−2 desde x₀=1 converge en 4 pasos a √2 ≈ 1.4142135624; cos(x)−x converge al número de Dottie 0.7390851332. Derivada nula, pasos divergentes o exceder el límite de iteraciones se informan explícitamente.
- [Integrador por regla de Simpson (∫f(x)dx)](https://elysiatools.com/es/tools/numerical-integration-simpson): Calcula ∫ₐᵇ f(x)dx con la regla de Simpson 1/3 compuesta (n par): S = h/3·(f(a) + 4Σnodos impares + 2Σnodos pares interiores + f(b)), con error O(h⁴) y exacta para polinomios de grado ≤ 3. Tabla por nodos, estimación y comparación opcional con el valor exacto. Ejemplos: ∫₀¹x²dx con n=4 da 0,333333 (¡exacta!); ∫₀¹e^(−x²)dx (sin primitiva elemental) con n=10 da 0,746825.
- [Integrador por regla del trapecio (∫f(x)dx)](https://elysiatools.com/es/tools/numerical-integration-trapezoid): Calcula ∫ₐᵇ f(x)dx con la regla del trapecio compuesta: T = h/2·(f(a) + 2Σf(xᵢ) + f(b)), con tabla por nodos, estimación de la integral y comparación opcional con el valor exacto y el error absoluto; el error es O(h²) (exacta para funciones lineales). Ejemplo: ∫₀¹x²dx con n=4 da 0,34375 frente al exacto 1/3, error 0,010417.
- [Solver numérico Runge-Kutta de 4º orden (RK4)](https://elysiatools.com/es/tools/runge-kutta-rk4-solver): Resuelve dy/dx = f(x,y), y(x₀)=y₀ con el Runge-Kutta clásico de cuarto orden: cada paso calcula las cuatro pendientes k1–k4 y actualiza y_{n+1} = y_n + h/6·(k1+2k2+2k3+k4), con error global O(h⁴): al dividir h entre 2 el error se reduce unas 16 veces. Devuelve la tabla por pasos, el detalle de k1–k4 de los primeros pasos y la estimación final; la solución exacta y(x) es opcional y añade columna de error. Ejemplo: dy/dx = y, y(0)=1, h=0,1 → y(1) ≈ 2,718282, casi exactamente e.

## Ejemplos

- [Ejemplos de Procesamiento de Imágenes Android Java](https://elysiatools.com/es/samples/android-image-processing-java): Ejemplos de procesamiento de imágenes Android Java incluyendo lectura/escritura, escalado y conversión de formato
- [Ejemplos de Procesamiento de Imágenes Android Kotlin](https://elysiatools.com/es/samples/android-image-processing-kotlin): Ejemplos de procesamiento de imágenes Android Kotlin incluyendo lectura/escritura, escalado y conversión de formato
- [Ejemplos de Procesamiento de Imágenes Web Python](https://elysiatools.com/es/samples/web-image-processing-python): Ejemplos de procesamiento de imágenes Web Python usando PIL/Pillow incluyendo lectura, guardado, redimensionamiento y conversión de formato
- [Ejemplos de Procesamiento de Imágenes Web Rust](https://elysiatools.com/es/samples/web-image-processing-rust): Ejemplos de procesamiento de imágenes Web Rust incluyendo lectura/escritura, escalado y conversión de formato