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_mzn module
    • CpMultiskillRcpspSolver
      • CpMultiskillRcpspSolver.add_hard_special_constraints()
      • CpMultiskillRcpspSolver.constraint_end_time_string()
      • CpMultiskillRcpspSolver.constraint_objective_equal_makespan()
      • CpMultiskillRcpspSolver.constraint_objective_max_time_set_of_jobs()
      • CpMultiskillRcpspSolver.constraint_start_time_string()
      • CpMultiskillRcpspSolver.constraint_sum_of_ending_time()
      • CpMultiskillRcpspSolver.constraint_sum_of_starting_time()
      • CpMultiskillRcpspSolver.constraint_task_to_mode()
      • CpMultiskillRcpspSolver.constraint_used_employee()
      • CpMultiskillRcpspSolver.init_model()
      • CpMultiskillRcpspSolver.manual_cumulative_resource_constraints()
      • CpMultiskillRcpspSolver.manual_starting_time()
      • CpMultiskillRcpspSolver.problem
      • CpMultiskillRcpspSolver.retrieve_solution()
      • CpMultiskillRcpspSolver.write_search_strategy_chuffed()
    • CpPartialPreemptiveMultiskillRcpspSolver
      • CpPartialPreemptiveMultiskillRcpspSolver.init_model()
    • CpPreemptiveMultiskillRcpspSolver
      • CpPreemptiveMultiskillRcpspSolver.add_hard_special_constraints()
      • CpPreemptiveMultiskillRcpspSolver.constraint_duration_string_preemptive_i()
      • CpPreemptiveMultiskillRcpspSolver.constraint_duration_to_min_duration_preemptive()
      • CpPreemptiveMultiskillRcpspSolver.constraint_end_time_string()
      • CpPreemptiveMultiskillRcpspSolver.constraint_is_paused()
      • CpPreemptiveMultiskillRcpspSolver.constraint_objective_equal_makespan()
      • CpPreemptiveMultiskillRcpspSolver.constraint_objective_max_time_set_of_jobs()
      • CpPreemptiveMultiskillRcpspSolver.constraint_start_time_string()
      • CpPreemptiveMultiskillRcpspSolver.constraint_start_time_string_preemptive_i()
      • CpPreemptiveMultiskillRcpspSolver.constraint_sum_of_ending_time()
      • CpPreemptiveMultiskillRcpspSolver.constraint_sum_of_starting_time()
      • CpPreemptiveMultiskillRcpspSolver.constraint_task_to_mode()
      • CpPreemptiveMultiskillRcpspSolver.constraint_used_employee()
      • CpPreemptiveMultiskillRcpspSolver.init_model()
      • CpPreemptiveMultiskillRcpspSolver.problem
      • CpPreemptiveMultiskillRcpspSolver.retrieve_solution()
    • PrecomputeEmployeesForTasks
      • PrecomputeEmployeesForTasks.init_model()
      • PrecomputeEmployeesForTasks.instance
      • PrecomputeEmployeesForTasks.retrieve_solutions()
      • PrecomputeEmployeesForTasks.solve()
    • SearchStrategyMultiskillRcpsp
      • SearchStrategyMultiskillRcpsp.NONE
      • SearchStrategyMultiskillRcpsp.PRIORITY_SEARCH_START_UNIT_USED
      • SearchStrategyMultiskillRcpsp.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.cp_mzn_mspsp_instlib module
    • CpMspspMznMultiskillRcpspSolver
      • CpMspspMznMultiskillRcpspSolver.constraint_end_time_string()
      • CpMspspMznMultiskillRcpspSolver.constraint_objective_equal_makespan()
      • CpMspspMznMultiskillRcpspSolver.constraint_objective_makespan()
      • CpMspspMznMultiskillRcpspSolver.constraint_objective_max_time_set_of_jobs()
      • CpMspspMznMultiskillRcpspSolver.constraint_start_time_string()
      • CpMspspMznMultiskillRcpspSolver.constraint_sum_of_ending_time()
      • CpMspspMznMultiskillRcpspSolver.constraint_sum_of_starting_time()
      • CpMspspMznMultiskillRcpspSolver.constraint_task_to_mode()
      • CpMspspMznMultiskillRcpspSolver.constraint_used_employee()
      • CpMspspMznMultiskillRcpspSolver.init_from_model()
      • CpMspspMznMultiskillRcpspSolver.init_model()
      • CpMspspMznMultiskillRcpspSolver.problem
      • CpMspspMznMultiskillRcpspSolver.retrieve_solution()
    • chuffed_specific_code()
    • create_usefull_res_data()
  • discrete_optimization.rcpsp_multiskill.solvers.cpsat module
    • CpSatMultiskillRcpspSolver
      • CpSatMultiskillRcpspSolver.add_lexico_constraint()
      • CpSatMultiskillRcpspSolver.constraint_mode()
      • CpSatMultiskillRcpspSolver.constraint_precedence()
      • CpSatMultiskillRcpspSolver.constraint_redundant_cumulative_skills()
      • CpSatMultiskillRcpspSolver.constraint_redundant_cumulative_worker()
      • CpSatMultiskillRcpspSolver.create_base_variable()
      • CpSatMultiskillRcpspSolver.create_constraint_resource()
      • CpSatMultiskillRcpspSolver.create_cost_objective_function()
      • CpSatMultiskillRcpspSolver.create_disjunctive_worker()
      • CpSatMultiskillRcpspSolver.create_employee_intervals()
      • CpSatMultiskillRcpspSolver.create_non_renewable_res_constraint()
      • CpSatMultiskillRcpspSolver.create_opt_variable_modes()
      • CpSatMultiskillRcpspSolver.create_skills_constraint_to_mode()
      • CpSatMultiskillRcpspSolver.create_skills_constraint_worker()
      • CpSatMultiskillRcpspSolver.create_skills_constraints_v2()
      • CpSatMultiskillRcpspSolver.create_skills_variables()
      • CpSatMultiskillRcpspSolver.create_workload_variables()
      • CpSatMultiskillRcpspSolver.get_global_makespan_variable()
      • CpSatMultiskillRcpspSolver.get_lexico_objective_value()
      • CpSatMultiskillRcpspSolver.get_lexico_objectives_available()
      • CpSatMultiskillRcpspSolver.get_task_mode_interval()
      • CpSatMultiskillRcpspSolver.get_task_mode_is_present_variable()
      • CpSatMultiskillRcpspSolver.get_task_start_or_end_variable()
      • CpSatMultiskillRcpspSolver.get_task_unary_resource_interval()
      • CpSatMultiskillRcpspSolver.get_task_unary_resource_is_present_variable()
      • CpSatMultiskillRcpspSolver.hyperparameters
      • CpSatMultiskillRcpspSolver.implements_lexico_api()
      • CpSatMultiskillRcpspSolver.init_model()
      • CpSatMultiskillRcpspSolver.problem
      • CpSatMultiskillRcpspSolver.retrieve_solution()
      • CpSatMultiskillRcpspSolver.set_lexico_objective()
  • discrete_optimization.rcpsp_multiskill.solvers.ga module
    • GaMultiskillRcpspSolver
      • GaMultiskillRcpspSolver.problem
      • GaMultiskillRcpspSolver.solve()
  • discrete_optimization.rcpsp_multiskill.solvers.lns_lp module
    • InitialMultiskillRcpspSolution
      • InitialMultiskillRcpspSolution.get_starting_solution()
  • discrete_optimization.rcpsp_multiskill.solvers.lns_post_process module
    • MultiskillRcpspPostProcessSolution
      • MultiskillRcpspPostProcessSolution.build_other_solution()
    • PreemptiveMultiskillRcpspPostProcessSolution
      • PreemptiveMultiskillRcpspPostProcessSolution.build_other_solution()
    • compute_schedule_per_employees()
    • sgs_variant()
    • sgs_variant_preemptive()
    • shift_left_method()
  • discrete_optimization.rcpsp_multiskill.solvers.lp module
    • MathOptMultiskillRcpspSolver
      • MathOptMultiskillRcpspSolver.convert_to_variable_values()
      • MathOptMultiskillRcpspSolver.init_model()
      • MathOptMultiskillRcpspSolver.problem
      • MathOptMultiskillRcpspSolver.retrieve_current_solution()
      • MathOptMultiskillRcpspSolver.solve()
  • discrete_optimization.rcpsp_multiskill.solvers.multimode_transposition module
    • MultimodeTranspositionMultiskillRcpspSolver
      • MultimodeTranspositionMultiskillRcpspSolver.problem
      • MultimodeTranspositionMultiskillRcpspSolver.solve()
    • rebuild_multiskill_solution()
    • rebuild_multiskill_solution_cp_based()
  • discrete_optimization.rcpsp_multiskill.solvers.optal module
    • OptalMSRcpspSolver
      • OptalMSRcpspSolver.add_employees_calendar_constraint()
      • OptalMSRcpspSolver.add_non_renewable_resources_constraint()
      • OptalMSRcpspSolver.add_renewable_resources_constraint()
      • OptalMSRcpspSolver.add_resource_calendar_constraint()
      • OptalMSRcpspSolver.all_skills_for_task()
      • OptalMSRcpspSolver.constraint_precedence()
      • OptalMSRcpspSolver.constraint_redundant_cumulative_skills()
      • OptalMSRcpspSolver.constraint_redundant_cumulative_worker()
      • OptalMSRcpspSolver.create_cost_objective_function()
      • OptalMSRcpspSolver.create_employee_intervals()
      • OptalMSRcpspSolver.create_main_and_modes_variables()
      • OptalMSRcpspSolver.create_skills_allocated_constraint()
      • OptalMSRcpspSolver.create_skills_req()
      • OptalMSRcpspSolver.get_task_interval_variable()
      • OptalMSRcpspSolver.get_task_mode_is_present_variable()
      • OptalMSRcpspSolver.get_task_unary_resource_is_present_variable()
      • OptalMSRcpspSolver.hyperparameters
      • OptalMSRcpspSolver.init_model()
      • OptalMSRcpspSolver.problem
      • OptalMSRcpspSolver.retrieve_solution()
      • OptalMSRcpspSolver.worker_can_do_task()
  • discrete_optimization.rcpsp_multiskill.solvers.rcpsp_based module
    • RcpspBasedMultiskillRcpspSolver
      • RcpspBasedMultiskillRcpspSolver.problem
      • RcpspBasedMultiskillRcpspSolver.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: MultiskillRcpspProblem)

Bases: object

construct_rcpsp_by_worker_type(limit_number_of_mode_per_task: bool = True, max_number_of_mode: int = 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.parser_imopse module

discrete_optimization.rcpsp_multiskill.parser_imopse.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.parser_imopse.parse_file(file_path, max_horizon=None, one_unit_per_task=True, preemptive=False) → tuple[MultiskillRcpspProblem, dict]

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

discrete_optimization.rcpsp_multiskill.parser_mslib module

discrete_optimization.rcpsp_multiskill.parser_mslib.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.parser_mslib.parse_file(file_path, skill_level_version: bool = True)

discrete_optimization.rcpsp_multiskill.parser_mspsp module

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

discrete_optimization.rcpsp_multiskill.parser_mspsp.parse_file(file_path) → MultiskillRcpspProblem

discrete_optimization.rcpsp_multiskill.problem module

class discrete_optimization.rcpsp_multiskill.problem.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: str) → int

to_json(with_calendar: bool = True)

class discrete_optimization.rcpsp_multiskill.problem.MultiskillRcpspProblem(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: int, tasks_list: list[Hashable] | None = None, employees_list: list[Hashable] | None = None, 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, special_constraints: SpecialConstraintsDescription | None = None, partial_preemption_data: dict[Hashable, dict[int, dict[str, bool]]] = None, always_releasable_resources: set[str] = None, never_releasable_resources: set[str] = None, resource_blocking_data: list[tuple[list[Hashable], set[str]]] = None, strictly_disjunctive_subtasks: bool = True)

Bases: AllocationSchedulingProblem[Hashable, Hashable, str], PrecedenceProblem[Hashable]

build_mode_dict(rcpsp_modes_from_solution)

build_multimode_rcpsp_calendar_representative()

compute_graph() → Graph

compute_lower_bound_nb_employees_per_task_mode(task: Hashable, mode: int) → int

copy()

create_employee_task_compatibility() → None

property cumulative_resources_list: list[str]

List of cumulative resources.

NB: we consider also skills as cumulative resources.

employees: dict[Hashable, Employee]

evaluate(rcpsp_sol: MultiskillRcpspSolution) → 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.

evaluate_function(rcpsp_sol: MultiskillRcpspSolution)

evaluate_mobj(variable: MultiskillRcpspSolution)

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.

Useful to find automatically available mutations for local search. Used by genetic algorithms Ga and Nsga.

This needs only to be implemented in child classes when GA or LS solvers are to be used.

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

get_dummy_solution()

Create a trivial solution for the problem.

Should satisfy the problem ideally. Does not exist for all kind of problems.

get_last_tasks() → list[Hashable]

Get a sublist of tasks that are candidate to be the last one scheduled.

Default to all tasks.

get_makespan_upper_bound() → int

Get a upper bound on global makespan.

get_max_resource_capacity(res)

get_max_skill_over_worker() → dict[str, int]

get_modes_dict(rcpsp_solution: MultiskillRcpspSolution)

get_objective_register() → ObjectiveRegister

Returns the objective definition.

Returns (ObjectiveRegister): object defining the objective criteria.

get_precedence_constraints() → dict[Hashable, list[Hashable]]

Map each task to the tasks that need to be performed after it.

get_resource_availabilities(resource: str | Hashable) → list[tuple[int, int, int]]

Get availabilities intervals for a given resource

List of availability intervals of a resource. If the resource is not available, potentially no interval returned.

It is assumed that the intervals are disjunct though.

Parameters:

resource

Returns:

list of intervals of the form (start, end, value), which means from time start to time end, there are value of the resource available. NB: the start is included, the end is excluded (start <= t < end)

get_resource_availability_array(res)

get_resource_available(res, time)

get_resource_consumption(resource: str, task: Hashable, mode: int) → int

Get resource consumption of the task in the given mode

NB: we consider also skills as cumulative resources.

Parameters:

• resource

• task

• mode – not used for single mode problems

Returns:

the consumption for cumulative resources.

Raises:

ValueError – if resource consumption is depending on other variables than mode

get_resource_names()

get_solution_type() → type[Solution]

Returns the class implementation of a Solution.

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

get_task_mode_duration(task: Hashable, mode: int) → int

Get task duration according to mode.

Parameters:

• task

• mode – not used for single-mode problems

Returns:

get_task_modes(task: Hashable) → set[int]

Retrieve mode found for given task.

Parameters:

task

Returns:

includes_special_constraint()

is_compatible_task_unary_resource(task: Hashable, unary_resource: Hashable) → bool

Should return False if the unary_resource can never be allocated to task.

This is only a hint used to reduce the number of variables or constraints generated.

Default to True, to be overriden in subclasses.

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: MultiskillRcpspSolution) → bool

satisfy_preemptive(rcpsp_sol: PreemptiveMultiskillRcpspSolution) → bool

sgs: ScheduleGenerationScheme

skills_set: set[str]

strictly_disjunctive_subtasks: bool

successors: dict[Hashable, list[Hashable]]

property tasks_list: list[Hashable]

List of all tasks to schedule or allocate to.

to_variant_model()

property unary_resources_list: list[Hashable]

Get available unary resources for allocation.

Warning: This is inherited from AllocationProblem which is used here for the employees allocation. Thus “resource” means “employee” in that particular case.

update_calendars()

update_functions()

update_problem()

Method to call when some attributes have been modified.

It recomputes what is needed (numba functions, calendars, …) It take into account modifications of: - horizon - resource/employee calendars - duration/resource consumption/skill requirement for a given task, mode - special constraints - successors

NB: special constraints may add precedence constraints. A new call to update_problem() with different special constraints will not roll back the updated precedence constraints.

update_resource_availabilities() → None

Method to call when the resource availabilities have changed.

Default implementation clears the cache on get_resource_max_capacity().

update_special_constraints()

class discrete_optimization.rcpsp_multiskill.problem.MultiskillRcpspSolution(problem: Problem, modes: dict[Hashable, int], schedule: dict[Hashable, dict[str, int | list[int]]], employee_usage: dict[Hashable, dict[Hashable, set[str]]])

Bases: AllocationSchedulingSolution[Hashable, Hashable, str]

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_mode(task: Hashable) → int

Retrieve mode found for given task.

Parameters:

task

Returns:

get_number_of_part(task)

get_start_time(task)

get_start_times_list(task)

is_allocated(task: Hashable, unary_resource: Hashable) → bool

Return the usage of the unary resource for the given task.

Parameters:

• task

• unary_resource

Returns:

problem: MultiskillRcpspProblem

class discrete_optimization.rcpsp_multiskill.problem.PreemptiveMultiskillRcpspSolution(problem: Problem, modes: dict[Hashable, int], schedule: dict[Hashable, dict[str, list[int]]], employee_usage: dict[Hashable, list[dict[Hashable, set[str]]]])

Bases: MultiskillRcpspSolution

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.problem.ScheduleGenerationScheme(*values)

Bases: Enum

PARALLEL_SGS = 1

SERIAL_SGS = 0

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

Bases: object

copy()

efficiency_ratio: float

experience: float

skill_value: int

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

Bases: object

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

Bases: object

class discrete_optimization.rcpsp_multiskill.problem.VariantMultiskillRcpspProblem(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, tasks_list: list[Hashable] = None, employees_list: list[Hashable] = None, 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, special_constraints: SpecialConstraintsDescription = None, partial_preemption_data: dict[Hashable, dict[int, dict[str, bool]]] = None, always_releasable_resources: set[str] = None, never_releasable_resources: set[str] = None, resource_blocking_data: list[tuple[list[Hashable], set[str]]] = None, strictly_disjunctive_subtasks: bool = True)

Bases: MultiskillRcpspProblem

convert_fixed_priority_worker_per_task_from_permutation(permutation: list[int]) → list[list[Hashable]]

convert_fixed_priority_worker_per_task_to_permutation(priority_worker_per_task: list[list[Hashable]]) → list[int]

evaluate_function(rcpsp_sol: VariantMultiskillRcpspSolution)

get_attribute_register() → EncodingRegister

Returns how the Solution should be encoded.

Useful to find automatically available mutations for local search. Used by genetic algorithms Ga and Nsga.

This needs only to be implemented in child classes when GA or LS solvers are to be used.

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

get_dummy_solution(preemptive: bool | None = None)

Create a trivial solution for the problem.

Should satisfy the problem ideally. Does not exist for all kind of problems.

get_solution_type() → type[Solution]

Returns the class implementation of a Solution.

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

set_fixed_attributes(attribute_name: str, solution: VariantMultiskillRcpspSolution) → None

Fix some solution attribute.

Useful when applying successively GA on different attribute of the solution, fixing the others.

Should be implemented at least for attributes described by attribute_register.

Parameters:

• attribute_name – an attribute name

• solution

Returns:

set_fixed_modes(fixed_modes)

set_fixed_priority_worker_per_task(fixed_priority_worker_per_task: list[list[Hashable]])

set_fixed_priority_worker_per_task_from_permutation(permutation: list[int])

set_fixed_task_permutation(fixed_permutation)

class discrete_optimization.rcpsp_multiskill.problem.VariantMultiskillRcpspSolution(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, priority_worker_per_task_perm: list[int] | None = None, modes: dict[int, int] = None, schedule: dict[int, dict[str, int]] = None, employee_usage: dict[int, dict[int, set[str]]] = None, fast: bool = True)

Bases: MultiskillRcpspSolution

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)

property priority_worker_per_task_perm: list[int]

Represent priority_worker_per_task as a big permutation.

problem: VariantMultiskillRcpspProblem

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.problem.VariantPreemptiveMultiskillRcpspSolution(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, priority_worker_per_task_perm: list[int] | None = None, modes: dict[int, int] = None, schedule: dict[Hashable, dict[str, list[int]]] = None, employee_usage: dict[Hashable, list[dict[Hashable, set[str]]]] = None, fast: bool = True)

Bases: PreemptiveMultiskillRcpspSolution

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)

property priority_worker_per_task_perm: list[int]

Represent priority_worker_per_task as a big permutation.

problem: VariantMultiskillRcpspProblem

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)

discrete_optimization.rcpsp_multiskill.problem.build_partial_vectors(problem: MultiskillRcpspProblem, completed_tasks: dict[Hashable, TaskDetails], scheduled_tasks_start_times: dict[Hashable, TaskDetails])

discrete_optimization.rcpsp_multiskill.problem.build_partial_vectors_preemptive(problem: MultiskillRcpspProblem, completed_tasks: dict[Hashable, TaskDetailsPreemptive], scheduled_tasks_start_times: dict[Hashable, TaskDetailsPreemptive])

discrete_optimization.rcpsp_multiskill.problem.check_solution(problem: MultiskillRcpspProblem, solution: MultiskillRcpspSolution | PreemptiveMultiskillRcpspSolution, relax_the_start_at_end: bool = True)

discrete_optimization.rcpsp_multiskill.problem.cluster_employees_to_resource_types(ms_rcpsp_problem: MultiskillRcpspProblem)

discrete_optimization.rcpsp_multiskill.problem.compute_constraints_details(solution: MultiskillRcpspSolution | PreemptiveMultiskillRcpspSolution, constraints: SpecialConstraintsDescription)

discrete_optimization.rcpsp_multiskill.problem.compute_discretize_calendar_skills(problem: MultiskillRcpspProblem) → tuple[dict[str, list[dict]], dict[str, ndarray]]

discrete_optimization.rcpsp_multiskill.problem.compute_overskill(problem: MultiskillRcpspProblem, solution: PreemptiveMultiskillRcpspSolution)

discrete_optimization.rcpsp_multiskill.problem.compute_ressource_array_preemptive(problem: MultiskillRcpspProblem, solution: MultiskillRcpspSolution | PreemptiveMultiskillRcpspSolution)

discrete_optimization.rcpsp_multiskill.problem.compute_skills_calendar(problem: MultiskillRcpspProblem)

discrete_optimization.rcpsp_multiskill.problem.compute_skills_missing_problem(problem: MultiskillRcpspProblem, solution: MultiskillRcpspSolution | PreemptiveMultiskillRcpspSolution)

discrete_optimization.rcpsp_multiskill.problem.create_fake_tasks_multiskills(rcpsp_problem: MultiskillRcpspProblem | VariantMultiskillRcpspSolution)

discrete_optimization.rcpsp_multiskill.problem.create_np_data_and_jit_functions(rcpsp_problem: MultiskillRcpspProblem | VariantMultiskillRcpspProblem)

discrete_optimization.rcpsp_multiskill.problem.discretize_calendar_(capacity_calendar: ndarray)

Compute decrease of capacity slots as a list of (interval, consumption)

discrete_optimization.rcpsp_multiskill.problem.employee_usage(solution: MultiskillRcpspSolution | PreemptiveMultiskillRcpspSolution, problem: MultiskillRcpspProblem)

discrete_optimization.rcpsp_multiskill.problem.evaluate_constraints(solution: MultiskillRcpspSolution | PreemptiveMultiskillRcpspSolution, constraints: SpecialConstraintsDescription)

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

discrete_optimization.rcpsp_multiskill.problem.permutation_do_to_permutation_sgs_fast(rcpsp_problem: MultiskillRcpspProblem, permutation_do)

discrete_optimization.rcpsp_multiskill.problem.priority_worker_per_task_do_to_permutation_sgs_fast(rcpsp_problem: MultiskillRcpspProblem, priority_worker_per_task)

discrete_optimization.rcpsp_multiskill.problem.schedule_solution_preemptive_to_variant(solution: PreemptiveMultiskillRcpspSolution)

discrete_optimization.rcpsp_multiskill.problem.schedule_solution_to_variant(solution: MultiskillRcpspSolution)

discrete_optimization.rcpsp_multiskill.problem.sgs_multi_skill(solution: VariantMultiskillRcpspSolution)

discrete_optimization.rcpsp_multiskill.problem.sgs_multi_skill_partial_schedule(solution: VariantMultiskillRcpspSolution, current_t, completed_tasks: dict[Hashable, TaskDetails], scheduled_tasks_start_times: dict[Hashable, TaskDetails])

discrete_optimization.rcpsp_multiskill.problem.sgs_multi_skill_preemptive(solution: VariantPreemptiveMultiskillRcpspSolution)

discrete_optimization.rcpsp_multiskill.problem.sgs_multi_skill_preemptive_partial_schedule(solution: VariantPreemptiveMultiskillRcpspSolution, current_t, completed_tasks: dict[Hashable, TaskDetailsPreemptive], scheduled_tasks_start_times: dict[Hashable, TaskDetailsPreemptive])

discrete_optimization.rcpsp_multiskill.problem.start_together_problem_description(solution: MultiskillRcpspSolution | PreemptiveMultiskillRcpspSolution, constraints: SpecialConstraintsDescription)

discrete_optimization.rcpsp_multiskill.problem.tree()

discrete_optimization.rcpsp_multiskill.solvers_map module

discrete_optimization.rcpsp_multiskill.solvers_map.look_for_solver(domain)

discrete_optimization.rcpsp_multiskill.solvers_map.look_for_solver_class(class_domain)

discrete_optimization.rcpsp_multiskill.solvers_map.return_solver(method, problem: MultiskillRcpspProblem, **args) → ResultStorage

discrete_optimization.rcpsp_multiskill.solvers_map.solve(method, problem: MultiskillRcpspProblem, **args) → ResultStorage

Module contents