32 बिट शब्द

Question

के दर्पण बिट्स आप सी में ऐसा कैसे करेंगे? (उदाहरण: 10110001 10001101 बन जाता है अगर हमें 8 बिट्स दर्पण करना पड़ा)। क्या कुछ प्रोसेसर पर कोई निर्देश हैं जो इस कार्य को सरल बना देंगे?

Answer 1

यही कारण है:

int mirror(int input) { 
    int returnval = 0; 
    for (int i = 0; i < 32; ++i) { 
     bit = input & 0x01; 
     returnval |= bit; 
     input >>= 1; 
     returnval <<= 1; 
    } 
    return returnval; 
} 

Answer 2

यह वास्तव में कहा जाता है "बिट उलट", और आमतौर पर पांव मार FFT में किया जाता है। हे (लॉग एन) जिस तरह से (32 बिट के लिए) है:

int reverse(int x, int bits) 
{ 
    x = ((x & 0x55555555) << 1) | ((x & 0xAAAAAAAA) >> 1); 
    x = ((x & 0x33333333) << 2) | ((x & 0xCCCCCCCC) >> 2); 
    x = ((x & 0x0F0F0F0F) << 4) | ((x & 0xF0F0F0F0) >> 4); 
    x = ((x & 0x00FF00FF) << 8) | ((x & 0xFF00FF00) >> 8); 
    x = ((x & 0x0000FFFF) << 16) | ((x & 0xFFFF0000) >> 16); 
    return x >> (32 - bits); 
} 

Answer 3

प्रति रिच इस MIT memo में Schroeppel (आप कोडांतरक अतीत को पढ़ सकते हैं), निम्नलिखित उपलब्ध कराने के एक 8 बिट बाइट में बिट्स रिवर्स जाएगा

byte = (byte * 0x0202020202ULL & 0x010884422010ULL) % 1023; 

कौन प्रशंसकों की तरह बिट्स बाहर (गुणा), उन्हें (और) का चयन करता है और फिर उन्हें वापस नीचे (मापांक) सिकुड़ता है: आप 64 बिट अंकगणितीय उपलब्ध है।

क्या यह वास्तव में आपके पास 8 बिट मात्रा है?

Answer 4

मुझे लगता है कि मैं bitpatterns 0-255 की लुकअप टेबल बनाउंगा। प्रत्येक बाइट पढ़ें और लुकअप टेबल के साथ उस बाइट को उलट दें और बाद में परिणामस्वरूप बाइट उचित तरीके से व्यवस्थित करें।

Answer 5

सबसे तेजी से दृष्टिकोण एक लुकअप तालिका होने के लिए लगभग निश्चित है:

out[0]=lut[in[3]]; 
out[1]=lut[in[2]]; 
out[2]=lut[in[1]]; 
out[3]=lut[in[0]]; 

या यदि आप तालिका डेटा की 128k खर्च कर सकते हैं (बर्दाश्त से, मेरा मतलब है सीपीयू कैश उपयोग, नहीं मुख्य स्मृति या आभासी स्मृति उपयोग), 16-बिट इकाइयों का उपयोग करें:

out[0]=lut[in[1]]; 
out[1]=lut[in[0]]; 

Answer 6

quint64 mirror(quint64 a,quint8 l=64) { 
    quint64 b=0; 
    for(quint8 i=0;i<l;i++) { 
     b|=(a>>(l-i-1))&((quint64)1<<i); 
    } 
return b; 
} 

इस समारोह से कम 64 बिट्स मिरर। उदाहरण के लिए यह 12 बिट्स प्रतिबिंबित कर सकता है।

quint64 और quint8 क्यूटी में परिभाषित किए गए हैं। लेकिन यह वैसे भी इसे फिर से परिभाषित करना संभव है।

Answer 7

मैंने केवल 16 बिट्स अस्थायी स्थान में 4 बिट्स (एक नींबू) मिररिंग के लिए एक न्यूनतम समाधान भी निकाला है।

mirr = ((orig * 0x222) & 0x1284) % 63