मंटिसा को सामान्य कैसे करें

Question

मैं एक कस्टम फ्लोट में int को परिवर्तित करने की कोशिश कर रहा हूं, जिसमें उपयोगकर्ता एक्सप और मंटिसा के लिए आरक्षित बिट्स की मात्रा निर्दिष्ट करता है, लेकिन मुझे समझ में नहीं आता कि रूपांतरण कैसे काम करता है। मेरा फ़ंक्शन एक int मान और int exp को संख्या (मान * 2^एक्सपी) i.e मान = 12, exp = 4 का प्रतिनिधित्व करने के लिए लेता है, 1 9 2 देता है। लेकिन मुझे यह समझने की आवश्यकता नहीं है कि मुझे इन प्रक्रियाओं को बदलने के लिए क्या करना है। मैं इसे दिनों के लिए देख रहा हूं और आईईईई कनवर्टर वेब ऐप्स के साथ खेल रहा हूं लेकिन मुझे समझ में नहीं आता कि सामान्यीकरण प्रक्रिया क्या है। जैसा कि मैंने देखा है कि यह "द्विआधारी बिंदु को स्थानांतरित करें और एक्सपोनेंट समायोजित करें" लेकिन मुझे नहीं पता कि इसका क्या अर्थ है, क्या कोई मुझे जाने के लिए एक उदाहरण दे सकता है? इसके अलावा मुझे समझ में नहीं आता कि एक्सपोनेंट पूर्वाग्रह क्या है। मेरे पास एकमात्र जानकारी यह है कि आप अपने एक्सपोनेंट में केवल एक संख्या जोड़ते हैं लेकिन मुझे समझ में नहीं आता क्यों। मैं लेकिन एक उदाहरण मैं समझ सकता के लिए Google खोज कर रहा है यह सिर्फ मेरे लिए कोई मतलब नहीं बना है

Answer 1

एक अपूर्णांश को सामान्य करने के लिए आप सबसे बाईं ओर गैर शून्य अंक के बाईं ओर दशमलव बिंदु जगह

उदाहरण के लिए

दूसरा सत्ता में सामान्य रूप में 10.11 आधार 2

= 0,1011 आधार 2 * 2 का प्रतिनिधित्व

दो का आधार है क्योंकि आप द्विआधारी संख्या और के + शक्ति के साथ काम कर रहे हैं ve 2 ऐसा इसलिए है क्योंकि आप टी चले गए हैं वह दशमलव बिंदु दो बार छोड़ दिया। याद रखें कि केवल 4 बिट्स-चुने श्रेणी में आदानों धर्मान्तरित mantizza

के लिए उपयोग किया जाता है तो mantizza 1011

Answer 2

"सामान्यीकरण की प्रक्रिया" होगा।

binary321.0 <= s < 2.0 श्रेणी में महत्व (मंटिसा) होने की अपेक्षा नहीं करता है जब तक कि संख्या में न्यूनतम एक्सपोनेंट न हो।

उदाहरण:
value = 12, exp = 4 रूप
value = 12/(2*2*2), exp = 4 + 3
value = 1.5, exp = 7

ही है significand हमेशा 1 के एक अग्रणी अंकों (जब तक नंबर एक न्यूनतम प्रतिपादक है), वहाँ के बाद से कोई इसे स्टोर करने की जरूरत है। और एक्सपोनेंट को 7 के रूप में संग्रहीत करने के बजाय, 127 की पूर्वाग्रह इसमें शामिल की गई है।

मूल्य = 1.5 दशमलव -> 1.1000 ... 000 द्विआधारी -> .1000 ... 000 संग्रहीत बाइनरी (23 सब में बिट्स)
exp = 7 -> पूर्वाग्रह exp 7 + 127 - > 134 दशमलव -> 10,000,110 द्विआधारी

बाइनरी पद्धति संग्रहीत, "हस्ताक्षर" के संयोजन है "significand एक अग्रणी 1 बिट निहित के साथ" और एक "पूर्वाग्रह प्रतिपादक"

0 10000110 1000...000 (1 + 8 + 23 = 32 bits) 

जब पक्षपातपूर्ण एक्सपोनेंट 0 है - न्यूनतम मूल्य, i mplied बिट 0 है और 0.0 जैसी छोटी संख्याएं संग्रहीत की जा सकती हैं।

जब पक्षपातपूर्ण एक्सपोनेंट 255 है - अधिकतम मूल्य, संग्रहीत डेटा अब सीमित संख्याओं का प्रतिनिधित्व नहीं करता है लेकिन "अनंतता" और "संख्या-संख्या"।

अधिक जानकारी के लिए संदर्भित लिंक देखें।

Answer 3

एक चल बिन्दु संख्या सामान्यीकृत जब हम वास्तव में 1 हो सकता है और इसके अंश हिस्सा बनने के लिए जो कुछ भी हम चाहते अनुमति देने के लिए अपने अपूर्णांश का पूर्णांक भाग के लिए मजबूर है।

उदाहरण के लिए, अगर हम संख्या 13.25, जो बाइनरी में 1101.01 है लग रही थी, 1101 पूर्णांक हिस्सा होगा और 01 अंश हिस्सा होगा।

मैं 13.251101.01*(2^0) के रूप में प्रतिनिधित्व कर सकता हूं, लेकिन यह सामान्य नहीं है क्योंकि पूर्णांक भाग 1 नहीं है।

1101.01*(2^0) 
= 110.101*(2^1) 
= 11.0101*(2^2) 
= 1.10101*(2^3) 

यह प्रतिनिधित्व 1.10101*(2^3)13.25 की सामान्यीकृत रूप है: हालांकि, हम अगर हम 1 से प्रतिपादक वृद्धि सही एक अंक के लिए अपूर्णांश शिफ्ट करने के लिए अनुमति दी जाती है।

---

जिसके अनुसार, हम जानते हैं कि सामान्यीकृत चल बिन्दु संख्या हमेशा प्रपत्र 1.fffffff * (2^exp)

में आ जाएगा दक्षता के लिए, हम द्विआधारी प्रतिनिधित्व अपने आप में 1 पूर्णांक भाग भंडारण परेशान नहीं करते हैं, हम सिर्फ यह दिखाते हैं कि यह वहां है। इसलिए यदि हम मंटिसा के लिए अपने कस्टम-निर्मित फ्लोट प्रकार 5 बिट्स देना चाहते थे, तो हम जानते होंगे कि 10100बिट्स वास्तव में 1.10100 के लिए खड़े होंगे।

यहां मानक 23-बिट अपूर्णांश साथ एक उदाहरण है:

---

प्रतिपादक पूर्वाग्रह का सवाल है, के मानक 32-बिट float प्रारूप पर एक नज़र है, जो टूट गया है लेते हैं 1 संकेत बिट, 8 प्रतिपादक बिट्स, और 23 अपूर्णांश बिट्स:

s eeeeeeee mmmmmmmmmmmmmmmmmmmmmmm 

एक्स्पोनेंट्स 00000000 और +०१२३४५३३३९ 3 भागों मेंमें विशेष प्रयोजन हैं (जैसे Inf और NaN का प्रतिनिधित्व करना), इसलिए 8 एक्सपोनेंट बिट्स के साथ, हम 2^1 से 2^254 पर उदाहरण के लिए 254 विभिन्न एक्सपोनेंट का प्रतिनिधित्व कर सकते हैं। लेकिन क्या होगा यदि हम 2^-3 का प्रतिनिधित्व करना चाहते हैं? हम नकारात्मक घाटे कैसे प्राप्त करते हैं?

प्रारूप द्वारा इस समस्या को स्वचालित रूप से से 127 को घटाकर ठीक करता है।इसलिए:

• 0000 0001 होगा 1 -127 = -126
• 0010 1101 होगा 45 -127 = -82
• 0111 1111 होगा 127-127 = 0
• 1001 0010 होगा 136-127 = 9

यह 2^1 ... 2^254 से 2^-126 ... 2^+127 के प्रतिपादक सीमा में परिवर्तन तो हमनकारात्मक घाटे का प्रतिनिधित्व कर सकते हैं।

Answer 4

टॉमी-चक्स और इगेंक्रिस, दूसरों के साथ उत्कृष्ट उत्तर प्रदान किए गए हैं, लेकिन यदि मैं आपकी टिप्पणियों को सही तरीके से देख रहा हूं, तो भी आप "मैं इसे कैसे ले जाऊंगा" जानकारी और उसके बाद कस्टम फ्लोट प्रतिनिधित्व बनाने में इसका उपयोग करें जहां उपयोगकर्ता एक्सपोनेंट के लिए बिट्स की मात्रा निर्दिष्ट करता है? " बुरा मत मानो, यह पहली दर्जन बार मिट्टी के रूप में स्पष्ट है कि आप इसके माध्यम से जाते हैं। मुझे लगता है कि मैं इसे साफ़ करने पर एक स्टैब ले सकता हूं।

आप की IEEE754-एकल प्रेसिजन-फ्लोटिंग प्वाइंट प्रतिनिधित्व से परिचित हैं:

IEEE-754 Single Precision Floating Point Representation of (13.25) 

    0 1 0 0 0 0 0 1 0 1 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 
|- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -| 
|s|  exp  |     mantissa     | 

कि 1-bit sign-bit, 8-bit biased exponent (में 8 बिट अतिरिक्त-127 अंकन), और शेष 23-bit mantissa।

जब आप उपयोगकर्ता को एक्सपोनेंट में बिट्स की संख्या चुनने की अनुमति देते हैं, तो आपको रीववर्क नए उपयोगकर्ता द्वारा चुनी गई सीमा के साथ काम करने के लिए एक्सपोनेंट नोटेशन होना होगा।

क्या परिवर्तन होगा? नहीं -

• यह sign-bit हैंडलिंग बदलेगा।

• यह mantissa हैंडलिंग बदलेगा - नहीं (आप अभी भी अपूर्णांश/significand को "छिपा बिट" प्रारूप में परिवर्तित कर देंगे)।

तो केवल एक चीज जिस पर आपको ध्यान केंद्रित करने की आवश्यकता है exponent handling है।

आप इस पर कैसे पहुंचेंगे? याद रखें, वर्तमान 8-बिट एक्सपोनेंट अतिरिक्त-127 नोटेशन (जहां 127 7 बिट्स के लिए सबसे बड़ा मान दर्शाता है, जो किसी भी पूर्वाग्रह को शामिल करने की अनुमति देता है और वर्तमान 8-bit सीमा के भीतर व्यक्त किया जाता है। यदि आपका उपयोगकर्ता 6 बिट्स चुनता है ? प्रतिपादक आकार, तो क्या आप बीमा करने के लिए आप अपने नए अतिरिक्त प्रतिनिधित्व करने के लिए एक निश्चित संख्या एक समान विधि प्रदान करना होगा -। ## अंकन है कि उपयोगकर्ता सीमा के भीतर काम करेंगे

एक उपयोगकर्ता 6-bit सीमा ले लो , तो निष्पक्ष एक्सपोनेंट वैल्यू के लिए एक विकल्प 31 (सबसे बड़े मान जिन्हें 5-bits में प्रदर्शित किया जा सकता है) के रूप में आजमाया जा सकता है। इसके लिए आप उसी तर्क को लागू कर सकते हैं (ऊपर 13.25 उदाहरण लेना)।संख्या से आपकी द्विआधारी प्रतिनिधित्व 1101.01 जो आप दशमलव 3 positions to the left स्थानांतरित करने के लिए जो आप 3 की एक प्रतिपादक पूर्वाग्रह देता 1.10101 प्राप्त करने के लिए है।

अपने 6-bit exponent मामले में आप 3 + 31 जोड़ने प्रतिपादक के लिए अपने excess-31 notation प्राप्त करने के लिए होगा: 100010, तो "छिपा बिट" प्रारूप में अपूर्णांश डाल (यानी अपने नए कस्टम टॉमी प्रेसिजन प्रतिनिधित्व में जिसके परिणामस्वरूप 1.10101 से ड्रॉप प्रमुख 1:

IEEE-754 Tommy Precision Floating Point Representation of (13.25) 

    0 1 0 0 0 1 0 1 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 
|- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -| 
|s| exp |     mantissa      | 

1-bit sign-bit साथ

, 6-bit biased exponent (6-बिट में अतिरिक्त -31 अंकन), और शेष 25-bit mantissa।

वही नियम पी पीछे करने के लिए लागू होगा उपर्युक्त नोटेशन से अपने फ़्लोटिंग पॉइंट नंबर को वापस पाने के लिए रोकस करें। (केवल 31 का उपयोग 127 के बजाय एक्सपोनेंट से पूर्वाग्रह को वापस करने के लिए

उम्मीद है कि यह किसी भी तरह से मदद करता है। यदि आप वास्तव में उपयोगकर्ता द्वारा चयनित एक्सपोनेंट आकार की अनुमति देने जा रहे हैं तो मैं और कुछ नहीं देख सकता हूं। याद रखें, आईईईई-754 मानक कुछ है कि में अनुमान लगाया गया था और अच्छा तर्क और व्यापार गत का एक बहुत 1-8-23 साइन-प्रतिपादक-अपूर्णांश लेआउट पर पहुंचने में चला गया नहीं था। हालांकि, मुझे लगता है कि मानक अभ्यास को दृढ़ता से समझने के लिए आपको अपना अभ्यास बहुत अच्छा काम करता है।

अब पूरी तरह से खो गया है और इस चर्चा में को संबोधित नहीं किया गया है, इस संख्या में Custom Precision Floating Point Representation में प्रदर्शित किए जा सकने वाले नंबरों की संख्या पर इसका असर होगा। मैं इसे देखा नहीं है, लेकिन प्राथमिक सीमा MAX/MIN कि निरूपित किया जा सकता में कमी होने के लिए प्रतीत होता है।

Answer 5

एक टिप्पणी 'कैसे कोड में यह करने के लिए' पर पोस्ट का जवाब करने के लिए: (यह मानते हुए यह एक आईईईई नाव है)

ए) आईईईई नाव से एक अहस्ताक्षरित 'प्रतिपादक' और 'अपूर्णांश' निकालें।

मैं) exp = 0x7F800000 & yourFloatVar;

// इस नाव से B8 के माध्यम से थोड़ा बी 1 लेता है। (B0 पर हस्ताक्षर किए बिट, B9 है और पर अपूर्णांश है)

ii) exp = exp >> 23; // ठीक है तो बदलाव इस प्रतिपादक सही उन्मुख

iii) exp += 127; // पूर्वाग्रह में जोड़ने (127 32 के लिए है -बिट केवल)

iv) mantissa = 0x007FFFFF & yourFloatVar; // नाव

बी) को सामान्य से पिछले 23 बिट्स ले

मैं)

while(true) 
{ 
    if(((mantissa & 0xC0000000) != 0x80000000) 
     &&((mantissa & 0xC0000000) != 0x40000000)) 
    { 
     mantissa = mantissa << 1; 
     exponent--; 
    } 
    else //AKA the float has been normalized 
    { 
     break; 
    } 
} 

यदि अग्रणी 2 बिट्स '01' या '10' (यह 2 के पूरक की संपत्ति है - हालत को सामान्य बनाने में) नहीं हैं, तो अपूर्णांश साथ-साथ बदल और प्रतिपादक घटती।

मैं ध्यान दें कि यह ऐसा करने के लिए सभी के लिए सबसे कुशल एल्गोरिथ्म पर नहीं है चाहते हैं; मैं सिर्फ कदम स्पष्ट करना चाहता था। उम्मीद है कि मुझे कुछ याद नहीं आया!