C ++ में टेम्प्लेट का उपयोग करके डेरिवेटिव की गणना

एक पोस्ट से प्रेरित है। रास्ते के साथ, मुझे लैम्ब्डा एक्सप्रेशन के अपने स्वयं के कार्यान्वयन के समान कुछ मिला :) कंप्लीट स्टेज पर भी व्युत्पन्न की गणना करने की क्षमता के साथ। किसी फ़ंक्शन को निर्दिष्ट करने के लिए, आप ऑपरेटर +, -, *, /, के साथ-साथ कई मानक गणितीय कार्यों का उपयोग कर सकते हैं।
Sqr - चुकता
Sqrt - स्क्वायर रूट
पोव - घातांक
Exp - घातीय कार्य
लॉग - लॉगरिदम
पाप, कोस, टीजी, सीटीजी, असिन, एसीस, एटीजी, एक्टग - त्रिकोणमिति

व्युत्पन्न की गणना व्युत्पन्न फ़ंक्शन का उपयोग करके की जाती है। इनपुट पर, उसके पास एक फ़नकार है, और आउटपुट पर, वह भी है। व्युत्पन्न को सटीक रूप से गणना करने के लिए, विशेष सिंटैक्स का उपयोग करके परिभाषित एक फ़नकार इनपुट होना चाहिए। सिंटैक्स सहज है (कम से कम मुझे आशा है)। यदि व्युत्पन्न इनपुट पर एक उपयुक्त हस्ताक्षर (डबल -> डबल) के साथ कोई अन्य फ़ंक्टर या लैम्ब्डा लगाया जाता है, तो व्युत्पन्न की गणना लगभग की जाएगी।
एक उदाहरण:

#include <iostream> #include "CrazyMath.h" using namespace std; using namespace CrazyMath; auto global = Tg(X) + Ctg(X) + Asin(X) * Acos(X) - Atg(X) / Actg(X); auto d_global = derivative(global); int main() { auto f1 = (Pow(X, 3) + 2 * Sqr(X) - 4 * X + 1 / Sqrt(1 - Sqr(X))) * (Sin(X) + Cos(X) * (Log(5, X) - Exp(2, X))); auto f2 = derivative(f1) * Sqrt(X - Tg(X / 4)); auto f3 = [](double x) -> double { return sin(x); }; auto df1 = derivative(f1); auto df2 = derivative(f2); auto df3 = derivative(f3); cout << "f(x)\t\tf'(x)" << endl; cout << f1(0.5) << " \t" << df1(0.5) << endl; cout << f2(0.5) << " \t" << df2(0.5) << endl; cout << f3(0) << " \t" << df3(0) << endl; cout << global(0.5) << " \t" << d_global(0.5) << endl; char temp[4]; cout << "\nPress ENTER to exit..." << endl; cin.getline(temp, 3); return 0; } 

यह इस तरह काम करता है:

 // CrazyMath.h,  //--------------------------------------------------- // base functions class Const { public: typedef Const Type; Const(double x) : m_const(x) {} double operator()(double) {} private: double m_const; }; class Simple { public: typedef Simple Type; double operator()(double x) { return x; } }; template <class F1, class F2> class Add { public: typedef typename Add<F1, F2> Type; Add(const F1& f1, const F2& f2) : m_f1(f1), m_f2(f2) {} double operator()(double x) { return m_f1(x) + m_f2(x); } F1 m_f1; F2 m_f2; }; //--------------------------------------------------- // helpers template <class F1, class F2> Add<F1, F2> operator+(const F1& f1, const F2& f2) { return Add<F1, F2>(f1, f2); } template <class F> Add<F, Const> operator+(double value, const F& f) { return Add<F, Const>(f, Const(value)); } template <class F> Add<F, Const> operator+(const F& f, double value) { return Add<F, Const>(f, Const(value)); } // other helpers ... //--------------------------------------------------- // derivatives template <class F> class Derivative { public: Derivative(const F& f, double dx = 1e-3) : m_f(f), m_dx(dx) {} double operator()(double x) { return (m_f(x + m_dx) - m_f(x)) / m_dx; } F m_f; double m_dx; typedef std::function<double (double)> Type; Type expression() { return [this](double x) -> double { return (m_f(x + m_dx) - m_f(x)) / m_dx; }; } }; template<> class Derivative<Const> { public: typedef Const Type; Derivative<Const> (Const) {} double operator()(double) { return 0; } Type expression() { return Const(0); } }; template<> class Derivative<Simple> { public: typedef Const Type; Derivative<Simple> (Simple) {} double operator()(double) { return 1; } Type expression() { return Const(1); } }; template <class F1, class F2> class Derivative< Add<F1, F2> > { public: Derivative< Add<F1, F2> > (const Add<F1, F2>& f) : m_df1(f.m_f1), m_df2(f.m_f2) { } double operator()(double x) { return m_df1(x) + m_df2(x); } Derivative<F1> m_df1; Derivative<F2> m_df2; typedef typename Add<typename Derivative<F1>::Type, typename Derivative<F2>::Type> Type; Type expression() { return m_df1.expression() + m_df2.expression(); } }; // other derivatives ... template <class F> typename Derivative<F>::Type derivative(F f) { return Derivative<F>(f).expression(); } extern Simple X; 

CrazyMath.h फ़ाइल काफी बड़ी हो गई है, इसलिए यह पूरी तरह से लेख में इसे शामिल करने का कोई मतलब नहीं है। जो लोग रुचि रखते हैं, वे जीथब से स्रोत डाउनलोड कर सकते हैं

यूपीडी ने व्युत्पन्न वर्ग में टाइप विधि जोड़ दी और अभिव्यक्ति विधि रिटर्न के प्रकार के अनुसार टाइप किया गया है। अभिव्यक्ति विधि आगे के भेदभाव के लिए उपयुक्त एक फ़नकार देता है। हालांकि, जब 2, 3 और उच्चतर आदेशों के कंप्यूटिंग डेरिवेटिव, अभिव्यक्ति का आकार तेजी से बढ़ता है, तो संकलन में एक लंबा समय लग सकता है।