宏 - 生成 4 位查找表答案

【问题标题】：Macro - Generating look up table for 4 bits宏 - 生成 4 位查找表
【发布时间】：2018-07-14 19:26:01
【问题描述】：

下面是位反转的查找表（8位）

  static const unsigned char BitReverseTable256[256] = 
{
  #   define R2(n)     n,     n + 2*64,     n + 1*64,     n + 3*64
  #   define R4(n) R2(n), R2(n + 2*16), R2(n + 1*16), R2(n + 3*16)
  #   define R6(n) R4(n), R4(n + 2*4 ), R4(n + 1*4 ), R4(n + 3*4 )
      R6(0), R6(2), R6(1), R6(3)
};

下面的链接解释了它背后的算法。但我没有完全理解它。 Look-up table for 8 bit reversal

我想要类似的 4 位反转宏，这样我就可以理解 8 位。有人可以为 4 位反转提供相同的宏吗？

谢谢，

【问题讨论】：

可以通过适配8位版本来提供。试试看吧。
创建它的最佳方法是自己弄清楚如何去做。想想你需要什么。阵列将有多大？每个单元格中的值应该是什么？所示代码每次调用R2 生成4 个值；你的R2 的模拟应该创建多少？您确定基于宏的解决方案是反转 4 位值的好主意吗？

标签： c macros bit

【解决方案1】：

对于 4 位整数，查找表的大小为 16，即pow(2, 4)。我将从手动枚举开始，以便我们可以找出是否存在模式：

Integer  Binary Representation  Reverse Binary Representation   Reverse Value

0            0000                        0000                        0
1            0001                        1000                        8
2            0010                        0100                        4
3            0011                        1100                        12
4            0100                        0010                        2
5            0101                        1010                        10
6            0110                        0110                        6
7            0111                        1110                        14
8            1000                        0001                        1
9            1001                        1001                        9 
10           1010                        0101                        5
11           1011                        1101                        13
12           1100                        0011                        3
13           1101                        1011                        11
14           1110                        0111                        7
15           1111                        1111                        15

请注意，在Reverse Binary Representation 列中，最左边（最高有效 2 位）以相同的方式增加，即每四次增加一次 00 10 01 11。

同样，请注意，在Reverse Binary Representation 列中，最右边（最低有效 2 位）也采用相同的模式，即 00 10 01 11，但一次四次。

数字，0123，二进制是00011011，如果你颠倒每个：@9876543@35@987643736@987643736 @11，你懂的，0213！

0213 应该是构建块，我们将使用以下等式进行概括：

n、n + 2 * 4、n + 1 * 4、n + 3 * 4

提示：尝试使用上面的等式推导列Reverse Value。例子，前四个值来自 n = 0

0         = 0
0 + 2 * 4 = 8
0 + 1 * 4 = 4
0 + 3 * 4 = 12

我好久没写C了，但我想你应该有（我有待纠正）：

static const unsigned char BitReverseTable[16] = 
{
     define R2(n) n, n + 2*4, n + 1*4, n + 3*4
     R2(0), R2(2), R2(1), R2(3)
};

在 Python 中：

def R2(n, FOUR_BIT_LUT):
    FOUR_BIT_LUT.extend([n, n + 2 * 4, n + 1 * 4, n + 3 * 4])


def LOOK_UP(FOUR_BIT_LUT):
    return (
        R2(0, FOUR_BIT_LUT),
        R2(2, FOUR_BIT_LUT),
        R2(1, FOUR_BIT_LUT),
        R2(3, FOUR_BIT_LUT),
    )


FOUR_BIT_LUT = list()
LOOK_UP(FOUR_BIT_LUT)

print(FOUR_BIT_LUT) # [0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15]

但是，对于 4 位，基于宏的解决方案可能有点过头了。您可以只初始化一个反向值数组。

无论如何，我希望这能帮助您理解这种模式。

【讨论】：