Inverter a resposta ao impulso em convolução

Durante a convolução em um sinal, por que precisamos inverter a resposta ao impulso durante o processo?

Adaptado de uma resposta para uma pergunta diferente (como mencionado em um comentário) na esperança de que essa pergunta não seja levantada repetidamente pelo Community Wiki como uma das principais perguntas ....

Não há "inversão" da resposta ao impulso por um sistema linear (invariável no tempo). A saída de um sistema linear invariável no tempo é a soma das versões escalonadas e atrasadas da resposta ao impulso, não a resposta ao impulso "invertida".

Dividimos o sinal de entrada em uma soma de sinais de pulso unitários em escala. A resposta do sistema ao sinal de pulso da unidade é a resposta de impulso ou resposta de pulso e, pela propriedade de escala, o valor de entrada único ou, se você preferir cria uma resposta ⋯ , 0 , 0 , 1 , 0 , 0 , ⋯ h [ 0 ] , h [ 1 ] , ⋯ , h [ n ] , ⋯ x [ 0 ] x [ 0 ] ( ⋯ , 0 , 0 , 1 , 0 , 0 , ⋯ ) = ⋯ 0 , 0 $x$$\cdots, ~0, ~0, ~1, ~0, ~0, \cdots$

$$h[0], ~h[1], \cdots, ~h[n], \cdots$$ $x[0]$ $$x[0](\cdots, ~0, ~0, ~1, ~0,~ 0, \cdots) = \cdots ~0, ~0, ~x[0], ~0, ~0, \cdots$$ $$x[0]h[0], ~~x[0]h[1], \cdots, ~~x[0]h[n], \cdots$$

Da mesma forma, o valor de entrada único ou cria cria uma resposta Observe o atraso na resposta para . Podemos continuar mais nesse sentido, mas é melhor mudar para uma forma mais tabular e mostrar as várias saídas alinhadas corretamente no tempo. Nós temos $x[1]$

$$x[1](\cdots, ~0, ~0, ~0, ~1,~ 0, \cdots) = \cdots ~0, ~0, ~0, ~x[1], ~0, \cdots$$ $$0, x[1]h[0], ~~x[1]h[1], \cdots, ~~x[1]h[n-1], x[1]h[n] \cdots$$ $x[1]$ $$\begin{array}{l|l|l|l|l|l|l|l} \text{time} \to & 0 &1 &2 & \cdots & n & n+1 & \cdots \\ \hline x[0] & x[0]h[0] &x[0]h[1] &x[0]h[2] & \cdots &x[0]h[n] & x[0]h[n+1] & \cdots\\ \hline x[1] & 0 & x[1]h[0] &x[1]h[1] & \cdots &x[1]h[n-1] & x[1]h[n] & \cdots\\ \hline x[2] & 0 & 0 &x[2]h[0] & \cdots &x[2]h[n-2] & x[2]h[n-1] & \cdots\\ \hline \vdots & \vdots & \vdots & \vdots & \ddots & \\ \hline x[m] & 0 &0 & 0 & \cdots & x[m]h[n-m] & x[m]h[n-m+1] & \cdots \\ \hline \vdots & \vdots & \vdots & \vdots & \ddots \end{array}$$ \ ddots \ end {array} As linhas no array acima são precisamente as versões em escala e atrasadas da resposta ao impulso que se somam à resposta ao sinal de entrada . $y$$x$ Mas se você fizer uma pergunta mais específica, como

Qual é a saída no tempo ?$n$

então você pode obter a resposta somando a ésima coluna para obter a amada fórmula de convolução que confunde gerações de estudantes, porque a resposta ao impulso parece estar "invertida" ou retrocedendo no tempo. Mas, o que as pessoas parecem esquecer é que, em vez disso, poderíamos ter escrito para que seja a entrada que parece "invertida" ou retrocedendo no tempo! Em outras palavras, são seres humanos$n$

$$\begin{align*} y[n] &= x[0]h[n] + x[1]h[n-1] + x[2]h[n-2] + \cdots + x[m]h[n-m] + \cdots\\ &= \sum_{m=0}^{\infty} x[m]h[n-m], \end{align*}$$ $$\begin{align*} y[n] &= x[n]h[0] + x[n-1]h[1] + x[n-2]h[2] + \cdots + x[0]h[n] + \cdots\\ &= \sum_{m=0}^{\infty} x[n-m]h[m], \end{align*}$$ que inverte a resposta de impulso (ou a entrada) ao calcular a resposta no tempo usando a fórmula de convolução, mas o próprio sistema não faz nada disso.$n$

Aqui está um exemplo de C / C ++ que mostra que a convolução pode ser feita sem o uso inverso da resposta ao impulso. Se você inspecionar a convolve_scatter()função, nenhuma variável será negada em qualquer lugar. Isso é convolução de dispersão, onde cada amostra de entrada é dispersa (somada) para várias amostras de saída na memória, usando pesos dados pela resposta ao impulso. Isso é um desperdício, porque as amostras de saída precisarão ser lidas e gravadas várias vezes.

Normalmente, a convolução é feita como convolução de coleta , como em convolve_gather(). Nesse método, cada amostra de saída é formada separadamente, reunindo (somando) amostras de entrada, com a resposta ao impulso reverso como pesos. A amostra de saída reside no registro de um processador usado como acumulador enquanto isso é feito. Normalmente, esse é o método de escolha, porque haverá apenas uma gravação de memória por cada amostra filtrada. Agora há mais leituras de memória da entrada, mas apenas quantas leituras de memória da saída no método de dispersão.

#include <stdio.h>

const int Nx = 5; 
const int x[Nx] = {1, 0, 0, 0, 2};
const int Ny = 3; 
const int y[Ny] = {1, 2, 3};
const int Nz = Nx+Ny-1;
int z[Nz];

void convolve_scatter() { // z = x conv y
  for (int k = 0; k < Nz; k++) {
    z[k] = 0;
  }
  for (int n = 0; n < Nx; n++) {
    for (int m = 0; m < Ny; m++) {
      z[n+m] += x[n]*y[m]; // No IR reversal
    }
  }
}

void convolve_gather() { // z = x conv y
  for (int k = 0; k < Nz; k++) {
    int accu = 0;
    for (int m = 0; m < Ny; m++) {
      int n = k+m - Ny + 1;
      if (n >= 0 && n < Nx) {
        accu += x[n]*y[Ny-m-1]; // IR reversed here
      }
    }
    z[k] = accu;
  }
}

void print() {
  for (int k = 0; k < Nz; k++) {
    printf("%d ", z[k]);
  }
  printf("\n");
}

int main() {
  convolve_scatter();
  print();
  convolve_gather();
  print();
}

Ele envolve as seqüências:

1 0 0 0 2
1 2 3

e usando as saídas dos dois métodos de convolução:

1 2 3 0 2 4 6

Não consigo imaginar alguém usando o método de dispersão, a menos que o filtro varie no tempo; nesse caso, os dois métodos produzirão resultados diferentes e um poderá ser mais apropriado.

É apenas 'invertido' para computação pontual.

O @Dilip explica o que a integral / soma de convolução representa, mas para explicar por que uma das duas funções de entrada (geralmente h(t)) é ativada para fins de computação, considere um sistema de tempo discreto com x[n]resposta de entrada e impulso h[n]:

• Você pode usar sua função de entrada x[n]e, para cada amostra diferente de zero *, x[n]calcular a resposta de impulso escalonada da amostra ne depois até que o deslocamento no tempo diminua h[n]para zero (assumindo um causal h[n]). Isso não envolveria 'inversão' (ou mais precisamente 'reversão de tempo') de um x[n]ou de outro h[n]. No entanto, no final, você teria que adicionar / sobrepor todos esses 'ecos' escalados + deslocados da resposta ao impulso para cada diferente de zero x[n].

• Ou , por conveniência, você pode reverter uma das funções sobre a origem da hora (geralmente 0), fazendo seu cálculo {multiplicar, adicionar, multiplicar, adicionar, ...} em vez de {multiplicar, multiplicar, ..., adicionar , adicionar, ...}. Isso resulta no mesmo sinal de saída, porque ele executará exatamente as mesmas operações de multiplicação e adição. Por exemplo, pense na contribuição da saída de um sinal de entrada diferente de zero no tempo 0 x[0]. Quando k= 0 para a equação a resposta ao impulso será revertida apenas no tempo, mas não deslocada, fornecendo a primeira resposta de amostra para a qual é . Então, incrementar um passo mudará para o passo certo uma vez, de modo que o tempo invertido

  $$\sum_{k=-\infty}^{\infty} x[k]h[n-k]$$ h[n]x[n]x[0]h[0]kh[n]h[n]A segunda entrada ( h[1]) estará agora em cima x[0], esperando para ser multiplicada. Isso produzirá a contribuição desejada x[0]h[1]no momento n=1, exatamente como teria sido feito no método anterior.

---

* Eu digo diferente de zero x[n]porque a resposta ao impulso é redimensionada para zero, contribuindo assim para a saída final .

$$\forall x[n] = 0$$ h[n]y[n]

No índice c [n], a convolução de a [n] e b [n] é tal que:

"c [n] é um somatório de todos os produtos (a [k] b [m]) tal que m + k = n", então m = n - k ou k = n - m, o que significa que uma das seqüências tem que ser invertido.

Agora, por que a convolução se comporta dessa maneira em primeiro lugar? Por causa de sua conexão com polinômios multiplicadores.

A multiplicação de dois polinômios resulta em um novo polinômio com coeficientes. Os coeficientes do polinômio do produto definem a operação de convolução. Agora, no processamento do sinal, as funções de transferência - transformadas de Laplace ou z-transformadas são esses polinômios, com cada coeficiente correspondendo a um atraso de tempo diferente. A combinação dos coeficientes do produto e dos multiplicandos resulta no fato de que "a multiplicação em uma representação corresponde à convolução na representação transformada".

Durante a convolução, nenhum "giro" da resposta ao impulso precisa ocorrer ...

No entanto, se você deseja impedir qualquer alteração de fase, pode distorcer um sinal com uma resposta de impulso e, em seguida, reverter a resposta de impulso e recolocar para cancelar os efeitos de fase.

No processamento off-line, você pode reverter o sinal facilmente após a primeira convolução para chegar à mesma conclusão (como sugerem os comentários).

Basta escrever a integral de convolução como um nomeadamente a integração do produto de e sobre todos os pares de argumento que soma de .

$$\int_{-\infty}^\infty f(\tau) g(t-\tau) d\tau$$ $$\iint\nolimits_{t_1+t_2 = t} f(t_1) \, g(t_2) \, dt_1\, dt_2$$ $f$$g$$t$

Agora, a forma de ondulação das mãos mostra claramente a simetria envolvida aqui e que não há "inversão". Converter isso em uma integral unidimensional adequada, no entanto, exige que um dos dois argumentos seja a variável de integração real. É isso ou encontrar uma forma simétrica rígida que não envolva a movimentação das mãos. O último é mais complicado. Basicamente, é necessário recuperar a normalização, criando algo (ao usar a função / distribuição do Dirac delta) como Se você reorganizar de uma maneira, obterá e da propriedade de peneiração do operador Dirac

$$\iint_{t_1,t_2} f(t_1)\,g(t_2)\,\delta(t-t_1-t_2)\,dt_1\,dt_2$$ $$\int_{t_1}f(t_1)\, dt_1\int_{t_2}g(t_2) \delta(t-t_1-t_2) \,dt_2$$ $$\int_{t_1}f(t_1)\,dt_1\,g(t-t_1)$$ que é a integral original com um pouco de renomeação.