วิธีที่เร็วที่สุดในการพิจารณาว่าจำนวนเต็มอยู่ระหว่างสองจำนวนเต็ม (รวม) กับชุดของค่าที่ทราบ

มีวิธีเร็วกว่าx >= start && x <= endใน C หรือ C ++ เพื่อทดสอบว่าจำนวนเต็มอยู่ระหว่างสองจำนวนเต็ม?

อัปเดต : แพลตฟอร์มเฉพาะของฉันคือ iOS นี่เป็นส่วนหนึ่งของฟังก์ชันเบลอเบลอที่ จำกัด พิกเซลไว้ที่วงกลมในสี่เหลี่ยมจัตุรัสที่กำหนด

UPDATE : หลังจากที่พยายามตอบรับผมได้มีคำสั่งเพิ่มความเร็วขนาดในหนึ่งบรรทัดของรหัสมากกว่าทำมันปกติx >= start && x <= endทาง

UPDATE : นี่คือโค้ดหลังและก่อนหน้ากับแอสเซมเบลอร์จาก XCode:

วิธีการใหม่

// 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

วิธีเก่า ๆ

#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

ค่อนข้างน่าทึ่งว่าการลดหรือกำจัดการแตกแขนงนั้นสามารถให้ความเร็วได้อย่างน่าทึ่ง

มีเคล็ดลับเก่า ๆ ในการทำเช่นนี้กับการเปรียบเทียบ / สาขาเดียว ไม่ว่าจะปรับปรุงความเร็วจริง ๆ อาจเปิดให้ถามได้และถึงแม้ว่าจะเป็นเช่นนั้นก็อาจน้อยเกินไปที่จะสังเกตเห็นหรือสนใจ แต่เมื่อคุณเริ่มจากการเปรียบเทียบสองครั้งโอกาสในการปรับปรุงครั้งใหญ่นั้นค่อนข้างไกล รหัสดูเหมือนว่า:

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

ด้วยคอมพิวเตอร์ทั่วไปที่ทันสมัย ​​(เช่นอะไรก็ตามที่ใช้ส่วนประกอบเสริม twos) การแปลงเป็นไม่ได้ลงนามนั้นเป็นสิ่งที่ไม่จริง - เพียงแค่การเปลี่ยนวิธีการดูบิตเดียวกัน

โปรดทราบว่าในกรณีทั่วไปคุณสามารถคำนวณล่วงหน้าupper-lowerนอกลูป (สันนิษฐาน) เพื่อที่จะไม่ได้มีส่วนร่วมในเวลาที่สำคัญ นอกเหนือจากการลดจำนวนคำสั่งสาขาแล้วยังช่วยปรับปรุงการทำนายสาขาด้วย ในกรณีนี้สาขาเดียวกันจะถูกนำมาใช้ไม่ว่าจะเป็นหมายเลขที่อยู่ด้านล่างสุดด้านล่างหรือด้านบนสุดของช่วง

สำหรับวิธีการทำงานแนวคิดพื้นฐานนั้นค่อนข้างง่าย: จำนวนลบเมื่อมองว่าเป็นตัวเลขที่ไม่ได้ลงชื่อจะมีขนาดใหญ่กว่าสิ่งใด ๆ ที่เริ่มเป็นตัวเลขบวก

ในทางปฏิบัติวิธีการนี้แปลnumberและช่วงเวลาไปยังจุดต้นทางและตรวจสอบว่าnumberอยู่ในช่วงเวลา[0, D]หรือD = upper - lowerไม่ ถ้าnumberด้านล่างลดผูกพัน: เชิงลบและถ้าข้างต้นที่ถูกผูกไว้บน: มีขนาดใหญ่กว่าD

มันยากที่จะสามารถทำการปรับแต่งที่สำคัญให้กับโค้ดในระดับเล็ก ๆ ประสิทธิภาพที่เพิ่มขึ้นอย่างมากมาจากการสังเกตและแก้ไขโค้ดจากระดับที่สูงขึ้น คุณอาจสามารถขจัดความจำเป็นในการทดสอบช่วงทั้งหมดหรือทำเพียง O (n) ของพวกเขาแทน O (n ^ 2) คุณอาจสามารถจัดลำดับการทดสอบอีกครั้งเพื่อให้ด้านหนึ่งของความไม่เท่าเทียมกันนั้นส่อให้เห็นอยู่เสมอ แม้ว่าอัลกอริธึมจะเหมาะสม แต่กำไรก็มีแนวโน้มที่จะมาเมื่อคุณเห็นว่ารหัสนี้ทดสอบช่วง 10 ล้านครั้งอย่างไรและคุณหาวิธีที่จะทำการผสมมันและใช้ SSE เพื่อทำการทดสอบหลายแบบพร้อมกัน

ขึ้นอยู่กับจำนวนครั้งที่คุณต้องการทำการทดสอบผ่านข้อมูลเดียวกัน

หากคุณทำการทดสอบในครั้งเดียวอาจไม่มีวิธีที่มีความหมายในการเร่งความเร็วอัลกอริทึม

หากคุณกำลังทำสิ่งนี้เพื่อชุดค่าที่ จำกัด มากคุณสามารถสร้างตารางการค้นหาได้ การจัดทำดัชนีอาจมีราคาแพงกว่า แต่ถ้าคุณสามารถใส่ทั้งตารางในแคชได้คุณสามารถลบการแยกทั้งหมดออกจากโค้ดซึ่งควรทำให้เร็วขึ้น

สำหรับข้อมูลของคุณตารางการค้นหาจะเป็น 128 ^ 3 = 2,097,152 หากคุณสามารถควบคุมหนึ่งในสามของตัวแปรเพื่อให้คุณพิจารณาอินสแตนซ์ทั้งหมดที่start = Nในครั้งเดียวขนาดของชุดการทำงานจะลดลงเป็น128^2 = 16432ไบต์ซึ่งน่าจะพอดีกับแคชที่ทันสมัยที่สุด

คุณยังคงต้องทำการเปรียบเทียบโค้ดจริงเพื่อดูว่าตารางการค้นหาแบบไม่มีสาขานั้นเร็วกว่าการเปรียบเทียบที่ชัดเจนหรือไม่

คำตอบนี้คือการรายงานการทดสอบที่ทำกับคำตอบที่ยอมรับได้ ฉันทำการทดสอบช่วงปิดบนเวกเตอร์ขนาดใหญ่ของจำนวนเต็มแบบสุ่มที่จัดเรียงและทำให้ฉันประหลาดใจวิธีพื้นฐานของ (ต่ำ <= num && num <= สูง) เป็นจริงเร็วกว่าคำตอบที่ยอมรับข้างต้น! ทำการทดสอบบน HP Pavilion g6 (AMD A6-3400APU พร้อม RAM 6GB นี่คือรหัสหลักที่ใช้สำหรับการทดสอบ:

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;

เปรียบเทียบกับต่อไปนี้ซึ่งเป็นคำตอบที่ยอมรับด้านบน:

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 เป็นเวกเตอร์ที่เรียงลำดับ สำหรับ MaxNum ทุกขนาดวิธีแรกจะชนะอันดับที่สองบนเครื่องของฉัน!

สำหรับการตรวจสอบช่วงตัวแปรใด ๆ :

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

มันเร็วกว่าที่จะใช้การทำงานของบิต:

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

สิ่งนี้จะลดสองกิ่งเป็นหนึ่ง

หากคุณสนใจเกี่ยวกับประเภทที่ปลอดภัย:

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

คุณสามารถรวมการตรวจสอบช่วงตัวแปรเพิ่มเติมเข้าด้วยกัน:

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

สิ่งนี้จะลด 4 สาขาเป็น 1

มันเป็น3.4 เท่าเร็วกว่าเดิมใน GCC:

เป็นไปไม่ได้หรือที่จะทำการบิตบิทในจำนวนเต็ม?

เนื่องจากต้องอยู่ระหว่าง 0 ถึง 128 หากตั้งค่าบิตที่ 8 (2 ^ 7) เป็น 128 หรือมากกว่า กรณีขอบจะเจ็บปวด แต่เนื่องจากคุณต้องการเปรียบเทียบรวม