erster commit

compute.py

@@ -0,0 +1,157 @@
+import math
+from tabulate import tabulate
+
+def matmul(matrix_a: list[list[float | int]], matrix_b: list[list[float | int]]) -> list[list[float | int]]:
+    """Multipliziert zwei Matrizen, die als verschachtelte Listen dargestellt sind.
+
+    Args:
+        matrix_a: Die erste Matrix als 2D-Liste (Größe m x n).
+        matrix_b: Die zweite Matrix als 2D-Liste (Größe n x p).
+
+    Returns:
+        Die resultierende Produkt-Matrix als 2D-Liste (Größe m x p).
+
+    Raises:
+        ValueError: Wenn die Breite der ersten Matrix (Anzahl der Spalten)
+                    nicht der Höhe der zweiten Matrix (Anzahl der Zeilen) entspricht.
+    """
+    if not matrix_a or not matrix_b or not matrix_a[0] or not matrix_b[0]:
+        raise ValueError("Die Matrizen dürfen nicht leer sein.")
+
+    rows_a = len(matrix_a)
+    cols_a = len(matrix_a[0])
+    rows_b = len(matrix_b)
+    cols_b = len(matrix_b[0])
+
+    # Überprüfung, ob die Multiplikation mathematisch möglich ist
+    if cols_a != rows_b:
+        raise ValueError(
+            f"Multiplikation nicht möglich: Breite von matrix_a ({cols_a}) "
+            f"stimmt nicht mit der Höhe von matrix_b ({rows_b}) überein."
+        )
+
+    # Berechnung des Matrixprodukts über eine List Comprehension
+    result = [
+        [
+            sum(matrix_a[i][k] * matrix_b[k][j] for k in range(cols_a))
+            for j in range(cols_b)
+        ]
+        for i in range(rows_a)
+    ]
+
+    return result
+
+
+def transpose(matrix: list[list[float | int]]) -> list[list[float | int]]:
+    """Transponiert eine Matrix (tauscht Zeilen und Spalten).
+
+    Args:
+        matrix: Die zu transponierende Matrix als 2D-Liste (m x n).
+
+    Returns:
+    Die transponierte Matrix als 2D-Liste (n x m).
+
+    Raises:
+        ValueError: Wenn die Matrix leer ist oder ungleichmäßig viele Spalten
+                    in den Zeilen besitzt (keine echte Matrix).
+    """
+    if not matrix or not matrix[0]:
+        raise ValueError("Die Matrix darf nicht leer sein.")
+
+    cols = len(matrix[0])
+
+    # Überprüfen, ob alle Zeilen exakt gleich viele Spalten haben
+    for row in matrix:
+        if len(row) != cols:
+            raise ValueError(
+                "Ungleichmäßige Matrix: Nicht jede Zeile hat dieselbe Anzahl an Spalten."
+            )
+
+    # Transponieren via Zip-Unpacking
+    return [list(row) for row in zip(*matrix)]
+
+
+
+def rot_2D(theta: float) -> list[list[float]]:
+    """Gibt die 2D-Rotationsmatrix für einen gegebenen Winkel theta (in Bogenmaß) zurück.
+
+    Args:
+        theta: Der Rotationswinkel in Bogenmaß (Radians).
+
+    Returns:
+        Die 2x2-Rotationsmatrix als 2D-Liste:
+        [[cos(theta), -sin(theta)],
+         [sin(theta),  cos(theta)]]
+    """
+    cos_theta = math.cos(theta)
+    sin_theta = math.sin(theta)
+
+    return [
+        [cos_theta, -sin_theta],
+        [sin_theta, cos_theta]
+    ]
+
+
+if __name__ == "__main__":
+
+ #matmul prüfung
+    matrix_a = [ [ 3, 4, -1, 4 ],
+                    [ -2, 2, 5, 1 ]
+                ]
+    matrix_b = [ [ 1, 3, -2 ],
+                [ 2, 5, 1 ],
+                [ -1, 4, -4 ],
+                [ 2, 3, 6 ]
+                ]
+    matrix_c = matmul(matrix_a, matrix_b)
+    print("Ergebnis C = A * B:")
+    for row in matrix_c:
+        print(row)
+
+    try:
+        matrix_c = [[1,2],[3,4]]
+        matrix_d = [[5,6]]
+        ergebnis = matmul(matrix_c, matrix_d)
+        print("Ergebnis:", ergebnis)
+
+    except ValueError as e:
+        print(f"Fehler abgefangen (matmul): {e}")
+
+#Agent Fehler ausgebessert: list[list/[float | int] -> list[list[float | int]
+#Gut gelöst -> TypeHints beachtet und verständlichen DocString; Ruff check passed
+
+#transpose prüfung
+    matrix = [
+        [1, 2, 3],
+        [4, 5, 6]
+    ]
+    print(transpose(matrix))
+    # Erwartete Ausgabe:
+    # [
+    # [1, 4],
+    # [2, 5],
+    # [3, 6]
+    # ]
+    matrix_2 = [
+        [1, 2, 3],
+        [4, 5, 6]
+    ]
+    print(transpose(matrix_2))
+
+    try:
+        un_matrix = [
+            [1, 2, 3],
+            [4, 5]
+        ]
+
+        ergebnis = transpose(un_matrix)
+        print("Ergebnis:", ergebnis)
+
+    except ValueError as e:
+        print(f"Fehler erfolgreich abgefangen (transpose): {e}")
+
+    #rotation prüfung
+    theta = math.pi / 2 #1,57...
+    print(f"Winkel: {math.degrees(theta)} Grad (pi / 2)")
+    print(rot_2D(theta))
+    print(tabulate(rot_2D(1.0)))