जूलिया से 6 अप्रत्याशित पुरुष

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

खोज के दौरान, मैं अर्थशास्त्रियों के लिए एक प्रोग्रामिंग कोर्स में आया (जूलिया के अलावा, पायथन भी है)। अनुभवी एक त्वरित पाठ्यक्रम के लिए जा सकते हैं या किताब पढ़ सकते हैं कि कैसे एक कंप्यूटर वैज्ञानिक की तरह सोचें

निम्नलिखित क्रिस्टोफर Rackauckas 7 जूलिया Gotchas और कैसे उन्हें संभालने के ब्लॉग से सामग्री का एक अनुवाद है

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

जूलिया यह समझने के लिए एक अच्छी भाषा है कि क्या हो रहा है, क्योंकि इसमें कोई जादू नहीं है। जूलिया डेवलपर्स आचरण के नियमों को स्पष्ट रूप से परिभाषित करना चाहते थे। इसका मतलब है कि सभी व्यवहार को समझाया जा सकता है। हालांकि, इसका मतलब यह हो सकता है कि आपको यह समझने के लिए अपने सिर पर दबाव डालना पड़े कि यह क्यों हो रहा है और दूसरा नहीं हो रहा है। इसलिए मैं न केवल कुछ सामान्य समस्याओं की व्याख्या करने जा रहा हूं, बल्कि मैं यह भी बताने जा रहा हूं कि वे क्यों उत्पन्न होते हैं। आप देखेंगे कि कुछ ऐसे ही पैटर्न हैं, और एक बार जब आप उनके बारे में जागरूक हो जाते हैं, तो आप उनमें से किसी पर भी अलग नहीं रहेंगे। इस वजह से, जूलिया में MATLAB / R / Python जैसी सरल भाषाओं की तुलना में थोड़ा स्टेटर सीखने की अवस्था है। हालाँकि, एक बार जब आप इसमें महारत हासिल कर लेते हैं, तो आप जूलिया के लैकोनिज़्म का पूरी तरह से सी / फोरट्रान प्रदर्शन हासिल करने में सक्षम होंगे। अब गहरी खुदाई करें।

अप्रत्याशित रूप से: REPL (टर्मिनल) में एक वैश्विक गुंजाइश है

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

एक छोटा विषयांतर: क्यों जूलिया तेज है

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

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

 function f(a,b) return 2a+b end 

ऐसा लगता है कि यह केवल एक , लेकिन वास्तव में बड़ी संख्या में यहां बनाए गए हैं। जूलिया की भाषा में, एक फ़ंक्शन एक अमूर्त है, और जिसे वास्तव में कहा जाता है वह एक विधि है। यदि आप f(2.0,3.0) कॉल करते हैं, तो जूलिया संकलित कोड चलाएगा, जो दो फ्लोटिंग पॉइंट नंबर लेता है और 2a + b । यदि आप f(2,3) , तो जूलिया एक और संकलित कोड चलाएगा जो दो पूर्णांक लेता है और 2a + b । फ़ंक्शन f कई अलग-अलग तरीकों के लिए एक अमूर्त या संक्षिप्त नाम है, जिसमें एक ही रूप है, और इन सभी विभिन्न तरीकों को कॉल करने के लिए प्रतीक च का उपयोग करने की ऐसी योजना को कई प्रेषण कहा जाता है। और यह हर जगह लागू होता है: + ऑपरेटर वास्तव में एक फ़ंक्शन है जो उस प्रकार के आधार पर विधियों को कॉल करेगा जो इसे देखता है। जूलिया वास्तव में अपनी गति प्राप्त करता है क्योंकि इसके द्वारा संकलित कोड इसके प्रकारों को जानता है, और इसलिए संकलित कोड जो f (2.0,3.0) कहता है, वास्तव में संकलित कोड है जो आप C / फोरट्रान में समान फ़ंक्शन को परिभाषित करके प्राप्त करते हैं। संकलित असेंबली देखने के लिए आप इसे code_native मैक्रो के साथ देख सकते हैं:

 @code_native f(2.0,3.0) 

 pushq %rbp movq %rsp, %rbp Source line: 2 vaddsd %xmm0, %xmm0, %xmm0 vaddsd %xmm1, %xmm0, %xmm0 popq %rbp retq nop 

यह वही संकलित असेंबली है जिसे आप C / फोरट्रान में एक फ़ंक्शन से उम्मीद करते हैं, और यह पूर्णांक के लिए असेंबली कोड से अलग है:

 @code_native f(2,3) pushq %rbp movq %rsp, %rbp Source line: 2 leaq (%rdx,%rcx,2), %rax popq %rbp retq nopw (%rax,%rax) 

सार: REPL / ग्लोबल स्कोप प्रकार विशिष्टता की अनुमति नहीं देता है

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

 function outer() a = 5 function inner() return 2a end b = inner() return 3a+b end 

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

 a=2.0; b=3.0 function linearcombo() return 2a+b end ans = linearcombo() 

और

 a = 2; b = 3 ans2= linearcombo() 

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

 pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r12 pushq %rsi pushq %rdi pushq %rbx subq $96, %rsp movl $2147565792, %edi # imm = 0x800140E0 movabsq $jl_get_ptls_states, %rax callq *%rax movq %rax, %rsi leaq -72(%rbp), %r14 movq $0, -88(%rbp) vxorps %xmm0, %xmm0, %xmm0 vmovups %xmm0, -72(%rbp) movq $0, -56(%rbp) movq $10, -104(%rbp) movq (%rsi), %rax movq %rax, -96(%rbp) leaq -104(%rbp), %rax movq %rax, (%rsi) Source line: 3 movq pcre2_default_compile_context_8(%rdi), %rax movq %rax, -56(%rbp) movl $2154391480, %eax # imm = 0x806967B8 vmovq %rax, %xmm0 vpslldq $8, %xmm0, %xmm0 # xmm0 = zero,zero,zero,zero,zero,zero,zero,zero,xmm0[0,1,2,3,4,5,6,7] vmovdqu %xmm0, -80(%rbp) movq %rdi, -64(%rbp) movabsq $jl_apply_generic, %r15 movl $3, %edx movq %r14, %rcx callq *%r15 movq %rax, %rbx movq %rbx, -88(%rbp) movabsq $586874896, %r12 # imm = 0x22FB0010 movq (%r12), %rax testq %rax, %rax jne L198 leaq 98096(%rdi), %rcx movabsq $jl_get_binding_or_error, %rax movl $122868360, %edx # imm = 0x752D288 callq *%rax movq %rax, (%r12) L198: movq 8(%rax), %rax testq %rax, %rax je L263 movq %rax, -80(%rbp) addq $5498232, %rdi # imm = 0x53E578 movq %rdi, -72(%rbp) movq %rbx, -64(%rbp) movq %rax, -56(%rbp) movl $3, %edx movq %r14, %rcx callq *%r15 movq -96(%rbp), %rcx movq %rcx, (%rsi) addq $96, %rsp popq %rbx popq %rdi popq %rsi popq %r12 popq %r14 popq %r15 popq %rbp retq L263: movabsq $jl_undefined_var_error, %rax movl $122868360, %ecx # imm = 0x752D288 callq *%rax ud2 nopw (%rax,%rax) 

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

 a = 1 for i = 1:100 a += a + f(a) end 

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

किसी समस्या से कैसे बचें

इस समस्या से बचने के कई तरीके हैं। सबसे आसान तरीका है कि आप अपनी स्क्रिप्ट को फ़ंक्शंस में हमेशा लपेटें। उदाहरण के लिए, पिछला कोड फॉर्म लेगा:

 function geta(a) # can also just define a=1 here for i = 1:100 a += a + f(a) end return a end a = geta(1) 

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

 const b = 5 

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

 const a = 5 f() = a println(f()) # Prints 5 a = 6 println(f()) # Prints 5 # WARNING: redefining constant a 

यह अपेक्षा के अनुरूप काम नहीं करता है, क्योंकि संकलक, यह महसूस करते हुए कि वह f () = a (चूंकि एक स्थिर है) का उत्तर जानता है, बस फ़ंक्शन को जवाब के साथ बदल दिया है, यदि कोई निरंतर नहीं था तो a अलग व्यवहार दे।

Moral: अपनी स्क्रिप्ट सीधे REPL में न लिखें, हमेशा उन्हें किसी फ़ंक्शन में लपेटें।

Nezhdanchik दो: टाइप अस्थिरता

इसलिए, मैंने सिर्फ एक राय व्यक्त की कि डेटा प्रकारों के लिए कोड की विशेषज्ञता कितनी महत्वपूर्ण है। मुझे आपसे एक सवाल पूछना है, जब आपके प्रकार बदल सकते हैं तो क्या होगा? यदि आपने अनुमान लगाया है: "ठीक है, इस मामले में, आप संकलित कोड को विशेषज्ञ नहीं कर सकते," तो आप सही हैं। इस तरह की समस्या को टाइप अस्थिरता के रूप में जाना जाता है। वे अलग-अलग दिखाई दे सकते हैं, लेकिन एक सामान्य उदाहरण यह है कि आप सरल के साथ मूल्य को इनिशियलाइज़ करते हैं, लेकिन जरूरी नहीं कि वह जिस प्रकार का होना चाहिए। उदाहरण के लिए, आइए देखें:

 function g() x=1 for i = 1:10 x = x/2 end return x end 

ध्यान दें कि जूलिया में 1/2 एक फ्लोटिंग पॉइंट नंबर है। इसलिए, यदि हमने x = 1 साथ शुरू किया, तो पूर्णांक एक फ्लोटिंग पॉइंट नंबर में बदल जाएगा, और इस प्रकार, फ़ंक्शन को आंतरिक लूप को संकलित करना चाहिए, जैसे कि यह किसी भी प्रकार का हो सकता है। अगर इसके बजाय हमारे पास था:

 function h() x=1.0 for i = 1:10 x = x/2 end return x end 

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

 pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rsi pushq %rdi pushq %rbx subq $136, %rsp movl $2147565728, %ebx # imm = 0x800140A0 movabsq $jl_get_ptls_states, %rax callq *%rax movq %rax, -152(%rbp) vxorps %xmm0, %xmm0, %xmm0 vmovups %xmm0, -80(%rbp) movq $0, -64(%rbp) vxorps %ymm0, %ymm0, %ymm0 vmovups %ymm0, -128(%rbp) movq $0, -96(%rbp) movq $18, -144(%rbp) movq (%rax), %rcx movq %rcx, -136(%rbp) leaq -144(%rbp), %rcx movq %rcx, (%rax) movq $0, -88(%rbp) Source line: 4 movq %rbx, -104(%rbp) movl $10, %edi leaq 477872(%rbx), %r13 leaq 10039728(%rbx), %r15 leaq 8958904(%rbx), %r14 leaq 64(%rbx), %r12 leaq 10126032(%rbx), %rax movq %rax, -160(%rbp) nopw (%rax,%rax) L176: movq %rbx, -128(%rbp) movq -8(%rbx), %rax andq $-16, %rax movq %r15, %rcx cmpq %r13, %rax je L272 movq %rbx, -96(%rbp) movq -160(%rbp), %rcx cmpq $2147419568, %rax # imm = 0x7FFF05B0 je L272 movq %rbx, -72(%rbp) movq %r14, -80(%rbp) movq %r12, -64(%rbp) movl $3, %edx leaq -80(%rbp), %rcx movabsq $jl_apply_generic, %rax vzeroupper callq *%rax movq %rax, -88(%rbp) jmp L317 nopw %cs:(%rax,%rax) L272: movq %rcx, -120(%rbp) movq %rbx, -72(%rbp) movq %r14, -80(%rbp) movq %r12, -64(%rbp) movl $3, %r8d leaq -80(%rbp), %rdx movabsq $jl_invoke, %rax vzeroupper callq *%rax movq %rax, -112(%rbp) L317: movq (%rax), %rsi movl $1488, %edx # imm = 0x5D0 movl $16, %r8d movq -152(%rbp), %rcx movabsq $jl_gc_pool_alloc, %rax callq *%rax movq %rax, %rbx movq %r13, -8(%rbx) movq %rsi, (%rbx) movq %rbx, -104(%rbp) Source line: 3 addq $-1, %rdi jne L176 Source line: 6 movq -136(%rbp), %rax movq -152(%rbp), %rcx movq %rax, (%rcx) movq %rbx, %rax addq $136, %rsp popq %rbx popq %rdi popq %rsi popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq nop 

के खिलाफ

 pushq %rbp movq %rsp, %rbp movabsq $567811336, %rax # imm = 0x21D81D08 Source line: 6 vmovsd (%rax), %xmm0 # xmm0 = mem[0],zero popq %rbp retq nopw %cs:(%rax,%rax) 

समान मान प्राप्त करने के लिए गणना की संख्या में ऐसा अंतर!

टाइप अस्थिरता के साथ कैसे पता करें और कैसे निपटें

इस बिंदु पर, आप पूछ सकते हैं: "ठीक है, क्यों न केवल सी का उपयोग करें ताकि आपको इन अस्थिरताओं की तलाश न करनी पड़े?" उत्तर है:

1. खोजने में आसान है
2. वे सहायक हो सकते हैं।

3. आप कार्यात्मक बाधाओं के साथ अस्थिरता को संभाल सकते हैं

   
   

   जूलिया आपको यह दिखाने के लिए code_warntype मैक्रो देता है जहाँ प्रकार की अस्थिरताएँ हैं। उदाहरण के लिए, यदि हम इसे हमारे द्वारा बनाए गए g फ़ंक्शन में उपयोग करते हैं:

   
   

    @code_warntype g() 

   
   

 Variables: #self#::#g x::ANY #temp#@_3::Int64 i::Int64 #temp#@_5::Core.MethodInstance #temp#@_6::Float64 Body: begin x::ANY = 1 # line 3: SSAValue(2) = (Base.select_value)((Base.sle_int)(1,10)::Bool,10,(Base.box)(Int64,(Base.sub_int)(1,1)))::Int64 #temp#@_3::Int64 = 1 5: unless (Base.box)(Base.Bool,(Base.not_int)((#temp#@_3::Int64 === (Base.box)(Int64,(Base.add_int)(SSAValue(2),1)))::Bool)) goto 30 SSAValue(3) = #temp#@_3::Int64 SSAValue(4) = (Base.box)(Int64,(Base.add_int)(#temp#@_3::Int64,1)) i::Int64 = SSAValue(3) #temp#@_3::Int64 = SSAValue(4) # line 4: unless (Core.isa)(x::UNION{FLOAT64,INT64},Float64)::ANY goto 15 #temp#@_5::Core.MethodInstance = MethodInstance for /(::Float64, ::Int64) goto 24 15: unless (Core.isa)(x::UNION{FLOAT64,INT64},Int64)::ANY goto 19 #temp#@_5::Core.MethodInstance = MethodInstance for /(::Int64, ::Int64) goto 24 19: goto 21 21: #temp#@_6::Float64 = (x::UNION{FLOAT64,INT64} / 2)::Float64 goto 26 24: #temp#@_6::Float64 = $(Expr(:invoke, :(#temp#@_5), :(Main./), :(x::Union{Float64,Int64}), 2)) 26: x::ANY = #temp#@_6::Float64 28: goto 5 30: # line 6: return x::UNION{FLOAT64,INT64} end::UNION{FLOAT64,INT64} 

ध्यान दें कि शुरुआत में हम कहते हैं कि टाइप एक्स Any । यह किसी भी प्रकार का उपयोग करेगा जिसे strict type रूप में नामित नहीं किया गया है, अर्थात यह एक अमूर्त प्रकार है जिसे प्रत्येक चरण में बॉक्सिंग / चेक करने की आवश्यकता होती है। हम देखते हैं कि अंत में हम x को UNION {FLOAT64, INT64} रूप में UNION {FLOAT64, INT64} , जो एक और गैर-सख्त प्रकार है। यह हमें बताता है कि टाइप बदल गया है, जिससे कठिनाइयां होती हैं। यदि हम h लिए code_warntype को code_warntype , तो हमें सभी सख्त प्रकार मिलते हैं:

 @code_warntype h() Variables: #self#::#h x::Float64 #temp#::Int64 i::Int64 Body: begin x::Float64 = 1.0 # line 3: SSAValue(2) = (Base.select_value)((Base.sle_int)(1,10)::Bool,10,(Base.box)(Int64,(Base.sub_int)(1,1)))::Int64 #temp#::Int64 = 1 5: unless (Base.box)(Base.Bool,(Base.not_int)((#temp#::Int64 === (Base.box)(Int64,(Base.add_int)(SSAValue(2),1)))::Bool)) goto 15 SSAValue(3) = #temp#::Int64 SSAValue(4) = (Base.box)(Int64,(Base.add_int)(#temp#::Int64,1)) i::Int64 = SSAValue(3) #temp#::Int64 = SSAValue(4) # line 4: x::Float64 = (Base.box)(Base.Float64,(Base.div_float)(x::Float64,(Base.box)(Float64,(Base.sitofp)(Float64,2)))) 13: goto 5 15: # line 6: return x::Float64 end::Float64 

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

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

प्रकार की अस्थिरताओं से कैसे निपटें

टाइप अस्थिरताओं से निपटने के कई तरीके हैं। सबसे पहले, यदि आप सी / फोरट्रान जैसी कोई चीज पसंद करते हैं, जहां आपके प्रकार घोषित किए जाते हैं और बदल नहीं सकते हैं (जो कि स्थिरता सुनिश्चित करता है), तो आप जूलिया में ऐसा कर सकते हैं:

 local a::Int64 = 5 

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

 a = (b/c)::Float64 

यह कहना प्रतीत होता है: "b / c की गणना करें और सुनिश्चित करें कि आउटपुट Float64 है। यदि यह नहीं है, तो स्वचालित रूपांतरण करने का प्रयास करें। यदि रूपांतरण आसानी से नहीं किया जा सकता है, तो एक त्रुटि उत्पन्न होती है।" इस तरह के डिजाइन रखने से आपको यह सुनिश्चित करने में मदद मिलेगी कि आप जानते हैं कि कौन से प्रकार शामिल हैं। हालांकि, कुछ मामलों में, टाइप अस्थिरता आवश्यक है। उदाहरण के लिए, मान लें कि आप विश्वसनीय कोड चाहते हैं, लेकिन उपयोगकर्ता आपको कुछ पागल देता है, जैसे:

 arr = Vector{Union{Int64,Float64}}(undef, 4) arr[1]=4 arr[2]=2.0 arr[3]=3.2 arr[4]=1 

जो 4x1 पूर्णांकों और फ्लोटिंग पॉइंट नंबरों की एक सरणी है। सरणी के लिए वास्तविक तत्व प्रकार Union {Int64, Float64} , जैसा कि हमने पहले देखा था, सख्त नहीं था, जिससे समस्याएं हो सकती थीं। कंपाइलर केवल यह जानता है कि प्रत्येक मान एक पूर्णांक या एक फ्लोटिंग पॉइंट नंबर हो सकता है, लेकिन किस प्रकार का तत्व नहीं। इसका मतलब यह है कि इस सरणी के साथ अंकगणित करना अच्छा है, उदाहरण के लिए:

 function foo{T,N}(array::Array{T,N}) for i in eachindex(array) val = array[i] # do algorithm X on val end end 

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

 function inner_foo{T<:Number}(val::T) # Do algorithm X on val end function foo2{T,N}(array::Array{T,N}) for i in eachindex(array) inner_foo(array[i]) end end 

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

इस प्रकार, मुझे आशा है कि आप देखते हैं कि जूलिया मजबूत टाइपिंग प्रदर्शन और गतिशील टाइपिंग की सुविधा का एक अच्छा संयोजन प्रदान करता है। एक अच्छा जूलिया प्रोग्रामर के पास आवश्यक होने पर उत्पादकता और / या उत्पादकता को अधिकतम करने के लिए उसके निपटान में दोनों होते हैं।

सरप्राइज़ 3: एवल विश्व स्तर पर काम करता है

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

 macro defa() :(a=5) end 

कोड के साथ किसी भी defa उदाहरण को प्रतिस्थापित करेगा a = 5 ( :(a = 5) को उद्धृत किया गया है । जूलिया का कोड अभिव्यक्ति है, और इसलिए मेटाप्रोग्रामिंग अभिव्यक्ति का एक संग्रह है)।

आप इसका उपयोग किसी भी जटिल जूलिया प्रोग्राम को बनाने के लिए कर सकते हैं जिसे आप एक फ़ंक्शन में डाल सकते हैं और वास्तव में स्मार्ट शॉर्टकट के एक प्रकार के रूप में कार्य कर सकते हैं। हालांकि, कभी-कभी आपको सीधे उत्पन्न कोड का मूल्यांकन करने की आवश्यकता हो सकती है। जूलिया आपको ऐसा करने के लिए एक eval function या @eval मैक्रो देता है। सामान्य तौर पर, आपको eval से बचने की कोशिश करनी चाहिए, लेकिन कुछ कोड हैं जहां यह आवश्यक है, उदाहरण के लिए, समानांतर प्रोग्रामिंग के लिए विभिन्न प्रक्रियाओं के बीच डेटा स्थानांतरित करने के लिए मेरा नया पुस्तकालय । , , :

 @eval :(a=5) 

(REPL). , / . उदाहरण के लिए:

 function testeval() @eval :(a=5) return 2a+5 end 

, a REPL. , , :

 function testeval() @eval :(a=5) b = a::Int64 return 2b+5 end 

b — , , , , , . eval , , REPL .

4:

Julia , . : , .

, ? , , . उदाहरण के लिए:

 a = 2 + 3 + 4 + 5 + 6 + 7 +8 + 9 + 10+ 11+ 12+ 13 a 

, 90, 27. ? a = 2 + 3 + 4 + 5 + 6 + 7 , a = 27 , +8 + 9 + 10+ 11+ 12+ 13 , , , :

 a = 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10+ 11+ 12+ 13 

90, . , .

. — , . rssdev10

. उदाहरण के लिए:

 x = rand(2,2) a = [cos(2*pi.*x[:,1]).*cos(2*pi.*x[:,2])./(4*pi) -sin(2.*x[:,1]).*sin(2.*x[:,2])./(4)] b = [cos(2*pi.*x[:,1]).*cos(2*pi.*x[:,2])./(4*pi) - sin(2.*x[:,1]).*sin(2.*x[:,2])./(4)] 

, a b — , ! (2,2) , — (1-) 2. , , :

 a = [1 -2] b = [1 - 2] 

: 1 -2 . : 1-2 . - . :

 a = [1 2 3 -4 2 -3 1 4] 

2x4. , . : hcat :

 a = hcat(cos(2*pi.*x[:,1]).*cos(2*pi.*x[:,2])./(4*pi),-sin(2.*x[:,1]).*sin(2.*x[:,2])./(4)) 

!

№5: ,

(View) — () , ( ), .

, , . , . , .

— "". "" , . "" — ( ). ( () ) . , :

 a = [3;4;5] b = a b[1] = 1 

, a — [1; 4; 5] , . . b a . , b = a b a . , , b , , ( b a ). , . , , :

 a = rand(2,2) # Makes a random 2x2 matrix b = vec(a) # Makes a view to the 2x2 matrix which is a 1-dimensional array 

b , b a , b . , , ( , ). . , . उदाहरण के लिए:

 c = a[1:2,1] 

( , c a ). , , , , . , , :

 d = @view a[1:2,1] e = view(a,1:2,1) 

d , e — , d e a , , , . ( , , — reshape , .) , . उदाहरण के लिए:

 a[1:2,1] = [1;2] 

a , a[1:2,1] view (a, 1:2,1) , , a . -? , :

 b = copy(a) 

, b a , , b a . a , copy! (B, a) , a a ( , b ). . , Vector {Vector} :

 a = [ [1, 2, 3], [4, 5], [6, 7, 8, 9] ] 

. , ?

 b = copy(a) b[1][1] = 10 a 

 3-element Array{Array{Int64,1},1}: [10, 2, 3] [4, 5] [6, 7, 8, 9] 

, a[1][1] 10! ? copy a . a , b , b . , deepcopy :

 b = deepcopy(a) 

, . , , .

№6: , In-Place

MATLAB / Python / R . Julia , , , " ". (. . , , , , ). (in-place), . ? in-place ( mutable function ) — , , . , . , :

 function f() x = [1;5;6] for i = 1:10 x = x + inner(x) end return x end function inner(x) return 2x end 

, inner , , 2x . , . , - y , :

 function f() x = [1;5;6] y = Vector{Int64}(3) for i = 1:10 inner(y,x) for i in 1:3 x[i] = x[i] + y[i] end copy!(y,x) end return x end function inner!(y,x) for i=1:3 y[i] = 2*x[i] end nothing end 

. inner!(y, x) , y . y , y , , , inner! (y, x) . , , mutable (, ""). ! ( ).

, inner!(y, x) . copy!(y, x) — , x y , . , , . : x y . , x + inner(x) , , , 11 . , .

, , , . - ( loop-fusion ). Julia v0.5 . ( ( broadcast ), ). , f.(x) — , f x , , . f x , x = x + f. (x) . :

 x .= x .+ f.(x) 

.= , , ,

 for i = 1:length(x) x[i] = x[i] + f(x[i]) end 

, :

 function f() x = [1;5;6] for i = 1:10 x .= x .+ inner.(x) end return x end function inner(x) return 2x end 

MATLAB / R / Python , , , . , , C / Fortran .

: ,

: , . , . , . , , . , .

- , C / Fortran , . - , , !

: ? , . , , ? [ , Javascript var x = 3 x , x = 3 x . ? , - Javascript!]