|
|||||||
|
|
|
![]() |
|
|
Strumenti |
|
|
#1 |
|
Senior Member
Iscritto dal: Jun 2003
Citt�: Genova
Messaggi: 5676
|
[c]giocando con i bit...
ho una serie imprecisata di numeri interi, devo sapere quante volte la sua versione binaria passa fa 0 a 1 e viceversa...
la coa pi� intelligente che ho al momento � un coso che tratta la sequenza come stringhe e le va a contare in modo stupidissimo... esiste qualche modo intelligente per farlo? ciao ciao!!! :-) |
|
|
|
|
|
#2 | |
|
Senior Member
Iscritto dal: May 2006
Citt�: Wursteland
Messaggi: 1749
|
Quote:
comunque esiste lエoperatore << o >> che shifta i bit di n posizioni verso destra o sinistra. Se ti puoエ servire
__________________
Nintendo WIII 4d Turbo Intercooler - Sestium X 666 99,312 GHz - 6.984 Ram Σ(9999) MHz - HDD SATA 97e^(10) bytes 93ウ rpm - ATI biberon X900z ∞Mb - Win Eight SP (1 > yours) 16 Valve |
|
|
|
|
|
|
#3 |
|
Senior Member
Iscritto dal: Feb 2004
Messaggi: 1454
|
shifta e maschera, evita di sprecare spazio trasformandoli in stringa o in altro tipo.
|
|
|
|
|
|
#4 |
|
Senior Member
Iscritto dal: Apr 2000
Citt�: Vicino a Montecatini(Pistoia) Moto:Kawasaki Ninja ZX-9R Scudetti: 29
Messaggi: 53971
|
Concordo: ti fai una copia dell'intero...poi testi il primo bit se � a zero o 1 con un & con 0x0001. A questo punto fai uno shift a destra e riparti da capo.
|
|
|
|
|
|
#5 |
|
Senior Member
Iscritto dal: Jun 2003
Citt�: Genova
Messaggi: 5676
|
si, cos� mi evito la conversione, ma non ha molta importanza la velocit� in questo caso (dato che comunque sarei costretto a farlo prima dell'esecuzione del programma).
quindi mi state confermando che non esistono modi intelligenti per capirlo al volo senza operazioni complesse (tenendo conto che deve giarere su un sistema che deve processare dati in tempo reale che gi� ora sta soffrendo un p� i troppi calcoli). grazie, ciao! |
|
|
|
|
|
#6 |
|
Senior Member
Iscritto dal: Apr 2000
Citt�: Vicino a Montecatini(Pistoia) Moto:Kawasaki Ninja ZX-9R Scudetti: 29
Messaggi: 53971
|
Mmmmhhh...non so sinceramente quale sia la versione pi� semplice fra il convertire in stringa e l'usare & e shift che sono comunque operazioni semplicissime per la CPU.
In alternativa ti propongo un metodo carino...e quasi immediato. Considera per� che devi avere 512 byte di memoria disponbile. Codice:
typedef struct XCHANGE
{
unsigned char x01;
unsigned char x10;
} XCHANGE;
XCHANGE table[256];
table[0].x01 = 0;
table[0].x10 = 0;
table[1].x01 = 0;
table[1].x10 = 1;
table[2].x01 = 1;
table[2].x10 = 1;
table[3].x01 = 0;
table[3].x10 = 1;
table[4].x01 = 1;
table[4].x10 = 1;
table[5].x01 = 1;
table[5].x10 = 2;
table[6].x01 = 2;
table[6].x10 = 2;
A questo punto la prima parte da controllare sar� questa: Codice:
int data = XXXXXX;
unsigned char dataByte1 = (unsigned char)(data & 0xFF);
unsigned char dataByte2 = (unsigned char)((data & 0xFF00) >> 8);
unsigned char dataByte3 = (unsigned char)((data & 0xFF0000) >> 16);
unsigned char dataByte4 = (unsigned char)((data & 0xFF000000) >> 24);
int x01 = table[dataByte1].x01 + table[dataByte2].x01 +
table[dataByte3].x01 + table[dataByte4].x01;
int x10 = table[dataByte1].x10 + table[dataByte2].x10 +
table[dataByte3].x10 + table[dataByte4].x10;
unsigned int sideBit1 = data & 0x01800000; unsigned int sideBit2 = data & 0x00018000; unsigned int sideBit3 = data & 0x00000180; if(sideBit1 == 0x1000000) x01++; if(sideBit1 == 0x0800000) x10++; if(sideBit2 == 0x10000) x01++; if(sideBit2 == 0x08000) x10++; if(sideBit3 == 0x100) x01++; if(sideBit3 == 0x080) x10++; Ultima modifica di cionci : 10-08-2007 alle 14:25. |
|
|
|
|
|
#7 |
|
Bannato
Iscritto dal: Feb 2005
Citt�: Roma
Messaggi: 7029
|
io propenderei per lo shift: � vantaggioso rispetto alla soluzione di cionci perch� ti risparmi i 512 bytes di memoria, ed � vantaggioso rispetto alla conversione a stringa perch� la conversione a stringa richiede sicuramente un numero maggiore di operazioni. ma ci vuole tanto a fare uno shift e controllare il bit meno significativo?
![]() verrebbe cos�: Codice:
int nTestValue;
.
.
.
unsigned int uBitCount = sizeof(nTestValue) * 8; // notare le manie di portabilit� estrema :asd:
for (int i = 0; i < uBitCount; i++) {
if ((nTestValue >> (i + 1)) & 1) {
// ho trovato un 1
}
else {
// ho trovato uno zero
}
}
Ultima modifica di 71104 : 10-08-2007 alle 13:33. |
|
|
|
|
|
#8 | |
|
Senior Member
Iscritto dal: Apr 2000
Citt�: Vicino a Montecatini(Pistoia) Moto:Kawasaki Ninja ZX-9R Scudetti: 29
Messaggi: 53971
|
Quote:
PS: avevo fatto qualche errorino sopra...corretto |
|
|
|
|
|
|
#9 |
|
Senior Member
Iscritto dal: Nov 2005
Messaggi: 1868
|
pi� leggero e performante dello shift credo ci sia solo asm in-line...
Io voto per lo shift
__________________
[ W.S. ] |
|
|
|
|
|
#10 |
|
Senior Member
Iscritto dal: Apr 2000
Citt�: Vicino a Montecatini(Pistoia) Moto:Kawasaki Ninja ZX-9R Scudetti: 29
Messaggi: 53971
|
Per farlo pi� leggero dell'algoritmo di 71104 c'� c'� la possibilit� di giocare con i bit per il conteggio per evitare l'if.
Da notare che non vuole contare il numero di 1 e di 0, ma il numero di passaggi da 1 a 0 e da 0 a 1. Ecco qui: Codice:
/*in counter[0] ci sono i passaggi da 1 a 0, in counter[1] i passaggi da 0 a 1 */
int counter[2]:
int data = xxxxx;
unsigned char previousLsb = data & 1;
data >>= 1;
for (int i = 1; i < uBitCount; i++)
{
unsigned char lsb = data & 1;
data >>= 1;
counter[lsb] += lsb ^ previousLsb;
previousLsb = lsb;
}
Ultima modifica di cionci : 12-08-2007 alle 18:47. |
|
|
|
|
|
#11 |
|
Senior Member
Iscritto dal: Apr 2000
Citt�: Vicino a Montecatini(Pistoia) Moto:Kawasaki Ninja ZX-9R Scudetti: 29
Messaggi: 53971
|
Correzioncina sopra
|
|
|
|
|
| Strumenti | |
|
|
Tutti gli orari sono GMT +1. Ora sono le: 07:17.





















