Question

虽然“卷积是频域中的乘法”，但它们似乎也是字面意义上的乘法。例如，如果我在内存中相邻的数字与某种列表相邻：

5:  (byte) 00000101
22: (byte) 00010110
7:  (byte) 00000111
8:  (byte) 00001000

Becomes:

(Int32) 00000101000101100000011100001000

然后将此结果列表/数字乘以另一个这样的列表，结果是一个列表与另一个列表的卷积。以下C＃程序演示了这一点：

using System;

public class Program
{
    public static void Main(string[] args)
    {
        var A = new byte[]{1, 2, 3, 4, 5, 6, 7, 8};
        var a = combine_to_Int64(A);
        var B = new byte[]{1, 2, 3, 4, 5, 6, 7, 8};
        var b = combine_to_Int64(B);
        var c = a * b;
        var C = separate_to_8_byte(c);
        var d = deconvolution(c, b); // not correct
        var D = separate_to_8_byte(d);
        Console.WriteLine(
            "The convolution of (" + to_string(A) + ") with ("
            + to_string(B) + ") is: (" + to_string(C) + ")");
        Console.WriteLine(
            "The deconvolution of (" + to_string(C) + ") with ("
            + to_string(B) + ") is: (" + to_string(D) + ")");
    }

    public static Int64 convolution(Int64 a, Int64 b)
    {
        return a * b;
    }

    private static Int64 combine_to_Int64(byte[] n)
    {
        if (n.Length == 4)
            return n[0] + 65536 * n[1] + 4294967296 * n[2] +
                281474976710656 * n[3];
        else if (n.Length == 8)
            return n[0] + 256 * n[1] + 65536 * n[2] + 16777216 * n[3] +
                4294967296 * n[4] + 1099511627776 * n[5] +
                281474976710656 * n[6] + 72057594037927936 * n[7];
        else
            throw new ArgumentException();
    }

    private static Int16[] separate_to_4_Int16(Int64 a)
    {
        return new []{(Int16) a, (Int16) (a >> 0x10),
            (Int16) (a >> 0x20), (Int16) (a >> 0x30)};
    }

    private static byte[] separate_to_8_byte(Int64 a)
    {
        return new []{(byte) a, (byte) (a >> 8), (byte) (a >> 0x10),
            (byte) (a >> 0x18), (byte) (a >> 0x20), (byte) (a >> 0x28),
            (byte) (a >> 0x30), (byte) (a >> 0x38)};
    }

    public static string to_string(byte[] values)
    {
        string s = "";
        foreach (var val in values)
            s += (s == "" ? "" : " ") + val;
        return s;
    }

    public static string to_string(Int16[] values)
    {
        string s = "";
        foreach (var val in values)
            s += (s == "" ? "" : " ") + val;
        return s;
    }

    // ---

    public static Int64 deconvolution(Int64 a, Int64 b)
    {
        var large = System.Numerics.BigInteger.Parse(
            "1000000000000000000000000000000");
        return (Int64)(((
            (new System.Numerics.BigInteger(a) * large)
            / new System.Numerics.BigInteger(b))
            * 72057594037927936) / large);
    }
}

请尝试以下代码：rextester.com/YPKFA14408

输出结果为：

The convolution of (1 2 3 4 5 6 7 8) with (1 2 3 4 5 6 7 8) is: (1 4 10 20 35 56 84 120)

The deconvolution of (1 4 10 20 35 56 84 120) with (1 2 3 4 5 6 7 8) is: (219 251 194 172 10 94 253 14)

可以在此处找到输出第一行正确的演示：https://oeis.org/A000292

“整数序列在线百科全书”......“四面体（或三角锥体）数字”......“自然数字与自身的卷积。” - Felix Goldberg“

问：所提供的代码中的反卷积功能有什么问题，或者我对结果的理解是什么？

Answer 1

差别在于。

将输入视为多项式...

00000101 becomes x^2 + x^0
00000111 becomes x^2 + x^1 + x^0

多项式乘法和卷积完全相同的操作（让x为z ^-1，z变换原语为延迟...现在乘法正在进行毕竟放在转换域中

但算术乘法与多项式乘法不同，因为携带。

的结果

(x^1 + x^0) * (x^1 + x^0)

是

x^2 + 2 x^1 + x^0

确实是卷积

conv([1 1], [1 1]) = [1 2 1]

但是

0011 * 0011

同样

0100 + 2 * 0010 + 0001

在算术中，2 * 0010变为0100，最终结果为

与卷积（多项式乘法）完全不同，因为发生了携带。

算术结果仅在x = 2时保留...但在卷积中x 必须为时间延迟运算符。

如果使用8位组，每组代表一次样本的幅度，则会产生相同的效果。组内的算术是可以的，但只要你有一个跨越组边界的进位，卷积和乘法之间的等价就会丢失。

通过乘以内存中的数字列表进行卷积，所以采用反卷积算法？

1 个答案: