Sistem Persamaan Linear

Menyelesaikan A*x = b adalah pekerjaan paling sering dipercayakan ke MATLAB — dari rangkaian listrik sampai regresi data. Satu operator menjadi pusatnya: backslash A\b, yang tahu membaca bentuk sistem dan memilih strategi sendiri: LU untuk matriks persegi, QR least squares untuk sistem berlebih persamaan, dan solusi basic untuk sistem kekurangan persamaan. Chapter ini membedakan ketiga wujud sistem tersebut, memperlihatkan apa yang terjadi ketika matriks singular, dan menimbang A\b melawan inv(A)*b. Cakupan chapter ini:

• Sistem persegi 3×3 dengan verifikasi solusi
• Sistem over-determined dan least squares otomatis
• Sistem under-determined dan keluarga solusi tak hingga
• Peringatan matriks singular
• A\b vs inv(A)*b, serta pengenalan linsolve

A\b: Solusi Utama #

Aturannya: x = A\b menyelesaikan A*x = b untuk bentuk sistem apa pun. Mekanismenya: MATLAB memeriksa struktur A — untuk matriks persegi umum, solver menjalankan faktorisasi LU dengan pivoting, lalu mensubstitusi maju-mundur; tidak pernah ada pembagian eksplisit dan tidak ada inverse yang dihitung. Contoh sistem tiga persamaan:

2x + y + z = 7
 x + 3y + 2z = 13
 x           = 1

A = [2 1 1; 1 3 2; 1 0 0];
b = [7; 13; 1];
x = A \ b;
fprintf('x       : %g %g %g\n', x);
fprintf('cek A*x : %g %g %g\n', A * x);
xl = linsolve(A, b);
fprintf('linsolve setara: %d\n', max(abs(x - xl)) < 1e-12);

Output yang Dihasilkan:

x       : 1 2 3
cek A*x : 7 13 1
linsolve setara: 1

Solusinya x = 1, y = 2, z = 3, dan verifikasi A*x kembali tepat ke [7; 13; 1] — kebiasaan wajib setiap kali menyelesaikan sistem. Fungsi linsolve(A, b) memberi hasil identik; fungsi ini berguna saat kita mau memberi tahu solver bahwa A sudah pasti persegi (lewat opsi struktur), sehingga pemeriksaan bentuk bisa dilewati.

Over-Determined: Least Squares Otomatis #

Masalah nyata: menarik garis lewat data (1, 2), (2, 3), (3, 5), (4, 6) — empat titik, dua parameter (intersep dan slope), sistem 4×2 tidak punya solusi eksak. Aturannya: untuk matriks tall (baris > kolom), A\b otomatis mengembalikan solusi least squares — vektor yang meminimalkan ‖A*x − b‖. Mekanismenya: solver memfaktorkan A = QR lalu menyelesaikan masalah minimisasi lewat properti ortogonal Q, tanpa kita menyentuh rumus normal A'*A sama sekali:

Ao = [1 1; 1 2; 1 3; 1 4];   % kolom 1 = intersep, kolom 2 = x
bo = [2; 3; 5; 6];           % data y pada x = 1..4
xo = Ao \ bo;
fprintf('intersep : %g, slope : %g\n', xo);
fprintf('residual : %g %g %g %g\n', Ao * xo - bo);
fprintf('norm resid: %g\n', norm(Ao * xo - bo));

Output yang Dihasilkan:

intersep : 0.5, slope : 1.4
residual : -0.1 0.3 -0.3 0.1
norm resid: 0.447214

Garis terbaiknya y = 0.5 + 1.4x. Residual per titik (-0.1, 0.3, -0.3, 0.1) tidak nol — memang tidak ada garis yang melalui keempat titik — tetapi jumlah kuadratnya (0.2) sekecil mungkin; itulah makna norm residual 0.447214 = √0.2. regresi linear di Statistics Toolbox dibangun di atas mekanisme yang sama.

Under-Determined: Keluarga Solusi Tak Hingga #

Kebalikannya: dua persamaan, tiga variabel — kekurangan informasi. Aturannya: A\b untuk matriks wide (baris < kolom) mengembalikan satu solusi basic (banyak komponen nol), tetapi solusi sebenarnya tak hingga banyaknya. Mekanismenya: selisih dua solusi mana pun berada di ruang nol A — vektor n dengan A*n = 0 — sehingga dari satu solusi x0, seluruh keluarga x0 + t*n valid untuk nilai t berapa pun:

Au = [1 2 3; 4 5 6];
bu = [6; 15];
x0  = [0; 3; 0];       % satu solusi eksak
nul = [1; -2; 1];      % vektor ruang nol: Au*nul = 0
fprintf('Au*x0   : %g %g\n', Au * x0);
fprintf('Au*nul  : %g %g\n', Au * nul);
x1 = x0 + 0.5 * nul;   % solusi lain dari keluarga tak hingga
fprintf('Au*x1   : %g %g\n', Au * x1);
fprintf('resid x0 & x1 : %g %g\n', norm(Au*x0 - bu), norm(Au*x1 - bu));

Output yang Dihasilkan:

Au*x0   : 6 15
Au*nul  : 0 0
Au*x1   : 6 15
resid x0 & x1 : 0 0

Mari kita bedah baris-baris kode di atas:

1. Baris 4 (x0 = [0; 3; 0]): substitusi membuktikan Au*x0 = [6; 15] — satu anggota keluarga solusi (bentuk dengan komponen pertama dan ketiga nol).
2. Baris 5 (nul = [1; -2; 1]): Au*nul = [0; 0] — vektor ruang nol; menggeser solusi sepanjang arah ini tidak mengubah ruas kiri.
3. Baris 9 (x1 = x0 + 0.5*nul): [0.5; 2; 0.5] juga menyelesaikan sistem (residual 0) — dua solusi berbeda untuk sistem yang sama, bukti langsung ketidaktunggalan.

Matriks Singular: Peringatan #

Ketika kolom-kolom A dependen dan b tidak berada di ruang kolomnya, sistem tidak punya solusi sama sekali. MATLAB merespons dengan peringatan (bukan galat) di Command Window:

Warning: Matrix is singular to working precision.

Nilai x yang dikembalikan berisi Inf atau NaN. Pemeriksaan pencegah yang murah sebelum menyelesaikan: rank(A) terhadap ukuran, atau rcond(A) yang jatuh mendekati nol. Kasus “hampir singular” lebih berbahaya lagi — tidak ada peringatan, tetapi solusinya tidak bisa dipercaya; itulah topik bagian berikutnya.

A\b vs inv(A)*b, dan Sensitivitas Solusi #

Dua jalur menghasilkan jawaban yang “secara teori sama”. Dalam praktik, A\b unggul: kerja komputasinya lebih sedikit (satu faktorisasi alih-alih inverse penuh), dan galat pembulatannya lebih kecil. Justru karena keduanya dekat, perbedaan yang terasa muncul bukan dari jalurnya melainkan dari kondisi matriksnya:

Ak = [1 1; 1 1+1e-10];
fprintf('cond(Ak): %g\n', cond(Ak));
xk  = Ak \ [2; 2];
xkp = Ak \ [2; 2+1e-10];
fprintf('x  (b =[2;2]        ): %g %g\n', xk);
fprintf('xp (b =[2;2+1e-10]  ): %g %g\n', xkp);
xinv = inv(Ak) * [2; 2];
fprintf('inv path (b =[2;2]  ): %g %g\n', xinv);

Output yang Dihasilkan:

cond(Ak): 4e+10
x  (b =[2;2]        ): 2 0
xp (b =[2;2+1e-10]  ): 1 1
inv path (b =[2;2]  ): 2 0

Ruas kanan bergeser hanya 1e-10 — relatif terhadap ‖b‖ ≈ 2 perubahan ini 5×10⁻¹¹, nyaris di level pembulatan double — tetapi solusinya berubah total dari [2; 0] menjadi [1; 1]. Pembesaran ini konsisten dengan cond(Ak) ≈ 4e10: galat input dapat membesar hingga sepuluh digit. Perhatikan pula inv(Ak)*b mengembalikan nilai yang sama dengan A\b — matriks yang ill-conditioned tidak jadi aman hanya karena kita memilih operator yang “benar”; solusi sensitif adalah sifat masalahnya, bukan sifat operatornya.

Ringkasan #

A\b adalah pintu satu masuk untuk semua bentuk sistem: solusi unik untuk matriks persegi, least squares otomatis untuk sistem over-determined, dan solusi basic untuk under-determined — semuanya tanpa inverse. Sistem under-determined punya keluarga solusi di ruang nol; matriks singular memicu peringatan Matrix is singular yang jangan diabaikan. Sensitivitas solusi dikendalikan cond(A), bukan pilihan A\b atau inv; keduanya sama-sama mewarisi masalah matriks yang sakit. Kode yang efisien untuk semua ini jarang berbentuk loop eksplisit — cara berpikir MATLABnya kita bahas di chapter Vectorization.