Решение систем линейных уравнений с помощью solve()
Найдите решения систем Ax = b и вычислите обратные матрицы
«Решение систем линейных уравнений с помощью solve()» — бесплатный урок R Academy на CoddyKit. Это урок 2 из 4. Ты можешь прочитать весь урок бесплатно ниже — а потом практиковать его прямо в браузере с встроенным редактором кода и ИИ-репетитором 24/7. Это часть пути обучения R Academy, и твой прогресс синхронизируется между веб-версией и приложением CoddyKit. Курс R Academy содержит 4 уроков всего.
Линейные системы: Ax = b
Систему линейных уравнений можно записать в виде Ax = b, где A — матрица коэффициентов, x — вектор неизвестных, а b — правая часть. Аналитическое решение относительно x означает вычисление 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): прямое решение
solve(A, b) решает Ax = b относительно x. Внутри используется разложение LU, которое численно устойчивее и эффективнее, чем явное вычисление A⁻¹ с последующим умножением на 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): обратная матрица
Вызов solve(A) только с одним аргументом возвращает обратную матрицу A: A⁻¹, такую что A %*% A⁻¹ = I. Не используйте этот вариант для решения Ax=b — вызывайте solve(A,b) напрямую: это быстрее и устойчивее.
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)Проверка решения
Всегда проверяйте решение, вычисляя A %*% x - b. Из-за арифметики с плавающей точкой остаток не будет в точности равен нулю, но должен быть близок к машинному эпсилону (~1e-15). Используйте norm(), чтобы получить одну величину остатка.
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Число обусловленности: kappa()
Число обусловленности A показывает, насколько решение чувствительно к возмущениям b. Большое число обусловленности означает, что небольшие ошибки в b вызывают большие ошибки в x — система является плохо обусловленной.
# 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() для верхнетреугольных матриц
backsolve(R, b) решает Rx = b, где R — верхнетреугольная матрица, методом обратной подстановки. Для треугольных систем это намного быстрее общего solve(): O(n²) вместо 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() для нижнетреугольных матриц
forwardsolve(L, b) решает Lx = b, где L — нижнетреугольная матрица, методом прямой подстановки. Вместе с backsolve() эта функция составляет основу решателей на основе разложения 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Несколько правых частей
solve(A, B), где B — матрица, одновременно решает AX = B для всех столбцов B. Это эффективнее, чем отдельно вызывать solve(A, b) для каждого столбца.
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Обнаружение вырожденных матриц
Вызов solve(A) для вырожденной матрицы приводит к ошибке. Перед решением проверьте det(A) или rcond(A) (обратное число обусловленности). Для надёжного кода используйте 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Метод наименьших квадратов с solve()
Для переопределённых систем (в которых уравнений больше, чем неизвестных) точного решения нет. Решение методом наименьших квадратов минимизирует ||Ax - b||². Оно удовлетворяет нормальным уравнениям: 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)Использование qr.solve() для устойчивости
qr.solve(A, b) численно устойчивее, чем solve(), для плохо обусловленных или переопределённых систем. Здесь используется разложение QR вместо LU. Функция lm() применяет этот подход внутри.
# 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()Быстрая проверка
Проверьте своё понимание решения линейных систем в R.
Повторение: решение линейных систем
Главное: solve(A, b) напрямую решает Ax=b и является предпочтительным вариантом. solve(A) вычисляет A⁻¹ — не используйте его для решения систем. backsolve(R,b) и forwardsolve(L,b) быстро решают треугольные системы. kappa(A) измеряет обусловленность: большие значения означают неустойчивые решения. Для переопределённых систем используйте qr.solve(). Всегда проверяйте результат с помощью 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)Часто задаваемые вопросы
Урок «Решение систем линейных уравнений с помощью solve()» бесплатный?
Да — полный текст урока «Решение систем линейных уравнений с помощью solve()» бесплатно доступен здесь в веб-версии. Чтобы практиковать его интерактивно (встроенный редактор кода и ИИ-репетитор 24/7) и разблокировать остальной курс R Academy, подпишись на CoddyKit PRO. Курс R Academy содержит 4 уроков всего.
Чему я научусь в уроке «Решение систем линейных уравнений с помощью solve()»?
Найдите решения систем Ax = b и вычислите обратные матрицы Ты практикуешь R Academy с помощью реального кода, который запускаешь прямо в браузере, и ИИ-репетитор 24/7 отвечает на твои вопросы во время урока.
Нужен ли мне опыт, чтобы начать R Academy?
Предыдущий опыт не требуется. R Academy на CoddyKit структурирован для всех уровней — от новичков до продвинутых, поэтому ты можешь начать отсюда или с самого начала и учиться в своем темпе. Это урок 2 из 4.
Сколько времени занимает урок «Решение систем линейных уравнений с помощью solve()»?
Большинство уроков CoddyKit занимают около 5–10 минут. Каждый из них компактный и интерактивный, поэтому ты постоянно делаешь прогресс и продолжаешь с того же места в веб-версии и приложении.
Можно ли писать и запускать код в этом уроке R Academy?
Да. Каждый урок R Academy включает встроенный редактор кода, поэтому ты пишешь и запускаешь реальный код прямо в браузере и получаешь моментальную обратную связь от AI — локальная установка не требуется.
Все уроки этого курса
- Умножение матриц и определители
- Решение систем линейных уравнений с помощью solve()
- Собственные значения и собственные векторы
- Разложения SVD, QR и Холецкого