负数的模运算让我感到困扰

有许多实现mod函数的方法，我认为值得列出所有的方法——至少根据维基百科，我相信还有更多。

// Important to be able to use `MathF`.
using System;

public static class MathFUtils {
    public static class Mod {
        public static float Trunc(float a, float b) =>
            a - b * ((int)(a / b));

        public static float Round(float a, float b) =>
            a - b * MathF.Round(a / b);

        public static float Floor(float a, float b) =>
            a - b * MathF.Floor(a / b);

        public static float Ceil(float a, float b) =>
            a - b * MathF.Ceiling(a / b);

        public static float Euclidean(float a, float b) =>
            a - MathF.Abs(b) * MathF.Floor(a / MathF.Abs(b));
    }
}

---

根据维基百科（以及我的经验），坚持使用欧几里得。 从数学和概率属性的角度来看，它是最有用的。 如果您需要截断，那么我相信%就可以胜任。

此外，对于那些可能对它们各自的作用及其如何运作感到困惑的人，我强烈建议阅读维基百科文章（即使很难）并查看每个表示形式的图像。

当然，这些不一定是最有效率的，但它们确实可以发挥作用。 如果您担心性能问题，我建议找到本地C＃专家，或者当他们穿过我们的世界时询问他们。

所有这里的答案都适用于除数为正数的情况，但它并不完整。这是我的实现，总是在范围[0，b)内返回，使输出的符号与除数的符号相同，允许负除数作为输出范围的端点。 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;
    }

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

ShreevatsaR的第二个答案：

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

可以在较新版本的C#中使用var模式和switch表达式以一行代码的方式编写：

int mod(int x, int m) => (x % m) switch 
{ 
    < 0 and var r => r + m, var r => r 
}

一行代码实现 dcastro 的答案（最符合其他语言要求）：

int Mod(int a, int n)
{
    return (((a %= n) < 0) && n > 0) || (a > 0 && n < 0) ? a + n : a;
}

如果您想保留使用 % 运算符（在 C# 中无法重载本机运算符）：

public class IntM
{
    private int _value;

    private IntM(int value)
    {
        _value = value;
    }

    private static int Mod(int a, int n)
    {
        return (((a %= n) < 0) && n > 0) || (a > 0 && n < 0) ? a + n : a;
    }

    public static implicit operator int(IntM i) => i._value;
    public static implicit operator IntM(int i) => new IntM(i);
    public static int operator %(IntM a, int n) => Mod(a, n);
    public static int operator %(int a, IntM n) => Mod(a, n);
}

应用场景，两者都有效：

int r = (IntM)a % n;

// Or
int r = a % n(IntM);

这是我针对正整数的一行代码，基于这个答案：

用法：

(-7).Mod(3); // returns 2

实现：

static int Mod(this int a, int n) => (((a %= n) < 0) ? n : 0) + a;