Operatore shift

[Luciano79]

Buongiorno a tutti,
sto facendo un programma in c# e ho un quesito che credo che sia comune a tutti i linguaggi di programmazione (per questo non ho specificato il linguaggio nel titolo). Questo programma prevede un algorito di potatura AlphaBeta di un albero a molti livelli, pertanto sto cercando di farlo il più snello possibile.

Devo valorizzare un unsigned long a 64 bit.
Il valore decimale è: 576460752303423488
In binario corrisponde a:

00001000 00000000 00000000 00000000 00000000 00000000 00000000 00000000

ho suddiviso i 64 bit in 8 gruppi da 8 per una maggiore leggibilità.

Guardando qua e la su internet ho notato che in casi del genere spesso non viene valorizzato direttamente il long assegnando un valore decimale come segue...

n = 576460752303423488;

...ma viene valorizzato tramite l'operatore shift, in questo caso:

n = (ulong)1 << 59;

Questo secondo modo per quanto mi riguarda è sicuramente più intuitivo, perchè nel mio caso ognuno dei 64 bit rappresenta una casella di una scacchiera di 64 caselle, quindi leggendo il codice capisco di che casella si tratta.

Il dubbio è: ma è anche più veloce l'esecuzione del programma utilizzando l'operatore shift?
Cioè, visto che il numero ulong va convertito in bit per salvarlo in memoria, la conversione in bit (fatta dividendo il numero per 2, prendendo il resto, ecc...) forse è più lenta rispetto ad eseguire lo shift per 59 volte.

Se fosse vero, allora utilizzare lo shift non è solo una questione di lettura del codice, ma anche di velocità di esecuzione.

Avete qualche nozione a riguardo?

Grazie
Luciano

[oregon]

Non ho capito bene la questione ... La domanda qual è esattamente? Cosa c' entrano le divisioni e il resto?

[Luciano79]

Cosa c' entrano le divisioni e il resto?

Se scrivo 55, il numero dovrà essere tradotto in 110111 per essere salvato in memoria.
La conversione intero/binario comporta una serie di divisioni, ovvero:

55%2 = 1 (salvo bit 1)
55/2 = 27
27%2 = 1 (salvo bit 1)
27/2 = 13
13%2 = 1 (salvo bit 1)
13/2 = 6
6%2 = 0 (salvo bit 0)
6/2 = 3
3%2 = 1 (salvo bit 1)
3/2= 1
1%2 = 1 (salvo bit 1)
1/2 = 0

Non ho capito bene la questione ... La domanda qual è esattamente?

In termini di prestazioni è meglio se scrivo...

n = 576460752303423488;

...oppure se scrivo...

n = (ulong)1 << 59;

Nel frattempo mi son reso conto che la domanda è stupida:
se nel codice scrivo n=123 sarà il compilatore a tradurre 123 in binario, pertanto in esecuzione non verrà effettuata nessuna conversione.
Peraltro la conversione dovrebbe essere da esadecimale a binario

[Scara95]

Tutto ciò che scrivi come costante numerica è solo una convenzione, le operazioni fra costanti vengono eseguite a tempo di compilazione quindi non c'è overhead. Ovvero scrivere x=2+2 e scrivere x=4 è la stessa cosa. Lo stesso vale se usi basi diverse da quella decimale.