2010-05-14 16 views
9

एसटीएल में या बूस्ट में जेनेरिक सरल तुलना कार्यों का एक सेट है?एसटीएल में फ्लोटिंग पॉइंट तुलना, बूस्ट

मुझे जो मिला वह हमेशा टेम्पलेट पैरामीटर, और/या संरचना टेम्पलेट की तत्कालता की आवश्यकता होती है।

मैं की तरह एक वाक्य रचना के साथ कुछ के लिए देख रहा हूँ:

if (is_equal(x,y)) 
{ 
    ... 
} 

कौन सा रूप में लागू किया जा सकता है:

template <typename T> 
bool is_equal(const T& x, const T& y) 
{ 
    return (fabs(x - y) < Precision<T>::eps); 
} 

संपादित करें: मैं बराबर करने के लिए ऑपरेटर बदल दिया है। मार्सेलो Cantos की टिप्पणी से (नीचे टिप्पणी देखें)

+1

आप अधिक या कम की तुलना करने के लिए एक ईपीएसलॉन का उपयोग क्यों करेंगे? – AshleysBrain

+3

एकमात्र ऐसा समय जब फ़्लोटिंग पॉइंट या डबल प्रकार के लिए एक ईपीएसलॉन तुलना की आवश्यकता होती है, समानता '==' तुलना के लिए होती है। अधिक या कम वास्तव में ईपीएसलॉन के साथ कोई अर्थ नहीं है, क्योंकि जब आप बराबर होते हैं तो इसका उत्तर क्या होता है? यदि आपके द्वारा उल्लिखित तरीके से अधिक या कम दोनों परिभाषित किए गए हैं, तो जब वे बराबर होते हैं, तो आपको बी = सत्य और एक == बी = सत्य मिलेगा, जो गलत है। सही व्यवहार यह है कि iff a == b फिर a> b = false, और Akanksh

+5

@ अंकांक, उपरोक्त कार्यान्वयन सही नहीं हो सकता है, लेकिन ईपीएसलॉन-आधारित असमानताएं आपके द्वारा हाइलाइट किए गए परिदृश्य के लिए सार्थक और महत्वपूर्ण हैं। यदि दो संख्याएं ईपीएसलॉन-आधारित '==' परीक्षण के हिसाब से बराबर होती हैं, तो आपको एक '<' परीक्षण की भी आवश्यकता होती है जो झूठी रिटर्न देता है, भले ही पहला नंबर दूसरे की तुलना में थोड़ा छोटा हो। –

उत्तर

9

मुझे लगता है कि यह करता है किसी भी पुस्तकालय के बारे में पता नहीं है, शायद इसलिए क्योंकि यह एक एक लाइनर के रूप में या शायद क्योंकि यह भुला दिया गया के रूप में सरल है ...

व्यापकता हालांकि चला जाता है के रूप में, आप क्या आप सुनिश्चित हैं ' डी एक दिए गए मूल्य पर एक दिए गए प्रकार के लिए ईपीएसलॉन स्थापित करना पसंद है ... पूरे आवेदन में? व्यक्तिगत रूप से मैं इसे संचालन के आधार पर अनुकूलित करना चाहता हूं (भले ही एक डिफ़ॉल्ट अच्छा होगा)।

अपने ऑपरेटरों के लिए, उन्हें स्वयं क्यों नहीं बनाते?

template <class T> 
bool rough_eq(T lhs, T rhs, T epsilon = Precision<T>::epsilon) // operator== 
{ 
    return fabs(lhs - rhs) < epsilon; 
} 

template <class T> 
bool rough_lt(T lhs, T rhs, T epsilon = Precision<T>::epsilon) // operator< 
{ 
    return rhs - lhs >= epsilon; 
     // tricky >= because if the difference is equal to epsilon 
     // then they are not equal per the rough_eq method 
} 

template <class T> 
bool rough_lte(T lhs, T rhs, T epsilon = Precision<T>::epsilon) // operator<= 
{ 
    return rhs - lhs > -epsilon; 
} 

असमानता और विधियों से अधिक इस से प्राप्त किया जा सकता है।

अतिरिक्त पैरामीटर का अर्थ है कि आप कम्प्यूटेशंस के दिए गए सेट के लिए एक और मान निर्दिष्ट करना चाहते हैं ... एक एप्लिकेशन-व्यापी सेटिंग बहुत सख्त है।

+0

roughlte भी एक <=b <=> के माध्यम से प्राप्त किया जा सकता! संरक्षित करने के लिए है (एक> ख) <=>! (ख <एक) – fulmicoton

+0

हाँ, मैं बस के साथ तुलना में अंतर दिखाना चाहते थे ईपीएसलॉन :) –

0

:

... तो आप भी एक < परीक्षण है कि रिटर्न झूठी जरूरत है, भले ही पहले संख्या कभी तो थोड़ा छोटा होता है दूसरे से ।

मैं कल्पना होगा कार्यान्वयन होगा:

return !roughly_equal(a, b) && a < b; 
+0

यह मेरे प्रश्न का उत्तर नहीं दे रहा है। वैसे भी विपक्ष के बराबर से अधिक से कम लागू करने के लिए बेहतर क्यों है और फिर कम और बराबर परिभाषित करना बेहतर है? x वाई ! ((वाई> एक्स) या (एक्स> वाई)) क्या कुछ प्रदर्शन समस्या है? – fulmicoton

+0

यह नहीं है। आम तौर पर आप '<' '' '== को अलग-अलग परिभाषित करते हैं, भले ही '==' निष्पादन के कारण '<=' से (सिद्धांत में) प्राप्त किया जा सके। क्या महत्वपूर्ण है तार्किक संबंध हालांकि ... –

1

आप बढ़ावा परीक्षण पुस्तकालय के दस्तावेज में, "जटिल" comparation तर्क के कुछ कारणों से मिल सकता है।

संबंधित मुद्दे