Bits tauschen?!

[C - Anfänger (Gast)]

Hallöle,

bin gerade etwas überfordert.
Möchte gerne diese ganze "if abfragerei" in einer "for" Schleife 
erledigen..
Muss doch funktionierten oder?

static inline uint8_t swapBits(uint8_t byte)
{
  uint8_t tmp = 0;
  if(byte&1<<7) tmp|=1<<0;
  if(byte&1<<6) tmp|=1<<1;
  if(byte&1<<5) tmp|=1<<2;
  if(byte&1<<4) tmp|=1<<3;
  if(byte&1<<3) tmp|=1<<4;
  if(byte&1<<2) tmp|=1<<5;
  if(byte&1<<1) tmp|=1<<6;
  if(byte&1<<0) tmp|=1<<7;
  return tmp;
}

[Sheeva P. (sheevaplug)]

C - Anfänger schrieb:
> bin gerade etwas überfordert.
> Möchte gerne diese ganze "if abfragerei" in einer "for" Schleife
> erledigen..

Was ist eigentlich eine Zählschleife? ;-)

[C - Anfänger (Gast)]

Die Schleife an sich verstehe Ich. Es geht um die Rechnerei.

[Teo D. (teoderix)]

Beitrag "Re: Bits drehen bzw. spiegeln"

for ( i = 0; i < 8; i++ )
{
   gespiegelt >>= 1;
   gespiegelt |= original & 0x80;
   original <<= 1;
}

[bascom lover (Gast)]

Mit den Behinderungen in Bascom könnte man es so machen. If ist nicht 
notwendig.

For I = 0 To 7
  K = 7 - I
  Tmp.i = Half_word.k
Next I

[Hans (Gast)]

http://graphics.stanford.edu/~seander/bithacks.html#BitReverseObvious

[C - Anfänger (Gast)]

Teo D. schrieb:
> Beitrag "Re: Bits drehen bzw. spiegeln"
> for ( i = 0; i < 8; i++ )
> {
>    gespiegelt >>= 1;
>    gespiegelt |= original & 0x80;
>    original <<= 1;
> }

Die Lösung ist Prima. Danke!

[Michael R. (Firma: Brainit GmbH) (fisa)]

je nach Architektur bietet der GCC dafür "builtins" an, zB für AVR das 
__builtin_avr_insert_bits:

// reverse bit order
static uint8_t mirror(const uint8_t bits)
{
    return __builtin_avr_insert_bits(0x01234567, bits, 0);
}

[Teo D. (teoderix)]

C - Anfänger schrieb:
> Die Lösung ist Prima. Danke!

Der Dank geht wohl an ARM-Fan (Gast), Florian (Gast) und Google. 8-)

Aber danke für dir Rückmeldung das es funst. ;)

[Markus F. (mfro)]

wer Platz hat, nimmt eine Lookup-Tabelle:

static const uint8_t lut = { 0xff, 0xfe, 0xfd, ... }

uint8_t bitrev(uint8_t bits) {
    return lut[bits];
}

... und wer keinen hat, der kann das auch in zwei 4-bit Lookups mit 
entsprechenden Shifts (und dem damit verbundenen Performanceverlust) 
aufteilen.

... und wer einen ColdFire hat, nimmt BITREV, die ARM-Fraktion RBIT...


C - Anfänger schrieb:
> Teo D. schrieb:
>> Beitrag "Re: Bits drehen bzw. spiegeln"
>> for ( i = 0; i < 8; i++ )
>> {
>>    gespiegelt >>= 1;
>>    gespiegelt |= original & 0x80;
>>    original <<= 1;
>> }
>
> Die Lösung ist Prima. Danke!

Die Lösung ist m.E. suboptimal. Wenn "orginal" 0 wird, kann man 
'fertigshiften' und aufhören. Macht man dennoch weiter, erzeugt man nur 
noch unnötig Wärme ;)

[Herbert P. (Gast)]

Hmm. Vergleicht man die beiden Ansätze:

typedef unsigned char uint8_t; // damit er uint8_t kennt

uint8_t swapBits(uint8_t byte)
{
  uint8_t tmp = 0;
  if(byte&1<<7) tmp|=1<<0;
  if(byte&1<<6) tmp|=1<<1;
  if(byte&1<<5) tmp|=1<<2;
  if(byte&1<<4) tmp|=1<<3;
  if(byte&1<<3) tmp|=1<<4;
  if(byte&1<<2) tmp|=1<<5;
  if(byte&1<<1) tmp|=1<<6;
  if(byte&1<<0) tmp|=1<<7;
  return tmp;
}

uint8_t swap2(uint8_t original)
{
    uint8_t gespiegelt = 0;
    for (int i = 0; i < 8; i++ )
    {
        gespiegelt >>= 1;
        gespiegelt |= original & 0x80;
        original <<= 1;
    }
    return gespiegelt;
}

z.B. im Compiler-Explorer (https://godbolt.org/#) und wählt die Option 
-O3 aus, so zeigt sich sowohl für AVR- als auch ARM-Compiler (die 
anderen habe ich nicht untersucht), dass durch die Optimierung die erste 
Lösung deutlich kürzer wird als die Schleife (Stichwort: 
Loop-Unrolling).

Nur so als Anregung...

Gruß
Herby

[Stefan F. (Gast)]

Mit der Lookup Tabelle hat man die beste Performance. Kostet aber 256 
Bytes RAM.

[A. S. (Gast)]

Stefan U. schrieb:
> Kostet aber 256
> Bytes RAM.

oder ensprechend ROM

[Frank M. (ukw) (Moderator)]

Ich werfe mal die in den Raum:

unsigned char reverse(unsigned char b) {
   b = (b & 0xF0) >> 4 | (b & 0x0F) << 4;
   b = (b & 0xCC) >> 2 | (b & 0x33) << 2;
   b = (b & 0xAA) >> 1 | (b & 0x55) << 1;
   return b;
}

oder auch diese mit lediglich 16 Bytes Lookup-Table.

static unsigned char lookup[16] = {
0x0, 0x8, 0x4, 0xc, 0x2, 0xa, 0x6, 0xe,
0x1, 0x9, 0x5, 0xd, 0x3, 0xb, 0x7, 0xf, };

uint8_t reverse(uint8_t n) {
   return (lookup[n&0b1111] << 4) | lookup[n>>4];
}

Quelle: 
https://stackoverflow.com/questions/2602823/in-c-c-whats-the-simplest-way-to-reverse-the-order-of-bits-in-a-byte

[spess53 (Gast)]

Hi

Ich finde die Lösung von PeDa eleganter:

Beitrag "Re: reihenfolge der bits in einem byte umdrehen"

MfG Spess

[spess53 (Gast)]

Hi

Mist. Zu spät.

MfG Spess

[Possetitjel (Gast)]

Frank M. schrieb:

> Ich werfe mal die in den Raum: [...]

Ungünstig, wenn die Zielplattform nur um ein Bit
je Befehl schieben kann.


> oder auch diese mit lediglich 16 Bytes Lookup-Table.

Könnte man pimpen, wenn getrennte Tabellen für
High- und Low-Nibble verwendet werden.

[S. R. (svenska)]

Possetitjel schrieb:
>> oder auch diese mit lediglich 16 Bytes Lookup-Table.
> Könnte man pimpen, wenn getrennte Tabellen für
> High- und Low-Nibble verwendet werden.

Ist bei einer 16 Byte-Tabelle schon geschehen, sonst bräuchte man ja 256 
Byte.

Vermutlich ist das Compiler-Builtin die sinnvollste Variante. Wenn ein 
Compiler ohne passendes Builtin benutzt werden soll, dann kann man ja 
immernoch gcc's builtin disassemblieren...

[Possetitjel (Gast)]

S. R. schrieb:

> Possetitjel schrieb:
>>> oder auch diese mit lediglich 16 Bytes Lookup-Table.
>> Könnte man pimpen, wenn getrennte Tabellen für
>> High- und Low-Nibble verwendet werden.
>
> Ist bei einer 16 Byte-Tabelle schon geschehen, [...]

Missverständnis.

Ich sprach davon, eine 16-Byte-Tabelle für das
High-Nibble und zusätzlich eine weitere 16-Byte-Tabelle
für das Low-Nibble zu verwenden. Das spart die Shifts
komplett ein.

[A. S. (Gast)]

Possetitjel schrieb:
> Das spart die Shifts komplett ein.

Ich finde Deine Idee gut. Führt man sie weiter, könnte man auch 2 * 8 
+1*4 Einträge nehmen (2*3Bit, 1*2Bit), 4*4 oder 8*2. Wobei letzteres 
dann wieder der Ursprungslösung entspricht ;-)

unsigned char bswap(unsigned char x)
{
   /* 8 literal tables of 2 values */
   return (unsigned char)
         ((x&128?  1:0)
         |(x& 64?  2:0)
         |(x& 32?  4:0)
         |(x& 16?  8:0)
         |(x&  8? 16:0)
         |(x&  4? 32:0)
         |(x&  2? 64:0)
         |(x&  1?128:0));
}

[S. R. (svenska)]

Possetitjel schrieb:
> Das spart die Shifts komplett ein.

Sind die 4 Bit-Shifts nicht auf den betroffenen 8 Bit-Architekturen 
beinahe kostenlos (wegen SWAP)? Auf größeren Systemen kann man gleich 
die volle Tabelle nehmen.