C# 负数的模式正在融化我的大脑

Mod of negative number is melting my brain

提问by

I'm trying to mod an integer to get an array position so that it will loop round. Doing i % arrayLengthworks fine for positive numbers but for negative numbers it all goes wrong.

我正在尝试修改一个整数以获得一个数组位置，以便它会循环。i % arrayLength对正数做的很好，但对于负数，一切都会出错。

 4 % 3 == 1
 3 % 3 == 0
 2 % 3 == 2
 1 % 3 == 1
 0 % 3 == 0
-1 % 3 == -1
-2 % 3 == -2
-3 % 3 == 0
-4 % 3 == -1

so i need an implementation of

所以我需要一个实现

int GetArrayIndex(int i, int arrayLength)

such that

以至于

GetArrayIndex( 4, 3) == 1
GetArrayIndex( 3, 3) == 0
GetArrayIndex( 2, 3) == 2
GetArrayIndex( 1, 3) == 1
GetArrayIndex( 0, 3) == 0
GetArrayIndex(-1, 3) == 2
GetArrayIndex(-2, 3) == 1
GetArrayIndex(-3, 3) == 0
GetArrayIndex(-4, 3) == 2

I've done this before but for some reason it's melting my brain today :(

我以前做过这个，但由于某种原因，它今天让我的大脑融化了:(

回答by starblue

Just add your modulus (arrayLength) to the negative result of % and you'll be fine.

只需将您的模数 (arrayLength) 添加到 % 的负结果中，您就可以了。

回答by ShreevatsaR

I always use my own modfunction, defined as

我总是使用我自己的mod函数，定义为

int mod(int x, int m) {
    return (x%m + m)%m;
}

Of course, if you're bothered about having twocalls to the modulus operation, you could write it as

当然，如果您对两次调用模数运算感到困扰，您可以将其写为

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

or variants thereof.

或其变体。

The reason it works is that "x%m" is always in the range [-m+1, m-1]. So if at all it is negative, adding m to it will put it in the positive range without changing its value modulo m.

它起作用的原因是“x%m”总是在 [-m+1, m-1] 范围内。因此，如果它完全是负数，则将 m 添加到它会使其处于正范围内，而不会更改其模 m 值。

回答by Петър Петров

Please note that C# and C++'s % operator is actually NOT a modulo, it's remainder. The formula for modulo that you want, in your case, is:

请注意，C# 和 C++ 的 % 运算符实际上不是模数，而是余数。在您的情况下，您想要的模数公式是：

float nfmod(float a,float b)
{
    return a - b * floor(a / b);
}

You have to recode this in C# (or C++) but this is the way you get modulo and not a remainder.

您必须在 C#（或 C++）中重新编码，但这是您获得模而不是余数的方式。

回答by RenniePet

I like the trick presented by Peter N Lewis on this thread: "If n has a limited range, then you can get the result you want simply by adding a known constant multiple of [the divisor] that is greater that the absolute value of the minimum."

我喜欢 Peter N Lewis 在此线程上提出的技巧：“如果 n 的范围有限，那么您只需添加一个已知的 [除数] 常数倍数，该倍数大于最低限度。”

So if I have a value dthat is in degrees and I want to take

所以如果我有一个以度为单位的值d并且我想取

d % 180f

and I want to avoid the problems if dis negative, then instead I just do this:

如果d为负，我想避免这些问题，那么我只是这样做：

(d + 720f) % 180f

This assumes that although dmay be negative, it is known that it will never be more negative than -720.

这假设虽然d可能是负数，但已知它永远不会比 -720 更负。

回答by Abin

Adding some understanding.

补充一些理解。

By Euclidean definitionthe mod result must be always positive.

根据欧几里德定义，mod 结果必须始终为正。

Ex:

前任：

 int n = 5;
 int x = -3;

 int mod(int n, int x)
 {
     return ((n%x)+x)%x;
 }

Output:

输出：

 -1

回答by dcastro

ShreevatsaR's answer won't work for all cases, even if you add "if(m<0) m=-m;", if you account for negative dividends/divisors.

ShreevatsaR 的答案不适用于所有情况，即使您添加“if(m<0) m=-m;”，如果您考虑负股息/除数。

For example, -12 mod -10 will be 8, and it should be -2.

例如，-12 mod -10 将是 8，它应该是 -2。

The following implementation will work for both positive and negative dividends / divisors and complies with other implementations (namely, Java, Python, Ruby, Scala, Scheme, Javascript and Google's Calculator):

以下实现适用于正和负红利/除数，并符合其他实现（即 Java、Python、Ruby、Scala、Scheme、Javascript 和 Google 的计算器）：

internal static class IntExtensions
{
    internal static int Mod(this int a, int n)
    {
        if (n == 0)
            throw new ArgumentOutOfRangeException("n", "(a mod 0) is undefined.");

        //puts a in the [-n+1, n-1] range using the remainder operator
        int remainder = a%n;

        //if the remainder is less than zero, add n to put it in the [0, n-1] range if n is positive
        //if the remainder is greater than zero, add n to put it in the [n-1, 0] range if n is negative
        if ((n > 0 && remainder < 0) ||
            (n < 0 && remainder > 0))
            return remainder + n;
        return remainder;
    }
}

---

---

Test suite using xUnit:

使用 xUnit 的测试套件：

    [Theory]
    [PropertyData("GetTestData")]
    public void Mod_ReturnsCorrectModulo(int dividend, int divisor, int expectedMod)
    {
        Assert.Equal(expectedMod, dividend.Mod(divisor));
    }

    [Fact]
    public void Mod_ThrowsException_IfDivisorIsZero()
    {
        Assert.Throws<ArgumentOutOfRangeException>(() => 1.Mod(0));
    }

    public static IEnumerable<object[]> GetTestData
    {
        get
        {
            yield return new object[] {1, 1, 0};
            yield return new object[] {0, 1, 0};
            yield return new object[] {2, 10, 2};
            yield return new object[] {12, 10, 2};
            yield return new object[] {22, 10, 2};
            yield return new object[] {-2, 10, 8};
            yield return new object[] {-12, 10, 8};
            yield return new object[] {-22, 10, 8};
            yield return new object[] { 2, -10, -8 };
            yield return new object[] { 12, -10, -8 };
            yield return new object[] { 22, -10, -8 };
            yield return new object[] { -2, -10, -2 };
            yield return new object[] { -12, -10, -2 };
            yield return new object[] { -22, -10, -2 };
        }
    }

回答by Evgeni Sergeev

Single-line implementation using %only once:

%仅使用一次的单行实现：

int mod(int k, int n) {  return ((k %= n) < 0) ? k+n : k;  }

回答by Markus Cozowicz

For the more performance aware devs

对于更注重性能的开发人员

uint wrap(int k, int n) ((uint)k)%n

A small performance comparison

一个小的性能比较

Modulo: 00:00:07.2661827 ((n%x)+x)%x)
Cast:   00:00:03.2202334 ((uint)k)%n
If:     00:00:13.5378989 ((k %= n) < 0) ? k+n : k

As for performance cost of cast to uint have a look here

至于 cast to uint 的性能成本，请看这里

回答by lilo0

Comparing two predominant answers

比较两个主要答案

(x%m + m)%m;

and

和

int r = x%m;
return r<0 ? r+m : r;

Nobody actually mentioned the fact that the first one may throw an OverflowExceptionwhile the second one won't. Even worse, with default unchecked context, the first answer may return the wrong answer (see mod(int.MaxValue - 1, int.MaxValue)for example). So the second answer not only seems to be faster, but also more correct.

实际上没有人提到第一个可能会抛出OverflowException而第二个不会的事实。更糟糕的是，在默认的未经检查的上下文中，第一个答案可能会返回错误的答案（参见mod(int.MaxValue - 1, int.MaxValue)示例）。所以第二个答案不仅看起来更快，而且更正确。

回答by Aaron Franke

All of the answers here work great if your divisor is positive, but it's not quite complete. Here is my implementation which always returns on a range of [0, b), such that the sign of the output is the same as the sign of the divisor, allowing for negative divisors as the endpoint for the output range.

如果您的除数为正数，这里的所有答案都很好用，但还不够完整。这是我的实现，它总是在 范围内返回[0, b)，这样输出的符号与除数的符号相同，允许负除数作为输出范围的端点。

PosMod(5, 3)returns 2
PosMod(-5, 3)returns 1
PosMod(5, -3)returns -1
PosMod(-5, -3)returns -2

PosMod(5, 3)退货2
PosMod(-5, 3)退货1
PosMod(5, -3)退货-1
PosMod(-5, -3)退货-2

    /// <summary>
    /// Performs a canonical Modulus operation, where the output is on the range [0, b).
    /// </summary>
    public static real_t PosMod(real_t a, real_t b)
    {
        real_t c = a % b;
        if ((c < 0 && b > 0) || (c > 0 && b < 0)) 
        {
            c += b;
        }
        return c;
    }

(where real_tcan be any number type)

（其中real_t可以是任何数字类型）