def test_dimension(self): """ Change the dimension of a layout. """ dim = random.randint(3, 10) # Pass in dim as an argument layout_pre = mml.Layout(self.S, dim=dim) self.assertEqual(layout_pre.dim, dim) self.assertIsLayout(self.S, layout_pre) # Change the layout to have the dim layout_post = mml.Layout(self.S) layout_post.dim = dim self.assertEqual(layout_post.dim, dim) self.assertIsLayout(self.S, layout_post) # Change the dimension without changing the object, layout = mml.Layout(self.S, dim=2) new_layout_array = _dimension_layout(layout.layout_array, dim) self.assertEqual(layout.dim, 2) # The layout_arrays changed after the fact should match each other self.assertArrayEqual(new_layout_array, layout_post.layout_array) # Test dimension too small layout = mml.Layout(self.S, dim=2) self.assertRaises(ValueError, _dimension_layout, layout.layout_array, 1)
def test_pnorm(self): """ Test the p_norm layout algorithm. """ # Some specs to test with low_dim = random.randint(3, 9) high_dim = len(self.S_small) center = low_dim * (1, ) scale = random.random() * random.randint(1, 10) # Default behavior mml.p_norm(self.S_small) # Using a starting_layout mml.p_norm(self.S_small, starting_layout=nx.random_layout(self.S_small)) # Passing in G_distances mml.p_norm(self.S_small, G_distances=nx.all_pairs_shortest_path_length(self.S_small)) # Passing in dim mml.p_norm(self.S_small, dim=low_dim) mml.p_norm(self.S_small, dim=high_dim) # Passing in center mml.p_norm(self.S_small, center=center) # Passing in scale mml.p_norm(self.S_small, scale=scale) # Different p-norms mml.p_norm(self.S_small, p=1) mml.p_norm(self.S_small, p=3) mml.p_norm(self.S_small, p=float("inf")) # Test through the Layout object layout = mml.Layout(self.S_small, mml.p_norm, dim=low_dim, center=center, scale=scale) self.assertArrayEqual(layout.center, center) self.assertAlmostEqual(layout.scale, scale) # Ensure that the rectangle packer works # TODO fix p_norm's issues with disconnected graphs layout = mml.Layout(self.S_components, mml.p_norm, dim=2, center=[12, 20], scale=scale) self.assertArrayEqual(layout.center, [12, 20]) self.assertAlmostEqual(layout.scale, scale)
def test_silly_graphs(self): """ Make sure things don't break for trivial graphs. """ # Empty graph layout = mml.Layout(self.G) self.assertIsLayout(self.G, layout) # Single vertex graph layout = mml.Layout(self.H) self.assertIsLayout(self.H, layout)
def test_layout_functions(self): """ Functions can be passed in to Layout objects. """ # Circular layout = mml.Layout(self.S, nx.circular_layout) self.assertIsLayout(self.S, layout) # Random layout = mml.Layout(self.S, nx.random_layout) self.assertIsLayout(self.S, layout)
def test_layout_functions(self): """ Functions can be passed in to Layout objects. """ # Circular layout = mml.Layout(self.S, nx.circular_layout) self.assertIsLayout(self.S, layout) # Random -- nx.random_layout doesn't accept a "scale" parameter, so we # need to disable component packing layout = mml.Layout(self.S, nx.random_layout, pack_components=False) self.assertIsLayout(self.S, layout)
def test_scale_ratio(self): """ Make sure filling works correctly. """ # Make C_layout bigger than S_layout S_layout = mml.Layout(self.S, scale=1) C_layout = mml.Layout(self.C, scale=10) # Have S_layout scale to various ratios placement = mml.Placement(S_layout, C_layout, scale_ratio=1) self.assertAlmostEqual(placement.S_layout.scale, 10) placement = mml.Placement(S_layout, C_layout, scale_ratio=.5) self.assertAlmostEqual(placement.S_layout.scale, 5)
def __init__(self, *args, **kwargs): super(TestLayoutPlacement, self).__init__(*args, **kwargs) # Graphs for testing self.S = nx.random_regular_graph(3, 50) self.S_small = nx.random_regular_graph(3, 10) self.G = nx.Graph() self.H = nx.complete_graph(1) self.C = dnx.chimera_graph(4) self.P = dnx.pegasus_graph(4) # Compute some layouts self.S_layout = mml.Layout(self.S) self.S_small_layout = mml.Layout(self.S_small) self.G_layout = mml.Layout(self.G) self.C_layout = mml.Layout(self.C) self.C_layout_3 = mml.Layout(self.C, dim=3)
def test_precomputed_layout(self): """ Pass in a precomputed layout to the Layout class. """ # Pick an arbitrary layout to precompute layout = nx.random_layout(self.S) # Initialize the layout object layout_obj = mml.Layout(self.S, layout) self.assertLayoutEqual(self.S, layout, layout_obj) self.assertIsLayout(self.S, layout_obj)
def test_intersection(self): """ Tests the intersection placement strategy. """ # Default behavior S_layout = mml.Layout(self.S) placement = mml.intersection(S_layout, self.C_layout) self.assertIsPlacement(self.S, self.C, placement) # Test different scale ratios placement_1 = mml.intersection(S_layout, self.C_layout, scale_ratio=.5) placement_2 = mml.intersection(S_layout, self.C_layout, scale_ratio=1) placement_3 = mml.intersection(S_layout, self.C_layout, scale_ratio=1.5) self.assertIsPlacement(self.S, self.C, placement_1) self.assertIsPlacement(self.S, self.C, placement_2) self.assertIsPlacement(self.S, self.C, placement_3) # Test a coordinate variations of chimera placement = mml.intersection(S_layout, self.C_coord_layout) self.assertIsPlacement(self.S, self.C_coord, placement) placement = mml.intersection(S_layout, self.C_blank_layout) self.assertIsPlacement(self.S, self.C_blank, placement) # Test coordinate variations of pegasus placement = mml.intersection(S_layout, self.P_coord_layout) self.assertIsPlacement(self.S, self.P_coord, placement) placement = mml.intersection(S_layout, self.P_layout) self.assertIsPlacement(self.S, self.P, placement) placement = mml.intersection(S_layout, self.P_nice_layout) self.assertIsPlacement(self.S, self.P_nice, placement) placement = mml.intersection(S_layout, self.P_nice_layout) self.assertIsPlacement(self.S, self.P_nice, placement) placement = mml.intersection(S_layout, self.P_blank_layout) self.assertIsPlacement(self.S, self.P_blank, placement) # Test coordinate variations of zephyr placement = mml.intersection(S_layout, self.Z_coord_layout) self.assertIsPlacement(self.S, self.Z_coord, placement) placement = mml.intersection(S_layout, self.Z_layout) self.assertIsPlacement(self.S, self.Z, placement) placement = mml.intersection(S_layout, self.Z_blank_layout) self.assertIsPlacement(self.S, self.Z_blank, placement)
def test_intersection(self): """ Tests the intersection placement strategy. """ # Default behavior S_layout = mml.Layout(self.S) placement = mml.intersection(S_layout, self.C_layout) self.assertIsPlacement(self.S, self.C, placement) # Test different scale ratios S_layout = mml.Layout(self.S) placement_1 = mml.intersection(S_layout, self.C_layout, scale_ratio=.5) S_layout = mml.Layout(self.S) placement_2 = mml.intersection(S_layout, self.C_layout, scale_ratio=1) S_layout = mml.Layout(self.S) placement_3 = mml.intersection(S_layout, self.C_layout, scale_ratio=1.5) self.assertIsPlacement(self.S, self.C, placement_1) self.assertIsPlacement(self.S, self.C, placement_2) self.assertIsPlacement(self.S, self.C, placement_3) # Test a coordinate version of chimera S_layout = mml.Layout(self.S) placement = mml.intersection(S_layout, self.C_coord_layout) self.assertIsPlacement(self.S, self.C_coord, placement) # Test bad inputs # Pegasus is not allowed self.assertRaises(NotImplementedError, mml.intersection, self.S_layout, self.P_layout) # Chimera must have data or coordinates self.assertRaises(NotImplementedError, mml.intersection, self.S_layout, self.C_blank_layout) # Pegasus coordinates not implemented self.assertRaises(NotImplementedError, _lookup_intersection_coordinates, self.P)
def test_scale(self): """ Rescale a layout. """ scale = random.random() * random.randint(1, 10) # Pass in scale as an argument layout_pre = mml.Layout(self.S, scale=scale) self.assertAlmostEqual(layout_pre.scale, scale) # Change the layout to have the scale layout_post = mml.Layout(self.S) layout_post.scale = scale self.assertAlmostEqual(layout_post.scale, scale) # Change the scale without changing the object, layout = mml.Layout(self.S, scale=1) new_layout_array = _scale_layout(layout.layout_array, scale) self.assertAlmostEqual(layout.scale, 1) # The layouts should match each other self.assertLayoutEqual(self.S, layout_pre, layout_post) self.assertIsLayout(self.S, layout_pre) self.assertArrayEqual(new_layout_array, layout_pre.layout_array)
def test_center(self): """ Recenter a layout. """ center = (random.randint(-10, 10), random.randint(-10, 10)) # Pass in center as an argument layout_pre = mml.Layout(self.S, center=center) self.assertArrayEqual(layout_pre.center, center) # Change the layout to have the center layout_post = mml.Layout(self.S) layout_post.center = center self.assertArrayEqual(layout_post.center, center) # Change the center without changing the object, layout = mml.Layout(self.S, center=(0, 0)) new_layout_array = _center_layout(layout.layout_array, center) self.assertArrayEqual(layout.center, (0, 0)) # The layouts should match each other self.assertLayoutEqual(self.S, layout_pre, layout_post) self.assertIsLayout(self.S, layout_pre) self.assertArrayEqual(new_layout_array, layout_pre.layout_array)
def test_dnx(self): """ Test the dnx layout. """ # Some specs to test with dim = random.randint(3, 9) center = dim * (1, ) scale = random.random() * random.randint(1, 10) # Default behavior # Chimera mml.dnx_layout(self.C) # Pegasus mml.dnx_layout(self.P) # Zephyr mml.dnx_layout(self.Z) # Passing in dim mml.dnx_layout(self.C, dim=dim) # Passing in center mml.dnx_layout(self.C, center=center) # Passing in scale mml.dnx_layout(self.C, scale=scale) # Test through the Layout object layout = mml.Layout(self.C, mml.dnx_layout, dim=dim, center=center, scale=scale) self.assertArrayEqual(layout.center, center) self.assertAlmostEqual(layout.scale, scale) # Test non-dnx_graph self.assertRaises(ValueError, mml.dnx_layout, self.S) # Test dim and center mismatch self.assertRaises(ValueError, mml.dnx_layout, self.C, dim=3, center=(0, 0))
def test_layout_class(self): """ Test the layout mutable mapping behavior. """ L = mml.Layout(nx.Graph()) # Test __setitem__ L['a'] = 1 # Test __iter__ and __getitem__ for k, v in L.items(): self.assertEqual(k, 'a') self.assertEqual(v, 1) # Test __len__ self.assertEqual(len(L), 1) # Test __del__ del L['a'] # Test __repr__ self.assertEqual(repr(L), "{}")
def __init__(self, *args, **kwargs): super(TestLayoutPlacement, self).__init__(*args, **kwargs) # Graphs for testing self.S = nx.random_regular_graph(3, 50) self.S_small = nx.random_regular_graph(3, 10) self.S_components = nx.Graph([(2*i, 2*i+1) for i in range(10)]) self.G = nx.Graph() self.H = nx.complete_graph(1) self.C = dnx.chimera_graph(4) self.C_coord = dnx.chimera_graph(4, coordinates=True) self.C_blank = dnx.chimera_graph(4, data=False) self.P = dnx.pegasus_graph(4) self.P_coord = dnx.pegasus_graph(4, coordinates=True) self.P_nice = dnx.pegasus_graph(4, nice_coordinates=True) self.P_blank = dnx.pegasus_graph(4, data=False) self.Z = dnx.zephyr_graph(4) self.Z_coord = dnx.zephyr_graph(4, coordinates=True) self.Z_blank = dnx.pegasus_graph(4, data=False) # Compute some layouts self.S_layout = mml.Layout(self.S) self.S_small_layout = mml.Layout(self.S_small) self.S_components_layout = mml.Layout(self.S_small) self.G_layout = mml.Layout(self.G) self.C_layout = mml.Layout(self.C) self.C_coord_layout = mml.Layout(self.C_coord) self.C_blank_layout = mml.Layout(self.C_blank) self.C_layout_3 = mml.Layout(self.C, dim=3) self.P_layout = mml.Layout(self.P) self.P_coord_layout = mml.Layout(self.P_coord) self.P_nice_layout = mml.Layout(self.P_nice) self.P_blank_layout = mml.Layout(self.P_blank) self.Z_layout = mml.Layout(self.Z) self.Z_coord_layout = mml.Layout(self.Z_coord) self.Z_blank_layout = mml.Layout(self.Z_blank)
def test_edge_input(self): """ Layouts can be computed with edges instead of graph objects. """ layout = mml.Layout(self.S.edges) self.assertIsLayout(self.S, layout)