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_lexico_objective_value()
      • CpSatMultiskillRcpspSolver.get_lexico_objectives_available()
      • 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.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 = 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, 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: 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.

abstract evaluate_from_encoding(int_vector, encoding_name)

evaluate_function(rcpsp_sol: MultiskillRcpspSolution)

evaluate_mobj(rcpsp_sol: 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.

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

get_dummy_solution()

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

satisfy_preemptive(rcpsp_sol: PreemptiveMultiskillRcpspSolution) → 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.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: 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.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(value)

Bases: Enum

An enumeration.

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 = 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: MultiskillRcpspProblem

convert_fixed_priority_worker_per_task_from_permutation(permutation)

evaluate_from_encoding(int_vector, encoding_name)

evaluate_function(rcpsp_sol: VariantMultiskillRcpspSolution)

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: VariantMultiskillRcpspSolution)

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.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, 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: 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)

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, 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: 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)

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