示例#1
0
 def test_write(self):
     results = SolverResults()
     results.write(StringIO())
     del results.objective
     results.write(StringIO())
     results.junk = 1
     results.write(StringIO())
示例#2
0
def _test_delayed_unbounded_min(comm):
    solver = Solver(comm=comm)
    baseline = SolverResults()
    baseline.solution_status = "unbounded"
    baseline.termination_condition = "no_nodes"
    baseline.objective = -inf
    baseline.bound = -inf
    baseline.nodes = _ignore_value_
    baseline.wall_time = _ignore_value_
    problem = delayed_unbounded_min.DelayedUnboundedMin()
    _execute_single_test(problem, baseline, solver=solver)
    for queue_strategy in sorted(pybnb.QueueStrategy):
        if queue_strategy == "custom":
            continue
        _execute_single_test(problem,
                             baseline,
                             solver=solver,
                             queue_strategy=queue_strategy)
示例#3
0
def _test_root_infeasible_min(comm):
    solver = Solver(comm=comm)
    baseline = SolverResults()
    baseline.solution_status = "infeasible"
    baseline.termination_condition = "optimality"
    baseline.objective = inf
    baseline.bound = inf
    baseline.nodes = 1
    baseline.wall_time = _ignore_value_
    problem = root_infeasible_min.RootInfeasibleMin()
    _execute_single_test(problem, baseline, solver=solver)
    for queue_strategy in sorted(pybnb.QueueStrategy):
        if queue_strategy == "custom":
            continue
        _execute_single_test(problem,
                             baseline,
                             solver=solver,
                             queue_strategy=queue_strategy)
示例#4
0
def _test_infeasible_max(comm):
    solver = None
    if comm is not None:
        solver = Solver(comm=comm)
    baseline = SolverResults()
    baseline.solution_status = "infeasible"
    baseline.termination_condition = "optimality"
    baseline.objective = -inf
    baseline.bound = -inf
    baseline.nodes = 255
    baseline.wall_time = _ignore_value_
    problem = infeasible_max.InfeasibleMax()
    if comm is None:
        _execute_tests(comm, problem, baseline)
    else:
        _execute_single_test(problem, baseline, solver=solver)

    baseline = SolverResults()
    baseline.solution_status = "unknown"
    baseline.termination_condition = "no_nodes"
    baseline.objective = -inf
    baseline.bound = -16
    baseline.nodes = 31
    baseline.wall_time = _ignore_value_
    problem = infeasible_max.InfeasibleMax(branching_abstol=0.1)
    if comm is None:
        _execute_tests(comm, problem, baseline)
    else:
        _execute_single_test(problem, baseline, solver=solver)

    baseline = SolverResults()
    baseline.solution_status = "unknown"
    baseline.termination_condition = "objective_limit"
    baseline.objective = -inf
    baseline.bound = -16
    baseline.nodes = 31
    baseline.wall_time = _ignore_value_
    problem = infeasible_max.InfeasibleMax(branching_abstol=0.1)
    if comm is None:
        _execute_tests(comm, problem, baseline, bound_stop=-15)
    else:
        _execute_single_test(problem, baseline, solver=solver, bound_stop=-15)

    baseline = SolverResults()
    baseline.solution_status = "feasible"
    baseline.termination_condition = "objective_limit"
    baseline.objective = -20
    baseline.bound = -16
    baseline.absolute_gap = 4
    baseline.relative_gap = 0.2
    baseline.nodes = 31
    baseline.wall_time = _ignore_value_
    problem = infeasible_max.InfeasibleMax(branching_abstol=0.1,
                                           fixed_objective=-20)
    if comm is None:
        _execute_tests(comm, problem, baseline, bound_stop=-15)
    else:
        _execute_single_test(problem, baseline, solver=solver, bound_stop=-15)

    baseline = SolverResults()
    baseline.solution_status = "unknown"
    baseline.termination_condition = "node_limit"
    baseline.objective = -inf
    baseline.bound = -16
    baseline.nodes = 31
    baseline.wall_time = _ignore_value_
    problem = infeasible_max.InfeasibleMax()
    if comm is None:
        _execute_tests(comm, problem, baseline, node_limit=31)
    elif comm.size <= 2:
        # skip for larger comm sizes
        # as the node_limit can lead to
        # a number of different outcomes
        _execute_single_test(problem, baseline, solver=solver, node_limit=31)

    baseline = SolverResults()
    baseline.solution_status = "feasible"
    baseline.termination_condition = "node_limit"
    baseline.objective = -17
    baseline.bound = -16
    baseline.absolute_gap = 1.0
    baseline.relative_gap = 1.0 / 17
    baseline.nodes = 31
    baseline.wall_time = _ignore_value_
    problem = infeasible_max.InfeasibleMax(fixed_objective=-17)
    if comm is None:
        _execute_tests(comm, problem, baseline, node_limit=31)
    elif comm.size <= 2:
        # skip for larger comm sizes
        # as the node_limit can lead to
        # a number of different outcomes
        _execute_single_test(problem, baseline, solver=solver, node_limit=31)

    baseline = SolverResults()
    baseline.solution_status = "unknown"
    baseline.termination_condition = "time_limit"
    baseline.objective = -inf
    baseline.bound = inf
    baseline.nodes = 0
    baseline.wall_time = _ignore_value_
    problem = infeasible_max.InfeasibleMax()
    if comm is None:
        _execute_tests(comm, problem, baseline, time_limit=0)
    else:
        _execute_single_test(problem, baseline, solver=solver, time_limit=0)

    if solver is None:
        solver = Solver(comm=comm)
    baseline = SolverResults()
    baseline.solution_status = "infeasible"
    baseline.termination_condition = "optimality"
    baseline.objective = -inf
    baseline.bound = -inf
    baseline.nodes = 255
    baseline.wall_time = _ignore_value_
    problem = infeasible_max.InfeasibleMax()
    for queue_strategy in sorted(pybnb.QueueStrategy):
        if queue_strategy == "custom":
            continue
        _execute_single_test(problem,
                             baseline,
                             solver=solver,
                             queue_strategy=queue_strategy)
示例#5
0
def _test_zero_objective_min(comm):
    solver = Solver(comm=comm)
    baseline = SolverResults()
    baseline.solution_status = "optimal"
    baseline.termination_condition = "optimality"
    baseline.objective = 0.0
    baseline.bound = -0.0078125
    baseline.absolute_gap = 0.0078125
    baseline.relative_gap = 0.0078125
    baseline.nodes = 255
    baseline.wall_time = _ignore_value_
    problem = zero_objective_min.ZeroObjectiveMin()
    _execute_single_test(problem,
                         baseline,
                         solver=solver,
                         relative_gap=0.01,
                         absolute_gap=0.01)
    _execute_single_test(problem,
                         baseline,
                         solver=solver,
                         relative_gap=0.0,
                         absolute_gap=0.01)
    _execute_single_test(problem,
                         baseline,
                         solver=solver,
                         relative_gap=0.01,
                         absolute_gap=0.0)

    baseline = SolverResults()
    baseline.solution_status = "optimal"
    baseline.termination_condition = "optimality"
    baseline.objective = 0.0
    baseline.bound = -0.0009765625
    baseline.absolute_gap = 0.0009765625
    baseline.relative_gap = 0.0009765625
    baseline.nodes = 2047
    baseline.wall_time = _ignore_value_
    problem = zero_objective_min.ZeroObjectiveMin()
    _execute_single_test(problem,
                         baseline,
                         solver=solver,
                         relative_gap=0.001,
                         absolute_gap=0.001)
    _execute_single_test(problem,
                         baseline,
                         solver=solver,
                         relative_gap=0.0,
                         absolute_gap=0.001)
    _execute_single_test(problem,
                         baseline,
                         solver=solver,
                         relative_gap=0.001,
                         absolute_gap=0.0)

    baseline = SolverResults()
    baseline.solution_status = "feasible"
    baseline.termination_condition = "no_nodes"
    baseline.objective = 0.0
    baseline.bound = -0.0009765625
    baseline.absolute_gap = 0.0009765625
    baseline.relative_gap = 0.0009765625
    baseline.nodes = 2047
    baseline.wall_time = _ignore_value_
    problem = zero_objective_min.ZeroObjectiveMin()
    _execute_single_test(problem,
                         baseline,
                         solver=solver,
                         relative_gap=0.0001,
                         absolute_gap=0.0001)
    _execute_single_test(problem,
                         baseline,
                         solver=solver,
                         relative_gap=0.0,
                         absolute_gap=0.0001)
    _execute_single_test(problem,
                         baseline,
                         solver=solver,
                         relative_gap=0.0001,
                         absolute_gap=0.0)

    baseline = SolverResults()
    baseline.solution_status = "optimal"
    baseline.termination_condition = "optimality"
    baseline.objective = 0.0
    baseline.bound = -0.0078125
    baseline.absolute_gap = 0.0078125
    baseline.relative_gap = 0.0078125
    baseline.nodes = None
    baseline.wall_time = _ignore_value_
    problem = zero_objective_min.ZeroObjectiveMin()
    for queue_strategy in sorted(pybnb.QueueStrategy):
        if queue_strategy == "custom":
            continue
        if queue_strategy == "depth":
            baseline.nodes = 2033
        elif queue_strategy == "random":
            baseline.nodes = _ignore_value_
        else:
            baseline.nodes = 255
        _execute_single_test(problem,
                             baseline,
                             solver=solver,
                             relative_gap=0.01,
                             absolute_gap=0.01,
                             queue_strategy=queue_strategy)