हम संकलन चरण पर संख्या ई के मूल्य की गणना करते हैं

स्कॉट मेयर्स द्वारा "सी + का प्रभावी उपयोग" पुस्तक को देखते हुए, जो (और मैं किसी को आश्चर्यचकित नहीं करूंगा) सभी प्रशंसा के योग्य हूं, मुझे बहुत छुआ गया था, फिर किस उत्साह, प्रेरणा, उत्साह के साथ (शायद यह मुझे प्रतीत हुआ?) लेखक टेम्पलेट्स और उनकी क्षमताओं के बारे में बात करता है। मुझे तुम्हें एक छोटा सा टुकड़ा दे दो:

टेम्प्लेट मेटाप्रोग्रामिंग ( TMP ) संकलन-आधारित C ​​++ प्रोग्राम लिखने की प्रक्रिया है जिसे संकलित समय पर निष्पादित किया जाता है। एक मिनट के लिए इसके बारे में सोचें: टेम्पलेट मेटाप्रोग्राम C ++ में लिखा गया एक प्रोग्राम है जो C ++ कंपाइलर के अंदर चलता है ...
यह साबित हो चुका है कि टीएमपी तकनीक पूरी तरह से ट्यूरिंग मशीन प्रदान करती है, अर्थात इसमें किसी भी गणना के लिए पर्याप्त शक्ति है ...

हाँ ... मेरा दिल धड़क रहा था, मैं फिर से आश्चर्यचकित था - बस सोचो - सभी आगामी परिणामों के साथ एक पूर्ण ट्यूरिंग मशीन ... मेरे लिए, यह बस अविश्वसनीय और आश्चर्यजनक है ... हालांकि कौन जानता है ...

मेरा सुझाव है कि महान अवसरों और अविश्वसनीय कारनामों की दुनिया के एक बहुत छोटे टुकड़े को देखते हुए - आइए हम संकलन चरण में गणना करने की कोशिश करते हैं कुख्यात नंबर ई का मान।

इसकी गणना कैसे करें (कुछ त्रुटि के साथ) - टेलर श्रृंखला , या बल्कि मैकलॉरिन श्रृंखला , आपको बताएगी:


यानी हमें एक संख्या के भाज्य को पढ़ने, एक शक्ति को बढ़ाने, संक्षिप्त करने और भिन्नात्मक संख्याओं के साथ काम करने में सक्षम होने की आवश्यकता होगी ... और यह सब C ++ टेम्पलेट्स की मदद से।
शुरू करने के लिए, मैं भिन्नात्मक संख्याओं से निपटना चाहूंगा - आपको किसी तरह अंश और हर को बचाने की जरूरत है, और उन तक पहुंच है ( एन - न्यूमेरियर, डी - डेनोमिनेटर):

template<int n, int d> struct Fractional { enum { N = n, D = d }; }; 

यह सरल है, लेकिन शून्य हर के बारे में क्या? आइये इसे आजमाते हैं:

 template<int n, int d> struct Fractional { private: enum { NonZeroDenominator = n / d }; public: enum { N = n, D = d }; }; 

हम उपयोग करते हैं:

 typedef Fractional<9, 0> number; // ... int temp = number::D; 

Msvc10 के मामले में, हमें error C2057: expected constant expression C2057 जैसा कुछ मिलता है error C2057: expected constant expression अप्राप्य है, लेकिन अगर हम त्रुटि के स्थान पर जाते हैं, तो हम केवल NonZeroDenominator चर देखेंगे - कम से कम कुछ ...

तो, हम 2 नंबर बचाने में सक्षम हैं, लेकिन भिन्नों को कम करने के बारे में क्या? यहां हमें पहले से ही दो नंबरों के gcd (सबसे सामान्य विभाजक) को सीखना चाहिए - एक पुनरावर्ती एल्गोरिथ्म हमारे लिए उपयुक्त है:

 int gcd(int a, int b) { if(b == 0) return a; return gcd(b, a % b); } 

जो टेम्प्लेट में बदल जाता है:

 template<int n1, int n2> struct GCD { enum { value = GCD<n2, n1 % n2>::value }; }; template<int n1> struct GCD<n1, 0> { enum { value = n1 }; }; 

यह आसान है, है ना? - हम टेम्पलेट का सबसे सामान्य कार्यान्वयन लिखते हैं और विशेष मामलों के लिए विशेषज्ञता करते हैं (यदि दूसरी संख्या शून्य है - परिणाम पहली संख्या है)।
ऊपर लिखी हर चीज की मदद से हम भिन्नात्मक संख्या का अंतिम संस्करण बनाते हैं:

 template<int n, int d> struct Fractional { private: enum { NonZeroDenominator = n / d }; enum { gcd = GCD<n, d>::value }; public: enum { N = n / gcd, D = d / gcd }; }; 

जाने-माने फ़ार्मुलों का उपयोग करना - विभाजित करना, गुणा करना, घटाना, हमारी संख्याएँ जोड़ना:

 // // Divide // template<typename n, typename d> struct Divide { }; template<int n1, int d1, int n2, int d2> struct Divide<Fractional<n1, d1>, Fractional<n2, d2> > { private: typedef Fractional<n1, d1> n; typedef Fractional<n2, d2> d; public: typedef Fractional<n::N * d::D, n::D * d::N> value; }; // // Multiple // template<typename n, typename d> struct Multiple { }; template<int n1, int d1, int n2, int d2> struct Multiple<Fractional<n1, d1>, Fractional<n2, d2> > { private: typedef Fractional<n1, d1> n; typedef Fractional<n2, d2> d; public: typedef Fractional<n::N * d::N, n::D * d::D> value; }; // // Substract // template<typename n, typename d> struct Substract { }; template<int n1, int d1, int n2, int d2> struct Substract<Fractional<n1, d1>, Fractional<n2, d2> > { private: typedef Fractional<n1, d1> n; typedef Fractional<n2, d2> d; public: typedef Fractional<n::N * d::D - d::N * n::D, n::D * d::D> value; }; // // Add // template<typename n, typename d> struct Add { }; template<int n1, int d1, int n2, int d2> struct Add<Fractional<n1, d1>, Fractional<n2, d2> > { private: typedef Fractional<n1, d1> n; typedef Fractional<n2, d2> d; public: typedef Fractional<n::N * d::D + d::N * n::D, n::D * d::D> value; }; 

फिर से - हम अपने " फ़ंक्शन " का एक खाली स्केच लिखते हैं, उदाहरण के लिए Divide - यह देखते हुए कि यह (फ़ंक्शन) 2 तर्क लेता है। और फिर, टेम्पलेट के एक आंशिक विशेषज्ञता की मदद से, हम स्पष्ट करते हैं कि हम कुछ नहीं देखना चाहते हैं, अर्थात् टेम्पलेट की पहचानकर्ता की हमें आवश्यकता है, अर्थात्। उदाहरण के लिए Divide<n1, n2> । उपयोग :

  typedef Fractional<4, 20> n1; typedef Fractional<5, 32> n2; typedef Add<n1, n2>::value summ; printf("%i/%i\n", summ::N, summ::D); // 57/160 

हमें घातांक और भाज्य की भी जरूरत है, जिसकी परिभाषा अपने लिए बोलती है:

 // // Factorial // template<int N> struct Factorial { enum { value = N * Factorial<N - 1>::value }; }; template<> struct Factorial<0> { enum { value = 1 }; }; // // Power // template<int x, int n> struct Pow { enum { value = x * Pow<x, n - 1>::value }; }; template<int x> struct Pow<x, 0> { enum { value = 1 }; }; 

इसलिए, अब हमारे पास सूत्र को लागू करने के लिए आवश्यक सभी चीज़ों का पूरा सेट है - यह स्पष्ट है कि हम असीम रूप से सारांश नहीं करेंगे, लेकिन हम कितना कर सकते हैं, अर्थात्। उदाहरण के लिए, एक्सप्रेशन Exp<4, 8>::value एक भिन्नात्मक संख्या देगा जो संख्यात्मक रूप से 4 वें अंश में घातांक के बराबर होगा और समावेशी शब्द के केवल 8 (अनंत पास) तक योग किया जाता है।

समस्या यह है कि हम भिन्नात्मक संख्याओं को कैसे जोड़ते हैं, जो संख्यात्मक मान भी नहीं हैं - ये केवल प्रकार हैं ! हां, उनके पास संख्यात्मक डेटा होते हैं, लेकिन आपको अभी भी श्रृंखला की राशि की गणना के दौरान उन्हें प्राप्त करने की आवश्यकता है ... लेकिन एक समाधान है और इसमें इस तथ्य में शामिल है कि हम व्युत्पन्न वर्ग से आधार वर्ग का डेटा (और टाइपडेफ़्स - सबसे महत्वपूर्ण) प्राप्त कर सकते हैं। बिलकुल सही! - श्रृंखला के योग की गणना करने के लिए, हमें विरासत में मिला और विरासत में मिला होगा, और विरासत में मिला होगा ... आदर्श रूप से विज्ञापन infinitum।
कोड का टुकड़ा:

 // // Exponent // template<int x, int n> struct Exp : public Exp<x, n - 1> { private: typedef typename Exp<x, n - 1>::value previous; protected: typedef Fractional<Pow<x, n>::value, Factorial<n>::value> current; public: typedef typename Add<current, previous>::value value; }; template<int x> struct Exp<x, 0> { public: typedef Fractional<Pow<x, 0>::value, Factorial<0>::value> current; public: typedef current value; }; 

current में श्रृंखला के एक सदस्य का मान है - अर्थात वर्गों के इस पूरे पदानुक्रम में एक वर्ग, मोटे तौर पर बोलना, एक सदस्य के मूल्य को संग्रहीत करने के लिए डिज़ाइन किया गया है। और इसकी मदद से वह आधार वर्ग का डेटा ले सकता है - अर्थात श्रृंखला के पिछले सदस्य का मूल्य - यह सब हमें यह तथ्य देता है कि श्रृंखला के एक अलग तत्व के मूल्य के अलावा, वर्तमान कक्षा में हमारे पास इस तत्व (वर्ग) तक श्रृंखला का योग सम्मिलित रूप से है।

और अंत में, और अंत में, हम गर्व से निम्नलिखित लिख सकते हैं:

 int main() { //  typedef Exp<1, 8>::value result; printf("%i/%i\n", result::N, result::D); //   printf("%f\n", result::N / static_cast<float>(result::D)); } 

32 बिट मशीन पर, श्रृंखला के 8 से अधिक सदस्यों को नहीं लिया जा सकता है - int अतिप्रवाह।

परिणाम : 2.718279 (109601/40320)।

जादू :)
मुझे आशा है कि आपको अच्छा लगा होगा। आपका ध्यान देने के लिए धन्यवाद।

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