💆 💰 👓 परिवर्तन और अन्य कार्यों के सवाल पर 👂🏼 🛌🏽 🐞

ब्लू कैटरपिलर: ठीक है, आप हमें नीचे नहीं लाएंगे। हम खुद बैठते हैं, हम जानते हैं: वे हमारे परिवर्तन की प्रतीक्षा कर रहे हैं। क्या? लेकिन कुछ भी नहीं! हम बैठते हैं, धूम्रपान करते हैं, प्रतीक्षा करते हैं ...
ऐलिस गुड़िया: क्या?
ब्लू कैटरपिलर: क्या, क्यों! परिवर्तनों का। घर में धुआं, एक महिला में धुआं, और एक माँ में महिला। वहां तुम जाओ। हस्तक्षेप न करें, आगे न कूदें, अन्यथा आप खुद ही समय से पहले किसी तरह के तितली में बदल जाएंगे।

Arduino को समर्पित मंचों में से एक पर कोड के माध्यम से देखने पर, मुझे एक फ्लोटिंग पॉइंट नंबर (PT) के साथ काम करने का एक मजेदार तरीका मिला। इस प्रारूप में संख्याओं के लिए दूसरा सामान्य नाम फ़्लोटिंग पॉइंट है, लेकिन इस मामले में उत्पन्न होने वाला संक्षिप्त नाम (पीपी) व्यक्तिगत रूप से मेरे लिए पूरी तरह से अलग संघों का कारण बनता है, इसलिए हम इस विकल्प का उपयोग करेंगे। पहली छाप (देखा कोड से) यहाँ किस तरह का कचरा लिखा गया है (मुझे कहना होगा कि दूसरा एक ही है, हालांकि बारीकियाँ हैं, लेकिन उस पर बाद में और अधिक), लेकिन सवाल यह उठता है - यह वास्तव में कैसे आवश्यक है - जिसका उत्तर इसमें दिया गया है। आगे का पाठ।

भाग एक - पूछताछ

हम समस्या को तैयार करते हैं - हमें प्रिंट विकल्पों का उपयोग किए बिना, एक फ़्लोटिंग-पॉइंट संख्या में कंसोल (एक प्रतीकात्मक प्रतिनिधित्व में बदल) की आवश्यकता होती है, जो इस उद्देश्य के लिए अभिप्रेत है। हम अपने दम पर ऐसा क्यों करना चाहते हैं -

% f प्रारूप का उपयोग लाइब्रेरी को फ़्लोटिंग पॉइंट और प्रांट फ़ंक्शन के विस्तारित संस्करण के साथ काम करने के लिए जोड़ता है (या यों कहें, इसके छंटे हुए संस्करण का उपयोग करना असंभव बनाता है), जो निष्पादन योग्य मॉड्यूल के आकार में महत्वपूर्ण वृद्धि की ओर जाता है,
एक मानक समाधान के लिए काफी समय की आवश्यकता होती है (यह हमेशा एक दोहरी परिशुद्धता संख्या के साथ काम करता है), जो इस विशेष स्थिति में अस्वीकार्य हो सकता है,
अच्छा (अंतिम, लेकिन कम से कम), यह सिर्फ दिलचस्प है।

शुरू करने के लिए, उपरोक्त सामग्री में प्रस्तावित विकल्प पर विचार करें:

for (float Power10=10000.0; Power10>0.1; Power10/=10.0; ) {char c=(int)(Fdata/Power10); Fdata -=Power10*c; };

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

भाग दो - प्राथमिक संचालन का प्रदर्शन मूल्यांकन

पहला दिलचस्प ऑपरेशन इसके अलावा (घटाव, खर्च किए गए समय के संदर्भ में, वे संख्याओं के पूर्णांक के बराबर हैं) और हम यह मान सकते हैं कि यह निम्नलिखित कैविएट के साथ समय (घड़ी चक्र) की एक इकाई लेता है - यह केवल "मूल" डेटा के लिए सच है। उदाहरण के लिए, MK श्रृंखला AVR के लिए, यह 8-बिट शब्द है, MSP430 के लिए यह एक 16-बिट शब्द है (और, ज़ाहिर है, छोटा), Cortex-M के लिए यह एक 32-बिट शब्द है, और इसी तरह। फिर मूल चक्र की तुलना में एच से अधिक की लंबाई के साथ संख्याओं के संचालन को एच चक्र के रूप में अनुमानित किया जा सकता है। उदाहरण के लिए, AVR नियंत्रकों में AddW हैं, लेकिन यह नियम को रद्द नहीं करता है।

अगला ऑपरेशन पूर्णांक का गुणन है (लेकिन विभाजन नहीं, यह गति के मामले में भिन्न है) और उसके लिए सब कुछ इतना सरल नहीं है। सबसे पहले, गुणा को हार्डवेयर में लागू किया जा सकता है और, उदाहरण के लिए, AVR MEGA में इसे 2 घड़ी चक्र की आवश्यकता होती है, और 51 में बेहतर के रूप में 6 (मूल संख्याओं को गुणा करने के लिए)।

लेकिन उस मामले पर विचार करें जब कोई हार्डवेयर कार्यान्वयन नहीं है और हमें सबरूटीन के रूप में गुणन को लागू करना होगा। चूँकि जब H बिट संख्याओं को गुणा किया जाता है, तो एक 2H बिट उत्पाद प्राप्त किया जाता है, पाली के साथ शास्त्रीय संस्करण का अनुमान निम्न प्रकार से लगाया जा सकता है: हमें प्रति घंटे 1 घड़ी चक्र के साथ कारक के H पारियों की आवश्यकता होती है, H को दूसरे कारक की HH शिफ्ट प्रति घड़ी 2 चक्रों से 2H लंबी होती है, तब H निर्णय लेंगे और , औसतन, 2H की लंबाई के साथ संख्याओं के एन / 2 परिवर्धन, निष्कर्ष में, 2 उपायों के एक चक्र का संगठन। कुल + 2 + + 2 / 2 + 2 = 7 R2 टिक, और वास्तव में उन से अंकगणितीय संचालन प्रदर्शन केवल एन टिक लेता है (वाह दक्षता, हालांकि हम इंजन के आसपास पाने में कामयाब रहे)।

यही है, 8p एमके द्वारा दो 8p संख्याओं को गुणा करने के लिए, 56 चक्रों की आवश्यकता होती है, और 16p संख्याओं को गुणा करने के लिए पहले से ही 112 चक्र हैं (थोड़ा कम है, लेकिन हम सटीक मूल्य की उपेक्षा करते हैं) चक्र, जो कुछ हद तक हम चाहते थे। सौभाग्य से, पारियों की दिशा को संशोधित किया जा सकता है और गुणन का एक अनूठा तरीका है, जिसके लिए केवल 2H अंकों की संख्या H H और मूल संख्याओं के H / 2 जोड़ की आवश्यकता होगी, जो गुणन एल्गोरिथम के ऑपरेटिंग समय को 0 + 2 + 1 + 1/2 में सुधारता है। + 2 = 5.5GHz - बेशक, इसे हार्डवेयर कार्यान्वयन के साथ तुलना नहीं की जा सकती है, लेकिन कार्यक्षमता के नुकसान के बिना कम से कम कुछ लाभ। इस एल्गोरिथ्म में सुधार हैं, उदाहरण के लिए, प्रति चक्र 2 बिट्स का विश्लेषण, लेकिन वे स्थिति में बहुत बदलाव नहीं करते हैं - परिमाण के आदेशों से गुणा का समय इसके अतिरिक्त समय से अधिक है।

लेकिन विभाजन के साथ स्थिति बदतर है - यहां तक कि हार्डवेयर-कार्यान्वित डिवीजन लगभग दो गुना तक गुणा करता है, इसके अलावा, हार्डवेयर गुणन के साथ एमके हैं, लेकिन हार्डवेयर विभाजन के बिना। कुछ शर्तों के तहत, विभाजन को पारस्परिक द्वारा गुणन द्वारा प्रतिस्थापित किया जा सकता है, लेकिन ये स्थितियां विशिष्ट हैं और एक समान परिणाम देती हैं - गुणन के दो पुनरावृत्तियों को योग के बाद की आवश्यकता होती है, इसलिए 2 गुना नुकसान होता है। यदि हम एक उपप्रोग्राम के रूप में विभाजन को लागू करते हैं, तो एन 2 की शिफ्ट 2H लंबी, एच 2 से विभाज्य 2H लंबी, परिणाम की H शिफ्ट, चक्र के 2H संगठन की आवश्यकता होती है, लेकिन यह सब संरेखण द्वारा पूर्ववर्ती है, जो एक और 5H चक्र लेगा, इसलिए कुल आंकड़ा 2 है + २ + १ + २ + ५ = १२ गुणा, जो गुणा से लगभग २ गुना खराब है।

खैर, अब हम पीटी संचालन पर विचार करेंगे, और यहां स्थिति कुछ हद तक विरोधाभासी है - गुणन ऑपरेशन को पूर्णांक (बिट क्षमता के अनुसार, लगभग एक नियम के रूप में, 24 बिट्स) के लिए लगभग उतना ही समय चाहिए, क्योंकि हमें म्यूनिसा को गुणा करना होगा और सिर्फ ऑर्डर जोड़ना होगा, सामान्यीकरण नहीं होता है की आवश्यकता है। विभाजन भी अच्छा है, मंटिसा को विभाजित करें और आदेशों को घटाएं, फिर से सामान्यीकरण की आवश्यकता नहीं है। इसलिए, इन दो कार्यों के लिए, पूर्णांकों की तुलना में नुकसान बहुत महत्वपूर्ण नहीं है, हालांकि इसमें एक जगह है।

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

आइए अपनी भेड़ों के पास वापस जाएं और सहमत हों कि पिछले अनुमानों के आधार पर, प्रस्तावित विधि बहुत लंबी नहीं हो सकती है, खासकर जब से यह तुरंत परिणाम देती है, लेकिन इसकी एक महत्वपूर्ण सीमा है - यह इनपुट पीटी मूल्यों के बहुत सीमित सीमा तक लागू है। इसलिए, यह एक सार्वभौमिक (अधिक या कम) समाधान की तलाश करेगा।

तुरंत एक आरक्षण करें कि हमारे समाधान को हमारे विकल्प की खूबियों पर जोर देने के लिए सामान्य रूप से (शब्द से बिल्कुल) फ्लोटिंग-पॉइंट ऑपरेशन का उपयोग नहीं करना चाहिए। और फिर इस सवाल का कि इस प्रकार का एक नंबर कैसे प्रकट होगा यदि ऑपरेशन अनुपलब्ध हैं, तो हम उत्तर देते हैं - यह अच्छी तरह से दिखाई दे सकता है, उदाहरण के लिए, जब प्रकाश सेंसर से जानकारी पढ़ना (जैसा कि यह मूल उदाहरण में था), जो पीटी प्रारूप में डेटा का उत्पादन करता है।

पीटी की संख्या कितनी सटीक रूप से व्यवस्थित की गई है, आप आसानी से कई साइटों पर पा सकते हैं, हैबे पर हाल ही में एक लेख था, इसके साथ कोई समस्या नहीं होनी चाहिए। फिर भी, "यदि मैं निर्देशक था" की शैली में बहुत सारे प्रश्न पीटी प्रारूप के लिए रुचि रखते हैं - क्यों ठीक है, और अन्यथा नहीं। मैं उनमें से कुछ को अपना उत्तर दूंगा, अगर किसी को अधिक सही पता है, तो कृपया टिप्पणी करें।

पहला सवाल यह है कि मंटिसा को डायरेक्ट कोड में क्यों रखा गया है और अतिरिक्त कोड में नहीं? मेरा उत्तर है क्योंकि एक छिपे हुए (वैकल्पिक) बिट के साथ सामान्यीकृत मंटिसा के साथ काम करना आसान है।

दूसरा सवाल यह है कि ऑर्डर को ऑफसेट के साथ क्यों संग्रहीत किया जाता है, और अन्यथा नहीं? मेरा जवाब है क्योंकि इस मामले में दो PT के मॉड्यूल की पूर्णांक के रूप में तुलना करना आसान है, अन्य तरीकों से यह अधिक जटिल है।

तीसरा सवाल यह है कि ऋणात्मक चिन्ह शून्य के बजाय एक से क्यों जुड़ा हुआ है, क्योंकि तब दो बिंदुओं की पूर्णांक के रूप में तुलना करना संभव होगा? मेरा जवाब है मैं नहीं जानता, यह सिर्फ "यहाँ स्वीकार है"।

भाग तीन - आवश्यक स्पष्टीकरण

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

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

इस धारणा के तहत कि बिट्स के सेट की लंबाई n होती है (हम उन्हें 0 से n-1 की पंक्ति में संख्या देते हैं) और समान रूप से 2 के चरण के साथ भारित होते हैं और कम से कम महत्वपूर्ण बिट (संख्या 0 के साथ) का वजन 1 होता है (जो, आम तौर पर बोलना आवश्यक नहीं है, हम बस आवश्यक नहीं हैं) हमें ऐसी चीजों की आदत हो गई है, और वे हमारे लिए स्पष्ट प्रतीत होती हैं) हमें संख्या का द्विआधारी प्रतिनिधित्व मिलता है, जिसमें कमी का सूत्र इस तरह दिखता है: बिट्स के सेट (2) = (0)*2^0 + (1)*2^1 + ... + (-1)*2^(-1) द्वारा प्रदर्शित संख्या (2) = (0)*2^0 + (1)*2^1 + ... + (-1)*2^(-1) या कैस्केड रूप में 2() = (0)+2*((1)+2*(...+2*((-1))..))) , इसके बाद, B (k) संख्या k के साथ थोड़ा सा सूचित करता है। एक अलग दृश्य मेमोरी में संख्या बाइट्स के स्थान पर कोई प्रतिबंध नहीं लगाता है, लेकिन निचले बाइट्स को निचले पतों में रखना अधिक तर्कसंगत होगा (यह इस तरह से आसानी से और स्वाभाविक रूप से मैंने "खुद के बारे में स्लाव के शाश्वत तर्क" को हल कर दिया है जिसके बारे में अंत में अंडे को तोड़ने के लिए अधिक सुविधाजनक है)।

लंबाई n (= 8) के बिट्स के एक सेट की इस व्याख्या के साथ, हमें 0 से (2 ^ n) -1 (= 255) संख्याओं के लिए एक प्रतिनिधित्व मिलता है (बाद में कोष्ठक में 8 बिट्स के सेट के लिए एक विशिष्ट मूल्य होगा), जिसमें उल्लेखनीय संख्या है और उपयोगी गुण, जिसके कारण यह व्यापक हो गया है। दुर्भाग्य से, इसमें कई कमियां भी हैं, जिनमें से एक यह है कि हम सिद्धांत रूप में इस तरह के रिकॉर्ड में नकारात्मक संख्याओं का प्रतिनिधित्व नहीं कर सकते हैं।

आप इस समस्या के समाधान (नकारात्मक संख्याओं का प्रतिनिधित्व) की पेशकश कर सकते हैं, जिनमें से व्यावहारिक महत्व के भी हैं, वे नीचे सूचीबद्ध हैं।

ऑफसेट के साथ एक प्रतिनिधित्व सूत्र H = N2 (n) - ऑफसेट (C) द्वारा वर्णित है, जहां N2 n बिट्स के साथ बाइनरी नोटेशन में प्राप्त संख्या है, और C कुछ पूर्व-चयनित मान है। फिर हम 0-C से 2 ^ (n) -1-C तक संख्याओं का प्रतिनिधित्व करते हैं, और अगर हम C = 2 ^ (n-1) -1 (= 127) चुनते हैं (यह पूरी तरह से वैकल्पिक है, लेकिन बहुत सुविधाजनक है), तो हमें 0- (2 ^ (n-1) -1) (= - 127) से 2 ^ (n-1) (= 128) तक की रेंज मिलती है। इस प्रतिनिधित्व का मुख्य लाभ पूरे अंतराल पर एकरसता (अधिक वृद्धि, वृद्धि) है, इसके नुकसान भी हैं, जिनमें से हम विषमता को उजागर करते हैं (इस प्रतिनिधित्व में संख्या पर प्रदर्शन संचालन की जटिलता से संबंधित अन्य हैं), लेकिन IEEE 457 मानक के डेवलपर्स (यह मानक के लिए मानक है) पीटी) ने इस दोष को एक गुण में बदल दिया (अतिरिक्त मान का उपयोग करके स्थिति को सांकेतिक शब्दों में बदलना), जो एक बार फिर शांत की निष्ठा पर जोर देते हुए कहता है: “यदि आप प्रतिद्वंद्वी से ऊंचे हैं, तो यह आपका फायदा है। यदि विरोधी आपसे अधिक लंबा है, तो यह भी आपका फायदा है। ”

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

प्रत्यक्ष कोड के रूप में प्रतिनिधित्व जब बिट्स में से एक (सबसे महत्वपूर्ण) संख्या एच = (-1) ^ बी (एन -1) * पी (एन -1) की एन्कोडेड संकेत का प्रतिनिधित्व करता है 0- (2 ^ (एन -1) से एक सीमा होती है -1) (= -127) से 2 ^ (एन -1) -1 (= 127)। यह ध्यान रखना दिलचस्प है कि मैंने सिर्फ समरूपता की मौलिक असंभवता की घोषणा की, और यहां यह स्पष्ट रूप से है - अधिकतम प्रतिनिधित्व योग्य सकारात्मक संख्या न्यूनतम प्रतिनिधित्व योग्य नकारात्मक संख्या के मापांक के बराबर है। यह परिणाम शून्य (00 ... 00 और 10 ... 00) के लिए दो अभ्यावेदन होने पर प्राप्त होता है, जिसे आमतौर पर इस पद्धति का मुख्य नुकसान माना जाता है। यह वास्तव में एक खामी है, लेकिन उतना भयानक नहीं है जितना आमतौर पर माना जाता है, क्योंकि अधिक महत्वपूर्ण हैं जो इसके उपयोग को सीमित करते हैं।

उलटा कोड प्रतिनिधित्व, जब प्रत्यक्ष प्रतिनिधित्व में हम नकारात्मक संख्या एच = (1-बी (एन -1)) * पी 2 (एन -1) + बी (एन -1) * (2 ^ (एन) के लिए मूल्य के सभी बिट्स को उल्टा करते हैं। -1) -CH2 (n-1)) - यह परिभाषा से है, आप बहुत अधिक समझने योग्य सूत्र H = Ch2 (n-1) -B (n-1) * (2 ^ (n-1) -1) बना सकते हैं, जो हमें 0-2 ^ (n-1) +1 (= - 127) से 2 ^ (n-1) -1 (= 127) से संख्याओं का प्रतिनिधित्व करने की अनुमति देता है। यह देखा जा सकता है कि यह प्रतिनिधित्व विस्थापित है, लेकिन विस्थापन स्टेप वाइज बदलता है, जो इस प्रतिनिधित्व को एकरस नहीं बनाता है। फिर से, हमारे पास दो शून्य हैं, जो बहुत डरावना नहीं है, इसके अलावा परिपत्र हस्तांतरण की घटना बहुत खराब है, जो एएलयू के कार्यान्वयन में कुछ समस्याएं पैदा करती है।

पिछले प्रतिनिधित्व की अंतिम खामी को समाप्त करना असामान्य रूप से सरल है, यह ऑफसेट को एक से बदलने के लिए पर्याप्त है, फिर हमें = = 22 (n-1) -B (n-1) * 2 ^ (n-1) मिलता है और हम 0-2 ^ (से संख्याओं का प्रतिनिधित्व कर सकते हैं) n-1) (= - 128) से 2 ^ (n-1) -1 (= 127)। यह देखना आसान है कि प्रतिनिधित्व असममित है, लेकिन शून्य अद्वितीय है। महत्वपूर्ण रूप से अधिक दिलचस्प निम्नलिखित संपत्ति है, "यह पूरी तरह से स्पष्ट है कि" रिंग ट्रांसफर एक अतिरिक्त प्रकार के ऑपरेशन के लिए नहीं होता है, जो कि नकारात्मक संख्याओं को एन्कोडिंग के इस विशेष तरीके के सार्वभौमिक वितरण के लिए कारण (अन्य सुखद सुविधाओं के साथ) है।

हमें कोड मान के विभिन्न तरीकों के लिए दिलचस्प मानों की एक तालिका तैयार करें, एच मान 2 ^ (n-1) (128) द्वारा दर्शाते हुए।

बिट्स	00..00	01..11	10..00	11..11
एच (एन)	0	एच -1 (127)	एच (128)	2 * एच -1 (255)
एच (एन -1)	0	एच -1 (127)	0	एच -1 (127)
ऑफसेट। एच	-एच + १ (-१२))	0	1	एच (128)
सीधे	0	एच -1 (127)	0	-एच + १ (-१२))
वापसी	0	एच -1 (127)	-एच + १ (-१२))	0
उन्नत।	0	एच -1 (127)	-एच (-128)	-1

खैर, विषय को समाप्त करने के लिए, हम सूचीबद्ध अभ्यावेदन के लिए ग्राफ देते हैं, जिसमें से उनके फायदे और नुकसान तुरंत दिखाई देते हैं (निश्चित रूप से, वह सब कुछ नहीं जो एक दिलचस्प तानाशाही को याद करता है "जानकारी की चित्रमय प्रस्तुति का लाभ दृश्य है, यह कोई अन्य लाभ नहीं है")।

भाग चार - वास्तव में मूल समस्या को हल करना (कभी देर से बेहतर)।

छोटा विषयांतर

इसके साथ शुरू करने के लिए, मैं पीटी को हेक्साडेसिमल प्रारूप में प्रिंट करना चाहता था (और आखिरकार मैंने ऐसा किया), लेकिन काफी अप्रत्याशित रूप से / पूरी तरह से अप्रत्याशित रूप से (मुझे स्थानापन्न करने की आवश्यकता थी) मैं निम्नलिखित परिणाम पर आया था। आपको क्या लगता है कि ऑपरेटरों को निष्पादित करने के परिणामस्वरूप मुद्रित किया जाएगा:

 printf("%f %x", 1.0,1.0); printf("%f %x",2.0,2.0); printf("%x %d",1.0,1.0); printf("%x %d",2.0,2.0);

, निम्नलिखित निर्माण और उसके परिणाम पर भी ध्यान दें:

 printf("%x %x %f",1.0,1.0);

मैं इस घटना को स्पष्टीकरण नहीं दूंगा, "पर्याप्त चतुर।"

हालांकि, हम पीटी के हेक्साडेसिमल प्रतिनिधित्व को सही ढंग से कैसे प्रिंट करते हैं? पहला समाधान स्पष्ट है - संघ, लेकिन दूसरा एकल-पंक्ति प्रशंसकों के प्रिंटफ ("% x", * ((int *) (& f)) के लिए है; (अगर किसी को अतिरिक्त कोष्ठक द्वारा नाराज किया गया था, तो मैं माफी मांगता हूं, लेकिन मैं कभी नहीं कर सकता था, और कभी नहीं करना चाहता था, संचालन की प्राथमिकताओं को याद रखें, खासकर यह देखते हुए कि कोष्ठक कोड उत्पन्न नहीं करते हैं, इसलिए मैं भी ऐसा ही करता रहूंगा)। और यहाँ यह है, कार्य का समाधान - हम वर्णों की एक स्ट्रिंग देखते हैं, 0x45678, जो विशिष्ट रूप से हमारे लिए वांछित संख्या निर्धारित करते हैं, लेकिन इस तरह से कि हम (मैं आपके बारे में नहीं जानता, मैं निश्चित रूप से) इस संख्या के बारे में कुछ भी समझदारी से नहीं कह सकता। मुझे लगता है कि शिक्षाविद करनाल, जो स्रोत कोड के साथ छिद्रित टेप में एक त्रुटि को इंगित कर सकते थे, ने इस कार्य से निपटा होगा, लेकिन हर कोई इतना उन्नत नहीं है, इसलिए हम जारी रखेंगे।

हम अधिक समझने योग्य रूप में जानकारी प्राप्त करने का प्रयास करेंगे।

ऐसा करने के लिए, हम पीटी (इसके बाद, मैं केवल फ्लोट पर विचार करता हूं) के प्रारूप पर लौटता हूं, जो बिट्स का एक सेट है जिसमें से आप तीन निश्चित संख्याओं का प्रतिनिधित्व करने के लिए बिट्स के तीन सेट निकाल सकते हैं - साइन (एस), मंटिसा (एम) और ऑर्डर (पी), और इन नंबरों से एन्कोड की गई वांछित संख्या निम्न सूत्र द्वारा निर्धारित की जाएगी: Cs * Chm * Chn। यहां, प्रतीक बिट्स के संगत सेट द्वारा दर्शाए गए संख्याओं को निर्दिष्ट करते हैं, इसलिए, वांछित संख्या को खोजने के लिए, हमें उन कानूनों को जानना होगा जिनके द्वारा हम बिट्स के मूल सेट से इन तीन सेटों को निकालते हैं, साथ ही उनमें से प्रत्येक के लिए एन्कोडिंग का प्रकार भी।

इस समस्या को हल करने में, हम IEEE मानक की ओर मुड़ते हैं और पता लगाते हैं कि साइन मूल सेट का एक (सीनियर) बिट है और Cs = (- 1) ^ B (0) को एन्कोडिंग करने का सूत्र है। आदेश अगले 8 उच्च बिट्स पर कब्जा कर लेता है, 127 की ऑफसेट के साथ कोड में लिखा जाता है, और दो की शक्ति का प्रतिनिधित्व करता है, फिर Cn = 2 ^ (C2 (8) -127)। मंटिसा 23 अंकों का अगला क्रम लेती है और Chm = 1 + Ch2 (23) / 2 ^ 23 संख्या का प्रतिनिधित्व करती है।

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

दुर्भाग्य से, हम केवल यात्रा की शुरुआत में हैं, क्योंकि रिकॉर्ड "+ 1.625 * 2 ^ 3" में इस पोस्ट के कुछ पाठक अशुभ संख्या को पहचानते हैं, जो कि अधिक सामान्य दशमलव "13" द्वारा एन्कोड किया गया है, और रिकॉर्ड "1.133125 * 2" में लगता है। ^ 9 "साधारण" 1E3 "या" 1 * 10 ^ 3 "या बहुत परिचित" 1000 "सामान्य रूप से लोगों की इकाइयों में सक्षम हैं, मैं निश्चित रूप से उनसे संबंधित नहीं हूं। यह अजीब है कि यह कैसे हुआ, क्योंकि हमने प्रारंभिक कार्य पूरा किया, जो एक बार फिर दर्शाता है कि आपको योगों का सावधानीपूर्वक इलाज कैसे करना चाहिए। और मुद्दा यह नहीं है कि दशमलव संकेतन द्विआधारी (इस मामले में, ड्यूस डिग्री पर आधारित है) से बेहतर या बदतर है, लेकिन यह कि हमें बचपन से दशमलव का उपयोग किया जाता है और लोगों को रीमेक करना कार्यक्रम की तुलना में बहुत अधिक कठिन है, इसलिए हम अपने अधिक परिचित के लिए प्रवेश।

गणित के दृष्टिकोण से, हमारे पास एक सरल ऑपरेशन है - एक रिकॉर्ड पीटी = (- 1) ^ s * m * 2 ^ n है, और हमें इसे फॉर्म PT = (-1) s '* m' * 10 ^ n 'में बदलने की आवश्यकता है। हम समानता, परिवर्तन और प्राप्त करते हैं (संभावित विकल्पों में से एक) समाधान s '= s', m '= m, n' = n * log (2)। यदि हम कोष्ठक को एक स्पष्ट रूप से अपरिमेय संख्या से गुणा करने की आवश्यकता को छोड़ देते हैं (यह किया जा सकता है यदि संख्या को युक्तिसंगत बनाया गया है, लेकिन हम इस बारे में बाद में बात करेंगे), तो समस्या का समाधान तब तक प्रतीत होता है जब तक हम उत्तर नहीं देखते हैं, क्योंकि यदि रिकॉर्ड "+1.953125 जैसा है" * 2 ^ 9 "हमें अस्पष्ट लगता है, रिकॉर्ड" + 1.953125 * 10 ^ 2.70927 "और भी कम स्वीकार्य है, हालांकि ऐसा लगता था कि कहीं भी बदतर नहीं था।

हम समाधान में सुधार करना जारी रखते हैं और निम्नलिखित समाधान खोजते हैं - बेस डिग्री 10 मीटर '= एम * 10 ^ {एन * लॉग (2)}, एन' = [एन * लॉग (2)], जहां घुंघराले और वर्गाकार तारों को कम करने के समीकरणों को भिन्नात्मक कहते हैं। और क्रमशः एक निश्चित संख्या का पूर्णांक भाग। फिर प्रश्न में उदाहरण के लिए हमें मिलता है (1.953125 * 10 ^ 0.7 0927) * 10 ^ 2 = "10 * 10 ^ 2", जो बहुत अधिक स्वीकार्य है, हालांकि सही नहीं है, लेकिन इसे पहले से ही लागू किया जा सकता है।

बात छोटी है, हमें सीखने की जरूरत है:

पहले से ज्ञात अपरिमेय (लॉग (2)) द्वारा पूर्णांक (एन) को गुणा करें (यह परिणाम की सटीकता पर कुछ प्रतिबंधों के साथ मुश्किल नहीं है);
पूर्णांक और एक निश्चित-बिंदु संख्या के भिन्नात्मक भाग को लें (यह आसान है);
एक ज्ञात पूरे (10) को एक अपरिमेय डिग्री (hmm ...) बढ़ाने के लिए;
एक मनमाना अपरिमेय द्वारा पूरे को गुणा करें ("हम गणना को सरल करेंगे, उन्होंने कहा ...")।

फिर भी, हम इस दिशा में आगे बढ़ने की कोशिश करेंगे और विचार करेंगे कि क्या करना मुश्किल नहीं है, अर्थात् बिंदु 1. हम इस बात पर ध्यान देते हैं कि यह समस्या मौलिक रूप से अस्वीकार्य है और हम n * log (2) की गणना नहीं कर सकते, हम "पूरी तरह से" शब्द से नहीं कर सकते। तुच्छ मामले को छोड़कर n = 0 (अच्छी तरह से, और स्पष्ट मामला n = k / log (10))। एक दिलचस्प बयान, विशेष रूप से बयान के बाद "यह मुश्किल नहीं है", लेकिन स्पष्ट विरोधाभास "एक निश्चित सटीकता के साथ" वाक्यांश द्वारा हटा दिया जाता है। यही है, हम अभी भी एक ज्ञात अपरिमेय के साथ एक मनमाना पूर्णांक के उत्पाद की गणना कर सकते हैं और यह एक निश्चित सटीकता के साथ परिणाम के लिए मुश्किल नहीं है। उदाहरण के लिए, यदि हम एक प्रतिशत की सटीकता के साथ परिणाम में रुचि रखते हैं, तो वांछित परिणाम n '= n * लॉग (2) को n n [[लॉग (2) * 256 + 1/2] / 256 में प्रस्तुत करते हुए हमें उस सटीकता के साथ मान प्राप्त करने की आवश्यकता है ।चूँकि संभव सापेक्ष त्रुटि 1/2/77 = 1/144 से अधिक नहीं हो सकती है, जो स्पष्ट रूप से आवश्यक 1/100 से बेहतर है। एक महत्वपूर्ण विचार को ध्यान में रखा जाना चाहिए - सापेक्ष विचलन का छोटा मूल्य फ़ंक्शन के व्यवहार के बारे में बिल्कुल कुछ नहीं कहता है जब एक गैर-रेखीय परिवर्तन इसे लागू किया जाता है, और पूर्णांक भाग लेने का संचालन स्पष्ट रूप से nonlinear है। हम एक सरल उदाहरण देते हैं [4.501] = 5, और [4.499] = 4 और, इस तथ्य के बावजूद कि स्रोत डेटा में सापेक्ष विचलन 0.002 / 4.5 = 0.04% है, परिणाम का विचलन 1/4 / 25% जितना होगा। दुर्भाग्य से, सामान्य तौर पर, समस्या किसी भी गोलाई एल्गोरिदम का उपयोग करके हल नहीं की जाती है। आप केवल एक विशेष मामले को हल कर सकते हैं जब इनपुट डेटा सीमित हो और, इसके अलावा, मानों का एक निश्चित सेट लें, फिर प्रारंभिक ऑफसेट और झुकाव के कोण को चुनकर, आप बिल्कुल सटीक प्राप्त कर सकते हैं,गोलाई, सन्निकटन के अर्थ में।

हमारे मामले के लिए, इस तरह के एक आदर्श सन्निकटन समारोह n '= n * 77/256 होगा।

एल्गोरिथ्म के डिजाइन के साथ जारी रखने से पहले, हमें उस सटीकता का मूल्यांकन करना चाहिए जो हमें चाहिए। चूंकि मंटिसा 24 बिट है, इसलिए इसका प्रतिनिधित्व किया गया नंबर 2 ^ -24 = 2 ^ -4 * 2 ^ -20 = 16 ^ -1 * (2 ^ 10) ^ - 2 ~ (10) ^ - 1 * (10) की एक सापेक्ष त्रुटि है ^ 3) ^ - 2 = 10 ^ -7, जिसका अर्थ है 7 सटीक दशमलव अंक। इस सीमा में सटीकता बनाए रखने के लिए दो 24-बिट संख्याओं को गुणा करना (अच्छी तरह से, लगभग पर्याप्त) होगा। बस ध्यान दें कि 32 बिट संख्या (दोनों कारक) के लिए संक्रमण 100 से अधिक (256) बार से सापेक्ष त्रुटि को कम करता है, यह तथ्य बाद में काम में आएगा।

सटीकता सूत्र के मामले में सबसे अप्रिय एक नए मंटिसा की गणना करता है और एम '= एम * 10 ^ {एन * लॉग (2%) जैसा दिखता है।

यह सबसे अप्रिय क्यों है - 1) इसमें n के संबंध में गणनाओं की एक श्रृंखला है और त्रुटि जमा हो जाएगी, 2) इसका सटीकता के दृष्टिकोण से एक बेहद खराब संचालन है, और यह भिन्नात्मक भाग नहीं ले रहा है, क्योंकि यदि आप एक साथ पूरे भाग को लेते हैं, तो सब कुछ। इतना बुरा नहीं है, लेकिन एक घातांक है। यदि बाकी के संचालन कई गुना हैं और इस मामले में सापेक्ष त्रुटियां बस जोड़ देती हैं, पूर्वानुमानित हैं और पूरी तरह से ऑपरेंड प्रतिनिधित्व के बिट ग्रिड की लंबाई पर निर्भर करती हैं, तो सब कुछ घातांक के लिए बेहद खराब है और यह पूरी तरह से स्पष्ट है कि तर्क के बड़े मूल्यों के लिए सापेक्ष त्रुटि बहुत बड़ी होगी।

"ठीक है, हाँ, यह स्पष्ट है कि"

q (10 ^ x) = 10 (10 ^ x) / 10 ^ x = (10 ^ (x + Δx) - 10 ^ x) / 10 ^ x = 10 ^ -1x -1 = 10 ^ (x * qx) -1,
10 ^ (x * qx)> ~ 10 ^ (x * 0) + (10 ^ (x * 0)) '* qx = 1 + x * ln (10) * 10 ^ (0) * qx = 1 + x * ln (10) * qx,

यहाँ से हम प्राप्त करते हैं

q (10^{x}) = x * l n (10) * q x .

$q(10^x) = x*ln(10)*qx.$

इस अभिव्यक्ति का मतलब यह है कि मानों की श्रेणी के किनारे पर, n = 127 के साथ, सापेक्ष त्रुटि 292 गुना बढ़ जाएगी और आवश्यक सीमा में परिणाम की सटीकता बनाए रखने के लिए, हमें तर्क की सटीकता को बढ़ाने की आवश्यकता है।

याद रखें कि 24 से 32 बिट्स में संक्रमण हमें सटीकता में आवश्यक वृद्धि देता है (काफी नहीं, लेकिन बहुत करीब), हम समझते हैं कि पहला गुणन (n * लॉग (2)) 32 बिट ऑपरेंड के साथ किया जाना चाहिए, अर्थात् ऐसी सटीकता के साथ। दो का लघुगणक व्यक्त किया जाना चाहिए, फिर यह 1'292'914'005 / 2 ^ 32 के बराबर होगा। ध्यान दें कि कोड में इस स्थिरांक के अंश को (int) ((log (2) * float (2 ^ 32)) + 0.5) के रूप में लिखा जाना चाहिए, लेकिन किसी भी मामले में एक रहस्यमय 0x4d104d42 के रूप में, इसके बारे में एक टिप्पणी के साथ भी नहीं कंप्यूटिंग, क्योंकि अच्छी तरह से लिखा कोड स्व-दस्तावेजीकरण है।

अगला, हमें परिणाम के पूरे भाग की आवश्यकता है, यह मुश्किल नहीं है, क्योंकि हम दोनों कारकों में दशमलव बिंदु की स्थिति को जानते हैं और, परिणामस्वरूप, परिणामस्वरूप।
लेकिन फिर हमें 0 से 1 की शक्ति के लिए 10 की गणना करनी होगी, और यहां हम आवश्यक सटीकता प्राप्त करने के लिए एक छोटी सी चाल का उपयोग करेंगे। चूंकि, त्रुटि के सूत्र के अनुसार, सीमा के दाहिने किनारे पर सटीकता दो से अधिक हो जाती है, तो अगर हम दो के दशमलव के लघुगणक और कुछ शेष के योग के रूप में तर्क के मूल्य का प्रतिनिधित्व करते हैं, n '= = लॉग (2) * i + (n' - log) 2) * i), तब योग का पहला सदस्य 2 से उचित डिग्री तक बढ़ जाएगा, जो कि शून्य त्रुटि (जब तक अतिप्रवाह नहीं होता) के साथ लागू करना आसान है, और शेष एक लॉग (2) के मान से सीमित होगा और हम 10 की गणना में सटीकता नहीं खोएंगे ^ n '' (उचित घटाव के अधीन)।

फिर भी, मूल्य lg (2) द्वारा सीमित तर्क के लिए घातीय फ़ंक्शन को अभी भी गणना करना होगा और मेरे द्वारा देखा जाने वाला एकमात्र तरीका टेलर श्रृंखला में विस्तार है। दुर्भाग्य से, यह हमारी सीमा पर बहुत जल्दी नहीं जुटता है, और उदाहरण के लिए, 10E-7 की सटीकता प्राप्त करने के लिए, हमें योग के 9 सदस्यों की आवश्यकता होती है, जिससे 32 + बिट पूर्णांकों के 1 + 9 * 2 = 19 गुणा करने की आवश्यकता होती है, जो कुछ हद तक है वांछित प्रदर्शन से अधिक है। ऐसी सटीकता के साथ n '= n * log (2) की गणना करने की हमारी क्षमता के बारे में अभी भी अस्पष्ट संदेह हैं कि यह n के अधिकतम मूल्य के लिए पर्याप्त है।

फिर भी, एल्गोरिथ्म काफी कार्यात्मक निकला और परिणाम प्राप्त करने के लिए हमें केवल 32-बिट गुणन की आवश्यकता है। 1 + 19 + 1 = 21 संचालन की मात्रा में जो एल्गोरिथ्म की कम्प्यूटेशनल जटिलता निर्धारित करता है

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

सबसे सरल समाधान - थोड़ी देर के लिए मेमोरी बदलें - सभी संभव के लिए अग्रिम में गणना करें (2 ^ 8 = 256) प्रतिपादक n के संगत मान [n '] (सबसे उपयुक्त घातांक 10) और {n'} (mishissa के लिए सुधारात्मक कारक), उन्हें दर्ज करें गणना प्रक्रिया में तालिका और उसके बाद उपयोग करना आसान है। सूत्र काफी सरल निकला - पीटी = एम * 2 ^ एन = एम * 10 ^ एन '* (2 ^ एन / 10 ^ एन') = (एम * (2 ^ एन / 10 ^ एन '))) * 10 ^ एन '।

सबसे सरल मामले में, हमें 256 * 3 (24 बिट्स का एक सुधार कारक, अब आवश्यकता नहीं है) + 256 * 1 (बेस 10 पर ऑर्डर 2 बेस पर ऑर्डर से कम होने की गारंटी है) = 1kbyte स्थिरांक की आवश्यकता है। इस मामले में, यह हमारे लिए केवल 24 * 24 बिट का एक गुणन करने के लिए रहता है (सबसे अधिक संभावना है कि यह 32 * 32 होगा), जो इस गणना के संस्करण की तुलना में काम को गति देता है।

आइए देखें कि स्मृति को बचाने के दृष्टिकोण से क्या किया जा सकता है (इस मामले में, हमें फिर से समय देना होगा, इसलिए हम एक उचित समझौता की तलाश कर रहे हैं)। सबसे पहले, यदि हम ऑर्डर साइन को अलग से ध्यान में रखते हैं, तो हम आवश्यक मेमोरी के केवल आधे का प्रबंधन कर सकते हैं (ऑर्डर 10 के लिए 256 बाइट में से) और यदि आवश्यक हो तो परिणाम को उल्टा कर सकते हैं। दुर्भाग्य से, सुधार कारक के साथ, यह सिर्फ इतना आसान नहीं होगा, क्योंकि

2 ^ -n / 10 ^ -n '= 1 / (2 ^ n / 10 ^ n')! = 2 ^ n / 10 ^ ',

एक दया।हमें या तो एक लंबी तालिका छोड़नी होगी, या नकारात्मक संकेतकों के लिए, सकारात्मक संकेतकों के लिए एक स्थिर विभाजन करना होगा। बेशक, विभाजन 18 गुणा नहीं है, लेकिन गति में सभी समान यह दो गुणा के बराबर है, इसलिए मेमोरी को दो बार बचाने के लिए 512 बाइट्स तक निश्चित रूप से समय दोगुना हो जाएगा। क्या यह इसके लायक है - सवाल सरल नहीं है, लेकिन, सौभाग्य से, हमारे पास बहुत अधिक सुंदर तरीका है जो हमें पसंद की पीड़ा से छुटकारा पाने की अनुमति देता है।

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

PT = m * 2 ^ n = m * 2 ^ (n0 + n1) = m * 10 ^ n '* (2 ^ (n0 + n1) / 10 ^ n') = m * (2 ^ n0 / 10 ^ n) ') * 2 ^ n1 * 10 ^ n',

जहां n0 कुछ संदर्भ मूल्य है, और n1 = n-n0। फिर नए मंटिसा की गणना एक निश्चित बिंदु के साथ दो संख्याओं को गुणा करके की जाती है, जिसके बाद परिणाम में बदलाव होता है, जो सटीकता को प्रभावित नहीं करता है।

फिर एक वैध सवाल उठता है - हमें आखिरकार एक तालिका की आवश्यकता क्यों है, क्योंकि आप न्यूनतम संकेतक को n0 के रूप में ले सकते हैं और सुधार कारक के सिर्फ एक मूल्य के साथ प्राप्त कर सकते हैं? दुर्भाग्य से, इस तरह के एक दृष्टिकोण दो पूरक परिस्थितियों के कारण प्रतिसंबंधी है - 10 का सबसे उपयुक्त प्रतिपादक प्राप्त करने की आवश्यकता और इस दृष्टिकोण के साथ बहुत लंबी पारियों की उपस्थिति। बाद की परिस्थिति इस तरह की विधि की प्रयोज्यता की सीमा का सुझाव देती है - यदि हम 32 * 32 गुणन करते हैं, और प्रारंभिक मंटिसा में 24 अंक हैं, तो 8 अंकों की एक पारी से अतिप्रवाह नहीं होगा और हमें 8 बाइनरी मानों के लिए एक संदर्भ बिंदु की आवश्यकता होगी।फिर आवश्यक मेमोरी की कुल मात्रा 256/8 * 4 = 32 * 4 = 128 बाइट्स होगी - कार्य के पूरे परिणाम को अधिकतम 8 बिट्स को स्थानांतरित करने की आवश्यकता के कारण निष्पादन समय पर अच्छी मेमोरी बचत।

आप 0 के संबंध में प्रतिपादक की समरूपता के कारण स्थिरांक की मात्रा को कुछ और कम कर सकते हैं, जिसका मैंने पहले उल्लेख किया था, लेकिन बचत 32/2 = 16 बाइट्स होगी, मुझे यकीन नहीं है कि यह प्रोग्राम की जटिलता (और कोड लंबाई में वृद्धि) को सही ठहराएगा।

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

 const UINT8 Bits[] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80}; ... data = data | Bits[n];

एक टिप्पणी के साथ कि AVR पर ऑपरेशन 1 << n को एक लंबा समय लगता है। अपनी पोस्ट में, मैंने पहले ही दिखाया था कि कंपाइलर एक स्थिर पैरामीटर के साथ क्या चमत्कार करता है, लेकिन यह ऐसा नहीं है।

यह मेरे लिए संदेहास्पद लग रहा था कि एक सरणी से बिटमास्क लेना सीधे शिफ्ट ऑपरेशन करने से अधिक तेज़ था, और बाद में कोड विश्लेषण (गॉडबोल्ट वेबसाइट का उपयोग करना, हालांकि यह बहुत कम संभावना नहीं है कि इसका निर्माता हैबर पढ़ेगा, फिर भी एक बार फिर से उसने मेरी ईमानदारी से काम लिया। कृतज्ञता) ने दिखाया कि यह वास्तव में ऐसा है।

दोनों विकल्पों के लिए संकलक द्वारा उत्पन्न कोड (यहां कार्य की विशेषताओं को ध्यान में रखते हुए, पाली के साथ सही विकल्प है, क्योंकि हमें केवल 1 बिट की आवश्यकता है)

  ldi r18,lo8(4) sbrs r25,1 ldi r18,lo8(1) sbrc r25,0 lsl r18 sbrs r25,2 swap r18

मेमोरी में ठीक उसी स्थान पर लिया गया, और यदि आप सब कुछ ध्यान से कोडांतरक में करते हैं, तो सूचकांक के साथ विकल्प 8: 7 के आगे टूट जाता है, कार्यक्रम के अतिरिक्त 8 बाइट्स के कारण (यदि हम उल्टे मास्क के अलग भंडारण के साथ वास्तव में रमणीय समाधान को गंभीरता से नहीं लेते हैं, जिसमें लागत आएगी 16 बाइट्स - और आईटी हर जगह उपयोग किया जाता है - "मुझे पता था कि यह खराब होगा, लेकिन मुझे नहीं पता था कि यह इतनी जल्दी होगा")। खैर, उल्लिखित पैकेज आम तौर पर एक अलग गीत है, जिसे एक अद्भुत पुस्तक से निम्नलिखित उद्धरण द्वारा संभव के रूप में वर्णित किया गया है: "इस महल ने कैप्शन के साथ एक किलेबंदी कवर का अनुरोध किया" महल बनाने या 12 त्रुटियों को खोजने के लिए कैसे नहीं "(" द लास्ट रिंगमैन ", यदि जिसने भी इसे नहीं पढ़ा है, मैं इसकी अनुशंसा करता हूं।)

आइए अपने अस्थायी बिंदु मेढ़े पर वापस जाएं और परिणामी सूत्र का निर्माण करें

पीटी = एम * 2 ^ एन = (एम * पीसी [एन / 8]) * 2 ^ (एन% 8) * 10 ^ एनएन [एन / 8],

जहां वर्ग कोष्ठक का मतलब एरेस के एक तत्व को ले जाना है, संकेतक और एनएन के पीसी-सुधार सूचक क्रम। एल्गोरिथ्म की कम्प्यूटेशनल जटिलता तुरंत दिखाई देती है, जो 32 * 32 (24 * 24) और बाद की पाली को गुणा करके निर्धारित की जाती है। इसके अलावा, आप एक 32-बिट शब्द में 10 के एक घातांक और एक सुधार कारक के संयोजन की संभावना को ध्यान में रख सकते हैं, यह एक जिज्ञासु (और रोगी के बाद, वह अंत में पढ़ा) इस पद के पाठक के हिस्से के लिए छोड़ दिया जाता है।

अंत में एकमात्र टिप्पणी यह है कि जब हम स्थिरांक की एक तालिका बनाएंगे, तो किसी भी स्थिति में हम इसे निम्न शैली के

कॉन्स्ट uint32_t डेटा में नहीं कर सकते [32] PROGMEM = {0xF82345, ...}

और बिंदु, निश्चित रूप से, सरणी के विवरण की विशेषताओं में नहीं है, लेकिन डेटा में ही जादू की संख्या के रूप में है। जैसा कि लेखकों ने ठीक ही कहा है, यह निश्चित रूप से मेरे से कम नहीं है, एक अच्छी तरह से लिखा कोड स्व-दस्तावेजीकरण है और, अगर हम उपरोक्त निरंतर (और बाकी) फॉर्म में लिखते हैं

 #define POWROUD(pow) ((uint8_t)((pow & 0x07)*log(2)+0.5)) #define MULT(pow) (2^pow / 10^POWROUND(pow)) #define MULTRAW(pow) (uint32_t((MULT(pow) << 24) +0.5)) #define BYTEMASK 0xFF #define POWDATA(pow) ((POWROUND(pow) & BYTEMASK)| (MULTRAW(pow) & (~BYTEMASK))) const uint32_t Data[(BYTEMASK/8)+1] = { POWDATA(0x00),POWDATA(0x08), ..POWDATA(0xF8)}

तब कोई भी हमें चिंतित प्रश्न नहीं भेजेगा, और यदि कोई हमें भेजता है, तो हम निश्चित रूप से उनका उत्तर नहीं दे सकते, यह अभी भी बेकार है।

हम इस पद्धति के एक संशोधन का प्रस्ताव कर सकते हैं जिसमें दस की एक उपयुक्त शक्ति की गणना खंड के दाएं किनारे के लिए नहीं की जाएगी, लेकिन बाईं ओर और फिर परिणाम दो की शक्ति को ध्यान में रखते हुए दाईं ओर नहीं, बल्कि बाईं ओर जाएगा। गणित की दृष्टि से, विधियाँ बिल्कुल समकक्ष हैं। परिणाम देखें:

1.953125 * 2 ^ 9 = 1.953125 * 2 ^ (8 + 1) = 1.953125 * 42949673/256/256/256 (2.56) * 2 * 10 = 2 * 10 * 10 ^ 2

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

परिवर्तन और अन्य कार्यों के सवाल पर

भाग एक - पूछताछ

भाग दो - प्राथमिक संचालन का प्रदर्शन मूल्यांकन

भाग तीन - आवश्यक स्पष्टीकरण

भाग चार - वास्तव में मूल समस्या को हल करना (कभी देर से बेहतर)।छोटा विषयांतर

More articles:

भाग चार - वास्तव में मूल समस्या को हल करना (कभी देर से बेहतर)।

छोटा विषयांतर