🔀 🕘 🤘🏿 जूलिया: प्रकार, बहुपत्नी और बहुपद पर अंकगणित 🥚 👨🏻‍🏫 🛌

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

मूल वाक्य रचना

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

अंकगणित संचालन

अंकगणित हर जगह के बारे में एक ही है: +, -, *, /, ^ प्रतिपादक के लिए, आदि।
तुलना:>, <,> =, <=, ==; = = आदि।
असाइनमेंट: =
विशेषताएं: / माध्यम से विभाजन हमेशा एक भिन्नात्मक संख्या देता है; यदि आपको दो पूर्णांकों के विभाजन के पूर्णांक भाग की आवश्यकता है, तो आपको ऑपरेशन div(m, n) या infix समकक्ष m ÷ n । m ÷ n का उपयोग करने की आवश्यकता है।

प्रकार

संख्यात्मक प्रकार:

इंटेगर ( Int ) - 2 , 3 , -42
UInt पूर्णांक ( UInt ) - 0x12345
फ्लोटिंग पॉइंट ( Float32 , Float64 ) - 1.0 , 3.1415 , -Inf , -Inf
परिमेय ( Rational ) - 3//3 , 7//2
वास्तविक ( Real ) - उपरोक्त सभी
कॉम्प्लेक्स ( Complex ) - 3+4*im , 2//3+2//3*im , 3.0+0.0*im ( im एक काल्पनिक इकाई है, केवल एक संख्या जिसमें स्पष्ट रूप से लिखित काल्पनिक भाग जटिल माना जाता है)
Number - उपरोक्त सभी

तार और पात्र:

'a' - चरित्र ( Char )
"a" एक स्ट्रिंग है ( String )

नायब: तार, जैसा कि अब कई भाषाओं में अपरिवर्तनीय है।
नायब: तार (साथ ही चर नाम) इमोजी का समर्थन करते हैं, जिसमें इमोजी भी शामिल है।

सरणियों:

x = [1, 2, 3] - तत्वों की प्रत्यक्ष गणना द्वारा एक सरणी निर्दिष्ट करना
विशेष रचनाकार: zeros(length) एक सरणी के लिए zeros(length) , ones(length) एक सरणी के लिए rand(length) , यादृच्छिक संख्या की एक सरणी के लिए rand(length) , आदि।
बहुआयामी सरणी समर्थन
मानक पुस्तकालय में रैखिक बीजगणित संचालन (सरणियों, स्केलर गुणन, मैट्रिक्स वेक्टर गुणा, और बहुत कुछ) के लिए समर्थन

NB: सभी संग्रह एक से शुरू अनुक्रमित हैं।
NB: क्योंकि भाषा कम्प्यूटेशनल कार्यों के लिए अभिप्रेत है, सरणियाँ सबसे महत्वपूर्ण प्रकारों में से एक हैं, आपको एक से अधिक बार अपने काम के सिद्धांतों पर लौटना होगा।

टुपल्स (तत्वों का सेट, अपरिवर्तनीय):

(2, 5.3, "k") एक नियमित टपल है
(a = 3, b = 4) - टपल नाम

नायब: एक नामित टपल के क्षेत्रों को एक अवधि के माध्यम से और सूचकांक के माध्यम से नाम से पहुँचा जा सकता है।

 julia> x = (a = 5, b = 12) (a = 5, b = 12) julia> x[1] 5 julia> sqrt(xa^2 + x[2]^2) 13.0

शब्दकोशों:

 julia> x = Dict('a' => 5, 'b' => 12) Dict{Char,Int64} with 2 entries: 'a' => 5 'b' => 12 julia> x['c'] = 13 13 julia> x Dict{Char,Int64} with 3 entries: 'a' => 5 'c' => 13 'b' => 12

बुनियादी नियंत्रण भाषा का निर्माण

1. चर स्वचालित रूप से असाइनमेंट पर बनाए जाते हैं। प्रकार वैकल्पिक है।

 julia> x = 7; x + 2 9 julia> x = 42.0; x * 4 168.0

2. सशर्त कूद ब्लॉक की शुरुआत अभिव्यक्ति के साथ होती है if <condition> और end शब्द के साथ होता है। आपके पास एक else प्रकाश या else प्रकाश हो सकता है:

 if x > y println("X is more than Y") elseif x == y println("X and Y are equal") else println("X is less than Y") end

3. दो लूप निर्माण हैं: while और के for । दूसरा काम अजगर की तरह, यानी संग्रह से अधिक Iterates। एक सामान्य उपयोग उन मानों की श्रेणी से अधिक पुनरावृत्त हो रहा है जिनका सिंटैक्स start[:increment]:end । पायथन के विपरीत, एक सीमा में शुरू और अंत मूल्य दोनों शामिल हैं, अर्थात्। खाली सीमा 1:1 नहीं होगी (यह 1 की सीमा है), लेकिन 1:0 । लूप बॉडी के end को शब्द के end के साथ चिह्नित किया गया है।

 julia> for i in 1:3; print(i, " "); end #   1  3   1 ( ) 1 2 3 julia> for i in 1:2:3; print(i, " "); end #   1  3   2 1 3

4. फ़ंक्शंस कीवर्ड function द्वारा परिभाषित किए गए function , function की परिभाषा भी शब्द के end साथ समाप्त होती है। डिफ़ॉल्ट मान और नामित तर्क के साथ तर्क समर्थित हैं।

 function square(x) return x * x end function cube(x) x * square(x) #       ; return   end function root(x, degree = 2) #  degree     return x^(1.0/degree) end function greeting(name; times = 42, greet = "hello") #       println(times, " times ", greet, " to ", name) end julia> greeting("John") 42 times hello to John julia> greeting("Mike", greet = "wassup", times = 100500) #           100500 times wassup to Mike

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

टाइप एनोटेशन और मल्टीपल डिस्पैच

आइए देखें कि कुछ अंतर्निहित फ़ंक्शन क्या हैं:

 julia> sqrt sqrt (generic function with 19 methods)

जैसा कि REPL हमें दिखाता है, sqrt 19 विधियों के साथ एक सामान्य कार्य है। किस प्रकार का सामान्यीकृत कार्य और किस प्रकार के तरीके?

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

 julia> methods(sqrt)

यह देखा जा सकता है कि फ़ंक्शन को विभिन्न प्रकार की संख्याओं के साथ-साथ मैट्रिसेस के लिए परिभाषित किया गया है।

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

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

 julia> @time sqrt(8) #  @time -      0.006811 seconds (3.15 k allocations: 168.516 KiB) #   ,        2.8284271247461903 julia> @time sqrt(15) 0.000002 seconds (5 allocations: 176 bytes) # 5   -     @time 3.872983346207417

बुरे मामले में, प्रत्येक फ़ंक्शन कॉल प्राप्त तर्कों के प्रकार और सूची में वांछित विधि की खोज का एक चेक है। हालांकि, यदि आप संकलक को संकेत देते हैं, तो आप चेक को समाप्त कर सकते हैं, जिससे तेज कोड हो जाएगा।

उदाहरण के लिए, राशि की गणना पर विचार करें

s u m_{k = 1}^{N} s q r t (1)^{k}

$\ sum_ {k = 1} ^ N \ sqrt {(1) ^ k}$

 function mysqrt(num) #    -     #   -           if num >= 0 return sqrt(num) else return sqrt(complex(num)) end end function S(n) #    sum = 0 sgn = -1 for k = 1:n sum += mysqrt(sgn) sgn = -sgn end return sum end function S_typed(n::Integer) # ..     ,      #     sum::Complex = 0.0 sgn::Int = -1 for k = 1:n sum += mysqrt(sgn) sgn = -sgn end return sum end

बेंचमार्क दर्शाता है कि S_typed() फ़ंक्शन न केवल तेजी से चलता है, बल्कि S() विपरीत प्रत्येक कॉल के लिए मेमोरी आवंटन की आवश्यकता नहीं है। यहाँ समस्या यह है कि mysqrt() से mysqrt() गए mysqrt() का प्रकार अभिव्यक्ति के दाईं ओर के प्रकार की तरह परिभाषित नहीं है

 sum = sum + mysqrt(sgn)

परिणामस्वरूप, कंपाइलर यह भी पता नहीं लगा सकता है कि प्रत्येक पुनरावृत्ति में किस प्रकार का sum होगा। तो, बॉक्सिंग (टाइप लेबल हुकिंग) एक चर है और मेमोरी आवंटित की जाती है।
S_typed() फ़ंक्शन के लिए, कंपाइलर पहले से जानता है कि sum एक जटिल मूल्य है, इसलिए कोड अधिक अनुकूलित है (विशेष रूप से, mysqrt() कॉल mysqrt() प्रभावी रूप से इनलाइन हो सकता है, हमेशा Complex में रिटर्न वैल्यू लौटाता है)।

अधिक महत्वपूर्ण बात, S_typed() कंपाइलर जानता है कि रिटर्न वैल्यू टाइप Complex , लेकिन S() के लिए आउटपुट वैल्यू S() प्रकार को फिर से परिभाषित नहीं किया गया है, जो उन सभी कार्यों को धीमा कर देगा जहां S() कहा जाएगा।
आप सत्यापित कर सकते हैं कि संकलक @code_warntype मैक्रो का उपयोग करके अभिव्यक्ति से लौटे प्रकारों के बारे में सोचता है:

 julia> @code_warntype S(3) Body::Any #     ,      ... julia> @code_warntype S_typed(3) Body::Complex{Float64} #      ...

यदि किसी फ़ंक्शन को लूप में कहीं कहा जाता है, जिसके लिए @code_warntype रिटर्न प्रकार को आउटपुट नहीं कर सकता है, या जिसके लिए यह शरीर में कहीं Any प्रकार के मूल्य की रसीद दिखाता है, तो इन कॉलों का अनुकूलन सबसे अधिक ध्यान देने योग्य वृद्धि को बढ़ाएगा।

यौगिक प्रकार

एक प्रोग्रामर struct निर्माण का उपयोग करके अपनी आवश्यकताओं के लिए समग्र डेटा प्रकारों को परिभाषित कर सकता है:

 julia> struct GenericStruct #   struct    name b::Int c::Char v::Vector end #       #       ,        julia> s = GenericStruct("Name", 1, 'z', [3., 0]) GenericStruct("Name", 1, 'z', [3.0, 0.0]) julia> s.name, sb, sc, sv ("Name", 1, 'z', [3.0, 0.0])

जूलिया में संरचनाएं अपरिवर्तनीय हैं, अर्थात्, संरचना का एक उदाहरण बनाकर, क्षेत्र मानों को बदलना अब संभव नहीं है (अधिक सटीक रूप से, आप स्मृति में फ़ील्ड के पते को बदल नहीं सकते हैं - उत्परिवर्तित फ़ील्ड के तत्व, जैसे कि ऊपर दिए गए उदाहरण में " sv बदल सकते हैं")। mutable struct संरचनाओं को mutable struct निर्माण द्वारा बनाया जाता है, जिसका वाक्य विन्यास नियमित संरचनाओं के लिए समान है।

"शास्त्रीय" अर्थों में संरचनाओं की विरासत का समर्थन नहीं किया जाता है, हालांकि मिश्रित प्रकारों को सुपरपेप्स में मिलाकर "विरासत" व्यवहार की संभावना है या, जैसा कि उन्हें जूलिया में कहा जाता है, सार प्रकार। टाइप रिश्तों को A<:B रूप में व्यक्त किया जाता है (ए A<:B का एक उपप्रकार है) और A>:B (ए A>:B का एक उपप्रकार है)। यह कुछ इस तरह दिखता है:

 abstract type NDimPoint end #   -     # ,    -     N  struct PointScalar<:NDimPoint x1::Real end struct Point2D<:NDimPoint x1::Real x2::Real end struct Point3D<:NDimPoint x1::Real x2::Real x3::Real end #     ;   Markdown """ mag(p::NDimPoint) Calculate the magnitude of the radius vector of an N-dimensional point `p` """ function mag(p::NDimPoint) sqrmag = 0.0 # ..   ,       #     T   fieldnames(T) for name in fieldnames(typeof(p)) sqrmag += getfield(p, name)^2 end return sqrt(sqrmag) end """ add(p1::T, p2::T) where T<:NDimPoint Calculate the sum of the radius vectors of two N-dimensional points `p1` and `p2` """ function add(p1::T, p2::T) where T<:NDimPoint #  -  , ..       #     list comprehension sumvector = [Float64(getfield(p1, name) + getfield(p1, name)) for name in fieldnames(T)] #     ,    #  ...      , .. # f([1, 2, 3]...) -   ,  f(1, 2, 3) return T(sumvector...) end

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

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

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

 abstract type AbstractPolynomial end """ Polynomial <: AbstractPolynomial Polynomials written in the canonical form """ struct Polynomial<:AbstractPolynomial degree::Int coeff::NTuple{N, Float64} where N # NTuple{N, Type} -    N    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

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

P (x) = s u m_{k = 0}^{N} c_{k} n_{k} (x),

$P (x) = \ sum_ {k = 0} ^ N {c_k n_k (x)},$

जहाँ n _k ( x ) मूल बहुपद हैं, n ₀ ( x ) और k > 0 के लिए

n_{k} (x) = p r o d_{i = 0}^{k - 1} (x - x_{i}),

$n_k (x) = \ prod_ {i = 0} ^ {k-1} {(x-x_i)},$

जहाँ x _मैं प्रक्षेप नोड्स हैं

उपरोक्त सूत्रों से यह देखा जा सकता है कि भंडारण आसानी से प्रक्षेप नोड्स x _i और गुणांक c _{i के} सेट के रूप में आयोजित किया जाता है, और गणना हॉर्नर की योजना के समान तरीके से की जा सकती है।

 """ InterpPolynomial <: AbstractPolynomial Interpolation polynomials in Newton's form """ struct InterpPolynomial<:AbstractPolynomial degree::Int xval::NTuple{N, Float64} where N coeff::NTuple{N, Float64} where N end """ evpoly(p::Polynomial, z::Real) Evaluate polynomial `p` at `z` using the Horner's rule """ function evpoly(p::InterpPolynomial, z::Real) ans = p.coeff[p.degree+1] for idx = p.degree:-1:1 ans = ans * (z - p.xval[idx]) + p.coeff[idx] end return ans end

दोनों मामलों में बहुपद के मूल्य की गणना करने के कार्य को एक ही कहा जाता है - evpoly() - लेकिन विभिन्न प्रकार के तर्कों को स्वीकार करता है।

गणना फ़ंक्शन के अलावा, एक फ़ंक्शन लिखना अच्छा होगा जो ज्ञात डेटा से एक बहुपद बनाता है।

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

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

एक आंतरिक कंस्ट्रक्टर लिखना जिसमें इन नियमों की गारंटी दी जाती है, यह सुनिश्चित करता है कि InterpPolynomial प्रकार के सभी बनाए गए चर, कम से कम, सही ढंग से evpoly() फ़ंक्शन द्वारा संसाधित किए जा सकते हैं।

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

 """ Polynomial <: AbstractPolynomial Polynomials written in the canonical form --- Polynomial(v::T) where T<:Union{Vector{<:Real}, NTuple{<:Any, <:Real}}) Construct a `Polynomial` from the list of the coefficients. The coefficients are assumed to go from power 0 in the ascending order. If an empty collection is provided, the constructor returns a zero polynomial. """ struct Polynomial<:AbstractPolynomial 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 """ InterpPolynomial <: AbstractPolynomial Interpolation polynomials in Newton's form --- InterpPolynomial(xsample::Vector{<:Real}, fsample::Vector{<:Real}) Construct an `InterpPolynomial` from a vector of points `xsample` and corresponding function values `fsample`. All values in `xsample` must be distinct. """ struct InterpPolynomial<:AbstractPolynomial degree::Int xval::NTuple{N, Float64} where N coeff::NTuple{N, Float64} where N function InterpPolynomial(xsample::X, fsample::F) where {X<:Union{Vector{<:Real}, NTuple{<:Any, <:Real}}, F<:Union{Vector{<:Real}, NTuple{<:Any, <:Real}}} #   ,    ,   f  ,   if !allunique(xsample) throw(DomainError("Cannot interpolate with duplicate X points")) end N = length(xsample) if length(fsample) != N throw(DomainError("Lengths of X and F are not the same")) end coeff = [Float64(f) for f in fsample] #     (Stoer, Bulirsch, Introduction to Numerical Analysis, . 2.1.3) for i = 2:N for j = 1:(i-1) coeff[i] = (coeff[j] - coeff[i]) / (xsample[j] - xsample[i]) end end new(N-1, tuple([Float64(x) for x in xsample]...), tuple(coeff...)) end end

बहुपद की वास्तविक पीढ़ी के अलावा, उनके साथ अंकगणितीय संचालन करने में सक्षम होना अच्छा होगा।

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

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

इसलिए, हम एक संख्या के साथ एक बहुपद का जोड़ जोड़ते हैं:

 # -   Base.+  , #    Base.:+,   " :+   Base" function Base.:+(p::Polynomial, x::Real) Polynomial(tuple(p.coeff[1] + x, p.coeff[2:end]...)) end function Base.:+(p::InterpPolynomial, x::Real) # ..           - #          . #       - #        fval::Vector{Float64} = [evpoly(p, xval) + x for xval in p.xval] InterpPolynomial(p.xval, fval) end #       function Base.:+(x::Real, p::AbstractPolynomial) return p + x end

दो साधारण बहुपद जोड़ने के लिए, यह गुणांक जोड़ने के लिए पर्याप्त है, और जब दूसरे में प्रक्षेप बहुपद जोड़ते हैं, तो आप कई बिंदुओं पर योग मान पा सकते हैं और उनसे एक नया प्रक्षेप बना सकते हैं।

 function Base.:+(p1::Polynomial, p2::Polynomial) #    ,      deg = max(p1.degree, p2.degree) coeff = zeros(deg+1) coeff[1:p1.degree+1] .+= p1.coeff coeff[1:p2.degree+1] .+= p2.coeff Polynomial(coeff) end function Base.:+(p1::InterpPolynomial, p2::InterpPolynomial) xmax = max(p1.xval..., p2.xval...) xmin = min(p1.xval..., p2.xval...) deg = max(p1.degree, p2.degree) #         #       xmid = 0.5 * xmax + 0.5 * xmin dx = 0.5 * (xmax - xmin) / cos(0.5 * π / (deg + 1)) chebgrid = [xmid + dx * cos((k - 0.5) * π / (deg + 1)) for k = 1:deg+1] fsample = [evpoly(p1, x) + evpoly(p2, x) for x in chebgrid] InterpPolynomial(chebgrid, fsample) end function Base.:+(p1::InterpPolynomial, p2::Polynomial) xmax = max(p1.xval...) xmin = min(p1.xval...) deg = max(p1.degree, p2.degree) xmid = 0.5 * xmax + 0.5 * xmin dx = 0.5 * (xmax - xmin) / cos(0.5 * π / (deg + 1)) chebgrid = [xmid + dx * cos((k - 0.5) * π / (deg + 1)) for k = 1:deg+1] fsample = [evpoly(p1, x) + evpoly(p2, x) for x in chebgrid] InterpPolynomial(chebgrid, fsample) end function Base.:+(p1::Polynomial, p2::InterpPolynomial) p2 + p1 end

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

अभी के लिए बस इतना ही। मैं अन्य संख्यात्मक तरीकों के कार्यान्वयन के बारे में आगे लिखने की कोशिश करूंगा।

तैयारी में, निम्नलिखित सामग्रियों का उपयोग किया गया था:

जूलिया भाषा प्रलेखन: docs.julialang.org
जूलिया भाषा चर्चा मंच: प्रवचन। Julialang.org
जे। स्टोएर, डब्ल्यू। बुलिरस्च। संख्यात्मक विश्लेषण का परिचय
जूलिया हब: habr.com/en/hub/julia
जूलिया सोचें: benlauwens.imtqy.com/ThinkJulia.jl/latest/.html

जूलिया: प्रकार, बहुपत्नी और बहुपद पर अंकगणित