# Calculadora de integral de convolução (numérica)

Calcula numericamente a convolução de dois sinais (f*g)(t) = ∫ f(τ)g(t−τ)dτ: modo causal (ambos os sinais são zero para t<0, integral em [max(τmin,0), min(τmax,t)], ideal para produtos do domínio de Laplace) e modo de janela direta (integral em todo [τmin, τmax], ideal para sinais bilaterais como gaussianas), pela regra de Simpson composta (2000 intervalos por padrão). Clássicos: e^(−t)*e^(−2t) = e^(−t)−e^(−2t), 0.2325 em t=1; duas gaussianas convoluem para √(π/2)·e^(−t²/2).

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

- **Categoria:** Math & Numbers

- **Palavras-chave:** convolução, integral de convolução, processamento de sinais, sistemas lti, resposta ao impulso, regra de simpson, integração numérica, produto de laplace, convolução gaussiana, cálculo

## Visão geral

A Calculadora de integral de convolução (numérica) avalia a convolução contínua (f*g)(t) = ∫ f(τ)g(t−τ)dτ utilizando a regra composta de Simpson. A ferramenta suporta o modo causal, ajustado para sinais com resposta zero antes de t=0 e produtos no domínio de Laplace, e o modo de janela direta para sinais bilaterais como gaussianas, calculando valores precisos em até 8 pontos de saída t.

## Entradas

- **Expressão de f(τ) (variável x)** (text): First signal, written in the variable x. Supports + - * / ^, parentheses, and functions like exp, sin, cos, sqrt, ln.
- **Expressão de g(τ) (variável x)** (text): Second signal, written in the variable x (it is evaluated at t − τ inside the integral).
- **Modo** (select)
- **Início da janela τmin** (number): Lower integration bound.
- **Fim da janela τmax** (number): Upper integration bound.
- **Valores de t de saída (separados por vírgulas)** (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).
- **Casas decimais** (number)

## Quando usar

- Quando você precisa determinar a resposta no tempo de um sistema LTI a partir da entrada e da resposta ao impulso.
- Quando a convolução analítica de duas funções contínuas for complexa ou demorada para integrar simbolicamente.
- Quando for necessário validar numericamente transformadas inversas de Laplace calculadas como produtos de funções.

## Como funciona

- Insira as funções f(τ) e g(τ) utilizando a variável x, com operadores matemáticos e funções como exp, sin, cos ou sqrt.
- Selecione o modo de cálculo: causal (integração entre max(τmin, 0) e min(τmax, t)) ou janela direta (integração em todo o intervalo \[τmin, τmax\]).
- Defina os limites τmin e τmax, o número de subintervalos de Simpson (100 a 20.000) e forneça até 8 valores de saída t separados por vírgula.
- O algoritmo calcula numericamente o produto f(τ)·g(t−τ) sobre a partição definida e exibe os valores resultantes para cada instante t.

## Casos de uso

- Análise de resposta ao impulso em disciplinas de Sistemas Lineares e Processamento de Sinais.
- Filtragem e suavização contínua por convolução gaussiana bilateral.
- Verificação de resultados de integrais de convolução obtidas por tabelas de transformadas de Laplace.

## Perguntas frequentes

### Como devo escrever as expressões das funções na ferramenta?

Utilize a variável x para representar a variável de integração τ em ambas as expressões, com operadores aritméticos (+, -, *, /, ^) e funções padrão como exp(x), sin(x) ou sqrt(x).

### Qual é a diferença entre o modo causal e a janela direta?

O modo causal assume que f e g são nulas para valores menores que zero, limitando a integração ao intervalo ativo [max(τmin, 0), min(τmax, t)]. A janela direta integra fixamente em todo o intervalo [τmin, τmax].

### Quantos pontos de tempo t posso calcular por vez?

Você pode inserir de 1 a 8 valores de t separados por vírgula na mesma execução.

### Como a precisão da integração numérica é controlada?

A precisão é controlada pelo número de subintervalos da regra de Simpson (entre 100 e 20.000) e pelo número de casas decimais selecionado.

### A ferramenta resolve a convolução de forma simbólica?

Não, o cálculo é estritamente numérico, avaliando o valor pontual da integral de convolução para os instantes t informados.

## Ferramentas relacionadas

- [Solucionador numérico pelo método de Euler (EDO 1ª ordem)](https://elysiatools.com/pt/tools/euler-method-solver): Resolve o problema de valor inicial dy/dx = f(x,y), y(x₀)=y₀ pelo método de Euler explícito: y_{n+1} = y_n + h·f(x_n, y_n), com tabela passo a passo e estimativa final. A solução exata y(x), opcional, adiciona uma coluna de erro que evidencia o erro global O(h) do método de primeira ordem. Exemplo: dy/dx = y, y(0)=1, h=0,1 → y(1) ≈ 1,1¹⁰ = 2,593742 contra e = 2,718282 (erro 0,124539).
- [Calculadora de diferenciação numérica (diferenças progressiva/retroativa/central)](https://elysiatools.com/pt/tools/numerical-differentiation): Aproxima f′(x₀) com três diferenças finitas: progressiva (f(x₀+h)−f(x₀))/h, retroativa (f(x₀)−f(x₀−h))/h e central (f(x₀+h)−f(x₀−h))/(2h), além da segunda derivada central. A derivada exata, opcional, adiciona o erro absoluto de cada método e mostra o contraste O(h) vs. O(h²). Exemplo: f=x², x₀=1, h=0,1 → progressiva 2,1; retroativa 1,9; central exatamente 2,0.
- [Calculadora de intervalo interquartil](https://elysiatools.com/pt/tools/interquartile-range-calculator): Calcula Q1, Q3, IQR e limites opcionais de 1.5 x IQR
- [Calculadora de quartis](https://elysiatools.com/pt/tools/quartile-calculator): Calcula Q1, mediana, Q3, intervalo interquartil e limites opcionais de outliers
- [Solucionador de EDO de primeira ordem (separação de variáveis)](https://elysiatools.com/pt/tools/first-order-ode-solver): Resolve dy/dx = g(x)·h(y) por separação de variáveis: separa, integra termo a termo obtendo H(y) = G(x) + C e, quando possível, isola y = f(x). Aceita h(y) de um termo (y, y^n, e^(ky), ky+m) e polinômios quadráticos decomponíveis em frações parciais (como o logístico y(1−y)); com a condição inicial y(x₀)=y₀ calcula C e detecta soluções de equilíbrio. Exemplo: dy/dx = 2x·y → y = e^(x²+C).
- [Construtor de Simulação Monte Carlo](https://elysiatools.com/pt/tools/monte-carlo-simulation-builder): Defina distribuições de entrada (normal/uniforme/lognormal/triangular), escreva uma fórmula, execute milhares de ensaios e obtenha o histograma com intervalos de confiança.
- [Calculadora de raízes por Newton-Raphson](https://elysiatools.com/pt/tools/newton-raphson-root-finder): Resolve f(x) = 0 com a iteração de Newton-Raphson x_{k+1} = x_k − f(x_k)/f'(x_k): a derivada pode ser dada analiticamente (se ficar vazia, usa-se uma diferença central numérica); são exibidos a tabela de iterações (x_k e f(x_k)), o critério de paragem (|f| < tolerância ou |Δx| < tolerância·max(1,|x|)), o número de iterações e o |f(raiz)| final. Clássicos: x²−2 a partir de x₀=1 converge em 4 passos para √2 ≈ 1.4142135624; cos(x)−x converge para o número de Dottie 0.7390851332. Derivada nula, passos divergentes ou exceder o limite de iterações são reportados explicitamente.
- [Integrador pela regra de Simpson (∫f(x)dx)](https://elysiatools.com/pt/tools/numerical-integration-simpson): Calcula ∫ₐᵇ f(x)dx pela regra de Simpson 1/3 composta (n par): S = h/3·(f(a) + 4Σnós ímpares + 2Σnós pares interiores + f(b)), com erro O(h⁴) e exata para polinômios de grau ≤ 3. Tabela por nós, estimativa e comparação opcional com o valor exato. Exemplos: ∫₀¹x²dx com n=4 dá 0,333333 (exata!); ∫₀¹e^(−x²)dx (sem primitiva elementar) com n=10 dá 0,746825.

## Exemplos

- [Exemplos de Processamento de Imagem Android Java](https://elysiatools.com/pt/samples/android-image-processing-java): Exemplos de processamento de imagem Android Java incluindo leitura/escrita, dimensionamento e conversão de formato
- [Exemplos de Processamento de Imagem Android Kotlin](https://elysiatools.com/pt/samples/android-image-processing-kotlin): Exemplos de processamento de imagem Android Kotlin incluindo leitura/escrita, dimensionamento e conversão de formato
- [Exemplos de Processamento de Imagem Web Python](https://elysiatools.com/pt/samples/web-image-processing-python): Exemplos de processamento de imagem Web Python usando PIL/Pillow incluindo leitura, salvamento, redimensionamento e conversão de formato
- [Exemplos de Processamento de Imagem Web Rust](https://elysiatools.com/pt/samples/web-image-processing-rust): Exemplos de processamento de imagem Web Rust incluindo leitura/gravação, redimensionamento e conversão de formato