Converted Basic QuickSort to work, but with max recdepth problems

schoeffelbe/pr03.py

@@ -0,0 +1,111 @@
+import logging
+logger = logging.getLogger(__name__)
+logging.basicConfig(level=logging.DEBUG)
+
+from utils.memory_array import MemoryArray
+from utils.memory_cell import MemoryCell
+from utils.literal import Literal
+from utils.constants import MIN_VALUE
+from utils.memory_manager import MemoryManager
+from utils.memory_range import mrange
+
+def example():
+    initial = [6, 5, 3, 8, 1, 7, 2, 4]
+    # initial = [-6, -5, -3, -8, 1, 7, 2, 4]
+    toSort = MemoryArray(initial)
+    # init_from_size not accessible?
+    quickSort(toSort, Literal(0), mode=0)
+    logger.debug(f"sorted {toSort} vs initial {initial}")
+    assert all(toSort[Literal(i)] == Literal(i+1) for i in range(len(initial))), "Array not sorted correctly"
+
+    # analyze_complexity(quickSort, [10, 20, 30, 40, 50, 60, 70, 80, 90, 100])
+
+def getPivot(z: MemoryArray, l: Literal, r: Literal, mode) -> Literal:
+    if mode == 0:
+        return r
+    else:
+        mid = MemoryCell(l) + MemoryCell(MemoryCell(r) - l) // Literal(2)
+    
+        # Return median of left, middle, and right elements
+        if ((z[l] <= z[mid] and z[mid] <= z[r]) or 
+            (z[r] <= z[mid] and z[mid] <= z[l])):
+            return mid
+        elif ((z[mid] <= z[l] and z[l] <= z[r]) or 
+              (z[r] <= z[l] and z[l] <= z[mid])):
+            return l
+        else:
+            return r
+
+
+def swap(z: MemoryArray, i: int, j: int):
+    tmp = z[Literal(i)].value
+    z[Literal(i)] = z[Literal(j)]
+    z[Literal(j)].set(tmp)
+
+def quickSort(z: MemoryArray, l: Literal = Literal(0), r: Literal = Literal(-1), mode=0):
+    if r == Literal(-1):
+        r = z.length().pred();
+    if l < r:
+        q = partition(z, l, r, mode)
+        quickSort(z, l, q.pred())
+        quickSort(z, q.succ(), r)
+
+def partition(z: MemoryArray, l: Literal, r: Literal, mode):
+    # Get pivot
+    pivot_idx = getPivot(z, l, r, mode)
+    
+    # If pivot is not already at the right end, swap it there
+    if pivot_idx != r:
+        swap(z, int(pivot_idx), int(r))
+
+    # with MemoryCell(z[r]) as pivot, MemoryCell(l) as i, MemoryCell(r.pred()) as j:
+    pivot = MemoryCell(z[r])
+    i = MemoryCell(l)
+    j = MemoryCell(r.pred())
+
+    while i < j:
+        while z[i] < pivot:
+            i.set(i.succ())
+        while j > l and z[j] >= pivot:
+            j.set(j.pred())
+        if i < j:
+            swap(z, int(i), int(j))
+            i.set(i.succ())
+            j.set(j.pred())
+    if i == j and z[i] < pivot:
+        i.set(i.succ())
+    if z[i] != pivot:
+        swap(z, int(i), int(r))
+    return Literal(i)
+
+
+def analyze_complexity(fn, 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)
+        other_array = MemoryArray([-1] * size)
+        fn(random_array, other_array)
+        MemoryManager.save_stats(size)
+
+    MemoryManager.plot_stats(["cells", "adds", "compares"])
+
+
+if __name__ == '__main__':
+    # For debug, assert if working and complexity-analysis
+    example()
+
+    toSort = MemoryArray.create_array_from_file("data/seq0.txt")
+    print(toSort)
+    quickSort(toSort)
+    print(toSort)
+
+    for filename in ["data/seq0.txt", "data/seq1.txt", "data/seq2.txt", "data/seq3.txt"]:
+        print(filename)
+        toSort = MemoryArray.create_array_from_file(filename)
+        quickSort(toSort,Literal(0), Literal(-1), mode=0)