पायथन प्रोग्राम फॉर कॉम्प्लेक्स नंबर्स

एक पॉजिटिव नंबर के हमेशा दो रियल रूट्स होते हैं। उदाहरण के लिए, यदि x² = 25 है, तो x = ±5 है। हालांकि, यदि x² = -25 है तो रियल रूट्स मौजूद नहीं हैं। किसी भी नेगेटिव नंबर का वर्गमूल उसके एब्सोल्यूट वैल्यू के वर्गमूल को एक काल्पनिक यूनिट j = √-1 से गुणा करने के बराबर होता है।

अतः √-25 = √25 × √-1 = √25 × √-1 = 5j

एक कॉम्प्लेक्स नंबर में रियल और इमैजिनरी कंपोनेंट होते हैं। इसे x + yj के रूप में दर्शाया जाता है। x और y दोनों रियल नंबर हैं। Y को काल्पनिक यूनिट से गुणा करने पर कॉम्प्लेक्स नंबर का इमैजिनरी भाग बनता है।

उदाहरण: 3+2j, 10-5.5J, 9.55+2.3j, 5.11e-6+4j

पायथन में एक बिल्ट-इन कॉम्प्लेक्स डेटा टाइप है। एक कॉम्प्लेक्स नंबर ऑब्जेक्ट को लिटरल प्रतिनिधित्व द्वारा बनाया जा सकता है:

>>> x = 2+3j
>>> type(x)
<class 'complex'>

कॉम्प्लेक्स नंबर ऑब्जेक्ट के दो एट्रिब्यूट्स हैं real (रियल कंपोनेंट लौटाता है) और imag (इमैजिनरी कंपोनेंट लौटाता है जिसमें काल्पनिक यूनिट j शामिल नहीं है)

>>> x.real
2.0
>>> x.imag
3.0

इसमें conjugate() मेथड भी है। एक कॉम्प्लेक्स नंबर का कंजुगेट का वही रियल कंपोनेंट होता है और इमैजिनरी कंपोनेंट विपरीत चिह्न के साथ होता है। इसलिए 2+3j का कंजुगेट 2-3j है।

>>> x.conjugate()
(2-3j)

पायथन में बिल्ट-इन complex() फंक्शन भी है जो एक कॉम्प्लेक्स नंबर ऑब्जेक्ट लौटाता है। फंक्शन दो पैरामीटर्स लेता है, एक-एक रियल और इमैजिनरी कंपोनेंट के लिए। वे किसी भी न्यूमेरिक टाइप (int, float या complex) के हो सकते हैं।

>>> complex(9, 5)
(9+5j)
>>> complex(-6, -2.5)
(-6-2.5j)
>>> complex(1.5j, 2.5j)
(-2.5+1.5j)

यदि केवल एक पैरामीटर दिया जाता है तो इसे रियल कंपोनेंट माना जाता है, इमैजिनरी कंपोनेंट को शून्य माना जाता है।

>>> complex(15)
(15+0j)

फंक्शन एक स्ट्रिंग को आर्गुमेंट के रूप में भी ले सकता है बशर्ते उसमें न्यूमेरिक प्रतिनिधित्व हो।

>>> complex('51')
(51+0j)
>>> complex('1.5')
(1.5+0j)

कॉम्प्लेक्स नंबर्स का जोड़ और घटाव इंटीजर्स या फ्लोट्स के समान है। रियल और इमैजिनरी भाग अलग-अलग जोड़े/घटाए जाते हैं।

>>> a = 6+4j
>>> b = 3+6j
>>> a + b
(9+10j)
>>> a - b
(3-2j)

गुणा के लिए कॉम्प्लेक्स नंबर को एक बाइनोमियल मानें और पहले नंबर के प्रत्येक टर्म को दूसरे नंबर के प्रत्येक टर्म से गुणा करें।

a = 6+4j
b = 3+2j
c = a * b
c = (6+4j) * (3+2j)
c = (18 + 12j + 12j + 8 * -1)
c = 10 + 24j

पायथन कंसोल में परिणाम इसे सत्यापित करता है:

>>> a = 6+4j
>>> b = 3+2j
>>> a * b
(10+24j)

कॉम्प्लेक्स नंबर्स का भाग निम्नानुसार किया जाता है:

मान लीजिए दो नंबर हैं

a = 2+4j

b = 1-2j

और हम a/b की गणना करना चाहते हैं।

हर का कंजुगेट प्राप्त करें जो 1+2j है।

अंश और हर को हर के कंजुगेट से गुणा करें ताकि विभाजन का परिणाम प्राप्त हो सके।

c = a / b
c = (2+4j) * (1+2j) / (1-2j)(1+2j)
c = (2 + 4j + 4j + 8 * -1) / (1 + 2j - 2j - 4 * -1)
c = (-6 + 8j) / 5
c = -1.2 + 1.6j

निम्नलिखित पायथन कंसोल सेशन उपरोक्त उपचार को सत्यापित करता है।

>>> a = 2+4j
>>> b = 1-2j
>>> a / b
(-1.2+1.6j)

cmath मॉड्यूल

पायथन के स्टैंडर्ड लाइब्रेरी के मैथ मॉड्यूल में परिभाषित मैथमेटिकल फंक्शंस फ्लोटिंग पॉइंट नंबर्स को प्रोसेस करते हैं। कॉम्प्लेक्स नंबर्स के लिए, पायथन लाइब्रेरी में cmath मॉड्यूल है।

कॉम्प्लेक्स नंबर z = x + yj एक कार्टेशियन प्रतिनिधित्व है। इसे आंतरिक रूप से पोलर कोऑर्डिनेट्स में दर्शाया जाता है इसके मॉड्यूलस r (जैसा कि बिल्ट-इन abs() फंक्शन द्वारा लौटाया गया) और फेज एंगल Φ (फाई के रूप में उच्चारित) जो x-एक्सिस और x को मूल से जोड़ने वाली लाइन के बीच रेडियन्स में काउंटरक्लॉकवाइज एंगल है।

cmath मॉड्यूल में फंक्शंस कार्टेशियन प्रतिनिधित्व को पोलर प्रतिनिधित्व में और इसके विपरीत बदलने की अनुमति देते हैं।

polar()

यह फंक्शन कॉम्प्लेक्स नंबर के कार्टेशियन नोटेशन का पोलर प्रतिनिधित्व लौटाता है। रिटर्न वैल्यू एक टपल है जिसमें मॉड्यूलस और फेज होते हैं।

>>> import cmath
>>> a = 2+4j
>>> cmath.polar(a)
(4.47213595499958, 1.1071487177940904)

ध्यान दें कि मॉड्यूलस abs() फंक्शन द्वारा लौटाया जाता है:

>>> abs(a)
4.47213595499958

phase()

यह फंक्शन x-एक्सिस और a को मूल से जोड़ने वाले सेगमेंट के बीच काउंटरक्लॉकवाइज एंगल लौटाता है। एंगल रेडियन्स में दर्शाया गया है और π और -π के बीच है।

>>> cmath.phase(a)
1.1071487177940904

rect()

यह फंक्शन पोलर फॉर्म में दर्शाए गए कॉम्प्लेक्स नंबर का कार्टेशियन प्रतिनिधित्व लौटाता है यानी मॉड्यूलस और फेज में।

>>> cmath.rect(4.47213595499958, 1.1071487177940904)
(2.0000000000000004+4j)

cmath मॉड्यूल में मैथ मॉड्यूल में परिभाषित सभी मैथमेटिकल फंक्शंस के विकल्प हैं। इसमें ट्रिग्नोमेट्रिक और लॉगरिदमिक फंक्शंस हैं:

cmath.sin()

यह फंक्शन रेडियन्स में दर्शाए गए फेज एंगल के लिए साइन ट्रिग्नोमेट्रिक अनुपात लौटाता है।

>>> import cmath
>>> a = 2+4j
>>> p = cmath.phase(a)
>>> cmath.sin(p)
(0.8944271909999159+0j)

इसी तरह, अन्य अनुपातों cos(), tan(), asin(), acos() और atan() के लिए फंक्शंस cmath मॉड्यूल में परिभाषित हैं।

cmath.exp()

math.exp() के समान, यह फंक्शन eˣ लौटाता है जहां x एक कॉम्प्लेक्स नंबर है और e 2.71828 है।

>>> cmath.exp(a)
(-1.1312043837568135+2.4717266720048188j)

cmath.log10()

यह फंक्शन बेस 10 लेकर कॉम्प्लेक्स नंबर का लॉग वैल्यू कैलकुलेट करता है।

>>> a = 1+2j
>>> cmath.log10(a)
(0.3494850021680094+0.480828578784234j)

cmath.sqrt()

यह फंक्शन कॉम्प्लेक्स नंबर का वर्गमूल लौटाता है।

>>> cmath.sqrt(a)
(1.272019649514069+0.7861513777574233j)

इस आर्टिकल में हमने पायथन के कॉम्प्लेक्स नंबर डेटा टाइप की महत्वपूर्ण विशेषताओं और इस पर अंकगणितीय ऑपरेशन कैसे किए जा सकते हैं, यह सीखा। हमने cmath मॉड्यूल में परिभाषित विभिन्न फंक्शंस का भी पता लगाया।