Negatif sayı modu beynimi eritiyor

Ben yuvarlak döngü böylece bir dizi pozisyon almak için bir tamsayı mod çalışıyorum. Yapmak i % arrayLengthpozitif sayılar için iyi çalışır, ancak negatif sayılar için her şey ters gider.

 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

bu yüzden bir uygulamaya ihtiyacım var

int GetArrayIndex(int i, int arrayLength)

öyle ki

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

Bunu daha önce yaptım ama nedense bugün beynimi eritiyor :(

Her zaman kendi modfonksiyonumu kullanıyorum,

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

Tabii ki, modül işlemine iki çağrı yapmaktan rahatsız olursanız,

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

veya bunların varyantları.

Çalışmasının nedeni "% x m" nin daima [-m + 1, m-1] aralığında olmasıdır. Yani eğer negatifse, ona m eklemek, modulo m değerini değiştirmeden pozitif aralığa koyacaktır.

C # ve C ++ 'ın% operatörünün aslında bir modulo DEĞİLDİR, geri kalanı olduğunu lütfen unutmayın. Sizin durumunuzda istediğiniz modulo için formül:

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

Bunu C # (veya C ++) ile yeniden kodlamanız gerekir, ancak bu modulo ve geri kalan değil.

%Yalnızca bir kez kullanılan tek hat uygulaması :

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

ShreevatsaR'ın cevabı, "if (m <0) m = -m;" ekleseniz bile, negatif temettü / bölenleri hesaba katarsanız tüm durumlar için işe yaramaz.

Örneğin, -12 mod -10 8 olacak ve -2 olmalıdır.

Aşağıdaki uygulama hem olumlu hem de negatif temettüler / bölücüler için çalışacak ve diğer uygulamalara (Java, Python, Ruby, Scala, Şema, Javascript ve Google'ın Hesap Makinesi) uygun olacaktır:

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 kullanarak test takımı:

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

Biraz anlayış katıyorum.

By Öklit tanımı mod sonucu her zaman pozitif olmalıdır.

Ör:

 int n = 5;
 int x = -3;

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

Çıktı:

 -1

İki baskın cevabı karşılaştırma

(x%m + m)%m;

ve

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

Aslında hiç kimse birincisinin bir OverflowExceptionsüre atabileceğinden , ikincisinin yapamayacağından bahsetmedi. Daha da kötüsü, varsayılan işaretlenmemiş bağlamda, ilk yanıt yanlış yanıtı döndürebilir ( mod(int.MaxValue - 1, int.MaxValue)örneğin bkz .). Yani ikinci cevap sadece daha hızlı değil aynı zamanda daha doğru görünüyor.

Modülünüzü (arrayLength)% negatif sonucuna eklemeniz yeterlidir.

Daha fazla performansa duyarlı geliştiriciler için

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

Küçük bir performans karşılaştırması

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

Dökümden uint'e performans maliyeti gelince buraya bir göz atın

Ben bu iş parçacığı üzerinde Peter N Lewis tarafından sunulan hüner gibi : "Eğer n sınırlı bir aralığı varsa, o zaman basitçe mutlak değeri daha büyük [divizör] bilinen bir sabit katını ekleyerek istediğiniz sonucu alabilirsiniz asgari."

Yani derece cinsinden bir d değerine sahipsem ve almak istiyorum

d % 180f

ve d negatifse sorunlardan kaçınmak istiyorum , bunun yerine ben sadece bunu yapmak:

(d + 720f) % 180f

Bu, d'nin negatif olmasına rağmen , asla -720'den daha olumsuz olmayacağı biliniyor.

% Operatörünün belgelenmiş davranışına aykırı bir davranış bekliyorsunuz - muhtemelen, daha çok alışık olduğunuz başka bir dilde çalışacak şekilde çalışmasını bekliyorsunuz. Dokümantasyon c # devletler (vurgu benim) tarih:

Tamsayı tiplerinin işlenenleri için% b'nin sonucu, a - (a / b) * b tarafından üretilen değerdir. Sıfır olmayan kalanın işareti, soldaki işlenenin işareti ile aynıdır.

İstediğiniz değer ekstra bir adımla hesaplanabilir:

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

Dcastro'nun cevabının tek bir satır uygulaması ( diğer dillerle en uyumlu):

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

%Operatör kullanımını korumak isterseniz (C # 'da yerel operatörleri aşırı yükleyemezsiniz):

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

Kullanım durumu, her ikisi de çalışır:

int r = (IntM)a % n;

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

Bölgeniz olumluysa, buradaki tüm cevaplar harika çalışıyor, ancak tam değil. İşte her zaman bir aralıkta dönen benim uygulama [0, b), böylece çıkış işareti bölen işareti ile aynı olacak, çıkış aralığı için bitiş noktası olarak negatif bölücüler izin.

PosMod(5, 3)döner 2
PosMod(-5, 3)döner 1
PosMod(5, -3)döner -1
PosMod(-5, -3)döner-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_therhangi bir sayı türü olabilir)