Belajar Math - Determinant, Inverse & Sistem Persamaan Linear
Determinant 2×2 & 3×3, matrix inverse, dan Gaussian elimination untuk menyelesaikan Ax = b — konsep ini muncul dalam area/volume transformasi, dependency analysis, dan numeric stability yang kritis untuk numerical computing.
#Pendahuluan
Setelah di episode 17 kita mempelajari matriks — representasi 2D data, penjumlahan, dan perkalian — pada episode ini kita mempelajari tiga konsep kunci: determinant (mengukur "scaling factor" transformasi), matrix inverse (membalik operasi matriks), dan Gaussian elimination (menyelesaikan sistem persamaan linear). Ketiganya saling berkaitan dan membentuk fondasi numerical computing.
Mengapa ini penting? Karena menyelesaikan sistem persamaan linear Ax = b adalah masalah yang muncul di mana-mana: circuit analysis, structural engineering, machine learning (least squares), dan economics (input-output models). Memahami determinant memberikan intuisi tentang kapan solusi ada dan stabil.
#Determinant
#Definisi
Determinant adalah skalar yang dihasilkan dari matriks persegi — mengukur scaling factor dan apakah matriks invertible:
def det_2x2(M):
"""det([[a,b],[c,d]]) = ad - bc."""
return M[0][0] * M[1][1] - M[0][1] * M[1][0]
def det_3x3(M):
"""Determinant 3×3 menggunakan expansion cofactor."""
return (
M[0][0] * (M[1][1] * M[2][2] - M[1][2] * M[2][1])
- M[0][1] * (M[1][0] * M[2][2] - M[1][2] * M[2][0])
+ M[0][2] * (M[1][0] * M[2][1] - M[1][1] * M[2][0])
)
# 2×2
A = [[3, 1], [2, 4]]
print(f"det(A) = {det_2x2(A)}") # 12-2 = 10
# 3×3
B = [
[1, 2, 3],
[4, 5, 6],
[7, 8, 0],
]
print(f"det(B) = {det_3x3(B)}") # -27#Arti Geometris
- det > 0: transformasi mempertahankan orientasi
- det < 0: transformasi membalik orientasi (mirror)
- det = 0: transformasi "meratakan" — kehilangan dimensi, matriks tidak invertible
# Matriks transformasi 2×2
import numpy as np
# Transformasi: area berubah sebesar |det(M)|
A = np.array([[2, 0], [0, 3]]) # scaling: x×2, y×3
print(f"Scaling 2×3: det = {np.linalg.det(A):.0f}") # 6 — area ×6
# Rotasi: det = 1 (area tidak berubah)
theta = np.pi / 4 # 45 derajat
R = np.array([[np.cos(theta), -np.sin(theta)],
[np.sin(theta), np.cos(theta)]])
print(f"Rotasi 45°: det = {np.linalg.det(R):.4f}") # ~1.0
# Shear: det = 1
S = np.array([[1, 1], [0, 1]])
print(f"Shear: det = {np.linalg.det(S):.0f}") # 1
# Singular: det = 0 — kehilangan dimensi
Z = np.array([[1, 2], [2, 4]])
print(f"Singular: det = {np.linalg.det(Z):.0f}") # 0 — baris kedua = 2× baris pertama#Matrix Inverse
#Definisi
Inverse dari matriks A adalah A⁻¹ sehingga A × A⁻¹ = I. Hanya matriks dengan det ≠ 0 yang punya inverse.
#Inverse 2×2
def inverse_2x2(M):
"""Inverse dari [[a,b],[c,d]]."""
det = M[0][0] * M[1][1] - M[0][1] * M[1][0]
if abs(det) < 1e-10:
raise ValueError("Matriks tidak invertible (det=0)")
return [
[M[1][1]/det, -M[0][1]/det],
[-M[1][0]/det, M[0][0]/det],
]
A = [[4, 7], [2, 6]]
A_inv = inverse_2x2(A)
print("A:")
for row in A:
print(f" {row}")
print("A⁻¹:")
for row in A_inv:
print(f" [{row[0]:.4f}, {row[1]:.4f}]")
# Verifikasi: A × A⁻¹ = I
print("\nA × A⁻¹ (should be identity):")
I = [[sum(A[i][k] * A_inv[k][j] for k in range(2)) for j in range(2)] for i in range(2)]
for row in I:
print(f" [{row[0]:.4f}, {row[1]:.4f}]")#Menggunakan Inverse untuk Menyelesaikan Ax = b
import numpy as np
A = np.array([[4, 7], [2, 6]])
b = np.array([20, 14])
x = np.linalg.solve(A, b)
print(f"Ax = b:")
print(f" A = {A.tolist()}")
print(f" b = {b.tolist()}")
print(f" x = {x.tolist()}")
# Verifikasi
print(f" A × x = {(A @ x).tolist()}") # Harus = b#Gaussian Elimination
#Konsep
Gaussian elimination mengubah matriks augmented [A|b] menjadi row echelon form menggunakan operasi baris:
- Tukar dua baris
- Kalikan baris dengan skalar
- Tambahkan kelipatan satu baris ke baris lain
def gaussian_elimination(A, b):
"""Selesaikan Ax = b dengan Gaussian elimination."""
n = len(A)
# Augmented matrix
aug = [A[i][:] + [b[i]] for i in range(n)]
# Forward elimination
for col in range(n):
# Partial pivoting — cari pivot terbesar
max_row = max(range(col, n), key=lambda r: abs(aug[r][col]))
aug[col], aug[max_row] = aug[max_row], aug[col]
if abs(aug[col][col]) < 1e-10:
raise ValueError("Sistem tidak memiliki solusi unik")
# Eliminasi
for row in range(col + 1, n):
factor = aug[row][col] / aug[col][col]
for j in range(col, n + 1):
aug[row][j] -= factor * aug[col][j]
# Back substitution
x = [0] * n
for i in range(n - 1, -1, -1):
x[i] = (aug[i][n] - sum(aug[i][j] * x[j] for j in range(i + 1, n))) / aug[i][i]
return x
# Sistem: 2x + y - z = 8, -3x - y + 2z = -11, -2x + y + 2z = -3
A = [
[2, 1, -1],
[-3, -1, 2],
[-2, 1, 2],
]
b = [8, -11, -3]
x = gaussian_elimination(A, b)
print(f"Solusi: x={x[0]:.0f}, y={x[1]:.0f}, z={x[2]:.0f}")
# Verifikasi
for i in range(len(A)):
result = sum(A[i][j] * x[j] for j in range(len(A)))
print(f" Eq {i+1}: {result:.0f} = {b[i]} ✓" if abs(result - b[i]) < 1e-10 else f" Eq {i+1}: {result} ≠ {b[i]} ✗")#Perbandingan dengan NumPy
import numpy as np
import time
# Sistem 500×500
n = 500
np.random.seed(42)
A = np.random.rand(n, n)
x_true = np.random.rand(n)
b = A @ x_true
# Manual (dari kode di atas, adaptasi untuk numpy)
start = time.perf_counter()
x_numpy = np.linalg.solve(A, b)
t_numpy = time.perf_counter() - start
print(f"Sistem {n}×{n}:")
print(f" NumPy solve: {t_numpy:.4f}s")
print(f" Error: {np.max(np.abs(A @ x_numpy - b)):.2e}")#Numeric Stability: Condition Number
import numpy as np
# Well-conditioned
A_good = np.array([[4, 1], [2, 3]])
cond_good = np.linalg.cond(A_good)
# Ill-conditioned
A_bad = np.array([[1, 1], [1, 1.0001]])
cond_bad = np.linalg.cond(A_bad)
print(f"Condition number (well-conditioned): {cond_good:.2f}")
print(f"Condition number (ill-conditioned): {cond_bad:.2e}")
print(f"Condition number tinggi → solusi tidak stabil!")Note
Condition number mengukur sensitivitas solusi terhadap perubahan input. Condition number rendah (< 100) = stabil; tinggi (> 10^6) = tidak stabil. Dalam machine learning, feature scaling mengurangi condition number dan mempercepat konvergensi gradient descent.
#Penutup
Inti yang harus dibawa pulang:
- Determinant mengukur scaling factor transformasi;
det = 0berarti matriks tidak invertible. - Matrix inverse
A⁻¹:A × A⁻¹ = I— memungkinkan menyelesaikanAx = bdenganx = A⁻¹b. - Gaussian elimination: forward elimination → back substitution — menyelesaikan sistem linear O(n³).
- Condition number: mengukur stabilitas numerik — tinggi berarti solusi sensitif terhadap perubahan kecil.
- Sistem persamaan linear muncul di circuit analysis, least squares regression, dan input-output economics.
Di episode 19 selanjutnya kita akan mempelajari linear transformations: rotasi, skala, shear — bagaimana matriks mentransformasi titik dan vektor dalam 2D/3D. Determinant yang baru kalian pelajari menjelaskan mengapa transformasi bisa "meratakan" ruang, dan inverse menjelaskan bagaimana membalikkan transformasi!