在C / C ++中获得正模的最快方法

通常，在我的内部循环中，我需要以“环绕”方式为数组建立索引，以便（例如）如果数组大小为100，并且我的代码要求输入元素-2，则应将其赋值为元素98。高级语言（例如Python）可以使用轻松实现my_array[index % array_size]，但是由于某些原因，C的整数算术（通常）会舍入为零而不是始终舍入，因此，当给定第一个负数时，其模运算符将返回负数。

我常常知道这index不会少于-array_size，在这种情况下我会做到my_array[(index + array_size) % array_size]。但是，有时无法保证，对于这些情况，我想知道实现始终为正的模函数的最快方法。有几种“智能”方式可以做到而无需分支，例如

inline int positive_modulo(int i, int n) {
    return (n + (i % n)) % n;
}

要么

inline int positive_modulo(int i, int n) {
    return (i % n) + (n * (i < 0));
}

当然，我可以对它们进行概要分析以找出哪个是系统上最快的，但是我不禁担心自己可能错过了更好的系统，或者我的计算机上的速度在另一台计算机上可能较慢。

那么，有没有一种标准的方法来执行此操作，或者我错过了一些巧妙的技巧，而这可能是最快的方法？

另外，我知道这可能是一厢情愿的想法，但是如果有一种方法可以自动矢量化，那就太神奇了。

大多数时候，编译器非常擅长优化代码，因此通常最好使代码保持可读性（让编译器和其他开发人员都知道您在做什么）。

由于您的数组大小始终为正，因此建议您将商定义为unsigned。编译器会将小的if / else小块优化为没有分支的条件指令：

unsigned modulo( int value, unsigned m) {
    int mod = value % (int)m;
    if (mod < 0) {
        mod += m;
    }
    return mod;
}

这将创建一个非常小的没有分支的函数：

modulo(int, unsigned int):
        mov     eax, edi
        cdq
        idiv    esi
        add     esi, edx
        mov     eax, edx
        test    edx, edx
        cmovs   eax, esi
        ret

例如modulo(-5, 7)return 2。

不幸的是，由于不知道商，它们必须执行整数除法，与其他整数运算相比，这有点慢。如果您知道数组的大小是2的幂，我建议将这些函数定义保留在标头中，以便编译器可以将它们优化为更有效的函数。这是函数unsigned modulo256(int v) { return modulo(v,256); }：

modulo256(int):                          # @modulo256(int)
        mov     edx, edi
        sar     edx, 31
        shr     edx, 24
        lea     eax, [rdi+rdx]
        movzx   eax, al
        sub     eax, edx
        lea     edx, [rax+256]
        test    eax, eax
        cmovs   eax, edx
        ret

参见程序集：https : //gcc.godbolt.org/z/DG7jMw

查看与投票最多的答案进行比较：http : //quick-bench.com/oJbVwLr9G5HJb0oRaYpQOCec4E4

编辑：事实证明，Clang能够在没有任何条件移动指令的情况下生成函数（这比常规的算术运算要花更多的钱）。在一般情况下，由于积分除法约占总时间的70％，因此这种差异是可以忽略的。

基本上，Clang会value向右移动以将其符号位扩展到用于屏蔽的第二个操作数的整个宽度m（即为0xffffffff负数时，0否则为负数）mod + m。

unsigned modulo (int value, unsigned m) {
    int mod = value % (int)m;
    m &= mod >> std::numeric_limits<int>::digits;
    return mod + m;
}

我学到的标准方法是

inline int positive_modulo(int i, int n) {
    return (i % n + n) % n;
}

此函数本质上是您不带的第一个变体abs（实际上，这会使它返回错误的结果）。如果优化的编译器能够识别这种模式并将其编译为计算“无符号模”的机器代码，我不会感到惊讶。

编辑：

继续进行第二个变体：首先，它也包含一个错误-n < 0应该是i < 0。

这个变体看起来好像不是分支，但是在许多体系结构上，i < 0它将编译为条件跳转。在任何情况下，这将是至少一样快，以取代(n * (i < 0))用i < 0? n: 0，这避免了乘法; 此外，它是“更干净的”，因为它避免将布尔值重新解释为int。

至于这两个变体中哪个更快，这可能取决于编译器和处理器体系结构-对这两个变体进行计时。不过，我认为没有比这两个变体更快的方法了。

模二的幂，以下工作（假设二进制补码表示）：

return i & (n-1);

一种老式的方法，使用二进制补码符号位传播来获取可选的加数：

int positive_mod(int i, int m)
{
    /* constexpr */ int shift = CHAR_BIT*sizeof i - 1;
    int r = i%m;
    return r+ (r>>shift & m);
}

如果您有能力升级为更大的类型（并对更大的类型进行模运算），则此代码将执行单个模运算，如果没有，则为：

int32_t positive_modulo(int32_t number, int32_t modulo) {
    return (number + ((int64_t)modulo << 32)) % modulo;
}

在C / C ++中获得正模的最快方法

以下快吗？-可能不如其他人快，但对于所有¹ 个人来说都是简单且功能正确的a,b-与其他人不同。

int modulo_Euclidean(int a, int b) {
  int m = a % b;
  if (m < 0) {
    // m += (b < 0) ? -b : b; // avoid this form: it is UB when b == INT_MIN
    m = (b < 0) ? m - b : m + b;
  }
  return m;
}

其他各种答案都有mod(a,b)弱点，尤其是在...时b < 0。

见欧几里德师约想法b < 0

inline int positive_modulo(int i, int n) {
    return (i % n + n) % n;
}

i % n + n溢出时失败（请考虑大i, n）-未定义的行为。

return i & (n-1);

依靠n两个的幂。（公平的回答确实提到了这一点。）

int positive_mod(int i, int n)
{
    /* constexpr */ int shift = CHAR_BIT*sizeof i - 1;
    int m = i%n;
    return m+ (m>>shift & n);
}

通常在以下情况时失败n < 0。e，g，positive_mod(-2,-3) --> -5

int32_t positive_modulo(int32_t number, int32_t modulo) {
    return (number + ((int64_t)modulo << 32)) % modulo;
}

必须使用2个整数宽度。（公平的回答确实提到了这一点。）
与失败modulo < 0。 positive_modulo(2, -3)-> -1。

inline int positive_modulo(int i, int n) {
    int tmp = i % n;
    return tmp ? i >= 0 ? tmp : tmp + n : 0;
}

通常在以下情况时失败n < 0。e，g，positive_modulo(-2,-3) --> -5

¹例外：在C中，如或中那样溢出a%b时未定义。a/ba/0INT_MIN/-1

如果要避免所有条件路径（包括上面生成的条件移动，（例如，如果需要此代码进行矢量化或以恒定时间运行），则可以使用符号位作为掩码：

unsigned modulo(int value, unsigned m) {
  int shift_width = sizeof(int) * 8 - 1;
  int tweak = (value >> shift_width);
  int mod = ((value - tweak) % (int) m) + tweak;
  mod += (tweak & m);
  return mod;
}

这是quickbench的结果您可以看到在gcc上，在一般情况下效果更好。对于clang，它在通用情况下的速度相同，因为clang在通用情况下会生成无分支代码。无论如何，该技术都是有用的，因为不能总是依靠编译器来进行特定的优化，并且您可能必须手动滚动以获取矢量代码。

您也可以这样做array[(i+array_size*N) % array_size]，其中N是足够大的整数以保证正参数，但又足够小而不溢出。

当array_size恒定时，有一些无需模数即可计算模量的技术。除了两种方法的功效外，还可以计算位组的加权总和乘以2 ^ i％n，其中i是每组中的最低有效位：

例如32位整数0xaabbccdd％100 = dd + cc * [2] 56 + bb * [655] 36 + aa * [167772] 16，最大范围为（1 + 56 + 36 + 16）* 255 = 27795通过重复应用和不同细分，可以将操作减少到很少的条件减法。

常见的做法还包括以2 ^ 32 / n的倒数进行近似除法，这通常可以处理相当大范围的参数。

 i - ((i * 655)>>16)*100; // (gives 100*n % 100 == 100 requiring adjusting...)

您的第二个示例比第一个示例更好。乘法是比if / else操作更复杂的操作，因此请使用以下命令：

inline int positive_modulo(int i, int n) {
    int tmp = i % n;
    return tmp ? i >= 0 ? tmp : tmp + n : 0;
}