def test_init(self):
GraphSet.set_universe([('i', 'ii')])
self.assertEqual(GraphSet.universe(), [('i', 'ii')])
GraphSet.set_universe(
[e1 + (.3, ), e2 + (-.2, ), e3 + (-.2, ), e4 + (.4, )],
traversal='bfs',
source=1)
self.assertEqual(
GraphSet.universe(),
[e1 + (.3, ), e2 + (-.2, ), e3 + (-.2, ), e4 + (.4, )])
GraphSet.set_universe(
[e1 + (.3, ), e2 + (-.2, ), e3 + (-.2, ), e4 + (.4, )],
traversal='dfs',
source=1)
self.assertEqual(
GraphSet.universe(),
[e2 + (-.2, ), e4 + (.4, ), e1 + (.3, ), e3 + (-.2, )])
GraphSet.set_universe(
[e1 + (.3, ), e2 + (-.2, ), e3 + (-.2, ), e4 + (.4, )],
traversal='greedy',
source=3)
self.assertEqual(
GraphSet.universe(),
[e2 + (-.2, ), e1 + (.3, ), e3 + (-.2, ), e4 + (.4, )])
self.assertRaises(KeyError, GraphSet.set_universe, [(1, 2), (2, 1)])
GraphSet.set_universe([(1, 2), (3, 4)]) # disconnected graph
self.assertEqual(GraphSet.universe(), [(1, 2), (3, 4)])
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_init(self):
GraphSet.set_universe([('i', 'ii')])
self.assertEqual(GraphSet.universe(), [('i', 'ii')])
GraphSet.set_universe([e1 + (.3,), e2 + (-.2,), e3 + (-.2,), e4 + (.4,)])
self.assertEqual(GraphSet.universe(),
[e1 + (.3,), e2 + (-.2,), e3 + (-.2,), e4 + (.4,)])
GraphSet.set_universe([e1 + (.3,), e2 + (-.2,), e3 + (-.2,), e4 + (.4,)],
traversal='dfs', source=1)
self.assertEqual(GraphSet.universe(),
[e2 + (-.2,), e4 + (.4,), e1 + (.3,), e3 + (-.2,)])
self.assertRaises(KeyError, GraphSet.set_universe, [(1,2), (2,1)])
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 draw_subgraph(subgraph=None, universe=None):
if not universe:
universe = GraphSet.universe()
g = nx.Graph(sorted(universe))
if not subgraph:
subgraph = set([])
else:
subgraph = set(subgraph)
pos = _graph2nx_layout(g)
nx.draw_networkx_nodes(g, pos, node_color='#FFFFFF', edgecolors='#000000')
edge_weights = []
edge_colors = []
for edge in g.edges():
if edge in subgraph or (edge[1], edge[0]) in subgraph:
edge_weights.append(5)
edge_colors.append('#FF0000')
else:
edge_weights.append(1)
edge_colors.append('#000000')
nx.draw_networkx_labels(g, pos)
nx.draw_networkx_edges(g, pos, edge_color=edge_colors, width=edge_weights)
plt.show()
def graph(self, g, wtd=None, n=None, universe=None):
if not isinstance(g, nx.Graph):
g = nx.Graph(list(g))
if n is None:
n = len(g)
if universe is None:
universe = GraphSet.universe()
if not isinstance(universe, nx.Graph):
universe = nx.Graph(list(universe))
#ここまでで (g, universe) ともにnx.graphが定まった．
m = n - 1
pos = {}
#position: optional {'vartex':(x, y)}
pos[0] = (-1, 0)
for v in range(1, m**2):
pos[v] = ((v - 1) // m, (v - 1) % m)
nx.draw(g, pos)
if wtd is None:
pass
else:
label = {}
for s in g.edges():
t = tuple(sorted(s)) # 辺が逆順で入力されてもソートできる
label[t] = wtd[t]
nx.draw_networkx_edge_labels(g, pos, edge_labels=label)
plt.show()
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 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 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 all_paths(dimension,dim):
from graphillion import GraphSet
import graphillion.tutorial as tl
start,goal = 1,(dimension[0]+1)*(dimension[1]+1)
universe = tl.grid(*dimension)
GraphSet.set_universe(universe)
paths = GraphSet()
for i in range(start,goal):
for j in range(i+1,goal+1):
paths = GraphSet.union(paths,GraphSet.paths(i,j))
f = open("graphs/general_ends-%d-%d.zdd" % (dim[0],dim[1]),"w")
paths.dump(f)
f.close()
nodes = [None] + [ (x,y) for x in xrange(dim[0]) for y in xrange(dim[1]) ]
from collections import defaultdict
graph = defaultdict(list)
for index,edge in enumerate(paths.universe()):
x,y = edge
x,y = nodes[x],nodes[y]
graph[x].append( (index+1,y) )
graph[y].append( (index+1,x) )
graph_filename = "graphs/general_ends-%d-%d.graph.pickle" % (dim[0],dim[1])
with open(graph_filename,'wb') as output:
pickle.dump(graph,output)
def test_networkx(self):
try:
import networkx as nx
except ImportError:
return
try:
if nx.__version__[0] == "1": # for NetworkX version 1.x
GraphSet.converters['to_graph'] = nx.Graph
GraphSet.converters['to_edges'] = nx.Graph.edges
else: # for NetworkX version 2.x
GraphSet.converters['to_graph'] = nx.from_edgelist
GraphSet.converters['to_edges'] = nx.to_edgelist
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(list(g.edges()) == [(v00, v01)] or list(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 main():
"""Create a structure that represents all paths going from a group of startpoints to a group of endpoints.
The start point given by the user is the NE point of a group of 4 points
The end point given by the user is the NE point of a group of 4 points
The other 3 points are the ones that are one step W, one step S, and two steps SW.
"""
if len(sys.argv) != 5:
print "usage: %s [GRID-M] [GRID-N] [STARTPOINT] [ENDPOINT]" % sys.argv[0]
exit(1)
dim = (int(sys.argv[1]),int(sys.argv[2]))
rows = dim[0]
cols = dim[1]
dimension = (dim[0]-1,dim[1]-1)
startpoint = int(sys.argv[3])
endpoint = int(sys.argv[4])
starts = neighbors(startpoint, cols)
ends = neighbors(endpoint, cols)
from graphillion import GraphSet
import graphillion.tutorial as tl
universe = tl.grid(*dimension)
GraphSet.set_universe(universe)
paths = GraphSet()
for start in starts:
for end in ends:
paths = GraphSet.union(paths,GraphSet.paths(start,end))
print "number of paths: " + str(paths.len())
""" AC: SAVE ZDD TO FILE """
f = open("graphs/fixed_ends-%d-%d-%d-%d.zdd" % (dim[0],dim[1],startpoint,endpoint),"w")
paths.dump(f)
f.close()
""" AC: SAVE GRAPH """
nodes = [None] + [ (x,y) for x in xrange(dim[0]) for y in xrange(dim[1]) ]
from collections import defaultdict
graph = defaultdict(list)
for index,edge in enumerate(paths.universe()):
x,y = edge
x,y = nodes[x],nodes[y]
graph[x].append( (index+1,y) )
graph[y].append( (index+1,x) )
graph_filename = "graphs/fixed_ends-%d-%d-%d-%d.graph.pickle" % (dim[0],dim[1],startpoint,endpoint)
# save to file
import pickle
with open(graph_filename,'wb') as output:
pickle.dump(graph,output)
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 draw(g, universe=None):
import networkx as nx
import matplotlib.pyplot as plt
if not isinstance(g, nx.Graph):
g = nx.Graph(list(g))
if universe is None:
universe = GraphSet.universe()
if not isinstance(universe, nx.Graph):
universe = nx.Graph(list(universe))
n = sorted(universe[1].keys())[1] - 1
m = universe.number_of_nodes() // n
g.add_nodes_from(universe.nodes())
pos = {}
for v in range(1, m * n + 1):
pos[v] = ((v - 1) % n, (m * n - v) // n)
nx.draw(g, pos)
plt.show()
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
zdd_file.close()
return zdd_content.decode('unicode_escape')
if __name__ == "__main__":
import sys
import itertools
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))
def universe(self):
return GraphSet.universe()
exponent = total_cost(conv_prob, path)
return 10**exponent
if __name__ == "__main__":
# 動作確認
edgelist = [(1, 2, 10), (1, 3, 20), (2, 3, 30), (2, 4, 40), (3, 4, 50),
(2, 1, 10), (3, 1, 20), (3, 2, 30), (4, 2, 40), (4, 3, 50)]
read_edgelist(edgelist)
GraphSet.set_universe(append_virtual_nodes())
print("edges_table", edges_table())
print("append_virtual_nodes", append_virtual_nodes())
print("append_virtual_nodes2", append_virtual_nodes2())
print("universe", GraphSet.universe())
print("virtual_node_edges", virtual_node_edges())
print("virtual_nodes", virtual_nodes())
print("original_nodes", original_nodes())
print("predecessor_nodes", predecessor_nodes(1))
print("internal_edges", internal_edges(2100))
print("neighbor_nodes", neighbor_nodes(1))
print("external_edges", external_edges(4))
print("two_internal_edges_subgraph", two_internal_edges_subgraph(2100))
print("invalid_direction_elms", invalid_direction_elms(4, 3))
di_paths_1_4 = directed_paths(1, 4)
print("directed_paths", di_paths_1_4)
for path in di_paths_1_4:
print(path)
print("connected_edges", connected_edges(1, 4, 2))
print("disjoint_paths", disjoint_paths(di_paths_1_4, [(3, 3200),
for i in range(start,goal):
print i
for j in range(i+1,goal+1):
#paths = GraphSet.union(paths,GraphSet.paths(i,j))
"""Exclude midpoint"""
if i != midpoint and j != midpoint:
paths_no_mp = GraphSet.union(paths_no_mp,GraphSet.paths(i,j))
paths = GraphSet.union(paths,GraphSet.paths(i,j))
pathsThruMidpoint = paths.including(midpoint)
pathsNoMidpoint = paths_no_mp.including(midpoint)
#tl.draw(pathsThruMidpoint.choice())
print "number of paths through midpoint: " + str(pathsThruMidpoint.len())
print "number of paths without stopping at midpoint: " + str(pathsNoMidpoint.len())
print_edge_numbering(paths.universe(),dim[0],dim[1])
#print paths.universe()
#for p in pathsThruMidpoint:
# print p
#dim = (dimension[0]+1,dimension[1]+1)
#""" AC: SAVE ZDD TO FILE
f = open("graphs/asdf-%d-%d-%d.zdd" % (dim[0],dim[1],midpoint),"w")
pathsThruMidpoint.dump(f)
f.close()
#"""
#""" AC: SAVE ZDD TO FILE
f = open("graphs/asdf-no-mp-%d-%d-%d.zdd" % (dim[0],dim[1],midpoint),"w")
pathsNoMidpoint.dump(f)
f.close()
#"""
def draw_zdd(graph_set, universe=None):
if not universe:
universe = GraphSet.universe()
zdd = dump2zdd(graph_set.dumps().split("\n"))
return draw(zdd, universe)
def subset(self, gs, n, universe=None):
if universe is None:
universe = GraphSet.universe()
return gs.including(n)
def GetLocalConstraintsForLeaveClusters(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 = {}
zdd_to_sdd_index = [None]
universe = []
node_pair_to_edges = {}
for internal_edge in self.internal_edges:
if (internal_edge.x, internal_edge.y) not in node_pair_to_edges:
universe.append((internal_edge.x, internal_edge.y))
node_pair_to_edges.setdefault((internal_edge.x, internal_edge.y),
[]).append(internal_edge)
GraphSet.set_universe(universe)
universe = GraphSet.universe()
then_sdd_index = 0
for node_pair in universe:
correponding_sdd_indexes = []
for internal_edge in node_pair_to_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))
paths = GraphSet()
for (i, j) in itertools.combinations(self.nodes, 2):
paths = paths.union(GraphSet.paths(i, j))
case_two_then = generate_sdd_from_graphset(paths, then_manager,
zdd_to_sdd_index)
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 node in self.nodes:
if node == entering_node:
continue
paths = paths.union(GraphSet.paths(entering_node, node))
cur_case_then = generate_sdd_from_graphset(paths, then_manager,
zdd_to_sdd_index)
# disjoin the empty path
cur_case_then = sdd.sdd_disjoin(
cur_case_then,
sdd.util.sdd_negative_term(then_manager,
range(1, then_sdd_index + 1)),
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)
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
