Inverse Matriks

Pada bilangan biasa, setiap angka bukan nol punya pasangan yang membatalkannya lewat perkalian: 5 berpasangan dengan 1/5, dan 5 × (1/5) = 1. Matriks persegi punya padanan persis. Bila A bisa dipasangkan dengan matriks yang memenuhi A @ A⁻¹ = A⁻¹ @ A = I (matriks identitas), maka A⁻¹ disebut inverse dari A, dan A disebut invertible.

Bab ini menghitung inverse dengan np.linalg.inv, memverifikasi sifat dasarnya, memperlihatkan matriks yang inverse-nya tidak ada, lalu menjawab pertanyaan praktis: untuk menyelesaikan Ax = b, mengapa solve lebih disukai daripada inv?

Menghitung Inverse dengan np.linalg.inv #

Kita memakai matriks yang sudah akrab dari section Operasi Matriks, A = [[1, 2], [3, 4]]. Untuk matriks 2x2, inverse punya rumus tertutup: tukar kedua elemen diagonal utama, beri tanda negatif pada dua elemen lainnya, lalu bagi semuanya dengan determinant ad - bc. Dengan det(A) = -2, hasilnya bisa kita duga: [[-2, 1], [1.5, -0.5]]. Fungsi np.linalg.inv menempuh prinsip yang sama (lewat dekomposisi LU) tetapi berlaku untuk matriks berukuran berapa pun.

import numpy as np

A = np.array([[1.0, 2.0],
              [3.0, 4.0]])
A_inv = np.linalg.inv(A)
print(A_inv)

Output yang Dihasilkan:

[[-2.   1. ]
 [ 1.5 -0.5]]

Baris demi baris:

1. Baris 3-4 (A = ...): matriks persegi 2x2 dengan entri float64.
2. Baris 5 (A_inv = np.linalg.inv(A)): fungsi inv memfaktorisasi A, menghitung inverse lewat rutin LAPACK, dan mengembalikan matriks baru berbentuk sama (2, 2). Array A tidak berubah.
3. Baris 6 (print(A_inv)): hasilnya cocok dengan dugaan rumus 2x2 — diagonal utama bertukar posisi (1 dan 4 menjadi -2 dan -0.5), dua entri lainnya berganti tanda, dan seluruhnya dibagi -2.

Verifikasi AA⁻¹ = I #

Definisi inverse mengatakan A @ A_inv harus menghasilkan matriks identitas I. Karena seluruh perhitungan berjalan di float64, kita menguji dengan toleransi, bukan kesetaraan persis.

import numpy as np

A = np.array([[1.0, 2.0],
              [3.0, 4.0]])
A_inv = np.linalg.inv(A)
identitas = A @ A_inv
print(identitas)
print("array_equal:", np.array_equal(identitas, np.eye(2)))
print("allclose   :", np.allclose(identitas, np.eye(2)))

Output yang Dihasilkan:

[[1.0000000e+00 0.0000000e+00]
 [8.8817842e-16 1.0000000e+00]]
array_equal: False
allclose   : True

Hasil kali itu hampir identitas, tetapi tidak persis: entri kiri bawah bernilai 8.88e-16, bukan 0. Angka sekecil itu adalah sisa pembulatan float64 yang tak terhindarkan. Karena itu np.array_equal (yang menuntut persis) mengembalikan False, sementara np.allclose (yang menoleransi selisih di kisaran 1e-8) mengembalikan True. Pola verifikasi inilah yang dipakai di seluruh komputasi numerik — lihat Floating Point Comparison.

Matriks Singular: Inverse Tidak Ada #

Tidak semua matriks bisa dibalik. Perhatikan S = [[1, 2], [2, 4]]: baris keduanya tepat 2 kali baris pertamanya, sehingga informasi yang dibawa baris kedua tidak menambah apa pun. Matriks seperti ini disebut singular. Apa yang dilakukan np.linalg.inv padanya?

import numpy as np

S = np.array([[1.0, 2.0],
              [2.0, 4.0]])
try:
    np.linalg.inv(S)
except np.linalg.LinAlgError as e:
    print("LinAlgError:", e)

Output yang Dihasilkan:

LinAlgError: Singular matrix

np.linalg.inv tidak mengembalikan nan atau array aneh; fungsi tersebut melempar exception np.linalg.LinAlgError dengan pesan “Singular matrix”. Menangkap exception ini penting ketika matriks berasal dari data nyata yang bisa saja memuat baris redundan.

Mengapa solve Lebih Baik untuk Ax = b #

Untuk menyelesaikan Ax = b, menghitung inverse lalu mengalikan A⁻¹ @ b adalah jalan memutar: membuat inverse berarti menyelesaikan n sistem persamaan sekaligus, padahal yang diminta hanya satu; di atas itu, perkalian A⁻¹ @ b menambah satu tahap aritmetika yang menyisakan pembulatan baru. Fungsi solve langsung menuju x tanpa tahap perantara. Bandingkan langsung:

import numpy as np

A = np.array([[1.0, 2.0],
              [3.0, 4.0]])
b = np.array([5.0, 10.0])
x_solve = np.linalg.solve(A, b)
x_inv = np.linalg.inv(A) @ b
print("solve :", x_solve)
print("inv@b :", x_inv)
print("allclose:", np.allclose(x_solve, x_inv))

Output yang Dihasilkan:

solve : [0.  2.5]
inv@b : [4.4408921e-16 2.5000000e+00]
allclose: True

Kedua jalur menghasilkan jawaban yang setara dalam toleransi allclose, tetapi jalur inv@b meninggalkan sisa 4.44e-16 pada komponen pertama, sedangkan solve menghasilkan 0 persis. Pada matriks 2x2 selisih ini bisa diabaikan; pada sistem besar atau matriks dengan condition number yang buruk, selisih bisa membesar. Pembahasan mendalamnya ada di bab Stabilitas Numerik.

Ringkasan pemilihan fungsi: