Qual è l'opzione migliore da usare per dividere un numero intero per 2?

Quale delle seguenti tecniche è l'opzione migliore per dividere un numero intero per 2 e perché?

Tecnica 1:

x = x >> 1;

Tecnica 2:

x = x / 2;

Ecco xun numero intero.

Utilizzare l'operazione che meglio descrive ciò che si sta tentando di fare.

• Se stai trattando il numero come una sequenza di bit, usa bitshift.
• Se lo stai trattando come un valore numerico, usa la divisione.

Si noti che non sono esattamente equivalenti. Possono dare risultati diversi per numeri interi negativi. Per esempio:

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

(Ideone)

Il primo sembra dividere? No. Se vuoi dividere, usa x / 2. Il compilatore può ottimizzarlo per usare bit-shift se possibile (si chiama riduzione della forza), il che lo rende una inutile micro-ottimizzazione se lo fai da solo.

Per accatastarsi: ci sono molti motivi per preferire l'utilizzo x = x / 2; Eccone alcuni:

• esprime il tuo intento in modo più chiaro (supponendo che tu non abbia a che fare con bit di registro o qualcosa del genere)

• il compilatore lo ridurrà comunque a un'operazione di spostamento

• anche se il compilatore non lo ha ridotto e ha scelto un'operazione più lenta rispetto allo spostamento, la probabilità che ciò influisca in modo misurabile sulle prestazioni del programma è di per sé piccola (e se influisce in modo misurabile, allora si ha un reale motivo per usare un turno)

• se la divisione farà parte di un'espressione più ampia, è più probabile che tu ottenga la precedenza giusta se usi l'operatore di divisione:

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

• l'aritmetica firmata potrebbe complicare le cose anche più del problema di precedenza sopra menzionato

• per ripetere: il compilatore lo farà già per te comunque. In effetti, convertirà la divisione di una costante in una serie di turni, aggiunte e moltiplicazioni per tutti i tipi di numeri, non solo per i poteri di due. Vedi questa domanda per i collegamenti a ulteriori informazioni al riguardo.

In breve, non si acquista nulla codificando un turno quando si intende realmente moltiplicare o dividere, tranne forse una maggiore possibilità di introdurre un bug. È stata una vita da quando i compilatori non sono stati abbastanza intelligenti da ottimizzare questo tipo di cose su un turno, quando appropriato.

Qual è l'opzione migliore e perché dividere il numero intero per 2?

Dipende da cosa intendi per meglio .

Se vuoi che i tuoi colleghi ti odino o rendano difficile la lettura del tuo codice, sceglierei sicuramente la prima opzione.

Se vuoi dividere un numero per 2, vai con il secondo.

I due non sono equivalenti, non si comportano allo stesso modo se il numero è negativo o all'interno di espressioni più grandi: lo spostamento dei bit ha una precedenza più bassa di +o -, la divisione ha la precedenza più alta.

Dovresti scrivere il tuo codice per esprimere qual è il suo intento. Se le prestazioni sono la tua preoccupazione, non ti preoccupare, l'ottimizzatore fa un buon lavoro in questo tipo di micro-ottimizzazioni.

Basta usare divide ( /), presumendo che sia più chiaro. Il compilatore ottimizzerà di conseguenza.

Concordo con altre risposte che dovresti favorire x / 2perché il suo intento è più chiaro e il compilatore dovrebbe ottimizzarlo per te.

Tuttavia, un altro motivo per preferire x / 2rispetto x >> 1è che il comportamento di >>dipende dall'implementazione se xè un segno inted è negativo.

Dalla sezione 6.5.7, punto 5 della norma ISO C99:

Il risultato E1 >> E2è posizioni di bit E1spostate E2a destra . Se E1ha un tipo senza segno o se E1ha un tipo con segno e un valore non negativo, il valore del risultato è la parte integrante del quoziente di E1/ 2 ^E2. Se E1ha un tipo con segno e un valore negativo, il valore risultante è definito dall'implementazione.

x / 2è più chiaro e x >> 1non è molto più veloce (secondo un micro-benchmark, circa il 30% più veloce per una JVM Java). Come altri hanno notato, per i numeri negativi l'arrotondamento è leggermente diverso, quindi è necessario considerare questo quando si desidera elaborare i numeri negativi. Alcuni compilatori possono convertirsi automaticamente x / 2in x >> 1se sanno che il numero non può essere negativo (anche se non potevo verificarlo).

Anche x / 2non è possibile utilizzare l'istruzione CPU (lenta) di divisione, perché alcune scorciatoie sono possibili , ma è ancora più lenta di x >> 1.

(Questo è un C / C ++ domanda, altri linguaggi di programmazione hanno più operatori. Per Java v'è anche lo spostamento a destra senza segno, x >>> 1che è ancora diverso. Permette di calcolare correttamente il valore medio (media) di due valori, in modo che (a + b) >>> 1la volontà restituisce il valore medio anche per valori molto grandi di ae b. Ciò è necessario ad esempio per la ricerca binaria se gli indici dell'array possono diventare molto grandi. C'era un bug in molte versioni della ricerca binaria , perché avevano usato (a + b) / 2per calcolare la media. non funziona correttamente. La soluzione corretta è quella di utilizzare (a + b) >>> 1invece.)

Knuth ha detto:

L'ottimizzazione prematura è la radice di tutti i mali.

Quindi suggerisco di usare x /= 2;

In questo modo il codice è facile da capire e penso anche che l'ottimizzazione di questa operazione in quella forma, non significhi una grande differenza per il processore.

Dai un'occhiata all'output del compilatore per aiutarti a decidere. Ho eseguito questo test su x86-64 con
gcc (GCC) 4.2.1 20070719 [FreeBSD]

Vedi anche le uscite del compilatore online su godbolt .

Quello che vedi è che il compilatore usa sarlun'istruzione (spostamento aritmetico a destra) in entrambi i casi, quindi riconosce la somiglianza tra le due espressioni. Se si utilizza la divisione, il compilatore deve anche regolare i numeri negativi. Per fare ciò sposta il bit di segno verso il basso al bit di ordine più basso e lo aggiunge al risultato. Questo risolve il problema off-by-one quando si spostano i numeri negativi, rispetto a ciò che farebbe una divisione.
Poiché il caso di divisione fa 2 turni, mentre il caso di turno esplicito fa solo uno, ora possiamo spiegare alcune delle differenze di prestazione misurate da altre risposte qui.

Codice C con uscita assembly:

Per dividere, il tuo input sarebbe

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

e questo si compila a

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

allo stesso modo per il turno

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

con uscita:

    sarl    %edi
    movl    %edi, %eax
    ret

Solo una nota aggiunta -

x * = 0,5 sarà spesso più veloce in alcuni linguaggi basati su VM, in particolare ActionScript, poiché la variabile non dovrà essere controllata per dividere per 0.

Usa x = x / 2; O x /= 2;Perché è possibile che un nuovo programmatore ci lavori in futuro. Quindi sarà più facile per lui scoprire cosa sta succedendo nella riga di codice. Tutti potrebbero non essere a conoscenza di tali ottimizzazioni.

Sto raccontando ai fini della programmazione delle competizioni. Generalmente hanno input molto grandi in cui la divisione per 2 ha luogo molte volte e si sa che l'input è positivo o negativo.

x >> 1 sarà migliore di x / 2. Ho controllato su ideone.com eseguendo un programma in cui sono avvenute più di 10 ^ 10 divisioni per 2 operazioni. x / 2 ha impiegato quasi 5,5 secondi mentre x >> 1 ha impiegato quasi 2,6 secondi per lo stesso programma.

Direi che ci sono diverse cose da considerare.

1. Bitshift dovrebbe essere più veloce, poiché non è davvero necessario un calcolo speciale per spostare i bit, tuttavia, come sottolineato, ci sono potenziali problemi con numeri negativi. Se hai la certezza di avere numeri positivi e stai cercando velocità, consiglierei bitshift.

2. L'operatore di divisione è molto facile da leggere per gli umani. Quindi, se stai cercando la leggibilità del codice, potresti usarlo. Si noti che il campo dell'ottimizzazione del compilatore ha fatto molta strada, quindi rendere il codice facile da leggere e comprendere è una buona pratica.

3. A seconda dell'hardware sottostante, le operazioni possono avere velocità diverse. La legge di Amdal è di accelerare il caso comune. Quindi potresti avere hardware in grado di eseguire diverse operazioni più velocemente di altri. Ad esempio, moltiplicare per 0,5 potrebbe essere più veloce della divisione per 2. (Concesso, potrebbe essere necessario prendere il piano della moltiplicazione se si desidera applicare la divisione intera).

Se stai cercando prestazioni allo stato puro, consiglierei di creare alcuni test che potrebbero eseguire le operazioni milioni di volte. Prova l'esecuzione più volte (la dimensione del tuo campione) per determinare quale sia statisticamente migliore con il tuo sistema operativo / hardware / compilatore / codice.

Per quanto riguarda la CPU, le operazioni bit-shift sono più veloci delle operazioni di divisione. Tuttavia, il compilatore lo sa e si ottimizzerà in modo adeguato nella misura del possibile, in modo da poter programmare nel modo più logico e tranquillo sapendo che il codice funziona in modo efficiente. Ma ricorda che una unsigned intlattina (in alcuni casi) può essere ottimizzata meglio di una intper ragioni precedentemente evidenziate. Se non hai bisogno di un segno aritmico, non includere il bit di segno.

x = x / 2; è il codice adatto da usare .. ma un'operazione dipende dal proprio programma su come si desidera produrre l'output.

Rendi le tue intenzioni più chiare ... per esempio, se vuoi dividere, usa x / 2 e lascia che il compilatore lo ottimizzi per spostare l'operatore (o qualsiasi altra cosa).

I processori di oggi non permetteranno che queste ottimizzazioni abbiano alcun impatto sulle prestazioni dei tuoi programmi.

La risposta a questo dipenderà dall'ambiente in cui lavori.

• Se stai lavorando su un microcontrollore a 8 bit o altro senza supporto hardware per la moltiplicazione, lo spostamento dei bit è previsto e banale e mentre il compilatore si trasformerà quasi sicuramente x /= 2in x >>= 1, la presenza di un simbolo di divisione innalzerà più sopracciglia in quell'ambiente rispetto a usando uno spostamento per effettuare una divisione.
• Se stai lavorando in un ambiente critico o in una sezione di codice, o il tuo codice potrebbe essere compilato con l'ottimizzazione del compilatore disattivata, x >>= 1con un commento che spiega che il suo ragionamento è probabilmente meglio solo per chiarezza di scopo.
• Se non sei in una delle condizioni di cui sopra, rendi il tuo codice più leggibile semplicemente usando x /= 2. Meglio salvare il programmatore successivo a cui capita di guardare il tuo codice il doppio di 10 secondi sulla tua operazione di cambio piuttosto che provare inutilmente di sapere che il turno era più efficiente ottimizzazione del compilatore.

Tutti questi assumono numeri interi senza segno. Il semplice spostamento non è probabilmente quello che vuoi per firmato. Inoltre, DanielH sottolinea un buon punto sull'uso x *= 0.5di alcuni linguaggi come ActionScript.

mod 2, prova per = 1. non so la sintassi in c. ma questo potrebbe essere il più veloce.

generalmente il turno giusto divide:

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

questo è talvolta usato per accelerare i programmi a costo di chiarezza. Non penso che dovresti farlo. Il compilatore è abbastanza intelligente da eseguire automaticamente l'accelerazione. Ciò significa che inserirsi in un turno non guadagna nulla a scapito della chiarezza .

Dai un'occhiata a questa pagina dalla Programmazione pratica C ++.

Ovviamente, se stai scrivendo il tuo codice per il prossimo che lo legge, cerca la chiarezza di "x / 2".

Tuttavia, se la velocità è il tuo obiettivo, provalo in entrambi i modi e cronometra i risultati. Qualche mese fa ho lavorato su una routine di convoluzione bitmap che prevedeva di passare attraverso una matrice di numeri interi e di dividere ogni elemento per 2. Ho fatto tutti i tipi di cose per ottimizzarlo, incluso il vecchio trucco di sostituire "x >> 1" con "x / 2" .

Quando ho cronometrato in entrambi i modi ho scoperto con mia sorpresa che x / 2 era più veloce di x >> 1

Questo utilizzava Microsoft VS2008 C ++ con le ottimizzazioni predefinite attivate.

In termini di prestazioni. Le operazioni di spostamento della CPU sono significativamente più veloci rispetto alla divisione dei codici operativi. Pertanto, dividendo per due o moltiplicando per 2 ecc. Tutti beneficiano delle operazioni a turni.

Per quanto riguarda l'aspetto grafico. Come ingegneri quando siamo diventati così attaccati ai cosmetici che nemmeno le belle donne lo usano! :)

X / Y è un operatore di spostamento corretto ... e ">>" ... se vogliamo due dividere un numero intero possiamo usare l'operatore di dividendo (/). l'operatore shift viene utilizzato per spostare i bit ..

x = x / 2; x / = 2; possiamo usare così ..

Mentre x >> 1 è più veloce di x / 2, l'uso corretto di >> quando si ha a che fare con valori negativi è un po 'più complicato. Richiede qualcosa di simile al seguente:

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