diff --git a/analytics.py b/analytics.py
index e69de29..a912e4e 100644
--- a/analytics.py
+++ b/analytics.py
@@ -0,0 +1,160 @@
+import math
+import random
+from .utils import euclidean_distance, random_points
+
+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
+
+    x = [i[0] for i in points]
+    y = [i[1] for i in points]
+
+    sumX = (sum(x) / len(points))
+    sumY = (sum(y) / len(points))
+
+    x = sumX
+    y = sumY
+
+    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
+
+    shortDistanceList = []
+
+    for firstPoint in points:
+        pointInList = 500
+        for secondPoint in points:
+            if firstPoint is not secondPoint:
+                distance = euclidean_distance(firstPoint, secondPoint)
+                if (pointInList > distance):
+                    pointInList = distance
+
+        shortDistanceList.append(pointInList)
+
+    mean_d = sum(shortDistanceList) / len(points)
+
+    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]
+    """
+
+    mbr = [0,0,0,0]
+
+    xmin = 0
+    ymin = 0
+    xmax = 0
+    ymax = 0
+
+    for i in points:
+        if i[0] < xmin:
+            xmin = i[0]
+        if i[1] < ymin:
+            ymin = i[1]
+        if i[0] > xmax:
+            xmax = i[0]
+        if i[1] > ymax:
+            ymax = i[1]
+
+    mbr = [xmin,ymin,xmax,ymax]
+
+
+    return mbr
+
+
+def mbr_area(mbr):
+    """
+    Compute the area of a minimum bounding rectangle
+    """
+    area = 0
+
+    length = mbr[3] - mbr[1]
+    width = mbr[2] - mbr [0]
+    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
+
+    expected = (math.sqrt(area/n)) * (0.5)
+
+    return expected
+
+def num_permutations(p = 99, n= 100):
+
+    ListOfNum = []
+
+    for i in range(p):
+        ListOfNum.append(average_nearest_neighbor_distance(random_points(n)))
+
+    return ListOfNum
\ No newline at end of file
diff --git a/point.py b/point.py
index e69de29..dd79e86 100644
--- a/point.py
+++ b/point.py
@@ -0,0 +1,16 @@
+from . import utils
+
+class Foo(object):
+    def __init__(self, x, y, mark={}):
+        self.x = x
+        self.y = y
+        self.mark = mark
+
+    def coincidentPoint(self, point1):
+        point2 = (self.x, self.y)
+        return utils.check_coincident(point1, point2)
+
+    def shiftPoint(self,xShift, yShift):
+        thePoint = (self.x, self.y)
+        self.x, self.y = utils.shift_point(thePoint,xShift,yShift)
+
diff --git a/tests/functional_test.py b/tests/functional_test.py
index 596af78..fd7a9d9 100644
--- a/tests/functional_test.py
+++ b/tests/functional_test.py
@@ -40,28 +40,28 @@ 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)
-        self.assertEqual(100, len(rand_points))
+        random_points = utils.random_points(100)
+        self.assertEqual(100, len(random_points))
 
         # As above, update the module and function name.
-        permutations = point_pattern.permutations(99)
-        self.assertEqual(len(permutations), 99)
-        self.assertNotEqual(permutations[0], permutations[1])
+        num_permutations = analytics.num_permutations(99)
+        self.assertEqual(len(num_permutations), 99)
+        self.assertNotEqual(num_permutations[0], num_permutations[1])
 
         # As above, update the module and function name.
-        lower, upper = point_pattern.compute_critical(permutations)
+        lower, upper = utils.critical_points(num_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.significant(lower, upper, 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/point_test.py b/tests/point_test.py
new file mode 100644
index 0000000..1720abd
--- /dev/null
+++ b/tests/point_test.py
@@ -0,0 +1,71 @@
+import unittest
+import sys
+import random
+import os
+
+from .. import utils
+from .. point import Foo
+
+
+
+class TestingPointTest(unittest.TestCase):
+    def setUp(self):
+        pass
+
+    def test_xyCoordinatesCheck(self):
+        points = Foo(4,8)
+        self.assertEqual(4,points.x)
+        self.assertEqual(8,points.y)
+
+    def test_concidentPoint(self):
+        thePoint = Foo(3,8)
+
+        self.assertTrue(thePoint.coincidentPoint((3,8)))
+        self.assertFalse(thePoint.coincidentPoint((8,3)))
+
+    def test_shiftPoint(self):
+        thePoint = Foo(6,2)
+        shiftX = 1
+        shiftY = 1
+        thePoint.shiftPoint(shiftX,shiftY)
+        self.assertEqual((7,3),(thePoint.x, thePoint.y))
+
+    def test_theMarks(self):
+
+        random.seed(88888888)
+        marks = ['James', 'Paul', 'Sarah', 'Michael', 'Nancy', 'Henry']
+        thePoints = []
+
+        JamesCounter = 0;
+        PaulCounter = 0;
+        SarahCounter = 0;
+        MichaelCounter = 0;
+        NancyCounter = 0;
+        HenryCounter = 0;
+
+        for i in range(20):
+            addPoints = Foo(random.randint(0,9),random.randint(0,9),random.choice(marks))
+            thePoints.append(addPoints)
+            if thePoints[i].mark == "James":
+                JamesCounter = JamesCounter + 1
+            elif thePoints[i].mark == "Paul":
+                PaulCounter = PaulCounter + 1
+            elif thePoints[i].mark == "Sarah":
+                SarahCounter = SarahCounter + 1
+            elif thePoints[i].mark == "Michael":
+                MichaelCounter = MichaelCounter + 1
+            elif thePoints[i].mark == "Nancy":
+                NancyCounter = NancyCounter + 1
+            elif thePoints[i].mark == "Henry":
+                HenryCounter = HenryCounter + 1
+
+        self.assertEqual(JamesCounter, 1)
+        self.assertEqual(PaulCounter, 5)
+        self.assertEqual(SarahCounter, 5)
+        self.assertEqual(MichaelCounter, 4)
+        self.assertEqual(NancyCounter, 2)
+        self.assertEqual(HenryCounter, 3)
+
+
+
+
diff --git a/utils.py b/utils.py
index e69de29..6d0df40 100644
--- a/utils.py
+++ b/utils.py
@@ -0,0 +1,181 @@
+import math
+import random
+
+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]
+
+def random_points(n):
+
+    listOfPoints = [(random.uniform(0,1), random.uniform(0,1)) for x in range(n)]
+
+    return listOfPoints
+
+
+def critical_points(list):
+
+    minNum = min(list)
+
+    maxNum = max(list)
+
+    return minNum,maxNum
+
+def significant(cmin,cmax,observed):
+    if observed < cmin:
+        return True
+    if observed > cmax:
+        return True
+    else:
+        return False
+
+from . import utils
\ No newline at end of file