def random_recurse(node, prev_solution):
solution = list(prev_solution) + [node.value]
valid = True
for constraint in constraints:
if not constraint(solution):
valid = False
break
if valid:
for terminator in terminators:
if not terminator(solution):
valid = False
break
if valid and node.children is None:
node.children = [
_SolutionNode(x, parent=node) for x in domain[0]
]
return solution
elif node.children == []:
return node
else:
if node.children is None:
node.children = [
_SolutionNode(x, parent=node) for x in domain[0]
]
result = random_recurse(
random.choice(node.children),
solution,
)
if isinstance(result, list):
return result
if isinstance(result, tuple):
solution, child = result
node.children.remove(child)
if node.children == []:
return solution, node
return solution
elif result is None:
return None
elif isinstance(result, type(node)):
node.children.remove(result)
if node.children == []:
return node
return None
else:
return node
def random_recurse(node, prev_solution):
solution = list(prev_solution) + [node.value]
valid = True
for constraint in constraints:
if not constraint(solution):
valid = False
break
if valid:
for terminator in terminators:
if not terminator(solution):
valid = False
break
if valid and node.children is None:
node.children = [_SolutionNode(x, parent=node)
for x in domain[0]]
return solution
elif node.children == []:
return node
else:
if node.children is None:
node.children = [_SolutionNode(x, parent=node)
for x in domain[0]]
result = random_recurse(
random.choice(node.children),
solution,
)
if isinstance(result, list):
return result
if isinstance(result, tuple):
solution, child = result
node.children.remove(child)
if node.children == []:
return solution, node
return solution
elif result is None:
return None
elif isinstance(result, type(node)):
node.children.remove(result)
if node.children == []:
return node
return None
else:
return node
def ordered_recurse(node, prev_solution, prev_depth=0):
depth = prev_depth + 1
solution = list(prev_solution) + [node.value]
valid = True
for constraint in constraints:
if not constraint(solution):
valid = False
break
if valid:
if depth == domain_length:
yield solution
else:
for x in domain[depth]:
child = _SolutionNode(x, parent=node, children=[])
node.append(child)
for y in ordered_recurse(child, solution, depth):
yield y
def ordered_recurse(node, prev_solution, prev_depth=0):
depth = prev_depth + 1
solution = list(prev_solution) + [node.value]
valid = True
for constraint in constraints:
if not constraint(solution):
valid = False
break
if valid:
if depth == domain_length:
yield solution
else:
for x in domain[depth]:
child = _SolutionNode(x, parent=node, children=[])
node.append(child)
for y in ordered_recurse(child, solution, depth):
yield y
def ordered_recurse(node, prev_solution):
solution = list(prev_solution) + [node.value]
valid = True
for constraint in constraints:
if not constraint(solution):
valid = False
break
if valid:
for terminator in terminators:
if not terminator(solution):
valid = False
break
if valid:
yield solution
for x in domain[0]:
child = _SolutionNode(x, parent=node, children=[])
node.append(child)
for y in ordered_recurse(child, solution):
yield y
def ordered_recurse(node, prev_solution):
solution = list(prev_solution) + [node.value]
valid = True
for constraint in constraints:
if not constraint(solution):
valid = False
break
if valid:
for terminator in terminators:
if not terminator(solution):
valid = False
break
if valid:
yield solution
for x in domain[0]:
child = _SolutionNode(x, parent=node, children=[])
node.append(child)
for y in ordered_recurse(child, solution):
yield y
def random_recurse(node, prev_solution, prev_depth=0):
depth = prev_depth + 1
solution = list(prev_solution) + [node.value]
valid = True
for constraint in constraints:
if not constraint(solution):
valid = False
break
if valid:
if depth == domain_length:
return solution, node
else:
if node.children is None:
node.children = [
_SolutionNode(x, parent=node)
for x in domain[depth]
]
elif node.children == []:
return node
else:
result = random_recurse(
random.choice(node.children),
solution,
depth,
)
if isinstance(result, list):
return result
if isinstance(result, tuple):
solution, child = result
node.children.remove(child)
if node.children == []:
return solution, node
return solution
elif result is None:
return None
elif isinstance(result, type(node)):
node.children.remove(result)
if node.children == []:
return node
return None
else:
return node
def random_recurse(node, prev_solution, prev_depth=0):
depth = prev_depth + 1
solution = list(prev_solution) + [node.value]
valid = True
for constraint in constraints:
if not constraint(solution):
valid = False
break
if valid:
if depth == domain_length:
return solution, node
else:
if node.children is None:
node.children = [_SolutionNode(x, parent=node)
for x in domain[depth]]
elif node.children == []:
return node
else:
result = random_recurse(
random.choice(node.children),
solution,
depth,
)
if isinstance(result, list):
return result
if isinstance(result, tuple):
solution, child = result
node.children.remove(child)
if node.children == []:
return solution, node
return solution
elif result is None:
return None
elif isinstance(result, type(node)):
node.children.remove(result)
if node.children == []:
return node
return None
else:
return node
def __iter__(self):
domain = self._domain
domain_length = len(domain)
constraints = self._constraints
def random_recurse(node, prev_solution, prev_depth=0):
depth = prev_depth + 1
solution = list(prev_solution) + [node.value]
valid = True
for constraint in constraints:
if not constraint(solution):
valid = False
break
if valid:
if depth == domain_length:
return solution, node
else:
if node.children is None:
node.children = [_SolutionNode(x, parent=node)
for x in domain[depth]]
elif node.children == []:
return node
else:
result = random_recurse(
random.choice(node.children),
solution,
depth,
)
if isinstance(result, list):
return result
if isinstance(result, tuple):
solution, child = result
node.children.remove(child)
if node.children == []:
return solution, node
return solution
elif result is None:
return None
elif isinstance(result, type(node)):
node.children.remove(result)
if node.children == []:
return node
return None
else:
return node
def ordered_recurse(node, prev_solution, prev_depth=0):
depth = prev_depth + 1
solution = list(prev_solution) + [node.value]
valid = True
for constraint in constraints:
if not constraint(solution):
valid = False
break
if valid:
if depth == domain_length:
yield solution
else:
for x in domain[depth]:
child = _SolutionNode(x, parent=node, children=[])
node.append(child)
for y in ordered_recurse(child, solution, depth):
yield y
# randomized traversal
if self.randomized:
graphs = [_SolutionNode(x) for x in domain[0]]
while graphs:
result = random_recurse(random.choice(graphs), [], 0)
if isinstance(result, list):
yield result
elif isinstance(result, tuple):
solution, node = result
graphs.remove(node)
yield solution
elif isinstance(result, _SolutionNode):
graphs.remove(result)
# ordered traversal
else:
for x in domain[0]:
node = _SolutionNode(x, children=[])
for y in ordered_recurse(node, [], 0):
yield y
def __iter__(self):
domain = self._domain
constraints = self._constraints
terminators = self._terminators
def ordered_recurse(node, prev_solution):
solution = list(prev_solution) + [node.value]
valid = True
for constraint in constraints:
if not constraint(solution):
valid = False
break
if valid:
for terminator in terminators:
if not terminator(solution):
valid = False
break
if valid:
yield solution
for x in domain[0]:
child = _SolutionNode(x, parent=node, children=[])
node.append(child)
for y in ordered_recurse(child, solution):
yield y
def random_recurse(node, prev_solution):
solution = list(prev_solution) + [node.value]
valid = True
for constraint in constraints:
if not constraint(solution):
valid = False
break
if valid:
for terminator in terminators:
if not terminator(solution):
valid = False
break
if valid and node.children is None:
node.children = [_SolutionNode(x, parent=node)
for x in domain[0]]
return solution
elif node.children == []:
return node
else:
if node.children is None:
node.children = [_SolutionNode(x, parent=node)
for x in domain[0]]
result = random_recurse(
random.choice(node.children),
solution,
)
if isinstance(result, list):
return result
if isinstance(result, tuple):
solution, child = result
node.children.remove(child)
if node.children == []:
return solution, node
return solution
elif result is None:
return None
elif isinstance(result, type(node)):
node.children.remove(result)
if node.children == []:
return node
return None
else:
return node
if self.randomized:
graphs = [_SolutionNode(x) for x in domain[0]]
while graphs:
result = random_recurse(random.choice(graphs), [])
if isinstance(result, list):
yield result
elif isinstance(result, tuple):
solution, node = result
graphs.remove(node)
yield solution
elif isinstance(result, _SolutionNode):
graphs.remove(result)
else:
for x in domain[0]:
node = _SolutionNode(x, children=[])
for y in ordered_recurse(node, ()):
yield y
def __iter__(self):
domain = self._domain
domain_length = len(domain)
constraints = self._constraints
def random_recurse(node, prev_solution, prev_depth=0):
depth = prev_depth + 1
solution = list(prev_solution) + [node.value]
valid = True
for constraint in constraints:
if not constraint(solution):
valid = False
break
if valid:
if depth == domain_length:
return solution, node
else:
if node.children is None:
node.children = [
_SolutionNode(x, parent=node)
for x in domain[depth]
]
elif node.children == []:
return node
else:
result = random_recurse(
random.choice(node.children),
solution,
depth,
)
if isinstance(result, list):
return result
if isinstance(result, tuple):
solution, child = result
node.children.remove(child)
if node.children == []:
return solution, node
return solution
elif result is None:
return None
elif isinstance(result, type(node)):
node.children.remove(result)
if node.children == []:
return node
return None
else:
return node
def ordered_recurse(node, prev_solution, prev_depth=0):
depth = prev_depth + 1
solution = list(prev_solution) + [node.value]
valid = True
for constraint in constraints:
if not constraint(solution):
valid = False
break
if valid:
if depth == domain_length:
yield solution
else:
for x in domain[depth]:
child = _SolutionNode(x, parent=node, children=[])
node.append(child)
for y in ordered_recurse(child, solution, depth):
yield y
# randomized traversal
if self.randomized:
graphs = [_SolutionNode(x) for x in domain[0]]
while graphs:
result = random_recurse(random.choice(graphs), [], 0)
if isinstance(result, list):
yield result
elif isinstance(result, tuple):
solution, node = result
graphs.remove(node)
yield solution
elif isinstance(result, _SolutionNode):
graphs.remove(result)
# ordered traversal
else:
for x in domain[0]:
node = _SolutionNode(x, children=[])
for y in ordered_recurse(node, [], 0):
yield y
def __iter__(self):
domain = self._domain
constraints = self._constraints
terminators = self._terminators
def ordered_recurse(node, prev_solution):
solution = list(prev_solution) + [node.value]
valid = True
for constraint in constraints:
if not constraint(solution):
valid = False
break
if valid:
for terminator in terminators:
if not terminator(solution):
valid = False
break
if valid:
yield solution
for x in domain[0]:
child = _SolutionNode(x, parent=node, children=[])
node.append(child)
for y in ordered_recurse(child, solution):
yield y
def random_recurse(node, prev_solution):
solution = list(prev_solution) + [node.value]
valid = True
for constraint in constraints:
if not constraint(solution):
valid = False
break
if valid:
for terminator in terminators:
if not terminator(solution):
valid = False
break
if valid and node.children is None:
node.children = [
_SolutionNode(x, parent=node) for x in domain[0]
]
return solution
elif node.children == []:
return node
else:
if node.children is None:
node.children = [
_SolutionNode(x, parent=node) for x in domain[0]
]
result = random_recurse(
random.choice(node.children),
solution,
)
if isinstance(result, list):
return result
if isinstance(result, tuple):
solution, child = result
node.children.remove(child)
if node.children == []:
return solution, node
return solution
elif result is None:
return None
elif isinstance(result, type(node)):
node.children.remove(result)
if node.children == []:
return node
return None
else:
return node
if self.randomized:
graphs = [_SolutionNode(x) for x in domain[0]]
while graphs:
result = random_recurse(random.choice(graphs), [])
if isinstance(result, list):
yield result
elif isinstance(result, tuple):
solution, node = result
graphs.remove(node)
yield solution
elif isinstance(result, _SolutionNode):
graphs.remove(result)
else:
for x in domain[0]:
node = _SolutionNode(x, children=[])
for y in ordered_recurse(node, ()):
yield y
