Mod der negativen Zahl schmilzt mein Gehirn

Ich versuche, eine Ganzzahl zu modifizieren, um eine Array-Position zu erhalten, damit sie sich um eine Schleife dreht. Das i % arrayLengthfunktioniert gut für positive Zahlen, aber für negative Zahlen geht alles schief.

 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

Also brauche ich eine Implementierung von

int GetArrayIndex(int i, int arrayLength)

so dass

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

Ich habe das schon einmal gemacht, aber aus irgendeinem Grund schmilzt es heute mein Gehirn :(

Ich benutze immer meine eigene modFunktion, definiert als

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

Wenn Sie sich die Mühe machen, zwei Aufrufe der Moduloperation zu haben, können Sie diese natürlich als schreiben

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

oder Varianten davon.

Der Grund dafür ist, dass "x% m" immer im Bereich [-m + 1, m-1] liegt. Wenn es also überhaupt negativ ist, wird es durch Hinzufügen von m in den positiven Bereich gebracht, ohne seinen Wert modulo m zu ändern.

Bitte beachten Sie, dass der% -Operator von C # und C ++ eigentlich KEIN Modulo ist, sondern der Rest. Die Formel für Modulo, die Sie in Ihrem Fall möchten, lautet:

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

Sie müssen dies in C # (oder C ++) neu codieren, aber auf diese Weise erhalten Sie Modulo und keinen Rest.

Einzeilige Implementierung mit %nur einmal:

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

Die Antwort von ShreevatsaR funktioniert nicht in allen Fällen, selbst wenn Sie "if (m <0) m = -m;" hinzufügen, wenn Sie negative Dividenden / Teiler berücksichtigen.

Zum Beispiel ist -12 mod -10 8 und sollte -2 sein.

Die folgende Implementierung funktioniert sowohl für positive als auch für negative Dividenden / Teiler und entspricht anderen Implementierungen (nämlich Java, Python, Ruby, Scala, Schema, Javascript und Googles Rechner):

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

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

Verständnis hinzufügen.

Nach euklidischer Definition muss das Mod-Ergebnis immer positiv sein.

Ex:

 int n = 5;
 int x = -3;

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

Ausgabe:

 -1

Addieren Sie einfach Ihren Modul (arrayLength) zum negativen Ergebnis von% und Sie werden in Ordnung sein.

Für leistungsorientiertere Entwickler

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

Ein kleiner Leistungsvergleich

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

Informationen zu den Leistungskosten von Cast to Uint finden Sie hier

Vergleich zweier vorherrschender Antworten

(x%m + m)%m;

und

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

Niemand erwähnte tatsächlich die Tatsache, dass der erste eine OverflowExceptionWeile werfen kann, der zweite nicht. Schlimmer noch, wenn der Standardkontext nicht aktiviert ist, gibt die erste Antwort möglicherweise die falsche Antwort zurück (siehe mod(int.MaxValue - 1, int.MaxValue)zum Beispiel). Die zweite Antwort scheint also nicht nur schneller, sondern auch korrekter zu sein.

Ich mag den Trick, den Peter N Lewis in diesem Thread vorgestellt hat : "Wenn n einen begrenzten Bereich hat, können Sie das gewünschte Ergebnis erzielen, indem Sie einfach ein bekanntes konstantes Vielfaches von [dem Divisor] hinzufügen, das größer ist als der absolute Wert von Minimum."

Wenn ich also einen Wert d habe , der in Grad angegeben ist und den ich nehmen möchte

d % 180f

und ich möchte die Probleme vermeiden, wenn d negativ ist, dann mache ich stattdessen einfach Folgendes:

(d + 720f) % 180f

Dies setzt voraus, dass d zwar negativ sein kann, es jedoch bekannt ist, dass es niemals negativer als -720 sein wird.

Sie erwarten ein Verhalten, das dem dokumentierten Verhalten des Operators% in c # widerspricht - möglicherweise, weil Sie erwarten, dass es so funktioniert, wie es in einer anderen Sprache funktioniert, an die Sie eher gewöhnt sind. Die Dokumentation zu c # besagt (Schwerpunkt Mine):

Für die Operanden ganzzahliger Typen ist das Ergebnis von a% b der Wert, der durch a - (a / b) * b erzeugt wird. Das Vorzeichen des Restes ungleich Null ist das gleiche wie das des linken Operanden

Der gewünschte Wert kann mit einem zusätzlichen Schritt berechnet werden:

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

Alle Antworten hier funktionieren hervorragend, wenn Ihr Divisor positiv ist, aber nicht ganz vollständig. Hier ist meine Implementierung, die immer in einem Bereich von zurückgibt [0, b), sodass das Vorzeichen der Ausgabe mit dem Vorzeichen des Divisors übereinstimmt und negative Divisoren als Endpunkt für den Ausgabebereich berücksichtigt werden.

PosMod(5, 3)return 2
PosMod(-5, 3)return 1
PosMod(5, -3)return -1
PosMod(-5, -3)return-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;
    }

(wo real_tkann ein beliebiger Nummerntyp sein)

Eine einzeilige Implementierung der Antwort von dcastro (die mit anderen Sprachen am kompatibelsten ist):

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

Wenn Sie die Verwendung des %Operators beibehalten möchten (Sie können native Operatoren in C # nicht überladen):

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

Anwendungsfall, beide Werke:

int r = (IntM)a % n;

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