From 99203c606c2890d4a926442e8fd309e7c2b83f0a Mon Sep 17 00:00:00 2001
From: Eric Berquist <eric.berquist@gmail.com>
Date: Thu, 10 Oct 2019 23:06:38 -0400
Subject: [PATCH 1/7] Initial implementation of Graham Scan in Nim

---
 contents/graham_scan/code/nim/.gitignore |  1 +
 contents/graham_scan/code/nim/graham.nim | 49 ++++++++++++++++++++++++
 contents/graham_scan/graham_scan.md      |  6 +++
 3 files changed, 56 insertions(+)
 create mode 100644 contents/graham_scan/code/nim/.gitignore
 create mode 100644 contents/graham_scan/code/nim/graham.nim

diff --git a/contents/graham_scan/code/nim/.gitignore b/contents/graham_scan/code/nim/.gitignore
new file mode 100644
index 000000000..c69e8da45
--- /dev/null
+++ b/contents/graham_scan/code/nim/.gitignore
@@ -0,0 +1 @@
+graham
diff --git a/contents/graham_scan/code/nim/graham.nim b/contents/graham_scan/code/nim/graham.nim
new file mode 100644
index 000000000..d185f255e
--- /dev/null
+++ b/contents/graham_scan/code/nim/graham.nim
@@ -0,0 +1,49 @@
+from algorithm import sorted
+from math import arctan2
+from sequtils import deduplicate, map
+import sugar
+
+type Point[T: SomeNumber] = tuple[x, y: T]
+
+proc tup_to_point[T](t: (T, T)): Point[T] =
+  (x: t[0], y: t[1])
+
+proc is_counter_clockwise(p1, p2, p3: Point): bool =
+  (p3.y - p1.y) * (p2.x - p1.x) >= (p2.y - p1.y) * (p3.x - p1.x)
+
+proc polar_angle(reference, point: Point): float =
+  arctan2(float(point.y - reference.y), float(point.x - reference.x))
+
+proc flipped_point_cmp(pa, pb: Point): int =
+  if (pa.y, pa.x) < (pb.y, pb.x): -1
+  elif pa == pb: 0
+  else: 1
+
+proc graham_scan(gift: seq[Point]): seq[Point] =
+  # TODO make sure input has length >= 3
+  let
+    gift_without_duplicates = sorted(deduplicate(gift), flipped_point_cmp)
+    start = gift_without_duplicates[0]
+    candidates = sorted(gift_without_duplicates[1..^1],
+                        proc (pa, pb: Point): int =
+                          if polar_angle(start, pa) < polar_angle(start, pb): -1
+                          else: 1)
+  # TODO take the approach outlined in the text where we perform rotations on
+  # the candidates, rather than add to a new sequence
+  var hull = @[start, candidates[0], candidates[1]]
+  for candidate in candidates:
+    while not is_counter_clockwise(hull[^2], hull[^1], candidate):
+      discard pop(hull)
+    add(hull, candidate)
+  hull
+
+when isMainModule:
+  let
+    test_gift = @[(-5, 2), (5, 7), (-6, -12), (-14, -14), (9, 9),
+                  (-1, -1), (-10, 11), (-6, 15), (-6, -8), (15, -9),
+                  (7, -7), (-2, -9), (6, -5), (0, 14), (2, 8)].map(t => tup_to_point(t))
+    hull = graham_scan(test_gift)
+  echo "Initial gift:"
+  echo test_gift
+  echo "Final hull:"
+  echo hull
diff --git a/contents/graham_scan/graham_scan.md b/contents/graham_scan/graham_scan.md
index 586d209db..050034ded 100644
--- a/contents/graham_scan/graham_scan.md
+++ b/contents/graham_scan/graham_scan.md
@@ -32,6 +32,8 @@ We can find whether a rotation is counter-clockwise with trigonometric functions
 [import:18-20, lang="cpp"](code/c++/graham_scan.cpp)
 {% sample lang="coco" %}
 [import:4-8, lang="coconut"](code/coconut/graham_scan.coco)
+{% sample lang="nim" %}
+[import:14-15, lang:"nim"](code/nim/graham.nim)
 {% endmethod %}
 
 If the output of this function is 0, the points are collinear.
@@ -66,6 +68,8 @@ In the end, the code should look something like this:
 [import:26-62, lang="cpp"](code/c++/graham_scan.cpp)
 {% sample lang="coco" %}
 [import:17-30, lang="coconut"](code/coconut/graham_scan.coco)
+{% sample lang="nim" %}
+[import, lang:"nim"](code/nim/graham.nim)
 {% endmethod %}
 
 ### Bibliography
@@ -95,6 +99,8 @@ In the end, the code should look something like this:
 [import, lang="cpp"](code/c++/graham_scan.cpp)
 {%sample lang="coco" %}
 [import, lang="coconut"](code/coconut/graham_scan.coco)
+{% sample lang="nim" %}
+[import, lang:"nim"](code/nim/graham.nim)
 {% endmethod %}
 
 <script>

From 3d9902c15d898999bf7a237e46f9fc97d33345a6 Mon Sep 17 00:00:00 2001
From: Eric Berquist <eric.berquist@gmail.com>
Date: Sat, 12 Oct 2019 18:46:07 -0400
Subject: [PATCH 2/7] fix is_counter_clockwise bug

---
 contents/graham_scan/code/nim/graham.nim | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/contents/graham_scan/code/nim/graham.nim b/contents/graham_scan/code/nim/graham.nim
index d185f255e..8de1d5172 100644
--- a/contents/graham_scan/code/nim/graham.nim
+++ b/contents/graham_scan/code/nim/graham.nim
@@ -9,7 +9,7 @@ proc tup_to_point[T](t: (T, T)): Point[T] =
   (x: t[0], y: t[1])
 
 proc is_counter_clockwise(p1, p2, p3: Point): bool =
-  (p3.y - p1.y) * (p2.x - p1.x) >= (p2.y - p1.y) * (p3.x - p1.x)
+  (p3.y - p1.y) * (p2.x - p1.x) < (p2.y - p1.y) * (p3.x - p1.x)
 
 proc polar_angle(reference, point: Point): float =
   arctan2(float(point.y - reference.y), float(point.x - reference.x))

From 254aedabc4820fbc8d2fd4fbb9df9a990f53362c Mon Sep 17 00:00:00 2001
From: Eric Berquist <eric.berquist@gmail.com>
Date: Sat, 12 Oct 2019 18:46:55 -0400
Subject: [PATCH 3/7] Do rotations on candidates rather than allocate a new
 list

---
 contents/graham_scan/code/nim/graham.nim | 38 ++++++++++++++----------
 1 file changed, 23 insertions(+), 15 deletions(-)

diff --git a/contents/graham_scan/code/nim/graham.nim b/contents/graham_scan/code/nim/graham.nim
index 8de1d5172..c4f0f2b2f 100644
--- a/contents/graham_scan/code/nim/graham.nim
+++ b/contents/graham_scan/code/nim/graham.nim
@@ -1,6 +1,6 @@
 from algorithm import sorted
 from math import arctan2
-from sequtils import deduplicate, map
+from sequtils import deduplicate, map, toSeq
 import sugar
 
 type Point[T: SomeNumber] = tuple[x, y: T]
@@ -20,22 +20,30 @@ proc flipped_point_cmp(pa, pb: Point): int =
   else: 1
 
 proc graham_scan(gift: seq[Point]): seq[Point] =
-  # TODO make sure input has length >= 3
+  assert(gift.len >= 3)
   let
     gift_without_duplicates = sorted(deduplicate(gift), flipped_point_cmp)
-    start = gift_without_duplicates[0]
-    candidates = sorted(gift_without_duplicates[1..^1],
-                        proc (pa, pb: Point): int =
-                          if polar_angle(start, pa) < polar_angle(start, pb): -1
-                          else: 1)
-  # TODO take the approach outlined in the text where we perform rotations on
-  # the candidates, rather than add to a new sequence
-  var hull = @[start, candidates[0], candidates[1]]
-  for candidate in candidates:
-    while not is_counter_clockwise(hull[^2], hull[^1], candidate):
-      discard pop(hull)
-    add(hull, candidate)
-  hull
+    pivot = gift_without_duplicates[0]
+  var
+    points = sorted(gift_without_duplicates[1..^1],
+                    proc (pa, pb: Point): int =
+                      if polar_angle(pivot, pa) < polar_angle(pivot, pb): -1
+                      else: 1)
+  points.insert(pivot, 0)
+  var
+    m = 1
+    en = toSeq(low(points) + 2..high(points))
+  for i in mitems(en):
+    while is_counter_clockwise(points[m - 1], points[m], points[i]):
+      if m > 1:
+        m -= 1
+      elif i == points.len:
+        break
+      else:
+        i += 1
+    m += 1
+    swap(points[i], points[m])
+  points[0..m]
 
 when isMainModule:
   let

From 0c6b85e816a206a629805925aead201f020e988d Mon Sep 17 00:00:00 2001
From: Eric Berquist <eric.berquist@gmail.com>
Date: Sat, 12 Oct 2019 19:13:11 -0400
Subject: [PATCH 4/7] Avoid a sequence copy then reinsertion after angle sort

---
 contents/graham_scan/code/nim/graham.nim | 17 +++++++----------
 1 file changed, 7 insertions(+), 10 deletions(-)

diff --git a/contents/graham_scan/code/nim/graham.nim b/contents/graham_scan/code/nim/graham.nim
index c4f0f2b2f..fc682e4e7 100644
--- a/contents/graham_scan/code/nim/graham.nim
+++ b/contents/graham_scan/code/nim/graham.nim
@@ -1,4 +1,4 @@
-from algorithm import sorted
+from algorithm import sort, sorted
 from math import arctan2
 from sequtils import deduplicate, map, toSeq
 import sugar
@@ -21,15 +21,12 @@ proc flipped_point_cmp(pa, pb: Point): int =
 
 proc graham_scan(gift: seq[Point]): seq[Point] =
   assert(gift.len >= 3)
-  let
-    gift_without_duplicates = sorted(deduplicate(gift), flipped_point_cmp)
-    pivot = gift_without_duplicates[0]
-  var
-    points = sorted(gift_without_duplicates[1..^1],
-                    proc (pa, pb: Point): int =
-                      if polar_angle(pivot, pa) < polar_angle(pivot, pb): -1
-                      else: 1)
-  points.insert(pivot, 0)
+  var points = sorted(deduplicate(gift), flipped_point_cmp)
+  let pivot = points[0]
+  sort(toOpenArray(points, 1, high(points)),
+       proc (pa, pb: Point): int =
+         if polar_angle(pivot, pa) < polar_angle(pivot, pb): -1
+         else: 1)
   var
     m = 1
     en = toSeq(low(points) + 2..high(points))

From b0a7246e802a48639ee324659bd770e03815b60d Mon Sep 17 00:00:00 2001
From: Eric Berquist <eric.berquist@gmail.com>
Date: Sat, 12 Oct 2019 19:22:18 -0400
Subject: [PATCH 5/7] Documentation

---
 contents/graham_scan/code/nim/graham.nim | 8 ++++++++
 contents/graham_scan/graham_scan.md      | 4 ++--
 2 files changed, 10 insertions(+), 2 deletions(-)

diff --git a/contents/graham_scan/code/nim/graham.nim b/contents/graham_scan/code/nim/graham.nim
index fc682e4e7..b34a50ac2 100644
--- a/contents/graham_scan/code/nim/graham.nim
+++ b/contents/graham_scan/code/nim/graham.nim
@@ -9,12 +9,15 @@ proc tup_to_point[T](t: (T, T)): Point[T] =
   (x: t[0], y: t[1])
 
 proc is_counter_clockwise(p1, p2, p3: Point): bool =
+  ## Do the given points form a counter-clockwise turn?
   (p3.y - p1.y) * (p2.x - p1.x) < (p2.y - p1.y) * (p3.x - p1.x)
 
 proc polar_angle(reference, point: Point): float =
+  ## Find the polar angle of a point relative to a reference point
   arctan2(float(point.y - reference.y), float(point.x - reference.x))
 
 proc flipped_point_cmp(pa, pb: Point): int =
+  ## Compare points first by their y-coordinate, then x-coordinate.
   if (pa.y, pa.x) < (pb.y, pb.x): -1
   elif pa == pb: 0
   else: 1
@@ -23,21 +26,26 @@ proc graham_scan(gift: seq[Point]): seq[Point] =
   assert(gift.len >= 3)
   var points = sorted(deduplicate(gift), flipped_point_cmp)
   let pivot = points[0]
+  # Mimic sorting a sliced sequence without copying
   sort(toOpenArray(points, 1, high(points)),
        proc (pa, pb: Point): int =
          if polar_angle(pivot, pa) < polar_angle(pivot, pb): -1
          else: 1)
   var
+    # Hull pointer
     m = 1
+    # Needed because the iteration variable from a slice is immutable
     en = toSeq(low(points) + 2..high(points))
   for i in mitems(en):
     while is_counter_clockwise(points[m - 1], points[m], points[i]):
       if m > 1:
         m -= 1
+      # All points are collinear
       elif i == points.len:
         break
       else:
         i += 1
+    # Counter-clockwise point found, update hull and swap
     m += 1
     swap(points[i], points[m])
   points[0..m]
diff --git a/contents/graham_scan/graham_scan.md b/contents/graham_scan/graham_scan.md
index 050034ded..3835699c4 100644
--- a/contents/graham_scan/graham_scan.md
+++ b/contents/graham_scan/graham_scan.md
@@ -33,7 +33,7 @@ We can find whether a rotation is counter-clockwise with trigonometric functions
 {% sample lang="coco" %}
 [import:4-8, lang="coconut"](code/coconut/graham_scan.coco)
 {% sample lang="nim" %}
-[import:14-15, lang:"nim"](code/nim/graham.nim)
+[import:15-17, lang:"nim"](code/nim/graham.nim)
 {% endmethod %}
 
 If the output of this function is 0, the points are collinear.
@@ -69,7 +69,7 @@ In the end, the code should look something like this:
 {% sample lang="coco" %}
 [import:17-30, lang="coconut"](code/coconut/graham_scan.coco)
 {% sample lang="nim" %}
-[import, lang:"nim"](code/nim/graham.nim)
+[import:25-51, lang:"nim"](code/nim/graham.nim)
 {% endmethod %}
 
 ### Bibliography

From f9b6a872db050a54b40307f2dad70a1c7bb06d1c Mon Sep 17 00:00:00 2001
From: Eric Berquist <eric.berquist@gmail.com>
Date: Sat, 12 Oct 2019 19:30:48 -0400
Subject: [PATCH 6/7] is_counter_clockwise should return a number

---
 contents/graham_scan/code/nim/graham.nim | 11 +++++++----
 contents/graham_scan/graham_scan.md      |  4 ++--
 2 files changed, 9 insertions(+), 6 deletions(-)

diff --git a/contents/graham_scan/code/nim/graham.nim b/contents/graham_scan/code/nim/graham.nim
index b34a50ac2..d06775122 100644
--- a/contents/graham_scan/code/nim/graham.nim
+++ b/contents/graham_scan/code/nim/graham.nim
@@ -8,9 +8,12 @@ type Point[T: SomeNumber] = tuple[x, y: T]
 proc tup_to_point[T](t: (T, T)): Point[T] =
   (x: t[0], y: t[1])
 
-proc is_counter_clockwise(p1, p2, p3: Point): bool =
-  ## Do the given points form a counter-clockwise turn?
-  (p3.y - p1.y) * (p2.x - p1.x) < (p2.y - p1.y) * (p3.x - p1.x)
+proc cross_product[T](p1, p2, p3: Point[T]): T =
+  ## Form the cross product of three points. If the result is
+  ## - zero, the points are collinear.
+  ## - positive, the points form a counter-clockwise "left" turn.
+  ## - negative, the points form a clockwise "right" turn.
+  (p3.y - p1.y) * (p2.x - p1.x) - (p2.y - p1.y) * (p3.x - p1.x)
 
 proc polar_angle(reference, point: Point): float =
   ## Find the polar angle of a point relative to a reference point
@@ -37,7 +40,7 @@ proc graham_scan(gift: seq[Point]): seq[Point] =
     # Needed because the iteration variable from a slice is immutable
     en = toSeq(low(points) + 2..high(points))
   for i in mitems(en):
-    while is_counter_clockwise(points[m - 1], points[m], points[i]):
+    while cross_product(points[m - 1], points[m], points[i]) <= 0:
       if m > 1:
         m -= 1
       # All points are collinear
diff --git a/contents/graham_scan/graham_scan.md b/contents/graham_scan/graham_scan.md
index 3835699c4..7830e0cd4 100644
--- a/contents/graham_scan/graham_scan.md
+++ b/contents/graham_scan/graham_scan.md
@@ -33,7 +33,7 @@ We can find whether a rotation is counter-clockwise with trigonometric functions
 {% sample lang="coco" %}
 [import:4-8, lang="coconut"](code/coconut/graham_scan.coco)
 {% sample lang="nim" %}
-[import:15-17, lang:"nim"](code/nim/graham.nim)
+[import:11-16, lang:"nim"](code/nim/graham.nim)
 {% endmethod %}
 
 If the output of this function is 0, the points are collinear.
@@ -69,7 +69,7 @@ In the end, the code should look something like this:
 {% sample lang="coco" %}
 [import:17-30, lang="coconut"](code/coconut/graham_scan.coco)
 {% sample lang="nim" %}
-[import:25-51, lang:"nim"](code/nim/graham.nim)
+[import:28-54, lang:"nim"](code/nim/graham.nim)
 {% endmethod %}
 
 ### Bibliography

From 7f29f64bfa9aa99984c4f39be3fb97c495d25487 Mon Sep 17 00:00:00 2001
From: Eric Berquist <eric.berquist@gmail.com>
Date: Mon, 26 Oct 2020 01:32:17 -0400
Subject: [PATCH 7/7] proc -> func

---
 contents/graham_scan/code/nim/graham.nim | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/contents/graham_scan/code/nim/graham.nim b/contents/graham_scan/code/nim/graham.nim
index d06775122..01709a0d0 100644
--- a/contents/graham_scan/code/nim/graham.nim
+++ b/contents/graham_scan/code/nim/graham.nim
@@ -5,33 +5,33 @@ import sugar
 
 type Point[T: SomeNumber] = tuple[x, y: T]
 
-proc tup_to_point[T](t: (T, T)): Point[T] =
+func tup_to_point[T](t: (T, T)): Point[T] =
   (x: t[0], y: t[1])
 
-proc cross_product[T](p1, p2, p3: Point[T]): T =
+func cross_product[T](p1, p2, p3: Point[T]): T =
   ## Form the cross product of three points. If the result is
   ## - zero, the points are collinear.
   ## - positive, the points form a counter-clockwise "left" turn.
   ## - negative, the points form a clockwise "right" turn.
   (p3.y - p1.y) * (p2.x - p1.x) - (p2.y - p1.y) * (p3.x - p1.x)
 
-proc polar_angle(reference, point: Point): float =
+func polar_angle(reference, point: Point): float =
   ## Find the polar angle of a point relative to a reference point
   arctan2(float(point.y - reference.y), float(point.x - reference.x))
 
-proc flipped_point_cmp(pa, pb: Point): int =
+func flipped_point_cmp(pa, pb: Point): int =
   ## Compare points first by their y-coordinate, then x-coordinate.
   if (pa.y, pa.x) < (pb.y, pb.x): -1
   elif pa == pb: 0
   else: 1
 
-proc graham_scan(gift: seq[Point]): seq[Point] =
+func graham_scan(gift: seq[Point]): seq[Point] =
   assert(gift.len >= 3)
   var points = sorted(deduplicate(gift), flipped_point_cmp)
   let pivot = points[0]
   # Mimic sorting a sliced sequence without copying
   sort(toOpenArray(points, 1, high(points)),
-       proc (pa, pb: Point): int =
+       func (pa, pb: Point): int =
          if polar_angle(pivot, pa) < polar_angle(pivot, pb): -1
          else: 1)
   var