From 1356dedf08469c8cdb27fd68a493016f1f8fcdd3 Mon Sep 17 00:00:00 2001 From: Christian Clauss Date: Sun, 10 May 2020 16:14:56 +0200 Subject: [PATCH 1/4] Fix astar Single character variable names are old school. --- machine_learning/astar.py | 51 +++++++++++++++------------------------ 1 file changed, 20 insertions(+), 31 deletions(-) diff --git a/machine_learning/astar.py b/machine_learning/astar.py index 2dd10b1d5fa7..5f6b05f1f47f 100644 --- a/machine_learning/astar.py +++ b/machine_learning/astar.py @@ -1,5 +1,3 @@ -import numpy as np - ''' The A* algorithm combines features of uniform-cost search and pure heuristic search to efficiently compute optimal solutions. @@ -12,6 +10,7 @@ essentially planning ahead at each step so a more optimal decision is made.A* also known as the algorithm with brains ''' +import numpy as np class Cell(object): @@ -32,6 +31,7 @@ def __init__(self): self.g = 0 self.h = 0 self.f = 0 + ''' overrides equals method because otherwise cell assign will give wrong results @@ -44,11 +44,10 @@ def showcell(self): class Gridworld(object): - ''' Gridworld class represents the external world here a grid M*M matrix - w : create a numpy array with the given world_size default is 5 + world_size: create a numpy array with the given world_size default is 5 ''' def __init__(self, world_size=(5, 5)): @@ -59,12 +58,10 @@ def __init__(self, world_size=(5, 5)): def show(self): print(self.w) - ''' - get_neighbours - As the name suggests this function will return the neighbours of - the a particular cell - ''' def get_neigbours(self, cell): + ''' + Return the neighbours of cell + ''' neughbour_cord = [ (-1, -1), (-1, 0), (-1, 1), (0, -1), (0, 1), (1, -1), (1, 0), (1, 1)] @@ -74,25 +71,21 @@ def get_neigbours(self, cell): for n in neughbour_cord: x = current_x + n[0] y = current_y + n[1] - if ( - (x >= 0 and x < self.world_x_limit) and - (y >= 0 and y < self.world_y_limit)): + if 0 <= x < self.world_x_limit and 0 <= y < self.world_y_limit: c = Cell() c.position = (x, y) c.parent = cell neighbours.append(c) return neighbours -''' -Implementation of a start algorithm -world : Object of the world object -start : Object of the cell as start position -stop : Object of the cell as goal position -''' - def astar(world, start, goal): ''' + Implementation of a start algorithm + world : Object of the world object + start : Object of the cell as start position + stop : Object of the cell as goal position + >>> p = Gridworld() >>> start = Cell() >>> start.position = (0,0) @@ -130,23 +123,19 @@ def astar(world, start, goal): path.append(current.position) current = current.parent path.append(current.position) - path = path[::-1] - return path + return path[::-1] + if __name__ == '__main__': - ''' - sample run - ''' -# object for the world - p = Gridworld() + world = Gridworld() # stat position and Goal start = Cell() start.position = (0, 0) goal = Cell() goal.position = (4, 4) - print("path from {} to {} ".format(start.position, goal.position)) - s = astar(p, start, goal) -# Just for visual Purpose + print(f"path from {start.position} to {goal.position}") + s = astar(world, start, goal) +# Just for visual reasons for i in s: - p.w[i] = 1 - print(p.w) + world.w[i] = 1 + print(world.w) From 384606cd09bfe7e5b74158c980f2bdd346e1fddd Mon Sep 17 00:00:00 2001 From: github-actions <${GITHUB_ACTOR}@users.noreply.github.com> Date: Sun, 10 May 2020 14:16:08 +0000 Subject: [PATCH 2/4] fixup! Format Python code with psf/black push --- machine_learning/astar.py | 45 +++++++++++++++++++++++---------------- 1 file changed, 27 insertions(+), 18 deletions(-) diff --git a/machine_learning/astar.py b/machine_learning/astar.py index 5f6b05f1f47f..ec8f214ab082 100644 --- a/machine_learning/astar.py +++ b/machine_learning/astar.py @@ -1,4 +1,4 @@ -''' +""" The A* algorithm combines features of uniform-cost search and pure heuristic search to efficiently compute optimal solutions. A* algorithm is a best-first search algorithm in which the cost @@ -9,12 +9,12 @@ regular graph-searching algorithm, essentially planning ahead at each step so a more optimal decision is made.A* also known as the algorithm with brains -''' +""" import numpy as np class Cell(object): - ''' + """ Class cell represents a cell in the world which have the property position : The position of the represented by tupleof x and y co-ordinates initially set to (0,0) @@ -23,7 +23,8 @@ class Cell(object): g,h,f : The parameters for constructing the heuristic function which can be any function. for simplicity used line distance - ''' + """ + def __init__(self): self.position = (0, 0) self.parent = None @@ -32,10 +33,11 @@ def __init__(self): self.h = 0 self.f = 0 - ''' + """ overrides equals method because otherwise cell assign will give wrong results - ''' + """ + def __eq__(self, cell): return self.position == cell.position @@ -44,11 +46,11 @@ def showcell(self): class Gridworld(object): - ''' + """ Gridworld class represents the external world here a grid M*M matrix world_size: create a numpy array with the given world_size default is 5 - ''' + """ def __init__(self, world_size=(5, 5)): self.w = np.zeros(world_size) @@ -59,12 +61,19 @@ def show(self): print(self.w) def get_neigbours(self, cell): - ''' + """ Return the neighbours of cell - ''' + """ neughbour_cord = [ - (-1, -1), (-1, 0), (-1, 1), (0, -1), - (0, 1), (1, -1), (1, 0), (1, 1)] + (-1, -1), + (-1, 0), + (-1, 1), + (0, -1), + (0, 1), + (1, -1), + (1, 0), + (1, 1), + ] current_x = cell.position[0] current_y = cell.position[1] neighbours = [] @@ -80,7 +89,7 @@ def get_neigbours(self, cell): def astar(world, start, goal): - ''' + """ Implementation of a start algorithm world : Object of the world object start : Object of the cell as start position @@ -93,7 +102,7 @@ def astar(world, start, goal): >>> goal.position = (4,4) >>> astar(p, start, goal) [(0, 0), (1, 1), (2, 2), (3, 3), (4, 4)] - ''' + """ _open = [] _closed = [] _open.append(start) @@ -111,7 +120,7 @@ def astar(world, start, goal): n.g = current.g + 1 x1, y1 = n.position x2, y2 = goal.position - n.h = (y2 - y1)**2 + (x2 - x1)**2 + n.h = (y2 - y1) ** 2 + (x2 - x1) ** 2 n.f = n.h + n.g for c in _open: @@ -126,16 +135,16 @@ def astar(world, start, goal): return path[::-1] -if __name__ == '__main__': +if __name__ == "__main__": world = Gridworld() -# stat position and Goal + # stat position and Goal start = Cell() start.position = (0, 0) goal = Cell() goal.position = (4, 4) print(f"path from {start.position} to {goal.position}") s = astar(world, start, goal) -# Just for visual reasons + # Just for visual reasons for i in s: world.w[i] = 1 print(world.w) From 780560e064a99d9badac8d45cf540e0b4ec2ba67 Mon Sep 17 00:00:00 2001 From: Christian Clauss Date: Sun, 10 May 2020 16:29:34 +0200 Subject: [PATCH 3/4] Tuple --- maths/{kadanes_algorithm.py => kadanes.py} | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) rename maths/{kadanes_algorithm.py => kadanes.py} (93%) diff --git a/maths/kadanes_algorithm.py b/maths/kadanes.py similarity index 93% rename from maths/kadanes_algorithm.py rename to maths/kadanes.py index d02f238a0dc9..d239d4a2589b 100644 --- a/maths/kadanes_algorithm.py +++ b/maths/kadanes.py @@ -3,7 +3,7 @@ https://medium.com/@rsinghal757/kadanes-algorithm-dynamic-programming-how-and-why-does-it-work-3fd8849ed73d https://en.wikipedia.org/wiki/Maximum_subarray_problem """ -test_data = ([-2, -8, -9], [2, 8, 9], [-1, 0, 1], [0, 0], []) +test_data: tuple = ([-2, -8, -9], [2, 8, 9], [-1, 0, 1], [0, 0], []) def negative_exist(arr: list) -> int: From 1cfc7b95baaf9288f864eede358bede42faaf514 Mon Sep 17 00:00:00 2001 From: github-actions <${GITHUB_ACTOR}@users.noreply.github.com> Date: Sun, 10 May 2020 14:29:56 +0000 Subject: [PATCH 4/4] updating DIRECTORY.md --- DIRECTORY.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/DIRECTORY.md b/DIRECTORY.md index 27fb1a8988e3..e5ec48e27e7f 100644 --- a/DIRECTORY.md +++ b/DIRECTORY.md @@ -266,6 +266,7 @@ * [Test Linear Algebra](https://github.com/TheAlgorithms/Python/blob/master/linear_algebra/src/test_linear_algebra.py) ## Machine Learning + * [Astar](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/astar.py) * [Decision Tree](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/decision_tree.py) * [Gaussian Naive Bayes](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/gaussian_naive_bayes.py) * [Gradient Descent](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/gradient_descent.py) @@ -327,6 +328,7 @@ * [Hardy Ramanujanalgo](https://github.com/TheAlgorithms/Python/blob/master/maths/hardy_ramanujanalgo.py) * [Is Square Free](https://github.com/TheAlgorithms/Python/blob/master/maths/is_square_free.py) * [Jaccard Similarity](https://github.com/TheAlgorithms/Python/blob/master/maths/jaccard_similarity.py) + * [Kadanes](https://github.com/TheAlgorithms/Python/blob/master/maths/kadanes.py) * [Karatsuba](https://github.com/TheAlgorithms/Python/blob/master/maths/karatsuba.py) * [Kth Lexicographic Permutation](https://github.com/TheAlgorithms/Python/blob/master/maths/kth_lexicographic_permutation.py) * [Largest Of Very Large Numbers](https://github.com/TheAlgorithms/Python/blob/master/maths/largest_of_very_large_numbers.py)