जूलिया: फ़ंक्शंस और स्ट्रक्चर्स-जैसा-फ़ंक्शंस

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

जूलिया में कार्यों की अवधारणा संभवतः लिस्प परिवार की भाषाओं के समान है (अधिक सटीक, लिस्प -1 शाखाएं), और कार्यों को तीन स्तरों पर माना जा सकता है: उपप्रोग्राम के रूप में, क्रियाओं के एक निश्चित अनुक्रम में सार के रूप में और इस अमूर्त का प्रतिनिधित्व करने वाले डेटा के रूप में। ।

स्तर 1. दिनचर्या के रूप में कार्य

उपप्रोग्रामों का आवंटन और उनके स्वयं के नामों का असाइनमेंट प्रागैतिहासिक काल से चल रहा है, जब फोरट्रान को उच्च-स्तरीय भाषा माना जाता था, और सी अभी तक नहीं था।

इस मायने में, जूलिया उत्पाद मानक हैं। "फ़ीचर" को इस तथ्य के रूप में कहा जा सकता है कि वाक्यात्मक रूप से प्रक्रियाओं और कार्यों में कोई विभाजन नहीं है। भले ही सबरूटिन को कुछ मूल्य प्राप्त करने के लिए कहा जाए या केवल डेटा पर कुछ कार्रवाई करने के लिए, इसे एक फ़ंक्शन कहा जाता है।

फ़ंक्शन की परिभाषा कीवर्ड function साथ शुरू होती है, इसके बाद तर्कों की सूची, कोष्ठक में आदेशों का क्रम और शब्द का end परिभाषा end होता है:

 """ sum_all(collection) Sum all elements of a collection and return the result """ function sum_all(collection) sum = 0 for item in collection sum += collection end sum end 

सिंटैक्स को लिस्प से विरासत में लिए गए व्यवहार से अलग किया जाता है: किसी फ़ंक्शन से मान के "सामान्य" वापसी के लिए, शब्द return आवश्यक नहीं है: अंतिम अभिव्यक्ति के मूल्य की गणना end पहले की जाती end । ऊपर दिए गए उदाहरण में, चर sum का मान लौटाया जाएगा। इस प्रकार, return का उपयोग फ़ंक्शन के विशेष व्यवहार के मार्कर के रूप में किया जा सकता है:

 function safe_division(number, divisor) if divisor == 0 return 0 end number / divisor end #    function safe_division1(number, divisor) if divisor == 0 0 #             else number / divisor end end 

छोटी परिभाषा वाले कार्यों के लिए, गणितीय संकेतन के समान छोटा सिंटैक्स है। तो, पैरों की लंबाई के साथ कर्ण की लंबाई की गणना निम्नानुसार परिभाषित की जा सकती है:

 hypotenuse(a, b) = sqrt(a^2 + b^2) 

टेनेरी ऑपरेटर का उपयोग करके "सुरक्षित" डिवीजन को निम्नानुसार लिखा जा सकता है:

 safe_division(number, divisor) = divisor == 0 ? 0 : number / divisor 

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

जैसा कि मैंने पिछले लेख में प्रदर्शित करने की कोशिश की थी, जूलिया कंपाइलर इनपुट तर्कों के प्रकार से रिटर्न परिणाम के प्रकार का अनुमान लगा सकता है। इसलिए, उदाहरण के लिए, safe_division फ़ंक्शन को फास्ट ऑपरेशन के लिए न्यूनतम संशोधन की आवश्यकता होती है:

 function safe_division(number, divisor) if divisor == 0 return zero(number / divisor) end number / divisor end 

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

फ़ंक्शंस में निश्चित संख्या में स्थितीय तर्क, डिफ़ॉल्ट मान के साथ स्थितीय तर्क, नामांकित तर्क और तर्कों की चर संख्या हो सकती है। वाक्य रचना:

 #    function hello(name) println("Hello, ", name) end #      #           function greeting_d(name, greeting = "Hello") println(greeting, ", ", name) end #       #          #       function greeting_kw(name; greeting = "Hello") println(greeting, ", ", name) end #  greeting   ,        function greeting_oblkw(name; greeting) println(greeting, ", ", name) end #      #  ,   ,      names function greeting_nary(greeting, names...) print(greeting) for name in names print(", ", name) end print('\n') end julia> hello("world") Hello, world julia> greeting_d("world") Hello, world julia> greeting_d("Mr. Smith", "How do you do") How do you do, Mr. Smith julia> greeting_kw("Mr. Smith") Hello, Mr. Smith julia> greeting_kw("mom", greeting = "Hi") Hi, mom julia> greeting_oblkw("world") ERROR: UndefKeywordError: keyword argument greeting not assigned Stacktrace: [1] greeting_oblkw(::String) at ./REPL[23]:3 [2] top-level scope at none:0 julia> greeting_oblkw("mom", greeting = "Hi") Hi, mom julia> greeting_nary("Hi", "mom", "dad", "everyone") Hi, mom, dad, everyone 

स्तर 2. डेटा के रूप में कार्य

फ़ंक्शन नाम का उपयोग न केवल प्रत्यक्ष कॉल में किया जा सकता है, बल्कि एक पहचानकर्ता के रूप में भी किया जाता है जिसके साथ मूल्य प्राप्त करने की प्रक्रिया जुड़ी हुई है। उदाहरण के लिए:

 function f_x_x(fn, x) fn(x, x) end julia> f_x_x(+, 3) 6 # +(3, 3) = 3+3 = 6 julia> f_x_x(*, 3) 9 # *(3, 3) = 9 julia> f_x_x(^, 3) 27 # ^(3, 3) = 3^3 = 27 julia> f_x_x(log, 3) 1.0 # log(3, 3) = 1 

"क्लासिक" फ़ंक्शन जो एक कार्यात्मक तर्क लेते हैं, वे हैं map , reduce और filter ।

map(f, x...) से सभी तत्वों के मानों के लिए फ़ंक्शन लागू करता है (या i-तत्वों के ट्यूपल्स) और परिणाम को एक नए संग्रह के रूप में लौटाता है:

 julia> map(cos, [0, π/3, π/2, 2*π/3, π]) 5-element Array{Float64,1}: 1.0 0.5000000000000001 6.123233995736766e-17 -0.4999999999999998 -1.0 julia> map(+, (2, 3), (1, 1)) (3, 4) 

reduce(f, x; init_val) "एकल" के लिए "कम करता है", श्रृंखला f(f(...f(f(init_val, x[1]), x[2])...), x[end]) :

 function myreduce(fn, values, init_val) accum = init_val for x in values accum = fn(accum, x) end accum end 

चूँकि यह वास्तव में निर्धारित नहीं होता है कि कमी के दौरान सरणी किस क्रम में fn(accum, x) , या क्या fn(accum, x) या fn(x, accum) , कमी केवल कम्यूटेटिव या सहयोगी संचालकों के साथ एक पूर्वानुमानित परिणाम देगी, जैसे कि इसके अलावा या गुणा।

filter(predicate, x) x तत्वों की एक सरणी लौटाता है जो विधेय predicate संतुष्ट करता predicate :

 julia> filter(isodd, 1:10) 5-element Array{Int64,1}: 1 3 5 7 9 julia> filter(iszero, [[0], 1, 0.0, 1:-1, 0im]) 4-element Array{Any,1}: [0] 0.0 1:0 0 + 0im 

लूप लिखने के बजाय सरणियों पर संचालन के लिए उच्च-क्रम के कार्यों का उपयोग करने के कई फायदे हैं:

1. कोड छोटा हो रहा है
2. map() या reduce() ऑपरेशन के शब्दार्थ को प्रदर्शित करता है, फिर भी आपको लूप में क्या हो रहा है के शब्दार्थ को समझना होगा
3. map() कंपाइलर को यह समझने की अनुमति देता है कि सरणी तत्वों पर संचालन डेटा द्वारा स्वतंत्र है, जो अतिरिक्त अनुकूलन को लागू करने की अनुमति देता है

स्तर 3. सार के रूप में कार्य

अक्सर map() या filter() आपको एक फ़ंक्शन का उपयोग करने की आवश्यकता होती है जिसे अपना स्वयं का नाम असाइन नहीं किया गया है। इस मामले में जूलिया आपको इस अनुक्रम के लिए अपना नाम दर्ज किए बिना, तर्क पर संचालन के अमूर्तता को व्यक्त करने की अनुमति देता है। इस तरह के अमूर्त को एक अनाम फ़ंक्शन या लैम्ब्डा फ़ंक्शन कहा जाता है (क्योंकि गणितीय परंपरा में इस तरह के कार्यों को लैम्बडा द्वारा चिह्नित किया जाता है)। इस दृश्य के लिए सिंटैक्स है:

 #   square(x) = x^2 #   x -> x^2 #   hypot(a, b) = sqrt(x^2 + y^2) #   -    ,    , #              (x, y) -> sqrt(x^2 + y^2) #   fortytwo() = 42 #   () -> 42 julia> map(i -> map(x -> x^i, 1:5), 1:5) 5-element Array{Array{Int64,1},1}: [1, 2, 3, 4, 5] [1, 4, 9, 16, 25] [1, 8, 27, 64, 125] [1, 16, 81, 256, 625] [1, 32, 243, 1024, 3125] 

नाम और अनाम दोनों कार्यों को चर के लिए सौंपा जा सकता है और मूल्यों के रूप में लौटाया जा सकता है:

 julia> double_squared = x -> (2 * x)^2 #17 (generic function with 1 method) julia> double_squared(5) 100 

वैरिएबल स्कोप और लेक्सिकल क्लोजर

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

 function normal(x, y) z = x + y x + y * z end function strange(x, y) x + y * z end 

normal() फ़ंक्शन के बारे में, हम कह सकते हैं कि इसके शरीर में सभी चर नाम संबंधित हैं , अर्थात्। अगर हम हर जगह (तर्क सूची सहित) "x" को "m" (या किसी अन्य पहचानकर्ता), "y" को "n" और "z" को "sum_of_m_and_n" से बदल दें, तो अभिव्यक्ति का अर्थ नहीं बदलेगा। strange() फ़ंक्शन में, नाम z असंबंधित है , अर्थात्। a) यदि यह नाम दूसरे द्वारा प्रतिस्थापित किया जाता है, तो इसका अर्थ बदल सकता है, और b) फ़ंक्शन की शुद्धता इस बात पर निर्भर करती है कि फ़ंक्शन "z" नाम के साथ एक वैरिएबल उस समय परिभाषित किया गया था जिसे फ़ंक्शन कहा जाता था।

सामान्यतया, normal() फ़ंक्शन भी इतना साफ नहीं है:

1. यदि z नाम का एक वैरिएबल फ़ंक्शन के बाहर परिभाषित किया जाता है तो क्या होगा?
2. + और * अक्षर, वास्तव में, असंबंधित पहचानकर्ता भी हैं।

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

पॉइंट 1 ऐसा लगता है कि कम स्पष्ट है। तथ्य यह है कि उत्तर इस बात पर निर्भर करता है कि फ़ंक्शन कहाँ परिभाषित है। यदि इसे विश्व स्तर पर परिभाषित किया जाता है, तो normal() अंदर z normal() एक स्थानीय चर होगा, अर्थात यदि कोई वैश्विक चर z इसका मान अधिलेखित नहीं किया जाएगा। यदि फ़ंक्शन की परिभाषा कोड ब्लॉक के अंदर है, तो यदि इस ब्लॉक में z की पहले की परिभाषा है, तो यह बाहरी चर का मान होगा जिसे बदल दिया जाएगा।

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

क्लोज़र मुख्य रूप से दो स्थितियों में उपयोगी होते हैं: जब आपको दिए गए मापदंडों के अनुसार एक फ़ंक्शन बनाने की आवश्यकता होती है और जब आपको एक फ़ंक्शन की आवश्यकता होती है जिसमें आंतरिक स्थिति होती है।

एक आंतरिक स्थिति को समेटने वाले फ़ंक्शन के साथ स्थिति पर विचार करें:

 function f_with_counter(fn) call_count = 0 ncalls() = call_count # invoke()  ,     #    ,  ncalls() function invoke(args...) call_count += 1 fn(args...) end #         # call_count     , #   invoke()  call_count()        (call = invoke, call_count = ncalls) end julia> abscount = f_with_counter(abs) (call = getfield(Main, Symbol("#invoke#22")){typeof(abs)}(abs, Core.Box(0)), call_count = getfield(Main, Symbol("#ncalls#21"))(Core.Box(0))) julia> abscount.call_count() 0 julia> abscount.call(-20) 20 julia> abscount.call_count() 1 julia> abscount.call(im) 1.0 julia> abscount.call_count() 2 

केस स्टडी: सभी एक ही बहुपद

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


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

 struct Polynomial degree::Int coeff::NTuple{N, Float64} where N function Polynomial(v::T where T<:Union{Vector{<:Real}, NTuple{<:Any, <:Real}}) #     /     P(x) ≡ 0 coeff = isempty(v) ? (0.0,) : tuple([Float64(x) for x in v]...) #   -   new #  -    return new(length(coeff)-1, coeff) end end """ evpoly(p::Polynomial, z::Real) Evaluate polynomial `p` at `z` using the Horner's rule """ function evpoly(p::Polynomial, z::Real) ans = p.coeff[end] for idx = p.degree:-1:1 ans = p.coeff[idx] + z * ans end return ans end 

हम इस परिभाषा को एक फ़ंक्शन में बदलते हैं जो गुणांक के एक सरणी / ट्यूपल लेता है और बहुपदों की गणना करने वाले वास्तविक फ़ंक्शन को वापस करता है:

 function Polynomial_as_closure(v::T where T<:Union{Vector{<:Real}, NTuple{<:Any, <:Real}}) #     /     P(x) ≡ 0 if isempty(v) return x::Real -> 0.0 end coeff = tuple(map(float, v)...) degree = length(coeff) - 1 function evpoly(z::Real) ans = coeff[end] for idx = degree:-1:1 ans = coeff[idx] + z * ans end return ans end evpoly end julia> p = Polynomial_as_closure((0, 1, 1)) # x² + x (::getfield(Main, Symbol("#evpoly#28")){Tuple{Float64,Float64,Float64},Int64}) (generic function with 1 method) julia> p(1) # ,    evpoly()! 2.0 julia> p(11) 132.0 

इसी तरह, आप प्रक्षेप बहुपद के लिए एक फ़ंक्शन लिख सकते हैं।

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

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

 function (p::Polynomial)(z::Real) evpoly(p, z) end function (p::InterpPolynomial)(z::Real) evpoly(p, z) end 

कार्यात्मक तर्कों का उपयोग करते हुए, आप एक सेट के निर्माण से निर्मित एक निश्चित फ़ंक्शन के लिए एक प्रक्षेप बहुपद का बाहरी कंस्ट्रक्टर भी जोड़ सकते हैं:

 function InterpPolynomial(fn, xsample::T) where {T<:Union{Vector{<:Real}, NTuple{<:Any, <:Real}}} InterpPolynomial(xsample, map(fn, xsample)) end 

निष्कर्ष

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