MatLab और OOP, अनुकूलन

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

लेखन MatLab कोड अनुकूलन पर एक हालिया पोस्ट से प्रेरित था, अधिक सटीक रूप से, टिप्पणियों में विषय पर गहन अंतर्दृष्टि की आवश्यकता थी।

इसलिए ...

कहानी

लंबे समय तक, MatLab में कोई OOP नहीं था।
2005 में, पहला डरावना दिखने वाला प्रयास दिखाई दिया: एक वर्ग - एक फ़ोल्डर, एक विधि - एक अलग फ़ाइल, गुण - पैरामीटर "गुण नाम" के साथ एक एकल एक्सेस विधि।
"सुंदर" शुरुआत, सौभाग्य से, उन्होंने जल्दी से इसे छोड़ दिया।

कुछ वर्षों बाद उन्होंने ओओपी को एक और परिचित रूप में बनाया - कक्षाएं, विरासत, सब कुछ मनुष्यों की तरह। कुछ विवरणों के अलावा।

कुछ विवरण

अधिभार

एक ही नाम के साथ कई विधियों को परिभाषित करना अभी भी संभव नहीं है। माटलाब खुद इसे वैरिएबल्स के टाइपिंग की कमी (विभिन्न तरीकों के बीच एकमात्र अंतर पैरामीटरों की संख्या) और कार्यों के लिए मापदंडों को पारित करने की वैकल्पिकता (आ गया) की कमी से समझाता है।

जिस तरह से समान नामों के साथ कई फ़ंक्शन लिखना है, संभवतः एक डिस्पैचर फ़ंक्शन के साथ मिलकर जो स्थिति का विश्लेषण करता है और इनमें से एक फ़ंक्शन को कॉल करता है।

सार स्थिर

अमूर्त स्थिर विधियों या गुणों को परिभाषित करने में असमर्थ। और कभी-कभी मैं वास्तव में चाहता हूं।

मुझे अभी तक कोई रास्ता नहीं मिला है, MatLab पता है, इसे बग नहीं मानता है।

मान या संदर्भ द्वारा मापदंडों को पास करना

सभी मापदंडों को मूल्य द्वारा पारित किया जाता है (जो कई उपयोगकर्ताओं को कार्यों का उपयोग करके दूर जाने की वकालत करता है - डरावनी, डरावनी!), लेकिन आलसी विधि के माध्यम से। यानी, परिवर्तन तभी होता है जब चर बदलता है। यदि यह तंत्र अच्छी तरह से समझा जाता है, तो आप गणना की गति में (संदर्भ द्वारा चर के सामान्य हस्तांतरण की तुलना में हार सकते हैं या नहीं खो सकते हैं)।

"साधारण" वर्गों की वस्तुओं को भी मूल्य द्वारा पारित किया जाता है।
हालाँकि, यदि वर्ग हैंडल वर्ग के मानक माटलाब वर्ग से विरासत में मिला है, तो उसकी वस्तुओं को संदर्भ द्वारा पारित किया जाएगा।

उत्पन्न दस्तावेज

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

सौभाग्य से, शिल्पकारों ने एक पर्ल-स्क्रिप्ट को पेंच किया, जो MatLab वर्गों को C ++ (केवल घोषणाएं और टिप्पणियां) में परिवर्तित करता है, जो आपको अपने सभी आकर्षण - आंतरिक लिंक, चित्र, LaTeX, आदि के साथ "मानक" Doxygen का उपयोग करने की अनुमति देता है।

परियोजना (मुझे इससे कोई लेना-देना नहीं है, लेकिन मैं विज्ञापन कर रहा हूं) मतलाब सेंट्रल पर उपलब्ध है।

OOP स्पीड

एक कक्षा में एक नियमित स्क्रिप्ट / फ़ंक्शन से जाने पर, मैंने एक बार 40 बार प्रदर्शन ड्रॉप की खोज की। एक साधारण कॉपी-पेस्ट के साथ कुछ कंघियों के साथ यह एक वर्ग जैसा दिखता है - और यह वह है, कोड 40 गुना धीमा हो जाता है।

चारों ओर खुदाई करने पर, मैंने पाया कि माटलैब उसी कक्षा के तरीकों से वर्ग चर का उपयोग करते समय धीमा हो जाता है। निम्न वर्ग को लें, जिसका एकमात्र तरीका समान फ़ंक्शन की तुलना में कई गुना धीमा है:

 classdef Toto < handle properties RatingDepart TauxRecouv Weight FluxScenario end methods function obj = CollectionTaux2() end function corrigerFluxScenario(obj, Survie, CoefRedGov, CoefRedCredit) nbScenario = size(obj.FluxScenario, 3); for i = 1 : nbScenario for j = 1 : numel(obj.Weight) obj.FluxScenario(i, j, :) = repmat(obj.Weight(j), 1, nbScenario) .* ... reshape(obj.FluxScenario(i, j, :), 1, nbScenario) .* ... (CoefRedGov' .* obj.TauxRecouv(j) + ... CoefRedCredit(:, obj.RatingDepart(j))' .* ... Survie(i, :, obj.RatingDepart(j)) .* (1 - obj.TauxRecouv(j))); end end end end end 

OOP पर स्विच करने पर MatLab इसे "उचित ओवरहेड" मानता है। यही है, प्रत्येक पुनरावृत्ति पर, वे जांचते हैं कि क्या चर को किसी तीसरे पक्ष की प्रक्रियाओं द्वारा बदल दिया गया है, क्या हम अभी भी इस तक पहुंच रखते हैं (जैसे कि कोई वास्तव में इस तरह के मोर्चे कोड को मटलब में लिख सकता है), आदि। "उपयोगी" संचालन।

कई समझदार लोगों के साथ लंबी बातचीत के बाद, मैटलैब अधिक सभ्य कार्यान्वयन के बारे में सोचने के लिए सहमत हुई।

एक चमत्कार की प्रत्याशा में, विधि के प्रवेश द्वार पर स्थानीय चर निर्धारित करने का तरीका है:

 function corrigerFluxScenario(obj, Survie, CoefRedGov, CoefRedCredit) localFluxScenario = obj.FluxScenario; localWeight = obj.Weight; localRatingDepart = obj.RatingDepart; localTauxRecouv = obj.TauxRecouv; nbScenario = size(localFluxScenario, 3); for i = 1 : nbScenario for j = 1 : numel(localWeight) localFluxScenario(i, j, :) = repmat(localWeight(j), 1, nbScenario) .* ... reshape(localFluxScenario(i, j, :), 1, nbScenario) .* ... (CoefRedGov' .* localTauxRecouv(j) + ... CoefRedCredit(:, localRatingDepart(j))' .* ... Survie(i, :, localRatingDepart(j)) .* (1 - localTauxRecouv(j))); end end obj.FluxScenario = localFluxScenario; end 

स्क्रिप्ट की तुलना में प्रदर्शन हानि नगण्य हो जाती है।