使用矩阵法的圆形卷积

给定两个长度分别为N和M 的数组X[]和H[] ，任务是使用矩阵方法找到给定数组的循环卷积。循环移位矩阵和列向量的乘法是数组的循环卷积。
例子：

Input: X[] = {1, 2, 4, 2}, H[] = {1, 1, 1} 
Output: 7 5 7 8
Input: X[] = {5, 7, 3, 2}, H[] = {1, 5} 
Output: 15 32 38 17 
 

解释：

• 使用长度最大的数组元素（在本例中为 X _n ），其中 K 为 MAX(N, M)，创建 K * K 的循环移位矩阵circle_shift_mat 。

数组 X _{n 的}循环移位矩阵。

• 创建一个长度为 K 的列向量col_vec
• 将数组 H _m的元素插入 col_vec 的位置 [0, m)。
• 由于 K = max(N, M)，这里是 N； M < K。因此将 col_vec [m, K) 的其余位置填充为 0。因此 col_vec 将是

col_vec = { 1, 1, 1, 0 }

• 乘circular_shift_mat和col_vec
• 循环移位矩阵 (circular_shift_mat) 和列向量 (col_vec) 的乘法是数组的循环卷积。

方法：

• 使用最大长度数组的元素创建 N * N 的循环移位矩阵。
• 使用另一个数组的元素创建一个长度为 N 的列向量，并用 0 填充其余位置。
• 矩阵和列向量的乘法是数组的循环卷积。

下面是上述方法的实现。

C++

// C++ program to compute circular
// convolution of two arrays
#include 
using namespace std;
 
#define MAX_SIZE 10
 
// Function to find circular convolution
void convolution(int* x, int* h, int n, int m)
{
    int row_vec[MAX_SIZE], col_vec[MAX_SIZE];
    int out[MAX_SIZE] = { 0 };
    int circular_shift_mat[MAX_SIZE][MAX_SIZE];
 
    // Finding the maximum size between the
    // two input sequence sizes
    int maxSize = n > m ? n : m;
 
    // Copying elements of x to row_vec and padding
    // zeros if size of x < maxSize
    for (int i = 0; i < maxSize; i++) {
        if (i >= n) {
            row_vec[i] = 0;
        }
        else {
            row_vec[i] = x[i];
        }
    }
 
    // Copying elements of h to col_vec and padding
    // zeros if size of h is less than maxSize
    for (int i = 0; i < maxSize; i++) {
        if (i >= m) {
            col_vec[i] = 0;
        }
        else {
            col_vec[i] = h[i];
        }
    }
 
    // Generating 2D matrix of
    // circularly shifted elements
    int k = 0, d = 0;
 
    for (int i = 0; i < maxSize; i++) {
        int curIndex = k - d;
        for (int j = 0; j < maxSize; j++) {
            circular_shift_mat[j][i] = row_vec
                [curIndex % maxSize];
            curIndex++;
        }
        k = maxSize;
        d++;
    }
 
    // Computing result by matrix
    // multiplication and printing results
    for (int i = 0; i < maxSize; i++) {
        for (int j = 0; j < maxSize; j++) {
 
            out[i] += circular_shift_mat[i][j]
                      * col_vec[j];
        }
        cout << out[i] << " ";
    }
}
 
// Driver program
int main()
{
    int x[] = { 5, 7, 3, 2 };
    int n = sizeof(x) / sizeof(int);
    int h[] = { 1, 5 };
    int m = sizeof(h) / sizeof(int);
 
    convolution(x, h, n, m);
 
    return 0;
}

Java

// Java program to compute circular
// convolution of two arrays
class GFG
{
    final static int MAX_SIZE = 10 ;
     
    // Function to find circular convolution
    static void convolution(int []x, int []h, int n, int m)
    {
        int row_vec[] = new int[MAX_SIZE];
        int col_vec[] = new int[MAX_SIZE];
        int out[] = new int [MAX_SIZE];
        int circular_shift_mat[][] = new int[MAX_SIZE][MAX_SIZE];
     
        // Finding the maximum size between the
        // two input sequence sizes
        int maxSize = n > m ? n : m;
     
        // Copying elements of x to row_vec and padding
        // zeros if size of x < maxSize
        for (int i = 0; i < maxSize; i++)
        {
            if (i >= n)
            {
                row_vec[i] = 0;
            }
            else
            {
                row_vec[i] = x[i];
            }
        }
     
        // Copying elements of h to col_vec and padding
        // zeros if size of h is less than maxSize
        for (int i = 0; i < maxSize; i++)
        {
            if (i >= m)
            {
                col_vec[i] = 0;
            }
            else
            {
                col_vec[i] = h[i];
            }
        }
     
        // Generating 2D matrix of
        // circularly shifted elements
        int k = 0, d = 0;
     
        for (int i = 0; i < maxSize; i++)
        {
            int curIndex = k - d;
            for (int j = 0; j < maxSize; j++)
            {
                circular_shift_mat[j][i] =
                row_vec[curIndex % maxSize];
                curIndex++;
            }
            k = maxSize;
            d++;
        }
     
        // Computing result by matrix
        // multiplication and printing results
        for (int i = 0; i < maxSize; i++)
        {
            for (int j = 0; j < maxSize; j++)
            {
     
                out[i] += circular_shift_mat[i][j] * col_vec[j];
            }
            System.out.print(out[i] + " ");
        }
    }
     
    // Driver program
    public static void main (String[] args)
    {
        int x[] = { 5, 7, 3, 2 };
        int n = x.length;
        int h[] = { 1, 5 };
        int m = h.length;
     
        convolution(x, h, n, m);
    }
}
 
// This code is contributed by AnkitRai01

Python3

# Python program to compute circular
# convolution of two arrays
MAX_SIZE = 10;
 
# Function to find circular convolution
def convolution(x, h, n, m):
    row_vec = [0] * MAX_SIZE;
    col_vec = [0] * MAX_SIZE;
    out = [0] * MAX_SIZE;
    circular_shift_mat = [[0 for i in range(MAX_SIZE)]
                            for j in range(MAX_SIZE)] ;
 
    # Finding the maximum size between the
    # two input sequence sizes
    if(n > m ):
        maxSize = n;
    else:
        maxSize = m;
 
    # Copying elements of x to row_vec and padding
    # zeros if size of x < maxSize
    for i in range(maxSize):
        if (i >= n):
            row_vec[i] = 0;
        else:
            row_vec[i] = x[i];
         
    # Copying elements of h to col_vec and padding
    # zeros if size of h is less than maxSize
    for i in range(maxSize):
        if (i >= m):
            col_vec[i] = 0;
        else:
            col_vec[i] = h[i];
         
    # Generating 2D matrix of
    # circularly shifted elements
    k = 0;
    d = 0;
 
    for i in range(maxSize):
        curIndex = k - d;
        for j in range(maxSize):
            circular_shift_mat[j][i] = \
            row_vec[curIndex % maxSize];
            curIndex += 1;
         
        k = maxSize;
        d += 1;
 
    # Computing result by matrix
    # multiplication and printing results
    for i in range(maxSize):
        for j in range(maxSize):
            out[i] += circular_shift_mat[i][j] * \
                                    col_vec[j];
         
        print(out[i], end = " ");
 
# Driver program
if __name__ == '__main__':
    x = [ 5, 7, 3, 2 ];
    n = len(x);
    h = [ 1, 5 ];
    m = len(h);
 
    convolution(x, h, n, m);
     
# This code is contributed by 29AjayKumar

C#

// C# program to compute circular
// convolution of two arrays
using System;
 
class GFG
{
    readonly static int MAX_SIZE = 10 ;
     
    // Function to find circular convolution
    static void convolution(int []x, int []h,
                            int n, int m)
    {
        int []row_vec = new int[MAX_SIZE];
        int []col_vec = new int[MAX_SIZE];
        int []out_ = new int [MAX_SIZE];
        int [,]circular_shift_mat =
            new int[MAX_SIZE,MAX_SIZE];
     
        // Finding the maximum size between the
        // two input sequence sizes
        int maxSize = n > m ? n : m;
     
        // Copying elements of x to row_vec and padding
        // zeros if size of x < maxSize
        for (int i = 0; i < maxSize; i++)
        {
            if (i >= n)
            {
                row_vec[i] = 0;
            }
            else
            {
                row_vec[i] = x[i];
            }
        }
     
        // Copying elements of h to col_vec and padding
        // zeros if size of h is less than maxSize
        for (int i = 0; i < maxSize; i++)
        {
            if (i >= m)
            {
                col_vec[i] = 0;
            }
            else
            {
                col_vec[i] = h[i];
            }
        }
     
        // Generating 2D matrix of
        // circularly shifted elements
        int k = 0, d = 0;
     
        for (int i = 0; i < maxSize; i++)
        {
            int curIndex = k - d;
            for (int j = 0; j < maxSize; j++)
            {
                circular_shift_mat[j, i] =
                row_vec[curIndex % maxSize];
                curIndex++;
            }
            k = maxSize;
            d++;
        }
     
        // Computing result by matrix
        // multiplication and printing results
        for (int i = 0; i < maxSize; i++)
        {
            for (int j = 0; j < maxSize; j++)
            {
     
                out_[i] += circular_shift_mat[i, j] *
                            col_vec[j];
            }
            Console.Write(out_[i] + " ");
        }
    }
     
    // Driver program
    public static void Main(String[] args)
    {
        int []x = {5, 7, 3, 2};
        int n = x.Length;
        int []h = {1, 5};
        int m = h.Length;
     
        convolution(x, h, n, m);
    }
}
 
// This code is contributed by PrinciRaj1992

Javascript

 
    // JavaScript program to compute circular
    // convolution of two arrays
     
    let MAX_SIZE = 10 ;
       
    // Function to find circular convolution
    function convolution(x, h, n, m)
    {
        let row_vec = new Array(MAX_SIZE);
        row_vec.fill(0);
        let col_vec = new Array(MAX_SIZE);
        col_vec.fill(0);
        let out = new Array(MAX_SIZE);
        out.fill(0);
        let circular_shift_mat = new Array(MAX_SIZE);
        circular_shift_mat.fill(0);
        for (let i = 0; i < MAX_SIZE; i++)
        {
            circular_shift_mat[i] = new Array(MAX_SIZE);
            for (let j = 0; j < MAX_SIZE; j++)
            {
                circular_shift_mat[i][j] = 0;
            }
        }
       
        // Finding the maximum size between the
        // two input sequence sizes
        let maxSize = n > m ? n : m;
       
        // Copying elements of x to row_vec and padding
        // zeros if size of x < maxSize
        for (let i = 0; i < maxSize; i++)
        {
            if (i >= n)
            {
                row_vec[i] = 0;
            }
            else
            {
                row_vec[i] = x[i];
            }
        }
       
        // Copying elements of h to col_vec and padding
        // zeros if size of h is less than maxSize
        for (let i = 0; i < maxSize; i++)
        {
            if (i >= m)
            {
                col_vec[i] = 0;
            }
            else
            {
                col_vec[i] = h[i];
            }
        }
       
        // Generating 2D matrix of
        // circularly shifted elements
        let k = 0, d = 0;
       
        for (let i = 0; i < maxSize; i++)
        {
            let curIndex = k - d;
            for (let j = 0; j < maxSize; j++)
            {
                circular_shift_mat[j][i] =
                row_vec[curIndex % maxSize];
                curIndex++;
            }
            k = maxSize;
            d++;
        }
       
        // Computing result by matrix
        // multiplication and printing results
        for (let i = 0; i < maxSize; i++)
        {
            for (let j = 0; j < maxSize; j++)
            {
       
                out[i] += circular_shift_mat[i][j] * col_vec[j];
            }
            document.write(out[i] + " ");
        }
    }
     
    let x = [ 5, 7, 3, 2 ];
    let n = x.length;
    let h = [ 1, 5 ];
    let m = h.length;
 
    convolution(x, h, n, m);
     

输出：

15 32 38 17

时间复杂度： O(MAX_SIZE * MAX_SIZE)
辅助空间： O(MAX_SIZE * MAX_SIZE)

如果您希望与专家一起参加现场课程，请参阅DSA 现场工作专业课程和学生竞争性编程现场课程。