2 युगल की तुलना करें लेकिन सी

Question

पर सभी अंकों के बिना मैं 2 डबल की तुलना करना चाहता हूं लेकिन सभी अंकों के बिना। उदाहरण के लिए मेरे पास यह डबल 1.548799778 है और यह 1.5479 9 0 9 78 है और मैं प्रत्येक से 1.xx की तुलना करना चाहता हूं। मैं इस डबल को 1.xx "कैसे" गोल कर सकता हूं ?? धन्यवाद

Answer 1

उपयोग floor या math.h

Answer 2

से ceil समारोह

(x==0.0 && y==0.0) || fabs(x-y)/max(fabs(x),fabs(y))<1e-6 

तरह तुलना करने के लिए है कि x और y काफी निकट हैं, कुछ x उपयोग floor(x) या ceil(x) दौर के रूप में जनवरी Vorcak ने सुझाव दिया

Addenda : मुझे यकीन है कि यह NaN के लिए काम करेंगे (विवरण के सिर में दर्द दे)

Answer 3

एक तकनीक इस तरह trunc समारोह का उपयोग किया जाएगा नहीं कर रहा हूँ:

double d1, d2; 
d1 = 1.548799778; 
d2 = 1.547990978; 
if (trunc(d1*100) == trunc(d2*100)) { 
    // do your thing 
} 

100 का उपयोग करना है क्योंकि आप दो दशमलव स्थानों चाहते हैं। यदि आप अधिक या कम दशमलव स्थान चाहते हैं तो आप अन्य नंबरों का उपयोग कर सकते हैं।

Answer 4

एक और संभावना सहिष्णुता के साथ तुलना का उपयोग करना है।

if (fabs(a - b) <= tolerance) { .... } 

अपनी सहनशीलता को चुनें कि आप कितनी सटीकता चाहते हैं।

उदाहरण के लिए, आप पहले 2 अंकों के उपयोग के लिए 0.001 होने के लिए सहनशीलता चुन सकते हैं।

Answer 5

निम्नलिखित में सबसे तेज़ निष्पादन समय हो सकता है, और यह फ़्लोटिंग पॉइंट चर की सामान्य तुलना के रूप में उपयोगी है।

if ( x-y < 0.01 && x-y > -0.01) 

Answer 6

आप Math.h कार्यों

double check(double number) 
{ 
    if (modf(number, 0) >= .5) 
     return number >= 0 ? ceil(number) : floor(number); 
    else 
     return number < 0 ? ceil(number) : floor(number); 
} 

double round(double number, unsigned int places) 
{ 
    double off = pow(10, places); 
    return check(number * off)/off; 
} 

if(round(1.548799778, 2) == round(1.547990978, 2)) 
{ 
} 

Answer 7

इस का उपयोग अगर जरूरत काफी तेजी से और विन्यास होना चाहिए कर सकते हैं। कोई अतिरिक्त विरासत पेश नहीं की गई है

int compare(double a, double b) 
{ 
    static const double PRECISION = 0.0001; 
    if (a < b) 
     return b - a < PRECISION ? 0 : 1; 
    else 
     return a - b < PRECISION ? 0 : -1; 
}