कम्प्यूटिंग फ्लोटिंग पॉइंट गणना

जैसा कि आप जानते हैं, सी ++ में आप संकलन चरण में जटिल फ्लोटिंग-पॉइंट गणना नहीं कर सकते हैं। मैंने इस कष्टप्रद दोष से छुटकारा पाने की कोशिश करने का फैसला किया। हम जिस लक्ष्य का उपयोग करने जा रहे हैं वह रूट की गणना का उदाहरण है:

typedef RATIONAL(2,0) x; typedef sqrt<x>::type result; 

संख्या की जड़ की गणना संकलन चरण में की जाती है। संख्या का प्रतिनिधित्व दो पूर्णांकों के अनुपात के रूप में संग्रहीत किया जाता है, इसलिए मूल्य प्राप्त करने के लिए, आपको प्राप्त () विधि के माध्यम से पहुंचने की आवश्यकता है;

 std::cout << result::get() << std::endl; 

1.41421356

फ्लोटिंग पॉइंट नंबरों को स्टोर करने के लिए, हम संबंध का उपयोग करेंगे
दो पूर्णांक - एक अंश।

 template <int64_t A, int64_t B> struct rational_t { const static int64_t a = A, b = B; static double get() { return (double)a/b; } }; 

उदाहरण के लिए, संख्या 2 को घोषित करने के लिए, आपको टाइप करने की आवश्यकता है rational_t ​​<2,1> (पहले दो)

 rational_t<3,2> -> 3/2 rational_t<56,10> -> 56/10 = 5.6 rational_t<3,100> -> 3/100 = 0.03 

सुविधा के लिए, हम चालाक राष्ट्रीय मैक्रो का उपयोग करेंगे:

 #define RATIONAL(A1, A2) rational_t<(int)(A1##A2), pow<10, sizeof(#A2)-1>::value> 

इसे एक उदाहरण के रूप में मानें: राष्ट्रीय (12.34) - 12.34 (12 अंक 34 सौवां भाग) घोषित करता है

 1) A1 ## A2 1234 में दो तर्क देता है
 2) आकार (# A2) -1 = आकार ("34") - 1 = 3 - 1 = 2
 3) पाउ <10, 2> :: मूल्य = 10 से 2 = 100 की शक्ति

इस प्रकार, RATIONAL (12.34) एक प्रकार को तर्कसंगत_t घोषित करता है <1234, 100> (अर्थात 1234/100 = 12.34)
पाव फ़ंक्शन इस तरह लिखा जाता है:

 template <int V, unsigned D> struct pow { const static int value = V * pow<V, D - 1>::value; }; template <int V> struct pow<V, 0> { const static int value = 1; }; 

हम तर्कसंगत_ट पैटर्न के लिए अंकगणितीय संचालन का वर्णन करते हैं।
अंशों का जोड़: a1 / b1 + a2 / b2 = (a1 * b2 + a2 * b1) / (b1 * b2), इसलिए:

 template <class R1, class R2> struct plus { typedef rational_t<R1::a * R2::b + R2::a * R1::b, R1::b * R2::b> type; }; 

निरंतर जोड़ के साथ, अंश और हर लगातार निरपेक्ष मूल्य में बढ़ेगा। अगले जोड़ के दौरान अतिप्रवाह से बचने के लिए, अंश को कम करना आवश्यक है। हम अतिरिक्त फ़ंक्शन को फिर से लिखते हैं:

 template <class R1, class R2> struct plus { typedef rational_t<R1::a * R2::b + R2::a * R1::b, R1::b * R2::b> type1; typedef typename reduce<type1>::type type; }; 

कम मेटा फ़ंक्शन एक अस्पष्ट अंश लेता है और संक्षिप्त रूप देता है। यहां शेष संचालन हैं:

 template <class R1, class R2> struct minus { typedef rational_t<R1::a * R2::b - R2::a * R1::b, R1::b * R2::b> type1; typedef typename reduce<type1>::type type; }; template <class R1, class R2> struct mult { typedef rational_t<R1::a * R2::a, R1::b * R2::b> type1; typedef typename reduce<type1>::type type; }; template <class R1, class R2> struct divide { typedef rational_t<R1::a * R2::b, R1::b * R2::a> type1; typedef typename reduce<type1>::type type; }; 

तुलना ऑपरेशन:

 template <class R1, class R2> struct less { static const bool value = (R1::a * R2::b - R2::a * R1::b) < 0; }; 

कमी की आवश्यकता को निर्धारित करने वाले मेटाफ़ंक्शन को परिभाषित करें। 64-बिट प्रारूप में भंडारण के लिए अधिकतम अनुमेय संख्या (2 ^ 64) ^ 0.5 / 2 = 1ll << 31 होगी, इसलिए:

 template <class R> struct require_reduce { const static int64_t max = (1ll<<31); const static bool value = (R::a >= max) || (R::b >= max); }; 

मूल्य का मतलब अंश को कम करने की आवश्यकता है, अन्यथा ऑपरेशन के दौरान अतिप्रवाह हो सकता है।
अंश को पहले ठीक से घटाया जाना चाहिए - जीसीडी द्वारा विभाजन के आधार पर (कम करें)
यदि कमी विफल रही, तो अंश को विभाजित करके गलत तरीके से घटाएं और
हर 2 पर है (कम करें)
साफ-सुथरी कटौती के मेटा-फंक्शन की घोषणा करें:

 template <bool, class R> struct reduce_accurate; 

गलत कटौती, जिसके बाद फिर से कम करने का प्रयास किया जाता है
ध्यान से, जब तक, निश्चित रूप से, यह आवश्यक है:

 template <bool, class R> struct reduce_inaccurate { typedef rational_t<(R::a >> 1), (R::b >> 1)> type_; typedef typename reduce_accurate<require_reduce<type_>::value, type_>::type type; }; 

यदि आवश्यक नहीं है, तो एक मैला कमी एक ही मूल्य लौटाती है:

 template <class R> struct reduce_inaccurate<false, R> { typedef R type; }; 

एक साफ कमी के लिए, उन्होंने टिप्पणियों में जीसीडी का उपयोग करने का सुझाव दिया, यह इसके साथ तेज हो गया, हालांकि यह उम्मीद थी कि नहीं।
जीसीडी की गणना (धन्यवाद ग्रिज़ोब्र ):

 template <int64_t m, int64_t n> struct gcd; template <int64_t a> struct gcd<a, 0> { static const int64_t value = a; }; template <int64_t a, int64_t b> struct gcd { static const int64_t value = gcd<b, a % b>::value; }; 

कटौती फ़ंक्शन जीसीडी में अंश और भाजक को विभाजित करता है और यदि आवश्यक हो, तो गलत कटौती करता है।

 template <bool, class R> struct reduce_accurate { template <bool, class R> struct reduce_accurate { const static int64_t new_a = R::a / gcd<R::a, R::b>::value; const static int64_t new_b = R::b / gcd<R::a, R::b>::value; typedef rational_t<new_a, new_b> new_type; typedef typename reduce_inaccurate<require_reduce<new_type>::value, new_type>::type type; }; }; 

यदि सटीक कमी पर्याप्त नहीं है, तो एक गलत प्रदर्शन करें:

 template <class R> struct reduce_accurate<false, R> { typedef typename reduce_inaccurate<require_reduce<R>::value, R>::type type; }; 

चलो सबसे दिलचस्प भाग पर चलते हैं, हम न्यूटन की विधि के अनुसार रूट की गणना के लिए एक एल्गोरिथ्म लिखेंगे।
यह कार्यान्वयन सटीक होने का दावा नहीं करता है और उदाहरण के रूप में दिया जाता है।

  : sqrt_eval(p, res, x) { t1 = x/res t2 = res+t1 tmp = t2/2 if (p-1 == 0) return tmp; return sqrt_eval(p-1, tmp, x) } 

Rational_t ​​का उपयोग करना:

 template <int64_t p, class res, class x> struct sqrt_eval { typedef typename divide<x, res>::type t1; typedef typename plus<res, t1>::type t2; typedef typename divide<t2, rational_t<2,1> >::type tmp; typedef typename sqrt_eval<p-1, tmp, x>::type type; }; template <class res, class x> struct sqrt_eval<0, res, x> { typedef res type; }; 

 sqrt(x) { res = (x + 1)/2 return sqrt_eval(15, res, x) } 

15 - न्यूटन के एल्गोरिथ्म में चरणों की संख्या।

 template <class x> struct sqrt { typedef typename divide< typename plus<x, rational_t<1,1> >::type, rational_t<2,1> >::type res; typedef typename sqrt_eval<15, res, x>::type type; }; template <int64_t a> struct sqrt< rational_t<0, a> > { static const int64_t value = 0; }; 

एक उदाहरण:

 #include <iostream> #include "rational_algo.hpp" int main() { std::cout.precision(15); const double s = rational::sqrt<RATIONAL(2,0)>::type::get(); std::cout << s << std::endl; std::cout << 2-s*s << std::endl; return 0; } 

उदाहरण पूरी फ़ाइल: pastebin.com/ea7S2KTd
प्रोजेक्ट: github.com/korkov/rational

_{UPD: यह एक अपडेटेड वर्जन है, टिप्स और करेक्शन के लिए सभी का धन्यवाद।}