Bit-Verschiebung

rean

Hi
Ich suche eine einfache und schnelle Möglichkeit zwischen jeweils 2 Bits in einem Wort ein zusätzliches Bit einzufügen.
Z.B: 11001 soll zu 10 10 00 00 10 werden
Also praktisch an jeder zweiten Stelle beginnend bei der ersten eine 0 einfügen.
Das ganze bräuchte ich dann auch noch für jede zweite Stelle beginnend bei der zweiten. (11001 = 01 01 00 00 01)
Die zwei Ergebnisse sollen dann später verodert werden.

Hat da einer eine Idee?

Gruß
rean

Dj_KoLoGe

auf die schnelle würd mir jetz einfallen das du deine zahl zerlegst
dann zu jedem etwas hinzufügst und zum schluss wieder alles zusammen-
hängen.

gibt bestimmt ncoh leichteres aber das fiel mir grad so ein

rean

Ja soweit war ich natürlich auch schon
Aber ich muss das mit 300000 Bytes und mehr machen. Und da wäre das Auseinander- und wieder Zusammenfriemeln doch recht zeitaufwändig.

Dj_KoLoGe

wie wärs in nen string casten oder so und dann per
substring und % vllt einfach ein zeichen adden und dann
wieder casten?

hustbaer

Für sowas würde ich auf jeden Fall einen Lookup-Table verwenden. Wenn die CPU auf der das laufen soll einen L1 Cache von >= 1kb hat würde ich einfach einen 8 Bit -> 16 Bit Table verwenden.
Dann brauchst du deine Daten bloss noch Byteweise durchzugehen.

Wie du den Table dabei erstellst ist ziemlich egal, da du das bloss 1x machst -- und 256x eine etwas umstäncliche Rechnung durchzuführen damit man dann 300.000x einen schnellen Table-Lookup verwenden kann... sollte denke ich OK sein.

EDIT: wenn du die beiden Zwischenergebnisse nicht brauchst, dann mach gleich alles in einem Schritt, also so dass im Lookup-Table gleich das Endresultat mit den "verdoppelten Bits" drinnen steht. Macht ja keinen Sinn das in 3 Schritten zu machen.

Helmut S.

rean schrieb:

Hi
Ich suche eine einfache und schnelle Möglichkeit zwischen jeweils 2 Bits in einem Wort ein zusätzliches Bit einzufügen.
Z.B: 11001 soll zu 10 10 00 00 10 werden
Also praktisch an jeder zweiten Stelle beginnend bei der ersten eine 0 einfügen.
Das ganze bräuchte ich dann auch noch für jede zweite Stelle beginnend bei der zweiten. (11001 = 01 01 00 00 01)
Die zwei Ergebnisse sollen dann später verodert werden.

Hat da einer eine Idee?

Gruß
rean

Hi!
Wie wärs mit Inline-Assembler?

#include "stdafx.h"

void bit2zero (unsigned int* dest, unsigned short* src, size_t count)   
{    
_asm{
            mov     esi, src
            mov     edi, dest
            mov     ecx, count
            shl     ecx, 4
            jmp L0  
        align 16    
        L0 :    
            lodsw
            shrd    ebx, eax, 16
        L1 :
            shld    eax, ebx, 1 //1<< Diese zwei Befehle stehen für x 0 (1 0 od. 0 0)
            dec     ecx
            shl     eax, 1      //2<< wenn du die vertauschst bekommst du  0 x
            shl     ebx, 1         
            test    cl, 01111b     
            jnz L1                  
            stosd
            or      ecx, ecx
            jne L0
    }
}

int main() 
{ 
    unsigned short src[75000];
    unsigned int   dest[75000];   

        src[74999] = 0xffff;

        bit2zero (dest, src, 75000);

   unsigned int test = dest[74999]; 
// test = 2863311530 binary = 10101010101010101010101010101010
}

Am einfachsten ist es, wenn du ein Ergebnis im Speicher vorliegen hast,
darauf den Befehl ror oder rol dword ptr[dest], 1 anzuwenden. (d.h. logisch shiften in C/C++)
Das zweite Ergebnis liegt dann sofort vor.

mfg

Es ist nie zu spät seine Sorgen nach hinten zu verschieben.