Mod di numero negativo mi sta sciogliendo il cervello

Sto provando a modificare un numero intero per ottenere una posizione di array in modo che si arrotoli. Fare i % arrayLengthfunziona bene per i numeri positivi ma per i numeri negativi va tutto storto.

 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

quindi ho bisogno di un'implementazione di

int GetArrayIndex(int i, int arrayLength)

tale che

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

L'ho già fatto prima, ma per qualche ragione oggi mi sta sciogliendo il cervello :(

Uso sempre la mia modfunzione, definita come

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

Naturalmente, se ti preoccupi di avere due chiamate all'operazione del modulo, potresti scriverlo come

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

o sue varianti.

Il motivo per cui funziona è che "x% m" è sempre nell'intervallo [-m + 1, m-1]. Quindi, se è del tutto negativo, l'aggiunta di m lo inserirà nell'intervallo positivo senza modificarne il valore modulo m.

Nota che l'operatore% C # e C ++ NON è in realtà un modulo, è il resto. La formula per modulo che vuoi, nel tuo caso, è:

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

Devi ricodificarlo in C # (o C ++) ma questo è il modo in cui ottieni modulo e non un resto.

Implementazione su linea singola usando %una sola volta:

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

La risposta di ShreevatsaR non funzionerà in tutti i casi, anche se si aggiunge "if (m <0) m = -m;", se si considerano dividendi / divisori negativi.

Ad esempio, -12 mod -10 sarà 8 e dovrebbe essere -2.

La seguente implementazione funzionerà sia per i dividendi / divisori positivi che negativi e è conforme ad altre implementazioni (vale a dire Java, Python, Ruby, Scala, Scheme, Javascript e Google's Calculator):

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

Suite di test utilizzando 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 };
        }
    }

Aggiungendo un po 'di comprensione.

Per definizione euclidea il risultato mod deve essere sempre positivo.

Ex:

 int n = 5;
 int x = -3;

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

Produzione:

 -1

Confronto tra due risposte predominanti

(x%m + m)%m;

e

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

Nessuno in realtà ha menzionato il fatto che il primo potrebbe lanciare un OverflowExceptionpo 'di tempo, il secondo no. Ancora peggio, con il contesto predefinito non selezionato, la prima risposta potrebbe restituire la risposta errata (vedere mod(int.MaxValue - 1, int.MaxValue)ad esempio). Quindi la seconda risposta non solo sembra essere più veloce, ma anche più corretta.

Aggiungi il tuo modulo (arrayLength) al risultato negativo di% e andrà tutto bene.

Per gli sviluppatori più consapevoli delle prestazioni

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

Un piccolo confronto delle prestazioni

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

Per quanto riguarda il costo delle prestazioni del cast, dai un'occhiata qui

Mi piace il trucco presentato da Peter N Lewis su questo thread : "Se n ha un intervallo limitato, puoi ottenere il risultato desiderato semplicemente aggiungendo un multiplo costante noto del [divisore] che è maggiore del valore assoluto del valore minimo."

Quindi, se ho un valore d che è in gradi e voglio prendere

d % 180f

e voglio evitare i problemi se d è negativo, quindi invece faccio solo questo:

(d + 720f) % 180f

Ciò presuppone che sebbene d possa essere negativo, è noto che non sarà mai più negativo di -720.

Ti aspetti un comportamento contrario al comportamento documentato dell'operatore% in c #, probabilmente perché ti aspetti che funzioni in un modo che funzioni in un'altra lingua a cui sei più abituato. La documentazione sugli stati c # (sottolineatura mia):

Per gli operandi di tipi interi, il risultato di a% b è il valore prodotto da a - (a / b) * b. Il segno del resto diverso da zero è uguale a quello dell'operando di sinistra

Il valore desiderato può essere calcolato con un ulteriore passaggio:

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

Un'implementazione a riga singola della risposta di dcastro (la più conforme ad altre lingue):

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

Se desideri mantenere l'uso %dell'operatore (non puoi sovraccaricare gli operatori nativi in ​​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);
}

Caso d'uso, entrambi funzionano:

int r = (IntM)a % n;

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

Tutte le risposte qui funzionano alla grande se il tuo divisore è positivo, ma non è del tutto completo. Ecco la mia implementazione che ritorna sempre su una gamma di[0, b) , in modo tale che il segno dell'output sia uguale al segno del divisore, consentendo divisori negativi come endpoint per l'intervallo di output.

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

(dove real_tpuò essere qualsiasi tipo di numero)