0Pricing
R Academy · Lektion

Matrixmultiplikation und Determinanten

Verwenden Sie %*% für die Matrixmultiplikation und det() zur Berechnung der Determinante.

Matrixmultiplikation und Determinanten ist eine kostenlose R Academy-Lektion auf CoddyKit. Dies ist Lektion 1 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.

Matrizen in R erstellen

Matrizen sind zweidimensionale Arrays, die standardmäßig spaltenweise gefüllt werden. Verwenden Sie matrix(data, nrow, ncol). Mit rownames() und colnames() können Sie Zeilen und Spalten benennen.

# Create a 3x3 matrix (filled column-wise)
A <- matrix(c(1, 2, 3,
              4, 5, 6,
              7, 8, 9), nrow = 3, ncol = 3, byrow = TRUE)
print(A)
#      [,1] [,2] [,3]
# [1,]    1    2    3
# [2,]    4    5    6
# [3,]    7    8    9

dim(A)   # 3 3
nrow(A)  # 3
ncol(A)  # 3

Matrixmultiplikation: %*%

Der Operator %*% führt eine echte Matrixmultiplikation durch (Skalarprodukt von Zeilen und Spalten). Der Operator * arbeitet elementweise – eine häufige Fehlerquelle! Die Dimensionen müssen kompatibel sein: (m×n) %*% (n×p) = (m×p).

A <- matrix(c(1, 2, 3, 4), nrow = 2)
B <- matrix(c(5, 6, 7, 8), nrow = 2)

# Element-wise multiplication (NOT matrix mult)
A * B
#      [,1] [,2]
# [1,]    5   21
# [2,]   12   32

# True matrix multiplication
A %*% B
#      [,1] [,2]
# [1,]   19   43
# [2,]   22   50

# Verify: entry [1,1] = 1*5 + 2*6 = 17... wait:
# A[1,] = c(1,3), B[,1] = c(5,6): 1*5 + 3*6 = 23

Ergebnisse von %*% verstehen

Überprüfen wir die Matrixmultiplikation manuell. Der Eintrag (i,j) von C = A %*% B ist das Skalarprodukt aus Zeile i von A und Spalte j von B: sum(A[i,] * B[,j]).

A <- matrix(c(1, 2, 3, 4, 5, 6), nrow = 2, byrow = TRUE)
B <- matrix(c(7, 8, 9, 10, 11, 12), nrow = 3, byrow = TRUE)
# A is 2x3, B is 3x2 -> result is 2x2
C <- A %*% B
print(C)

# Verify entry C[1,1]:
# row 1 of A: c(1,2,3), col 1 of B: c(7,9,11)
manual_11 <- sum(A[1, ] * B[, 1])
manual_11  # 1*7 + 2*9 + 3*11 = 58
C[1, 1]   # should match

Die Determinante: det()

Die Determinante ist ein Skalarwert, der den Skalierungsfaktor einer Matrix beschreibt. det(A) berechnet sie. Wenn det(A) == 0 gilt, ist die Matrix singulär (nicht invertierbar). Für eine 2×2-Matrix gilt: det = ad - bc.

# 2x2 matrix: det = a*d - b*c
A <- matrix(c(3, 2, 1, 4), nrow = 2)
det(A)  # 3*4 - 2*1 = 10

# Singular matrix: det = 0
S <- matrix(c(1, 2, 2, 4), nrow = 2)
det(S)  # 0 -> not invertible

# Larger matrix
B <- matrix(c(2, -1, 0,
             -1,  2, -1,
              0, -1,  2), nrow = 3, byrow = TRUE)
det(B)  # 4

Spur: sum(diag())

Die Spur einer Matrix ist die Summe ihrer Diagonalelemente. R verfügt über keine integrierte trace()-Funktion für Matrizen (es handelt sich um eine andere Funktion); verwenden Sie daher sum(diag(A)). Die Spur entspricht der Summe der Eigenwerte.

A <- matrix(c(4, 2, 1,
              3, 5, 0,
              2, 1, 6), nrow = 3, byrow = TRUE)
# Extract diagonal elements
diag(A)  # c(4, 5, 6)

# Trace = sum of diagonal
trace_A <- sum(diag(A))
trace_A  # 15

# Trace = sum of eigenvalues (verify)
eigs <- eigen(A)$values
sum(Re(eigs))  # should also be approximately 15

# trace() in base R is NOT the matrix trace:
# trace(A) # this does something else

crossprod() und tcrossprod()

crossprod(A, B) berechnet effizient t(A) %*% B – das Kreuzprodukt. tcrossprod(A, B) berechnet A %*% t(B). Diese Funktionen sind schneller als die explizite Transposition, da sie das Erstellen der transponierten Matrix vermeiden.

A <- matrix(c(1, 2, 3, 4, 5, 6), nrow = 3)
B <- matrix(c(7, 8, 9, 10, 11, 12), nrow = 3)

# t(A) %*% B  (the slow way)
result1 <- t(A) %*% B

# crossprod(A, B) = t(A) %*% B (faster)
result2 <- crossprod(A, B)
all.equal(result1, result2)  # TRUE

# crossprod(A) = t(A) %*% A
ATA <- crossprod(A)
print(ATA)

# tcrossprod(A, B) = A %*% t(B)
result3 <- tcrossprod(A, B)
all.equal(A %*% t(B), result3)  # TRUE

Einheitsmatrix mit diag()

diag(n) erstellt eine n×n-Einheitsmatrix. diag(v), wobei v ein Vektor ist, erstellt eine Diagonalmatrix mit v auf der Diagonale. diag(A), wobei A eine Matrix ist, extrahiert die Diagonale.

# 3x3 identity matrix
I3 <- diag(3)
print(I3)
#      [,1] [,2] [,3]
# [1,]    1    0    0
# [2,]    0    1    0
# [3,]    0    0    1

# A * I = A (identity property)
A <- matrix(c(2, 3, 4, 5), nrow = 2)
all.equal(A %*% diag(2), A)  # TRUE

# Create diagonal matrix from vector
D <- diag(c(2, 5, 10))
print(D)
det(D)  # Product of diagonal: 100

Matrixpotenz und wiederholte Multiplikation

R verfügt über keinen integrierten Operator für Matrixpotenzen, aber Sie können einen mit %*% in einer Schleife schreiben oder das Paket expm verwenden. Das Matrixquadrat A² = A %*% A ist eine häufige Operation.

# Matrix square
A <- matrix(c(1, 1, 1, 0), nrow = 2)
A_sq <- A %*% A
print(A_sq)
# Fibonacci connection: A^n gives Fib numbers!

# Simple matrix power function
mat_pow <- function(M, n) {
  result <- diag(nrow(M))  # start with identity
  for (i in seq_len(n)) result <- result %*% M
  result
}

mat_pow(A, 5)  # A to the 5th power
# [1,]  8  5
# [2,]  5  3

Äußeres Produkt mit %o%

Das äußere Produkt x %o% y erzeugt eine Matrix, deren Eintrag (i,j) = x[i] * y[j] ist. Es ist gleichbedeutend mit outer(x, y). Es eignet sich zum Erstellen von Interaktionsmatrizen und für bestimmte mathematische Konstruktionen.

x <- c(1, 2, 3)
y <- c(10, 20)

# Outer product: 3x2 matrix
P <- x %o% y
print(P)
#      [,1] [,2]
# [1,]   10   20
# [2,]   20   40
# [3,]   30   60

# Same as outer(x, y)
identical(P, outer(x, y))  # TRUE

# Outer with custom function
outer(1:3, 1:3, FUN = '+')
#      [,1] [,2] [,3]
# [1,]    2    3    4
# [2,]    3    4    5
# [3,]    4    5    6

Eigenschaften der Determinante

Wichtige Eigenschaften: det(A %*% B) = det(A) * det(B); det(t(A)) = det(A); det(k*A) = k^n * det(A) für eine n×n-Matrix; Zeilenoperationen verändern die Determinante auf vorhersehbare Weise.

A <- matrix(c(2, 1, 5, 3), nrow = 2)
B <- matrix(c(4, 2, 1, 6), nrow = 2)

# det(A %*% B) = det(A) * det(B)
det(A %*% B)
det(A) * det(B)

# det(t(A)) = det(A)
det(t(A)); det(A)

# det(2A) = 2^n * det(A) for n=2
det(2 * A); 2^2 * det(A)

# det of upper triangular = product of diagonal
U <- matrix(c(3, 0, 0, 4, 2, 0, 1, 5, 7), nrow = 3, byrow = TRUE)
det(U); prod(diag(U))  # both = 42

Praxis: Normalgleichungen

Bei der linearen Regression löst der OLS-Schätzer t(X) %*% X %*% beta = t(X) %*% y. Dabei werden Matrixmultiplikation und die Bedingung det(t(X)%*%X) != 0 verwendet, um eine eindeutige Lösung sicherzustellen.

# Generate simple regression data
set.seed(42)
n <- 20
x <- runif(n, 0, 10)
y <- 2 + 3 * x + rnorm(n)

# Design matrix with intercept column
X <- cbind(1, x)

# Check det of X'X (should be nonzero)
XtX <- crossprod(X)  # t(X) %*% X
det(XtX)  # large positive value

# Solve normal equations: beta = solve(X'X) %*% X'y
Xty <- crossprod(X, y)  # t(X) %*% y
beta <- solve(XtX) %*% Xty
beta  # Should be close to c(2, 3)

# Compare with lm()
coef(lm(y ~ x))  # same result

Kurzer Test

Testen Sie Ihr Verständnis der Matrixoperationen in R.

Zusammenfassung: Matrixoperationen

Wichtigste Erkenntnisse: Verwenden Sie %*% für Matrixmultiplikation, nicht *. det(A) liefert die Determinante — null bedeutet singulär. sum(diag(A)) ist die Spur. crossprod(A,B) berechnet t(A)%*%B effizient. diag(n) erzeugt die Einheitsmatrix; diag(v) erstellt eine Diagonalmatrix. Diese Operationen bilden die Grundlage für Regression, PCA und viele numerische Verfahren.

A <- matrix(c(2, 1, 1, 3), nrow = 2)
B <- matrix(c(1, 0, 0, 1), nrow = 2)  # Identity

# Core matrix operations summary:
A %*% B             # matrix multiply -> A
det(A)              # 2*3 - 1*1 = 5
sum(diag(A))        # trace = 2+3 = 5
crossprod(A)        # t(A) %*% A
tcrossprod(A)       # A %*% t(A)
diag(3)             # 3x3 identity
diag(c(1,2,3))      # diagonal matrix
A %o% c(1, 2)       # outer product

Häufig gestellte Fragen

Ist die Lektion „Matrixmultiplikation und Determinanten“ kostenlos?

Ja — der vollständige Text von „Matrixmultiplikation und Determinanten“ 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 „Matrixmultiplikation und Determinanten“?

Verwenden Sie %*% für die Matrixmultiplikation und det() zur Berechnung der Determinante. 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 1 von 4.

Wie lange dauert die Lektion „Matrixmultiplikation und Determinanten“?

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