Який варіант краще використовувати для ділення цілого числа на 2?

Який із наведених методів є найкращим варіантом ділення цілого числа на 2 і чому?

Техніка 1:

x = x >> 1;

Техніка 2:

x = x / 2;

Ось xціле число.

Скористайтеся операцією, яка найкраще описує те, що ви намагаєтесь зробити.

• Якщо ви розглядаєте число як послідовність бітів, використовуйте бітсифт.
• Якщо ви трактуєте це як числове значення, використовуйте поділ.

Зауважте, що вони не зовсім рівноцінні. Вони можуть давати різні результати для від'ємних цілих чисел. Наприклад:

-5 / 2  = -2
-5 >> 1 = -3

(ideone)

Чи схожий на перший поділ? Ні. Якщо ви хочете розділити, використовуйте x / 2. Компілятор може оптимізувати його, щоб по можливості використовувати біт-зсув (це називається зниження сили), що робить його марною мікрооптимізацією, якщо ви робите це самостійно.

Складати: є так багато причин на користь використання x = x / 2; Ось кілька:

• це виражає ваші наміри чіткіше (якщо припустити, що ви не маєте справу з бітними подвійними реєстраційними бітами чи іншим)

• компілятор все одно зменшить це до операції зсуву

• навіть якщо компілятор не зменшив його і вибрав більш повільну операцію, ніж зміщення, ймовірність того, що це в кінцевому підсумку впливає на продуктивність вашої програми, що вимірюється, сама по собі є малим (і якщо це вплине на неї помірно, то у вас є фактичний причина використовувати зміну)

• якщо поділ буде частиною більшого виразу, ви, швидше за все, отримаєте право пріоритету, якщо будете використовувати оператор поділу:

  x = x / 2 + 5;
  x = x >> 1 + 5;  // not the same as above

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

• ще раз повторюю - компілятор все одно зробить це для вас. Насправді це перетворить поділ на постійне на серію змін, додає та помножить на всілякі числа, а не лише на дві потужності. Дивіться це запитання для посилань на ще більше інформації про це.

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

Який із них найкращий варіант і чому для ділення цілого числа на 2?

Залежить від того, що ви маєте на увазі найкраще .

Якщо ви хочете, щоб ваші колеги ненавиділи вас або зробили ваш код важким для читання, я б неодмінно пішов із першим варіантом.

Якщо ви хочете поділити число на 2, перейдіть з другим.

Два не є рівнозначними, вони не поводяться однаково, якщо число від’ємне або всередині більших виразів - бітшіфт має нижчий пріоритет, ніж +або -, поділ має більший пріоритет.

Ви повинні написати свій код, щоб висловити його наміри. Якщо продуктивність викликає занепокоєння, не хвилюйтесь, оптимізатор добре працює в таких мікрооптимізаціях.

Просто використовуйте поділ ( /), припускаючи, що це зрозуміліше. Компілятор буде оптимізовано відповідно.

Я погоджуюся з іншими відповідями, які вам слід x / 2надати перевагу, оскільки його намір ясніший, і компілятор повинен оптимізувати його для вас.

Тим НЕ менше, ще одна причина віддати перевагу x / 2більш x >> 1, що поведінка >>залежить від реалізації , якщо xце знакова intі негативний.

З розділу 6.5.7, пункт 5 стандарту ISO C99:

Результат - E1 >> E2це E1зміщені E2бітові позиції вправо . Якщо E1має неподписаний тип або якщо E1має підписаний тип і негативне значення, значення результату є невід'ємною частиною коефіцієнта E1/ 2 ^E2. Якщо E1має підписаний тип та негативне значення, отримане значення визначається реалізацією.

x / 2зрозуміліше і x >> 1не набагато швидше (згідно з мікро-орієнтиром, приблизно на 30% швидше для Java JVM). Як зазначали інші, округлення для від'ємних чисел дещо відрізняється, тому вам доведеться враховувати це, коли ви хочете обробити від’ємні числа. Деякі компілятори можуть автоматично конвертувати x / 2в , x >> 1якщо вони знають , що число не може бути негативним (навіть думав , що я не міг перевірити це).

Навіть x / 2не можна використовувати інструкцію процесора (повільного) поділу процесора, оскільки деякі ярлики можливі , але це все-таки повільніше, ніж x >> 1.

(Це питання C / C ++, інші мови програмування мають більше операторів. Для Java є також підписаний правий зсув x >>> 1, який знову відрізняється. Це дозволяє правильно обчислити середнє (середнє) значення двох значень, так що (a + b) >>> 1буде повернути середнє значення навіть для дуже великих значень aі b. Це потрібно, наприклад, для двійкового пошуку, якщо показники масиву можуть бути дуже великими. У багатьох версіях двійкового пошуку виникла помилка , оскільки вони використовувались (a + b) / 2для обчислення середнього значення. Це не означає не працюю правильно. Правильне рішення - (a + b) >>> 1замість цього використовувати .)

Кнут сказав:

Передчасна оптимізація - корінь усього зла.

Тому я пропоную використовувати x /= 2;

Таким чином код легко зрозуміти, а також я думаю, що оптимізація цієї операції в такому вигляді не означає великої різниці для процесора.

Погляньте на висновок компілятора, щоб допомогти вам прийняти рішення. Я провів цей тест на x86-64 з
gcc (GCC) 4.2.1 20070719 [FreeBSD]

Також дивіться результати компілятора в Інтернеті на godbolt .

Те, що ви бачите, компілятор використовує sarlв обох випадках інструкцію (арифметичне праворушення), тож вона визнає схожість між двома виразами. Якщо ви використовуєте ділення, компілятору також потрібно скоригуватися на від’ємні числа. Для цього він зміщує біт знака вниз до біта нижнього порядку і додає це до результату. Це виправляє проблему, що не відповідає одному, при зміщенні від'ємних чисел, порівняно з тим, що буде ділити.
Оскільки випадок поділу робить 2 зміни, а випадок явного зсуву - лише один, то тепер ми можемо пояснити деякі відмінності в продуктивності, виміряні іншими відповідями.

C код з складанням виводу:

Для розділення ваш внесок буде

int div2signed(int a) {
  return a / 2;
}

і це збирається в

    movl    %edi, %eax
    shrl    $31, %eax
    addl    %edi, %eax
    sarl    %eax
    ret

аналогічно для зміни

int shr2signed(int a) {
  return a >> 1;
}

з виходом:

    sarl    %edi
    movl    %edi, %eax
    ret

Просто додана примітка -

x * = 0,5 часто буде швидшим у деяких мовах, що базуються на VM - особливо сценаріїв дій, оскільки змінну не потрібно перевіряти на ділення на 0.

Використовуйте x = x / 2; АБО x /= 2;Тому, що можливо, в майбутньому над ним працює новий програміст. Так йому буде простіше дізнатися, що відбувається в рядку коду. Кожна людина може не знати про такі оптимізації.

Я розповідаю з метою змагань з програмування. Як правило, вони мають дуже великі входи, де поділ на 2 відбувається багато разів, і відомо, що вхід позитивний чи негативний.

x >> 1 буде кращим, ніж x / 2. Я перевірив на ideone.com, запустивши програму, де відбулося більше 10 ^ 10 поділу на 2 операції. x / 2 зайняв майже 5,5 секунди, тоді як x >> 1 взяв майже 2,6 для тієї самої програми.

Я б сказав, що слід розглянути кілька речей.

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

2. Оператор поділу для людей дуже легко читати. Тож якщо ви шукаєте читабельність коду, ви могли б скористатися цим. Зауважте, що поле оптимізації компілятора пройшло довгий шлях, тому полегшення практики читання та розуміння коду є хорошою практикою.

3. Залежно від базового обладнання, операції можуть мати різну швидкість. Закон Амдала полягає в тому, щоб зробити загальну справу швидкою. Тож у вас може бути обладнання, яке може виконувати різні операції швидше, ніж інші. Наприклад, множення на 0,5 може бути швидшим, ніж ділення на 2. (Дозволено, вам може знадобитися взяти слово множення, якщо ви хочете застосувати ціле ділення).

Якщо ви після чистої продуктивності, я б рекомендував створити кілька тестів, які могли б зробити операції мільйони разів. Виконайте кілька разів виконання (розмір вибірки), щоб визначити, який із статистичних даних найкращий для вашої ОС / апаратного забезпечення / компілятора / коду.

Що стосується процесора, операції з переміщенням бітів проходять швидше, ніж операції поділу. Однак компілятор це знає і оптимізує належним чином настільки, наскільки це можливо, тож ви можете кодувати таким чином, щоб максимально зрозуміло та було легко, знаючи, що ваш код працює ефективно. Але пам’ятайте, що баночка unsigned int(в деяких випадках) може бути оптимізована краще, ніж з intпричин, зазначених раніше. Якщо вам не потрібен арифметичний підпис, не включайте біт знаків.

х = х / 2; є відповідним кодом для використання .. але операція залежить від вашої власної програми того, як саме ви хочете отримати результат.

Зробіть свої наміри яснішими ... наприклад, якщо ви хочете розділити, використовуйте x / 2, і дозвольте компілятору оптимізувати його для переміщення оператора (або будь-чого іншого).

Сьогоднішні процесори не дозволяють цим оптимізаціям вплинути на продуктивність ваших програм.

Відповідь на це залежатиме від середовища, в якому ви працюєте.

• Якщо ви працюєте над 8-бітовим мікроконтролером чи іншим без апаратної підтримки для множення, зміна бітів очікується і звичайне явище, і поки компілятор майже напевно перетвориться x /= 2наx >>= 1 , наявність символу поділу призведе до більшої кількості брів у цьому середовищі, ніж використовуючи зсув для здійснення поділу.
• Якщо ви працюєте в критичному для продуктивного середовища середовищі або в розділі коду, або ваш код може бути складений при відключенні оптимізації компілятора, x >>= 1 з коментарем, що пояснює його міркування, мабуть, найкраще саме для ясності мети.
• Якщо ви не перебуваєте в одній з перерахованих вище умов, зробіть свій код читабельнішим просто використанням x /= 2. Краще збережіть наступного програміста, який випадково перегляне ваш код на 10-секундне подвійне виконання вашої операції зміни, ніж непотрібно доводити, що ви знали, що зміна була більш ефективною оптимізацією компілятора.

Всі ці припущення мають непідписані цілі числа. Простий зсув, мабуть, не те, що ви хочете для підписаних. Крім того, DanielH пропонує хороший момент щодо використання x *= 0.5для таких мов, як ActionScript.

мод 2, тест на = 1. не синтаксис у c. але це може бути найшвидшим.

як правило, правильний зсув ділиться:

q = i >> n; is the same as: q = i / 2**n;

це іноді використовується для прискорення програм ціною ясності. Я не думаю, що ти повинен це робити. Компілятор досить розумний для автоматичного виконання прискорення. Це означає, що введення змін у день не приносить вам нічого за рахунок ясності .

Погляньте на цю сторінку з Практичного програмування на C ++.

Очевидно, якщо ви пишете свій код для наступного хлопця, який його читає, перейдіть до ясності "x / 2".

Однак якщо швидкість - ваша мета, спробуйте її як способами, так і часом. Кілька місяців тому я працював над програмою згортання растрових карт, яка передбачала перехід масиву цілих чисел і розділення кожного елемента на 2. Я робив усілякі речі для його оптимізації, включаючи старий трюк заміни "x >> 1" на "x / 2 ".

Коли я насправді приуротив обидва способи, я здивував, що x / 2 швидше, ніж x >> 1

Для цього використовується Microsoft VS2008 C ++ із увімкненими оптимізаціями за замовчуванням.

З точки зору продуктивності. Операції з перемикання процесора значно швидші, ніж діючі оп-коди. Таким чином, ділення на два або множення на 2 і т.д. всі виграють від операцій зсуву.

Щодо зовнішнього вигляду. Як інженери, коли ми стали настільки прихильні до косметики, що навіть прекрасні дами не користуються! :)

X / Y є правильним ... і ">>" оператором зсуву. Якщо ми хочемо два розділити ціле число, ми можемо використовувати (/) оператор дивідендів. Оператор shift використовується для переміщення бітів.

х = х / 2; х / = 2; ми можемо використовувати так ..

Хоча x >> 1 швидше, ніж x / 2, правильне використання >> при роботі з негативними значеннями трохи складніше. Для цього потрібно щось подібне до наступного:

// Extension Method
public static class Global {
    public static int ShiftDivBy2(this int x) {
        return (x < 0 ? x + 1 : x) >> 1;
    }
}