Question

我正在为fft实现开发一个反转算法，到目前为止我的实现是

//assume the proper includes

template<unsigned long bits>
unsigned long&& bitreverse(unsigned long value){
    std::bitset<bits> input(value);
    std::bitset<bits> result;
    unsigned long j=input.size()-1;
    for (unsigned long i=0; i<input.size(); ++i) {
        result[i]=input[j];
        j--;
    }
    return std::move(result.to_ulong());
}

我需要能够反转N位字中的位。我当前的实现是有用的，但我想重新编写它，以便结果可以用作constexpr，函数签名需要是：

template<unsigned long bits>
constexpr unsigned long&& bitreverse(unsigned long value);

或：

template<unsigned long bits,unsigned long value>
constexpr unsigned long&& bitreverse();

或接近......

我不确定如何开始实施此功能。

如果可能的话，我想避免按位操作，但我并不反对它们。

由于

Answer 1

你可以这样做：

template <unsigned long bits>
constexpr unsigned long bitreverse(unsigned long value) {
    unsigned long result = 0;
    for (std::size_t i = 0, j = bits - 1; i < bits; ++i, --j) {
        result |= ((value & (1 << j)) >> j) << i;
    }
    return result;
}

我不确定为什么要为返回类型使用r值引用。它不会提高效率，我认为will result in a dangling reference。

Answer 2

嗯，这是显而易见的，＃34;蛮力＆＃34;方法

这假定实现上的unsigned long long数据类型是64位整数。对于32位平台，代码显然可以被删减。

观察bitreverse始终最初可以作为64位bitreverse处理，然后向右移动以从中获取正确的位数。

这有点冗长，但它的优势在于它足够简单，以至于大多数编译器可以在编译时咀嚼bitreverse常量。对于变量，这肯定会产生比迭代方法更多的代码，但现代CPU很可能能够毫不拖延地使用它，因为它们不必处理循环和分支预测。

template<unsigned long bits>
constexpr unsigned long long bitreverse(unsigned long long v)
{
    return (((v & 0x00000001ULL) << 63) |
        ((v & 0x00000002ULL) << 61) |
        ((v & 0x00000004ULL) << 59) |
        ((v & 0x00000008ULL) << 57) |
        ((v & 0x00000010ULL) << 55) |
        ((v & 0x00000020ULL) << 53) |
        ((v & 0x00000040ULL) << 51) |
        ((v & 0x00000080ULL) << 49) |
        ((v & 0x00000100ULL) << 47) |
        ((v & 0x00000200ULL) << 45) |
        ((v & 0x00000400ULL) << 43) |
        ((v & 0x00000800ULL) << 41) |
        ((v & 0x00001000ULL) << 39) |
        ((v & 0x00002000ULL) << 37) |
        ((v & 0x00004000ULL) << 35) |
        ((v & 0x00008000ULL) << 33) |
        ((v & 0x00010000ULL) << 31) |
        ((v & 0x00020000ULL) << 29) |
        ((v & 0x00040000ULL) << 27) |
        ((v & 0x00080000ULL) << 25) |
        ((v & 0x00100000ULL) << 23) |
        ((v & 0x00200000ULL) << 21) |
        ((v & 0x00400000ULL) << 19) |
        ((v & 0x00800000ULL) << 17) |
        ((v & 0x01000000ULL) << 15) |
        ((v & 0x02000000ULL) << 13) |
        ((v & 0x04000000ULL) << 11) |
        ((v & 0x08000000ULL) << 9) |
        ((v & 0x10000000ULL) << 7) |
        ((v & 0x20000000ULL) << 5) |
        ((v & 0x40000000ULL) << 3) |
        ((v & 0x80000000ULL) << 1) |
        ((v & 0x100000000ULL) >> 1) |
        ((v & 0x200000000ULL) >> 3) |
        ((v & 0x400000000ULL) >> 5) |
        ((v & 0x800000000ULL) >> 7) |
        ((v & 0x1000000000ULL) >> 9) |
        ((v & 0x2000000000ULL) >> 11) |
        ((v & 0x4000000000ULL) >> 13) |
        ((v & 0x8000000000ULL) >> 15) |
        ((v & 0x10000000000ULL) >> 17) |
        ((v & 0x20000000000ULL) >> 19) |
        ((v & 0x40000000000ULL) >> 21) |
        ((v & 0x80000000000ULL) >> 23) |
        ((v & 0x100000000000ULL) >> 25) |
        ((v & 0x200000000000ULL) >> 27) |
        ((v & 0x400000000000ULL) >> 29) |
        ((v & 0x800000000000ULL) >> 31) |
        ((v & 0x1000000000000ULL) >> 33) |
        ((v & 0x2000000000000ULL) >> 35) |
        ((v & 0x4000000000000ULL) >> 37) |
        ((v & 0x8000000000000ULL) >> 39) |
        ((v & 0x10000000000000ULL) >> 41) |
        ((v & 0x20000000000000ULL) >> 43) |
        ((v & 0x40000000000000ULL) >> 45) |
        ((v & 0x80000000000000ULL) >> 47) |
        ((v & 0x100000000000000ULL) >> 49) |
        ((v & 0x200000000000000ULL) >> 51) |
        ((v & 0x400000000000000ULL) >> 53) |
        ((v & 0x800000000000000ULL) >> 55) |
        ((v & 0x1000000000000000ULL) >> 57) |
        ((v & 0x2000000000000000ULL) >> 59) |
        ((v & 0x4000000000000000ULL) >> 61) |
        ((v & 0x8000000000000000ULL) >> 63)) >> (64 - bits);
}

使用c ++ constexpr对N位字进行位反转

2 个答案: