मैंने पायथन से जूलिया (और क्यों) का स्विच किया

अजगर के बारे में एक छोटी पृष्ठभूमि

किसके लिए क्या अच्छा है?

np.count_nonzero(x[:-1] - x[1:]) 

1. Numba JIT। अगर वह नुम्बा शीर्षक पृष्ठ पर वर्णित के रूप में काम करती है, तो मुझे लगता है कि कहानी खत्म करना सार्थक होगा। मैं अतीत को थोड़ा भूल गया था कि उसके साथ क्या गलत हुआ था; लब्बोलुआब यह है कि त्वरण उतना प्रभावशाली नहीं था जितना मुझे उम्मीद थी, अफसोस।
2. Cython। ठीक है, अपने हाथों को उठाएं जो मानते हैं कि साइथन वास्तव में सुंदर, सुरुचिपूर्ण समाधान है जो अजगर के बहुत अर्थ और आत्मा को नष्ट नहीं करता है? मुझे ऐसा नहीं लगता; यदि आप साइथन को मिलते हैं, तो आप पहले से ही खुद को बेवकूफ बनाना बंद कर सकते हैं और कुछ कम परिष्कृत जैसे सी ++ और सी पर स्विच कर सकते हैं।
3. सी में अड़चनों को फिर से लिखें और उन्हें अपने प्यारे पायथन से दें। ठीक है, लेकिन क्या होगा अगर मेरे पास पूरा कार्यक्रम है - यह सब गणना और बाधाओं के बारे में है? शी न चढ़ाता है! मैं इस तथ्य के बारे में बात नहीं कर रहा हूं कि इस समाधान में आपको न केवल एक, बल्कि दो भाषाओं - पायथन और सी।

यहाँ जूलिया आती है!

1. फोरट्रान । और हँसो मत, हममें से किसने अपनी पसंदीदा भाषाओं से BLAS / LAPACK नहीं निकाला? फोरट्रान SCIENTIFIC कंप्यूटिंग के लिए एक बहुत अच्छा (बेहतर SI!) भाषा है। मैंने इसे इस कारण से नहीं लिया कि फोरट्रान के समय से कई चीजों का आविष्कार किया गया है और प्रोग्रामिंग भाषाओं में जोड़ा गया है; मैं कुछ और आधुनिक की उम्मीद कर रहा था।
2. आर पायथन (वैश्वीकरण) जैसी ही समस्याओं से ग्रस्त है।
3. मतलाब - शायद हां, मेरे पास दुर्भाग्य से जांचने के लिए पैसे नहीं हैं।
4. जूलिया - घोड़ा अंधेरा है, दूर ले जाएगा, दूर नहीं ले जाएगा (और यह स्थिर संस्करण 1.0 तक स्वाभाविक था)

जूलिया के कुछ स्पष्ट लाभ

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

    rand() #       0  1 rand(10) #   10     0  1 rand(3,5) #   3  5   .... using Distributions d = Normal() #     0, 1 rand(d) #     rand(d, 10) #   10 ...    

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

विपक्ष जिसके बारे में चुप रहना अपराध होगा!

1. नई भाषा। एक तरफ, ज़ाहिर है, एक माइनस। कुछ में, शायद अपरिपक्व। दूसरी ओर, उन्होंने कई पिछली भाषाओं की रेक को संभाला, "दिग्गजों के कंधों पर" खड़ा हुआ, बहुत सारी दिलचस्प और नई चीजों को अवशोषित किया।
2. तुरंत तेज कार्यक्रम लिखने की संभावना नहीं है। कुछ गैर-स्पष्ट चीजें हैं जिनसे निपटना बहुत आसान है: आप रेक पर कदम रखते हैं, समुदाय से मदद मांगते हैं, फिर से कदम बढ़ाते हैं आदि। ये मुख्य रूप से अस्थिरता, प्रकार की अस्थिरता और वैश्विक चर हैं। सामान्य तौर पर, जहां तक ​​मैं खुद बता सकता हूं, एक प्रोग्रामर जो जूलिया में जल्दी लिखना चाहता है, कई चरणों से गुजरता है: ए) पायथन में लिखता है। यह बहुत अच्छा है, और इसलिए यह है, लेकिन कभी-कभी प्रदर्शन समस्याएं होंगी। बी) सी में लिखते हैं: जहाँ भी संभव हो वहाँ मैन्युअल लिखावट। ग) धीरे-धीरे समझता है कि प्रकारों को निर्धारित करने के लिए यह कहां (बहुत पैमाइश) आवश्यक है, और जहां वे हस्तक्षेप करते हैं।
3. पारिस्थितिकी तंत्र। कुछ पैकेज कच्चे हैं, इस अर्थ में कि कहीं न कहीं कुछ लगातार गिरता है; कुछ परिपक्व हैं, लेकिन एक दूसरे के साथ असंगत हैं (अन्य प्रकारों में रूपांतरण आवश्यक है, उदाहरण के लिए)। एक ओर, यह स्पष्ट रूप से बुरा है; दूसरी ओर, जूलिया के पास बहुत सारे दिलचस्प और साहसिक विचार हैं क्योंकि "हम दिग्गजों के कंधों पर खड़े हैं" - हमारे पास एक रेक पर कदम रखने का जबरदस्त अनुभव है और "यह कैसे नहीं करना है", और यह पैकेज डेवलपर्स द्वारा (आंशिक रूप से) ध्यान में रखा गया है।
4. 1. हा, मजाक से गिरते हुए नंबर, यह निश्चित रूप से एक प्लस है! नहीं, ठीक है, गंभीरता से, क्या बात है, अंकन किस सूचकांक के साथ शुरू होता है? 5 मिनट में आपको इसकी आदत हो जाती है। कोई भी शिकायत नहीं करता है कि पूर्णांक को पूर्णांक कहा जाता है, संपूर्ण नहीं। ये सभी स्वाद के मामले हैं। और हाँ, एल्गोरिदम के अनुसार कम से कम एक ही कॉर्मेन लें - सब कुछ एक से गिना जाता है, और कभी-कभी इसे इसके विपरीत पायथन में फिर से करना असुविधाजनक होता है।

खैर, गति क्यों?

 def process_fft(x, boundary): return np.count_nonzero(np.abs(np.fft.fft(2*x-1)) > boundary) %timeit process_fft(x, 2000) 84.1 ms ± 335 µs per loop (mean ± std. dev. of 7 runs, 10 loops each) 

 function process_fft(x, boundary) count(t -> t > boundary, abs.(fft(2*x.-1))) end @benchmark process_fft(x, 2000) BenchmarkTools.Trial: memory estimate: 106.81 MiB allocs estimate: 61 -------------- minimum time: 80.233 ms (4.75% GC) median time: 80.746 ms (4.70% GC) mean time: 85.000 ms (8.67% GC) maximum time: 205.831 ms (52.27% GC) -------------- samples: 59 evals/sample: 1 

 def longest(x): maxLen = 0 currLen = 0 # This will count the number of ones in the block for bit in x: if bit == 1: currLen += 1 maxLen = max(maxLen, currLen) else: maxLen = max(maxLen, currLen) currLen = 0 return max(maxLen, currLen) %timeit longest(x) 599 ms ± 639 µs per loop (mean ± std. dev. of 7 runs, 1 loop each) 

 function longest(x) maxLen = 0 currLen = 0 # This will count the number of ones in the block for bit in x if bit == 1 currLen += 1 maxLen = max(maxLen, currLen) else maxLen = max(maxLen, currLen) currLen = 0 end end return max(maxLen, currLen) end @benchmark longest(x) BenchmarkTools.Trial: memory estimate: 0 bytes allocs estimate: 0 -------------- minimum time: 9.094 ms (0.00% GC) median time: 9.248 ms (0.00% GC) mean time: 9.319 ms (0.00% GC) maximum time: 12.177 ms (0.00% GC) -------------- samples: 536 evals/sample: 1 

आखिर में क्या निकला?

मैंने यह सब क्यों लिखा?