如何在C / C ++ / Obj-C中编码模（％）运算符以处理负数

我最讨厌C语言衍生的语言（作为数学家）是

(-1) % 8 // comes out as -1, and not 7

fmodf(-1,8) // fails similarly

最好的解决方案是什么？

C ++允许模板和运算符重载，但对我而言，这两者都是晦涩难懂的地方。实例感激不尽。

首先我要指出，你甚至不能依靠事实(-1) % 8 == -1。您唯一可以依靠的是(x / y) * y + ( x % y) == x。但是，余数是否为负是实现定义的。

现在为什么在这里使用模板？int和long的重载就可以了。

int mod (int a, int b)
{
   int ret = a % b;
   if(ret < 0)
     ret+=b;
   return ret;
}

现在您可以像mod（-1,8）这样称呼它，它看起来像是7。

编辑：我发现我的代码中的错误。如果b为负，则它将不起作用。所以我认为这更好：

int mod (int a, int b)
{
   if(b < 0) //you can check for b == 0 separately and do what you want
     return -mod(-a, -b);   
   int ret = a % b;
   if(ret < 0)
     ret+=b;
   return ret;
}

参考：C ++ 03第5.6节第4节：

二进制/运算符产生商，二进制％运算符产生第一个表达式除以第二个表达式的余数。如果/或％的第二个操作数为零，则行为不确定。否则（a / b）* b + a％b等于a。如果两个操作数均为非负数，则其余为非负数；如果不是，则其余符号由实现定义。

这是一个处理两个操作数的正或负整数或小数的C函数

#include <math.h>
float mod(float a, float N) {return a - N*floor(a/N);} //return in range [0, N)

从数学的角度来看，这无疑是最优雅的解决方案。但是，我不确定它在处理整数方面是否健壮。有时在转换int-> fp-> int时会出现浮点错误。

我将此代码用于non-int，并将单独的函数用于int。

注意：需要陷阱N = 0！

测试人员代码：

#include <math.h>
#include <stdio.h>

float mod(float a, float N)
{
    float ret = a - N * floor (a / N);

    printf("%f.1 mod %f.1 = %f.1 \n", a, N, ret);

    return ret;
}

int main (char* argc, char** argv)
{
    printf ("fmodf(-10.2, 2.0) = %f.1  == FAIL! \n\n", fmodf(-10.2, 2.0));

    float x;
    x = mod(10.2f, 2.0f);
    x = mod(10.2f, -2.0f);
    x = mod(-10.2f, 2.0f);
    x = mod(-10.2f, -2.0f);

    return 0;
}

（注意：您可以直接从CodePad编译并运行它：http ://codepad.org/UOgEqAMA ）

输出：

fmodf（-10.2，2.0）= -0.20 ==失败！

10.2 mod 2.0 = 0.2
10.2 mod -2.0 = -1.8
-10.2 mod 2.0 = 1.8
-10.2 mod -2.0 = -0.2

我刚刚注意到Bjarne Stroustrup标记%为余数运算符，而不是模运算符。

我敢打赌，这是ANSI C＆C ++规范中的正式名称，并且滥用术语已广为流行。有人知道这一点吗？

但是，如果是这种情况，那么C的fmodf（）函数（可能还有其他函数）将极具误导性。它们应标记为fremf（）等

找到正模的最简单的通用函数是this-它对x的正值和负值都起作用。

int modulo(int x,int N){
    return (x % N + N) %N;
}

对于整数，这很简单。做就是了

(((x < 0) ? ((x % N) + N) : x) % N)

我认为这N是积极的，可以代表的x。您最喜欢的编译器应该能够对此进行优化，以使其最终仅在汇编器中执行一次mod操作。

对于数学家来说，最好的解决方案是使用Python。

C ++运算符重载与此无关。您不能为内置类型重载运算符。您想要的只是一个函数。当然，您可以使用C ++模板为所有相关类型实现该功能，而只需编写一段代码。

标准C库提供 fmod如果我没有记错的话，为浮点类型提供了。

对于整数，您可以定义一个C ++函数模板，该模板总是将非负余数（对应于欧几里得除法）返回为...

#include <stdlib.h>  // abs

template< class Integer >
auto mod( Integer a, Integer b )
    -> Integer
{
    Integer const r = a%b;
    return (r < 0? r + abs( b ) : r);
}

...而只是写mod(a, b)而不是a%b。

这里的类型 Integer必须是有符号整数类型。

如果您想要普通的数学行为，其中余数的符号与除数的符号相同，则可以执行例如

template< class Integer >
auto floor_div( Integer const a, Integer const b )
    -> Integer
{
    bool const a_is_negative = (a < 0);
    bool const b_is_negative = (b < 0);
    bool const change_sign  = (a_is_negative != b_is_negative);

    Integer const abs_b         = abs( b );
    Integer const abs_a_plus    = abs( a ) + (change_sign? abs_b - 1 : 0);

    Integer const quot = abs_a_plus / abs_b;
    return (change_sign? -quot : quot);
}

template< class Integer >
auto floor_mod( Integer const a, Integer const b )
    -> Integer
{ return a - b*floor_div( a, b ); }

…在上有相同的约束Integer，那就是有符号类型。

^{¹因为Python的整数除法向负无穷大舍入。}

噢，我也讨厌这个设计。

您可以通过以下方式将股息转换为未签名：

unsigned int offset = (-INT_MIN) - (-INT_MIN)%divider

result = (offset + dividend) % divider

其中offset最接近模块的（-INT_MIN）倍数，因此对其进行加法和减法运算不会改变模数。请注意，它具有无符号类型，结果将是整数。不幸的是，它无法正确转换值INT_MIN ...（-offset-1），因为它们会导致自动计数溢出。但是，这种方法在使用常数除法器时，每次操作仅具有一个附加的算术优势（而没有条件），因此可以在类似DSP的应用中使用。

在特殊情况下，分频器为2 ^N（2的整数次方），可以使用简单的算术运算和按位逻辑计算模

dividend&(divider-1)

例如

x mod 2 = x & 1
x mod 4 = x & 3
x mod 8 = x & 7
x mod 16 = x & 15

较常见且较不麻烦的方法是使用此函数进行模运算（仅适用于正除数）：

int mod(int x, int y) {
    int r = x%y;
    return r<0?r+y:r;
}

如果它是负数，那么这只是正确的结果。

您也可以欺骗：

（p％q + q）％q

它很短，但是使用两个通常很慢的％-s。

我相信解决此问题的另一种方法是使用long类型的变量而不是int类型。

我只是在处理一些代码，其中％运算符返回一个负值，这导致了一些问题（要在[0,1]上生成统一的随机变量，您实际上并不需要负数:)），但是在将变量切换为键入long，一切运行顺利，结果与在python中运行相同代码时得到的结果匹配（对我来说很重要，因为我希望能够在多个平台上生成相同的“随机”数字。

根据Microsoft Research论文及其中的参考文献，这是对旧问题的新答案。

请注意，从C11和C ++ 11开始，的语义div已被截断为零（请参阅参考资料[expr.mul]/4）。此外，对于D除以d，C ++ 11确保有关商qT和余数的以下内容rT

auto const qT = D / d;
auto const rT = D % d;
assert(D == d * qT + rT);
assert(abs(rT) < abs(d));
assert(signum(rT) == signum(D));

其中的signum-1、0，+ 1取决于其参数是否<，==，>大于0（请参阅此问题与解答以获取源代码）。

截断除法时，余数的符号等于除数的符号D，即-1 % 8 == -1。C ++ 11还提供了一个std::div函数，该函数返回带有成员quot和rem根据截断分裂。

还有其他可能的定义，例如，可以根据内置的截断分割来定义所谓的地板分割

auto const I = signum(rT) == -signum(d) ? 1 : 0;
auto const qF = qT - I;
auto const rF = rT + I * d;
assert(D == d * qF + rF);
assert(abs(rF) < abs(d));
assert(signum(rF) == signum(d));

对于底数除法，余数的符号等于除数的符号d。在诸如Haskell和Oberon之类的语言中，存在用于地板分割的内置运算符。在C ++中，您需要使用上述定义编写函数。

还有一种方法是欧几里得除法，它也可以根据内置的截断法来定义

auto const I = rT >= 0 ? 0 : (d > 0 ? 1 : -1);
auto const qE = qT - I;
auto const rE = rT + I * d;
assert(D == d * qE + rE);
assert(abs(rE) < abs(d));
assert(signum(rE) != -1);

在欧几里得除法运算中，余数始终为正。

对于不使用分支且仅使用1个mod的解决方案，您可以执行以下操作

// Works for other sizes too,
// assuming you change 63 to the appropriate value
int64_t mod(int64_t x, int64_t div) {
  return (x % div) + (((x >> 63) ^ (div >> 63)) & div);
}

/ *警告：宏mod会多次评估其参数的副作用。* /
＃定义mod（r，m）（（[[r）％（m））+（（r）<0）？（m）：0）

...或者只是习惯于接受等效课程的任何代表。

C ++示例模板

template< class T >
T mod( T a, T b )
{
    T const r = a%b;
    return ((r!=0)&&((r^b)<0) ? r + b : r);
}

使用此模板，返回的余数将为零或与除数（分母）具有相同的符号（等效于向负无穷大舍入），而不是余数的C ++行为为零或与除数具有相同的符号（分子）（相当于四舍五入）。

define  MOD(a, b)       ((((a)%(b))+(b))%(b))

unsigned mod(int a, unsigned b) {
    return (a >= 0 ? a % b : b - (-a) % b);
}

此解决方案（在mod正数时使用）避免同时进行负数除法或余数运算：

int core_modulus(int val, int mod)
{
    if(val>=0)
        return val % mod;
    else
        return val + mod * ((mod - val - 1)/mod);
}

我会做：

((-1)+8) % 8 

这将后一个数字加到第一个数字上，然后根据需要进行模加7。这适用于任何数字（低至-8）。对于-9，请添加2 * 8。