115 lines
3.5 KiB
Python
115 lines
3.5 KiB
Python
"""Einfache Matrixoperationen:
|
||
Multiplikation, Transponieren und Drehung um 90° im Uhrzeigersinn.
|
||
"""
|
||
|
||
from __future__ import annotations
|
||
from typing import List
|
||
|
||
# Eine Matrix ist hier eine Liste von Zeilen mit Zahlen.
|
||
Matrix = List[List[float]]
|
||
|
||
|
||
def matmul(A: Matrix, B: Matrix) -> Matrix:
|
||
"""Multipliziert zwei Matrizen A und B."""
|
||
|
||
# Leere Matrizen sind nicht erlaubt.
|
||
if not A or not B:
|
||
raise ValueError("Matrizen dürfen nicht leer sein")
|
||
|
||
# Prüfen, ob alle Zeilen von A gleich lang sind.
|
||
spalten_A = len(A[0])
|
||
if any(len(zeile) != spalten_A for zeile in A):
|
||
raise ValueError("Matrix A ist nicht rechteckig")
|
||
|
||
# Prüfen, ob alle Zeilen von B gleich lang sind.
|
||
spalten_B = len(B[0])
|
||
if any(len(zeile) != spalten_B for zeile in B):
|
||
raise ValueError("Matrix B ist nicht rechteckig")
|
||
|
||
# Für A × B muss die Spaltenzahl von A
|
||
# der Zeilenzahl von B entsprechen.
|
||
if spalten_A != len(B):
|
||
raise ValueError(
|
||
f"Multiplikation nicht möglich: A hat {spalten_A} Spalten, "
|
||
f"B hat {len(B)} Zeilen"
|
||
)
|
||
|
||
ergebnis: Matrix = []
|
||
|
||
# Jede Zeile von A mit jeder Spalte von B kombinieren.
|
||
for i in range(len(A)):
|
||
ergebnis_zeile: List[float] = []
|
||
|
||
for j in range(spalten_B):
|
||
# Produkte der passenden Elemente bilden und addieren.
|
||
wert = sum(A[i][k] * B[k][j] for k in range(spalten_A))
|
||
ergebnis_zeile.append(wert)
|
||
|
||
ergebnis.append(ergebnis_zeile)
|
||
|
||
return ergebnis
|
||
|
||
|
||
def transpose(M: Matrix) -> Matrix:
|
||
"""Vertauscht Zeilen und Spalten einer Matrix."""
|
||
|
||
if not M:
|
||
raise ValueError("Matrix darf nicht leer sein")
|
||
|
||
# Eine rechteckige Matrix muss gleich lange Zeilen haben.
|
||
spalten = len(M[0])
|
||
if any(len(zeile) != spalten for zeile in M):
|
||
raise ValueError("Matrix ist nicht rechteckig")
|
||
|
||
# Die Elemente jeder Spalte werden zu einer neuen Zeile.
|
||
return [[M[i][j] for i in range(len(M))] for j in range(spalten)]
|
||
|
||
|
||
def rotate90_clockwise(M: Matrix) -> Matrix:
|
||
"""Dreht eine Matrix um 90° im Uhrzeigersinn."""
|
||
|
||
if not M:
|
||
raise ValueError("Matrix darf nicht leer sein")
|
||
|
||
spalten = len(M[0])
|
||
if any(len(zeile) != spalten for zeile in M):
|
||
raise ValueError("Matrix ist nicht rechteckig")
|
||
|
||
# Erst transponieren, dann jede neue Zeile umkehren.
|
||
transponiert = [
|
||
[M[i][j] for i in range(len(M))]
|
||
for j in range(spalten)
|
||
]
|
||
return [zeile[::-1] for zeile in transponiert]
|
||
|
||
|
||
if __name__ == "__main__":
|
||
# Beispiel: Eine 2×3-Matrix mal eine 3×2-Matrix.
|
||
A = [[1, 2, 3], [4, 5, 6]]
|
||
B = [[7, 8], [9, 10], [11, 12]]
|
||
print("A × B:")
|
||
print(matmul(A, B)) # [[58, 64], [139, 154]]
|
||
|
||
# Eine Einheitsmatrix verändert eine Matrix bei der Multiplikation nicht.
|
||
C = [[1, 0, 0], [0, 1, 0], [0, 0, 1]]
|
||
D = [[2, 3, 4], [5, 6, 7], [8, 9, 10]]
|
||
print("D × C:")
|
||
print(matmul(D, C)) # ergibt wieder D
|
||
|
||
# Zeilen und Spalten tauschen.
|
||
E = [[1, 2, 3], [4, 5, 6]]
|
||
print("Transponierte Matrix:")
|
||
print(transpose(E)) # [[1, 4], [2, 5], [3, 6]]
|
||
|
||
# Erst transponieren, dann die Zeilen umkehren.
|
||
F = [[1, 2, 3], [4, 5, 6]]
|
||
print("90° im Uhrzeigersinn gedreht:")
|
||
print(rotate90_clockwise(F)) # [[4, 1], [5, 2], [6, 3]]
|
||
|
||
def rot_2D(theta: float):
|
||
"""Return a 2x2 rotation matrix for angle theta in radians."""
|
||
import math
|
||
c = math.cos(theta)
|
||
s = math.sin(theta)
|
||
return [[c, -s], [s, c]]
|
||
# Katzen-Test |