बाइनरी, ऑक्टल और हेक्साडेसिमल (जिसे हेक्स भी कहते हैं) अलग-अलग आधार वाली अलग-अलग संख्या पद्धतियाँ हैं।
बाइनरी का आधार 2 है, ऑक्टल का आधार 8 है, और हेक्साडेसिमल का आधार 16 है।
Crystal में सामान्य पूर्णांकों का आधार 10 होता है।
बाइनरी, ऑक्टल और हेक्साडेसिमल सभी पूर्णांकों के निरूपण हैं।
इसका मतलब है कि ये धनात्मक और ऋणात्मक संख्याओं (शून्य सहित) को बिना भिन्न या दशमलव के निरूपित करते हैं और वे सभी संक्रियाएँ कर सकते हैं जो हम पूर्णांकों के साथ कर सकते हैं।
बाइनरी
बाइनरी आधार 2 की एक संख्या पद्धति है, जिसमें केवल 0 और 1 अंकों का उपयोग होता है।
यह आमतौर पर कंप्यूटर में ट्रांजिस्टर और स्विच से गुज़रने वाले विद्युत प्रवाह की 0 ("बंद") और 1 ("चालू") अवस्थाओं को निरूपित करती है, साथ ही चुंबकीय भंडारण माध्यमों में धनात्मक और ऋणात्मक आवेशों को भी।
बाइनरी उन सभी पूर्णांकों को निरूपित कर सकती है जो आधार 10 में उपयोग होते हैं।
आधार 2 पद्धति का एक छोटा टुकड़ा ऐसा दिखता है, हालाँकि यह अनंत तक चलती रहती है और 128 पर रुकती नहीं:
| 128 |
64 |
32 |
16 |
8 |
4 |
2 |
1 |
| 2 ** 7 |
2 ** 6 |
2 ** 5 |
2 ** 4 |
2 ** 3 |
2 ** 2 |
2 ** 1 |
2 ** 0 |
तो अगर हमें संख्या 6 निरूपित करनी है, तो बाइनरी में यह होगी: 110
| स्थानीय मान |
4 |
2 |
1 |
| बाइनरी संख्या |
1 |
1 |
0 |
और संक्रिया यह होगी: 4 + 2 + 0 = 6
एक और उदाहरण: 19
| स्थानीय मान |
16 |
8 |
4 |
2 |
1 |
| बाइनरी संख्या |
1 |
0 |
0 |
1 |
1 |
बाइनरी संख्या यह होगी: 10011
और संक्रिया यह होगी: 16 + 0 + 0 + 2 + 1 = 19
Crystal में बाइनरी
Crystal में हम 0b प्रीफिक्स का उपयोग करके बाइनरी लिटरल निरूपित कर सकते हैं।
अगर हम 0b10011 लिखते हैं, तो Crystal इसे एक बाइनरी संख्या के रूप में समझेगा और इसे आधार 10 में बदल देगा।
0b10011
# => 19
typeof(0b10011)
# => Int32
अगर आप 0b प्रीफिक्स के साथ कोई ऐसी संख्या लिखते हैं जो बाइनरी पद्धति में नहीं है, तो कंपाइलेशन एरर आती है।
0b10211
# => Error: unexpected token: "211"
बाइनरी संख्याओं के साथ संक्रियाएँ
चूँकि बाइनरी संख्याएँ पूर्णांक होती हैं, हम उन पर वे सभी संक्रियाएँ कर सकते हैं जो हम पूर्णांकों पर कर सकते हैं।
0b10011 + 0b10011
# => 38
0b10011 * 0b10011
# => 361
0b10011 / 3
# => 6.333333333333333
बाइनरी निरूपण में बदलना और उससे वापस बदलना
Crystal एक बाइनरी लिटरल को अपने आप Int32 में बदल देता है।
किसी Int32 को बाइनरी निरूपण में बदलने के लिए <int>.to_s(base) मेथड का उपयोग कीजिए और base आर्गुमेंट को 2 पर सेट कीजिए।
यह मेथड उस बाइनरी संख्या का स्ट्रिंग निरूपण लौटाएगा:
19.to_s(2)
# => "10011"
किसी बाइनरी के स्ट्रिंग निरूपण को पूर्णांक में बदलने के लिए हम <int>.to_i(base) मेथड का उपयोग कर सकते हैं और आर्गुमेंट के रूप में base (2) पास कर सकते हैं:
"10011".to_i(2)
# => 19
गलत base देने पर (या अमान्य बाइनरी निरूपण देने पर) ArgumentError आती है:
"011021".to_i(2)
# => Invalid Int32: "011021" (ArgumentError)
बाइनरी मेथड
पूर्णांकों पर कुछ मेथड ऐसे हैं जिनसे उस संख्या के बाइनरी निरूपण की जानकारी मिलती है।
<int>.bit_length उस संख्या को निरूपित करने के लिए ज़रूरी बिट की संख्या लौटाता है:
19.bit_length
# => 5
<int>.bit(index) दिए गए इंडेक्स पर मौजूद बिट लौटाता है, और गिनती दाईं ओर से शुरू होती है (सबसे कम महत्व वाला बिट):
19.bit(0)
# => 1
0b10011.bit(1)
# => 1
ऑक्टल
ऑक्टल आधार 8 की एक संख्या पद्धति है।
यह 0, 1, 2, 3, 4, 5, 6 और 7 अंकों का उपयोग करती है।
Crystal में हम 0o प्रीफिक्स का उपयोग करके ऑक्टल संख्याएँ निरूपित कर सकते हैं।
बाइनरी की तरह ही, Crystal ऑक्टल निरूपण को अपने आप Int32 में बदल देता है।
0o123
# => 83
किसी ऐसी संख्या के आगे 0o लगाने पर जो ऑक्टल पद्धति में नहीं है, कंपाइलेशन एरर आती है।
ऑक्टल निरूपण में बदलना और उससे वापस बदलना
बाइनरी की तरह ही, हम <int>.to_s(base) मेथड से किसी Int32 को ऑक्टल निरूपण में बदल सकते हैं।
और हम <int>.to_i(base) मेथड से ऑक्टल निरूपण को Int32 में बदल सकते हैं।
83.to_s(8)
# => "123"
"123".to_i(8)
# => 83
बाइनरी की तरह ही, गलत base देने पर ArgumentError आती है।
हेक्साडेसिमल
हेक्साडेसिमल आधार 16 की एक संख्या पद्धति है।
यह 0 - 9 अंकों और A, B, C, D, E और F अक्षरों का उपयोग करती है।
A का मतलब 10, B का 11, C का 12, D का 13, E का 14 और F का 15 है।
Crystal में हम 0x प्रीफिक्स का उपयोग करके हेक्साडेसिमल संख्याएँ निरूपित कर सकते हैं।
बाइनरी और ऑक्टल की तरह ही, Crystal हेक्साडेसिमल लिटरल को अपने आप Int32 में बदल देगा।
#=> 0x123
291
किसी गैर-हेक्साडेसिमल संख्या के आगे 0x लगाने पर कंपाइलेशन एरर आती है।
हेक्साडेसिमल निरूपण में बदलना और उससे वापस बदलना
बाइनरी की तरह ही, हम <int>.to_s(base) मेथड से किसी Int32 को हेक्साडेसिमल निरूपण में बदल सकते हैं।
और हम <int>.to_i(base) मेथड से हेक्साडेसिमल निरूपण को Int32 में बदल सकते हैं।
291.to_s(16)
# => "123"
"123".to_i(16)
# => 291
बाइनरी और ऑक्टल की तरह ही, गलत base देने पर ArgumentError आती है।
प्रिसीज़न
किसी संख्या को स्ट्रिंग निरूपण में बदलते समय हम उस संख्या की प्रिसीज़न तय कर सकते हैं।
यानी संख्या को निरूपित करने के लिए उपयोग होने वाले अंकों की न्यूनतम संख्या।
अगर संख्या में प्रिसीज़न से कम अंक हैं, तो स्ट्रिंग निरूपण के शुरू में शून्य जोड़ दिए जाते हैं।
यह <int>.to_s(<base>, precision: <value>) मेथड को precision आर्गुमेंट पास करके किया जाता है।
291.to_s(16, precision: 5)
# => "00123"
543.to_s(precision: 2)
# => "543"
सीखने का अभ्यास
