💲 👩‍⚕️ 📩 जूलिया। स्ट्रिंग्स और मेटाप्रोग्रामिंग 💅🏾 👸 ⚓️

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

पंक्तियां

स्ट्रिंग वैरिएबल दोहरे उद्धरण चिह्नों में वर्णों को सम्मिलित करके बनाए जाते हैं, एकल वर्ण प्रकार वर्ण के एकल वर्णों पर सेट होते हैं। स्ट्रिंग संयोजन का उपयोग गुणन "*" का उपयोग करके किया जाता है:

cats = 4 s1 = "How many cats "; s2 = "is too many cats?"; s3 = s1*s2 Out[]: "How many cats is too many cats?"

यही है, घातांक इस तरह से कार्य करता है:

 s1^3 Out[]: "How many cats How many cats How many cats "

दूसरी ओर, पंक्तियों को अनुक्रमित किया जाता है:

 s1[3] Out[]: 'w': ASCII/Unicode U+0077 (category Ll: Letter, lowercase) s1[5:13] Out[]: "many cats" s1[13:-1:5] Out[]: "stac ynam" s2[end] Out[]: '?': ASCII/Unicode U+003f (category Po: Punctuation, other)

तार तार और अन्य प्रकार से बनाए जा सकते हैं:

 s4 = string(s3, " - I don't know, but ", cats, " is too few.") #   s4 = "$s3 - I don't know, but $cats is too few." Out[]: "How many cats is too many cats? - I don't know, but 4 is too few."

शस्त्रागार में कई उपयोगी कार्य हैं , उदाहरण के लिए, एक तत्व की खोज:

 findfirst( isequal('o'), s4 ) Out[]: 4 findlast( isequal('o'), s4 ) Out[]: 26 findnext( isequal('o'), s4, 7 ) #      Out[]: 11

और इसलिए, आप आसानी से सीज़र के सिफर को लागू कर सकते हैं

 caesar(X, n) = prod( [x += n for x in X] ) str3 = "    "; caesar(str3, 3) Out[]: "####" str4 = caesar(str3, -32) Out[]: "\0\0\0\0" "Latin letters go before Cyrillic" < str4 < str3 Out[]: true

यहाँ, स्ट्रिंग के सभी वर्णों पर एक रन होता है, उनमें से प्रत्येक के कोड में n जोड़ा जाता है। यह चार वर्णों की एक सरणी को निकालता है जो ठेस () फ़ंक्शन द्वारा एक साथ चिपके होते हैं, जो प्राप्त सरणी के सभी तत्वों के गुणन को लागू करता है।

चरित्र कम्प्यूटिंग

जूलिया के पास पहले से ही प्रतीकात्मक गणना के लिए तत्परता की अलग-अलग डिग्री के पैकेज हैं, उदाहरण के लिए:

लेकिन हमने किसी तरह स्ट्रिंग्स को गोंद करना सीखा, क्यों न मैट्रिक के साथ सांकेतिक क्रियाओं को लागू किया जाए। मान लें कि हम दो विषम सरणियों को जोड़ना चाहते हैं:

 m1 = [1 1 "a"; 1 0 1] Out[]: 2×3 Array{Any,2}: 1 1 "a" 1 0 1 m3 = [1 2 "ln(3)"; 2 1 0] Out[]: 2×3 Array{Any,2}: 1 2 "ln(3)" 2 1 0 m1+m3 Out[]: MethodError: no method matching +(::String, ::String) ...

आरंभ करने के लिए, अपने चंचल कलम को मूल ऑपरेटरों में चलाएं:

 import Base: *, -, +

यदि C ++ में इस तरह के उत्परिवर्तन को ऑपरेटर ओवरलोडिंग कहा जाता है, तो यहां हम मौजूदा फ़ंक्शन के लिए एक विधि जोड़ते हैं।

 +(a::String, b::String) = a * "+" * b Out[]: + (generic function with 164 methods)

डेढ़ सौ से अधिक तरीके, और यहाँ एक और एक है जो सत्र के अंत तक जीवित रहेगा।

 m1+m3 Out[]: 2×3 Array{Any,2}: 2 3 "a+ln(3)" 3 1 1

अब गुणा गुणा करें, अर्थात्, हम एक स्ट्रिंग को एक संख्या से गुणा करने के मामले को निर्धारित करते हैं:

 function *(a::String, b::Number) if b == 0 0 else if b == 1 a else "$b" * "*(" * a * ")" end end end Out[]: * (generic function with 344 methods)

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

 *(a::String, b::Number) = (b==0) ? 0 : (b==1) ? a : "$b" * "*(" * a * ")" Out[]:

हम शेष मामलों को भी इसी तरह निष्पादित करने और कुछ पाने के लिए उजागर करेंगे:

 import Base: *, -, + +(a::String, b::String) = a * "+" * b *(a::String, b::String) = a * "*(" * b * ")" *(a::String, b::Number) = (b==0) ? 0 : (b==1) ? a : "$b" * "*(" * a * ")" *(b::Number, a::String) = (b==0) ? 0 : (b==1) ? a : "$b" * "*(" * a * ")" +(a::String, b::Number) = (b==0) ? a : a * "+" * "$b" +(b::Number, a::String) = (b==0) ? a : a * "+" * "$b" -(b::Number, a::String) = (b==0) ? "-" * a : "$b" * "-" * a -(a::String, b::Number) = (b==0) ? a : a * "-" * "$b" # m1 = [1 1 "a"; 1 0 1] m2 = [2 0 2; 2 "b" 2; 2 2 2] m1*m2 Out[]: 2×3 Array{Any,2}: "2*(a)+4" "b+2*(a)" "2*(a)+4" 4 2 4

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

 ε = zeros(Int, 3,3,3) ε[1,2,3] = ε[2,3,1] = ε[3,1,2] = 1 ε[3,2,1] = ε[1,3,2] = ε[2,1,3] = -1 ε Out[]: 3×3×3 Array{Int64,3}: [:, :, 1] = 0 0 0 0 0 1 0 -1 0 [:, :, 2] = 0 0 -1 0 0 0 1 0 0 [:, :, 3] = 0 1 0 -1 0 0 0 0 0

मिश्रित उत्पाद सूत्र

l e f t [v e c a v e c b v e c c r i g h t] = s u m_{i, j, k = 1}^{3} v a r e p s i l o n_{i j k} a^{i} b^{j} c^{k}

$\ left [\ vec {a} \ vec {b} \ vec {c} \ right] = \ sum_ {i, j, k = 1} ^ {3} \ varepsilon_ {ijk} a ^ ib ^ jc ^ k$

एक 3x3 मैट्रिक्स के निर्धारक को खोजने के लिए इस्तेमाल किया जा सकता है, क्रमशः, बी , सी को पहली, दूसरी और तीसरी पंक्ति (स्तंभ) के रूप में समझना

 detrmnt(arr) = sum( ε[i,j,k]*arr[1,i]*arr[2,j]*arr[3,k] for i in 1:3, j in 1:3, k in 1:3 ) detrmnt(["a" 2 "b"; 1 0 1; "c" 2 "d"]) Out[]: "2*(c)+2*(b)+2*(-1*(a))+-2*(d)"

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

 Rx = [1 0 0 0; 0 "cos(ϕ)" "sin(ϕ)" 0; 0 "-sin(ϕ)" "cos(ϕ)" 0; 0 0 0 1]; Rz = ["cos(ϕ)" "sin(ϕ)" 0 0; "-sin(ϕ)" "cos(ϕ)" 0 0; 0 0 1 0; 0 0 0 1]; T = [1 0 0 0; 0 1 0 0; 0 0 1 0; "x0" "y0" "z0" 1]; Rx*Rz Out[]: MethodError: no method matching zero(::String) ...

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

 function *( a::Array{Any,2}, b::Array{Any,2} ) if size(a)[2] == size(b)[1] res = Array{Any}(undef, size(a)[1], size(b)[2] ) fill!(res, 0) for i = 1:size(a)[1], j = 1:size(b)[2], k = 1:size(a)[2] res[i,j] = res[i,j] + a[i,k]*b[k,j] end res else error("Matrices must have same size mult") end end Out[]: * (generic function with 379 methods)

अब आप सुरक्षित रूप से गुणा कर सकते हैं:

 X = Rx*Rz*T Out[]: 4?4 Array{Any,2}: "cos(ϕ)" "sin(ϕ)" 0 0 "cos(ϕ)*(-sin(ϕ))" "cos(ϕ)*(cos(ϕ))" "sin(ϕ)" 0 "-sin(ϕ)*(-sin(ϕ))" "-sin(ϕ)*(cos(ϕ))" "cos(ϕ)" 0 "x0" "y0" "z0" 1

आइए इस मैट्रिक्स को ध्यान में रखें, लेकिन अभी के लिए, हम पहले चरणों को शुरू करेंगे

metaprogramming

कोटी Rovkov

जूलिया मेटाप्रोग्रामिंग का समर्थन करता है। यह प्रतीकात्मक प्रोग्रामिंग के समान है, जहां हम भावों के साथ व्यवहार करते हैं (जैसे 6 * 7) मूल्यों के विपरीत (जैसे। 42)। दुभाषिया में संचालन को खींचने से, हमें तुरंत परिणाम मिलता है, जिसे हमने देखा है, लाइनों की मदद से देखा जा सकता है:

 x = "6*7" Out[]: "6*7"

स्ट्रिंग्स को पार्स () का उपयोग करके अभिव्यक्तियों में बदला जा सकता है, और फिर इवल () का उपयोग करके मूल्यांकन किया जाता है:

 eval(Meta.parse(ans)) Out[]: 42

ये सारी मुश्किलें क्यों? चाल यह है कि जब हमारे पास एक अभिव्यक्ति है , तो हम इसे विभिन्न दिलचस्प तरीकों से संशोधित कर सकते हैं:

 x = replace(x, "*" => "+") eval(Meta.parse(x)) Out[]: 13

लाइनों के साथ उपद्रव से बचने के लिए, एक फ्रॉस्टिंग फेस ऑपरेटर प्रदान किया जाता है :()

 y = :(2^8-1) Out[]: :(2^8-1) eval(y) Out[]: 255

आप एक अभिव्यक्ति, फ़ंक्शन, कोड ब्लॉक "उद्धरण" कर सकते हैं ...

 quote x = 2 + 2 hypot(x, 5) end Out[]: quote #= In[13]:2 =# x = 2 + 2 #= In[13]:3 =# hypot(x, 5) end :(function mysum(xs) sum = 0 for x in xs sum += x end end) Out[]: :(function mysum(xs) #= In[14]:2 =# sum = 0 #= In[14]:3 =# for x = xs #= In[14]:4 =# sum += x end end)

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

 X = [ "cos(ϕ)" "sin(ϕ)" 0 0; "cos(ϕ)*(-sin(ϕ))" "cos(ϕ)*(cos(ϕ))" "sin(ϕ)" 0; "-sin(ϕ)*(-sin(ϕ))" "-sin(ϕ)*(cos(ϕ))" "cos(ϕ)" 0; "x0" "y0" "z0" 1; ] for i = 1:size(X,1), j = 1:size(X,2) if typeof(X[i,j]) == String X[i,j] = Meta.parse(X[i,j]) end end X Out[]: 4×4 Array{Any,2}: :(cos(ϕ)) :(sin(ϕ)) 0 0 :(cos(ϕ) * -(sin(ϕ))) :(cos(ϕ) * cos(ϕ)) :(sin(ϕ)) 0 :(-(sin(ϕ)) * -(sin(ϕ))) :(-(sin(ϕ)) * cos(ϕ)) :(cos(ϕ)) 0 :x0 :y0 :z0 1

जैसा कि कुछ ने अनुमान लगाया है, यह परिवर्तनों का एक मैट्रिक्स है, हमने इसे पहले ही हल कर दिया है , केवल अब तीन-आयामी निर्देशांक के लिए। हम विशिष्ट मानों की गणना करेंगे:

 ϕ = 20*pi/180 x0 = 4 y0 = -0.5 z0 = 1.3 Xtr = [ eval(x) for x in X] Out[]: 4×4 Array{Real,2}: 0.939693 0.34202 0 0 -0.321394 0.883022 0.34202 0 0.116978 -0.321394 0.939693 0 4 -0.5 1.3 1

यह मैट्रिक्स X और Z अक्षों के चारों ओर घूमता है $20 ^ {\ circ}$ और करने के लिए स्थानांतरण $\ vec {R} = \ {x0, y0, z0 \}$

 x = [-1 -1 1 1 -1 -1 1 1 -1 -1]; y = [-1 -1 -1 -1 -1 1 1 1 1 -1]; z = [1 -1 -1 1 1 1 1 -1 -1 -1] R = [ x' y' z' ones( length(x) ) ] plot(x', y', z', w = 3)

 R2 = R*Xtr plot!( R2[:,1], R2[:,2], R2[:,3], w = 3)

अभिव्यक्ति वृक्ष का फल

जैसा कि हमने पहले ही देखा है, स्ट्रिंग्स "इंटरपोलेशन" का समर्थन करते हैं, जो हमें छोटे घटकों से आसानी से बड़े स्ट्रिंग्स बनाने की अनुमति देता है।

 x = "" print("$x $x $x  ...") Out[]:     ...

उद्धरण (उद्धरण) के साथ - एक ही कहानी:

 x = :(6*7) y = :($x + $x) Out[]: :(6 * 7 + 6 * 7) eval(y) Out[]: 84

सभी Eval की जड़

eval() न केवल एक अभिव्यक्ति का मूल्य लौटाता है। चलो समारोह घोषणा को उद्धृत करने का प्रयास करें:

 ex = :( cats() = println("Meow!") ) cats() Out[]: UndefVarError: cats not defined

अब उसे पुनर्जीवित करें:

 eval(ex) Out[]: cats (generic function with 1 method) cats() Out[]: Meow!

प्रक्षेप का उपयोग करना, हम मक्खी पर एक फ़ंक्शन की परिभाषा का निर्माण कर सकते हैं; वास्तव में, हम तुरंत कई कार्य कर सकते हैं।

 for name in [:dog, :bird, :mushroom] println(:($name() = println($("I'm $(name)!")))) end Out[]: dog() = begin #= In[27]:2 =# println("I'm dog!") end bird() = begin #= In[27]:2 =# println("I'm bird!") end mushroom() = begin #= In[27]:2 =# println("I'm mushroom!") end for name in [:dog, :bird, :mushroom] eval(:($name() = println($("I'm $(name)!")))) end dog() Out[]: I'm dog! mushroom() Out[]: I'm mushroom!

एपीआई लपेटते समय यह बेहद उपयोगी हो सकता है (जैसे, सी लाइब्रेरी से या एचटीटीपी के माध्यम से)। एपीआई अक्सर उपलब्ध कार्यों की एक सूची को परिभाषित करते हैं, इसलिए आप उन्हें कैप्चर कर सकते हैं और एक ही बार में संपूर्ण शेल बना सकते हैं! Clang.jl, TensorFlow.jl, या बेसिक रैखिक बीजगणित के उदाहरण देखें।

मूल पाप

यहाँ एक और अधिक व्यावहारिक उदाहरण है। टेलर श्रृंखला पर आधारित sin() फ़ंक्शन की निम्न परिभाषा पर विचार करें:

प ा प (x) = s u m_{k = 1}^{i n f t y} f r a c (- 1)^{k} (1 + 2 k)! x^{1 + 2 k}

$पाप (x) = \ sum_ {k = 1} ^ {\ infty} \ frac {(- 1) ^ k} {(1 + 2k)!} x ^ {1 + 2k}$

 mysin(x) = sum((-1)^k/factorial(1+2*k) * x^(1+2k) for k = 0:5) mysin(0.5), sin(0.5) Out[]: (0.4794255386041834, 0.479425538604203) using BenchmarkTools @benchmark mysin(0.5) Out[]: BenchmarkTools.Trial: memory estimate: 112 bytes allocs estimate: 6 -------------- minimum time: 1.105 μs (0.00% GC) median time: 1.224 μs (0.00% GC) mean time: 1.302 μs (0.00% GC) maximum time: 9.473 μs (0.00% GC) -------------- samples: 10000 evals/sample: 10

अब यह जितना हो सकता है उससे कहीं ज्यादा धीमा है। इसका कारण यह है कि हम कश्मीर के ऊपर से चलते हैं, जो अपेक्षाकृत महंगा है। स्पष्ट लिखना बहुत तेज़ है:

 mysin(x) = x - x^3/6 + x^5/120 # + ...

लेकिन यह लिखने के लिए थकाऊ है और अब मूल टेलर श्रृंखला की तरह नहीं दिखता है। इसके अलावा, पौधे के एक उच्च जोखिम है। क्या दो शॉट्स के साथ एक खरगोश को मारने का एक तरीका है? जूलिया ने हमें यह कोड कैसे लिखा? सबसे पहले, + फ़ंक्शन के प्रतीकात्मक संस्करण पर विचार करें।

 plus(a, b) = :($a + $b) plus(1, 2) Out[]: :(1 + 2)

plus() हम कई दिलचस्प चीजें कर सकते हैं, उदाहरण के लिए, एक प्रतीकात्मक योग:

 reduce(+, 1:10) Out[]: 55 reduce(plus, 1:10) Out[]: :(((((((((1 + 2) + 3) + 4) + 5) + 6) + 7) + 8) + 9) + 10) eval(ans) Out[]: 55 reduce(plus, [:(x^2), :x, 1]) Out[]: :((x ^ 2 + x) + 1)

यह हमें पहेली का एक महत्वपूर्ण हिस्सा देता है, लेकिन हमें यह भी पता लगाने की जरूरत है कि हम क्या समेट रहे हैं। आइए उपरोक्त टेलर श्रृंखला का एक प्रतीकात्मक संस्करण बनाएं जो k के मान को प्रक्षेपित करता है।

 k = 2 :($((-1)^k) * x^$(1+2k) / $(factorial(1+2k))) Out[]: :((1 * x ^ 5) / 120)

अब आप एक कन्वेयर पर पंक्ति के तत्वों को रोक सकते हैं:

 terms = [:($((-1)^k) * x^$(1+2k) / $(factorial(1+2k))) for k = 0:5] Out[]: 6-element Array{Expr,1}: :((1 * x ^ 1) / 1) :((-1 * x ^ 3) / 6) :((1 * x ^ 5) / 120) :((-1 * x ^ 7) / 5040) :((1 * x ^ 9) / 362880) :((-1 * x ^ 11) / 39916800)

और उन्हें सारांशित करें:

 reduce(plus, ans) Out[]: :((((((1 * x ^ 1) / 1 + (-1 * x ^ 3) / 6) + (1 * x ^ 5) / 120) + (-1 * x ^ 7) / 5040) + (1 * x ^ 9) / 362880) + (-1 * x ^ 11) / 39916800) :(mysin(x) = $ans) Out[]: :(mysin(x) = begin #= In[52]:1 =# (((((1 * x ^ 1) / 1 + (-1 * x ^ 3) / 6) + (1 * x ^ 5) / 120) + (-1 * x ^ 7) / 5040) + (1 * x ^ 9) / 362880) + (-1 * x ^ 11) / 39916800 end) eval(ans) mysin(0.5), sin(0.5) Out[]: (0.4794255386041834, 0.479425538604203) @benchmark mysin(0.5) Out[]: BenchmarkTools.Trial: memory estimate: 0 bytes allocs estimate: 0 -------------- minimum time: 414.363 ns (0.00% GC) median time: 416.328 ns (0.00% GC) mean time: 431.885 ns (0.00% GC) maximum time: 3.352 μs (0.00% GC) -------------- samples: 10000 evals/sample: 201

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

जूलिया। स्ट्रिंग्स और मेटाप्रोग्रामिंग