Curry cost functions for flexibility

Author: twitu

main.py

@@ -20,7 +20,7 @@ def is_valid_pos(cur_pos):
         (0, -1),
         (-1, 0)
     ]
-    path_finder = PathFinder(linear_cost, cost, is_valid_pos)
+    path_finder = PathFinder(linear_cost(), linear_cost(), is_valid_pos)
     path = path_finder.find_path(moves, start, end)
     map_generator.view_path(map_data, path)
 

movement_cost.py

@@ -3,44 +3,49 @@
 import math
 
 
-def linear_cost(start, end, cost=1):
+def linear_cost(scale=1):
     """
     Manhattan distance, only linear movement is allowed
 
     Args:
         start (int, int): x and y coordinates of start point
         end   (int, int): x and y coordinates of end point
-        cost       (int): cost of one step
+        scale       (int): scale of one step
 
     Returns:
-        Linear cost between start and end point
+        Returns linear cost function between start and end point
     """
 
-    delta_x = abs(start[0] - end[0])
-    delta_y = abs(start[1] - end[1])
-    return (delta_x + delta_y) * cost
+    def cost(start, end):
+        delta_x = abs(start[0] - end[0])
+        delta_y = abs(start[1] - end[1])
+        return (delta_x + delta_y) * scale
 
+    return cost
 
-def euclidean_cost(start, end, cost=1):
+def euclidean_cost(scale=1):
     """
     Euclidean distance, linear and diagonal movement is allowed,
     cost of diagonal movement is calculated using square root method
 
     Args:
         start (int, int): x and y coordinates of start point
         end   (int, int): x and y coordinates of end point
-        cost  (int): cost of one step
+        scale  (int): scale of one step
 
     Returns:
-        Euclidean cost between start and end point
+        Returns euclidean cost fuction between start and end point
     """
 
-    delta_x = abs(start[0] - end[0])
-    delta_y = abs(start[1] - end[1])
-    return math.sqrt(delta_x * delta_x + delta_y * delta_y) * cost
+    def cost(start, end):
+        delta_x = abs(start[0] - end[0])
+        delta_y = abs(start[1] - end[1])
+        return math.sqrt(delta_x * delta_x + delta_y * delta_y) * scale
 
+    return cost
 
-def diagonal_cost(start, end, lin=1, diag=1):
+
+def diagonal_cost(lin=1, diag=1):
     """
     Diagonal distance, 8 directions.
     Linear and diagonal movement is allowed at same cost
@@ -50,35 +55,39 @@ def diagonal_cost(start, end, lin=1, diag=1):
     Args:
         start (int, int): x and y coordinates of start point
         end   (int, int): x and y coordinates of end point
-        lin          int: cost of one linear step
-        diag         int: cost of one diagonal step
+        lin          int: scale of one linear step
+        diag         int: scale of one diagonal step
 
     Returns:
-        Diagonal cost between start and end point
+        Returns diagonal cost function between start and end point
     """
 
-    delta_x = abs(start[0] - end[0])
-    delta_y = abs(start[1] - end[1])
-    return (delta_x + delta_y) * lin + min(delta_x, delta_y) * (diag - 2 * lin)
+    def cost(start, end):
+        delta_x = abs(start[0] - end[0])
+        delta_y = abs(start[1] - end[1])
+        return (delta_x + delta_y) * lin + min(delta_x, delta_y) * (diag - 2 * lin)
+
+    return cost
 
 
-def scaled_cost(h_func, p_scale, *args):
+def scaled_cost(h_func, p_scale):
     """
     Scales cost function based on given parameter
 
     Args:
         h_func: cost function
         p_scale: scales cost function multiple times
-        *args: arguments passed to cost function
 
     Returns:
-        Scaled value of cost cost
+        Scaled cost function
     """
 
-    return h_func(*args) * p_scale
+    def cost(start, end):
+        return h_func(start, end) * p_scale
 
+    return cost
 
-def randomized_cost(sigma, mu, h_func, *args):
+def randomized_cost(sigma, mu, h_func):
     """
     Generates random number with normal distribution based on given sigma and mu.
     Scales cost function by generated random number. Suggested values are
@@ -88,10 +97,12 @@ def randomized_cost(sigma, mu, h_func, *args):
         sigma: standard deviation in normal distribution
         mu: average value in normal distribution
         h_func: cost function
-        *args: arguments passed to cost function
 
     Returns:
-        Randomly scaled value of cost cost
+        Randomly scaled cost function
     """
 
-    return h_func(*args) * random.normalvariate(mu, sigma)
+    def cost(start, end):
+        return h_func(start, end) * random.normalvariate(mu, sigma)
+
+    return cost