પાયથોન, જટિલ સંખ્યાઓ સાથે કામ કરવા માટેના જટિલ પ્રકારો (સંપૂર્ણ મૂલ્યો, ક્ષીણતા, ધ્રુવીય પરિવર્તન, વગેરે)

જટિલ સંખ્યાઓને હેન્ડલ કરવા માટે 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 હોય, તો તેને અવગણવાથી NameError આવે છે. જો 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)

વાસ્તવિક અને કાલ્પનિક ભાગો કોસાઇન 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)