MODUL PRAKTIKUM MATA KULIAH

KOMPUTASI NUMERIK

MODUL 1: GALAT NUMERIK (DARI KALKULUS MENUJU KOMPUTASI)

JURUSAN TEKNIK KOMPUTER DAN INFORMATIKA

POLITEKNIK NEGERI BANDUNG

2026

---

LEMBAR PERSETUJUAN

GALAT NUMERIK (DARI KALKULUS MENUJU KOMPUTASI)

Proses	Jabatan	Nama	Tanda Tangan
Disusun Oleh	Pengampu Praktikum Mata Kuliah Komputasi Numerik
Diperiksa oleh	Ketua Kelompok Bidang Keahlian (KBK) Multimedia
Disahkan oleh	Ketua Program Sarjana Terapan Teknik Informatika

PUBLISHED BY

Jurusan Teknik Komputer & Informatika Politeknik Negeri Bandung

Jl. Gegerkalong Hilir, Desa Ciwaruga, Kecamatan Parongpong, Kabupaten Bandung Barat, Jawa Barat 40559

Copyright © 2026 by JTK POLBAN

All rights reserved. No part of the contents of this book may be reproduced or transmitted in any form or by any means without the written permission of the publisher.

Penanggung jawab	: Iwan Awaludin
Penanggung jawab	: Muhammad Rizqi Sholahuddin
Tim Penulis	: Tim Praktikum Komputasi Numerik

---

KATA PENGANTAR

Puji syukur kehadirat Tuhan Yang Maha Esa, karena berkat karunia dan ridho-NYA "GALAT NUMERIK (DARI KALKULUS MENUJU KOMPUTASI)" telah selesai disusun.

Penyusunan "GALAT NUMERIK (DARI KALKULUS MENUJU KOMPUTASI)" ini bertujuan untuk memberikan petunjuk dan prosedur operasional baku (POB) mengenai proses kegiatan praktikum, mulai dari tahap persiapan, pelaksanaan, pelaporan, dan evaluasi untuk penilaian. Melalui modul ini diharapkan proses praktikum dapat mudah dipahami, baik oleh mahasiswa dan dosen di lingkungan Jurusan Teknik Komputer dan Informatika Politeknik Negeri Bandung.

Komputasi Numerik adalah mata kuliah yang menjembatani matematika analitik dengan komputasi digital. Mudahnya: matematika bekerja dengan bilangan yang "sempurna" tanpa batas digit, sedangkan komputer bekerja dengan ruang simpan yang terbatas. Setiap bilangan riil yang aslinya punya tak hingga angka di belakang koma harus "dipangkas" agar muat di dalam memori yang jumlah bitnya terbatas. Akibatnya, hasil hitung komputer hampir selalu sedikit berbeda dari nilai sejatinya; selisih kecil inilah yang disebut galat. Memahami dari mana galat berasal, seberapa besar ia, dan bagaimana ia menjalar dari satu perhitungan ke perhitungan berikutnya adalah bekal paling dasar sebelum mahasiswa mempelajari metode-metode numerik lanjutan seperti pencarian akar, integrasi numerik, hingga optimasi. Pada Modul 1 ini mahasiswa tidak hanya menghitung galat di atas kertas, tetapi juga membuktikannya sendiri melalui program Python yang sederhana dan mudah diikuti.

Semoga modul ini bermanfaat untuk memperkuat pelaksanaan pengajaran di Jurusan Teknik Komputer & Informatika Politeknik Negeri Bandung, sehingga transparansi dan akuntabilitas kinerja bidang akademik dapat tercapai.

Bandung, 2026

---

DAFTAR ISI

Judul	Halaman
LEMBAR PERSETUJUAN	i
KATA PENGANTAR	iii
DAFTAR ISI	iv
DAFTAR GAMBAR	v
DAFTAR TABEL	vi
IDENTITAS MATA KULIAH, PROGRAM STUDI DAN KURIKULUM	vii
CAPAIAN PEMBELAJARAN	viii
BAGIAN I. BAHAN KAJIAN	1
I.1. Penggunaan Pedoman	1
I.2. Ruang Lingkup	1
I.3. Teknologi	1
I.4. Studi Kasus	2
I.5. Konsep yang Digunakan	2
BAGIAN II. PENYIAPAN PELAKSANAAN PRAKTIKUM (PREPARATION)	3
II.1. Peralatan Praktikum	3
II.2. Keamanan & Keselamatan Kerja	4
BAGIAN III. PROSEDUR PELAKSANAAN PRAKTIKUM (STEP BY STEP)	6
III.1. Teori Singkat: Galat dalam Komputasi Numerik	6
III.2. Environment & Setup Praktikum	8
III.3. Task 0: Hello World & Verifikasi Environment	9
III.4. Task I: Galat Pembulatan & Representasi Floating Point	10
III.5. Task II: Galat Absolut dan Galat Relatif	12
III.6. Task III: Catastrophic Cancellation	14
III.7. Task IV: Galat Pemotongan Deret	16
III.8. Kesimpulan Praktikum	18
III.9. Tugas Praktikum	19
III.10. Soal Latihan HOTS (Pengayaan)	20
BAGIAN IV. MEDIA DAN MEKANISME PENGUMPULAN	21
BAGIAN V. PEMBAHASAN DAN EVALUASI HASIL PRAKTIKUM	22
DAFTAR PUSTAKA	23
LAMPIRAN	1

DAFTAR GAMBAR

Gambar 1. Grafik Batang Galat Relatif Berbagai Aproksimasi π (Skala Logaritmik)

Gambar 2. Perbandingan Nilai 1 − cos(x) Dihitung Langsung vs Identitas Trigonometri vs Nilai Eksak

Gambar 3. Konvergensi Galat Pemotongan Deret Taylor e^x pada x = 1

DAFTAR TABEL

Tabel 1. Pemetaan Capaian Pembelajaran Mata Kuliah (CPMK) Terhadap Modul Praktikum Komputasi Numerik

Tabel 2. Standar Penamaan Proyek dan Berkas Pengumpulan Praktikum Komputasi Numerik

Tabel 3. Tiga Sumber Utama Galat dalam Komputasi Numerik

Tabel 4. Ilustrasi Galat Absolut dan Relatif pada Aproksimasi π

Tabel 5. Hasil Iterasi Pencarian Epsilon Mesin

Tabel 6. Ringkasan Perbandingan Galat Pembulatan dan Galat Pemotongan

Tabel 7. Rubrik dan Matriks Kriteria Penilaian Evaluasi Praktikum

---

IDENTITAS MATA KULIAH, PROGRAM STUDI DAN KURIKULUM

Atribut	Keterangan
Mata Kuliah	: Komputasi Numerik (Praktikum)
Mata Kuliah (Inggris)	: Numerical Computing (Practicum)
Kode Mata Kuliah	: 25TI3101
SKS	: 3 (2 Teori, 1 Praktikum)
Sifat Pengambilan	: Wajib
Bentuk Pembelajaran	: Tutorial, Praktik
Metode Pembelajaran	: Problem Based Learning, Project Based Learning
Media	: Offline / Daring (Google Colab)
Semester	: V
Kelompok Mata Kuliah	: Mata Kuliah KBK Multimedia
Program Pendidikan	: Sarjana Terapan (D-4) Prodi Teknik Informatika
Jurusan	: Teknik Komputer & Informatika
Penyusun	: Iwan Awaludin

---

CAPAIAN PEMBELAJARAN

Tabel 1. Pemetaan Capaian Pembelajaran Mata Kuliah (CPMK) Terhadap Modul Praktikum Komputasi Numerik

CAPAIAN PEMBELAJARAN MATA KULIAH	INTEGRASI DENGAN MODUL PRAKTIKUM
CPMK 1 Mahasiswa mampu menjelaskan konsep galat numerik, galat pemotongan, dan galat pembulatan dalam komputasi.	MODUL 1
CPMK 2 Mahasiswa mampu menerapkan algoritma numerik untuk menyelesaikan masalah matematika yang kompleks.	MODUL 3, 4, 5, 6
CPMK 3 Mahasiswa mampu menganalisis kestabilan, akurasi, dan konvergensi suatu metode numerik.	MODUL 2, 3, 5, 6
CPMK 4 Mahasiswa mampu mengimplementasikan metode numerik menggunakan bahasa pemrograman.	MODUL 2, 4, 5, 8
CPMK 5 Mahasiswa mampu menyelesaikan permasalahan rekayasa dan sains secara numerik dengan pendekatan yang sistematis dan kritis.	MODUL 7, 9, 10, 11

---

BAGIAN I. BAHAN KAJIAN

I.1. Penggunaan Pedoman

Pedoman ini memberikan instruksi sistematis mengenai tata cara persiapan, pengoperasian, penyelesaian tugas praktikum galat numerik untuk mata kuliah Komputasi Numerik, hingga mekanisme evaluasi. Baca bagian BAGIAN II sebelum praktikum dimulai, kerjakan BAGIAN III secara berurutan dari Task 0, lalu kumpulkan hasil pekerjaan sesuai BAGIAN IV.

I.2. Ruang Lingkup

Kegiatan mencakup setup environment komputasi Python (Google Colab / Jupyter Notebook), penguasaan konsep galat absolut dan galat relatif, representasi bilangan riil dalam floating point IEEE 754 (presisi ganda), galat pembulatan dan epsilon mesin, fenomena catastrophic cancellation pada pengurangan bilangan hampir sama besar, serta galat pemotongan yang muncul ketika proses matematis kontinu (deret tak hingga) dipangkas menjadi berhingga.

I.3. Teknologi

Berikut adalah teknologi yang digunakan pada modul praktikum ini:

• Bahasa Pemrograman Python (versi 3.10 atau 3.11).
• Google Colaboratory (Google Colab), yaitu lingkungan komputasi berbasis cloud yang tampilannya seperti Jupyter Notebook, atau Jupyter Notebook / JupyterLab yang terinstal lokal.
• Library NumPy, terpasang otomatis pada Google Colab atau via pip install numpy.
• Library Matplotlib untuk visualisasi hasil (pip install matplotlib).
• Peramban modern (Google Chrome / Mozilla Firefox) untuk mengakses Google Colab.

I.4. Studi Kasus

Mahasiswa diminta membangun sebuah notebook audit numerik untuk mengukur akurasi beberapa aproksimasi terhadap konstanta matematika (π). Selanjutnya mahasiswa membuktikan secara eksperimental dua fenomena khas komputasi: (1) galat pembulatan yang muncul karena representasi floating point, dan (2) catastrophic cancellation pada perhitungan $1-\cos (x)$ untuk $x$ sangat kecil, lalu membandingkannya dengan formulasi aljabar yang setara namun lebih stabil. Pada akhir praktikum mahasiswa menganalisis konvergensi galat pemotongan deret Taylor $e^x$ sebagai jembatan menuju modul berikutnya.

I.5. Konsep yang Digunakan

Galat (Error): Selisih antara nilai sejati dan nilai aproksimasi. Karena representasi bilangan pada komputer terbatas (berhingga bit), tidak ada perhitungan numerik yang sepenuhnya bebas galat; yang bisa dilakukan adalah mengukur, mengendalikan, dan meminimalkannya. Ibaratnya seperti menimbang gula memakai timbangan dapur: jarum menunjuk angka 250 gram, padahal berat sesungguhnya 253 gram. Selisih 3 gram itulah galat. Semakin halus skala timbangan, semakin kecil galatnya; tetapi bagaimanapun halusnya, tidak ada timbangan yang sempurna.

Galat Absolut dan Relatif: Galat absolut $E_a=|x_{sejati}-x_{aproks}|$ menyatakan simpangan dalam satuan besaran; galat relatif $E_r=E_a/|x_{sejati}|$ menyatakan simpangan proporsional sehingga lebih informatif untuk membandingkan akurasi antar besaran yang berbeda skala. Lanjutkan analogi timbangan tadi: salah 3 gram ketika menimbang bayi (bobotnya sekitar 3.000 gram) tentu masalah besar, tetapi salah 3 gram ketika menimbang truk (bobotnya sekitar 3.000.000 gram) justru nyaris tak terasa. Galat absolutnya sama-sama 3 gram, tetapi galat relatifnya sangat berbeda (sekitar 0,1% berbanding 0,000001%). Karena itu galat relatif dijadikan tolok ukur yang lebih adil.

Floating Point IEEE 754 & Galat Pembulatan: Bilangan riil disimpan dalam format $\pm d.dddd\times {10}^n$ (secara biner) dengan 52 bit mantisa untuk presisi ganda, sehingga hanya $\approx 15$–$16$ angka desimal signifikan yang dapat dijamin. Bayangkan sebuah penggaris yang garis skalanya hanya ada setiap 1 mm: benda sepanjang 2,37 mm tidak mungkin diukur persis; ia harus dinaikkan ke tanda 2 mm atau diturunkan ke tanda 3 mm terdekat. Komputer mengalami nasib yang sama pada setiap bilangan yang tidak menempel persis di kisi floating point: hasilnya dibulatkan ke bilangan terdekat yang bisa disimpan, dan setiap pembulatan meninggalkan galat kecil. Epsilon mesin ($\epsilon \approx 2.22\times {10}^{-16}$) adalah ukuran "jarak antar garis skala" terkecil di sekitar angka 1.0: dua bilangan yang selisihnya lebih kecil dari itu tidak lagi bisa dibedakan oleh komputer.

Catastrophic Cancellation: Pengurangan dua bilangan yang hampir sama besar menggugurkan angka signifikan sehingga galat relatif melonjak. Ibaratnya mengukur tebal satu lembar kertas dengan cara mengukur tinggi dua tumpukan besar yang ketinggiannya nyaris sama lalu mengurangkannya: masing-masing pengukuran besar sudah menyimpan kesalahan kecil, dan pada saat dikurangkan, kesalahan kecil itu justru menjadi dominan pada hasil akhir. Solusinya adalah reformulasi aljabar (misalnya menggunakan identitas trigonometri atau rasionalisasi) agar pengurangan berbahaya tersebut dihindari sejak awal.

Galat Pemotongan (Truncation Error): Galat yang timbul karena proses matematis tak hingga (misalnya deret Taylor) dipotong menjadi sejumlah suku berhingga. Ibaratnya menuliskan π = 3.14159265... cukup dengan 3.14: praktis dan mudah, tetapi ada "sisa" yang dibuang, dan sisa itulah galat pemotongan. Semakin banyak suku (atau digit) yang dipertahankan, semakin kecil galatnya; di sinilah muncul trade-off klasik antara akurasi hasil dan biaya komputasi.

---

BAGIAN II. PENYIAPAN PELAKSANAAN PRAKTIKUM (PREPARATION)

II.1. Peralatan Praktikum

Kebutuhan peralatan praktikum dapat dilihat pada list berikut:

Perangkat Hardware:

• PC/Laptop (Processor Dual-Core 2.0 GHz+, RAM minimal 4 GB, Ruang Disk minimal 2 GB).
• Koneksi internet yang stabil (wajib apabila menggunakan Google Colab).

System Software:

• Sistem Operasi Windows 10/11 64-bit, Linux, atau macOS.

Development Tools:

• Akun Google (Gmail) aktif untuk mengakses Google Colab, atau instalasi Python 3.10/3.11 beserta Jupyter Notebook/JupyterLab untuk penggunaan lokal.
• Library NumPy dan Matplotlib (terpasang otomatis di Colab; pip install numpy matplotlib untuk penggunaan lokal).
• Peramban modern (Google Chrome / Mozilla Firefox).

II.2. Keamanan & Keselamatan Kerja

Komputer merupakan perangkat teknologi komunikasi dan informasi yang sering digunakan dewasa ini. Pada saat bekerja dengan komputer ada beberapa hal yang harus diperhatikan agar tidak berdampak buruk bagi kesehatan bahkan keselamatan kita. Komputer dapat menyebabkan penggunanya menderita nyeri otot dan tulang terutama bahu, pergelangan tangan, leher, punggung, pinggang bagian bawah, mata merah berair, bahkan gangguan penglihatan.

Beberapa hal yang bisa dilakukan untuk menghindari efek negatif dari bekerja dengan komputer:

• Aturlah posisi tubuh saat bekerja dengan komputer sehingga merasa nyaman.
• Aturlah posisi perangkat komputer dan ruangan sehingga memberi rasa nyaman.
• Makan, minum, dan istirahatlah yang cukup.
• Gerakkan badan untuk mengurangi ketegangan otot dan pikiran, dan olahragalah secara teratur.
• Sesekali alihkan pandangan ke luar ruangan untuk menyegarkan mata.

Mengatur posisi tubuh:

• Posisi Kepala & Leher harus tegak lurus dengan wajah menghadap langsung ke komputer, jangan menengadah atau membungkuk.
• Posisi Punggung yang baik adalah tegak, tidak miring ke kanan/kiri, tidak membungkuk dan tidak menyandar terlalu ke belakang.
• Posisi Pundak tidak terlalu terangkat dan tidak terlalu ke bawah, pastikan otot pundak tidak tegang.
• Posisi Lengan & Siku yang baik adalah apabila mengetik dan menggunakan mouse dengan nyaman.
• Posisi Kaki harus bebas, diluruskan sesekali agar aliran darah lancar.

Mengatur Posisi Komputer:

• Monitor harus diletakkan di tempat yang tidak memantulkan cahaya lain.
• Letakkan monitor lebih rendah dari garis horizontal mata.
• Aturlah cahaya monitor (contrast/brightness) agar tidak terlalu gelap dan terang.
• Sering-seringlah mengedipkan mata (minimal 5 detik setiap 10 menit).

Istirahat Mata: Terapkan aturan 20-20-20, yaitu setiap 20 menit alihkan pandangan ke objek yang berjarak 20 kaki (±6 meter) selama 20 detik, untuk mencegah kelelahan mata akibat paparan monitor visual.

---

BAGIAN III. PROSEDUR PELAKSANAAN PRAKTIKUM (STEP BY STEP)

III.1. Teori Singkat: Galat dalam Komputasi Numerik

Metode numerik adalah teknik penyederhanaan masalah matematika menjadi operasi aritmetika berhingga agar dapat dikerjakan komputer. Konsekuensinya, hasil numerik hampir selalu berupa aproksimasi yang menyimpan galat, yaitu selisih antara nilai sejati dan nilai hampiran. Secara formal, untuk nilai sejati $x_t$ dan aproksimasi $x_a$:

• Galat absolut: $E_a=|x_t-x_a|$
• Galat relatif: $E_r={\displaystyle \frac{|x_t-x_a|}{|x_t|}}$ (sering dinyatakan dalam persen)

Sebagai contoh cepat: jika nilai sejati $x_t=10$ dan hampiran $x_a=9.9$, maka $E_a=|10-9.9|=0.1$ dan $E_r=0.1/10=1\mathrm{\%}$. Angka absolut memberi tahu "seberapa jauh meleset dalam satuan aslinya", sedangkan angka relatif memberi tahu "seberapa besar meleset ini dibanding besaran yang diukur".

Ada tiga sumber galat utama dalam komputasi numerik:

Tabel 3. Tiga Sumber Utama Galat dalam Komputasi Numerik

Sumber Galat	Penyebab	Contoh
Galat data (inkonsistensi input)	Kesalahan pengukuran/pembacaan data	Sensor suhu terbaca 24.9°C padahal 25.0°C
Galat pembulatan (round-off)	Representasi bilangan riil dengan bit berhingga	$0.1+0.2=0.30000000000000004$
Galat pemotongan (truncation)	Proses tak hingga dipangkas jadi berhingga	Deret Taylor $e^x$ dihentikan pada suku ke-$n$

Tabel di atas bisa dibaca dengan santai: galat bisa masuk melalui tiga pintu berbeda. Bisa dari awal (data masukan sudah salah), bisa dari cara komputer menyimpan angka (pembulatan), dan bisa dari cara kita menyederhanakan rumus (pemotongan). Ketiganya akan kita buktikan sendiri dengan kode pada task berikutnya.

Bilangan Floating Point. Standar IEEE 754 presisi ganda menyimpan bilangan dalam bentuk $(-1{)}^s\times 1.m\times 2^{e-1023}$ dengan 1 bit tanda, 11 bit eksponen, dan 52 bit mantisa. Apa artinya bagi kita yang bukan insinyur komputer? Sederhananya, setiap bilangan riil harus "dipaskan" ke 64 bit memori (kira-kira 16 angka penting), sama seperti foto resolusi tak hingga yang dipaksa disimpan dalam 16 digit. Akibatnya bilangan desimal seperti $0.1$ tidak dapat disimpan persis; yang disimpan adalah bilangan biner terdekat, sama seperti hasil mengukur dengan penggaris berskala mm tadi yang selalu jatuh di tanda terdekat. Ketika dua bilangan yang hampir sama besar dikurangkan, angka-angka signifikan saling menggugurkan (catastrophic cancellation), dan galat relatif dapat meledak meskipun galat absolut kecil.

Epsilon Mesin. Didefinisikan sebagai jarak floating point terkecil antara 1.0 dan bilangan berikutnya yang dapat direpresentasikan:

$$\epsilon =min\{\delta >0:1.0+\delta \ne 1.0\}$$

Untuk presisi ganda, $\epsilon =2^{-52}\approx 2.22\times {10}^{-16}$. Bayangkan kisi penggaris di sekitar angka 1.0: bilangan berikutnya yang masih bisa "dilihat" komputer berjarak $\epsilon$ dari 1.0. Selisih yang lebih kecil dari itu hilang ditelan pembulatan, seperti garis 0,1 mm yang tidak ada pada penggaris mm. Epsilon mesin menjadi patokan batas akurasi relatif terbaik yang mungkin dicapai suatu perhitungan; menargetkan galat lebih kecil dari $\epsilon$ sama saja dengan meminta penggaris mm membaca 0,1 mm, sesuatu yang mustahil.

Pendekatan Kalkulus vs Komputasi. Kalkulus bekerja dengan limit dan proses kontinu (turunan sebagai limit, integral sebagai limit jumlah Riemann). Komputer bekerja secara diskret dan berhingga (selisih hingga, jumlah berhingga). Contoh konkretnya: menghitung luas daerah di bawah kurva secara analitik memakai rumus integral, sedangkan komputer memotong daerah itu menjadi jutaan persegi panjang kecil lalu menjumlahkan luasnya satu per satu. Seluruh mata kuliah ini pada dasarnya adalah kajian tentang bagaimana memangkas proses kontinu menjadi operasi berhingga secara terkendali, dan galat adalah alat ukurnya.

III.2. Environment & Setup Praktikum

Untuk praktikum Komputasi Numerik, media komputasi yang sangat disarankan adalah Google Colaboratory (Google Colab) karena bersifat cloud-based, tidak memerlukan instalasi, dan sudah menyertakan Python serta library ilmiah populer (NumPy, Matplotlib) secara bawaan. Tampilannya mirip Google Docs, tetapi setiap cell dapat berisi kode Python yang bisa dijalankan langsung. Alternatif lain adalah Jupyter Notebook/JupyterLab yang dijalankan secara lokal dengan Python 3.10 atau 3.11.

A. Menggunakan Google Colab (Direkomendasikan)

1. Buka peramban, lalu akses https://colab.research.google.com.
2. Login menggunakan akun Google (Gmail).
3. Klik menu File → New notebook untuk membuat notebook baru. Beri nama notebook, misalnya KN2026_Modul1_Nama_NIM, melalui klik judul di kiri atas.

B. Menggunakan Jupyter Notebook (Lokal)

1. Pastikan Python 3.10/3.11 terinstal. Verifikasi melalui Command Prompt/PowerShell:

   python --version

   Perintah ini meminta Python memperkenalkan dirinya; jika muncul Python 3.10.x atau Python 3.11.x berarti aman.
2. Instal Jupyter, NumPy, dan Matplotlib:

   pip install jupyter numpy matplotlib

   pip adalah asisten pemasang paket Python; satu baris ini memasang ketiga alat sekaligus dari internet.
3. Jalankan server Jupyter:

   jupyter notebook

   Perintah ini menjalankan server lokal dan otomatis membuka halaman kerja Jupyter di peramban.
4. Pada peramban yang terbuka, klik New → Python 3 (ipykernel) untuk membuat notebook baru.

C. Mengenal Anatomi Cell

Notebook tersusun atas cell (sel) yang dieksekusi satu per satu, seperti rangkaian kotak kerja yang diisi bergantian:

• Code Cell berisi kode Python; hasil eksekusinya muncul sebagai Output Cell di bawahnya, lengkap dengan teks, tabel, atau grafik.
• Markdown Cell berisi teks naratif/penjelasan (mendukung penulisan rumus matematika LaTeX), berguna untuk memberi catatan pada kode agar laporan mudah dibaca.

Untuk mengeksekusi sebuah cell, tekan Shift + Enter (jalankan cell dan pindah ke cell berikutnya) atau Ctrl + Enter (jalankan tanpa berpindah cell).

III.3. Task 0: Hello World & Verifikasi Environment

TASK 0: HELLO WORLD & VERIFIKASI ENVIRONMENT

Sebelum masuk ke materi, kita pastikan dulu lingkungan kerja kita siap: Python dan NumPy siap dipakai selama satu semester.

1. Buat notebook baru di Google Colab / Jupyter Notebook.
2. Pada Code Cell pertama, ketik dan jalankan kode berikut:

print("Hello, Komputasi Numerik!")
import sys
print("Python version:", sys.version.split()[0])
import numpy as np
print("NumPy version:", np.__version__)

Cara membaca kode (bahasa awam):

• print("Hello, ...") = perintah mencetak teks ke layar. Kalau baris ini jalan tanpa error, artinya notebook Anda sudah menyala dan siap dipakai.
• import sys = membuka kotak alat bawaan Python bernama sys yang menyimpan informasi tentang program Python itu sendiri.
• sys.version.split()[0] = mengambil teks versi Python yang panjang, memotongnya per kata dengan split(), lalu mengambil kata pertama saja ([0]), yaitu nomor versinya.
• import numpy as np = memuat library NumPy (alat hitung angka andalan praktikum ini) dan memberinya nama pendek np supaya pemanggilannya tidak panjang.
• np.__version__ = menanyakan kepada NumPy "kamu versi berapa?"; jawabannya dicetak ke layar.

Output:

Hello, Komputasi Numerik!
Python version: 3.10.12
NumPy version: 1.21.5

3. Amati output yang dihasilkan. Catat versi Python dan NumPy pada catatan praktikum (versi di komputer Anda boleh sedikit berbeda dari contoh; yang penting tidak ada pesan error).
4. Tambahkan sebuah Markdown Cell berisi identitas mahasiswa (Nama, NIM, Kelas) sebagai judul notebook.

III.4. Task I: Galat Pembulatan & Representasi Floating Point

TASK I: EKSPLORASI GALAT PEMBULATAN PADA FLOATING POINT

Pada task ini kita membuktikan bahwa komputer "curang" sedikit pada bilangan desimal, lalu mengukur seberapa kecil "kecurangan" yang masih bisa dideteksi.

1. Pada notebook, buat Code Cell berikut untuk membuktikan bahwa 0.1 + 0.2 tidak persis sama dengan 0.3:

a = 0.1
b = 0.2
print(a + b)
print(a + b == 0.3)

Cara membaca kode (bahasa awam):

• a = 0.1 dan b = 0.2 = menyimpan angka ke dalam dua "kotak bernama", yaitu a dan b.
• print(a + b) = meminta komputer menjumlahkan isi kedua kotak lalu menampilkan hasilnya.
• print(a + b == 0.3) = tanda == di sini bukan menjumlah, melainkan bertanya: "apakah ruas kiri persis sama dengan 0.3?" Jawabannya selalu True (benar) atau False (salah). Hasil False pada output di bawah justru penemuan penting kita, bukan kesalahan program.

Output:

0.30000000000000004
False

Teks False di atas bukan bug, melainkan bukti bahwa hasil simpanan 0.1 + 0.2 memang tidak identik dengan hasil simpanan 0.3.

2. Tampilkan representasi biner-desimal dari 0.1 hingga 20 digit untuk melihat bahwa bilangan ini tidak tersimpan persis:

print(f"{a:.20f}")

Cara membaca kode (bahasa awam):

• f"..." = f-string, yaitu kalimat templat yang lubangnya bisa diisi angka atau teks.
• :.20f = aturan tampilan di dalam lubang templat: tulis angka dengan 20 digit di belakang titik. Padahal biasanya Python hanya menampilkan belasan digit, sehingga sisa pembulatan yang tersembunyi ikut terlihat melalui trik ini.

Output:

0.10000000000000000555

Nilai yang benar-benar tersimpan di memori adalah 0.1000000000000000055511151231257827..., sehingga operasi penjumlahannya mewarisi galat pembulatan tersebut. Angka ...0555 di ujung itulah sisa pembulatan yang tidak pernah hilang.

3. Cari epsilon mesin secara eksperimental dengan membagi dua suatu bilangan terus-menerus hingga tidak lagi bisa dibedakan dari 1.0. Idenya seperti menurunkan volume musik selangkah demi selangkah (tiap selangkah volumenya dibagi dua): pada satu titik telinga tidak lagi bisa membedakan suara terakhir itu dengan hening total. "Volume terkecil yang masih terdengar" itulah padanan epsilon mesin.

eps = 1.0
while 1.0 + eps != 1.0:
    eps = eps / 2.0
print("epsilon mesin (loop) =", eps * 2)

import numpy as np
print("epsilon mesin (numpy) =", np.finfo(float).eps)

Cara membaca kode (bahasa awam, per baris):

• eps = 1.0 = mulai dari bilangan besar yang pasti masih "terlihat" komputer ketika ditambahkan ke 1.0.
• while 1.0 + eps != 1.0: = arti harfiahnya "selama 1.0 + eps masih tidak sama dengan 1.0, kerjakan blok di bawahnya". Dengan kata lain: ulangi terus selama eps masih cukup besar untuk menggeser angka 1.0 dari tempatnya.
• eps = eps / 2.0 = isi perulangannya cuma satu: potong eps jadi setengahnya. Deretnya: 1.0, 0.5, 0.25, 0.125, ... mengecil cepat.
• Mengapa berhenti? Pada suatu putaran eps menjadi begitu kecil sehingga 1.0 + eps hasilnya "diserap" pembulatan kembali menjadi tepat 1.0; syarat != tidak terpenuhi lagi dan perulangan berhenti.
• Mengapa dicetak eps * 2? Karena saat perulangan berhenti, nilai eps terakhir sudah satu langkah TERLALU KECIL (gagal menggeser 1.0). Epsilon mesin adalah nilai tepat sebelumnya yang MASIH bisa menggeser, yaitu eps * 2.
• np.finfo(float).eps = jalan pintas untuk memastikan: NumPy membacakan spesifikasi pabrik tipe float 64-bit, termasuk epsilon resminya. Dua cara yang berbeda harus menghasilkan angka yang sama persis.

Output:

epsilon mesin (loop) = 2.220446049250313e-16
epsilon mesin (numpy) = 2.220446049250313e-16

Tabel 5. Hasil Iterasi Pencarian Epsilon Mesin

Iterasi	eps yang diuji	$1.0+eps$	Masih $\ne 1.0$?
1	1.0	2.0	Ya
2	0.5	1.5	Ya
...	...	...	...
52	$2^{-52}\approx 2.22\times {10}^{-16}$	1.0000000000000002	Ya
53	$2^{-53}\approx 1.11\times {10}^{-16}$	1.0 (dibulatkan)	Tidak (berhenti)

4. Bandingkan dengan nilai resmi $\epsilon =2^{-52}$ pada standar IEEE 754 presisi ganda. Keduanya harus identik.
5. Tuliskan Lesson Learnt mengenai mengapa perbandingan bilangan real dengan == adalah praktik yang berbahaya dan bagaimana seharusnya membandingkan dua bilangan floating point (petunjuk: toleransi abs(a-b) < tol).

Penjelasan: Loop pada langkah 3 berhenti ketika eps menjadi lebih kecil daripada setengah jarak antar bilangan floating point di sekitar 1.0, sehingga hasil penjumlahannya "diserap" pembulatan kembali menjadi 1.0; intinya 1.0 ditambah sesuatu yang terlalu kecil tetap terbaca 1.0. Epsilon mesin menandai batas akurasi relatif perhitungan presisi ganda: tidak ada algoritma yang mungkin menghasilkan galat relatif di bawah $\sim {10}^{-16}$ tanpa teknik khusus (mis. Kahan summation atau presisi arbitrer dengan modul decimal/mpmath). Anggaplah ini batas kepekaan komputer: selisih lebih kecil dari itu dianggap tidak ada.

III.5. Task II: Galat Absolut dan Galat Relatif

TASK II: MENGHITUNG GALAT ABSOLUT DAN RELATIF APROKSIMASI π

Kali ini kita memakai π, konstanta yang paling akrab di matematika, sebagai bahan uji. Nilai sejatinya sudah disediakan Python dengan hampir 16 digit presisi.

1. Nilai sejati yang menjadi acuan adalah math.pi (nilai π hingga presisi penuh Python). Evaluasi lima aproksimasi π yang umum digunakan:

import math

pi_aproks = [3.0, 3.14, 3.142, 22/7, 355/113]
for p in pi_aproks:
    Ea = abs(math.pi - p)               # galat absolut
    Er = Ea / abs(math.pi) * 100        # galat relatif (%)
    print(f"aproks = {p:<12.8f} Ea = {Ea:.10f}  Er = {Er:.8f}%")

Cara membaca kode (bahasa awam):

• import math = membuka kotak alat matematika, di dalamnya ada math.pi yaitu nilai π dengan hampir 16 digit ketelitian yang kita pakai sebagai "nilai sejati".
• pi_aproks = [...] = membuat daftar (list) berisi lima "kandidat" hampiran π; dua yang terakhir adalah pecahan yang langsung dihitung Python (22/7 dan 355/113).
• for p in pi_aproks: = ambil kandidat pertama, kerjakan seluruh perhitungan di bawahnya, lalu ulangi untuk kandidat berikutnya sampai habis.
• Ea = abs(math.pi - p) = galat absolut: selisih mutlak antara π sejati dan kandidat; abs memastikan hasilnya tidak pernah negatif.
• Er = Ea / abs(math.pi) * 100 = galat relatif dalam persen: galat absolut dibagi nilai sejati lalu dikali 100.
• Bagian f"...{p:<12.8f}..." = teknik mencetak rapi: <12 menyediakan kolom selebar 12 karakter rata kiri, sedangkan .8f dan .10f menampilkan 8 dan 10 digit di belakang titik supaya hasilnya sejajar seperti tabel.

Output:

aproks = 3.00000000   Ea = 0.1415926536  Er = 4.50703414%
aproks = 3.14000000   Ea = 0.0015926536  Er = 0.05069574%
aproks = 3.14200000   Ea = 0.0004073464  Er = 0.01296624%
aproks = 3.14285714   Ea = 0.0012644893  Er = 0.04024994%
aproks = 3.14159292   Ea = 0.0000002668  Er = 0.00000849%

Tabel 4. Ilustrasi Galat Absolut dan Relatif pada Aproksimasi π

Aproksimasi	Nilai	Galat Absolut	Galat Relatif
Bulat kasar	3.0	0.1415926536	4.5070%
Dua desimal	3.14	0.0015926536	0.0507%
Tiga desimal (lebih)	3.142	0.0004073464	0.0130%
Rasio 22/7	3.1428571429	0.0012644893	0.0402%
Rasio 355/113	3.1415929204	0.0000002668	0.0000085%

2. Amati bahwa 22/7 memiliki galat lebih besar daripada 3.142 meskipun pecahan itu tampak "alami", sedangkan 355/113, pecahan sederhana penemuan Zu Chongzhi, memberikan 7 digit benar berturut-turut. Pelajarannya: penampilan pecahan yang rapi tidak menjamin akurasi; besar galatnyalah yang menentukan.
3. Tuliskan Lesson Learnt mengapa galat relatif lebih informatif daripada galat absolut saat membandingkan aproksimasi besaran yang berbeda skala (mis. mengukur panjang jalan dalam km vs ketebalan rambut dalam mm).

Penjelasan: Galat absolut bergantung pada satuan, seperti kilometer atau milimeter, sehingga maknanya berubah kalau satuan diganti. Galat 1 mm fatal untuk komponen presisi, namun sepele untuk survei jalan. Galat relatif membebaskan pengukuran dari satuan (karena selisih dibagi besaran aslinya), sehingga menjadi tolok ukur kualitas aproksimasi yang adil untuk semua skala.

III.6. Task III: Catastrophic Cancellation

TASK III: DETEKSI DAN MENGATASI CATASTROPHIC CANCELLATION

Task ini memperlihatkan fenomena catastrophic cancellation pada floating point: pengurangan dua bilangan yang nyaris kembar.

1. Hitung $1-\cos (x)$ untuk $x={10}^{-8}$ dengan dua cara: langsung, dan melalui identitas setengah sudut $1-\cos (x)=2{\sin }^2(x/2)$:

import math

x = 1e-8
langsung = 1.0 - math.cos(x)          # cara langsung
bagus    = 2.0 * math.sin(x/2) ** 2   # identitas trigonometri
eksak    = x ** 2 / 2                 # pendekatan eksak: x^2/2

print("1 - cos(x)          =", langsung)
print("2 sin^2(x/2)        =", bagus)
print("eksak x^2/2         =", eksak)
print("galat relatif langsung =", abs(langsung - eksak) / eksak * 100, "%")
print("galat relatif bagus    =", abs(bagus - eksak) / eksak * 100, "%")

Cara membaca kode (bahasa awam):

• x = 1e-8 = notasi ilmiah untuk 0.00000001 (dibaca "satu dikali sepuluh pangkat minus delapan"); menulis 1e-8 jauh lebih singkat daripada menghitung jumlah nolnya.
• langsung = 1.0 - math.cos(x) = cara pertama: hitung cos(x) lebih dulu, baru kurangkan dari 1.0. Ini rumus "apa adanya" yang ternyata berbahaya secara numerik.
• bagus = 2.0 * math.sin(x/2) ** 2 = cara kedua: pakai identitas trigonometri $1-\cos (x)=2{\sin }^2(x/2)$ yang hasilnya sama persis di atas kertas. Tanda ** berarti pangkat, jadi sin(x/2) dikuadratkan.
• eksak = x ** 2 / 2 = nilai pembanding yang sangat dekat ke jawaban sejati (untuk x kecil berlaku $1-\cos (x)\approx x^2/2$).
• Empat baris pertama print = memajang ketiga hasil berdampingan supaya mudah dibandingkan.
• Dua baris print terakhir = menghitung galat relatif (dalam persen) tiap cara terhadap nilai eksak; semakin kecil angkanya, semakin tepat caranya.

Output:

1 - cos(x)          = 0.0
2 sin^2(x/2)        = 5.0000000000000005e-17
eksak x^2/2         = 5.0000000000000005e-17
galat relatif langsung = 100.0 %
galat relatif bagus    = 0.0 %

2. Perhatikan: nilai sejati $\approx 5\times {10}^{-17}$, namun cara langsung menghasilkan 0.0, artinya galat relatifnya 100% dan seluruh informasi hilang. Ini terjadi karena $\cos ({10}^{-8})$ sangat dekat ke 1 sehingga dibulatkan menjadi tepat 1.0; pengurangan $1-1$ kemudian menggugurkan semua angka penting. Rumusnya benar secara matematis, tetapi rawan secara numerik.
3. Visualisasikan fenomena ini pada rentang $x={10}^{-12}$ hingga ${10}^{-1}$:

Grafik memperlihatkan kurva identitas menempel pada kurva eksak $x^2/2$ di seluruh rentang, sementara kurva langsung "terkunci" pada nilai-nilai diskret ($0$, $1.1\times {10}^{-16}$, dst.) untuk $x<{10}^{-8}$; itulah bukti bahwa seluruh angka signifikan telah hilang.

4. Tuliskan Lesson Learnt: strategi apa yang dapat dilakukan ketika rumus fisika/matematika mengandung pengurangan dua bilangan hampir sama (petunjuk: rasionalisasi, identitas trigonometri, seri Taylor alternatif).

Penjelasan: Catastrophic cancellation tidak diakibatkan oleh kesalahan algoritma, melainkan oleh bentuk rumus. Dua rumus yang setara di atas kertas dapat berbeda nasib di dalam komputer. Programmer numerik yang baik memilih formulasi yang numerically stable: menghindari pengurangan bilangan yang besarnya sebanding, menjumlahkan dari bilangan terkecil, dan memanfaatkan identitas aljabar untuk menghindari titik rawan.

III.7. Task IV: Galat Pemotongan Deret

TASK IV: ANALISIS GALAT PEMOTONGAN DERET TAYLOR e^x

Sekarang kita berpindah dari galat yang dipaksakan perangkat (pembulatan) ke galat yang sengaja kita pilih sendiri (pemotongan), dan melihat bagaimana galat ini bisa kita kendalikan.

1. Implementasikan deret Maclaurin $e^x=\sum _{k=0}^{\mathrm{\infty }}\frac{x^k}{k!}$ yang dipotong pada suku ke-$n$:

import math

def taylor_exp(x, n):
    s = 0.0
    for k in range(n + 1):
        s += x ** k / math.factorial(k)
    return s

Cara membaca kode (bahasa awam):

• def taylor_exp(x, n): = membuat fungsi buatan sendiri bernama taylor_exp dengan dua masukan: titik x tempat kita menghitung $e^x$, dan n yaitu banyaknya suku deret yang dipakai (makin besar n, makin teliti tetapi makin lama dihitung).
• s = 0.0 = menyiapkan "kotak penampung" hasil penjumlahan yang mula-mula kosong (berisi nol).
• for k in range(n + 1): = mengulang untuk k = 0, 1, 2, ..., n. Catatan: range(n + 1) berhenti sebelum angka n + 1, makanya kita menambah satu agar suku ke-n ikut terhitung.
• s += x ** k / math.factorial(k) = inti deretnya: tambahkan satu suku $\frac{x^k}{k!}$ ke kotak penampung. Tanda += artinya "tambahkan ke isi sebelumnya", x ** k adalah x pangkat k, dan math.factorial(k) menghitung k! = 1×2×...×k.
• return s = mengirim isi kotak penampung keluar dari fungsi supaya hasilnya bisa dicetak atau dipakai perhitungan lain.

2. Amati konvergensi aproksimasi terhadap nilai eksak math.exp(1.0):

x = 1.0
print(f"{'n':>3} {'aproks':>14} {'eksak':>14} {'Er (%)':>14}")
for n in [1, 2, 3, 5, 8, 10]:
    aproks = taylor_exp(x, n)
    Ea = abs(math.exp(x) - aproks)
    Er = Ea / math.exp(x) * 100
    print(f"{n:>3} {aproks:>14.10f} {math.exp(x):>14.10f} {Er:>14.8f}")

Cara membaca kode (bahasa awam):

• x = 1.0 = pengujian dilakukan di titik x = 1, sehingga target yang dicari adalah nilai e ≈ 2.71828...
• Baris print pertama = mencetak kepala tabel; kode :>3 dan :>14 membuat tiap judul kolom rata kanan dengan lebar tetap supaya tabelnya lurus rapi.
• for n in [1, 2, 3, 5, 8, 10]: = mencoba beberapa jumlah suku yang makin banyak; dengan begitu tren "makin banyak suku, makin dekat ke nilai eksak" bisa terlihat.
• math.exp(x) = nilai $e^x$ "resmi" dari Python yang kita perlakukan sebagai nilai eksak pembanding.
• Baris print terakhir = mencetak satu baris tabel untuk tiap n: jumlah suku, hasil hampiran, nilai eksak, dan galat relatifnya dalam persen.

Output:

  n         aproks          eksak         Er (%)
  1   2.0000000000   2.7182818285    26.42411177
  2   2.5000000000   2.7182818285     8.03013971
  3   2.6666666667   2.7182818285     1.89881569
  5   2.7166666667   2.7182818285     0.05941848
  8   2.7182787698   2.7182818285     0.00011252
 10   2.7182818011   2.7182818285     0.00000100

3. Setiap penambahan satu suku memperkecil galat dengan faktor yang semakin besar (karena faktorial tumbuh sangat cepat; ibarat menambah lapis cat, tiap lapisan baru menutup lubang yang tersisa). Pada $n=10$, galat relatif sudah di bawah ${10}^{-3}$%.
4. Tuliskan Lesson Learnt mengenai trade-off antara jumlah suku (biaya komputasi) dan akurasi, serta mengapa galat pemotongan dapat dikendalikan oleh pemrogram berbeda dengan galat pembulatan yang melekat pada perangkat.

III.8. Kesimpulan Praktikum

Tabel 6. Ringkasan Perbandingan Galat Pembulatan dan Galat Pemotongan

Aspek	Galat Pembulatan	Galat Pemotongan
Sumber	Representasi floating point berhingga	Pemangkasan proses matematis tak hingga
Bergantung pada	Perangkat (presisi IEEE 754)	Pilihan algoritma (jumlah suku/langkah)
Perilaku saat langkah ditambah	Menumpuk / membesar	Menurun (konvergen)
Cara meminimalkan	Rumus stabil, presisi lebih tinggi, Kahan summation	Tambah suku / perkecil langkah $h$
Batas bawah	$\epsilon \approx 2.22\times {10}^{-16}$ (double)	Sekecil apa pun (hingga kena galat pembulatan)

Dari seluruh task dapat disimpulkan bahwa: (1) komputer tidak pernah menyimpan bilangan riil secara persis, sehingga setiap hasil komputasi wajib dibaca dengan kesadaran akan galat; (2) galat relatif adalah ukuran akurasi yang lebih objektif daripada galat absolut karena tidak dipengaruhi satuan; (3) rumus yang setara secara analitik belum tentu setara secara numerik, sehingga pemilihan formulasi yang stabil menentukan mutu hasil; dan (4) galat pemotongan dan galat pembulatan bergerak berlawanan arah, sehingga setiap metode numerik memiliki titik keseimbangan optimum yang akan dijumpai berulang kali pada modul-modul selanjutnya.

III.9. Tugas Praktikum

Kerjakan soal berikut pada notebook yang sama, kemudian kumpulkan sesuai mekanisme pada BAGIAN IV. Kunci jawaban tersedia pada dosen/tim praktikum dan dibahas pada pertemuan berikutnya.

1. Analisis aproksimasi π. Hitunglah galat absolut dan galat relatif (dalam persen) dari tiga aproksimasi berikut: $\pi \approx 3.1415$, $\pi \approx 22/7$, dan $\pi \approx 355/113$. Gunakan math.pi sebagai nilai sejati. Manakah aproksimasi terbaik? Tunjukkan perhitungan Anda dalam bentuk tabel.
2. Akumulasi galat pembulatan. Jumlahkan bilangan 0.01 sebanyak 100.000 kali dalam tipe np.float32 (gunakan np.full(100000, 0.01, dtype=np.float32) lalu .sum(dtype=np.float32)) dan bandingkan dengan penjumlahan yang sama dalam tipe float64. Hitung galat relatif keduanya terhadap nilai eksak 1000.0. Mengapa hasil float32 menyimpang cukup jauh sedangkan float64 nyaris tepat?
3. Catastrophic cancellation. Untuk $x={10}^{-6}$, hitung $1-\cos (x)$ dengan cara langsung dan dengan identitas $2{\sin }^2(x/2)$, lalu bandingkan keduanya dengan nilai eksak $x^2/2$. Hitung galat relatif masing-masing dan jelaskan penyebab perbedaannya.
4. Menentukan jumlah suku deret. Dengan fungsi taylor_exp(x, n) dari Task IV, tentukan banyaknya suku minimum $n$ agar aproksimasi $e^2$ memiliki galat relatif lebih kecil dari ${10}^{-10}$. Tuliskan program perulangan pencarian $n$ tersebut beserta output-nya.

III.10. Soal Latihan HOTS (Pengayaan)

Soal-soal berikut melatih kemampuan berpikir tingkat tinggi (Higher Order Thinking Skills, HOTS): menganalisis (C4), mengevaluasi (C5), dan mencipta (C6). Kerjakan mandiri atau berkelompok kecil. Soal ini tidak wajib dikumpulkan, tetapi akan dibahas bersama pada pertemuan berikutnya. Petunjuk: mulailah dari percobaan kecil di notebook, catat hasilnya, lalu tarik kesimpulan.

1. [C4 Analisis] Detektif pecahan. Pecahan 22/7 dan 355/113 sama-sama terkenal sebagai hampiran π, tetapi 355/113 jauh lebih akurat. Analisislah mengapa hal ini bisa terjadi dengan membandingkan galat relatif keduanya terhadap nilai eksak. Jelaskan pula dengan bahasa awam mengapa pecahan berpenyebut besar cenderung (tetapi tidak selalu) lebih akurat, dan kapan dugaan itu bisa keliru.
2. [C4 Analisis] Kisah roket Ariane 5. Pada tahun 1996 roket Ariane 5 meledak belasan detik setelah peluncuran karena sebuah angka yang aman di komputer 64-bit dikonversi ke ruang 16-bit sehingga meluap (overflow). Pelajari kasus tersebut dari sumber tepercaya, kemudian jelaskan kaitannya dengan materi galat representasi pada modul ini: di titik mana persisnya angka "tidak muat", dan mengapa pengujian ulang perangkat lunak tidak menangkapnya? Tuliskan kesimpulan satu paragraf.
3. [C5 Evaluasi] Menilai saran teman. Seorang teman berpendapat: "Kalau ingin membandingkan dua bilangan float, bulatkan saja keduanya dengan round(x, 2) lalu bandingkan dengan ==." Evaluasilah pendapat itu: buat satu contoh kasus di mana saran ini berhasil dan satu contoh kasus di mana saran ini gagal atau justru menyesatkan (petunjuk: angka yang sangat besar, sangat kecil, atau dua angka yang berbeda tipis di digit ketiga). Berikan rekomendasi praktik pembandingan yang lebih aman beserta alasannya.
4. [C5 Evaluasi] Memilih rumus yang stabil. Diberikan persamaan kuadrat $x^2-{10}^{8}x+1=0$ yang memiliki satu akar besar dan satu akar sangat kecil (sekitar ${10}^{-8}$). Hitung akar kecil tersebut dengan rumus abc secara langsung, lalu bandingkan dengan rumus alternatif $x_{kecil}=c/(a\cdot x_{besar})$. Evaluasi galat relatif kedua cara, putuskan rumus mana yang layak dipakai, dan jelaskan alasannya memakai konsep catastrophic cancellation.
5. [C6 Mencipta] Merancang eksperimen epsilon sendiri. Rancang dan jalankan eksperimen untuk menjawab: berapa epsilon mesin tipe np.float32, dan bagaimana perbandingannya dengan float64? Aturannya, Anda tidak boleh menyalin pola bagi dua dari modul; gunakan strategi lain (misalnya membagi suatu bilangan dengan tiga berulang kali, atau memanfaatkan np.nextafter). Sajikan hasil dalam tabel dan grafik batang berskala logaritmik, lalu jelaskan makna kedua angka tersebut bagi praktikan.
6. [C6 Mencipta] Fungsi penjumlahan stabil. Buatlah fungsi rata_rata_stabil(data) yang menghitung rata-rata dengan strategi yang tahan terhadap galat pembulatan (misalnya mengurutkan data dari terkecil ke terbesar sebelum dijumlahkan, atau menerapkan penjumlahan Kahan). Buktikan keunggulannya dengan data uji [1e16, 1.0, -1e16, 1.0] dibandingkan penjumlahan biasa sum(data), dan jelaskan dengan bahasa awam mengapa urutan penjumlahan bisa mengubah hasil.
7. [C5 Evaluasi] Kapan menambah suku menjadi sia-sia? Pada Task IV, galat memotongan mengecil saat suku ditambah. Perluas eksperimen hingga $n=30$ dan amati apakah galat terus mengecil atau justru berhenti mengecil di sekitar batas tertentu. Evaluasilah: pada n berapa penambahan suku berikutnya praktis tidak lagi memberi manfaat, dan apa kaitan titik berhentinya itu dengan epsilon mesin? Kemukakan juga implikasinya jika $x$ diperbesar menjadi 10 atau 100.

---

BAGIAN IV. MEDIA DAN MEKANISME PENGUMPULAN

IV.1. Media Pengumpulan

Media pengumpulan menggunakan Microsoft Teams (MS Teams) yang dapat diakses pada link berikut:

https://teams.microsoft.com

Kemudian masuk ke dalam Tim (Team) khusus untuk mata kuliah Komputasi Numerik.

IV.2. Mekanisme Pengumpulan

Mekanisme proses pengumpulan untuk modul praktikum ini mengikuti tahapan berikut:

1. Format penamaan notebook/berkas: gunakan format standar berikut.

   Tabel 2. Standar Penamaan Proyek dan Berkas Pengumpulan Praktikum Komputasi Numerik

   Kode	Penjelasan
   KN2026	Komputasi Numerik tahun 2026
   5A/5B	Kelas
   D4	Prodi D-4 Sarjana Terapan
   2024	Angkatan
   Modul1	Nomor Modul
   001	3 Digit NIM Terakhir

   Format berkas: [KN2026_5A_D4_2024]_Modul1_001.ipynb

2. Ekspor notebook Google Colab/Jupyter menjadi berkas .ipynb (File → Download → Download .ipynb). Apabila diperlukan, lampirkan juga hasil output dalam format .pdf atau .html.

3. Susun Laporan Praktikum (.pdf) yang mencakup:

   • Tangkapan layar (screenshot) notebook dan output yang dihasilkan.
   • Code snippet Python (Task 0, I, II, III, IV) beserta penjelasan fungsinya.
   • Analisis hasil eksekusi (Lesson Learnt) untuk tiap task.
   • Jawaban Tugas Praktikum (III.9).

4. Kompresi seluruh berkas menjadi satu arsip .zip dengan nama [KN2026_5A_D4_2024]_Modul1_001.zip.

5. Unggah arsip tersebut pada slot Tugas (Assignment) "Pengumpulan Praktikum Modul 1" di Microsoft Teams sebelum batas waktu berakhir.

---

BAGIAN V. PEMBAHASAN DAN EVALUASI HASIL PRAKTIKUM

Penilaian pada praktikum berdasarkan kriteria berikut:

Tabel 7. Rubrik dan Matriks Kriteria Penilaian Evaluasi Praktikum

Kriteria Penilaian	Skor ≥ 80 (A)	Skor 70–79.99 (AB/B)	Skor 60–69.99 (BC/C)	Skor < 60 (D/E)
Setup Environment (10%)	Python/Colab, NumPy & Matplotlib terkonfigurasi sempurna tanpa kendala eksekusi.	Environment terkonfigurasi, terdapat masalah minor yang berhasil diatasi.	Setup kurang, memerlukan bantuan untuk menjalankan cell/notebook.	Environment gagal dikonfigurasi / kode tidak dapat berjalan.
Galat Pembulatan & Epsilon Mesin (22.5%)	Mampu mendemonstrasikan fenomena 0.1+0.2, menjelaskan representasi floating point, dan menemukan epsilon mesin dengan benar.	Demonstrasi berjalan namun penjelasan konsep floating point kurang mendalam.	Hanya sebagian demonstrasi berhasil; konsep epsilon mesin keliru.	Gagal mendemonstrasikan galat pembulatan.
Galat Absolut & Relatif (22.5%)	Perhitungan Ea dan Er tepat untuk semua aproksimasi, interpretasi hasil kritis dan tepat.	Perhitungan tepat namun interpretasi kurang lengkap.	Terdapat kesalahan perhitungan pada sebagian aproksimasi.	Perhitungan galat salah total / tidak dikerjakan.
Cancellation & Galat Pemotongan (25%)	Membuktikan cancellation 100% dengan benar, menawarkan solusi identitas, dan analisis konvergensi deret tajam.	Fenomena terbukti namun analisis penyebab kurang mendalam.	Hanya menjalankan kode tanpa mampu menjelaskan fenomena.	Gagal membuktikan kedua fenomena.
Pelaporan & Lesson Learnt (20%)	Laporan sangat lengkap: screenshot, analisis kode, lesson learnt mendalam, dan jawaban tugas benar semua.	Laporan lengkap dengan screenshot dan penjelasan kode standar.	Laporan kurang detail, sebagian lesson learnt tidak dicantumkan.	Tidak mengumpulkan laporan / tidak sesuai format.

---

DAFTAR PUSTAKA

Burden, R. L., & Faires, J. D. (2011). Numerical Analysis (9th ed.). Brooks/Cole, Cengage Learning.

Chapra, S. C., & Canale, R. P. (2015). Numerical Methods for Engineers (7th ed.). McGraw-Hill Education.

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., et al. (2020). Array programming with NumPy. Nature, 585(7825), 357–362. https://doi.org/10.1038/s41586-020-2649-2

Munir, R. (2021). Metode Numerik (Edisi Revisi). Informatika, Bandung.

LAMPIRAN

Jika Ada