Added flood fill in Coconut

contents/flood_fill/code/coconut/flood_fill.coco

@@ -0,0 +1,126 @@
+from collections import deque
+import numpy as np
+
+
+data Point(x, y):
+    def __add__(self, other is Point) = Point(self.x + other.x, self.y + other.y)
+
+
+# This function is necessary, because negative indices wrap around the
+# array in Coconut.
+def inbounds(canvas_shape, location is Point) =
+    min(location) >= 0 and location.x < canvas_shape[0] and location.y < canvas_shape[1]
+
+
+def colour(canvas, location is Point, old_value, new_value):
+    if not inbounds(canvas.shape, location):
+        return
+
+    if canvas[location] != old_value:
+        return
+    else:
+        canvas[location] = new_value
+
+
+def find_neighbours(canvas, location is Point, old_value, new_value):
+    possible_neighbours = (Point(0, 1), Point(1, 0), Point(0, -1), Point(-1, 0)) |> map$(location.__add__)
+
+    for neighbour in possible_neighbours:
+        if inbounds(canvas.shape, neighbour) and canvas[neighbour] == old_value:
+            yield neighbour
+
+
+def stack_fill(canvas, location is Point, old_value, new_value):
+    if new_value == old_value:
+        return
+
+    stack = [location]
+
+    while stack:
+        current_location = stack.pop()
+        colour(canvas, current_location, old_value, new_value)
+        for neighbour in find_neighbours(canvas, current_location, old_value,
+                                         new_value):
+            stack.append(neighbour)
+
+
+def queue_fill(canvas, location is Point, old_value, new_value):
+    if new_value == old_value:
+        return
+
+    queue = deque()
+    queue.append(location)
+
+    colour(canvas, location, old_value, new_value)
+
+    while queue:
+        current_location = queue.popleft()
+        for neighbour in find_neighbours(canvas, current_location, old_value,
+                                         new_value):
+            queue.append(neighbour)
+            colour(canvas, neighbour, old_value, new_value)
+
+
+def recursive_fill(canvas, location is Point, old_value, new_value):
+    if new_value == old_value:
+        return
+    colour(canvas, location, old_value, new_value)
+
+    for neighbour in find_neighbours(canvas, location, old_value, new_value):
+        recursive_fill(canvas, neighbour, old_value, new_value)
+
+
+if __name__ == '__main__':
+    # Testing setup
+    from collections import namedtuple
+
+    TestResults = namedtuple('TestResults', 'passes failures')
+    pass_count = failure_count = 0
+
+    grid = np.zeros((5, 5))
+    grid[2,:] = 1
+    solution_grid = np.zeros((5, 5))
+    solution_grid[:3,] = 1
+
+    starting_location = Point(0, 0)
+
+
+    # The following is manual unit testing of the function
+    recursive_fill(grid, starting_location, 0, 1)
+    try:
+        assert (grid == solution_grid).all()
+    except AssertionError:
+        print('F', end='')
+        failure_count += 1
+    else:
+        print('.', end='')
+        pass_count += 1
+
+    # Resetting the grid, if everything went well.
+    grid[:2,] = 0
+
+    stack_fill(grid, starting_location, 0, 1)
+    try:
+        assert (grid == solution_grid).all()
+    except AssertionError:
+        print('F', end='')
+        failure_count += 1
+    else:
+        print('.', end='')
+        pass_count += 1
+
+    grid[:2,] = 0
+
+    queue_fill(grid, starting_location, 0, 1)
+    try:
+        assert (grid == solution_grid).all()
+    except AssertionError:
+        print('F', end='')
+        failure_count += 1
+    else:
+        print('.', end='')
+        pass_count += 1
+
+    print('')
+    print(TestResults(pass_count, failure_count))
+

contents/flood_fill/flood_fill.md

@@ -88,6 +88,8 @@ In code, this might look like this:
 {% method %}
 {% sample lang="jl" %}
 [import:37-55, lang:"julia"](code/julia/flood_fill.jl)
+{% sample lang="coco" %}
+[import:25-30, lang:"coconut"](code/coconut/flood_fill.coco)
 {% endmethod %}
 
 
@@ -106,6 +108,8 @@ In code, it might look like this:
 All Julia code snippets for this chapter rely on an exterior `color!(...)` function, defined as
 
 [import:23-35, lang:"julia"](code/julia/flood_fill.jl)
+{% sample lang="coco" %}
+[import:64-70, lang:"coconut"](code/coconut/flood_fill.coco)
 {% endmethod %}
 
 The above code continues recursing through available neighbors as long as neighbors exist, and this should work so long as we are adding the correct set of neighbors.
@@ -115,6 +119,8 @@ Additionally, it is possible to do the same type of traversal by managing a stac
 {% method %}
 {% sample lang="jl" %}
 [import:57-77, lang:"julia"](code/julia/flood_fill.jl)
+{% sample lang="coco" %}
+[import:33-44, lang:"coconut"](code/coconut/flood_fill.coco)
 {% endmethod %}
 
 This is ultimately the same method of traversal as before; however, because we are managing our own data structure, there are a few distinct differences:
@@ -152,6 +158,8 @@ The code would look something like this:
 {% method %}
 {% sample lang="jl" %}
 [import:80-104, lang:"julia"](code/julia/flood_fill.jl)
+{% sample lang="coco" %}
+[import:47-61, lang:"coconut"](code/coconut/flood_fill.coco)
 {% endmethod %}
 
 Now, there is a small trick in this code that must be considered to make sure it runs optimally.
@@ -228,6 +236,8 @@ After, we will fill in the left-hand side of the array to be all ones by choosin
 {% method %}
 {% sample lang="jl" %}
 [import, lang:"julia"](code/julia/flood_fill.jl)
+{% sample lang="coco" %}
+[import, lang:"coconut"](code/coconut/flood_fill.coco)
 {% endmethod %}