用于在 C++ 中包装整数的干净、高效的算法
Posted
技术标签:
【中文标题】用于在 C++ 中包装整数的干净、高效的算法【英文标题】：Clean, efficient algorithm for wrapping integers in C++ 【发布时间】：2010-10-16 23:33:15 【问题描述】：/**
* Returns a number between kLowerBound and kUpperBound
* e.g.: Wrap(-1, 0, 4); // Returns 4
* e.g.: Wrap(5, 0, 4); // Returns 0
*/
int Wrap(int const kX, int const kLowerBound, int const kUpperBound)
// Suggest an implementation?
【问题讨论】：
这个函数应该做什么？它是如何在第一种情况下达到 4 而在第二种情况下达到 0 的？ 这是一个“换行”功能。任何不在两个边界之间的数字然后“环绕”到另一侧并根据它所在的一侧开始递减/递增。 群编程。太棒了。 :) 是的。我现在的代码库中有一个糟糕的解决方案，所以我可以继续工作，但这是我能想到的非专有代码的最佳伙伴检查。 :) ***.com/questions/478721/…可能的灵感 【参考方案1】：在下限为零的特殊情况下，此代码避免了除法、取模和乘法。上限不必是二的幂。这段代码过于冗长，看起来很臃肿，但编译成 3 条指令：减法、移位（按常数）和“与”。
#include <climits> // CHAR_BIT
// -------------------------------------------------------------- allBits
// sign extend a signed integer into an unsigned mask:
// return all zero bits (+0) if arg is positive,
// or all one bits (-0) for negative arg
template <typename SNum>
static inline auto allBits (SNum arg)
static constexpr auto argBits = CHAR_BIT * sizeof( arg);
static_assert( argBits < 256, "allBits() sign extension may fail");
static_assert( std::is_signed< SNum>::value, "SNum must be signed");
typedef typename std::make_unsigned< SNum>::type UNum;
// signed shift required, but need unsigned result
const UNum mask = UNum( arg >> (argBits - 1));
return mask;
// -------------------------------------------------------------- boolWrap
// wrap reset a counter without conditionals:
// return arg >= limit? 0 : arg
template <typename UNum>
static inline auto boolWrap (const UNum arg, const UNum limit)
static_assert( ! std::is_signed< UNum>::value, "UNum assumed unsigned");
typedef typename std::make_signed< UNum>::type SNum;
const SNum negX = SNum( arg) - SNum( limit);
const auto signX = allBits( negX); // +0 or -0
return arg & signX;
// example usage:
for (int j= 0; j < 15; ++j)
cout << j << boolWrap( j, 11);
【讨论】：
【参考方案2】：我个人发现，如果范围是互斥的并且除数被限制为正值，这些类型的函数的解决方案会更简洁。
int ifloordiv(int x, int y)
if (x > 0)
return x / y;
if (x < 0)
return (x + 1) / y - 1;
return 0
int iwrap(int x, int y)
return x - y * ifloordiv(x, y);
集成。
int iwrap(int x, int y)
if (x > 0)
return x % y;
if (x < 0)
return (x + 1) % y + y - 1;
return 0;
同一个家庭。为什么不呢？
int ireflect(int x, int y)
int z = iwrap(x, y*2);
if (z < y)
return z;
return y*2-1 - z;
int ibandy(int x, int y)
if (y != 1)
return ireflect(abs(x + x / (y - 1)), y);
return 0;
可以为所有功能实现远程功能，
// output is in the range [min, max).
int func2(int x, int min, int max)
// increment max for inclusive behavior.
assert(min < max);
return func(x - min, max - min) + min;
【讨论】：
【参考方案3】：为什么不使用扩展方法。
public static class IntExtensions
public static int Wrap(this int kX, int kLowerBound, int kUpperBound)
int range_size = kUpperBound - kLowerBound + 1;
if (kX < kLowerBound)
kX += range_size * ((kLowerBound - kX) / range_size + 1);
return kLowerBound + (kX - kLowerBound) % range_size;
用法：currentInt = (++currentInt).Wrap(0, 2);
【讨论】：
因为问题是关于 C++，而不是关于 C#？【参考方案4】：请不要忽视这篇文章。 :)
这样好吗？
int Wrap(N,L,H)
H=H-L+1; return (N-L+(N<L)*H)%H+L;
这适用于负输入，只要 L 小于 H，所有参数都可以是负数。
背景...（注意这里H是重用变量，设置为原始H-L+1）。
我在递增时一直使用(N-L)%H+L，但与几个月前开始学习 C 之前我在 Lua 中使用的不同，如果我使用低于下限的输入，这将不起作用，更不用说负输入。 （Lua 是用 C 构建的，但我不知道它在做什么，而且它可能不会很快......）
我决定添加+(N<L)*H 来生成(N-L+(N<L)*H)%H+L，因为C 似乎被定义为true=1 和false=0。它对我来说效果很好，并且似乎巧妙地回答了原始问题。如果有人知道如何在没有 MOD 运算符 % 的情况下使其速度惊人，请这样做。我现在不需要速度，但有一段时间我会的，毫无疑问。
编辑：
如果N 比L 低超过H-L+1，则该函数会失败，但这不会：
int Wrap(N,L,H)
H-=L; return (N-L+(N<L)*((L-N)/H+1)*++H)%H+L;
我认为它会在任何系统中在整数范围的负极端处中断，但应该适用于大多数实际情况。它增加了一个额外的乘法和除法，但仍然相当紧凑。
（这个编辑只是为了完成，因为我想出了一个更好的方法，在这个线程的一个更新的帖子中。）
乌鸦。
【讨论】：
【参考方案5】：我的另一篇文章很糟糕，所有“纠正性”乘法和除法都失控了。在查看了 Martin Stettner 的帖子以及我自己的 (N-L)%H+L 起始条件后，我想出了这个：
int Wrap(N,L,H)
H=H-L+1; N=(N-L)%H+L; if(N<L)N+=H; return N;
在整数范围的极端负端，它会像我的另一个那样中断，但它会更快，并且更容易阅读，并且避免了其他的讨厌。
乌鸦。
【讨论】：
【参考方案6】：我也遇到过这个问题。这是我的解决方案。
template <> int mod(const int &x, const int &y)
return x % y;
template <class T> T mod(const T &x, const T &y)
return ::fmod((T)x, (T)y);
template <class T> T wrap(const T &x, const T &max, const T &min = 0)
if(max < min)
return x;
if(x > max)
return min + mod(x - min, max - min + 1);
if(x < min)
return max - mod(min - x, max - min + 1);
return x;
我不知道它是否好，但我想我会分享，因为我在对这个问题进行谷歌搜索时被引导到这里，发现上述解决方案缺乏我的需求。 =)
【讨论】：
【参考方案7】：一个具有一定对称性的答案，并且很明显，当 kX 在范围内时，它会原封不动地返回。
int Wrap(int const kX, int const kLowerBound, int const kUpperBound)
int range_size = kUpperBound - kLowerBound + 1;
if (kX < kLowerBound)
return kX + range_size * ((kLowerBound - kX) / range_size + 1);
if (kX > kUpperBound)
return kX - range_size * ((kX - kUpperBound) / range_size + 1);
return kX;
【讨论】：
【参考方案8】：a % b 的符号仅在 a 和 b 均为非负数时定义。
int Wrap(int kX, int const kLowerBound, int const kUpperBound)
int range_size = kUpperBound - kLowerBound + 1;
if (kX < kLowerBound)
kX += range_size * ((kLowerBound - kX) / range_size + 1);
return kLowerBound + (kX - kLowerBound) % range_size;
【讨论】：
第一个适用于负数的解决方案，无需依赖未指定的行为或循环。 我希望如此...考虑到这个问题看起来多么“简单”，如果我犯了错误我不会感到惊讶。它确实依赖于 kUpperBound >= kLowerBound。 对于 Wrap(-1, 1, 4)) 它给出 3。我认为它应该返回 4。 对于 1 -> 4 的范围，肯定是 0 == 4 和 -1 == 3？ 好吧，你是对的。我的回答将 kX 视为某种下限和上限的索引。【参考方案9】：最快的解决方案，最不灵活：利用将在硬件中进行包装的本机数据类型。
包装整数的绝对最快的方法是确保您的数据缩放为 int8/int16/int32 或任何本机数据类型。然后当你需要你的数据来包装本机数据类型时，将在硬件中完成！比这里看到的任何软件封装实现都非常轻松且速度快几个数量级。
作为一个案例研究：
当我需要使用 sin/cos 实现的查找表快速实现 sin/cos 时，我发现这非常有用。基本上，您可以缩放数据，使 INT16_MAX 为 pi，而 INT16_MIN 为 -pi。那你准备好了吗？
附带说明一下，缩放数据会增加一些前期有限计算成本，通常看起来像：
int fixedPoint = (int)( floatingPoint * SCALING_FACTOR + 0.5 )
随意将 int 换成您想要的其他东西，例如 int8_t / int16_t / int32_t。
下一个最快的解决方案，更灵活：mod 操作很慢，尽可能尝试使用位掩码！
我浏览的大多数解决方案在功能上都是正确的……但它们依赖于 mod 操作。
mod 操作非常慢，因为它本质上是在做一个hardware division。外行人对 mod 和除法为什么慢的解释是将除法操作等同于一些伪代码 for(quotient = 0;inputNum> 0;inputNum -= divisor) quotient++; （quotient and divisor 的 def ）。如您所见，如果相对于除数而言，硬件除法可能很快...但是如果它比除数大得多，除法也可能非常慢。
如果您可以将数据缩放到 2 的幂，那么您可以使用将在一个周期内执行的位掩码（在所有平台的 99% 上），并且您的速度将提高大约一个数量级（至少快 2 到 3 倍）。
实现包装的C代码：
#define BIT_MASK (0xFFFF)
int wrappedAddition(int a, int b)
return ( a + b ) & BIT_MASK;
int wrappedSubtraction(int a, int b)
return ( a - b ) & BIT_MASK;
随意将#define 设置为运行时。并随意将位掩码调整为您需要的任何二的幂。比如 0xFFFFFFFF 或您决定实施的 2 的幂。
附言我强烈建议在处理包装/溢出条件时阅读有关定点处理的信息。我建议阅读：
Fixed-Point Arithmetic: An Introduction by Randy Yates August 23, 2007
【讨论】：
【参考方案10】：实际上，因为 -1 % 4 在我使用过的每个系统上都返回 -1，所以简单的 mod 解决方案不起作用。我会尝试：
int range = kUpperBound - kLowerBound +1;
kx = ((kx - kLowerBound) % range) + range;
return (kx % range) + kLowerBound;
如果 kx 是正数，你修改，添加范围，然后修改回来，撤消添加。如果 kx 是负数，你修改，添加使其成为正数的范围，然后再次修改，这不会做任何事情。
【讨论】：
这比我的'while'好:) 尝试 lb = 3, ub = 8, kx = 5。显然 kx 在范围内，所以应该给出 5 但是... 第 2 行：kx = (5 % 6) + 6 == 11，然后在第 3 行： (kx % 6) + 3 = 5 + 3 == 8 != 5. 仅仅因为它在您知道的每个系统上都这样做，并不意味着它是正确的。 必须在第二行读取kx=((kx-kLowerBound)%range)+range。【参考方案11】：我会给出最常见情况下界=0，上界=N-1 的入口点。并在一般情况下调用此函数。在我已经在范围内的地方没有进行任何 mod 计算。它假设upper>=lower，或n>0。
int wrapN(int i,int n)
if (i<0) return (n-1)-(-1-i)%n; // -1-i is >=0
if (i>=n) return i%n;
return i; // In range, no mod
int wrapLU(int i,int lower,int upper)
return lower+wrapN(i-lower,1+upper-lower);
【讨论】：
【参考方案12】：以下内容应独立于 mod 运算符的实现：
int range = kUpperBound - kLowerBound + 1;
kx = ((kx-kLowerBound) % range);
if (kx<0)
return kUpperBound + 1 + kx;
else
return kLowerBound + kx;
相对于其他解决方案的一个优势是，它只使用一个 %（即除法），这使得它非常高效。
注意（离题）：
这是一个很好的例子，为什么有时定义区间是明智的，上限是不在范围内的第一个元素（例如对于 STL 迭代器...）。在这种情况下，两个“+1”都会消失。
【讨论】：
【参考方案13】：我会建议这个解决方案：
int Wrap(int const kX, int const kLowerBound, int const kUpperBound)
int d = kUpperBound - kLowerBound + 1;
return kLowerBound + (kX >= 0 ? kX % d : -kX % d ? d - (-kX % d) : 0);
?: 运算符的 if-then-else 逻辑确保 % 的两个操作数都是非负数。
【讨论】：
【参考方案14】：对于负kX，可以加：
int temp = kUpperBound - kLowerBound + 1;
while (kX < 0) kX += temp;
return kX%temp + kLowerBound;
【讨论】：
工作但不优雅。试试“temp2 = -kX/temp;kX += temp2+1;” 应该是“如果 (kX 这不适用于非零下限。例如。 lb = 3, ub = 8, kX = 5。显然 5 已经在范围内，但 temp = 6 和 5 % 6 + 3 = 8 != 5。以上是关于用于在 C++ 中包装整数的干净、高效的算法的主要内容，如果未能解决你的问题，请参考以下文章