जवाबों:
यह मैं क्या मिला जब मैं इस संदेह नहीं था है।
mysql> create table numbers (a decimal(10,2), b float);
mysql> insert into numbers values (100, 100);
mysql> select @a := (a/3), @b := (b/3), @a * 3, @b * 3 from numbers \G
*************************** 1. row ***************************
@a := (a/3): 33.333333333
@b := (b/3): 33.333333333333
@a + @a + @a: 99.999999999000000000000000000000
@b + @b + @b: 100दशमलव ने वास्तव में इस मामले पर क्या करना है, यह बाकी को छोटा कर दिया, इस प्रकार 1/3 भाग खो दिया।
तो रकम के लिए दशमलव बेहतर है, लेकिन डिवीजनों के लिए फ्लोट बेहतर है, कुछ बिंदु तक, निश्चित रूप से। मेरा मतलब है, DECIMAL का उपयोग आपको किसी भी तरह से "असफल प्रमाण अंकगणित" नहीं देगा।
उम्मीद है की यह मदद करेगा।
@a99.99999999900000000000000000 DECIMAL नहीं दे रहा है? जो तकनीकी रूप से सही है।
अधिकांश वातावरण में एक "फ्लोट" एक बाइनरी फ्लोटिंग-पॉइंट प्रकार है। यह बेस -2 मूल्यों (एक निश्चित बिंदु तक) को सही ढंग से स्टोर कर सकता है, लेकिन कई बेस -10 (दशमलव) मूल्यों को सही ढंग से स्टोर नहीं कर सकता है। वैज्ञानिक गणना के लिए फ़्लैट सबसे उपयुक्त होते हैं। वे अधिकांश व्यवसाय-उन्मुख गणित के लिए उपयुक्त नहीं हैं , और फ़्लोट्स का अनुचित उपयोग आपको काट देगा। कई दशमलव मानों को बेस -2 में बिल्कुल नहीं दिखाया जा सकता है। 0.1उदाहरण के लिए, और आप जैसे अजीब परिणाम देख सकते हैं 1.0 - 0.1 = 0.8999999।
दशमलव संख्या आधार -10 संख्याओं को संग्रहीत करती है। दशमांश अधिकांश व्यावसायिक गणित के लिए एक अच्छा प्रकार है (लेकिन कोई भी "इन-मनी" प्रकार वित्तीय गणना के लिए अधिक उपयुक्त है), जहां पूर्णांक प्रकारों द्वारा प्रदान किए गए मानों की सीमा से अधिक है, और भिन्नात्मक मूल्यों की आवश्यकता है। दशमलव, जैसा कि नाम से पता चलता है, बेस -10 नंबर के लिए डिज़ाइन किए गए हैं - वे दशमलव मानों को फिर से स्टोर कर सकते हैं (फिर से, एक निश्चित बिंदु पर)।
MySQL ने हाल ही में बदल दिया है कि वे जिस तरह से DECIMAL प्रकार को स्टोर करते हैं । अतीत में वे प्रत्येक अंक के लिए वर्ण (या nybbles) संग्रहीत करते थे जिसमें एक संख्या का ASCII (या nybble) प्रतिनिधित्व होता है - बनाम - एक दो का पूरक पूर्णांक, या कुछ व्युत्पन्न।
DECIMAL के लिए वर्तमान संग्रहण प्रारूप 1,2,3, या 4-बाइट पूर्णांकों की एक श्रृंखला है, जिनके बिट्स को एक अंतर्निहित दशमलव बिंदु के साथ एक दो के पूरक संख्या बनाने के लिए संक्षिप्त किया गया है, जिसे आपके द्वारा परिभाषित किया गया है, और जब घोषित किया जाता है तो DB स्कीमा में संग्रहीत किया जाता है। कॉलम और निर्दिष्ट करें कि यह DECIMAL आकार और दशमलव बिंदु स्थिति है।
उदाहरण के अनुसार, यदि आप 32-बिट इंट लेते हैं तो आप 0 - 4,294,967,295 में से किसी भी संख्या को स्टोर कर सकते हैं। यह केवल मज़बूती से 999,999,999 को कवर करेगा, इसलिए यदि आप 2 बिट्स को बाहर फेंकते हैं और उपयोग किया जाता है (1 << 30 -1) तो आप कुछ भी नहीं देंगे। केवल 4 बाइट्स के साथ सभी 9-अंकीय संख्याओं को कवर करना 4 ASCII वर्णों या 8 नायब अंकों का उपयोग करके 32 बिट्स में 4 अंकों को कवर करने से अधिक कुशल है। (एक नायबबल 4-बिट्स है, जिससे 0-15 मानों की अनुमति मिलती है, 0-9 से अधिक की आवश्यकता है, लेकिन आप 3 बिट्स पर जाकर उस कचरे को समाप्त नहीं कर सकते, क्योंकि यह केवल 0-4 को मानों को कवर करता है)
MySQL ऑनलाइन डॉक्स पर उपयोग किया गया उदाहरण DECIMAL (18,9) का उपयोग एक उदाहरण के रूप में करता है। यह 9 अंक से आगे का अंक है और निहित दशमलव बिंदु के पीछे 9 अंक है, जैसा कि ऊपर बताया गया है कि निम्नलिखित भंडारण की आवश्यकता है।
18 8-बिट वर्ण के रूप में: 144 बिट्स
18 18 बिट बिट्स के रूप में: 72 बिट्स
2 32-बिट पूर्णांक के रूप में: 64 बिट्स
वर्तमान में DECIMAL अधिकतम 65 अंकों का समर्थन करता है, DECIMAL (M, D) के रूप में जहां M के लिए सबसे बड़ा मान 65 है, और D के लिए सबसे बड़ा मान 30 है।
तो एक समय में 9 अंको का हिस्सा लेने की आवश्यकता नहीं है, 32-बिट्स से छोटे पूर्णांकों का उपयोग 1,2 और 3 बाइट पूर्णांकों का उपयोग करके अंकों को जोड़ने के लिए किया जाता है। किसी कारण के लिए, जो तर्क को धता बताती है, हस्ताक्षरित के बजाय, अहस्ताक्षरित ints का उपयोग किया गया था, और ऐसा करने में, 1 बिट बाहर फेंक दिया जाता है, जिसके परिणामस्वरूप निम्नलिखित भंडारण क्षमता होती है। 1,2 और 4 बाइट के लिए खोई हुई बिट्स को कोई फर्क नहीं पड़ता, लेकिन 3-बाइट इंट के लिए यह एक आपदा है क्योंकि उस एकल बिट के नुकसान के कारण एक संपूर्ण अंक खो जाता है।
7-बिट इंट के साथ: 0 - 99
15-बिट इंट के साथ: 0 - 9,999
23-बिट इंट के साथ: 0 - 999,999 (24-बिट इंट के साथ 0 - 9,999,999)
1,2,3 और 4-बाइट पूर्णांकों को एक "बिट पूल" बनाने के लिए एक साथ सम्मिलित किया जाता है, दो नंबर के पूरक पूर्णांक के रूप में संख्या का सही प्रतिनिधित्व करने के लिए DECIMAL उपयोग करता है। दशमलव बिंदु संग्रहीत नहीं है, यह निहित है।
इसका मतलब यह है कि कोई भी ASCII से पूर्व रूपांतरण के लिए DB नंबर की आवश्यकता नहीं है कि "नंबर" को सीपीयू द्वारा एक नंबर के रूप में पहचाने जाने वाली चीज़ में परिवर्तित किया जाए। कोई गोलाई नहीं, कोई रूपांतरण त्रुटियां नहीं, यह एक वास्तविक संख्या है जिसे CPU हेरफेर कर सकता है।
इस मनमाने ढंग से बड़े पूर्णांक की गणना सॉफ्टवेयर में की जानी चाहिए, क्योंकि इस तरह की संख्या के लिए कोई हार्डवेयर समर्थन नहीं है, लेकिन ये लाइब्रेरी बहुत पुरानी और अत्यधिक अनुकूलित हैं, जो कि आईबीएम 370 फोरट्रान के सटीक फ़्लोटिंग पॉइंट डेटा का समर्थन करने के लिए 50 साल पहले लिखी गई हैं। । वे अभी भी सीपीयू पूर्णांक हार्डवेयर के साथ किए गए निश्चित आकार के पूर्णांक बीजगणित, या एफपीयू पर किए गए फ्लोटिंग पॉइंट गणनाओं की तुलना में बहुत धीमी हैं।
भंडारण दक्षता के संदर्भ में, क्योंकि एक फ्लोट का घातांक प्रत्येक और प्रत्येक फ्लोट से जुड़ा होता है, यह स्पष्ट रूप से निर्दिष्ट करता है कि दशमलव बिंदु कहां है, यह बड़े पैमाने पर निरर्थक है, और इसलिए डीबी कार्य के लिए अक्षम है। एक DB में आप पहले से ही जानते हैं कि दशमलव बिंदु कहाँ से ऊपर जाना है, और तालिका में प्रत्येक पंक्ति जिसमें DECIMAL कॉलम के लिए एक मान है, केवल उस दशमलव बिंदु को रखने के लिए 1 और एकमात्र विनिर्देश को देखना होगा, जिसे संग्रहीत किया जाना है एक DECIMAL (M, D) के तर्क के रूप में M और D मान के निहितार्थ के रूप में स्कीमा में।
विभिन्न प्रकार के अनुप्रयोगों के लिए किस प्रारूप का उपयोग किया जाना है, इसके बारे में यहां मिली कई टिप्पणियां सही हैं, इसलिए मैं इस बिंदु पर विश्वास नहीं करूंगा। मैंने इसे यहां लिखने का समय लिया क्योंकि जो कोई भी लिंक किए गए MySQL ऑनलाइन दस्तावेज़ को बनाए रख रहा है, वह उपरोक्त में से किसी को भी नहीं समझता है और तेजी से निराशा के दौर के बाद इसे समझाने की कोशिश करता है कि मैंने उन्हें छोड़ दिया था। इस बात का एक अच्छा संकेत कि वे जो कुछ लिख रहे थे, वह कितना खराब था, यह विषय की बहुत ही अस्पष्ट और लगभग अशोभनीय प्रस्तुति है।
अंतिम विचार के रूप में, यदि आपको उच्च-सटीक फ़्लोटिंग पॉइंट कम्प्यूटेशन की आवश्यकता है, तो पिछले 20 वर्षों में फ़्लोटिंग पॉइंट कोड में जबरदस्त प्रगति हुई है, और 96-बिट और क्वाड्रुपल प्रिसिजन फ़्लोट के लिए हार्डवेयर समर्थन कोने के चारों ओर सही है, अगर वहाँ संग्रहीत मूल्य का हेरफेर महत्वपूर्ण है, तो वहाँ अच्छा मनमाना सटीक पुस्तकालय हैं।
MySQL के लिए केवल विशिष्ट नहीं है, फ्लोट और दशमलव प्रकारों के बीच का अंतर यह है कि वे भिन्नात्मक मूल्यों का प्रतिनिधित्व करते हैं। फ़्लोटिंग पॉइंट प्रकार बाइनरी में अंशों का प्रतिनिधित्व करते हैं, जो केवल मानों का प्रतिनिधित्व कर सकते हैं {m*2^n | m, n Integers}। मान जैसे कि 1/5 का सही प्रतिनिधित्व नहीं किया जा सकता (बिना राउंड ऑफ एरर के)। दशमलव संख्याएँ समान रूप से सीमित होती हैं, लेकिन संख्याओं का प्रतिनिधित्व करती हैं {m*10^n | m, n Integers}। दशमलव अभी भी 1/3 जैसी संख्याओं का प्रतिनिधित्व नहीं कर सकता है, लेकिन वित्त जैसे कई सामान्य क्षेत्रों में अक्सर ऐसा होता है, उम्मीद यह है कि निश्चित दशमलव अंश हमेशा निष्ठा के नुकसान के बिना व्यक्त किए जा सकते हैं। चूंकि एक दशमलव संख्या एक मूल्य का प्रतिनिधित्व कर सकती है जैसे $0.20(एक डॉलर का पांचवां हिस्सा), यह उन स्थितियों में पसंद किया जाता है।
दशमलव पैसे की तरह निश्चित मात्रा के लिए है जहाँ आप एक विशिष्ट संख्या में दशमलव स्थान चाहते हैं। फ्लोट्स स्टोर करने के लिए हैं ... फ्लोटिंग पॉइंट प्रिसिजन नंबर।
मुझे यह उपयोगी लगा:
आमतौर पर, फ्लोट मूल्य वैज्ञानिक गणनाओं के लिए अच्छे हैं, लेकिन इसका उपयोग वित्तीय / मौद्रिक मूल्यों के लिए नहीं किया जाना चाहिए। बिजनेस ओरिएंटेड मैथ के लिए, हमेशा दशमलव का उपयोग करें।
स्रोत: http://code.rohitink.com/2013/06/12/mysql-integer-float-decimal-data-types-differences/
mysql> CREATE TABLE num(id int ,fl float,dc dec(5,2));
Query OK, 0 rows affected (0.00 sec)
mysql> INSERT INTO num VALUES(1,13.75,13.75);
Query OK, 1 row affected (0.00 sec)
mysql> INSERT INTO num VALUES(2,13.15,13.15);
Query OK, 1 row affected (0.00 sec)
mysql> SELECT * FROM num WHERE fl = 13.15;
Empty set (0.00 sec)
mysql> SELECT * FROM num WHERE dc = 13.15;
+------+-------+-------+
| id | fl | dc |
+------+-------+-------+
| 2 | 13.15 | 13.15 |
+------+-------+-------+
1 row in set (0.00 sec)
mysql> SELECT SUM(fl) ,SUM(dc) FROM num;
+--------------------+---------+
| SUM(fl) | SUM(dc) |
+--------------------+---------+
| 26.899999618530273 | 26.90 |
+--------------------+---------+
1 row in set (0.00 sec)
mysql> SELECT * FROM num WHERE ABS(fl - 13.15)<0.01;
+------+-------+-------+
| id | fl | dc |
+------+-------+-------+
| 2 | 13.15 | 13.15 |
+------+-------+-------+
1 row in set (0.00 sec)फ्लोटिंग-पॉइंट प्रकार (अनुमानित मूल्य) - FLOAT, DOUBLE
FLOAT और DOUBLE प्रकार अनुमानित संख्यात्मक डेटा मानों का प्रतिनिधित्व करते हैं। MySQL एकल-सटीक मानों के लिए चार बाइट्स और डबल-परिशुद्धता मानों के लिए आठ बाइट्स का उपयोग करता है।
FLOAT के लिए, SQL मानक कोष्ठक में कीवर्ड FLOAT का अनुसरण करते हुए बिट्स में सटीक (लेकिन घातांक की सीमा नहीं) के एक वैकल्पिक विनिर्देश की अनुमति देता है। MySQL भी इस वैकल्पिक परिशुद्धता विनिर्देश का समर्थन करता है, लेकिन सटीक मान का उपयोग केवल संग्रहण आकार निर्धारित करने के लिए किया जाता है। 4-बाइट एकल-सटीक FLOAT कॉलम में 0 से 23 के बीच की सटीकता। 8-बाइट से 8-बाइट डबल-सटीक डबल-स्तंभ में एक सटीक परिणाम।
MySQL एक नॉनस्टैंडर्ड सिंटैक्स की अनुमति देता है: FLOAT (M, D) या REAL (M, D) या DOUBLE PRECISION (M, D)। यहाँ, "(M, D)" का अर्थ है मानों को कुल M अंकों तक संग्रहीत किया जा सकता है, जिनमें से D अंक दशमलव बिंदु के बाद हो सकते हैं। उदाहरण के लिए, FLOAT (7,4) के रूप में परिभाषित एक स्तंभ प्रदर्शित होने पर -999.9999 जैसा दिखेगा। मान जमा करते समय MySQL राउंडिंग करता है, इसलिए यदि आप 999.00009 को FLOAT (7,4) कॉलम में सम्मिलित करते हैं, तो अनुमानित परिणाम 999.0001 है।
क्योंकि फ़्लोटिंग-पॉइंट मान अनुमानित हैं और सटीक मानों के रूप में संग्रहीत नहीं किए जाते हैं, तुलनात्मक रूप से उनका सटीक इलाज करने का प्रयास समस्याओं का कारण बन सकता है। वे मंच या कार्यान्वयन निर्भरता के अधीन भी हैं।
अधिकतम पोर्टेबिलिटी के लिए, अनुमानित संख्यात्मक डेटा मूल्यों के भंडारण की आवश्यकता वाले कोड को सटीक या अंकों की संख्या के विनिर्देश के साथ FLOAT या DOUBLE PRECISION का उपयोग करना चाहिए।
https://dev.mysql.com/doc/refman/5.5/en/floating-point-types.html
फ्लोटिंग-पॉइंट वैल्यू के साथ समस्या
फ़्लोटिंग-पॉइंट नंबर कभी-कभी भ्रम का कारण बनते हैं क्योंकि वे अनुमानित होते हैं और सटीक मानों के रूप में संग्रहीत नहीं होते हैं । SQL कथन में लिखा गया फ्लोटिंग-पॉइंट मान आंतरिक रूप से दर्शाए गए मान के समान नहीं हो सकता है। तुलना में सटीक रूप से फ्लोटिंग-पॉइंट मानों का इलाज करने का प्रयास समस्याओं का कारण बन सकता है। वे मंच या कार्यान्वयन निर्भरता के अधीन भी हैं। फ़्लोट और डबल डेटा प्रकार इन मुद्दों के अधीन हैं। DECIMAL कॉलम के लिए, MySQL 65 दशमलव अंकों की सटीकता के साथ संचालन करता है, जो कि सबसे आम अशुद्धि समस्याओं को हल करना चाहिए।
निम्न उदाहरण डबले का उपयोग करके प्रदर्शित करता है कि फ्लोटिंग-पॉइंट ऑपरेशन का उपयोग करके की जाने वाली गणना फ़्लोटिंग-पॉइंट त्रुटि के अधीन कैसे होती है।
mysql> CREATE TABLE t1 (i INT, d1 DOUBLE, d2 DOUBLE);
mysql> INSERT INTO t1 VALUES (1, 101.40, 21.40), (1, -80.00, 0.00),
-> (2, 0.00, 0.00), (2, -13.20, 0.00), (2, 59.60, 46.40),
-> (2, 30.40, 30.40), (3, 37.00, 7.40), (3, -29.60, 0.00),
-> (4, 60.00, 15.40), (4, -10.60, 0.00), (4, -34.00, 0.00),
-> (5, 33.00, 0.00), (5, -25.80, 0.00), (5, 0.00, 7.20),
-> (6, 0.00, 0.00), (6, -51.40, 0.00);
mysql> SELECT i, SUM(d1) AS a, SUM(d2) AS b
-> FROM t1 GROUP BY i HAVING a <> b;
+------+-------+------+
| i | a | b |
+------+-------+------+
| 1 | 21.4 | 21.4 |
| 2 | 76.8 | 76.8 |
| 3 | 7.4 | 7.4 |
| 4 | 15.4 | 15.4 |
| 5 | 7.2 | 7.2 |
| 6 | -51.4 | 0 |
+------+-------+------+परिणाम सही है। हालाँकि, पहले पाँच रिकॉर्ड ऐसे दिखते हैं कि उन्हें तुलना को संतुष्ट नहीं करना चाहिए (a और b के मान भिन्न नहीं दिखते हैं), वे ऐसा कर सकते हैं क्योंकि संख्याओं के बीच का अंतर दसवें दशमलव या उसके आसपास के कारकों के आधार पर दिखता है। जैसे कंप्यूटर आर्किटेक्चर या कंपाइलर वर्जन या ऑप्टिमाइज़ेशन लेवल। उदाहरण के लिए, अलग-अलग सीपीयू फ्लोटिंग-पॉइंट संख्याओं का अलग-अलग मूल्यांकन कर सकते हैं।
यदि स्तंभ d1 और d2 को DOUBLE के बजाय DECIMAL के रूप में परिभाषित किया गया था, तो SELECT क्वेरी के परिणाम में केवल एक पंक्ति शामिल होगी - ऊपर दिखाया गया अंतिम।
फ्लोटिंग-पॉइंट संख्या तुलना करने का सही तरीका यह है कि पहले संख्याओं के बीच अंतर के लिए एक स्वीकार्य सहिष्णुता पर निर्णय लें और फिर सहिष्णुता मूल्य के खिलाफ तुलना करें। उदाहरण के लिए, यदि हम सहमत हैं कि फ्लोटिंग-पॉइंट नंबरों को एक ही माना जाना चाहिए यदि वे दस हजार (0.0001) में एक की सटीकता के भीतर समान हैं, तो तुलनात्मकता मान से बड़े अंतर को खोजने के लिए तुलना लिखी जानी चाहिए:
mysql> SELECT i, SUM(d1) AS a, SUM(d2) AS b FROM t1
-> GROUP BY i HAVING ABS(a - b) > 0.0001;
+------+-------+------+
| i | a | b |
+------+-------+------+
| 6 | -51.4 | 0 |
+------+-------+------+
1 row in set (0.00 sec)इसके विपरीत, पंक्तियों को प्राप्त करने के लिए जहां संख्या समान होती है, परीक्षण को सहिष्णुता मूल्य के भीतर अंतर खोजना चाहिए:
mysql> SELECT i, SUM(d1) AS a, SUM(d2) AS b FROM t1
-> GROUP BY i HAVING ABS(a - b) <= 0.0001;
+------+------+------+
| i | a | b |
+------+------+------+
| 1 | 21.4 | 21.4 |
| 2 | 76.8 | 76.8 |
| 3 | 7.4 | 7.4 |
| 4 | 15.4 | 15.4 |
| 5 | 7.2 | 7.2 |
+------+------+------+
5 rows in set (0.03 sec)फ़्लोटिंग-पॉइंट मान प्लेटफ़ॉर्म या कार्यान्वयन निर्भरता के अधीन हैं। मान लीजिए कि आप निम्नलिखित कथनों को निष्पादित करते हैं:
CREATE TABLE t1(c1 FLOAT(53,0), c2 FLOAT(53,0));
INSERT INTO t1 VALUES('1e+52','-1e+52');
SELECT * FROM t1;कुछ प्लेटफार्मों पर, SELECT स्टेटमेंट inf और -inf देता है। दूसरों पर, यह 0 और -0 लौटाता है।
पूर्ववर्ती मुद्दों का एक निहितार्थ यह है कि यदि आप मास्टर पर mysqldump के साथ तालिका सामग्री को डंप करके प्रतिकृति दास बनाने का प्रयास करते हैं और डंप फ़ाइल को दास में पुनः लोड करते हैं, तो फ़्लोटिंग-पॉइंट कॉलम वाली तालिकाएँ दोनों मेजबानों के बीच भिन्न हो सकती हैं।
https://dev.mysql.com/doc/refman/5.5/en/problems-with-float.html
कठोर और तेज़ नियम
यदि आप सभी को जोड़ने की जरूरत है, घटाना या गुणा आप संख्या में हैं, DECIMAL सबसे अच्छा है।
यदि आपको डेटा पर अंकगणित या बीजगणित के किसी अन्य रूप को विभाजित करने या करने की आवश्यकता है, तो आप फ्लोट के साथ लगभग निश्चित रूप से खुश होंगे। फ़्लोटिंग पॉइंट लाइब्रेरीज़, और इंटेल प्रोसेसर पर, फ़्लोटिंग पॉइंट प्रोसेसर स्वयं, ऑपरेशन के TONs को सही, फिक्स-अप, डिटेक्ट करते हैं और विशिष्ट गणित फ़ंक्शंस करते समय होने वाले अपवादों के बर्फ़ीलेपन का पता लगाते हैं - विशेष रूप से ट्रान्सेंडैंटल फ़ंक्शंस।
सटीकता के लिए, मैंने एक बार एक बजट प्रणाली लिखी थी जिसमें ३,६००+ खातों में से प्रत्येक के ३,६०० बजट इकाइयों के लिए% योगदान की गणना की गई थी, उस महीने तक उस इकाई का समेकन नोड था, फिर प्रतिशत के उस मैट्रिक्स के आधार पर (3,000 + x १२ x ३,६००) मैंने संगठनात्मक नोड्स के अगले 3 स्तरों के लिए उच्चतम संगठनात्मक नोड्स द्वारा निर्धारित मात्राओं को गुणा किया, और उसके बाद सभी 3,200 विस्तार इकाइयों के लिए सभी (3,000 + 12) मूल्यों की गणना की। लाखों और लाखों और लाखों डबल फ़्लोटिंग फ़्लोटिंग पॉइंट गणना, जिनमें से कोई भी उन सभी अनुमानों के रोल-अप को एक बॉटम-अप समेकन में वापस उच्चतम स्तर पर फेंक देगा।
उन सभी गणनाओं के बाद कुल फ्लोटिंग पॉइंट एरर ZERO था । यह 1986 में था, और फ्लोटिंग पॉइंट लाइब्रेरी आज बहुत हैं, जितना कि वे वापस आ गए थे। इंटेल 80 बिट बिट में युगल की मध्यवर्ती गणना करता है, जो सभी लेकिन गोल त्रुटि को समाप्त करता है। जब कोई आपसे कहता है "यह फ्लोटिंग पॉइंट एरर है" तो यह लगभग निश्चित नहीं है।
float(और double) द्विआधारी अंशों का प्रतिनिधित्व करता है
decimal दशमलव अंशों का प्रतिनिधित्व करता है
declare @float as float(10)
declare @Decimal as decimal(10)
declare @Inetger as int
set @float =10.7
set @Decimal =10.7
set @Inetger=@Decimal
print @Inetgerफ्लोट में जब पूर्णांक प्रिंट 10 पर दशमलव 11 में मान सेट करें
FLOAT(m,n), यह दो दौर की ओर जाता है; इस बीच, यह किसी भी उपयोग के कुछ भी नहीं प्रदान करता है।