📤 👎🏿 👩🏻‍🎓 कई शेड्यूलिंग का समझ से बाहर प्रदर्शन 🔫 🔵 🐄

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

अनुवादक से : रिपोर्ट का शीर्षक यूजीन विग्नर के एक लेख को संदर्भित करता है, "प्राकृतिक विज्ञान में गणित की अतुलनीय प्रभावकारिता । "

एकाधिक शेड्यूलिंग जूलिया भाषा का एक प्रमुख प्रतिमान है, और इसके अस्तित्व के दौरान, हम, भाषा के डेवलपर्स ने कुछ अपेक्षित देखा, लेकिन एक ही समय में puzzling। कम से कम हमें इस बात की उम्मीद नहीं थी कि हमने इसे किस हद तक देखा है। यह कुछ है - जूलिया इकोसिस्टम में कोड के पुन: उपयोग का एक चौंका देने वाला स्तर, जो किसी भी अन्य भाषा में जितना मुझे पता है, उससे कहीं अधिक है।

हम लगातार देखते हैं कि कुछ लोग सामान्यीकृत कोड लिखते हैं, कोई और नए डेटा प्रकार को परिभाषित करता है, ये लोग एक दूसरे से परिचित नहीं होते हैं, और फिर कोई इस कोड को इस असामान्य डेटा प्रकार पर लागू करता है ... और सब कुछ बस काम करता है। और यह आश्चर्यजनक रूप से अक्सर होता है ।
मैंने हमेशा सोचा था कि ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग से इस तरह के व्यवहार की उम्मीद की जानी चाहिए, लेकिन मैंने कई ऑब्जेक्ट-ओरिएंटेड भाषाओं का उपयोग किया, और यह पता चला कि आमतौर पर सब कुछ बस उनमें काम नहीं करता है। इसलिए, कुछ बिंदु पर मैंने सोचा: जूलिया इस संबंध में इतनी प्रभावी भाषा क्यों है? कोड पुन: उपयोग स्तर इतना उच्च क्यों है? और यह भी - इससे क्या सबक सीखा जा सकता है कि अन्य भाषाएँ बेहतर बनने के लिए जूलिया से उधार ले सकती हैं?

कभी-कभी, जब मैं यह कहता हूं, तो जनता मुझ पर विश्वास नहीं करती है, लेकिन आप पहले से ही जूलियाकॉन पर हैं, इसलिए आप जानते हैं कि क्या हो रहा है, इसलिए मैं इस पर ध्यान केंद्रित करूंगा, मेरी राय में, यह हो रहा है।

लेकिन शुरुआत के लिए - मेरे पसंदीदा उदाहरणों में से एक।

स्लाइड में क्रिस राकाकास के काम का नतीजा है। वह अंतर समीकरणों को हल करने के लिए सभी प्रकार के बहुत सामान्यीकृत पैकेज लिखते हैं। आप जो चाहें, दोहरी संख्या या बिगफ्लोट फ़ीड कर सकते हैं। और किसी तरह उसने तय किया कि वह एकीकरण परिणाम की त्रुटि देखना चाहता है। और एक माप पैकेज था जो सूत्रों के अनुक्रम के माध्यम से भौतिक मात्रा के मूल्य और त्रुटि के प्रसार दोनों को ट्रैक कर सकता है। यह पैकेज यूनिकोड वर्ण also के उपयोग से अनिश्चितता के मूल्यों के लिए सुरुचिपूर्ण वाक्यविन्यास का भी समर्थन करता है। यहां स्लाइड पर यह दिखाया गया है कि गुरुत्वाकर्षण का त्वरण, पेंडुलम की लंबाई, प्रारंभिक वेग, विचलन के कोण सभी को किसी न किसी त्रुटि के साथ जाना जाता है। तो, आप एक सरल पेंडुलम को परिभाषित करते हैं, गति के समीकरणों को सॉल्वर ODE और - bam के माध्यम से पास करते हैं ! - सब कुछ काम करता है । और आप मूंछें गलत होने के साथ एक ग्राफ देखते हैं। और मैं अभी भी नहीं दिखा रहा हूं कि ग्राफ़ को आरेखित करने के लिए कोड भी सामान्यीकृत है, और आप माप से एक त्रुटि के साथ मूल्य में डालते हैं ।jl और त्रुटियों के साथ एक ग्राफ प्राप्त करें।

विभिन्न संकुल और सामान्यीकरण कोड आसान mozgovynosyaschy की अनुकूलता का स्तर। यह कैसे काम करता है? यह हाँ निकलता है।

ठीक है, ऐसा नहीं है कि हमें इसकी उम्मीद नहीं थी। आखिरकार, हमने भाषा में कई प्रेषण की अवधारणा को सटीक रूप से शामिल किया क्योंकि यह हमें सामान्यीकृत एल्गोरिदम को व्यक्त करने की अनुमति देता है। इसलिए उपरोक्त सभी पागल नहीं हैं। लेकिन यह सिद्धांत में यह जानने के लिए एक बात है, और व्यवहार में यह देखने के लिए कि दृष्टिकोण वास्तव में काम करता है। आखिरकार, C ++ में सिंगल डिस्पैचिंग और ऑपरेटर ओवरलोडिंग को भी एक समान परिणाम देना चाहिए - लेकिन वास्तव में वे अक्सर काम नहीं करते हैं जैसा वे चाहते हैं।

इसके अलावा, हम एक से अधिक हम प्रत्याशित देख रहे हैं, एक भाषा के विकास: न सिर्फ एक सामान्य कोड लिखा। तो फिर मैं आपको बताना क्या, मेरी राय में, यह अधिक है की कोशिश करेंगे।

तो, कोड पुन: उपयोग के दो प्रकार हैं, और वे काफी अलग हैं। एक सामान्यीकृत एल्गोरिदम है, और यह पहली चीज है जो वे याद करते हैं। दूसरा, कम स्पष्ट है, लेकिन लगता है कि अधिक महत्वपूर्ण पहलू वह सादगी है जिसके साथ जूलिया कई प्रकार के पैकेजों में समान डेटा प्रकारों का उपयोग करता है। कुछ हद तक, ऐसा इसलिए होता है क्योंकि प्रकार विधियाँ इसके उपयोग के लिए बाधा नहीं बनती हैं: आपको उस प्रकार के इंटरफेस और विधियों के बारे में लेखक से सहमत होने की आवश्यकता नहीं है जो उसे विरासत में मिलते हैं; आप बस कह सकते हैं: "ओह, मुझे इस तरह का RGB पसंद है। मैं इस पर अपने स्वयं के संचालन के साथ आऊंगा, लेकिन इसकी संरचना पसंद है।"

प्रस्तावना। एकाधिक शेड्यूलिंग बनाम फ़ंक्शन ओवरलोडिंग

अब मुझे C ++ या Java में फ़ंक्शन ओवरलोडिंग का उल्लेख करना है, क्योंकि मुझे उनसे लगातार सवाल पूछे जाते हैं। पहली नज़र में, यह कई शेड्यूलिंग से अलग नहीं है। क्या अंतर है और क्यों कार्य अधिभार बदतर है?

मैं जूलिया पर एक उदाहरण के साथ शुरू करूँगा:

 abstract type Pet end struct Dog <: Pet; name::String end struct Cat <: Pet; name::String end function encounter(a::Pet, b::Pet) verb = meets(a, b) println("$(a.name) meets $(b.name) and $verb") end meets(a::Dog, b::Dog) = "sniffs" meets(a::Dog, b::Cat) = "chases" meets(a::Cat, b::Dog) = "hisses" meets(a::Cat, b::Cat) = "slinks" $ (b.name) और $ क्रिया") abstract type Pet end struct Dog <: Pet; name::String end struct Cat <: Pet; name::String end function encounter(a::Pet, b::Pet) verb = meets(a, b) println("$(a.name) meets $(b.name) and $verb") end meets(a::Dog, b::Dog) = "sniffs" meets(a::Dog, b::Cat) = "chases" meets(a::Cat, b::Dog) = "hisses" meets(a::Cat, b::Cat) = "slinks" बिल्ली) = "पीछा" abstract type Pet end struct Dog <: Pet; name::String end struct Cat <: Pet; name::String end function encounter(a::Pet, b::Pet) verb = meets(a, b) println("$(a.name) meets $(b.name) and $verb") end meets(a::Dog, b::Dog) = "sniffs" meets(a::Dog, b::Cat) = "chases" meets(a::Cat, b::Dog) = "hisses" meets(a::Cat, b::Cat) = "slinks" कुत्ता) = "hisses" abstract type Pet end struct Dog <: Pet; name::String end struct Cat <: Pet; name::String end function encounter(a::Pet, b::Pet) verb = meets(a, b) println("$(a.name) meets $(b.name) and $verb") end meets(a::Dog, b::Dog) = "sniffs" meets(a::Dog, b::Cat) = "chases" meets(a::Cat, b::Dog) = "hisses" meets(a::Cat, b::Cat) = "slinks"

हम Pet के सार प्रकार को परिभाषित करते हैं, इसके लिए Dog और Cat के उपप्रकारों का परिचय देते हैं, उनके पास एक नाम फ़ील्ड है (कोड थोड़ा दोहराता है, लेकिन सहन करने योग्य है) और एक सामान्यीकृत "मीटिंग" फ़ंक्शन को परिभाषित करता है जो तर्कों के Pet प्रकार Pet दो ऑब्जेक्ट लेता है। इसमें, हम पहले सामान्यीकृत मीटिंग meet() फ़ंक्शन को कॉल करने के परिणाम द्वारा निर्धारित "कार्रवाई" की गणना करते हैं, और फिर मीटिंग का वर्णन करने वाले वाक्य को प्रिंट करते हैं। meets() फंक्शन में, हम उस एक्शन को निर्धारित करने के लिए मल्टीपल डिस्पैच का उपयोग करते हैं जो एक जानवर तब करता है जब उसका दूसरे से सामना होता है।

कुत्तों के जोड़े और बिल्लियों की एक जोड़ी जोड़ें और बैठक के परिणाम देखें:

 fido = Dog("Fido") rex = Dog("Rex") whiskers = Cat("Whiskers") spots = Cat("Spots") encounter(fido, rex) encounter(rex, whiskers) encounter(spots, fido) encounter(whiskers, spots)

अब हम C ++ में समान रूप से यथासंभव "अनुवाद" करेंगे। name फ़ील्ड के साथ Pet वर्ग को परिभाषित करें - C ++ में हम यह कर सकते हैं (वैसे, C ++ के फायदों में से एक यह है कि डेटा फ़ील्ड को अमूर्त प्रकारों में भी जोड़ा जा सकता है। फिर हम बेस meets() फ़ंक्शन को परिभाषित करते हैं, encounter() को टाइप करें encounter() और दो प्रकार के Pet लिए फ़ंक्शन। अंत में, व्युत्पन्न वर्गों Dog और Cat को परिभाषित करें और उनके लिए ओवरलोड meets() करें:

 class Pet { public: string name; }; string meets(Pet a, Pet b) { return "FALLBACK"; } void encounter(Pet a, Pet b) { string verb = meets(a, b); cout << a.name << " meets " << b. name << " and " << verb << endl; } class Cat : public Pet {}; class Dog : public Pet {}; string meets(Dog a, Dog b) { return "sniffs"; } string meets(Dog a, Cat b) { return "chases"; } string meets(Cat a, Dog b) { return "hisses"; } string meets(Cat a, Cat b) { return "slinks"; } ) { class Pet { public: string name; }; string meets(Pet a, Pet b) { return "FALLBACK"; } void encounter(Pet a, Pet b) { string verb = meets(a, b); cout << a.name << " meets " << b. name << " and " << verb << endl; } class Cat : public Pet {}; class Dog : public Pet {}; string meets(Dog a, Dog b) { return "sniffs"; } string meets(Dog a, Cat b) { return "chases"; } string meets(Cat a, Dog b) { return "hisses"; } string meets(Cat a, Cat b) { return "slinks"; } ) {वापसी "sniffs"; class Pet { public: string name; }; string meets(Pet a, Pet b) { return "FALLBACK"; } void encounter(Pet a, Pet b) { string verb = meets(a, b); cout << a.name << " meets " << b. name << " and " << verb << endl; } class Cat : public Pet {}; class Dog : public Pet {}; string meets(Dog a, Dog b) { return "sniffs"; } string meets(Dog a, Cat b) { return "chases"; } string meets(Cat a, Dog b) { return "hisses"; } string meets(Cat a, Cat b) { return "slinks"; } ) {वापसी "hisses"; class Pet { public: string name; }; string meets(Pet a, Pet b) { return "FALLBACK"; } void encounter(Pet a, Pet b) { string verb = meets(a, b); cout << a.name << " meets " << b. name << " and " << verb << endl; } class Cat : public Pet {}; class Dog : public Pet {}; string meets(Dog a, Dog b) { return "sniffs"; } string meets(Dog a, Cat b) { return "chases"; } string meets(Cat a, Dog b) { return "hisses"; } string meets(Cat a, Cat b) { return "slinks"; }

जूलिया कोड में main() फ़ंक्शन, कुत्तों और बिल्लियों को बनाता है और उन्हें पूरा करता है:

 int main() { Dog fido; fido.name = "Fido"; Dog rex; rex.name = "Rex"; Cat whiskers; whiskers.name = "Whiskers"; Cat spots; spots.name = "Spots"; encounter(fido, rex); encounter(rex, whiskers); encounter(spots, fido); encounter(whiskers, spots); return 0; }

इसलिए, फंक्शन ओवरलोडिंग के खिलाफ कई प्रेषण। घंटा!

आपको क्या लगता है कि कई प्रेषण के साथ कोड वापस आ जाएगा?

$ जूलिया pets.jl

 Fido meets Rex and sniffs Rex meets Whiskers and chases Spots meets Fido and hisses Whiskers meets Spots and slinks

जानवरों का मिलना, सूँघना, फुफकारना और पकड़ना-खेलना - जैसा कि इरादा था।

$ g ++ -o Pets Pets.cpp &&/pets

 Fido meets Rex and FALLBACK Rex meets Whiskers and FALLBACK Spots meets Fido and FALLBACK Whiskers meets Spots and FALLBACK

सभी मामलों में, "फ़ॉलबैक" विकल्प वापस आ गया है।

क्यों? क्योंकि यह कैसे कार्य अधिभार काम करता है। यदि एक से अधिक प्रेषण काम किया है, तो meets(a, b) के भीतर encounter() एक विशेष प्रकार जिनमें से साथ ही कहा जाता है a और b कॉल के समय कर रहे हैं। लेकिन ओवरलोडिंग को लागू किया जाता है, इसलिए meets() स्थैतिक प्रकारों के लिए कहा जाता है a और b , जो इस मामले में दोनों Pet ।

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

मेरे लिए, ऐसे उदाहरण बताते हैं कि एकाधिक प्रेषण सही काम करता है, और अन्य सभी दृष्टिकोण सही परिणाम के लिए बहुत अच्छा अनुमान नहीं हैं।

अब आइए ऐसी तालिका देखें। मुझे आशा है कि आप इसे सार्थक पाएंगे:

शेड्यूलिंग प्रकार	वाक्य-विन्यास	तर्क वितर्क करें	अभिव्यक्ति की डिग्री	स्पष्ट अवसर
नहीं	f (x ₁ , x ₂ , ...)	{}	हे (1)	स्थिर
एक	x ₁ .f (x ₂ , ...)	{X _1}	O (\| X ₁ \|)	रैखिक
विभिन्न	f (x ₁ , x ₂ , ...)	{x ₁ , x ₂ , ...}	ओ (\| एक्स ₁ \| \| एक्स ₂ \| ...)	घातीय

प्रेषण के बिना भाषाओं में, आप बस f(x, y, ...) लिखते हैं f(x, y, ...) सभी तर्कों के प्रकार निश्चित हैं, अर्थात कॉल टू f() सिंगल फंक्शन f() लिए एक कॉल है, जो प्रोग्राम में हो सकता है। अभिव्यक्ति निरंतर की डिग्री: कॉल f() हमेशा एक और केवल एक बात बना देता है। 1990 और 2000 के दशक में ओओपी के संक्रमण में एकल प्रेषण एक बड़ी सफलता थी। डॉट सिंटैक्स का उपयोग आमतौर पर किया जाता है, जिसे लोग वास्तव में पसंद करते हैं। और एक अतिरिक्त अभिव्यंजक अवसर प्रकट होता है: कॉल ऑब्जेक्ट एक्स ₁ के प्रकार के अनुसार भेजा जाता है। एक अभिव्यंजक अवसर सेट की शक्ति की विशेषता है। X ₁ | f() विधि वाले प्रकार। कई प्रेषण में, हालांकि, फ़ंक्शन f() लिए संभावित विकल्पों की संख्या उन प्रकारों के सेट के कार्टेशियन उत्पाद की शक्ति के बराबर है, जिनके लिए तर्क हो सकते हैं। वास्तव में, निश्चित रूप से, शायद ही किसी को एक कार्यक्रम में इतने सारे विभिन्न कार्यों की आवश्यकता होती है। लेकिन यहां मुख्य बात यह है कि इस किस्म के किसी भी तत्व का उपयोग करने के लिए प्रोग्रामर को एक सरल और प्राकृतिक तरीका दिया जाता है, और इससे अवसरों की तेजी से वृद्धि होती है।

भाग 1. सामान्य प्रोग्रामिंग

आइए सामान्यीकृत कोड के बारे में बात करते हैं - कई प्रेषण की मुख्य विशेषता।

यहाँ जेनेरिक कोड का एक (पूरी तरह से कृत्रिम) उदाहरण है:

 using LinearAlgebra function inner_sum(A, vs) t = zero(eltype(A)) for v in vs t += inner(v, A, v) #  ! end return t end inner(v, A, w) = dot(v, A * w) #

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

तो, "देखो, माँ, यह काम करता है":

 julia> A = rand(3, 3) 3×3 Array{Float64,2}: 0.934255 0.712883 0.734033 0.145575 0.148775 0.131786 0.631839 0.688701 0.632088 julia> vs = [rand(3) for _ in 1:4] 4-element Array{Array{Float64,1},1}: [0.424535, 0.536761, 0.854301] [0.715483, 0.986452, 0.82681] [0.487955, 0.43354, 0.634452] [0.100029, 0.448316, 0.603441] julia> inner_sum(A, vs) 6.825340887556694

कुछ खास नहीं, यह कुछ मूल्य की गणना करता है। लेकिन - कोड एक सामान्य शैली में लिखा गया है और किसी भी A और vs लिए काम करेगा, यदि केवल उनके लिए इसी संचालन को करना संभव होगा।

विशिष्ट डेटा प्रकारों पर दक्षता के लिए - कितना भाग्यशाली है। मेरा मतलब है कि घने वैक्टर और मैट्रिस के लिए यह कोड "जैसा कि होना चाहिए" - यह बीएलएएस संचालन के आह्वान के साथ मशीन कोड उत्पन्न करेगा, आदि। आदि यदि आप स्थिर सरणियों को पास करते हैं, तो संकलक इसे ध्यान में रखेगा, चक्रों का विस्तार करेगा, वैश्वीकरण लागू करेगा - सब कुछ वैसा ही है जैसा इसे होना चाहिए।

लेकिन इससे भी महत्वपूर्ण बात, कोड नए प्रकारों के लिए काम करेगा, और आप इसे न केवल सुपर-कुशल, बल्कि सुपर-डुपर-कुशल बना सकते हैं! हमें (यह है कि मशीन सीखने में प्रयोग किया जाता है वास्तविक डेटा प्रकार है) एक नए प्रकार की परिभाषा, एक एकात्मक वेक्टर (एक गर्म वेक्टर) का विस्तार करते हैं। यह एक वेक्टर है जिसमें घटकों में से एक 1 है, और अन्य सभी शून्य हैं। आप इसे बहुत कॉम्पैक्ट रूप से कल्पना कर सकते हैं: सभी को संग्रहीत करने की आवश्यकता है जो वेक्टर की लंबाई और नॉनजेरो घटक की संख्या है।

 import Base: size, getindex, * struct OneHotVector <: AbstractVector{Int} len :: Int ind :: Int end size(v::OneHotVector) = (v.len,) getindex(v::OneHotVector, i::Integer) = Int(i == v.ind)

वास्तव में, यह वास्तव में इसे जोड़ने वाले पैकेज से पूरी प्रकार की परिभाषा है। और इस परिभाषा के साथ, inner_sum() भी काम करता है:

 julia> vs = [OneHotVector(3, rand(1:3)) for _ in 1:4] 4-element Array{OneHotVector,1}: [0, 1, 0] [0, 0, 1] [1, 0, 0] [1, 0, 0] julia> inner_sum(A, vs) 2.6493739294755123

लेकिन एक स्केलर उत्पाद के लिए, यहां एक सामान्य परिभाषा का उपयोग किया जाता है - इस प्रकार के डेटा के लिए यह धीमा है, ठंडा नहीं है!

इसलिए, सामान्य परिभाषाएं काम करती हैं, लेकिन हमेशा एक इष्टतम तरीके से नहीं, और आप कभी-कभी जूलिया का उपयोग करते समय इसका सामना कर सकते हैं: "ठीक है, एक सामान्य परिभाषा को कहा जाता है, यही कारण है कि यह GPU कोड पांचवें घंटे के लिए काम कर रहा है ..."

inner() डिफ़ॉल्ट रूप से, वेक्टर उत्पाद द्वारा मैट्रिक्स उत्पाद की सामान्य परिभाषा को कहा जाता है, जो जब एक एकात्मक वेक्टर द्वारा गुणा किया जाता है, तो Vector{Float64} प्रकार के स्तंभों में से एक की प्रतिलिपि देता है। फिर स्केलर उत्पाद dot() की सामान्य परिभाषा को एकात्मक वेक्टर और इस कॉलम के साथ कहा जाता है, जो बहुत सारे अनावश्यक काम करता है। वास्तव में, प्रत्येक घटक के लिए यह जाँच की जाती है "क्या आप एक के बराबर हैं? और आप?" आदि

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

 *(A::AbstractMatrix, v::OneHotVector) = A[:, v.ind]

और यहाँ यह है, हम कहते हैं, "हम दूसरा तर्क को समय-निर्धारण चाहते हैं," यह कोई बात नहीं क्या मैदान में है। ऐसी परिभाषा बस मैट्रिक्स से पंक्ति को खींच लेगी और सामान्य विधि की तुलना में बहुत तेज होगी - स्तंभों पर पुनरावृत्ति और संक्षेपण हटा दिया जाता है।

लेकिन आप आगे जा सकते हैं और सीधे inner() अनुकूलन कर सकते हैं inner() , क्योंकि मैट्रिक्स के माध्यम से दो एकात्मक वैक्टर को गुणा करना बस इस मैट्रिक्स के एक तत्व को बाहर निकालता है:

 inner(v::OneHotVector, A, w::OneHotVector) = A[v.ind, w.ind]

यह वादा किया सुपर डुपर दक्षता है। और जो कुछ आवश्यक है वह इस inner() विधि को परिभाषित करना है।

यह उदाहरण कई शेड्यूलिंग के अनुप्रयोगों में से एक को दर्शाता है: एक फ़ंक्शन की एक सामान्य परिभाषा है, लेकिन कुछ डेटा प्रकारों के लिए यह बेहतर तरीके से काम नहीं करता है। और फिर हम एक ऐसा तरीका जोड़ते हैं जो इन प्रकारों के लिए फ़ंक्शन व्यवहार को संरक्षित करता है, लेकिन बहुत अधिक कुशलता से काम करता है।

लेकिन एक और क्षेत्र है - जब किसी फ़ंक्शन की सामान्य परिभाषा नहीं होती है, लेकिन मैं कुछ प्रकारों के लिए कार्यक्षमता जोड़ना चाहता हूं। फिर आप इसे न्यूनतम प्रयास के साथ जोड़ सकते हैं।

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

एकल प्रेषण भाषाओं में समान व्यवहार कैसे प्राप्त करें? यह संभव है, लेकिन मुश्किल है। समस्या: फ़ंक्शन को ओवरलोड करते समय * दूसरे तर्क पर प्रेषण के लिए आवश्यक था, और पहले पर नहीं। आप डबल प्रेषण कर सकते हैं: पहला, पहले तर्क से प्रेषण करें और AbstractMatrix.*(v) कॉल करें AbstractMatrix.*(v) विधि। और यह विधि, बदले में, v.__rmul__(A) , जैसे कुछ कहती है। मूल कॉल में दूसरा तर्क अब वह वस्तु बन गया है जिसका तरीका वास्तव में कहा जा रहा है। __rmul__ यहां पायथन से लिया गया है, जहां इस तरह का व्यवहार एक मानक पैटर्न है, लेकिन यह केवल जोड़ और गुणा के लिए काम करता है। यानी डबल डिस्पैचिंग की समस्या हल हो जाती है अगर हम + या * नामक एक फ़ंक्शन को कॉल करना चाहते हैं, अन्यथा - अफसोस, हमारा दिन नहीं। C ++ और अन्य भाषाओं में - आपको अपनी बाइक बनाने की आवश्यकता है।

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

भाग 2. सामान्य प्रकार

मैं जूलिया प्रतिमान के पीछे की तरफ से गुजरूंगा - सामान्य प्रकार। यह, मेरी राय में, भाषा का मुख्य "वर्कहॉर्स" है, क्योंकि यह इस क्षेत्र में है कि मैं उच्च स्तर के कोड का पुन: उपयोग करता हूं।

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

सवाल उठता है - और चो? मैं इस तरह से ध्यान देने के लाने में क्यों हूं? यह पता चलता है कि कक्षाओं के आधार पर ऑब्जेक्ट-ओरिएंटेड भाषाओं में, इस तरह के दृष्टिकोण को लागू करना आश्चर्यजनक रूप से कठिन है। चूंकि इन भाषाओं में विधि परिभाषाएं वर्ग परिभाषा के अंदर होती हैं, इसलिए पद्धति जोड़ने के लिए केवल दो तरीके हैं - या तो वांछित व्यवहार को जोड़ने के लिए वर्ग कोड को संपादित करें, या आवश्यक विधियों के साथ एक अंतर्निहित वर्ग बनाएं।

पहला विकल्प बेस क्लास की परिभाषा को बढ़ाता है, और कोड को बदलते समय सभी जोड़े गए तरीकों के समर्थन का ध्यान रखने के लिए बेस क्लास के डेवलपर को भी मजबूर करता है। ऐसे वर्ग को एक दिन क्या असमर्थ बना सकता है।

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

तो, दोनों विकल्प बहुत सारे हैं। हालांकि, अन्य समाधान हैं:

कक्षा विधि के बजाय एक बाहरी फ़ंक्शन में कार्यात्मक रखो - xf(y) बजाय f(x, y) जाएं। लेकिन तब सामान्यीकृत व्यवहार खो दिया है।
पुन: उपयोग कोड पर थूक (और, ऐसा लगता है, कई मामलों में ऐसा होता है)। बस अपने आप को एक विदेशी RGB क्लास कॉपी करें और जो कुछ याद आ रहा है उसे जोड़ें।

पुन: उपयोग कोड के संदर्भ में जूलिया की प्रमुख विशेषता इस तथ्य से लगभग पूरी तरह से कम है कि विधि प्रकार के बाहर परिभाषित की गई है । वह सब है। और प्रकार आप एक ही आसानी के साथ पुन: उपयोग कर सकते हैं - एक ही प्रेषण के साथ भाषाओं में भी ऐसा ही करने के लिए। तो इसलिए यह विचार है, वास्तव में - यह पूरी "की कक्षा के तरीकों करते हैं"। एक नाम स्थान के रूप में कक्षाओं का उपयोग - लेकिन वहाँ एक अच्छा समय है,,। यदि मैं xf(y) - f() वर्तमान नामस्थान में होना आवश्यक नहीं हूँ, तो उसे नाम स्थान x में खोजना होगा। हां, यह अच्छी बात है - लेकिन क्या यह अन्य सभी परेशानियों के लायक है? मैं नहीं जानता मेरी राय में, नहीं (हालांकि मेरी राय, जैसा कि आप अनुमान लगा सकते हैं, थोड़ा पक्षपाती है)।

उपसंहार। अभिव्यक्ति की समस्या

प्रोग्रामिंग, जो 70 के दशक में देखा गया था में एक समस्या है। यह काफी हद तक स्थैतिक प्रकार की जाँच से संबंधित है, क्योंकि यह ऐसी भाषाओं में दिखाई देता है। सच है, मुझे लगता है कि इसका स्थैतिक प्रकार की जाँच से कोई लेना-देना नहीं है। समस्या का सार निम्नलिखित है: क्या संदिग्ध तकनीकों का सहारा लिए बिना डेटा मॉडल और एक ही समय में डेटा पर संचालन के सेट को बदलना संभव है।

समस्या कम या ज्यादा हो सकती है:

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

(1) आसानी से वस्तु उन्मुख भाषाओं में किया जा सकता है, और यह कार्य करने के लिए मुश्किल है, (2) - इसके विपरीत पर। इस अर्थ में, हम केवल ओओपी और एफपी दृष्टिकोण के द्वैतवाद के बारे में बात कर सकते हैं।

बहु-प्रेषण भाषाओं में, दोनों ऑपरेशन आसान हैं। (1) , (2) — . , . ( https://en.wikipedia.org/wiki/Expression_problem ), . ? , , . , " , " — " " . " , " , , .

, . , , — .

, Julia ( ), . .

कई शेड्यूलिंग का समझ से बाहर प्रदर्शन

प्रस्तावना। एकाधिक शेड्यूलिंग बनाम फ़ंक्शन ओवरलोडिंग

भाग 1. सामान्य प्रोग्रामिंग

भाग 2. सामान्य प्रकार

उपसंहार। अभिव्यक्ति की समस्या

More articles: