Mod de nombre négatif fait fondre mon cerveau

J'essaie de modifier un entier pour obtenir une position de tableau afin qu'il boucle autour. Faire i % arrayLengthfonctionne bien pour les nombres positifs, mais pour les nombres négatifs, tout va mal.

 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

donc j'ai besoin d'une implémentation de

int GetArrayIndex(int i, int arrayLength)

tel que

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

Je l'ai déjà fait mais pour une raison quelconque, cela fait fondre mon cerveau aujourd'hui :(

J'utilise toujours ma propre modfonction, définie comme

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

Bien sûr, si vous êtes dérangé d'avoir deux appels à l'opération de module, vous pouvez l'écrire comme

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

ou leurs variantes.

La raison pour laquelle cela fonctionne est que "x% m" est toujours dans la plage [-m + 1, m-1]. Donc, s'il est négatif, ajouter m le mettra dans la plage positive sans changer sa valeur modulo m.

Veuillez noter que l'opérateur% de C # et C ++ n'est en fait PAS un modulo, c'est le reste. La formule du modulo que vous souhaitez, dans votre cas, est:

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

Vous devez recoder ceci en C # (ou C ++) mais c'est ainsi que vous obtenez modulo et non un reste.

Implémentation sur %une seule ligne en utilisant une seule fois:

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

La réponse de ShreevatsaR ne fonctionnera pas dans tous les cas, même si vous ajoutez "si (m <0) m = -m;", si vous tenez compte des dividendes / diviseurs négatifs.

Par exemple, -12 mod -10 sera 8 et il devrait être -2.

L'implémentation suivante fonctionnera pour les dividendes / diviseurs positifs et négatifs et est conforme à d'autres implémentations (à savoir, Java, Python, Ruby, Scala, Scheme, Javascript et 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 de tests utilisant 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 };
        }
    }

Ajout d'un peu de compréhension.

Par définition euclidienne, le résultat du mod doit être toujours positif.

Ex:

 int n = 5;
 int x = -3;

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

Production:

 -1

Comparaison de deux réponses prédominantes

(x%m + m)%m;

et

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

Personne n'a en fait mentionné le fait que le premier peut lancer un OverflowExceptioncertain temps tandis que le second ne le fera pas. Pire encore, avec un contexte non coché par défaut, la première réponse peut renvoyer la mauvaise réponse (voir mod(int.MaxValue - 1, int.MaxValue)par exemple). La deuxième réponse semble donc non seulement plus rapide, mais aussi plus correcte.

Ajoutez simplement votre module (arrayLength) au résultat négatif de% et tout ira bien.

Pour les développeurs plus sensibles aux performances

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

Une petite comparaison des performances

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

En ce qui concerne le coût des performances du casting, jetez un œil ici

J'aime le truc présenté par Peter N Lewis sur ce fil : «Si n a une plage limitée, alors vous pouvez obtenir le résultat que vous voulez simplement en ajoutant un multiple constant connu de [le diviseur] qui est supérieur à la valeur absolue du le minimum."

Donc si j'ai une valeur d qui est en degrés et que je veux prendre

d % 180f

et je veux éviter les problèmes si d est négatif, alors je fais simplement ceci:

(d + 720f) % 180f

Cela suppose que bien que d puisse être négatif, on sait qu'il ne sera jamais plus négatif que -720.

Vous vous attendez à un comportement contraire au comportement documenté de l'opérateur% dans c # - peut-être parce que vous vous attendez à ce qu'il fonctionne de manière à fonctionner dans un autre langage auquel vous êtes plus habitué. La documentation sur les états c # (c'est moi qui souligne):

Pour les opérandes de types entiers, le résultat de a% b est la valeur produite par a - (a / b) * b. Le signe du reste non nul est le même que celui de l'opérande de gauche

La valeur souhaitée peut être calculée avec une étape supplémentaire:

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

Une implémentation en ligne unique de la réponse de dcastro (la plus compatible avec les autres langages):

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

Si vous souhaitez conserver l'utilisation d' %opérateur (vous ne pouvez pas surcharger les opérateurs natifs en 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);
}

Cas d'utilisation, les deux fonctionnent:

int r = (IntM)a % n;

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

Toutes les réponses ici fonctionnent très bien si votre diviseur est positif, mais ce n'est pas tout à fait complet. Voici mon implémentation qui retourne toujours sur une plage de [0, b), telle que le signe de la sortie est le même que le signe du diviseur, ce qui permet des diviseurs négatifs comme point final de la plage de sortie.

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

(où real_tpeut être n'importe quel type de nombre)