Bir tam sayının bilinen değer kümeleriyle iki tam sayı (dahil) arasında olup olmadığını belirlemenin en hızlı yolu

x >= start && x <= endBir tamsayının iki tamsayı arasında olup olmadığını test etmenin C veya C ++ ' dan daha hızlı bir yolu var mı ?

GÜNCELLEME : Özel platformum iOS. Bu, belirli bir karedeki pikselleri bir daireyle sınırlayan bir kutu bulanıklaştırma işlevinin bir parçasıdır.

GÜNCELLEME : Kabul edilen cevabı denedikten sonra , kodun bir satırında normal x >= start && x <= endşekilde yapmanın üstünde bir hız artışı emri aldım .

GÜNCELLEME : İşte XCode'un derleyicisi ile sonraki ve öncesi kodu:

YENİ YOL

// diff = (end - start) + 1
#define POINT_IN_RANGE_AND_INCREMENT(p, range) ((p++ - range.start) < range.diff)

Ltmp1313:
 ldr    r0, [sp, #176] @ 4-byte Reload
 ldr    r1, [sp, #164] @ 4-byte Reload
 ldr    r0, [r0]
 ldr    r1, [r1]
 sub.w  r0, r9, r0
 cmp    r0, r1
 blo    LBB44_30

ESKİ YOL

#define POINT_IN_RANGE_AND_INCREMENT(p, range) (p <= range.end && p++ >= range.start)

Ltmp1301:
 ldr    r1, [sp, #172] @ 4-byte Reload
 ldr    r1, [r1]
 cmp    r0, r1
 bls    LBB44_32
 mov    r6, r0
 b      LBB44_33
LBB44_32:
 ldr    r1, [sp, #188] @ 4-byte Reload
 adds   r6, r0, #1
Ltmp1302:
 ldr    r1, [r1]
 cmp    r0, r1
 bhs    LBB44_36

Dallanmayı azaltmanın veya ortadan kaldırmanın böylesine dramatik bir hızlanmayı nasıl sağlayabileceği oldukça şaşırtıcı.

Bunu sadece bir karşılaştırma / dal ile yapmak için eski bir hile var. Hızı gerçekten geliştirip geliştirmeyeceği sorgulamaya açık olabilir ve bunu yapsa bile, muhtemelen fark etmek veya önemsemek için çok azdır, ancak sadece iki karşılaştırma ile başladığınızda, büyük bir gelişme şansı oldukça uzaktır. Kod şöyle görünür:

// use a < for an inclusive lower bound and exclusive upper bound
// use <= for an inclusive lower bound and inclusive upper bound
// alternatively, if the upper bound is inclusive and you can pre-calculate
//  upper-lower, simply add + 1 to upper-lower and use the < operator.
    if ((unsigned)(number-lower) <= (upper-lower))
        in_range(number);

Tipik, modern bir bilgisayarla (yani, iki tamamlayıcı kullanan herhangi bir şey), imzasıza dönüştürme gerçekten bir nop - sadece aynı bitlerin nasıl görüntülendiğinde bir değişiklik.

Tipik bir durumda, upper-lower(varsayılan) bir döngü dışında önceden hesaplayabileceğinizi unutmayın , böylece normalde önemli bir zamana katkıda bulunmaz. Şube talimatlarının sayısını azaltmanın yanı sıra, bu (genellikle) şube tahminini de iyileştirir. Bu durumda, sayı aralığın alt ucunun altında mı yoksa üst ucunun üstünde mi olsa aynı dal alınır.

Bunun nasıl çalıştığı konusunda temel fikir oldukça basittir: işaretsiz bir sayı olarak bakıldığında negatif bir sayı, pozitif bir sayı olarak başlayan her şeyden daha büyük olacaktır.

Pratikte bu yöntem number, menşe noktasına kadar olan aralığı çevirir ve nerede numberaralıkta olup olmadığını kontrol eder . Eğer : Bu bağlanmış alt negatif üst yukarıda bağlanmış ise ve: daha büyük .[0, D]D = upper - lowernumberD

Böyle küçük ölçekte kodlamak için önemli optimizasyonlar yapmak nadirdir. Büyük performans kazançları, kodu daha yüksek bir seviyeden gözlemleyerek ve değiştirerek gelir. Aralık testi ihtiyacını tamamen ortadan kaldırabilir veya O (n ^ 2) yerine sadece O (n) yapabilirsiniz. Eşitsizliğin bir tarafının her zaman ima edilmesi için testleri yeniden sıralayabilirsiniz. Algoritma ideal olsa bile, bu kodun aralık testini 10 milyon kez nasıl yaptığını gördüğünüzde ve kazançları toplamanın ve paralel olarak birçok test yapmak için SSE'yi kullandığınızda kazanç elde etme olasılığı daha yüksektir.

Aynı veriler üzerinden testi kaç kez yapmak istediğinize bağlıdır.

Testi tek bir kez yapıyorsanız, muhtemelen algoritmayı hızlandırmanın anlamlı bir yolu yoktur.

Bunu sonlu değerler kümesi için yapıyorsanız, bir arama tablosu oluşturabilirsiniz. Dizin oluşturma işlemi daha pahalı olabilir, ancak tüm tabloyu önbellekte sığdırabiliyorsanız, işleri hızlandıracak olan tüm dalları koddan kaldırabilirsiniz.

Verileriniz için arama tablosu 128 ^ 3 = 2,097,152 olacaktır. Üç değişkenden birini kontrol edebiliyorsanız start = N, bir kerede tüm örnekleri göz önünde bulundurursanız , çalışma kümesinin boyutu 128^2 = 16432baytlara düşer , bu da çoğu modern önbelleğe iyi uyum sağlar.

Dalsız bir arama tablosunun, açık karşılaştırmalardan yeterince hızlı olup olmadığını görmek için gerçek kodu karşılaştırmanız gerekir.

Bu cevap, kabul edilen cevapla yapılan bir test hakkında rapor vermek içindir. Sıralı rasgele tamsayının büyük bir vektörü üzerinde kapalı bir aralık testi yaptım ve sürpriz olarak temel yöntem (düşük <= num && num <= yüksek) yukarıdaki kabul edilen cevaptan daha hızlı! Test, HP Pavilion g6 (6GB ram'lı AMD A6-3400APU) ​​üzerinde yapılmıştır. İşte test için kullanılan temel kod:

int num = rand();  // num to compare in consecutive ranges.
chrono::time_point<chrono::system_clock> start, end;
auto start = chrono::system_clock::now();

int inBetween1{ 0 };
for (int i = 1; i < MaxNum; ++i)
{
    if (randVec[i - 1] <= num && num <= randVec[i])
        ++inBetween1;
}
auto end = chrono::system_clock::now();
chrono::duration<double> elapsed_s1 = end - start;

yukarıdaki kabul edilen cevap olan aşağıdakilerle karşılaştırıldığında:

int inBetween2{ 0 };
for (int i = 1; i < MaxNum; ++i)
{
    if (static_cast<unsigned>(num - randVec[i - 1]) <= (randVec[i] - randVec[i - 1]))
        ++inBetween2;
}

RandVec'in sıralı bir vektör olduğuna dikkat edin. Herhangi bir MaxNum boyutu için ilk yöntem ikincisini makinemde atıyor!

Değişken aralık kontrolü için:

if (x >= minx && x <= maxx) ...

Bit işlemini kullanmak daha hızlıdır:

if ( ((x - minx) | (maxx - x)) >= 0) ...

Bu iki dalı bire indirecektir.

Güvenli kasayı önemsiyorsanız:

if ((int32_t)(((uint32_t)x - (uint32_t)minx) | ((uint32_t)maxx - (uint32_t)x)) > = 0) ...

Daha fazla değişken aralık kontrolünü bir araya getirebilirsiniz:

if (( (x - minx) | (maxx - x) | (y - miny) | (maxy - y) ) >= 0) ...

Bu 4 dalı 1'e indirecektir.

Öyle hızlı 3.4 kat gcc eski olandan:

Tamsayı üzerinde sadece bitsel işlem yapmak mümkün değil mi?

0 ile 128 arasında olması gerektiğinden, 8. bit ayarlanmışsa (2 ^ 7) 128 veya daha fazladır. Yine de kapsamlı bir karşılaştırma yapmak istediğiniz için kenar durumu bir acı olacaktır.