From 10cdcbef3d7acd372d0743fba50ef6123032b974 Mon Sep 17 00:00:00 2001
From: Sagarika Kadambi <sskadamb@asu.edu>
Date: Sun, 28 Feb 2016 05:55:35 -0700
Subject: [PATCH 1/5] Added updates to assignment 5

---
 analytics.py             | 244 +++++++++++++++++++++++++++++++++++++++
 io_geojson.py            |  22 ++++
 tests/functional_test.py |  23 ++--
 tests/test_analytics.py  |  64 +++++++++-
 tests/test_io_geojson.py |   5 +-
 tests/test_utils.py      | 146 ++++++++++++++++++++++-
 utils.py                 | 167 +++++++++++++++++++++++++++
 7 files changed, 658 insertions(+), 13 deletions(-)

diff --git a/analytics.py b/analytics.py
index e69de29..7ed1454 100644
--- a/analytics.py
+++ b/analytics.py
@@ -0,0 +1,244 @@
+import math
+import random
+from utils import euclidean_distance, n_random_points
+
+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
+    """
+    #features is a list, so iteration is by position
+    #if you want to iterate over the features you need to first grab the list out of the dictionary.
+
+    featureList = gj['features']
+    # now that you have the features, compare the pop_max fields to find the largest one
+    max_population = 0
+    for featureEntry in featureList:
+        if featureEntry["properties"]["pop_max"] > max_population:
+            max_population = featureEntry["properties"]["pop_max"]
+            city = featureEntry["properties"]["nameascii"]
+
+
+    return city, max_population
+
+def write_your_own(gj):
+    """
+    This function finds the least populated city, pop_min
+    """
+    featureList = gj["features"]
+    minPop = 999999999
+    for featureEntry in featureList:
+        #feature["properties"]["pop_min"] for feature in self.gj["features"]
+        if featureEntry["properties"]["pop_min"] < minPop:
+            minPop = featureEntry["properties"]["pop_min"]
+            city = featureEntry["properties"]["nameascii"]
+  #  minn = min(featureEntry["properties"]["pop_min"])
+#    print(minn)
+    return city, minPop
+
+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
+    """
+
+    #find the average of all the X points in the list
+
+  #  x_sum = sum(points[0])
+    #points_length = len(points)
+
+    sums = map(sum,zip(*points)) # returns iterable object of type map
+    sumsL = list(sums)
+    avgs = map(lambda xy: xy/len(points),sumsL)
+    avgsL = list(avgs)
+    x = avgsL[0]
+    y = avgsL[1]
+
+    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.
+    """
+
+    #d_i is the set of all of the distances between i and it's closest neighbor.
+    #then, between all of those distances, you divide by the number of points.
+
+    #find the distance between a point i and every other point
+    shDistL =[]       #list of shortest distances
+    mean_sum = 0
+    for point in points:
+        shortestDistance = 9999999999
+        for dpoint in points:
+            if point != dpoint:
+                dist = euclidean_distance(point, dpoint)
+                if(shortestDistance > dist):
+                    shortestDistance = dist
+        #now add the shortest distance of that point before it moves on to a new point
+        shDistL.append(shortestDistance)
+        mean_sum = shortestDistance + mean_sum
+
+    #once shDistL has all of the shortest distances, find the sum of those and divide by the number of points sums = map(sum,zip(*points))
+    #sums = map(sum,shDistL) #list like [x]
+   # print(type(sums))
+    print(shDistL)
+    sums = sum(shDistL)
+    mean_d = mean_sum/len(shDistL)
+    return mean_d
+
+
+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]
+    """
+    # a minimum bounding rectangle would be on the extremes of x/y
+
+    xmin = 99999999999
+    ymin = 99999999999
+    xmax = -9999999999
+    ymax = -9999999999
+    for point in points:
+        if point[0] < xmin:
+            xmin = point[0]
+        if point[1] < ymin:
+            ymin = point[1]
+        if point[0] > xmax:
+            xmax = point[0]
+        if point[1] > ymax:
+            ymax = point[1]
+    mbr = [xmin,ymin,xmax,ymax]
+
+    return mbr
+
+def mbr_area(mbr):
+    """
+    Compute the area of a minimum bounding rectangle
+    """
+    length = mbr[2] - mbr[0]
+    width  = mbr[3] - mbr[1]
+    area = length*width
+
+    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.5 * (math.sqrt(area/n))
+    return expected
+
+
+def permutation_nearest_distance(p=99,n=100):
+    """
+    Finds the nearest neighbor distance for p permutations with n
+    random points
+    :param p: permutation number of times you want to try different
+    simulations for monte carlo
+    :param n: random point number
+    :return LDist: list of distances, length p
+    """
+    LDist = []
+    for x in range(p): #loop from 0 to p
+        #create n random points
+        points = n_random_points(n) # returns [(x,y),(a,b)..]
+        #compute mean neighbor distance
+        mean_d = average_nearest_neighbor_distance(points)
+        LDist.append(mean_d)
+
+    return LDist
+
+def critical_points(LDist):
+    """
+    Find the critical points, the largest/smallest distances
+    :param LDist: the list of mean distances
+    :return CList: list containing critical points
+    """
+    CList = []
+    smallest = min(LDist)
+    largest = max(LDist)
+    CList.append(smallest)
+    CList.append(largest)
+    #print(CList)
+    return CList
+
+def significant(CList,distance):
+    """
+    Returns True if the observed distance is significant
+    :param CList: list of critical points
+    :param distance: the observed distance
+    :return result: True/False
+    """
+
+    if distance < CList[0] or distance > CList[1]:
+        result = True
+    else:
+        result = False
+    return result
diff --git a/io_geojson.py b/io_geojson.py
index e69de29..9b4ad41 100644
--- a/io_geojson.py
+++ b/io_geojson.py
@@ -0,0 +1,22 @@
+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.
+    with open(input_file,'r') as file:
+        gj = json.load(file)
+        print(gj)
+    return gj
diff --git a/tests/functional_test.py b/tests/functional_test.py
index 596af78..27a1b37 100644
--- a/tests/functional_test.py
+++ b/tests/functional_test.py
@@ -40,28 +40,33 @@ 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)
-        self.assertAlmostEqual(0.027, observed_avg, 3)
+        observed_avg = analytics.average_nearest_neighbor_distance(self.points)
+        self.assertAlmostEqual(0.03, 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.n_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_nearest_distance(99)
         self.assertEqual(len(permutations), 99)
         self.assertNotEqual(permutations[0], permutations[1])
 
+        """
+        Changed the test case regarding significant slightly, because my critical_points method returns a list of the
+        two critical points, and significant gets passed a list. So there aren't 3 parameters.
+        """
+
         # As above, update the module and function name.
-        lower, upper = point_pattern.compute_critical(permutations)
-        self.assertTrue(lower > 0.03)
-        self.assertTrue(upper < 0.07)
-        self.assertTrue(observed_avg < lower or observed_avg > upper)
+        critical = analytics.critical_points(permutations)
+        self.assertTrue(critical[0] > 0.03)
+        self.assertTrue(critical[1] < 0.07)
+        self.assertTrue(observed_avg < critical[0] or observed_avg > critical[1])
 
         # As above, update the module and function name.
-        significant = point_pattern.check_significant(lower, upper, observed)
+        significant = analytics.significant(critical, observed_avg)
         self.assertTrue(significant)
 
         self.assertTrue(False)
\ No newline at end of file
diff --git a/tests/test_analytics.py b/tests/test_analytics.py
index 9714da3..fd85507 100644
--- a/tests/test_analytics.py
+++ b/tests/test_analytics.py
@@ -1,11 +1,71 @@
 import os
 import sys
 import unittest
+import random
 sys.path.insert(0, os.path.abspath('..'))
 
 from .. import analytics
 
 class TestAnalytics(unittest.TestCase):
 
-    def setUp(self):
-        pass
\ No newline at end of file
+    @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)]
+
+    def test_permutation(self):
+        list = analytics.permutation_nearest_distance()
+        self.assertEqual(99,len(list))
+        list = analytics.permutation_nearest_distance(50,20)
+        self.assertEqual(50,len(list))
+
+    def test_critical(self):
+        list = analytics.permutation_nearest_distance()
+        critical = analytics.critical_points(list)
+        self.assertEqual(min(list),critical[0])
+        self.assertEqual(max(list),critical[1])
+
+    def test_significant(self):
+        critical = analytics.critical_points(analytics.permutation_nearest_distance())
+
+        distance = random.uniform(0,critical[0]-.000000001) #distance < min +
+        self.assertTrue(analytics.significant(critical,distance))
+
+        distance = random.uniform(critical[1]+.00000000000000001,9999999999999999999999999999999999999999999999999999999999) #distance > max
+        self.assertTrue(analytics.significant(critical,distance))
+
+        distance = random.uniform(critical[0],critical[1]) # min < distance < max
+        self.assertFalse(analytics.significant(critical,distance))
+
+    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)
+
+
diff --git a/tests/test_io_geojson.py b/tests/test_io_geojson.py
index 5394cd2..b13cf9b 100644
--- a/tests/test_io_geojson.py
+++ b/tests/test_io_geojson.py
@@ -1,5 +1,6 @@
 import os
 import sys
+import random
 import unittest
 sys.path.insert(0, os.path.abspath('..'))
 
@@ -7,5 +8,7 @@
 
 class TestIoGeoJson(unittest.TestCase):
 
+    @classmethod
     def setUp(self):
-        pass
\ No newline at end of file
+        pass
+
diff --git a/tests/test_utils.py b/tests/test_utils.py
index bcfcb35..37f2ccb 100644
--- a/tests/test_utils.py
+++ b/tests/test_utils.py
@@ -1,6 +1,8 @@
 import os
 import sys
 import unittest
+import random
+
 sys.path.insert(0, os.path.abspath('..'))
 
 from .. import utils
@@ -8,4 +10,146 @@
 class TestUtils(unittest.TestCase):
 
     def setUp(self):
-        pass
\ No newline at end of file
+        pass
+
+    def test_n_random(self):
+        """
+        Tests if a list of length n was created
+        """
+
+        random.seed(123)
+        point = [(random.randint(0,100), random.randint(0,100)) for i in range(50)]
+        length = len(point)
+        x = utils.n_random_points(50)
+        self.assertEqual(length,len(x))
+
+
+    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_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 = utils.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 = utils.euclidean_distance(point_a, point_b)
+        self.assertAlmostEqual(7.7074639, distance, 4)
+
+        point_a = (0, 0)
+        point_b = (0, 0)
+        distance = utils.euclidean_distance(point_b, point_a)
+        self.assertAlmostEqual(0.0, distance, 4)
+
+    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)
\ No newline at end of file
diff --git a/utils.py b/utils.py
index e69de29..24ca511 100644
--- a/utils.py
+++ b/utils.py
@@ -0,0 +1,167 @@
+import math
+import random
+
+def n_random_points(n):
+    """
+    :param n:the amount of random points you wish to create
+    :return :the list of n (tuple) points
+    """
+
+    #use list comprehensions to generate n point list
+    points = [(random.randint(0,500), random.randint(0,500)) for x in range(n)]
+
+    return points
+
+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 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 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]
\ No newline at end of file

From 2c2cc663b4c7ed3092fa98177f28904ba59a592f Mon Sep 17 00:00:00 2001
From: Sagarika Kadambi <sskadamb@asu.edu>
Date: Sun, 28 Feb 2016 06:04:20 -0700
Subject: [PATCH 2/5] changed util import

---
 analytics.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/analytics.py b/analytics.py
index 7ed1454..5b9b583 100644
--- a/analytics.py
+++ b/analytics.py
@@ -1,6 +1,6 @@
 import math
 import random
-from utils import euclidean_distance, n_random_points
+from utils import *
 
 def find_largest_city(gj):
     """

From 5c4c7aaa3140036afb76a0905b075035f9952ff1 Mon Sep 17 00:00:00 2001
From: Sagarika Kadambi <sskadamb@asu.edu>
Date: Sun, 28 Feb 2016 06:08:24 -0700
Subject: [PATCH 3/5] fixing util import

---
 analytics.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/analytics.py b/analytics.py
index 5b9b583..8b51997 100644
--- a/analytics.py
+++ b/analytics.py
@@ -1,6 +1,6 @@
 import math
 import random
-from utils import *
+from .utils import euclidean_distance, n_random_points
 
 def find_largest_city(gj):
     """

From 09d5c465c241cc74819097525394b843f68fac31 Mon Sep 17 00:00:00 2001
From: Sagarika Kadambi <sskadamb@asu.edu>
Date: Sun, 28 Feb 2016 20:39:33 -0700
Subject: [PATCH 4/5] changed point array to float, [0,1]

---
 analytics.py             | 10 ++++------
 tests/functional_test.py |  2 +-
 tests/test_analytics.py  | 20 +++++++++++++++-----
 utils.py                 |  2 +-
 4 files changed, 21 insertions(+), 13 deletions(-)

diff --git a/analytics.py b/analytics.py
index 8b51997..73d1278 100644
--- a/analytics.py
+++ b/analytics.py
@@ -108,7 +108,6 @@ def average_nearest_neighbor_distance(points):
 
     #find the distance between a point i and every other point
     shDistL =[]       #list of shortest distances
-    mean_sum = 0
     for point in points:
         shortestDistance = 9999999999
         for dpoint in points:
@@ -118,14 +117,12 @@ def average_nearest_neighbor_distance(points):
                     shortestDistance = dist
         #now add the shortest distance of that point before it moves on to a new point
         shDistL.append(shortestDistance)
-        mean_sum = shortestDistance + mean_sum
 
     #once shDistL has all of the shortest distances, find the sum of those and divide by the number of points sums = map(sum,zip(*points))
     #sums = map(sum,shDistL) #list like [x]
-   # print(type(sums))
-    print(shDistL)
+   
     sums = sum(shDistL)
-    mean_d = mean_sum/len(shDistL)
+    mean_d = sums/len(shDistL)
     return mean_d
 
 
@@ -159,7 +156,8 @@ def minimum_bounding_rectangle(points):
         if point[1] > ymax:
             ymax = point[1]
     mbr = [xmin,ymin,xmax,ymax]
-
+    print("This is the mbr:")
+    print(mbr)
     return mbr
 
 def mbr_area(mbr):
diff --git a/tests/functional_test.py b/tests/functional_test.py
index 27a1b37..80ab8dd 100644
--- a/tests/functional_test.py
+++ b/tests/functional_test.py
@@ -69,4 +69,4 @@ def test_point_pattern(self):
         significant = analytics.significant(critical, observed_avg)
         self.assertTrue(significant)
 
-        self.assertTrue(False)
\ No newline at end of file
+        self.assertTrue(True)
\ No newline at end of file
diff --git a/tests/test_analytics.py b/tests/test_analytics.py
index fd85507..e31cf62 100644
--- a/tests/test_analytics.py
+++ b/tests/test_analytics.py
@@ -13,7 +13,7 @@ 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.uniform(0,1), random.uniform(0,1)) for i in range(50)]
 
     def test_permutation(self):
         list = analytics.permutation_nearest_distance()
@@ -41,7 +41,10 @@ def test_significant(self):
 
     def test_average_nearest_neighbor_distance(self):
         mean_d = analytics.average_nearest_neighbor_distance(self.points)
-        self.assertAlmostEqual(mean_d, 7.629178, 5)
+        self.assertAlmostEqual(mean_d, 0.0884470472, 5)
+    """
+    Changed from 7.629178 to 0.0884470472 because with the changed domain from (1-100) to (0-1), mean_d will be very different
+    """
 
     def test_mean_center(self):
         """
@@ -49,13 +52,20 @@ def test_mean_center(self):
          expect to see here and why?  Why are the values
          not what you might expect?
         """
+        """
+        Changed assert statements/test values slightly to match with domain of [0,1]
+        """
+
         x, y = analytics.mean_center(self.points)
-        self.assertEqual(x, 47.52)
-        self.assertEqual(y, 45.14)
+        self.assertAlmostEqual(x, 0.50273194,5)
+        self.assertAlmostEqual(y, 0.45796236, 5)
 
     def test_minimum_bounding_rectangle(self):
         mbr = analytics.minimum_bounding_rectangle(self.points)
-        self.assertEqual(mbr, [0,0,94,98])
+        self.assertAlmostEqual(mbr[0], 0.003331,5)
+        self.assertAlmostEqual(mbr[1], 0.003184,5)
+        self.assertAlmostEqual(mbr[2], 0.994604,5)
+        self.assertAlmostEqual(mbr[3], 0.967482,5)
 
     def test_mbr_area(self):
         mbr = [0,0,94,98]
diff --git a/utils.py b/utils.py
index 24ca511..818764a 100644
--- a/utils.py
+++ b/utils.py
@@ -8,7 +8,7 @@ def n_random_points(n):
     """
 
     #use list comprehensions to generate n point list
-    points = [(random.randint(0,500), random.randint(0,500)) for x in range(n)]
+    points = [(random.uniform(0,1), random.uniform(0,1)) for x in range(n)]
 
     return points
 

From 0b86e68b2517a0e2c6468dc3d8ad9271cad50370 Mon Sep 17 00:00:00 2001
From: Sagarika Kadambi <sskadamb@asu.edu>
Date: Mon, 29 Feb 2016 19:33:19 -0700
Subject: [PATCH 5/5] changed point comparison

---
 analytics.py             | 28 +++++++++++++---------------
 tests/functional_test.py |  2 +-
 2 files changed, 14 insertions(+), 16 deletions(-)

diff --git a/analytics.py b/analytics.py
index 73d1278..85bc696 100644
--- a/analytics.py
+++ b/analytics.py
@@ -40,7 +40,7 @@ def write_your_own(gj):
     This function finds the least populated city, pop_min
     """
     featureList = gj["features"]
-    minPop = 999999999
+    minPop = math.inf
     for featureEntry in featureList:
         #feature["properties"]["pop_min"] for feature in self.gj["features"]
         if featureEntry["properties"]["pop_min"] < minPop:
@@ -103,24 +103,22 @@ def average_nearest_neighbor_distance(points):
      p. 445-453.
     """
 
-    #d_i is the set of all of the distances between i and it's closest neighbor.
-    #then, between all of those distances, you divide by the number of points.
-
-    #find the distance between a point i and every other point
     shDistL =[]       #list of shortest distances
-    for point in points:
-        shortestDistance = 9999999999
-        for dpoint in points:
-            if point != dpoint:
+
+    #now the points are numbered... so if the points
+    #have the same counter number attached also, then they
+    #are self-neighbors, but if num1 != num2, then they are
+    # coincident points, with distance = 0
+    for num1, point in enumerate(points):
+        shortestDistance = math.inf
+        for num2, dpoint in enumerate(points):
+            if num1 != num2:
                 dist = euclidean_distance(point, dpoint)
                 if(shortestDistance > dist):
                     shortestDistance = dist
         #now add the shortest distance of that point before it moves on to a new point
         shDistL.append(shortestDistance)
-
-    #once shDistL has all of the shortest distances, find the sum of those and divide by the number of points sums = map(sum,zip(*points))
-    #sums = map(sum,shDistL) #list like [x]
-   
+    print(shDistL)
     sums = sum(shDistL)
     mean_d = sums/len(shDistL)
     return mean_d
@@ -142,8 +140,8 @@ def minimum_bounding_rectangle(points):
     """
     # a minimum bounding rectangle would be on the extremes of x/y
 
-    xmin = 99999999999
-    ymin = 99999999999
+    xmin = math.inf
+    ymin = math.inf
     xmax = -9999999999
     ymax = -9999999999
     for point in points:
diff --git a/tests/functional_test.py b/tests/functional_test.py
index 80ab8dd..dd3e6fa 100644
--- a/tests/functional_test.py
+++ b/tests/functional_test.py
@@ -41,7 +41,7 @@ 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 = analytics.average_nearest_neighbor_distance(self.points)
-        self.assertAlmostEqual(0.03, observed_avg, 3)
+        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