MODUL PRAKTIKUM MATA KULIAH

KOMPUTASI NUMERIK

MODUL 4: SOLUSI SISTEM PERSAMAAN LANJAR (ELIMINASI DAN METODE ITERATIF)

JURUSAN TEKNIK KOMPUTER DAN INFORMATIKA

POLITEKNIK NEGERI BANDUNG

2026

---

LEMBAR PERSETUJUAN

SOLUSI SISTEM PERSAMAAN LANJAR (ELIMINASI DAN METODE ITERATIF)

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 ke hadirat Tuhan Yang Maha Esa, karena berkat karunia dan rida-Nya "SOLUSI SISTEM PERSAMAAN LANJAR (ELIMINASI DAN METODE ITERATIF)" telah selesai disusun.

Penyusunan "SOLUSI SISTEM PERSAMAAN LANJAR (ELIMINASI DAN METODE ITERATIF)" 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.

Linear system (sistem persamaan lanjar) adalah bahasa alami pemodelan rekayasa: analisis rangkaian listrik berbasis hukum Kirchhoff, distribusi gaya pada rangka bangunan, penyeimbangan reaksi kimia, hingga regresi kuadrat terkecil, semuanya bermuara pada satu bentuk yang sama, yaitu $\mathbf{Ax}=\mathbf{b}$. Modul 4 melatih mahasiswa menaklukkannya dari dua sisi. Direct method (metode langsung), yaitu Gaussian elimination (eliminasi Gauss) dengan partial pivoting (pivoting parsial) serta Gauss-Jordan, memberi jawaban dalam sejumlah langkah pasti. Iterative method (metode iteratif), yaitu Jacobi dan Gauss-Seidel, menyusuri menuju solusi langkah demi langkah dan unggul untuk sistem sangat besar yang sparse (jarang), sebagaimana dipakai pada simulasi teknik modern. Keduanya dipertemukan kembali pada satu pertanyaan yang sama: kapan memilih yang pasti, kapan memilih yang iteratif?

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: Sistem Persamaan Lanjar	6
III.2. Environment & Setup Praktikum	8
III.3. Task I: Eliminasi Gauss dengan Pivoting	9
III.4. Task II: Gauss-Jordan dan Matriks Invers	11
III.5. Task III: Metode Iteratif Jacobi dan Gauss-Seidel	13
III.6. Task IV: Dominansi Diagonal dan Kestabilan Iterasi	15
III.7. Kesimpulan Praktikum	17
III.8. Tugas Praktikum	18
III.9. Soal Latihan HOTS: Pemrograman ala Kompetisi (Kumulatif Modul 1 sampai 4)	19
BAGIAN IV. MEDIA DAN MEKANISME PENGUMPULAN	21
BAGIAN V. PEMBAHASAN DAN EVALUASI HASIL PRAKTIKUM	22
DAFTAR PUSTAKA	23
LAMPIRAN	24

DAFTAR GAMBAR

Gambar 1. Solution of Linear System (Solusi SPL) sebagai Perpotongan Garis

Gambar 2. Gaussian Elimination (Eliminasi Gauss): Menuju Matriks Segitiga Atas

Gambar 3. Convergence (Konvergensi) Jacobi vs Gauss-Seidel pada Matriks Diagonal-Dominan

Gambar 4. Divergence (Divergensi) Jacobi pada Matriks Tidak Diagonal-Dominan

DAFTAR TABEL

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

Tabel 2. Perbandingan Direct Method (Metode Langsung) dan Iterative Method (Metode Iteratif)

Tabel 3. Hasil Eliminasi Gauss dan Verifikasi

Tabel 4. Enam Iterasi Pertama Jacobi

Tabel 5. Enam Iterasi Pertama Gauss-Seidel

Tabel 6. Panduan Memilih Metode Penyelesaian SPL

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

Tabel 8. 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 solusi sistem persamaan lanjar untuk mata kuliah Komputasi Numerik, hingga mekanisme evaluasi. Baca BAGIAN II sebelum praktikum dimulai, kerjakan BAGIAN III secara berurutan dari Task I, lalu kumpulkan hasil pekerjaan sesuai BAGIAN IV.

I.2. Ruang Lingkup

Kegiatan mencakup implementasi Gaussian elimination (eliminasi Gauss) dengan strategi partial pivoting (pivoting parsial) dan back substitution (substitusi mundur), eliminasi Gauss-Jordan hingga bentuk reduced row echelon (eselon baris tereduksi) beserta kaitannya dengan matrix inverse (invers matriks), iterative method (metode iteratif) Jacobi dan Gauss-Seidel beserta syarat convergence (konvergensi) berupa diagonal dominance (dominansi diagonal), perbandingan jumlah iterasi kedua metode, serta eksperimen divergence (divergensi) pada matriks yang tidak diagonal-dominan.

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

Studi kasus utama adalah sistem 4 variabel yang bersumber dari analisis nodal rangkaian listrik. Mahasiswa menyelesaikannya dengan eliminasi Gauss, Gauss-Jordan, Jacobi, dan Gauss-Seidel, membandingkan jumlah iterasi kedua metode iteratif, lalu membuktikan pentingnya pivoting dan dominansi diagonal melalui eksperimen divergensi. Sebagai kasus geometris, solution (solusi) sistem 2×2 divisualisasikan sebagai perpotongan dua garis.

I.5. Konsep yang Digunakan

Linear System (Sistem Persamaan Lanjar): Bentuk umum $\mathbf{Ax}=\mathbf{b}$ dengan $\mathbf{A}$ matriks koefisien $n\times n$, $\mathbf{b}$ vektor konstanta, dan $\mathbf{x}$ vektor yang dicari. Solusi tunggal yang unik dijamin ada jika $det\mathbf{A}\ne 0$. Secara geometris, tiap persamaan adalah satu garis (atau bidang); solusi sistem adalah satu-satunya titik tempat semua garis bersepakat untuk bertemu.

Gaussian Elimination (Eliminasi Gauss): Mengubah $\mathbf{A}$ menjadi upper triangular matrix (matriks segitiga atas) $\mathbf{U}$ lewat elementary row operation (operasi baris elementer), lalu menyelesaikan dengan back substitution (substitusi mundur) dari baris terakhir ke baris pertama. Kompleksitas $O(n^3/3)$ operasi floating point. Ibarat barisan prajurit yang merapikan formasi menjadi segitiga: satu kolom demi satu kolom dibersihkan sampai tinggal baris atas yang berdiri.

Partial Pivoting (Pivoting Parsial): Menukar baris agar elemen pivot (elemen pembagi) bernilai absolut terbesar pada kolomnya, mencegah pembagian dengan bilangan mendekati nol yang memperbesar round-off error (galat pembulatan). Ini kelanjutan pelajaran Modul 1: membagi dengan bilangan nyaris nol itu seperti menimbang semangka memakai timbangan gram; skala alat tidak cocok dengan besaran yang diukur, dan hasilnya berantakan.

Gauss-Jordan dan Matrix Inverse (Invers Matriks): Melanjutkan eliminasi hingga bentuk reduced row echelon (eselon baris tereduksi), yaitu matriks identitas, sehingga solusi terbaca langsung pada kolom terakhir matriks augmented (terkembar). Jalur yang sama dipakai untuk menghitung ${\mathbf{A}}^{-1}$, meskipun dalam praktik numerik invers jarang dihitung eksplisit karena mahal dan kurang akurat.

Iterative Method (Metode Iteratif) dan Diagonal Dominance (Dominansi Diagonal): Pecah $\mathbf{A}=\mathbf{D}+\mathbf{L}+\mathbf{U}$ (diagonal, bawah, atas), lalu isolasi $x_i$ dari tiap baris dan iterasi. Jacobi memakai nilai iterasi lama untuk semua komponen, seperti rapat tim yang hanya boleh memakai laporan kemarin; Gauss-Seidel langsung memakai nilai terbaru yang sudah tersedia, seperti anggota tim yang saling update sepanjang hari. Keduanya dijamin konvergen bila $\mathbf{A}$ diagonal-dominan: $|a_{ii}|\ge \sum _{j\ne i}|a_{ij}|$ untuk semua baris; tanpa syarat itu, iterasi bisa divergence (divergen), menjauh dari solusi alih-alih mendekat.

---

BAGIAN II. PENYIAPAN PELAKSANAAN PRAKTIKUM (PREPARATION)

II.1. Peralatan Praktikum

Kebutuhan peralatan praktikum dapat dilihat pada daftar berikut:

Perangkat Keras (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).

Perangkat Lunak Sistem (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 (kontras/kecerahan) 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: Sistem Persamaan Lanjar

Sistem persamaan lanjar (SPL) $n$ variabel dapat ditulis ringkas sebagai $\mathbf{Ax}=\mathbf{b}$. Untuk $n=2$ dan $n=3$, solution (solusi) dapat divisualisasikan sebagai perpotongan garis dan bidang:

import numpy as np
import matplotlib.pyplot as plt

x = np.linspace(-1, 4, 200)
plt.figure(figsize=(8, 4.8))
plt.plot(x, (5 - x) / 2, lw=2, label="$x_1 + 2x_2 = 5$")
plt.plot(x, 5 - 3 * x, lw=2, label="$3x_1 + x_2 = 5$")
plt.plot([1], [2], "o", ms=10, color="tab:red", label="solusi (1, 2)")
plt.xlim(-1, 4)
plt.ylim(-2, 6)
plt.xlabel("$x_1$")
plt.ylabel("$x_2$")
plt.title("Solusi SPL sebagai perpotongan garis")
plt.legend()
plt.grid(True)
plt.show()

Cara membaca kode (bahasa awam):

• plt.plot(x, (5 - x) / 2) = menggambar garis pertama: dari persamaan $x_1+2x_2=5$, isolasi $x_2=(5-x_1)/2$, lalu plot terhadap rentang x.
• Titik merah = perpotongan kedua garis; itulah solusi sistem, satu titik yang memenuhi kedua persamaan sekaligus.

Tabel 2. Perbandingan Direct Method (Metode Langsung) dan Iterative Method (Metode Iteratif)

Aspek	Metode Langsung (Gauss, Gauss-Jordan)	Metode Iteratif (Jacobi, Gauss-Seidel)
Karakter hasil	Jawaban pasti dalam langkah berhingga	Mendekati solusi melalui iterasi
Jumlah operasi	Tetap, $O(n^3)$	Bergantung toleransi dan laju konvergensi
Kebutuhan memori	Padat $O(n^2)$	Bisa memanfaatkan struktur sparse (jarang)
Galat	Galat pembulatan menumpuk pada $n$ besar	Galat terkontrol lewat toleransi
Syarat khusus	Pivot ≠ 0 (aman dengan pivoting)	Konvergen bila diagonal-dominan / definit positif
Cocok untuk	Sistem kecil sampai menengah yang padat	Sistem sangat besar dan jarang (mis. PDE, jaringan besar)

Rumus inti iterative method (metode iteratif), yaitu untuk tiap baris $i$, isolasi $x_i$:

$$x_i^{(k+1)}=\frac{1}{a_{ii}}(b_i-\sum _{j<i}{a}_{ij}{x}_j^{(k+1)}-\sum _{j>i}{a}_{ij}{x}_j^{(k)})$$

Jacobi memakai nilai iterasi lama $x_j^{(k)}$ untuk seluruh penjumlahan; Gauss-Seidel memakai nilai terbaru $x_j^{(k+1)}$ untuk $j<i$ segera setelah tersedia. Perbedaan sekecil itu ternyata mengubah laju konvergensi secara drastis, sebagaimana akan dibuktikan pada Task III.

III.2. Environment & Setup Praktikum

Praktikum menggunakan Google Colab (direkomendasikan) atau Jupyter Notebook lokal dengan Python 3.10/3.11. Prosedur pembuatan notebook, anatomi sel notebook, dan verifikasi environment identik dengan Modul 1 (BAGIAN III.2). Pastikan import numpy as np dan import matplotlib.pyplot as plt berjalan tanpa galat.

III.3. Task I: Eliminasi Gauss dengan Pivoting

TASK I: ELIMINASI GAUSS + SUBSTITUSI MUNDUR

Task pembuka memakai metode paling mendasar: merapikan sistem menjadi segitiga lalu membacanya dari bawah ke atas.

1. Sistem uji:

$$\{\begin{array}{l}2x_1+x_2-x_3=8\\ -3x_1-x_2+2x_3=-11\\ -2x_1+x_2+2x_3=-3\end{array}$$

2. Implementasikan eliminasi Gauss lengkap dengan partial pivoting (pivoting parsial):

import numpy as np

def gauss_elim(A, b, verbose=True):
    A = A.astype(float).copy()
    b = b.astype(float).copy()
    n = len(b)
    for k in range(n - 1):                      # eliminasi maju
        p = np.argmax(np.abs(A[k:, k])) + k     # cari pivot terbesar
        if p != k:
            A[[k, p]] = A[[p, k]]               # tukar baris
            b[[k, p]] = b[[p, k]]
            if verbose: print(f"  tukar baris {k} <-> {p}")
        for i in range(k + 1, n):
            m = A[i, k] / A[k, k]               # faktor eliminasi
            A[i, k:] -= m * A[k, k:]
            b[i] -= m * b[k]
    x = np.zeros(n)                             # substitusi mundur
    for i in range(n - 1, -1, -1):
        x[i] = (b[i] - A[i, i+1:] @ x[i+1:]) / A[i, i]
    return x

A = np.array([[ 2.,  1., -1.],
              [-3., -1.,  2.],
              [-2.,  1.,  2.]])
b = np.array([8., -11., -3.])

x = gauss_elim(A, b)
print("solusi =", x)
print("cek np.linalg.solve:", np.linalg.solve(A, b))

Cara membaca kode (bahasa awam):

• A.astype(float).copy() = menyalin matriks ke tipe desimal; salinan dibuat agar matriks asli tidak ikut berubah saat dimanipulasi.
• for k in range(n - 1) = forward elimination (eliminasi maju): bersihkan kolom 0, lalu kolom 1, dan seterusnya sampai tersisa bentuk segitiga.
• p = np.argmax(np.abs(A[k:, k])) + k = inti pivoting: cari baris (mulai baris k ke bawah) yang elemen kolom k-nya paling besar nilai absolutnya, untuk dijadikan pivot (pembagi). Ukurannya mutlak karena yang penting jauh dari nol, bukan tandanya.
• A[[k, p]] = A[[p, k]] = trik penukaran dua baris sekaligus dalam satu ekspresi NumPy.
• m = A[i, k] / A[k, k] dan A[i, k:] -= m * A[k, k:] = kurangi baris ke-$i$ dengan kelipatan baris pivot supaya elemen kolom k menjadi nol; operasi dilakukan serentak pada sisa baris (vectorized operation, operasi tervesi).
• Loop for i in range(n - 1, -1, -1) = back substitution (substitusi mundur): dari baris terakhir yang hanya berisi satu variabel, naik ke atas sambil memanfaatkan hasil yang sudah dikenal; A[i, i+1:] @ x[i+1:] menghitung kontribusi variabel-variabel di kanannya.

Output:

  tukar baris 0 <-> 1
  tukar baris 1 <-> 2
solusi = [ 2.  3. -1.]
cek np.linalg.solve: [ 2.  3. -1.]

Tabel 3. Hasil Eliminasi Gauss dan Verifikasi: solusi $(2,3,-1)$ identik dengan np.linalg.solve yang di belakang layar memakai pustaka LAPACK; program kita melakukan dua kali penukaran baris karena pivot alami $a_{11}=2$ bukan yang terbesar pada kolomnya.

Visualisasikan efek eliminasi pada matriks:

U = A.astype(float).copy()
bb = b.astype(float).copy()
for k in range(2):
    p = np.argmax(np.abs(U[k:, k])) + k
    U[[k, p]] = U[[p, k]]
    bb[[k, p]] = bb[[p, k]]
    for i in range(k + 1, 3):
        m = U[i, k] / U[k, k]
        U[i, k:] -= m * U[k, k:]
        bb[i] -= m * bb[k]

fig, axes = plt.subplots(1, 2, figsize=(8.6, 4))
axes[0].imshow(A, cmap="RdBu_r")
axes[0].set_title("matriks A mula-mula")
axes[1].imshow(U, cmap="RdBu_r")
axes[1].set_title("setelah eliminasi maju")
for ax in axes:
    ax.set_xticks(range(3))
    ax.set_yticks(range(3))
    ax.grid(False)
fig.colorbar(axes[1].imshow(U, cmap="RdBu_r"), ax=axes, shrink=0.85)
plt.show()

imshow menggambar matriks sebagai peta warna: setelah eliminasi, area di bawah diagonal bernilai nol (warna netral), tanda sistem sudah berbentuk segitiga atas dan siap dibaca mundur.

3. Tuliskan Lesson Learnt: program melakukan dua kali penukaran baris karena pivot alami ($a_{11}=2$) bukan yang terbesar pada kolomnya. Tanpa pivoting, pembagian dengan pivot kecil membiaskan hasil dengan galat pembulatan; dengan pivoting, algoritma menjadi stabil untuk hampir semua sistem yang dipakai.

Penjelasan: Eliminasi Gauss mengubah sistem menjadi segitiga atas $\mathbf{Ux}=\mathbf{c}$ yang diselesaikan dari baris terakhir ke atas (substitusi mundur). Partial pivoting memilih elemen kolom bernilai absolut terbesar sebagai pivot; ini praktik wajib pada implementasi numerik sungguhan, termasuk di dalam LAPACK.

III.4. Task II: Gauss-Jordan dan Matriks Invers

TASK II: GAUSS-JORDAN HINGGA REDUCED ROW ECHELON

Jika eliminasi Gauss berhenti di bentuk segitiga, Gauss-Jordan melaju sampai garis finish: matriks identitas.

1. Gauss-Jordan melanjutkan eliminasi hingga matriks menjadi identitas:

def gauss_jordan(A, b):
    M = np.hstack([A.astype(float), b.reshape(-1, 1).astype(float)])
    n = len(b)
    for k in range(n):
        p = np.argmax(np.abs(M[k:, k])) + k
        M[[k, p]] = M[[p, k]]
        M[k] = M[k] / M[k, k]                   # normalisasi pivot = 1
        for i in range(n):
            if i != k:
                M[i] -= M[i, k] * M[k]          # lenyapkan di atas & bawah
    return M[:, -1]                             # kolom terakhir = solusi

x = gauss_jordan(A, b)
print("solusi =", x)

Cara membaca kode (bahasa awam):

• np.hstack([...]) = menyusun augmented matrix (matriks terkembar): matriks $\mathbf{A}$ dan vektor $\mathbf{b}$ direkatkan berdampingan agar operasi baris mengenai keduanya sekaligus.
• M[k] = M[k] / M[k, k] = normalisasi: bagi baris pivot dengan dirinya sendiri sehingga pivot menjadi tepat 1.
• for i in range(n): if i != k: M[i] -= M[i, k] * M[k] = membersihkan kolom k, baik di bawah maupun di atas diagonal; berbeda dengan Gauss yang hanya membersihkan bawah.
• return M[:, -1] = setelah semua kolom bersih, matriks menjadi identitas dan kolom terakhir langsung berisi solusi tanpa perlu substitusi mundur.

Output:

solusi = [ 2.  3. -1.]

2. Bandingkan dengan jalur inverse (invers); secara konsep $\mathbf{x}={\mathbf{A}}^{-1}\mathbf{b}$:

print("invers A:")
print(np.linalg.inv(A))

Output:

invers A:
[[ 4.  3. -1.]
 [-2. -2.  1.]
 [ 5.  4. -1.]]

3. Tuliskan Lesson Learnt: mengapa dalam praktik numerik kita jarang menghitung ${\mathbf{A}}^{-1}$ secara eksplisit? (petunjuk: biayanya sekitar tiga kali eliminasi Gauss dan galatnya lebih besar; np.linalg.solve memakai dekomposisi LU, bukan invers).

Penjelasan: Gauss-Jordan cocok saat kita butuh solusi untuk banyak vektor $\mathbf{b}$ sekaligus atau ingin menampilkan proses dalam bentuk paling sederhana, misalnya untuk pembelajaran. Untuk satu $\mathbf{b}$, eliminasi Gauss lebih hemat operasi.

III.5. Task III: Metode Iteratif Jacobi dan Gauss-Seidel

TASK III: JACOBI vs GAUSS-SEIDEL PADA SISTEM 4×4 DIAGONAL-DOMINAN

Metode langsung tadi menuntaskan sistem dalam langkah pasti; kini metode iteratif menyusuri menuju solusi, dan kita adu kecepatan dua jagoannya.

1. Sistem uji (klasik dari Burden & Faires); periksa dulu diagonal dominance (dominansi diagonalnya):

A = np.array([[10., -1.,  2.,  0.],
              [-1., 11., -1.,  3.],
              [ 2., -1., 10., -1.],
              [ 0.,  3., -1.,  8.]])
b = np.array([6., 25., -11., 15.])

for i in range(4):
    off = np.sum(np.abs(A[i])) - abs(A[i, i])
    print(f"baris {i+1}: |a_ii|={abs(A[i,i]):.0f} > jumlah off-diagonal={off:.0f} ?",
          abs(A[i, i]) > off)

Cara membaca kode (bahasa awam):

• off = np.sum(np.abs(A[i])) - abs(A[i, i]) = menjumlah nilai mutlak seluruh baris lalu mengurangi elemen diagonal; hasilnya adalah beban off-diagonal yang harus "dikalahkan" diagonal.
• Baris dikatakan diagonal-dominan bila elemen diagonalnya lebih besar dari beban tersebut; sistem aman untuk iteratif bila semua baris lolos.

Output:

baris 1: |a_ii|=10 > jumlah off-diagonal=3 ? True
baris 2: |a_ii|=11 > jumlah off-diagonal=5 ? True
baris 3: |a_ii|=10 > jumlah off-diagonal=4 ? True
baris 4: |a_ii|=8 > jumlah off-diagonal=4 ? True

2. Implementasikan kedua metode:

def jacobi(A, b, tol=1e-8, max_iter=100):
    A = A.astype(float); b = b.astype(float)
    n = len(b)
    x = np.zeros(n)
    for it in range(1, max_iter + 1):
        x_baru = np.zeros(n)
        for i in range(n):
            s = A[i, :i] @ x[:i] + A[i, i+1:] @ x[i+1:]
            x_baru[i] = (b[i] - s) / A[i, i]    # pakai x LAMA
        if np.linalg.norm(x_baru - x, np.inf) < tol:
            return x_baru, it
        x = x_baru
    return x, max_iter

def gauss_seidel(A, b, tol=1e-8, max_iter=100):
    A = A.astype(float); b = b.astype(float)
    n = len(b)
    x = np.zeros(n)
    for it in range(1, max_iter + 1):
        x_lama = x.copy()
        for i in range(n):
            s = A[i, :i] @ x[:i] + A[i, i+1:] @ x[i+1:]
            x[i] = (b[i] - s) / A[i, i]         # pakai x TERBARU
        if np.linalg.norm(x - x_lama, np.inf) < tol:
            return x, it
    return x, max_iter

xj, nj = jacobi(A, b)
xg, ng = gauss_seidel(A, b)
print("jacobi      : x =", xj, " iterasi =", nj)
print("gauss-seidel: x =", xg, " iterasi =", ng)
print("cek         :", np.linalg.solve(A, b))

Cara membaca kode (bahasa awam):

• s = A[i, :i] @ x[:i] + A[i, i+1:] @ x[i+1:] = kontribusi semua variabel kecuali $x_i$: irisan kiri (:i) dan kanan (i+1:) dijumlah terpisah lalu digabung; inilah rumus $x_i^{(k+1)}$ pada teori yang diterjemahkan ke slicing NumPy.
• Perbedaan kedua fungsi hanya satu: Jacobi menulis hasil ke wadah baru x_baru (seluruh pembaruan memakai potret kemarin), sedangkan Gauss-Seidel menimpa langsung x[i] (pembaruan di kiri langsung terpakai untuk variabel di kanannya dalam putaran yang sama).
• np.linalg.norm(x_baru - x, np.inf) = stopping criterion (kriteria penghentian): perubahan terbesar antar komponen; jika sudah di bawah toleransi, iterasi dinyatakan selesai.

Output:

jacobi      : x = [ 1.  2. -1.  1.]  iterasi = 24
gauss-seidel: x = [ 1.  2. -1.  1.]  iterasi = 10
cek         : [ 1.  2. -1.  1.]

3. Amati enam iterasi pertama masing-masing metode (dipangkas dari tabel iterasi lengkap):

Tabel 4. Enam Iterasi Pertama Jacobi

it	$x_1$	$x_2$	$x_3$	$x_4$
1	0.600000	2.272727	−1.100000	1.875000
2	1.047273	1.715909	−0.805227	0.885227
3	0.932636	2.053306	−1.049341	1.130881
4	1.015199	1.953696	−0.968109	0.973843
5	0.988991	2.011415	−1.010286	1.021351
6	1.003199	1.992241	−0.994522	0.994434

Tabel 5. Enam Iterasi Pertama Gauss-Seidel

it	$x_1$	$x_2$	$x_3$	$x_4$
1	0.600000	2.327273	−0.987273	0.878864
2	1.030182	2.036938	−1.014456	0.984341
3	1.006585	2.003555	−1.002527	0.998351
4	1.000861	2.000298	−1.000307	0.999850
5	1.000091	2.000021	−1.000031	0.999988
6	1.000008	2.000001	−1.000003	0.999999

Plot penurunan galat terhadap solusi eksak ${\mathbf{x}}^{\ast }=(1,2,-1,1)$:

x_star = np.array([1., 2., -1., 1.])

def jalur(metode, n):
    x = np.zeros(4)
    err = []
    for _ in range(n):
        if metode == "J":
            xb = np.zeros(4)
            for i in range(4):
                s = A[i, :i] @ x[:i] + A[i, i+1:] @ x[i+1:]
                xb[i] = (b[i] - s) / A[i, i]
            x = xb
        else:
            for i in range(4):
                s = A[i, :i] @ x[:i] + A[i, i+1:] @ x[i+1:]
                x[i] = (b[i] - s) / A[i, i]
        err.append(np.linalg.norm(x - x_star, np.inf))
    return err

plt.figure(figsize=(8, 4.8))
plt.semilogy(range(1, 25), jalur("J", 24), "o-", label="Jacobi")
plt.semilogy(range(1, 11), jalur("G", 10), "s-", label="Gauss-Seidel")
plt.xlabel("iterasi ke-k")
plt.ylabel(r"galat $\|x^{(k)} - x^*\|_\infty$")
plt.title("Konvergensi Jacobi vs Gauss-Seidel")
plt.legend()
plt.grid(True)
plt.show()

4. Tuliskan Lesson Learnt: Gauss-Seidel mencapai pola desimal stabil pada iterasi ke-4 sampai 5, sementara Jacobi masih bergoyang pada iterasi ke-6. Dengan informasi terbaru yang langsung dipakai, Gauss-Seidel konvergen kurang lebih dua kali lebih cepat pada kasus ini.

Penjelasan: Solusi eksak $\mathbf{x}=(1,2,-1,1)$. Kedua metode menuju solusi yang sama dan perbedaannya hanya laju. Keunggulan Gauss-Seidel ini berlaku umum untuk matriks diagonal-dominan, meskipun bukan jaminan mutlak untuk matriks sebarang (lihat Soal Latihan HOTS Problem F).

III.6. Task IV: Dominansi Diagonal dan Kestabilan Iterasi

TASK IV: EKSPERIMEN DIVERGENSI PADA MATRIKS TIDAK DIAGONAL-DOMINAN

Apa terjadi bila syarat diagonal dominance (dominansi diagonal) dilanggar? Task ini sengaja memacu metode iteratif tanpa sabuk pengaman.

1. Uji Jacobi pada matriks yang jelas tidak diagonal-dominan:

A2 = np.array([[1., 2.],
               [3., 1.]])
b2 = np.array([5., 5.])
print("solusi eksak:", np.linalg.solve(A2, b2))

x = np.zeros(2)
for it in range(14):
    xb = np.zeros(2)
    for i in range(2):
        s = A2[i, :i] @ x[:i] + A2[i, i+1:] @ x[i+1:]
        xb[i] = (b2[i] - s) / A2[i, i]
    x = xb
    print(f"iter {it+1:2d}: x = {x},  ||x-x*|| = {np.linalg.norm(x - [1., 2.], np.inf):.3e}")

Cara membaca kode (bahasa awam):

• Matriks A2 sengaja dibuat bandel: baris pertama ($1$ melawan $2$) dan baris kedua ($1$ melawan $3$) sama-sama kalah di diagonal, sehingga syarat iteratif dilanggar telak.
• Loop ini adalah Jacobi tanpa toleransi: tepat 14 putaran penuh agar ledakan galat terlihat evolusinya; ||x-x*|| mengukur jarak ke solusi eksak $(1,2)$ yang sudah diketahui di depan.

Output (dipangkas):

solusi eksak: [1. 2.]
iter  1: x = [5. 5.],  ||x-x*|| = 4.000e+00
iter  2: x = [ -5. -10.],  ||x-x*|| = 1.200e+01
iter  3: x = [25. 20.],  ||x-x*|| = 2.400e+01
...
iter 14: x = [-279935. -559870.],  ||x-x*|| = 5.599e+05

Visualisasikan ledakan galat:

A2 = np.array([[1., 2.], [3., 1.]])
b2 = np.array([5., 5.])
x = np.zeros(2)
errs = []
for _ in range(14):
    xb = np.zeros(2)
    for i in range(2):
        s = A2[i, :i] @ x[:i] + A2[i, i+1:] @ x[i+1:]
        xb[i] = (b2[i] - s) / A2[i, i]
    x = xb
    errs.append(np.linalg.norm(x - np.array([1., 2.]), np.inf))

plt.figure(figsize=(8, 4.8))
plt.semilogy(range(1, 15), errs, "o-", color="tab:red")
plt.xlabel("iterasi ke-k")
plt.ylabel(r"galat $\|x^{(k)} - x^*\|_\infty$")
plt.title("Divergensi Jacobi tanpa dominansi diagonal")
plt.grid(True)
plt.show()

Pada skala logaritmik, konvergensi tampak sebagai garis menurun; di sini garisnya menanjak tajam: galat membengkak setiap putaran, bukan menyusut.

2. Tuliskan Lesson Learnt: galat tidak mengecil melainkan meledak; iterasi menjadi tidak stabil (divergen). Solusi penyelamatan: (a) tukar urutan persamaan agar diagonal menjadi dominan; (b) gunakan metode langsung yang tidak mensyaratkan dominansi; atau (c) gunakan pelembut relaksasi (SOR). Selalu periksa dominansi diagonal sebelum menjalankan Jacobi atau Gauss-Seidel.

III.7. Kesimpulan Praktikum

Tabel 6. Panduan Memilih Metode Penyelesaian SPL

Situasi	Rekomendasi	Alasan
Sistem kecil sampai menengah yang padat	Eliminasi Gauss + pivoting	Langkah pasti, hasil terverifikasi, biaya $O(n^3)$ terjangkau
Banyak vektor $\mathbf{b}$ sekaligus atau butuh tampilan proses	Gauss-Jordan	Sekali kerja, semua kolom solusi selesai
Sistem sangat besar dan sparse (jarang)	Jacobi / Gauss-Seidel	Biaya per iterasi ringan, struktur jarang bisa dipertahankan
Diagonal dominan terpenuhi	Iteratif aman dijalankan	Syarat cukup konvergensi terpenuhi
Butuh akselerasi iteratif maksimum	SOR dengan $\omega$ tepat	Relaksasi mempercepat konvergensi bila dioptimasi
Kebutuhan produksi	np.linalg.solve (LAPACK, dekomposisi LU)	Dioptimasi puluhan tahun, teruji industri

Dari seluruh task dapat disimpulkan bahwa: (1) direct method (metode langsung), yaitu Gauss dan Gauss-Jordan, memberi solusi eksak-numerik dalam langkah pasti dan wajib dipasangi pivoting untuk kestabilan; (2) iterative method (metode iteratif), yaitu Jacobi dan Gauss-Seidel, menyusuri menuju solusi dengan biaya per iterasi ringan sehingga ekonomis untuk sistem besar dan jarang; (3) Gauss-Seidel umumnya konvergen lebih cepat karena langsung memakai nilai terbaru; (4) syarat aman metode iteratif adalah diagonal dominance (dominansi diagonal), dan tanpanya iterasi dapat divergen; serta (5) pustaka numerik produksi memakai keluarga eliminasi dengan dekomposisi LU yang telah dioptimasi, bukan invers eksplisit.

III.8. 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. Sistem 3×3. Selesaikan sistem berikut dengan eliminasi Gauss (implementasi Task I) dan Jacobi (toleransi ${10}^{-8}$), lalu laporkan jumlah iterasi Jacobi beserta penyebab konvergensinya relatif lambat:$$\{\begin{array}{l}3x_1+2x_2+x_3=10\\ x_1+4x_2+2x_3=12\\ 2x_1+x_2+5x_3=15\end{array}$$
2. Analisis nodal rangkaian listrik. Tiga node dalam suatu rangkaian menghasilkan sistem $\{\begin{array}{l}4V_1-V_2=15\\ -V_1+4V_2-V_3=10\\ -V_2+4V_3=10\end{array}$. Selesaikan dengan Jacobi dan Gauss-Seidel (toleransi ${10}^{-8}$), laporkan $V_1,V_2,V_3$, jumlah iterasi masing-masing, dan bandingkan kecepatannya.
3. Pivoting menyelamatkan. Bangun sistem $\{\begin{array}{l}{10}^{-20}{x}_1+x_2=1\\ x_1+x_2=2\end{array}$. Selesaikan dengan eliminasi Gauss tanpa pivoting (modifikasi program agar penukaran baris dimatikan) dan dengan pivoting. Bandingkan hasil keduanya terhadap solusi eksak $(1,1)$ dan jelaskan penyebab perbedaannya.
4. Sistem 4×4 dari model jaringan. Selesaikan $\{\begin{array}{l}5x_1+x_2-x_3=10\\ 2x_1+6x_2+x_4=12\\ -x_1+7x_3+x_4=14\\ x_2+2x_3+8x_4=16\end{array}$ dengan Gauss-Seidel, cek dominansi diagonalnya terlebih dahulu, dan verifikasi solusi dengan np.linalg.solve.

III.9. Soal Latihan HOTS: Pemrograman ala Kompetisi (Kumulatif Modul 1 sampai 4)

Soal-soal berikut ala kompetisi pemrograman: program Anda membaca masukan sesuai format, lalu mencetak keluaran persis seperti contoh. Latihan ini melatih kemampuan berpikir tingkat tinggi (HOTS) sekaligus merangkum materi Modul 1 (galat dan floating point), Modul 2 (deret Taylor), Modul 3 (pencarian akar), dan Modul 4 (sistem persamaan lanjar). Kerjakan mandiri di notebook; cocokkan keluaran program Anda dengan contoh keluaran yang diberikan (semua angka contoh telah diverifikasi dengan Python).

Problem A. Pivot Kecil [C4 Analisis · Modul 1 + 4]

Diberikan sistem $\epsilon x_1+x_2=1$ dan $x_1+x_2=2$ yang solusi eksaknya dekat ke $(1,1)$. Selesaikan dengan eliminasi Gauss tanpa pivoting dan dengan pivoting, lalu cetak kedua solusi.

Masukan: baris pertama $T$ ($1\le T\le 100$); $T$ baris berisi satu bilangan riil $\epsilon$ (${10}^{-20}\le \epsilon \le 1$).

Keluaran: untuk tiap kasus dua baris, tanpa: x1 x2 lalu dengan: x1 x2, masing-masing 6 desimal.

masukan:
3
1e-20
1e-8
0.5

keluaran:
tanpa: 0.000000 1.000000
dengan: 1.000000 1.000000
tanpa: 1.000000 1.000000
dengan: 1.000000 1.000000
tanpa: 2.000000 -0.000000
dengan: 2.000000 0.000000

Petunjuk: tambahkan parameter pivot=True/False pada gauss_elim Task I. Hanya $\epsilon$ sangat kecil yang menghancurkan versi tanpa pivoting; kaitkan dengan pelajaran galat pembulatan Modul 1 bahwa membagi dengan bilangan nyaris nol adalah bencana. (Tanda minus pada nol di kasus ketiga adalah artefak floating point yang menarik: hasil $0/(-1)$ dalam IEEE 754 memang bernilai nol bertanda negatif.)

Problem B. Dominan atau Bukan [C4 Analisis · Modul 4]

Tentukan apakah sebuah matriks diagonal-dominan dan berapa banyak barisnya yang lolos uji dominansi.

Masukan: baris pertama $n$ ($2\le n\le 50$); diikuti $n$ baris berisi $n$ bilangan riil (elemen matriks).

Keluaran: satu baris YES/NO k, dengan YES bila semua baris dominan, NO bila tidak, dan k banyaknya baris yang dominan.

masukan:
4
10 -1 2 0
-1 11 -1 3
2 -1 10 -1
0 3 -1 8

keluaran:
YES 4

masukan:
2
1 2
3 1

keluaran:
NO 0

Petunjuk: gunakan uji baris dari Task III; ingat bahwa toleransi ketat ($>$, bukan $\ge$) menentukan status tiap baris.

Problem C. Adu Iterasi [C5 Evaluasi · Modul 4]

Sistem tiga node dari analisis nodal rangkaian: $4V_1-V_2=15$, $-V_1+4V_2-V_3=10$, $-V_2+4V_3=10$. Jalankan Jacobi dan Gauss-Seidel dengan toleransi ${10}^{-8}$ dan maksimum 200 iterasi.

Masukan: tidak ada (program berjalan langsung pada sistem tetap di atas).

Keluaran: satu baris V1 V2 V3 (6 desimal), satu baris jacobi nj, satu baris gauss_seidel ng.

keluaran:
4.910714 4.642857 3.660714
jacobi 21
gauss_seidel 12

Petunjuk: sistem ini diagonal-dominan ketat sehingga keduanya pasti konvergen; yang dievaluasi adalah seberapa besar Gauss-Seidel memangkas jumlah iterasi dibanding Jacobi, dan mengapa (nilai terbaru langsung terpakai).

Problem D. Newton untuk Dua Persamaan [C5 Evaluasi · Modul 2 + 3 + 4]

Selesaikan sistem nonlinear $\{\begin{array}{l}{x}^2+y^2=4\\ e^{x/2}+y=1\end{array}$ dengan multivariate Newton: pada tiap langkah, bentuk Jacobian $2\times 2$, lalu selesaikan sistem lanjar $\mathbf{J}\mathbf{d}=-\mathbf{f}$ memakai gauss_elim dari Task I. Mulai dari $(1.5,-1.2)$; berhenti saat $\parallel \mathbf{d}{\parallel }_{\mathrm{\infty }}<{10}^{-10}$.

Masukan: tidak ada.

Keluaran: satu baris x y (10 desimal) dan satu baris iterasi n.

keluaran:
1.5894943738 -1.2138812279
iterasi 4

Petunjuk: inilah perjumpaan tiga modul: fungsi eksponensial dievaluasi deret Taylor (Modul 2), kerangka iterasi Newton (Modul 3), dan tiap langkahnya menuntaskan sistem lanjar (Modul 4). Sebagai eksperimen tambahan, mulai dari $(1,1)$ dan amati lompatan liar di awal: Newton sistem juga menuntut tebakan awal yang wajar.

Problem E. Sakit Kondisi [C5 Evaluasi · Modul 1 + 4]

Matriks Hilbert $H_{ij}=\frac{1}{i+j+1}$ tampak jinak tetapi terkenal ill-conditioned (sangat berkondisi buruk). Untuk tiap $n$, selesaikan $H\mathbf{x}=\mathbf{b}$ dengan $\mathbf{b}=H\cdot \mathbf{1}$ (solusi eksak semua satu), lalu laporkan condition number (bilangan kondisi) dan galat relatif solusi.

Masukan: baris pertama $T$; $T$ baris berisi satu bilangan bulat $n$ ($4\le n\le 12$).

Keluaran: untuk tiap kasus satu baris cond galat_relatif dalam notasi ilmiah 2 desimal.

masukan:
3
6
10
12

keluaran:
1.50e+07 2.39e-10
1.60e+13 1.69e-04
1.76e+16 6.96e-01

Petunjuk: gunakan np.linalg.cond(H) dan bandingkan solusi dengan vektor semua satu. Perhatikan keajaiban yang menipu: residual (sisa) $H\hat{x}-b$ nyaris nol padahal galat solusi besar; kaitkan dengan batas presisi floating point dari Modul 1.

Problem F. Pengecualian Aturan [C6 Mencipta · Modul 4]

Klaim populer menyatakan Gauss-Seidel selalu lebih cepat dari Jacobi. Ujilah pada matriks $\left(\begin{array}{ccc}1& 2& -2\\ 1& 1& 1\\ 2& 2& 1\end{array}\right)$ dengan $\mathbf{b}=(1,1,1)$: jalankan kedua metode (toleransi ${10}^{-8}$, maksimum 25 iterasi), deteksi status masing-masing.

Masukan: tidak ada.

Keluaran: dua baris, jacobi STATUS n dan gauss_seidel STATUS n, dengan STATUS bernilai CONVERGED atau DIVERGED.

keluaran:
jacobi CONVERGED 4
gauss_seidel DIVERGED 25

Petunjuk: matriks ini pengecualian terverifikasi dari literatur: radius spektral (spectral radius) matriks iterasi Jacobi bernilai 0, sedangkan milik Gauss-Seidel sekitar 4.83, sehingga Jacobi konvergen kilat sementara Gauss-Seidel meledak. Kesimpulan yang benar: Gauss-Seidel unggul pada kelas matriks yang umum (mis. diagonal-dominan), bukan pada semua matriks; tuliskan analisis singkatmu pada komentar program.

---

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 7. 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
   Modul4	Nomor Modul
   001	3 Digit NIM Terakhir

   Format berkas: [KN2026_5A_D4_2024]_Modul4_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.
   • Potongan kode (code snippet) Python (Task I, II, III, IV) beserta penjelasan fungsinya.
   • Analisis hasil eksekusi (Lesson Learnt) untuk tiap task.
   • Jawaban Tugas Praktikum (III.8).

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

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

---

BAGIAN V. PEMBAHASAN DAN EVALUASI HASIL PRAKTIKUM

Penilaian pada praktikum berdasarkan kriteria berikut:

Tabel 8. 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)
Eliminasi Gauss & Gauss-Jordan (30%)	Kedua metode benar, pivoting diimplementasikan, hasil diverifikasi dengan np.linalg.solve.	Kedua metode benar tanpa verifikasi menyeluruh.	Salah satu metode keliru / tanpa pivoting.	Kedua metode gagal.
Metode Iteratif (30%)	Jacobi & Gauss-Seidel benar, tabel iterasi lengkap, perbedaan laju dijelaskan.	Kedua metode benar, analisis laju permukaan.	Implementasi ada galat rumus.	Gagal mengimplementasikan metode iteratif.
Analisis Kestabilan (20%)	Eksperimen divergensi berhasil, syarat dominansi diagonal dijelaskan tepat.	Eksperimen berhasil, penjelasan kurang lengkap.	Eksperimen sebagian berjalan.	Tidak melakukan eksperimen divergensi.
Pelaporan & Lesson Learnt (20%)	Laporan sangat lengkap: screenshot, analisis kode, lesson learnt mendalam, 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.

Gerald, C. F., & Wheatley, P. O. (2004). Applied Numerical Analysis (7th ed.). Pearson.

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

LAMPIRAN

Jika Ada