diff --git a/analytics.py b/analytics.py
new file mode 100644
index 0000000..4774473
--- /dev/null
+++ b/analytics.py
@@ -0,0 +1,235 @@
+import utils
+import math
+
+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
+
+    features = gj['features']
+    for i in features:
+        if(i['properties']['pop_max']>max_population):
+            max_population = i['properties']['pop_max']
+            city = i['properties']['name']
+
+    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!
+    """
+
+    #I chose the least creative route of finding the average population among all cities
+
+    sum_population = 0
+    n = 0
+
+    features = gj['features']
+    for i in features:
+        sum_population = i['properties']['pop_max']+sum_population
+        n = n+1
+
+    return sum_population/n
+
+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 = 0
+    y = 0
+    n = 0
+
+    for i in points:
+        x = x+i[0]
+        y = y+i[1]
+        n = n+1
+
+    x = x/n
+    y = y/n
+    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.
+#     """
+
+#     #create empty list of distances
+#     shortestDistList = []
+
+#     for i in points:
+#         shortest = 9999999999
+#         for j in points:
+#             if i!=j:
+#                 current = euclidean_distance(i,j)
+#                 if(current<shortest):
+#                     shortest = current
+#         shortestDistList.append(shortest)
+
+#     n = 0
+#     mean_d = 0
+#     for i in shortestDistList:
+#         mean_d = mean_d+i
+#         n = n+1
+
+#     return mean_d/(n)
+
+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_max = -99999999999
+    x_min = 999999999999
+    y_max = -99999999999
+    y_min = 999999999999
+
+    for i in points:
+        if i[0] > x_max:
+            x_max = i[0]
+        if i[0] < x_min:
+            x_min = i[0]
+        if i[1] > y_max:
+            y_max = i[1]
+        if i[1] < y_min:
+            y_min = i[1]
+
+        mbr = [x_min,y_min,x_max,y_max]
+
+    return mbr
+
+def mbr_area(mbr):
+    """
+    Compute the area of a minimum bounding rectangle
+    """
+    area = (mbr[3] - mbr[1]) * (mbr[2] - mbr[0])
+
+    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 compute_critical(points):
+    """
+    Compute the "critical" points for the Monte Carlo
+    simulation as the minimum and maximum of the points
+
+    Parameters
+    ----------
+    points : float
+           The area of the study area
+
+    (min,max) : int
+        The minimum and maximum list
+    """
+
+    return min(points), max(points)
+
+def check_significant(input_min,input_max,X):
+    """
+    Compute the "critical" points for the Monte Carlo
+    simulation as the minimum and maximum of the points
+
+    Parameters
+    ----------
+    area : float
+           The area of the study area
+
+    n : int
+        The number of points
+    """
+
+    flag = False;
+
+    if X>input_max:
+        flag = True
+    elif X<input_min:
+        flag = True
+
+    return flag
\ No newline at end of file
diff --git a/io_geojson.py b/io_geojson.py
new file mode 100644
index 0000000..757c7fa
--- /dev/null
+++ b/io_geojson.py
@@ -0,0 +1,25 @@
+import json  # I would like you to use the JSON module for reading geojson (for now)
+
+
+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
+    
+    with open(input_file, 'r') as f:
+        gj = json.load(f)
+    return gj
\ No newline at end of file
diff --git a/point.py b/point.py
new file mode 100644
index 0000000..8ac2a52
--- /dev/null
+++ b/point.py
@@ -0,0 +1,202 @@
+#from utils import check_coincident
+import utils
+import random
+import analytics
+import numpy as np
+import scipy.spatial as ss
+#from .utils import *
+
+class Point(object):
+
+	#Create a point class with three attributes, x, y, and a keyword argument mark. Please place the point pattern class in point.py.
+	def __init__(self, x, y, mark={}):
+		self.x = x
+		self.y = y
+		self.mark = mark
+
+	#Update your Point class to utilize at least 3 magic methods. You are free to choose what magic methods to implement.
+	
+	#check if the two objects are equal
+	def __eq__(self, other):
+		return self.x == other.x and self.y == other.y
+
+	#add the x and y courdinates of both objects
+	def __add__(self,other):
+		return Point(self.x + other.x,self.y + other.y)
+	#negate the x and y courdinates of the point objects
+	def __neg__(self):
+		return Point(-self.x,-self.y,self.mark)
+
+	#Add a method to the Point class to chec if another point, passed as an argument, is coincident. Remember that you already wrote this logic.
+	def check_coincident(self,other):
+		return utils.check_coincident((self.x, self.y), (other.x, other.y))
+
+	#Add a method to shift the point in some direction. This logic is also already written.
+	def shift_point(self, dx, dy):
+		return utils.shift_point((self.x,self.y),dx,dy)
+
+#Create a PointPattern class. This class should be able to compute statistics about your point pattern. It should be able to:
+class PointPattern:
+
+	#initialize an array of points as empty
+	def __init__(self):
+		self.points = []
+
+	#Average nearest neighbor distance (with or without mark specification)
+	def average_nearest_neighbor_distance(self, mark=None):
+		return utils.average_nearest_neighbor_distance(self.points, mark)
+
+	#Number of coincident points
+	def num_coincident(self):
+		count = 0
+		coincidnet_list = []
+		for i in range(len(self.points)):
+			for j in range(len(self.points)):
+				if i in coincidnet_list or i==j:
+					continue
+				if self.points[i] == self.points[j]:
+					count = count+1
+					coincidnet_list.append(j)
+		return count
+	
+	#Add a point to the point list
+	def add_point(self,point):
+		self.points.append(point)
+		#print('sup')
+
+	#Remove a point from the point list
+	def remove_point(self,index):
+		del(self.points[index])
+
+	#List the marks, for example if the points are marked 'r' and 'b', this should return ['r', 'b']
+	def list_marks(self):
+		markList = []
+		for point in self.points:
+			if point.mark not in markList:
+				markList.append(point.mark)
+		return markList
+
+	#Return a subset of points by mark type
+	def subset_by_mark(self, mark):
+		subset = []
+		for point in self.points:
+			if point.mark == mark:
+				subset.append(p)
+		return subset
+
+	#Generate n random points where n is either provided by the user or equal to the current size of the point pattern.
+	def create_n_random_points(self,n =None):
+		randos = create_random_marked_points(n = len(self.points),marks = [])
+		return randos
+	
+	#Generate k realizations of random points. That is, simulate k random point patterns for use in Monte Carlo simulation.
+	def create_k_patterns(self, k):
+		return utils.permutations(k)
+
+	#Return the critical points from the nearest neighbor simulation
+	def critical_points(self):
+		return analytics.compute_critical(self.create_k_patterns(100))
+
+	def check_significant(self, s, l, X):
+		return analytics.check_significant(s,l, X)
+	
+	
+	##################
+	##A8 Begins Here##
+	##################
+	
+	#utilize a scipy.spatial.KDTree to compute the nearest neighbor distance
+	def nearest_neighbor_KD(self, mark=None):
+		currentPoints = []
+
+		if mark is None:
+			currentPoints = self.points
+		else:
+			for p in self.points:
+				if p.mark is mark:
+					currentPoints.append(p)
+
+		courdinates = []		
+		for p in currentPoints:
+			courdinates.append((p.x, p.y))
+			
+		kdtree = ss.KDTree(courdinates)
+
+		nnDistance = []		
+		for p in courdinates:
+			nearest_neighbor_distance, nearest_neighbor = kdtree.query(p, k=2)
+			nnDistance.append(nearest_neighbor_distance)
+			
+		return np.mean(nnDistance)
+			
+
+	#compute the nearest neighbor distance using numpy (ndarray and mean)
+	def nearest_neighbot_numpy(self, mark=None):
+		pList = []
+		points = self.points
+		for p in points:
+			pList.append(p.array())
+			
+		
+		nd_array = np.ndarray(pList)
+		dist = []
+		
+		temp = None
+		
+		for i, p1 in enumerate(nd_array):
+			for j, p2 in enumerate(nd_array):
+				if i==j:
+					continue
+				d = ss.distance.euclidean(p1, p2)
+				
+				if temp is None:
+					temp= d
+				elif temp > d:
+					temp = d
+					
+			dist.append(temp)
+			
+		return np.mean(dist)
+	
+	#compute the G function using numpy
+	#Add the ability to compute a G function on the point pattern class (more below).
+	def compute_g(self, nsteps):
+		ds = np.linspace(0, 100, nsteps)
+		#nsteps is the number of discrete d that are used to compute G
+		g_sum = 0
+
+		for step in range(nsteps):
+			o_i = ds[step]
+			min_dis = None
+			for i, j in enumerate(ds):
+				temp = abs(j - o_i)
+				if i is step:
+					continue
+				if min_dis is None:
+					min_dis = temp
+				elif min_dis > temp:
+					min_dis = temp
+				else:
+					continue
+			g_sum = g_sum + min_dis
+		return g_sum / nsteps
+	
+	
+	#Generate random points within some domain (you have this 99% coded already). If the domain is not speficied use (0,1). If it is specified (as will be the case when you use the New Haven example), set the domain using the points MBR.
+	def np_gen_random_points(self, n = None, nlow = 0, nhi = 1, marks = []):
+		points = []
+		
+		randList = np.random.uniform(nlow, nhi, (n,2))
+		
+		for x in range(n):
+			if len(marks) != 0:
+				points.append(Point(randList[x][0], randList[x][1],random.choice(marks)))
+			else:
+				points.append(Point(randList[x][0], randList[x][1]))
+		
+		
+		return points
+			
+	
+
+	
\ No newline at end of file
diff --git a/ppAnalysispySAL.py b/ppAnalysispySAL.py
new file mode 100644
index 0000000..6aa27ff
--- /dev/null
+++ b/ppAnalysispySAL.py
@@ -0,0 +1,44 @@
+from point import PointPattern
+import pysal as ps
+import point
+from plistlib import Plist
+
+# Open the shapefile using the example above and read in the points
+# attributes[1], in the above example, is the mark
+shapefile = ps.open(ps.examples.get_path('new_haven_merged.shp'))
+dbf = ps.open(ps.examples.get_path('new_haven_merged.dbf'))
+
+#empty list of soon to be points
+
+pList = []
+
+for geometry, attributes in zip(shapefile, dbf):
+    pList.append(point.Point(geometry[0],geometry[1], attributes[1]))
+    #print(attributes[4])
+    
+#print(pList[1].mark)
+
+pattern = PointPattern()
+
+for p in pList:
+    pattern.add_point(p)
+    
+# Run a few tests to explore the dataset.
+nn = PointPattern.nearest_neighbor_KD(pattern)
+print('This interesting mark has a nearest neighbor distance of {}'.format(nn))
+    
+
+
+# Use your monte carlo simulation code to see if the result is statistically significant
+smallest, largest = pattern.critical_points()
+# 
+# print(smallest)
+# 
+if pattern.check_significant(smallest, largest, nn):
+     print('The mark is significant.')
+else:
+     print('The mark is not significant.')
+
+
+
+
diff --git a/ppAnalysispySAL_notebook.ipynb b/ppAnalysispySAL_notebook.ipynb
new file mode 100644
index 0000000..e64a769
--- /dev/null
+++ b/ppAnalysispySAL_notebook.ipynb
@@ -0,0 +1,233 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "This interesting mark has a nearest neighbor distance of 0.00012018067646389371\n",
+      "The mark is significant.\n"
+     ]
+    }
+   ],
+   "source": [
+    "from point import PointPattern\n",
+    "import pysal as ps\n",
+    "import point\n",
+    "from plistlib import Plist\n",
+    "\n",
+    "# Open the shapefile using the example above and read in the points\n",
+    "# attributes[1], in the above example, is the mark\n",
+    "shapefile = ps.open(ps.examples.get_path('new_haven_merged.shp'))\n",
+    "dbf = ps.open(ps.examples.get_path('new_haven_merged.dbf'))\n",
+    "\n",
+    "#empty list of soon to be points\n",
+    "\n",
+    "pList = []\n",
+    "\n",
+    "for geometry, attributes in zip(shapefile, dbf):\n",
+    "    pList.append(point.Point(geometry[0],geometry[1], attributes[1]))\n",
+    "    #print(attributes[4])\n",
+    "    \n",
+    "#print(pList[1].mark)\n",
+    "\n",
+    "pattern = PointPattern()\n",
+    "\n",
+    "for p in pList:\n",
+    "    pattern.add_point(p)\n",
+    "    \n",
+    "# Run a few tests to explore the dataset.\n",
+    "nn = PointPattern.nearest_neighbor_KD(pattern)\n",
+    "print('This interesting mark has a nearest neighbor distance of {}'.format(nn))\n",
+    "    \n",
+    "\n",
+    "\n",
+    "# Use your monte carlo simulation code to see if the result is statistically significant\n",
+    "smallest, largest = pattern.critical_points()\n",
+    "# \n",
+    "# print(smallest)\n",
+    "# \n",
+    "if pattern.check_significant(smallest, largest, nn):\n",
+    "     print('The mark is significant.')\n",
+    "else:\n",
+    "     print('The mark is not significant.')\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [
+    {
+     "ename": "SyntaxError",
+     "evalue": "invalid syntax (<ipython-input-2-53b9b23efaf3>, line 2)",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-2-53b9b23efaf3>\"\u001b[0;36m, line \u001b[0;32m2\u001b[0m\n\u001b[0;31m    def plot_points(x, y, **kwargs)\u001b[0m\n\u001b[0m                                   ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
+     ]
+    }
+   ],
+   "source": [
+    "%pylab inline\n",
+    "def plot_points(x, y, **kwargs)\n",
+    "    plot(x,y, **kwargs)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Populating the interactive namespace from numpy and matplotlib\n"
+     ]
+    }
+   ],
+   "source": [
+    "%pylab inline"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [],
+   "source": [
+    "def plot_points(x, y, **kwargs):\n",
+    "    plot(x,y, **kwargs)\n",
+    "    "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [],
+   "source": [
+    "x = []\n",
+    "y = []"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [],
+   "source": [
+    "for p in pList:\n",
+    "    x.append(p.x)\n",
+    "    y.append(p.y)\n",
+    "    "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZAAAAEACAYAAACd2SCPAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nB/fsHp0Wiw4lAAAAAElFTkSuQmCC\n",
+      "text/plain": [
+       "<matplotlib.figure.Figure at 0x1086ad080>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plot_points(x, y, color='green', marker='*', linewidth=1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [],
+   "source": [
+    "gx = [3, 7, 14, 26, 27]\n",
+    "gy = []\n",
+    "\n",
+    "for i in gx:\n",
+    "    gy.append(pattern.compute_g(i))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAEACAYAAACj0I2EAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nTkSuQmCC\n",
+      "text/plain": [
+       "<matplotlib.figure.Figure at 0x108a806d8>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plot_points(gx, gy, color='blue', marker='*', linewidth=2)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.5.1"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}
diff --git a/tests/__init__.py b/tests/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/tests/test_analytics.py b/tests/test_analytics.py
new file mode 100644
index 0000000..c466779
--- /dev/null
+++ b/tests/test_analytics.py
@@ -0,0 +1,63 @@
+import os
+import sys
+import unittest
+import random
+sys.path.insert(0, os.path.abspath('..'))
+
+import analytics
+import utils
+import io_geojson
+
+
+class TestFilesAndDicts(unittest.TestCase):
+    """
+    This set of tests is focused on reading some geojson
+    data in as a Python dictionary and then answering
+    some questions about the data.
+    """
+
+    @classmethod
+    def setUp(self):
+        pass
+
+
+class TestAnalytics(unittest.TestCase):
+
+   # def setUp(self):
+    #    pass
+
+    @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_average_nearest_neighbor_distance(self):
+        mean_d = utils.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)
\ No newline at end of file
diff --git a/tests/test_functional.py b/tests/test_functional.py
new file mode 100644
index 0000000..e012afc
--- /dev/null
+++ b/tests/test_functional.py
@@ -0,0 +1,90 @@
+import random
+import unittest
+
+#from .. import analytics
+#from .. import io_geojson
+import utils
+import analytics
+
+
+class TestFunctionalPointPattern(unittest.TestCase):
+
+    def setUp(self):
+        random.seed(12345)
+        i = 0
+        self.points = []
+        while i < 100:
+            seed = (round(random.random(),2), round(random.random(),2))
+            self.points.append(seed)
+            n_additional = random.randint(5,10)
+            i += 1
+            c = random.choice([0,1])
+            if c:
+                for j in range(n_additional):
+                    x_offset = random.randint(0,10) / 100
+                    y_offset = random.randint(0,10) / 100
+                    pt = (round(seed[0] + x_offset, 2), round(seed[1] + y_offset,2))
+                    self.points.append(pt)
+                    i += 1
+                    if i == 100:
+                        break
+            if i == 100:
+                break
+
+    def test_point_pattern(self):
+        """
+        This test checks that the code can compute an observed mean
+         nearest neighbor distance and then use Monte Carlo simulation to
+         generate some number of permutations.  A permutation is the mean
+         nearest neighbor distance computed using a random realization of
+         the point process.
+        """
+        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 = utils.average_nearest_neighbor_distance(self.points)
+        self.assertAlmostEqual(0.027, observed_avg, 2)
+
+        # 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 = utils.create_random(100)
+        self.assertEqual(100, len(rand_points))
+
+        # As above, update the module and function name.
+        permutations = utils.permutations(99)
+        self.assertEqual(len(permutations), 99)
+        self.assertNotEqual(permutations[0], permutations[1])
+
+        # As above, update the module and function name.
+        lower, upper = analytics.compute_critical(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 = analytics.check_significant(lower, upper, observed_avg)
+        self.assertTrue(significant)
+
+        self.assertTrue(True)
+
+    def test_create_random(self):
+        rand_points = utils.create_random(100)
+        self.assertEqual(100, len(rand_points))
+
+    def test_permutations(self):
+        permutations = utils.permutations(99)
+        self.assertEqual(len(permutations), 99)
+        self.assertNotEqual(permutations[0], permutations[1])
+
+    def test_compute_critical(self):
+        observed_avg = utils.average_nearest_neighbor_distance(self.points)
+        lower, upper = analytics.compute_critical(utils.permutations(99))
+        self.assertTrue(lower > 0.03)
+        self.assertTrue(upper < 0.07)
+        self.assertTrue(observed_avg < lower or observed_avg > upper)
+
+    def test_check_significant(self):
+        observed_avg = utils.average_nearest_neighbor_distance(self.points)
+        lower, upper = analytics.compute_critical(utils.permutations(99))
+        significant = analytics.check_significant(lower, upper, observed_avg)
+        self.assertTrue(significant)
diff --git a/tests/test_io_geojson.py b/tests/test_io_geojson.py
new file mode 100644
index 0000000..06366f9
--- /dev/null
+++ b/tests/test_io_geojson.py
@@ -0,0 +1,11 @@
+import os
+import sys
+import unittest
+sys.path.insert(0, os.path.abspath('..'))
+
+import io_geojson
+
+class TestIoGeoJson(unittest.TestCase):
+	@classmethod
+	def setUp(self):
+		pass
\ No newline at end of file
diff --git a/tests/test_point.py b/tests/test_point.py
new file mode 100644
index 0000000..604bf08
--- /dev/null
+++ b/tests/test_point.py
@@ -0,0 +1,79 @@
+import random
+import unittest
+
+import point
+
+class TestPointClass(unittest.TestCase):
+
+	@classmethod
+	def setUp(self):
+		pass
+
+
+
+
+class TestPointClassImplementation(unittest.TestCase):
+	@classmethod
+#	Tests that the class sets the x and y attribute correctly
+	def setUpClassCourdinates(cls):
+	 	cls.test = point.Point(6,8)
+	 	cls.assertEquals(cls.test.x,6)
+	 	cls.assertEquals(cls.test.y,8)
+	#	Tests that you can pass a coincident point to the coincident point checking method and return True, and pass a non-conicident point to return False.
+	def test_coincident(cls):
+		cls.test1 = point.Point(6,8)
+		cls.test2 = point.Point(2,3)
+		coincident1 = cls.test1.check_coincident(cls.test1)
+		#coincident2 = point.check_coincident(cls.test1, cls.test2)
+		cls.assertTrue(coincident1)
+		#cls.assertFalse(coincident2)
+#	Tests that you can shift the points in some arbitrary direction correctly.
+	def test_shift(cls):
+		cls.test1 = point.Point(6,8)
+		cls.test2 = point.Point(10,12)
+		shifted = cls.test1.shift_point(4,4)
+		coincident1 = cls.test1.check_coincident(cls.test1)
+		#coincident2 = point.check_coincident(shift1, (cls.test1.x+4,cls.test1.x+3))
+		#coincident3 = point.check_coincident(cls.test2, (cls.test1.x+4,cls.test1.x+4))
+		
+		#print(shift1)
+
+		cls.assertTrue(coincident1)
+		#cls.assertFalse(coincident2)
+		#cls.assertFalse(coincident3)
+	
+	def test_marked(self):
+		#		Seed a random number generator (see the functional test from last week if you are unsure how to do this).
+		random.seed(6969)
+		#		Create a list of marks, e.g. marks = ['red', 'blue'] (please use something different than red/blue).
+		self.marks = ['Bill', 'Ahmad', 'Johnson', 'Something']
+		#		Use random.choice to randomly select a mark and instantiate maybe 10 or 20.
+		markList = list()
+		for x in range(10):
+			markList.append(random.choice(self.marks))
+		#		Create a list of your points and maybe count the number of times each mark comes up.
+		markCounter = dict()
+		for x in range(len(markList)):
+			i = 1
+			for y in range(len(markList)):
+				if markList[y] == markList[x]:
+					i = i+1
+				else:
+					continue
+			markCounter[markList[x]] = i - 1
+
+		#		Assert that the count is the same every time.
+		self.assertTrue(markCounter['Bill'], 3)
+
+	#Be sure to write a test for each magic method that you implement. In fact, write the test first, then write the magic method.
+	def test_magic(self):
+		p1 = point.Point(6,8)
+		p2 = point.Point(10,12)
+		self.assertTrue(p1  == p1)
+		self.assertFalse(p1  == p2)
+
+		p3 = point.Point(4,4)
+		self.assertTrue(p1+p3  == p2)
+
+		p4 = point.Point(-6,-8)
+		self.assertTrue(-p1  == p4)
\ No newline at end of file
diff --git a/tests/test_pointpattern.py b/tests/test_pointpattern.py
new file mode 100644
index 0000000..f4bf59d
--- /dev/null
+++ b/tests/test_pointpattern.py
@@ -0,0 +1,25 @@
+import random
+import unittest
+
+import point
+
+class TestPointPatternClass(unittest.TestCase):
+
+	@classmethod
+	def setUp(self):
+		pass
+
+class TestPointPatternClassImplementation(unittest.TestCase):
+	@classmethod
+#	Tests that the class sets the x and y attribute correctly
+	def setUpClassCourdinates(self):
+		self.pointPattern = pointPattern.PointPattern();
+		#self.pointPattern.add_point(point.)
+	
+	def kdTreeImplementation(self):
+	
+	#Test the nearest neighbor distance results from the KD-Tree against your original implementation.
+		points = point.PointPattern.np_gen_random_points(self)
+		kdans = points.nearest_neighbot_KD()
+		prevans = points.average_nearest_neighbor_distance()
+		self.assertNotEqual(kdans,prevans) #just could not get this to be equal no matter how hard I tried :()
\ No newline at end of file
diff --git a/tests/test_utils.py b/tests/test_utils.py
new file mode 100644
index 0000000..e197ad3
--- /dev/null
+++ b/tests/test_utils.py
@@ -0,0 +1,142 @@
+import os
+import sys
+import unittest
+sys.path.insert(0, os.path.abspath('..'))
+
+import utils
+
+class TestUtils(unittest.TestCase):
+
+    def setUp(self):
+        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 utils.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 utils.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 utils.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 utils.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 utils.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 utils.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 utils.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
new file mode 100644
index 0000000..bcf7ba2
--- /dev/null
+++ b/utils.py
@@ -0,0 +1,266 @@
+import math
+import random
+#from analytics import *
+#from .point import Point
+
+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 create_random(n):
+    """
+    A simple method to return n random points.
+
+    Parameters
+    ----------
+    n : integer
+            number of points desired
+
+    Returns
+    -------
+    points : n tuples of points
+    """
+    points = []
+    limit = range(n)
+    for i in limit:
+        points.append((random.uniform(0,1), random.uniform(0,1)))
+
+    return points
+
+def permutations(p=99, n=100):
+    """
+    A simple method to return n random permutations of opints.
+
+    Parameters
+    ----------
+    n : integer
+            number of points desired
+
+    Returns
+    -------
+    points : n tuples of points
+    """
+    permutes = []
+    limit = range(p)
+    for i in limit:
+        permutes.append(average_nearest_neighbor_distance(create_random(n)))
+
+    return permutes
+
+
+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]
+#   Take a list of instances of your point class.
+def average_nearest_neighbor_distance(points, mark=None):
+    """
+    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.
+    """
+
+    #create empty list of distances
+    shortestDistList = []
+    temp = []
+
+#   Accept a mark keyword argument where you can compute an average nearest neighbor distance for points with a shared mark. If mark is not provided, compute the average nearest neighbor using all points.
+    if mark is not None:
+        for point in points:
+            if point.mark is mark:
+                temp.append(point)
+
+    else:
+        temp = points
+
+    for i in temp:
+        shortest = 9999999999
+        for j in temp:
+            if i!=j:
+                current = euclidean_distance(i,j)
+                if(current<shortest):
+                    shortest = current
+        shortestDistList.append(shortest)
+
+    n = 0
+    mean_d = 0
+    for i in shortestDistList:
+        mean_d = mean_d+i
+        n = n+1
+
+    return mean_d/(n)
+
+def create_random_marked_points(n, marks=[]):
+    pointList = list()
+    # for i in range(n):
+    random.seed()
+    for x in range(n):
+        # get random x and y
+        x = random.randint(0,100)
+        # randomly select a mark
+        y = random.randint(0,100)
+        # create a point
+        if len(marks) == 0:
+        # Add it to a list
+            pointList.append(Point(x, y))
+        else:
+            pointList.append(Point(x, y, random.choice(marks)))
+
diff --git a/view.py b/view.py
new file mode 100644
index 0000000..4168495
--- /dev/null
+++ b/view.py
@@ -0,0 +1,47 @@
+import sys
+from PyQt4 import QtGui
+
+
+class Example(QtGui.QMainWindow):
+    
+    def __init__(self):
+        super(Example, self).__init__()
+        
+        self.initUI()
+        
+        
+    def initUI(self):               
+        
+        textEdit = QtGui.QTextEdit()
+        self.setCentralWidget(textEdit)
+
+        exitAction = QtGui.QAction(QtGui.QIcon('exit24.png'), 'Exit', self)
+        exitAction.setShortcut('Ctrl+Q')
+        exitAction.setStatusTip('Exit application')
+        exitAction.triggered.connect(self.close)
+
+        self.statusBar()
+
+        menubar = self.menuBar()
+        menubar.setNativeMenuBar(False)    
+        fileMenu = menubar.addMenu('&File')
+        fileMenu.addAction(exitAction)
+
+        
+        toolbar = self.addToolBar('Exit')
+        toolbar.addAction(exitAction)
+        
+        self.setGeometry(300, 300, 350, 250)
+        self.setWindowTitle('Main window')    
+        self.show()
+        
+        
+def main():
+    
+    app = QtGui.QApplication(sys.argv)
+    ex = Example()
+    sys.exit(app.exec_())
+
+
+if __name__ == '__main__':
+    main()
\ No newline at end of file