बाइनरी से दशमलव कन्वर्टर

1011 = 1×2³ + 0×2² + 1×2¹ + 1×2⁰ = 8 + 2 + 1 = 11

बाइनरी

जिस संख्या को पढ़ना है, आधार-2 में लिखी हुई। उसके अंक 0 और 1 हैं और बस वही, और पूरी संख्या का मान इस पर निर्भर करता है कि हर अंक कहाँ बैठा है — इस पर नहीं कि अंक कितने हैं

2ⁿ

किसी स्थान का स्थानीय मान: दो की उतनी घात जितना वह स्थान दाएँ सिरे से दूर है, जहाँ सबसे दाहिने स्थान की गिनती शून्य से होती है। श्रेणी है 1, 2, 4, 8, 16, 32, 64, 128 और हर क़दम पिछले से दुगना है

अंक × 2ⁿ

जोड़ का एक अकेला पद। चूँकि अंक या तो 0 होता है या 1, यह गुणा कुछ बदलता ही नहीं — 1 अपना पूरा स्थानीय मान जोड़ता है और 0 कुछ भी नहीं, इसीलिए बदलना घटकर 'जिन स्थानों पर 1 है उन्हें चुन लेना' रह जाता है

Σ

हर पद का जोड़। यही पूरा बदलाव है: जगह-वाले बिटों के स्थानीय मान जोड़ दीजिए और कुल दशमलव में वही संख्या है

8 + 2 + 1

वही जोड़ शून्य वाले पद हटाकर, यानी जिस रूप में इसे हाथ से लिखा जाता है। 1011 में 8, 2 और 1 के स्थानों पर एक है और 4 के स्थान पर शून्य, इसलिए 4 जोड़ में कभी दिखता ही नहीं — उसे ग़ायब देखना ही बात है, क्योंकि लोग ठीक यहीं भूल करते हैं

53 बिट

इनपुट कितना लंबा हो सकता है: तिरपन बाइनरी अंक, यानी 9007199254740991। यह वह चौड़ाई है जिसके आगे मशीन पड़ोसी पूर्ण संख्याओं में फ़र्क़ नहीं कर पाती, इसलिए लंबा इनपुट अंदाज़े से नहीं, अस्वीकार करके निपटाया जाता है

यह बदलाव पढ़ने की दोनों दिशाओं में चाहिए होता है। सीधी दिशा तब है जब कोई मान बाइनरी में आया हो और उसे समझना हो: डीबगर का छापा हुआ स्टेटस बाइट, हार्डवेयर रजिस्टर का फ़्लैग कॉलम, कॉन्फ़िगरेशन फ़ाइल का बिटमास्क, किसी नेटवर्क टूल का आउटपुट, या कोई गृहकार्य जिसमें जवाब आधार-10 में लिखना है। उलटी दिशा वह दो की घातों वाला तर्क है जो आम संख्याओं के पीछे छिपा रहता है — कोई संख्या दो की घात है या नहीं, किसी आँकड़े के ऊपर की अगली दो की घात क्या है, कोई मान रखने में कितने बिट लगेंगे, या किसी चौड़ाई की बस कितना बड़ा पता-क्षेत्र संभाल सकती है — और ये सब सवाल यह देखकर हल होते हैं कि कौन-से स्थान जगह-वाले हैं। प्रोग्रामरों को वही जोड़ सबनेट मास्क निकालते, कई छोटे मान एक पूर्णांक में पैक करते, या किसी रखी हुई संख्या में कौन-से विकल्प चालू हैं यह देखते समय मिलता है। स्थानीय मान वाला आउटपुट ही इस पेज को पढ़ाने के औज़ार के रूप में काम का बनाता है: कैरी के नियम और स्थानों के भार — ये दो चीज़ें तब तक मनमानी लगती हैं जब तक जोड़ खुलकर लिखा न हो, और जो कुछ भी टाइप किया गया हो उसका जोड़ पेज से लिखवा लेना किताब के हल किए उदाहरण को अपनी कोशिश की जाँच में बदल देता है। जो हाथ से बाइनरी संख्या पढ़ता है, और जो यह जानना चाहता है कि जवाब जो है वह क्यों है — सिर्फ़ क्या है यह नहीं — दोनों को इससे एक ही चीज़ मिलती है।

1. 1011 पढ़ना

   1. चारों अंकों के नीचे उनके स्थानीय मान लिखिए, दाईं ओर से: 1, 2, 4, 8
   2. जो अंक 1 हैं उन्हें रखिए और जो 0 हैं उन्हें छोड़ दीजिए: बचते हैं 8, 2 और 1
   3. 4 के स्थान पर 0 है, इसलिए वह कुछ नहीं जोड़ता और जोड़ में दिखता ही नहीं
   4. इन्हें जोड़िए: 8 + 2 + 1 = 11

   यही डिफ़ॉल्ट है, और वही जो ग़ायब पद दिखाता है: 1011 में चौके के स्थान पर शून्य है, इसलिए जोड़ 8 + 4 + 2 + 1 नहीं, 8 + 2 + 1 पढ़ा जाता है। अंकों को दशमलव अंक मानकर पढ़ने पर एक हज़ार ग्यारह बनता, और यह बदलाव चूकने का सबसे आम तरीक़ा यही है।

2. पूरी बाइट पढ़ना, 10110010

   1. आठ अंक हैं, इसलिए स्थानीय मान 128 से नीचे 1 तक चलेंगे
   2. जगह-वाले स्थान हैं 128, 32, 16 और 2
   3. इन्हें जोड़िए: 128 + 32 = 160, उसमें 16 जोड़िए तो 176, और 2 जोड़िए तो 178
   4. एक बाइट में सबसे बड़ा मान 11111111 होता है, यानी 255

   इसे एक बार चलाकर देख लेना इसलिए लायक़ है कि व्यवहार में लगभग हर बाइनरी मान इसी चौड़ाई में आता है, और यह जानना कि सबसे बायाँ बिट 128 का है तथा सबसे दाहिना 1 का, ही किसी बाइट को एक नज़र में पढ़ने लायक़ बनाता है। वही आठ अंक दूसरे सिरे से पढ़ने पर बिल्कुल और होते, इसलिए दिशा कोई छोटी बात नहीं है।

3. आगे के शून्य मान नहीं बदलते

   1. चारों आगे के शून्य 128, 64, 32 और 16 के स्थानों पर बैठे हैं
   2. शून्य कहीं भी बैठे, वह कुछ नहीं जोड़ता, इसलिए वे स्थान जोड़ से हट जाते हैं
   3. जो बचता है वही पहले वाला 8 + 2 + 1 है, जो 11 देता है

   किसी मान को तय चौड़ाई तक भर देना आम बात है — जहाँ चौड़ाई का मतलब हो वहाँ बाइट 1011 नहीं, 00001011 लिखी जाती है — इसलिए कन्वर्टर को दोनों रूप स्वीकार करने पड़ते हैं और दोनों पर एक ही जवाब देना पड़ता है। यह देता है, और जो जोड़ छापता है वह बिल्कुल एक जैसा रहता है क्योंकि आगे के शून्य उसमें कभी आते ही नहीं।

4. ऋणात्मक मान पढ़ना, -1011

   1. ऋण चिह्न बाइनरी संख्या का हिस्सा नहीं है — वह उसके आगे लगा एक चिह्न है
   2. अंकों को पहले की तरह पढ़िए: 1011 यानी 8 + 2 + 1 = 11
   3. चिह्न वापस लगाइए: मान -11 है

   चिह्न अंकों के बाहर ही रखा जाता है, उनमें मोड़ा नहीं जाता, क्योंकि यहाँ उसे मोड़ने के लिए कोई तय चौड़ाई ही नहीं है। कोई प्रोसेसर -11 को आठ बिट में रखता तो 11110101 लिखता, जो अंकों की बिल्कुल अलग श्रृंखला है और यह जानने पर टिकी है कि चौड़ाई आठ है। इस पेज की कोई चौड़ाई नहीं है, इसलिए चिह्न चिह्न ही रहता है।

यह पेज सिर्फ़ पूर्ण बाइनरी संख्याएँ पढ़ता है। यहाँ कोई बाइनरी बिंदु नहीं है, इसलिए 1.01 स्वीकार नहीं होता और बदला नहीं जा सकता — भिन्नात्मक पढ़त के लिए यह दूसरा नियम चाहिए होता कि बिंदु कहाँ बैठता है, और वह नियम हर इनपुट के लिए मानने के बजाय लिखना पड़ता। इनपुट ज़्यादा से ज़्यादा तिरपन अंकों का हो सकता है, जो दशमलव में 9007199254740991 है; इससे लंबे मान मशीन ठीक-ठीक नहीं रख सकती और पूर्णांकित किए बजाय अस्वीकार कर दिए जाते हैं। आगे के शून्य स्वीकार होते हैं और अनदेखे किए जाते हैं, इसलिए 00001011 और 1011 एक ही संख्या हैं, और दोनों के लिए छपने वाला जोड़ बिल्कुल एक जैसा है। आगे लगा ऋण चिह्न स्वीकार होता है और दोनों आउटपुट तक पहुँचाया जाता है। यह पेज बाइनरी से दशमलव में बदलता है; उलटी दिशा का अपना अलग पेज है, और हेक्साडेसिमल पढ़तें एक और पेज पर हैं। यहाँ गणना नहीं होती और बिटवाइज़ क्रियाएँ भी नहीं होतीं — यहाँ कोई AND, OR, XOR या शिफ़्ट नहीं है।

बाइनरी को दशमलव में हाथ से कैसे बदलें?

अंकों के नीचे उनके स्थानीय मान लिखिए, दाईं ओर 1 से शुरू करके हर बार बाईं ओर जाने पर दुगना करते हुए — 1, 2, 4, 8, 16 वग़ैरह। फिर जो मान किसी 1 के नीचे बैठे हैं उन्हें रखिए और जो किसी 0 के नीचे बैठे हैं उन्हें हटा दीजिए, और जो बचे उन्हें जोड़ दीजिए। 1011 के लिए इससे 8, 2 और 1 मिलते हैं, यानी 11। इसमें दो तरह से चूक होती है: अंकों को बाईं ओर से पढ़ लेना, और ऐसा स्थानीय मान जोड़ देना जिसके नीचे शून्य बैठा हो — दोनों इस पेज पर छपा जोड़ दिखा देता है, क्योंकि वह सिर्फ़ गिनने लायक़ पद ही लिखता है।

जवाब में उन स्थानों के मान क्यों नहीं आते जिनके नीचे शून्य है?

क्योंकि वे कुछ नहीं जोड़ते, और उन्हें लिखने से जो बात असल में मायने रखती है वह दब जाती। किसी भी स्थानीय मान का शून्य गुना शून्य होता है, इसलिए 0×4 जैसा पद कुल बदले बिना हटाया जा सकता है। जोड़ 8 + 0 + 2 + 1 के बजाय 8 + 2 + 1 इसीलिए दिखाया जाता है कि ग़ायब चार नज़र आए: यह देखना कि कौन-से स्थान नहीं हैं, ही यह जाँचने का तरीक़ा है कि अंक पहली बार में सही सीध में लगे थे या नहीं।

क्या आगे का शून्य संख्या बदल देता है?

नहीं। आगे के शून्य ऐसे स्थानों पर बैठते हैं जो कुछ नहीं जोड़ते, ठीक वैसे ही जैसे दशमलव में — वहाँ 007 अब भी सात है। 00001011 और 1011 एक ही संख्या हैं और यह पेज दोनों के लिए वही दो आउटपुट देता है। तय चौड़ाई तक भरना तब आम है जब चौड़ाई का कोई मतलब हो — बाइट आमतौर पर आठों अंकों के साथ लिखी जाती है — इसलिए भरे हुए रूप को स्वीकार करना मजबूरी है, सुविधा नहीं।

यहाँ सबसे बड़ी कौन-सी बाइनरी संख्या बदल सकता हूँ?

तिरपन अंकों की, जो दशमलव में 9007199254740991 है। यह सीमा इस पेज का चुना हुआ नियम नहीं है: यह वह चौड़ाई है जिसके आगे मशीन की संख्या पड़ोसी पूर्ण संख्याओं में फ़र्क़ नहीं कर पाती, इसलिए लंबा इनपुट ठीक-ठीक पढ़ा नहीं जा सकता और पेज को ऐसा कुछ छापना पड़ता जो जवाब जैसा लगे और जवाब न हो। लंबा इनपुट एक संदेश के साथ अस्वीकार कर दिया जाता है। यह बात यहाँ गणना वाले पेजों से ज़्यादा मायने रखती है, क्योंकि बदलना पढ़ने जैसा लगता है और पढ़ना बिना सीमा का।

क्या यह दो से बार-बार भाग देने जैसा ही है?

यह अलग रास्ते से वही जवाब देता है। दो से बार-बार भाग देने पर अंक दाईं ओर से निकलते हैं, और वही तरीक़ा दूसरी दिशा में इस्तेमाल होता है — दशमलव से बाइनरी जाते समय। बाइनरी से दशमलव जाते समय स्थानीय मान वाला जोड़ छोटा पड़ता है, क्योंकि अंक तो पता ही हैं और सिर्फ़ उनके भार जोड़ने हैं। दोनों सही हैं; यह पेज जोड़ छापता है, क्योंकि उसे एक नज़र में जाँचा जा सकता है।

क्या भिन्नात्मक भाग वाली बाइनरी संख्या बदल सकता हूँ?

यहाँ नहीं। यह पेज पूर्ण संख्याएँ पढ़ता है, इसलिए बाइनरी बिंदु अंदाज़ा लगाने के बजाय अस्वीकार कर दिया जाता है। बाइनरी में भिन्न पूरी तरह परिभाषित हैं — बिंदु के दाईं ओर के स्थान आधे, चौथाई, आठवें हिस्से के होते हैं — पर जो पेज उन्हें स्वीकार करता उसे यह तय करना पड़ता कि उनमें से कितने दिखाने हैं और आख़िरी को कैसे पूर्णांकित करना है, और इस परिवार के सारे पेज पूर्ण संख्याओं पर काम करते हैं। इस सीमा को हर पेज पर एक ही जगह रखने से ऐसा कभी नहीं होता कि कोई इनपुट एक पेज पर स्वीकार हो और दूसरे पर अस्वीकार।

• Binary number — positional notation, place values, and the conversion between base two and base ten — Wolfram MathWorld (United States)
• Number base — why a numeral's value depends on its position and on the base, and how one quantity is written in several bases — Wolfram MathWorld (United States)
• Powers of two — the sequence 1, 2, 4, 8, 16 … that a binary number's place values are taken from, catalogued as OEIS A000079 — OEIS Foundation Inc. (United States)