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);

单行实现只使用%一次:

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

请注意，c#和c++的%运算符实际上不是模数，而是余数。在你的例子中，求模的公式是:

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

你必须用c#(或c++)重新编码，但这是你得到模数而不是余数的方法。

我喜欢Peter N Lewis在这篇文章中提出的技巧:“如果N有一个有限的范围，那么你可以通过添加一个已知的常数倍数(除数)来得到你想要的结果，这个倍数大于最小值的绝对值。”

如果我有一个以度数为单位的值d，我想取

d % 180f

我想避免d为负时的问题，那么我就这样做:

(d + 720f) % 180f

这里假设d可能是负数，但已知它永远不会大于-720。

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

重新启动2 返回1 重新启动-1 重新启动-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可以是任何数字类型)