0Pricing
R Academy · Lektion

Lineare Gleichungssysteme mit solve() lösen

Lösen Sie Gleichungssysteme der Form Ax = b und berechnen Sie Matrixinverse

Lineare Gleichungssysteme mit solve() lösen ist eine kostenlose R Academy-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des R Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der R Academy-Kurs umfasst insgesamt 4 Lektionen.

Lineare Gleichungssysteme: Ax = b

Ein System linearer Gleichungen lässt sich als Ax = b schreiben. Dabei ist A eine Koeffizientenmatrix, x der Vektor der Unbekannten und b die rechte Seite. x analytisch zu bestimmen bedeutet, x = A⁻¹b zu berechnen.

# 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): Die direkte Lösung

solve(A, b) löst Ax = b nach x auf. Intern wird eine LU-Zerlegung verwendet, die numerisch stabiler und effizienter ist, als A⁻¹ explizit zu berechnen und anschließend mit b zu multiplizieren.

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): Die Matrixinverse

Der Aufruf von solve(A) mit nur einem Argument gibt die Inverse von A zurück: A⁻¹ mit A %*% A⁻¹ = I. Verwenden Sie dies nicht zum Lösen von Ax=b — nutzen Sie direkt solve(A,b) (schneller und stabiler).

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)

Überprüfen Ihrer Lösung

Überprüfen Sie die Lösung immer, indem Sie A %*% x - b berechnen. Aufgrund der Gleitkommaarithmetik ist das Residuum nicht exakt null, sollte aber nahe an der Maschinenpräzision (~1e-15) liegen. Verwenden Sie norm() für einen einzelnen Residuenbetrag.

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

Konditionszahl: kappa()

Die Konditionszahl von A misst, wie empfindlich die Lösung auf Störungen in b reagiert. Eine große Konditionszahl bedeutet, dass kleine Fehler in b große Fehler in x verursachen — das System ist schlecht konditioniert.

# 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() für obere Dreiecksmatrizen

backsolve(R, b) löst Rx = b, wobei R eine obere Dreiecksmatrix ist, mithilfe der Rückwärtssubstitution. Für Dreieckssysteme ist dies wesentlich schneller als solve() für allgemeine Matrizen — O(n²) gegenüber 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() für untere Dreiecksmatrizen

forwardsolve(L, b) löst Lx = b, wobei L eine untere Dreiecksmatrix ist, mithilfe der Vorwärtssubstitution. Die Funktion ergänzt backsolve(); gemeinsam bilden beide die Grundlage von LU-Zerlegungs-Lösern.

# 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

Mehrere rechte Seiten

solve(A, B) löst, wenn B eine Matrix ist, AX = B gleichzeitig für alle Spalten von B. Das ist effizienter, als für jede Spalte separat solve(A, b) aufzurufen.

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

Singuläre Matrizen erkennen

Der Aufruf von solve(A) für eine singuläre Matrix löst einen Fehler aus. Überprüfen Sie vor dem Lösen det(A) oder rcond(A) (reziproke Konditionszahl). Verwenden Sie tryCatch() für robusten Code.

# 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

Kleinste Quadrate mit solve()

Für überbestimmte Systeme (mehr Gleichungen als Unbekannte) gibt es keine exakte Lösung. Die Lösung der kleinsten Quadrate minimiert ||Ax - b||². Sie löst die Normalgleichungen: 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() für Stabilität verwenden

qr.solve(A, b) ist für schlecht konditionierte oder überbestimmte Systeme numerisch stabiler als solve(). Die Funktion verwendet eine QR- statt einer LU-Zerlegung. lm() verwendet sie intern.

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

Kurzer Test

Testen Sie Ihr Verständnis zum Lösen linearer Gleichungssysteme in R.

Zusammenfassung: Lineare Gleichungssysteme lösen

Wichtigste Erkenntnisse: solve(A, b) löst Ax=b direkt (empfohlen). solve(A) berechnet A⁻¹ (zum Lösen vermeiden). backsolve(R,b) und forwardsolve(L,b) sind schnell bei Dreieckssystemen. kappa(A) misst die Kondition — große Werte bedeuten instabile Lösungen. Für überbestimmte Systeme verwenden Sie qr.solve(). Überprüfen Sie die Lösung immer mit 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)

Häufig gestellte Fragen

Ist die Lektion „Lineare Gleichungssysteme mit solve() lösen“ kostenlos?

Ja — der vollständige Text von „Lineare Gleichungssysteme mit solve() lösen“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des R Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der R Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Lineare Gleichungssysteme mit solve() lösen“?

Lösen Sie Gleichungssysteme der Form Ax = b und berechnen Sie Matrixinverse Du übst R Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um R Academy zu starten?

Keine Vorkenntnisse erforderlich. R Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.

Wie lange dauert die Lektion „Lineare Gleichungssysteme mit solve() lösen“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser R Academy-Lektion Code schreiben und ausführen?

Ja. Jede R Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. Matrixmultiplikation und Determinanten
  2. Lineare Gleichungssysteme mit solve() lösen
  3. Eigenwerte und Eigenvektoren
  4. SVD-, QR- und Cholesky-Zerlegungen
← Zurück zu R Academy