Initial commit of project

compute.py

@@ -0,0 +1,115 @@
+"""Einfache Matrixoperationen:
+Multiplikation, Transponieren und Drehung um 90° im Uhrzeigersinn.
+"""
+
+from __future__ import annotations
+from typing import List
+
+# Eine Matrix ist hier eine Liste von Zeilen mit Zahlen.
+Matrix = List[List[float]]
+
+
+def matmul(A: Matrix, B: Matrix) -> Matrix:
+    """Multipliziert zwei Matrizen A und B."""
+
+    # Leere Matrizen sind nicht erlaubt.
+    if not A or not B:
+        raise ValueError("Matrizen dürfen nicht leer sein")
+
+    # Prüfen, ob alle Zeilen von A gleich lang sind.
+    spalten_A = len(A[0])
+    if any(len(zeile) != spalten_A for zeile in A):
+        raise ValueError("Matrix A ist nicht rechteckig")
+
+    # Prüfen, ob alle Zeilen von B gleich lang sind.
+    spalten_B = len(B[0])
+    if any(len(zeile) != spalten_B for zeile in B):
+        raise ValueError("Matrix B ist nicht rechteckig")
+
+    # Für A × B muss die Spaltenzahl von A
+    # der Zeilenzahl von B entsprechen.
+    if spalten_A != len(B):
+        raise ValueError(
+            f"Multiplikation nicht möglich: A hat {spalten_A} Spalten, "
+            f"B hat {len(B)} Zeilen"
+        )
+
+    ergebnis: Matrix = []
+
+    # Jede Zeile von A mit jeder Spalte von B kombinieren.
+    for i in range(len(A)):
+        ergebnis_zeile: List[float] = []
+
+        for j in range(spalten_B):
+            # Produkte der passenden Elemente bilden und addieren.
+            wert = sum(A[i][k] * B[k][j] for k in range(spalten_A))
+            ergebnis_zeile.append(wert)
+
+        ergebnis.append(ergebnis_zeile)
+
+    return ergebnis
+
+
+def transpose(M: Matrix) -> Matrix:
+    """Vertauscht Zeilen und Spalten einer Matrix."""
+
+    if not M:
+        raise ValueError("Matrix darf nicht leer sein")
+
+    # Eine rechteckige Matrix muss gleich lange Zeilen haben.
+    spalten = len(M[0])
+    if any(len(zeile) != spalten for zeile in M):
+        raise ValueError("Matrix ist nicht rechteckig")
+
+    # Die Elemente jeder Spalte werden zu einer neuen Zeile.
+    return [[M[i][j] for i in range(len(M))] for j in range(spalten)]
+
+
+def rotate90_clockwise(M: Matrix) -> Matrix:
+    """Dreht eine Matrix um 90° im Uhrzeigersinn."""
+
+    if not M:
+        raise ValueError("Matrix darf nicht leer sein")
+
+    spalten = len(M[0])
+    if any(len(zeile) != spalten for zeile in M):
+        raise ValueError("Matrix ist nicht rechteckig")
+
+    # Erst transponieren, dann jede neue Zeile umkehren.
+    transponiert = [
+        [M[i][j] for i in range(len(M))]
+        for j in range(spalten)
+    ]
+    return [zeile[::-1] for zeile in transponiert]
+
+
+if __name__ == "__main__":
+    # Beispiel: Eine 2×3-Matrix mal eine 3×2-Matrix.
+    A = [[1, 2, 3], [4, 5, 6]]
+    B = [[7, 8], [9, 10], [11, 12]]
+    print("A × B:")
+    print(matmul(A, B))  # [[58, 64], [139, 154]]
+
+    # Eine Einheitsmatrix verändert eine Matrix bei der Multiplikation nicht.
+    C = [[1, 0, 0], [0, 1, 0], [0, 0, 1]]
+    D = [[2, 3, 4], [5, 6, 7], [8, 9, 10]]
+    print("D × C:")
+    print(matmul(D, C))  # ergibt wieder D
+
+    # Zeilen und Spalten tauschen.
+    E = [[1, 2, 3], [4, 5, 6]]
+    print("Transponierte Matrix:")
+    print(transpose(E))  # [[1, 4], [2, 5], [3, 6]]
+
+    # Erst transponieren, dann die Zeilen umkehren.
+    F = [[1, 2, 3], [4, 5, 6]]
+    print("90° im Uhrzeigersinn gedreht:")
+    print(rotate90_clockwise(F))  # [[4, 1], [5, 2], [6, 3]]
+
+def rot_2D(theta: float):
+    """Return a 2x2 rotation matrix for angle theta in radians."""
+    import math
+    c = math.cos(theta)
+    s = math.sin(theta)
+    return [[c, -s], [s, c]]
+# Katzen-Test