Init

utils/constants.py

@@ -0,0 +1,5 @@
+from utils.literal import Literal
+
+MAX_VALUE = Literal(99999999999999999999)
+MIN_VALUE = Literal(-99999999999999999999)
+

utils/game.py

@@ -0,0 +1,53 @@
+import pygame
+
+class Game:
+
+    def __init__(self, title, fps=60, size=(640, 400)):
+        self.title = title
+        self.fps = fps
+        self.size = size
+        self.clock = pygame.time.Clock()
+        self.dt = 0
+        self.screen = None
+
+    def init_game(self):
+        pygame.init()
+        pygame.display.set_caption(self.title)
+        self.screen = pygame.display.set_mode(self.size)
+
+
+    def game_loop(self):
+        while True:
+            # Berechnung der Zeitdifferenz seit dem letzten Frame
+            self.dt = self.clock.tick(self.fps) / 1000
+            if self.event_handling() == False:
+                break
+            if self.update_game() == False:
+                break
+            self.draw_game()
+
+    def exit_game(self):
+        pygame.quit()
+
+    def event_handling(self):  # bleibt in der Unterklasse unverändert
+        for event in pygame.event.get():
+            if not self.handle_event(event):
+                return False
+        return True
+
+    def handle_event(self, event):  # wird in der Unterklasse überschrieben
+        if event.type == pygame.QUIT:
+            return False
+        return True
+
+    def update_game(self):
+        return True
+
+    def draw_game(self):
+        pygame.display.flip()
+
+    def run(self):
+        self.init_game()
+        self.game_loop()
+        self.exit_game()
+

utils/literal.py

@@ -0,0 +1,103 @@
+
+class Literal:
+    def __init__(self, value):
+        """Initialisiert Literal."""
+        if isinstance(value, Literal):
+            self.value = value.value
+        else:
+            self.value = value
+        self.read_count = 0
+        self.compare_count = 0
+
+    def reset_counters(self):
+        """Setzt alle Zähler auf 0 zurück."""
+        self.read_count = 0
+        self.compare_count = 0
+
+    def get(self):
+        """Liest den Wert aus."""
+        self.read_count += 1
+        return self.value
+
+    def __eq__(self, other):
+        """Vergleicht den Wert mit einem anderen Wert."""
+        if other is None:
+            return False
+        assert isinstance(other, Literal), "Can only compare with Literal or MemoryCell"
+        self.compare_count += 1
+        self.read_count += 1
+        other.read_count += 1
+        return self.value == other.value
+
+    def __ne__(self, other):
+        """Vergleicht den Wert der Speicherzelle mit einem anderen Wert."""
+        if other is None:
+            return True
+        assert isinstance(other, Literal), "Can only compare with Literal or MemoryCell"
+        self.compare_count += 1
+        self.read_count += 1
+        other.read_count += 1
+        return self.value != other.value
+
+    def __lt__(self, other):
+        """Vergleicht den Wert der Speicherzelle mit einem anderen Wert."""
+        assert isinstance(other, Literal), "Can only compare with Literal or MemoryCell"
+        self.compare_count += 1
+        self.read_count += 1
+        other.read_count += 1
+        return self.value < other.value
+
+    def __le__(self, other):
+        """Vergleicht den Wert der Speicherzelle mit einem anderen Wert."""
+        assert isinstance(other, Literal), "Can only compare with Literal or MemoryCell"
+        self.compare_count += 1
+        self.read_count += 1
+        other.read_count += 1
+        return self.value <= other.value
+
+    def __gt__(self, other):
+        """Vergleicht den Wert der Speicherzelle mit einem anderen Wert."""
+        assert isinstance(other, Literal), "Can only compare with Literal or MemoryCell"
+        self.compare_count += 1
+        self.read_count += 1
+        other.read_count += 1
+        return self.value > other.value
+
+    def __ge__(self, other):
+        """Vergleicht den Wert der Speicherzelle mit einem anderen Wert."""
+        assert isinstance(other, Literal), "Can only compare with Literal or MemoryCell"
+        self.compare_count += 1
+        self.read_count += 1
+        other.read_count += 1
+        return self.value >= other.value
+
+    def __str__(self):
+        """Repräsentation des Werts."""
+        return f"{self.value}"
+
+    def __repr__(self):
+        """Repräsentation des Werts für Debugging-Zwecke."""
+        return f"Literal(value={self.value}, reads={self.read_count})"
+
+    def get_read_count(self):
+        """Gibt zurück, wie oft der Wert gelesen wurde."""
+        return self.read_count
+
+    def __int__(self):
+        """Gibt den Wert als Integer zurück."""
+        self.read_count += 1
+        return int(self.value)
+
+    def succ(self):
+        return Literal(self.value+1)
+
+    def pred(self):
+        return Literal(self.value-1)
+
+
+if __name__ == "__main__":
+    l1 = Literal(5)
+    l2 = Literal(3)
+    print(l1 == l2)
+    print(l1 > l2)
+

utils/memory_array.py

@@ -0,0 +1,126 @@
+from utils.literal import Literal
+from utils.memory_cell import MemoryCell
+from utils.memory_manager import MemoryManager
+from utils.project_dir import get_path
+from random import randint
+
+class MemoryArray:
+
+    def __init__(self, parm):
+        if isinstance(parm, Literal):
+            self.init_with_size(parm)
+        elif isinstance(parm, list):
+            self.size = len(parm)
+            self.cells = [MemoryCell(value) for value in parm]
+        else:
+            raise ValueError("Invalid parameter type")
+
+    def init_with_size(self, size):
+        """Initialisiert ein Speicherarray mit einer bestimmten Größe."""
+        assert isinstance(size, Literal), "Size must be a Literal or MemoryCell"
+        assert isinstance(size.value, int), "Size must be an int"
+        assert size.value > 0, "Size must be positive"
+        self.size = size.value
+        self.cells = [MemoryCell() for _ in range(self.size)]
+
+    def __getitem__(self, index):
+        """Gibt den Wert einer Speicherzelle zurück."""
+        assert isinstance(index, Literal), "Index must be a Literal or MemoryCell"
+        assert isinstance(index.value, int), "Index value must be an int"
+        assert 0 <= index.value < self.size, "Index out of bounds"
+        return self.cells[index.value]
+
+    def __setitem__(self, index, value):
+        """Setzt den Wert einer Speicherzelle."""
+        assert isinstance(index, Literal), "Index must be a Literal or MemoryCell"
+        assert isinstance(index.value, int), "Index value must be an int"
+        assert 0 <= index.value < self.size, "Index out of bounds"
+        assert isinstance(value, Literal), "Value must be a Literal or MemoryCell"
+        self.cells[index.value].set(value.value)
+
+    def __len__(self):
+        """Gibt die Größe des Speicherarrays zurück."""
+        return self.size
+
+    def __str__(self):
+        """Gibt eine Liste der Speicherzellen zurück."""
+        return str([cell.value for cell in self.cells])
+
+    def __iter__(self):
+        """Gibt einen Iterator über die Speicherzellen zurück."""
+        return iter(self.cells)
+
+    def indices(self):
+        """Gibt eine Liste der Indizes der Speicherzellen zurück."""
+        return [Literal(i) for i in range(self.size)]
+
+    def length(self):
+        """Gibt die Größe des Speicherarrays zurück."""
+        return Literal(self.size)
+
+    def count_compares(self):
+        return sum([cell.compare_count for cell in self.cells])
+
+
+    def reset_counters(self):
+        """Setzt alle Zähler auf 0 zurück."""
+        for cell in self.cells:
+            cell.reset_counters()
+
+    @staticmethod
+    def create_random_array(count, min_value, max_value):
+        """Erzeugt ein zufälliges Speicherarray."""
+        size = Literal(count)
+        a = MemoryArray(size)
+        for i in a.indices():
+            a[i] = Literal(randint(min_value, max_value))
+        a.reset_counters()
+        return a
+
+    @staticmethod
+    def create_sorted_array(count):
+        """Erzeugt ein sortiertes Speicherarray."""
+        a = MemoryArray(list(range(count)))
+        a.reset_counters()
+        return a
+
+
+    @staticmethod
+    def create_array_from_file(filename, limit=None):
+        """Erzeugt ein Speicherarray aus einer Datei."""
+        filename = get_path(filename)
+        with open(filename) as f:
+            lines = f.readlines()
+        if limit is not None:
+            lines = lines[:limit]
+        size = Literal(len(lines))
+        a = MemoryArray(size)
+        for i, line in enumerate(lines):
+            a[Literal(i)] = Literal(int(line))
+        a.reset_counters()
+        return a
+
+    def __str__(self):
+        result = "[ "
+        for cell in self.cells:
+            result += str(cell) + ", "
+        result += "]"
+        return result
+
+
+if __name__ == "__main__":
+    import random
+    size = Literal(5)
+    a = MemoryArray(size)
+    for i in a.indices():
+        a[i] = Literal(random.randint(1,100))
+    print(a)
+    s = MemoryCell(0)
+    for cell in a.cells:
+        s += cell
+    print(s)
+    print(f"Anzahl der Additionen: {MemoryManager.count_adds()}")
+
+    a = MemoryArray.create_array_from_file("data/seq0.txt")
+    print(a)
+

utils/memory_cell.py

@@ -0,0 +1,194 @@
+from utils.memory_manager import MemoryManager
+from utils.literal import Literal
+
+class MemoryCell (Literal):
+
+    def __new__(cls, *args, **kwargs):
+        """Erstellt eine neue Instanz von MemoryCell."""
+        instance = MemoryManager().acquire_cell()
+        if instance is None:
+            instance = super().__new__(cls)
+            MemoryManager().register_cell(instance)
+        return instance
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        MemoryManager().release_cell(self)
+
+    def __init__(self, value=None):
+        """Initialisiert eine Speicherzelle mit optionalem Startwert."""
+        super().__init__(value)
+        self.write_count = 0
+        self.add_count = 0
+        self.sub_count = 0
+        self.mul_count = 0
+        self.div_count = 0
+        self.bitop_count = 0
+        if value is not None:
+            self.write_count +=1
+        else:
+            self.value = 0
+
+    def reset_counters(self):
+        """Setzt alle Zähler auf 0 zurück."""
+        super().reset_counters()
+        self.write_count = 0
+        self.add_count = 0
+        self.sub_count = 0
+        self.mul_count = 0
+        self.div_count = 0
+        self.bitop_count = 0
+
+    def set(self, new_value):
+        """Schreibt einen neuen Wert in die Speicherzelle und erhöht den Schreibzähler."""
+        self.write_count += 1
+        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."""
+        self.set((self + other).value)
+
+    def sub(self, other):
+        """Subtrahiert den Wert der Speicherzelle mit einem anderen Wert."""
+        self.set((self - other).value)
+
+    def mul(self, other):
+        """Multipliziert den Wert der Speicherzelle mit einem anderen Wert."""
+        self.set((self * other).value)
+
+    def div(self, other):
+        """Dividiert den Wert der Speicherzelle durch einen anderen Wert."""
+        self.set((self // other).value)
+
+    def modulo(self, other):
+        """Berechnet den Modulo des Wertes der Speicherzelle durch einen anderen Wert."""
+        self.set((self % other).value)
+
+    def lshift(self, other):
+        """Verschiebt den Wert der Speicherzelle um eine bestimmte Anzahl von Bits nach links."""
+        assert isinstance(other, Literal), "Can only lshift Literal or MemoryCell by MemoryCell"
+        self.bitop_count += 1
+        self.read_count += 1
+        self.write_count += 1
+        other.read_count += 1
+        self.value <<= other.value
+
+    def rshift(self, other):
+        """Verschiebt den Wert der Speicherzelle um eine bestimmte Anzahl von Bits nach rechts."""
+        assert isinstance(other, Literal), "Can only rshift Literal or MemoryCell by MemoryCell"
+        self.bitop_count += 1
+        self.read_count += 1
+        self.write_count += 1
+        other.read_count += 1
+        self.value >>= other.value
+
+    def and_op(self, other):
+        """Führt ein Bitweise AND auf den Wert der Speicherzelle mit einem anderen Wert aus."""
+        assert isinstance(other, Literal), "Can only and Literal or MemoryCell with MemoryCell"
+        self.bitop_count += 1
+        self.read_count += 1
+        self.write_count += 1
+        other.read_count += 1
+        self.value &= other.value
+
+    def or_op(self, other):
+        """Führt ein Bitweise OR auf den Wert der Speicherzelle mit einem anderen Wert aus."""
+        assert isinstance(other, Literal), "Can only or Literal or MemoryCell with MemoryCell"
+        self.bitop_count += 1
+        self.read_count += 1
+        self.write_count += 1
+        other.read_count += 1
+        self.value |= other.value
+
+    def xor_op(self, other):
+        """Führt ein Bitweise XOR auf den Wert der Speicherzelle mit einem anderen Wert aus."""
+        assert isinstance(other, Literal), "Can only xor Literal or MemoryCell with MemoryCell"
+        self.bitop_count += 1
+        self.read_count += 1
+        self.write_count += 1
+        other.read_count += 1
+        self.value ^= other.value
+
+    def get_write_count(self):
+        """Gibt zurück, wie oft der Wert geschrieben wurde."""
+        return self.write_count
+
+    def __repr__(self):
+        """Repräsentation der Speicherzelle für Debugging-Zwecke."""
+        return f"MemoryCell(value={self.value}, reads={self.read_count}, writes={self.write_count})"
+
+    def __add__(self, other):
+        assert isinstance(other, Literal), "Can only add Literal or MemoryCell to MemoryCell"
+        self.add_count += 1
+        self.read_count += 1
+        other.read_count += 1
+        return Literal(self.value + other.value)
+
+    def __sub__(self, other):
+        assert isinstance(other, Literal), "Can only add Literal or MemoryCell to MemoryCell"
+        self.sub_count += 1
+        self.read_count += 1
+        other.read_count += 1
+        return Literal(self.value - other.value)
+
+    def __mul__(self, other):
+        assert isinstance(other, Literal), "Can only mul Literal or MemoryCell with MemoryCell"
+        self.mul_count += 1
+        self.read_count += 1
+        other.read_count += 1
+        return Literal(self.value * other.value)
+
+    def __truediv__(self, other):
+        assert isinstance(other, Literal), "Can only div Literal or MemoryCell by MemoryCell"
+        self.div_count += 1
+        self.read_count += 1
+        other.read_count += 1
+        return Literal(self.value / other.value)
+
+    def __floordiv__(self, other):
+        assert isinstance(other, Literal), "Can only div Literal or MemoryCell by MemoryCell"
+        self.div_count += 1
+        self.read_count += 1
+        other.read_count += 1
+        return Literal(self.value // other.value)
+
+    def __mod__(self, other):
+        assert isinstance(other, Literal), "Can only div Literal or MemoryCell by MemoryCell"
+        self.div_count += 1
+        self.read_count += 1
+        other.read_count += 1
+        return Literal(self.value % other.value)
+
+    def __iadd__(self, other):
+        self.add(other)
+        return self
+
+    def __isub__(self, other):
+        self.sub(other)
+        return self
+
+    def __imul__(self, other):
+        self.mul(other)
+        return self
+
+    def __itruediv__(self, other):
+        self.set(self // other)
+        return self
+
+    def __ifloordiv__(self, other):
+        self.div(other)
+        return self
+
+
+if __name__ == "__main__":
+    a = MemoryCell(5)
+    b = MemoryCell(3)
+    a += b
+    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.")

utils/memory_manager.py

@@ -0,0 +1,148 @@
+import matplotlib.pyplot as plt
+import queue
+
+
+class MemoryManager:
+
+    _instance = None
+    stats = {}
+
+    def __new__(cls, *args, **kwargs):
+        """Erstellt eine einzige Instanz von MemoryManager."""
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+            cls._instance._initialize()  # Eigene Init-Methode, damit __init__ nicht mehrfach läuft
+        return cls._instance
+
+    def _initialize(self):
+        """Initialisiert die Speicherverwaltung (einmalig)."""
+        self.cells = []
+        self._pool = queue.Queue()
+        self._finalizers = {}
+
+
+    @staticmethod
+    def count_cells():
+        return len(MemoryManager().cells)
+
+
+    @staticmethod
+    def count_reads():
+        return sum([cell.read_count for cell in MemoryManager().cells])
+
+    @staticmethod
+    def count_writes():
+        return sum([cell.write_count for cell in MemoryManager().cells])
+
+    @staticmethod
+    def count_compares():
+        return sum([cell.compare_count for cell in MemoryManager().cells])
+
+    @staticmethod
+    def count_adds():
+        return sum([cell.add_count for cell in MemoryManager().cells])
+
+    @staticmethod
+    def count_subs():
+        return sum([cell.sub_count for cell in MemoryManager().cells])
+
+    @staticmethod
+    def count_muls():
+        return sum([cell.mul_count for cell in MemoryManager().cells])
+
+    @staticmethod
+    def count_divs():
+        return sum([cell.div_count for cell in MemoryManager().cells])
+
+    @staticmethod
+    def count_bitops():
+        return sum([cell.bitop_count for cell in MemoryManager().cells])
+
+    @staticmethod
+    def reset():
+        manager = MemoryManager()
+        for cell in manager.cells:
+            cell.reset_counters()
+
+    @staticmethod
+    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 acquire_cell(self):
+        try:
+            return self._pool.get_nowait()
+        except queue.Empty:
+            return None
+
+    def register_cell(self, cell):
+        self.cells.append(cell)
+
+    def release_cell(self, cell):
+        self._pool.put(cell)
+
+
+class Testcell:
+
+    def __new__(cls, *args, **kwargs):
+        instance = MemoryManager().acquire_cell()
+        if instance is None:
+            instance = super().__new__(cls)
+            MemoryManager().register_cell(instance)
+        return instance
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        MemoryManager().release_cell(self)
+
+
+if __name__ == "__main__":
+
+    # Einfaches Anlegen einer Zelle
+    a = Testcell()
+    print(MemoryManager.count_cells())
+
+    # Anlegen einer Zelle und Beenden des Scopes
+    with Testcell() as b:
+        print(MemoryManager.count_cells())
+
+    print(MemoryManager.count_cells())
+
+    # Reuse einer Zelle
+    c = Testcell()
+    print(MemoryManager.count_cells())
+

utils/memory_range.py

@@ -0,0 +1,29 @@
+from utils.literal import Literal
+
+# a generator that yields items instead of returning a list
+def mrange(parm1, parm2=None, parm3=None):
+    if parm2 is None:
+        start = 0
+        stop = int(parm1)
+        step = 1
+    elif parm3 is None:
+        start = int(parm1)
+        stop = int(parm2)
+        step = 1
+    else:
+        start = int(parm1)
+        stop = int(parm2)
+        step = int(parm3)
+    num = start
+    if step > 0:
+        while num < stop:
+            yield Literal(num)
+            num += step
+    else:
+        while num > stop:
+            yield Literal(num)
+            num += step
+
+if __name__ == "__main__":
+    for l in mrange(10):
+        print(l)

utils/priority_queue.py

@@ -0,0 +1,40 @@
+import heapq
+
+class PriorityQueue:
+    def __init__(self):
+        self.heap = []
+        self.entry_finder = {}  # map: item -> [priority, item]
+        self.REMOVED = '<removed>'
+        self.counter = 0  # unique sequence count to break ties
+
+    def add_or_update(self, item, priority):
+        if item in self.entry_finder:
+            self.remove(item)
+        count = self.counter
+        entry = [priority, count, item]
+        self.entry_finder[item] = entry
+        heapq.heappush(self.heap, entry)
+        self.counter += 1
+
+    def remove(self, item):
+        entry = self.entry_finder.pop(item)
+        entry[-1] = self.REMOVED  # mark as removed
+
+    def pop(self):
+        while self.heap:
+            priority, count, item = heapq.heappop(self.heap)
+            if item != self.REMOVED:
+                del self.entry_finder[item]
+                return item, priority
+        return None
+
+if __name__ == "__main__":
+    pq = PriorityQueue()
+    pq.add_or_update('task1', 1)
+    pq.add_or_update('task2', float('inf'))
+    pq.add_or_update('task3', float('inf'))
+
+    print(pq.pop())  # Should print ('task1', 1)
+    pq.add_or_update('task2', 0)  # Update priority of 'task1'
+    print(pq.pop())  # Should print ('task2', 0)
+    print(pq.pop())  # Should print ('task3', 3)

utils/project_dir.py

@@ -0,0 +1,13 @@
+from pathlib import Path
+
+def get_path(filename) -> Path:
+    this_dir = Path(__file__).resolve().parent
+    project_dir = this_dir.parent
+    return project_dir / filename
+
+if __name__ == "__main__":
+    filename = get_path("data/seq0.txt")
+    print(filename)
+    print(filename.resolve())
+    print(filename.is_file())
+    print(filename.exists())

utils/test_memory_array.py

@@ -0,0 +1,47 @@
+from unittest import TestCase
+from utils.literal import Literal
+from utils.memory_array import MemoryArray
+import random
+
+class TestMemoryArray(TestCase):
+
+    def test_create_array(self):
+        l = random.randint(5,10)
+        size = Literal(l)
+        a = MemoryArray(size)
+        self.assertEqual(len(a), l)
+
+    def test_set_item(self):
+        l = random.randint(5,10)
+        size = Literal(l)
+        a = MemoryArray(size)
+        i = Literal(random.randint(0,l-1))
+        v = Literal(random.randint(1,100))
+        a[i] = v
+        self.assertEqual(a[i].value, v.value)
+
+    def test_get_item(self):
+        l = random.randint(5,10)
+        values = [random.randint(1,100) for _ in range(l)]
+        a = MemoryArray(values)
+        for pos, i in enumerate(a.indices()):
+            self.assertEqual(a[i].value, values[pos])
+
+    def test_reset_counters(self):
+        l = random.randint(5,10)
+        values = [random.randint(1,100) for _ in range(l)]
+        a = MemoryArray(values)
+        for i in a.indices():
+            self.assertEqual(a[i].write_count, 1)
+        a.reset_counters()
+        for i in a.indices():
+            self.assertEqual(a[i].write_count, 0)
+
+    def test_create_random_array(self):
+        a = MemoryArray.create_random_array(10, 1, 100)
+        self.assertEqual(len(a), 10)
+
+    def test_create_array_from_file(self):
+        a = MemoryArray.create_array_from_file("data/seq0.txt")
+        self.assertEqual(len(a), 14)
+

utils/test_memory_cell.py

@@ -0,0 +1,166 @@
+from unittest import TestCase
+from utils.memory_cell import MemoryCell
+from utils.literal import Literal
+import random
+
+
+class TestMemoryCell(TestCase):
+
+    def test_create_cell(self):
+        v = random.randint(1, 100)
+        cell = MemoryCell(v)
+        self.assertEqual(cell.value, v)
+        self.assertEqual(cell.read_count, 0)
+        self.assertEqual(cell.write_count, 1)
+        self.assertEqual(cell.add_count, 0)
+        self.assertEqual(cell.sub_count, 0)
+        self.assertEqual(cell.mul_count, 0)
+        self.assertEqual(cell.div_count, 0)
+        self.assertEqual(cell.bitop_count, 0)
+
+    def test_cast_cell(self):
+        v = random.randint(1, 100)
+        cell = MemoryCell(v)
+        self.assertEqual(int(cell), v)
+        self.assertEqual(cell.read_count, 1)
+        self.assertEqual(cell.write_count, 1)
+        self.assertEqual(cell.add_count, 0)
+        self.assertEqual(cell.sub_count, 0)
+        self.assertEqual(cell.mul_count, 0)
+        self.assertEqual(cell.div_count, 0)
+        self.assertEqual(cell.bitop_count, 0)
+
+    def test_add(self):
+        v1 = random.randint(1, 100)
+        v2 = random.randint(1, 100)
+
+        # "in place" Addition zweier MemoryCells
+        cell1 = MemoryCell(v1)
+        cell2 = MemoryCell(v2)
+        cell1 += cell2
+        self.assertEqual(cell1.value, v1 + v2)
+        self.assertEqual(cell1.add_count, 1)
+        self.assertEqual(cell1.read_count, 1)
+        self.assertEqual(cell2.read_count, 1)
+        self.assertTrue(isinstance(cell1, MemoryCell))
+        self.assertTrue(isinstance(cell2, MemoryCell))
+
+        # Freie Addition zweier MemoryCells
+        cell1 = MemoryCell(v1)
+        cell2 = MemoryCell(v2)
+        result = cell1 + cell2
+
+        self.assertEqual(result.value, v1 + v2)
+        self.assertEqual(cell1.add_count, 1)
+        self.assertEqual(cell1.read_count, 1)
+        self.assertEqual(cell2.read_count, 1)
+        self.assertTrue(isinstance(result, Literal))
+
+    def test_sub(self):
+        v1 = random.randint(1, 100)
+        v2 = random.randint(1, 100)
+
+        # "in place" Subtraktion zweier MemoryCells
+        cell1 = MemoryCell(v1)
+        cell2 = MemoryCell(v2)
+        cell1 -= cell2
+
+        self.assertEqual(cell1.value, v1 - v2)
+        self.assertEqual(cell1.sub_count, 1)
+        self.assertEqual(cell1.read_count, 1)
+        self.assertEqual(cell2.read_count, 1)
+        self.assertTrue(isinstance(cell1, MemoryCell))
+        self.assertTrue(isinstance(cell2, MemoryCell))
+
+        # Freie Subtraktion zweier MemoryCells
+        cell1 = MemoryCell(v1)
+        cell2 = MemoryCell(v2)
+        result = cell1 - cell2
+        self.assertEqual(result.value, v1 - v2)
+        self.assertEqual(cell1.sub_count, 1)
+        self.assertEqual(cell1.read_count, 1)
+        self.assertEqual(cell2.read_count, 1)
+        self.assertTrue(isinstance(result, Literal))
+
+    def test_mul(self):
+        v1 = random.randint(1, 100)
+        v2 = random.randint(1, 100)
+
+        # "in place" Multiplikation zweier MemoryCells
+        cell1 = MemoryCell(v1)
+        cell2 = MemoryCell(v2)
+        cell1 *= cell2
+
+        self.assertEqual(cell1.value, v1 * v2)
+        self.assertEqual(cell1.mul_count, 1)
+        self.assertEqual(cell1.read_count, 1)
+        self.assertEqual(cell2.read_count, 1)
+        self.assertTrue(isinstance(cell1, MemoryCell))
+        self.assertTrue(isinstance(cell2, MemoryCell))
+
+        # Freie Multiplikation zweier MemoryCells
+        cell1 = MemoryCell(v1)
+        cell2 = MemoryCell(v2)
+        result = cell1 * cell2
+        self.assertEqual(result.value, v1 * v2)
+        self.assertEqual(cell1.mul_count, 1)
+        self.assertEqual(cell1.read_count, 1)
+        self.assertEqual(cell2.read_count, 1)
+        self.assertTrue(isinstance(result, Literal))
+
+    def test_div(self):
+        v1 = random.randint(1, 100)
+        v2 = random.randint(1, 100)
+
+        # "in place" Division zweier MemoryCells
+        cell1 = MemoryCell(v1)
+        cell2 = MemoryCell(v2)
+        cell1 //= cell2
+
+        self.assertEqual(cell1.value, v1 // v2)
+        self.assertEqual(cell1.div_count, 1)
+        self.assertEqual(cell1.read_count, 1)
+        self.assertEqual(cell2.read_count, 1)
+        self.assertTrue(isinstance(cell1, MemoryCell))
+        self.assertTrue(isinstance(cell2, MemoryCell))
+
+        # Freie Division zweier MemoryCells
+        cell1 = MemoryCell(v1)
+        cell2 = MemoryCell(v2)
+        result = cell1 // cell2
+        self.assertEqual(result.value, v1 // v2)
+        self.assertEqual(cell1.div_count, 1)
+        self.assertEqual(cell1.read_count, 1)
+        self.assertEqual(cell2.read_count, 1)
+        self.assertTrue(isinstance(result, Literal))
+
+    def test_reset_counters(self):
+        v1 = random.randint(1, 100)
+        v2 = random.randint(1, 100)
+        cell = MemoryCell(v1)
+        cell += Literal(v2)
+
+        self.assertEqual(cell.value, v1+v2)
+        self.assertEqual(cell.read_count, 1)
+        self.assertEqual(cell.add_count, 1)
+        self.assertEqual(cell.write_count, 2)
+
+        cell.reset_counters()
+
+        self.assertEqual(cell.value, v1+v2)
+        self.assertEqual(cell.read_count, 0)
+        self.assertEqual(cell.add_count, 0)
+        self.assertEqual(cell.write_count, 0)
+
+
+    def test_set(self):
+        v1 = random.randint(1, 100)
+        v2 = random.randint(1, 100)
+
+        cell = MemoryCell(v1)
+        cell.set(v2)
+
+        self.assertEqual(cell.value, v2)
+        self.assertEqual(cell.read_count, 0)
+        self.assertEqual(cell.write_count, 2)
+