first commit

test/calculators/subarray_graph_test.py

@@ -0,0 +1,78 @@
+import copy
+from time import clock
+import unittest
+from nose.tools import eq_
+from helix.calculators.subarray_graph import SubarrayGraph
+from test.fixtures.sample_arrays import *
+from helix.constants.system_type import SystemType
+
+
+class SubarrayGraphTest(unittest.TestCase):
+    def test_find_disconnected_subgraphs(self):
+        copy_dumbell_no_wind_anchors = copy.deepcopy(dumbell_no_wind_anchors)
+        graph = SubarrayGraph(copy_dumbell_no_wind_anchors, SystemType.singleTilt)
+
+        graph.pop_rung()
+        subgraphs = graph.find_disconnected_subgraphs()
+
+        eq_(len(subgraphs), 2)
+        eq_(len(subgraphs[0]), 4)
+        eq_(len(subgraphs[1]), 4)
+
+    def test_find_disconnected_subgraphs_more_complicated(self):
+        copy_odd_shape_no_wind_anchors = copy.deepcopy(odd_shape_no_wind_anchors)
+        graph = SubarrayGraph(copy_odd_shape_no_wind_anchors, SystemType.singleTilt)
+
+        graph.pop_rung()
+        subgraphs = graph.find_disconnected_subgraphs()
+
+        eq_(len(subgraphs), 3)
+        eq_(len(subgraphs[0]), 4)
+        eq_(len(subgraphs[1]), 8)
+        eq_(len(subgraphs[2]), 1)
+
+    def test_find_node(self):
+        copy_odd_shape_no_wind_anchors = copy.deepcopy(odd_shape_no_wind_anchors)
+        graph = SubarrayGraph(copy_odd_shape_no_wind_anchors, SystemType.singleTilt)
+
+        eq_(graph.find_node(Coordinate(-1, -1)), None)
+
+        lower_left_node = self.naive_find_node(graph, Coordinate(0, 0))
+        eq_(graph.find_node(Coordinate(0, 0)), lower_left_node)
+
+        middle_ish_node = self.naive_find_node(graph, Coordinate(2, 7))
+        eq_(graph.find_node(Coordinate(2, 7)), middle_ish_node)
+
+    # def test_find_node_performance(self):
+    #     copy_odd_shape_no_wind_anchors = copy.deepcopy(odd_shape_no_wind_anchors)
+    #     graph = SubarrayGraph(copy_odd_shape_no_wind_anchors, SystemType.singleTilt)
+    #
+    #     iteration_count = 100
+    #
+    #     invalid_base = self.check_performance(lambda: self.naive_find_node(graph, Coordinate(-1, -1)), iteration_count)
+    #     lower_left_base = self.check_performance(lambda: self.naive_find_node(graph, Coordinate(0, 0)), iteration_count)
+    #     middle_ish_base = self.check_performance(lambda: self.naive_find_node(graph, Coordinate(2, 7)), iteration_count)
+    #
+    #     invalid_test = self.check_performance(lambda: graph.find_node(Coordinate(-1, -1)), iteration_count)
+    #     lower_left_test = self.check_performance(lambda: graph.find_node(Coordinate(0, 0)), iteration_count)
+    #     middle_ish_test = self.check_performance(lambda: graph.find_node(Coordinate(2, 7)), iteration_count)
+    #
+    #     print("Invalid coordinate: %f base, %f actual" % (invalid_base, invalid_test))
+    #     print("0, 0 coordinate: %f base, %f actual" % (lower_left_base, lower_left_test))
+    #     print("2, 7 coordinate: %f base, %f actual" % (middle_ish_base, middle_ish_test))
+    #
+    #     assert invalid_test < (invalid_base / 10), "Expected invalid coordinate to almost no-op, didn't"
+    #     assert lower_left_test < lower_left_base, "Expected 0, 0 coordinate to be better than naive approach"
+    #     assert middle_ish_base < middle_ish_test, "Expected 2, 7 coordinate to be better than naive approach"
+
+    def naive_find_node(self, graph, coordinate):
+        for node in graph.nodes:
+            if node.location == coordinate:
+                return node
+
+    def check_performance(self, function, iterations):
+        start = clock()
+        for _ in range(iterations):
+            function()
+        end = clock()
+        return (end - start) / iterations