Erster Stand:compute.py

compute.py

@@ -0,0 +1,93 @@
+"""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]]