Julia Language
अंकगणित

वाक्य - विन्यास

• + x
• -एक्स
• ए + बी
• ए - बी
• ए * बी
• ए / बी
• ए ^ बी
• अ% ख
• 4a
• sqrt (क)

द्विघात सूत्र

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

उदाहरण के लिए, नीचे दिया गया कोड द्विघात सूत्र को लागू करता है , जो क्रमशः + , - , * , और / इसके अलावा, घटाव, गुणन और विभाजन के लिए ऑपरेटरों को प्रदर्शित करता है। यह भी दिखाया गया है कि निहित गुणा , जहां एक संख्या को सीधे प्रतीक से पहले गुणा करने के लिए रखा जा सकता है; अर्थात 4a अर्थ 4*a के समान 4*a ।

function solvequadratic(a, b, c)
    d = sqrt(b^2 - 4a*c)
    (-b - d) / 2a, (-b + d) / 2a
end

उपयोग:

julia> solvequadratic(1, -2, -3)
(-1.0,3.0)

एराटोस्थनीज की छलनी

जूलिया में शेष ऑपरेटर % ऑपरेटर है। यह ऑपरेटर C और C ++ जैसी भाषाओं में % समान व्यवहार करता है। a % b पर हस्ताक्षर किए शेष विभाजित के बाद बचे है a से b ।

यह ऑपरेटर कुछ एल्गोरिदम को लागू करने के लिए बहुत उपयोगी है, जैसे कि चलनी ऑफ एराटोस्थनीज का निम्नलिखित कार्यान्वयन।

iscoprime(P, i) = !any(x -> i % x == 0, P)

function sieve(n)
    P = Int[]
    for i in 2:n
        if iscoprime(P, i)
            push!(P, i)
        end
    end
    P
end

उपयोग:

julia> sieve(20)
8-element Array{Int64,1}:
  2
  3
  5
  7
 11
 13
 17
 19

मैट्रिक्स अंकगणित

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

रकम

मैट्रिक्स पर + ऑपरेटर एक मैट्रिक्स योग है। यह एक तत्व योग के समान है, लेकिन यह आकार को प्रसारित नहीं करता है। यही कारण है, अगर है A और B एक ही आकार है, तो A + B रूप में ही है A .+ B ; अन्यथा, A + B एक त्रुटि है, जबकि A .+ B आवश्यक नहीं हो सकता है।

julia> A = [1 2
            3 4]
2×2 Array{Int64,2}:
 1  2
 3  4

julia> B = [5 6
            7 8]
2×2 Array{Int64,2}:
 5  6
 7  8

julia> A + B
2×2 Array{Int64,2}:
  6   8
 10  12

julia> A .+ B
2×2 Array{Int64,2}:
  6   8
 10  12

julia> C = [9, 10]
2-element Array{Int64,1}:
  9
 10

julia> A + C
ERROR: DimensionMismatch("dimensions must match")
 in promote_shape(::Tuple{Base.OneTo{Int64},Base.OneTo{Int64}}, ::Tuple{Base.OneTo{Int64}}) at ./operators.jl:396
 in promote_shape(::Array{Int64,2}, ::Array{Int64,1}) at ./operators.jl:382
 in _elementwise(::Base.#+, ::Array{Int64,2}, ::Array{Int64,1}, ::Type{Int64}) at ./arraymath.jl:61
 in +(::Array{Int64,2}, ::Array{Int64,1}) at ./arraymath.jl:53

julia> A .+ C
2×2 Array{Int64,2}:
 10  11
 13  14

इसी तरह, - एक मैट्रिक्स अंतर की गणना करता है। + और - दोनों का उपयोग एकात्मक ऑपरेटर के रूप में भी किया जा सकता है।

उत्पाद

मैट्रिक्स पर * ऑपरेटर मैट्रिक्स उत्पाद है (एलिमेंट वाइज उत्पाद नहीं)। एक तत्वपूर्ण उत्पाद के लिए .* ऑपरेटर का उपयोग करें। तुलना करें (ऊपर के समान मैट्रिस का उपयोग करके):

julia> A * B
2×2 Array{Int64,2}:
 19  22
 43  50

julia> A .* B
2×2 Array{Int64,2}:
  5  12
 21  32

पॉवर्स

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

fib(n) = (BigInt[1 1; 1 0]^n)[2]

हमेशा की तरह, .^ ऑपरेटर का उपयोग किया जा सकता है जहां एलीमेंटवाइज़ एक्सपेंशनशिप वांछित ऑपरेशन है।