From 4ae6d89e17d8815799dd048a3d22cdf609c61338 Mon Sep 17 00:00:00 2001 From: smortime Date: Sat, 2 Apr 2016 16:39:17 -0700 Subject: [PATCH 1/6] Initial push --- PointPattern.py | 88 ++++++++++++ __init__.py | 0 analytics.py | 274 +++++++++++++++++++++++++++++++++++++ io_geojson.py | 22 +++ point.py | 36 +++++ tests/PointPattern.py | 88 ++++++++++++ tests/__init__.py | 0 tests/functional_test.py | 77 +++++++++++ tests/point_tests.py | 58 ++++++++ tests/pointpattern_test.py | 33 +++++ tests/test_analytics.py | 116 ++++++++++++++++ tests/test_io_geojson.py | 18 +++ tests/test_utils.py | 86 ++++++++++++ utils.py | 129 +++++++++++++++++ 14 files changed, 1025 insertions(+) create mode 100644 PointPattern.py create mode 100644 __init__.py create mode 100644 analytics.py create mode 100644 io_geojson.py create mode 100644 point.py create mode 100644 tests/PointPattern.py create mode 100644 tests/__init__.py create mode 100644 tests/functional_test.py create mode 100644 tests/point_tests.py create mode 100644 tests/pointpattern_test.py create mode 100644 tests/test_analytics.py create mode 100644 tests/test_io_geojson.py create mode 100644 tests/test_utils.py create mode 100644 utils.py diff --git a/PointPattern.py b/PointPattern.py new file mode 100644 index 0000000..6e7b71d --- /dev/null +++ b/PointPattern.py @@ -0,0 +1,88 @@ +from .point import Point +from . import analytics +import random +import numpy as np + +def PointPattern(object): + def __init__(self): + self.points = [] + + def average_nearest_neighbor_distance(self, mark=None): + return analytics.average_nearest_neighbor_distance(self.points, mark) + + def add_point(self, point): + self.points.append(point) + + def remove_point(self, index): + del(self.points[index]) + + def count_coincident_points(self): + count = 0 + coincidnet_list = [] + + for i, point in enumerate(self.points): + for j, point2 in enumerate(self.points): + if i is j: + continue + if j in coincident_list: + continue + #Should use the magic method in point class + if point == point2: + count += 1 + coincident_list.append(j) + return count + + def list_marks(self): + marks = [] + + for point in self.points: + if point.mark is not None and point.mark not in marks: + marks.append(point.mark) + + def return_subset(self, mark): + #creates a list of points that have the same mark as passed + return [i for i in self.points if i == mark] + + def create_random_points(self, n=None): + rand_points = [] + rand = random.Random() + marks = ['North', 'East', 'South', 'West'] + + if n is None: + n = len(self.points) + + for i in range(n): + rand_points.append(point.Point(rand.randint(1,100), rand.randint(1,100), mark=rand.choice(marks))) + + return rand_points + + def create_realizations(self, k): + return analytics.permutations(k) + + def critical_points(self): + return analytics.find_criticals(self.create_realizations(99)) + + def compute_g(self, nsteps): + ds = np.linspace(0, 100, nsteps) + 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 += min_dis + return g_sum / nsteps + + + diff --git a/__init__.py b/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/analytics.py b/analytics.py new file mode 100644 index 0000000..283a8f0 --- /dev/null +++ b/analytics.py @@ -0,0 +1,274 @@ +#analytics +import math +import json +import sys +import os + +sys.path.insert(0, os.path.abspath('..')) + +from . import utils +from . import point + +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 + """ + temp = gj['features'] + city = "" + max_population = 0 + + for i in temp: + 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! + """ + #Finds how many megacities there are in the geoJSON + temp = gj['features'] + megacities = 0 + + for i in temp: + if(i['properties']['megacity'] == 1): + megacities += 1 + + + return megacities + +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 + + for point in points: + x += point[0] + y += point[1] + + x = x / len(points) + y = y / len(points) + + return x, y + +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. + """ + + temp_points = [] + + if mark is not None: + for point in points: + if point.mark is mark: + temp_points.append(point) + else: + temp_points = points + + nearest = [] + + for i, point in enumerate(temp_points): + nearest.append(None) + for j, point2 in enumerate(temp_points): + if i is not j: + dist = euclidean_distance((point.x, point.y), (point2.x, point2.y)) + if nearest[i] == None: + nearest[i] = dist + elif nearest[i] > dist: + nearest[i] = dist + + mean_d = sum(nearest) / 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] + """ + + first = True + mbr = [0,0,0,0] + + for point in points: + if first: + first = False + mbr[0] = point[0] + mbr[1] = point[1] + mbr[2] = point[0] + mbr[3] = point[1] + + if point[0] < mbr[0]: + mbr[0] = point[0] + if point[1] < mbr[1]: + mbr[1] = point[1] + if point[0] > mbr[2]: + mbr[2] = point[0] + if point[1] > mbr[3]: + mbr[3] = point[1] + + return mbr + +def mbr_area(mbr): + """ + Compute the area of a minimum bounding rectangle + """ + area = (mbr[1] - mbr[3]) * (mbr[0] - mbr[2]) + 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 * (area / n) ** 0.5 + return expected + +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 permutations(p=99, n=100, marks=None): + perms = [] + + if marks is None: + for i in range(p): + perms.append(average_nearest_neighbor_distance(utils.create_random_marked_points(n, marks=None))) + + else: + for i in range(p): + perms.append(average_nearest_neighbor_distance(utils.create_random_marked_points(n, marks))) + + return perms + +def find_criticals(perms): + lower = min(perms) + upper = max(perms) + return lower, upper + +def check_significance(lower, upper, observed): + if observed > upper: + return True + elif observed < lower: + return True + else: + return False diff --git a/io_geojson.py b/io_geojson.py new file mode 100644 index 0000000..c41c48f --- /dev/null +++ b/io_geojson.py @@ -0,0 +1,22 @@ +#io_geojson +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 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..37bafdf --- /dev/null +++ b/point.py @@ -0,0 +1,36 @@ +#Point class +import sys +import os + +sys.path.insert(0, os.path.abspath('..')) + +from . import utils + + +class Point(object): + + def __init__(self, x, y, mark=None): + self.x = x + self.y = y + self.mark = mark + + #Magic methods + def __str__(self): + return ("({0}, {1}").format(self.x, self.y) + + def __eq__(self, other): + return self.x == other.x and self.y == other.y + + def __add__(self, other): + return Point(self.x + other.x, self.y + other.y) + + def __ne__(self, other): + return self.x != other.x or self.y != other.y + + #Class methods + def check_coincident(self, test): + return utils.check_coincident((self.x, self.y), test) + + def shift_point(self, x_shift, y_shift): + point = (self.x, self.y) + self.x, self.y = utils.shift_point(point, x_shift, y_shift) diff --git a/tests/PointPattern.py b/tests/PointPattern.py new file mode 100644 index 0000000..a5dfa7f --- /dev/null +++ b/tests/PointPattern.py @@ -0,0 +1,88 @@ +from .point import point +from . import analytics +import random +import numpy as np + +def PointPattern(object): + def __init__(self): + self.points = [] + + def average_nearest_neighbor_distance(self, mark=None): + return analytics.average_nearest_neighbor_distance(self.points, mark) + + def add_point(self, point): + self.points.append(point) + + def remove_point(self, index): + del(self.points[index]) + + def count_coincident_points(self): + count = 0 + coincidnet_list = [] + + for i, point in enumerate(self.points): + for j, point2 in enumerate(self.points): + if i is j: + continue + if j in coincident_list: + continue + #Should use the magic method in point class + if point == point2: + count += 1 + coincident_list.append(j) + return count + + def list_marks(self): + marks = [] + + for point in self.points: + if point.mark is not None and point.mark not in marks: + marks.append(point.mark) + + def return_subset(self, mark): + #creates a list of points that have the same mark as passed + return [i for i in self.points if i == mark] + + def create_random_points(self, n=None): + rand_points = [] + rand = random.Random() + marks = ['North', 'East', 'South', 'West'] + + if n is None: + n = len(self.points) + + for i in range(n): + rand_points.append(point.Point(rand.randint(1,100), rand.randint(1,100), mark=rand.choice(marks))) + + return rand_points + + def create_realizations(self, k): + return analytics.permutations(k) + + def critical_points(self): + return analytics.find_criticals(self.create_realizations(99)) + + def compute_g(self, nsteps): + ds = np.linspace(0, 100, nsteps) + 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 += min_dis + return g_sum / nsteps + + + diff --git a/tests/__init__.py b/tests/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/functional_test.py b/tests/functional_test.py new file mode 100644 index 0000000..118ad4d --- /dev/null +++ b/tests/functional_test.py @@ -0,0 +1,77 @@ +import random +import unittest + +from .. import analytics +from .. import io_geojson +from .. import utils +from .. import point + + +class TestFunctionalPointPattern(unittest.TestCase): + + def setUp(self): + random.seed(12345) + i = 0 + self.points = [] + marks = ["North", "East", "South", "West"] + while i < 100: + seed = (round(random.random(),2), round(random.random(),2)) + self.points.append(point.Point(seed[0], seed[1], mark=random.choice(marks))) + 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(point.Point(pt[0], pt[1], mark=random.choice(marks))) + 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 = analytics.average_nearest_neighbor_distance(self.points) + self.assertAlmostEqual(0.037, 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 = utils.create_random_points(100) + self.assertEqual(100, len(rand_points)) + + # As above, update the module and function name. + marks = ["North", "East", "South", "West"] + permutations = analytics.permutations(99, marks=marks) + self.assertEqual(len(permutations), 99) + self.assertNotEqual(permutations[0], permutations[1]) + + # As above, update the module and function name. + lower, upper = analytics.find_criticals(permutations) + self.assertTrue(lower > 1) + self.assertTrue(upper < 101) + self.assertTrue(observed_avg < lower or observed_avg > upper) + + # As above, update the module and function name. + significant = analytics.check_significance(lower, upper, observed_avg) + self.assertTrue(significant) + + self.assertTrue(True) + + # Tests for step 8 + expected = {"North": 0.016635, "East": 0.01878, "South": 0.01533, "West": 0.018719} + + for mark in marks: + avg = analytics.average_nearest_neighbor_distance(self.points, mark) + self.assertAlmostEqual(expected[mark], avg, 3) \ No newline at end of file diff --git a/tests/point_tests.py b/tests/point_tests.py new file mode 100644 index 0000000..bcb96b2 --- /dev/null +++ b/tests/point_tests.py @@ -0,0 +1,58 @@ +import unittest +import random + +from .. import point + +class TestPoint(unittest.TestCase): + + @classmethod + def setUpClass(cls): + cls.test = point.Point(2,3) + cls.test2 = point.Point(1,1) + + def test_setup(self): + self.assertEqual(self.test.x, 2) + self.assertEqual(self.test.y, 3) + + def test_coincident(self): + coincident = self.test.check_coincident((2,3)) + self.assertTrue(coincident) + coincident = self.test.check_coincident((4,2)) + self.assertFalse(coincident) + + def test_shift(self): + new_point = ((self.test.x + 2), (self.test.y + 4)) + self.test.shift_point(2, 4) + self.assertEqual((self.test.x, self.test.y), new_point) + + #I did this part wrong, not 100% sure what is required for this test + def test_marked(self): + random.seed(12345) + marks = ['North', 'East', 'South', 'West'] + temp = [] + dic = {} + i = 0 + + while i < 15: + temp.append(random.choice(marks)) + i += 1 + + for mark in marks: + if mark not in dic: + dic[mark] = 1 + else: + dic[mark] += 1 + + test1 = point.Point(0,0, dic) + self.assertTrue(test1.mark['North'] == dic['North']) + + + def test_magic_methods(self): + #Checks the __ne__ magic method + self.assertTrue(self.test != self.test2) + + #Checks the __eq__ magic method + self.assertFalse(self.test == self.test2) + + #Checks the __add__ magic method + self.assertEqual(self.test + self.test2, point.Point(3,4)) \ No newline at end of file diff --git a/tests/pointpattern_test.py b/tests/pointpattern_test.py new file mode 100644 index 0000000..562f6a9 --- /dev/null +++ b/tests/pointpattern_test.py @@ -0,0 +1,33 @@ +import unittest + +from .. import PointPattern +from .. import point + +class TestPointPattern(unittest.TestCase): + def setUp(self): + self.test = PointPattern() + self.test.add_point(point.Point(2, 5, mark='North')) + self.test.add_point(point.Point(4, 1, mark='North')) + self.test.add_point(point.Point(2, 5, mark='South')) + self.test.add_point(point.Point(1, 1)) + + def check_coincident(self): + self.assertEqual(self.test.count_coincident_points(), 2) + + def check_list_marks(self): + self.assertEqual(self.test.list_marks(), ['North', 'South']) + + def check_return_subset(self): + self.assertEqual(len(self.test.return_subset('South')), 2) + + def check_generate_points(self): + self.assertEqual(len(self.test.create_random_points(20)), 20) + + def check_realizations(self): + self.assertEqual(len(self.test.create_realizations(20)), 20) + + def check_critical_points(self): + self.assertEqual(self.test.critical_points(), (1, 100)) + + def check_g_function(self): + self.assertAlmostEqual(self.test.compute_g(100), 1, places=4) \ No newline at end of file diff --git a/tests/test_analytics.py b/tests/test_analytics.py new file mode 100644 index 0000000..0b55f2c --- /dev/null +++ b/tests/test_analytics.py @@ -0,0 +1,116 @@ +import os +import sys +import unittest +import random +sys.path.insert(0, os.path.abspath('..')) + +from .. import analytics as point_pattern +from .. import point + +class TestAnalytics(unittest.TestCase): + + def setUp(self): + # 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 + self.points = [(random.randint(0,100), random.randint(0,100)) for i in range(50)] + self.gj = [] + + def test_average_nearest_neighbor_distance(self): + temp_points = [point.Point(random.randint(0,100), random.randint(0,100)) for i in range(20)] + mean_d = point_pattern.average_nearest_neighbor_distance(temp_points) + self.assertAlmostEqual(mean_d, 11.8949885, 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 = point_pattern.mean_center(self.points) + self.assertEqual(x, 47.52) + self.assertEqual(y, 45.14) + + def test_minimum_bounding_rectangle(self): + mbr = point_pattern.minimum_bounding_rectangle(self.points) + self.assertEqual(mbr, [0,0,94,98]) + + def test_mbr_area(self): + mbr = [0,0,94,98] + area = point_pattern.mbr_area(mbr) + self.assertEqual(area, 9212) + + def test_expected_distance(self): + area = 9212 + npoints = 50 + expected = point_pattern.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 = point_pattern.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 = point_pattern.euclidean_distance(point_a, point_b) + self.assertAlmostEqual(7.7074639, distance, 4) + + point_a = (0, 0) + point_b = (0, 0) + distance = point_pattern.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 = point_pattern.manhattan_distance(point_a, point_b) + self.assertEqual(4.0, distance) + + point_a = (-1.25, 2.35) + point_b = (4.2, -3.1) + distance = point_pattern.manhattan_distance(point_a, point_b) + self.assertEqual(10.9, distance) + + point_a = (0, 0) + point_b = (0, 0) + distance = point_pattern.manhattan_distance(point_b, point_a) + self.assertAlmostEqual(0.0, distance, 4) + + def test_permutations(self): + self.assertEqual(len(point_pattern.permutations(100)), 100) + + def test_find_criticals(self): + crit_values = point_pattern.find_criticals([1, 2, 3, 4, 5, 6, 7]) + self.assertTrue(crit_values[0] == 1 and crit_values[1] == 7) + + def test_check_significance(self): + self.assertTrue(point_pattern.check_significance(22, 4, 40)) + \ No newline at end of file diff --git a/tests/test_io_geojson.py b/tests/test_io_geojson.py new file mode 100644 index 0000000..ab1375a --- /dev/null +++ b/tests/test_io_geojson.py @@ -0,0 +1,18 @@ +import os +import sys +import unittest +sys.path.insert(0, os.path.abspath('..')) + +from .. import io_geojson as point_pattern + +class TestIoGeoJson(unittest.TestCase): + + def setUp(self): + pass + +''' + def test_read_geojson(self): + self.assertIsInstance(self.gj, dict) +''' + + \ No newline at end of file diff --git a/tests/test_utils.py b/tests/test_utils.py new file mode 100644 index 0000000..f755578 --- /dev/null +++ b/tests/test_utils.py @@ -0,0 +1,86 @@ +import os +import sys +import unittest +sys.path.insert(0, os.path.abspath('..')) + +from .. import utils as point_pattern + +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 point_pattern.py, you must complete the + `getx` function so that the correct + values are returned. + """ + point = (1,2) + x = point_pattern.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 = point_pattern.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 = point_pattern.shift_point(point, 3, 4) + self.assertEqual((3,4), new_point) + + point = (-2.34, 1.19) + new_point = point_pattern.shift_point(point, 2.34, -1.19) + self.assertEqual((0,0), new_point) + + def test_check_coincident(self): + """ + As above, update the function in point_pattern.py + + """ + point_a = (3, 7) + point_b = (3, 7) + coincident = point_pattern.check_coincident(point_a, point_b) + self.assertEqual(coincident, True) + + point_b = (-3, -7) + coincident = point_pattern.check_coincident(point_a, point_b) + self.assertEqual(coincident, False) + + point_a = (0, 0) + point_b = (0.0, 0.0) + coincident = point_pattern.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 = point_pattern.check_in((0,0), point_list) + self.assertTrue(inlist) + + inlist = point_pattern.check_in((6,4), point_list) + self.assertFalse(inlist) + + def test_create_random_points(self): + self.assertEqual(len(point_pattern.create_random_points(100)), 100) \ No newline at end of file diff --git a/utils.py b/utils.py new file mode 100644 index 0000000..70ce6d2 --- /dev/null +++ b/utils.py @@ -0,0 +1,129 @@ +#utils +import random +from . import point + +def create_random_marked_points(n, marks=[]): + rand = random.Random() + rand_points = [] + + if marks is None: + for i in range(n): + rand_points.append(point.Point(rand.randint(0, 100), rand.randint(0,100))) + else: + for i in range(n): + rand_points.append(point.Point(rand.randint(0, 100), rand.randint(0,100), rand.choice(marks))) + + return rand_points + +def create_random_points(n): + rand = random.Random() + random_points = [(rand.randint(0,100), rand.randint(0,100)) for i in range(n)] + return random_points + +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 94055aaaf93e20eeaaea8dd01b9c1b7601e6c6c9 Mon Sep 17 00:00:00 2001 From: smortime Date: Tue, 5 Apr 2016 22:43:42 -0700 Subject: [PATCH 2/6] Fixed test cases and added required functions to poitpattern --- __pycache__/PointPattern.cpython-35.pyc | Bin 0 -> 4603 bytes __pycache__/__init__.cpython-35.pyc | Bin 0 -> 138 bytes __pycache__/analytics.cpython-35.pyc | Bin 0 -> 6298 bytes __pycache__/point.cpython-35.pyc | Bin 0 -> 1636 bytes __pycache__/pointpattern.cpython-35.pyc | Bin 0 -> 4559 bytes __pycache__/utils.cpython-35.pyc | Bin 0 -> 3319 bytes analytics.py | 2 +- PointPattern.py => pointpattern.py | 42 ++++++++- tests/PointPattern.py | 88 ------------------ tests/__pycache__/__init__.cpython-35.pyc | Bin 0 -> 144 bytes .../pointpattern_test.cpython-35.pyc | Bin 0 -> 2347 bytes tests/pointpattern_test.py | 22 ++--- 12 files changed, 50 insertions(+), 104 deletions(-) create mode 100644 __pycache__/PointPattern.cpython-35.pyc create mode 100644 __pycache__/__init__.cpython-35.pyc create mode 100644 __pycache__/analytics.cpython-35.pyc create mode 100644 __pycache__/point.cpython-35.pyc create mode 100644 __pycache__/pointpattern.cpython-35.pyc create mode 100644 __pycache__/utils.cpython-35.pyc rename PointPattern.py => pointpattern.py (63%) delete mode 100644 tests/PointPattern.py create mode 100644 tests/__pycache__/__init__.cpython-35.pyc create mode 100644 tests/__pycache__/pointpattern_test.cpython-35.pyc diff --git a/__pycache__/PointPattern.cpython-35.pyc b/__pycache__/PointPattern.cpython-35.pyc new file mode 100644 index 0000000000000000000000000000000000000000..89b00bc13e8ab3ac60c2479926f019417bb271c0 GIT binary patch literal 4603 zcmbtXOK%(36+U-fe2B8>hiogBB`0YbGe{*TO=}lb>}X~rQ6z`d zouMHSQa3Vc2VG@VwErO60$q0B-!R**^cS+qcg}D~Nudy+l|7gDaqhY2p2v62y*)cy z{@35FEpL|SzjW@;K>z3X;$Nc)@Ly4fsH@0TqW$A-phJuRpA=)ej*Q5{PISQ)MFAA&c6x<-@ zjJ-E0xJAJ{1-B`lFtZnzrzdxN7+s8{P@+)jG^)nEN) z^M@aPu*Ap<4H|SW=sga3pYNkrx^j?J8+YOsh=;<&{@Y~wm+wSRR z(25f;@cb+u912f}OS^W4vXrOqw47aAV z7QGfDw2P$Qqt}Y|g&tZ z%A-`ZFv(*v)xsX9uHICh;+>YrnCY99bTHVl#YUNC7mfxL8!fwCWm&kHwbm(>R zK`HmjIJITnbuwvE)pr-J^kKJpc_~-oL|;XmoId;IpE$Kk*lmn?Zf zkSX*n%;izLe1)_*?R0S%@-uPZpg$Yq;swyKTTu`mUY4Sw!*1_Im=8bU6b2psnPZlv6E)QvUE(-JKCtNUkC)bdCu=sxI&k6GmayBT zgD2ci3~D>1w`FK?{I?C#SQ3zVj1xft`~WH21Dm!E7HJF1n>BMovxHi*sFjw&XwU`Z z0_-_}-8mm_?zaNY1stYYtXIh3*7kdYC>hg4;fRL4PfVMteK$)%A70k)9ogGF$6f*^ zW~hnpq7lzE7S*DvD3d?9 zfTy%eq^qMLG}SK15Llkmh$^eJm3x&rfxJvh=15DNl;WwbUS^dxW&H^xirN2hZ=@b{r zPZ70TAr&`Ld!wh5z0~^Hi<8ve>bNt)WQ^gQ&IB(_MX^rxI(w!rc!PM9|^RZgXUMudk9h4GH zU$^l1#Pdf#<~1c2x-9fuPBjXP21s*(-?>WQjPGd2SflxKM1=kKSlG<&5yWYC(=LRW{sOm7+X2-D+~prs=s2+nRD|M6aT7}LdBY! zoiFo9uY(2{BZaqsJ;_U3@W!=K{PmAA0Aj*(r%hnJxYq3jgHE{4Q6eQvRaK#pit!CJ CcGocg literal 0 HcmV?d00001 diff --git a/__pycache__/__init__.cpython-35.pyc b/__pycache__/__init__.cpython-35.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a51296fee08c3e899b4a83abb5b1a576f11eef32 GIT binary patch literal 138 zcmWgR<>e|5X9#Big2x~N1{i@12OutH0TL+;48fX=ek&P@K*9*(m$`mMer~FMadJj! zWln05zDsIxc1eDLzPo3zv5}#EVsUY1dR}g7UP-)xg?@Z|W?p7Ve7s&k8Hr>!x)qCryEN92n8 zgPvJhq#*$f;zNO==()G{m_vKWt$#&}9v3K3puPA{XfEyd-tJPAA{h>f9=g&l=l8ss z_r3SNnbY(0bHDw)^WYaNLi|HaJ!PbSjMpq!LU{PML?A?KlD0(4D#~rqvWs*{v`RwR zV#^U*Whzu9PFI9yi!Utkg)Jig!c|!S0h#EwJzQ}@cEzEcu? zN9dQQ%h0@NQ4w_v@#tmoV8<3{yJ=JrV}-A+dt z!=<4+^21>$2k~GSxID0LM@^H4hC2va4?)hgcn#@6vHX*J(*lL}4XNaqGR9w?po%Cu(k?Ma;o+w!Go zlvBIAl{$$E2Q7yLZXL(&wf81UEnm-K82)_y-ql_ls;j2c8;%2|udXW7PvXJVk3L?% z_V!y>U1R)i6sjm`fA77kZsZ2z#P68qV4R*LZMSnxw`rytA@u}4VrkB*SQUHTTDFc` zi?%+FvI(#qWG28SbRPuv=t>6Zi-d1r6F{%$ui?JZ%06_2O!44LXKI38N zW8`V!Vhu^c(AEAE1v|RmgF)awi4!*n#&S5I*65#0wi?SQPUL0`>w{o%zIa*?>?{rk zZZzg;$u|9n1xt`7eZImuOsL z^T?*hdHdV6{cUXj8z?i>PRs)#89qvS0r`FCAcPPwOa~wMO>%ko+G6wufo1jKtBeeb z!C{H|yJ(QPF?dGgfQu#I!V(FC3&G=T)?z9Tug9I(@s*zZo0tEQ|5(8_NQ3QzJ+ebK zR{)xDK;WQ_43!HM!61}=5r>ow0jCl8X37WL=KS6q1@54_P+lHg88@EqiAET4Gl<>2 zAwMCxMi4dDo*%(=X9JMGI;7!vx*<8FOy{IzM50olqK1=JGT~Eelv-m=N;#oJ0$RayP{+~J=~j=q zRYmO1h@G<7sjwKIi-esI=m=a87zu!~GeeAozMKUk*{xDUMXx$Z59jnZu~QV?dh~fw ziLyR|G4j)u4<3Cc9wd<85fCcD?1BcYz~#5Tf8)Ab%?BVaxR&q8TD~J3`?;%x)fgf(F!uEUIENd^dnzLzrsogfZ6o>V zgpZh}ybIbBcR^~d-MDpajIh1ta)p}TDB|rt0P^vYSty|1X3qp z+NW)O4(&RCC_m&MCXV}G$mEV2vAX#0I_$*L%)I}aJ8|tZm1V0Y{|)2C&n*i4;Ifo+ zvRqzQ-d9)ISBEBj?Aot5G8{1$xA+6MIAZ)d8S9^?$2d4Aw>UpN2IP2jJ|`nH?)rSjA@NO~|iiDqhaBpAO`fP-iT#;k` zjzBso?T#L@P2A@I^C8oSXA}#bmGCJD1wlP6Z~EFKX(`;$hX$LM@{MX28`Yj{)UVM$ zgY7~E(3~gs3FgUvHgV9s7i{zbT2Ek0vP@w6Ix;yMr5^z34E=(C(htybW|@cto#e_- zZt}wJOmPD^UYB;q1)n=gr`#!HQxdafarZo>m|WTVRismghB|1zRqRZgD!xJ!LqZGZ zRZG8y-${6-U8VO9UUM2BSRrJG$Y+sSTBcA-M?Ks9vViFH3e;!-@PYS|1DSYX*(F}Y zk~3X4$(XMj|81KukR&X7w|~ zP%`5nx5{@AT)0vos^q?Y7@|ILBOLqT&-T!?p^|L{o}FyRImLbvChcOck|9*i8^Y`% z>%GqjO>yUqZ`RP6Ng)cU-29;H@x<`h;MHqpSOmpbN=P8uam$6x(j`dp#UPmptpB=$VI4hx|G{WT|vIXKVc>5_I&zVFgS{@G)skjN-ks@9M+Ld^dyOY{yMzb5D8)rYSg-WQYM_)~PmIRNXWDPXMU`;*<7otjshu%#2jjcCIYxh6onIY3nbkskNc fMEu$3`DUSZuC`J;x6rJ;R+~X;xpw;0e69Q+w2`*^ literal 0 HcmV?d00001 diff --git a/__pycache__/point.cpython-35.pyc b/__pycache__/point.cpython-35.pyc new file mode 100644 index 0000000000000000000000000000000000000000..17cf2d256c756b334f349a6080be081cd74b5872 GIT binary patch literal 1636 zcmZ`(O>fgc5S_IhyGfn4ASg&6@o^#&YWR}ifDjT$h)adk15$*vGPX<7CULs!3KHn4 z{2BhzUODjxIB??47`sV+^XOF3sYfbhjZ7QeuSfl1G0FQj9Ujle zx#_>m?O|EW`mbK^J$!J#pIAHkFrDPnQr~;hpE0+c+1#yZJ(`Y6tz+zAc~eqt{1zKR zf2Ve*tS>k2Sy4I0HULySz!{KKIS*2cEbjHZ-9`J(=X)o2Z+^aif`f$ng_$Jf8Tp<9 zc*4Q8igK8n^Hf5u^CPVOxIi*Rm8JG=KrerG&`q?|36j!Nd%fqbFHr}@n|$*#|n+6POf7) zG-)b?_3&w5B&p>H3@>+E=`c?Zb&3K_M;XfXFM(W8<|u?!g$&mV->O=j?J85}cS|`4 zH`cz%*<%d;6pye3vlE|6`AYGnL}jC_eR@~jR9UR$Ga?lgoN=rUv2KT>{Zh~Pmh}Ru zu|f1n%j_VUSHQKzfBqnsz=ez1GCNWi)#5^Rl;u4;d~v7A1d6+k){`PT9y5-$J~~du zmB*}O1Jh-*$!3eq1vV^};Xq5lMNhthQkD!XS7PjKhOsZdAg)Tb*LJ?0Tjv$l1+%0a wx^OhLxhY+gytgtzl@4L?{vc1ws?g68)`W6vPb=!rxMD4T4`LO2H@q$XH$ucFa{vGU literal 0 HcmV?d00001 diff --git a/__pycache__/pointpattern.cpython-35.pyc b/__pycache__/pointpattern.cpython-35.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2e77354054041dee2fe98c195a1da770a2cbaac7 GIT binary patch literal 4559 zcmbVPOLH7o6+X9L^U%l|KV(~eDaIl3qzWl9Au-@M0Si(gL1hqCqPh@GySpWiG}AM> z-Q$v`BsOy8QLM5GTbBF?So0ft%Ss!5KvsO`-0qP^C07bY>eKge?!D)p$9GO&otN(^)RJL96y{cWK z?K=4l`Z#te_UI*6dz3Wk2&-p!D@nGK4~EMhf3o(&2k$J0S=QZ3`$?JyZ$Dg?Er#as zrQv>24}xym&4Ylq%2)zY#?>kxYYw-!>i*_A(kd(Y9iFw=FtQbY$VC5ZTtu zRoo3m9r~H zinrK%lMXCe*;u4Qmkw-Eh${*KwRs)*)b3MS&mGzp7GCJl-h0fxvav*mH9GKU+oJ<` zrbOA1Qh%`Muug{!I>0h0xo-CP3j0W?VHo?Yb==jcawfKqgNIF%-8YwnaW?MIp(=&O zPPivu5~nHp+M->L)Fs_rKFO%iCXI{oMc|w8wTOE z4u(wE#Pma2-@Qfam|pAHtC}U$k}2(?k))$OP!vf+f>TUWGl1zvgHf9Ma}m-*)QuVG zIes+jR_s=&ZQmr12WPc-P1XjdmP!z09jwjR=HiXkEp zW0%U|Y?7VpzD?FrAoD+lL>cD>T-R!=JL-xxzBYBi6W%FDuI?p~iwv;|>BYLASANau zfz3Hl#S}V!->8Do`6ep_cSS_L5}H+s%9=|AF>uEW8M{iVoWs-#o(hboQ>9Mwkxqkb z^ejvA^AHysvL>sz7dYdPuMU#PpPky~=hbOsjc-h8ZHjH8INqPP6leGb4HI~#ia3H} zAoqz9O%mL4IP^GZOvd_YFZvB3r-A|9m5nEofZ<3k{Sga>e2!OM$B0&)`>F!_-#`cXgoi=Y{i&Fv|;fZ7|}_I;t3n%wvdDX39q4 z=`f84{lfdLdE31tHCfBW%vK_PsoDHRjagC56<+jw(2bIgXS`LV#SBkX*~#IK{vID9 z(Ja_2M9gp{LMqFXfVl?!a?vlrowY$YbX)2Y0(Q>2tbS&V?@rm~ytOBoqc38Eh#`o7 zeA>ifaPxEQW2|QiKqwDth0?j|0dTrvVU#+*qFhi?4E0E`v&Q8Ompu;UsFYwal;R#O z@T*1(sN8eJ1ne|rp(n5q3YJb|RdWdGH<-N1>Wvy+h28I_AmN@~`@x3WCoxgGtODr)z5=)E<#ttSJ%4E(URkVhQ?vL^??+((e zif(q3v$9^U90OHScWn4Kz*pt>*QUffhdHY1P=52-A{*C-rECaYsiHaJ7#ywD;|R0m z_kw?66A3?vbQj-)C?+@I&z tzXSv1-LU7^%7&iDA%!=1ww*+|>~@|wMg5Vv{9}$KsZiRg4Fxi${}*Y2y;lGL literal 0 HcmV?d00001 diff --git a/__pycache__/utils.cpython-35.pyc b/__pycache__/utils.cpython-35.pyc new file mode 100644 index 0000000000000000000000000000000000000000..50d8cce1f676a67ff6b7631e7cef81254f93619c GIT binary patch literal 3319 zcmeHJUvCpf5T8BAb}$zR1kqNgV*Auw>)L^$f)KTeLRImCC_##pidvVub$rR)t+Tss zY?M3&_0MD9`vv+j`ZZ4KQ=j+>JauN*=h$fgAzr)kt!MUTW@mr%XYcCLQsZC~HXk$q z{(+fMLHZkf^Z`yW{urbHTS#~iS0H7Od9dXH+rgy;h^z2|!Bz$08pL&Yfugv$2=O^f zS0QddeBRP1;6uD*={m$0Aiij66kdk-lBLhlejCB%m$*4RddYAOSWz9wBsY;qi#V$I z)bUxzNB@PB0oY}53~=NDx^+~6Lq@*uErLp5^amIZ4groCJa~2+juzms0=pG33$R;- zLl1V*HB|8680F?!TtPLq|2b^tPhs@^tf}>PGewr`0*Ii z7Uya1S`2l;l0QLRLIbaEwfiy?Z5{Q8<5Z~j1EKef9JIfCxbfx98|_f*WGBx=Zn|rC z+C!71x-}RV*CHiCBf4Z$W?kAxl*TDAdKo8RKC5{?TVZ#+6?WfKE4UWX329Iq=?L`b zHcr#{{RZ$0Ko4VK!|^k|nnn&$J7NSMp*3f#h9+nOeG4ayKZg3*XC(Y9=0%yr7|2s> z&x7AR*sq~M&!VpuP(NS_O9BF~@LFq%4udNf@Xvy#E+h4-aW74@iDWkDTtQybfzHA6 z)p=+f;H`V9jKWlRkSLXciXx~KIj$&^(E%U-ww5NSI#s)4xjSuKTsdn8dZWn{p?;mI zt4KwJEe+a-+*`*-e}xlb?MeZw#2}uwEL=$-wzsKvus%GbY?&Z~IBf(he2Qio9LGjK z=@}k!>m=VEbB$@l!%Ply!;_qwzThK{>A}Z5PLzmDB6Hoax{pH@X2J-iE&IiESk_s* z%gu0*3cEu4(U_R+NtN-{QF9zPbEB@d&fG--!=>WAREB0wlcNvXgn1;mk=%(-ot(Po z%#Gj6+{|g6xhKL56`q_9Fgd8Db8*le@i+L4UK$Z2h>?^EiyQ0BStQNzTQqy5I{uI9 zBWVzUerRlboD0sJNCj27=AjZ?S)b8Di2NiF*6D9YVOB=Uliz6an@(W$Msq@8r7i3TGqUqIsJiY}pMd#Ds;&_!enHDNm)`<7G3|m>>dssEtmD%_U3n9i9rU zW!`$f_{^d_)7oE`*%+;}di`9lq$s)@ojL{HpmZCaLSIq4_z|BneTn}cc+TGu__>?L z0#6C+y2#nUe~9n*XMiU@XxJ~J0$ix*YtDYh*amJpi!BTrG(`$C(LA{g7Vl*;9;Tv0 XF4zxIpDlYAm;9>#sejqO;II4(0gC$y literal 0 HcmV?d00001 diff --git a/analytics.py b/analytics.py index 283a8f0..dd646f8 100644 --- a/analytics.py +++ b/analytics.py @@ -263,7 +263,7 @@ def permutations(p=99, n=100, marks=None): def find_criticals(perms): lower = min(perms) upper = max(perms) - return lower, upper + return (lower, upper) def check_significance(lower, upper, observed): if observed > upper: diff --git a/PointPattern.py b/pointpattern.py similarity index 63% rename from PointPattern.py rename to pointpattern.py index 6e7b71d..d0bf0c4 100644 --- a/PointPattern.py +++ b/pointpattern.py @@ -2,14 +2,36 @@ from . import analytics import random import numpy as np +import scipy.spatial as ss -def PointPattern(object): +class PointPattern(object): def __init__(self): self.points = [] def average_nearest_neighbor_distance(self, mark=None): return analytics.average_nearest_neighbor_distance(self.points, mark) + def average_nearest_neighbor_distance_kdtree(self, mark=None): + temp_points = [] + real_points = [] + distances = [] + + if mark is None: + temp_points = self.points + else: + temp_points = [i for i in self.points if self.points.mark is mark] + + for point in temp_points: + real_points.append((point.x, point.y)) + + kdtree = ss.KDTree(real_points) + + for p in real_points: + nearest_neighbor_distance, nearest_neighbor = kdtree.query(p, k=2) + distances.append(nearest_neighbor_distance) + + return np.mean(distances) + def add_point(self, point): self.points.append(point) @@ -18,7 +40,7 @@ def remove_point(self, index): def count_coincident_points(self): count = 0 - coincidnet_list = [] + coincident_list = [] for i, point in enumerate(self.points): for j, point2 in enumerate(self.points): @@ -39,9 +61,11 @@ def list_marks(self): if point.mark is not None and point.mark not in marks: marks.append(point.mark) + return marks + def return_subset(self, mark): #creates a list of points that have the same mark as passed - return [i for i in self.points if i == mark] + return [i for i in self.points if i.mark is mark] def create_random_points(self, n=None): rand_points = [] @@ -52,10 +76,20 @@ def create_random_points(self, n=None): n = len(self.points) for i in range(n): - rand_points.append(point.Point(rand.randint(1,100), rand.randint(1,100), mark=rand.choice(marks))) + rand_points.append(Point(rand.randint(1,100), rand.randint(1,100), mark=rand.choice(marks))) return rand_points + def generate_random_points(self, min=0, max=1, count=2): + marks = ['North', 'East', 'South', 'West'] + rand_points = np.random.uniform(min, max, (count,2)) + generated_points = [] + + for i, rpoint in enumerate(rand_points): + generated_points.append(point.Point(rpoint[0], rpoint[1], mark=random.choice(marks))) + + return generated_points + def create_realizations(self, k): return analytics.permutations(k) diff --git a/tests/PointPattern.py b/tests/PointPattern.py deleted file mode 100644 index a5dfa7f..0000000 --- a/tests/PointPattern.py +++ /dev/null @@ -1,88 +0,0 @@ -from .point import point -from . import analytics -import random -import numpy as np - -def PointPattern(object): - def __init__(self): - self.points = [] - - def average_nearest_neighbor_distance(self, mark=None): - return analytics.average_nearest_neighbor_distance(self.points, mark) - - def add_point(self, point): - self.points.append(point) - - def remove_point(self, index): - del(self.points[index]) - - def count_coincident_points(self): - count = 0 - coincidnet_list = [] - - for i, point in enumerate(self.points): - for j, point2 in enumerate(self.points): - if i is j: - continue - if j in coincident_list: - continue - #Should use the magic method in point class - if point == point2: - count += 1 - coincident_list.append(j) - return count - - def list_marks(self): - marks = [] - - for point in self.points: - if point.mark is not None and point.mark not in marks: - marks.append(point.mark) - - def return_subset(self, mark): - #creates a list of points that have the same mark as passed - return [i for i in self.points if i == mark] - - def create_random_points(self, n=None): - rand_points = [] - rand = random.Random() - marks = ['North', 'East', 'South', 'West'] - - if n is None: - n = len(self.points) - - for i in range(n): - rand_points.append(point.Point(rand.randint(1,100), rand.randint(1,100), mark=rand.choice(marks))) - - return rand_points - - def create_realizations(self, k): - return analytics.permutations(k) - - def critical_points(self): - return analytics.find_criticals(self.create_realizations(99)) - - def compute_g(self, nsteps): - ds = np.linspace(0, 100, nsteps) - 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 += min_dis - return g_sum / nsteps - - - diff --git a/tests/__pycache__/__init__.cpython-35.pyc b/tests/__pycache__/__init__.cpython-35.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6633f51be570d127ff2e0c3fda08cf0ee2ecfe00 GIT binary patch literal 144 zcmWgR<>e|5X9#Big2x~N1{i@12OutH0TL+;48fX=ek&P@K*9*(m#uzAer~FMadJj! zWln05zDsIxc1eDLzPo3zv5}#EVsUY1dR}g7UP-)xg?>qDaY?a$e0*kJW=VX!UP0w8 T4x8Nkl+v73JCL!(K+FIDts)`k literal 0 HcmV?d00001 diff --git a/tests/__pycache__/pointpattern_test.cpython-35.pyc b/tests/__pycache__/pointpattern_test.cpython-35.pyc new file mode 100644 index 0000000000000000000000000000000000000000..03aa2b097db089cba08eaf8f08cc1564cba4b4c4 GIT binary patch literal 2347 zcmb_eOOM<{5U%!P#yjiD&OX>60#cL!!k0`S7Y-2#3J~QoinJgkAFv#|U_oj_&Y-X$w1CmI1Gx=_1EB-#aq2?af!FBS0S+*A;oOF> zLlI7b?i|CxXl|hmSmQsfCZ&2BE5${L*Y1q26Y^OcnVq~WbrWPn0rU*)dH89UDcFurZ_Rz9j>9LH_g)K3V zWe1-D#YdG+0&gTpz`2X2af(=+HtwhrYCL!7Hc@EYld4wZz!kQ3Qph*liPJRF$q?ii zx>^CukRy5i{C5!7@a{j~498W$hcX%0uW~MiUvYV=s@d@IlaqU&eL9S#oMdIeOBLPy zd`NNSP{*8^ghzDi&g@m=O0K?}bupyup#kQzTl#Z$d|CZF+I1rb1Y76e100a5#%lF3 zA1FO4V&t%l9D&{JA~-J8*DvZg7e2liUQenTktSGy$s{Gv8mkPL=;L$E*qA-MZ1xEJ znl}j|No!zdH{U>g$$0}m39Rwo#z8B7tn&<$x?o|CgomzT7foP`eHv>Dy?lb0D9cx) zUb)e`Z$Z6sZb$twhA^m=DSHd1xExV+{YC6=04JFOM+0x{oR>smt4>*rq-^n zQTeEy%B45{2QuQgmCWIS43G24S*#{ixvi@9FOsryd~c1&t#%?P)iUk|3+h#RJ*+Bg z*(*(1(Vn9_KDI%#u-(xd`yFJzcsG9iA^7`2)0yRQ!ll?DZg#V8miw1^QOWg1zmrtO ztVaE_E%j!Wc@{md%Y-DL9`lw3vvO{yb=5LQT1!sOD8tF{`0IfnJukS38#LDI{ge15 zR!_#GlE;GDQOPIS_*o^Q6dOTYCOkS#mEe2}xkH^d@1p9!@A(?l`P`!(H$-Ga7#9iyN)KUdCTR|m3TdkxZ zKJ&Z2z53{ Date: Tue, 5 Apr 2016 22:47:57 -0700 Subject: [PATCH 3/6] Seeing why it says scipy does not exist --- requirements.txt | 1 + 1 file changed, 1 insertion(+) diff --git a/requirements.txt b/requirements.txt index 8836ba4..aa3b156 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1 +1,2 @@ pysal +scipy \ No newline at end of file From edd317a7faaf1f311c2a15ce24e8e88a9b9b266b Mon Sep 17 00:00:00 2001 From: smortime Date: Tue, 5 Apr 2016 22:49:31 -0700 Subject: [PATCH 4/6] ... --- requirements.txt | 1 - 1 file changed, 1 deletion(-) diff --git a/requirements.txt b/requirements.txt index aa3b156..8836ba4 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,2 +1 @@ pysal -scipy \ No newline at end of file From 133c935796ab64ea162232fd59f3aa5a43d9a590 Mon Sep 17 00:00:00 2001 From: smortime Date: Tue, 5 Apr 2016 22:52:31 -0700 Subject: [PATCH 5/6] trying again --- requirements.txt | 1 + 1 file changed, 1 insertion(+) diff --git a/requirements.txt b/requirements.txt index 8836ba4..d110aa7 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1 +1,2 @@ pysal +scipy From 3095b058af29293fa93b83c4c2863a00ac03aa13 Mon Sep 17 00:00:00 2001 From: smortime Date: Wed, 6 Apr 2016 00:02:32 -0700 Subject: [PATCH 6/6] Pretty sure adding the notebook and trying to make that work broke a lot of my code --- .../Assignment_08-checkpoint.ipynb | 3420 +++++++++++++++++ Assignment_08.ipynb | 128 + __pycache__/analytics.cpython-35.pyc | Bin 6298 -> 6266 bytes __pycache__/point.cpython-35.pyc | Bin 1636 -> 1618 bytes __pycache__/pointpattern.cpython-35.pyc | Bin 4559 -> 4541 bytes __pycache__/utils.cpython-35.pyc | Bin 3319 -> 3301 bytes analytics.py | 6 +- point.py | 4 +- pointpattern.py | 18 +- requirements.txt | 1 - utils.py | 2 +- 11 files changed, 3564 insertions(+), 15 deletions(-) create mode 100644 .ipynb_checkpoints/Assignment_08-checkpoint.ipynb create mode 100644 Assignment_08.ipynb diff --git a/.ipynb_checkpoints/Assignment_08-checkpoint.ipynb b/.ipynb_checkpoints/Assignment_08-checkpoint.ipynb new file mode 100644 index 0000000..76caac6 --- /dev/null +++ b/.ipynb_checkpoints/Assignment_08-checkpoint.ipynb @@ -0,0 +1,3420 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "collapsed": false, + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-72.976512, 41.337662, all-cases-dead-on-arrival\n", + "-72.960621, 41.326316, animal-bites\n", + "-72.896278, 41.324366, animal-bites\n", + "-72.952039, 41.325584, animal-bites\n" + ] + } + ], + "source": [ + "from pointpattern import PointPattern\n", + "from point import Point\n", + "import pysal as ps\n", + "\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", + "points = []\n", + "\n", + "for geometry, attributes in zip(shapefile, dbf):\n", + " points.append(Point(geometry[0], geometry[1], mark=attributes[1]))\n", + "\n", + "i = 0\n", + "\n", + "\n", + "for point in points:\n", + " i += 1\n", + " #Print the first five of the points\n", + " if i < 5:\n", + " print(\"{0}, {1}, {2}\".format(point.x, point.y, point.mark))\n", + " else:\n", + " break\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "all-cases-dead-on-arrival\n", + "animal-bites\n", + "animal-bites\n", + "animal-bites\n", + "animal-bites\n", + "animal-bites\n", + "animal-bites\n", + "animal-bites\n", + "animal-bites\n", + "animal-nuisance\n", + "animal-nuisance\n", + "animal-nuisance\n", + "animal-nuisance\n", + "animal-nuisance\n", + "animal-shelter\n", + "arson\n", + "arson\n", + "assault-wdangerous-weapon\n", + "assault-wdangerous-weapon\n", + "assault-wdangerous-weapon\n", + "assault-wdangerous-weapon\n", + "assault-wdangerous-weapon\n", + "assault-wdangerous-weapon\n", + "assault-wdangerous-weapon\n", + "assault-wdangerous-weapon\n", + "assault-wdangerous-weapon\n", + "assault-wdangerous-weapon\n", + "assault-wdangerous-weapon\n", + "assault-with-a-firearm\n", + "assault-with-a-firearm\n", + "assault-with-a-firearm\n", + "assault-with-a-firearm\n", + "assault-with-a-firearm\n", + "asslt-po-firefighter-or-co\n", + "asslt-po-firefighter-or-co\n", + "att-theft-of-mv-or-documents\n", + "awol\n", + "breach-of-peace\n", + "breach-of-peace\n", + "breach-of-peace\n", + "breach-of-peace\n", + "breach-of-peace\n", + "breach-of-peace\n", + "breach-of-peace\n", + "breach-of-peace\n", + "breach-of-peace\n", + "breach-of-peace\n", + "breach-of-peace\n", + "breach-of-peace\n", + "breach-of-peace\n", + "breach-of-peace\n", + "breach-of-peace\n", + "breach-of-peace\n", + "breach-of-peace\n", + "breach-of-peace\n", + "breach-of-peace\n", + "breach-of-peace\n", + "breach-of-peace\n", + "breach-of-peace\n", + "breach-of-peace\n", + "breach-of-peace\n", + "breach-of-peace\n", + "breach-of-peace\n", + "breach-of-peace\n", + "breach-of-peace\n", + "breach-of-peace\n", + "breach-of-peace\n", + "breach-of-peace\n", + "breach-of-peace\n", + "breach-of-peace\n", + "breach-of-peace\n", + "breach-of-peace\n", + "breach-of-peace\n", + "breach-of-peace\n", + "breach-of-peace\n", + "breach-of-peace\n", + "breach-of-peace\n", + "breach-of-peace\n", + "breach-of-peace\n", + "breach-of-peace\n", + "breach-of-peace\n", + "breach-of-peace\n", + "breach-of-peace\n", + "breach-of-peace\n", + "breach-of-peace\n", + "breach-of-peace\n", + "breach-of-peace\n", + "breach-of-peace\n", + "breach-of-peace\n", + "breach-of-peace\n", + "breach-of-peace\n", + "breach-of-peace\n", + "breach-of-peace\n", + "breach-of-peace\n", + "breach-of-peace\n", + "breach-of-peace\n", + "breach-of-peace\n", + "breach-of-peace\n", + "breach-of-peace\n", + "breach-of-peace\n", + "breach-of-peace\n", + "breach-of-peace\n", + "breach-of-peace\n", + "breach-of-peace\n", + "breach-of-peace\n", + "breach-of-peace\n", + "breach-of-peace\n", + "breach-of-peace\n", + "breach-of-peace\n", + "breach-of-peace\n", + "breach-of-peace\n", + "breach-of-peace\n", + "breach-of-peace\n", + "breach-of-peace\n", + "breach-of-peace\n", + "breach-of-peace\n", + "breach-of-peace\n", + "breach-of-peace\n", + "breach-of-peace\n", + "breach-of-peace\n", + "breach-of-peace\n", + "breach-of-peace\n", + "breach-of-peace\n", + "breach-of-peace\n", + "breach-of-peace\n", + "breach-of-peace\n", + "breach-of-peace\n", + "breach-of-peace\n", + "breach-of-peace\n", + "breach-of-peace\n", + "breach-of-peace\n", + "breach-of-peace\n", + "breach-of-peace\n", + "breach-of-peace\n", + "breach-of-peace\n", + "breach-of-peace\n", + "breach-of-peace\n", + "building-found-open\n", + "building-found-open\n", + "building-found-open\n", + "building-found-open\n", + "building-found-open\n", + "building-found-open\n", + "building-found-open\n", + "building-found-open\n", + "building-found-open\n", + "building-found-open\n", + "building-found-open\n", + "building-found-open\n", + "building-found-open\n", + "building-found-open\n", + "building-found-open\n", + "building-found-open\n", + "building-found-open\n", + "building-found-open\n", + "building-found-open\n", + "building-found-open\n", + "building-found-open\n", + "building-found-open\n", + "burglar-alarms\n", + "burglar-alarms\n", + "burglar-alarms\n", + "burglar-alarms\n", + "burglar-alarms\n", + "burglar-alarms\n", + "burglar-alarms\n", + "burglar-alarms\n", + "burglar-alarms\n", + "burglar-alarms\n", + "burglar-alarms\n", + "burglar-alarms\n", + "burglar-alarms\n", + "burglar-alarms\n", + "burglar-alarms\n", + "burglar-alarms\n", + "burglar-alarms\n", + "burglar-alarms\n", + "burglar-alarms\n", + "burglar-alarms\n", + "burglar-alarms\n", + "burglar-alarms\n", + "burglar-alarms\n", + "burglar-alarms\n", + "burglar-alarms\n", + "burglar-alarms\n", + "burglar-alarms\n", + "burglar-alarms\n", + "burglar-alarms\n", + "burglar-alarms\n", + "burglar-alarms\n", + "burglar-alarms\n", + "burglar-alarms\n", + "burglar-alarms\n", + "burglar-alarms\n", + "burglar-alarms\n", + "burglar-alarms\n", + "burglar-alarms\n", + "burglar-alarms\n", + "burglar-alarms\n", + "burglar-alarms\n", + "burglar-alarms\n", + "burglar-alarms\n", + "burglar-alarms\n", + "burglar-alarms\n", + "burglar-alarms\n", + "burglar-alarms\n", + "burglar-alarms\n", + "burglar-alarms\n", + "burglar-alarms\n", + "burglar-alarms\n", + "burglar-alarms\n", + "burglar-alarms\n", + "burglar-alarms\n", + "burglar-alarms\n", + "burglar-alarms\n", + "burglar-alarms\n", + "burglar-alarms\n", + "burglar-alarms\n", + "burglar-alarms\n", + "burglar-alarms\n", + "burglar-alarms\n", + "burglar-alarms\n", + "burglar-alarms\n", + "burglar-alarms\n", + "burglar-alarms\n", + "burglar-alarms\n", + "burglar-alarms\n", + "burglar-alarms\n", + "burglar-alarms\n", + "burglar-alarms\n", + "burglar-alarms\n", + "burglary-aptforcible\n", + "burglary-aptforcible\n", + "burglary-aptforcible\n", + "burglary-aptforcible\n", + "burglary-aptforcible\n", + "burglary-aptforcible\n", + "burglary-aptforcible\n", + "burglary-aptforcible\n", + "burglary-aptforcible\n", + "burglary-aptforcible\n", + "burglary-aptforcible\n", + "burglary-aptforcible\n", + "burglary-aptnonforcible\n", + "burglary-aptnonforcible\n", + "burglary-aptnonforcible\n", + "burglary-aptnonforcible\n", + "burglary-aptnonforcible\n", + "burglary-aptnonforcible\n", + "burglary-aptnonforcible\n", + "burglary-aptnonforcible\n", + "burglary-attempt\n", + "burglary-attempt\n", + "burglary-attempt\n", + "burglary-attempt\n", + "burglary-commforcible\n", + "burglary-commforcible\n", + "burglary-commforcible\n", + "burglary-commforcible\n", + "burglary-commforcible\n", + "burglary-commforcible\n", + "burglary-commnonforcible\n", + "burglary-commnonforcible\n", + "burglary-nothing-taken\n", + "burglary-nothing-taken\n", + "burglary-nothing-taken\n", + "burglary-nothing-taken\n", + "burglary-nothing-taken\n", + "burglary-nothing-taken\n", + "burglary-nothing-taken\n", + "burglary-other-forcible\n", + "burglary-resforcible\n", + "burglary-resforcible\n", + "burglary-resforcible\n", + "burglary-resforcible\n", + "burglary-resforcible\n", + "burglary-resforcible\n", + "burglary-resforcible\n", + "burglary-resforcible\n", + "burglary-resforcible\n", + "burglary-resforcible\n", + "burglary-resforcible\n", + "burglary-resforcible\n", + "burglary-resforcible\n", + "burglary-resforcible\n", + "burglary-resforcible\n", + "burglary-resforcible\n", + "burglary-resforcible\n", + "burglary-resforcible\n", + "burglary-resforcible\n", + "burglary-resforcible\n", + "burglary-resforcible\n", + "burglary-resnonforcible\n", + "burglary-resnonforcible\n", + "burglary-resnonforcible\n", + "burglary-resnonforcible\n", + "burglary-resnonforcible\n", + "burglary-resnonforcible\n", + "burglary-resnonforcible\n", + "burglary-resnonforcible\n", + "burglary-resnonforcible\n", + "burglary-resnonforcible\n", + "burglary-resnonforcible\n", + "burglary-resnonforcible\n", + "burglary-resnonforcible\n", + "burglary-resnonforcible\n", + "burglary-resnonforcible\n", + "burglary-resnonforcible\n", + "burglary-resnonforcible\n", + "burglary-resnonforcible\n", + "burglary-schoolforcible\n", + "burglary-schoolnonforc\n", + "burglary-schoolnonforc\n", + "burglary-schoolnonforc\n", + "carrying-a-concealed-weapon\n", + "carrying-a-concealed-weapon\n", + "carrying-of-bb-gun\n", + "carrying-of-bb-gun\n", + "carrying-of-bb-gun\n", + "carrying-weapon-in-mv\n", + "carrying-weapon-in-mv\n", + "civil-investigation\n", + "civil-investigation\n", + "civil-investigation\n", + "civil-investigation\n", + "civil-investigation\n", + "civil-investigation\n", + "civil-investigation\n", + "civil-investigation\n", + "civil-investigation\n", + "civil-investigation\n", + "civil-investigation\n", + "civil-investigation\n", + "civil-investigation\n", + "civil-investigation\n", + "civil-investigation\n", + "common-drunkeness\n", + "common-drunkeness\n", + "common-drunkeness\n", + "confidence-flim-flam\n", + "confidence-flim-flam\n", + "confidence-flim-flam\n", + "confidence-flim-flam\n", + "confidence-flim-flam\n", + "confidence-flim-flam\n", + "confidence-flim-flam\n", + "confidence-flim-flam\n", + "crim-impersonationnon-po\n", + "crim-mischief-priv-prop\n", + "crim-mischief-priv-prop\n", + "crim-mischief-priv-prop\n", + "crim-mischief-priv-prop\n", + "crim-mischief-priv-prop\n", + "crim-mischief-priv-prop\n", + "crim-mischief-priv-prop\n", + "crim-mischief-priv-prop\n", + "crim-mischief-priv-prop\n", + "crim-mischief-priv-prop\n", + "crim-mischief-priv-prop\n", + "crim-mischief-priv-prop\n", + "crim-mischief-priv-prop\n", + "crim-mischief-priv-prop\n", + "crim-mischief-priv-prop\n", + "crim-mischief-priv-prop\n", + "crim-mischief-priv-prop\n", + "crim-mischief-priv-prop\n", + "crim-mischief-priv-prop\n", + "crim-mischief-priv-prop\n", + "crim-mischief-priv-prop\n", + "crim-mischief-priv-prop\n", + "crim-mischief-priv-prop\n", + "crim-mischief-priv-prop\n", + "crim-mischief-priv-prop\n", + "crim-mischief-priv-prop\n", + "crim-mischief-priv-prop\n", + "crim-mischief-priv-prop\n", + "crim-mischief-priv-prop\n", + "crim-mischief-priv-prop\n", + "crim-mischief-priv-prop\n", + "crim-mischief-priv-prop\n", + "crim-mischief-priv-prop\n", + "crim-mischief-priv-prop\n", + "crim-mischief-priv-prop\n", + "crim-mischief-priv-prop\n", + "crim-mischief-priv-prop\n", + "crim-mischief-priv-prop\n", + "crim-mischief-priv-prop\n", + "crim-mischief-priv-prop\n", + "crim-mischief-priv-prop\n", + "crim-mischief-priv-prop\n", + "crim-mischief-priv-prop\n", + "crim-mischief-priv-prop\n", + "crim-mischief-priv-prop\n", + "crim-mischief-priv-prop\n", + "crim-mischief-priv-prop\n", + "crim-mischief-priv-prop\n", + "crim-mischief-priv-prop\n", + "crim-mischief-priv-prop\n", + "crim-mischief-priv-prop\n", + "crim-mischief-priv-prop\n", + "crim-mischief-priv-prop\n", + "crim-mischief-priv-prop\n", + "crim-mischief-priv-prop\n", + "crim-mischief-priv-prop\n", + "crim-mischief-priv-prop\n", + "crim-mischief-priv-prop\n", + "crim-mischief-priv-prop\n", + "crim-mischief-priv-prop\n", + "crim-mischief-priv-prop\n", + "crim-mischief-priv-prop\n", + "crim-mischief-priv-prop\n", + "crim-mischief-priv-prop\n", + "crim-mischief-priv-prop\n", + "crim-mischief-priv-prop\n", + "crim-mischief-priv-prop\n", + "crim-mischief-priv-prop\n", + "crim-mischief-priv-prop\n", + "crim-mischief-priv-prop\n", + "crim-mischief-priv-prop\n", + "crim-mischief-priv-prop\n", + "crim-mischief-priv-prop\n", + "crim-mischief-priv-prop\n", + "crim-mischief-priv-prop\n", + "crim-mischief-priv-prop\n", + "crim-mischief-priv-prop\n", + "crim-mischief-priv-prop\n", + "crim-mischief-priv-prop\n", + "crim-mischief-priv-prop\n", + "crim-mischief-priv-prop\n", + "crim-mischief-priv-prop\n", + "crim-mischief-priv-prop\n", + "crim-mischief-pub-propsvc\n", + "crim-mischief-pub-propsvc\n", + "crim-mischief-pub-propsvc\n", + "crim-mischief-pub-propsvc\n", + "crim-mischief-pub-propsvc\n", + "crim-mischief-pub-propsvc\n", + "criminal-trespass\n", + "criminal-trespass\n", + "criminal-trespass\n", + "criminal-trespass\n", + "criminal-trespass\n", + "criminal-trespass\n", + "criminal-trespass\n", + "criminal-trespass\n", + "criminal-trespass\n", + "criminal-trespass\n", + "criminal-trespass\n", + "criminal-trespass\n", + "criminal-trespass\n", + "criminal-trespass\n", + "criminal-trespass\n", + "criminal-trespass\n", + "criminal-trespass\n", + "criminal-trespass\n", + "criminal-trespass\n", + "criminal-trespass\n", + "criminal-trespass\n", + "criminal-trespass\n", + "criminal-trespass\n", + "criminal-trespass\n", + "criminal-trespass\n", + "criminal-trespass\n", + "criminal-trespass\n", + "criminal-trespass\n", + "criminal-trespass\n", + "criminal-trespass\n", + "criminal-trespass\n", + "criminal-trespass\n", + "criminal-trespass\n", + "criminal-trespass\n", + "criminal-trespass\n", + "criminal-trespass\n", + "criminal-trespass\n", + "criminal-trespass\n", + "criminal-trespass\n", + "criminal-trespass\n", + "criminal-trespass\n", + "criminal-trespass\n", + "criminal-trespass\n", + "criminal-trespass\n", + "criminal-trespass\n", + "criminal-trespass\n", + "criminal-trespass\n", + "criminal-trespass\n", + "criminal-trespass\n", + "criminal-trespass\n", + "criminal-trespass\n", + "criminal-trespass\n", + "criminal-trespass\n", + "criminal-trespass\n", + "criminal-trespass\n", + "cruelty-to-animals\n", + "custodial-interference\n", + "custodial-interference\n", + "custodial-interference\n", + "custodial-interference\n", + "custodial-interference\n", + "custodial-interference\n", + "custodial-interference\n", + "custodial-interference\n", + "custodial-interference\n", + "custodial-interference\n", + "custodial-interference\n", + "custodial-interference\n", + "detention-notice\n", + "discrimination-housing\n", + "disorderly-conduct\n", + "disorderly-conduct\n", + "disorderly-conduct\n", + "disorderly-conduct\n", + "disorderly-conduct\n", + "disorderly-conduct\n", + "disorderly-conduct\n", + "disorderly-conduct\n", + "disorderly-conduct\n", + "disorderly-conduct\n", + "disorderly-conduct\n", + "disorderly-conduct\n", + "disorderly-conduct\n", + "disorderly-conduct\n", + "disorderly-conduct\n", + "disorderly-conduct\n", + "disorderly-conduct\n", + "disorderly-conduct\n", + "disorderly-conduct\n", + "disorderly-conduct\n", + "disorderly-conduct\n", + "disorderly-conduct\n", + "disorderly-conduct\n", + "disorderly-conduct\n", + "disorderly-conduct\n", + "disorderly-conduct\n", + "disorderly-conduct\n", + "disorderly-conduct\n", + "disorderly-conduct\n", + "disorderly-conduct\n", + "disorderly-conduct\n", + "disorderly-conduct\n", + "disputeno-disturbance\n", + "disputeno-disturbance\n", + "disputeno-disturbance\n", + "disputeno-disturbance\n", + "disputeno-disturbance\n", + "disputeno-disturbance\n", + "disputeno-disturbance\n", + "disputeno-disturbance\n", + "disputeno-disturbance\n", + "disputeno-disturbance\n", + "disputeno-disturbance\n", + "disputeno-disturbance\n", + "disputeno-disturbance\n", + "disputeno-disturbance\n", + "disputeno-disturbance\n", + "disputeno-disturbance\n", + "disputeno-disturbance\n", + "disputeno-disturbance\n", + "disputeno-disturbance\n", + "disputeno-disturbance\n", + "disputeno-disturbance\n", + "disputeno-disturbance\n", + "disputeno-disturbance\n", + "disputeno-disturbance\n", + "disputeno-disturbance\n", + "disputeno-disturbance\n", + "disputeno-disturbance\n", + "disputeno-disturbance\n", + "disputeno-disturbance\n", + "disputeno-disturbance\n", + "disputeno-disturbance\n", + "disputeno-disturbance\n", + "disputeno-disturbance\n", + "disputeno-disturbance\n", + "disputeno-disturbance\n", + "disputeno-disturbance\n", + "disputeno-disturbance\n", + "disputeno-disturbance\n", + "disputeno-disturbance\n", + "disputeno-disturbance\n", + "disputeno-disturbance\n", + "disputeno-disturbance\n", + "disputeno-disturbance\n", + "disputeno-disturbance\n", + "disputeno-disturbance\n", + "disputeno-disturbance\n", + "disputeno-disturbance\n", + "disputeno-disturbance\n", + "disputeno-disturbance\n", + "disputeno-disturbance\n", + "disputeno-disturbance\n", + "disputeno-disturbance\n", + "disputeno-disturbance\n", + "disputeno-disturbance\n", + "disputeno-disturbance\n", + "disputeno-disturbance\n", + "disputeno-disturbance\n", + "disputeno-disturbance\n", + "disputeno-disturbance\n", + "disputeno-disturbance\n", + "disputeno-disturbance\n", + "disputeno-disturbance\n", + "disputeno-disturbance\n", + "disputeno-disturbance\n", + "disputeno-disturbance\n", + "disputeno-disturbance\n", + "disputeno-disturbance\n", + "disputeno-disturbance\n", + "disputeno-disturbance\n", + "disputeno-disturbance\n", + "disputeno-disturbance\n", + "disputeno-disturbance\n", + "disputeno-disturbance\n", + "disputeno-disturbance\n", + "disputeno-disturbance\n", + "disputeno-disturbance\n", + "disputeno-disturbance\n", + "disputeno-disturbance\n", + "disputeno-disturbance\n", + "disputeno-disturbance\n", + "disputeno-disturbance\n", + "disputeno-disturbance\n", + "disputeno-disturbance\n", + "disputeno-disturbance\n", + "disputeno-disturbance\n", + "door-checks\n", + "door-checks\n", + "door-checks\n", + "door-checks\n", + "door-checks\n", + "door-checks\n", + "door-checks\n", + "door-checks\n", + "door-checks\n", + "door-checks\n", + "door-checks\n", + "door-checks\n", + "door-checks\n", + "door-checks\n", + "door-checks\n", + "door-checks\n", + "door-checks\n", + "door-checks\n", + "door-checks\n", + "drug-overdose\n", + "drug-overdose\n", + "drug-overdose\n", + "drug-overdose\n", + "dwi-alcohol\n", + "dwi-alcohol\n", + "dwi-alcohol\n", + "dwi-alcohol\n", + "dwi-drugs\n", + "dwi-drugs\n", + "emotionally-disturbed\n", + "emotionally-disturbed\n", + "emotionally-disturbed\n", + "emotionally-disturbed\n", + "emotionally-disturbed\n", + "emotionally-disturbed\n", + "emotionally-disturbed\n", + "emotionally-disturbed\n", + "emotionally-disturbed\n", + "emotionally-disturbed\n", + "emotionally-disturbed\n", + "emotionally-disturbed\n", + "emotionally-disturbed\n", + "emotionally-disturbed\n", + "emotionally-disturbed\n", + "emotionally-disturbed\n", + "emotionally-disturbed\n", + "emotionally-disturbed\n", + "emotionally-disturbed\n", + "emotionally-disturbed\n", + "emotionally-disturbed\n", + "emotionally-disturbed\n", + "emotionally-disturbed\n", + "emotionally-disturbed\n", + "emotionally-disturbed\n", + "emotionally-disturbed\n", + "emotionally-disturbed\n", + "emotionally-disturbed\n", + "emotionally-disturbed\n", + "emotionally-disturbed\n", + "emotionally-disturbed\n", + "emotionally-disturbed\n", + "emotionally-disturbed\n", + "emotionally-disturbed\n", + "emotionally-disturbed\n", + "emotionally-disturbed\n", + "emotionally-disturbed\n", + "emotionally-disturbed\n", + "emotionally-disturbed\n", + "emotionally-disturbed\n", + "emotionally-disturbed\n", + "emotionally-disturbed\n", + "emotionally-disturbed\n", + "emotionally-disturbed\n", + "emotionally-disturbed\n", + "emotionally-disturbed\n", + "emotionally-disturbed\n", + "emotionally-disturbed\n", + "emotionally-disturbed\n", + "emotionally-disturbed\n", + "emotionally-disturbed\n", + "emotionally-disturbed\n", + "emotionally-disturbed\n", + "emotionally-disturbed\n", + "emotionally-disturbed\n", + "emotionally-disturbed\n", + "emotionally-disturbed\n", + "emotionally-disturbed\n", + "emotionally-disturbed\n", + "emotionally-disturbed\n", + "emotionally-disturbed\n", + "emotionally-disturbed\n", + "emotionally-disturbed\n", + "emotionally-disturbed\n", + "emotionally-disturbed\n", + "emotionally-disturbed\n", + "emotionally-disturbed\n", + "emotionally-disturbed\n", + "evading-responsibility\n", + "evading-responsibility\n", + "evading-responsibility\n", + "evading-responsibility\n", + "evading-responsibility\n", + "evading-responsibility\n", + "evading-responsibility\n", + "evading-responsibility\n", + "evading-responsibility\n", + "evading-responsibility\n", + "evading-responsibility\n", + "evading-responsibility\n", + "evading-responsibility\n", + "evading-responsibility\n", + "evading-responsibility\n", + "evading-responsibility\n", + "evading-responsibility\n", + "evading-responsibility\n", + "evading-responsibility\n", + "evading-responsibility\n", + "evading-responsibility\n", + "evading-responsibility\n", + "evading-responsibility\n", + "evading-responsibility\n", + "evading-responsibility\n", + "evading-responsibility\n", + "evading-responsibility\n", + "evading-responsibility\n", + "evading-responsibility\n", + "evading-responsibility\n", + "evading-responsibility\n", + "evading-responsibility\n", + "evading-responsibility\n", + "evading-responsibility\n", + "evading-responsibility\n", + "evading-responsibility\n", + "evading-responsibility\n", + "evading-responsibility\n", + "evading-responsibility\n", + "evading-responsibility\n", + "evading-responsibility\n", + "evading-responsibility\n", + "evading-responsibility\n", + "evading-responsibility\n", + "evading-responsibility\n", + "evading-responsibility\n", + "evading-responsibility\n", + "evading-responsibility\n", + "evading-responsibility\n", + "evading-responsibility\n", + "evading-responsibility\n", + "evading-responsibility\n", + "evading-responsibility\n", + "evading-responsibility\n", + "evading-responsibility\n", + "evading-responsibility\n", + "evading-responsibility\n", + "evading-responsibility\n", + "evading-responsibility\n", + "evading-responsibility\n", + "evading-responsibility\n", + "evading-responsibility\n", + "evading-responsibility\n", + "evading-responsibility\n", + "evading-responsibility\n", + "evading-responsibility\n", + "evading-responsibility\n", + "evading-responsibility\n", + "evading-responsibility\n", + "evading-responsibility\n", + "evading-responsibility\n", + "evading-responsibility\n", + "evading-responsibility\n", + "evading-responsibility\n", + "evading-responsibility\n", + "evading-responsibility\n", + "evading-responsibility\n", + "evading-responsibility\n", + "evading-responsibility\n", + "evading-responsibility\n", + "evading-responsibility\n", + "evading-responsibility\n", + "evading-responsibility\n", + "evading-responsibility\n", + "evading-responsibility\n", + "evading-responsibility\n", + "evading-responsibility\n", + "evading-responsibility\n", + "evading-responsibility\n", + "evading-responsibility\n", + "evading-responsibility\n", + "evading-responsibility\n", + "evading-responsibility\n", + "evading-responsibility\n", + "evading-responsibility\n", + "evading-responsibility\n", + "evading-responsibility\n", + "evading-responsibility\n", + "evading-responsibility\n", + "evading-responsibility\n", + "falsely-reporting-incident\n", + "falsely-reporting-incident\n", + "family-dispute\n", + "family-dispute\n", + "family-dispute\n", + "family-dispute\n", + "family-dispute\n", + "family-dispute\n", + "family-dispute\n", + "family-dispute\n", + "family-dispute\n", + "family-dispute\n", + "family-dispute\n", + "family-dispute\n", + "family-dispute\n", + "family-dispute\n", + "family-dispute\n", + "family-dispute\n", + "family-dispute\n", + "family-dispute\n", + "family-dispute\n", + "family-dispute\n", + "family-dispute\n", + "family-dispute\n", + "family-dispute\n", + "family-dispute\n", + "family-dispute\n", + "family-dispute\n", + "family-dispute\n", + "family-dispute\n", + "family-dispute\n", + "family-dispute\n", + "family-dispute\n", + "family-dispute\n", + "family-dispute\n", + "family-dispute\n", + "family-dispute\n", + "family-dispute\n", + "family-dispute\n", + "family-dispute\n", + "family-dispute\n", + "family-dispute\n", + "family-dispute\n", + "family-dispute\n", + "family-dispute\n", + "family-dispute\n", + "family-dispute\n", + "family-dispute\n", + "family-dispute\n", + "family-dispute\n", + "family-dispute\n", + "family-dispute\n", + "family-dispute\n", + "family-dispute\n", + "family-dispute\n", + "family-dispute\n", + "family-dispute\n", + "family-dispute\n", + "family-dispute\n", + "family-dispute\n", + "family-dispute\n", + "family-dispute\n", + "family-dispute\n", + "family-dispute\n", + "family-dispute\n", + "family-dispute\n", + "family-dispute\n", + "family-dispute\n", + "family-dispute\n", + "family-dispute\n", + "family-dispute\n", + "family-dispute\n", + "family-dispute\n", + "family-dispute\n", + "family-dispute\n", + "family-dispute\n", + "family-dispute\n", + "family-dispute\n", + "family-dispute\n", + "family-dispute\n", + "family-dispute\n", + "family-dispute\n", + "family-dispute\n", + "family-dispute\n", + "family-dispute\n", + "family-dispute\n", + "family-dispute\n", + "family-dispute\n", + "family-dispute\n", + "family-dispute\n", + "family-dispute\n", + "family-dispute\n", + "family-dispute\n", + "family-dispute\n", + "family-dispute\n", + "family-dispute\n", + "family-dispute\n", + "family-dispute\n", + "family-dispute\n", + "family-dispute\n", + "family-dispute\n", + "family-dispute\n", + "field-interrogation\n", + "field-interrogation\n", + "field-interrogation\n", + "field-interrogation\n", + "field-interrogation\n", + "field-interrogation\n", + "field-interrogation\n", + "field-interrogation\n", + "field-interrogation\n", + "field-interrogation\n", + "field-interrogation\n", + "field-interrogation\n", + "field-interrogation\n", + "field-interrogation\n", + "field-interrogation\n", + "field-interrogation\n", + "field-interrogation\n", + "field-interrogation\n", + "field-interrogation\n", + "field-interrogation\n", + "field-interrogation\n", + "field-interrogation\n", + "field-interrogation\n", + "field-interrogation\n", + "field-interrogation\n", + "field-interrogation\n", + "field-interrogation\n", + "field-interrogation\n", + "field-interrogation\n", + "field-interrogation\n", + "field-interrogation\n", + "field-interrogation\n", + "field-interrogation\n", + "field-interrogation\n", + "field-interrogation\n", + "field-interrogation\n", + "field-interrogation\n", + "field-interrogation\n", + "field-interrogation\n", + "field-interrogation\n", + "field-interrogation\n", + "field-interrogation\n", + "field-interrogation\n", + "field-interrogation\n", + "field-interrogation\n", + "field-interrogation\n", + "field-interrogation\n", + "field-interrogation\n", + "field-interrogation\n", + "field-interrogation\n", + "field-interrogation\n", + "field-interrogation\n", + "fight\n", + "fight\n", + "fight\n", + "fight\n", + "fight\n", + "fight\n", + "fight\n", + "fight\n", + "fight\n", + "fight\n", + "fight\n", + "fight\n", + "fight\n", + "fight\n", + "fight\n", + "fight\n", + "fight\n", + "fire-alarms-fire\n", + "fire-alarms-fire\n", + "fire-alarms-fire\n", + "fire-alarms-fire\n", + "fire-alarms-fire\n", + "fire-alarms-fire\n", + "fire-alarms-fire\n", + "fire-alarms-no-fire\n", + "fire-alarms-no-fire\n", + "fire-alarms-no-fire\n", + "fire-alarms-no-fire\n", + "fire-alarms-no-fire\n", + "fire-alarms-no-fire\n", + "fire-alarms-no-fire\n", + "fire-alarms-no-fire\n", + "fire-alarms-no-fire\n", + "fire-alarms-no-fire\n", + "fire-alarms-no-fire\n", + "fire-alarms-no-fire\n", + "fire-alarms-no-fire\n", + "fire-alarms-no-fire\n", + "fire-alarms-no-fire\n", + "fire-alarms-no-fire\n", + "fire-alarms-no-fire\n", + "fire-alarms-no-fire\n", + "fire-alarms-no-fire\n", + "fire-alarms-no-fire\n", + "fire-alarms-no-fire\n", + "fire-alarms-no-fire\n", + "fire-alarms-no-fire\n", + "fire-alarms-no-fire\n", + "fire-no-alarm\n", + "fire-no-alarm\n", + "fire-no-alarm\n", + "fire-no-alarm\n", + "firearms-unlawful-discharge\n", + "firearms-unlawful-discharge\n", + "firearms-unlawful-discharge\n", + "firearms-unlawful-discharge\n", + "firearms-unlawful-discharge\n", + "firearms-unlawful-discharge\n", + "firearms-unlawful-discharge\n", + "firearms-unlawful-discharge\n", + "firearms-unlawful-discharge\n", + "forgery-of-public-records\n", + "forgery-of-public-records\n", + "forgery-of-public-records\n", + "forgery-of-symbols-of-value\n", + "forgerychecks-mv-document\n", + "forgerychecks-mv-document\n", + "forgerychecks-mv-document\n", + "forgerychecks-mv-document\n", + "forging-narcotic-prescript\n", + "found-animal\n", + "found-dead-animal\n", + "found-intoxicated\n", + "found-intoxicated\n", + "found-intoxicated\n", + "found-intoxicated\n", + "found-intoxicated\n", + "found-intoxicated\n", + "found-property\n", + "found-property\n", + "found-property\n", + "found-property\n", + "found-property\n", + "found-property\n", + "found-property\n", + "found-property\n", + "found-property\n", + "found-property\n", + "found-property\n", + "found-property\n", + "found-property\n", + "found-property\n", + "found-property\n", + "found-property\n", + "found-property\n", + "found-property\n", + "found-property\n", + "found-property\n", + "found-property\n", + "found-property\n", + "found-property\n", + "found-property\n", + "found-property\n", + "found-property\n", + "found-property\n", + "found-property\n", + "found-property\n", + "found-property\n", + "found-property\n", + "found-property\n", + "found-property\n", + "found-property\n", + "found-property\n", + "found-property\n", + "found-property\n", + "found-property\n", + "found-property\n", + "found-property\n", + "found-property\n", + "found-property\n", + "found-property\n", + "found-property\n", + "found-property\n", + "found-property\n", + "found-property\n", + "found-property\n", + "found-property\n", + "found-property\n", + "found-property\n", + "found-property\n", + "found-property\n", + "found-property\n", + "found-property\n", + "found-property\n", + "found-property\n", + "found-property\n", + "found-property\n", + "found-property\n", + "found-property\n", + "found-property\n", + "found-property\n", + "found-property\n", + "found-property\n", + "fraud-with-credit-card\n", + "fraud-with-credit-card\n", + "fraud-with-credit-card\n", + "fraud-with-credit-card\n", + "fraud-with-credit-card\n", + "fraud-with-credit-card\n", + "fraud-with-credit-card\n", + "fraud-with-credit-card\n", + "fraud-with-credit-card\n", + "fraud-with-credit-card\n", + "fraud-with-credit-card\n", + "fraud-with-credit-card\n", + "fraud-with-credit-card\n", + "fraud-with-credit-card\n", + "fraud\n", + "fraud\n", + "fraud\n", + "fraud\n", + "fraud\n", + "fraud\n", + "fraud\n", + "fraud\n", + "fraud\n", + "fraud\n", + "fraud\n", + "fraud\n", + "fraud\n", + "fraud\n", + "fraud\n", + "fraud\n", + "fraud\n", + "fraud\n", + "fraud\n", + "fraud\n", + "fraud\n", + "fraud\n", + "fraud\n", + "fraud\n", + "fraud\n", + "fraud\n", + "fraud\n", + "fraud\n", + "fraud\n", + "fraud\n", + "fraud\n", + "fraud\n", + "fraud\n", + "fraud\n", + "fraud\n", + "harassment\n", + "harassment\n", + "harassment\n", + "harassment\n", + "harassment\n", + "harassment\n", + "harassment\n", + "harassment\n", + "harassment\n", + "harassment\n", + "harassment\n", + "harassment\n", + "harassment\n", + "harassment\n", + "harassment\n", + "harassment\n", + "harassment\n", + "harassment\n", + "harassment\n", + "harassment\n", + "harassment\n", + "harassment\n", + "harassment\n", + "harassment\n", + "harassment\n", + "harassment\n", + "harassment\n", + "harassment\n", + "harassment\n", + "harassment\n", + "harassment\n", + "harassment\n", + "harassment\n", + "harassment\n", + "harassment\n", + "harassment\n", + "harassment\n", + "harassment\n", + "harassment\n", + "harassment\n", + "harassment\n", + "harassment\n", + "harassment\n", + "harassment\n", + "harassment\n", + "harassment\n", + "harassment\n", + "harassment\n", + "harassment\n", + "harassment\n", + "harassment\n", + "harassment\n", + "harassment\n", + "harassment\n", + "harassment\n", + "harassment\n", + "harassment\n", + "harassment\n", + "harassment\n", + "harassment\n", + "harassment\n", + "harassment\n", + "harassment\n", + "harassment\n", + "harassment\n", + "harassment\n", + "harassment\n", + "harassment\n", + "illegal-poss-of-a-weapon\n", + "illegal-poss-of-a-weapon\n", + "illegal-poss-of-a-weapon\n", + "incident-unfounded\n", + "incident-unfounded\n", + "incident-unfounded\n", + "incident-unfounded\n", + "incident-unfounded\n", + "incident-unfounded\n", + "incident-unfounded\n", + "incident-unfounded\n", + "incident-unfounded\n", + "incident-unfounded\n", + "incident-unfounded\n", + "incident-unfounded\n", + "incident-unfounded\n", + "incident-unfounded\n", + "incident-unfounded\n", + "incident-unfounded\n", + "incident-unfounded\n", + "incident-unfounded\n", + "incident-unfounded\n", + "incident-unfounded\n", + "incident-unfounded\n", + "incident-unfounded\n", + "incident-unfounded\n", + "incident-unfounded\n", + "incident-unfounded\n", + "incident-unfounded\n", + "incident-unfounded\n", + "incident-unfounded\n", + "incident-unfounded\n", + "incident-unfounded\n", + "incident-unfounded\n", + "incident-unfounded\n", + "incident-unfounded\n", + "incident-unfounded\n", + "incident-unfounded\n", + "incident-unfounded\n", + "incident-unfounded\n", + "incident-unfounded\n", + "incident-unfounded\n", + "incident-unfounded\n", + "incident-unfounded\n", + "incident-unfounded\n", + "incident-unfounded\n", + "incident-unfounded\n", + "incident-unfounded\n", + "incident-unfounded\n", + "incident-unfounded\n", + "incident-unfounded\n", + "incident-unfounded\n", + "incident-unfounded\n", + "incident-unfounded\n", + "incident-unfounded\n", + "incident-unfounded\n", + "incident-unfounded\n", + "incident-unfounded\n", + "incident-unfounded\n", + "incident-unfounded\n", + "incident-unfounded\n", + "incident-unfounded\n", + "incident-unfounded\n", + "incident-unfounded\n", + "incident-unfounded\n", + "incident-unfounded\n", + "incident-unfounded\n", + "incident-unfounded\n", + "incident-unfounded\n", + "incident-unfounded\n", + "incident-unfounded\n", + "incident-unfounded\n", + "incident-unfounded\n", + "incident-unfounded\n", + "incident-unfounded\n", + "incident-unfounded\n", + "incident-unfounded\n", + "incident-unfounded\n", + "incident-unfounded\n", + "incident-unfounded\n", + "incident-unfounded\n", + "incident-unfounded\n", + "incident-unfounded\n", + "incident-unfounded\n", + "incident-unfounded\n", + "incident-unfounded\n", + "incident-unfounded\n", + "incident-unfounded\n", + "incident-unfounded\n", + "incident-unfounded\n", + "incident-unfounded\n", + "incident-unfounded\n", + "incident-unfounded\n", + "incident-unfounded\n", + "incident-unfounded\n", + "incident-unfounded\n", + "incident-unfounded\n", + "incident-unfounded\n", + "incident-unfounded\n", + "incident-unfounded\n", + "incident-unfounded\n", + "incident-unfounded\n", + "incident-unfounded\n", + "injunction-violation\n", + "injunction-violation\n", + "injunction-violation\n", + "injunction-violation\n", + "injunction-violation\n", + "interfering-with-an-officer\n", + "interfering-with-an-officer\n", + "interfering-with-an-officer\n", + "interfering-with-an-officer\n", + "interfering-with-an-officer\n", + "interfering-with-an-officer\n", + "interfering-with-an-officer\n", + "interfering-with-an-officer\n", + "interfering-with-an-officer\n", + "interfering-with-an-officer\n", + "interfering-with-an-officer\n", + "interfering-with-an-officer\n", + "interfering-with-an-officer\n", + "issuing-bad-checks\n", + "landlordtenant-dispute\n", + "landlordtenant-dispute\n", + "landlordtenant-dispute\n", + "landlordtenant-dispute\n", + "landlordtenant-dispute\n", + "landlordtenant-dispute\n", + "landlordtenant-dispute\n", + "landlordtenant-dispute\n", + "landlordtenant-dispute\n", + "landlordtenant-dispute\n", + "landlordtenant-dispute\n", + "landlordtenant-dispute\n", + "landlordtenant-dispute\n", + "landlordtenant-dispute\n", + "landlordtenant-dispute\n", + "landlordtenant-dispute\n", + "landlordtenant-dispute\n", + "landlordtenant-dispute\n", + "landlordtenant-dispute\n", + "landlordtenant-dispute\n", + "landlordtenant-dispute\n", + "landlordtenant-dispute\n", + "landlordtenant-dispute\n", + "landlordtenant-dispute\n", + "landlordtenant-dispute\n", + "licensereg-check\n", + "licensereg-check\n", + "licensereg-check\n", + "licensereg-check\n", + "licensereg-check\n", + "licensereg-check\n", + "licensereg-check\n", + "licensereg-check\n", + "licensereg-check\n", + "licensereg-check\n", + "licensereg-check\n", + "licensereg-check\n", + "licensereg-check\n", + "licensereg-check\n", + "littering-violations\n", + "littering-violations\n", + "littering-violations\n", + "littering-violations\n", + "littering-violations\n", + "littering-violations\n", + "littering-violations\n", + "littering-violations\n", + "littering-violations\n", + "littering-violations\n", + "loitering-school-grounds\n", + "loitering\n", + "loitering\n", + "loitering\n", + "loitering\n", + "loitering\n", + "loitering\n", + "loitering\n", + "loitering\n", + "loitering\n", + "lost-property\n", + "lost-property\n", + "lost-property\n", + "lost-property\n", + "lost-property\n", + "lost-property\n", + "lost-property\n", + "lost-property\n", + "lost-property\n", + "lost-property\n", + "lost-property\n", + "lost-property\n", + "lost-property\n", + "lost-property\n", + "lost-property\n", + "lost-property\n", + "lost-property\n", + "lost-property\n", + "lost-property\n", + "lost-property\n", + "lost-property\n", + "lost-property\n", + "lost-property\n", + "lost-property\n", + "lost-property\n", + "lost-property\n", + "lost-property\n", + "lost-property\n", + "lost-property\n", + "lost-property\n", + "lost-property\n", + "lost-property\n", + "lost-property\n", + "lost-property\n", + "lost-property\n", + "lost-property\n", + "medical-assistance-needed\n", + "medical-assistance-needed\n", + "medical-assistance-needed\n", + "medical-assistance-needed\n", + "medical-assistance-needed\n", + "medical-assistance-needed\n", + "medical-assistance-needed\n", + "medical-assistance-needed\n", + "medical-assistance-needed\n", + "medical-assistance-needed\n", + "medical-assistance-needed\n", + "medical-assistance-needed\n", + "medical-assistance-needed\n", + "medical-assistance-needed\n", + "medical-assistance-needed\n", + "medical-assistance-needed\n", + "medical-assistance-needed\n", + "medical-assistance-needed\n", + "medical-assistance-needed\n", + "medical-assistance-needed\n", + "medical-assistance-needed\n", + "medical-assistance-needed\n", + "medical-assistance-needed\n", + "medical-assistance-needed\n", + "medical-assistance-needed\n", + "medical-assistance-needed\n", + "medical-assistance-needed\n", + "medical-assistance-needed\n", + "medical-assistance-needed\n", + "medical-assistance-needed\n", + "medical-assistance-needed\n", + "medical-assistance-needed\n", + "medical-assistance-needed\n", + "medical-assistance-needed\n", + "medical-assistance-needed\n", + "medical-assistance-needed\n", + "medical-assistance-needed\n", + "medical-assistance-needed\n", + "medical-assistance-needed\n", + "medical-assistance-needed\n", + "medical-assistance-needed\n", + "medical-assistance-needed\n", + "medical-assistance-needed\n", + "medical-assistance-needed\n", + "medical-assistance-needed\n", + "medical-assistance-needed\n", + "medical-assistance-needed\n", + "medical-assistance-needed\n", + "medical-assistance-needed\n", + "medical-assistance-needed\n", + "medical-assistance-needed\n", + "medical-assistance-needed\n", + "medical-assistance-needed\n", + "medical-assistance-needed\n", + "medical-assistance-needed\n", + "medical-assistance-needed\n", + "medical-assistance-needed\n", + "medical-assistance-needed\n", + "medical-assistance-needed\n", + "medical-assistance-needed\n", + "medical-assistance-needed\n", + "medical-assistance-needed\n", + "medical-assistance-needed\n", + "medical-assistance-needed\n", + "medical-assistance-needed\n", + "medical-assistance-needed\n", + "medical-assistance-needed\n", + "medical-assistance-needed\n", + "medical-assistance-needed\n", + "medical-assistance-needed\n", + "medical-assistance-needed\n", + "medical-assistance-needed\n", + "medical-assistance-needed\n", + "medical-assistance-needed\n", + "medical-assistance-needed\n", + "medical-assistance-needed\n", + "medical-assistance-needed\n", + "medical-assistance-needed\n", + "medical-assistance-needed\n", + "medical-assistance-needed\n", + "medical-assistance-needed\n", + "medical-assistance-needed\n", + "medical-assistance-needed\n", + "medical-assistance-needed\n", + "medical-assistance-needed\n", + "medical-assistance-needed\n", + "medical-assistance-needed\n", + "medical-assistance-needed\n", + "medical-assistance-needed\n", + "medical-assistance-needed\n", + "medical-assistance-needed\n", + "medical-assistance-needed\n", + "medical-assistance-needed\n", + "medical-assistance-needed\n", + "medical-assistance-needed\n", + "medical-assistance-needed\n", + "medical-assistance-needed\n", + "medical-assistance-needed\n", + "medical-assistance-needed\n", + "medical-assistance-needed\n", + "medical-assistance-rendered\n", + "medical-assistance-rendered\n", + "medical-assistance-rendered\n", + "medical-assistance-rendered\n", + "mv-accident-fatal\n", + "mv-accident-nonfatal\n", + "mv-accident-nonfatal\n", + "mv-accident-nonfatal\n", + "mv-accident-nonfatal\n", + "mv-accident-nonfatal\n", + "mv-accident-nonfatal\n", + "mv-accident-nonfatal\n", + "mv-accident-nonfatal\n", + "mv-accident-nonfatal\n", + "mv-accident-nonfatal\n", + "mv-accident-nonfatal\n", + "mv-accident-nonfatal\n", + "mv-accident-nonfatal\n", + "mv-accident-nonfatal\n", + "mv-accident-nonfatal\n", + "mv-accident-nonfatal\n", + "mv-accident-nonfatal\n", + "mv-accident-nonfatal\n", + "mv-accident-nonfatal\n", + "mv-accident-nonfatal\n", + "mv-accident-nonfatal\n", + "mv-accident-nonfatal\n", + "mv-accident-nonfatal\n", + "mv-accident-nonfatal\n", + "mv-accident-nonfatal\n", + "mv-accident-nonfatal\n", + "mv-accident-nonfatal\n", + "mv-accident-nonfatal\n", + "mv-accident-nonfatal\n", + "mv-accident-nonfatal\n", + "mv-accident-nonfatal\n", + "mv-accident-nonfatal\n", + "mv-accident-nonfatal\n", + "mv-accident-nonfatal\n", + "mv-accident-nonfatal\n", + "mv-accident-nonfatal\n", + "mv-accident-nonfatal\n", + "mv-accident-nonfatal\n", + "mv-accident-nonfatal\n", + "mv-accident-nonfatal\n", + "mv-accident-nonfatal\n", + "mv-accident-nonfatal\n", + "mv-accident-nonfatal\n", + "mv-accident-nonfatal\n", + "mv-accident-nonfatal\n", + "mv-accident-nonfatal\n", + "mv-accident-nonfatal\n", + "mv-accident-nonfatal\n", + "mv-accident-nonfatal\n", + "mv-accident-nonfatal\n", + "mv-accident-nonfatal\n", + "mv-accident-nonfatal\n", + "mv-accident-nonfatal\n", + "mv-accident-nonfatal\n", + "mv-accident-nonfatal\n", + "mv-accident-nonfatal\n", + "mv-accident-nonfatal\n", + "mv-accident-nonfatal\n", + "mv-accident-nonfatal\n", + "mv-accident-nonfatal\n", + "mv-accident-nonfatal\n", + "mv-accident-nonfatal\n", + "mv-accident-nonfatal\n", + "mv-accident-nonfatal\n", + "mv-accident-nonfatal\n", + "mv-accident-nonfatal\n", + "mv-accident-nonfatal\n", + "mv-accident-nonfatal\n", + "mv-accident-nonfatal\n", + "mv-accident-nonfatal\n", + "mv-accident-nonfatal\n", + "mv-accident-nonfatal\n", + "mv-accident-nonfatal\n", + "mv-accident-nonfatal\n", + "mv-accident-nonfatal\n", + "mv-accident-nonfatal\n", + "mv-accident-nonfatal\n", + "mv-accident-nonfatal\n", + "mv-accident-nonfatal\n", + "mv-accident-nonfatal\n", + "mv-accident-nonfatal\n", + "mv-accident-nonfatal\n", + "mv-accident-nonfatal\n", + "mv-accident-nonfatal\n", + "mv-accident-nonfatal\n", + "mv-accident-nonfatal\n", + "mv-accident-nonfatal\n", + "mv-accident-nonfatal\n", + "mv-accident-nonfatal\n", + "mv-accident-nonfatal\n", + "mv-accident-nonfatal\n", + "mv-accident-nonfatal\n", + "mv-accident-nonfatal\n", + "mv-accident-nonfatal\n", + "mv-accident-nonfatal\n", + "mv-accident-nonfatal\n", + "mv-accident-nonfatal\n", + "mv-accident-nonfatal\n", + "mv-accident-nonfatal\n", + "mv-accident-nonfatal\n", + "mv-accidentpriv-property\n", + "mv-accidentproperty-damage\n", + "mv-accidentproperty-damage\n", + "mv-accidentproperty-damage\n", + "mv-accidentproperty-damage\n", + "mv-accidentproperty-damage\n", + "mv-accidentproperty-damage\n", + "mv-accidentproperty-damage\n", + "mv-accidentproperty-damage\n", + "mv-accidentproperty-damage\n", + "mv-accidentproperty-damage\n", + "mv-accidentproperty-damage\n", + "mv-accidentproperty-damage\n", + "mv-accidentproperty-damage\n", + "mv-accidentproperty-damage\n", + "mv-accidentproperty-damage\n", + "mv-accidentproperty-damage\n", + "mv-accidentproperty-damage\n", + "mv-accidentproperty-damage\n", + "mv-accidentproperty-damage\n", + "mv-accidentproperty-damage\n", + "mv-accidentproperty-damage\n", + "mv-accidentproperty-damage\n", + "mv-accidentproperty-damage\n", + "mv-accidentproperty-damage\n", + "mv-accidentproperty-damage\n", + "mv-accidentproperty-damage\n", + "mv-accidentproperty-damage\n", + "mv-accidentproperty-damage\n", + "mv-accidentproperty-damage\n", + "mv-accidentproperty-damage\n", + "mv-accidentproperty-damage\n", + "mv-accidentproperty-damage\n", + "mv-accidentproperty-damage\n", + "mv-accidentproperty-damage\n", + "mv-accidentproperty-damage\n", + "mv-accidentproperty-damage\n", + "mv-accidentproperty-damage\n", + "mv-accidentproperty-damage\n", + "mv-accidentproperty-damage\n", + "mv-accidentproperty-damage\n", + "mv-accidentproperty-damage\n", + "mv-accidentproperty-damage\n", + "mv-accidentproperty-damage\n", + "mv-accidentproperty-damage\n", + "mv-accidentproperty-damage\n", + "mv-accidentproperty-damage\n", + "mv-accidentproperty-damage\n", + "mv-accidentproperty-damage\n", + "mv-accidentproperty-damage\n", + "mv-accidentproperty-damage\n", + "mv-accidentproperty-damage\n", + "mv-accidentproperty-damage\n", + "mv-accidentproperty-damage\n", + "mv-accidentproperty-damage\n", + "mv-accidentproperty-damage\n", + "mv-accidentproperty-damage\n", + "mv-accidentproperty-damage\n", + "mv-accidentproperty-damage\n", + "mv-accidentproperty-damage\n", + "mv-accidentproperty-damage\n", + "mv-accidentproperty-damage\n", + "mv-accidentproperty-damage\n", + "mv-accidentproperty-damage\n", + "mv-accidentproperty-damage\n", + "mv-accidentproperty-damage\n", + "mv-accidentproperty-damage\n", + "mv-accidentproperty-damage\n", + "mv-accidentproperty-damage\n", + "mv-accidentproperty-damage\n", + "mv-accidentproperty-damage\n", + "mv-accidentproperty-damage\n", + "mv-accidentproperty-damage\n", + "mv-accidentproperty-damage\n", + "mv-accidentproperty-damage\n", + "mv-accidentproperty-damage\n", + "mv-accidentproperty-damage\n", + "mv-accidentproperty-damage\n", + "mv-accidentproperty-damage\n", + "mv-accidentproperty-damage\n", + "mv-accidentproperty-damage\n", + "mv-accidentproperty-damage\n", + "mv-accidentproperty-damage\n", + "mv-accidentproperty-damage\n", + "mv-accidentproperty-damage\n", + "mv-accidentproperty-damage\n", + "mv-accidentproperty-damage\n", + "mv-accidentproperty-damage\n", + "mv-accidentproperty-damage\n", + "mv-accidentproperty-damage\n", + "mv-accidentproperty-damage\n", + "mv-accidentproperty-damage\n", + "mv-accidentproperty-damage\n", + "mv-accidentproperty-damage\n", + "mv-accidentproperty-damage\n", + "mv-accidentproperty-damage\n", + "mv-accidentproperty-damage\n", + "mv-accidentproperty-damage\n", + "mv-accidentproperty-damage\n", + "mv-accidentproperty-damage\n", + "mv-accidentproperty-damage\n", + "mv-violations-moving-veh\n", + "mv-violations-moving-veh\n", + "mv-violations-moving-veh\n", + "mv-violations-moving-veh\n", + "mv-violations-moving-veh\n", + "mv-violations-moving-veh\n", + "mv-violations-moving-veh\n", + "mv-violations-moving-veh\n", + "mv-violations-moving-veh\n", + "mv-violations-moving-veh\n", + "mv-violations-moving-veh\n", + "mv-violations-moving-veh\n", + "mv-violations-moving-veh\n", + "mv-violations-moving-veh\n", + "mv-violations-moving-veh\n", + "mv-violations-moving-veh\n", + "mv-violations-moving-veh\n", + "mv-violations-moving-veh\n", + "mv-violations-moving-veh\n", + "mv-violations-moving-veh\n", + "mv-violations-moving-veh\n", + "mv-violations-moving-veh\n", + "mv-violations-moving-veh\n", + "mv-violations-moving-veh\n", + "mv-violations-moving-veh\n", + "mv-violations-moving-veh\n", + "mv-violations-moving-veh\n", + "mv-violations-moving-veh\n", + "mv-violations-moving-veh\n", + "mv-violations-moving-veh\n", + "mv-violations-moving-veh\n", + "mv-violations-moving-veh\n", + "mv-violations-moving-veh\n", + "mv-violations-moving-veh\n", + "mv-violations-moving-veh\n", + "mv-violations-moving-veh\n", + "mv-violations-moving-veh\n", + "mv-violations-moving-veh\n", + "mv-violations-moving-veh\n", + "mv-violations-moving-veh\n", + "mv-violations-moving-veh\n", + "mv-violations-moving-veh\n", + "mv-violations-moving-veh\n", + "mv-violations-moving-veh\n", + "mv-violations-moving-veh\n", + "mv-violations-moving-veh\n", + "mv-violations-moving-veh\n", + "mv-violations-moving-veh\n", + "mv-violations-moving-veh\n", + "mv-violations-moving-veh\n", + "mv-violations-moving-veh\n", + "mv-violations-moving-veh\n", + "mv-violations-moving-veh\n", + "mv-violations-moving-veh\n", + "mv-violations-moving-veh\n", + "mv-violations-moving-veh\n", + "mv-violations-moving-veh\n", + "mv-violations-moving-veh\n", + "mv-violations-moving-veh\n", + "mv-violations-moving-veh\n", + "mv-violations-moving-veh\n", + "mv-violations-moving-veh\n", + "mv-violations-moving-veh\n", + "mv-violations-moving-veh\n", + "mv-violations-moving-veh\n", + "mv-violations-moving-veh\n", + "mv-violations-moving-veh\n", + "mv-violations-moving-veh\n", + "mv-violations-moving-veh\n", + "mv-violations-moving-veh\n", + "mv-violations-moving-veh\n", + "mv-violations-moving-veh\n", + "mv-violations-moving-veh\n", + "mv-violations-moving-veh\n", + "mv-violations-moving-veh\n", + "mv-violations-moving-veh\n", + "mv-violations-moving-veh\n", + "mv-violations-moving-veh\n", + "mv-violations-moving-veh\n", + "mv-violations-moving-veh\n", + "mv-violations-moving-veh\n", + "mv-violations-moving-veh\n", + "mv-violations-moving-veh\n", + "mv-violations-moving-veh\n", + "mv-violations-moving-veh\n", + "mv-violations-moving-veh\n", + "mv-violations-moving-veh\n", + "mv-violations-moving-veh\n", + "mv-violations-moving-veh\n", + "mv-violations-moving-veh\n", + "mv-violations-moving-veh\n", + "mv-violations-moving-veh\n", + "mv-violations-moving-veh\n", + "mv-violations-moving-veh\n", + "mv-violations-moving-veh\n", + "mv-violations-moving-veh\n", + "mv-violations-moving-veh\n", + "mv-violations-moving-veh\n", + "mv-violations-moving-veh\n", + "mv-violations-moving-veh\n", + "mv-violations-parked-veh\n", + "mv-violations-parked-veh\n", + "mv-violations-parked-veh\n", + "mv-violations-parked-veh\n", + "mv-violations-parked-veh\n", + "mv-violations-parked-veh\n", + "mv-violations-parked-veh\n", + "mv-violations-parked-veh\n", + "mv-violations-parked-veh\n", + "mv-violations-parked-veh\n", + "mv-violations-parked-veh\n", + "mv-violations-parked-veh\n", + "mv-violations-parked-veh\n", + "mv-violations-parked-veh\n", + "mv-violations-parked-veh\n", + "mv-violations-parked-veh\n", + "mv-violations-parked-veh\n", + "mv-violations-parked-veh\n", + "mv-violations-parked-veh\n", + "mv-violations-parked-veh\n", + "mv-violations-parked-veh\n", + "mv-violations-parked-veh\n", + "mv-violations-parked-veh\n", + "mv-violations-parked-veh\n", + "mv-violations-parked-veh\n", + "mv-violations-parked-veh\n", + "mv-violations-parked-veh\n", + "mv-violations-parked-veh\n", + "mv-violations-parked-veh\n", + "mv-violations-parked-veh\n", + "mv-violations-parked-veh\n", + "mv-violations-parked-veh\n", + "mv-violations-parked-veh\n", + "mv-violations-parked-veh\n", + "mv-violations-parked-veh\n", + "mv-violations-parked-veh\n", + "mv-violations-parked-veh\n", + "mv-violations-parked-veh\n", + "mv-violations-parked-veh\n", + "mv-violations-parked-veh\n", + "mv-violations-parked-veh\n", + "mv-violations-parked-veh\n", + "mv-violations-parked-veh\n", + "mv-violations-parked-veh\n", + "mv-violations-parked-veh\n", + "mv-violations-parked-veh\n", + "mv-violations-parked-veh\n", + "mv-violations-parked-veh\n", + "mv-violations-parked-veh\n", + "mv-violations-parked-veh\n", + "mv-violations-parked-veh\n", + "mv-violations-parked-veh\n", + "mv-violations-parked-veh\n", + "mv-violations-parked-veh\n", + "mv-violations-parked-veh\n", + "mv-violations-parked-veh\n", + "mv-violations-parked-veh\n", + "mv-violations-parked-veh\n", + "mv-violations-parked-veh\n", + "mv-violations-parked-veh\n", + "mv-violations-parked-veh\n", + "mv-violations-parked-veh\n", + "mv-violations-parked-veh\n", + "mv-violations-parked-veh\n", + "mv-violations-parked-veh\n", + "mv-violations-parked-veh\n", + "mv-violations-parked-veh\n", + "mv-violations-parked-veh\n", + "mv-violations-parked-veh\n", + "mv-violations-parked-veh\n", + "mv-violations-parked-veh\n", + "mv-violations-parked-veh\n", + "mv-violations-parked-veh\n", + "mv-violations-parked-veh\n", + "mv-violations-parked-veh\n", + "mv-violations-parked-veh\n", + "mv-violations-parked-veh\n", + "mv-violations-parked-veh\n", + "mv-violations-parked-veh\n", + "mv-violations-parked-veh\n", + "mv-violations-parked-veh\n", + "mv-violations-parked-veh\n", + "mv-violations-parked-veh\n", + "mv-violations-parked-veh\n", + "mv-violations-parked-veh\n", + "mv-violations-parked-veh\n", + "mv-violations-parked-veh\n", + "mv-violations-parked-veh\n", + "mv-violations-parked-veh\n", + "mv-violations-parked-veh\n", + "mv-violations-parked-veh\n", + "mv-violations-parked-veh\n", + "mv-violations-parked-veh\n", + "mv-violations-parked-veh\n", + "mv-violations-parked-veh\n", + "mv-violations-parked-veh\n", + "mv-violations-parked-veh\n", + "mv-violations-parked-veh\n", + "mv-violations-parked-veh\n", + "mv-violations-parked-veh\n", + "neglect-or-abuse-of-family\n", + "neighbor-trouble\n", + "neighbor-trouble\n", + "neighbor-trouble\n", + "neighbor-trouble\n", + "neighbor-trouble\n", + "neighbor-trouble\n", + "neighbor-trouble\n", + "neighbor-trouble\n", + "neighbor-trouble\n", + "neighbor-trouble\n", + "neighbor-trouble\n", + "neighbor-trouble\n", + "neighbor-trouble\n", + "neighbor-trouble\n", + "neighbor-trouble\n", + "neighbor-trouble\n", + "neighbor-trouble\n", + "neighbor-trouble\n", + "neighbor-trouble\n", + "neighbor-trouble\n", + "neighbor-trouble\n", + "neighbor-trouble\n", + "neighbor-trouble\n", + "neighbor-trouble\n", + "neighbor-trouble\n", + "neighbor-trouble\n", + "neighbor-trouble\n", + "neighbor-trouble\n", + "neighbor-trouble\n", + "neighbor-trouble\n", + "neighbor-trouble\n", + "neighbor-trouble\n", + "neighbor-trouble\n", + "neighbor-trouble\n", + "neighbor-trouble\n", + "neighbor-trouble\n", + "neighbor-trouble\n", + "neighbor-trouble\n", + "neighbor-trouble\n", + "neighbor-trouble\n", + "neighbor-trouble\n", + "non-motor-vehicle-accident\n", + "non-motor-vehicle-accident\n", + "non-motor-vehicle-accident\n", + "non-motor-vehicle-accident\n", + "oper-wo-owners-permission\n", + "oper-wo-owners-permission\n", + "oper-wo-owners-permission\n", + "oper-wo-owners-permission\n", + "oper-wo-owners-permission\n", + "oper-wo-owners-permission\n", + "oper-wo-owners-permission\n", + "oper-wo-owners-permission\n", + "oper-wo-owners-permission\n", + "other-alarms\n", + "other-alarms\n", + "other-alarms\n", + "other-code-violations\n", + "other-code-violations\n", + "other-code-violations\n", + "other-code-violations\n", + "other-code-violations\n", + "other-code-violations\n", + "other-code-violations\n", + "other-code-violations\n", + "other-code-violations\n", + "other-code-violations\n", + "other-internal-functions\n", + "other-internal-functions\n", + "other-internal-functions\n", + "other-internal-functions\n", + "other-internal-functions\n", + "other-internal-functions\n", + "other-internal-functions\n", + "other-internal-functions\n", + "other-internal-functions\n", + "other-internal-functions\n", + "other-internal-functions\n", + "other-investigation\n", + "other-investigation\n", + "other-investigation\n", + "other-investigation\n", + "other-investigation\n", + "other-investigation\n", + "other-investigation\n", + "other-investigation\n", + "other-investigation\n", + "other-investigation\n", + "other-investigation\n", + "other-investigation\n", + "other-investigation\n", + "other-investigation\n", + "other-investigation\n", + "other-investigation\n", + "other-investigation\n", + "other-investigation\n", + "other-investigation\n", + "other-investigation\n", + "other-investigation\n", + "other-investigation\n", + "other-investigation\n", + "other-investigation\n", + "other-investigation\n", + "other-investigation\n", + "other-investigation\n", + "other-investigation\n", + "other-investigation\n", + "other-investigation\n", + "other-investigation\n", + "other-investigation\n", + "other-investigation\n", + "other-investigation\n", + "other-investigation\n", + "other-investigation\n", + "other-investigation\n", + "other-investigation\n", + "other-investigation\n", + "other-investigation\n", + "other-investigation\n", + "other-investigation\n", + "other-investigation\n", + "other-investigation\n", + "other-investigation\n", + "other-investigation\n", + "other-investigation\n", + "other-investigation\n", + "other-investigation\n", + "other-investigation\n", + "other-investigation\n", + "other-investigation\n", + "other-investigation\n", + "other-investigation\n", + "other-investigation\n", + "other-investigation\n", + "other-investigation\n", + "other-investigation\n", + "other-investigation\n", + "other-investigation\n", + "other-investigation\n", + "other-investigation\n", + "other-investigation\n", + "other-investigation\n", + "other-investigation\n", + "other-investigation\n", + "other-investigation\n", + "other-investigation\n", + "other-investigation\n", + "other-investigation\n", + "other-investigation\n", + "other-investigation\n", + "other-investigation\n", + "other-investigation\n", + "other-investigation\n", + "other-investigation\n", + "other-investigation\n", + "other-investigation\n", + "other-investigation\n", + "other-investigation\n", + "other-investigation\n", + "other-investigation\n", + "other-investigation\n", + "other-investigation\n", + "other-investigation\n", + "other-investigation\n", + "other-investigation\n", + "other-investigation\n", + "other-investigation\n", + "other-liquor-offenses\n", + "other-liquor-offenses\n", + "other-liquor-offenses\n", + "other-liquor-offenses\n", + "other-liquor-offenses\n", + "other-liquor-offenses\n", + "other-liquor-offenses\n", + "other-liquor-offenses\n", + "other-liquor-offenses\n", + "other-liquor-offenses\n", + "other-liquor-offenses\n", + "other-liquor-offenses\n", + "other-liquor-offenses\n", + "other-liquor-offenses\n", + "other-liquor-offenses\n", + "other-liquor-offenses\n", + "other-liquor-offenses\n", + "other-liquor-offenses\n", + "other-liquor-offenses\n", + "other-liquor-offenses\n", + "other-liquor-offenses\n", + "other-liquor-offenses\n", + "other-liquor-offenses\n", + "other-liquor-offenses\n", + "other-miscellaneous\n", + "other-miscellaneous\n", + "other-miscellaneous\n", + "other-miscellaneous\n", + "other-miscellaneous\n", + "other-miscellaneous\n", + "other-miscellaneous\n", + "other-miscellaneous\n", + "other-miscellaneous\n", + "other-miscellaneous\n", + "other-miscellaneous\n", + "other-miscellaneous\n", + "other-miscellaneous\n", + "other-miscellaneous\n", + "other-miscellaneous\n", + "other-miscellaneous\n", + "other-miscellaneous\n", + "other-miscellaneous\n", + "other-miscellaneous\n", + "other-miscellaneous\n", + "other-miscellaneous\n", + "other-miscellaneous\n", + "other-miscellaneous\n", + "other-miscellaneous\n", + "other-miscellaneous\n", + "other-nuisances\n", + "other-nuisances\n", + "other-nuisances\n", + "park-violation\n", + "patrol-division\n", + "patrol-division\n", + "patrol-division\n", + "patronizing-a-prostitute\n", + "possessdangcontrol-drugs\n", + "possession-of-heroin\n", + "possession-of-marijuana\n", + "possession-of-marijuana\n", + "possession-of-marijuana\n", + "possession-of-marijuana\n", + "possession-of-marijuana\n", + "possession-of-marijuana\n", + "possession-of-marijuana\n", + "possession-of-marijuana\n", + "possession-of-marijuana\n", + "possession-of-marijuana\n", + "possession-of-marijuana\n", + "possession-of-marijuana\n", + "possession-of-marijuana\n", + "possession-of-marijuana\n", + "possession-of-marijuana\n", + "possession-of-marijuana\n", + "possession-of-marijuana\n", + "possession-of-marijuana\n", + "possession-of-marijuana\n", + "possession-of-marijuana\n", + "possession-of-marijuana\n", + "possession-of-marijuana\n", + "possession-of-marijuana\n", + "possession-of-marijuana\n", + "possession-of-marijuana\n", + "possession-of-marijuana\n", + "possession-of-marijuana\n", + "possession-of-marijuana\n", + "possession-of-marijuana\n", + "possession-of-marijuana\n", + "possession-of-marijuana\n", + "possession-of-marijuana\n", + "possession-of-marijuana\n", + "possession-of-marijuana\n", + "possession-of-marijuana\n", + "possession-of-marijuana\n", + "possession-of-marijuana\n", + "possession-of-marijuana\n", + "possession-of-marijuana\n", + "possession-of-marijuana\n", + "possession-of-marijuana\n", + "possession-of-marijuana\n", + "possession-of-marijuana\n", + "possession-of-marijuana\n", + "possession-of-marijuana\n", + "possession-of-marijuana\n", + "possession-of-marijuana\n", + "possession-of-paraphernalia\n", + "possession-of-paraphernalia\n", + "possession-of-paraphernalia\n", + "possession-of-paraphernalia\n", + "possessof-narcoticsgeneral\n", + "possessof-narcoticsgeneral\n", + "possessof-narcoticsgeneral\n", + "possessof-narcoticsgeneral\n", + "possessof-narcoticsgeneral\n", + "possessof-narcoticsgeneral\n", + "possessof-narcoticsgeneral\n", + "possessof-narcoticsgeneral\n", + "possessof-narcoticsgeneral\n", + "possessof-narcoticsgeneral\n", + "possessof-narcoticsgeneral\n", + "possessof-narcoticsgeneral\n", + "possessof-narcoticsgeneral\n", + "possessof-narcoticsgeneral\n", + "possessof-narcoticsgeneral\n", + "possessof-narcoticsgeneral\n", + "possessof-narcoticsgeneral\n", + "possessof-narcoticsgeneral\n", + "possessof-narcoticsgeneral\n", + "possessof-narcoticsgeneral\n", + "possessof-narcoticsgeneral\n", + "possessof-narcoticsgeneral\n", + "possessof-narcoticsgeneral\n", + "possessof-narcoticsgeneral\n", + "possessof-narcoticsgeneral\n", + "possessof-narcoticsgeneral\n", + "possessof-narcoticsgeneral\n", + "possessof-narcoticsgeneral\n", + "possessof-narcoticsgeneral\n", + "possessof-narcoticsgeneral\n", + "possessof-narcoticsgeneral\n", + "possessof-narcoticsgeneral\n", + "possessof-narcoticsgeneral\n", + "possessof-narcoticsgeneral\n", + "possessof-narcoticsgeneral\n", + "possessof-narcoticsgeneral\n", + "possessof-narcoticsgeneral\n", + "possessof-narcoticsgeneral\n", + "possessof-narcoticsgeneral\n", + "possessof-narcoticsgeneral\n", + "possessof-narcoticsgeneral\n", + "possessof-narcoticsgeneral\n", + "possessof-narcoticsgeneral\n", + "possessof-narcoticsgeneral\n", + "possessof-narcoticsgeneral\n", + "possessof-narcoticsgeneral\n", + "possessof-narcoticsgeneral\n", + "possessof-narcoticsgeneral\n", + "possessof-narcoticsgeneral\n", + "possessof-narcoticsgeneral\n", + "possessof-narcoticsgeneral\n", + "possessof-narcoticsgeneral\n", + "possessof-narcoticsgeneral\n", + "possessof-narcoticsgeneral\n", + "possessof-narcoticsgeneral\n", + "possessof-narcoticsgeneral\n", + "possessof-narcoticsgeneral\n", + "possessof-narcoticsgeneral\n", + "possessof-narcoticsgeneral\n", + "possessof-narcoticsgeneral\n", + "possessof-narcoticsgeneral\n", + "possessof-narcoticsgeneral\n", + "possessof-narcoticsgeneral\n", + "possessof-narcoticsgeneral\n", + "possessof-narcoticsgeneral\n", + "possessof-narcoticsgeneral\n", + "possessof-narcoticsgeneral\n", + "possessof-narcoticsgeneral\n", + "possessof-narcoticsgeneral\n", + "possessof-narcoticsgeneral\n", + "possessof-narcoticsgeneral\n", + "possessof-narcoticsgeneral\n", + "possessof-narcoticsgeneral\n", + "possessof-narcoticsgeneral\n", + "possessof-narcoticsgeneral\n", + "possessof-narcoticsgeneral\n", + "possessof-narcoticsgeneral\n", + "possessof-narcoticsgeneral\n", + "possessof-narcoticsgeneral\n", + "public-hazards\n", + "public-hazards\n", + "public-hazards\n", + "public-hazards\n", + "public-hazards\n", + "public-hazards\n", + "public-hazards\n", + "public-hazards\n", + "public-hazards\n", + "public-hazards\n", + "receiving-stolen-property\n", + "receiving-stolen-property\n", + "receiving-stolen-property\n", + "reckless-burning\n", + "reckless-burning\n", + "reckless-burning\n", + "recovered-auto-stolen-ot\n", + "recovered-auto-stolen-ot\n", + "recovered-auto-stolen-ot\n", + "recovered-auto-stolen-ot\n", + "recovered-auto-stolen-ot\n", + "recovered-auto-stolen-ot\n", + "recovered-auto-stolen-ot\n", + "recovered-auto-stolen-ot\n", + "recovered-auto-stolen-ot\n", + "recovered-auto-stolen-ot\n", + "recovered-auto-stolen-ot\n", + "recovered-auto-stolen-ot\n", + "recovered-auto-stolen-ot\n", + "recovered-auto-stolen-ot\n", + "recovered-auto-stolen-ot\n", + "recovered-auto-stolen-ot\n", + "recovered-auto-stolen-ot\n", + "recovered-auto-stolen-ot\n", + "recovered-auto-stolen-ot\n", + "recovered-auto-stolen-ot\n", + "recovered-auto-stolen-ot\n", + "recovered-auto-stolen-ot\n", + "recovered-auto-stolen-ot\n", + "recovered-auto-stolen-ot\n", + "recovered-auto-stolen-ot\n", + "recovered-auto-stolen-ot\n", + "recovered-auto-stolen-ot\n", + "recovered-auto-stolen-ot\n", + "recovered-auto-stolen-ot\n", + "recovered-auto-stolen-ot\n", + "recovered-auto-stolen-ot\n", + "recovered-auto-stolen-ot\n", + "recovered-auto-stolen-ot\n", + "recovered-auto-stolen-ot\n", + "recovered-auto-stolen-ot\n", + "recovered-auto-stolen-ot\n", + "recovered-auto-stolen-ot\n", + "recovered-auto-stolen-ot\n", + "recovered-auto-stolen-ot\n", + "recovered-auto-stolen-ot\n", + "recovered-auto-stolen-ot\n", + "recovered-platesstolen-ot\n", + "recovered-platesstolen-ot\n", + "recovered-platesstolen-ot\n", + "recovered-prop-owner-unk\n", + "recoveredother-stolen-ot\n", + "recoveredother-stolen-ot\n", + "recoveredother-stolen-ot\n", + "recoveredother-stolen-ot\n", + "recoveredother-stolen-ot\n", + "robbery-attempt-firearm\n", + "robbery-attempt-no-weapon\n", + "robbery-attempt-no-weapon\n", + "robbery-attempt-oth-weap\n", + "robbery-attempt-oth-weap\n", + "robbery-attempt-oth-weap\n", + "robbery-commfirearm\n", + "robbery-commfirearm\n", + "robbery-res-firearm\n", + "robbery-res-firearm\n", + "robbery-res-firearm\n", + "robbery-res-no-weapon\n", + "robbery-res-no-weapon\n", + "robbery-street-firearm\n", + "robbery-street-firearm\n", + "robbery-street-firearm\n", + "robbery-street-firearm\n", + "robbery-street-firearm\n", + "robbery-street-firearm\n", + "robbery-street-firearm\n", + "robbery-street-firearm\n", + "robbery-street-firearm\n", + "robbery-street-firearm\n", + "robbery-street-no-weapon\n", + "robbery-street-no-weapon\n", + "robbery-street-no-weapon\n", + "robbery-street-no-weapon\n", + "robbery-street-no-weapon\n", + "robbery-street-no-weapon\n", + "robbery-street-no-weapon\n", + "robbery-street-no-weapon\n", + "robbery-street-no-weapon\n", + "robbery-street-no-weapon\n", + "robbery-street-no-weapon\n", + "robbery-street-no-weapon\n", + "robbery-street-other-weap\n", + "robbery-street-other-weap\n", + "roving-gangs\n", + "sale-of-narcoticsgeneral\n", + "sale-of-narcoticsgeneral\n", + "sale-of-narcoticsgeneral\n", + "sale-of-narcoticsgeneral\n", + "sale-of-narcoticsgeneral\n", + "sale-of-narcoticsgeneral\n", + "sale-of-narcoticsgeneral\n", + "sale-of-narcoticsgeneral\n", + "sale-of-narcoticsgeneral\n", + "sale-of-narcoticsgeneral\n", + "sale-of-narcoticsgeneral\n", + "sale-of-narcoticsgeneral\n", + "sale-of-narcoticsgeneral\n", + "sale-of-narcoticsgeneral\n", + "sale-of-narcoticsgeneral\n", + "sale-of-narcoticsgeneral\n", + "sale-of-narcoticsgeneral\n", + "sale-of-narcoticsgeneral\n", + "sale-of-narcoticsgeneral\n", + "sale-of-narcoticsgeneral\n", + "sale-of-narcoticsgeneral\n", + "sale-of-narcoticsgeneral\n", + "sale-of-narcoticsgeneral\n", + "sale-of-narcoticsgeneral\n", + "sale-of-narcoticsgeneral\n", + "sale-of-narcoticsgeneral\n", + "sale-of-narcoticsgeneral\n", + "sale-of-narcoticsgeneral\n", + "sale-of-narcoticsgeneral\n", + "sale-of-narcoticsgeneral\n", + "sale-of-narcoticsgeneral\n", + "sale-of-narcoticsgeneral\n", + "sale-of-narcoticsgeneral\n", + "sale-of-narcoticsgeneral\n", + "sale-of-narcoticsgeneral\n", + "simple-assault\n", + "simple-assault\n", + "simple-assault\n", + "simple-assault\n", + "simple-assault\n", + "simple-assault\n", + "simple-assault\n", + "simple-assault\n", + "simple-assault\n", + "simple-assault\n", + "simple-assault\n", + "simple-assault\n", + "simple-assault\n", + "simple-assault\n", + "simple-assault\n", + "simple-assault\n", + "simple-assault\n", + "simple-assault\n", + "simple-assault\n", + "simple-assault\n", + "simple-assault\n", + "simple-assault\n", + "simple-assault\n", + "simple-assault\n", + "simple-assault\n", + "simple-assault\n", + "simple-assault\n", + "simple-assault\n", + "simple-assault\n", + "simple-assault\n", + "simple-assault\n", + "simple-assault\n", + "simple-assault\n", + "simple-assault\n", + "simple-assault\n", + "simple-assault\n", + "simple-assault\n", + "simple-assault\n", + "simple-assault\n", + "simple-assault\n", + "simple-assault\n", + "simple-assault\n", + "simple-assault\n", + "simple-assault\n", + "simple-assault\n", + "simple-assault\n", + "simple-assault\n", + "simple-assault\n", + "simple-assault\n", + "simple-assault\n", + "simple-assault\n", + "simple-assault\n", + "simple-assault\n", + "simple-assault\n", + "simple-assault\n", + "simple-assault\n", + "simple-assault\n", + "simple-assault\n", + "simple-assault\n", + "simple-assault\n", + "simple-assault\n", + "simple-assault\n", + "simple-assault\n", + "simple-assault\n", + "simple-assault\n", + "simple-assault\n", + "simple-assault\n", + "simple-assault\n", + "simple-assault\n", + "simple-assault\n", + "simple-assault\n", + "simple-assault\n", + "simple-assault\n", + "simple-assault\n", + "simple-assault\n", + "simple-assault\n", + "simple-assault\n", + "simple-assault\n", + "simple-assault\n", + "simple-assault\n", + "simple-assault\n", + "simple-assault\n", + "simple-assault\n", + "simple-assault\n", + "simple-assault\n", + "simple-assault\n", + "simple-assault\n", + "simple-assault\n", + "simple-assault\n", + "simple-assault\n", + "simple-assault\n", + "simple-assault\n", + "simple-assault\n", + "stolen-auto-nhrecvd-nh\n", + "stolen-auto-nhrecvd-nh\n", + "stolen-auto-nhrecvd-nh\n", + "stolen-auto-nhrecvd-nh\n", + "stolen-auto-nhrecvd-nh\n", + "stolen-auto-nhrecvd-nh\n", + "stolen-auto-nhrecvd-nh\n", + "stolen-auto-nhrecvd-nh\n", + "stolen-auto-nhrecvd-nh\n", + "stolen-auto-nhrecvd-nh\n", + "stolen-auto-nhrecvd-nh\n", + "stolen-auto-nhrecvd-nh\n", + "stolen-auto-nhrecvd-nh\n", + "stolen-auto-nhrecvd-nh\n", + "stolen-auto-nhrecvd-nh\n", + "stolen-auto-nhrecvd-nh\n", + "stolen-auto-nhrecvd-nh\n", + "stolen-auto-nhrecvd-nh\n", + "stolen-auto-nhrecvd-nh\n", + "stolen-auto-nhrecvd-ot\n", + "stolen-auto-nhrecvd-ot\n", + "stolen-auto-nhrecvd-ot\n", + "stolen-auto-nhrecvd-ot\n", + "stolen-auto-nhrecvd-ot\n", + "stolen-auto-nhrecvd-ot\n", + "stolen-auto-nhrecvd-ot\n", + "stolen-auto-nhrecvd-ot\n", + "stolen-other-nhrecvd-nh\n", + "stolen-other-nhrecvd-nh\n", + "stolen-other-nhrecvd-ot\n", + "stolen-other-nhrecvd-ot\n", + "stolen-plate-nhrecvd-nh\n", + "stolen-plate-nhrecvd-nh\n", + "sudden-deathbodies-found\n", + "sudden-deathbodies-found\n", + "sudden-deathbodies-found\n", + "sudden-deathbodies-found\n", + "sudden-deathbodies-found\n", + "sudden-deathbodies-found\n", + "sudden-deathbodies-found\n", + "supplementary-investigation\n", + "supplementary-investigation\n", + "supplementary-investigation\n", + "supplementary-investigation\n", + "supplementary-investigation\n", + "supplementary-investigation\n", + "supplementary-investigation\n", + "supplementary-investigation\n", + "supplementary-investigation\n", + "supplementary-investigation\n", + "supplementary-investigation\n", + "supplementary-investigation\n", + "supplementary-investigation\n", + "supplementary-investigation\n", + "supplementary-investigation\n", + "supplementary-investigation\n", + "supplementary-investigation\n", + "supplementary-investigation\n", + "supplementary-investigation\n", + "supplementary-investigation\n", + "supplementary-investigation\n", + "supplementary-investigation\n", + "supplementary-investigation\n", + "supplementary-investigation\n", + "supplementary-investigation\n", + "supplementary-investigation\n", + "supplementary-investigation\n", + "supplementary-investigation\n", + "supplementary-investigation\n", + "supplementary-investigation\n", + "supplementary-investigation\n", + "supplementary-investigation\n", + "supplementary-investigation\n", + "supplementary-investigation\n", + "supplementary-investigation\n", + "supplementary-investigation\n", + "supplementary-investigation\n", + "supplementary-investigation\n", + "supplementary-investigation\n", + "supplementary-investigation\n", + "supplementary-investigation\n", + "supplementary-investigation\n", + "supplementary-investigation\n", + "supplementary-investigation\n", + "supplementary-investigation\n", + "supplementary-investigation\n", + "supplementary-investigation\n", + "supplementary-investigation\n", + "supplementary-investigation\n", + "supplementary-investigation\n", + "supplementary-investigation\n", + "supplementary-investigation\n", + "supplementary-investigation\n", + "supplementary-investigation\n", + "supplementary-investigation\n", + "supplementary-investigation\n", + "supplementary-investigation\n", + "supplementary-investigation\n", + "supplementary-investigation\n", + "supplementary-investigation\n", + "supplementary-investigation\n", + "supplementary-investigation\n", + "supplementary-investigation\n", + "supplementary-investigation\n", + "supplementary-investigation\n", + "supplementary-investigation\n", + "supplementary-investigation\n", + "supplementary-investigation\n", + "supplementary-investigation\n", + "supplementary-investigation\n", + "supplementary-investigation\n", + "supplementary-investigation\n", + "supplementary-investigation\n", + "supplementary-investigation\n", + "supplementary-investigation\n", + "supplementary-investigation\n", + "supplementary-investigation\n", + "supplementary-investigation\n", + "supplementary-investigation\n", + "supplementary-investigation\n", + "supplementary-investigation\n", + "supplementary-investigation\n", + "supplementary-investigation\n", + "supplementary-investigation\n", + "supplementary-investigation\n", + "supplementary-investigation\n", + "supplementary-investigation\n", + "supplementary-investigation\n", + "supplementary-investigation\n", + "supplementary-investigation\n", + "supplementary-investigation\n", + "supplementary-investigation\n", + "supplementary-investigation\n", + "supplementary-investigation\n", + "supplementary-investigation\n", + "supplementary-investigation\n", + "supplementary-investigation\n", + "supplementary-investigation\n", + "supplementary-investigation\n", + "supplementary-investigation\n", + "suspicious-activity\n", + "suspicious-activity\n", + "suspicious-activity\n", + "suspicious-activity\n", + "suspicious-activity\n", + "suspicious-activity\n", + "suspicious-activity\n", + "suspicious-activity\n", + "suspicious-activity\n", + "suspicious-activity\n", + "suspicious-activity\n", + "suspicious-activity\n", + "suspicious-activity\n", + "suspicious-activity\n", + "suspicious-activity\n", + "suspicious-activity\n", + "suspicious-activity\n", + "suspicious-activity\n", + "suspicious-activity\n", + "suspicious-activity\n", + "suspicious-activity\n", + "suspicious-activity\n", + "suspicious-activity\n", + "suspicious-activity\n", + "suspicious-activity\n", + "suspicious-activity\n", + "suspicious-activity\n", + "suspicious-activity\n", + "suspicious-activity\n", + "suspicious-activity\n", + "suspicious-activity\n", + "suspicious-activity\n", + "suspicious-activity\n", + "suspicious-activity\n", + "suspicious-activity\n", + "suspicious-activity\n", + "suspicious-activity\n", + "suspicious-activity\n", + "suspicious-activity\n", + "suspicious-activity\n", + "suspicious-activity\n", + "suspicious-activity\n", + "suspicious-activity\n", + "suspicious-activity\n", + "suspicious-activity\n", + "suspicious-activity\n", + "suspicious-activity\n", + "suspicious-activity\n", + "suspicious-activity\n", + "suspicious-activity\n", + "suspicious-activity\n", + "suspicious-activity\n", + "suspicious-activity\n", + "suspicious-activity\n", + "suspicious-activity\n", + "suspicious-activity\n", + "suspicious-activity\n", + "suspicious-activity\n", + "suspicious-activity\n", + "suspicious-activity\n", + "suspicious-activity\n", + "suspicious-activity\n", + "suspicious-activity\n", + "suspicious-activity\n", + "suspicious-activity\n", + "suspicious-activity\n", + "suspicious-activity\n", + "suspicious-activity\n", + "suspicious-activity\n", + "suspicious-activity\n", + "suspicious-activity\n", + "suspicious-activity\n", + "suspicious-activity\n", + "suspicious-activity\n", + "suspicious-activity\n", + "suspicious-activity\n", + "suspicious-activity\n", + "suspicious-activity\n", + "suspicious-activity\n", + "suspicious-activity\n", + "suspicious-activity\n", + "suspicious-activity\n", + "suspicious-activity\n", + "suspicious-activity\n", + "suspicious-activity\n", + "suspicious-activity\n", + "suspicious-activity\n", + "suspicious-activity\n", + "suspicious-activity\n", + "suspicious-activity\n", + "suspicious-activity\n", + "suspicious-activity\n", + "suspicious-activity\n", + "suspicious-activity\n", + "suspicious-activity\n", + "suspicious-activity\n", + "suspicious-activity\n", + "suspicious-activity\n", + "suspicious-activity\n", + "suspicious-activity\n", + "suspicious-fires\n", + "suspicious-fires\n", + "suspicious-fires\n", + "suspicious-person\n", + "suspicious-person\n", + "suspicious-person\n", + "suspicious-person\n", + "suspicious-person\n", + "suspicious-person\n", + "suspicious-person\n", + "suspicious-person\n", + "suspicious-person\n", + "suspicious-person\n", + "suspicious-person\n", + "suspicious-person\n", + "suspicious-person\n", + "suspicious-person\n", + "suspicious-person\n", + "suspicious-person\n", + "suspicious-person\n", + "suspicious-person\n", + "suspicious-person\n", + "suspicious-person\n", + "suspicious-person\n", + "suspicious-person\n", + "suspicious-person\n", + "suspicious-person\n", + "suspicious-person\n", + "suspicious-person\n", + "suspicious-person\n", + "suspicious-person\n", + "suspicious-person\n", + "suspicious-person\n", + "suspicious-person\n", + "suspicious-person\n", + "suspicious-person\n", + "suspicious-person\n", + "suspicious-person\n", + "suspicious-person\n", + "suspicious-person\n", + "suspicious-person\n", + "suspicious-person\n", + "suspicious-person\n", + "suspicious-person\n", + "suspicious-person\n", + "suspicious-person\n", + "suspicious-person\n", + "suspicious-person\n", + "suspicious-person\n", + "suspicious-person\n", + "suspicious-person\n", + "suspicious-person\n", + "suspicious-person\n", + "suspicious-person\n", + "suspicious-person\n", + "suspicious-person\n", + "suspicious-person\n", + "suspicious-person\n", + "suspicious-person\n", + "suspicious-person\n", + "suspicious-person\n", + "suspicious-person\n", + "suspicious-person\n", + "suspicious-person\n", + "suspicious-person\n", + "suspicious-person\n", + "suspicious-person\n", + "suspicious-person\n", + "suspicious-person\n", + "suspicious-person\n", + "suspicious-person\n", + "suspicious-person\n", + "suspicious-person\n", + "suspicious-person\n", + "suspicious-person\n", + "suspicious-person\n", + "suspicious-person\n", + "suspicious-person\n", + "suspicious-person\n", + "suspicious-person\n", + "suspicious-person\n", + "suspicious-person\n", + "suspicious-person\n", + "suspicious-person\n", + "suspicious-person\n", + "suspicious-person\n", + "suspicious-person\n", + "suspicious-person\n", + "suspicious-person\n", + "suspicious-person\n", + "suspicious-person\n", + "suspicious-person\n", + "suspicious-person\n", + "suspicious-person\n", + "suspicious-person\n", + "suspicious-person\n", + "suspicious-person\n", + "suspicious-person\n", + "suspicious-person\n", + "suspicious-person\n", + "suspicious-person\n", + "suspicious-person\n", + "suspicious-person\n", + "tampering-with-motor-veh\n", + "tampering-with-motor-veh\n", + "tampering-with-motor-veh\n", + "tampering-with-motor-veh\n", + "tampering-with-motor-veh\n", + "tampering-with-motor-veh\n", + "tampering-with-motor-veh\n", + "tampering-with-motor-veh\n", + "tampering-with-motor-veh\n", + "tampering-with-motor-veh\n", + "theft-of-auto\n", + "theft-of-auto\n", + "theft-of-auto\n", + "theft-of-auto\n", + "theft-of-auto\n", + "theft-of-auto\n", + "theft-of-auto\n", + "theft-of-auto\n", + "theft-of-auto\n", + "theft-of-auto\n", + "theft-of-auto\n", + "theft-of-auto\n", + "theft-of-auto\n", + "theft-of-auto\n", + "theft-of-auto\n", + "theft-of-auto\n", + "theft-of-auto\n", + "theft-of-auto\n", + "theft-of-auto\n", + "theft-of-auto\n", + "theft-of-auto\n", + "theft-of-auto\n", + "theft-of-auto\n", + "theft-of-auto\n", + "theft-of-auto\n", + "theft-of-auto\n", + "theft-of-auto\n", + "theft-of-auto\n", + "theft-of-auto\n", + "theft-of-auto\n", + "theft-of-auto\n", + "theft-of-auto\n", + "theft-of-auto\n", + "theft-of-auto\n", + "theft-of-auto\n", + "theft-of-auto\n", + "theft-of-auto\n", + "theft-of-auto\n", + "theft-of-auto\n", + "theft-of-auto\n", + "theft-of-auto\n", + "theft-of-auto\n", + "theft-of-auto\n", + "theft-of-lic-reg-or-title\n", + "theft-of-license-plates\n", + "theft-of-license-plates\n", + "theft-of-license-plates\n", + "theft-of-license-plates\n", + "theft-of-license-plates\n", + "theft-of-license-plates\n", + "theft-of-license-plates\n", + "theft-of-license-plates\n", + "theft-of-license-plates\n", + "theft-of-license-plates\n", + "theft-of-license-plates\n", + "theft-of-license-plates\n", + "theft-of-license-plates\n", + "theft-of-license-plates\n", + "theft-of-license-plates\n", + "theft-of-license-plates\n", + "theft-of-license-plates\n", + "theft-of-license-plates\n", + "theft-of-license-plates\n", + "theft-of-license-plates\n", + "theft-of-services\n", + "theft-of-services\n", + "theft-of-services\n", + "theft-other-mv\n", + "theft-other-mv\n", + "theft-university-acadbldg\n", + "threatening\n", + "threatening\n", + "threatening\n", + "threatening\n", + "threatening\n", + "threatening\n", + "threatening\n", + "threatening\n", + "threatening\n", + "threatening\n", + "threatening\n", + "threatening\n", + "threatening\n", + "threatening\n", + "threatening\n", + "threatening\n", + "threatening\n", + "threatening\n", + "threatening\n", + "threatening\n", + "threatening\n", + "threatening\n", + "threatening\n", + "threatening\n", + "threatening\n", + "threatening\n", + "threatening\n", + "threatening\n", + "threatening\n", + "threatening\n", + "threatening\n", + "threatening\n", + "threatening\n", + "threatening\n", + "threatening\n", + "threatening\n", + "threatening\n", + "threatening\n", + "threatening\n", + "threatening\n", + "threatening\n", + "threatening\n", + "threatening\n", + "unable-to-locate-complainant\n", + "unable-to-locate-complainant\n", + "unable-to-locate-complainant\n", + "unable-to-locate-complainant\n", + "unable-to-locate-complainant\n", + "unable-to-locate-complainant\n", + "unable-to-locate-complainant\n", + "unable-to-locate-complainant\n", + "unable-to-locate-complainant\n", + "unable-to-locate-complainant\n", + "unable-to-locate-complainant\n", + "unable-to-locate-complainant\n", + "unable-to-locate-complainant\n", + "unable-to-locate-complainant\n", + "unable-to-locate-complainant\n", + "unable-to-locate-complainant\n", + "unable-to-locate-complainant\n", + "unable-to-locate-complainant\n", + "unable-to-locate-complainant\n", + "unable-to-locate-complainant\n", + "unable-to-locate-complainant\n", + "unable-to-locate-complainant\n", + "unable-to-locate-complainant\n", + "unable-to-locate-complainant\n", + "unable-to-locate-complainant\n", + "unable-to-locate-complainant\n", + "unable-to-locate-complainant\n", + "unable-to-locate-complainant\n", + "unable-to-locate-complainant\n", + "unwanted-person\n", + "unwanted-person\n", + "unwanted-person\n", + "unwanted-person\n", + "unwanted-person\n", + "unwanted-person\n", + "unwanted-person\n", + "unwanted-person\n", + "unwanted-person\n", + "unwanted-person\n", + "unwanted-person\n", + "unwanted-person\n", + "unwanted-person\n", + "unwanted-person\n", + "unwanted-person\n", + "unwanted-person\n", + "unwanted-person\n", + "unwanted-person\n", + "unwanted-person\n", + "unwanted-person\n", + "unwanted-person\n", + "unwanted-person\n", + "unwanted-person\n", + "unwanted-person\n", + "unwanted-person\n", + "unwanted-person\n", + "unwanted-person\n", + "unwanted-person\n", + "unwanted-person\n", + "unwanted-person\n", + "unwanted-person\n", + "unwanted-person\n", + "unwanted-person\n", + "unwanted-person\n", + "unwanted-person\n", + "unwanted-person\n", + "unwanted-person\n", + "unwanted-person\n", + "unwanted-person\n", + "unwanted-person\n", + "unwanted-person\n", + "unwanted-person\n", + "unwanted-person\n", + "unwanted-person\n", + "unwanted-person\n", + "unwanted-person\n", + "wanted-personnew-haven\n", + "wanted-personnew-haven\n", + "wanted-personnew-haven\n", + "wanted-personother-town\n", + "wanted-personother-town\n", + "wanted-personother-town\n", + "wanted-personother-town\n", + "wanted-personother-town\n", + "wanted-personother-town\n", + "wanted-personother-town\n", + "wanted-personother-town\n", + "wanted-personother-town\n", + "wanted-personother-town\n", + "wanted-personother-town\n", + "wanted-personother-town\n", + "wanted-personother-town\n", + "wanted-personother-town\n", + "wanted-personother-town\n", + "wanted-personother-town\n", + "wanted-personother-town\n", + "wanted-personother-town\n", + "wanted-personother-town\n", + "wanted-personother-town\n", + "wanted-personother-town\n", + "wanted-personother-town\n", + "wanted-personother-town\n", + "wanted-personother-town\n", + "wanted-personother-town\n", + "wanted-personother-town\n", + "wanted-personother-town\n", + "wanted-personother-town\n", + "wanted-personother-town\n", + "wanted-personother-town\n", + "wanted-personother-town\n", + "wanted-personother-town\n", + "wanted-personother-town\n", + "wanted-personother-town\n", + "wanted-personother-town\n", + "wanted-personother-town\n", + "wanted-personother-town\n", + "wanted-personother-town\n", + "wanted-personother-town\n", + "wanted-personother-town\n", + "wanted-personother-town\n", + "wanted-personother-town\n", + "wanted-personother-town\n", + "wanted-personother-town\n", + "wanted-personother-town\n", + "wanted-personother-town\n", + "wanted-personother-town\n", + "wanted-personother-town\n", + "wanted-personother-town\n", + "wanted-personother-town\n", + "wanted-personother-town\n", + "wanted-personother-town\n", + "wanted-personother-town\n", + "wanted-personother-town\n", + "wanted-personother-town\n", + "wanted-personother-town\n", + "wanted-personother-town\n", + "wanted-personother-town\n", + "wanted-personother-town\n", + "wanted-personother-town\n", + "wanted-personother-town\n", + "wanted-personother-town\n", + "wanted-personother-town\n", + "wanted-personother-town\n", + "wanted-personother-town\n", + "wanted-personother-town\n", + "wanted-personother-town\n", + "wanted-personother-town\n", + "wanted-personother-town\n", + "wanted-personother-town\n", + "wanted-personother-town\n", + "wanted-personother-town\n", + "wanted-personother-town\n", + "wanted-personother-town\n", + "wanted-personother-town\n", + "wanted-personother-town\n", + "wanted-personother-town\n", + "wanted-personother-town\n", + "wanted-personother-town\n", + "wanted-personother-town\n", + "wanted-personother-town\n", + "wanted-personother-town\n", + "wanted-personother-town\n", + "warrant-service\n", + "warrant-service\n", + "warrant-service\n", + "warrant-service\n", + "warrant-service\n", + "warrant-service\n", + "warrant-service\n", + "warrant-service\n", + "warrant-service\n", + "warrant-service\n", + "warrant-service\n", + "warrant-service\n", + "warrant-service\n", + "warrant-service\n", + "warrant-service\n", + "warrant-service\n", + "warrant-service\n", + "warrant-service\n", + "warrant-service\n", + "warrant-service\n", + "warrant-service\n", + "warrant-service\n", + "warrant-service\n", + "warrant-service\n", + "warrant-service\n", + "warrant-service\n", + "warrant-service\n", + "warrant-service\n", + "warrant-service\n", + "warrant-service\n", + "warrant-service\n", + "warrant-service\n", + "warrant-service\n", + "warrant-service\n", + "warrant-service\n", + "warrant-service\n", + "warrant-service\n", + "warrant-service\n", + "warrant-service\n", + "warrant-service\n", + "warrant-service\n", + "warrant-service\n", + "warrant-service\n", + "warrant-service\n", + "warrant-service\n", + "warrant-service\n", + "warrant-service\n", + "warrant-service\n", + "warrant-service\n", + "warrant-service\n", + "warrant-service\n", + "warrant-service\n", + "warrant-service\n", + "warrant-service\n", + "warrant-service\n", + "warrant-service\n", + "warrant-service\n", + "warrant-service\n", + "warrant-service\n", + "warrant-service\n", + "warrant-service\n", + "warrant-service\n", + "warrant-service\n", + "warrant-service\n", + "warrant-service\n", + "warrant-service\n", + "warrant-service\n", + "warrant-service\n", + "warrant-service\n", + "warrant-service\n", + "warrant-service\n", + "warrant-service\n", + "warrant-service\n", + "warrant-service\n", + "warrant-service\n", + "warrant-service\n", + "warrant-service\n", + "warrant-service\n", + "warrant-service\n", + "warrant-service\n", + "warrant-service\n", + "warrant-service\n", + "warrant-service\n", + "warrant-service\n", + "warrant-service\n", + "warrant-service\n", + "warrant-service\n", + "warrant-service\n", + "warrant-service\n", + "warrant-service\n", + "warrant-service\n", + "warrant-service\n", + "warrant-service\n", + "warrant-service\n", + "warrant-service\n", + "warrant-service\n", + "warrant-service\n", + "warrant-service\n", + "warrant-service\n", + "warrant-service\n", + "window-breaking\n", + "window-breaking\n", + "window-breaking\n", + "window-breaking\n", + "window-breaking\n", + "window-breaking\n", + "window-breaking\n", + "window-breaking\n", + "window-breaking\n", + "window-breaking\n", + "window-breaking\n", + "window-breaking\n", + "window-breaking\n", + "window-breaking\n", + "window-breaking\n", + "window-breaking\n", + "window-breaking\n", + "window-breaking\n", + "wrong-address\n", + "The overall nearest neighbor distance of the data set is: 0.000120180676464\n" + ] + }, + { + "ename": "AttributeError", + "evalue": "'list' object has no attribute 'mark'", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mAttributeError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[0;32m 10\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"The overall nearest neighbor distance of the data set is: \"\u001b[0m \u001b[1;33m+\u001b[0m \u001b[0mstr\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mnn\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 11\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 12\u001b[1;33m \u001b[0mnn\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mpattern\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0maverage_nearest_neighbor_distance_kdtree\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mmark\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;34m\"all-cases-dead-on-arrival\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 13\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"The nearest neighbor distance of the mark 'all-cases-dead-on-arrival' is \"\u001b[0m \u001b[1;33m+\u001b[0m \u001b[0mstr\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mnn\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 14\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;32m/home/schuyler/Desktop/GIS321/assignment_08/pointpattern.py\u001b[0m in \u001b[0;36maverage_nearest_neighbor_distance_kdtree\u001b[1;34m(self, mark)\u001b[0m\n\u001b[0;32m 20\u001b[0m \u001b[0mtemp_points\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mpoints\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 21\u001b[0m \u001b[1;32melse\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 22\u001b[1;33m \u001b[1;32mfor\u001b[0m \u001b[0mi\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mpoint\u001b[0m \u001b[1;32min\u001b[0m \u001b[0menumerate\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mpoints\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 23\u001b[0m \u001b[1;32mif\u001b[0m \u001b[0mpoints\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mi\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mmark\u001b[0m \u001b[1;32mis\u001b[0m \u001b[0mmark\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 24\u001b[0m \u001b[0mtemp_points\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mpoint\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;32m/home/schuyler/Desktop/GIS321/assignment_08/pointpattern.py\u001b[0m in \u001b[0;36m\u001b[1;34m(.0)\u001b[0m\n\u001b[0;32m 20\u001b[0m \u001b[0mtemp_points\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mpoints\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 21\u001b[0m \u001b[1;32melse\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 22\u001b[1;33m \u001b[1;32mfor\u001b[0m \u001b[0mi\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mpoint\u001b[0m \u001b[1;32min\u001b[0m \u001b[0menumerate\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mpoints\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 23\u001b[0m \u001b[1;32mif\u001b[0m \u001b[0mpoints\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mi\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mmark\u001b[0m \u001b[1;32mis\u001b[0m \u001b[0mmark\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 24\u001b[0m \u001b[0mtemp_points\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mpoint\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;31mAttributeError\u001b[0m: 'list' object has no attribute 'mark'" + ] + } + ], + "source": [ + "pattern = PointPattern()\n", + "\n", + "for point in points:\n", + " pattern.add_point(point)\n", + "\n", + "#It prints the mark attribute... not sure why recieving error below\n", + "#for point in pattern.points:\n", + " #print(point.mark)\n", + "\n", + "nn = pattern.average_nearest_neighbor_distance_kdtree()\n", + "print(\"The overall nearest neighbor distance of the data set is: \" + str(nn))\n", + "\n", + "nn = pattern.average_nearest_neighbor_distance_kdtree(mark=\"all-cases-dead-on-arrival\")\n", + "print(\"The nearest neighbor distance of the mark 'all-cases-dead-on-arrival' is \" + str(nn))\n", + "\n", + "nn = pattern.average_nearest_neighbor_distance_kdtree(mark=\"animal-bites\")\n", + "print(\"The nearest neighbor distance of the mark 'animal-bites' is \" + str(nn))" + ] + }, + { + "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/Assignment_08.ipynb b/Assignment_08.ipynb new file mode 100644 index 0000000..822e51f --- /dev/null +++ b/Assignment_08.ipynb @@ -0,0 +1,128 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "collapsed": false, + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-72.976512, 41.337662, all-cases-dead-on-arrival\n", + "-72.960621, 41.326316, animal-bites\n", + "-72.896278, 41.324366, animal-bites\n", + "-72.952039, 41.325584, animal-bites\n" + ] + } + ], + "source": [ + "from pointpattern import PointPattern\n", + "from point import Point\n", + "import pysal as ps\n", + "\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", + "points = []\n", + "\n", + "for geometry, attributes in zip(shapefile, dbf):\n", + " points.append(Point(geometry[0], geometry[1], mark=attributes[1]))\n", + "\n", + "i = 0\n", + "\n", + "\n", + "for point in points:\n", + " i += 1\n", + " #Print the first five of the points\n", + " if i < 5:\n", + " print(\"{0}, {1}, {2}\".format(point.x, point.y, point.mark))\n", + " else:\n", + " break\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": { + "collapsed": false, + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The overall nearest neighbor distance of the data set is: 0.000120180676464\n" + ] + }, + { + "ename": "AttributeError", + "evalue": "'list' object has no attribute 'mark'", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mAttributeError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[0;32m 11\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"The overall nearest neighbor distance of the data set is: \"\u001b[0m \u001b[1;33m+\u001b[0m \u001b[0mstr\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mnn\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 12\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 13\u001b[1;33m \u001b[0mnn\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mpattern\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0maverage_nearest_neighbor_distance_kdtree\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mmark\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;34m\"all-cases-dead-on-arrival\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 14\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"The nearest neighbor distance of the mark 'all-cases-dead-on-arrival' is \"\u001b[0m \u001b[1;33m+\u001b[0m \u001b[0mstr\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mnn\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 15\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;32m/home/schuyler/Desktop/GIS321/assignment_08/pointpattern.py\u001b[0m in \u001b[0;36maverage_nearest_neighbor_distance_kdtree\u001b[1;34m(self, mark)\u001b[0m\n\u001b[0;32m 20\u001b[0m \u001b[0mdistances\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m[\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 21\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 22\u001b[1;33m \u001b[1;32mif\u001b[0m \u001b[0mmark_name\u001b[0m \u001b[1;32mis\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 23\u001b[0m \u001b[0mtemp_points\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mpoints\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 24\u001b[0m \u001b[1;32melse\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;32m/home/schuyler/Desktop/GIS321/assignment_08/pointpattern.py\u001b[0m in \u001b[0;36m\u001b[1;34m(.0)\u001b[0m\n\u001b[0;32m 20\u001b[0m \u001b[0mdistances\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m[\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 21\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 22\u001b[1;33m \u001b[1;32mif\u001b[0m \u001b[0mmark_name\u001b[0m \u001b[1;32mis\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 23\u001b[0m \u001b[0mtemp_points\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mpoints\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 24\u001b[0m \u001b[1;32melse\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;31mAttributeError\u001b[0m: 'list' object has no attribute 'mark'" + ] + } + ], + "source": [ + "pattern = PointPattern()\n", + "\n", + "for point in points:\n", + " pattern.add_point(point)\n", + "\n", + "#It prints the mark attribute... not sure why recieving error below\n", + "#for point in pattern.points:\n", + " #print(point.mark)\n", + "\n", + "nn = pattern.average_nearest_neighbor_distance_kdtree()\n", + "print(\"The overall nearest neighbor distance of the data set is: \" + str(nn))\n", + "\n", + "nn = pattern.average_nearest_neighbor_distance_kdtree(mark=\"all-cases-dead-on-arrival\")\n", + "print(\"The nearest neighbor distance of the mark 'all-cases-dead-on-arrival' is \" + str(nn))\n", + "\n", + "nn = pattern.average_nearest_neighbor_distance_kdtree(mark=\"animal-bites\")\n", + "print(\"The nearest neighbor distance of the mark 'animal-bites' is \" + str(nn))" + ] + }, + { + "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/__pycache__/analytics.cpython-35.pyc b/__pycache__/analytics.cpython-35.pyc index 5f574c65af8bdf40a5744a1ba0ab436c7a654447..12997ef35b4250d63c0899aefe4c4412e631ffb6 100644 GIT binary patch delta 1074 zcmY*WOK;Oa5T3Q2*iD`HyQHD057liI`apn?S^)(vR7j-EYbsZ960H+xIe=7E zNQe{i0f{SIP`UZarRu-f3kSI5z#l*y*x5FvSoWuHXTJG7v-5G`_xyMv9*@2Gsy*ry z0e--_CnESw@%j4u@r~C2lt5F5x(@V&8&EfZsz5b30H_ZEjR1{G9s??5hUCLoNJTaV z2L$RSP!Ta@Dh^b<3CR;clR#6F3z7z!kvs)73p95}9z-+`v>+XeKud6-LOlbt40J>a zg!BT?isU(zZCImyoawDjwnYuTRj1*`~Hws*MJb-WJOw%qO> zPl)uUkoB5&*KM~rahWb$m>wRhIpv;$oFHfdxZye5HrDlJ43(C~49pK4=-B#D`zR=GcR>o#Ysq z4c{eyk&E)qR5pVe(&C1*+i|wK&RLHi(iW+ON9lbsF}Nzb;ae&vHYW{kP}lF;tu1F@ zy`7yQOTkgP93E!dBr5wz1!MW#!aTOLfUt;gvI=Bzgo=Ql;`4E_kXa(E5;*ze)QC8- z2?0FP>$*)pxLO#m%wh1l40asm{lDB^p+;7M&xQ5!vQ#wNFB~SSJ3>0>GEtl+tHHJ6 z{Y$6w-$KXRs5jaT-(k=H-N2{fym?n-tUSAdg5Y~`YW)W4akDIekU=ORV5`hRm_?`| rEFs{4Yz1Kz0UgiXfgU_9O^%qvRLrVbG^@#)Ice&G<;+4pZbtqB7#`nu delta 1079 zcmY*XO>fgc5S_K1ZzoQg#7WvTO$ll1(u7hZzFH(s2vOibB@n(;Zr0F9aT3-Jw7r0; z9?As?`2-gP>Ob&LfM4MY2e|aWi5myR&bEctlAqq}yqTT1yT2DdTx#g)bn^WtZ3p6LV26PN)UU0rx09r)eF>^q5pe2#uiZalO=r|5^0`_Du z^FXUWCxw8Q)qqY3UPRfNQ9nd)4|b$>`;c&EkT5dxx;+=kaM100!FAG>i0N<2)w-#4 zy56>#ajdQN;b1uGSzdS04@s9Lcr8l=2XaBWjYq_=8H;f+%i+_U?J5=O;bZb-I5vdxrJCEsEfNg>eUb$MwF zm-8G#*&R77iye|IhpRbf17$jYJMwP35Z&e zmT-_m0Wx+%*W3$s4I@vx%=JRq* z5bzxQ3B6IB!DxvCe>XOB&fcY|x1(2iu0#CkQo;YMU#naZ(%#^u&G?fW@|qLtzw|k> z;#W(n)5p$lVC!WLW_+;W+U&)D@B5`i^(N04I%}iA|5}=P6h*zbAn`ad7-|Rw1Tl64 vSrcInp@o2E8BWPo5U}m3^GNv1<>q*nWF@txmeiWoR-0;!vx2G@(`w`|{3_1` diff --git a/__pycache__/point.cpython-35.pyc b/__pycache__/point.cpython-35.pyc index 17cf2d256c756b334f349a6080be081cd74b5872..7a9192818b2400ab583335dd195bbbe5bad46ce3 100644 GIT binary patch delta 562 zcmaFDbBRY;jF*?ob`4ATdnN{k#|%h-1;};);^Nqe%GQPq3@MBZIjjs(tPJic%nT_k z3@tz*7KT(dhGu4lD0Yx^uqNwEkO6*GOnQ0~7v2+M26Bo(<`l64iIogR?2{)lu9krd zYcdwGfn?d?1jpnErVM3-0w%D6Tdesd8L34m>K-$tssWwMP=v0yhzD*O*j$dudCVD# zgjIcKj(5DpT3V8sQ+!JxIU_YWJ3cu-GcP$aB{i=E!_yV9|C7LV{53yIogGFz#S3()AV0m-{g(t_cdRcIS%;p9WydZ)P zMDT+MK@cGfA`n3c@ia(`Y4QVBX*N(GX>v?vWK(d2xQ8u2DJwO(qzD{(SoGcEu*uC& WDa}c>1F0zH01`ZmJWTRTJj?({9%Z)x delta 580 zcmcb_^MprPjF*?IJe(o?8xsS=V+JI^0%SV?adF~AWou_u|n zx(Hoy5g*(%u(@25W0*4(39EX_9B*I54Agr|AUPv7IXgZ%KQk{mGbJ^z1jCM7EG4PM zCCKgp*(o%+m8I4PZWF{X?&6Hhw37G&pkXDNEMV_Mu~)={MWfg&A>BV0m-{MJD^P zdRcIT%;p6V{2)RALv~f$g1Fcivi*yw)~{5 m)Z~&PaOh#td5gm)H$SB`C)Ey^NEnJiF~q~j!z9lnzzhK2DQHyy diff --git a/__pycache__/pointpattern.cpython-35.pyc b/__pycache__/pointpattern.cpython-35.pyc index 2e77354054041dee2fe98c195a1da770a2cbaac7..039a77f96b0d30a435c4566406d3a99573343926 100644 GIT binary patch delta 1424 zcmZWoTZQWgvq+bj+=Fp2qGdVUO^FwlHfoXYrAXL-b`0_PWOcD z(|Y>>LjM3?6$H_JRPosdUGVX|3d;Tq g}E>JC9l|58ka$fX!dA^GfxsUyaYy(8HbV|O8YV(c&EKpghOxG&yL z>Dm)t5z`Yo6kifyAkLAS4`cs~Vu)Cx|3Q(N`p55{l`?4llHUw5R7OpY>MW^n)SUXG zP2j|02YmWLFIR9E0uo#3u{1dO#o3qJtR*`(hset4?Chepa5ok4C9KtlKYGo2#p>OXoxSQ7O zP?p$S^Pkwlb)yyNs-75~9elc1fX!kltzJ|5KaXtg8#ebg_C?OSQ*QHKFnOxm5I-}i zez0Wnd+^UEl6Yqfv5TQLvs{C!b=w>3zt{HDPl}nTaV??3k}TDxo=mA6pvNJAgQGme zz?OA=Dacy?^y>ee2J6zDyW|m7mb}D>!k@0#5y|;&?!}x5v-3xXW;j;kvzHcxY(fTp!M}_5}j$%}lmmKn~BaihI;{#bN0s zf;enj=H{6}H&+kfGGE!OUM30G545q98!ZyI*h(Yk?I874(u z&T8H0^}}0z4m4mGFC+OGM{Uu=D#^;D9jd#|)D(Mj0nU*%2F2c?PHJFZkA!M|*tpPNk^EV6{sVp2 BGt~e9 delta 1442 zcmZWpON$g&6u!5fU0vNXJp*F~HIuaCs|R0kAt7i`5Q1bANTP5-+M236V~tg}%Tv|h ztVT@!L2a@LAv+g>m|2M$e}c=v-3o!(BgS!k8{pF@5j7Zf49DOq}y%( z^Sg8Bmo8)P+04g5`a1r~2qD2QXBlHTXM!_Myu~t$=|b-#Y=_SeB9GYfnYIe7#RpoL@u0a4-pGi!^VBPr^UI&=)JtqYelPf}pFD!pUW%2JOazY(-efyciagc_~7WQ8s0Q zBrU5*#j@0{c^BS;q#}pB5Ov=@dP?+^j6jyvP|0-r{^kfw7ISF@^*#4h-{ih*a&Ka< zQrpmZ+H6DIR3-A!oXSh@?|U>{F#Wc5Ak{dR5LL42jq&d{{dD8eSXE*%#=_z> zk*XSISPm?ZJq6c%M|h^J%X2~g^WUBS&}lF(?TJeoQE80lEdFi%v0+BUC({AkNM<4p z8d0NeM!H!472KFDw3*~ec&tlFX%`~3En&HS7#_c57KbYx zqA;0G%^?O(Of#6v^i6m>{LnyHs@FPC_fC=KX@WBZX9<=F4i(MLwcrzyZXjrXtkSI! zQU1bi>QkTgP>`dou^9MdGrWAqbHNq7f6ZTwp3nmC`M8Rzbfn73;XscZ&o0vP!sBzKE*7?Mg@!Stc!*I}!j~w-fl$|G4fg+BSmk@B z+5u^}rclw!QdJgFEa5yEP^H?AHp|KJ2v3!jEJ|S|rEs^05D zzI~3y!l6T(4NM+`c$638O4dL2c5b&(0wKXsf@1`q67&hy2~HARCb&XCCBat&*9Z>V zU?{V2ZoRT}CU)_8&^ervX68SU8K-dZjEdc+>~0yS#qI^Hyh@`?_!9zF(1G?wn>#YD UfV_Patp0UrwbkPt{9CmC2NgmpY5)KL diff --git a/__pycache__/utils.cpython-35.pyc b/__pycache__/utils.cpython-35.pyc index 50d8cce1f676a67ff6b7631e7cef81254f93619c..ade4766d6a7fe511e9d0a4c362fab588d53fff55 100644 GIT binary patch delta 506 zcmYjN%}T>S5T4mIwn>vVtmT*gitE~)$4s|n1H40O8RQ?*2}6Q_Ho^#? z_wOV05H2Vb5E!takemzzCM@8#eUwM&_}-Fw;p8c@FdLh*>2NYvFW5p)ed7$vY9=1G z1TlP+78?&tqA&Xlua`(Fe>Y>rG=;+&!6luL{{lQ6`{K delta 522 zcmZ{f%}T>S5XWaWO>JUQ(-isv3f2!K2qK;p6a-K8B2oxKtpudd+PW$9=%pv|BKrgi zK0wJs_zt;>hhFsP)tQZlTwJoho!$A*{3oBypJuz}y7sgKol_g&19Hot_?UJ)B}DWg z3;;q31Vjc55QYLm0eDMK1&B1l5>7P;_q1acf~W6+E%}F2$eLCumNmv2 lW1Z1r)EV3$=gU^oC#0pr;YhtZUfB~Xu46hoj_;J6>Mx%5RvQ2S diff --git a/analytics.py b/analytics.py index dd646f8..6264a88 100644 --- a/analytics.py +++ b/analytics.py @@ -6,8 +6,8 @@ sys.path.insert(0, os.path.abspath('..')) -from . import utils -from . import point +import utils +import point def find_largest_city(gj): """ @@ -263,7 +263,7 @@ def permutations(p=99, n=100, marks=None): def find_criticals(perms): lower = min(perms) upper = max(perms) - return (lower, upper) + return lower, upper def check_significance(lower, upper, observed): if observed > upper: diff --git a/point.py b/point.py index 37bafdf..24b5490 100644 --- a/point.py +++ b/point.py @@ -4,7 +4,7 @@ sys.path.insert(0, os.path.abspath('..')) -from . import utils +import utils class Point(object): @@ -16,7 +16,7 @@ def __init__(self, x, y, mark=None): #Magic methods def __str__(self): - return ("({0}, {1}").format(self.x, self.y) + return ("{0}, {1}").format(self.x, self.y) def __eq__(self, other): return self.x == other.x and self.y == other.y diff --git a/pointpattern.py b/pointpattern.py index d0bf0c4..87a1347 100644 --- a/pointpattern.py +++ b/pointpattern.py @@ -1,5 +1,5 @@ -from .point import Point -from . import analytics +from point import Point +import analytics import random import numpy as np import scipy.spatial as ss @@ -8,18 +8,23 @@ class PointPattern(object): def __init__(self): self.points = [] + def add_point(self, point): + self.points.append(point) + def average_nearest_neighbor_distance(self, mark=None): return analytics.average_nearest_neighbor_distance(self.points, mark) - def average_nearest_neighbor_distance_kdtree(self, mark=None): + def average_nearest_neighbor_distance_kdtree(self, mark_name=None): temp_points = [] real_points = [] distances = [] - if mark is None: + if mark_name is None: temp_points = self.points else: - temp_points = [i for i in self.points if self.points.mark is mark] + for i, point in self.points: + if point.mark is mark: + temp_points.append(point) for point in temp_points: real_points.append((point.x, point.y)) @@ -32,9 +37,6 @@ def average_nearest_neighbor_distance_kdtree(self, mark=None): return np.mean(distances) - def add_point(self, point): - self.points.append(point) - def remove_point(self, index): del(self.points[index]) diff --git a/requirements.txt b/requirements.txt index d110aa7..8836ba4 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,2 +1 @@ pysal -scipy diff --git a/utils.py b/utils.py index 70ce6d2..68468da 100644 --- a/utils.py +++ b/utils.py @@ -1,6 +1,6 @@ #utils import random -from . import point +import point def create_random_marked_points(n, marks=[]): rand = random.Random()