इसके लिए हमेशा printfपरिवार के कार्यों का उपयोग करें। यहां तक कि अगर आप मान को एक फ्लोट के रूप में प्राप्त करना चाहते हैं, तो आप snprintfएक स्ट्रिंग के रूप में गोल मूल्य प्राप्त करने और फिर इसे वापस पार्स करने के लिए उपयोग कर रहे हैं atof:
#include <math.h>
#include <stdio.h>
#include <stddef.h>
#include <stdlib.h>
double dround(double val, int dp) {
int charsNeeded = 1 + snprintf(NULL, 0, "%.*f", dp, val);
char *buffer = malloc(charsNeeded);
snprintf(buffer, charsNeeded, "%.*f", dp, val);
double result = atof(buffer);
free(buffer);
return result;
}
मैं ऐसा इसलिए कहता हूं क्योंकि वर्तमान में शीर्ष-वोट किए गए उत्तर और यहां कई अन्य लोगों द्वारा दिखाए गए दृष्टिकोण - 100 से गुणा करना, निकटतम पूर्णांक तक घूमना, और फिर 100 से फिर से विभाजित करना - दो तरीकों से त्रुटिपूर्ण है:
- कुछ मानों के लिए, यह गलत दिशा में गोल होगा क्योंकि 100 के गुणन में दशमलव अंक 4 से 5 या इसके विपरीत गोल दिशा निर्धारित करने वाला परिवर्तन होता है, जो फ्लोटिंग पॉइंट नंबरों की गड़बड़ी के कारण होता है।
- कुछ मानों के लिए, गुणा करना और फिर 100 से विभाजित करना राउंड-ट्रिप नहीं है, जिसका अर्थ है कि भले ही कोई राउंडिंग न हो, अंतिम परिणाम गलत होगा
पहली तरह की त्रुटि को स्पष्ट करने के लिए - गोलाई दिशा कभी-कभी गलत होने पर - इस कार्यक्रम को चलाने का प्रयास करें:
int main(void) {
// This number is EXACTLY representable as a double
double x = 0.01499999999999999944488848768742172978818416595458984375;
printf("x: %.50f\n", x);
double res1 = dround(x, 2);
double res2 = round(100 * x) / 100;
printf("Rounded with snprintf: %.50f\n", res1);
printf("Rounded with round, then divided: %.50f\n", res2);
}
आप इस आउटपुट को देखेंगे:
x: 0.01499999999999999944488848768742172978818416595459
Rounded with snprintf: 0.01000000000000000020816681711721685132943093776703
Rounded with round, then divided: 0.02000000000000000041633363423443370265886187553406
ध्यान दें कि हमने जो मूल्य शुरू किया था वह 0.015 से कम था, और इसलिए इसे 2 दशमलव स्थानों पर गोल करते समय गणितीय रूप से सही उत्तर 0.01 है। बेशक, 0.01 एक डबल के रूप में बिल्कुल प्रतिनिधित्व योग्य नहीं है , लेकिन हम उम्मीद करते हैं कि हमारा परिणाम 0.01 के करीब डबल हो। उपयोग करने snprintfसे हमें वह परिणाम मिलता है, लेकिन उपयोग करने round(100 * x) / 100से हमें 0.02 मिलते हैं, जो गलत है। क्यों? क्योंकि 100 * xपरिणाम के रूप में हमें ठीक 1.5 देता है। इस प्रकार 100 से गुणा करने से सही दिशा बदल जाती है।
दूसरी तरह की त्रुटि का वर्णन करने के लिए - परिणाम कभी-कभी गलत होने के कारण * 100और / 100सही मायने में एक-दूसरे के विपरीत नहीं होने के कारण - हम एक बहुत बड़ी संख्या के साथ एक समान व्यायाम कर सकते हैं:
int main(void) {
double x = 8631192423766613.0;
printf("x: %.1f\n", x);
double res1 = dround(x, 2);
double res2 = round(100 * x) / 100;
printf("Rounded with snprintf: %.1f\n", res1);
printf("Rounded with round, then divided: %.1f\n", res2);
}
हमारी संख्या में अब भिन्नात्मक भाग भी नहीं है; यह पूर्णांक मान है, बस प्रकार के साथ संग्रहीत किया जाता है double। तो इसे राउंड करने के बाद परिणाम वही होना चाहिए जो हमने शुरू किया था, है ना?
यदि आप ऊपर कार्यक्रम चलाते हैं, तो आप देखेंगे:
x: 8631192423766613.0
Rounded with snprintf: 8631192423766613.0
Rounded with round, then divided: 8631192423766612.0
उफ़। हमारा snprintfतरीका फिर से सही परिणाम देता है, लेकिन गुणा-फिर-दौर-तब-विभाजन दृष्टिकोण विफल हो जाता है। ऐसा इसलिए है क्योंकि गणितीय रूप से सही मान 8631192423766613.0 * 100, 863119242376661300.0एक डबल के रूप में बिल्कुल प्रतिनिधित्व योग्य नहीं है; निकटतम मूल्य है 863119242376661248.0। जब आप उस पीठ को 100 से विभाजित करते हैं, तो आप प्राप्त करते हैं 8631192423766612.0- आपके द्वारा शुरू की गई एक अलग संख्या।
उम्मीद है कि एक पर्याप्त प्रदर्शन है कि roundfकई दशमलव स्थानों के लिए उपयोग करने के लिए टूट गया है, और आप snprintfइसके बजाय का उपयोग करना चाहिए । यदि वह आपको एक भयानक हैक की तरह लगता है, तो शायद आप इस ज्ञान से आश्वस्त होंगे कि यह मूल रूप से सीपीथॉन क्या करता है ।
float(औरdouble) दशमलव फ़्लोटिंग-पॉइंट नहीं हैं - वे बाइनरी फ़्लोटिंग-पॉइंट हैं - इसलिए दशमलव स्थिति के लिए राउंडिंग अर्थहीन है। हालाँकि, आप आउटपुट को राउंड कर सकते हैं।