👮 🤱🏽 🐁 जूलिया। कहां से शुरू करें प्रोजेक्ट ... 🚮 🚽 📗

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

परियोजना

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

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

पैकेज नामकरण नियम

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

विभिन्न क्षेत्रों में अलग-अलग तरीके से उपयोग किए जाने वाले जर्गॉन और विवादास्पद संकुचन से बचा जाना चाहिए।
पैकेज नाम में जूलिया शब्द का उपयोग न करें।
उन पैकेजों को प्रदान करता है जो उनके साथ घोषित किए गए नए प्रकारों के साथ-साथ बहुवचन में नामित किए जाने चाहिए।
◦ DataFrames एक DataFrame प्रकार प्रदान करता है।
◦ ब्लूमफिल्टर ब्लूमफिल्टर प्रकार प्रदान करता है।
Time एक ही समय में, जूलियापरर एक नया प्रकार प्रदान नहीं करता है, और नई कार्यक्षमता जूलियापाररपर्स () फ़ंक्शन है।
पूर्ण नाम का उपयोग करते हुए पारदर्शिता और समझदारी को संक्षेप में पसंद किया जाना चाहिए। RandomMatrices RndMat या RMT से कम अस्पष्ट है।
नाम विषय क्षेत्र की बारीकियों के अनुरूप हो सकता है। उदाहरण:
◦ जूलिया के पास अपने स्वयं के ग्राफिक्स ड्राइंग पैकेज नहीं हैं। इसके बजाय, वहाँ Gadfly , PyPlot , Winston आदि पैकेज हैं, जिनमें से प्रत्येक अपने स्वयं के दृष्टिकोण और उपयोग के लिए कार्यप्रणाली को लागू करता है।
SortingAlgorithms एक ही समय में, SortingAlgorithms एल्गोरिदम छँटाई एल्गोरिदम का उपयोग करने के लिए एक पूर्ण इंटरफ़ेस प्रदान करता है।
ऐसे मामलों में जब पैकेज कुछ तृतीय-पक्ष पुस्तकालयों पर एक आवरण होते हैं, वे इस पुस्तकालय का नाम रखते हैं। उदाहरण:
CPLEX.jl , CPLEX लाइब्रेरी के ऊपर एक आवरण है।
◦ MATLAB.jl जूलिया से MATLAB को सक्रिय करने के लिए एक इंटरफ़ेस प्रदान करता है।

इसी समय, गिट रिपॉजिटरी के नाम में आमतौर पर प्रत्यय ".jl" होता है।

पैकेज पीढ़ी

पैकेज बनाने का सबसे आसान तरीका यह है कि इसे जूलिया में निर्मित जेनरेटर से बनाया जाए। ऐसा करने के लिए, कंसोल में, आपको उस निर्देशिका में जाने की आवश्यकता है जिसमें पैकेज बनाया जाना चाहिए, फिर जूलिया चलाएं और इसे पैकेज प्रबंधन मोड में डालें:

 julia> ]

अंतिम चरण पैकेज जनरेटर को उस नाम को निर्दिष्ट करके शुरू करना है जिसे हम पैकेज देना चाहते हैं।

 (v1.2) pkg> generate HelloWorld

परिणामस्वरूप, पैकेज के नाम के अनुरूप वर्तमान निर्देशिका में एक नई निर्देशिका दिखाई देती है, जिसकी संरचना tree कमांड का उपयोग करके देखी जा सकती है (यदि यह स्थापित है):

 shell> cd HelloWorld shell> tree . . ├── Project.toml └── src └── HelloWorld.jl 1 directory, 2 files

इस मामले में, हम एक अच्छी तरह से डिज़ाइन किए गए प्रोजेक्ट के लिए फ़ाइलों का एक न्यूनतम लेकिन अपर्याप्त सेट देखते हैं। अधिक जानकारी के लिए https://julialang.imtqy.com/Pkg.jl/v1/creating-packages/ देखें ।

पैकेज बनाने का एक वैकल्पिक तरीका PkgTemplates.jl जनरेटर के साथ है। अंतर्निहित जनरेटर के विपरीत, यह आपको पैकेज की सर्विसिंग के लिए तुरंत सेवा फ़ाइलों का एक पूरा सेट उत्पन्न करने की अनुमति देता है। एकमात्र दोष यह है कि इसे स्वयं एक पैकेज के रूप में स्थापित किया जाना चाहिए।

इसकी सहायता से पैकेज बनाने की प्रक्रिया निम्नानुसार है। हम एक पैकेज कनेक्ट करते हैं:

 julia> using PkgTemplates

हम एक टेम्पलेट बनाते हैं जिसमें लेखकों की सूची, एक लाइसेंस, जूलिया की आवश्यकताएं, निरंतर एकीकरण प्रणालियों के लिए प्लगइन्स की सूची ( PkgTemplates लिए प्रलेखन से एक उदाहरण) शामिल हैं:

 julia> t = Template(; user="myusername", #   github license="ISC", #   authors=["Chris de Graaf", "Invenia Technical Computing Corporation"], dir="~/code", # ,    julia_version=v"1.0", #   Julia plugins=[ #     TravisCI(), Codecov(), Coveralls(), AppVeyor(), GitHubPages(), CirrusCI(), ], )

हम टेम्पलेट प्राप्त करते हैं:

 Template: → User: myusername → Host: github.com → License: ISC (Chris de Graaf, Invenia Technical Computing Corporation 2018) → Package directory: ~/code → Minimum Julia version: v0.7 → SSH remote: No → Commit Manifest.toml: No → Plugins: • AppVeyor: → Config file: Default → 0 gitignore entries • Codecov: → Config file: None → 3 gitignore entries: "*.jl.cov", "*.jl.*.cov", "*.jl.mem" • Coveralls: → Config file: None → 3 gitignore entries: "*.jl.cov", "*.jl.*.cov", "*.jl.mem" • GitHubPages: → 0 asset files → 2 gitignore entries: "/docs/build/", "/docs/site/" • TravisCI: → Config file: Default → 0 gitignore entries

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

 julia> generate(t, "MyPkg1")

न्यूनतम संस्करण में, टेम्पलेट इस तरह दिख सकता है:

 julia> t = Template(; user="rssdev10", authors=["rssdev10"]) Template: → User: rssdev10 → Host: github.com → License: MIT (rssdev10 2019) → Package directory: ~/.julia/dev → Minimum Julia version: v1.0 → SSH remote: No → Add packages to main environment: Yes → Commit Manifest.toml: No → Plugins: None

यदि हम इस टेम्पलेट से MyPkg2 नामक पैकेज बनाते हैं:

 julia> generate(t, "MyPkg2")

फिर हम जूलिया से सीधे परिणाम की जांच कर सकते हैं:

 julia> run(`git -C $(joinpath(t.dir, "MyPkg2")) ls-files`); .appveyor.yml .gitignore .travis.yml LICENSE Project.toml README.md REQUIRE docs/Manifest.toml docs/Project.toml docs/make.jl docs/src/index.md src/MyPkg2.jl test/runtests.jl

निम्नलिखित क्षेत्रों पर ध्यान दिया जाना चाहिए:

user="myusername" , git पंजीकरण प्रविष्टि का नाम है।
dir - पैकेज कोड प्लेसमेंट के लिए निर्देशिका। यदि निर्दिष्ट नहीं है, तो इसे विकास निर्देशिका ~/.julia/dev में बनाया जाएगा। इसके अलावा, यूनिक्स फाइल सिस्टम के नियमों के अनुसार, ~/.julia छिपी हुई है।

प्रोजेक्ट बनाने के बाद, फ़ाइलों का एक पर्याप्त सेट उत्पन्न होगा और एक गिट रिपॉजिटरी बनाई जाएगी। इसके अलावा, सभी जेनरेट की गई फाइलें इस रिपॉजिटरी में अपने आप जुड़ जाएंगी।

एक परियोजना में विशिष्ट फ़ाइल स्थान

हम https://en.wikibooks.org/wiki/Introducing_Julia/Modules_and_packages से फ़ाइलों और उनकी सामग्री की एक विशिष्ट व्यवस्था के साथ एक तस्वीर उधार लेंगे, लेकिन हम इसे थोड़ा विस्तारित करेंगे:

 Calculus.jl/ #    Calculus deps/ #       docs/ #       src/ #    Calculus.jl #    —   . module Calculus #        ! import Base.ctranspose #     , export derivative, check_gradient, #      ... include("derivative.jl") #     include("check_derivative.jl") include("integrate.jl") import .Derivative end #   Calculus.jl derivative.jl #     - , module Derivative #    Calculus.jl export derivative function derivative() ... end … end check_derivative.jl #     , function check_derivative(f::...)#     ... # "include("check_derivative.jl")"  Calculus.jl end … integrate.jl #     , function adaptive_simpsons_inner(f::Funct#      Calculus.jl ... end ... symbolic.jl #     Calculus.jl export processExpr, BasicVariable, ...#       import Base.show, ... #     Base , type BasicVariable <: AbstractVariable# ...       ... end function process(x::Expr) ... end ... test/ #     Calculus runtests.jl #     using Calculus #    Calculus... using Test #   Base.Test... tests = ["finite_difference", ... #  -   ... for t in tests include("$(t).jl") # ...     end ... finite_difference.jl #    -   @test ... # ...      runtests.jl ...

हम जोड़ते हैं कि deps डायरेक्टरी में पैकेज की सही असेंबली के लिए आवश्यक फाइलें हो सकती हैं। उदाहरण के लिए, deps/build.jl एक स्क्रिप्ट है जो पैकेज स्थापित होने पर स्वचालित रूप से चलती है। स्क्रिप्ट में डेटा तैयार करने के लिए कोई कोड हो सकता है (डेटा सेट डाउनलोड करना या प्रीप्रोसेसिंग करना) या काम के लिए आवश्यक अन्य प्रोग्राम।

यह ध्यान दिया जाना चाहिए कि एक परियोजना में केवल एक मुख्य मॉड्यूल हो सकता है। यह ऊपर दिए गए उदाहरण में है - Calculus । हालांकि, एक ही उदाहरण में, एक Derivative नेस्टेड मॉड्यूल है जो कि के माध्यम से जोड़ता है। इस पर ध्यान दें। इसमें फ़ाइल को पाठ के रूप include शामिल किया गया है, न कि एक मॉड्यूल के रूप में, जो using या import साथ होता है। पिछले दो कार्यों में न केवल मॉड्यूल शामिल हैं, बल्कि जूलिया को एक अलग इकाई के रूप में संकलित करने के लिए मजबूर करते हैं। इसके अलावा, जूलिया निर्भरता संकुल में इस मॉड्यूल को खोजने और एक चेतावनी जारी करने की कोशिश करेगा कि यह Project.toml में गायब है। इसलिए, यदि हमारा कार्य फ़ंक्शंस तक हाइरार्चिकल पहुंच बनाना है, तो उन्हें नामस्थानों से परिसीमन करना है, तो हम शामिल फ़ाइलों को include , और डॉट के माध्यम से मॉड्यूल को सक्रिय करते हैं, इसके स्थानीय जुड़ाव का संकेत देते हैं। वह है:

 module Calculus include("derivative.jl") import .Derivative ... end

derivative फ़ंक्शन जो Derivative मॉड्यूल से निर्यात किया जाता है, वह हमारे लिए उपलब्ध है।

Project.toml प्रोजेक्ट फ़ाइल

प्रोजेक्ट फाइल एक टेक्स्ट फाइल है। इसके मुख्य खंडों का वर्णन https://julialang.imtqy.com/Pkg.jl/v1/toml-files/ में किया गया है

फ़ाइल उत्पन्न होने के बाद, सभी आवश्यक फ़ील्ड पहले से ही इसमें मौजूद हैं। हालांकि, आपको विवरण का हिस्सा बदलने, पैकेज की संरचना, उनके संस्करण और विभिन्न ऑपरेटिंग सिस्टम या कॉन्फ़िगरेशन की विशिष्ट निर्भरता बदलने की आवश्यकता हो सकती है।

मुख्य क्षेत्र हैं:

 name = "Example" uuid = "7876af07-990d-54b4-ab0e-23690620f79a" version = "1.2.5"

name - नामकरण नियमों के अनुसार चुने गए पैकेज का नाम। uuid एक एकीकृत पहचानकर्ता है जो पैकेज जनरेटर या किसी अन्य uuid जनरेटर द्वारा उत्पन्न किया जा सकता है। version - तीन दशमलव संख्याओं के प्रारूप में पैकेज संस्करण संख्या, जो अवधि से अलग होती है। यह सिमेंटिक वर्जनिंग 2.0.0 के प्रारूप के अनुरूप है। घोषित संस्करण 1.0.0 से पहले, प्रोग्राम इंटरफ़ेस में कोई भी बदलाव संभव है। इस संस्करण के जारी होने के बाद, पैकेज के मालिक को संगतता नियमों का पालन करना चाहिए। किसी भी संगत परिवर्तन को मामूली संख्या (दाएं) में परिलक्षित किया जाना चाहिए। असंगत परिवर्तन उच्च संख्या में परिवर्तन के साथ होने चाहिए। स्वाभाविक रूप से, वर्जनिंग नियम पर कोई स्वचालित नियंत्रण नहीं है, लेकिन नियम का पालन न करने से केवल इस तथ्य को बढ़ावा मिलेगा कि पैकेज के उपयोगकर्ता बड़े पैमाने पर उपयोग करना बंद कर देंगे और उस पैकेज पर माइग्रेट करेंगे जिनके लेखक इस नियम का अनुपालन करते हैं।

सभी पैकेज निर्भरताएँ [deps] अनुभाग में प्रस्तुत की जाती हैं।

 [deps] Example = "7876af07-990d-54b4-ab0e-23690620f79a" Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"

इस खंड में हमारे पैकेज की प्रत्यक्ष निर्भरता की एक सूची है। कैस्केडिंग निर्भरताएं Manifest.toml फ़ाइल में परिलक्षित होती हैं, जो परियोजना निर्देशिका में स्वचालित रूप से उत्पन्न होती है। सभी निर्भरताएँ = जोड़े द्वारा दर्शाई जाती हैं। और, आमतौर पर, यह हिस्सा हाथों से नहीं भरा होता है। इसके लिए, Pkg पैकेज के कार्य प्रदान किए जाते हैं। और, सबसे अधिक बार, यह REPL से किया जाता है, इसे पैकेज प्रबंधन मोड में बदल दिया जाता है - ] । अगला - ऑपरेशन add , rm , st , आदि, लेकिन हमेशा वर्तमान पैकेज के संदर्भ में। यदि नहीं, तो आपको activate . से निष्पादित करने की आवश्यकता है activate . ।

Manifest.toml को git वर्जन कंट्रोल सिस्टम में सेव किया जा सकता है। दो फ़ाइलों के साथ यह दृष्टिकोण आपको सॉफ़्टवेयर उत्पाद के परीक्षण के दौरान निर्भरता के पेड़ में पैकेजों को सख्ती से ठीक करने की अनुमति देता है, जिसके बाद यह गारंटी दी जाती है कि यदि हमारे पैकेज को नए स्थान पर तैनात किया गया है, तो तृतीय-पक्ष पैकेजों के समान संस्करणों को उसी स्थान पर दोहराया जाएगा। या, इसके विपरीत, Manifest.toml की अनुपस्थिति में Manifest.toml किसी भी उपलब्ध संस्करण का उपयोग करने का अवसर दिया जाएगा जो मूल स्थितियों को पूरा करता है।

[compat] खंड आपको उन विशिष्ट संस्करणों को निर्दिष्ट करने की अनुमति देता है जिनकी हमें आवश्यकता होती है।

 [deps] Example = "7876af07-990d-54b4-ab0e-23690620f79a" [compat] Example = "1.2" julia = "1.1"

संकुल की पहचान उस नाम से की जाती है जिसका उपयोग पहले [compat] अनुभाग में किया गया था। julia के संस्करण को इंगित करता है।

संस्करण निर्दिष्ट करते समय, https://julialang.imtqy.com/Pkg.jl/dev/compatibility/ पर सूचीबद्ध नियम लागू होते हैं। हालाँकि, सिमेंटिक वर्जनिंग में समान नियम निर्दिष्ट हैं।

कई संस्करण नियम हैं। उदाहरण के लिए:

 [compat] Example = "1.2, 2"

इसका मतलब है कि रेंज में कोई भी संस्करण [1.2.0, 3.0.0) उपयुक्त है, न कि 3.0.0 । और यह पूरी तरह से एक सरल नियम के अनुरूप है:

 [compat] Example = "1.2"

इसके अलावा, बस संस्करण संख्या निर्दिष्ट करना "^1.2" का संक्षिप्त रूप है। आवेदन का एक उदाहरण जैसा दिखता है:

 [compat] PkgA = "^1.2.3" # [1.2.3, 2.0.0) PkgB = "^1.2" # [1.2.0, 2.0.0) PkgC = "^1" # [1.0.0, 2.0.0) PkgD = "^0.2.3" # [0.2.3, 0.3.0) PkgE = "^0.0.3" # [0.0.3, 0.0.4) PkgF = "^0.0" # [0.0.0, 0.1.0) PkgG = "^0" # [0.0.0, 1.0.0)

यदि हमें अधिक कड़े प्रतिबंधों को निर्दिष्ट करने की आवश्यकता है, तो एक टिल्ड के साथ एक फॉर्म का उपयोग करना आवश्यक है।

 [compat] PkgA = "~1.2.3" # [1.2.3, 1.3.0) PkgB = "~1.2" # [1.2.0, 1.3.0) PkgC = "~1" # [1.0.0, 2.0.0) PkgD = "~0.2.3" # [0.2.3, 0.3.0) PkgE = "~0.0.3" # [0.0.3, 0.0.4) PkgF = "~0.0" # [0.0.0, 0.1.0) PkgG = "~0" # [0.0.0, 1.0.0)

ठीक है, निश्चित रूप से, समान संकेतों / असमानताओं का संकेत उपलब्ध है:

 [compat] PkgA = ">= 1.2.3" # [1.2.3, ∞) PkgB = "≥ 1.2.3" # [1.2.3, ∞) PkgC = "= 1.2.3" # [1.2.3, 1.2.3] PkgD = "< 1.2.3" # [0.0.0, 1.2.2]

[targets] अनुभाग में निर्भरता के लिए कई विकल्पों को निर्दिष्ट करना संभव है। परंपरागत रूप से, संस्करण 1.2 से पहले जूलिया में, पैकेज का उपयोग करने और परीक्षण चलाने के लिए निर्भरता निर्दिष्ट करने के लिए इसका उपयोग किया गया था। ऐसा करने के लिए, अतिरिक्त संकुल को [extras] अनुभाग में निर्दिष्ट किया गया था, और संकुल नामों के साथ लक्ष्य विन्यास [targets] में सूचीबद्ध थे।

 [extras] Markdown = "d6f4376e-aef5-505a-96c1-9c027394607a" Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40" [targets] test = ["Markdown", "Test"]

जूलिया 1.2 के साथ शुरू, यह अनुशंसा की जाती है कि आप test/Project.toml लिए बस एक अलग परियोजना फ़ाइल जोड़ें।

अतिरिक्त निर्भरताएँ

अतिरिक्त निर्भरता deps/build.jl माध्यम से कनेक्ट किया जा सकता है, हालांकि, Artifacts.toml फ़ाइल जूलिया परियोजना संरचना में प्रदान की जाती है। Pkg.Artifacts परियोजना प्रबंधन Pkg.Artifacts अतिरिक्त निर्भरता के लोड को स्वचालित करने के लिए कार्य प्रदान करता है। ऐसी फ़ाइल का एक उदाहरण:

 # Example Artifacts.toml file [socrates] git-tree-sha1 = "43563e7631a7eafae1f9f8d9d332e3de44ad7239" lazy = true [[socrates.download]] url = "https://github.com/staticfloat/small_bin/raw/master/socrates.tar.gz" sha256 = "e65d2f13f2085f2c279830e863292312a72930fee5ba3c792b14c33ce5c5cc58" [[socrates.download]] url = "https://github.com/staticfloat/small_bin/raw/master/socrates.tar.bz2" sha256 = "13fc17b97be41763b02cbb80e9d048302cec3bd3d446c2ed6e8210bddcd3ac76" [[c_simple]] arch = "x86_64" git-tree-sha1 = "4bdf4556050cb55b67b211d4e78009aaec378cbc" libc = "musl" os = "linux" [[c_simple.download]] sha256 = "411d6befd49942826ea1e59041bddf7dbb72fb871bb03165bf4e164b13ab5130" url = "https://github.com/JuliaBinaryWrappers/c_simple_jll.jl/releases/download/c_simple+v1.2.3+0/c_simple.v1.2.3.x86_64-linux-musl.tar.gz" [[c_simple]] arch = "x86_64" git-tree-sha1 = "51264dbc770cd38aeb15f93536c29dc38c727e4c" os = "macos" [[c_simple.download]] sha256 = "6c17d9e1dc95ba86ec7462637824afe7a25b8509cc51453f0eb86eda03ed4dc3" url = "https://github.com/JuliaBinaryWrappers/c_simple_jll.jl/releases/download/c_simple+v1.2.3+0/c_simple.v1.2.3.x86_64-apple-darwin14.tar.gz" [processed_output] git-tree-sha1 = "1c223e66f1a8e0fae1f9fcb9d3f2e3ce48a82200"

हम अधिक विवरण में नहीं रहेंगे, क्योंकि आगे का विवरण विशिष्ट उपयोग के मामले पर निर्भर करता है। लाइब्रेरी में artifact_hash , download , create_artifact , bind_artifact । अधिक विवरण के लिए प्रलेखन https://julialang.imtqy.com/Pkg.jl/dev/artifacts/ देखें।

मुख्य कोड कार्यान्वयन और डिबगिंग

बेशक, हम पैकेज बनाते समय विकास निर्देशिका को स्पष्ट रूप से या अंतर्निहित रूप से निर्दिष्ट करते हैं। हालाँकि, यदि आवश्यक हो, तो हम इसे बदल सकते हैं। यदि पैकेज डिफ़ॉल्ट मापदंडों के साथ PkgTemplates द्वारा उत्पन्न किया गया था, तो इसे ~/.julia/dev । इस तथ्य के बावजूद कि निर्देशिका छिपी हुई है, इसके लिए संक्रमण फ़ाइल नेविगेटर में एक सीधा लिंक के माध्यम से संभव है। फाइंडर में MacOS के लिए, उदाहरण के लिए, यह कमांड + शिफ्ट + जी दबाकर किया जाता है। यदि पैकेज किसी अन्य निर्देशिका में बनाया गया है, तो बस इसे टेक्स्ट एडिटर में खोलें। जूलिया कोड के साथ काम करने के लिए सबसे अच्छा संपादक एटम है और यह सब uber-juno प्लगइन का समर्थन करता है। इस मामले में, आपको कोड के ऑटो-स्वरूपण के साथ एक पाठ संपादक मिलता है, इंटरैक्टिव कोड निष्पादन के लिए एक REPL कंसोल, केवल चयनित कोड टुकड़े निष्पादित करने और ग्राफिक्स को प्रदर्शित करने सहित परिणामों को देखने की क्षमता है। और भी, एक कदम दर कदम डिबगर। हालांकि, हमें यह स्वीकार करना चाहिए कि फिलहाल यह काफी धीमा है, इसलिए वर्तमान डिबगिंग मोड - पहले हम सोचते हैं कि हम डिबग आउटपुट को जांचना और रखना चाहते हैं, फिर हम परीक्षण के लिए परीक्षण चलाते हैं।

यह अनुशंसा की जाती है कि आप गतिशील प्रोग्रामिंग भाषाओं के लिए सामान्य डिज़ाइन पैटर्न देखें । इसके अलावा, पुस्तक "हैंड्स-ऑन डिज़ाइन पैटर्न जूलिया 1.0। टॉम क्वॉन्ग" और इसके लिए नमूना कोड । और कार्यक्रमों को लागू करते समय, आपको जूलिया स्टाइल गाइड प्रोग्रामिंग शैली पर सिफारिशों पर विचार करना चाहिए।

डिबगिंग की पेचीदगियों में से, Revise.jl पैकेज नोट किया जा सकता है। इसकी सक्रियण फ़ाइल .julia/config/startup.jl केवल इंटरेक्टिव मोड के लिए सेट की जा सकती है, जिसमें REPL को एटम संपादक से चलाया जा सकता है। रिवाइज़ आपको REPL सत्र को फिर से शुरू किए बिना हमारे पैकेज के अंदर फ़ंक्शन कोड को संपादित करने की अनुमति देता है, और हमारे परीक्षणों में उपयोग / आयात करने वाले प्रत्येक रन इन अपडेट को सक्षम करेंगे।

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

परीक्षण

एक विशिष्ट परीक्षण स्थान परीक्षण निर्देशिका है। फ़ाइल test/runtests.jl सभी परीक्षणों के लिए प्रारंभिक बिंदु है।

उपर्युक्त उदाहरण के संबंध में, फ़ाइल का विशिष्ट रूप है:

 using Calculus #    Calculus  ... using Test #   Test... tests = ["finite_difference", "..."]#      -... for t in tests include("$(t).jl") #        end

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

यूनिट परीक्षण के लिए, जूलिया बेस लाइब्रेरी सेट से Test मॉड्यूल प्रदान करता है। इस मॉड्यूल में @test मैक्रो को परिभाषित किया गया है, जिसका उद्देश्य निर्दिष्ट कथन की शुद्धता को सत्यापित करना है। उदाहरण:

 julia> @test true Test Passed julia> @test [1, 2] + [2, 1] == [3, 3] Test Passed julia> @test π ≈ 3.14 atol=0.01 Test Passed

लगभग तुलना ऑपरेटर के पूर्ण रूप पर ध्यान दें form।

अपवाद की पसंद की जाँच करने वाला बयान @test_throws । उदाहरण - एक सरणी बनाएं और इसके परे सूचकांक तक पहुंचें:

 julia> @test_throws BoundsError [1, 2, 3][4] Test Passed Thrown: BoundsError

एक उपयोगी निर्माण @testset । यह आपको तार्किक रूप से जुड़े परीक्षण में व्यक्तिगत बयानों को समूहित करने की अनुमति देता है। उदाहरण के लिए:

 julia> @testset "trigonometric identities" begin θ = 2/3*π @test sin(-θ) ≈ -sin(θ) @test cos(-θ) ≈ cos(θ) @test sin(2θ) ≈ 2*sin(θ)*cos(θ) @test cos(2θ) ≈ cos(θ)^2 - sin(θ)^2 end; Test Summary: | Pass Total trigonometric identities | 4 4

@testset माध्यम से घोषित प्रत्येक सेट के लिए, पास किए गए परीक्षणों की अपनी तालिका बनाई जाती है। टेस्ट सूट को नस्ट किया जा सकता है। उनके सफल पारित होने के मामले में, एक सारांश तालिका जारी की जाती है, विफलता के मामले में - परीक्षणों के प्रत्येक समूह के लिए अपने स्वयं के आंकड़े जारी किए जाएंगे।

 julia> @testset "Foo Tests" begin @testset "Animals" begin @testset "Felines" begin @test foo("cat") == 9 end @testset "Canines" begin @test foo("dog") == 9 end end @testset "Arrays" begin @test foo(zeros(2)) == 4 @test foo(fill(1.0, 4)) == 15 end end Arrays: Test Failed Expression: foo(fill(1.0, 4)) == 15 Evaluated: 16 == 15 [...] Test Summary: | Pass Fail Total Foo Tests | 3 1 4 Animals | 2 2 Arrays | 1 1 2 ERROR: Some tests did not pass: 3 passed, 1 failed, 0 errored, 0 broken.

@test_broken , @test_skip .

. julia :

  --code-coverage={none|user|all}, --code-coverage Count executions of source lines (omitting setting is equivalent to "user") --code-coverage=tracefile.info Append coverage information to the LCOV tracefile (filename supports format tokens). --track-allocation={none|user|all}, --track-allocation Count bytes allocated by each source line (omitting setting is equivalent to "user")

code-coverage — . ( ), . , . .cov . .
:

  - function vectorize(str::String) 96 tokens = str |> tokenizer |> wordpiece 48 text = ["[CLS]"; tokens; "[SEP]"] 48 token_indices = vocab(text) 48 segment_indices = [fill(1, length(tokens) + 2);] 48 sample = (tok = token_indices, segment = segment_indices) 48 bert_embedding = sample |> bert_model.embed 48 collect(sum(bert_embedding, dims=2)[:]) - end

track-allocation — . , , , , .mem .

  - function vectorize(str::String) 0 tokens = str |> tokenizer |> wordpiece 6766790 text = ["[CLS]"; tokens; "[SEP]"] 0 token_indices = vocab(text) 11392 segment_indices = [fill(1, length(tokens) + 2);] 1536 sample = (tok = token_indices, segment = segment_indices) 0 bert_embedding = sample |> bert_model.embed 170496 collect(sum(bert_embedding, dims=2)[:]) - end

, . , , , , . , . .

— :

 julia --project=@. --code-coverage --track-allocation test/runtests.jl

— Profile.jl @profile . https://julialang.org/blog/2019/09/profilers . @noinline , . , fib fib_r .

 julia> @noinline function fib(n) return n > 1 ? fib_r(n - 1) + fib_r(n - 2) : 1 end julia> @noinline fib_r(n) = fib(n) julia> @time fib(40) 0.738735 seconds (3.16 k allocations: 176.626 KiB) 165580141 julia> using Profile julia> @profile fib(40) 165580141 julia> Profile.print(format=:flat, sortedby=:count) Count File Line Function 12 int.jl 52 - 14 int.jl 53 + 212 boot.jl 330 eval 5717 REPL[2] 1 fib_r 6028 REPL[1] 2 fib julia> count(==(0), Profile.fetch()) 585

@profile fib(40) . Profile.print(format=:flat, sortedby=:count) . , , , fib_r fib , . , :

 julia> Profile.print(format=:tree) 260 REPL[1]:2; fib(::Int64) 112 REPL[1]:1; fib_r(::Int64) 212 task.jl:333; REPL.var"##26#27" 212 REPL.jl:118; macro expansion 212 REPL.jl:86; eval_user_input 212 boot.jl:330; eval ╎ 210 REPL[1]:2; fib ╎ 210 REPL[1]:1; fib_r ╎ 210 REPL[1]:2; fib ╎ 210 REPL[1]:1; fib_r ╎ 210 REPL[1]:2; fib ╎ ╎ 210 REPL[1]:1; fib_r ╎ ╎ 210 REPL[1]:2; fib ╎ ╎ 210 REPL[1]:1; fib_r ╎ ╎ 210 REPL[1]:2; fib ╎ ╎ 210 REPL[1]:1; fib_r ╎ ╎ ╎ 210 REPL[1]:2; fib ╎ ╎ ╎ 210 REPL[1]:1; fib_r ╎ ╎ ╎ 210 REPL[1]:2; fib ╎ ╎ ╎ 210 REPL[1]:1; fib_r ╎ ╎ ╎ 210 REPL[1]:2; fib ...

. PProf.jl, .

. https://github.com/vchuravy/PProf.jl .

doc . https://habr.com/ru/post/439442/
, , Julia .

Project.toml , . , , - , , .

, , . , — . :

. . . https://github.com/JuliaRegistries/General . https://github.com/JuliaRegistries/Registrator.jl
. . . https://julialang.imtqy.com/Pkg.jl/v1/registries/
git-. — , , Julia , .
, .

, , . , , git clone, . PackageCompiler.jl . , , - .

C

- , , ( - , ), deps, deps/build.jl . . , , , . , , , , . , , build.jl , :

 #!/usr/bin/env julia --project=@. using Pkg Pkg.activate(".") Pkg.build() # Pkg.build(; verbose = true) for Julia 1.1 and up Pkg.test() # (coverage=true)

. julia --project=@. Julia Project.toml . , — build.jl , executable . , julia --project=@. build.jl .

Pkg.activate(".") ( Project.toml ).

Pkg.build() , C-, . deps/build.jl , .

Pkg.test() . , -, , . -, , . coverage=true . , . build.jl .

, . , PkgTempletes . — Gitlab CI, Travis CI, GitHub , .

निष्कर्ष

, , Julia. , , . , — , -, , . , .

जूलिया। कहां से शुरू करें प्रोजेक्ट ...