Найшвидший спосіб визначити, чи є ціле число між двома цілими числами (включно) з відомими наборами значень

Чи є швидший спосіб x >= start && x <= endперевірити, чи є ціле число між двома цілими числами?

ОНОВЛЕННЯ : Моя конкретна платформа - iOS. Це частина функції розмиття поля, яка обмежує пікселі колом у заданому квадраті.

ОНОВЛЕННЯ : Після спробу прийнятої відповіді я отримав порядок прискорення масштабу в одному рядку коду над тим, як робити це звичайним x >= start && x <= endчином.

ОНОВЛЕННЯ : Ось код після і перед асемблером від 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);

З типовим сучасним комп’ютером (тобто все, що використовує двійки), перетворення на безпідписаний насправді є nop - лише зміною способу перегляду одних і тих же бітів.

Зауважте, що в типовому випадку ви можете попередньо обчислити 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байтів, що має добре відповідати в більшості сучасних кеш-пам'яток.

Вам все одно доведеться порівняти фактичний код, щоб побачити, чи достатньо швидка таблиця пошуку без гілок, ніж очевидні порівняння.

Ця відповідь полягає у звіті про тестування, проведене за допомогою прийнятої відповіді. Я провів тест закритого діапазону на великому векторі відсортованого випадкового цілого числа, і на мій подив, основний метод (низький <= число & & число <= високий) насправді швидший, ніж прийнятий відповідь вище! Тест проводився на HP Pavilion g6 (AMD A6-3400APU з 6 ГБ оперативної пам’яті. Ось основний код, який використовується для тестування:

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 або більше. Крайній випадок буде болем, оскільки ви хочете всебічне порівняння.