गतिशील चटाई। c ++ में कार्य करता है

हैलो, Habrausers।
हाल ही में, मैंने C ++ में अनाम कार्यों के बारे में एक लेख यहां पढ़ा, और तब मेरे दिमाग में यह विचार आया: मुझे उन कार्यों के साथ काम करने के लिए तत्काल एक वर्ग लिखने की आवश्यकता है जो गणित से हमें परिचित हैं। अर्थात्, वे एक वास्तविक तर्क लेते हैं और एक वास्तविक मूल्य लौटाते हैं। कार्यान्वयन के बारे में सोचने के बिना, ऐसी वस्तुओं को यथासंभव सरल रूप से संभालने का अवसर देना आवश्यक है।
और यहाँ है कि मैंने इसे कैसे लागू किया।

समस्या।

ये सभी लंबोदर भाव कभी-कभी अजीब तरह से व्यवहार करते हैं, कम से कम मेरे लिए। यह शायद इस तथ्य के कारण है कि मैं पूरी तरह से समझ नहीं पा रहा हूं कि इन अभिव्यक्तियों को बनाने का तंत्र कैसे काम करता है। मैं पहले से मौजूद आदिम क्रियाओं के आधार पर बड़े कार्य बनाऊंगा, अर्थात् f (x) = a (x) + b (x) जैसा कुछ। और इसका मतलब है कि कार्यों के निर्माण में केवल मध्यवर्ती लिंक के रूप में बनाए गए सभी लंबोदा, उन तक पहुंच के लिए सहेजे जाने चाहिए। अब मैं अधिक स्पष्ट रूप से समझाने की कोशिश करूंगा।

मान लें कि हम एक निश्चित प्रक्रिया चाहते हैं कि ए और बी की एक जोड़ी लें और एक नई अभिव्यक्ति लौटें, उदाहरण के लिए, 5 ए + बी। हमारी प्रक्रिया एक लैम्ब्डा 5 ए बनाएगी, फिर 5 ए और बी का उपयोग कर 5 ए और बी बनाएं। परिणामी प्रक्रिया वापस आएगी और समाप्त होगी। पल lambda 5A गुंजाइश से गायब हो जाएगा, और लौटे अभिव्यक्ति बस काम नहीं करेगा।

निर्णय।

मैंने सभी लंबों का एक वैश्विक संग्रह बनाने का फैसला किया, निर्माणाधीन सभी अभिव्यक्तियों को इसमें संग्रहीत किया गया है, और संग्रह के तत्वों के केवल संकेत वस्तुओं में मौजूद होंगे। मैं कोड समझाऊंगा:

#include <xstddef> #include <functional> #include <list> typedef std::tr1::function<double(double)> realfunc; // y = f(x) as in maths class func_t { protected: static std::list<realfunc> all_functions; //   realfunc *f; //    public: func_t(); func_t(const double); func_t(const realfunc&); func_t(const func_t&); ~func_t() {}; friend func_t operator+ (const func_t&, const func_t&); friend func_t operator- (const func_t&, const func_t&); friend func_t operator* (const func_t&, const func_t&); friend func_t operator/ (const func_t&, const func_t&); friend func_t operator^ (const func_t&, const func_t&); func_t operator() (const func_t&); double operator() (const double); }; 

शुरुआत के लिए, डिजाइनरों ।
डिफ़ॉल्ट निर्माता (पैरामीटर के बिना) एक फ़ंक्शन बनाएगा जो एक तर्क देता है। यह प्रस्थान का बिंदु होगा। f (x) = x।
बाकी स्पष्ट हैं: दूसरा एक स्थिर फ़ंक्शन बनाता है - f (x) = c, तीसरा मेरी श्रेणी के ऑब्जेक्ट में वांछित प्रकार के लंबो को बदल देता है, बाद वाला सिर्फ एक कॉपी कंस्ट्रक्टर है।

कंस्ट्रक्टर्स के कार्यान्वयन, यह तुरंत दिखाएगा कि कक्षा के सभी तरीके कैसे व्यवस्थित होते हैं:

 func_t::func_t() { f = &(*all_functions.begin()); } func_t::func_t(const double c) { func_t::all_functions.push_back( [=](double x)->double {return c;} ); this->f = &all_functions.back(); } func_t::func_t(const realfunc &realf) { func_t::all_functions.push_back(realf); this->f = &all_functions.back(); } func_t::func_t(const func_t &source) { this->f = source.f; } 

जैसा कि आप देख सकते हैं, मैं एक लैम्ब्डा बनाता हूं, इसे संग्रह के अंत में धकेल देता हूं और एक पॉइंटर के साथ एक ऑब्जेक्ट वापस करता हूं।
मैं तुरंत पहले निर्माता को समझाना चाहता हूं। जैसा कि मैंने कहा, एक "तर्क" का निर्माण, अर्थात्। function f (x) = x मेरी कक्षा के साथ लगभग किसी भी कार्य की शुरुआत है, इसलिए मैंने इस फ़ंक्शन को हाइलाइट करने और संग्रह के पहले सेल में इस अभिव्यक्ति को रखने का फैसला किया। और फिर डिफ़ॉल्ट कंस्ट्रक्टर को कॉल करते समय, ऑब्जेक्ट को हमेशा संग्रह के पहले तत्व को एक पॉइंटर मिलता है।

अरे हाँ, मैं लगभग भूल गया, सभी डिजाइनरों का उपयोग अंतर्निहित रूपांतरण के लिए किया जा सकता है, जो मुख्य प्रयोज्य बनाता है।

अगला, ऑपरेटरों । उनके साथ, सब कुछ सरल है। मैं उनमें से तीन दिखाऊंगा: पहला लागू जोड़, दूसरा रचना का कार्य और तीसरा अनुमान।

 func_t operator+ (const func_t &arg, const func_t &arg2) { realfunc realf = [&](double x)->double { return (*arg.f)(x) + (*arg2.f)(x); }; return func_t(realf); } func_t func_t::operator() (const func_t &arg) { realfunc realf = [&](double x)->double { return (*f)((*arg.f)(x)); }; return func_t(realf); } double func_t::operator() (const double x) { return (*f)(x); } 

यह सरल है, है ना? पहले दो में, आवश्यक लैम्ब्डा फिर से बनाया जाता है, और फिर ऑब्जेक्ट के निर्माता को भेजा जाता है। तीसरी विधि में आम तौर पर फ्रीबी =)
मुझे समझाएं कि हर जगह मैं विधि के तर्कों तक पहुंचने के लिए लिंक द्वारा पर्यावरण हस्तांतरण का उपयोग करता हूं (यह [और] लैम्ब्डा से पहले) है।

सिद्धांत रूप में, वह सब है। अब तकनीकी विवरण की एक जोड़ी। मैं स्थैतिक क्षेत्रों को शुरू करने में बहुत मजबूत नहीं हूं, इसलिए मुझे भयानक रूप से बोझिल और बदसूरत तरीकों को याद करना पड़ा जो मैंने एक बार कहीं जासूसी की थी।

 protected: static class func_t_static_init_class { public: func_t_static_init_class(); }; static func_t_static_init_class func_t_static_init_obj; ... //Static: std::list<realfunc> func_t::all_functions = std::list<realfunc>(); func_t::func_t_static_init_class func_t::func_t_static_init_obj = func_t::func_t_static_init_class(); func_t::func_t_static_init_class::func_t_static_init_class() { func_t::all_functions.push_back( [](double x)->double {return x;} ); } 

ठीक है, आप समझते हैं, मैं एक सूची बनाता हूं और पहले तत्व का उल्लेख करता हूं जिसे मैंने पहले ही उल्लेख किया था।
मैं इस हॉरर के लिए माफी चाहता हूं, बस प्रोग्राम करना सीख रहा हूं।

बोनस।

वह मूल रूप से यह है। वहाँ कुछ चीजें हैं जो मैंने पहले से ही पूरी तरह से मनोरंजन के लिए की थीं (हालांकि, वास्तव में, सब कुछ पसंद है)।

सबसे पहले, cmath से कुछ कार्यों को ओवरलोड करें।

 friend func_t sin(const func_t&); friend func_t cos(const func_t&); friend func_t tan(const func_t&); friend func_t abs(const func_t&); ... func_t sin(const func_t& arg) { realfunc realf = [&](double x)->double { return sin((*arg.f)(x)); }; return func_t(realf); } 

दूसरी बात, जहां बिना डेरिवेटिव्स और एंटिडराइवर्स =) हैं

 static double delta_x; func_t operator~ (); func_t operator| (const double); ... double func_t::delta_x = 0.01; func_t func_t::operator~ () { realfunc realf = [&](double x)->double { return ((*f)(x + delta_x / 2) - (*f)(x - delta_x / 2)) / delta_x; }; return func_t(realf); } func_t func_t::operator| (double first_lim) { realfunc realf = [=](double x)->double { double l_first_lim = first_lim; //will move with this copy of first_lim double area = 0; bool reverse = x < first_lim; //first_lim > second_lim? if (reverse) { l_first_lim = x; x = first_lim; } double l_delta_x = delta_x; //step while (l_first_lim < x) { //move along the whole span if ((l_first_lim += l_delta_x) > x) //stepped too far? l_delta_x += x - l_first_lim; //the last l_delta_x may be shorter /* integral summ, the point is chosen between the point for f(x) is chosen between l_first_lim and l_first_lim + l_delta_x */ area += l_delta_x * (*f)(l_first_lim + l_delta_x / 2); } return area * (reverse?-1:1); }; return func_t(realf); } 

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

निष्कर्ष।

खैर, बस इतना ही। उम्मीद है कि दिलचस्प था। मुझे नहीं पता कि ऐसा कुछ होता है या नहीं, लेकिन मैंने कक्षाओं में अभ्यास किया है, और सभी प्रकार के & *, लेकिन मेरे लिए यह महत्वपूर्ण है =) आपके ध्यान के लिए धन्यवाद।

ऊप्स! एक बात और।

वैसे हां, इसका उपयोग कैसे करें।
उदाहरण के लिए, इस तरह:

 func_t f1 = cos(5 * func_t() + 8); 

यह, जाहिरा तौर पर, एक समारोह बनाएगा
f1 (x) = cos (5x + 8)

या इस तरह:

 funt_t x = func_t(); func_t f = x + f1(x / ~f1); 

यह f (x) = x + f1 (x / f1` (x)) द्वारा पारित कैप है

या इस तरह से अंत में:

 realfunc g = [](double->double) { ... //   ,    ... } func_t f3 = g; 

निष्कर्ष संख्या 2।

खैर अब यकीन के लिए। आपके ध्यान के लिए फिर से धन्यवाद!
अगर कुछ भी, पूर्ण और अधूरा कोड यहाँ है ।