Java.math.MathContext का उपयोग करें

हाल ही में मैंने java.math.MathContext के उपयोग को समझने की कोशिश की लेकिन ठीक से समझने में विफल रहा। क्या यह java.math.bigDecimal में घूमने के लिए प्रयोग किया जाता है, यदि हां, तो यह दशमलव अंकों को क्यों नहीं लेता है बल्कि यहां तक ​​कि mentissa भाग भी है।

एपीआई दस्तावेज़ों से, मुझे पता चला कि यह ANSI X3.274-1996 और ANSI X3.274-1996 / AM 1-2000 विनिर्देशों में निर्दिष्ट मानक का पालन करता है लेकिन मैं उन्हें ऑनलाइन पढ़ने के लिए नहीं मिला।

अगर आपको इस पर कोई विचार है तो कृपया मुझे बताएं।

0
ro fr bn

5 उत्तर

यह मस्ती के लिए नहीं है। असल में मुझे कुछ ऑनलाइन उदाहरण मिला, जिसमें बिगडेसिमल में संग्रहीत रकम / संख्याओं को गोल करने के लिए MathContext का उपयोग कहा गया था।

उदाहरण के लिए,

If MathContext is configured to have precision = 2 and rounding mode = ROUND_HALF_EVEN

BigDecimal Number = 0.5294, is rounded to 0.53

तो मैंने सोचा कि यह एक नई तकनीक है और इसे गोल करने के उद्देश्य के लिए इस्तेमाल किया जाता है। हालांकि यह दुःस्वप्न में बदल गया क्योंकि यह संख्या के मंथिसा भाग को भी गोल करना शुरू कर दिया।

उदाहरण के लिए,

Number = 1.5294 is rounded to 1.5

Number = 10.5294 is rounded to 10

Number = 101.5294 is rounded to 100

.... और इसी तरह

तो यह ऐसा व्यवहार नहीं है जिसे मैं गोल करने के लिए अपेक्षित था (सटीक = 2 ​​के रूप में)।

ऐसा लगता है कि कुछ तर्क होने लगते हैं क्योंकि पटर से मैं कह सकता हूं कि यह संख्या के पहले दो अंक (सटीक 2 के रूप में) लेता है और फिर 0 तक नंबर जोड़ता है। अंकों के अनगिनत राशि के समान हो जाते हैं (101.5294 का उदाहरण चेकआउट करें ...)

0
जोड़ा
तो क्या आप इसके बजाय समाधान के लिए भी सुझाव दे सकते हैं?
जोड़ा लेखक Sumit Ramteke, स्रोत

अगर मैं आपको सही तरीके से समझ रहा हूं, ऐसा लगता है कि आप MathContext को यह नियंत्रित करने की उम्मीद कर रहे हैं कि दशमलव बिंदु के बाद कितने अंक रखा जाना चाहिए। ऐसा नहीं है कि यह क्या है। यह निर्दिष्ट करता है कि कितने अंक रखना है, कुल । इसलिए यदि आप निर्दिष्ट करते हैं कि आप 3 महत्वपूर्ण अंक चाहते हैं, तो यह सब कुछ आपको मिल जाएगा।

उदाहरण के लिए, यह:

System.out.println(new BigDecimal("1234567890.123456789",
                   new MathContext(20)));

System.out.println(new BigDecimal("1234567890.123456789",
                   new MathContext(10)));

System.out.println(new BigDecimal("1234567890.123456789",
                   new MathContext(5)));

आउटपुट होगा:

1234567890.123456789
1234567890
1.2346E+9
0
जोड़ा
यह वास्तव में BigDecimal के लिए एक सवाल नहीं है। BigDecimal के साथ, आपको इसके बजाय महत्वपूर्ण अंकों की संख्या निर्दिष्ट करनी चाहिए। प्रदर्शन के लिए स्वरूपण करते समय दशमलव बिंदु के बाद कितने अंक निर्धारित किए जाने चाहिए। आप इसे String.format() या DecimalFormat.format() के साथ नियंत्रित कर सकते हैं।
जोड़ा लेखक Derek Park, स्रोत
@ ड्रू मुझे लगता है कि आप BigDecimal.setScale इसके लिए विधि। पहला पैरामीटर (स्केल) निर्दिष्ट करता है कि आप दशमलव बिंदु के बाद कितनी संख्या रखना चाहते हैं, और दूसरा पैरामीटर (राउंडिंगमोड) आपके इच्छित गोलिंग व्यवहार को निर्दिष्ट करता है।
जोड़ा लेखक Quazi Irfan, स्रोत
@Drew यहां एक ऐसा उत्तर है जो इसे अधिक जानकारी में बताता है।
जोड़ा लेखक Quazi Irfan, स्रोत
धन्यवाद। मैं दशमलव के बाद कितने अंक रखना चाहूंगा?
जोड़ा लेखक Drew, स्रोत

@jatan

आपके उत्तर के लिए धन्यवाद। यह समझ में आता है। क्या आप कृपया BigDecimal # राउंड विधि के संदर्भ में MathContext को समझा सकते हैं।

BigDecimal.round() बनाम किसी अन्य BigDecimal विधि के बारे में कुछ खास नहीं है। सभी मामलों में, MathContext महत्वपूर्ण अंकों और गोल करने वाली तकनीक की संख्या निर्दिष्ट करता है। असल में, प्रत्येक के दो भाग हैं MathContext । एक परिशुद्धता है, और एक RoundingMode

परिशुद्धता फिर से महत्वपूर्ण अंकों की संख्या निर्दिष्ट करता है। इसलिए यदि आप किसी संख्या के रूप में 123 निर्दिष्ट करते हैं, और 2 महत्वपूर्ण अंक मांगते हैं, तो आपको 120 प्राप्त होगा। यदि आप वैज्ञानिक नोटेशन के संदर्भ में सोचते हैं तो यह स्पष्ट हो सकता है।

123 would be 1.23e2 in scientific notation. If you only keep 2 significant digits, then you get 1.2e2, or 120. By reducing the number of significant digits, we reduce the precision with which we can specify a number.

RoundingMode भाग निर्दिष्ट करता है कि हमें परिशुद्धता के नुकसान को कैसे संभालना चाहिए। उदाहरण का पुन: उपयोग करने के लिए, यदि आप संख्या के रूप में 123 का उपयोग करते हैं, और 2 महत्वपूर्ण अंकों के लिए पूछते हैं, तो आपने अपनी परिशुद्धता कम कर दी है। HALF_UP (डिफ़ॉल्ट मोड) के RoundingMode के साथ, 123 120 बन जाएगा। CEILING के RoundingMode के साथ, आपको 130 मिल जाएगा।

उदाहरण के लिए:

System.out.println(new BigDecimal("123.4",
                   new MathContext(4,RoundingMode.HALF_UP)));
System.out.println(new BigDecimal("123.4",
                   new MathContext(2,RoundingMode.HALF_UP)));
System.out.println(new BigDecimal("123.4",
                   new MathContext(2,RoundingMode.CEILING)));
System.out.println(new BigDecimal("123.4",
                   new MathContext(1,RoundingMode.CEILING)));

आउटपुट:

123.4
1.2E+2
1.3E+2
2E+2

आप देख सकते हैं कि सटीकता और गोल दोनों मोड आउटपुट को प्रभावित करते हैं।

0
जोड़ा
120 जैसे स्ट्रिंग में 2 महत्वपूर्ण आंकड़ों के परिणामस्वरूप 123.4 प्रारूपित करने का कोई तरीका है? यह 2 महत्वपूर्ण आंकड़े हैं (जैसा कि 1.2E2 है) क्योंकि पीछे की ओर शून्य होने तक महत्वपूर्ण आंकड़ों को पुनर्प्राप्त करने में पीछे शून्यों को पारंपरिक रूप से शामिल नहीं किया जाता है। और मेरे उद्देश्यों के लिए, यदि प्रारूपित करने की संख्या 103.4 थी, तो मुझे परवाह नहीं है कि आप परिणामस्वरूप 100 संख्या में 2 सिग अंजीर नहीं बता सकते हैं। मैं सिर्फ संख्याओं के सरल / क्लीनर देखना चाहता हूं।
जोड़ा लेखक hepcat72, स्रोत

मैं यहां कुछ उदाहरण जोड़ूंगा। मैंने उन्हें पिछले उत्तरों में नहीं पाया है, लेकिन मुझे उन लोगों के लिए उपयोगी लगता है जो दशमलव स्थान की संख्या के साथ महत्वपूर्ण अंक को गुमराह कर सकते हैं। आइए मान लें, हमारे पास ऐसा संदर्भ है:

MathContext MATH_CTX = new MathContext(3, RoundingMode.HALF_UP);

इस कोड के लिए:

BigDecimal d1 = new BigDecimal(1234.4, MATH_CTX);
System.out.println(d1);

यह पूरी तरह से स्पष्ट है, कि आपका परिणाम 1.23E + 3 जैसा ऊपर बताया गया है। पहले महत्वपूर्ण अंक 123 हैं ...

लेकिन इस मामले में क्या है:

BigDecimal d2 = new BigDecimal(0.000000454770054, MATH_CTX);
System.out.println(d2);

आपका नंबर कोमा के बाद 3 स्थानों पर गोल नहीं किया जाएगा - किसी के लिए यह अंतर्ज्ञानी और जोर देने योग्य नहीं हो सकता है। इसके बजाय इसे पहले 3 महत्वपूर्ण अंक तक गोल किया जाएगा, जो इस मामले में "4 5 4" हैं। तो कोड के ऊपर 4.55E-7 में परिणाम नहीं है और 0.000 में नहीं है क्योंकि कोई उम्मीद कर सकता है।

इसी तरह के उदाहरण:

BigDecimal d3 = new BigDecimal(0.001000045477, MATH_CTX);
 System.out.println(d3);  // 0.00100

BigDecimal d4 = new BigDecimal(0.200000477, MATH_CTX);
 System.out.println(d4);   // 0.200

BigDecimal d5 = new BigDecimal(0.000000004, MATH_CTX);
    System.out.println(d5); //4.00E-9

मुझे आशा है कि यह स्पष्ट, लेकिन प्रासंगिक उदाहरण उपयोगी होगा ...

0
जोड़ा

बिगडिसीमल के केवल आंशिक भाग को गोल करने के लिए, BigDecimal.setScale (int newScale, int roundingMode) विधि देखें।

जैसे दशमलव बिंदु के बाद तीन अंकों के साथ एक अंक को दो अंकों के साथ बदलने के लिए, और गोलाकार:

BigDecimal original = new BigDecimal("1.235");
BigDecimal scaled = original.setScale(2, BigDecimal.ROUND_HALF_UP);

इसका परिणाम मूल्य 1.24 के साथ एक बिगडिसीमल है (राउंडिंग अप नियम के कारण)

0
जोड़ा
यह निश्चित उत्तर है कि लोग निश्चित-दशमलव संख्याओं के साथ काम करते हैं और दशमलव स्थानों की निश्चित संख्या रखते हैं। पता नहीं क्यों सूर्य ने यहां एक फ्लोटिंग-पॉइंट शैली 'परिशुद्धता' को घुमाया, लेकिन यही वह है जो मैथकॉन्टेक्स्ट है।
जोड़ा लेखक Thomas W, स्रोत