# Calculadora de integral de convolución (numérica)

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).

> Página canónica: https://elysiatools.com/es/tools/convolution-integral-calculator

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

- **Palabras clave:** convolución, integral de convolución, procesamiento de señales, sistemas lti, respuesta al impulso, regla de simpson, integración numérica, producto de laplace, convolución gaussiana, cálculo

## Descripción general

Esta calculadora evalúa numéricamente la integral de convolución continua (f*g)(t) = ∫ f(τ)g(t−τ)dτ mediante la regla compuesta de Simpson. Permite analizar sistemas lineales e invariantes en el tiempo (LTI) tanto en modo causal como en modo de ventana directa para señales bilaterales, calculando resultados precisos en múltiples puntos temporales.

## Entradas

- **Expresión de f(τ) (variable x)** (text): First signal, written in the variable x. Supports + - * / ^, parentheses, and functions like exp, sin, cos, sqrt, ln.
- **Expresión de g(τ) (variable x)** (text): Second signal, written in the variable x (it is evaluated at t − τ inside the integral).
- **Modo** (select)
- **Inicio de ventana τmin** (number): Lower integration bound.
- **Fin de ventana τmax** (number): Upper integration bound.
- **Valores de t de salida (separados por comas)** (text): 1–8 evaluation points t at which (f*g)(t) is reported.
- **Intervalos de Simpson** (number): Number of Simpson subintervals per integral (even, 100–20000).
- **Decimales** (number)

## Cuándo usarlo

- Al evaluar la respuesta en el tiempo de un sistema LTI causal a partir de su respuesta al impulso.
- Para verificar analíticamente productos de convolución en el dominio del tiempo o la transformada de Laplace.
- Al calcular la convolución bilateral de funciones no causales, como pulsos continuos o distribuciones gaussianas.

## Cómo funciona

- Define las señales f(x) y g(x) utilizando expresiones matemáticas estándar en términos de la variable x.
- Selecciona el modo de integración: causal (donde las funciones son cero para valores menores a 0) o ventana directa (rango completo \[τmin, τmax\]).
- Especifica los límites de integración, los puntos t de salida (hasta 8 valores) y la cantidad de intervalos de Simpson (entre 100 y 20000).
- La herramienta ejecuta la integración numérica compuesta de Simpson y entrega el valor exacto redondeado a los decimales configurados.

## Casos de uso

- Cálculo de la respuesta temporal de circuitos RLC ante excitaciones exponenciales o escalón.
- Filtrado continuo y suavizado de señales continuas mediante convolución con núcleos gaussianos.
- Comprobación de ejercicios académicos de análisis de señales y sistemas de control.

## Preguntas frecuentes

### ¿Qué variable se debe usar al escribir las fórmulas de f y g?

Debes usar la variable x en ambas expresiones; la herramienta evalúa internamente f(τ) y g(t−τ).

### ¿Cuál es la diferencia entre el modo causal y la ventana directa?

El modo causal limita la integración a [max(τmin, 0), min(τmax, t)], mientras que la ventana directa integra siempre en todo el intervalo [τmin, τmax].

### ¿Cuántos puntos t de salida se pueden calcular en una sola ejecución?

Puedes ingresar entre 1 y 8 valores de t separados por comas.

### ¿Qué funciones matemáticas son compatibles en las expresiones?

Admite operadores básicos (+, -, *, /, ^), paréntesis y funciones como exp, sin, cos, sqrt y ln.

### ¿Cómo influye el número de intervalos de Simpson en el resultado?

Un mayor número de intervalos pares (hasta 20000) incrementa la precisión numérica de la aproximación.

## Herramientas relacionadas

- [Solver numérico por método de Euler (EDO de primer orden)](https://elysiatools.com/es/tools/euler-method-solver): 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).
- [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.
- [Calculadora de rango intercuartil](https://elysiatools.com/es/tools/interquartile-range-calculator): Calcula Q1, Q3, IQR y limites opcionales de 1.5 x IQR
- [Calculadora de cuartiles](https://elysiatools.com/es/tools/quartile-calculator): Calcula Q1, mediana, Q3, rango intercuartil y limites opcionales de atipicos
- [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.

## 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