discrete_optimization.rcpsp_multiskill package

Subpackages

• discrete_optimization.rcpsp_multiskill.plots package
  • Submodules
  • discrete_optimization.rcpsp_multiskill.plots.plot_solution module
    • compute_schedule_per_resource_individual()
    • compute_schedule_per_resource_individual_preemptive()
    • plot_resource_individual_gantt()
    • plot_resource_individual_gantt_preemptive()
    • plot_task_gantt()
  • Module contents
• discrete_optimization.rcpsp_multiskill.solvers package
  • Submodules
  • discrete_optimization.rcpsp_multiskill.solvers.cp_solver_mspsp_instlib module
    • CP_MSPSP_MZN
      • CP_MSPSP_MZN.constraint_end_time_string()
      • CP_MSPSP_MZN.constraint_objective_equal_makespan()
      • CP_MSPSP_MZN.constraint_objective_makespan()
      • CP_MSPSP_MZN.constraint_objective_max_time_set_of_jobs()
      • CP_MSPSP_MZN.constraint_start_time_string()
      • CP_MSPSP_MZN.constraint_sum_of_ending_time()
      • CP_MSPSP_MZN.constraint_sum_of_starting_time()
      • CP_MSPSP_MZN.constraint_task_to_mode()
      • CP_MSPSP_MZN.constraint_used_employee()
      • CP_MSPSP_MZN.init_from_model()
      • CP_MSPSP_MZN.init_model()
      • CP_MSPSP_MZN.problem
      • CP_MSPSP_MZN.retrieve_solution()
    • chuffed_specific_code()
    • create_usefull_res_data()
  • discrete_optimization.rcpsp_multiskill.solvers.cp_solvers module
    • CP_MS_MRCPSP_MZN
      • CP_MS_MRCPSP_MZN.add_hard_special_constraints()
      • CP_MS_MRCPSP_MZN.constraint_end_time_string()
      • CP_MS_MRCPSP_MZN.constraint_objective_equal_makespan()
      • CP_MS_MRCPSP_MZN.constraint_objective_max_time_set_of_jobs()
      • CP_MS_MRCPSP_MZN.constraint_start_time_string()
      • CP_MS_MRCPSP_MZN.constraint_sum_of_ending_time()
      • CP_MS_MRCPSP_MZN.constraint_sum_of_starting_time()
      • CP_MS_MRCPSP_MZN.constraint_task_to_mode()
      • CP_MS_MRCPSP_MZN.constraint_used_employee()
      • CP_MS_MRCPSP_MZN.init_model()
      • CP_MS_MRCPSP_MZN.manual_cumulative_resource_constraints()
      • CP_MS_MRCPSP_MZN.manual_starting_time()
      • CP_MS_MRCPSP_MZN.problem
      • CP_MS_MRCPSP_MZN.retrieve_solution()
      • CP_MS_MRCPSP_MZN.write_search_strategy_chuffed()
    • CP_MS_MRCPSP_MZN_PARTIAL_PREEMPTIVE
      • CP_MS_MRCPSP_MZN_PARTIAL_PREEMPTIVE.init_model()
    • CP_MS_MRCPSP_MZN_PREEMPTIVE
      • CP_MS_MRCPSP_MZN_PREEMPTIVE.add_hard_special_constraints()
      • CP_MS_MRCPSP_MZN_PREEMPTIVE.constraint_duration_string_preemptive_i()
      • CP_MS_MRCPSP_MZN_PREEMPTIVE.constraint_duration_to_min_duration_preemptive()
      • CP_MS_MRCPSP_MZN_PREEMPTIVE.constraint_end_time_string()
      • CP_MS_MRCPSP_MZN_PREEMPTIVE.constraint_is_paused()
      • CP_MS_MRCPSP_MZN_PREEMPTIVE.constraint_objective_equal_makespan()
      • CP_MS_MRCPSP_MZN_PREEMPTIVE.constraint_objective_max_time_set_of_jobs()
      • CP_MS_MRCPSP_MZN_PREEMPTIVE.constraint_start_time_string()
      • CP_MS_MRCPSP_MZN_PREEMPTIVE.constraint_start_time_string_preemptive_i()
      • CP_MS_MRCPSP_MZN_PREEMPTIVE.constraint_sum_of_ending_time()
      • CP_MS_MRCPSP_MZN_PREEMPTIVE.constraint_sum_of_starting_time()
      • CP_MS_MRCPSP_MZN_PREEMPTIVE.constraint_task_to_mode()
      • CP_MS_MRCPSP_MZN_PREEMPTIVE.constraint_used_employee()
      • CP_MS_MRCPSP_MZN_PREEMPTIVE.init_model()
      • CP_MS_MRCPSP_MZN_PREEMPTIVE.problem
      • CP_MS_MRCPSP_MZN_PREEMPTIVE.retrieve_solution()
    • PrecomputeEmployeesForTasks
      • PrecomputeEmployeesForTasks.init_model()
      • PrecomputeEmployeesForTasks.retrieve_solutions()
      • PrecomputeEmployeesForTasks.solve()
    • SearchStrategyMS_MRCPSP
      • SearchStrategyMS_MRCPSP.NONE
      • SearchStrategyMS_MRCPSP.PRIORITY_SEARCH_START_UNIT_USED
      • SearchStrategyMS_MRCPSP.START_THEN_USED_UNIT
    • SolutionPrecomputeEmployeesForTasks
    • add_constraints_string()
    • add_fake_task_cp_data()
    • add_hard_special_constraints()
    • add_soft_special_constraints()
    • define_second_part_objective()
    • hard_end_window()
    • hard_start_after_nunit()
    • hard_start_at_end()
    • hard_start_at_end_plus_offset()
    • hard_start_times()
    • hard_start_together()
    • hard_start_window()
    • soft_end_window()
    • soft_start_after_nunit()
    • soft_start_at_end()
    • soft_start_at_end_plus_offset()
    • soft_start_times()
    • soft_start_together()
    • soft_start_window()
    • stick_to_solution()
    • stick_to_solution_preemptive()
  • discrete_optimization.rcpsp_multiskill.solvers.lns_post_process_rcpsp module
    • PostProMSRCPSP
      • PostProMSRCPSP.build_other_solution()
    • PostProMSRCPSPPreemptive
      • PostProMSRCPSPPreemptive.build_other_solution()
    • compute_schedule_per_employees()
    • sgs_variant()
    • sgs_variant_preemptive()
    • shift_left_method()
  • discrete_optimization.rcpsp_multiskill.solvers.lp_model module
    • LP_Solver_MRSCPSP
      • LP_Solver_MRSCPSP.init_model()
      • LP_Solver_MRSCPSP.problem
      • LP_Solver_MRSCPSP.retrieve_current_solution()
      • LP_Solver_MRSCPSP.solve()
  • discrete_optimization.rcpsp_multiskill.solvers.ms_rcpsp_ga_solver module
    • GA_MSRCPSP_Solver
      • GA_MSRCPSP_Solver.problem
      • GA_MSRCPSP_Solver.solve()
  • discrete_optimization.rcpsp_multiskill.solvers.ms_rcpsp_lp_lns_solver module
    • ConstraintHandlerFixStartTime
      • ConstraintHandlerFixStartTime.adding_constraint_from_results_store()
      • ConstraintHandlerFixStartTime.remove_constraints_from_previous_iteration()
    • ConstraintHandlerStartTimeIntervalMRCPSP
      • ConstraintHandlerStartTimeIntervalMRCPSP.adding_constraint_from_results_store()
      • ConstraintHandlerStartTimeIntervalMRCPSP.remove_constraints_from_previous_iteration()
    • InitialSolutionMS_RCPSP
      • InitialSolutionMS_RCPSP.get_starting_solution()
  • discrete_optimization.rcpsp_multiskill.solvers.multimode_transposition module
    • MultimodeTranspositionSolver
      • MultimodeTranspositionSolver.problem
      • MultimodeTranspositionSolver.solve()
    • rebuild_multiskill_solution()
    • rebuild_multiskill_solution_cp_based()
  • discrete_optimization.rcpsp_multiskill.solvers.solver_rcpsp_based module
    • Solver_RCPSP_Based
      • Solver_RCPSP_Based.problem
      • Solver_RCPSP_Based.solve()
  • Module contents

Submodules

discrete_optimization.rcpsp_multiskill.fast_function_ms_rcpsp module

discrete_optimization.rcpsp_multiskill.fast_function_ms_rcpsp.sgs_fast_ms(permutation_task, priority_worker_per_task, modes_array, consumption_array, skills_needs, duration_array, predecessors, successors, horizon, ressource_available, ressource_renewable, worker_available, worker_skills, minimum_starting_time_array, one_unit_per_task: bool = True)

discrete_optimization.rcpsp_multiskill.fast_function_ms_rcpsp.sgs_fast_ms_partial_schedule(permutation_task, priority_worker_per_task, modes_array, scheduled_task_indicator, scheduled_start_task_times, scheduled_end_task_times, worker_used, current_time, consumption_array, skills_needs, duration_array, predecessors, successors, horizon, ressource_available, ressource_renewable, worker_available, worker_skills, minimum_starting_time_array, one_unit_per_task: bool = True)

discrete_optimization.rcpsp_multiskill.fast_function_ms_rcpsp.sgs_fast_ms_preemptive(permutation_task, priority_worker_per_task, modes_array, consumption_array, skills_needs, duration_array, preemptive_tag, predecessors, successors, horizon, ressource_available, ressource_renewable, worker_available, worker_skills, minimum_starting_time_array, is_releasable, one_unit_per_task: bool = True, consider_partial_preemptive: bool = False, strictly_disjunctive_subtasks: bool = False)

discrete_optimization.rcpsp_multiskill.fast_function_ms_rcpsp.sgs_fast_ms_preemptive_partial_schedule(permutation_task, priority_worker_per_task, modes_array, scheduled_task_indicator, scheduled_start_task_times, scheduled_end_task_times, nb_subparts, worker_used, current_time, consumption_array, skills_needs, duration_array, preemptive_tag, predecessors, successors, horizon, ressource_available, ressource_renewable, worker_available, worker_skills, minimum_starting_time_array, is_releasable, one_unit_per_task: bool = True, consider_partial_preemptive: bool = False)

discrete_optimization.rcpsp_multiskill.fast_function_ms_rcpsp.sgs_fast_ms_preemptive_some_special_constraints(permutation_task, priority_worker_per_task, modes_array, consumption_array, skills_needs, duration_array, preemptive_tag, predecessors, successors, start_at_end_plus_offset, start_after_nunit, horizon, ressource_available, ressource_renewable, worker_available, worker_skills, minimum_starting_time_array, is_releasable, one_unit_per_task: bool = True, consider_partial_preemptive: bool = False, strictly_disjunctive_subtasks: bool = False)

discrete_optimization.rcpsp_multiskill.multiskill_to_rcpsp module

class discrete_optimization.rcpsp_multiskill.multiskill_to_rcpsp.MultiSkillToRCPSP(multiskill_model: MS_RCPSPModel)

Bases: object

construct_rcpsp_by_worker_type(limit_number_of_mode_per_task: bool = True, max_number_of_mode: int | None = None, check_resource_compliance: bool = True, one_worker_type_per_task: bool = False)

is_compatible(task_requirements: Dict[str, int], ressource_availability: Dict[str, array], duration_task, horizon)

discrete_optimization.rcpsp_multiskill.rcpsp_multiskill module

class discrete_optimization.rcpsp_multiskill.rcpsp_multiskill.Employee(dict_skill: Dict[str, SkillDetail], calendar_employee: List[bool], salary: float = 0.0)

Bases: object

calendar_employee: List[bool]

copy()

dict_skill: Dict[str, SkillDetail]

get_non_zero_skills()

get_skill_level(s)

to_json(with_calendar: bool = True)

class discrete_optimization.rcpsp_multiskill.rcpsp_multiskill.MS_RCPSPModel(skills_set: Set[str], resources_set: Set[str], non_renewable_resources: Set[str], resources_availability: Dict[str, List[int]], employees: Dict[Hashable, Employee], mode_details: Dict[Hashable, Dict[int, Dict[str, int]]], successors: Dict[Hashable, List[Hashable]], horizon, employees_availability: List[int] | None = None, tasks_list: List[Hashable] | None = None, employees_list: List[Hashable] | None = None, horizon_multiplier=1, sink_task: Hashable | None = None, source_task: Hashable | None = None, one_unit_per_task_max: bool = False, preemptive: bool = False, preemptive_indicator: Dict[Hashable, bool] | None = None, special_constraints: SpecialConstraintsDescription | None = None, partial_preemption_data: Dict[Hashable, Dict[int, Dict[str, bool]]] | None = None, always_releasable_resources: Set[str] | None = None, never_releasable_resources: Set[str] | None = None, resource_blocking_data: List[Tuple[List[Hashable], Set[str]]] | None = None, strictly_disjunctive_subtasks: bool = True)

Bases: Problem

build_mode_dict(rcpsp_modes_from_solution)

build_multimode_rcpsp_calendar_representative()

compute_graph() → Graph

copy()

employees: Dict[Hashable, Employee]

employees_availability: List[int]

evaluate(rcpsp_sol: MS_RCPSPSolution) → Dict[str, float]

Evaluate a given solution object for the given problem.

This method should return a dictionnary of KPI, that can be then used for mono or multiobjective optimization.

Parameters:

variable (Solution) – the Solution object to evaluate.

Returns: Dictionnary of float kpi for the solution.

abstract evaluate_from_encoding(int_vector, encoding_name)

evaluate_function(rcpsp_sol: MS_RCPSPSolution)

evaluate_mobj(rcpsp_sol: MS_RCPSPSolution)

Default implementation of multiobjective evaluation.

It consists in flattening the evaluate() function and put in an array. User should probably custom this to be more efficient.

Parameters:

variable (Solution) – the Solution object to evaluate.

Returns (TupleFitness): a flattened tuple fitness object representing the multi-objective criteria.

evaluate_mobj_from_dict(dict_values: Dict[str, float]) → TupleFitness

Return an multiobjective fitness from a dictionnary of kpi (output of evaluate function).

It consists in flattening the evaluate() function and put in an array. User should probably custom this to be more efficient.

Parameters:

dict_values – output of evaluate() function

Returns (TupleFitness): a flattened tuple fitness object representing the multi-objective criteria.

get_attribute_register() → EncodingRegister

Returns how the Solution should be encoded.

Returns (EncodingRegister): content of the encoding of the solution

get_dummy_solution()

get_max_resource_capacity(res)

get_modes_dict(rcpsp_solution: MS_RCPSPSolution)

get_objective_register() → ObjectiveRegister

Returns the objective definition.

Returns (ObjectiveRegister): object defining the objective criteria.

get_resource_availability_array(res)

get_resource_available(res, time)

get_resource_names()

get_solution_type() → Type[Solution]

Returns the class implementation of a Solution.

Returns (class): class object of the given Problem.

get_tasks_list()

includes_special_constraint()

is_multiskill()

is_preemptive()

is_rcpsp_multimode()

is_varying_resource()

mode_details: Dict[Hashable, Dict[int, Dict[str, int]]]

n_jobs_non_dummy: int

non_renewable_resources: Set[str]

partial_preemption_data: Dict[Hashable, Dict[int, Dict[str, bool]]]

resource_blocking_data: List[Tuple[List[Hashable], Set[str]]]

resources_availability: Dict[str, List[int]]

resources_set: Set[str]

return_index_task(task, offset=0)

satisfy(variable: Solution) → bool

Computes if a solution satisfies or not the constraints of the problem.

Parameters:

variable – the Solution object to check satisfability

Returns (bool): boolean true if the constraints are fulfilled, false elsewhere.

satisfy_classic(rcpsp_sol: MS_RCPSPSolution) → bool

satisfy_preemptive(rcpsp_sol: MS_RCPSPSolution_Preemptive) → bool

sgs: ScheduleGenerationScheme

skills_set: Set[str]

strictly_disjunctive_subtasks: bool

successors: Dict[Hashable, List[Hashable]]

to_variant_model()

update_function()

update_functions()

class discrete_optimization.rcpsp_multiskill.rcpsp_multiskill.MS_RCPSPModel_Variant(skills_set: Set[str], resources_set: Set[str], non_renewable_resources: Set[str], resources_availability: Dict[str, List[int]], employees: Dict[Hashable, Employee], employees_availability: List[int], mode_details: Dict[Hashable, Dict[int, Dict[str, int]]], successors: Dict[Hashable, List[Hashable]], horizon, tasks_list: List[Hashable] | None = None, employees_list: List[Hashable] | None = None, horizon_multiplier=1, sink_task: Hashable | None = None, source_task: Hashable | None = None, one_unit_per_task_max: bool = False, preemptive: bool = False, preemptive_indicator: Dict[Hashable, bool] | None = None, special_constraints: SpecialConstraintsDescription | None = None, partial_preemption_data: Dict[Hashable, Dict[int, Dict[str, bool]]] | None = None, always_releasable_resources: Set[str] | None = None, never_releasable_resources: Set[str] | None = None, resource_blocking_data: List[Tuple[List[Hashable], Set[str]]] | None = None, strictly_disjunctive_subtasks: bool = True)

Bases: MS_RCPSPModel

convert_fixed_priority_worker_per_task_from_permutation(permutation)

evaluate_from_encoding(int_vector, encoding_name)

evaluate_function(rcpsp_sol: MS_RCPSPSolution_Variant)

get_attribute_register() → EncodingRegister

Returns how the Solution should be encoded.

Returns (EncodingRegister): content of the encoding of the solution

get_dummy_solution(preemptive: bool | None = None)

get_solution_type() → Type[Solution]

Returns the class implementation of a Solution.

Returns (class): class object of the given Problem.

set_fixed_attributes(encoding_str: str, sol: MS_RCPSPSolution_Variant)

set_fixed_modes(fixed_modes)

set_fixed_priority_worker_per_task(fixed_priority_worker_per_task)

set_fixed_priority_worker_per_task_from_permutation(permutation)

set_fixed_task_permutation(fixed_permutation)

class discrete_optimization.rcpsp_multiskill.rcpsp_multiskill.MS_RCPSPSolution(problem: Problem, modes: Dict[Hashable, int], schedule: Dict[Hashable, Dict[str, int | List[int]]], employee_usage: Dict[Hashable, Dict[Hashable, Set[str]]])

Bases: Solution

change_problem(new_problem: Problem)

If relevant to the optimisation problem, change the underlying problem instance for the solution.

This method can be used to evaluate a solution for different instance of problems.

Parameters:

new_problem (Problem) – another problem instance from which the solution can be evaluated

Returns: None

copy()

Deep copy of the solution.

The copy() function should return a new object containing the same input as the current object, that respects the following expected behaviour: -y = x.copy() -if do some inplace change of y, the changes are not done in x.

Returns: a new object from which you can manipulate attributes without changing the original object.

employee_used(task)

get_active_time(task)

get_end_time(task)

get_end_times_list(task)

get_max_end_time()

get_number_of_part(task)

get_start_time(task)

get_start_times_list(task)

class discrete_optimization.rcpsp_multiskill.rcpsp_multiskill.MS_RCPSPSolution_Preemptive(problem: Problem, modes: Dict[Hashable, int], schedule: Dict[Hashable, Dict[str, List[int]]], employee_usage: Dict[Hashable, List[Dict[Hashable, Set[str]]]])

Bases: MS_RCPSPSolution

copy()

Deep copy of the solution.

The copy() function should return a new object containing the same input as the current object, that respects the following expected behaviour: -y = x.copy() -if do some inplace change of y, the changes are not done in x.

Returns: a new object from which you can manipulate attributes without changing the original object.

employee_used(task)

get_active_time(task)

get_end_time(task)

get_end_times_list(task)

get_max_preempted()

get_min_duration_subtask()

get_nb_task_preemption()

get_number_of_part(task)

get_start_time(task)

get_start_times_list(task)

get_task_preempted()

total_number_of_cut()

class discrete_optimization.rcpsp_multiskill.rcpsp_multiskill.MS_RCPSPSolution_Preemptive_Variant(problem: Problem, modes_vector: List[int] | None = None, modes_vector_from0: List[int] | None = None, priority_list_task: List[int] | None = None, priority_worker_per_task: List[List[Hashable]] | None = None, modes: Dict[int, int] | None = None, schedule: Dict[Hashable, Dict[str, List[int]]] | None = None, employee_usage: Dict[Hashable, List[Dict[Hashable, Set[str]]]] | None = None, fast: bool = True)

Bases: MS_RCPSPSolution_Preemptive

copy()

Deep copy of the solution.

The copy() function should return a new object containing the same input as the current object, that respects the following expected behaviour: -y = x.copy() -if do some inplace change of y, the changes are not done in x.

Returns: a new object from which you can manipulate attributes without changing the original object.

do_recompute(fast=True)

run_sgs_partial(current_t, completed_tasks: Dict[Hashable, TaskDetailsPreemptive], scheduled_tasks_start_times: Dict[Hashable, TaskDetailsPreemptive], fast: bool = True)

update_from_numba_output(starts_dict, ends_dict, skills_usage, unfeasible_non_renewable_resources)

class discrete_optimization.rcpsp_multiskill.rcpsp_multiskill.MS_RCPSPSolution_Variant(problem: Problem, modes_vector: List[int] | None = None, modes_vector_from0: List[int] | None = None, priority_list_task: List[int] | None = None, priority_worker_per_task: List[List[Hashable]] | None = None, modes: Dict[int, int] | None = None, schedule: Dict[int, Dict[str, int]] | None = None, employee_usage: Dict[int, Dict[int, Set[str]]] | None = None, fast: bool = True)

Bases: MS_RCPSPSolution

copy()

Deep copy of the solution.

The copy() function should return a new object containing the same input as the current object, that respects the following expected behaviour: -y = x.copy() -if do some inplace change of y, the changes are not done in x.

Returns: a new object from which you can manipulate attributes without changing the original object.

do_recompute(fast=True)

run_sgs_partial(current_t, completed_tasks: Dict[Hashable, TaskDetails], scheduled_tasks_start_times: Dict[Hashable, TaskDetails], fast=True)

update_infos_from_numba_output(rcpsp_schedule, skills_usage, unfeasible_non_renewable_resources)

class discrete_optimization.rcpsp_multiskill.rcpsp_multiskill.ScheduleGenerationScheme(value)

Bases: Enum

An enumeration.

PARALLEL_SGS = 1

SERIAL_SGS = 0

class discrete_optimization.rcpsp_multiskill.rcpsp_multiskill.SkillDetail(skill_value: float, efficiency_ratio: float, experience: float)

Bases: object

copy()

efficiency_ratio: float

experience: float

skill_value: float

class discrete_optimization.rcpsp_multiskill.rcpsp_multiskill.TaskDetails(start, end, resource_units_used: List[int])

Bases: object

class discrete_optimization.rcpsp_multiskill.rcpsp_multiskill.TaskDetailsPreemptive(starts: List[int], ends: List[int], resource_units_used: List[List[Hashable]])

Bases: object

discrete_optimization.rcpsp_multiskill.rcpsp_multiskill.build_partial_vectors(problem: MS_RCPSPModel, completed_tasks: Dict[Hashable, TaskDetails], scheduled_tasks_start_times: Dict[Hashable, TaskDetails])

discrete_optimization.rcpsp_multiskill.rcpsp_multiskill.build_partial_vectors_preemptive(problem: MS_RCPSPModel, completed_tasks: Dict[Hashable, TaskDetailsPreemptive], scheduled_tasks_start_times: Dict[Hashable, TaskDetailsPreemptive])

discrete_optimization.rcpsp_multiskill.rcpsp_multiskill.check_solution(problem: MS_RCPSPModel, solution: MS_RCPSPSolution | MS_RCPSPSolution_Preemptive, relax_the_start_at_end: bool = True)

discrete_optimization.rcpsp_multiskill.rcpsp_multiskill.cluster_employees_to_resource_types(ms_rcpsp_problem: MS_RCPSPModel)

discrete_optimization.rcpsp_multiskill.rcpsp_multiskill.compute_constraints_details(solution: MS_RCPSPSolution | MS_RCPSPSolution_Preemptive, constraints: SpecialConstraintsDescription)

discrete_optimization.rcpsp_multiskill.rcpsp_multiskill.compute_overskill(problem: MS_RCPSPModel, solution: MS_RCPSPSolution_Preemptive)

discrete_optimization.rcpsp_multiskill.rcpsp_multiskill.compute_ressource_array_preemptive(problem: MS_RCPSPModel, solution: MS_RCPSPSolution | MS_RCPSPSolution_Preemptive)

discrete_optimization.rcpsp_multiskill.rcpsp_multiskill.compute_skills_missing_problem(problem: MS_RCPSPModel, solution: MS_RCPSPSolution | MS_RCPSPSolution_Preemptive)

discrete_optimization.rcpsp_multiskill.rcpsp_multiskill.create_fake_tasks_multiskills(rcpsp_problem: MS_RCPSPModel | MS_RCPSPSolution_Variant)

discrete_optimization.rcpsp_multiskill.rcpsp_multiskill.create_np_data_and_jit_functions(rcpsp_problem: MS_RCPSPModel | MS_RCPSPModel_Variant)

discrete_optimization.rcpsp_multiskill.rcpsp_multiskill.employee_usage(solution: MS_RCPSPSolution | MS_RCPSPSolution_Preemptive, problem: MS_RCPSPModel)

discrete_optimization.rcpsp_multiskill.rcpsp_multiskill.evaluate_constraints(solution: MS_RCPSPSolution | MS_RCPSPSolution_Preemptive, constraints: SpecialConstraintsDescription)

discrete_optimization.rcpsp_multiskill.rcpsp_multiskill.intersect(i1, i2)

discrete_optimization.rcpsp_multiskill.rcpsp_multiskill.permutation_do_to_permutation_sgs_fast(rcpsp_problem: MS_RCPSPModel, permutation_do)

discrete_optimization.rcpsp_multiskill.rcpsp_multiskill.priority_worker_per_task_do_to_permutation_sgs_fast(rcpsp_problem: MS_RCPSPModel, priority_worker_per_task)

discrete_optimization.rcpsp_multiskill.rcpsp_multiskill.schedule_solution_preemptive_to_variant(solution: MS_RCPSPSolution_Preemptive)

discrete_optimization.rcpsp_multiskill.rcpsp_multiskill.schedule_solution_to_variant(solution: MS_RCPSPSolution)

discrete_optimization.rcpsp_multiskill.rcpsp_multiskill.sgs_multi_skill(solution: MS_RCPSPSolution_Variant)

discrete_optimization.rcpsp_multiskill.rcpsp_multiskill.sgs_multi_skill_partial_schedule(solution: MS_RCPSPSolution_Variant, current_t, completed_tasks: Dict[Hashable, TaskDetails], scheduled_tasks_start_times: Dict[Hashable, TaskDetails])

discrete_optimization.rcpsp_multiskill.rcpsp_multiskill.sgs_multi_skill_preemptive(solution: MS_RCPSPSolution_Preemptive_Variant)

discrete_optimization.rcpsp_multiskill.rcpsp_multiskill.sgs_multi_skill_preemptive_partial_schedule(solution: MS_RCPSPSolution_Preemptive_Variant, current_t, completed_tasks: Dict[Hashable, TaskDetailsPreemptive], scheduled_tasks_start_times: Dict[Hashable, TaskDetailsPreemptive])

discrete_optimization.rcpsp_multiskill.rcpsp_multiskill.start_together_problem_description(solution: MS_RCPSPSolution | MS_RCPSPSolution_Preemptive, constraints: SpecialConstraintsDescription)

discrete_optimization.rcpsp_multiskill.rcpsp_multiskill.tree()

discrete_optimization.rcpsp_multiskill.rcpsp_multiskill_mslib_parser module

discrete_optimization.rcpsp_multiskill.rcpsp_multiskill_mslib_parser.get_data_available(data_folder: str | None = None, data_home: str | None = None)

Get datasets available for knapsack. Params:

data_folder: folder where datasets for knapsack whould be find.

If None, we look in “knapsack” subdirectory of data_home.

data_home: root directory for all datasets. Is None, set by

default to “~/discrete_optimization_data “

discrete_optimization.rcpsp_multiskill.rcpsp_multiskill_mslib_parser.parse_file_mslib(file_path, skill_level_version: bool = True)

discrete_optimization.rcpsp_multiskill.rcpsp_multiskill_mspsp_parser module

discrete_optimization.rcpsp_multiskill.rcpsp_multiskill_mspsp_parser.get_data_available_mspsp(data_folder: str | None = None, data_home: str | None = None)

discrete_optimization.rcpsp_multiskill.rcpsp_multiskill_mspsp_parser.parse_dzn_file(file_path) → MS_RCPSPModel

discrete_optimization.rcpsp_multiskill.rcpsp_multiskill_parser module

discrete_optimization.rcpsp_multiskill.rcpsp_multiskill_parser.get_data_available(data_folder: str | None = None, data_home: str | None = None)

Get datasets available for rcpsp_multiskill.

Params:

data_folder: folder where datasets for rcpsp_multiskill whould be find.

If None, we look in “rcpsp_multiskill” subdirectory of data_home.

data_home: root directory for all datasets. Is None, set by

default to “~/discrete_optimization_data “

discrete_optimization.rcpsp_multiskill.rcpsp_multiskill_parser.parse_file(file_path, max_horizon=None, one_unit_per_task=True, preemptive=False) → Tuple[MS_RCPSPModel, Dict]

discrete_optimization.rcpsp_multiskill.rcpsp_multiskill_parser.parse_imopse(input_data, max_horizon=None, one_unit_per_task=True, preemptive=False)

discrete_optimization.rcpsp_multiskill.rcpsp_multiskill_solvers module

discrete_optimization.rcpsp_multiskill.rcpsp_multiskill_solvers.look_for_solver(domain)

discrete_optimization.rcpsp_multiskill.rcpsp_multiskill_solvers.look_for_solver_class(class_domain)

discrete_optimization.rcpsp_multiskill.rcpsp_multiskill_solvers.return_solver(method, problem: MS_RCPSPModel, **args) → ResultStorage

discrete_optimization.rcpsp_multiskill.rcpsp_multiskill_solvers.solve(method, problem: MS_RCPSPModel, **args) → ResultStorage

Module contents