discrete_optimization.rcpsp_multiskill.solvers package

Submodules

discrete_optimization.rcpsp_multiskill.solvers.cp_mzn module

class discrete_optimization.rcpsp_multiskill.solvers.cp_mzn.CpMultiskillRcpspSolver(problem: MultiskillRcpspProblem, cp_solver_name: CpSolverName = CpSolverName.CHUFFED, params_objective_function: ParamsObjectiveFunction = None, silent_solve_error: bool = False, **kwargs)

Bases: MinizincCpSolver

add_hard_special_constraints(partial_solution)

constraint_end_time_string(task, end_time, sign: SignEnum = SignEnum.EQUAL) → str

constraint_objective_equal_makespan(task_sink)

constraint_objective_max_time_set_of_jobs(set_of_jobs)

constraint_start_time_string(task, start_time, sign: SignEnum = SignEnum.EQUAL) → str

constraint_sum_of_ending_time(set_subtasks: set[Hashable])

constraint_sum_of_starting_time(set_subtasks: set[Hashable])

constraint_task_to_mode(task_id, mode)

constraint_used_employee(task, employee, indicator: bool = False)

init_model(**args)

Instantiate a CP model instance

Afterwards, self.instance should not be None anymore.

manual_cumulative_resource_constraints(instance)

manual_starting_time(instance)

problem: MultiskillRcpspProblem

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

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:

write_search_strategy_chuffed(instance)

class discrete_optimization.rcpsp_multiskill.solvers.cp_mzn.CpPartialPreemptiveMultiskillRcpspSolver(problem: MultiskillRcpspProblem, cp_solver_name: CpSolverName = CpSolverName.CHUFFED, params_objective_function: ParamsObjectiveFunction = None, silent_solve_error: bool = False, **kwargs)

Bases: CpPreemptiveMultiskillRcpspSolver

init_model(**args)

Instantiate a CP model instance

Afterwards, self.instance should not be None anymore.

class discrete_optimization.rcpsp_multiskill.solvers.cp_mzn.CpPreemptiveMultiskillRcpspSolver(problem: MultiskillRcpspProblem, cp_solver_name: CpSolverName = CpSolverName.CHUFFED, params_objective_function: ParamsObjectiveFunction = None, silent_solve_error: bool = False, **kwargs)

Bases: MinizincCpSolver

add_hard_special_constraints(partial_solution)

constraint_duration_string_preemptive_i(task, duration, part_id=1, sign: SignEnum = SignEnum.EQUAL) → str

constraint_duration_to_min_duration_preemptive(task, min_duration)

constraint_end_time_string(task, end_time, sign: SignEnum = SignEnum.EQUAL) → str

constraint_is_paused(task, is_paused)

constraint_objective_equal_makespan(task_sink)

constraint_objective_max_time_set_of_jobs(set_of_jobs)

constraint_start_time_string(task, start_time, sign: SignEnum = SignEnum.EQUAL) → str

constraint_start_time_string_preemptive_i(task, start_time, part_id=1, sign: SignEnum = SignEnum.EQUAL) → str

constraint_sum_of_ending_time(set_subtasks: set[Hashable])

constraint_sum_of_starting_time(set_subtasks: set[Hashable])

constraint_task_to_mode(task_id, mode)

constraint_used_employee(task, employee, part_id=1, indicator: bool = False)

init_model(**args)

Instantiate a CP model instance

Afterwards, self.instance should not be None anymore.

problem: MultiskillRcpspProblem

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

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.rcpsp_multiskill.solvers.cp_mzn.PrecomputeEmployeesForTasks(ms_rcpsp_problem: MultiskillRcpspProblem, cp_solver_name: CpSolverName = CpSolverName.CHUFFED)

Bases: object

init_model(**kwargs)

instance: Instance

retrieve_solutions(result, parameters_cp: ParametersCp)

solve(parameters_cp: ParametersCp | None = None, time_limit: float | None = 100.0, nr_solutions: int = 100, all_solutions: bool = False, **args)

Solve the CP problem with minizinc

Parameters:

• parameters_cp – parameters specific to CP solvers

• time_limit – the solve process stops after this time limit (in seconds). If None, no time limit is applied.

• nr_solutions – of not all_solutions, the solve stops after finding nr_solutions

• all_solutions – if True, do not stop when reaching nr_solutions

• **args – passed to init_model()

Returns:

class discrete_optimization.rcpsp_multiskill.solvers.cp_mzn.SearchStrategyMultiskillRcpsp(*values)

Bases: Enum

NONE = 'none'

PRIORITY_SEARCH_START_UNIT_USED = 'priority_smallest'

START_THEN_USED_UNIT = 'durThenStartThenMode'

class discrete_optimization.rcpsp_multiskill.solvers.cp_mzn.SolutionPrecomputeEmployeesForTasks(unit_used, worker_type_used, mode_dict, overskill_unit, overskill_type)

Bases: object

discrete_optimization.rcpsp_multiskill.solvers.cp_mzn.add_constraints_string(child_instance, list_of_strings)

discrete_optimization.rcpsp_multiskill.solvers.cp_mzn.add_fake_task_cp_data(rcpsp_problem: MultiskillRcpspProblem, ignore_fake_task: bool = True, max_time_to_consider: int = None)

discrete_optimization.rcpsp_multiskill.solvers.cp_mzn.add_hard_special_constraints(partial_solution: PartialSolution, cp_solver: CpMultiskillRcpspSolver | CpPreemptiveMultiskillRcpspSolver)

discrete_optimization.rcpsp_multiskill.solvers.cp_mzn.add_soft_special_constraints(partial_solution: PartialSolution, cp_solver: CpMultiskillRcpspSolver | CpPreemptiveMultiskillRcpspSolver)

discrete_optimization.rcpsp_multiskill.solvers.cp_mzn.define_second_part_objective(weights, name_penalty, equal=False)

discrete_optimization.rcpsp_multiskill.solvers.cp_mzn.hard_end_window(end_times_window: dict[Hashable, tuple[int, int]], cp_solver: CpMultiskillRcpspSolver | CpPreemptiveMultiskillRcpspSolver)

discrete_optimization.rcpsp_multiskill.solvers.cp_mzn.hard_start_after_end_plus_offset(list_start_after_end_plus_offset, cp_solver: CpMultiskillRcpspSolver | CpPreemptiveMultiskillRcpspSolver)

discrete_optimization.rcpsp_multiskill.solvers.cp_mzn.hard_start_after_nunit(list_start_after_nunit: list[tuple[Hashable, Hashable, int]], cp_solver: CpMultiskillRcpspSolver | CpPreemptiveMultiskillRcpspSolver)

discrete_optimization.rcpsp_multiskill.solvers.cp_mzn.hard_start_at_end(list_start_at_end: list[tuple[Hashable, Hashable]], cp_solver: CpMultiskillRcpspSolver | CpPreemptiveMultiskillRcpspSolver)

discrete_optimization.rcpsp_multiskill.solvers.cp_mzn.hard_start_times(dict_start_times: dict[Hashable, int], cp_solver: CpMultiskillRcpspSolver | CpPreemptiveMultiskillRcpspSolver)

discrete_optimization.rcpsp_multiskill.solvers.cp_mzn.hard_start_together(list_start_together: list[tuple[Hashable, Hashable]], cp_solver: CpMultiskillRcpspSolver | CpPreemptiveMultiskillRcpspSolver)

discrete_optimization.rcpsp_multiskill.solvers.cp_mzn.hard_start_window(start_times_window: dict[Hashable, tuple[int, int]], cp_solver: CpMultiskillRcpspSolver | CpPreemptiveMultiskillRcpspSolver)

discrete_optimization.rcpsp_multiskill.solvers.cp_mzn.soft_end_window(end_times_window: dict[Hashable, tuple[int, int]], cp_solver: CpMultiskillRcpspSolver | CpPreemptiveMultiskillRcpspSolver)

discrete_optimization.rcpsp_multiskill.solvers.cp_mzn.soft_start_after_end_plus_offset(list_start_after_end_plus_offset: list[tuple[Hashable, Hashable, int]], cp_solver: CpMultiskillRcpspSolver | CpPreemptiveMultiskillRcpspSolver)

discrete_optimization.rcpsp_multiskill.solvers.cp_mzn.soft_start_after_nunit(list_start_after_nunit: list[tuple[Hashable, Hashable, int]], cp_solver: CpMultiskillRcpspSolver | CpPreemptiveMultiskillRcpspSolver)

discrete_optimization.rcpsp_multiskill.solvers.cp_mzn.soft_start_at_end(list_start_at_end: list[tuple[Hashable, Hashable]], cp_solver: CpMultiskillRcpspSolver | CpPreemptiveMultiskillRcpspSolver)

discrete_optimization.rcpsp_multiskill.solvers.cp_mzn.soft_start_times(dict_start_times: dict[Hashable, int], cp_solver: CpMultiskillRcpspSolver | CpPreemptiveMultiskillRcpspSolver)

discrete_optimization.rcpsp_multiskill.solvers.cp_mzn.soft_start_together(list_start_together: list[tuple[Hashable, Hashable]], cp_solver: CpMultiskillRcpspSolver | CpPreemptiveMultiskillRcpspSolver)

discrete_optimization.rcpsp_multiskill.solvers.cp_mzn.soft_start_window(start_times_window: dict[Hashable, tuple[int, int]], cp_solver: CpMultiskillRcpspSolver | CpPreemptiveMultiskillRcpspSolver)

discrete_optimization.rcpsp_multiskill.solvers.cp_mzn.stick_to_solution(solution: RcpspSolution, cp_solver: CpMultiskillRcpspSolver)

discrete_optimization.rcpsp_multiskill.solvers.cp_mzn.stick_to_solution_preemptive(solution: PreemptiveRcpspSolution, cp_solver: CpPreemptiveMultiskillRcpspSolver)

discrete_optimization.rcpsp_multiskill.solvers.cp_mzn_mspsp_instlib module

class discrete_optimization.rcpsp_multiskill.solvers.cp_mzn_mspsp_instlib.CpMspspMznMultiskillRcpspSolver(problem: MultiskillRcpspProblem, cp_solver_name: CpSolverName = CpSolverName.CHUFFED, params_objective_function: ParamsObjectiveFunction = None, silent_solve_error: bool = False, **kwargs)

Bases: MinizincCpSolver

constraint_end_time_string(task, end_time, sign: SignEnum = SignEnum.EQUAL) → str

constraint_objective_equal_makespan(task_sink)

constraint_objective_makespan()

constraint_objective_max_time_set_of_jobs(set_of_jobs)

constraint_start_time_string(task, start_time, sign: SignEnum = SignEnum.EQUAL) → str

constraint_sum_of_ending_time(set_subtasks: set[Hashable])

constraint_sum_of_starting_time(set_subtasks: set[Hashable])

constraint_task_to_mode(task_id, mode)

constraint_used_employee(task, employee, indicator: bool = False)

init_from_model(**args)

init_model(**args)

Instantiate a CP model instance

Afterwards, self.instance should not be None anymore.

problem: MultiskillRcpspProblem

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

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:

discrete_optimization.rcpsp_multiskill.solvers.cp_mzn_mspsp_instlib.chuffed_specific_code()

discrete_optimization.rcpsp_multiskill.solvers.cp_mzn_mspsp_instlib.create_usefull_res_data(rcpsp_problem: MultiskillRcpspProblem)

discrete_optimization.rcpsp_multiskill.solvers.cpsat module

class discrete_optimization.rcpsp_multiskill.solvers.cpsat.CpSatMultiskillRcpspSolver(problem: Problem, params_objective_function: ParamsObjectiveFunction | None = None, **kwargs: Any)

Bases: GenericSchedulingAutoCpSatSolver[Hashable, Hashable, str, str, str]

avoid_interval_optional: bool = False

Whether using task intervals + demand vars instead of optional intervals depending on is_present[mode].

convert_task_variables_to_solution(raw_sol: RawSolution[Hashable, Hashable, str]) → Solution

Convert solution from autosolver format into do format.

To be used in self.retrieve_solution().

Parameters:

raw_sol

Returns:

create_total_cost_variable()

create_workload_variables()

hyperparameters: list[Hyperparameter] = [CategoricalHyperparameter(name='redundant_skill_cumulative', default=True, depends_on=None, name_in_kwargs='redundant_skill_cumulative'), CategoricalHyperparameter(name='redundant_worker_cumulative', default=True, depends_on=None, name_in_kwargs='redundant_worker_cumulative')]

Hyperparameters available for this solver.

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

• __init__()

• init_model() (when available)

• solve()

include_constraint_on_cumulative_resource(resource: str) → bool

Whether the cp model should take into account the constraint on the given cumulative resource.

The constraints on skills as cumulative resources and on number of employees are to be added according to redundant_skill_cumulative and redundant_worker_cumulative hyperparameters.

Parameters:

resource

Returns:

init_model(**kwargs: Any) → None

Init cp model and reset stored variables if any.

problem: MultiskillRcpspProblem

retrieve_tasks_variables(cpsolvercb: CpSolverSolutionCallback) → RawSolution[Hashable, Hashable, str]

Construct each task variable 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).

We override the method from generic auto solver to add internal objective value.

Parameters:

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

Returns:

the task variables for the intermediate solution

use_only_skill_to_allocate: bool = True

Do not allocate a unary_resource if not contributing to a skill needed by a given task.

discrete_optimization.rcpsp_multiskill.solvers.ga module

class discrete_optimization.rcpsp_multiskill.solvers.ga.GaMultiskillRcpspSolver(problem: Problem, params_objective_function: ParamsObjectiveFunction | None = None, **kwargs: Any)

Bases: SolverDO

problem: RcpspProblem

solve(parameters_ga: ParametersAltGa = None, **args)

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.rcpsp_multiskill.solvers.lns_lp module

class discrete_optimization.rcpsp_multiskill.solvers.lns_lp.InitialMultiskillRcpspSolution(problem: MultiskillRcpspProblem, params_objective_function: ParamsObjectiveFunction = None, initial_method: InitialRcpspMethod = InitialRcpspMethod.PILE)

Bases: InitialSolution

get_starting_solution() → ResultStorage

discrete_optimization.rcpsp_multiskill.solvers.lns_post_process module

class discrete_optimization.rcpsp_multiskill.solvers.lns_post_process.MultiskillRcpspPostProcessSolution(problem: MultiskillRcpspProblem, params_objective_function: ParamsObjectiveFunction = None)

Bases: PostProcessSolution

build_other_solution(result_storage: ResultStorage) → ResultStorage

class discrete_optimization.rcpsp_multiskill.solvers.lns_post_process.PreemptiveMultiskillRcpspPostProcessSolution(problem: MultiskillRcpspProblem, params_objective_function: ParamsObjectiveFunction = None)

Bases: PostProcessSolution

build_other_solution(result_storage: ResultStorage) → ResultStorage

discrete_optimization.rcpsp_multiskill.solvers.lns_post_process.compute_schedule_per_employees(solution: PreemptiveMultiskillRcpspSolution | MultiskillRcpspSolution, problem: MultiskillRcpspProblem, predecessors_dict)

discrete_optimization.rcpsp_multiskill.solvers.lns_post_process.sgs_variant(solution: MultiskillRcpspSolution, problem: MultiskillRcpspProblem, predecessors_dict)

discrete_optimization.rcpsp_multiskill.solvers.lns_post_process.sgs_variant_preemptive(solution: PreemptiveMultiskillRcpspSolution, problem: MultiskillRcpspProblem, predecessors_dict)

discrete_optimization.rcpsp_multiskill.solvers.lns_post_process.shift_left_method(solution: PreemptiveMultiskillRcpspSolution | MultiskillRcpspSolution, problem: MultiskillRcpspProblem, predecessors_dict)

discrete_optimization.rcpsp_multiskill.solvers.lp module

class discrete_optimization.rcpsp_multiskill.solvers.lp.MathOptMultiskillRcpspSolver(problem: MultiskillRcpspProblem, params_objective_function: ParamsObjectiveFunction = None, **kwargs)

Bases: OrtoolsMathOptMilpSolver

convert_to_variable_values(solution: MultiskillRcpspSolution) → dict[Variable, int]

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.

Implement it in subclasses to have a proper warm start.

init_model(**args)

Initialize internal model used to solve.

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

problem: MultiskillRcpspProblem

retrieve_current_solution(get_var_value_for_current_solution: Callable[[Any], float], get_obj_value_for_current_solution: Callable[[], float]) → MultiskillRcpspSolution

Retrieve current solution from internal gurobi solution.

This converts internal gurobi solution into a discrete-optimization Solution. This method can be called after the solve in retrieve_solutions() or during solve within a gurobi/pymilp/cplex callback. The difference will be the get_var_value_for_current_solution and get_obj_value_for_current_solution callables passed.

Parameters:

• get_var_value_for_current_solution – function extracting the value of the given variable for the current solution will be different when inside a callback or after the solve is finished

• get_obj_value_for_current_solution – function extracting the value of the objective for the current solution.

Returns:

the converted solution at d-o format

solve(parameters_milp: ParametersMilp | None = None, time_limit: float | None = 30.0, **args) → ResultStorage

Solve with OR-Tools MathOpt API

Parameters:

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

• parameters_milp – parameters passed to the MILP solver

• mathopt_solver_type – underlying solver type to use. Passed as solver_type to mathopt.solve()

• time_limit – the solve process stops after this time limit (in seconds). If None, no time limit is applied.

• mathopt_enable_output – turn on mathopt logging

• mathopt_model_parameters – passed to mathopt.solve() as model_params

• mathopt_additional_solve_parameters – passed to mathopt.solve() as params, except that parameters defined by above time_limit and parameters_milp will be overriden by them.

• store_mathopt_res – whether to store the mathopt.SolveResult generated by mathopt.solve()

• extract_solutions_from_mathopt_res – whether to extract solutions from the mathopt.SolveResult generated by mathopt.solve(). If False, the solutions are rather extracted on the fly inside a callback at each mip solution improvement. By default, this is False except for HiGHS solver type, as its OR-Tools wrapper does not yet integrate callbacks.

• **kwargs – passed to init_model() if model not yet existing

Returns:

discrete_optimization.rcpsp_multiskill.solvers.multimode_transposition module

class discrete_optimization.rcpsp_multiskill.solvers.multimode_transposition.MultimodeTranspositionMultiskillRcpspSolver(problem: MultiskillRcpspProblem, multimode_problem: RcpspProblem | PreemptiveRcpspProblem = None, worker_type_to_worker: dict[str, set[str | int]] = None, params_objective_function: ParamsObjectiveFunction = None, solver_multimode_rcpsp: SolverDO = None, limit_number_of_mode_per_task: bool = True, max_number_of_mode: int = 3, check_resource_compliance: bool = True, reconstruction_cp_time_limit: int = 3600, **kwargs)

Bases: SolverDO

problem: MultiskillRcpspProblem

solve(**kwargs) → ResultStorage

Solve the multi-skill RCPSP using two-stage decomposition. The idea is to transform MS-RCPSP to multi-mode RCPSP by abstracting employees as worker types.

Returns:

ResultStorage containing the reconstructed multi-skill RCPSP solutions

discrete_optimization.rcpsp_multiskill.solvers.multimode_transposition.rebuild_multiskill_solution(multiskill_rcpsp_problem: MultiskillRcpspProblem, multimode_rcpsp_problem: RcpspProblem | PreemptiveRcpspProblem, worker_type_to_worker: dict[str, set[str | int]], solution_rcpsp: RcpspSolution | PreemptiveRcpspSolution) → MultiskillRcpspSolution | PreemptiveMultiskillRcpspSolution

This function takes the schedule from the RCPSP solution and rebuilds the solution for the multiskill problem. NOTE: need review, this function is currently not used.

discrete_optimization.rcpsp_multiskill.solvers.multimode_transposition.rebuild_multiskill_solution_cp_based(multiskill_rcpsp_problem: MultiskillRcpspProblem, multimode_rcpsp_problem: RcpspProblem | PreemptiveRcpspProblem, worker_type_to_worker: dict[str, set[str | int]], solution_rcpsp: RcpspSolution | PreemptiveRcpspSolution, time_limit: int = 3600) → ResultStorage

Reconstructs a valid multi-skill RCPSP solution from the schedule from an RCPSP solution by assigning specific employees to tasks.

Parameters:

• multiskill_rcpsp_problem – The multi-skill RCPSP problem

• multimode_rcpsp_problem – The multimode RCPSP problem (for reference)

• worker_type_to_worker – Mapping from worker types to employee sets

• solution_rcpsp – The RCPSP solution to constrain to

• time_limit – Time limit in seconds for CP solver

Returns:

containing the reconstructed multi-skill RCPSP solutions

Return type:

ResultStorage

discrete_optimization.rcpsp_multiskill.solvers.optal module

class discrete_optimization.rcpsp_multiskill.solvers.optal.OptalMSRcpspSolver(problem: MultiskillRcpspProblem, params_objective_function: ParamsObjectiveFunction | None = None, **args)

Bases: SchedulingOptalSolver[Hashable], MultimodeOptalSolver[Hashable], AllocationOptalSolver[Hashable, Hashable]

add_employees_calendar_constraint()

add_non_renewable_resources_constraint(res: str)

add_renewable_resources_constraint(res: str)

add_resource_calendar_constraint()

all_skills_for_task(task: Hashable) → list[Hashable]

constraint_precedence()

constraint_redundant_cumulative_skills()

constraint_redundant_cumulative_worker()

create_cost_objective_function()

create_employee_intervals(one_worker_per_task: bool, one_skill_per_task: bool)

create_main_and_modes_variables()

create_skills_allocated_constraint()

create_skills_req()

get_task_interval_variable(task: Task) → cp.IntervalVar

Retrieve the interval variable of given task.

get_task_mode_is_present_variable(task: Task, mode: int) → cp.BoolExpr

Retrieve the 0-1 variable/expression telling if the mode is used for the task.

Parameters:

• task

• mode

Returns:

get_task_unary_resource_is_present_variable(task: Task, unary_resource: UnaryResource) → cp.BoolExpr

Return a 0-1 variable/expression telling if the unary_resource is used for the task.

NB: sometimes the given resource is never to be used by a task and the variable has not been created. The convention is to return 0 in that case.

hyperparameters = [CategoricalHyperparameter(name='redundant_skill_cumulative', default=True, depends_on=None, name_in_kwargs='redundant_skill_cumulative'), CategoricalHyperparameter(name='redundant_worker_cumulative', default=True, depends_on=None, name_in_kwargs='redundant_worker_cumulative')]

Hyperparameters available for this solver.

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

• __init__()

• init_model() (when available)

• solve()

init_model(**args: Any) → None

Instantiate a CP model instance

Afterwards, self.instance should not be None anymore.

problem: MultiskillRcpspProblem

retrieve_solution(result: cp.SolveResult) → MultiskillRcpspSolution

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

Parameters:

result – output of the cp.solve

Returns:

worker_can_do_task(task: Hashable, worker: Hashable, one_worker_per_task: bool) → bool

discrete_optimization.rcpsp_multiskill.solvers.rcpsp_based module

class discrete_optimization.rcpsp_multiskill.solvers.rcpsp_based.RcpspBasedMultiskillRcpspSolver(problem: MultiskillRcpspProblem | VariantMultiskillRcpspProblem, method, params_objective_function: ParamsObjectiveFunction = None, **args)

Bases: SolverDO

problem: MultiskillRcpspProblem | VariantMultiskillRcpspProblem

solve(**kwargs)

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

Module contents