Voltear la respuesta al impulso en convolución

Durante la convolución en una señal, ¿por qué necesitamos voltear la respuesta al impulso durante el proceso?

Adaptado de una respuesta a una pregunta diferente (como se menciona en un comentario) con la esperanza de que esta pregunta no sea planteada repetidamente por Community Wiki como una de las preguntas principales ...

No hay "volteo" de la respuesta al impulso por un sistema lineal (invariante en el tiempo). La salida de un sistema lineal invariante en el tiempo es la suma de versiones escaladas y retardadas en el tiempo de la respuesta al impulso, no la respuesta al impulso "invertida".

Desglosamos la señal de entrada $x$ en una suma de señales de pulso de unidad escalada. La respuesta del sistema a la señal de pulso de la unidad $\cdots, ~0, ~0, ~1, ~0, ~0, \cdots$ es la respuesta al impulso o la respuesta al pulso

$$h[0], ~h[1], \cdots, ~h[n], \cdots$$ y así propiedad de escala el valor de entrada único $x[0]$, o, si prefiere $$x[0](\cdots, ~0, ~0, ~1, ~0,~ 0, \cdots) = \cdots ~0, ~0, ~x[0], ~0, ~0, \cdots$$ crea una respuesta $$x[0]h[0], ~~x[0]h[1], \cdots, ~~x[0]h[n], \cdots$$

Del mismo modo, el valor de entrada único o crea x [ 1 ] ( ⋯ , 0 , 0 , 0 , 1 , 0 , ⋯ ) = ⋯ 0 , 0 , 0 , x [ 1 ] , 0 , ⋯ crea una respuesta 0 , x [ 1 ] h [ 0 ] , x [ $x[1]$

$$x[1](\cdots, ~0, ~0, ~0, ~1,~ 0, \cdots) = \cdots ~0, ~0, ~0, ~x[1], ~0, \cdots$$ Observe el retraso en la respuesta a x [ 1 ] . Podemos continuar más en este sentido, pero es mejor cambiar a una forma más tabular y mostrar las distintas salidas alineadas correctamente en el tiempo. Tenemos tiempo → 0 1 2 ⋯ n n + 1 ⋯ x $$0, x[1]h[0], ~~x[1]h[1], \cdots, ~~x[1]h[n-1], x[1]h[n] \cdots$$ $x[1]$ Las filas en la matriz anterior son precisamente las versiones escaladas y retrasadas de la respuesta de impulso que se suman a la respuestaya la señal de entradax. Pero si haces una pregunta más específica como $$\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}$$ $y$$x$

¿Cuál es la salida en el tiempo ?$n$

$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*}$$ $n$

Aquí hay un ejemplo de C / C ++ que muestra que la convolución se puede hacer sin usar la respuesta de impulso en reversa. Si inspecciona la convolve_scatter()función, no se niega ninguna variable en ninguna parte. Esta es una convolución de dispersión donde cada muestra de entrada se dispersa (suma) a múltiples muestras de salida en la memoria, utilizando pesos dados por la respuesta al impulso. Esto es un desperdicio porque las muestras de salida deberán leerse y escribirse varias veces.

Normalmente, la convolución se realiza como convolución de reunión , como en convolve_gather(). En este método, cada muestra de salida se forma por separado, reuniendo (sumando) muestras de entrada, con la respuesta de impulso invertida como los pesos. La muestra de salida reside en el registro de un procesador utilizado como acumulador mientras se hace esto. Normalmente, este es el método de elección, porque solo habrá una escritura de memoria por cada muestra filtrada. Ahora hay más lecturas de memoria de la entrada, pero solo tantas como lecturas de memoria de la salida en el método de dispersión.

#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();
}

Convoluciona las secuencias:

1 0 0 0 2
1 2 3

y usando ambos métodos de convolución salidas:

1 2 3 0 2 4 6

No puedo imaginar a nadie usando el método de dispersión, a menos que el filtro varíe en el tiempo, en cuyo caso los dos métodos producirán resultados diferentes y uno puede ser más apropiado.

Solo se 'voltea' para el cálculo puntual.

@Dilip explica lo que representa la integral / suma de convolución, pero para explicar por qué una de las dos funciones de entrada (a menudo h(t)) se invierte para fines de cálculo, considere un sistema de tiempo discreto con entrada x[n]y respuesta de impulso h[n]:

• Puede tomar su función de entrada x[n], y para cada muestra que no sea cero * x[n]calcule la respuesta de impulso escalada de la muestra ny así sucesivamente hasta que el cambio de tiempo se h[n]reduzca a cero (suponiendo un causal h[n]). Esto implicaría no 'voltear' (o más exactamente 'inversión de tiempo') de cualquiera x[n]o h[n]. Sin embargo, al final tendría que agregar / superponer todos estos 'ecos' escalados + desplazados de la respuesta de impulso para cada no-cero x[n].

• x[0]k

  $$\sum_{k=-\infty}^{\infty} x[k]h[n-k]$$ h[n]x[n], Que es x[0]h[0]. Luego, kal aumentar en uno, se desplazará h[n]hacia la derecha un paso de tiempo, de modo que la h[n]segunda entrada ( h[1]) de tiempo invertido ahora se colocará encima x[0], esperando ser multiplicada. Esto producirá la contribución deseada x[0]h[1]en el momento n=1, tal como se habría hecho en el método anterior.

---

x[n]

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

En el índice c [n], la convolución de a [n] yb [n] es tal que:

"c [n] es una suma de todos los productos (a [k] b [m]) tal que m + k = n", entonces m = n - k o k = n - m, lo que significa que una de las secuencias tiene que ser volteado.

Ahora, ¿por qué la convolución se comporta de esta manera en primer lugar? Debido a su conexión con la multiplicación de polinomios.

Multiplicar dos polinomios da como resultado un nuevo polinomio con coeficientes. Los coeficientes del polinomio del producto definen el funcionamiento de la convolución. Ahora, en el procesamiento de señales, las funciones de transferencia: las transformadas de Laplace o las transformadas z son estos polinomios, y cada coeficiente corresponde a un retardo de tiempo diferente. Unir los coeficientes del producto y los multiplicandos da como resultado el hecho de que "la multiplicación en una representación corresponde a la convolución en la representación transformada".

Durante la convolución, no debe producirse ningún "giro" de la respuesta al impulso ...

Sin embargo, si desea evitar cualquier alteración de fase, puede convolucionar una señal con una respuesta de impulso y luego revertir la respuesta de impulso y volver a convolucionar para cancelar los efectos de fase.

En el procesamiento fuera de línea, podría revertir la señal con la misma facilidad después de la primera convolución para llegar a la misma conclusión (como sugieren los comentarios).

$$\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$

$$\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)$$