0Pricing
R Academy · Lekcja

Rozwiązywanie układów równań liniowych za pomocą solve()

Znajdź rozwiązania układów Ax = b i oblicz macierze odwrotne.

Rozwiązywanie układów równań liniowych za pomocą solve() to bezpłatna lekcja R Academy na CoddyKit. To lekcja 2 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej R Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs R Academy zawiera 4 lekcji w sumie.

Układy liniowe: Ax = b

Układ równań liniowych można zapisać jako Ax = b, gdzie A jest macierzą współczynników, x — wektorem niewiadomych, a b — prawą stroną równania. Analityczne rozwiązanie względem x oznacza obliczenie 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): rozwiązanie bezpośrednie

solve(A, b) rozwiązuje równanie Ax = b względem x. Wewnątrz wykorzystuje rozkład LU, który jest stabilniejszy numerycznie i wydajniejszy niż jawne obliczanie A⁻¹, a następnie mnożenie przez 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): macierz odwrotna

Wywołanie solve(A) tylko z jednym argumentem zwraca macierz odwrotną do A: A⁻¹ taką, że A %*% A⁻¹ = I. Należy unikać tego sposobu przy rozwiązywaniu Ax=b — proszę używać bezpośrednio solve(A,b), ponieważ jest to szybsze i stabilniejsze.

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)

Sprawdzanie rozwiązania

Zawsze weryfikuj rozwiązanie, obliczając A %*% x - b. Ze względu na arytmetykę zmiennoprzecinkową residuum nie będzie dokładnie równe zero, ale powinno być bliskie epsilonowi maszynowemu (~1e-15). Użyj norm(), aby uzyskać pojedynczą wartość bezwzględną residuum.

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

Współczynnik uwarunkowania: kappa()

Współczynnik uwarunkowania macierzy A mierzy wrażliwość rozwiązania na zaburzenia wektora b. Duża wartość współczynnika oznacza, że małe błędy w b powodują duże błędy w x — układ jest źle uwarunkowany.

# 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() dla macierzy trójkątnej górnej

backsolve(R, b) rozwiązuje równanie Rx = b, gdy R jest macierzą trójkątną górną, używając podstawiania wstecznego. Jest znacznie szybsza niż ogólna funkcja solve() dla układów trójkątnych — O(n²) zamiast 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() dla macierzy trójkątnej dolnej

forwardsolve(L, b) rozwiązuje równanie Lx = b, gdy L jest macierzą trójkątną dolną, używając podstawiania w przód. Uzupełnia funkcję backsolve(); razem stanowią podstawę algorytmów rozwiązywania układów opartych na rozkładzie 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) -> x

Wiele prawych stron

solve(A, B), gdzie B jest macierzą, rozwiązuje jednocześnie równanie AX = B dla wszystkich kolumn macierzy B. Jest to wydajniejsze niż osobne wywoływanie solve(A, b) dla każdej kolumny.

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

Wykrywanie macierzy osobliwych

Wywołanie solve(A) dla macierzy osobliwej zgłasza błąd. Przed rozwiązaniem proszę sprawdzić det(A) lub rcond(A) (odwrotność współczynnika uwarunkowania). W odpornym na błędy kodzie należy używać tryCatch().

# 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

Metoda najmniejszych kwadratów za pomocą solve()

W przypadku układów nadokreślonych (z większą liczbą równań niż niewiadomych) nie istnieje rozwiązanie dokładne. Rozwiązanie metodą najmniejszych kwadratów minimalizuje ||Ax - b||². Spełnia ono równania normalne: 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)

Używanie qr.solve() dla większej stabilności

qr.solve(A, b) jest numerycznie stabilniejsza niż solve() w przypadku źle uwarunkowanych lub nadokreślonych układów. Wykorzystuje rozkład QR zamiast LU. Funkcja lm() używa jej wewnętrznie.

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

Szybkie sprawdzenie

Sprawdź swoją znajomość rozwiązywania układów liniowych w R.

Podsumowanie: rozwiązywanie układów liniowych

Najważniejsze informacje: solve(A, b) bezpośrednio rozwiązuje Ax=b (jest to preferowane rozwiązanie). solve(A) oblicza A⁻¹ (należy unikać tej funkcji przy rozwiązywaniu układu). backsolve(R,b) i forwardsolve(L,b) są szybkie dla układów trójkątnych. kappa(A) mierzy uwarunkowanie — duże wartości oznaczają niestabilne rozwiązania. W przypadku układów nadokreślonych używaj qr.solve(). Zawsze weryfikuj rozwiązanie za pomocą 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)

Często zadawane pytania

Czy lekcja „Rozwiązywanie układów równań liniowych za pomocą solve()” jest bezpłatna?

Tak — pełny tekst „Rozwiązywanie układów równań liniowych za pomocą solve()” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu R Academy, przejdź na CoddyKit PRO. Kurs R Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Rozwiązywanie układów równań liniowych za pomocą solve()”?

Znajdź rozwiązania układów Ax = b i oblicz macierze odwrotne. Ćwiczysz R Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć R Academy?

Nie wymagamy żadnego doświadczenia. R Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 2 z 4.

Ile czasu zajmuje lekcja „Rozwiązywanie układów równań liniowych za pomocą solve()”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji R Academy?

Tak. Każda lekcja R Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

  1. Mnożenie macierzy i wyznaczniki
  2. Rozwiązywanie układów równań liniowych za pomocą solve()
  3. Wartości własne i wektory własne
  4. Rozkłady SVD, QR i Cholesky’ego
← Powrót do R Academy