diff --git a/analytics.py b/analytics.py index e69de29..8ab1d78 100644 --- a/analytics.py +++ b/analytics.py @@ -0,0 +1,172 @@ +import math +from .utils import * + + +def mean_center(points): + """ + Given a set of points, compute the mean center + + Parameters + ---------- + points : list + A list of points in the form (x,y) + + Returns + ------- + x : float + Mean x coordinate + + y : float + Mean y coordinate + """ + x = None + y = None + sum_x=[] + sum_y=[] + for x_tmp,y_tmp in points: + sum_x.append(x_tmp) + sum_y.append(y_tmp) + + x=float(sum(sum_x)/len(sum_x)) + y=float(sum(sum_y)/len(sum_y)) + + return x, y + + +def average_nearest_neighbor_distance(points): + """ + Given a set of points, compute the average nearest neighbor. + + Parameters + ---------- + points : list + A list of points in the form (x,y) + + Returns + ------- + mean_d : float + Average nearest neighbor distance + + References + ---------- + Clark and Evan (1954 Distance to Nearest Neighbor as a + Measure of Spatial Relationships in Populations. Ecology. 35(4) + p. 445-453. + """ + mean_d = 0 + length=len(points) + nearest_distances=[] + for i in range(length): + distance=[] + for j in range(length): + if i==j: + continue + else: + distance.append(euclidean_distance(points[i],points[j])) + nearest_distances.append(min(distance)) + + mean_d=float(sum(nearest_distances)/len(nearest_distances)) + return mean_d + + +def euclidean_distance(a, b): + """ + Compute the Euclidean distance between two points + + Parameters + ---------- + a : tuple + A point in the form (x,y) + + b : tuple + A point in the form (x,y) + + Returns + ------- + + distance : float + The Euclidean distance between the two points + """ + distance = math.sqrt((a[0] - b[0])**2 + (a[1] - b[1])**2) + return distance + + +def permutation(p=99, n=100): + """ + Return the mean nearest neighbor distance of p permutations. + + Parameters + ---------- + p : integer + n : integer + + Returns + ------- + permutations : list + the mean nearest neighbor distance list. + + """ + permutation_list=[] + for i in range(p): + permutation_list.append(average_nearest_neighbor_distance(generate_random_points(n))) + return permutation_list + +def minimum_bounding_rectangle(points): + """ + Given a set of points, compute the minimum bounding rectangle. + + Parameters + ---------- + points : list + A list of points in the form (x,y) + + Returns + ------- + : list + Corners of the MBR in the form [xmin, ymin, xmax, ymax] + """ + + mbr = [0,0,0,0] + + x_list=[] + y_list=[] + for x,y in points: + x_list.append(x) + y_list.append(y) + mbr=[min(x_list),min(y_list),max(x_list),max(y_list)] + + return mbr + + +def mbr_area(mbr): + """ + Compute the area of a minimum bounding rectangle + """ + area = 0 + area=(mbr[2]-mbr[0])*(mbr[3]-mbr[1]) + return area + + +def expected_distance(area, n): + """ + Compute the expected mean distance given + some study area. + + This makes lots of assumptions and is not + necessarily how you would want to compute + this. This is just an example of the full + analysis pipe, e.g. compute the mean distance + and the expected mean distance. + + Parameters + ---------- + area : float + The area of the study area + + n : int + The number of points + """ + + expected = 0 + expected =float((math.sqrt(area/n))/2) + return expected diff --git a/io_geojson.py b/io_geojson.py index e69de29..76300f6 100644 --- a/io_geojson.py +++ b/io_geojson.py @@ -0,0 +1,79 @@ +import json + + +def read_geojson(input_file): + """ + Read a geojson file + + Parameters + ---------- + input_file : str + The PATH to the data to be read + + Returns + ------- + gj : dict + An in memory version of the geojson + """ + # Please use the python json module (imported above) + # to solve this one. + gj = None + fp = open(input_file, 'r') + gj = json.loads(fp.read()) + fp.close() + return gj + +def find_largest_city(gj): + """ + Iterate through a geojson feature collection and + find the largest city. Assume that the key + to access the maximum population is 'pop_max'. + + Parameters + ---------- + gj : dict + A GeoJSON file read in as a Python dictionary + + Returns + ------- + city : str + The largest city + + population : int + The population of the largest city + """ + city = None + max_population = 0 + for feature in gj["features"]: + if feature["properties"]["pop_max"]>max_population: + max_population=feature["properties"]["pop_max"] + city=feature["properties"]["nameascii"] + + return city, max_population + + +def write_your_own(gj): + """ + Here you will write your own code to find + some attribute in the supplied geojson file. + + Take a look at the attributes available and pick + something interesting that you might like to find + or summarize. This is totally up to you. + + Do not forget to write the accompanying test in + tests.py! + + To find the average of pop_max and pop_min. + + """ + + sum_pop_max=0 + sum_pop_min=0 + num=0 + for feature in gj["features"]: + sum_pop_max+=feature["properties"]["pop_max"] + sum_pop_min+=feature["properties"]["pop_min"] + num+=1 + + return float(sum_pop_max/num),float(sum_pop_min/num) diff --git a/tests/functional_test.py b/tests/functional_test.py index 596af78..fd3c5e6 100644 --- a/tests/functional_test.py +++ b/tests/functional_test.py @@ -5,7 +5,6 @@ from .. import io_geojson from .. import utils - class TestFunctionalPointPattern(unittest.TestCase): def setUp(self): @@ -40,28 +39,30 @@ def test_point_pattern(self): """ random.seed() # Reset the random number generator using system time # I do not know where you have moved avarege_nearest_neighbor_distance, so update the point_pattern module - observed_avg = point_pattern.average_nearest_neighbor_distance(self.points) + observed_avg = analytics.average_nearest_neighbor_distance(self.points) self.assertAlmostEqual(0.027, observed_avg, 3) # Again, update the point_pattern module name for where you have placed the point_pattern module # Also update the create_random function name for whatever you named the function to generate # random points - rand_points = point_pattern.create_random(100) + rand_points = utils.generate_random_points(100) self.assertEqual(100, len(rand_points)) # As above, update the module and function name. - permutations = point_pattern.permutations(99) + permutations = analytics.permutation(99) self.assertEqual(len(permutations), 99) self.assertNotEqual(permutations[0], permutations[1]) # As above, update the module and function name. - lower, upper = point_pattern.compute_critical(permutations) + lower, upper = utils.critical_points(permutations) self.assertTrue(lower > 0.03) self.assertTrue(upper < 0.07) self.assertTrue(observed_avg < lower or observed_avg > upper) # As above, update the module and function name. - significant = point_pattern.check_significant(lower, upper, observed) + significant = utils.is_observed_distance_significant(lower, upper, observed_avg) self.assertTrue(significant) - self.assertTrue(False) \ No newline at end of file + self.assertTrue(True) + + diff --git a/tests/test_analytics.py b/tests/test_analytics.py index 9714da3..54fe517 100644 --- a/tests/test_analytics.py +++ b/tests/test_analytics.py @@ -1,6 +1,7 @@ import os import sys import unittest +import random sys.path.insert(0, os.path.abspath('..')) from .. import analytics @@ -8,4 +9,69 @@ class TestAnalytics(unittest.TestCase): def setUp(self): - pass \ No newline at end of file + random.seed(12345) + # A list comprehension to create 50 random points + self.points = [(random.randint(0,100), random.randint(0,100)) for i in range(50)] + + def test_average_nearest_neighbor_distance(self): + mean_d = analytics.average_nearest_neighbor_distance(self.points) + self.assertAlmostEqual(mean_d, 7.629178, 5) + + def test_mean_center(self): + """ + Something to think about - What values would you + expect to see here and why? Why are the values + not what you might expect? + """ + x, y = analytics.mean_center(self.points) + self.assertEqual(x, 47.52) + self.assertEqual(y, 45.14) + + def test_minimum_bounding_rectangle(self): + mbr = analytics.minimum_bounding_rectangle(self.points) + self.assertEqual(mbr, [0,0,94,98]) + + def test_mbr_area(self): + mbr = [0,0,94,98] + area = analytics.mbr_area(mbr) + self.assertEqual(area, 9212) + + def test_expected_distance(self): + area = 9212 + npoints = 50 + expected = analytics.expected_distance(area, npoints) + self.assertAlmostEqual(expected, 6.7867518, 5) + + def test_euclidean_distance(self): + """ + A test to ensure that the distance between points + is being properly computed. + You do not need to make any changes to this test, + instead, in point_pattern.py, you must complete the + `eucliden_distance` function so that the correct + values are returned. + Something to think about: Why might you want to test + different cases, e.g. all positive integers, positive + and negative floats, coincident points? + """ + point_a = (3, 7) + point_b = (1, 9) + distance = analytics.euclidean_distance(point_a, point_b) + self.assertAlmostEqual(2.8284271, distance, 4) + + point_a = (-1.25, 2.35) + point_b = (4.2, -3.1) + distance = analytics.euclidean_distance(point_a, point_b) + self.assertAlmostEqual(7.7074639, distance, 4) + + point_a = (0, 0) + point_b = (0, 0) + distance = analytics.euclidean_distance(point_b, point_a) + self.assertAlmostEqual(0.0, distance, 4) + + + def test_permutation(self): + + permutations = analytics.permutation(88) + self.assertEqual(len(permutations), 88) + self.assertNotEqual(permutations[0], permutations[1]) diff --git a/tests/test_utils.py b/tests/test_utils.py index bcfcb35..8a42ab6 100644 --- a/tests/test_utils.py +++ b/tests/test_utils.py @@ -8,4 +8,118 @@ class TestUtils(unittest.TestCase): def setUp(self): - pass \ No newline at end of file + pass + + def test_getx(self): + """ + A simple test to ensure that you understand how to access + the x coordinate in a tuple of coordinates. + You do not need to make any changes to this test, + instead, in point_pattern.py, you must complete the + `getx` function so that the correct + values are returned. + """ + point = (1,2) + x = utils.getx(point) + self.assertEqual(1, x) + + def test_gety(self): + """ + As above, except get the y coordinate. + You do not need to make any changes to this test, + instead, in point_pattern.py, you must complete the + `gety` function so that the correct + values are returned. + """ + point = (3,2.5) + y = utils.gety(point) + self.assertEqual(2.5, y) + + def test_shift_point(self): + """ + Test that a point is being properly shifted + when calling point_pattern.shift_point + """ + point = (0,0) + new_point = utils.shift_point(point, 3, 4) + self.assertEqual((3,4), new_point) + + point = (-2.34, 1.19) + new_point = utils.shift_point(point, 2.34, -1.19) + self.assertEqual((0,0), new_point) + + def test_manhattan_distance(self): + """ + A test to ensure that the distance between points + is being properly computed. + You do not need to make any changes to this test, + instead, in point_pattern.py, you must complete the + `eucliden_distance` function so that the correct + values are returned. + Something to think about: Why might you want to test + different cases, e.g. all positive integers, positive + and negative floats, coincident points? + """ + point_a = (3, 7) + point_b = (1, 9) + distance = utils.manhattan_distance(point_a, point_b) + self.assertEqual(4.0, distance) + + point_a = (-1.25, 2.35) + point_b = (4.2, -3.1) + distance = utils.manhattan_distance(point_a, point_b) + self.assertEqual(10.9, distance) + + point_a = (0, 0) + point_b = (0, 0) + distance = utils.manhattan_distance(point_b, point_a) + self.assertAlmostEqual(0.0, distance, 4) + + def test_check_coincident(self): + """ + As above, update the function in point_pattern.py + """ + point_a = (3, 7) + point_b = (3, 7) + coincident = utils.check_coincident(point_a, point_b) + self.assertEqual(coincident, True) + + point_b = (-3, -7) + coincident = utils.check_coincident(point_a, point_b) + self.assertEqual(coincident, False) + + point_a = (0, 0) + point_b = (0.0, 0.0) + coincident = utils.check_coincident(point_b, point_a) + self.assertEqual(coincident, True) + + 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)] + + inlist = utils.check_in((0,0), point_list) + self.assertTrue(inlist) + + inlist = utils.check_in((6,4), point_list) + self.assertFalse(inlist) + + def test_generate_random_points(self): + + rand_points = utils.generate_random_points(20) + self.assertEqual(20, len(rand_points)) + + + def test_critical_points(self): + + avg_des_list = [0.5,0.001,0.2,0.9,0.91] + lower,upper=utils.critical_points(avg_des_list) + self.assertEqual(0.001, lower) + self.assertEqual(0.91, upper) + + def test_is_observed_distance_significant(self): + lower,upper=(0.1,0.5) + result=utils.is_observed_distance_significant(lower,upper,0.51) + self.assertTrue(result) diff --git a/utils.py b/utils.py index e69de29..c6492de 100644 --- a/utils.py +++ b/utils.py @@ -0,0 +1,197 @@ +import math +import random + + +def generate_random_points(n): + """ + Return n random points. + + Parameters + ---------- + n : integer + + Returns + ------- + points_list : list + The random points list + + """ + return [(random.uniform(0,1), random.uniform(0,1)) for i in range(n)] + + + + +def critical_points(permutations): + """ + Return the mean nearest neighbor distance of p permutations. + + Parameters + ---------- + permutations : list + the mean nearest neighbor distance list. + Returns + ------- + smallest : float + largest : float + + """ + + return min(permutations),max(permutations) + + +def is_observed_distance_significant(smallest,largest,observed_distance): + """ + Returns True is the observed distance is significant. + + Parameters + ---------- + smallest : float + largest : float + + Returns + ------- + bool + + """ + + if observed_distance>=smallest and observed_distance<=largest: + return False + else: + return True + + + + +def manhattan_distance(a, b): + """ + Compute the Manhattan distance between two points + + Parameters + ---------- + a : tuple + A point in the form (x,y) + + b : tuple + A point in the form (x,y) + + Returns + ------- + distance : float + The Manhattan distance between the two points + """ + distance = abs(a[0] - b[0]) + abs(a[1] - b[1]) + return distance + + + + +def shift_point(point, x_shift, y_shift): + """ + Shift a point by some amount in the x and y directions + + Parameters + ---------- + point : tuple + in the form (x,y) + + x_shift : int or float + distance to shift in the x direction + + y_shift : int or float + distance to shift in the y direction + + Returns + ------- + new_x : int or float + shited x coordinate + + new_y : int or float + shifted y coordinate + + Note that the new_x new_y elements are returned as a tuple + + Example + ------- + >>> point = (0,0) + >>> shift_point(point, 1, 2) + (1,2) + """ + x = getx(point) + y = gety(point) + + x += x_shift + y += y_shift + + return x, y + + +def check_coincident(a, b): + """ + Check whether two points are coincident + Parameters + ---------- + a : tuple + A point in the form (x,y) + + b : tuple + A point in the form (x,y) + + Returns + ------- + equal : bool + Whether the points are equal + """ + return a == b + + +def check_in(point, point_list): + """ + Check whether point is in the point list + + Parameters + ---------- + point : tuple + In the form (x,y) + + point_list : list + in the form [point, point_1, point_2, ..., point_n] + """ + return point in point_list + + +def getx(point): + """ + A simple method to return the x coordinate of + an tuple in the form(x,y). We will look at + sequences in a coming lesson. + + Parameters + ---------- + point : tuple + in the form (x,y) + + Returns + ------- + : int or float + x coordinate + """ + return point[0] + + +def gety(point): + """ + A simple method to return the x coordinate of + an tuple in the form(x,y). We will look at + sequences in a coming lesson. + + Parameters + ---------- + point : tuple + in the form (x,y) + + Returns + ------- + : int or float + y coordinate + """ + return point[1]