discrete_optimization.knapsack.solvers package

Submodules

discrete_optimization.knapsack.solvers.asp module

class discrete_optimization.knapsack.solvers.asp.AspKnapsackSolver(problem: Problem, params_objective_function: ParamsObjectiveFunction | None = None, **kwargs: Any)

Bases: AspClingoSolver, KnapsackSolver

Solver based on Answer Set Programming formulation and clingo solver.

build_string_data_input()

init_model(**kwargs: Any) → None

Initialize internal model used to solve.

Can initialize a ortools, milp, gurobi, … model.

retrieve_solution(model: Model) → KnapsackSolution

Construct a do solution from a clingo model.

Parameters:

model – the current constructed clingo model

Returns:

the intermediate solution, at do format.

discrete_optimization.knapsack.solvers.cp_mzn module

class discrete_optimization.knapsack.solvers.cp_mzn.Cp2KnapsackSolver(problem: KnapsackProblem, params_objective_function: ParamsObjectiveFunction | None = None, silent_solve_error: bool = False, **kwargs: Any)

Bases: MinizincCpSolver, KnapsackSolver

hyperparameters: list[Hyperparameter] = [EnumHyperparameter(name='cp_solver_name', default=<CpSolverName.CHUFFED: 0>, depends_on=None, name_in_kwargs='cp_solver_name')]

Hyperparameters available for this solver.

These hyperparameters are to be feed to **kwargs found in

• __init__()

• init_model() (when available)

• solve()

init_model(**kwargs: Any) → None

Instantiate a CP model instance

Afterwards, self.instance should not be None anymore.

retrieve_solution(_output_item: str | None = None, **kwargs: Any) → KnapsackSolution

Return a d-o solution from the variables computed by minizinc.

Parameters:

• _output_item – string representing the minizinc solver output passed by minizinc to the solution constructor

• **kwargs – keyword arguments passed by minzinc to the solution contructor containing the objective value (key “objective”), and the computed variables as defined in minizinc model.

Returns:

class discrete_optimization.knapsack.solvers.cp_mzn.CpKnapsackSolver(problem: KnapsackProblem, params_objective_function: ParamsObjectiveFunction | None = None, silent_solve_error: bool = False, **kwargs: Any)

Bases: MinizincCpSolver, KnapsackSolver

hyperparameters: list[Hyperparameter] = [EnumHyperparameter(name='cp_solver_name', default=<CpSolverName.CHUFFED: 0>, depends_on=None, name_in_kwargs='cp_solver_name')]

Hyperparameters available for this solver.

These hyperparameters are to be feed to **kwargs found in

• __init__()

• init_model() (when available)

• solve()

init_model(**kwargs: Any) → None

Instantiate a CP model instance

Afterwards, self.instance should not be None anymore.

retrieve_solution(_output_item: str | None = None, **kwargs: Any) → KnapsackSolution

Return a d-o solution from the variables computed by minizinc.

Parameters:

• _output_item – string representing the minizinc solver output passed by minizinc to the solution constructor

• **kwargs – keyword arguments passed by minzinc to the solution contructor containing the objective value (key “objective”), and the computed variables as defined in minizinc model.

Returns:

class discrete_optimization.knapsack.solvers.cp_mzn.CpMultidimensionalKnapsackSolver(problem: MultidimensionalKnapsackProblem, params_objective_function: ParamsObjectiveFunction | None = None, silent_solve_error: bool = False, **kwargs: Any)

Bases: MinizincCpSolver

hyperparameters: list[Hyperparameter] = [EnumHyperparameter(name='cp_solver_name', default=<CpSolverName.CHUFFED: 0>, depends_on=None, name_in_kwargs='cp_solver_name')]

Hyperparameters available for this solver.

These hyperparameters are to be feed to **kwargs found in

• __init__()

• init_model() (when available)

• solve()

init_model(**kwargs: Any) → None

Instantiate a CP model instance

Afterwards, self.instance should not be None anymore.

problem: MultidimensionalKnapsackProblem

retrieve_solution(_output_item: str | None = None, **kwargs: Any) → MultidimensionalKnapsackSolution

Return a d-o solution from the variables computed by minizinc.

Parameters:

• _output_item – string representing the minizinc solver output passed by minizinc to the solution constructor

• **kwargs – keyword arguments passed by minzinc to the solution contructor containing the objective value (key “objective”), and the computed variables as defined in minizinc model.

Returns:

class discrete_optimization.knapsack.solvers.cp_mzn.CpMultidimensionalMultiScenarioKnapsackSolver(problem: MultiScenarioMultidimensionalKnapsackProblem, params_objective_function: ParamsObjectiveFunction | None = None, silent_solve_error: bool = False, **kwargs: Any)

Bases: MinizincCpSolver

hyperparameters: list[Hyperparameter] = [EnumHyperparameter(name='cp_solver_name', default=<CpSolverName.CHUFFED: 0>, depends_on=None, name_in_kwargs='cp_solver_name')]

Hyperparameters available for this solver.

These hyperparameters are to be feed to **kwargs found in

• __init__()

• init_model() (when available)

• solve()

init_model(**kwargs: Any) → None

Instantiate a CP model instance

Afterwards, self.instance should not be None anymore.

problem: MultiScenarioMultidimensionalKnapsackProblem

retrieve_solution(_output_item: str | None = None, **kwargs: Any) → MultidimensionalKnapsackSolution

Return a d-o solution from the variables computed by minizinc.

Parameters:

• _output_item – string representing the minizinc solver output passed by minizinc to the solution constructor

• **kwargs – keyword arguments passed by minzinc to the solution contructor containing the objective value (key “objective”), and the computed variables as defined in minizinc model.

Returns:

class discrete_optimization.knapsack.solvers.cp_mzn.KnapsackConstraintHandler(fraction_fix: float = 0.95)

Bases: MznConstraintHandler

adding_constraint_from_results_store(solver: MinizincCpSolver, child_instance: Instance, result_storage: ResultStorage, last_result_store: ResultStorage | None = None, **kwargs: Any) → Iterable[Any]

hyperparameters: list[Hyperparameter] = [FloatHyperparameter(name='fraction_fix', default=0.95, depends_on=None, name_in_kwargs='fraction_fix', low=0.0, high=1.0, suggest_low=False, suggest_high=False, step=None, log=False)]

Hyperparameters available for this solver.

These hyperparameters are to be feed to **kwargs found in

• __init__()

• init_model() (when available)

• solve()

discrete_optimization.knapsack.solvers.cpmpy module

class discrete_optimization.knapsack.solvers.cpmpy.CpmpyKnapsackSolver(problem: KnapsackProblem, params_objective_function: ParamsObjectiveFunction | None = None, **kwargs)

Bases: KnapsackSolver

init_model(**kwargs: Any) → None

Initialize internal model used to solve.

Can initialize a ortools, milp, gurobi, … model.

solve(time_limit: float | None = 100.0, **kwargs: Any) → ResultStorage

time_limit: the solve process stops after this time limit (in seconds).

If None, no time limit is applied.

Parameters:

• time_limit

• **kwargs

Returns:

discrete_optimization.knapsack.solvers.cpsat module

class discrete_optimization.knapsack.solvers.cpsat.CpSatKnapsackSolver(problem: KnapsackProblem, params_objective_function: ParamsObjectiveFunction | None = None, **kwargs)

Bases: OrtoolsCpSatSolver, KnapsackSolver, WarmstartMixin

add_lexico_constraint(obj: str, value: float) → Iterable[Constraint]

Parameters:

• obj – a string representing the desired objective. Should be one of self.problem.get_objective_names().

• value – the limiting value. If the optimization direction is maximizing, this is a lower bound, else this is an upper bound.

Returns:

the created constraints.

get_lexico_objectives_available() → list[str]

List objectives available for lexico optimization

It corresponds to the labels accepted for obj argument for - set_lexico_objective() - add_lexico_constraint() - get_lexico_objective_value()

Default to self.problem.get_objective_names().

Returns:

static implements_lexico_api() → bool

Tell whether this solver is implementing the api for lexicographic optimization.

Should return True only if

• set_lexico_objective()

• add_lexico_constraint()

• get_lexico_objective_value()

have been really implemented, i.e. - calling set_lexico_objective() and add_lexico_constraint()

should actually change the next call to solve(),

• get_lexico_objective_value() should correspond to the internal model objective

init_model(**args: Any) → None

Init CP model.

retrieve_solution(cpsolvercb: CpSolverSolutionCallback) → KnapsackSolution

Construct a do solution from the cpsat solver internal solution.

It will be called each time the cpsat solver find a new solution. At that point, value of internal variables are accessible via cpsolvercb.Value(VARIABLE_NAME).

Parameters:

cpsolvercb – the ortools callback called when the cpsat solver finds a new solution.

Returns:

the intermediate solution, at do format.

set_lexico_objective(obj: str) → None

Update internal model objective.

Parameters:

obj – a string representing the desired objective. Should be one of self.get_lexico_objectives_available().

Returns:

set_warm_start(solution: KnapsackSolution) → None

Make the solver warm start from the given solution.

discrete_optimization.knapsack.solvers.decomposition module

class discrete_optimization.knapsack.solvers.decomposition.DecomposedKnapsackSolver(problem: Problem, params_objective_function: ParamsObjectiveFunction | None = None, **kwargs: Any)

Bases: KnapsackSolver, WarmstartMixin

This solver is based on the current observation. From a given knapsack model and one current solution, if we decide to freeze the decision variable for a subset of items, the remaining problem to solve is also a knapsack problem, with fewer items and smaller capacity. A solution to this subproblem can be found by any knapsack solver and a full solution to the original problem, can be rebuilt. DecomposedKnapsackSolver is a basic iterative solver that starts from a given solution, then freeze random items, solve subproblem with a custom root solver, rebuild original solution and repeat the process.

hyperparameters: list[Hyperparameter] = [FloatHyperparameter(name='proportion_to_remove', default=0.7, depends_on=None, name_in_kwargs='proportion_to_remove', low=0.0, high=1.0, suggest_low=False, suggest_high=False, step=None, log=False), IntegerHyperparameter(name='nb_iteration', default=100, depends_on=None, name_in_kwargs='nb_iteration', low=0, high=10000000, step=1, log=False), SubBrickHyperparameter(name='initial_solver', default=SubBrick(cls=<class 'discrete_optimization.knapsack.solvers.greedy.GreedyBestKnapsackSolver'>, kwargs={}, kwargs_from_solution=None), depends_on=None, name_in_kwargs='initial_solver'), SubBrickHyperparameter(name='root_solver', default=SubBrick(cls=<class 'discrete_optimization.knapsack.solvers.greedy.GreedyBestKnapsackSolver'>, kwargs={}, kwargs_from_solution=None), depends_on=None, name_in_kwargs='root_solver')]

Hyperparameters available for this solver.

These hyperparameters are to be feed to **kwargs found in

• __init__()

• init_model() (when available)

• solve()

initial_solution: KnapsackSolution | None = None

Initial solution used for warm start.

rebuild_sol(sol: KnapsackSolution, original_knapsack_problem: KnapsackProblem, original_solution: KnapsackSolution, indexes_to_remove: set[int])

Rebuild a knapsack solution object from a partial solution. :param sol: solution to a sub-knapsack problem :param original_knapsack_problem: original knapsack model to solve :param original_solution: original base solution :param indexes_to_remove: indexes of item removed when building the sub-knapsack problem. :return: A new solution object for the original problem.

set_warm_start(solution: KnapsackSolution) → None

Make the solver warm start from the given solution.

Will be ignored if arg initial_solver is set and not None in call to solve().

solve(callbacks: list[Callback] | None = None, **kwargs: Any) → ResultStorage

Generic solving function.

Parameters:

• callbacks – list of callbacks used to hook into the various stage of the solve

• **kwargs – any argument specific to the solver

Solvers deriving from SolverDo should use callbacks methods .on_step_end(), … during solve(). But some solvers are not yet updated and are just ignoring it.

Returns (ResultStorage): a result object containing potentially a pool of solutions to a discrete-optimization problem

discrete_optimization.knapsack.solvers.dp module

class discrete_optimization.knapsack.solvers.dp.DpKnapsackSolver(problem: Problem, params_objective_function: ParamsObjectiveFunction | None = None, **kwargs: Any)

Bases: KnapsackSolver, DpSolver, WarmstartMixin

hyperparameters: list[Hyperparameter] = [CategoricalHyperparameter(name='solver', default=<class 'builtins.CABS'>, depends_on=None, name_in_kwargs='solver'), CategoricalHyperparameter(name='float_cost', default=False, depends_on=None, name_in_kwargs='float_cost'), CategoricalHyperparameter(name='dual_bound', default=True, depends_on=('float_cost', True), name_in_kwargs='dual_bound')]

Hyperparameters available for this solver.

These hyperparameters are to be feed to **kwargs found in

• __init__()

• init_model() (when available)

• solve()

init_model(**kwargs)

Initialize internal model used to solve.

Can initialize a ortools, milp, gurobi, … model.

init_model_float(**kwargs)

init_model_int(**kwargs)

Adapted from https://didppy.readthedocs.io/en/stable/quickstart.html

retrieve_solution(sol: Solution) → Solution

set_warm_start(solution: KnapsackSolution) → None

Make the solver warm start from the given solution.

transitions: dict

class discrete_optimization.knapsack.solvers.dp.ExactDpKnapsackSolver(problem: KnapsackProblem, params_objective_function: ParamsObjectiveFunction | None = None, **kwargs)

Bases: KnapsackSolver

hyperparameters: list[Hyperparameter] = [CategoricalHyperparameter(name='greedy_start', default=False, depends_on=None, name_in_kwargs='greedy_start')]

Hyperparameters available for this solver.

These hyperparameters are to be feed to **kwargs found in

• __init__()

• init_model() (when available)

• solve()

solve(**kwargs: Any) → ResultStorage

Generic solving function.

Parameters:

• callbacks – list of callbacks used to hook into the various stage of the solve

• **kwargs – any argument specific to the solver

Solvers deriving from SolverDo should use callbacks methods .on_step_end(), … during solve(). But some solvers are not yet updated and are just ignoring it.

Returns (ResultStorage): a result object containing potentially a pool of solutions to a discrete-optimization problem

discrete_optimization.knapsack.solvers.gphh module

class discrete_optimization.knapsack.solvers.gphh.FeatureEnum(value)

Bases: Enum

An enumeration.

AVG_RES_CONSUMPTION_DELTA_CAPACITY = 'avg_res_consumption_delta_capacity'

CAPACITIES = 'capacities'

PROFIT = 'profit'

RES_CONSUMPTION_ARRAY = 'res_consumption'

class discrete_optimization.knapsack.solvers.gphh.GphhKnapsackSolver(problem: MultidimensionalKnapsackProblem, training_domains: list[MultidimensionalKnapsackProblem] | None = None, weight: int = 1, params_gphh: ParametersGphh | None = None, params_objective_function: ParamsObjectiveFunction | None = None, **kwargs)

Bases: SolverDO

build_result_storage_for_domain(domain: MultidimensionalKnapsackProblem) → ResultStorage

build_solution(domain: MultidimensionalKnapsackProblem, individual: Any | None = None, func_heuristic: Callable[[...], float] | None = None) → MultidimensionalKnapsackSolution

evaluate_complexity(individual: Any) → float

evaluate_heuristic(individual: Any, domains: list[MultidimensionalKnapsackProblem]) → list[float]

hyperparameters: list[Hyperparameter] = [FloatHyperparameter(name='tournament_ratio', default=0.1, depends_on=None, name_in_kwargs='tournament_ratio', low=0, high=1.0, suggest_low=False, suggest_high=False, step=None, log=False), IntegerHyperparameter(name='pop_size', default=10, depends_on=None, name_in_kwargs='pop_size', low=1, high=100, step=1, log=False), IntegerHyperparameter(name='min_tree_depth', default=1, depends_on=None, name_in_kwargs='min_tree_depth', low=1, high=20, step=1, log=False), IntegerHyperparameter(name='max_tree_depth', default=4, depends_on=None, name_in_kwargs='max_tree_depth', low=1, high=20, step=1, log=False), FloatHyperparameter(name='crossover_rate', default=0.7, depends_on=None, name_in_kwargs='crossover_rate', low=0.0, high=1.0, suggest_low=False, suggest_high=False, step=None, log=False), FloatHyperparameter(name='mutation_rate', default=0.3, depends_on=None, name_in_kwargs='mutation_rate', low=0, high=1.0, suggest_low=False, suggest_high=False, step=None, log=False), IntegerHyperparameter(name='n_gen', default=2, depends_on=None, name_in_kwargs='n_gen', low=1, high=100, step=1, log=False)]

Hyperparameters available for this solver.

These hyperparameters are to be feed to **kwargs found in

• __init__()

• init_model() (when available)

• solve()

init_model(**kwargs) → None

Initialize internal model used to solve.

Can initialize a ortools, milp, gurobi, … model.

init_primitives(pset: PrimitiveSetTyped) → PrimitiveSetTyped

plot_solution(show: bool = True) → None

solve(**kwargs: Any) → ResultStorage

Generic solving function.

Parameters:

• callbacks – list of callbacks used to hook into the various stage of the solve

• **kwargs – any argument specific to the solver

Solvers deriving from SolverDo should use callbacks methods .on_step_end(), … during solve(). But some solvers are not yet updated and are just ignoring it.

Returns (ResultStorage): a result object containing potentially a pool of solutions to a discrete-optimization problem

toolbox: Toolbox

class discrete_optimization.knapsack.solvers.gphh.ParametersGphh(list_feature: list[FeatureEnum], set_primitves: PrimitiveSetTyped, tournament_ratio: float, pop_size: int, n_gen: int, min_tree_depth: int, max_tree_depth: int, crossover_rate: float, mutation_rate: float, deap_verbose: bool)

Bases: object

static default() → ParametersGphh

discrete_optimization.knapsack.solvers.gphh.get_avg_res_consumption_delta_capacity(problem: MultidimensionalKnapsackProblem, item_index: int, **kwargs: Any) → float

discrete_optimization.knapsack.solvers.gphh.get_capacities(problem: MultidimensionalKnapsackProblem, **kwargs: Any) → list[float]

discrete_optimization.knapsack.solvers.gphh.get_profit(problem: MultidimensionalKnapsackProblem, item_index: int, **kwargs: Any) → float

discrete_optimization.knapsack.solvers.gphh.get_res_consumption(problem: MultidimensionalKnapsackProblem, item_index: int, **kwargs: Any) → list[float]

discrete_optimization.knapsack.solvers.greedy module

class discrete_optimization.knapsack.solvers.greedy.GreedyBestKnapsackSolver(problem: Problem, params_objective_function: ParamsObjectiveFunction | None = None, **kwargs: Any)

Bases: KnapsackSolver

solve(**kwargs: Any) → ResultStorage

Generic solving function.

Parameters:

• callbacks – list of callbacks used to hook into the various stage of the solve

• **kwargs – any argument specific to the solver

Solvers deriving from SolverDo should use callbacks methods .on_step_end(), … during solve(). But some solvers are not yet updated and are just ignoring it.

Returns (ResultStorage): a result object containing potentially a pool of solutions to a discrete-optimization problem

class discrete_optimization.knapsack.solvers.greedy.GreedyDummyKnapsackSolver(problem: Problem, params_objective_function: ParamsObjectiveFunction | None = None, **kwargs: Any)

Bases: KnapsackSolver

solve(**kwargs: Any) → ResultStorage

Generic solving function.

Parameters:

• callbacks – list of callbacks used to hook into the various stage of the solve

• **kwargs – any argument specific to the solver

Solvers deriving from SolverDo should use callbacks methods .on_step_end(), … during solve(). But some solvers are not yet updated and are just ignoring it.

Returns (ResultStorage): a result object containing potentially a pool of solutions to a discrete-optimization problem

discrete_optimization.knapsack.solvers.greedy.best_of_greedy(knapsack_problem: KnapsackProblem) → KnapsackSolution

discrete_optimization.knapsack.solvers.greedy.compute_density(knapsack_problem: KnapsackProblem) → list[Item]

discrete_optimization.knapsack.solvers.greedy.compute_density_and_penalty(knapsack_problem: KnapsackProblem) → list[Item]

discrete_optimization.knapsack.solvers.greedy.greedy_using_queue(knapsack_problem: KnapsackProblem, method_queue: Callable[[KnapsackProblem], list[Item]] | None = None) → KnapsackSolution

discrete_optimization.knapsack.solvers.knapsack_solver module

class discrete_optimization.knapsack.solvers.knapsack_solver.KnapsackSolver(problem: Problem, params_objective_function: ParamsObjectiveFunction | None = None, **kwargs: Any)

Bases: SolverDO

problem: KnapsackProblem

discrete_optimization.knapsack.solvers.lns_cp module

class discrete_optimization.knapsack.solvers.lns_cp.KnapsackMznConstraintHandler(problem: KnapsackProblem, fraction_to_fix: float = 0.9)

Bases: MznConstraintHandler

adding_constraint_from_results_store(solver: MinizincCpSolver, child_instance: Instance, result_storage: ResultStorage, last_result_store: ResultStorage | None = None, **kwargs: Any) → Iterable[Any]

hyperparameters: list[Hyperparameter] = [FloatHyperparameter(name='fraction_to_fix', default=0.9, depends_on=None, name_in_kwargs='fraction_to_fix', low=0.0, high=1.0, suggest_low=False, suggest_high=False, step=None, log=False)]

Hyperparameters available for this solver.

These hyperparameters are to be feed to **kwargs found in

• __init__()

• init_model() (when available)

• solve()

class discrete_optimization.knapsack.solvers.lns_cp.OrtoolsCpSatKnapsackConstraintHandler(problem: KnapsackProblem, fraction_to_fix: float = 0.9)

Bases: OrtoolsCpSatConstraintHandler

adding_constraint_from_results_store(solver: OrtoolsCpSatSolver, result_storage: ResultStorage, last_result_store: ResultStorage | None = None, **kwargs: Any) → Iterable[Constraint]

hyperparameters: list[Hyperparameter] = [FloatHyperparameter(name='fraction_to_fix', default=0.9, depends_on=None, name_in_kwargs='fraction_to_fix', low=0.0, high=1.0, suggest_low=False, suggest_high=False, step=None, log=False)]

Hyperparameters available for this solver.

These hyperparameters are to be feed to **kwargs found in

• __init__()

• init_model() (when available)

• solve()

discrete_optimization.knapsack.solvers.lns_lp module

class discrete_optimization.knapsack.solvers.lns_lp.InitialKnapsackMethod(value)

Bases: Enum

An enumeration.

DUMMY = 0

GREEDY = 1

class discrete_optimization.knapsack.solvers.lns_lp.InitialKnapsackSolution(problem: KnapsackProblem, initial_method: InitialKnapsackMethod, params_objective_function: ParamsObjectiveFunction)

Bases: InitialSolution

get_starting_solution() → ResultStorage

hyperparameters: list[Hyperparameter] = [EnumHyperparameter(name='initial_method', default=None, depends_on=None, name_in_kwargs='initial_method')]

Hyperparameters available for this solver.

These hyperparameters are to be feed to **kwargs found in

• __init__()

• init_model() (when available)

• solve()

class discrete_optimization.knapsack.solvers.lns_lp.MathOptKnapsackConstraintHandler(problem: KnapsackProblem, fraction_to_fix: float = 0.9)

Bases: OrtoolsMathOptConstraintHandler

adding_constraint_from_results_store(solver: MathOptKnapsackSolver, result_storage: ResultStorage, **kwargs: Any) → Iterable[Any]

discrete_optimization.knapsack.solvers.lp module

class discrete_optimization.knapsack.solvers.lp.CbcKnapsackSolver(problem: KnapsackProblem, params_objective_function: ParamsObjectiveFunction | None = None, **kwargs: Any)

Bases: KnapsackSolver

init_model(warm_start: dict[int, int] | None = None, **kwargs: Any) → None

Initialize internal model used to solve.

Can initialize a ortools, milp, gurobi, … model.

solve(**kwargs: Any) → ResultStorage

Generic solving function.

Parameters:

• callbacks – list of callbacks used to hook into the various stage of the solve

• **kwargs – any argument specific to the solver

Solvers deriving from SolverDo should use callbacks methods .on_step_end(), … during solve(). But some solvers are not yet updated and are just ignoring it.

Returns (ResultStorage): a result object containing potentially a pool of solutions to a discrete-optimization problem

class discrete_optimization.knapsack.solvers.lp.GurobiKnapsackSolver(problem: KnapsackProblem, params_objective_function: ParamsObjectiveFunction | None = None, **kwargs: Any)

Bases: GurobiMilpSolver, _BaseLpKnapsackSolver

convert_to_variable_values(solution: KnapsackSolution) → dict[Var, float]

Convert a solution to a mapping between model variables and their values.

Will be used by set_warm_start().

init_model(**kwargs: Any) → None

Initialize internal model used to solve.

Can initialize a ortools, milp, gurobi, … model.

class discrete_optimization.knapsack.solvers.lp.MathOptKnapsackSolver(problem: KnapsackProblem, params_objective_function: ParamsObjectiveFunction | None = None, **kwargs: Any)

Bases: OrtoolsMathOptMilpSolver, _BaseLpKnapsackSolver

convert_to_variable_values(solution: KnapsackSolution) → dict[Variable, float]

Convert a solution to a mapping between model variables and their values.

Will be used by set_warm_start() to provide a suitable SolutionHint.variable_values. See https://or-tools.github.io/docs/pdoc/ortools/math_opt/python/model_parameters.html#SolutionHint for more information.

class discrete_optimization.knapsack.solvers.lp.OrtoolsKnapsackSolver(problem: Problem, params_objective_function: ParamsObjectiveFunction | None = None, **kwargs: Any)

Bases: KnapsackSolver

init_model(**kwargs: Any) → None

Initialize internal model used to solve.

Can initialize a ortools, milp, gurobi, … model.

model: knapsack_solver.KnapsackSolver | None = None

solve(**kwargs: Any) → ResultStorage

Generic solving function.

Parameters:

• callbacks – list of callbacks used to hook into the various stage of the solve

• **kwargs – any argument specific to the solver

Solvers deriving from SolverDo should use callbacks methods .on_step_end(), … during solve(). But some solvers are not yet updated and are just ignoring it.

Returns (ResultStorage): a result object containing potentially a pool of solutions to a discrete-optimization problem

discrete_optimization.knapsack.solvers.quantum module

class discrete_optimization.knapsack.solvers.quantum.KnapsackQiskit(problem: KnapsackProblem)

Bases: object

interpret(result: object | ndarray)

to_quadratic_program() → object

class discrete_optimization.knapsack.solvers.quantum.QaoaKnapsackSolver(problem: KnapsackProblem, params_objective_function: ParamsObjectiveFunction | None = None, **kwargs)

Bases: KnapsackSolver, QiskitQaoaSolver

init_model(**kwargs)

Initialize internal model used to solve.

Can initialize a ortools, milp, gurobi, … model.

retrieve_current_solution(result) → Solution

Retrieve current solution from qiskit result.

Parameters:

result – list of value for each binary variable of the problem

Returns:

the converted solution at d-o format

class discrete_optimization.knapsack.solvers.quantum.VqeKnapsackSolver(problem: KnapsackProblem, params_objective_function: ParamsObjectiveFunction | None = None, **kwargs)

Bases: KnapsackSolver, QiskitVqeSolver

init_model(**kwargs)

Initialize internal model used to solve.

Can initialize a ortools, milp, gurobi, … model.

retrieve_current_solution(result) → Solution

Retrieve current solution from qiskit result.

Parameters:

result – list of value for each binary variable of the problem

Returns:

the converted solution at d-o format

Module contents