Fungsi complex() Pada Python

38 views | by Admin

Python merupakan salah satu bahasa pemrograman yang cukup fleksibel dan serbaguna. Salah satu fiturnya yang kadang terlupakan namun sangat berguna adalah dukungan untuk bilangan kompleks (complex numbers). Dalam matematika, bilangan kompleks terdiri dari bagian real dan bagian imajiner, yang umumnya dituliskan dalam bentuk a + bj (di mana a adalah bagian real dan b adalah bagian imajiner). Python menyediakan tipe data bernama complex untuk mewakili bilangan kompleks, dan kita bisa membuat bilangan kompleks dengan fungsi complex().

Artikel ini akan membahas secara lengkap tentang fungsi complex() di Python, bagaimana cara kerjanya, mengapa kita membutuhkannya, serta contoh-contoh penggunaan pada berbagai konteks. Meskipun topik ini mungkin terdengar agak “matematis,” pendekatan kita di artikel ini akan bersifat semi-santai. Semoga setelah membaca, kamu akan lebih paham dan dapat mengaplikasikan tipe data bilangan kompleks di Python untuk berbagai kebutuhan, mulai dari perhitungan sederhana hingga kasus-kasus yang lebih rumit di dunia nyata.

Apa Itu Bilangan Kompleks?

Sebelum kita masuk ke detail fungsi complex() di Python, mari sedikit mengulas kembali apa itu bilangan kompleks. Bilangan kompleks adalah bilangan yang memiliki dua komponen: bagian real dan bagian imajiner. Secara umum dapat dituliskan:

z = a + bj

Dalam contoh di atas, a adalah komponen real (real part), sedangkan b adalah komponen imajiner (imaginary part). Huruf j sering kali digunakan oleh para insinyur untuk melambangkan akar dari -1, meskipun dalam konteks matematika, kita lebih sering melihat huruf i. Namun, di ranah teknik, j digunakan karena i sering dikhususkan untuk arus listrik (current). Python, secara default, menggunakan huruf j sebagai penanda bagian imajiner.

Secara matematis, j^2 = -1. Karena itu, bilangan kompleks dipahami sebagai perluasan dari bilangan real, yang memungkinkan kita menghitung hal-hal yang tidak bisa diwakili hanya dengan bilangan real saja. Dalam dunia pemrograman, khususnya Python, tipe data complex memudahkan kita untuk melakukan komputasi yang berkaitan dengan bilangan kompleks tanpa perlu repot mengurusi implementasi detail manual.

Membuat Bilangan Kompleks di Python

Python memberikan dua cara utama untuk membuat objek bilangan kompleks:

  1. Menggunakan fungsi complex(real, imag).
  2. Menggunakan literal, misalnya a + bj.

Namun, topik kita kali ini berfokus pada fungsi complex(). Mari kita lihat contoh sederhana: 

z1 = complex(3, 4)  # 3 + 4j
z2 = complex(2, -5) # 2 - 5j

print(z1)  # Output: (3+4j)
print(z2)  # Output: (2-5j)

Jika kita jalankan potongan kode di atas, kita akan mendapatkan output (3+4j) dan (2-5j). Python menampilkan bilangan kompleks dalam tanda kurung untuk menunjukkan bahwa tipe datanya adalah complex.

Selain itu, fungsi complex() juga memungkinkan kita membuat bilangan kompleks dari string, selama string tersebut merepresentasikan bilangan kompleks dengan benar. Contohnya: 

z3 = complex("7+9j")
z4 = complex("-2+3j")

print(z3)  # Output: (7+9j)
print(z4)  # Output: (-2+3j)

Dalam kasus ini, Python secara otomatis akan mem-parsing string yang kita berikan menjadi bilangan kompleks, asalkan format penulisan string tersebut valid, seperti "7+9j", "-2+3j", atau "4j". Namun, string semacam "5 + j" yang tidak mengikuti format penulisan yang tepat dapat menimbulkan error.

Struktur Fungsi complex()

Sintaks fungsinya cukup sederhana: 

complex([real[, imag]])

Artinya, argumen pertama adalah real, dan argumen kedua adalah imag. Jika kita hanya memberikan satu argumen, Python akan menafsirkannya sebagai bagian real, sedangkan bagian imajiner adalah 0 (nol). Jika kita memberikan argumen berupa string, kita cukup memberikan satu argumen saja.

Contoh: 

z = complex(5)
print(z)  # Output: (5+0j)

z_string = complex("4+2j")
print(z_string)  # Output: (4+2j)

Seperti terlihat, complex(5) memberi hasil (5+0j), karena kita tidak menentukan nilai untuk bagian imajiner.

Operasi Dasar pada Bilangan Kompleks

Layaknya bilangan integer atau float, kita juga dapat melakukan operasi dasar pada bilangan kompleks, seperti penjumlahan, pengurangan, perkalian, maupun pembagian. Python sudah menyediakan operator aritmatika yang relevan: 

z1 = complex(3, 4)
z2 = complex(1, 2)

# Penjumlahan
print(z1 + z2)  # (3+4j) + (1+2j) = (4+6j)

# Pengurangan
print(z1 - z2)  # (3+4j) - (1+2j) = (2+2j)

# Perkalian
print(z1 * z2)  # (3+4j)*(1+2j) = 3*1 + 3*2j + 4j*1 + 4j*2j = (3 + 6j + 4j + 8j^2)
                # Ingat j^2 = -1, jadi 8j^2 = 8*(-1) = -8
                # Total = (3 - 8) + (6+4)j = -5 + 10j

# Pembagian
print(z1 / z2)  # Pembagian bilangan kompleks dilakukan via formula khusus,
                # tapi Python mengurus semua secara otomatis

Contoh-contoh di atas menunjukkan bahwa kita dapat menggunakan operator aritmatika (+, -, *, /) langsung pada complex tanpa perlu menuliskan rumus manual.

Fungsi-Fungsi Pendukung

Untuk memanipulasi atau membaca nilai dari suatu complex, Python juga memberikan beberapa atribut dan fungsi pendukung. Misalnya:

Mari kita coba: 

z = complex(3, 4)
print(z.real)  # 3.0
print(z.imag)  # 4.0
print(abs(z))  # 5.0, karena sqrt(3^2 + 4^2) = 5

Atribut z.real dan z.imag akan menghasilkan tipe data float, meskipun kita memasukkan integer ke dalam fungsi complex(). Fungsi abs() untuk bilangan kompleks menghitung “jarak” bilangan tersebut dari titik (0,0) di bidang kompleks.

Aplikasi Bilangan Kompleks dalam Konteks Pemrograman

Setelah kita memahami bagaimana cara membuat dan memanipulasi complex di Python, mari kita bahas beberapa situasi di mana bilangan kompleks berguna, baik itu untuk kebutuhan akademik, penelitian, maupun industri.

  1. Pemrosesan Sinyal: Dalam domain sinyal dan sistem, terutama di bidang teknik elektro dan telekomunikasi, bilangan kompleks sering digunakan untuk merepresentasikan sinyal dalam domain frekuensi, seperti pada Transformasi Fourier. Dengan complex(), Python bisa membantu kita melakukan perhitungan Fourier, filter sinyal, dan sebagainya.
  2. Sistem Kendali: Dalam analisis sistem kendali (Control Systems), bilangan kompleks membantu untuk menghitung respons frekuensi suatu sistem, mencari root locus, dan lain-lain. Python, bersama paket seperti numpy dan scipy, sering dimanfaatkan untuk simulasi.
  3. Perhitungan Fisika: Bilangan kompleks banyak muncul di perhitungan fisika kuantum, terutama saat menghitung fungsi gelombang yang memiliki komponen riil dan imajiner.
  4. Fraktal: Salah satu penerapan paling menarik adalah dalam membuat fraktal seperti Mandelbrot Set, di mana tiap titik di peta ditentukan dari iterasi bilangan kompleks.

Mari kita lihat beberapa contoh penggunaan complex() di Python untuk kasus-kasus di atas.

Contoh Penggunaan: Menghitung Fraktal Mandelbrot

Fraktal Mandelbrot adalah himpunan titik di bidang kompleks yang memenuhi syarat tertentu berdasarkan iterasi fungsi z = z^2 + c. Kecantikan fraktal ini terletak pada pola tanpa batas yang muncul saat kita memvisualisasikannya. Berikut contoh kode sederhana (tidak sepenuhnya lengkap, tapi ilustratif) untuk menggambar fraktal Mandelbrot menggunakan Python: 

import matplotlib.pyplot as plt

def mandelbrot(h, w, max_iter=20):
    """
    Membuat array 2D berukuran (h, w) yang mewakili fraktal Mandelbrot.
    h: tinggi gambar
    w: lebar gambar
    max_iter: jumlah iterasi maksimal
    """
    # Tentukan range pada bidang kompleks
    re_start, re_end = -2.0, 1.0
    im_start, im_end = -1.0, 1.0
    
    # Buat array 2D untuk menyimpan hasil
    result = [[0]*w for _ in range(h)]
    
    for row in range(h):
        for col in range(w):
            # Hitung nilai real dan imajiner berdasarkan posisi pixel
            c_real = re_start + (col / w) * (re_end - re_start)
            c_imag = im_start + (row / h) * (im_end - im_start)
            c = complex(c_real, c_imag)
            
            z = complex(0, 0)
            iteration = 0
            
            while abs(z) <= 2 and iteration < max_iter:
                z = z*z + c
                iteration += 1
            
            result[row][col] = iteration
    return result

# Penggunaan fungsi di atas
h, w = 400, 400
mandelbrot_set = mandelbrot(h, w)

plt.imshow(mandelbrot_set, extent=[-2, 1, -1, 1], cmap='hot')
plt.title("Fraktal Mandelbrot Sederhana")
plt.colorbar()
plt.show()

Pada kode di atas, kita membuat suatu grid piksel berukuran 400x400. Untuk setiap piksel, kita tentukan koordinat di bidang kompleks, lalu kita terapkan iterasi untuk melihat apakah titik tersebut “berkembang” tak terbatas (berarti berada di luar himpunan) atau tetap terkendali (berada di dalam himpunan). Semua perhitungan bilangan kompleks diatur oleh Python, berkat tipe data complex. Fungsi complex(c_real, c_imag) adalah kunci yang memudahkan perhitungan ini.

Contoh Penggunaan: Pemrosesan Sinyal dengan Fourier Transform

Dalam pemrosesan sinyal digital, kita sering bertemu dengan Transformasi Fourier yang memetakan sinyal dari domain waktu ke domain frekuensi. Bilangan kompleks sangat esensial di sini karena setiap frekuensi sinyal biasanya direpresentasikan sebagai Amplitude * e^(j * Phase). Meskipun contoh di bawah tidak langsung menggunakan fungsi complex() secara eksplisit untuk perhitungan Fourier (karena kita biasanya mengandalkan numpy.fft), pemahaman tentang kompleks tetap penting. 

import numpy as np
import matplotlib.pyplot as plt

# Buat sinyal sederhana
t = np.linspace(0, 1, 1000, endpoint=False)
freq = 5  # 5 Hz
sinyal = np.sin(2 * np.pi * freq * t)

# Hitung Fourier Transform
ft = np.fft.fft(sinyal)

# Dapatkan frekuensi
freq_axis = np.fft.fftfreq(len(sinyal), d=(t[1]-t[0]))

# Plot domain waktu
plt.subplot(2, 1, 1)
plt.plot(t, sinyal)
plt.title("Sinyal di Domain Waktu")
plt.xlabel("Waktu")
plt.ylabel("Amplitudo")

# Plot domain frekuensi
plt.subplot(2, 1, 2)
plt.plot(freq_axis, np.abs(ft))
plt.title("Sinyal di Domain Frekuensi")
plt.xlabel("Frekuensi (Hz)")
plt.ylabel("Magnitudo")

plt.tight_layout()
plt.show()

Walau kita tidak memanggil complex() secara langsung, sebenarnya numpy bekerja dengan bilangan kompleks di balik layar. Hasil ft dari np.fft.fft() adalah array yang berisi bilangan kompleks, karena domain frekuensi mencakup informasi amplitudo dan fase.

Jika kita mau, kita juga bisa secara manual membuat sinyal dengan fungsi complex(). Misalnya, jika kita ingin membuat sinyal “kompleks” yang terdiri dari real part dan imaginary part berbeda, kita bisa menulis: 

# Membuat sinyal kompleks
sinyal_kompleks = [complex(np.sin(2*np.pi*freq*t[i]), np.cos(2*np.pi*freq*t[i])) 
                   for i in range(len(t))]

# Lalu kita bisa menghitung Fourier transform-nya
ft_kompleks = np.fft.fft(sinyal_kompleks)

print(ft_kompleks[:10])

Baris di atas hanya ilustrasi bahwa kita bisa membangun sinyal kompleks secara manual menggunakan complex().

Contoh Penggunaan: Simulasi Arus dan Tegangan Listrik

Di bidang teknik elektro, perhitungan arus (I) dan tegangan (V) dalam rangkaian AC (arus bolak-balik) sering menggunakan notasi fasor, yang merupakan representasi bilangan kompleks. Berikut contoh sederhana perhitungan impedansi rangkaian RL (Resistor-Induktor) menggunakan bilangan kompleks. 

import cmath  # cmath memiliki fungsi tambahan khusus untuk bilangan kompleks

R = 10  # Resistansi (ohm)
X_L = 20  # Reaktansi induktif (ohm)

Z = complex(R, X_L)  # Impedansi total = R + jX_L
print("Impedansi:", Z, "ohm")

# Untuk menghitung magnitudo dan sudut fase
magnitude = abs(Z)
phase = cmath.phase(Z)
print("Magnitudo:", magnitude, "ohm")
print("Sudut fase (radian):", phase)
print("Sudut fase (derajat):", phase * 180 / 3.14159)

Di sini, kita menggunakan complex(R, X_L) untuk membuat impedansi total. Lalu, kita memanfaatkan abs() dan cmath.phase() untuk mendapatkan magnitudo dan sudut fase. Dengan demikian, kita bisa menganalisis rangkaian AC dengan sangat mudah. Fitur built-in yang disediakan Python menjadikan perhitungan kompleks ini cukup efisien dan mudah dibaca.

Menangani Bilangan Kompleks dengan Paket Eksternal

Meskipun Python sudah menyediakan dukungan dasar untuk bilangan kompleks melalui complex(), ada kalanya kita membutuhkan fungsionalitas yang lebih kaya. Dua modul/paket yang sering digunakan adalah cmath (yang sudah disertakan di Python) dan numpy.

  1. cmath: Menyediakan fungsi-fungsi matematika kompleks seperti log, exp, sin, cos, dan sebagainya, yang semuanya bekerja dengan tipe data kompleks. Contoh: 
    import cmath

z = complex(1, 1)
print(cmath.sin(z))
print(cmath.exp(z))
  2. numpy: Library untuk komputasi numerik yang juga mendukung array bilangan kompleks. Ini bermanfaat kalau kita ingin melakukan operasi secara vektor atau matriks pada kumpulan bilangan kompleks. 
    import numpy as np

arr = np.array([complex(1, 2), complex(3, -1), complex(0, 4)])
print(arr)
print(arr * 2)  # Perkalian scalar

Dengan kedua modul tersebut, kita punya keleluasaan lebih besar untuk melakukan komputasi sains atau rekayasa yang melibatkan bilangan kompleks.

Penanganan Error dan Hal-Hal yang Perlu Diingat

Saat menggunakan complex(), pastikan format input string benar. Misalnya, complex("3+4j") valid, tapi complex("3 + 4j") dengan spasi tambahan bisa menimbulkan error. Selain itu, jika kita memasukkan nilai non-numerik, Python jelas akan melempar ValueError.

Berikut contoh bagaimana menangani error tersebut: 

try:
    z_invalid = complex("3 + 4j")  # Ada spasi yang tidak semestinya
except ValueError as e:
    print("Error:", e)

Python akan memberikan pesan bahwa string yang kita masukkan tidak dapat diubah menjadi bilangan kompleks, sehingga kita tahu harus mengecek formatnya.

Kapan Harus Menggunakan complex()?

Meskipun complex() terlihat sangat spesifik, sebenarnya ia penting untuk situasi di mana bilangan real saja tidak cukup. Jika kamu mengerjakan proyek yang membutuhkan perhitungan frekuensi, pemrosesan sinyal, simulasi rangkaian listrik, analisis kontrol, atau sekadar ingin bereksperimen dengan fraktal, maka complex() wajib ada dalam daftar alatmu.

Namun, jika proyekmu hanya melibatkan perhitungan aritmatika sederhana pada bilangan real, mungkin kamu tidak akan pernah menyentuh complex(). Hanya saja, mengetahui fitur ini ada akan sangat membantu ketika suatu hari kamu membutuhkannya.

Performa dan Kecepatan

Python memang bukan bahasa pemrograman paling cepat di muka bumi, terutama jika dibandingkan dengan C atau C++. Namun, untuk ukuran keperluan umum, perhitungan bilangan kompleks di Python sudah cukup efisien, apalagi jika kita memanfaatkan modul seperti numpy. Ketika kita menggunakan numpy array dengan tipe complex128, misalnya, komputasi bilangan kompleks dilakukan dalam format internal yang cukup teroptimasi.

Jika kamu memerlukan komputasi bilangan kompleks dengan skala sangat besar (misalnya, data berukuran gigabyte untuk pemrosesan sinyal), kamu mungkin perlu mempertimbangkan optimalisasi lebih lanjut atau bahasa pemrograman lain yang terkompilasi. Tetapi dalam banyak kasus penelitian, prototyping, dan analisis, Python sudah sangat memadai.

Ringkasan

Dukungan Python terhadap bilangan kompleks tidak sekadar “fitur tambahan”, tetapi merupakan bagian integral yang mempermudah banyak skenario komputasi sains dan rekayasa. Fungsi complex() adalah pintu gerbang untuk menciptakan bilangan kompleks secara eksplisit, baik dari real dan imaginary part, maupun dari string. Python kemudian menyediakan operator aritmatika, fungsi-fungsi matematika di cmath, dan kemampuan array kompleks di numpy.

Apakah kamu sedang mempelajari konsep bilangan kompleks untuk keperluan kuliah, meneliti resonansi pada sirkuit AC, memvisualisasikan fraktal, atau bahkan menganalisis respons frekuensi pada sistem kontrol, complex() di Python siap menyederhanakan pekerjaanmu. Kamu tidak perlu menulis fungsi penjumlahan dan perkalian bilangan kompleks secara manual; cukup manfaatkan tipe data complex dan operator bawaan Python.

Selain itu, dengan memahami cara kerja complex(), kamu juga lebih mudah mengerti bagaimana numpy mengelola array bilangan kompleks dan bagaimana modul cmath menyediakan fungsi-fungsi matematika yang relevan. Ini semua membuka peluang bagi kita untuk merancang aplikasi yang lebih kreatif, canggih, dan efisien.

Tips Terakhir

Itulah sedikit panduan dan pembahasan semi-santai kita tentang fungsi complex() di Python, lengkap dengan contoh penerapannya di berbagai bidang. Semoga pembahasan ini membantu memperluas wawasanmu dan memudahkanmu dalam menghadapi kasus-kasus perhitungan yang memerlukan bilangan kompleks di masa mendatang.


Baca Juga :