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のパスを含むグラフセットを返す
パスが仮想ノードを２個以上通るとき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))
