160 lines
5.1 KiB
Python
160 lines
5.1 KiB
Python
# Matrixfunktionen für das Projekt MatrixMania
|
|
|
|
#Was die Aufgabe war:
|
|
#opencode verwenden und python code generieren lassen
|
|
#den generierten code auf funktionalität und clean code prüfen
|
|
#in compute.py sollten wir eine matrixmultiplikation anwenden
|
|
#und das modul danach um eine Transposition und 2d rotationmatrix erweitern
|
|
#gefordert: type hints, docstrings und fehlerbehandlung mit valueerror
|
|
|
|
#auf kurz:
|
|
#Agent generiert code
|
|
#wir prüfen ihn selbst
|
|
#pep 8 beachten
|
|
#verständlicher name
|
|
#type hints
|
|
#docstrings
|
|
#fehler sinnvoll behandeln
|
|
#mindestens einen verbesserungspunkt am Agentencode erkennen
|
|
|
|
|
|
"""Matrix-Operationen ohne externe Bibliotheken (reine Python-Listen)."""
|
|
|
|
import math
|
|
from typing import List #da wir eine aktuelle python version verwenden wäre eingebaute schreibweise mit list[float] beser
|
|
|
|
Matrix = List[List[float]] #Matrix ist hier ein typ alias für eine verschachtelte liste aus zahlen dadurch werden die type hints lesbarer
|
|
|
|
#Funktion matmul: zwei matrizen multiplizieren
|
|
def matmul(matrix_a: Matrix, matrix_b: Matrix) -> Matrix:
|
|
#jetzt kommt mein docstring hier dokumentiert open code:
|
|
#was macht die funktion?
|
|
#wleche parameter bekommt sie? (args)
|
|
#was gibt sie zurück?(returns)
|
|
#welche fehler können auftreten?(raises)
|
|
"""Multipliziere zwei Matrizen ``A * B``. #
|
|
|
|
Args:
|
|
matrix_a: Linke Matrix der Form ``(m, n)``.
|
|
matrix_b: Rechte Matrix der Form ``(n, p)``.
|
|
|
|
Returns:
|
|
Die Produktmatrix der Form ``(m, p)``.
|
|
|
|
Raises:
|
|
ValueError: Wenn ``matrix_a`` weniger Spalten hat, als ``matrix_b``
|
|
Zeilen hat, oder wenn eine der Matrizen leer ist.
|
|
"""
|
|
if not matrix_a or not matrix_b: #sicherheitsprüfung wenn matrix a leer oder matrix b leer ist, breche ab
|
|
raise ValueError("Matrizen dürfen nicht leer sein.") #fehler wird absichtlich ausgeführt
|
|
|
|
#die größe wird bestimmt
|
|
rows_a = len(matrix_a)
|
|
cols_a = len(matrix_a[0])
|
|
rows_b = len(matrix_b)
|
|
cols_b = len(matrix_b[0])
|
|
|
|
#Dimensionsprüfung
|
|
#hier ist auch mein zweiter verbesserungspunkt siehe ausführlich unten
|
|
if cols_a != rows_b:
|
|
raise ValueError(
|
|
"Breite der ersten Matrix muss der Höhe der zweiten entsprechen."
|
|
)
|
|
|
|
result: Matrix = []
|
|
for i in range(rows_a): #i steht für die zeile von a
|
|
result_row: List[float] = []
|
|
for j in range(cols_b): #j steht für die spalte von b
|
|
total = 0
|
|
for k in range(cols_a): #k läuft durch die einszlnen werte die miteinander multipliziert und addiert werden
|
|
total += matrix_a[i][k] * matrix_b[k][j] #"nimm einen wert aus der aktuellen zeile von a multipliziere ihn mit den passenden wert aus der aktuellen spalte von b und addiere das ergebnis zu total
|
|
result_row.append(total) #fügt die fertige zeile zur ergebnismatrix hinzu
|
|
result.append(result_row)
|
|
|
|
return result
|
|
|
|
#Zeilen und Spalten einer Matrix vertauschen
|
|
def transpose(matrix: Matrix) -> Matrix:
|
|
"""Transponiere eine Matrix (Zeilen werden zu Spalten).
|
|
|
|
Args:
|
|
matrix: Nicht leere, rechteckige Matrix.
|
|
|
|
Returns:
|
|
Die transponierte Matrix.
|
|
|
|
Raises:
|
|
ValueError: Wenn die Matrix leer ist oder die Zeilen unterschiedlich
|
|
viele Spalten enthalten.
|
|
"""
|
|
if not matrix or not matrix[0]:
|
|
raise ValueError("Die Matrix darf nicht leer sein.")
|
|
|
|
num_cols = len(matrix[0])
|
|
if any(len(row) != num_cols for row in matrix):
|
|
raise ValueError("Alle Zeilen müssen gleich viele Spalten haben.")
|
|
|
|
return [[matrix[row][col] for row in range(len(matrix))]
|
|
for col in range(num_cols)]
|
|
|
|
|
|
|
|
#Rotationsmatrix für einen Winkel erzeugen
|
|
def rot_2D(theta: float) -> Matrix:
|
|
"""Erzeuge die 2D-Rotationsmatrix für einen Winkel ``theta``.
|
|
|
|
Args:
|
|
theta: Rotationswinkel im Bogenmaß.
|
|
|
|
Returns:
|
|
Die Rotationsmatrix ``[[cos(theta), -sin(theta)],
|
|
[sin(theta), cos(theta)]]``.
|
|
"""
|
|
cosine = math.cos(theta)
|
|
sine = math.sin(theta)
|
|
return [[cosine, -sine], [sine, cosine]]
|
|
|
|
|
|
if __name__ == "__main__": #führe den testcode nur aus wenn compute.py direkt gestartet wird
|
|
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)
|
|
|
|
matrix = [
|
|
[1, 2, 3],
|
|
[4, 5, 6],
|
|
]
|
|
|
|
print("\nTransponierte Matrix:")
|
|
for row in transpose(matrix):
|
|
print(row)
|
|
|
|
print("\nRotationsmatrix für 90 Grad (pi / 2):")
|
|
for row in rot_2D(math.pi / 2):
|
|
print(row)
|
|
|
|
|
|
|
|
|
|
#Code Beurteilung durch opencode generiert
|
|
#1. Der matmul-DocString sagt "weniger Spalten", obwohl der Code allgemein auf != prüft
|
|
#Das sollte präziser dokumentiert werden weil zb 4 != 3 ist True aber ValueError
|
|
#der Code prüft nicht weniger sondern generell nicht gleich
|
|
|
|
|
|
#2.opencode verwendet noch typing.list obwohl meine python version schon die
|
|
#moderne Schreibweise mit list[...] möglich ist und sogar im skript verwendet wird |