आईईईई 754 संख्याओं को घटाने के लिए कैसे?

Question

मैं आईईईई 754 नंबरों को कैसे घटा सकता हूं?

उदाहरण के लिए: 0,546875 - 32.875 ...

-> -32.875 1 10,000,111 01000101111000000000000 आईईईई-754

में है -> 0,546875 0 01,111,110 आईईईई-754

में 10001100000000000000000 है

तो मैं घटाव कैसे करूं? मुझे पता है कि मुझे दोनों एक्सपोनेंट बराबर बनाना है लेकिन इसके बाद मैं क्या करूँ? 2'32.875 मंथिसा का पूरक और 0.546875 मंटिसा के साथ जोड़ें?

Answer 1

वास्तव में आप पेंसिल और कागज के साथ ऐसा करने से अलग नहीं हैं। ठीक है थोड़ा अलग

123400 - 5432 = 1.234*10^5 - 5.432*10^3 

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

1.234*10^5 - 0.05432*10^5 

तो mantissas साथ घटाव प्रदर्शन

1.234 - 0.05432 = 1.17968 
1.17968 * 10^5 

फिर सामान्य करें (जो इस मामले में है)

आधार 10 संख्या के साथ था।

आईईईई नाव में, एकल परिशुद्धता

123400 = 0x1E208 = 0b11110001000001000 
11110001000001000.000... 

सामान्य हम 16 स्थानों इसलिए छोड़ दिया

1.1110001000001000 * 2^16 

प्रतिपादक पक्षपाती है तो हम 16 के लिए 127 जोड़ सकते हैं और करने के लिए दशमलव स्थान शिफ्ट करने के लिए है कि 143 = 0x8F प्राप्त करें।यह एक सकारात्मक संख्या है इसलिए साइन बिट 0 है, हम आईईईई फ्लोटिंग पॉइंट नंबर को अग्रणी 1 बनाने के लिए शुरू करते हैं, दशमलव को इंगित करने से पहले और एकल परिशुद्धता में उपयोग नहीं किया जाता है, हम इससे छुटकारा पा सकते हैं और अंश

संकेत बिट, प्रतिपादक, अपूर्णांश

0 10001111 1110001000001000... 
0100011111110001000001000... 
0100 0111 1111 0001 0000 0100 0... 
0x47F10400 

और आप एक प्रोग्राम लिखने यदि क्या एक कंप्यूटर बातें 123,400 आप एक ही बात मिलता है देखने के लिए:

0x47F10400 123400.000000 

तो हम पहले के लिए प्रतिपादक और अपूर्णांश पता ऑपरेंड '

अब दूसरा संकार्य

5432 = 0x1538 = 0b0001010100111000 

मानक के अनुसार, बदलाव दशमलव 12 बिट्स छोड़ दिया

1010100111000.000 
1.010100111000000 * 2^12 

प्रतिपादक 127 जोडें और 139 = 0x8B = 0b10001011

यह सब एक साथ रखो पक्षपाती है

0 10001011 010100111000000 
010001011010100111000000 
0100 0101 1010 1001 1100 0000... 
0x45A9C00 

और एक कंप्यूटर प्रोग्राम/कंपाइलर एक ही

0x45A9C000 5432.000000 

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

0 10001111 111100010000010000000000 - 0 10001011 101010011100000000000000 

हम सिर्फ ग्रेड स्कूल में की तरह हमारे दशमलव स्थानों को पंक्तिबद्ध करने से पहले हम इस संदर्भ में तो घटाना कर सकते हैं आप अंत बंद अपूर्णांश बिट्स घालना तक एक्स्पोनेंट्स से मेल

0 10001111 111100010000010000000000 - 0 10001011 101010011100000000000000 
0 10001111 111100010000010000000000 - 0 10001100 010101001110000000000000 
0 10001111 111100010000010000000000 - 0 10001101 001010100111000000000000 
0 10001111 111100010000010000000000 - 0 10001110 000101010011100000000000 
0 10001111 111100010000010000000000 - 0 10001111 000010101001110000000000 

अब हम mantissas घटाना कर सकते हैं, छोटे प्रतिपादक संख्या सही शिफ्ट करने के लिए किया है। यदि साइन बिट्स मेल खाते हैं तो हम वास्तव में घटाना चाहते हैं अगर वे मेल नहीं खाते तो हम जोड़ते हैं। वे मेल खाते हैं यह एक घटाव होगा।

      1 
    111100010000010000000000 
+ 111101010110001111111111 
========================== 

और अब बस के साथ कागज और पेंसिल प्रदर्शन करते हैं जैसे:

कंप्यूटर, इसके अलावा तर्क का प्रयोग योजक में रास्ते पर दूसरे ऑपरेटर inverting और बिट में कैरी जोर देते हुए, इस तरह से एक घटाव प्रदर्शन अपने कैलकुलेटर पर हेक्स साथ

1111000100000111111111111 
    111100010000010000000000 
+ 111101010110001111111111 
========================== 
    111001100110100000000000 

जोड़ सकते हैं या यह कर

111100010000010000000000 = 1111 0001 0000 0100 0000 0000 = 0xF10400 
111101010110001111111111 = 1111 0101 0110 0011 1111 1111 = 0xF563FF 
0xF10400 + 0xF563FF + 1 = 0x1E66800 
1111001100110100000000000 =1 1110 0110 0110 1000 0000 0000 = 0x1E66800 

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

बहुत जल्दी से एक और तरीका है कि देखते हैं, बजाय inverting और एक जोड़ने सिर्फ एक कैलकुलेटर का उपयोग करने देता

111100010000010000000000 - 000010101001110000000000 = 
0xF10400 - 0x0A9C00 = 
0xE66800 

यह कल्पना करने के लिए मैं शायद यह बदतर बना दिया की कोशिश कर रहा द्वारा की सुविधा देता है। मंथिसा घटाने का नतीजा 111001100110100000000000 (0xE66800) है, इस मामले में 24 बिट संख्या के साथ समाप्त होने वाले सबसे महत्वपूर्ण बिट में कोई आंदोलन नहीं था। 1 सामान्यीकरण के साथ। सामान्य करने के लिए आपको मंथिसा को बाएं या दाएं स्थानांतरित करने की आवश्यकता है जब तक कि 24 बिट्स लाइनों को सबसे महत्वपूर्ण स्थिति में सबसे महत्वपूर्ण स्थिति में छोड़ दें, प्रत्येक बिट शिफ्ट के लिए एक्सपोनेंट समायोजित करें।

अब अलग करना जवाब बंद 1. बिट हम आपको यह करने के लिए एक कार्यक्रम लिख कर अपने साथ निम्नलिखित किया गया है भागों को एक साथ

0 10001111 11001100110100000000000 
01000111111001100110100000000000 
0100 0111 1110 0110 0110 1000 0000 0000 
0x47E66800 

शब्दों में कहें, मैं के रूप में अच्छा प्रदर्शन किया। यह कार्यक्रम एक अनुचित तरीके से संघ का उपयोग करके सी मानक का उल्लंघन करता है। मैं अपने कंप्यूटर पर अपने कंपाइलर के साथ इसके साथ दूर हो गया, यह हर समय काम करने की उम्मीद नहीं है।

#include <stdio.h> 

union 
{ 
    float f; 
    unsigned int u; 
} myun; 


int main (void) 
{ 
    float a,b,c; 

    a=123400; 
    b= 5432; 

    c=a-b; 

    myun.f=a; printf("0x%08X %f\n",myun.u,myun.f); 
    myun.f=b; printf("0x%08X %f\n",myun.u,myun.f); 
    myun.f=c; printf("0x%08X %f\n",myun.u,myun.f); 

    return(0); 
} 

और हमारे परिणाम उपरोक्त कार्यक्रम के उत्पादन से मेल खाता है, हम एक 0x47E66800 हाथ

0x47F10400 123400.000000 
0x45A9C000 5432.000000 
0x47E66800 117968.000000 

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

तो:

1) भागों, हस्ताक्षर, प्रतिपादक, अपूर्णांश निकालें।

2) सबसे छोटी प्रतिपादक के साथ नंबर से अपूर्णांश बिट्स का त्याग करके अपने दशमलव स्थानों संरेखित, जब तक एक्स्पोनेंट्स

3 से मेल खाते हैं सही करने के लिए कि mantissa शिफ्ट) एक घटाना आपरेशन किया जा रहा है, तो संकेत बिट्स तो एक ही हैं यदि आप संकेत बिट्स अलग हैं तो आप एक घटिया प्रदर्शन करते हैं, आप मंटिसस का एक जोड़ करते हैं।

4) यदि परिणाम शून्य तो आपका जवाब एक शून्य है, शून्य परिणाम के रूप में के लिए सांकेतिक शब्दों में बदलना आईईईई मूल्य, अन्यथा:

5) संख्या को सामान्य, (दाएं या बाएं का जवाब बदलाव उत्तर 24 बिट एड/घटाव से 25 बिट्स हो सकता है, जोड़/घटाकर सामान्य करने के लिए नाटकीय बदलाव हो सकता है, या तो एक दाएं या बाएं से कई बिट्स) जब तक कि आपके पास 24 बिट नंबर नहीं है, जो कि सबसे महत्वपूर्ण एक उचित है। 24 बिट्स एकल परिशुद्धता फ्लोट के लिए है। सामान्यीकरण को परिभाषित करने का अधिक सही तरीका बाएं या दाएं स्थानांतरित करना है जब तक कि संख्या जैसा दिखता है 1. कुछ नहीं। अगर आपके पास 0.001 था तो आप बाएं 3 को बदल देंगे, अगर आपके पास 11.10 था तो आप सही स्थानांतरित करेंगे 1. एक शिफ्ट बायीं ओर आपके एक्सपोनेंट को बढ़ाता है, एक शिफ्ट सही हो जाता है। जब हम पूर्णांक से ऊपर फ़्लोट करने के लिए परिवर्तित किया गया से अलग नहीं है।

6) एकल परिशुद्धता के लिए अग्रणी 1 को हटा दें। मंटिसा से, यदि एक्सपोनेंट बह गया है तो आप सिग्नलिंग नैन बनाने में आते हैं। यदि साइन बिट अलग थे और आपने एक ऐड किया था, तो आपको परिणाम साइन बिट को समझने के साथ निपटना होगा। यदि उपर्युक्त सबकुछ ठीक है तो आप परिणाम

गुणा करें और विभाजन अलग है, तो आपने सबकुछ ठीक करने के बारे में पूछा है, इसलिए सब कुछ ठीक है।