From efbd44d1820042ecf11b462ed9bb51c71e3ed097 Mon Sep 17 00:00:00 2001
From: rapplu93184 <rapplu93184@th-nuernberg.de>
Date: Tue, 20 Oct 2026 16:05:39 +0200
Subject: [PATCH] =?UTF-8?q?compute=20hinzugef=C3=BCgt?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 compute.py | 169 +++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 169 insertions(+)
 create mode 100644 compute.py

diff --git a/compute.py b/compute.py
new file mode 100644
index 0000000..5ae38a9
--- /dev/null
+++ b/compute.py
@@ -0,0 +1,169 @@
+"""Modul zur Matrizenmultiplikation."""
+from __future__ import annotations
+import math
+
+
+Matrix = list[list[float]]
+
+
+def matmul(a: Matrix, b: Matrix) -> Matrix:
+    """Multipliziert zwei Matrizen a * b.
+
+    Args:
+        a: Erste Matrix der Dimension (m x n).
+        b: Zweite Matrix der Dimension (n x p).
+
+    Returns:
+        Ergebnismatrix der Dimension (m x p).
+
+    Raises:
+        ValueError: Wenn die Matrizen leer sind, unregulär sind
+            (ungleiche Zeilenlängen) oder die Innen Dimensionen
+            nicht zusammenpassen (a.Zeilen != b.Spalten).
+    """
+    if not a or not b:
+        raise ValueError("Matrizen duerfen nicht leer sein.")
+
+    rows_a = len(a)
+    cols_a = len(a[0])
+    rows_b = len(b)
+    cols_b = len(b[0])
+
+    for row in a:
+        if len(row) != cols_a:
+            raise ValueError("Matrix a ist nicht rechteckig.")
+    for row in b:
+        if len(row) != cols_b:
+            raise ValueError("Matrix b ist nicht rechteckig.")
+
+    if cols_a != rows_b:
+        raise ValueError(
+            f"Nicht passende Dimensionen: a ist {rows_a}x{cols_a}, "
+            f"b ist {rows_b}x{cols_b} (a.Spalten muss b.Zeilen sein)."
+        )
+
+    result: Matrix = []
+    for i in range(rows_a):
+        new_row: list[float] = []
+        for j in range(cols_b):
+            new_row.append(sum(a[i][k] * b[k][j] for k in range(cols_a)))
+        result.append(new_row)
+    return result
+
+
+def transpose(m: Matrix) -> Matrix:
+    """Transponiert die gegebene Matrix.
+
+    Args:
+        m: Matrix von Dimension (rows x cols).
+    Returns:
+        Eine neue Matrix mit umgekehrter Dimension (cols x rows).
+    """
+    if not m:
+        raise ValueError("Matrix darf nicht leer sein.")
+    rows = len(m)
+    cols = len(m[0])
+    # überprüfen, ob die Matrix rechteckig ist
+    for row in m:
+        if len(row) != cols:
+            raise ValueError("Matrix ist nicht rechteckig.")
+    # Transponieren
+    return [[m[r][c] for r in range(rows)] for c in range(cols)]
+
+def rot_2D(m: Matrix | float) -> Matrix:
+    """Rotiert die Matrix um 90 Grad im Uhrzeigersinn.
+
+    Falls ``m`` ein Zahlenwert ist, wird die Rotationsmatrix
+    für den Winkel ``m`` (in Bogenmaß) zurückgegeben. Andernfalls
+    wird die Matrix um 90° gedreht.
+
+    Args:
+        m: Eingabe‑Matrix oder Winkel in Radiant.
+    Returns:
+        Rotierte Matrix bzw. 2×2‑Rotationsmatrix.
+    """
+    if isinstance(m, (int, float)):
+        theta = float(m)
+        c = math.cos(theta)
+        s = math.sin(theta)
+        return [[c, -s], [s, c]]
+    # Ansonsten normal 90°‑Rotation (wie bisher)
+    if not m:
+        raise ValueError("Matrix darf nicht leer sein.")
+    rows = len(m)
+    cols = len(m[0])
+    for row in m:
+        if len(row) != cols:
+            raise ValueError("Matrix ist nicht rechteckig.")
+    return [[m[row][col] for row in reversed(range(rows))] for col in range(cols)]
+
+
+
+
+
+
+if __name__ == "__main__":
+    # Beispiel 1: klassischer Fall 2x3 * 3x2 -> 2x2
+    a1 = [[1, 2, 3],
+          [4, 5, 6]]
+    b1 = [[7, 8],
+          [9, 10],
+          [11, 12]]
+    expected1 = [[58, 64],
+                 [139, 154]]
+    got1 = matmul(a1, b1)
+    assert got1 == expected1, f"Beispiel 1 fehlgeschlagen: {got1}"
+    print("Beispiel 1 ok:", got1)
+
+    # Beispiel 4: Transponieren einer 3x2 Matrix -> 2x3
+    m4 = [[1, 2],
+          [3, 4],
+          [5, 6]]
+    expected4 = [[1, 3, 5],
+                 [2, 4, 6]]
+    got4 = transpose(m4)
+    assert got4 == expected4, f"Beispiel 4 fehlgeschlagen: {got4}"
+    print("Beispiel 4 ok:", got4)
+
+    # Beispiel 5: Transponieren einer Einheitsmatrix -> gleich
+    e5 = [[1, 0, 0],
+          [0, 1, 0],
+          [0, 0, 1]]
+    got5 = transpose(e5)
+    assert got5 == e5, f"Beispiel 5 fehlgeschlagen: {got5}"
+    print("Beispiel 5 ok:", got5)
+
+    # Beispiel 6: Fehlerfall – transponieren leerer Matrix
+    try:
+        transpose([])
+    except ValueError as err:
+        print("Beispiel 6 ok (Fehler erwartet):", err)
+
+    m7 = [[1, 2, 3],
+          [4, 5, 6]]
+    expected7 = [[4, 1],
+                 [5, 2],
+                 [6, 3]]
+    got7 = rotate(m7)
+    assert got7 == expected7, f"Beispiel 7 fehlgeschlagen: {got7}"
+    print("Beispiel 7 ok:", got7)
+
+    # Beispiel 8: Rotation einer quadratischen 3x3 Matrix
+    m8 = [[1, 2, 3],
+          [4, 5, 6],
+          [7, 8, 9]]
+    expected8 = [[7, 4, 1],
+                 [8, 5, 2],
+                 [9, 6, 3]]
+    got8 = rotate(m8)
+    assert got8 == expected8, f"Beispiel 8 fehlgeschlagen: {got8}"
+    print("Beispiel 8 ok:", got8)
+
+    # Beispiel 9: Fehlerfall – Rotation leerer Matrix
+    try:
+        rotate([])
+    except ValueError as err:
+        print("Beispiel 9 ok (Fehler erwartet):", err)
+    else:
+        raise AssertionError("ValueError wurde nicht ausgeloest.")
+