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_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.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.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.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_cumulative_resource_constraint()
      • 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_is_present_variable()
      • CpSatMultiskillRcpspSolver.get_task_start_or_end_variable()
      • 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.build_command()
      • OptalMSRcpspSolver.init_model()
      • OptalMSRcpspSolver.problem
      • OptalMSRcpspSolver.retrieve_current_solution()
    • dump_to_json()
  • 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)

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, employees_availability: list[int] | None = None, tasks_list: list[Hashable] | None = None, employees_list: list[Hashable] | None = None, horizon_multiplier: int = 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, 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: SchedulingProblem[Hashable], MultimodeProblem[Hashable], AllocationProblem[Hashable, Hashable], PrecedenceProblem[Hashable]

build_mode_dict(rcpsp_modes_from_solution)

build_multimode_rcpsp_calendar_representative()

compute_graph() → Graph

copy()

create_employee_task_compatibility() → None

employees: dict[Hashable, Employee]

employees_availability: list[int]

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_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_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_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_function()

update_functions()

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: SchedulingSolution[Hashable], MultimodeSolution[Hashable], AllocationSolution[Hashable, Hashable]

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: float, efficiency_ratio: float, experience: float)

Bases: object

copy()

efficiency_ratio: float

experience: float

skill_value: float

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], employees_availability: list[int], 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, 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, 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