def generate_ising(args):
domain_size = args.range
size = args.size
d = VariableDomain('d', 'dummy', range(domain_size))
variables = {}
constraints = {}
for i in range(size):
for j in range(size):
v = Variable('v{}_{}'.format(i, j), d,
floor(domain_size * random.random()))
variables[(i, j)] = v
for i, j in variables:
c = _create_ising_constraint(i, j, i, (j + 1) % size, domain_size,
variables)
constraints[(i, j, i, (j + 1) % size)] = c
c = _create_ising_constraint(i, j, (i + 1) % size, j, domain_size,
variables)
constraints[(i, j, (i + 1) % size), j] = c
dcop = DCOP('radom ising', 'min')
#dcop.domains = {'d': d}
#dcop.variables = variables
dcop._agents_def = {}
for c in constraints.values():
dcop.add_constraint(c)
if args.output:
outputfile = args.output[0]
write_in_file(outputfile, dcop_yaml(dcop))
else:
print(dcop_yaml(dcop))
def test_3nodes_tree_cycle(self):
domain = ['a', 'b', 'c']
x1 = Variable('x1', domain)
x2 = Variable('x2', domain)
x3 = Variable('x3', domain)
variables = [x1, x2, x3]
r1 = NAryFunctionRelation(lambda x, y: x + y, [x1, x2], name='r1')
r2 = NAryFunctionRelation(lambda x, y: x + y, [x1, x3], name='r2')
r3 = NAryFunctionRelation(lambda x, y: x + y, [x2, x3], name='r3')
relations = [r1, r2, r3]
dcop = DCOP('test', 'min')
dcop.add_constraint(r1)
dcop.add_constraint(r2)
dcop.add_constraint(r3)
cg = build_computation_graph(dcop)
self.assertEqual(len(cg.nodes), len(variables))
self.assertEqual(len(cg.roots), 1)
# All variables have the same number of neighbors, they could all be
# root
self.assertIn(cg.roots[0].variable, [x1, x2, x3])
self.assertEqual(cg.roots[0].parent, None)
root = _generate_dfs_tree(variables, relations, root=x1)
self.assertEqual(root.variable, x1)
self.assertEqual(root.parent, None)
def test_density_two_var_one_factor(self):
dcop = DCOP('test', 'min')
d1 = VariableDomain('d1', '--', [1, 2, 3])
v1 = Variable('v1', d1)
v2 = Variable('v2', d1)
c1 = relation_from_str('c1', '0.5 * v1 + v2', [v1, v2])
dcop.add_constraint(c1)
g = build_computation_graph(dcop)
self.assertEqual(g.density(), 2 / 2)
def test_dcop_add_constraint_is_enough():
dcop = DCOP()
d = VariableDomain('test', 'test', values=range(10))
v1 = Variable('v1', d)
v2 = Variable('v2', d)
c1 = constraint_from_str('c1', '0 if v1 != v2 else 1000', [v1, v2])
dcop.add_constraint(c1)
assert dcop.constraints == {'c1': c1}
assert dcop.variables == {'v1': v1, 'v2': v2}
assert dcop.domains == {'test': d}
def test_graph_density():
d = Domain('d', 'test', [1, 2, 3])
v1 = Variable('v1', d)
v2 = Variable('v2', d)
v3 = Variable('v3', d)
c1 = constraint_from_str('c1', 'v1 * 0.5 + v2 - v3', [v1, v2, v3])
dcop = DCOP('dcop_test', 'min')
dcop.add_constraint(c1)
graph = build_computation_graph(dcop)
density = graph.density()
assert density == 1 / 3
def test_build_two_var(self):
v1 = Variable('v1', [1, 2, 3])
v2 = Variable('v2', [1, 2, 3])
c1 = relation_from_str('c1', 'v1 + v2 ', [v1, v2])
dcop = DCOP('test', 'min')
dcop.add_constraint(c1)
cg = build_computation_graph(dcop)
self.assertEqual(len(cg.nodes), 2)
self.assertEqual(cg.computation('v1').variable, v1)
self.assertEqual(cg.computation('v2').variable, v2)
# one parent link, one children link
self.assertEqual(len(cg.links), 2)
