C / C ++ 'da bir tamsayı bölümünün hızlı tavanı

Verilen tamsayı değerleri xve yC ve C ++ her ikisi q = x/yde kayan nokta eşdeğerinin zemini olarak geri döner . Bunun yerine tavanı döndürme yöntemiyle ilgileniyorum. Örneğin, ceil(10/5)=2veceil(11/5)=3 .

Açık yaklaşım şöyle bir şey içerir:

q = x / y;
if (q * y < x) ++q;

Bu ekstra bir karşılaştırma ve çarpma gerektirir; ve gördüğüm diğer yöntemler (aslında kullanıldı) bir floatveya olarak döküm yapmayı içerir double. Ek çarpma (veya ikinci bir bölme) ve daldan kaçınan ve aynı zamanda bir kayan nokta sayısı olarak dökümü önleyen daha doğrudan bir yöntem var mı?

Pozitif sayılar için

unsigned int x, y, q;

Yuvarlamak ...

q = (x + y - 1) / y;

veya (x + y cinsinden taşmayı önleme)

q = 1 + ((x - 1) / y); // if x != 0

Pozitif sayılar için:

    q = x/y + (x % y != 0);

Sparky'nin cevabı, bu sorunu çözmenin standart bir yoludur, ancak yorumumda da yazdığım gibi, taşma riski taşıyorsunuz. Bu, daha geniş bir tür kullanılarak çözülebilir, ancak bölmek istersenizlong long ?

Nathan Ernst'ün cevabı bir çözüm sunuyor, ancak bir işlev çağrısı, değişken bir bildirim ve bir koşul içeriyor, bu da OPs kodundan daha kısa ve muhtemelen daha da yavaş yapıyor, çünkü optimize etmek daha zor.

Benim çözümüm şudur:

q = (x % y) ? x / y + 1 : x / y;

OPs kodundan biraz daha hızlı olacaktır, çünkü modulo ve bölme işlemci üzerinde aynı talimat kullanılarak gerçekleştirilir, çünkü derleyici eşdeğer olduğunu görebilir. En azından gcc 4.4.1 bu optimizasyonu x86'da -O2 bayrağıyla gerçekleştirir.

Teoride derleyici, Nathan Ernst kodundaki fonksiyon çağrısını sıralayabilir ve aynı şeyi yayabilir, ancak gcc test ettiğimde bunu yapmadı. Bunun nedeni, derlenmiş kodu standart kitaplığın tek bir sürümüne bağlaması olabilir.

Son bir not olarak, son derece sıkı bir döngüde olmanız ve tüm verileriniz kayıtlarda veya L1-önbelleğinde olması haricinde, bunların hiçbiri modern bir makinede önemli değildir. Aksi takdirde, muhtemelen Nathan Ernst'in dışında, bu çözümlerin tümü eşit derecede hızlı olacaktır, bu fonksiyonun ana bellekten alınması gerekiyorsa önemli ölçüde daha yavaş olabilir.

divTek bir çağrıda bölüm ve kalanı almak için cstdlib'deki işlevi kullanabilir ve daha sonra, aşağıdaki gibi tavanı ayrı ayrı kullanabilirsiniz.

#include <cstdlib>
#include <iostream>

int div_ceil(int numerator, int denominator)
{
        std::div_t res = std::div(numerator, denominator);
        return res.rem ? (res.quot + 1) : res.quot;
}

int main(int, const char**)
{
        std::cout << "10 / 5 = " << div_ceil(10, 5) << std::endl;
        std::cout << "11 / 5 = " << div_ceil(11, 5) << std::endl;

        return 0;
}

Buna ne dersin? (negatif olmayan y gerektirir, bu nedenle y'nin olumsuzluk garantisi olmayan bir değişken olduğu nadir durumlarda bunu kullanmayın)

q = (x > 0)? 1 + (x - 1)/y: (x / y);

Ben azaltılmış y/yterimini ortadan kaldırarak, birine x + y - 1taşma ihtimalini ve onunla.

İmzasız bir tür olduğunda ve sıfır içerdiğinde x - 1etrafta dolaşmaktan kaçınırım x.

İmzalı x, negatif ve sıfır hala tek bir vakada birleşir.

Muhtemelen modern bir genel amaçlı CPU üzerinde büyük bir fayda değil, ancak bu gömülü bir sistemde diğer doğru cevaplardan daha hızlı olacaktır.

Hem pozitif hem de negatif için bir çözüm var, xancak ysadece 1 bölümlü ve şubesiz pozitif için bir çözüm var :

int ceil(int x, int y) {
    return x / y + (x % y > 0);
}

Olumluysa, xbölüm sıfıra doğrudur ve hatırlatıcı sıfır değilse 1 eklemeliyiz.

xNegatif ise , bölünme sıfıra doğrudur, ihtiyacımız olan budur ve hiçbir şey eklemeyeceğiz çünkü x % ypozitif değil

Bu, pozitif veya negatif sayılar için çalışır:

q = x / y + ((x % y != 0) ? !((x > 0) ^ (y > 0)) : 0);

Geriye kalanlar varsa x,y aynı işarete sahiptir ve ekler 1buna göre.

Ben daha çok yorum olurdu ama yeterince yüksek bir temsilcisi yok.

Bildiğim kadarıyla, olumlu argümanlar ve 2'nin gücü olan bir bölen için, bu en hızlı yoldur (CUDA'da test edildi):

//example y=8
q = (x >> 3) + !!(x & 7);

Sadece jenerik pozitif argümanlar için, ben böyle yapmak eğilimindedir:

q = x/y + !!(x % y);

basitleştirilmiş genel form,

int div_up(int n, int d) {
    return n / d + (((n < 0) ^ (d > 0)) && (n % d));
} //i.e. +1 iff (not exact int && positive result)

Daha genel bir cevap için, iyi tanımlanmış yuvarlama stratejisi ile tamsayı bölme için C ++ işlevleri

O3 ile derleyin, derleyici optimizasyonu iyi yapar.

q = x / y;
if (x % y)  ++q;