पायथन, जटिल संख्याओं के साथ काम करने के लिए जटिल प्रकार (पूर्ण मान, गिरावट, ध्रुवीय परिवर्तन, आदि)

जटिल संख्याओं को संभालने के लिए पायथन का एक मानक प्रकार है, 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)

इसे “जटिल” प्रकार के एक निर्माता द्वारा भी उत्पन्न किया जा सकता है, जैसा कि “जटिल (वास्तविक भाग, काल्पनिक भाग)” में है।

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

दोनों ही मामलों में, कोण की इकाई जो प्राप्त की जा सकती है, रेडियन है। डिग्रियों में बदलने के लिए, गणित.डिग्री () का उपयोग करें।

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)