From ecb417eba2ea4a18281b7ba0c622033984b27e03 Mon Sep 17 00:00:00 2001 From: Oliver Hofmann Date: Tue, 25 Mar 2025 20:52:19 +0100 Subject: [PATCH] Max Sequence --- praktika/01_big_o/__init__.py | 0 praktika/01_big_o/max_folge.py | 52 ++++++++++++++++++++++++++++++++++ requirements.txt | 3 ++ utils/constants.py | 42 ++------------------------- utils/literal.py | 5 +++- utils/memory_array.py | 9 +++--- utils/memory_cell.py | 10 ++++--- utils/memory_manager.py | 44 ++++++++++++++++++++++++---- utils/test_memory_array.py | 5 ++-- utils/test_memory_cell.py | 4 +-- 10 files changed, 116 insertions(+), 58 deletions(-) create mode 100644 praktika/01_big_o/__init__.py create mode 100644 praktika/01_big_o/max_folge.py create mode 100644 requirements.txt diff --git a/praktika/01_big_o/__init__.py b/praktika/01_big_o/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/praktika/01_big_o/max_folge.py b/praktika/01_big_o/max_folge.py new file mode 100644 index 0000000..3629315 --- /dev/null +++ b/praktika/01_big_o/max_folge.py @@ -0,0 +1,52 @@ +from utils.memory_array import MemoryArray +from utils.literal import Literal +from utils.memory_cell import MemoryCell +from utils.constants import MIN_VALUE +from utils.memory_manager import MemoryManager + +def max_sequence_1(z: MemoryArray): + n = len(z) + m = MemoryCell(MIN_VALUE) + s = MemoryCell() + l = MemoryCell() + r = MemoryCell() + for i in range(n): + for j in range(i, n): + s.set(0) + for k in range(i, j): + s += z[Literal(k)] + if s > m: + m.set(s) + l.set(i) + r.set(j) + return m, l, r + + +def example(max_sequende_func): + z = MemoryArray(Literal(10)) + for i, v in enumerate([-59, 52, 46, 14, -50, 58, -87, -77, 34, 15]): + z[Literal(i)] = Literal(v) + m, l, r = max_sequende_func(z) + print(m, l, r) + + +def analyze_complexity(max_sequence_func, sizes): + """ + Analysiert die Komplexität einer maximalen Teilfolgenfunktion. + + :param max_sequence_func: Die Funktion, die analysiert wird. + :param sizes: Eine Liste von Eingabegrößen für die Analyse. + """ + for size in sizes: + MemoryManager.purge() # Speicher zurücksetzen + random_array = MemoryArray.create_random_array(size, -100, 100) + max_sequence_func(random_array) + MemoryManager.save_stats(size) + + MemoryManager.plot_stats(["cells", "adds"]) + + + +if __name__ == '__main__': + example(max_sequence_1) + analyze_complexity(max_sequence_1, [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]) \ No newline at end of file diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000..7f12edc --- /dev/null +++ b/requirements.txt @@ -0,0 +1,3 @@ +matplotlib +numpy +pygame diff --git a/utils/constants.py b/utils/constants.py index e683459..b68a192 100644 --- a/utils/constants.py +++ b/utils/constants.py @@ -1,41 +1,5 @@ -from literal import Literal +from utils.literal import Literal -class MinValue(Literal): +MAX_VALUE = Literal(99999999999999999999) +MIN_VALUE = Literal(-99999999999999999999) - def __init__(self): - super().__init__(0) - - def __gt__(self, other): - return False - - def __ge__(self, other): - return False - - def __lt__(self, other): - return True - - def __le__(self, other): - return True - - def __eq__(self, other): - return False - -class MaxValue(Literal): - - def __init__(self): - super().__init__(0) - - def __gt__(self, other): - return True - - def __ge__(self, other): - return True - - def __lt__(self, other): - return False - - def __le__(self, other): - return False - - def __eq__(self, other): - return False \ No newline at end of file diff --git a/utils/literal.py b/utils/literal.py index 61ebbcf..92cd423 100644 --- a/utils/literal.py +++ b/utils/literal.py @@ -2,7 +2,10 @@ class Literal: def __init__(self, value): """Initialisiert Literal.""" - self.value = value + if isinstance(value, Literal): + self.value = value.value + else: + self.value = value self.read_count = 0 self.compare_count = 0 diff --git a/utils/memory_array.py b/utils/memory_array.py index 6000b15..8aeecb6 100644 --- a/utils/memory_array.py +++ b/utils/memory_array.py @@ -1,7 +1,8 @@ -from literal import Literal -from memory_cell import MemoryCell -from memory_manager import MemoryManager +from utils.literal import Literal +from utils.memory_cell import MemoryCell +from utils.memory_manager import MemoryManager from pathlib import Path +from random import randint class MemoryArray: @@ -55,7 +56,7 @@ class MemoryArray: size = Literal(count) a = MemoryArray(size) for i in a.indices(): - a[i] = Literal(random.randint(min_value, max_value)) + a[i] = Literal(randint(min_value, max_value)) a.reset_counters() return a diff --git a/utils/memory_cell.py b/utils/memory_cell.py index 56f97ec..1bc4d60 100644 --- a/utils/memory_cell.py +++ b/utils/memory_cell.py @@ -1,5 +1,5 @@ -from memory_manager import MemoryManager -from literal import Literal +from utils.memory_manager import MemoryManager +from utils.literal import Literal class MemoryCell (Literal): def __init__(self, value=None): @@ -31,7 +31,10 @@ class MemoryCell (Literal): def set(self, new_value): """Schreibt einen neuen Wert in die Speicherzelle und erhöht den Schreibzähler.""" self.write_count += 1 - self.value = new_value + if isinstance(new_value, Literal): + self.value = new_value.value + else: + self.value = new_value def add(self, other): """Addiert den Wert der Speicherzelle mit einem anderen Wert.""" @@ -180,4 +183,3 @@ if __name__ == "__main__": print(f"Ergebnis: {a}") print(f"a wurde {a.get_read_count()} mal gelesen und {a.get_write_count()} mal geschrieben.") print(f"b wurde {b.get_read_count()} mal gelesen und {b.get_write_count()} mal geschrieben.") - MemoryManager.print_statistics() \ No newline at end of file diff --git a/utils/memory_manager.py b/utils/memory_manager.py index 3f094b1..e07012f 100644 --- a/utils/memory_manager.py +++ b/utils/memory_manager.py @@ -1,6 +1,11 @@ +import numpy as np +import matplotlib.pyplot as plt + + class MemoryManager: instance = None + stats = {} @staticmethod def get_instance(): @@ -51,11 +56,40 @@ class MemoryManager: cell.reset_counters @staticmethod - def print_statistics(): - print(f"Anzahl der Speicherzellen: {MemoryManager.count_cells()}") - print(f"Anzahl der Lesezugriffe: {MemoryManager.count_reads()}") - print(f"Anzahl der Schreibzugriffe: {MemoryManager.count_writes()}") - print(f"Anzahl der Vergleiche: {MemoryManager.count_compares()}") + def purge(): + MemoryManager.instance = None + + @staticmethod + def save_stats(count): + data = { "cells": MemoryManager.count_cells(), + "reads": MemoryManager.count_reads(), + "writes": MemoryManager.count_writes(), + "compares": MemoryManager.count_compares(), + "adds": MemoryManager.count_adds(), + "subs": MemoryManager.count_subs(), + "muls": MemoryManager.count_muls(), + "divs": MemoryManager.count_divs(), + "bitops": MemoryManager.count_bitops() } + MemoryManager.stats[count] = data + + @staticmethod + def plot_stats(labels): + data = MemoryManager.stats + x = list(data.keys()) + + fig, axes = plt.subplots(len(labels), 1, figsize=(8, 4 * len(labels)), sharex=True) + + if len(labels) == 1: + axes = [axes] # Falls nur ein Plot vorhanden ist, in eine Liste umwandeln + + for ax, l in zip(axes, labels): + y = [data[k][l] for k in x] + ax.plot(x, y, label=l) + ax.set_ylabel(l) + ax.legend() + + plt.xlabel("n") + plt.show() def __init__(self): self.cells = [] diff --git a/utils/test_memory_array.py b/utils/test_memory_array.py index 29ecc28..0d15eee 100644 --- a/utils/test_memory_array.py +++ b/utils/test_memory_array.py @@ -1,8 +1,7 @@ from unittest import TestCase -from literal import Literal -from memory_array import MemoryArray +from utils.literal import Literal +from utils.memory_array import MemoryArray import random -from pathlib import Path class TestMemoryArray(TestCase): diff --git a/utils/test_memory_cell.py b/utils/test_memory_cell.py index b20d397..8b6578a 100644 --- a/utils/test_memory_cell.py +++ b/utils/test_memory_cell.py @@ -1,6 +1,6 @@ from unittest import TestCase -from memory_cell import MemoryCell -from literal import Literal +from utils.memory_cell import MemoryCell +from utils.literal import Literal import random