R Academy · Ders

solve() ile Doğrusal Sistemleri Çözme

Ax = b sistemleri için çözümler bulun ve matris terslerini hesaplayın.

solve() ile Doğrusal Sistemleri Çözme, CoddyKit'te ücretsiz bir R Academy dersidir. Bu, 4 dersinin 2. dersidir. Aşağıdan dersin tamamını ücretsiz okuyabilir, sonra tarayıcıda yerleşik kod editörü ve 7/24 yapay zeka koçu ile uygulamalı olarak pratik yapabilirsin. Bu, R Academy öğrenme yolunun bir parçasıdır ve ilerlemeniz web ve CoddyKit uygulaması arasında senkronize olur. R Academy kursu toplamda 4 dersten oluşur.

Doğrusal Sistemler: Ax = b

Bir doğrusal denklem sistemi Ax = b biçiminde yazılabilir. Burada A katsayılar matrisi, x bilinmeyen vektör ve b sağ taraf vektörüdür. x için analitik çözüm bulmak, x = A⁻¹b hesaplamak anlamına gelir.

# 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): Doğrudan Çözüm

solve(A, b), Ax = b denklemini x için çözer. Bu işlem, A⁻¹ değerini açıkça hesaplayıp b ile çarpmaktan sayısal olarak daha kararlı ve verimli olan LU ayrıştırmasını dahili olarak kullanır.

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): Matris Tersi

Yalnızca bir bağımsız değişkenle solve(A) çağrıldığında A'nın tersi döndürülür: A %*% A⁻¹ = I koşulunu sağlayan A⁻¹. Ax=b denklemini çözmek için bunu kullanmaktan kaçının — doğrudan solve(A,b) kullanın (daha hızlı ve daha kararlıdır).

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)

Çözümünüzü Doğrulama

Çözümü her zaman A %*% x - b hesaplayarak doğrulayın. Kayan nokta aritmetiği nedeniyle kalan tam olarak sıfır olmayacaktır; ancak makine epsilon değerine (~1e-15) yakın olmalıdır. Tek bir kalan büyüklüğü için norm() kullanın.

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-16

Koşul Sayısı: kappa()

A'nın koşul sayısı, çözümün b'deki küçük değişikliklere ne kadar duyarlı olduğunu ölçer. Büyük bir koşul sayısı, b'deki küçük hataların x'te büyük hatalara yol açtığı anlamına gelir — sistem kötü koşulludur.

# 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')

Üst Üçgensel Sistemler için backsolve()

backsolve(R, b), R'nin üst üçgensel olduğu Rx = b denklemini geri yerine koyma yöntemiyle çözer. Üçgensel sistemlerde genel solve() işlevinden çok daha hızlıdır — O(n²) yerine 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)

Alt Üçgensel Sistemler için forwardsolve()

forwardsolve(L, b), L'nin alt üçgensel olduğu Lx = b denklemini ileri yerine koyma yöntemiyle çözer. backsolve() işlevini tamamlar ve birlikte LU ayrıştırmalı çözücülerin temelini oluştururlar.

# 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) -> x

Birden Fazla Sağ Taraf

B'nin bir matris olduğu solve(A, B), AX = B denklemini B'nin tüm sütunları için aynı anda çözer. Bu, her sütun için solve(A, b) işlevini ayrı ayrı çağırmaktan daha verimlidir.

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)  # TRUE

Tekil Matrisleri Belirleme

Tekil bir matris üzerinde solve(A) çağrılması bir hata oluşturur. Çözüm yapmadan önce det(A) veya rcond(A) değerini (koşul sayısının karşılığını) kontrol edin. Sağlam kod için tryCatch() kullanın.

# 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)  # NULL

solve() ile En Küçük Kareler

Aşırı belirlenmiş sistemlerde (bilinmeyenlerden daha fazla denklem olduğunda) tam bir çözüm yoktur. En küçük kareler çözümü ||Ax - b||² değerini en aza indirir. Normal denklemleri çözer: 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)

Kararlılık için qr.solve() Kullanımı

qr.solve(A, b), kötü koşullu veya aşırı belirlenmiş sistemlerde solve() işlevinden sayısal olarak daha kararlıdır. LU yerine QR ayrıştırmasını kullanır. lm() bunu dahili olarak kullanır.

# 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()

Hızlı Kontrol

R'de doğrusal sistem çözümünü anlayıp anlamadığınızı test edin.

Özet: Doğrusal Sistemleri Çözme

Temel çıkarımlar: solve(A, b), Ax=b denklemini doğrudan çözer (tercih edilen yöntem). solve(A), A⁻¹ değerini hesaplar (çözüm için kullanmaktan kaçının). backsolve(R,b) ve forwardsolve(L,b) üçgensel sistemlerde hızlıdır. kappa(A) koşulluluğu ölçer — büyük değerler kararsız çözümler anlamına gelir. Aşırı belirlenmiş sistemler için qr.solve() kullanın. Çözümü her zaman A %*% x - b ile doğrulayın.

# 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)

Sıkça Sorulan Sorular

“solve() ile Doğrusal Sistemleri Çözme” dersi ücretsiz mi?

Evet — “solve() ile Doğrusal Sistemleri Çözme” dersin tüm metni burada web'de ücretsiz olarak okunabilir. Etkileşimli olarak pratik yapmak (yerleşik kod editörü ve 7/24 yapay zeka koçu) ve R Academy kursunun geri kalanını açmak için CoddyKit PRO'ya yükselt. R Academy kursu toplamda 4 dersten oluşur.

“solve() ile Doğrusal Sistemleri Çözme” dersinde ne öğreneceğim?

Ax = b sistemleri için çözümler bulun ve matris terslerini hesaplayın. R Academy ile uygulamalı kodu tarayıcıda doğrudan çalıştırarak pratik yaparsın ve 7/24 yapay zeka koçu dersi çalışırken sorularını yanıtlar.

R Academy öğrenmeye başlamak için deneyim gerekli mi?

Önceden deneyim gerekmez. CoddyKit'te R Academy, başlangıçtan ileri seviyeye kadar yapılandırıldığı için buradan başlayabilir veya başından başlayıp kendi hızında ilerleme yapabilirsin. Bu, 4 dersinin 2. dersidir.

“solve() ile Doğrusal Sistemleri Çözme” dersi ne kadar sürer?

Çoğu CoddyKit dersi yaklaşık 5–10 dakika sürer. Her biri kısa ve etkileşimli olduğu için sabit ilerleme yaparsın ve web ile uygulama arasında tam olarak bıraktığın yerden devam edebilirsin.

Bu R Academy dersinde kod yazıp çalıştırabilir miyim?

Evet. Her R Academy dersi yerleşik bir kod editörü içerir, bu sayede tarayıcıda gerçek kod yazıp çalıştırabilir ve anlık yapay zeka geri bildirimi alırsın — yerel kurulum gerekli değildir.

Bu kursun tüm dersleri

← R Academy Sayfasına Dön