दशमलव, फ्लोट और .NET में डबल के बीच अंतर?

Question

बीच क्या अंतर है decimal, floatऔर double.NET में?

इनमें से कोई कब इस्तेमाल करेगा?

Comments

दिलचस्प लेख zetcode.com/lang/csharp/datatypes

— गिब्बो मार्क

सम्बंधित: sandbox.mc.edu/~bennet/cs110/flt/dtof.html

— पेसियर

Answer 1

floatऔर doubleकर रहे हैं चल बाइनरी बिंदु प्रकार । दूसरे शब्दों में, वे इस तरह एक संख्या का प्रतिनिधित्व करते हैं:

10001.10010110011

बाइनरी नंबर और बाइनरी पॉइंट का स्थान दोनों मूल्य के भीतर एन्कोडेड हैं।

decimalएक अस्थायी दशमलव बिंदु प्रकार है । दूसरे शब्दों में, वे इस तरह एक संख्या का प्रतिनिधित्व करते हैं:

12345.65789

फिर, दशमलव बिंदु की संख्या और स्थान दोनों मूल्य के भीतर एन्कोडेड हैं - यही वह है जो decimalस्थिर बिंदु प्रकार के बजाय अभी भी एक अस्थायी बिंदु प्रकार बनाता है ।

ध्यान देने वाली महत्वपूर्ण बात यह है कि मनुष्यों का उपयोग दशमलव रूप में गैर-पूर्णांक का प्रतिनिधित्व करने के लिए किया जाता है, और दशमलव प्रतिनिधित्व में सटीक परिणामों की अपेक्षा करता है; बाइनरी फ़्लोटिंग पॉइंट - 0.1 में सभी दशमलव संख्याएँ बिल्कुल प्रतिनिधित्व करने योग्य नहीं हैं, उदाहरण के लिए - इसलिए यदि आप बाइनरी फ़्लोटिंग पॉइंट वैल्यू का उपयोग करते हैं, तो आप वास्तव में 0.1 के लिए एक अनुमान प्राप्त करेंगे। फ़्लोटिंग दशमलव बिंदु का उपयोग करते समय आपको अभी भी सन्निकटन मिलेंगे - उदाहरण के लिए 1 को 3 से विभाजित करने के परिणाम का बिल्कुल प्रतिनिधित्व नहीं किया जा सकता है।

क्या जब उपयोग करने के लिए के रूप में:

• उन मूल्यों के लिए जो "स्वाभाविक रूप से सटीक दशमलव" हैं, यह उपयोग करना अच्छा है decimal। यह आमतौर पर मनुष्यों द्वारा आविष्कृत किसी भी अवधारणा के लिए उपयुक्त है: वित्तीय मूल्य सबसे स्पष्ट उदाहरण हैं, लेकिन अन्य भी हैं। उदाहरण के लिए, गोताखोरों या आइस स्केटर्स को दिए गए स्कोर पर विचार करें।

• उन मूल्यों के लिए जो प्रकृति के अधिक कलाकृतियाँ हैं जिन्हें वास्तव में वैसे भी मापा नहीं जा सकता है , float/ doubleअधिक उपयुक्त हैं। उदाहरण के लिए, वैज्ञानिक डेटा को आमतौर पर इस रूप में दर्शाया जाएगा। यहाँ, मूल मानों को "दशमलव के साथ सटीक" शुरू नहीं किया जाएगा, इसलिए "दशमलव सटीकता" बनाए रखने के लिए अपेक्षित परिणामों के लिए यह महत्वपूर्ण नहीं है। दशमलव की तुलना में काम करने के लिए फ्लोटिंग बाइनरी पॉइंट प्रकार बहुत तेज़ हैं।

Comments

float/ doubleआमतौर पर संख्याओं का प्रतिनिधित्व नहीं करते हैं 101.101110, आम तौर पर इसे कुछ के रूप में दर्शाया जाता है 1101010 * 2^(01010010)- एक घातांक

— मिंगवेई सैम्युअल

@ हैज़र्ड: यही कारण है कि "और द्विआधारी बिंदु का स्थान" उत्तर का मतलब है।

— जॉन स्कीट

मुझे आश्चर्य है कि यह पहले से ही नहीं कहा गया है, floatएक C # उपनाम है और एक .Net प्रकार नहीं है। यह System.Single.. singleऔर doubleद्विआधारी बिंदु प्रकार तैर रहे हैं।

— ब्रेट कैसवेल

@BKSpurgeon: ठीक है, केवल उसी तरीके से कि आप कह सकते हैं कि सब कुछ एक द्विआधारी प्रकार है, जिस बिंदु पर यह एक काफी बेकार परिभाषा बन जाती है। दशमलव एक दशमलव प्रकार है जिसमें यह एक पूर्णांक महत्व और पैमाने के रूप में दर्शाया जाता है, जैसे कि परिणाम का महत्व * 10 ^ स्केल है, जबकि फ्लोट और डबल का महत्व * 2 ^ स्केल है। आप दशमलव में लिखे गए एक नंबर को लेते हैं, और दशमलव बिंदु को उस दाईं ओर ले जाते हैं, जो आपको एक पूर्णांक मिला है, जो कि महत्व और पैमाने पर काम करता है। फ्लोट / डबल के लिए आप बाइनरी में लिखे नंबर से शुरू करेंगे।

— जॉन स्कीट

एक और अंतर: फ्लोट 32-बिट; डबल 64-बिट; और दशमलव 128-बिट।

— डेविड

Answer 2

परिशुद्धता मुख्य अंतर है।

फ्लोट - 7 अंक (32 बिट)

डबल -15-16 अंक (64 बिट)

दशमलव -28-29 महत्वपूर्ण अंक (128 बिट)

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

दशमलव और फ़्लोट्स / डबल्स की तुलना बिना कास्ट के नहीं की जा सकती है जबकि फ़्लोट्स और डबल्स कर सकते हैं। दशमलव भी एन्कोडिंग या अनुगामी शून्य की अनुमति देता है।

float flt = 1F/3;
double dbl = 1D/3;
decimal dcm = 1M/3;
Console.WriteLine("float: {0} double: {1} decimal: {2}", flt, dbl, dcm);

परिणाम :

float: 0.3333333  
double: 0.333333333333333  
decimal: 0.3333333333333333333333333333

Comments

@ क्रोकोडाइलहंटर: क्षमा करें, लेकिन नहीं। दशमलव उन सभी संख्याओं का प्रतिनिधित्व कर सकता है जिन्हें दशमलव संकेतन में दर्शाया जा सकता है, लेकिन उदाहरण के लिए 1/3 नहीं। 1.0 मी / 3.0 मी 0.33333333 पर मूल्यांकन करेगा ... अंत में 3 एस की एक बड़ी लेकिन परिमित संख्या के साथ। इसे 3 से गुणा करने पर सटीक 1.0 वापस नहीं आएगा।

— एरिक पी।

@ क्रोकोडाइलहंटर: मुझे लगता है कि आप सटीकता और सटीकता को भ्रमित कर रहे हैं। वे इस संदर्भ में अलग-अलग चीजें हैं। किसी संख्या का प्रतिनिधित्व करने के लिए सटीक संख्या उपलब्ध अंक है। अधिक सटीक, आपको कम करने की आवश्यकता है। किसी भी डेटा प्रकार में अनंत परिशुद्धता नहीं है।

— Igby Largeman

@ Thecrocodilehunter: आप मान रहे हैं कि जिस मूल्य को मापा जा रहा है, वह बिल्कुल वैसा 0.1 ही है - वास्तविक दुनिया में शायद ही ऐसा हो! किसी भी परिमित भंडारण प्रारूप बिट मूल्यों के परिमित संख्या के लिए संभावित मूल्यों की एक अनंत संख्या का पता लगाएगा। उदाहरण के लिए, floatconflate जाएगा 0.1और 0.1 + 1e-8है, जबकि decimalconflate जाएगा 0.1और 0.1 + 1e-29। निश्चित रूप से, दी गई सीमा के भीतर , कुछ मूल्यों को सटीकता के शून्य नुकसान के साथ किसी भी प्रारूप में दर्शाया जा सकता है (जैसे floatकि सटीकता के शून्य नुकसान के साथ 1.6e7 तक किसी भी पूर्णांक को संग्रहीत कर सकते हैं) - लेकिन यह अभी भी अनंत सटीकता नहीं है।

— डैनियल प्राइडेन

@ क्रोकोडाइलहंटर: आपने मेरी बात को याद किया। 0.1है एक विशेष मूल्य नहीं ! केवल एक चीज जो 0.1"से बेहतर" बनाती है 0.10000001, क्योंकि मानव आधार 10 पसंद करता है। और यहां तक ​​कि एक floatमान के साथ , यदि आप 0.1एक ही तरह से दो मूल्यों को शुरू करते हैं, तो वे दोनों समान मूल्य होंगे । यह सिर्फ इतना है कि मूल्य बिल्कुल नहीं होगा 0.1- यह निकटतम मूल्य होगा 0.1जो बिल्कुल एक के रूप में प्रतिनिधित्व किया जा सकता हैfloat । ज़रूर, बाइनरी फ़्लोट्स के साथ (1.0 / 10) * 10 != 1.0, लेकिन दशमलव फ़्लोट्स के साथ, (1.0 / 3) * 3 != 1.0या तो। न ही पूरी तरह से सटीक है।

— डैनियल प्राइडेन

@ क्रोकोडाइलहंटर: आप अभी भी नहीं समझे। मैं नहीं जानता कि यह कैसे और अधिक स्पष्ट रूप से कहना है: सी में, यदि आप करते हैं double a = 0.1; double b = 0.1;तो a == b सच होगा । यह सिर्फ इतना है aऔर दोनों बिल्कुल समान नहीं bहोंगे । C # में, अगर आप करते हैं तो यह भी सच होगा। लेकिन उस मामले में, न की और न ही होगा बिल्कुल बराबर - वे दोनों बराबर । में दोनों मामलों में, कुछ सटीकता प्रतिनिधित्व की वजह से खो दिया है। आप हठपूर्वक कहते हैं कि "अनंत" सटीक है, जो गलत है । 0.1decimal a = 1.0m / 3.0m; decimal b = 1.0m / 3.0m;a == bab1/30.3333...decimal

— डैनियल प्राइडेन

Answer 3

दशमलव संरचना को सटीकता की आवश्यकता वाले वित्तीय गणना के लिए कड़ाई से तैयार किया जाता है, जो कि गोलाई के अपेक्षाकृत असहिष्णु हैं। हालांकि, वैज्ञानिक अनुप्रयोगों के लिए दशमलव कई कारणों से पर्याप्त नहीं हैं:

• सटीक की एक निश्चित हानि कई वैज्ञानिक गणनाओं में स्वीकार्य है क्योंकि शारीरिक समस्या या विरूपण साक्ष्य की व्यावहारिक सीमा को मापा जाता है। वित्त में शुद्धता का नुकसान स्वीकार्य नहीं है।
• दशमांश ज्यादातर कार्यों के लिए फ्लोट और डबल की तुलना में बहुत अधिक (धीमा) होता है, मुख्यतः क्योंकि फ्लोटिंग पॉइंट ऑपरेशन बाइनरी में किया जाता है, जबकि दशमलव सामान बेस 10 में किया जाता है (अर्थात फ्लोट और डबल्स को FPU हार्डवेयर द्वारा नियंत्रित किया जाता है, जैसे MMX / SSE) , जबकि दशमलव सॉफ्टवेयर में गणना की जाती है)।
• दशमलव में डबल की तुलना में अस्वीकार्य रूप से छोटी मान सीमा होती है, इस तथ्य के बावजूद कि यह सटीकता के अधिक अंकों का समर्थन करता है। इसलिए, कई वैज्ञानिक मूल्यों का प्रतिनिधित्व करने के लिए दशमलव का उपयोग नहीं किया जा सकता है।

Comments

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

— जेम्स मूर

Answer 4

+---------+----------------+---------+----------+---------------------------------------------+
| C#      | .Net Framework | Signed? | Bytes    | Possible Values                             |
| Type    | (System) type  |         | Occupied |                                             |
+---------+----------------+---------+----------+---------------------------------------------+
| sbyte   | System.Sbyte   | Yes     | 1        | -128 to 127                                 |
| short   | System.Int16   | Yes     | 2        | -32768 to 32767                             |
| int     | System.Int32   | Yes     | 4        | -2147483648 to 2147483647                   |
| long    | System.Int64   | Yes     | 8        | -9223372036854775808 to 9223372036854775807 |
| byte    | System.Byte    | No      | 1        | 0 to 255                                    |
| ushort  | System.Uint16  | No      | 2        | 0 to 65535                                  |
| uint    | System.UInt32  | No      | 4        | 0 to 4294967295                             |
| ulong   | System.Uint64  | No      | 8        | 0 to 18446744073709551615                   |
| float   | System.Single  | Yes     | 4        | Approximately ±1.5 x 10-45 to ±3.4 x 1038   |
|         |                |         |          |  with 7 significant figures                 |
| double  | System.Double  | Yes     | 8        | Approximately ±5.0 x 10-324 to ±1.7 x 10308 |
|         |                |         |          |  with 15 or 16 significant figures          |
| decimal | System.Decimal | Yes     | 12       | Approximately ±1.0 x 10-28 to ±7.9 x 1028   |
|         |                |         |          |  with 28 or 29 significant figures          |
| char    | System.Char    | N/A     | 2        | Any Unicode character (16 bit)              |
| bool    | System.Boolean | N/A     | 1 / 2    | true or false                               |
+---------+----------------+---------+----------+---------------------------------------------+

अधिक जानकारी के लिए यहाँ देखें ।

Comments

आपने सबसे बड़े अंतर को छोड़ दिया, जो दशमलव प्रकार के लिए उपयोग किया जाने वाला आधार है (दशमलव को आधार 10 के रूप में संग्रहीत किया जाता है, सूचीबद्ध अन्य सभी संख्यात्मक प्रकार 2 साल के हैं)।

— BrainSlugs83

सिंगल और डबल के लिए मूल्य सीमाएं उपरोक्त छवि या स्रोत फ़ोरम पोस्ट में सही ढंग से चित्रित नहीं की गई हैं। चूँकि हम यहाँ आसानी से पाठ को सुपरस्क्रिप्ट नहीं कर सकते, कैरेट वर्ण का उपयोग करें: सिंगल 10 ^ -45 और 10 ^ 38 होना चाहिए, और डबल 10 ^ -324 और 10 ^ 308 होना चाहिए। इसके अलावा, MSDN के पास फ्लोट -3.4x10 ^ 38 से + 3.4x10 ^ 38 है। लिंक के मामले में System.Single और System.Double के लिए MSDN खोजें। एकल: msdn.microsoft.com/en-us/library/b1e65aza.aspx डबल: msdn.microsoft.com/en-us/library/678hzkk9.aspx

— deegee

दशमलव 128 बिट है ... इसका मतलब यह है कि 16 बाइट्स 12 नहीं

— user1477332

Answer 5

मैं अन्य उत्तर और टिप्पणियों में पहले से वर्णित अच्छी (और कुछ बुरी) जानकारी को दोहरा नहीं सकता, लेकिन मैं आपके टिप प्रश्न का उत्तर एक टिप के साथ दूंगा:

इनमें से कोई कब इस्तेमाल करेगा?

गिने गए मानों के लिए दशमलव का उपयोग करें

मापा मूल्यों के लिए फ्लोट / डबल का उपयोग करें

कुछ उदाहरण:

• पैसा (क्या हम पैसा गिनते हैं या पैसा मापते हैं?)

• दूरी (क्या हम दूरी या माप दूरी की गणना करते हैं? *)

• स्कोर (क्या हम स्कोर की गणना करते हैं या स्कोर मापते हैं?)

हम हमेशा पैसे गिनते हैं और इसे कभी नहीं मापना चाहिए। हम आमतौर पर दूरी को मापते हैं। हम अक्सर स्कोर गिनते हैं।

* कुछ मामलों में, जिसे मैं नाममात्र की दूरी कहूंगा , हम वास्तव में दूरी की 'गणना' करना चाहते हैं। उदाहरण के लिए, हो सकता है कि हम उन देश चिह्नों के साथ काम कर रहे हैं जो शहरों की दूरियां दिखाते हैं, और हम जानते हैं कि उन दूरियों में कभी भी एक से अधिक दशमलव अंक (xxx.x किमी) नहीं होते हैं।

Comments

मुझे वास्तव में यह उत्तर पसंद है, विशेष रूप से सवाल "क्या हम पैसे की गणना या माप करते हैं?" हालांकि, पैसे के अलावा, मैं कुछ भी नहीं सोच सकता हूं जो "गिना" गया है जो कि केवल पूर्णांक नहीं है। मैंने कुछ अनुप्रयोगों को देखा है जो केवल दशमलव का उपयोग करते हैं क्योंकि डबल में बहुत कम महत्वपूर्ण अंक हैं। दूसरे शब्दों में, दशमलव क्योंकि सी # एक नहीं है इस्तेमाल किया जा सकता चौगुनी प्रकार en.wikipedia.org/wiki/Quadruple-precision_floating-point_format

— जॉन Henckel

Answer 6

float परिशुद्धता के 7 अंक

double सटीक के लगभग 15 अंक हैं

decimal परिशुद्धता के बारे में 28 अंक है

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

मैंने पाया कि यह दिलचस्प है। फ्लोटिंग-पॉइंट अंकगणित के बारे में हर कंप्यूटर वैज्ञानिक को क्या जानना चाहिए

Comments

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

— सुपरकैट

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

— पाल

लेखांकन अनुप्रयोगों में @supercat डबल कभी भी उचित नहीं है । क्योंकि डबल केवल दशमलव मानों (यहां तक ​​कि अपनी परिशुद्धता की सीमा के भीतर) कर सकता है। ऐसा इसलिए है क्योंकि आधार -2 (बाइनरी) -सेंट्रिक प्रारूप में मूल्यों को दोगुना करता है।

— BrainSlugs83

@ BrainSlugs83: गैर-पूर्ण-संख्या मात्रा रखने के लिए फ़्लोटिंग-पॉइंट प्रकारों का उपयोग अनुचित होगा, लेकिन भाषाओं के लिए यह ऐतिहासिक रूप से बहुत सामान्य था कि फ़्लोटिंग-पॉइंट प्रकार जो अपने पूर्णांक प्रकारों की तुलना में बड़े पूर्ण-संख्या मानों का ठीक-ठीक प्रतिनिधित्व कर सकें। । शायद सबसे चरम उदाहरण टर्बो -87 था जिसका केवल पूर्णांक प्रकार -32768 से +32767 तक सीमित था, लेकिन जिसका RealIIRC इकाई परिशुद्धता के साथ 1.8E + 19 तक मूल्यों का प्रतिनिधित्व कर सकता है। मुझे लगता है कि यह एक लेखांकन अनुप्रयोग के लिए Realपैसे की एक पूरी संख्या का प्रतिनिधित्व करने के लिए उपयोग करने के लिए बहुत ही

— पवित्र होगा

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

— सुपरकैट

Answer 7

जिसका किसी ने उल्लेख नहीं किया है

डिफ़ॉल्ट सेटिंग्स में, फ़्लोट्स (System.Single) और डबल्स (System.Double) कभी भी ओवरफ़्लो जाँच का उपयोग नहीं करेगा, जबकि दशमलव (System.Decimal) हमेशा ओवरफ़्लो जाँच का उपयोग करेगा।

मेरा मतलब

decimal myNumber = decimal.MaxValue;
myNumber += 1;

फेंकता है OverflowException ।

लेकिन ये नहीं हैं:

float myNumber = float.MaxValue;
myNumber += 1;

और

double myNumber = double.MaxValue;
myNumber += 1;

Comments

float.MaxValue+1 == float.MaxValue, बस decimal.MaxValue+0.1D == decimal.MaxValue। शायद आपका मतलब कुछ ऐसा था float.MaxValue*2?

— सुपरकैट

@ सिक्सरकार लेकिन यह सच नहीं है कि दशमलव। maxValue + 1 == दशमलव। maxValue

— गोरक्षमूलु

@ सिक्सरकार दशमलव। मैक्वल्यू + 0.1 एम == दशमलव। मैक्वल्यू ओके

— गोर्कमहलू

System.Decimalएक अपवाद बस से पहले ही पूरे इकाइयों भेद करने में असमर्थ हो जाता है फेंकता है, लेकिन एक आवेदन जैसे डॉलर और सेंट, कि बहुत देर हो चुकी हो सकता है के साथ काम कर होना चाहिए किया जाता है।

— सुपरकैट

Answer 8

1. संकलन और रन टाइम दोनों पर बिना किसी अपवाद के डबल और फ्लोट को पूर्णांक शून्य से विभाजित किया जा सकता है।
2. दशमलव को पूर्णांक शून्य से विभाजित नहीं किया जा सकता है। यदि आप ऐसा करते हैं तो संकलन हमेशा विफल रहेगा।

Comments

उन्हें यकीन है कि कर सकते हैं! उनके पास इन्फिनिटी, नेगेटिव इन्फिनिटी, और NaN (नंबर नहीं) जैसे "जादू" मूल्यों की एक जोड़ी है, जो ढलानों की गणना करते समय खड़ी रेखाओं का पता लगाने के लिए इसे बहुत उपयोगी बनाते हैं ... आगे, यदि आपको कॉलिंग फ्लोट के बीच निर्णय लेने की आवश्यकता है .TryParse, double.TryParse, और दशमलव। TryParse (यह पता लगाने के लिए कि क्या एक स्ट्रिंग एक संख्या है, उदाहरण के लिए), मैं डबल या फ्लोट का उपयोग करने की सलाह देता हूं, क्योंकि वे "इन्फिनिटी", "-इनफिनिटी" और "NaN" को ठीक से पार्स करेंगे। , जबकि दशमलव नहीं होगा।

— BrainSlugs83

यदि आप शाब्दिक रूप decimalसे शून्य (CS0020) से विभाजित करने का प्रयास करते हैं, तो संकलन विफल हो जाता है , और अभिन्न शाब्दिकों का भी यही हाल है। हालाँकि, यदि रनटाइम दशमलव मान शून्य से विभाजित होता है, तो आपको एक अपवाद मिलेगा, संकलन त्रुटि नहीं।

— ड्रू नोक

@ BrainSlugs83 हालांकि, आप संदर्भ के आधार पर "इन्फिनिटी" या "NaN" पार्स नहीं करना चाहते हैं। उपयोगकर्ता इनपुट के लिए एक अच्छा शोषण की तरह लगता है अगर विकासक पर्याप्त कठोर नहीं है।

— विंटर

Answer 9

पूर्णांक, जैसा कि उल्लेख किया गया था, पूरे नंबर हैं। वे बिंदु को कुछ स्टोर नहीं कर सकते, जैसे .7, .42, और .007। यदि आपको ऐसी संख्याएँ संग्रहीत करने की आवश्यकता है जो पूरी संख्याएँ नहीं हैं, तो आपको एक भिन्न प्रकार के चर की आवश्यकता होगी। आप डबल प्रकार या फ्लोट प्रकार का उपयोग कर सकते हैं। आप इस प्रकार के चर को ठीक उसी तरह सेट करते हैं: शब्द का उपयोग करने के बजाय int, आप टाइप करते हैं doubleया float। ऐशे ही:

float myFloat;
double myDouble;

( float"फ्लोटिंग पॉइंट" के लिए संक्षिप्त है, और अंत में एक बिंदु के साथ एक संख्या का मतलब है।)

दोनों के बीच का अंतर उन संख्याओं के आकार में है जिन्हें वे पकड़ सकते हैं। इसके लिए float, आपकी संख्या में 7 अंक तक हो सकते हैं। के लिए doubleहै, आप 16 अंक से ऊपर हो सकता है। अधिक सटीक होने के लिए, यहां आधिकारिक आकार है:

float:  1.5 × 10^-45  to 3.4 × 10^38  
double: 5.0 × 10^-324 to 1.7 × 10^308

floatएक 32-बिट संख्या है, और double64-बिट संख्या है।

कोड पर पाने के लिए अपने नए बटन पर डबल क्लिक करें। निम्नलिखित तीन पंक्तियों को अपने बटन कोड में जोड़ें:

double myDouble;
myDouble = 0.007;
MessageBox.Show(myDouble.ToString());

अपने कार्यक्रम को रोकें और कोडिंग विंडो पर वापस लौटें। इस पंक्ति को बदलें:

myDouble = 0.007;
myDouble = 12345678.1234567;

अपना प्रोग्राम चलाएं और अपने डबल बटन पर क्लिक करें। संदेश बॉक्स सही ढंग से संख्या प्रदर्शित करता है। अंत में एक और नंबर जोड़ें, और C # फिर से ऊपर या नीचे गोल होगा। नैतिकता है अगर आप सटीकता चाहते हैं, गोलाई से सावधान रहें!

Comments

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

— BrainSlugs83 1

Answer 10

• फ्लोट: at 1.5 x 10 ^ -45 से ^ 3.4 x 10 ^ 38 (~ 7 महत्वपूर्ण आंकड़े)
• डबल: ± 5.0 x 10 ^ -324 से 10 1.7 x 10 ^ 308 (15-16 महत्वपूर्ण आंकड़े)
• दशमलव: ± 1.0 x 10 ^ -28 से 10 7.9 x 10 ^ 28 (28-29 महत्वपूर्ण आंकड़े)

Comments

अंतर सिर्फ परिशुद्धता से अधिक है। - decimalवास्तव में दशमलव प्रारूप में संग्रहीत किया जाता है (जैसा कि आधार 2 के विपरीत है; इसलिए यह दो संख्यात्मक प्रणालियों के बीच रूपांतरण के कारण अंकों को खो या गोल नहीं करेगा); इसके अतिरिक्त, decimalNaN, -0, or, या-Na जैसे विशेष मूल्यों की कोई अवधारणा नहीं है।

— ब्रेनस्ल्गस83

Answer 11

यह मेरे लिए एक दिलचस्प धागा रहा है, आज के रूप में, हमारे पास सिर्फ एक छोटा सा बग है, decimalएक से कम परिशुद्धता होने के बारे में float।

हमारे सी # कोड में, हम एक एक्सेल स्प्रेडशीट से संख्यात्मक मान पढ़ रहे हैं, उन्हें एक में परिवर्तित कर रहे हैं decimal, फिर decimalएक SQL सर्वर डेटाबेस में सहेजने के लिए इस सेवा को वापस भेज रहे हैं ।

Microsoft.Office.Interop.Excel.Range cell = …
object cellValue = cell.Value2;
if (cellValue != null)
{
    decimal value = 0;
    Decimal.TryParse(cellValue.ToString(), out value);
}

अब, हमारे लगभग सभी एक्सेल मूल्यों के लिए, इसने खूबसूरती से काम किया। लेकिन कुछ के लिए, बहुत छोटे एक्सेल मान, decimal.TryParseपूरी तरह से खोए मूल्य का उपयोग करते हुए । ऐसा ही एक उदाहरण है

• सेलवैल्यू = 0.00006317592

• Decimal.TryParse (cellValue.ToString (), आउट वैल्यू); // 0 पर लौटेगा

समाधान, विचित्र रूप से, एक्सेल मूल्यों को doubleपहले में बदलना था , और फिर एक में decimal:

Microsoft.Office.Interop.Excel.Range cell = …
object cellValue = cell.Value2;
if (cellValue != null)
{
    double valueDouble = 0;
    double.TryParse(cellValue.ToString(), out valueDouble);
    decimal value = (decimal) valueDouble;
    …
}

भले ही doubleएक से कम परिशुद्धता है decimal, यह वास्तव में सुनिश्चित छोटे संख्या अभी भी पहचाना जाएगा। किसी कारण से, double.TryParseवास्तव में ऐसी छोटी संख्या को पुनः प्राप्त करने में सक्षम था, जबकि decimal.TryParseउन्हें शून्य पर सेट किया जाएगा।

अजीब। बहुत अजीब।

Comments

जिज्ञासा से बाहर, सेल वैल्यू का कच्चा मूल्य क्या था। स्टोइरिंग ()? Decimal.TryParse ("0.00006317592", आउट वैल) काम करने लगता है ...

— 23

-1 मुझे गलत मत समझिए, अगर यह सच है, तो यह बहुत दिलचस्प है, लेकिन यह एक अलग सवाल है, यह निश्चित रूप से इस सवाल का जवाब नहीं है।

— पश्चिमायन

हो सकता है कि क्योंकि एक्सेल सेल एक डबल और ToString लौट रहा था () मान "6.31759E-05" था इसलिए दशमलव.पर्स () अंकन पसंद नहीं आया। मैं शर्त लगाता हूं कि अगर आपने Decimal.TryParse () का रिटर्न वैल्यू चेक किया तो यह झूठा होगा।

— सर्जियोएल

@ वेस्टन उत्तर अक्सर वे याद किए गए बारीकियों को भरने में अन्य उत्तरों को पूरक करते हैं। यह उत्तर पार्सिंग के संदर्भ में एक अंतर पर प्रकाश डालता है। यह प्रश्न का उत्तर है!

— रोबिनो

एर ... decimal.Parse("0.00006317592")काम करता है - आपको कुछ और मिल रहा है। - संभवतः वैज्ञानिक संकेतन?

— BrainSlugs83

Answer 12

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

Comments

बहुत सारे आधुनिक सिस्टम, यहां तक ​​कि सेल फोन, डबल के लिए हार्डवेयर का समर्थन है; और यदि आपके गेम में सरल भौतिकी भी है, तो आप डबल और फ्लोट के बीच एक बड़ा अंतर देखेंगे। (उदाहरण के लिए, एक साधारण क्षुद्रग्रह क्लोन में वेग / घर्षण की गणना करते हुए, युगल त्वरण को फ्लोट की तुलना में बहुत अधिक द्रव प्रवाहित करने की अनुमति देते हैं। - ऐसा लगता है कि यह कोई फर्क नहीं पड़ता, लेकिन यह पूरी तरह से करता है।)

— BrainSlugs83

डबल्स भी फ्लोट्स के आकार से दोगुने हैं, जिसका अर्थ है कि आपको दो बार अधिक डेटा के माध्यम से चबाने की ज़रूरत है, जो आपके कैश प्रदर्शन को नुकसान पहुंचाता है। हमेशा की तरह, माप और तदनुसार आगे बढ़ें।

— योयो

Answer 13

दशमलव, डबल और फ्लोट चर प्रकार भिन्न होते हैं, जिस तरह से वे मूल्यों को संग्रहीत करते हैं। परिशुद्धता मुख्य अंतर है जहां फ्लोट एकल परिशुद्धता (32 बिट) फ्लोटिंग पॉइंट डेटा प्रकार है, डबल एक डबल परिशुद्धता (64 बिट) फ्लोटिंग पॉइंट डेटा प्रकार है और दशमलव 128-बिट फ्लोटिंग पॉइंट डेटा प्रकार है।

फ्लोट - 32 बिट (7 अंक)

डबल - 64 बिट (15-16 अंक)

दशमलव - 128 बिट (28-29 महत्वपूर्ण अंक)

अधिक के बारे में ... दशमलव, फ्लोट और डबल के बीच का अंतर

Answer 14

इन सभी प्रकारों के साथ समस्या यह है कि एक निश्चित गतिरोध कम हो जाता है और यह समस्या छोटे दशमलव संख्याओं के साथ हो सकती है जैसे कि उदाहरण में

Dim fMean as Double = 1.18
Dim fDelta as Double = 0.08
Dim fLimit as Double = 1.1

If fMean - fDelta < fLimit Then
    bLower = True
Else
    bLower = False
End If

प्रश्न: बेलर चर में कौन सा मान होता है?

उत्तर: एक 32 बिट मशीन पर चलने वाले में TRUE होता है !!!

यदि मैं दशमलव से डबल की जगह लेता हूं, तो bower में FALSE होता है जो कि अच्छा उत्तर है।

डबल में, समस्या यह है कि fMean-fDelta = 1.09999999999 जो कि 1.1 से कम है।

सावधानी: मुझे लगता है कि एक ही समस्या निश्चित रूप से अन्य संख्या के लिए मौजूद हो सकती है क्योंकि दशमलव उच्च परिशुद्धता के साथ केवल एक डबल है और सटीक में हमेशा एक सीमा होती है।

वास्तव में, डबल, फ्लोट और दशमलव COBOL में द्विआधारी दशमलव के अनुरूप हैं!

यह अफसोसजनक है कि COBOL में लागू अन्य संख्यात्मक प्रकार .Net में मौजूद नहीं हैं। उन लोगों के लिए जो COBOL नहीं जानते हैं, संख्यात्मक प्रकार के बाद COBOL में मौजूद हैं

BINARY or COMP like float or double or decimal
PACKED-DECIMAL or COMP-3 (2 digit in 1 byte)
ZONED-DECIMAL (1 digit in 1 byte) 

Answer 15

सरल शब्दों में:

1. दशमलव, डबल और फ्लोट चर प्रकार भिन्न होते हैं जिस तरह से वे मूल्यों को संग्रहीत करते हैं।
2. परिशुद्धता मुख्य अंतर है (ध्यान दें कि यह एकल अंतर नहीं है) जहां फ्लोट एकल परिशुद्धता (32 बिट) फ्लोटिंग पॉइंट डेटा प्रकार है, डबल एक डबल परिशुद्धता (64 बिट) फ्लोटिंग पॉइंट डेटा प्रकार है और दशमलव एक 128-बिट है फ्लोटिंग पॉइंट डेटा प्रकार।
3. सारांश तालिका:

/==========================================================================================
    Type       Bits    Have up to                   Approximate Range 
/==========================================================================================
    float      32      7 digits                     -3.4 × 10 ^ (38)   to +3.4 × 10 ^ (38)
    double     64      15-16 digits                 ±5.0 × 10 ^ (-324) to ±1.7 × 10 ^ (308)
    decimal    128     28-29 significant digits     ±7.9 x 10 ^ (28) or (1 to 10 ^ (28)
/==========================================================================================

आप यहां अधिक पढ़ सकते हैं , फ्लोट , डबल और दशमलव ।

Comments

यह जवाब क्या जोड़ता है जो पहले से मौजूद उत्तरों में शामिल नहीं है? BTW, आपकी "या" "दशमलव" लाइन में गलत है: वेब पेज में जिस स्लैश से आप कॉपी कर रहे हैं, वह विकल्प के बजाय विभाजन को इंगित करता है।

— मार्क डिकिंसन

और मैं दृढ़ता से विवाद करूंगा कि परिशुद्धता मुख्य अंतर है। मुख्य अंतर आधार है: दशमलव फ़्लोटिंग-पॉइंट बनाम बाइनरी फ़्लोटिंग-पॉइंट। यही कारण है कि क्या फर्क बनाता है Decimalवित्तीय अनुप्रयोगों के लिए उपयुक्त है, और यह जब बीच तय उपयोग करने के लिए मुख्य कसौटी है Decimalऔर Double। यह दुर्लभ है कि Doubleसटीक वैज्ञानिक अनुप्रयोगों के लिए पर्याप्त नहीं है, उदाहरण के लिए (और Decimalअक्सर इसकी सीमित सीमा के कारण वैज्ञानिक अनुप्रयोगों के लिए अनुपयुक्त है )।

— मार्क डिकिंसन

Answer 16

इनमें से प्रत्येक के बीच मुख्य अंतर सटीक है।

floatएक 32-bitसंख्या है, doubleएक 64-bitसंख्या है और decimalएक 128-bitसंख्या है।

Answer 17

• दशमलव 128 बिट (28-29 महत्वपूर्ण अंक) वित्तीय अनुप्रयोगों के मामले में दशमलव प्रकार का उपयोग करना बेहतर है क्योंकि यह आपको उच्च स्तर की सटीकता देता है और गोलाई त्रुटियों से बचने में आसान है गैर-पूर्णांक गणित के लिए दशमलव का उपयोग करें जहां परिशुद्धता की आवश्यकता है (जैसे पैसा और मुद्रा)

• डबल 64 बिट (15-16 अंक) डबल प्रकार संभवतः वास्तविक मूल्यों के लिए सबसे अधिक इस्तेमाल किया जाने वाला डेटा प्रकार है, पैसे को संभालने के अलावा। गैर-पूर्णांक गणित के लिए डबल का उपयोग करें जहां सबसे सटीक उत्तर आवश्यक नहीं है।

• फ्लोट 32 बिट (7 अंक) इसका उपयोग ज्यादातर ग्राफिक पुस्तकालयों में किया जाता है क्योंकि प्रसंस्करण शक्तियों के लिए बहुत अधिक मांगें, ऐसी स्थितियों का भी उपयोग करती हैं जो गोलाकार त्रुटियों को सहन कर सकती हैं।

Decimalsएक की तुलना में बहुत धीमी है double/float।

Decimalsऔर Floats/Doublesएक डाली के बिना तुलना नहीं की जा सकती है जबकि Floatsऔर Doublesकर सकते हैं।

Decimals एन्कोडिंग या अनुगामी शून्य को भी अनुमति दें।

Answer 18

दशमलव, फ्लोट और डबल को .Net (c #) में परिभाषित करने के लिए

आपको निम्न मानों का उल्लेख करना चाहिए:

Decimal dec = 12M/6;
Double dbl = 11D/6;
float fl = 15F/6;

और परिणामों की जाँच करें।

और प्रत्येक के द्वारा कब्जे में बाइट्स हैं

Float - 4
Double - 8
Decimal - 12