diff --git a/point_pattern.py b/point_pattern.py index 1b0a5cb..dc30a66 100644 --- a/point_pattern.py +++ b/point_pattern.py @@ -33,10 +33,10 @@ def read_geojson(input_file): """ # Please use the python json module (imported above) # to solve this one. - gj = None + with open(input_file, 'r') as f: + gj = json.load(f) return gj - def find_largest_city(gj): """ Iterate through a geojson feature collection and @@ -56,8 +56,19 @@ def find_largest_city(gj): population : int The population of the largest city """ - city = None - max_population = 0 + list_cities = [] + list_pop = [] + + for d in kj['features']: + pop_max = d['properties']['pop_max'] + citys = d['properties']['ls_name'] + list_cities.append(citys) + list_pop.append(pop_max) + + max_population = max(list_pop) + index_pop = list_pop.index(max_population) + + city = list_cities[index_pop] return city, max_population @@ -74,7 +85,22 @@ def write_your_own(gj): Do not forget to write the accompanying test in tests.py! """ - return + list_cities2 = [] + home_state = [] + + for s in gj['features']: + citys2 = s['properties']['ls_name'] + statenm = s['properties']['adm1name'] + list_cities2.append(citys2) + home_state.append(statenm) + + v = raw_input('Type a city name to return its state...') + citynumber = list_cities2.index(v) + stateans = home_state[citynumber] + + return stateans + + def mean_center(points): """ @@ -93,13 +119,19 @@ def mean_center(points): y : float Mean y coordinate """ - x = None - y = None + x = 0 + y = 0 + for coor in points: + x += coor[0]/len(points) + y += coor[1]/len(points) return x, y +sub = [(1,2), (3,4)] + def average_nearest_neighbor_distance(points): + """ Given a set of points, compute the average nearest neighbor. @@ -119,10 +151,19 @@ def average_nearest_neighbor_distance(points): Measure of Spatial Relationships in Populations. Ecology. 35(4) p. 445-453. """ + shortest_path = [] mean_d = 0 - return mean_d + for p_one in points: + distance = [] + for p_two in points: + if math.sqrt((p_one[0] - p_two[0])**2 + (p_one[1] - p_two[1])**2)==0: + continue + distance.append(math.sqrt((p_one[0] - p_two[0])**2 + (p_one[1] - p_two[1])**2)) + shortest_path.append(min(distance)) + mean_d = sum(shortest_path)/len(shortest_path) + return mean_d def minimum_bounding_rectangle(points): """ @@ -139,7 +180,18 @@ def minimum_bounding_rectangle(points): Corners of the MBR in the form [xmin, ymin, xmax, ymax] """ - mbr = [0,0,0,0] + mbr = [] + x_list = [] + y_list = [] + + for point in points: + x_list.append(point[0]) + y_list.append(point[1]) + + mbr.append(min(x_list)) + mbr.append(min(y_list)) + mbr.append(max(x_list)) + mbr.append(max(y_list)) return mbr @@ -150,6 +202,11 @@ def mbr_area(mbr): """ area = 0 + length = abs(mbr[0] - mbr[2]) + width = abs(mbr[1] - mbr[3]) + + area = length * width + return area @@ -174,6 +231,8 @@ def expected_distance(area, n): """ expected = 0 + + expected = 0.5 * (math.sqrt(area / n)) return expected diff --git a/tests/tests.py b/tests/tests.py index 2518463..8d80982 100644 --- a/tests/tests.py +++ b/tests/tests.py @@ -31,23 +31,27 @@ def test_write_your_own(self): """ Here you will write a test for the code you write in point_pattern.py. + + Teagan: how would I test a function that used user input? """ some_return = point_pattern.write_your_own(self.gj) self.assertTrue(False) + class TestIterablePointPattern(unittest.TestCase): """ This set of tests is focused on iterables and sequences. Once passing, you will have the foundation of some point pattern analysis functionality. """ + # This is like the standard setup, except it is only called once @classmethod def setUpClass(cls): # Seed a random number generator so we get the same random values every time random.seed(12345) # A list comprehension to create 50 random points - cls.points = [(random.randint(0,100), random.randint(0,100)) for i in range(50)] + cls.points = [(random.randint(0, 100), random.randint(0, 100)) for i in range(50)] def test_average_nearest_neighbor_distance(self): mean_d = point_pattern.average_nearest_neighbor_distance(self.points) @@ -65,10 +69,10 @@ def test_mean_center(self): def test_minimum_bounding_rectangle(self): mbr = point_pattern.minimum_bounding_rectangle(self.points) - self.assertEqual(mbr, [0,0,94,98]) + self.assertEqual(mbr, [0, 0, 94, 98]) def test_mbr_area(self): - mbr = [0,0,94,98] + mbr = [0, 0, 94, 98] area = point_pattern.mbr_area(mbr) self.assertEqual(area, 9212) @@ -84,6 +88,7 @@ class TestPointPattern(unittest.TestCase): These are the tests that you got working in assignment 3. You should not need to alter these at all. """ + def setUp(self): pass @@ -97,7 +102,7 @@ def test_getx(self): `getx` function so that the correct values are returned. """ - point = (1,2) + point = (1, 2) x = point_pattern.getx(point) self.assertEqual(1, x) @@ -110,7 +115,7 @@ def test_gety(self): `gety` function so that the correct values are returned. """ - point = (3,2.5) + point = (3, 2.5) y = point_pattern.gety(point) self.assertEqual(2.5, y) @@ -119,13 +124,13 @@ def test_shift_point(self): Test that a point is being properly shifted when calling point_pattern.shift_point """ - point = (0,0) + point = (0, 0) new_point = point_pattern.shift_point(point, 3, 4) - self.assertEqual((3,4), new_point) + self.assertEqual((3, 4), new_point) point = (-2.34, 1.19) new_point = point_pattern.shift_point(point, 2.34, -1.19) - self.assertEqual((0,0), new_point) + self.assertEqual((0, 0), new_point) def test_euclidean_distance(self): """ @@ -208,11 +213,11 @@ def test_check_in(self): """ As above, update the function in point_pattern.py """ - point_list = [(0,0), (1,0.1), (-2.1, 1), - (2,4), (1,1), (3.5, 2)] + point_list = [(0, 0), (1, 0.1), (-2.1, 1), + (2, 4), (1, 1), (3.5, 2)] - inlist = point_pattern.check_in((0,0), point_list) + inlist = point_pattern.check_in((0, 0), point_list) self.assertTrue(inlist) - inlist = point_pattern.check_in((6,4), point_list) + inlist = point_pattern.check_in((6, 4), point_list) self.assertFalse(inlist)