def test_serialization(self):
node = Node()
node.objective = 0.0
node.bound = 1.0
node.tree_depth = -1
node.queue_priority = (1, 2, 3)
node._uuid = None
node.state = "a"
s = _SerializedNode.from_node(node)
assert s.objective == node.objective
assert s.bound == node.bound
assert s.tree_depth == node.tree_depth
assert s.queue_priority == node.queue_priority
assert s._uuid is None
assert s.data is not None
s._generate_uuid()
assert s._uuid is not None
node_ = s.restore_node(s.slots)
assert node_.objective == node.objective
assert node_.bound == node.bound
assert node_.tree_depth == node.tree_depth
assert node_.queue_priority == node.queue_priority
assert node_.state == node.state
assert node_._uuid == s._uuid
def _test_initialize_queue(comm):
solver = Solver(comm=comm)
# no initial queue
for sense in (minimize, maximize):
problem = DummyProblem(sense)
results = solver.solve(problem, queue_limit=0)
assert results.solution_status == "unknown"
assert results.termination_condition == "queue_limit"
assert results.objective == (inf if (sense == minimize) else -inf)
assert results.bound == (-inf if (sense == minimize) else inf)
assert results.absolute_gap is None
assert results.relative_gap is None
assert results.nodes == 0
assert results.wall_time is not None
assert results.best_node is None
assert problem._notify_new_best_node_call_count == 0
assert solver._local_solve_info.explored_nodes_count == 0
problem = DummyProblem(sense)
results = solver.solve(problem)
assert results.solution_status == "optimal"
assert results.termination_condition == "optimality"
assert results.objective == 0
assert results.bound == 0
assert results.absolute_gap == 0
assert results.relative_gap == 0
assert results.nodes == 1
assert results.wall_time is not None
assert results.best_node is not None
assert results.best_node.objective == results.objective
assert results.best_node.tree_depth == 0
if solver.is_worker:
assert problem._notify_new_best_node_call_count == 1
assert problem._notify_new_best_node_args[0] is results.best_node
if solver._local_solve_info.explored_nodes_count == 1:
assert problem._notify_new_best_node_args[1]
else:
assert solver._local_solve_info.explored_nodes_count == 0
assert not problem._notify_new_best_node_args[1]
else:
assert problem._notify_new_best_node_call_count == 0
problem = DummyProblem(sense)
results = solver.solve(
problem, best_objective=(1 if (sense == minimize) else -1)
)
assert results.solution_status == "optimal"
assert results.termination_condition == "optimality"
assert results.objective == 0
assert results.bound == 0
assert results.absolute_gap == 0
assert results.relative_gap == 0
assert results.nodes == 1
assert results.wall_time is not None
assert results.best_node is not None
assert results.best_node.objective == results.objective
assert results.best_node.tree_depth == 0
if solver.is_worker:
assert problem._notify_new_best_node_call_count == 1
assert problem._notify_new_best_node_args[0] is results.best_node
if solver._local_solve_info.explored_nodes_count == 1:
assert problem._notify_new_best_node_args[1]
else:
assert solver._local_solve_info.explored_nodes_count == 0
assert not problem._notify_new_best_node_args[1]
else:
assert problem._notify_new_best_node_call_count == 0
problem = DummyProblem(sense)
results = solver.solve(
problem,
best_objective=(1 if (sense == minimize) else -1),
disable_objective_call=True,
)
assert results.solution_status == "feasible"
assert results.termination_condition == "queue_empty"
assert results.objective == (1 if (sense == minimize) else -1)
assert results.bound == 0
assert results.absolute_gap == 1
assert results.relative_gap == 1
assert results.nodes == 1
assert results.wall_time is not None
assert results.best_node is None
assert problem._notify_new_best_node_call_count == 0
best_node_ = Node()
best_node_.objective = 1 if (sense == minimize) else -1
best_node_._uuid = "abcd"
problem = DummyProblem(sense)
results = solver.solve(
problem, best_node=best_node_, disable_objective_call=True
)
assert results.solution_status == "feasible"
assert results.termination_condition == "queue_empty"
assert results.objective == best_node_.objective
assert results.bound == 0
assert results.absolute_gap == 1
assert results.relative_gap == 1
assert results.nodes == 1
assert results.best_node._uuid == best_node_._uuid
if (comm is None) or (comm.size == 1):
assert results.best_node is best_node_
assert results.best_node.objective == results.objective
if solver.is_worker:
assert problem._notify_new_best_node_call_count == 1
assert problem._notify_new_best_node_args[0] is results.best_node
if solver._local_solve_info.explored_nodes_count == 1:
assert not problem._notify_new_best_node_args[1]
else:
assert solver._local_solve_info.explored_nodes_count == 0
assert not problem._notify_new_best_node_args[1]
else:
assert problem._notify_new_best_node_call_count == 0
best_node_ = Node()
best_node_.objective = 1 if (sense == minimize) else -1
best_node_._uuid = "abcd"
problem = DummyProblem(sense)
results = solver.solve(problem, best_node=best_node_)
assert results.solution_status == "optimal"
assert results.termination_condition == "optimality"
assert results.objective == 0
assert results.bound == 0
assert results.absolute_gap == 0
assert results.relative_gap == 0
assert results.nodes == 1
assert results.wall_time is not None
assert results.best_node._uuid != best_node_._uuid
if (comm is None) or (comm.size == 1):
assert results.best_node is not best_node_
assert results.best_node.objective == results.objective
assert results.best_node.tree_depth == 0
if solver.is_worker:
assert problem._notify_new_best_node_call_count >= 1
assert problem._notify_new_best_node_args[0] is results.best_node
if problem._notify_new_best_node_call_count == 2:
assert problem._notify_new_best_node_args[1]
else:
assert problem._notify_new_best_node_args[0]
else:
assert problem._notify_new_best_node_call_count == 0
# empty initial queue
queue = DispatcherQueueData(nodes=[], worst_terminal_bound=None, sense=minimize)
for sense in (minimize, maximize):
queue.sense = sense
problem = DummyProblem(sense)
results = solver.solve(problem, initialize_queue=queue)
assert results.solution_status == "unknown"
assert results.termination_condition == "queue_empty"
assert results.objective == (inf if (sense == minimize) else -inf)
assert results.bound == (-inf if (sense == minimize) else inf)
assert results.absolute_gap is None
assert results.relative_gap is None
assert results.nodes == 0
assert results.wall_time is not None
assert results.best_node is None
assert problem._notify_new_best_node_call_count == 0
problem = DummyProblem(sense)
results = solver.solve(problem, initialize_queue=queue, best_objective=0)
assert results.solution_status == "feasible"
assert results.termination_condition == "queue_empty"
assert results.objective == 0
assert results.bound == (-inf if (sense == minimize) else inf)
assert results.absolute_gap == inf
assert results.relative_gap == inf
assert results.nodes == 0
assert results.wall_time is not None
assert results.best_node is None
assert problem._notify_new_best_node_call_count == 0
problem = DummyProblem(sense)
results = solver.solve(
problem,
initialize_queue=queue,
best_objective=0,
disable_objective_call=True,
)
assert results.solution_status == "feasible"
assert results.termination_condition == "queue_empty"
assert results.objective == 0
assert results.bound == (-inf if (sense == minimize) else inf)
assert results.absolute_gap == inf
assert results.relative_gap == inf
assert results.nodes == 0
assert results.wall_time is not None
assert results.best_node is None
assert problem._notify_new_best_node_call_count == 0
best_node_ = Node()
best_node_.objective = 1 if (sense == minimize) else -1
best_node_._uuid = "abcd"
problem = DummyProblem(sense)
results = solver.solve(
problem, initialize_queue=queue, best_objective=0, best_node=best_node_
)
assert results.solution_status == "feasible"
assert results.termination_condition == "queue_empty"
assert results.objective == 0
assert results.bound == (-inf if (sense == minimize) else inf)
assert results.absolute_gap == inf
assert results.relative_gap == inf
assert results.nodes == 0
assert results.wall_time is not None
assert results.best_node._uuid == best_node_._uuid
if (comm is None) or (comm.size == 1):
assert results.best_node is best_node_
if solver.is_worker:
assert problem._notify_new_best_node_call_count == 1
assert problem._notify_new_best_node_args[0] is results.best_node
assert solver._local_solve_info.explored_nodes_count == 0
assert not problem._notify_new_best_node_args[1]
else:
assert problem._notify_new_best_node_call_count == 0
best_node_ = Node()
best_node_.objective = 1 if (sense == minimize) else -1
best_node_._uuid = "abcd"
problem = DummyProblem(sense)
results = solver.solve(
problem,
initialize_queue=queue,
best_objective=(2 if (sense == minimize) else -2),
best_node=best_node_,
)
assert results.solution_status == "feasible"
assert results.termination_condition == "queue_empty"
assert results.objective == (1 if (sense == minimize) else -1)
assert results.bound == (-inf if (sense == minimize) else inf)
assert results.absolute_gap == inf
assert results.relative_gap == inf
assert results.nodes == 0
assert results.wall_time is not None
assert results.best_node._uuid == best_node_._uuid
if (comm is None) or (comm.size == 1):
assert results.best_node is best_node_
if solver.is_worker:
assert problem._notify_new_best_node_call_count == 1
assert problem._notify_new_best_node_args[0] is results.best_node
assert solver._local_solve_info.explored_nodes_count == 0
assert not problem._notify_new_best_node_args[1]
else:
assert problem._notify_new_best_node_call_count == 0
# non-empty initial queue
root = Node()
root._uuid = "abcd"
root.tree_depth = 0
root.objective = 0
root.bound = 0
queue = DispatcherQueueData(nodes=[root], worst_terminal_bound=None, sense=minimize)
orig_objective = queue.nodes[0].objective
for sense in (minimize, maximize):
queue.sense = sense
queue.nodes[0].objective = orig_objective
problem = DummyProblem(sense)
results = solver.solve(problem, initialize_queue=queue)
assert results.solution_status == "optimal"
assert results.termination_condition == "optimality"
assert results.objective == 0
assert results.bound == 0
assert results.absolute_gap == 0
assert results.relative_gap == 0
assert results.nodes == 1
assert results.wall_time is not None
assert results.best_node._uuid == root._uuid
if (comm is None) or (comm.size == 1):
assert results.best_node is root
if solver.is_worker:
assert problem._notify_new_best_node_call_count == 1
assert problem._notify_new_best_node_args[0] is results.best_node
if solver._local_solve_info.explored_nodes_count == 1:
assert problem._notify_new_best_node_args[1]
else:
assert solver._local_solve_info.explored_nodes_count == 0
assert not problem._notify_new_best_node_args[1]
else:
assert problem._notify_new_best_node_call_count == 0
queue.nodes[0].objective = orig_objective
problem = DummyProblem(sense)
results = solver.solve(
problem,
initialize_queue=queue,
best_objective=(1 if (sense == minimize) else -1),
)
assert results.solution_status == "optimal"
assert results.termination_condition == "optimality"
assert results.objective == 0
assert results.bound == 0
assert results.absolute_gap == 0
assert results.relative_gap == 0
assert results.nodes == 1
assert results.wall_time is not None
assert results.best_node._uuid == root._uuid
if (comm is None) or (comm.size == 1):
assert results.best_node is root
if solver.is_worker:
assert problem._notify_new_best_node_call_count == 1
assert problem._notify_new_best_node_args[0] is results.best_node
if solver._local_solve_info.explored_nodes_count == 1:
assert problem._notify_new_best_node_args[1]
else:
assert solver._local_solve_info.explored_nodes_count == 0
assert not problem._notify_new_best_node_args[1]
else:
assert problem._notify_new_best_node_call_count == 0
queue.nodes[0].objective = inf if (sense == minimize) else -inf
problem = DummyProblem(sense)
results = solver.solve(
problem,
initialize_queue=queue,
best_objective=(1 if (sense == minimize) else -1),
)
assert results.solution_status == "optimal"
assert results.termination_condition == "optimality"
assert results.objective == 0
assert results.bound == 0
assert results.absolute_gap == 0
assert results.relative_gap == 0
assert results.nodes == 1
assert results.wall_time is not None
assert results.best_node._uuid == root._uuid
if (comm is None) or (comm.size == 1):
assert results.best_node is root
if solver.is_worker:
assert problem._notify_new_best_node_call_count == 1
assert problem._notify_new_best_node_args[0] is results.best_node
if solver._local_solve_info.explored_nodes_count == 1:
assert problem._notify_new_best_node_args[1]
else:
assert solver._local_solve_info.explored_nodes_count == 0
assert not problem._notify_new_best_node_args[1]
else:
assert problem._notify_new_best_node_call_count == 0
queue.nodes[0].objective = inf if (sense == minimize) else -inf
problem = DummyProblem(sense)
results = solver.solve(
problem,
initialize_queue=queue,
best_objective=(1 if (sense == minimize) else -1),
disable_objective_call=True,
)
assert results.solution_status == "feasible"
assert results.termination_condition == "queue_empty"
assert results.objective == (1 if (sense == minimize) else -1)
assert results.bound == 0
assert results.absolute_gap == 1
assert results.relative_gap == 1
assert results.nodes == 1
assert results.wall_time is not None
assert results.best_node is None
assert problem._notify_new_best_node_call_count == 0
queue.nodes[0].objective = orig_objective