93 lines
3.0 KiB
Python
93 lines
3.0 KiB
Python
"""Hilfsfunktionen für grundlegende Matrixoperationen."""
|
|
|
|
from __future__ import annotations
|
|
from typing import List, Sequence, TypeVar
|
|
|
|
Number = TypeVar("Number", int, float)
|
|
|
|
|
|
def matmul(a: Sequence[Sequence[Number]], b: Sequence[Sequence[Number]]) -> List[List[Number]]:
|
|
"""
|
|
Multipliziert zwei Matrizen miteinander.
|
|
|
|
:param a: Die linke Matrix der Dimension (m, n).
|
|
:type a: Sequence[Sequence[Number]]
|
|
:param b: Die rechte Matrix der Dimension (n, p).
|
|
:type b: Sequence[Sequence[Number]]
|
|
:return: Die entstehende Ergebnismatrix der Dimension (m, p).
|
|
:rtype: List[List[Number]]
|
|
:raises ValueError: Wenn die Matrizen aufgrund inkompatibler
|
|
Dimensionen oder unregelmäßiger Form nicht multipliziert werden können.
|
|
"""
|
|
if not a or not b:
|
|
raise ValueError("Matrix-Eingaben dürfen nicht leer sein")
|
|
|
|
m = len(a)
|
|
n = len(a[0])
|
|
for row in a:
|
|
if len(row) != n:
|
|
raise ValueError("Matrix a ist nicht rechteckig")
|
|
|
|
if len(b) != n:
|
|
raise ValueError("Die Anzahl der Spalten in a muss der Anzahl der Zeilen in b entsprechen")
|
|
p = len(b[0])
|
|
for row in b:
|
|
if len(row) != p:
|
|
raise ValueError("Matrix b ist nicht rechteckig")
|
|
|
|
result: List[List[Number]] = [[0 for _ in range(p)] for _ in range(m)]
|
|
for i in range(m):
|
|
for j in range(p):
|
|
total: Number = 0
|
|
for k in range(n):
|
|
total += a[i][k] * b[k][j]
|
|
result[i][j] = total
|
|
return result
|
|
|
|
|
|
def transpose(matrix: Sequence[Sequence[Number]]) -> List[List[Number]]:
|
|
"""
|
|
Transponiert eine Matrix.
|
|
|
|
:param matrix: Die Eingabematrix der Dimension (m, n).
|
|
:type matrix: Sequence[Sequence[Number]]
|
|
:return: Die transponierte Matrix der Dimension (n, m).
|
|
:rtype: List[List[Number]]
|
|
:raises ValueError: Wenn die Matrix leer ist oder Zeilen unterschiedlicher Länge hat.
|
|
"""
|
|
if not matrix or not matrix[0]:
|
|
raise ValueError("Matrix darf nicht leer sein")
|
|
|
|
row_len = len(matrix[0])
|
|
for row in matrix:
|
|
if len(row) != row_len:
|
|
raise ValueError("Die Zeilen der Matrix haben unterschiedliche Längen")
|
|
|
|
n_rows = len(matrix)
|
|
n_cols = row_len
|
|
transposed: List[List[Number]] = [[0] * n_rows for _ in range(n_cols)]
|
|
for i in range(n_rows):
|
|
for j in range(n_cols):
|
|
transposed[j][i] = matrix[i][j]
|
|
return transposed
|
|
|
|
|
|
import math
|
|
|
|
|
|
def rot_2D(theta: Number) -> List[List[Number]]:
|
|
"""
|
|
Erstellt die 2D-Rotationsmatrix für einen gegebenen Winkel.
|
|
|
|
:param theta: Der Winkel in Bogenmaß (Radiant).
|
|
:type theta: Number
|
|
:return: Die Rotationsmatrix ``[[cos(theta), -sin(theta)], [sin(theta), cos(theta)]]``.
|
|
:rtype: List[List[Number]]
|
|
:raises TypeError: Wenn theta kein numerischer Typ ist.
|
|
"""
|
|
if not isinstance(theta, (int, float)):
|
|
raise TypeError("theta muss numerisch sein (int oder float)")
|
|
|
|
cos_t = math.cos(theta)
|
|
sin_t = math.sin(theta)
|
|
return [[cos_t, -sin_t], [sin_t, cos_t]] |