Pendahuluan

Belajar komputasi ilmiah bukan sekadar belajar menulis program. Tujuan utamanya adalah belajar mengubah pertanyaan ilmiah menjadi perhitungan yang dapat diperiksa.

Misalnya, seorang mahasiswa bertanya:

“Berapa cepat suhu kopi turun di dalam ruangan?”

Pertanyaan ini tampak sederhana. Namun untuk menjawabnya secara ilmiah, kita perlu melakukan beberapa langkah. Kita harus menentukan besaran fisis yang diamati, misalnya suhu kopi dan waktu. Kita harus memilih model matematis, misalnya hukum pendinginan Newton. Kita harus menentukan parameter, misalnya laju pendinginan. Kita harus menghitung prediksi model, membandingkannya dengan data, menggambar grafik, lalu menilai apakah hasilnya masuk akal.

Di sinilah Python menjadi alat yang sangat berguna. Python memungkinkan kita menulis perhitungan numerik, mengolah data, membuat visualisasi, melakukan pencocokan kurva, dan menyusun simulasi dalam satu lingkungan kerja yang relatif mudah dibaca. Ekosistem ilmiah Python modern dibangun oleh pustaka seperti NumPy untuk komputasi larik, SciPy untuk algoritma ilmiah, dan Matplotlib untuk visualisasi data; pustaka-pustaka ini telah menjadi bagian penting dari praktik komputasi ilmiah berbasis Python (Harris et al., 2020; Virtanen et al., 2020; Hunter, 2007).

Namun alat yang kuat juga mudah disalahgunakan. Grafik yang rapi belum tentu menunjukkan kesimpulan yang benar. Angka dengan banyak digit belum tentu akurat. Program yang berhasil berjalan belum tentu menerapkan model yang tepat. Buku ini ditulis untuk membantu Anda bergerak lebih hati-hati: dari persoalan sains, menuju model matematis, menuju program Python, lalu kembali lagi ke penafsiran ilmiah.

Apa yang dimaksud dengan komputasi ilmiah?

Komputasi ilmiah adalah penggunaan metode komputasi untuk mempelajari persoalan ilmiah atau teknis. Kata “komputasi” berarti proses menghitung dengan aturan tertentu. Kata “ilmiah” berarti proses itu dilakukan untuk memahami, menguji, atau memprediksi gejala yang dapat dipertanggungjawabkan secara rasional dan empiris.

Dalam buku ini, komputasi ilmiah biasanya melibatkan lima unsur.

Pertama, ada pertanyaan ilmiah. Contohnya: bagaimana posisi benda berubah terhadap waktu? Bagaimana konsentrasi zat berkurang dalam reaksi? Bagaimana hubungan antara tegangan dan arus listrik pada suatu perangkat fisik?

Kedua, ada besaran. Besaran adalah sesuatu yang dapat dinyatakan dengan nilai dan satuan. Dalam fisika, kita sering menyebutnya besaran fisis: waktu dalam sekon, panjang dalam meter, massa dalam kilogram, suhu dalam kelvin atau derajat Celsius, dan seterusnya. Dalam bidang lain, besaran dapat berupa jumlah populasi, konsentrasi larutan, intensitas cahaya, atau skor pengukuran.

Ketiga, ada model matematis. Model matematis adalah penyederhanaan suatu sistem nyata ke dalam bentuk variabel, persamaan, fungsi, atau aturan. Model bukan salinan sempurna dari kenyataan. Model adalah cara terkontrol untuk menangkap bagian penting dari kenyataan. Misalnya, jika hambatan udara diabaikan, gerak jatuh bebas dekat permukaan Bumi dapat dimodelkan dengan percepatan konstan. Penyederhanaan ini berguna dalam kondisi tertentu, tetapi tidak selalu benar untuk semua keadaan.

Keempat, ada metode numerik. Metode numerik adalah cara menghitung jawaban pendekatan ketika jawaban eksak sulit, tidak praktis, atau tidak tersedia. Misalnya, integral tertentu dapat dihitung dengan rumus analitik jika bentuk fungsinya sederhana. Tetapi jika data berasal dari eksperimen, kita sering hanya memiliki titik-titik pengukuran. Dalam keadaan seperti itu, integral dapat diperkirakan dengan metode trapesium atau metode Simpson.

Kelima, ada penafsiran. Hasil komputasi harus dikaitkan kembali dengan pertanyaan awal. Jika program menghasilkan angka 0.37, kita harus bertanya: 0.37 apa? Apakah satuannya? Apakah nilainya masuk akal? Seberapa besar ketidakpastiannya? Apakah model yang digunakan memang sesuai dengan data?

Dengan demikian, komputasi ilmiah bukan hanya urusan komputer. Ia adalah cara berpikir yang menghubungkan sains, matematika, pemrograman, data, dan penilaian kritis.

Dari model ke program

Salah satu kemampuan utama yang akan dilatih dalam buku ini adalah menerjemahkan model matematis menjadi program.

Ambil contoh model sederhana:

\[ y = a x + b. \]

Secara matematis, ini adalah model linear. Variabel \(x\) adalah masukan, \(y\) adalah keluaran, sedangkan \(a\) dan \(b\) adalah parameter. Parameter adalah nilai yang menentukan bentuk khusus suatu model. Jika \(a = 2\) dan \(b = 1\), maka modelnya menjadi:

\[ y = 2x + 1. \]

Dalam Python, model itu dapat ditulis sebagai fungsi:

def model_linear(x, a, b):
    return a * x + b

Fungsi adalah blok kode yang menerima masukan dan mengembalikan keluaran. Pada contoh di atas, x, a, dan b adalah masukan fungsi. Baris return a * x + b menyatakan nilai keluaran.

Jika x hanya satu angka, fungsi itu menghitung satu nilai. Tetapi dalam komputasi ilmiah, kita sering ingin menghitung banyak nilai sekaligus. Misalnya, kita ingin mengevaluasi model pada \(x = 0, 1, 2, 3, 4\). Dengan NumPy, kumpulan nilai seperti ini dapat disimpan sebagai larik. Larik adalah struktur data yang menyimpan banyak nilai sejenis dalam susunan teratur. NumPy menyediakan objek larik yang efisien untuk perhitungan numerik dan menjadi fondasi banyak pustaka ilmiah Python (Harris et al., 2020).

import numpy as np

x = np.array([0, 1, 2, 3, 4])
y = model_linear(x, a=2, b=1)

print(y)

Hasilnya:

[1 3 5 7 9]

Contoh kecil ini menunjukkan pola besar yang akan berulang sepanjang buku:

1. tulis model matematis,
2. nyatakan variabel dan parameter,
3. ubah model menjadi fungsi Python,
4. hitung nilai numerik,
5. periksa dan tafsirkan hasilnya.

Pola ini berlaku untuk model linear sederhana, persamaan diferensial, simulasi Monte Carlo, optimisasi, hingga pencocokan kurva nonlinear.

Mengapa visualisasi penting?

Data numerik sering sulit dipahami jika hanya dibaca sebagai tabel. Misalnya, deretan angka berikut tidak langsung memberi gambaran jelas:

0.0, 0.2, 0.5, 1.1, 2.0, 3.8, 7.1

Namun jika angka-angka itu diplot terhadap waktu, kita mungkin segera melihat pola pertumbuhan, peluruhan, osilasi, pencilan, atau kesalahan pengukuran. Visualisasi adalah penyajian data atau hasil model dalam bentuk grafis agar pola, hubungan, dan kejanggalan lebih mudah dilihat.

Matplotlib adalah pustaka Python yang dirancang untuk membuat grafik dua dimensi dan banyak digunakan dalam ekosistem ilmiah Python (Hunter, 2007). Dengan beberapa baris kode, kita dapat membuat grafik garis sederhana:

import matplotlib.pyplot as plt

t = np.array([0, 1, 2, 3, 4, 5, 6])
y = np.array([0.0, 0.2, 0.5, 1.1, 2.0, 3.8, 7.1])

plt.plot(t, y, marker="o")
plt.xlabel("Waktu")
plt.ylabel("Nilai pengamatan")
plt.title("Contoh perubahan nilai terhadap waktu")
plt.show()

Grafik bukan hiasan akhir. Grafik adalah alat berpikir. Grafik membantu kita memeriksa apakah data tampak linear, apakah ada titik yang menyimpang, apakah skala yang dipakai sesuai, dan apakah model mengikuti pola data. Dalam laporan ilmiah, visualisasi yang baik juga membantu pembaca memahami argumen kita.

Tetapi visualisasi harus jujur. Memotong sumbu secara tidak tepat, memilih skala yang menyesatkan, atau memakai warna yang menyembunyikan pola dapat menghasilkan kesimpulan keliru. Karena itu, buku ini tidak hanya mengajarkan cara membuat grafik, tetapi juga cara membaca dan merancang visualisasi secara bertanggung jawab.

Angka komputer bukan angka matematika murni

Dalam matematika, bilangan real dapat memiliki tak hingga banyak digit. Misalnya, \(\pi\) tidak berakhir setelah beberapa angka desimal. Tetapi komputer tidak dapat menyimpan tak hingga digit. Komputer menyimpan bilangan dengan representasi terbatas.

Dalam komputasi numerik, bilangan pecahan biasanya disimpan sebagai floating-point number. Istilah ini merujuk pada cara komputer merepresentasikan bilangan dengan sejumlah digit signifikan dan eksponen, mirip notasi ilmiah seperti \(1.23 \times 10^4\). Karena jumlah digit yang disimpan terbatas, tidak semua bilangan real dapat direpresentasikan secara tepat. Goldberg (1991) memberikan pembahasan klasik tentang cara kerja floating-point dan berbagai konsekuensinya dalam komputasi.

Contoh sederhana:

print(0.1 + 0.2)

Di banyak lingkungan Python, hasilnya bukan tepat 0.3, melainkan:

0.30000000000000004

Ini bukan berarti Python “salah” dalam pengertian biasa. Penyebabnya adalah representasi biner floating-point tidak dapat menyimpan beberapa pecahan desimal secara eksak. Kesalahan kecil seperti ini disebut galat pembulatan. Galat adalah selisih antara nilai yang dihitung atau diukur dengan nilai acuan yang dianggap benar. Dalam komputasi ilmiah, kita harus belajar mengenali, mengendalikan, dan menafsirkan galat.

Karena itu, membandingkan dua bilangan floating-point dengan == sering tidak aman untuk perhitungan numerik. Daripada menulis:

hasil == 0.3

kita biasanya memakai toleransi:

np.isclose(hasil, 0.3)

Toleransi adalah batas perbedaan kecil yang masih dianggap dapat diterima. Gagasan ini penting karena hasil numerik hampir selalu perlu dibaca bersama konteks: metode yang digunakan, ukuran langkah, kualitas data, satuan, dan ketidakpastian.

Data, model, dan pencocokan kurva

Banyak persoalan ilmiah dimulai dari data. Data adalah catatan hasil pengamatan, pengukuran, simulasi, atau eksperimen. Data mentah jarang langsung siap dianalisis. Kadang ada nilai hilang, satuan tidak konsisten, pencilan, kesalahan pengetikan, atau format berkas yang tidak rapi. Karena itu, pengolahan data adalah bagian penting dari komputasi ilmiah.

Misalnya kita mengukur suhu kopi setiap menit. Kita memperoleh pasangan data:

\[ (t_i, T_i), \]

dengan \(t_i\) menyatakan waktu pengukuran ke-\(i\) dan \(T_i\) menyatakan suhu pada waktu itu. Kita mungkin menduga bahwa suhu kopi mengikuti model:

\[ T(t) = T_{\text{ruang}} + A e^{-kt}. \]

Di sini \(T_{\text{ruang}}\) adalah suhu ruangan, \(A\) adalah selisih suhu awal terhadap suhu ruangan, dan \(k\) adalah parameter laju pendinginan. Semakin besar \(k\), semakin cepat suhu mendekati suhu ruangan.

Jika data tersedia, kita dapat melakukan pencocokan kurva. Pencocokan kurva adalah proses mencari nilai parameter model agar kurva model mendekati data menurut kriteria tertentu. Dalam kasus ini, kita dapat mencari nilai \(A\) dan \(k\) yang membuat \(T(t)\) paling sesuai dengan titik-titik pengukuran.

Pustaka SciPy menyediakan banyak algoritma untuk optimisasi, pencocokan kurva, aljabar linear, integrasi numerik, dan penyelesaian persamaan diferensial; pustaka ini memang dirancang sebagai kumpulan algoritma dasar untuk komputasi ilmiah di Python (Virtanen et al., 2020). Dalam buku ini, kita akan memakai SciPy secara bertahap, setelah konsep matematisnya diperkenalkan.

Namun pencocokan kurva bukan sekadar mencari garis atau kurva yang tampak bagus. Kita harus memeriksa residual. Residual adalah selisih antara data pengamatan dan nilai prediksi model. Jika residual menunjukkan pola tertentu, misalnya selalu positif di awal dan negatif di akhir, model mungkin tidak menangkap struktur penting dalam data. Jika residual tampak acak dan kecil dibandingkan ketidakpastian pengukuran, model mungkin cukup baik untuk tujuan tertentu.

Kata “cukup” penting di sini. Model tidak perlu sempurna untuk berguna. Tetapi kita harus jelas: berguna untuk apa, pada rentang data mana, dengan ketidakpastian berapa, dan berdasarkan asumsi apa.

Program ilmiah harus dapat diperiksa ulang

Dalam pembelajaran pemrograman umum, program sering dinilai dari apakah ia berjalan. Dalam komputasi ilmiah, itu belum cukup. Program harus dapat diperiksa ulang. Hasil yang baik adalah hasil yang dapat ditelusuri: data asalnya jelas, kode yang dipakai tersedia, versi pustaka diketahui, parameter tercatat, dan grafik dapat dibuat ulang.

Kebiasaan ini disebut reproduksibilitas. Secara praktis, reproduksibilitas berarti orang lain—atau diri kita sendiri beberapa bulan kemudian—dapat menjalankan kembali analisis dan memperoleh hasil yang sama atau sepadan. Dalam praktik komputasi ilmiah, dokumentasi, pengujian, pengelolaan dependensi, dan organisasi proyek merupakan bagian dari mutu kerja ilmiah; Wilson et al. (2014) merangkum banyak praktik baik yang relevan untuk penulisan kode ilmiah.

Contoh sederhana: jika sebuah simulasi memakai bilangan acak, hasilnya dapat berubah setiap kali dijalankan. Ini tidak selalu buruk, tetapi harus dikendalikan ketika kita ingin membandingkan hasil. Salah satu caranya adalah menetapkan seed, yaitu nilai awal untuk pembangkit bilangan acak.

rng = np.random.default_rng(seed=42)
sampel = rng.normal(loc=0.0, scale=1.0, size=5)

print(sampel)

Dengan seed yang sama dan lingkungan yang sesuai, urutan bilangan acak yang dihasilkan dapat diulang. Ini membantu kita memeriksa analisis, membuat contoh yang stabil, dan membandingkan perubahan kode secara lebih adil.

Reproduksibilitas juga berarti menulis kode yang mudah dibaca. Nama variabel seperti waktu, suhu, atau laju_pendinginan lebih jelas daripada a, b, dan c jika konteksnya eksperimen pendinginan. Komentar harus menjelaskan alasan, bukan mengulang kode yang sudah jelas. Fungsi harus dibuat cukup kecil agar mudah diuji. Prinsip-prinsip seperti ini akan dibahas lagi pada bagian akhir buku.

Cara buku ini akan membawa Anda belajar

Buku ini dimulai dari cara berpikir komputasi ilmiah, bukan langsung dari pustaka. Alasannya sederhana: pustaka dapat berubah, tetapi cara berpikir yang baik bertahan lebih lama. Anda akan belajar menyusun alur kerja: merumuskan persoalan, membuat model, memilih metode numerik, menulis program, memeriksa galat, memvisualisasikan hasil, lalu menafsirkan maknanya.

Setelah itu, kita membangun lingkungan kerja Python yang andal. Lingkungan kerja adalah susunan perangkat lunak yang dipakai untuk menulis, menjalankan, dan menyimpan program. Di dalamnya termasuk Python, editor, Jupyter, pustaka ilmiah, dan lingkungan virtual. Lingkungan yang rapi membuat perhitungan lebih mudah diulang dan dibagikan.

Kemudian kita meninjau dasar Python untuk perhitungan: variabel, tipe data, percabangan, perulangan, fungsi, modul, dan dokumentasi. Bagian ini bukan pengantar Python umum yang terlalu luas, melainkan pengantar yang diarahkan pada persoalan numerik.

Sesudah itu, kita masuk ke bilangan floating-point dan galat numerik. Ini penting karena komputer bukan papan tulis matematika. Setiap angka yang dihitung memiliki keterbatasan representasi. Dengan memahami galat absolut, galat relatif, pembatalan numerik, dan toleransi, Anda akan lebih siap membaca hasil komputasi secara dewasa.

Bagian berikutnya membahas NumPy, pengolahan larik, visualisasi dengan Matplotlib, visualisasi ilmiah yang jujur, pembacaan data, dan pandas untuk data berlabel. Setelah fondasi itu kuat, buku bergerak ke topik-topik numerik: aljabar linear, interpolasi, akar persamaan, optimisasi, diferensiasi, integrasi, pencocokan kurva, statistik, Monte Carlo, persamaan diferensial biasa, simulasi sistem, visualisasi dua dan tiga dimensi, kinerja kode, pengujian, dan reproduksibilitas.

Pada akhirnya, semua keterampilan itu akan dipadukan dalam studi kasus. Tujuannya bukan agar Anda menghafal banyak fungsi Python, melainkan agar Anda mampu menghadapi persoalan baru dengan tenang:

Apa pertanyaannya?
Apa besaran yang terlibat?
Apa modelnya?
Apa metodenya?
Bagaimana menghitungnya?
Bagaimana memeriksa hasilnya?
Apa makna ilmiah atau makna fisisnya?

Jika Anda dapat menjawab pertanyaan-pertanyaan itu dengan jelas, Python tidak lagi hanya menjadi bahasa pemrograman. Python menjadi alat berpikir ilmiah.

Sikap belajar yang disarankan

Saat membaca buku ini, jangan hanya menyalin kode. Jalankan kode, ubah nilainya, rusakkan sedikit, lalu perbaiki. Jika grafik tampak aneh, jangan langsung mengganti warna atau gaya. Periksa datanya. Periksa satuannya. Periksa apakah sumbu sudah benar. Periksa apakah model memang sesuai.

Jika suatu hasil numerik berbeda dari dugaan, jangan terburu-buru menyimpulkan bahwa program salah. Bisa jadi dugaan awal yang salah. Bisa jadi satuan tidak konsisten. Bisa jadi metode numerik tidak stabil. Bisa jadi ada galat pembulatan. Bisa juga program memang keliru. Komputasi ilmiah yang baik melatih kita memisahkan kemungkinan-kemungkinan itu secara sistematis.

Buku ini mengandaikan Anda sudah pernah belajar dasar pemrograman atau matematika tingkat awal perguruan tinggi, tetapi tidak mengandaikan Anda sudah mahir komputasi numerik. Setiap konsep penting akan dibangun bertahap. Jika ada istilah baru, bacalah definisinya, lihat contohnya, lalu gunakan dalam latihan.

Yang paling penting: jangan memperlakukan komputer sebagai pemberi jawaban terakhir. Perlakukan komputer sebagai rekan kerja yang sangat cepat, tetapi perlu diberi instruksi dengan teliti dan hasilnya perlu diperiksa. Dalam sains, kecepatan menghitung hanya berguna jika disertai kejernihan berpikir.

References

Goldberg, D. (1991). What every computer scientist should know about floating-point arithmetic. ACM Computing Surveys, 23(1), 5–48. https://doi.org/10.1145/103162.103163

Harris, C. R., Millman, K. J., van der Walt, S. J., Gommers, R., Virtanen, P., Cournapeau, D., Wieser, E., Taylor, J., Berg, S., Smith, N. J., Kern, R., Picus, M., Hoyer, S., van Kerkwijk, M. H., Brett, M., Haldane, A., del Río, J. F., Wiebe, M., Peterson, P., Gérard-Marchant, P., Sheppard, K., Reddy, T., Weckesser, W., Abbasi, H., Gohlke, C., & Oliphant, T. E. (2020). Array programming with NumPy. Nature, 585, 357–362. https://doi.org/10.1038/s41586-020-2649-2

Hunter, J. D. (2007). Matplotlib: A 2D graphics environment. Computing in Science & Engineering, 9(3), 90–95. https://doi.org/10.1109/MCSE.2007.55

Virtanen, P., Gommers, R., Oliphant, T. E., Haberland, M., Reddy, T., Cournapeau, D., Burovski, E., Peterson, P., Weckesser, W., Bright, J., van der Walt, S. J., Brett, M., Wilson, J., Millman, K. J., Mayorov, N., Nelson, A. R. J., Jones, E., Kern, R., Larson, E., Carey, C. J., Polat, İ., Feng, Y., Moore, E. W., VanderPlas, J., Laxalde, D., Perktold, J., Cimrman, R., Henriksen, I., Quintero, E. A., Harris, C. R., Archibald, A. M., Ribeiro, A. H., Pedregosa, F., van Mulbregt, P., & SciPy 1.0 Contributors. (2020). SciPy 1.0: Fundamental algorithms for scientific computing in Python. Nature Methods, 17, 261–272. https://doi.org/10.1038/s41592-019-0686-2

Wilson, G., Aruliah, D. A., Brown, C. T., Chue Hong, N. P., Davis, M., Guy, R. T., Haddock, S. H. D., Huff, K. D., Mitchell, I. M., Plumbley, M. D., Waugh, B., White, E. P., & Wilson, P. (2014). Best practices for scientific computing. PLoS Biology, 12(1), e1001745. https://doi.org/10.1371/journal.pbio.1001745