0Pricing
R Academy · Leçon

Résoudre des systèmes linéaires avec solve()

Trouvez les solutions des systèmes Ax = b et calculez les inverses de matrices.

Résoudre des systèmes linéaires avec solve() est une leçon R Academy gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage R Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours R Academy comprend 4 leçons au total.

Systèmes linéaires : Ax = b

Un système d’équations linéaires peut s’écrire Ax = b, où A est une matrice de coefficients, x le vecteur inconnu et b le membre de droite. Résoudre analytiquement par rapport à x signifie calculer 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) : la solution directe

solve(A, b) résout Ax = b par rapport à x. Cette fonction utilise en interne une décomposition LU, qui est plus stable et plus efficace numériquement que le calcul explicite de A⁻¹ suivi de sa multiplication par 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) : l’inverse d’une matrice

L’appel de solve(A) avec un seul argument renvoie l’inverse de A : A⁻¹ tel que A %*% A⁻¹ = I. Évitez cette approche pour résoudre Ax=b : utilisez directement solve(A,b), qui est plus rapide et plus stable.

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)

Vérification de votre solution

Vérifiez toujours la solution en calculant A %*% x - b. En raison de l’arithmétique en virgule flottante, le résidu ne sera pas exactement nul, mais devrait être proche de l’epsilon machine (~1e-15). Utilisez norm() pour obtenir une seule mesure du résidu.

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

Nombre de conditionnement : kappa()

Le nombre de conditionnement de A mesure la sensibilité de la solution aux perturbations de b. Un nombre de conditionnement élevé signifie que de petites erreurs dans b provoquent de grandes erreurs dans x : le système est mal conditionné.

# 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() pour les matrices triangulaires supérieures

backsolve(R, b) résout Rx = b lorsque R est triangulaire supérieure, par substitution arrière. Cette fonction est beaucoup plus rapide que solve() pour les systèmes triangulaires : O(n²) contre 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() pour les matrices triangulaires inférieures

forwardsolve(L, b) résout Lx = b lorsque L est triangulaire inférieure, par substitution avant. Cette fonction complète backsolve() et, ensemble, elles constituent la base des solveurs fondés sur la décomposition 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

Plusieurs seconds membres

solve(A, B), lorsque B est une matrice, résout simultanément AX = B pour toutes les colonnes de B. Cette approche est plus efficace que l’appel de solve(A, b) séparément pour chaque colonne.

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

Détection des matrices singulières

L’appel de solve(A) sur une matrice singulière génère une erreur. Vérifiez det(A) ou rcond(A) (l’inverse du nombre de conditionnement) avant la résolution. Utilisez tryCatch() pour obtenir un code robuste.

# 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

Moindres carrés avec solve()

Pour les systèmes surdéterminés (qui comportent plus d’équations que d’inconnues), il n’existe pas de solution exacte. La solution des moindres carrés minimise ||Ax - b||². Elle résout les équations normales : 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)

Utilisation de qr.solve() pour la stabilité

qr.solve(A, b) est numériquement plus stable que solve() pour les systèmes mal conditionnés ou surdéterminés. Cette fonction utilise une décomposition QR plutôt que LU. lm() l’utilise en interne.

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

Vérification rapide

Testez votre compréhension de la résolution des systèmes linéaires dans R.

Récapitulatif : résolution des systèmes linéaires

Points essentiels : solve(A, b) résout directement Ax=b (approche recommandée). solve(A) calcule A⁻¹ (à éviter pour résoudre un système). backsolve(R,b) et forwardsolve(L,b) sont rapides pour les systèmes triangulaires. kappa(A) mesure le conditionnement : des valeurs élevées indiquent des solutions instables. Pour les systèmes surdéterminés, utilisez qr.solve(). Vérifiez toujours avec 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)

Questions Fréquemment Posées

La leçon « Résoudre des systèmes linéaires avec solve() » est-elle gratuite ?

Oui — le texte complet de « Résoudre des systèmes linéaires avec solve() » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours R Academy, passe à CoddyKit PRO. Le cours R Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Résoudre des systèmes linéaires avec solve() » ?

Trouvez les solutions des systèmes Ax = b et calculez les inverses de matrices. Tu pratiques R Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer R Academy ?

Aucune expérience préalable n'est requise. R Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.

Combien de temps prend la leçon « Résoudre des systèmes linéaires avec solve() » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon R Academy ?

Oui. Chaque leçon R Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Multiplication matricielle et déterminants
  2. Résoudre des systèmes linéaires avec solve()
  3. Valeurs propres et vecteurs propres
  4. Décompositions SVD, QR et de Cholesky
← Retour à R Academy