負の数のModが私の脳を溶かしている

整数を変更して配列の位置を取得し、ループするようにしています。こう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

だから私はの実装が必要です

int GetArrayIndex(int i, int arrayLength)

そのような

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

私は以前にこれをやったことがあるが、何らかの理由で今日それは私の脳を溶かしている:(

私は常に自分のmod関数を使用します。

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

もちろん、モジュラス演算を2回呼び出すのが面倒な場合は、次のように書くことができます。

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

またはその変種。

これが機能する理由は、「x％m」が常に[-m + 1、m-1]の範囲にあるためです。したがって、それが負の場合、mを追加すると、mを法としてその値を変更せずに正の範囲に入れられます。

C＃およびC ++の％演算子は実際には剰余ではなく、残りの部分であることに注意してください。あなたの場合、あなたが望むモジュロの式は次のとおりです：

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

これをC＃（またはC ++）で再コーディングする必要がありますが、これは剰余ではなくモジュロを取得する方法です。

%1回だけ使用する単一行の実装：

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

ShreevatsaRの答えは、負の被除数/除数を考慮に入れる場合、「if（m <0）m = -m;」を追加しても、すべてのケースで機能するわけではありません。

たとえば、-12 mod -10は8になり、-2になります。

次の実装は、正と負の両方の被除数/除数で機能し、他の実装（つまり、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;
    }
}

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

理解を深める。

することにより、ユークリッド定義 MOD結果は常に正でなければなりません。

例：

 int n = 5;
 int x = -3;

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

出力：

 -1

2つの主な答えを比較する

(x%m + m)%m;

そして

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

最初のものはスローするOverflowExceptionが2番目のものはスローしないかもしれないという事実に実際に言及した人はいません。さらに悪いことに、デフォルトのチェックされていないコンテキストでは、最初の回答が間違った回答を返す可能性があります（mod(int.MaxValue - 1, int.MaxValue)例を参照）。したがって、2番目の答えはより高速であるだけでなく、より正確であるように見えます。

モジュラス（arrayLength）を％の負の結果に追加するだけで大​​丈夫です。

よりパフォーマンスを意識した開発者向け

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

小さなパフォーマンス比較

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

uintへのキャストのパフォーマンスコストについては、こちらをご覧ください。

私はこのスレッドでピーターNルイスが提示したトリックが好きです。「nの範囲が限られている場合、[除数]の既知の定数倍数を追加するだけで、必要な結果を得ることができます。最小。"

したがって、度単位の値dがあり、

d % 180f

dが負の場合は問題を回避したいので、代わりに次のようにします。

(d + 720f) % 180f

これは、dが負になる可能性があるとしても、-720よりも負になることはないことがわかっていることを前提としています。

文書化されているC＃の％演算子の動作とは逆の動作を期待しています-慣れ親しんでいる別の言語で動作するように動作することを期待している可能性があります。ドキュメント C＃の状態で（強調鉱山）：

整数型のオペランドの場合、a％bの結果は、a-（a / b）* bによって生成された値です。ゼロ以外の剰余の符号は、左側のオペランドの符号と同じです

必要な値は、1つの追加ステップで計算できます。

int GetArrayIndex(int i, int arrayLength){
    int mod = i % arrayLength;
    return (mod>=0) : mod ? mod + arrayLength;
}

dcastroの回答の1行の実装（他の言語に最も準拠）：

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

ここでの答えはすべて、除数が正の場合はうまく機能しますが、完全ではありません。[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任意の数値タイプにすることができます）