Mod de número negativo está derritiendo mi cerebro

Estoy tratando de modificar un número entero para obtener una posición de matriz para que se repita. Hacerlo i % arrayLengthfunciona bien para números positivos pero para números negativos todo sale 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

así que necesito una implementación de

int GetArrayIndex(int i, int arrayLength)

tal 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

He hecho esto antes, pero por alguna razón hoy me está derritiendo el cerebro :(

Siempre uso mi propia modfunción, definida como

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

Por supuesto, si le preocupa tener dos llamadas a la operación de módulo, puede escribirlo como

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

o variantes de los mismos.

La razón por la que funciona es que "x% m" siempre está en el rango [-m + 1, m-1]. Por lo tanto, si es negativo, agregar m lo colocará en el rango positivo sin cambiar su valor módulo m.

Tenga en cuenta que el operador% de C # y C ++ en realidad NO es un módulo, es el resto. La fórmula para el módulo que desea, en su caso, es:

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

Debe recodificar esto en C # (o C ++), pero esta es la forma en que obtiene el módulo y no un resto.

Implementación de %una sola línea usando solo una vez:

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

La respuesta de ShreevatsaR no funcionará en todos los casos, incluso si agrega "if (m <0) m = -m;", si tiene en cuenta los dividendos / divisores negativos.

Por ejemplo, -12 mod -10 será 8, y debería ser -2.

La siguiente implementación funcionará para dividendos / divisores positivos y negativos y cumple con otras implementaciones (a saber, Java, Python, Ruby, Scala, Scheme, Javascript y la Calculadora de 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;
    }
}

Conjunto de pruebas con 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 };
        }
    }

Agregando algo de comprensión.

Por definición euclidiana, el resultado del mod debe ser siempre positivo.

Ex:

 int n = 5;
 int x = -3;

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

Salida:

 -1

Comparar dos respuestas predominantes

(x%m + m)%m;

y

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

En realidad, nadie mencionó el hecho de que el primero puede tirar un OverflowExceptionrato, mientras que el segundo no lo hará. Peor aún, con el contexto predeterminado sin marcar, la primera respuesta puede devolver la respuesta incorrecta (ver, mod(int.MaxValue - 1, int.MaxValue)por ejemplo). Entonces, la segunda respuesta no solo parece ser más rápida, sino también más correcta.

Simplemente agregue su módulo (arrayLength) al resultado negativo de% y estará bien.

Para los desarrolladores más conscientes del rendimiento

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

Una pequeña comparación de rendimiento

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 cuanto al costo de rendimiento del elenco, mira aquí

Me gusta el truco presentado por Peter N Lewis en este hilo : "Si n tiene un rango limitado, entonces puede obtener el resultado que desea simplemente agregando un múltiplo constante conocido de [el divisor] que es mayor que el valor absoluto de la mínimo."

Entonces, si tengo un valor d que está en grados y quiero tomar

d % 180f

y quiero evitar los problemas si d es negativo, entonces solo hago esto:

(d + 720f) % 180f

Esto supone que aunque d puede ser negativo, se sabe que nunca será más negativo que -720.

Espera un comportamiento que es contrario al comportamiento documentado del operador% en c #, posiblemente porque espera que funcione de una manera que funcione en otro idioma al que está más acostumbrado. La documentación sobre los estados de c # (énfasis mío):

Para los operandos de tipos enteros, el resultado de a% b es el valor producido por a - (a / b) * b. El signo del resto distinto de cero es el mismo que el del operando izquierdo

El valor que desea puede calcularse con un paso adicional:

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

Una implementación de una sola línea de la respuesta de dcastro (la más compatible con otros idiomas):

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

Si desea mantener el uso del %operador (no puede sobrecargar los operadores nativos 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);
}

Caso de uso, ambos trabajos:

int r = (IntM)a % n;

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

Todas las respuestas aquí funcionan muy bien si su divisor es positivo, pero no está completo. Aquí está mi implementación que siempre regresa en un rango de [0, b), de modo que el signo de la salida es el mismo que el del divisor, permitiendo divisores negativos como punto final para el rango de salida.

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

(donde real_tpuede ser cualquier tipo de número)