मुद्रा विनिमय

Julia एक सामान्य प्रयोजन वाली भाषा है, जिसका इस्तेमाल ज़्यादातर प्रोग्रामिंग कामों के लिए किया जा सकता है। लेकिन व्यवहार में इसके मुख्य उपयोग ज़्यादातर इंजीनियरिंग और विज्ञान में ही होते हैं। तेज़, बहुमुखी और परिष्कृत संख्यात्मक गणनाएँ इसके डिज़ाइन के केंद्र में हैं।

पूर्णांक

पूर्णांक एक ऐसी "पूरी" संख्या होती है, जिसमें दशमलव बिंदु नहीं होता।

मूल बातें कॉन्सेप्ट में हमने देखा था कि किसी वेरिएबल को टाइप बताए बिना भी पूर्णांक वैल्यू असाइन की जा सकती है।

पढ़ने में आसानी के लिए अंडरस्कोर का इस्तेमाल अंकों को अलग करने के लिए किया जा सकता है। कंपाइलर इन्हें अनदेखा कर देता है।

julia> x = 3
3

julia> typeof(x)
Int64

julia> large_number = 1_234_567_890
1234567890

दशमलव संख्याएँ

यह कोई हैरानी की बात नहीं है कि दशमलव संख्याओं में एक दशमलव बिंदु होता है और बिंदु के बाद भिन्नात्मक भाग होता है।

julia> f = 3.45
3.45

julia> typeof(f)
Float64

स्वाभाविक है कि वैज्ञानिक संकेतन भी इस्तेमाल किया जा सकता है।

julia> avogadro = 6.02e23
6.02e23

सबसे बड़ी और सबसे छोटी वैल्यू शायद चौंका दें:

julia> typemax(Float64)
Inf

julia> typemin(Float64)
-Inf

अनंत भी एक मान्य वैल्यू है!

अंकगणितीय ऑपरेटर

जैसा कि मूल बातें कॉन्सेप्ट में बताया गया था, अंकगणितीय ऑपरेटर ज़्यादातर वैसे ही काम करते हैं जैसे बच्चों को सिखाया जाने वाला सामान्य अंकगणित करता है। ध्यान दीजिए कि घातांक के लिए ^ इस्तेमाल होता है, ** नहीं (दोनों ही दूसरी भाषाओं में आम हैं)।

2 + 3  # 5 (addition)
2 - 3  # -1 (subtraction)
2 * 3  # 6 (multiplication)
8 / 2  # 4.0 (division)
8 % 3  # 2 (remainder)
2 ^ 3  # 8 (exponentiation)

लेकिन Julia से जुड़ी कुछ खास बातें हैं जिन पर चर्चा करनी ज़रूरी है।

गुणा

julia> x = 4.2
4.2

julia> 2 * x
8.4

julia> 2x
8.4

julia> 2.4x
10.08

यह चौंकाने वाला लग सकता है।

बाकी ज़्यादातर कंप्यूटर भाषाओं की तरह * को इन्फिक्स ऑपरेटर की तरह इस्तेमाल करना हमेशा संभव होता है।

लेकिन Julia को उन लोगों ने बनाया है जो मानते हैं कि कोड जितना संभव हो गणितीय समीकरणों जैसा दिखना चाहिए।

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

उदाहरण के लिए, अगर हमें किसी गोले की सतह का क्षेत्रफल चाहिए, तो 4 * pi * r * r लिखने के बजाय हम यह कर सकते हैं:

julia> surface(r) = 4π * r^2
surface (generic function with 1 method)

julia> surface(3)
113.09733552923255

हालाँकि π एक पहले से मौजूद कॉन्स्टेंट है, यह एक (यूनानी) अक्षर भी है। इसलिए पार्सर को π को r से अलग करने के लिए एक स्पष्ट * की फिर भी ज़रूरत पड़ती है।

भाग

/ को इन्फिक्स ऑपरेटर की तरह इस्तेमाल करने पर हमेशा दशमलव परिणाम मिलेगा, चाहे इनपुट पूर्णांक ही क्यों न हों।

पूर्णांक भाग के लिए और भी विकल्प हैं।

julia> 10 / 3  # floating-point division
3.3333333333333335

julia> div(10, 3)  # integer division
3

julia> 10 ÷ 3  # synonym for div()
3

julia> 10 // 3  # rational number (fraction)
10//3

div() फंक्शन पूर्णांक भाग के लिए है, और इसका परिणाम शून्य की ओर काटा जाता है: धनात्मक संख्याओं के लिए नीचे की ओर, और ऋणात्मक संख्याओं के लिए ऊपर की ओर।

इसका पर्याय इन्फिक्स ऑपरेटर ÷ भी है, जिसका उद्देश्य फिर कोड को ज़्यादा गणितीय दिखाना है। अगर आप ऐसा एडिटर इस्तेमाल कर रहे हैं जो Julia को समझता है, तो इसे \div लिखकर <Tab> कुंजी दबाइए।

// ऑपरेटर इस कॉन्सेप्ट के दायरे से बाहर है। फिलहाल हम इतना कह सकते हैं कि // का परिणाम एक "परिमेय" संख्या होती है, जिसे ज़्यादातर लोग भिन्न कहते हैं।

संख्यात्मक टाइपों का रूपांतरण

यह अक्सर अपने आप हो जाता है:

julia> x = 2 + 3.5
5.5

julia> typeof(x)
Float64

हमने एक Int64 को एक Float64 में जोड़ा, और परिणाम Float64 मिला।

वास्तव में, जोड़ने से पहले पूर्णांक चुपचाप Float64 में बदल दिया गया था।

दशमलव से पूर्णांक में रूपांतरण अनिवार्य रूप से ज़्यादा जटिल होता है। दशमलव बिंदु के बाद आने वाले हिस्से का आप क्या करना चाहेंगे?

• round() फंक्शन संख्या को सबसे नज़दीकी पूर्ण संख्या में बदल देता है; और जहाँ दो संख्याएँ बराबर नज़दीक हों, जैसे 4.5, वहाँ यह सबसे नज़दीकी सम पूर्ण संख्या चुनता है।
• floor() नीचे की ओर, ceil() ऊपर की ओर, और trunc() शून्य की ओर राउंड करता है।
• सीधे कास्ट करने की कोशिश, उदाहरण के लिए Int32() से, InexactError के साथ विफल हो जाती है।

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

julia> round(4.5)
4.0

julia> ceil(Int, 4.3)
5

दशमलव बिंदु के बाद अंकों की तय संख्या तक राउंड करना भी digits कीवर्ड की मदद से संभव है।

julia> round(π, digits=10)
3.1415926536

शून्य से भाग

क्या इसमें सिर्फ एरर ही मिलती है? वास्तव में मामला इतना आसान नहीं है।

÷ या // से पूर्णांक भाग देने पर एरर आती है, जैसा आप सोचेंगे भी।

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

julia> 2 / 0
Inf

julia> 0 / 0
NaN

जैसा कि पिछले भाग में बताया गया था, Julia में अनंत एक मान्य दशमलव संख्या है, जिसे Inf से दर्शाया जाता है।

जब अंश भी शून्य हो, तो परिणाम गणितीय रूप से अपरिभाषित होता है। तब Julia इसे "संख्या नहीं" मानती है, जिसे NaN से दर्शाया जाता है।