[#2] organize code a bit

Author: iechevarria

main.py renamed to sorting.py

@@ -1,41 +1,31 @@
-import random
-
-import svg
-
-
-def swap(history, idx1, idx2):
-
-    arr = history[-1].copy()
-    tmp = arr[idx1]
-    arr[idx1] = arr[idx2]
-    arr[idx2] = tmp
-
-    return history + [arr]
-
+def insertion_sort_history(arr):
+    history = [arr.copy()]
 
-def insertion_sort(arr):
     i = 1
-
-    while i < len(arr[0]):
+    while i < len(arr):
         j = i
-        while j > 0 and arr[-1][j - 1] > arr[-1][j]:
-            arr = swap(arr, j, j - 1)
+        while j > 0 and arr[j - 1] > arr[j]:
+            arr[j], arr[j - 1] = arr[j - 1], arr[j]
+            history.append(arr.copy())
             j -= 1
         i += 1
 
-    svg.generate(arr, "insertion_sort")
+    return history
+
 
+def bubble_sort_history(arr):
+    history = [arr.copy()]
 
-def bubble_sort(arr):
     flag = True
     while flag:
         flag = False
-        for i in range(len(arr[-1]) - 1):
-            if arr[-1][i] > arr[-1][i + 1]:
-                arr = swap(arr, i, i + 1)
+        for i in range(len(arr) - 1):
+            if arr[i] > arr[i + 1]:
+                arr[i], arr[i + 1] = arr[i + 1], arr[i]
+                history.append(arr.copy())
                 flag = True
 
-    svg.generate(arr, "bubble_sort")
+    return history
 
 
 def partition_lomuto(arr, history, low, high):
@@ -61,10 +51,10 @@ def quicksort_lomuto(arr, history, low, high):
         quicksort_lomuto(arr, history, p + 1, high)
 
 
-def quicksort_lomuto_svg(arr):
+def quicksort_lomuto_history(arr):
     history = [arr.copy()]
     quicksort_lomuto(arr, history, 0, len(arr) - 1)
-    svg.generate(history, "quicksort_lomuto")
+    return history
 
 
 def partition_hoare(arr, history, low, high):
@@ -94,18 +84,7 @@ def quicksort_hoare(arr, history, low, high):
         quicksort_hoare(arr, history, split_index + 1, high)
 
 
-def quicksort_hoare_svg(arr):
+def quicksort_hoare_history(arr):
     history = [arr.copy()]
-    quicksort_hoare(list_to_sort, history, 0, len(arr) - 1)
-    svg.generate(history, "quicksort_hoare")
-
-
-if __name__ == "__main__":
-    list_length = 80
-    list_to_sort = list(range(list_length))
-    random.Random(777).shuffle(list_to_sort)
-
-    insertion_sort([list_to_sort[:20]])
-    bubble_sort([list_to_sort[:20]])
-    quicksort_lomuto_svg(list_to_sort.copy())
-    quicksort_hoare_svg(list_to_sort)
+    quicksort_hoare(arr, history, 0, len(arr) - 1)
+    return history

macaroni.py renamed to svg_composites.py

@@ -1,5 +1,7 @@
 import math
 
+import svg_primitives
+
 
 class Circle:
     def __init__(self, x, y, radius):
@@ -56,58 +58,12 @@ def get_tangent_lines(c1, c2):
     return (c1t1, c2t1), (c1t2, c2t2)
 
 
-def circle_to_svg(c):
-    return f"""
-        <circle
-            cx="{c.x}"
-            cy="{c.y}"
-            r="{c.radius}"
-            fill="transparent"
-            stroke="black"
-        />
-    """
-
-
-def make_line_svg(
-    x1, y1, x2, y2, stroke_width=10, stroke_color="red", stroke_linecap="round"
-):
-    return (
-        f'<line x1="{round(x1, 4)}" y1="{round(y1, 4)}"'
-        f' x2="{round(x2, 4)}" y2="{round(y2, 4)}"'
-        f' stroke="{stroke_color}"'
-        f' stroke-width="{stroke_width}"'
-        f' stroke-linecap="{stroke_linecap}"/>'
-    )
-
-
-def make_arc_svg(
-    pt1,
-    pt2,
-    radius,
-    arc_flag,
-    stroke_width=10,
-    stroke_color="red",
-    stroke_linecap="round",
-):
-    x1, y1 = pt1
-    x2, y2 = pt2
-
-    return (
-        f'<path d="M {round(x1, 4)} {round(y1, 4)} A {round(radius, 4)}'
-        f' {round(radius, 4)} 0 0 {arc_flag} {round(x2, 4)} {round(y2, 4)}"'
-        f' fill="transparent"'
-        f' stroke="{stroke_color}"'
-        f' stroke-linecap="{stroke_linecap}"'
-        f' stroke-width="{stroke_width}"/>'
-    )
-
-
 def choose_tangent_line(tl1, tl2):
     # this is pretty hacky but I have luxury of never running into edge cases
     return tl1 if tl1[0] < tl2[0] else tl2
 
 
-def make_double_macaroni_connection_svg(
+def double_macaroni(
     x1,
     y1,
     x2,
@@ -157,43 +113,10 @@ def make_double_macaroni_connection_svg(
     arc_flag = int(a.y > b.y)
 
     return (
-        make_line_svg(*p1, *p2, **{**bg_kwargs, "stroke_linecap": "round"})
-        + make_arc_svg(**arc1_kwargs, **bg_kwargs, arc_flag=arc_flag)
-        + make_arc_svg(**arc2_kwargs, **bg_kwargs, arc_flag=arc_flag)
-        + make_line_svg(*p1, *p2, **fg_kwargs)
-        + make_arc_svg(**arc1_kwargs, **fg_kwargs, arc_flag=arc_flag)
-        + make_arc_svg(**arc2_kwargs, **fg_kwargs, arc_flag=arc_flag)
+        svg_primitives.line(*p1, *p2, **{**bg_kwargs, "stroke_linecap": "round"})
+        + svg_primitives.arc(**arc1_kwargs, **bg_kwargs, arc_flag=arc_flag)
+        + svg_primitives.arc(**arc2_kwargs, **bg_kwargs, arc_flag=arc_flag)
+        + svg_primitives.line(*p1, *p2, **fg_kwargs)
+        + svg_primitives.arc(**arc1_kwargs, **fg_kwargs, arc_flag=arc_flag)
+        + svg_primitives.arc(**arc2_kwargs, **fg_kwargs, arc_flag=arc_flag)
     )
-
-
-if __name__ == "__main__":
-    inner_svg = ""
-    inner_svg += make_double_macaroni_connection_svg(
-        x1=60,
-        y1=60,
-        x2=200,
-        y2=200,
-        radius=50,
-        stroke_width=30,
-        stroke_color="red",
-        stroke_linecap="flat",
-    )
-
-    svg = ""
-    if display_circles:
-        svg = circle_to_svg(a) + circle_to_svg(b)
-
-
-    with open("tangent_test.html", "w+") as text_file:
-        text_file.write(
-            f"""
-                <!DOCTYPE html>
-                <html>
-                <body>
-                <svg width="400" height="400">
-                {inner_svg}
-                </svg>
-                </body>
-                </html>
-            """
-        )

svg_primitives.py

@@ -0,0 +1,37 @@
+def circle(circle):
+    return (
+        f'<circle cx="{circle.x}" cy="{circle.y}" r="{circle.radius}"'
+        'fill="transparent" stroke="black"/>'
+    )
+
+
+def line(x1, y1, x2, y2, stroke_width=10, stroke_color="red", stroke_linecap="round"):
+    return (
+        f'<line x1="{round(x1, 4)}" y1="{round(y1, 4)}"'
+        f' x2="{round(x2, 4)}" y2="{round(y2, 4)}"'
+        f' stroke="{stroke_color}"'
+        f' stroke-width="{stroke_width}"'
+        f' stroke-linecap="{stroke_linecap}"/>'
+    )
+
+
+def arc(
+    pt1,
+    pt2,
+    radius,
+    arc_flag,
+    stroke_width=10,
+    stroke_color="red",
+    stroke_linecap="round",
+):
+    x1, y1 = pt1
+    x2, y2 = pt2
+
+    return (
+        f'<path d="M {round(x1, 4)} {round(y1, 4)} A {round(radius, 4)}'
+        f' {round(radius, 4)} 0 0 {arc_flag} {round(x2, 4)} {round(y2, 4)}"'
+        f' fill="transparent"'
+        f' stroke="{stroke_color}"'
+        f' stroke-linecap="{stroke_linecap}"'
+        f' stroke-width="{stroke_width}"/>'
+    )

svg.py renamed to visualization.py

@@ -2,7 +2,8 @@
 
 from matplotlib import cm
 
-from macaroni import make_line_svg, make_double_macaroni_connection_svg
+import svg_primitives
+import svg_composites
 
 
 def unnest_svg_list(svg_list):
@@ -25,6 +26,8 @@ def get_color(color_dict, val):
 
 
 def get_swaps_and_straights(history):
+    """Transform history into format more useful for drawing"""
+
     # pad history at the beginning and end to make my life easier
     padded_history = history.copy()
     padded_history.insert(0, padded_history[0])
@@ -74,7 +77,7 @@ def make_straight_path(val, indices, color_dict, transform_kwargs):
     stroke_width = transform_kwargs["line_width"]
     stroke_linecap = "round"
 
-    return make_line_svg(*coords, stroke_width, stroke_color, stroke_linecap)
+    return svg_primitives.line(*coords, stroke_width, stroke_color, stroke_linecap)
 
 
 def make_swap_path(
@@ -89,7 +92,7 @@ def make_swap_path(
     curve_radius = min_curve_radius + curve_radius_delta / distance
     stroke_width = transform_kwargs["line_width"]
 
-    return make_double_macaroni_connection_svg(
+    return svg_composites.double_macaroni(
         x1,
         y1,
         x2,
@@ -138,6 +141,7 @@ def generate(
 ):
 
     # set up some params
+    final_state = history[-1]
     y_offset = line_width / 2
     transform_kwargs = {
         "spacing": spacing,
@@ -146,35 +150,36 @@ def generate(
         "y_offset": y_offset,
     }
 
-    # compute curve stuff
+    # compute curve params
     min_curve_radius = (line_height - line_width) / min_curve_radius_denominator
     curve_kwargs = {
         "min_curve_radius": min_curve_radius,
         "curve_radius_delta": line_height - line_width - spacing - min_curve_radius,
     }
 
     # set up colors
-    color_dict = get_color_dict(history[-1])
+    color_dict = get_color_dict(final_state)
 
     # get path histories
     swaps, straights = get_swaps_and_straights(history)
 
+    # compute svg dimensions
+    num_vals = len(final_state)
+    total_width = (num_vals) * spacing + num_vals * line_width
+    total_height = (len(history) + 1) * line_height + 2 * y_offset
+
     # actually make the svgs
     swap_kwargs = {
         "swaps": swaps,
         "color_dict": color_dict,
         "transform_kwargs": transform_kwargs,
         "curve_kwargs": curve_kwargs,
     }
+    # ensure that left-right swaps render over right-left swaps
     under_swap_paths = make_swap_paths(mode="under", **swap_kwargs)
     over_swap_paths = make_swap_paths(mode="over", **swap_kwargs)
     straight_paths = make_straight_paths(straights, color_dict, transform_kwargs)
 
-    # compute svg dimensions
-    num_vals = len(history[0])
-    total_width = (num_vals) * spacing + num_vals * line_width
-    total_height = (len(history) + 1) * line_height + 2 * y_offset
-
     with open(f"{filename}.svg", "w+") as text_file:
         text_file.write(
             f'<svg role="img" height="{int(total_height)}" width="{int(total_width)}"'
@@ -184,3 +189,14 @@ def generate(
             + over_swap_paths
             + "</svg>\n"
         )
+
+
+if __name__ == "__main__":
+    import random
+    import sorting
+
+    list_length = 80
+    list_to_sort = list(range(list_length))
+    random.Random(777).shuffle(list_to_sort)
+
+    generate(sorting.quicksort_hoare_history(list_to_sort), "quicksort_hoare")