Menyelesaikan Sistem Linear dengan solve()
Temukan solusi untuk sistem Ax = b dan hitung invers matriks.
Menyelesaikan Sistem Linear dengan solve() adalah pelajaran R Academy gratis di CoddyKit. Ini adalah pelajaran 2 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar R Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus R Academy mencakup 4 pelajaran total.
Sistem Linear: Ax = b
Sistem persamaan linear dapat ditulis sebagai Ax = b, dengan A sebagai matriks koefisien, x sebagai vektor tak diketahui, dan b sebagai ruas kanan. Menyelesaikan x secara analitis berarti menghitung x = A⁻¹b.
# System of equations:
# 2x + y = 5
# x + 3y = 7
# Matrix form: A %*% x = b
A <- matrix(c(2, 1,
1, 3), nrow = 2, byrow = TRUE)
b <- c(5, 7)
# What are A and b?
print(A)
print(b)
cat('We want to find x such that A %*% x = b')solve(A, b): Solusi Langsung
solve(A, b) menyelesaikan Ax = b untuk x. Fungsi ini secara internal menggunakan dekomposisi LU, yang lebih stabil dan efisien secara numerik daripada menghitung A⁻¹ secara eksplisit lalu mengalikannya dengan b.
A <- matrix(c(2, 1,
1, 3), nrow = 2, byrow = TRUE)
b <- c(5, 7)
# Solve Ax = b
x <- solve(A, b)
print(x) # x[1] = ?, x[2] = ?
# Verify: A %*% x should equal b
residual <- A %*% x - b
print(residual) # Should be near zero
# Manual check:
# 2*(8/5) + (9/5) = 16/5 + 9/5 = 25/5 = 5 ✓
# 1*(8/5) + 3*(9/5) = 8/5 + 27/5 = 35/5 = 7 ✓solve(A): Invers Matriks
Memanggil solve(A) dengan hanya satu argumen menghasilkan invers A: A⁻¹ sedemikian rupa sehingga A %*% A⁻¹ = I. Hindari penggunaannya untuk menyelesaikan Ax=b — gunakan solve(A,b) secara langsung (lebih cepat dan lebih stabil).
A <- matrix(c(4, 3,
3, 2), nrow = 2, byrow = TRUE)
# Compute inverse
A_inv <- solve(A)
print(A_inv)
# Verify: A %*% A_inv = I
A %*% A_inv # Should be identity matrix
round(A %*% A_inv, 10)
# Also A_inv %*% A = I
round(A_inv %*% A, 10)
# det(A) != 0 required for invertibility
det(A) # -1 (nonzero, so invertible)Memeriksa Solusi Anda
Selalu verifikasi solusi dengan menghitung A %*% x - b. Karena aritmetika titik mengambang, residu tidak akan persis nol, tetapi seharusnya mendekati epsilon mesin (~1e-15). Gunakan norm() untuk memperoleh satu besaran residu.
A <- matrix(c(3, -1, 2,
1, 4, 0,
-2, 1, 5), nrow = 3, byrow = TRUE)
b <- c(1, 2, 3)
# Solve
x <- solve(A, b)
cat('Solution x:\n'); print(x)
# Residual check
residual <- A %*% x - b
cat('Residual vector:\n'); print(residual)
# Residual norm (should be near 0)
resid_norm <- sqrt(sum(residual^2))
cat('Residual norm:', resid_norm, '\n')
# Expected: something like 2e-16Bilangan Kondisi: kappa()
Bilangan kondisi A mengukur seberapa sensitif solusi terhadap perubahan kecil pada b. Bilangan kondisi yang besar berarti kesalahan kecil pada b menyebabkan kesalahan besar pada x — sistem tersebut berkondisi buruk.
# Well-conditioned matrix
A_good <- matrix(c(2, 1, 1, 3), nrow = 2, byrow = TRUE)
kappa(A_good) # Small -> good
# Ill-conditioned (nearly singular) matrix
A_bad <- matrix(c(1.000, 1.001,
1.001, 1.002), nrow = 2, byrow = TRUE)
kappa(A_bad) # Very large -> bad!
# Rule of thumb: kappa > 1/machine_epsilon is trouble
.Machine$double.eps # ~2.2e-16
# For A_bad: you lose about log10(kappa) digits of precision
cat('Digits lost:', log10(kappa(A_bad)), '\n')backsolve() untuk Matriks Segitiga Atas
backsolve(R, b) menyelesaikan Rx = b ketika R adalah matriks segitiga atas menggunakan substitusi mundur. Jauh lebih cepat daripada solve() umum untuk sistem segitiga — O(n²) dibandingkan O(n³).
# Upper triangular system: Rx = b
# 2x + 3y + z = 14
# 5y + 2z = 13
# 4z = 8
R <- matrix(c(2, 3, 1,
0, 5, 2,
0, 0, 4), nrow = 3, byrow = TRUE)
b <- c(14, 13, 8)
# Solve using back-substitution
x <- backsolve(R, b)
print(x) # z=2, y=(13-4)/5=9/5, x=(14-3*9/5-2)/2
# Verify
all.equal(as.vector(R %*% x), b) # TRUE
# Compare with general solve
x_general <- solve(R, b)
all.equal(x, x_general) # TRUE (same result)forwardsolve() untuk Matriks Segitiga Bawah
forwardsolve(L, b) menyelesaikan Lx = b ketika L adalah matriks segitiga bawah menggunakan substitusi maju. Fungsi ini melengkapi backsolve(), dan keduanya menjadi dasar penyelesai dekomposisi LU.
# Lower triangular system: Lx = b
# 3x = 6
# 2x + 4y = 10
# x + 2y + 5z = 16
L <- matrix(c(3, 0, 0,
2, 4, 0,
1, 2, 5), nrow = 3, byrow = TRUE)
b <- c(6, 10, 16)
# Solve using forward-substitution
x <- forwardsolve(L, b)
print(x) # x=2, y=(10-4)/4=1.5, z=(16-2-3)/5=2.2
# Verify
all.equal(as.vector(L %*% x), b) # TRUE
# Use case: solving L*U*x = b
# forwardsolve(L, b) -> y, then backsolve(U, y) -> xBeberapa Ruas Kanan
solve(A, B), dengan B sebagai matriks, menyelesaikan AX = B secara bersamaan untuk semua kolom B. Ini lebih efisien daripada memanggil solve(A, b) secara terpisah untuk setiap kolom.
A <- matrix(c(2, 1,
1, 3), nrow = 2, byrow = TRUE)
# Solve for two right-hand sides simultaneously
B <- matrix(c(5, 7, # first system
3, 1), # second system
nrow = 2, byrow = TRUE)
# X[:,1] solves Ax = B[:,1]
# X[:,2] solves Ax = B[:,2]
X <- solve(A, B)
print(X)
# Verify both solutions
A %*% X # Should equal B
all.equal(A %*% X, B) # TRUEMendeteksi Matriks Singular
Memanggil solve(A) pada matriks singular menimbulkan kesalahan. Periksa det(A) atau rcond(A) (kebalikan bilangan kondisi) sebelum menyelesaikan sistem. Gunakan tryCatch() untuk kode yang tangguh.
# Singular matrix (rows are linearly dependent)
S <- matrix(c(1, 2,
2, 4), nrow = 2, byrow = TRUE)
det(S) # 0 -> singular
kappa(S) # Inf
# Safe solve with tryCatch
safe_solve <- function(A, b) {
tryCatch(
solve(A, b),
error = function(e) {
cat('Matrix is singular or nearly so:\n')
cat(e$message, '\n')
return(NULL)
}
)
}
result <- safe_solve(S, c(1, 2))
print(result) # NULLKuadrat Terkecil dengan solve()
Untuk sistem yang terlalu ditentukan (lebih banyak persamaan daripada peubah tak diketahui), tidak ada solusi eksak. Solusi kuadrat terkecil meminimalkan ||Ax - b||². Solusi ini menyelesaikan persamaan normal: A'Ax = A'b.
# Overdetermined: 4 equations, 2 unknowns (y = a + b*x)
set.seed(1)
x_vals <- c(1, 2, 3, 4)
y_vals <- c(2.1, 4.0, 5.9, 8.2) # approx y = 0 + 2x
A <- cbind(1, x_vals) # Design matrix (4x2)
b <- y_vals
# Normal equations: (A'A) beta = A'b
AtA <- crossprod(A)
Atb <- crossprod(A, b)
beta_ols <- solve(AtA, Atb)
print(beta_ols) # Intercept ~0.1, slope ~2.0
# Residual sum of squares
y_hat <- A %*% beta_ols
rss <- sum((b - y_hat)^2)
cat('RSS:', rss)Menggunakan qr.solve() untuk Stabilitas
qr.solve(A, b) lebih stabil secara numerik daripada solve() untuk sistem yang berkondisi buruk atau terlalu ditentukan. Fungsi ini menggunakan dekomposisi QR, bukan LU. lm() menggunakannya secara internal.
# For overdetermined system, qr.solve is preferred
x_vals <- c(1, 2, 3, 4, 5)
y_vals <- c(1.9, 4.1, 6.0, 7.8, 10.1)
A <- cbind(1, x_vals)
b <- y_vals
# qr.solve handles overdetermined systems directly
beta_qr <- qr.solve(A, b)
print(beta_qr) # intercept, slope
# Equivalent to:
beta_lm <- coef(lm(y_vals ~ x_vals))
all.equal(beta_qr, beta_lm, check.names = FALSE) # TRUE
# For well-determined square systems, solve() is fine
# For overdetermined or ill-conditioned: use qr.solve()Pemeriksaan Singkat
Uji pemahaman Anda tentang penyelesaian sistem linear di R.
Ringkasan: Menyelesaikan Sistem Linear
Hal-hal penting: solve(A, b) menyelesaikan Ax=b secara langsung (lebih disarankan). solve(A) menghitung A⁻¹ (hindari untuk penyelesaian sistem). backsolve(R,b) dan forwardsolve(L,b) cepat untuk sistem segitiga. kappa(A) mengukur kondisi — nilai besar berarti solusi tidak stabil. Untuk sistem yang terlalu ditentukan, gunakan qr.solve(). Selalu verifikasi dengan A %*% x - b.
# Summary of solve() functions:
A <- matrix(c(3, 1, 1, 2), nrow = 2)
b <- c(9, 8)
# Solve Ax = b
x <- solve(A, b)
print(x) # c(2, 3)
# Check conditioning
kappa(A) # Small -> well-conditioned
# Verify
max(abs(A %*% x - b)) # Near zero
# For triangular systems:
R <- matrix(c(2, 3, 0, 4), nrow = 2, byrow = TRUE)
backsolve(R, c(8, 4)) # x=c(1, 1)
# For least squares (overdetermined):
# qr.solve(design_matrix, y)Pertanyaan yang Sering Diajukan
Apakah pelajaran “Menyelesaikan Sistem Linear dengan solve()” gratis?
Ya — teks lengkap “Menyelesaikan Sistem Linear dengan solve()” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus R Academy, upgrade ke CoddyKit PRO. Kursus R Academy mencakup 4 pelajaran total.
Apa yang akan aku pelajari di “Menyelesaikan Sistem Linear dengan solve()”?
Temukan solusi untuk sistem Ax = b dan hitung invers matriks. Kamu berlatih R Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.
Apakah aku perlu pengalaman untuk memulai R Academy?
Tidak diperlukan pengalaman sebelumnya. R Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 2 dari 4.
Berapa lama pelajaran “Menyelesaikan Sistem Linear dengan solve()” memakan waktu?
Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.
Bisakah aku menulis dan menjalankan kode dalam pelajaran R Academy ini?
Ya. Setiap pelajaran R Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.
Semua pelajaran dalam kursus ini
- Perkalian Matriks dan Determinan
- Menyelesaikan Sistem Linear dengan solve()
- Nilai Eigen dan Vektor Eigen
- Dekomposisi SVD, QR, dan Cholesky