Poiché la dimensione se fissato a 8 bit solo la "tavola" la ricerca dal basso è sufficiente - quando si ha a che fare con una semplice byte
una ricerca è probabilmente il modo più rapido. Il sovraccarico extra di BitSet per ottenere/impostare i dati potrebbe, tuttavia, vanificare il vantaggio di ricerca. Anche il costo di costruzione iniziale e necessità in testa persistente da prendere in considerazione (ma i valori potrebbero essere codificati in un array letterale ... sigh!)
D'altra parte, se i dati sono solo 8 bit (mai) e "le prestazioni sono importanti", perché usare un BitArray? Un BitArray può sempre essere usato per le funzioni gradevoli, come "esplodere" su Enumerable mentre C# ha già una discreta manipolazione di bit di byte integrata.
Ipotizzando un caso più generale che i dati sono a 8 bit allineato ... ma di una certa lunghezza indeterminata
è questo in realtà meglio (più veloce, più efficiente, ecc) che solo farlo "per articolo "nel BitArray? Non ho idea ma non sospetto. Sicuramente inizierei con i metodi "semplici" - questo è qui solo come una prova di concetto e può (o potrebbe non essere) interessante da confrontare in un benchmark. Ad ogni modo, scrivi per chiarezza prima ... e il sotto non lo è! (Non v'è almeno un bug in esso - Do la colpa la complessità in più ;-)
byte reverse (byte b) {
byte o = 0;
for (var i = 0; i < 8; i++) {
o <<= 1;
o |= (byte)(b & 1);
b >>= 1;
}
return o;
}
byte[] table;
BitArray reverse8 (BitArray ar) {
if (ar.Count % 8 != 0) {
throw new Exception("no!");
}
byte[] d = new byte[ar.Count/8];
ar.CopyTo(d, 0);
// this only works if the bit array is
// a multiple of 8. we swap bytes and
// then reverse bits in each byte
int mid = d.Length/2;
for (int i = 0, j = d.Length - 1; i < mid; i++, j--) {
byte t = d[i];
d[i] = table[d[j]];
d[j] = table[t];
}
return new BitArray(d);
}
string tostr (BitArray x) {
return string.Join("",
x.OfType<bool>().Select(i => i ? "1" : "0").ToArray());
}
void Main()
{
table = Enumerable.Range(0,256).Select(v => reverse((byte)v)).ToArray();
{
byte[] s = new byte[] { 1, 0xff };
BitArray ar = new BitArray(s);
// linqpad :)
tostr(ar).Dump();
tostr(reverse8(ar)).Dump();
}
"--".Dump();
{
byte[] s = new byte[] { 3, 42, 19 };
BitArray ar = new BitArray(s);
// linqpad :)
tostr(ar).Dump();
tostr(reverse8(ar)).Dump();
}
}
uscita:
1000000011111111
1111111100000001
--
110000000101010011001000
000100110101010000000011
Il expr.Dump()
è una caratteristica LINQPad.
fonte
2011-01-25 08:50:16
è la dimensione fissa? –
Che ne dici di usare (leggere) indietro? –
Sì, la dimensione è fissa (8 bit) – Christopher