పైథాన్, సంక్లిష్ట సంఖ్యలతో పని చేయడానికి సంక్లిష్ట రకాలు (సంపూర్ణ విలువలు, క్షీణత, ధ్రువ పరివర్తనాలు మొదలైనవి)

సంక్లిష్ట సంఖ్యలను నిర్వహించడానికి పైథాన్ ప్రామాణిక రకాన్ని కలిగి ఉంది, కాంప్లెక్స్ రకం. మీరు సాధారణ గణనలను చేయాలనుకుంటే, మీరు ఏ మాడ్యూల్‌లను దిగుమతి చేయనవసరం లేదు, కానీ మీరు ప్రామాణిక లైబ్రరీ 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

రెండు సందర్భాల్లోనూ, రేడియన్‌లు పొందగలిగే కోణం యూనిట్. డిగ్రీలకు మార్చడానికి, 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)

నిజమైన మరియు ఊహాత్మక భాగాలు సంపూర్ణ విలువలు మరియు క్షీణత కోణాల నుండి cosine 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)