पायथन, जटिल संख्यांसह कार्य करण्यासाठी जटिल प्रकार (निरपेक्ष मूल्ये, घट, ध्रुवीय परिवर्तन इ.)

Python मध्ये जटिल संख्या हाताळण्यासाठी एक मानक प्रकार आहे, COMPLEX प्रकार. तुम्हाला फक्त साधी गणना करायची असल्यास, तुम्हाला कोणतेही मॉड्यूल आयात करण्याची आवश्यकता नाही, परंतु जर तुम्ही मानक लायब्ररी cmath आयात केले, तर तुम्ही जटिल संख्यांशी संबंधित गणितीय कार्ये (घातांक, लॉगरिदमिक, त्रिकोणमितीय इ.) देखील वापरू शकता.

• cmath — Mathematical functions for complex numbers — Python 3.10.4 Documentation

खालील सामग्री येथे नमुना कोडसह स्पष्ट केली आहे.

• जटिल व्हेरिएबल्स तयार करा
• वास्तविक आणि काल्पनिक भाग मिळवा:real,imagविशेषता
• संयुग्मित संमिश्र संख्या मिळवा:conjugate()पद्धत
• परिपूर्ण मूल्य मिळवा (विशालता):abs()कार्य (उदा. गणित, प्रोग्रामिंग, प्रोग्रामिंग)
• नकार प्राप्त करा (टप्पा):math,cmathमॉड्यूल
• ध्रुवीय समन्वय परिवर्तन (ध्रुवीय स्वरूपाचे प्रतिनिधित्व):math,cmathमॉड्यूल
• जटिल संख्यांची गणना (चतुष्कोण, शक्ती, वर्गमूळ)

जटिल व्हेरिएबल्स तयार करा

काल्पनिक एकक j ने दर्शवा आणि खालील लिहा, लक्षात घ्या की ते i नाही.

c = 3 + 4j

print(c)
print(type(c))
# (3+4j)
# <class 'complex'>

जर काल्पनिक भाग 1 असेल, तर तो वगळल्याने नाव त्रुटी येते. जर j नावाचे व्हेरिएबल प्रथम परिभाषित केले असेल तर ते व्हेरिएबल मानले जाते.

1j
हे अशा प्रकारे स्पष्टपणे सांगितले पाहिजे.

# c = 3 + j
# NameError: name 'j' is not defined

c = 3 + 1j

print(c)
# (3+1j)

वास्तविक भाग 0 असल्यास, तो वगळला जाऊ शकतो.

c = 3j

print(c)
# 3j

जर तुम्हाला 0 च्या काल्पनिक भागासह मूल्य एक जटिल जटिल प्रकार म्हणून परिभाषित करायचे असेल तर 0 स्पष्टपणे लिहा. खाली वर्णन केल्याप्रमाणे, ऑपरेशन जटिल प्रकार आणि पूर्णांक प्रकार किंवा फ्लोटिंग-पॉइंट प्रकार दरम्यान केले जाऊ शकते.

c = 3 + 0j

print(c)
# (3+0j)

वास्तविक आणि काल्पनिक भाग फ्लोटिंग-पॉइंट फ्लोट प्रकार म्हणून निर्दिष्ट केले जाऊ शकतात. घातांक नोटेशन देखील स्वीकार्य आहे.

c = 1.2e3 + 3j

print(c)
# (1200+3j)

हे “complex(वास्तविक भाग, काल्पनिक भाग)” प्रमाणे “complex” प्रकाराच्या कन्स्ट्रक्टरद्वारे देखील व्युत्पन्न केले जाऊ शकते.

c = complex(3, 4)

print(c)
print(type(c))
# (3+4j)
# <class 'complex'>

जटिल संख्यांचे वास्तविक आणि काल्पनिक भाग मिळवा:real,imagविशेषता

जटिल जटिल प्रकाराचे वास्तविक आणि काल्पनिक भाग अनुक्रमे वास्तविक आणि प्रतिमा गुणधर्मांसह मिळवता येतात. दोन्ही फ्लोटिंग-पॉइंट फ्लोट प्रकार आहेत.

c = 3 + 4j

print(c.real)
print(type(c.real))
# 3.0
# <class 'float'>

print(c.imag)
print(type(c.imag))
# 4.0
# <class 'float'>

ते फक्त वाचले जाते आणि बदलता येत नाही.

# c.real = 5.5
# AttributeError: readonly attribute

संयुग्मित संमिश्र संख्या मिळवा:conjugate()

संयुग्मित संमिश्र संख्या प्राप्त करण्यासाठी, संयुग्मित() पद्धत वापरा.

c = 3 + 4j

print(c.conjugate())
# (3-4j)

संमिश्र संख्येचे परिपूर्ण मूल्य (मोठेपणा) मिळवा:abs()

कॉम्प्लेक्स नंबरचे परिपूर्ण मूल्य (मॅग्निट्यूड) मिळविण्यासाठी, अंगभूत फंक्शन abs() वापरा.

c = 3 + 4j

print(abs(c))
# 5.0

c = 1 + 1j

print(abs(c))
# 1.4142135623730951

संमिश्र संख्येचे अवनती (फेज) मिळवा:math,cmathमॉड्यूल

कॉम्प्लेक्स नंबरचे डिक्लिनेशन (फेज) प्राप्त करण्यासाठी, गणित किंवा cmath मॉड्यूल वापरा.

cmath मॉड्यूल हे कॉम्प्लेक्स संख्यांसाठी गणितीय फंक्शन मॉड्यूल आहे.

• cmath — Mathematical functions for complex numbers — Python 3.10.4 Documentation

हे परिभाषित केल्याप्रमाणे व्यस्त स्पर्शिका फंक्शन math.atan2() सह मोजले जाऊ शकते किंवा cmath.phase() वापरा, जे घट (फेज) मिळवते.

import cmath
import math

c = 1 + 1j

print(math.atan2(c.imag, c.real))
# 0.7853981633974483

print(cmath.phase(c))
# 0.7853981633974483

print(cmath.phase(c) == math.atan2(c.imag, c.real))
# True

दोन्ही प्रकरणांमध्ये, मिळू शकणारे कोनाचे एकक रेडियन आहे. अंशांमध्ये रूपांतरित करण्यासाठी, math.degrees() वापरा.

print(math.degrees(cmath.phase(c)))
# 45.0

जटिल संख्यांचे ध्रुवीय समन्वय परिवर्तन (ध्रुवीय औपचारिक प्रतिनिधित्व):math,cmathमॉड्यूल

वर नमूद केल्याप्रमाणे, मिश्र संख्येचे निरपेक्ष मूल्य (विशालता) आणि अवनती (फेज) मिळवता येते, परंतु cmath.polar() वापरून ते (संपूर्ण मूल्य, अवनती) ट्युपल म्हणून मिळू शकतात.

c = 1 + 1j

print(cmath.polar(c))
print(type(cmath.polar(c)))
# (1.4142135623730951, 0.7853981633974483)
# <class 'tuple'>

print(cmath.polar(c)[0] == abs(c))
# True

print(cmath.polar(c)[1] == cmath.phase(c))
# True

ध्रुवीय निर्देशांकांपासून कार्टेशियन निर्देशांकांमध्ये रूपांतरण cmath.rect() वापरून केले जाते. cmath.rect(संपूर्ण मूल्य, विचलन) आणि तत्सम वितर्क समतुल्य जटिल जटिल जटिल प्रकाराची मूल्ये मिळविण्यासाठी वापरले जाऊ शकतात.

print(cmath.rect(1, 1))
# (0.5403023058681398+0.8414709848078965j)

print(cmath.rect(1, 0))
# (1+0j)

print(cmath.rect(cmath.polar(c)[0], cmath.polar(c)[1]))
# (1.0000000000000002+1j)

वास्तविक आणि काल्पनिक भाग कोसाइन math.cos() आणि sine math.sin() द्वारे परिपूर्ण मूल्ये आणि अवनती कोनातून काढलेल्या निकालांच्या समतुल्य आहेत.

r = 2
ph = math.pi

print(cmath.rect(r, ph).real == r * math.cos(ph))
# True

print(cmath.rect(r, ph).imag == r * math.sin(ph))
# True

जटिल संख्यांची गणना (चतुष्कोण, शक्ती, वर्गमूळ)

चार अंकगणित ऑपरेशन्स आणि पॉवर कॅल्क्युलेशन नेहमीच्या अंकगणित ऑपरेटर वापरून करता येतात.

c1 = 3 + 4j
c2 = 2 - 1j

print(c1 + c2)
# (5+3j)

print(c1 - c2)
# (1+5j)

print(c1 * c2)
# (10+5j)

print(c1 / c2)
# (0.4+2.2j)

print(c1 ** 3)
# (-117+44j)

स्क्वेअर रूटची गणना **0.5 ने केली जाऊ शकते, परंतु त्यात त्रुटी आढळते. cmath.sqrt() चा वापर अचूक मूल्य मोजण्यासाठी केला जाऊ शकतो.

print((-3 + 4j) ** 0.5)
# (1.0000000000000002+2j)

print((-1) ** 0.5)
# (6.123233995736766e-17+1j)

print(cmath.sqrt(-3 + 4j))
# (1+2j)

print(cmath.sqrt(-1))
# 1j

हे जटिल प्रकार, इंट प्रकार आणि फ्लोट प्रकारांसह अंकगणित ऑपरेशन देखील करू शकते.

print(c1 + 3)
# (6+4j)

print(c1 * 0.5)
# (1.5+2j)