Lật ngược đáp ứng xung trong tích chập

Trong quá trình tích chập trên một tín hiệu, tại sao chúng ta cần phải lật đáp ứng xung trong quá trình này?

Được chuyển thể từ một câu trả lời cho một câu hỏi khác (như được đề cập trong một bình luận) với hy vọng rằng câu hỏi này sẽ không bị Cộng đồng Wiki ném lên liên tục như một trong những Câu hỏi hàng đầu ....

Không có "lật" đáp ứng xung bởi hệ thống tuyến tính (bất biến thời gian). Đầu ra của hệ thống bất biến thời gian tuyến tính là tổng của các phiên bản thu nhỏ và trễ thời gian của đáp ứng xung, không phải là đáp ứng xung "lật".

Chúng tôi chia tín hiệu đầu vào thành tổng các tín hiệu xung đơn vị tỷ lệ. Phản hồi của hệ thống đối với tín hiệu xung đơn vị là đáp ứng xung hoặc đáp ứng xung và do đó, thuộc tính tỷ lệ , giá trị đầu vào đơn hoặc, nếu bạn thích tạo phản hồi ⋯ , 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 ] h [ 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$$

Tương tự, giá trị đầu vào đơn hoặc tạo tạo phản hồi Lưu ý độ trễ trong phản hồi với . Chúng ta có thể tiếp tục đi xa hơn trong tĩnh mạch này, nhưng tốt nhất là chuyển sang dạng bảng hơn và hiển thị các đầu ra khác nhau được căn chỉnh đúng thời gian. Chúng ta có $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 {mảng} Các hàng trong mảng trên chính xác là các phiên bản được thu nhỏ và bị trì hoãn của đáp ứng xung cộng với đáp ứng cho tín hiệu đầu vào . $y$$x$ Nhưng nếu bạn hỏi một câu hỏi cụ thể hơn như

Đầu ra tại thời điểm gì?$n$

sau đó bạn có thể nhận được câu trả lời bằng cách tóm tắt cột thứ để có được công thức tích chập được yêu thích làm rối loạn các thế hệ học sinh vì phản ứng thúc đẩy dường như bị "lật" hoặc chạy ngược thời gian. Nhưng, điều mà mọi người dường như quên là thay vào đó chúng ta có thể đã viết để đầu vào có vẻ như "bị lật" hoặc chạy ngược thời gian! Nói cách khác, đó là con người$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*}$$ người lật đáp ứng xung (hoặc đầu vào) khi tính toán đáp ứng tại thời điểm bằng cách sử dụng công thức tích chập, nhưng bản thân hệ thống không làm gì cả.$n$

Dưới đây là một ví dụ C / C ++ cho thấy rằng tích chập có thể được thực hiện mà không cần sử dụng đáp ứng xung theo chiều ngược lại. Nếu bạn kiểm tra convolve_scatter()chức năng, không có biến bị phủ định ở bất cứ đâu. Đây là tích chập tán xạ trong đó mỗi mẫu đầu vào được phân tán (tổng hợp) thành nhiều mẫu đầu ra trong bộ nhớ, sử dụng các trọng số được đưa ra bởi đáp ứng xung. Điều này là lãng phí vì các mẫu đầu ra sẽ cần phải được đọc và ghi lại nhiều lần.

Thông thường tích chập được thực hiện như thu thập chập, như trong convolve_gather(). Trong phương pháp này, mỗi mẫu đầu ra được hình thành riêng biệt, bằng cách thu thập (tổng hợp) cho mẫu đầu vào, với đáp ứng xung đảo ngược là trọng số. Mẫu đầu ra nằm trong thanh ghi của bộ xử lý được sử dụng làm bộ tích lũy trong khi việc này được thực hiện. Đây thường là phương pháp được lựa chọn, vì sẽ chỉ có một bộ nhớ ghi cho mỗi mẫu được lọc. Bây giờ có nhiều lần đọc bộ nhớ hơn của đầu vào, nhưng chỉ có nhiều lần đọc bộ nhớ của đầu ra trong phương thức tán xạ.

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

Nó kết hợp các chuỗi:

1 0 0 0 2
1 2 3

và sử dụng cả hai phương thức đầu ra chập:

1 2 3 0 2 4 6

Tôi không thể tưởng tượng bất cứ ai sử dụng phương pháp tán xạ, trừ khi bộ lọc thay đổi theo thời gian, trong trường hợp đó, hai phương pháp sẽ tạo ra kết quả khác nhau và một phương pháp có thể phù hợp hơn.

Nó chỉ 'lật' để tính toán theo chiều.

@Dilip giải thích những gì tích phân / tổng tích chập thể hiện, nhưng để giải thích tại sao một trong hai hàm đầu vào (thường h(t)) được lật cho mục đích tính toán, hãy xem xét một hệ thống thời gian rời rạc với x[n]đáp ứng đầu vào và xung h[n]:

• Bạn có thể lấy hàm đầu vào của mình x[n]và với mỗi mẫu khác không * x[n]tính toán đáp ứng xung theo tỷ lệ từ mẫu nvà tiếp tục cho đến khi thời gian thay đổi h[n]giảm xuống 0 (giả sử là nguyên nhân h[n]). Điều này sẽ liên quan đến việc không 'lật' (hay chính xác hơn là 'đảo ngược thời gian') x[n]hoặc h[n]. Tuy nhiên, cuối cùng, bạn sẽ phải thêm / chồng tất cả các tỷ lệ + thay đổi 'echos' của đáp ứng xung cho mỗi khác không x[n].

• x[0]k

  $$\sum_{k=-\infty}^{\infty} x[k]h[n-k]$$ h[n]x[n], đó là x[0]h[0]. Sau đó, tăng dần ktheo một bước sẽ chuyển h[n]sang bước một lần đúng, sao cho h[n]mục nhập thứ hai của s đảo ngược thời gian ( h[1]) bây giờ sẽ được đặt lên trên cùng x[0], chờ đợi để được nhân lên. Điều này sẽ mang lại sự đóng góp mong muốn x[0]h[1]tại thời điểm n=1, giống như đã được thực hiện trong phương pháp trước đó.

---

x[n]

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

Tại chỉ số c [n], tích chập của a [n] và b [n], sao cho:

"c [n] là tổng của tất cả các sản phẩm (a [k] b [m]) sao cho m + k = n," vì vậy m = n - k hoặc k = n - m, có nghĩa là một trong các chuỗi phải được lật

Bây giờ tại sao chập chững lại hành xử theo cách này ngay từ đầu? Bởi vì kết nối của nó với đa thức nhân.

Nhân hai đa thức dẫn đến một đa thức mới với các đồng hiệu quả. Các hệ số của đa thức sản phẩm xác định hoạt động của tích chập. Bây giờ, trong xử lý tín hiệu, các hàm truyền - Biến đổi Laplace hoặc biến đổi z là các đa thức này, với mỗi hệ số tương ứng với độ trễ thời gian khác nhau. Việc kết hợp các hệ số của sản phẩm và bội số dẫn đến thực tế là 'phép nhân trong một biểu diễn tương ứng với tích chập trong biểu diễn được chuyển đổi'.

Trong quá trình tích chập, không có hiện tượng "lật" đáp ứng xung nào xảy ra cả ...

Tuy nhiên, nếu bạn muốn ngăn chặn bất kỳ sự thay đổi pha nào, bạn có thể kết hợp tín hiệu với đáp ứng xung và sau đó đảo ngược đáp ứng xung và kết hợp lại để hủy hiệu ứng pha.

Trong xử lý ngoại tuyến, bạn có thể dễ dàng đảo ngược tín hiệu sau lần tích chập đầu tiên để đi đến kết luận tương tự (như các ý kiến ​​đề xuất).

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