रूबी में बिटवाइज़ हैक्स

संभावना है कि आपको आमतौर पर अपने दिन के काम में थोड़ा सा गणित करने की आवश्यकता नहीं होती है। रूबी के बिटवाइज़ AND और OR ऑपरेटर्स ( &और | ) का उपयोग संभवतः दुर्घटनावश उद्देश्य से अधिक किया जाता है। किसने गलती से टाइप नहीं किया और कब उनका मतलब &&था?

लेकिन अगर आप सी या असेंबलर, या मेरे मामले में टर्बो पास्कल जैसी निचले स्तर की भाषाओं की प्रोग्रामिंग करते हुए बड़े हुए हैं तो आपने शायद कम से कम कुछ ट्विडलिंग किया है।

समस्याओं का बिटवाइज़ समाधान बहुत अच्छा है। यदि आप सबसे बुनियादी संचालन का उपयोग करके अपनी समस्या को हल करने में सक्षम हैं जो एक कंप्यूटर (बाइनरी गणित) में सक्षम है, तो यह इससे अधिक सुरुचिपूर्ण नहीं है।

रूबी में बाइनरी के साथ काम करना

आप शायद जानते हैं कि आपके कंप्यूटर में सब कुछ संख्याओं के रूप में दर्शाया गया है, और वे संख्याएँ बाइनरी प्रारूप में हैं। लेकिन रूबी में ऐसा क्या दिखता है? इस उदाहरण में, मैं "ए" अक्षर के लिए ASCII चार कोड देखने के लिए रूबी का उपयोग कर रहा हूं, फिर इसे "बाइनरी" के रूप में प्रिंट कर रहा हूं।

आप ord का उपयोग कर सकते हैं एक चरित्र का ASCII कोड प्राप्त करने के लिए रूबी में विधि, और फिर printf . का उपयोग करें इसका "बाइनरी" प्रतिनिधित्व प्रिंट करने के लिए।

हालाँकि हमें बाइनरी में नंबर प्रदर्शित करने के लिए प्रिंटफ जैसी विधि का उपयोग करना पड़ता है, यह हमेशा बाइनरी था। आप 0b11111111 . जैसे सिंटैक्स का उपयोग करके अपने रूबी कोड के अंदर बाइनरी नंबर लिख सकते हैं ।

अपने कोड में बाइनरी लिटरल जोड़ने के लिए, 0b के साथ स्ट्रिंग्स और ज़ीरो का उपसर्ग लगाएं। तो 0b11111111

बाइनरी मानों में हेर-फेर

अब जब हम जानते हैं कि रूबी में बाइनरी लिटरल का उपयोग कैसे किया जाता है, तो हम उनके साथ खेलना शुरू कर सकते हैं। ऐसा करने के लिए हम बिटवाइज़ ऑपरेटरों का उपयोग करेंगे।

आप शायद &&जैसे बूलियन ऑपरेटरों के साथ सहज हैं। व्यंजक a &&b तभी सही होता है जब a और b दोनों सत्य हों। बिटवाइज़ ऑपरेटर बहुत समान हैं।

उदाहरण के लिए, बिटवाइज़ AND दो मान लेता है और उनकी तुलना थोड़ा-थोड़ा करके करता है। यदि दोनों बिट्स 1 हैं, तो यह संबंधित आउटपुट बिट को 1 पर सेट करता है। यदि नहीं, तो यह इसे शून्य पर सेट करता है। इसलिए यदि आपके पास आठ बिट हैं, तो आपके पास आठ अलग-अलग AND होंगे। यदि आपके पास एक बिट है, तो आपके पास एक AND है। निम्नलिखित उदाहरण एक बिट का उपयोग करके इसे स्पष्ट करते हैं।

बिटवाइज़ और एक बिट के साथ संचालन का उदाहरण।

यह दो बिट्स के लिए समान कार्य करता है।

बिट्स के प्रत्येक जोड़े को अलग से एंडेड किया जाता है

रूबी के बिटवाइज़ ऑपरेटर

लगभग हर प्रोग्रामिंग भाषा बिटवाइज़ ऑपरेटरों के इस सेट के साथ आती है। यदि आप उनसे परिचित नहीं हैं, तो IRB में उन्हें आज़माने में थोड़ा समय बिताएँ। एक बार जब आप उन्हें सीख लेते हैं, तो आप जीवन भर उनका उपयोग कर सकेंगे।

व्यावहारिक उपयोग:कॉन्फ़िगरेशन फ़्लैग

ठीक है, ठीक है, यह बिटवाइज़ गणित का सबसे उबाऊ उपयोग होना चाहिए। लेकिन यह भी सबसे आम में से एक है। यदि आपको कभी भी जावा या सी या सी++ में लिखे कोड के साथ इंटरफेस करना पड़े तो आपको अंततः बिटवाइज़ कॉन्फ़िगरेशन फ़्लैग्स मिलेंगे।

कल्पना कीजिए कि यह 1996 है और आपने अभी-अभी शुरू से एक डेटाबेस सिस्टम बनाया है। चूंकि आपने अभी हाल ही में हैकर्स फिल्म देखी है, आपको लगता है कि किसी प्रकार के एक्सेस कंट्रोल में निर्माण करना अच्छा हो सकता है।

एक उपयोगकर्ता आपके DB में 8 कार्य कर सकता है:पढ़ना, लिखना, हटाना, और पाँच और। आप उनमें से प्रत्येक को स्वतंत्र रूप से सेट करने में सक्षम होना चाहते हैं। आपके पास एक ऐसा उपयोगकर्ता हो सकता है जो पढ़ तो सकता है लेकिन लिख या हटा नहीं सकता। आपके पास एक ऐसा हो सकता है जो लिख सकता है लेकिन ड्रॉप टेबल नहीं।

इन कॉन्फ़िगरेशन फ़्लैग को स्टोर करने का सबसे कारगर तरीका एक बाइट में बिट्स के रूप में होना है। फिर एक उपयोगकर्ता बस OR उन्हें एक साथ मिलकर अनुमतियों के किसी भी संयोजन की आवश्यकता होगी।

MYDB_READ   = 0b00000001 # These numbers are called bitmasks
MYDB_WRITE  = 0b00000010
MYDB_DELETE = 0b00000100
MYDB_INDEX  = 0b00001000

user.permissions = MYDB_READ | MYDB_WRITE

वैसे, यह वास्तव में समान है कि कैसे यूनिक्स फ़ाइल अनुमतियों को संभाला जाता है। अगर आपने कभी सोचा है कि किसी फ़ाइल को केवल पढ़ने के लिए बनाने के लिए आपको जादुई संख्या का उपयोग क्यों करना पड़ता है, तो अब आप जानते हैं।

कॉन्फ़िगरेशन विकल्पों को बिट्स में स्टोर करना बहुत उपयोगी नहीं होगा जब तक कि आप यह पता नहीं लगा सकें कि कोई निश्चित बिट सेट किया गया था या नहीं। ऐसा करने के लिए, आप बस थोड़ा सा AND का उपयोग करें।

बिट सेट है या नहीं, यह निर्धारित करने के लिए बिटमास्क के साथ AND का उपयोग करें।

कम व्यावहारिक उपयोग (जब तक कि आप C प्रोग्रामर न हों)

चलिए अब कुछ गणित-जादुई चीजें करते हैं।

ऐतिहासिक रूप से, बिट हेरफेर का उपयोग तब किया जाता था जब आप कुछ गणना से मिलीसेकंड के अंतिम अंश को निचोड़ने का प्रयास कर रहे थे। तो जैसा कि आप कल्पना कर सकते हैं, इसका उपयोग ग्राफिक्स प्रोग्रामर और अन्य लोगों द्वारा किया गया था जिन्हें सबसे ऊपर प्रदर्शन की आवश्यकता थी।

तो इस तरह की तकनीकें रोज़ाना रूबी विकास के लिए व्यावहारिक नहीं हैं। लेकिन वे अभी भी एक मजेदार सीखने का अभ्यास हैं, और यदि आप एम्बेडेड सिस्टम प्रोग्रामिंग जैसी चीजों में शामिल हो जाते हैं तो वैध रूप से उपयोगी हो सकते हैं। अधिक गहन उपचार के लिए, थोड़ा ट्विडलिंग हैक की यह सूची देखें।

दो की घात से गुणा और भाग करना

आइए संख्याओं 1, 2, 4, और 8 के द्विआधारी निरूपण को देखें। जैसा कि आप देख सकते हैं, संख्या को दोगुना करना सभी बिट्स को एक स्थान बाईं ओर स्थानांतरित करने के बराबर है। इसी तरह, संख्या को आधा करना दाईं ओर खिसकने के समान है।

1, 2, 4 8 का बाइनरी प्रतिनिधित्व

अगर आपको याद होगा, हमारे पास शिफ्ट-लेफ्ट और शिफ्ट-राइट ऑपरेटर्स हैं। इसका मतलब है कि हम केवल बिट्स को स्थानांतरित करके दो की शक्तियों से गुणा और विभाजित कर सकते हैं।

आप बिटवाइज़ शिफ्ट ऑपरेटरों का उपयोग दो की घात से गुणा या भाग करने के लिए कर सकते हैं

दो सकारात्मक पूर्णांकों का औसत

आप दो पूर्णांकों का मूल जोड़ कर सकते हैं जैसे:  (x+y) ==(x&y)+(x|y) ==(x^y)+2*(x&y)। औसत की गणना करने के लिए, आपको केवल दो से एक छोटे से भाग की आवश्यकता है, जिसे आप एक सही शिफ्ट ऑपरेटर के माध्यम से प्राप्त कर सकते हैं।

आप इस तरह से दो धनात्मक पूर्णांकों का औसत निकाल सकते हैं:(x&y)+((x^y)>>1)

तेज़ उलटा वर्गमूल

मैं सबसे प्रसिद्ध उदाहरणों में से एक को शामिल किए बिना बिट ट्विडलिंग पर एक ब्लॉग पोस्ट नहीं कर सका। 1999 के क्वैक 3 एरिना सोर्स कोड से यह जॉन कार्मैक का तेज़ उलटा वर्गमूल सन्निकटन है। एल्गोरिथ्म उसका नहीं है, लेकिन सबसे प्रसिद्ध कार्यान्वयन है।

मैं रूबी के लिए इसका सीधा पोर्ट करने का प्रयास नहीं करने जा रहा हूं, क्योंकि यह एक फ्लोटिंग पॉइंट नंबर के बाइनरी प्रतिनिधित्व को इस तरह से बनाकर काम करता है जो सी से रूबी में सीधे अनुवाद योग्य नहीं है।

float Q_rsqrt( float number )
{
    long i;
    float x2, y;
    const float threehalfs = 1.5F;

    x2 = number * 0.5F;
    y  = number;
    i  = * ( long * ) &y;                       // evil floating point bit level hacking
    i  = 0x5f3759df - ( i >> 1 );               // what the fuck? 
    y  = * ( float * ) &i;
    y  = y * ( threehalfs - ( x2 * y * y ) );   // 1st iteration
//  y  = y * ( threehalfs - ( x2 * y * y ) );   // 2nd iteration, this can be removed

    return y;
}