def test_large(self): try: import networkx as nx except ImportError: return try: GraphSet.converters['to_graph'] = nx.Graph GraphSet.converters['to_edges'] = nx.Graph.edges g = nx.grid_2d_graph(8, 8) v00, v01, v10 = (0, 0), (0, 1), (1, 0) GraphSet.set_universe(g) self.assertEqual(len(GraphSet.universe().edges()), 112) # self.assertEqual(GraphSet.universe().edges()[:2], [(v00, v01), (v00, v10)]) gs = GraphSet({}) gs -= GraphSet( [nx.Graph([(v00, v01)]), nx.Graph([(v00, v01), (v00, v10)])]) self.assertEqual(gs.len(), 5192296858534827628530496329220094) i = 0 for g in gs: if i > 100: break i += 1 paths = GraphSet.paths((0, 0), (7, 7)) self.assertEqual(len(paths), 789360053252) except: raise finally: GraphSet.converters['to_graph'] = lambda edges: edges GraphSet.converters['to_edges'] = lambda graph: graph
def capacity(self): gs = GraphSet() self.assertFalse(gs) gs = GraphSet([g0, g12, g13]) self.assertTrue(gs) self.assertEqual(len(gs), 3) self.assertEqual(gs.len(), 3)
def test_linear_constraints(self): GraphSet.set_universe([(1, 2), (1, 4), (2, 3), (2, 5), (3, 6), (4, 5), (5, 6)]) gs = GraphSet.graphs(linear_constraints=[([(2, 3)], (2, 1))]) self.assertEqual(gs, GraphSet()) gs = GraphSet.graphs(linear_constraints=[([], (1, 2))]) self.assertEqual(gs, GraphSet()) gs = GraphSet.graphs(linear_constraints=[([(5, 6, -1.5)], (-1.5, 0))]) self.assertEqual(gs, GraphSet.graphs()) gs = GraphSet.graphs(linear_constraints=[([(1, 2, 3.14)], (0, float("inf")))]) self.assertEqual(gs, GraphSet.graphs()) gs = GraphSet.graphs(linear_constraints=[(GraphSet.universe(), (0, float("inf")))]) self.assertEqual(gs, GraphSet.graphs()) gs = GraphSet.graphs(linear_constraints=[(GraphSet.universe(), (7, 7))]) self.assertEqual(gs, GraphSet([GraphSet.universe()])) gs = GraphSet.graphs(linear_constraints=[(GraphSet.universe(), (1, 7))]) self.assertEqual(gs, GraphSet.graphs() - GraphSet([[]])) gs = GraphSet.graphs( linear_constraints=[([(2, 3, -1), (2, 5, 10), (4, 1), (3, 6), (4, 5, -1), (5, 6)], (10, 100))]) self.assertEqual(len(gs), 52) gs = GraphSet.graphs( linear_constraints=[([(2, 3), (2, 5, -10), (4, 1, -1), (3, 6, -1), (4, 5), (5, 6, -1)], (-100, -10))]) self.assertEqual(len(gs), 52) gs = GraphSet.graphs(linear_constraints=[([(1, 2)], ( 1, 1)), ([(1, 4)], (1, 2)), ([(2, 3)], (1, 3)), ([(2, 5)], (1, 4)), ([(4, 5)], (1, 6)), ([(5, 6)], (1, 7))]) self.assertEqual(len(gs), 2)
def test_forests(self): try: universe = tl.grid(8, 8, 0.37) GraphSet.set_universe(universe) generators = [1, 9, 73, 81] forests = GraphSet.forests(roots=generators, is_spanning=True) self.assertEqual(len(forests), 54060425088) too_large_trees = GraphSet() for substation in generators: too_large_trees |= GraphSet.trees(root=substation).larger(23) safe_forests = forests.excluding(too_large_trees) self.assertEqual(len(safe_forests), 294859080) closed_switches = (forests - safe_forests).choice() scores = {} for switch in universe: scores[switch] = 1 if switch in closed_switches else -1 failures = safe_forests.blocking().minimal() self.assertEqual(len(failures), 1936) failure = failures.choice() for line in failure: safe_forests = safe_forests.excluding(line) self.assertEqual(len(safe_forests), 0) except ImportError: pass
def GetLocalConstraintsForRoot(self, file_prefix): then_vtree_filename = "%s/%s_then_vtree.vtree" % (file_prefix, self.name) then_sdd_filename = "%s/%s_then_sdd.sdd" % (file_prefix, self.name) constraint = {} constraint["then_vtree"] = then_vtree_filename constraint["then"] = [then_sdd_filename] universe = [] # internal edges for sub_region_edge_tup in self.sub_region_edges: universe.append(sub_region_edge_tup) GraphSet.set_universe(universe) universe = GraphSet.universe() paths = GraphSet() child_names = self.children.keys() for (i, j) in itertools.combinations(child_names, 2): paths = paths.union(GraphSet.paths(i, j)) name_to_sdd_index = {} zdd_to_sdd_index = [None] # for generating sdd from graphset sdd_index = 0 for child in child_names: sdd_index += 1 name_to_sdd_index["c%s" % child] = sdd_index for sub_region_edge in universe: corresponding_network_edges = self.sub_region_edges[ sub_region_edge] coresponding_network_edges_sdd_index = [] for single_edge in corresponding_network_edges: sdd_index += 1 name_to_sdd_index[str(single_edge)] = sdd_index coresponding_network_edges_sdd_index.append(sdd_index) zdd_to_sdd_index.append(coresponding_network_edges_sdd_index) constraint["then_variable_mapping"] = name_to_sdd_index rl_vtree = sdd.sdd_vtree_new(sdd_index, "right") sdd_manager = sdd.sdd_manager_new(rl_vtree) sdd.sdd_vtree_free(rl_vtree) sdd.sdd_manager_auto_gc_and_minimize_off(sdd_manager) # Construct simple path constraint simple_path_constraint = generate_sdd_from_graphset( paths, sdd_manager, zdd_to_sdd_index) # non empty path in this region map none_of_child = sdd.util.sdd_negative_term( sdd_manager, [name_to_sdd_index["c%s" % child] for child in self.children]) case_one = sdd.sdd_conjoin(none_of_child, simple_path_constraint, sdd_manager) # empty path in this region map exactly_one_child = sdd.util.sdd_exactly_one( sdd_manager, [name_to_sdd_index["c%s" % child] for child in self.children]) empty_path_constraint = sdd.util.sdd_negative_term( sdd_manager, sum(zdd_to_sdd_index[1:], [])) case_two = sdd.sdd_conjoin(exactly_one_child, empty_path_constraint, sdd_manager) total_constraint = sdd.sdd_disjoin(case_one, case_two, sdd_manager) sdd.sdd_save(then_sdd_filename, total_constraint) sdd.sdd_vtree_save(then_vtree_filename, sdd.sdd_manager_vtree(sdd_manager)) sdd.sdd_manager_free(sdd_manager) return constraint
def test_networkx(self): try: import networkx as nx except ImportError: return try: GraphSet.converters['to_graph'] = nx.Graph GraphSet.converters['to_edges'] = nx.Graph.edges g = nx.grid_2d_graph(3, 3) GraphSet.set_universe(g) g = GraphSet.universe() self.assertTrue(isinstance(g, nx.Graph)) self.assertEqual(len(g.edges()), 12) v00, v01, v10 = (0, 0), (0, 1), (1, 0) e1, e2 = (v00, v01), (v00, v10) gs = GraphSet([nx.Graph([e1])]) self.assertEqual(len(gs), 1) g = gs.pop() self.assertEqual(len(gs), 0) self.assertTrue(isinstance(g, nx.Graph)) self.assertTrue(g.edges() == [(v00, v01)] or g.edges() == [(v01, v00)]) gs.add(nx.Graph([e2])) self.assertEqual(len(gs), 1) except: raise finally: GraphSet.converters['to_graph'] = lambda edges: edges GraphSet.converters['to_edges'] = lambda graph: graph
def bidirectional_disjoint_paths(paths, path): """ パスのグラフセットから指定したパスの双方向link-disjoint pathを求める 双方向にリンクが共有されないようにする つまり(i,j), (j,v), (v,i)と共有されないパス集合が返る arguments: * paths(GraphSet) * path(list) returns: * di_paths(GraphSet) """ disjoint_elms = [] v_nodes = virtual_nodes() v_table = virtual_node_table() for e in path: if e[0] in v_nodes: i, j = v_table[e[0]] disjoint_elms += [[(i, j)], [(e[0], i)], [(j, e[0])]] elif e[1] in v_nodes: j, i = v_table[e[1]] disjoint_elms += [[(i, j)], [(e[1], i)], [(j, e[1])]] else: disjoint_elms.append([e]) i, j = e[0], e[1] v = virtual_node_expression(i, j) if v in v_nodes: disjoint_elms += [[(i, v)], [(v, j)]] else: v = virtual_node_expression(j, i) disjoint_elms += [[(i, v)], [(v, j)]] return paths.excluding(GraphSet(disjoint_elms))
def _enumerate_trees(self, root): gs = GraphSet() if self._satisfies_electric_constraints(root, set()): sur_switches = self._find_surrounding_switches(root, set()) gs = self._find_trees(set(), sur_switches) border_switches = self._find_border_switches(root) return gs | self._do_enumerate_trees(root, set(), border_switches)
def external_edges(node): """ nodeの流出リンクを返す arguments: * node(node label) returns: * external_edges(list) nodeの流出リンク """ in_edges = internal_edges(node) ex_edges = [ l for l in GraphSet({}).graph_size(1).including(node) - GraphSet(in_edges) ] return ex_edges
def test_io(self): gs = GraphSet() st = gs.dumps() self.assertEqual(st, "B\n.\n") gs = GraphSet.loads(st) self.assertEqual(gs, GraphSet()) gs = GraphSet([g0]) st = gs.dumps() self.assertEqual(st, "T\n.\n") gs = GraphSet.loads(st) self.assertEqual(gs, GraphSet([g0])) v = [g0, g1, g12, g123, g1234, g134, g14, g4] gs = GraphSet(v) st = gs.dumps() gs = GraphSet.loads(st) self.assertEqual(gs, GraphSet(v)) # skip this test, becasue string is treated as an element # gs = GraphSet(st) # self.assertEqual(gs, GraphSet(v)) f = tempfile.TemporaryFile() gs.dump(f) f.seek(0) gs = GraphSet.load(f) self.assertEqual(gs, GraphSet(v))
def test_lookup(self): gs1 = GraphSet([g1, g12]) self.assertTrue(g12 in gs1) self.assertTrue(g2 not in gs1) self.assertTrue(e1 in gs1) self.assertTrue(e4 not in gs1) self.assertTrue(1 in gs1) self.assertTrue(4 not in gs1)
def connected_edges(start_node, target_node, num_edges): """ start_nodeをパスのスタートノードとし、かつtarget_nodeを含まない 長さがnum_edgesのパスを含むグラフセットを返す パスが仮想ノードを2個以上通るときnum_edgesよりも短いパスもグラフセットに含まれてしまう arguments: * start_node(node label) * target_node(node label) * num_edges(int) パスの長さ returns: * di_path(GraphSet) 有向性を考慮したパスだけを含むグラフセット """ all_nodes = set(original_nodes()) | set(virtual_nodes()) v_nodes = virtual_nodes() degree_constraints = {} for node in all_nodes: if node in v_nodes: degree_constraints[node] = [0, 2] elif node == start_node: degree_constraints[node] = 1 elif node == target_node: degree_constraints[node] = 0 else: degree_constraints[node] = [0, 1, 2] elms = invalid_direction_elms(start_node, target_node) v_edges = virtual_node_edges() n_range = GraphSet.graphs(vertex_groups=[[start_node]], no_loop=True, num_edges=num_edges, degree_constraints=degree_constraints) n_inc_range = GraphSet.graphs(vertex_groups=[[start_node]], no_loop=True, num_edges=num_edges + 1, degree_constraints=degree_constraints) n_range = n_range.excluding(GraphSet(elms))\ .excluding(GraphSet(v_edges)) n_inc_range = n_inc_range.excluding(GraphSet(elms))\ .including(GraphSet(v_edges)) return n_range | n_inc_range
def test_constructors(self): gs = GraphSet() self.assertTrue(isinstance(gs, GraphSet)) self.assertEqual(len(gs), 0) gs = GraphSet([]) self.assertEqual(len(gs), 0) gs = GraphSet([g1, [(3, 1)]]) self.assertEqual(len(gs), 2) self.assertTrue(g1 in gs) self.assertTrue(g2 in gs) gs = GraphSet({}) self.assertEqual(len(gs), 2**4) gs = GraphSet({'include': [e1, e2], 'exclude': [(4, 3)]}) self.assertEqual(len(gs), 2) self.assertTrue(g12 in gs) self.assertTrue(g123 in gs) self.assertRaises(KeyError, GraphSet, [(1, 4)]) self.assertRaises(KeyError, GraphSet, [[(1, 4)]]) self.assertRaises(KeyError, GraphSet, {'include': [(1, 4)]}) # copy constructor gs1 = GraphSet([g0, g12, g13]) gs2 = gs1.copy() self.assertTrue(isinstance(gs2, GraphSet)) gs1.clear() self.assertEqual(gs1, GraphSet()) self.assertEqual(gs2, GraphSet([g0, g12, g13])) # repr gs = GraphSet([g0, g12, g13]) self.assertEqual(repr(gs), "GraphSet([[], [(1, 2), (1, 3)], [(1, 2), (2, 4)]])") gs = GraphSet({}) self.assertEqual( repr(gs), "GraphSet([[], [(1, 2)], [(1, 3)], [(2, 4)], [(3, 4)], [(1, 2), (1, 3)], [(1, ..." )
def disjoint_paths(paths, path): """ パスのグラフセットから指定したパスのlink-disjoint pathを求める arguments: * paths(GraphSet) * path(list) returns: * di_paths(GraphSet) """ disjoint_elms = [[e] for e in path] return paths.excluding(GraphSet(disjoint_elms))
def degree(node): """ nodeの字数を返す arguments: * node(node label) returns: * degree(int) nodeの次数 """ return len(GraphSet({}).including(node).graph_size(1))
def _do_enumerate_trees(self, root, closed_switches, fixed_switches): gs = GraphSet() sur_switches = self._find_surrounding_switches(root, closed_switches) unfixed_switches = sur_switches - fixed_switches if len(unfixed_switches) == 0: return gs s = sorted(unfixed_switches)[0] fixed_switches.add(s) gs |= self._do_enumerate_trees(root, closed_switches.copy(), fixed_switches.copy()) closed_switches.add(s) if self._satisfies_electric_constraints(root, closed_switches): sur_switches = self._find_surrounding_switches(root, closed_switches) gs |= self._find_trees(closed_switches, sur_switches) gs |= self._do_enumerate_trees(root, closed_switches.copy(), fixed_switches.copy()) return gs
def directed_paths(DiGraph, start_node, target_node): """ 有向性を考慮したパスだけを含むグラフセットを返す arguments: * DiGraph(networkx directed Graph object) * start_node(start node label) * target_node(target node label) returns: * di_paths(graphillion.GraphSet) 有向性を考慮したパスだけを含むグラフセット """ di_paths = GraphSet.paths(start_node, target_node) elms = invalid_direction_elms(DiGraph, start_node) di_paths = di_paths.excluding(GraphSet(elms)) return di_paths
def directed_paths(start_node, target_node): """ 有向性を考慮したパスだけを含むグラフセットを返す arguments: * start_node(node label) * target_node(node label) returns: * di_paths(GraphSet) 有効性を考慮したパスだけを含むグラフセット """ elms = invalid_direction_elms(start_node, target_node) elms = GraphSet(elms) di_paths = GraphSet.paths(start_node, target_node) di_paths = di_paths.excluding(elms) return di_paths
def test_forests(self): try: #universe = tl.grid(8, 8, 0.37) universe = [(1, 2), (1, 10), (2, 3), (2, 11), (3, 12), (4, 5), (5, 6), (5, 14), (6, 15), (7, 8), (8, 9), (8, 17), (9, 18), (10, 11), (11, 12), (11, 20), (13, 22), (14, 15), (14, 23), (16, 25), (17, 26), (18, 27), (19, 20), (19, 28), (20, 21), (21, 22), (21, 30), (22, 23), (22, 31), (23, 24), (24, 25), (25, 26), (26, 27), (26, 35), (27, 36), (28, 29), (28, 37), (29, 30), (29, 38), (30, 31), (31, 40), (32, 33), (32, 41), (33, 42), (34, 35), (37, 38), (37, 46), (38, 39), (40, 41), (41, 42), (41, 50), (42, 51), (43, 52), (44, 45), (45, 54), (46, 55), (47, 48), (47, 56), (48, 49), (49, 58), (50, 59), (51, 52), (51, 60), (52, 53), (53, 54), (53, 62), (55, 56), (56, 65), (57, 58), (57, 66), (59, 60), (59, 68), (61, 62), (61, 70), (62, 63), (64, 65), (64, 73), (65, 74), (66, 75), (67, 76), (68, 69), (69, 70), (69, 78), (70, 71), (70, 79), (71, 80), (72, 81), (74, 75), (75, 76), (76, 77), (80, 81)] GraphSet.set_universe(universe) generators = [1, 9, 73, 81] forests = GraphSet.forests(roots=generators, is_spanning=True) self.assertEqual(len(forests), 54060425088) too_large_trees = GraphSet() for substation in generators: too_large_trees |= GraphSet.trees(root=substation).larger(23) safe_forests = forests.excluding(too_large_trees) self.assertEqual(len(safe_forests), 294859080) closed_switches = (forests - safe_forests).choice() scores = {} for switch in universe: scores[switch] = 1 if switch in closed_switches else -1 failures = safe_forests.blocking().minimal() self.assertEqual(len(failures), 1936) failure = failures.choice() for line in failure: safe_forests = safe_forests.excluding(line) self.assertEqual(len(safe_forests), 0) except ImportError: pass
def test_probability(self): p = {e1: .9, e2: .8, e3: .7, e4: .6} gs = GraphSet() self.assertEqual(gs.probability(p), 0) gs = GraphSet([g0]) self.assertAlmostEqual(gs.probability(p), .0024) gs = GraphSet([g1]) self.assertAlmostEqual(gs.probability(p), .0216) gs = GraphSet([g2]) self.assertAlmostEqual(gs.probability(p), .0096) gs = GraphSet([g12, g13]) self.assertAlmostEqual(gs.probability(p), .1368) gs = GraphSet([g1234]) self.assertAlmostEqual(gs.probability(p), .3024) gs = GraphSet([g0, g1, g2, g12, g13, g1234]) self.assertAlmostEqual(gs.probability(p), .4728)
def GetLocalConstraintsForInternalClusters(self, file_prefix): if_vtree_filename = "%s/%s_if_vtree.vtree" % (file_prefix, self.name) if_sdd_filename_prefix = "%s/%s_if_sdd" % (file_prefix, self.name) then_vtree_filename = "%s/%s_then_vtree.vtree" % (file_prefix, self.name) then_sdd_filename_prefix = "%s/%s_then_sdd" % (file_prefix, self.name) ifs = [] thens = [] if_variable_mapping = {} if_sdd_index = 0 if_sdd_index += 1 if_variable_mapping[ "c%s" % self.name] = if_sdd_index # cluster indicator for current cluster for external_edge in self.external_edges: if_sdd_index += 1 if_variable_mapping[str(external_edge)] = if_sdd_index then_variable_mapping = {} # variables for the child clusters then_sdd_index = 0 zdd_to_sdd_index = [None] for child in self.children: then_sdd_index += 1 then_variable_mapping["c%s" % child] = then_sdd_index universe = self.sub_region_edges.keys() GraphSet.set_universe(universe) universe = GraphSet.universe() for node_pair in universe: correponding_sdd_indexes = [] for internal_edge in self.sub_region_edges[node_pair]: then_sdd_index += 1 then_variable_mapping[str(internal_edge)] = then_sdd_index correponding_sdd_indexes.append(then_sdd_index) zdd_to_sdd_index.append(correponding_sdd_indexes) if_vtree, then_vtree = sdd.sdd_vtree_new(if_sdd_index, "right"), sdd.sdd_vtree_new( then_sdd_index, "right") if_manager, then_manager = sdd.sdd_manager_new( if_vtree), sdd.sdd_manager_new(then_vtree) sdd.sdd_manager_auto_gc_and_minimize_off(if_manager) sdd.sdd_manager_auto_gc_and_minimize_off(then_manager) sdd.sdd_vtree_free(if_vtree) sdd.sdd_vtree_free(then_vtree) #none of the external edges are used and cluster indicator is off case_index = 0 case_one_if = sdd.util.sdd_negative_term(if_manager, range(1, if_sdd_index + 1)) case_one_then = sdd.util.sdd_negative_term( then_manager, range(1, then_sdd_index + 1)) sdd.sdd_save("%s_%s" % (if_sdd_filename_prefix, case_index), case_one_if) sdd.sdd_save("%s_%s" % (then_sdd_filename_prefix, case_index), case_one_then) ifs.append("%s_%s" % (if_sdd_filename_prefix, case_index)) thens.append("%s_%s" % (then_sdd_filename_prefix, case_index)) #none of the external edges are used and cluster indicator is on case_index += 1 case_two_if = sdd.util.sdd_exactly_one_among( if_manager, [if_variable_mapping["c%s" % self.name]], range(1, if_sdd_index + 1)) #***Non empty path in this region map none_of_child = sdd.util.sdd_negative_term( then_manager, [then_variable_mapping["c%s" % child] for child in self.children]) paths = GraphSet() child_names = self.children.keys() for c1, c2 in itertools.combinations(child_names, 2): paths = paths.union(GraphSet.paths(c1, c2)) simple_path_constraint = generate_sdd_from_graphset( paths, then_manager, zdd_to_sdd_index) case_one = sdd.sdd_conjoin(simple_path_constraint, none_of_child, then_manager) #***Empty path in the region map exactly_one_chlid = sdd.util.sdd_exactly_one( then_manager, [then_variable_mapping["c%s" % child] for child in self.children]) empty_path_constraint = sdd.util.sdd_negative_term( then_manager, sum(zdd_to_sdd_index[1:], [])) case_two = sdd.sdd_conjoin(empty_path_constraint, exactly_one_chlid, then_manager) case_two_then = sdd.sdd_disjoin(case_one, case_two, then_manager) sdd.sdd_save("%s_%s" % (if_sdd_filename_prefix, case_index), case_two_if) sdd.sdd_save("%s_%s" % (then_sdd_filename_prefix, case_index), case_two_then) ifs.append("%s_%s" % (if_sdd_filename_prefix, case_index)) thens.append("%s_%s" % (then_sdd_filename_prefix, case_index)) #Exactly one of the external edge is used and cluster_indicator is off aggregated_cases = {} for external_edge in self.external_edges: aggregated_cases.setdefault(self.external_edges[external_edge], []).append(external_edge) for entering_node in aggregated_cases: case_index += 1 cur_case_if = sdd.util.sdd_exactly_one_among( if_manager, [ if_variable_mapping[str(e)] for e in aggregated_cases[entering_node] ], range(1, if_sdd_index + 1)) paths = GraphSet() for child in self.children: if child == entering_node: continue paths = paths.union(GraphSet.paths(entering_node, child)) cur_case_then = generate_sdd_from_graphset(paths, then_manager, zdd_to_sdd_index) cur_case_then = sdd.sdd_disjoin( cur_case_then, sdd.util.sdd_negative_term(then_manager, [ then_variable_mapping[str(e)] for e in self.internal_edges ]), then_manager) #conjoin that all the child indicator is off cur_case_then = sdd.sdd_conjoin( cur_case_then, sdd.util.sdd_negative_term(then_manager, [ then_variable_mapping["c%s" % child] for child in self.children ]), then_manager) sdd.sdd_save("%s_%s" % (if_sdd_filename_prefix, case_index), cur_case_if) sdd.sdd_save("%s_%s" % (then_sdd_filename_prefix, case_index), cur_case_then) ifs.append("%s_%s" % (if_sdd_filename_prefix, case_index)) thens.append("%s_%s" % (then_sdd_filename_prefix, case_index)) #Exactly two of the external edge is used and cluster_indicator is off aggregated_cases = {} for (i, j) in itertools.combinations(self.external_edges.keys(), 2): entering_points = (self.external_edges[i], self.external_edges[j]) entering_points = (max(entering_points), min(entering_points)) aggregated_cases.setdefault(entering_points, []).append((i, j)) for entering_points in aggregated_cases: case_index += 1 entering_edges = aggregated_cases[entering_points] cur_case_if = generate_exactly_two_from_tuples( if_manager, [(if_variable_mapping[str(e1)], if_variable_mapping[str(e2)]) for (e1, e2) in entering_edges], range(1, if_sdd_index + 1)) if entering_points[0] == entering_points[1]: cur_case_then = sdd.util.sdd_negative_term( then_manager, range(1, then_sdd_index + 1)) else: paths = GraphSet.paths(entering_points[0], entering_points[1]) cur_case_then = generate_sdd_from_graphset( paths, then_manager, zdd_to_sdd_index) cur_case_then = sdd.sdd_conjoin( cur_case_then, sdd.util.sdd_negative_term(then_manager, [ then_variable_mapping["c%s" % child] for child in self.children ]), then_manager) sdd.sdd_save("%s_%s" % (if_sdd_filename_prefix, case_index), cur_case_if) sdd.sdd_save("%s_%s" % (then_sdd_filename_prefix, case_index), cur_case_then) ifs.append("%s_%s" % (if_sdd_filename_prefix, case_index)) thens.append("%s_%s" % (then_sdd_filename_prefix, case_index)) sdd.sdd_vtree_save(if_vtree_filename, sdd.sdd_manager_vtree(if_manager)) sdd.sdd_vtree_save(then_vtree_filename, sdd.sdd_manager_vtree(then_manager)) sdd.sdd_manager_free(if_manager) sdd.sdd_manager_free(then_manager) constraint = {} constraint["if_vtree"] = if_vtree_filename constraint["if"] = ifs constraint["if_variable_mapping"] = if_variable_mapping constraint["then_vtree"] = then_vtree_filename constraint["then"] = thens constraint["then_variable_mapping"] = then_variable_mapping return constraint
def test_modifiers(self): v = [g0, g12, g13] gs = GraphSet(v) gs.add(g1) self.assertTrue(g1 in gs) gs.remove(g1) self.assertTrue(g1 not in gs) self.assertRaises(KeyError, gs.remove, g1) gs.add(g0) gs.discard(g0) self.assertTrue(g0 not in gs) gs.discard(g0) # no exception raised gs = GraphSet(v) gs.add(e2) self.assertEqual(gs, GraphSet([g12, g123, g2])) gs = GraphSet(v) gs.remove(e2) self.assertEqual(gs, GraphSet([g0, g1, g13])) self.assertRaises(KeyError, gs.remove, e4) gs = GraphSet(v) gs.discard(e2) self.assertEqual(gs, GraphSet([g0, g1, g13])) gs.discard(e4) # no exception raised v = [g1, g12, g13] gs = GraphSet(v) g = gs.pop() self.assertTrue(isinstance(g, list)) self.assertTrue(g not in gs) self.assertEqual(gs | GraphSet([g]), GraphSet(v)) self.assertTrue(gs) gs.clear() self.assertFalse(gs) self.assertRaises(KeyError, gs.pop) self.assertRaises(KeyError, gs.add, [(1, 4)]) self.assertRaises(KeyError, gs.remove, [(1, 4)]) self.assertRaises(KeyError, gs.discard, [(1, 4)]) self.assertRaises(KeyError, gs.add, (1, 4)) self.assertRaises(KeyError, gs.remove, (1, 4)) self.assertRaises(KeyError, gs.discard, (1, 4)) u = [g0, g1, g12, g123, g1234, g134, g14, g4] gs = GraphSet(u) gs.flip(e1) self.assertEqual(gs, GraphSet([g0, g1, g14, g2, g23, g234, g34, g4]))
def _find_trees(self, closed_switches, open_switches): closed_switches = [self._to_edge(s) for s in closed_switches] open_switches = [self._to_edge(s) for s in open_switches] return GraphSet({'include': closed_switches, 'exclude': open_switches})
def test_iterators(self): gs1 = GraphSet([g0, g12, g13]) gs2 = GraphSet() for g in gs1: self.assertTrue(isinstance(g, list)) gs2 = gs2 | GraphSet([g]) self.assertEqual(gs1, GraphSet([g0, g12, g13])) self.assertEqual(gs1, gs2) gs2 = GraphSet() for g in gs1: self.assertTrue(isinstance(g, list)) gs2 = gs2 | GraphSet([g]) self.assertEqual(gs1, gs2) gs1 = GraphSet([g0, g12, g13]) gs2 = GraphSet() for g in gs1.rand_iter(): self.assertTrue(isinstance(g, list)) gs2 = gs2 | GraphSet([g]) self.assertEqual(gs1, gs2) gen = gs1.rand_iter() self.assertTrue(isinstance(gen.next(), list)) gs = GraphSet([g0, g1, g12, g123, g1234, g134, g14, g4]) r = [] for g in gs.max_iter(): self.assertTrue(isinstance(g, list)) r.append(g) self.assertEqual(len(r), 8) self.assertEqual(r[0], g14) self.assertEqual(r[1], g134) self.assertEqual(r[2], g4) r = [] for g in gs.max_iter({e1: -.3, e2: .2, e3: .2, e4: -.4}): self.assertTrue(isinstance(g, list)) r.append(g) self.assertEqual(len(r), 8) self.assertEqual(r[0], g123) self.assertEqual(r[1], g0) self.assertEqual(r[2], g12) r = [] for g in gs.min_iter(): self.assertTrue(isinstance(g, list)) r.append(g) self.assertEqual(len(r), 8) self.assertEqual(r[0], g123) self.assertEqual(r[1], g0) self.assertEqual(r[2], g12) r = [] for g in gs.min_iter({e1: -.3, e2: .2, e3: .2, e4: -.4}): self.assertTrue(isinstance(g, list)) r.append(g) self.assertEqual(len(r), 8) self.assertEqual(r[0], g14) self.assertEqual(r[1], g134) self.assertEqual(r[2], g4)
def test_binary_operators(self): u = [g0, g1, g12, g123, g1234, g134, g14, g4] v = [g12, g14, g23, g34] gs = GraphSet(u) | GraphSet(v) self.assertTrue(isinstance(gs, GraphSet)) self.assertEqual( gs, GraphSet([g0, g1, g12, g123, g1234, g134, g14, g23, g34, g4])) gs = GraphSet(u).union(GraphSet(u), GraphSet(v)) self.assertTrue(isinstance(gs, GraphSet)) self.assertEqual( gs, GraphSet([g0, g1, g12, g123, g1234, g134, g14, g23, g34, g4])) gs = GraphSet(u) gs |= GraphSet(v) self.assertTrue(isinstance(gs, GraphSet)) self.assertEqual( gs, GraphSet([g0, g1, g12, g123, g1234, g134, g14, g23, g34, g4])) gs = GraphSet(u) gs.update(GraphSet(u), GraphSet(v)) self.assertTrue(isinstance(gs, GraphSet)) self.assertEqual( gs, GraphSet([g0, g1, g12, g123, g1234, g134, g14, g23, g34, g4])) gs = GraphSet(u) & GraphSet(v) self.assertTrue(isinstance(gs, GraphSet)) self.assertEqual(gs, GraphSet([g12, g14])) gs = GraphSet(u).intersection(GraphSet(u), GraphSet(v)) self.assertTrue(isinstance(gs, GraphSet)) self.assertEqual(gs, GraphSet([g12, g14])) gs = GraphSet(u) gs &= GraphSet(v) self.assertTrue(isinstance(gs, GraphSet)) self.assertEqual(gs, GraphSet([g12, g14])) gs = GraphSet(u) gs.intersection_update(GraphSet(u), GraphSet(v)) self.assertTrue(isinstance(gs, GraphSet)) self.assertEqual(gs, GraphSet([g12, g14])) gs = GraphSet(u) - GraphSet(v) self.assertTrue(isinstance(gs, GraphSet)) self.assertEqual(gs, GraphSet([g0, g1, g123, g1234, g134, g4])) gs = GraphSet(u).difference(GraphSet(), GraphSet(v)) self.assertTrue(isinstance(gs, GraphSet)) self.assertEqual(gs, GraphSet([g0, g1, g123, g1234, g134, g4])) gs = GraphSet(u) gs -= GraphSet(v) self.assertTrue(isinstance(gs, GraphSet)) self.assertEqual(gs, GraphSet([g0, g1, g123, g1234, g134, g4])) gs = GraphSet(u) gs.difference_update(GraphSet(), GraphSet(v)) self.assertTrue(isinstance(gs, GraphSet)) self.assertEqual(gs, GraphSet([g0, g1, g123, g1234, g134, g4])) gs = GraphSet(u) ^ GraphSet(v) self.assertTrue(isinstance(gs, GraphSet)) self.assertEqual(gs, GraphSet([g0, g1, g123, g1234, g134, g23, g34, g4])) gs = GraphSet(u).symmetric_difference(GraphSet(), GraphSet(v)) self.assertTrue(isinstance(gs, GraphSet)) self.assertEqual(gs, GraphSet([g0, g1, g123, g1234, g134, g23, g34, g4])) gs = GraphSet(u) gs ^= GraphSet(v) self.assertTrue(isinstance(gs, GraphSet)) self.assertEqual(gs, GraphSet([g0, g1, g123, g1234, g134, g23, g34, g4])) gs = GraphSet(u) gs.symmetric_difference_update(GraphSet(), GraphSet(v)) self.assertTrue(isinstance(gs, GraphSet)) self.assertEqual(gs, GraphSet([g0, g1, g123, g1234, g134, g23, g34, g4])) # v = [g12] # gs = GraphSet(u) / GraphSet(v) # self.assertTrue(isinstance(gs, GraphSet)) # self.assertEqual(gs, GraphSet([g0, g3, g34])) # gs = GraphSet(u).quotient(GraphSet(v)) # self.assertTrue(isinstance(gs, GraphSet)) # self.assertEqual(gs, GraphSet([g0, g3, g34])) # gs = GraphSet(u) # gs /= GraphSet(v) # self.assertTrue(isinstance(gs, GraphSet)) # self.assertEqual(gs, GraphSet([g0, g3, g34])) # gs = GraphSet(u) # gs.quotient_update(GraphSet(v)) # self.assertTrue(isinstance(gs, GraphSet)) # self.assertEqual(gs, GraphSet([g0, g3, g34])) # gs = GraphSet(u) % GraphSet(v) # self.assertTrue(isinstance(gs, GraphSet)) # self.assertEqual(gs, GraphSet([g0, g1, g134, g14, g4])) # gs = GraphSet(u).remainder(GraphSet(v)) # self.assertTrue(isinstance(gs, GraphSet)) # self.assertEqual(gs, GraphSet([g0, g1, g134, g14, g4])) # gs = GraphSet(u) # gs %= GraphSet(v) # self.assertTrue(isinstance(gs, GraphSet)) # self.assertEqual(gs, GraphSet([g0, g1, g134, g14, g4])) # gs = GraphSet(u) # gs.remainder_update(GraphSet(v)) # self.assertTrue(isinstance(gs, GraphSet)) # self.assertEqual(gs, GraphSet([g0, g1, g134, g14, g4])) gs = GraphSet(u).complement() self.assertEqual(gs, GraphSet([g0, g123, g1234, g2, g23, g234, g34, g4])) # v = [g12, g14, g23, g34] # gs = GraphSet(u).join(GraphSet(v)) # self.assertTrue(isinstance(gs, GraphSet)) # self.assertEqual( # gs, GraphSet([g12, g123, g124, g1234, g134, g14, g23, g234, g34])) # gs = GraphSet(u).meet(GraphSet(v)) # self.assertTrue(isinstance(gs, GraphSet)) # self.assertEqual(gs, GraphSet([g0, g1, g12, g14, g2, g23, g3, g34, g4])) # v = [g12, g14, g23, g34] # gs = GraphSet(u).subgraphs(GraphSet(v)) # self.assertTrue(isinstance(gs, GraphSet)) # self.assertEqual(gs, GraphSet([g0, g1, g12, g14, g4])) # gs = GraphSet(u).supergraphs(GraphSet(v)) # self.assertTrue(isinstance(gs, GraphSet)) # self.assertEqual(gs, GraphSet([g12, g123, g1234, g134, g14])) # gs = GraphSet(u).non_subgraphs(GraphSet(v)) # self.assertTrue(isinstance(gs, GraphSet)) # self.assertEqual(gs, GraphSet([g123, g1234, g134])) # gs = GraphSet(u).non_supergraphs(GraphSet(v)) # self.assertTrue(isinstance(gs, GraphSet)) # self.assertEqual(gs, GraphSet([g0, g1, g4])) gs1 = GraphSet({}) - GraphSet([g1, g34]) gs2 = gs1.including(GraphSet([g1, g2])) self.assertTrue(isinstance(gs2, GraphSet)) self.assertEqual(len(gs2), 11) gs2 = gs1.including(g1) self.assertTrue(isinstance(gs2, GraphSet)) self.assertEqual(len(gs2), 7) gs2 = gs1.including((2, 1)) self.assertTrue(isinstance(gs2, GraphSet)) self.assertEqual(len(gs2), 7) gs2 = gs1.including(1) self.assertTrue(isinstance(gs2, GraphSet)) self.assertEqual(len(gs2), 11) self.assertRaises(KeyError, gs1.including, (1, 4)) self.assertRaises(KeyError, gs1.including, 5) gs2 = gs1.excluding(GraphSet([g1, g2])) self.assertTrue(isinstance(gs2, GraphSet)) self.assertEqual(len(gs2), 3) gs2 = gs1.excluding(g1) self.assertTrue(isinstance(gs2, GraphSet)) self.assertEqual(len(gs2), 7) gs2 = gs1.excluding(e2) self.assertTrue(isinstance(gs2, GraphSet)) self.assertEqual(len(gs2), 6) gs2 = gs1.excluding(1) self.assertTrue(isinstance(gs2, GraphSet)) self.assertEqual(len(gs2), 3) self.assertRaises(KeyError, gs1.excluding, (1, 4)) self.assertRaises(KeyError, gs1.excluding, 5) v = [g12, g14, g23, g34] gs = GraphSet(u).included(GraphSet(v)) self.assertTrue(isinstance(gs, GraphSet)) self.assertEqual(gs, GraphSet([g0, g1, g12, g14, g4])) gs = GraphSet(u).included(g12) self.assertTrue(isinstance(gs, GraphSet)) self.assertEqual(gs, GraphSet([g0, g1, g12]))
# file.close() I_max = 20 C_max = 50 #-------------Optimization-mf------------------ tl_mf = [] R_min_mf = np.inf w_opt_mf = copy.deepcopy(weights) tl_so = [] R_min_so = np.inf w_opt_so = copy.deepcopy(weights) #-----Set F_mf in PSO-M and non-failure case in SO----- cand_mf = GraphSet() cand_so = GraphSet() #Setting for F_mf for i in range(0, f): cand_mf.update(gc.len(E - i)) cand_select = gc.len(E - f) for cnt in range(0, m_np): rand_graph = next(cand_select.rand_iter()) cand_mf.add(rand_graph) cand_select.remove(rand_graph) #Setting non-failure set cand_so = GraphSet() cand_so.update(gc.len(E)) # for i in cand_so:
problem_spec_file = sys.argv[1] with open(problem_spec_file, "r") as fp: problem_spec = json.load(fp) edge_list = problem_spec["graph"] terminal_nodes = problem_spec["terminal_nodes"] non_terminal_nodes = problem_spec["non_terminal_nodes"] universe = ConvertEdgesToUniverse(edge_list) GraphSet.set_universe(universe) universe = GraphSet.universe() nodes = NodesInEdges(edge_list) terminal_path = {} non_terminal_path = {} path_cache = {} for i, j in itertools.combinations(nodes, 2): path_cache[(min(i, j), max(i, j))] = GraphSet.paths(i, j) internal_path = GraphSet() for path in path_cache.values(): internal_path = internal_path.union(path) for node in terminal_nodes: cur_path = GraphSet() for other_node in nodes: if other_node == node: continue node_key = (min(node, other_node), max(node, other_node)) cur_path = cur_path.union(path_cache[node_key]) terminal_path[node] = cur_path result = {} result["internal_path"] = DumpToStr(internal_path) for node in terminal_nodes: result["terminal_%s" % node] = DumpToStr(terminal_path[node]) for node_pair in non_terminal_nodes:
def test_unary_operators(self): gs = GraphSet([g0, g1, g12, g123, g1234, g134, g14, g4]) self.assertTrue(isinstance(~gs, GraphSet)) self.assertEqual(~gs, GraphSet([g124, g13, g2, g23, g234, g24, g3, g34])) self.assertTrue(isinstance(gs.smaller(3), GraphSet)) self.assertEqual(gs.smaller(3), GraphSet([g0, g1, g12, g14, g4])) self.assertTrue(isinstance(gs.larger(3), GraphSet)) self.assertEqual(gs.larger(3), GraphSet([g1234])) self.assertTrue(isinstance(gs.graph_size(3), GraphSet)) self.assertEqual(gs.graph_size(3), GraphSet([g123, g134])) self.assertTrue(isinstance(gs.len(3), GraphSet)) self.assertEqual(gs.len(3), GraphSet([g123, g134])) gs = GraphSet([g12, g123, g234]) self.assertTrue(isinstance(gs.minimal(), GraphSet)) self.assertEqual(gs.minimal(), GraphSet([g12, g234])) self.assertTrue(isinstance(gs.maximal(), GraphSet)) self.assertEqual(gs.maximal(), GraphSet([g123, g234])) gs = GraphSet([g12, g14, g23, g34]) self.assertTrue(isinstance(gs.blocking(), GraphSet)) self.assertEqual(gs.blocking(), GraphSet([g123, g1234, g124, g13, g134, g234, g24]))
print(tr) print('\n') #---------Setting failure patterns--------------- f = calc_f(nk) m_np = calc_mnp(nk, f) print("f = ", f, " m = ", m_np) # file = open('output.txt','a') # file.write("p ={0}, eps = {1}, f = {2}, m = {3} \n".format(p, eps, f, m_np)) # file.close() tl = [] R_min_global = np.inf for itr_cand in range(1): cand_list = GraphSet() #故障しないものはcand_listへ for i in range(0, 1): cand_list.update(gc.len(E - i)) #print(cand_list.len()) # #f本故障はm_npの数だけ抽出(ひとまずランダムに) # cand_select = gc.len(E-f) # #print(cand_select.len()) # for cnt in range(0,m_np): # rand_graph = next(cand_select.rand_iter()) # cand_list.add(rand_graph) # cand_select.remove(rand_graph) print("total {0} patterns to consider".format(cand_list.len()))
def test_comparison(self): gs = GraphSet([g12]) self.assertEqual(gs, GraphSet([g12])) self.assertNotEqual(gs, GraphSet([g13])) # __nonzero__ self.assertTrue(gs) self.assertFalse(GraphSet()) v = [g0, g12, g13] gs = GraphSet(v) self.assertTrue(gs.isdisjoint(GraphSet([g1, g123]))) self.assertFalse(gs.isdisjoint(GraphSet([g1, g12]))) self.assertTrue(gs.issubset(GraphSet(v))) self.assertFalse(gs.issubset(GraphSet([g0, g12]))) self.assertTrue(gs <= GraphSet(v)) self.assertFalse(gs <= GraphSet([g0, g12])) self.assertTrue(gs < GraphSet([g0, g1, g12, g13])) self.assertFalse(gs < GraphSet(v)) self.assertTrue(gs.issuperset(GraphSet(v))) self.assertFalse(gs.issuperset(GraphSet([g1, g12]))) self.assertTrue(gs >= GraphSet(v)) self.assertFalse(gs >= GraphSet([g1, g12])) self.assertTrue(gs > GraphSet([[], g12])) self.assertFalse(gs > GraphSet(v))