Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
127 lines
3.5 KiB
Python
127 lines
3.5 KiB
Python
"""Matrix-Funktionen: Multiplikation, Transponieren und 2D-Rotation."""
|
|
|
|
import math
|
|
|
|
from tabulate import tabulate
|
|
|
|
# Alle Matrizen sind Listen von Zeilen, z.B. [[1, 2], [3, 4]].
|
|
|
|
|
|
def check_matrix(matrix: list[list[float]]) -> None:
|
|
"""Prüft, ob die Matrix gültig ist.
|
|
|
|
Raises
|
|
------
|
|
ValueError
|
|
Wenn die Matrix leer ist oder die Zeilen unterschiedlich lang sind.
|
|
"""
|
|
if not matrix:
|
|
raise ValueError("Matrix darf nicht leer sein")
|
|
for row in matrix:
|
|
if len(row) != len(matrix[0]):
|
|
raise ValueError("Alle Zeilen müssen gleich lang sein")
|
|
|
|
|
|
def matmul(a: list[list[float]], b: list[list[float]]) -> list[list[float]]:
|
|
"""Multipliziert zwei Matrizen (a mal b).
|
|
|
|
Raises
|
|
------
|
|
ValueError
|
|
Wenn eine Matrix ungültig ist oder die Spaltenzahl von a
|
|
nicht zur Zeilenzahl von b passt.
|
|
"""
|
|
check_matrix(a)
|
|
check_matrix(b)
|
|
if len(a[0]) != len(b):
|
|
raise ValueError("Spaltenzahl von a muss gleich Zeilenzahl von b sein")
|
|
|
|
result = []
|
|
for i in range(len(a)): # jede Zeile von a
|
|
new_row = []
|
|
for j in range(len(b[0])): # jede Spalte von b
|
|
total = 0
|
|
for k in range(len(b)): # Zeile mal Spalte
|
|
total += a[i][k] * b[k][j]
|
|
new_row.append(total)
|
|
result.append(new_row)
|
|
return result
|
|
|
|
|
|
def transpose(matrix: list[list[float]]) -> list[list[float]]:
|
|
"""Transponiert eine Matrix: Zeilen werden zu Spalten.
|
|
|
|
Raises
|
|
------
|
|
ValueError
|
|
Wenn die Matrix ungültig ist.
|
|
"""
|
|
check_matrix(matrix)
|
|
result = []
|
|
for col in range(len(matrix[0])):
|
|
new_row = []
|
|
for row in range(len(matrix)):
|
|
new_row.append(matrix[row][col])
|
|
result.append(new_row)
|
|
return result
|
|
|
|
|
|
def rot_2D(angle: float) -> list[list[float]]:
|
|
"""Gibt die 2D-Rotationsmatrix zum Winkel angle zurück.
|
|
|
|
Multipliziert man die Matrix mit einem Punkt (x, y) als Spaltenvektor,
|
|
erhält man den um angle gedrehten Punkt (x', y').
|
|
|
|
Parameters
|
|
----------
|
|
angle : float
|
|
Drehwinkel im Bogenmaß (z.B. math.pi / 2 für 90 Grad).
|
|
|
|
Returns
|
|
-------
|
|
list[list[float]]
|
|
Die 2x2-Matrix [[cos, -sin], [sin, cos]].
|
|
"""
|
|
cos = math.cos(angle)
|
|
sin = math.sin(angle)
|
|
return [[cos, -sin], [sin, cos]]
|
|
|
|
|
|
if __name__ == "__main__":
|
|
# matmul
|
|
assert matmul([[1, 2], [3, 4]], [[5, 6], [7, 8]]) == [[19, 22], [43, 50]]
|
|
assert matmul([[1, 2, 3], [4, 5, 6]], [[7, 8], [9, 10], [11, 12]]) == [
|
|
[58, 64],
|
|
[139, 154],
|
|
]
|
|
|
|
# transpose
|
|
assert transpose([[1, 2, 3], [4, 5, 6]]) == [[1, 4], [2, 5], [3, 6]]
|
|
assert transpose([[7, 8], [9, 10]]) == [[7, 9], [8, 10]]
|
|
|
|
# rot_2D
|
|
assert rot_2D(0) == [[1, 0], [0, 1]] # 0 Grad: nichts ändert sich
|
|
# Punkt (1, 0) um 90 Grad drehen -> (0, 1)
|
|
point = [[1], [0]]
|
|
rotated = matmul(rot_2D(math.pi / 2), point)
|
|
assert math.isclose(rotated[0][0], 0, abs_tol=1e-9)
|
|
assert math.isclose(rotated[1][0], 1, abs_tol=1e-9)
|
|
|
|
# Fehlerfälle: hier muss ein ValueError kommen
|
|
try:
|
|
matmul([[1, 2], [3, 4]], [[1, 2, 3]]) # Dimensionen passen nicht
|
|
raise AssertionError("ValueError erwartet")
|
|
except ValueError:
|
|
pass
|
|
|
|
try:
|
|
transpose([[1, 2], [3]]) # Zeilen ungleich lang
|
|
raise AssertionError("ValueError erwartet")
|
|
except ValueError:
|
|
pass
|
|
|
|
print("All tests passed")
|
|
|
|
# Rotationsmatrix für 1 rad als Tabelle ausgeben
|
|
print(tabulate(rot_2D(1.0)))
|