आप दशमलव बिंदु तक सटीक दिए गए डिग्री के डार्ट में दोहरे को कैसे गोल करते हैं?

Question

एक डबल को देखते हुए, मैं इसे दशमलव बिंदु के बाद सटीक बिंदुओं की एक संख्या के लिए गोल करना चाहता हूं , जो PHP के गोल () फ़ंक्शन के समान है।

डार्ट डॉक्स में मैं जो सबसे करीबी चीज पा सकता हूं, वह डबल है। स्ट्रींगरिपर्सप्रेशन (), लेकिन यह वह नहीं है जिसकी मुझे जरूरत है क्योंकि इसमें सटीक के कुल बिंदुओं में दशमलव बिंदु से पहले अंक शामिल हैं ।

उदाहरण के लिए, स्ट्रिंजर्स का उपयोग करते हुए खतना (3):

0.123456789 rounds to 0.123  
9.123456789 rounds to 9.12  
98.123456789 rounds to 98.1  
987.123456789 rounds to 987  
9876.123456789 rounds to 9.88e+3

जैसे ही संख्या का परिमाण बढ़ता है, मैं दशमलव स्थान के बाद सटीक रूप से खो देता हूं।

Answer 1

Num.toStringAsFixed () के लिए डॉक्स देखें ।

स्ट्रिंग toStringAsFixed (int भिन्न)

इस के एक दशमलव-बिंदु स्ट्रिंग-प्रतिनिधित्व लौटाता है।

स्ट्रिंग प्रतिनिधित्व की गणना करने से पहले इसे एक दोहरे में रूपांतरित करता है।

• यदि इसका निरपेक्ष मान 10 ^ 21 से अधिक या बराबर है, तो यह विधियाँ इस द्वारा गणना की गई एक घातांक प्रतिनिधित्व को लौटाती हैं ।toStringAsExponential () ।

उदाहरण:

1000000000000000000000.toStringAsExponential(3); // 1.000e+21

• अन्यथा परिणाम दशमलव बिंदु के बाद बिल्कुल अंशांक अंकों के साथ निकटतम स्ट्रिंग प्रतिनिधित्व है। यदि अंशांक 0 के बराबर है तो दशमलव बिंदु छोड़ा जाता है।

पैरामीटर अंशनिर्माता पूर्णांक संतोषजनक होना चाहिए: 0 <= अंशकालिक <= 20।

उदाहरण:

1.toStringAsFixed(3);  // 1.000
(4321.12345678).toStringAsFixed(3);  // 4321.123
(4321.12345678).toStringAsFixed(5);  // 4321.12346
123456789012345678901.toStringAsFixed(3);  // 123456789012345683968.000
1000000000000000000000.toStringAsFixed(3); // 1e+21
5.25.toStringAsFixed(0); // 5

Comments

स्वीकार किया जाना चाहिए + संदर्भ + स्पष्टीकरण + उदाहरण

— कोहल्स

मैं तर्क देता हूं कि इसकी असंगति के कारण उपयोग करने के लिए गोलाई विधि () राउंडिंग विधि है। उदाहरण के लिए, कोशिश करें5.550.toStringAsFixed(1)

— ब्रेंडन

यह भी देखें कि 0 स्थानों पर चक्कर लगाते समय अभिव्यक्ति एक के intबजाय doubleएक मामले में लौटती है जैसे num.parse(50.123.toStringAsFixed(0)) is int- यह .toDouble()इसके अंत में जोड़कर तय किया जा सकता है।

— abulka

Answer 2

num.toStringAsFixed()राउंड। यह आप को (n) एक स्ट्रिंग में बदल देता है, जिसे आप चाहते हैं (2) दशमलव की संख्या के साथ, और फिर कोड की एक मीठी पंक्ति में इसे आपकी संख्या पर वापस भेज देता है:

n = num.parse(n.toStringAsFixed(2));

Comments

ऐसा करने का यह सबसे तेज तरीका है। लेकिन यह गूंगा है कि डार्ट के पास ऐसा करने का एक सीधा तरीका नहीं है

— थिंकडिजिटल

विस्तार विधि: extension NumberRounding on num { num toPrecision(int precision) { return num.parse((this).toStringAsFixed(precision)); } }

— Vit Veres

Answer 3

उपरोक्त समाधान उचित रूप से गोल संख्या नहीं हैं। मैं उपयोग करता हूं:

double dp(double val, int places){ 
   double mod = pow(10.0, places); 
   return ((val * mod).round().toDouble() / mod); 
}

Comments

पुष्टि की गई, यह dp(5.550, 1)सही ढंग से 5.6- सबसे लोकप्रिय उत्तर के विपरीत है जो 5.5@brendan के रूप में थोड़ा गलत उत्तर देता है।

— abulka

Dp (73.4750, 2) के लिए काम नहीं करता है, यह 73.48 calculatorsoup.com/calculators/math/ के बजाय 73.47 देता है। इस लिंक को देखें

— दीप शाह

Answer 4

void main() {
  int decimals = 2;
  int fac = pow(10, decimals);
  double d = 1.234567889;
  d = (d * fac).round() / fac;
  print("d: $d");
}

प्रिंट: 1.23

Comments

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

— LRN

यह भी इंगित करने के लायक है कि यदि js को संकलित किया जाता है, तो डार्ट पूर्णांक भी सटीक खोना शुरू कर देंगे और आपको एक पैकेज का उपयोग करना होगा जैसे: pub.dartlang.org/packages/bignum

— ग्रेग लोव

यह विधि ऐसा करने के लिए वर्तमान सबसे अच्छा और सबसे सुरुचिपूर्ण तरीके की तरह महसूस करती है।

— जियोवन्नी

डबल को इंट त्रुटि के लिए नहीं सौंपा जा सकता है लाइन 3 पर होता है

— गायन पथिरेज

Answer 5

var price = 99.012334554;
price = price.toStringAsFixed(2);
print(price); // 99.01

वह डार्ट का रेफ है। रेफरी: https://api.dartlang.org/stable/2.3.0/dart-core/num/toStringAsFixed.html

Answer 6

दशमलव बिंदु तक सटीक दिए गए डार्ट में डार्ट में एक डबल चक्कर लगाने के लिए, आप डार्ट toStringAsFixed()विधि में अंतर्निहित समाधान का उपयोग कर सकते हैं , लेकिन आपको इसे वापस डबल में बदलना होगा।

void main() {
  double step1 = 1/3;  
  print(step1); // 0.3333333333333333
  
  String step2 = step1.toStringAsFixed(2); 
  print(step2); // 0.33 
  
  double step3 = double.parse(step2);
  print(step3); // 0.33
}

Answer 7

एक विस्तार को परिभाषित करें:

extension Ex on double {
  double toPrecision(int n) => double.parse(toStringAsFixed(n));
}

उपयोग:

void main() {
  double d = 2.3456789;
  double d1 = d.toPrecision(1); // 2.3
  double d2 = d.toPrecision(2); // 2.35
  double d3 = d.toPrecision(3); // 2.345
}

Answer 8

डार्ट एक्सटेंशन विधियों का उपयोग करके @andyw का संशोधित उत्तर:

extension Precision on double {
    double toPrecision(int fractionDigits) {
        double mod = pow(10, fractionDigits.toDouble());
        return ((this * mod).round().toDouble() / mod);
    }
}

उपयोग:

var latitude = 1.123456;
var latitudeWithFixedPrecision = latitude.toPrecision(3); // Outputs: 1.123

Answer 9

आप toStringAsFixedदशमलव अंकों के बाद सीमित अंकों को प्रदर्शित करने के लिए उपयोग कर सकते हैं । toStringAsFixedदशमलव-बिंदु स्ट्रिंग-प्रतिनिधित्व लौटाता है। toStringAsFixedएक तर्क को स्वीकार करता है जिसे fraction Digitsदशमलव के बाद हम कितने अंकों में प्रदर्शित करना चाहते हैं। यहाँ इसका उपयोग कैसे करना है।

double pi = 3.1415926;
const val = pi.toStringAsFixed(2); // 3.14

Answer 10

मैंने toStringAsFixed()दशमलव बिंदु EX के बाद किसी संख्या को विशिष्ट संख्याओं में राउंड करने के लिए विधि का उपयोग किया :

double num = 22.48132906

और जब मैंने इसे इस तरह दो नंबरों पर राउंड किया:

print(num.toStringAsFixed(2)) ;

यह छपा 22.48

और जब मैं एक नंबर पर गया, तो यह छपा 22.5

Answer 11

उपरोक्त समाधान सभी मामलों के लिए काम नहीं करते हैं। मेरी समस्या के लिए जो काम किया गया वह था यह समाधान जो आपके नंबर (0.5 से 1 या 0.49 से 0) को गोल करेगा और इसे बिना किसी निर्णय के छोड़ देगा :

इनपुट: १२.६ :

double myDouble = 12.67;
var myRoundedNumber; // Note the 'var' datatype

// Here I used 1 decimal. You can use another value in toStringAsFixed(x)
myRoundedNumber = double.parse((myDouble).toStringAsFixed(1));
myRoundedNumber = myRoundedNumber.round();

print(myRoundedNumber);

आउटपुट: 13

इस लिंक के अन्य समाधान भी हैं

Answer 12

यदि आप नहीं चाहते हैं कि कोई भी दशमलव जब परिणामी दशमलव सभी शून्य हैं, तो ऐसा कुछ काम करेगा:

String fixedDecimals(double d, int decimals, {bool removeZeroDecimals = true}){
  double mod = pow(10.0, decimals);
  double result = ((d * mod).round().toDouble() / mod);
  if( removeZeroDecimals && result - (result.truncate()) == 0.0 ) decimals = 0;
  return result.toStringAsFixed(decimals);
}

यह केवल होगा उत्पादन 9के बजाय 9.00यदि इनपुट है 9.004और आप 2 दशमलव चाहते हैं।

Answer 13

यह बहुत अच्छी तरह से काम करता है

var price=99.012334554
price = price.roundTodouble();
print(price); // 99.01