प्रोग्रामर कैलकुलेटर

HEX
0
DEC
0
OCT
0
BIN
0
संख्या आधार
वर्ड आकार
बिट

यह प्रोग्रामर कैलकुलेटर वैसे ही गणना करता है जैसे कंप्यूटर के भीतर पूर्णांक काम करते हैं: तय संख्या के बिट पर, टू'ज़ कॉम्प्लिमेंट में, और ओवरफ़्लो पर घूमकर। हेक्साडेसिमल, दशमलव, ऑक्टल या बाइनरी में लिखें और मान को चारों आधारों में एक साथ देखें; AND, OR और XOR से मानों को जोड़ें, उन्हें शिफ़्ट और रोटेट करें, और अलग-अलग बिट बदलें। यह फ़र्मवेयर, नेटवर्किंग, एम्बेडेड और सिस्टम प्रोग्रामिंग के लिए, और बाइनरी संख्याओं को समझने के लिए बनाया गया है।

  • HEX, DEC, OCT और BIN एक साथ
  • BYTE, WORD, DWORD और QWORD, साइन्ड (टू'ज़ कॉम्प्लिमेंट) या अनसाइन्ड
  • AND, OR, XOR, NOT, NAND और NOR
  • बाएँ और दाएँ शिफ़्ट, अंकगणितीय और तार्किक, और रोटेट
  • ओवरफ़्लो फ़्लैग और C जैसी ऑपरेटर वरीयता
  • सभी 64 बिट का क्लिक करने योग्य दृश्य

प्रोग्रामर कैलकुलेटर का उपयोग कैसे करें

  1. वह आधार चुनें जिसमें लिखना है (HEX, DEC, OCT या BIN), वर्ड आकार (BYTE, WORD, DWORD या QWORD) और यह कि संख्याएँ साइन्ड हैं या नहीं। जिन अंकों का आधार में अस्तित्व नहीं, उनकी कुंजियाँ बंद हो जाती हैं।
  2. कुंजियों या कीबोर्ड से व्यंजक लिखें, जैसे F0 AND 3C, फिर = दबाएँ। स्क्रीन परिणाम चारों आधारों में दिखाती है; बड़ी पंक्ति वह आधार है जिसमें आप लिख रहे हैं।
  3. शिफ़्ट के लिए Lsh और Rsh, तार्किक दाएँ शिफ़्ट के लिए >>>, रोटेट के लिए RoL और RoR, और दिखाए गए मान के सभी बिट उलटने के लिए NOT का उपयोग करें। कोष्ठक और C की ऑपरेटर वरीयता लागू होती है।
  4. मान का हर बिट देखने के लिए बिट खोलें। किसी बिट पर क्लिक करके उसे उलटें; वर्ड आकार से ऊपर के बिट धुंधले रहते हैं।
  5. मौजूदा आधार में उपसर्ग (0x, 0o या 0b) के साथ मान कॉपी करने के लिए कॉपी कुंजी दबाएँ। AC सब साफ़ करता है; आधार, वर्ड आकार और अंतिम मान इस ब्राउज़र में याद रहते हैं।

हेक्साडेसिमल, दशमलव, ऑक्टल और बाइनरी

आधार वह संख्या है कि एक स्थान पर कितने अलग अंक आ सकते हैं। बाइनरी 0 और 1, ऑक्टल 0 से 7, दशमलव 0 से 9 और हेक्साडेसिमल 0 से 9 तथा A से F का उपयोग करता है। हर स्थान अपने दाएँ स्थान का आधार गुना होता है, इसलिए एक ही संख्या हर आधार में अलग लिखी जाती है:

2F16=2×16+15=47=1011112=578

हेक्साडेसिमल इसलिए लोकप्रिय है क्योंकि हर हेक्स अंक ठीक चार बिट है: एक बाइट हमेशा दो हेक्स अंक और 64-बिट मान 16 हेक्स अंक होता है। ऑक्टल बिटों को तीन-तीन में समूहित करता है, इसीलिए 755 जैसी Unix फ़ाइल अनुमतियाँ ऑक्टल में लिखी जाती हैं।

साइन्ड संख्याएँ और टू'ज़ कॉम्प्लिमेंट

कंप्यूटर ऋणात्मक पूर्णांक को टू'ज़ कॉम्प्लिमेंट में रखता है: सभी बिट उलटें और एक जोड़ें। 8 बिट में ऋण एक FF होता है और परिसर −128 से 127 है; अनसाइन्ड में वही 8 बिट 0 से 255 होते हैं।

−x=¬x+1−1=FF16 (8 bit)−128≤x≤127

हर वर्ड आकार का परिसर
वर्डबिटअनसाइन्डसाइन्ड (टू'ज़ कॉम्प्लिमेंट)
BYTE80…255−128…127
WORD160…65535−32768…32767
DWORD320…232−1−231…231−1
QWORD640…264−1−263…263−1

साइन्ड और अनसाइन्ड के बीच बदलने से कोई बिट नहीं बदलता, केवल उसे पढ़ने का तरीका बदलता है: 1111 1111 अनसाइन्ड में 255 और साइन्ड में −1 है। वर्ड आकार बदलने पर, C के टाइप कास्ट की तरह, सबसे निचले बिट बने रहते हैं।

बिटवाइज़ ऑपरेटर, शिफ़्ट और रोटेट

बिटवाइज़ ऑपरेटर हर बिट-जोड़ी पर अलग से काम करते हैं। शिफ़्ट सभी बिट बाएँ या दाएँ खिसकाते हैं; रोटेट एक सिरे से गिरे बिट को दूसरे सिरे से वापस डालते हैं।

प्रोग्रामर कैलकुलेटर के ऑपरेटर
कुंजीक्या करती हैउदाहरण
ANDकेवल वहाँ 1 जहाँ दोनों बिट 1 हों। बिट मास्क करने में काम आता है।1100&1010=1000
ORजहाँ कोई भी बिट 1 हो वहाँ 1। बिट सेट करने में काम आता है।1100∣1010=1110
XORजहाँ बिट अलग हों वहाँ 1। बिट टॉगल करने में काम आता है।1100⊕1010=0110
NOTवर्ड के सभी बिट उलट देता है।¬ 00001111=11110000
NAND · NORAND या OR के बाद NOT।¬(a&b)¬(a∣b)
Lshबिट बाएँ खिसकाता है और शून्य भरता है; हर कदम 2 से गुणा करता है जब तक बिट बाहर न गिरें।5≪3=5×23=40
Rshबिट दाएँ खिसकाता है। साइन्ड वर्ड में साइन बिट कॉपी होता है (अंकगणितीय शिफ़्ट), यानी नीचे की ओर पूर्णांकित 2 से भाग; अनसाइन्ड में शून्य आते हैं।−16≫2=−4
>>>तार्किक दाएँ शिफ़्ट: साइन्ड वर्ड में भी हमेशा शून्य आते हैं।F016⋙4=0F16
RoL · RoRवर्ड के भीतर बिट घुमाता है; कुछ भी नहीं खोता।rol⁡(10000001,1)=00000011
modपूर्णांक भाग का शेषफल। C की तरह, भाग शून्य की ओर पूर्णांकित होता है और शेषफल भाज्य का चिह्न लेता है।−7 mod 2=−1−7÷2=−3

ऑपरेटर वरीयता

व्यंजक C, C++, Java और JavaScript की वरीयता का पालन करते हैं: पहले NOT और ऋण चिह्न, फिर × ÷ mod, फिर + −, फिर शिफ़्ट और रोटेट, फिर AND और NAND, फिर XOR, अंत में OR और NOR। एक ही स्तर के ऑपरेटर बाएँ से दाएँ लगते हैं।

1+2≪3=(1+2)≪3=246&3∣8=(6&3)∣8=10

जो लोग मानते हैं कि शिफ़्ट जोड़ से पहले होगा, वे चौंकते हैं: 1 + 2 Lsh 3 का मान 24 है, 17 नहीं। संदेह हो तो कोष्ठक लगाएँ; कैलकुलेटर व्यंजक ठीक वैसे ही दिखाता है जैसे उसकी गणना होगी।

ओवरफ़्लो और घूमकर लौटना

जब जोड़, घटाव, गुणा या भाग का परिणाम वर्ड में नहीं समाता, तो परिणाम हार्डवेयर की तरह दो की वर्ड-आकार घात के मॉड्यूलो में घूम जाता है और स्क्रीन पर OVF दिखता है:

127+1=128∉[−128,127]  ⇒  128−28=−128

शिफ़्ट और बिटवाइज़ ऑपरेटर कभी OVF नहीं जलाते: बिट छोड़ना ही उनका काम है। वर्ड में न समाने वाली लिखी गई संख्या चुपचाप काटी नहीं जाती, अस्वीकार की जाती है।

यह कितना सटीक है?

हर मान सटीक पूर्णांक (JavaScript BigInt) के रूप में रखा जाता है, इसलिए QWORD के सभी 64 बिट सटीक हैं। साधारण फ़्लोटिंग पॉइंट केवल 53 बिट रखता है: वह 9007199254740992 और 9007199254740993 में फ़र्क नहीं कर पाता, जबकि यह कैलकुलेटर हमेशा कर पाता है।

सटीकता और परीक्षण उदाहरण

इस पृष्ठ का हर ऑपरेटर हर रिलीज़ से पहले 56 परीक्षण उदाहरणों पर अपने-आप जाँचा जाता है, जिनमें भाग, शेषफल और शिफ़्ट के C नियम तथा हर वर्ड आकार शामिल हैं। सारणी में कुछ चुने हुए उदाहरण हैं; सब को अपने ब्राउज़र में चलाकर देखें कि वही इंजन पास होता है जिसका आप उपयोग कर रहे हैं।

परीक्षण उदाहरण: आधार और टाइप सहित व्यंजक, सटीक मान, कैलकुलेटर क्या दिखाता है और साधारण डबल-प्रिसिज़न अंकगणित क्या देता है
व्यंजकसटीक मानकैलकुलेटर दिखाता है (DEC)साधारण फ़्लोटिंग पॉइंटजाँच
आधार और वर्ड आकार u8 अनसाइन्ड BYTE है, i64 साइन्ड QWORD, इत्यादि।
FF[HEX, u8]15⋅16+15255——
FF[HEX, i8]255−28−1——
FFFFFFFFFFFFFFFF[HEX, u64]264−118446744073709551615——
8000000000000000[HEX, i64]−263−9223372036854775808——
ओवरफ़्लो और घूमकर लौटना OVF फ़्लैग भी जाँचा जाता है।
127+1[DEC, i8]128−28−128——
2147483647+1[DEC, i32]—−2147483648——
पूर्णांक भाग और शेषफल C की तरह शून्य की ओर पूर्णांकन, शेषफल भाज्य के चिह्न के साथ।
−7÷2[DEC, i32]trunc⁡(−3.5)−3——
−7 mod 2[DEC, i32]—−1——
वे पूर्णांक जिन्हें फ़्लोटिंग पॉइंट नहीं रख सकता 2⁵³ से ऊपर double आख़िरी अंक खो देता है; BigInt उन्हें रखता है।
9007199254740992+1[DEC, i64]253+190071992547409939007199254740992—
123456789×987654321[DEC, i64]—121932631112635269121932631112635260—
बिटवाइज़ तर्क हर बिट अलग से।
F0AND3C[HEX, u8]301648——
FFXOR0F[HEX, u8]F016240——
∼0[DEC, u16]216−165535——
शिफ़्ट और रोटेट अंकगणितीय और तार्किक शिफ़्ट, वर्ड से बड़े रोटेट।
1≪7[DEC, i8]—−128——
−16≫2[DEC, i8]—−4——
−16⋙2[DEC, i8]F016≫2=3C1660——
81ROL1[HEX, u8]03163——
ऑपरेटर वरीयता C और JavaScript जैसा ही क्रम।
1+2≪3[DEC, i32](1+2)≪324——
6&3∣8[DEC, i32](6&3)∣810——
अमान्य इनपुट ग़लत संख्या देने की जगह कैलकुलेटर क्या कहता है।
1÷0[DEC, i32]—शून्य से भाग नहीं दिया जा सकता——
19[OCT, u16]—इस आधार में यह अंक नहीं होता——
256[DEC, u8]—इस वर्ड आकार के लिए बहुत बड़ा——

सभी परीक्षण उदाहरण दिखाएँ

किसी एक संख्या को आधारों के बीच बदलने, या अन्य गणनाओं के लिए, ये कैलकुलेटर आज़माएँ।

अक्सर पूछे जाने वाले प्रश्न

127 + 1 का परिणाम −128 क्यों आता है?

साइन्ड BYTE में सबसे बड़ा मान 127 है। 1 जोड़ने के लिए नौवाँ बिट चाहिए, जो वर्ड में नहीं है, इसलिए परिणाम घूमकर −128 हो जाता है और OVF जलता है। 128 पाने के लिए बड़ा वर्ड या अनसाइन्ड चुनें।

Rsh और >>> में क्या अंतर है?

Rsh साइन्ड वर्ड पर अंकगणितीय शिफ़्ट है: यह साइन बिट कॉपी करता है, इसलिए −16 Rsh 2 का मान −4 है। >>> तार्किक शिफ़्ट है: हमेशा शून्य आते हैं, इसलिए साइन्ड BYTE में −16 >>> 2 का मान 60 है।

FF, −1 के बराबर क्यों है?

क्योंकि वर्ड साइन्ड है। टू'ज़ कॉम्प्लिमेंट में सभी बिट 1 वाला पैटर्न −1 है। साइन्ड का चयन हटाएँ, तो वही FF 255 पढ़ा जाता है।

मेरा परिणाम किसी दूसरे प्रोग्रामर कैलकुलेटर से अलग क्यों है?

पहले वर्ड आकार और साइन्ड सेटिंग जाँचें: वही बिट अलग वर्ड में अलग संख्या होते हैं। फिर वरीयता जाँचें: यह कैलकुलेटर C का पालन करता है, इसलिए शिफ़्ट + और − के बाद होते हैं।

पूर्णांक भाग कैसे पूर्णांकित होता है?

C और अधिकांश प्रोसेसरों की तरह शून्य की ओर: −7 ÷ 2 का मान −3 और −7 mod 2 का मान −1 है। भागफल गुणा भाजक जमा शेषफल हमेशा भाज्य लौटाता है।

क्या मैं कीबोर्ड से लिख सकता हूँ?

हाँ, जब कैलकुलेटर पर फ़ोकस हो: अंक और A से F, + − * / %, AND, OR और NOT के लिए & | ~, शिफ़्ट के लिए < और >, कोष्ठक, = के लिए Enter, Backspace और Escape।

क्या यह 64-बिट संख्याओं के लिए सटीक है?

हाँ। मान फ़्लोटिंग पॉइंट नहीं, सटीक पूर्णांक हैं, इसलिए QWORD का हर बिट सुरक्षित रहता है। नीचे के परीक्षण उदाहरणों में 2⁵³ से बड़े वे मान भी हैं जिन्हें साधारण फ़्लोटिंग पॉइंट ग़लत निकालता है।