一种优雅的方法来找到 2 的幂

Question

我的问题和Fastest way of computing the power that a "power of 2" number used?很相似：

将x=2^y 作为输入，我想输出y。 不同之处在于我使用 C 而不是 C++ 进行编码，而且我确信我的输入中只有一个位设置，所以我想知道是否有更有效的方法来解决这个问题。

这是我的尝试：

unsigned int get_power_of_two(unsigned int x)
{
    unsigned int y=0;
    for(unsigned int input=x; input>0; input=input>>1)
    {
        if(input & 1U)
        {
            break;
        }
        y++;
    }
    return y;
}

与@Dave 的答案中建议的查找表相比，这种效率是多少？ （同样，我用 C 编码，所以我没有像 lower_bound 这样的迭代器函数）

Answer 1

您的算法的效率是O(log x)，而Dave（执行二的幂次方搜索）的效率是O(log log x)。所以他的速度越来越快。

当然，最快的方法是使用BSF 指令。

Answer 2

除了前面所说的其他方式，例如严格依赖底层ISA的BSF或CLZ指令，还有一些其他方式，例如：

http://graphics.stanford.edu/~seander/bithacks.html#IntegerLogObvious

事实上，你可以在这里找到很多“小技巧”。

Answer 3

作为旁注，您应该考虑将函数 get_power_of_two 重命名为 get_log_two。

如果你经常调用这个函数，那么你可以初始化一个相对较小的查找表。

使用此表，您可以逐字节检查每个输入的数字，如下所示：

#include <limits.h>

static unsigned int table[1<<CHAR_BIT];

void init_table() // should be called once
{
    for (unsigned int n=0; n<CHAR_BIT; n++)
        table[1<<n] = n;
}

unsigned int get_log_two(unsigned int x)
{
    for (unsigned int n=0; x>0; n+=CHAR_BIT, x>>=CHAR_BIT)
    {
        unsigned int y = x & ((1<<CHAR_BIT)-1);
        if (y > 0)
            return n+table[y];
    }
    return ~0; // will never be reached during runtime
}

就“纯粹的学术复杂性”而言，这不一定是最有效的方法，因为函数 get_log_two 不执行二进制搜索。

尽管如此，考虑到sizeof(unsigned int) 在任何平台上的相对较小的值（通常为 4），它在平均情况和最坏情况下的性能几乎相同。

Answer 4

在您的情况下，因为您知道只设置了一位，因此计算尾随零就足够了。这可以在没有硬件指令的情况下非常快速地完成。看看这个answer，这就是下面代码的来源（我不是一个篡改完美的人......有时）。

unsigned v;  // this is the number with one bit set
unsigned r;  // this becomes the exponent in v == pow(2, r)
static const unsigned MultiplyDeBruijnBitPosition[32] = 
{
  0, 1, 28, 2, 29, 14, 24, 3, 30, 22, 20, 15, 25, 17, 4, 8, 
  31, 27, 13, 23, 21, 19, 16, 7, 26, 12, 18, 6, 11, 5, 10, 9
};
r = MultiplyDeBruijnBitPosition[((unsigned)((v & -v) * 0x077CB531U)) >> 27];

在您的情况下，因为v 只有一个位集，所以您不需要找到最低位集；因此你可以跳过v & -v。你的代码版本变成了这样：

unsigned v;  // this is the number with one bit set
unsigned r;  // this becomes the exponent in v == pow(2, r)
static const unsigned MultiplyDeBruijnBitPosition[32] = 
{
  0, 1, 28, 2, 29, 14, 24, 3, 30, 22, 20, 15, 25, 17, 4, 8, 
  31, 27, 13, 23, 21, 19, 16, 7, 26, 12, 18, 6, 11, 5, 10, 9
};
r = MultiplyDeBruijnBitPosition[(v * 0x077CB531U) >> 27];

查看链接了解更多信息，它又链接到它的源信息。

Answer 5

这是一个有趣的想法...

如果你知道只有 1 位设置，那为什么不使用开关呢？

unsigned int get_log_two(unsigned int x)
{
        switch(x)
        {
            case 1<<0: return 0;
            case 1<<1: return 1;
            case 1<<2: return 2;
            case 1<<3: return 3;
            case 1<<4: return 4;
            case 1<<5: return 5;
            case 1<<6: return 6;
            case 1<<7: return 7;
            case 1<<8: return 8;
            case 1<<9: return 9;
            case 1<<10: return 10;
            case 1<<11: return 11;
            case 1<<12: return 12;
            case 1<<13: return 13;
            case 1<<14: return 14;
            case 1<<15: return 15;
        }
        return 0;
}

将此扩展到31，您将拥有一个很好的功能。 这应该很快；但只有设置了一个位时才会起作用。