Negatif sayıları işleyen C / C ++ / Obj-C modulo (%) operatörü nasıl kodlanır

C türevi dillerden (bir matematikçi olarak) nefret ettiğim şeylerden biri,

(-1) % 8 // comes out as -1, and not 7

fmodf(-1,8) // fails similarly

En iyi çözüm nedir?

C ++ şablonların ve operatörün aşırı yüklenmesi olasılığına izin veriyor, ancak bunların ikisi de benim için bulanık sular. örnekler minnetle alındı.

Her şeyden önce, buna güvenemeyeceğinizi belirtmek isterim (-1) % 8 == -1. güvenebileceğiniz tek şey budur (x / y) * y + ( x % y) == x. Ancak geri kalanın negatif olup olmadığı uygulama tanımlıdır .

Şimdi neden buradaki şablonları kullanalım? İnsler ve uzunlar için bir aşırı yük olur.

int mod (int a, int b)
{
   int ret = a % b;
   if(ret < 0)
     ret+=b;
   return ret;
}

ve şimdi mod (-1,8) gibi çağırabilirsiniz ve 7 olarak görünecektir.

Düzenleme: Kodumda bir hata buldum. B negatifse işe yaramaz. Bu yüzden bunun daha iyi olduğunu düşünüyorum:

int mod (int a, int b)
{
   if(b < 0) //you can check for b == 0 separately and do what you want
     return -mod(-a, -b);   
   int ret = a % b;
   if(ret < 0)
     ret+=b;
   return ret;
}

Referans: C ++ 03 paragraf 5.6 madde 4:

İkili / işleç bölümü verir ve ikili% işleci, ilk ifadenin ikinciye bölünmesinden kalanı verir. / Veya% 'nin ikinci işleneni sıfır ise davranış tanımsızdır; aksi takdirde (a / b) * b + a% b, a'ya eşittir. Her iki işlenen de negatif değilse, geri kalanı negatif değildir; değilse, kalanın işareti uygulama tanımlıdır .

İşte BOTH OPERANDS için pozitif OR negatif tamsayı VEYA kesirli değerleri işleyen bir C işlevi.

#include <math.h>
float mod(float a, float N) {return a - N*floor(a/N);} //return in range [0, N)

Bu kesinlikle matematiksel açıdan en zarif çözümdür. Ancak, tam sayıları işlemede sağlam olup olmadığından emin değilim. Bazen, int -> fp -> int dönüştürülürken kayan nokta hataları ortaya çıkar.

Bu kodu int olmayanlar için ve int için ayrı bir işlev kullanıyorum.

NOT: N = 0'ı tuzağa düşürmeniz gerekir!

Test cihazı kodu:

#include <math.h>
#include <stdio.h>

float mod(float a, float N)
{
    float ret = a - N * floor (a / N);

    printf("%f.1 mod %f.1 = %f.1 \n", a, N, ret);

    return ret;
}

int main (char* argc, char** argv)
{
    printf ("fmodf(-10.2, 2.0) = %f.1  == FAIL! \n\n", fmodf(-10.2, 2.0));

    float x;
    x = mod(10.2f, 2.0f);
    x = mod(10.2f, -2.0f);
    x = mod(-10.2f, 2.0f);
    x = mod(-10.2f, -2.0f);

    return 0;
}

(Not: Kodu doğrudan CodePad'den derleyip çalıştırabilirsiniz: http://codepad.org/UOgEqAMA )

Çıktı:

fmodf (-10.2, 2.0) = -0.20 == BAŞARISIZ!

10,2 mod 2,0 = 0,2
10,2 mod -2,0 = -1,8
-10,2 mod 2,0 = 1,8
-10,2 mod -2,0 = -0,2

Bjarne Stroustrup'un modulo operatörü olarak değil , kalan operatör %olarak etiketlediğini fark ettim .

Bahse girerim ANSI C & C ++ şartnamelerindeki resmi adıdır ve terminolojinin kötüye kullanımı ortaya çıkmıştır. Bunu bir gerçek için bilen var mı?

Ama durum buysa, o zaman C'nin fmodf () işlevi (ve muhtemelen diğerleri) çok yanıltıcıdır. fremf (), vb. olarak etiketlenmeleri gerekir.

Pozitif modülü bulmanın en basit genel işlevi şudur: x'in hem pozitif hem de negatif değerleri üzerinde çalışır.

int modulo(int x,int N){
    return (x % N + N) %N;
}

Tam sayılar için bu basittir. Sadece yap

(((x < 0) ? ((x % N) + N) : x) % N)

Nbunun türünün olumlu ve temsil edilebilir olduğunu varsayıyorum x. En sevdiğiniz derleyiciniz bunu, assembler'da sadece bir mod işlemiyle sonuçlanacak şekilde optimize edebilmelidir.

Bir matematikçi için en iyi çözüm Python kullanmaktır.

C ++ operatörü aşırı yüklemesinin bununla çok az ilgisi vardır. Yerleşik türler için operatörleri aşırı yükleyemezsiniz. İstediğiniz şey basitçe bir işlevdir. Elbette, bu işlevi tüm ilgili türler için yalnızca 1 parça kodla uygulamak için C ++ şablonunu kullanabilirsiniz.

Standart C kitaplığı fmod, eğer adı doğru hatırlıyorsam, kayan nokta türleri için sağlar.

Tamsayılar için, her zaman negatif olmayan kalanı (Öklid bölünmesine karşılık gelir) şu şekilde döndüren bir C ++ işlev şablonu tanımlayabilirsiniz ...

#include <stdlib.h>  // abs

template< class Integer >
auto mod( Integer a, Integer b )
    -> Integer
{
    Integer const r = a%b;
    return (r < 0? r + abs( b ) : r);
}

... ve mod(a, b)bunun yerine sadece yazın a%b.

Burada türün Integerişaretli bir tamsayı türü olması gerekir.

Kalanın işaretinin bölenin işareti ile aynı olduğu ortak matematik davranışını istiyorsanız, o zaman örneğin

template< class Integer >
auto floor_div( Integer const a, Integer const b )
    -> Integer
{
    bool const a_is_negative = (a < 0);
    bool const b_is_negative = (b < 0);
    bool const change_sign  = (a_is_negative != b_is_negative);

    Integer const abs_b         = abs( b );
    Integer const abs_a_plus    = abs( a ) + (change_sign? abs_b - 1 : 0);

    Integer const quot = abs_a_plus / abs_b;
    return (change_sign? -quot : quot);
}

template< class Integer >
auto floor_mod( Integer const a, Integer const b )
    -> Integer
{ return a - b*floor_div( a, b ); }

… Aynı kısıtlamayla Integer, bu imzalı bir tür.

^{¹ Çünkü Python'un tamsayı bölümü negatif sonsuza doğru yuvarlanır.}

Oh, ben de bunun için tasarımdan nefret ediyorum ....

Temettüyü aşağıdaki gibi imzasız olarak dönüştürebilirsiniz:

unsigned int offset = (-INT_MIN) - (-INT_MIN)%divider

result = (offset + dividend) % divider

ofset modülün (-INT_MIN) katına en yakın olduğu yerde, bu yüzden eklemek ve çıkarmak moduloyu değiştirmeyecektir. İşaretsiz türe sahip olduğunu ve sonucun tamsayı olacağını unutmayın. Maalesef arifmetik taşmaya neden oldukları için INT_MIN ... (- ofset-1) değerlerini doğru şekilde dönüştüremiyor. Ancak bu yöntem, sabit bölücü ile çalışırken işlem başına yalnızca tek bir ek aritmetik avantaja sahiptir (ve koşulsuz), bu nedenle DSP benzeri uygulamalarda kullanılabilir.

Bölücünün 2 ^N (ikinin tamsayı gücü) olduğu özel bir durum vardır, bunun için modulo basit aritmetik ve bitsel mantık kullanılarak hesaplanabilir.

dividend&(divider-1)

Örneğin

x mod 2 = x & 1
x mod 4 = x & 3
x mod 8 = x & 7
x mod 16 = x & 15

Daha yaygın ve daha az karmaşık olan yol, bu işlevi kullanarak modulo elde etmektir (yalnızca pozitif bölücü ile çalışır):

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

Negatif ise bu sadece doğru sonuçtur.

Ayrıca kandırabilirsiniz:

(p% q + q)% q

Çok kısadır, ancak genellikle yavaş olan% iki kullanır.

Bu soruna başka bir çözümün int yerine long türündeki değişkenler için kullanılacağına inanıyorum.

% Operatörünün bazı sorunlara neden olan negatif bir değer döndürdüğü bir kod üzerinde çalışıyordum ([0,1] üzerinde tek tip rastgele değişkenler oluşturmak için gerçekten negatif sayılar istemiyorsunuz :)), ancak değişkenleri uzun yazın, her şey sorunsuz çalışıyordu ve sonuçlar python'da aynı kodu çalıştırırken aldığım sonuçlarla eşleşiyordu (benim için önemli çünkü birkaç platformda aynı "rastgele" sayıları üretebilmek istiyordum.

İşte bu Microsoft Araştırma makalesine göre eski bir soruya yeni bir cevap ve buradaki referanslara .

C11 ve C ++ 11 itibaren, bir anlambilim o Not divolmuştur sıfıra doğru kesme (bakınız [expr.mul]/4). Üstelik, Dbölü d, C ++ 11 teminat bölüm ile ilgili aşağıdaki qTve geri kalanırT

auto const qT = D / d;
auto const rT = D % d;
assert(D == d * qT + rT);
assert(abs(rT) < abs(d));
assert(signum(rT) == signum(D));

signumargümanı olup olmadığına bağlı olarak, 0, -1 +1 haritalar <==,> 0 (bakınız daha bu soru-cevap kaynak kodu).

Kesik bölme ile, kalanın işareti temettü işaretine eşittirD , yani -1 % 8 == -1. C ++ 11 ayrıca std::divüyelerle quotve remkesilmiş bölüme göre bir yapı döndüren bir işlev sağlar .

Mümkün olan başka tanımlar da vardır, örneğin, sözde tabana bölünmüş bölme , yerleşik kesik bölme açısından tanımlanabilir

auto const I = signum(rT) == -signum(d) ? 1 : 0;
auto const qF = qT - I;
auto const rF = rT + I * d;
assert(D == d * qF + rF);
assert(abs(rF) < abs(d));
assert(signum(rF) == signum(d));

Tabana bölünmüş bölme ile, geri kalanın işareti bölenin işaretine eşittird . Haskell ve Oberon gibi dillerde, katlanmış bölme için yerleşik operatörler vardır. C ++ 'da, yukarıdaki tanımları kullanarak bir işlev yazmanız gerekir.

Yine başka bir yol, yerleşik kesik bölünme açısından da tanımlanabilen Öklid bölünmesidir

auto const I = rT >= 0 ? 0 : (d > 0 ? 1 : -1);
auto const qE = qT - I;
auto const rE = rT + I * d;
assert(D == d * qE + rE);
assert(abs(rE) < abs(d));
assert(signum(rE) != -1);

Öklid bölünmesi ile, geri kalanın işareti her zaman pozitiftir .

Dal içermeyen ve sadece 1 mod kullanan bir çözüm için aşağıdakileri yapabilirsiniz

// Works for other sizes too,
// assuming you change 63 to the appropriate value
int64_t mod(int64_t x, int64_t div) {
  return (x % div) + (((x >> 63) ^ (div >> 63)) & div);
}

/ * Uyarı: makro modu, argümanlarının yan etkilerini birden çok kez değerlendirir. * /
# tanımlı mod (r, m) (((r)% (m)) + ((r) <0)? [m): 0)

... ya da denklik sınıfı için herhangi bir temsilci almaya alışabilirsiniz.

C ++ için örnek şablon

template< class T >
T mod( T a, T b )
{
    T const r = a%b;
    return ((r!=0)&&((r^b)<0) ? r + b : r);
}

Bu şablonla, geri kalan C ++ davranışının sıfır olması veya temettüyle aynı işarete sahip olması yerine, geri kalan kalan sıfır olacaktır veya bölenle (payda) aynı işarete (negatif sonsuzluğa yuvarlama eşdeğeri) sahip olacaktır ( pay) (sıfıra yuvarlama eşdeğeri).

define  MOD(a, b)       ((((a)%(b))+(b))%(b))

unsigned mod(int a, unsigned b) {
    return (a >= 0 ? a % b : b - (-a) % b);
}

Bu çözüm (kullanım için mod pozitif ), negatif bölme veya kalan işlemlerin topluca alınmasını önler:

int core_modulus(int val, int mod)
{
    if(val>=0)
        return val % mod;
    else
        return val + mod * ((mod - val - 1)/mod);
}

Yapardım:

((-1)+8) % 8 

Bu, moduloyu yapmadan önce istenen şekilde 7 veren son numarayı birinciye ekler. Bu, -8'e kadar herhangi bir sayı için çalışmalıdır. -9 için 2 * 8 ekleyin.