discrete_optimization.generic_tasks_tools.objectives package

Submodules

discrete_optimization.generic_tasks_tools.objectives.allocated_tasks module

class discrete_optimization.generic_tasks_tools.objectives.allocated_tasks.AllocatedTasksObjective(problem: TasksProblem[Task] = None, weight_objective: float = 1.0)

Bases: ObjectiveComputer[Task], Generic[Task, UnaryResource]

compute_objective(solution: AllocationSolution[Task, UnaryResource])

static get_objective_name() → Objective | str

problem: AllocationProblem[Task, UnaryResource]

discrete_optimization.generic_tasks_tools.objectives.allocation_changes module

class discrete_optimization.generic_tasks_tools.objectives.allocation_changes.AllocationSwitchObjectiveComputer(problem: AllocationProblem[Task, UnaryResource], base_allocation_solution: AllocationSolution[Task, UnaryResource] = None, weight_objective: float = 1.0, switch_on_cost: dict[Task, dict[UnaryResource, int]] = None, switch_off_cost: dict[Task, dict[UnaryResource, int]] = None)

Bases: ObjectiveComputer[Task], Generic[Task, UnaryResource]

base_allocation_solution: AllocationSolution[Task, UnaryResource]

compute_objective(solution: AllocationSolution[Task, UnaryResource]) → float

static get_objective_name() → Objective | str

get_switch_off_cost(task: Task, unary_resource: UnaryResource) → int

get_switch_on_cost(task: Task, unary_resource: UnaryResource) → int

has_switch_off_cost()

has_switch_on_cost()

has_switches_cost()

problem: AllocationProblem[Task, UnaryResource]

set_base_allocation_solution(allocation_solution: AllocationSolution[Task, UnaryResource])

discrete_optimization.generic_tasks_tools.objectives.allocation_cost module

class discrete_optimization.generic_tasks_tools.objectives.allocation_cost.AllocationCostComputer(problem: AllocationProblem[Task, UnaryResource] = None, weight_objective: float = 1.0, cost_allocation_resource_to_task: dict[Task, dict[UnaryResource, int]] = None)

Bases: ObjectiveComputer[Task], Generic[Task, UnaryResource]

compute_objective(solution: AllocationSolution[Task, UnaryResource]) → float

cost_allocation_resource_to_task(task: Task, unary_resource: UnaryResource) → float

static get_objective_name() → Objective | str

has_any_cost_allocation()

problem: AllocationProblem[Task, UnaryResource]

class discrete_optimization.generic_tasks_tools.objectives.allocation_cost.AllocationCostComputerMultimode(problem: MultimodeAllocationProblem[Task, UnaryResource] = None, weight_objective: float = 1.0, cost_allocation_resource_to_task_mode: dict[tuple[Task, int], dict[UnaryResource, int]] = None)

Bases: ObjectiveComputer[Task], Generic[Task, UnaryResource]

compute_objective(solution: MultimodeAllocationSolution[Task, UnaryResource]) → float

cost_allocation_resource_to_task_mode(task: Task, mode: int, unary_resource: UnaryResource) → float

static get_objective_name() → Objective | str

get_tasks_having_cost()

has_any_cost_allocation()

problem: MultimodeAllocationProblem[Task, UnaryResource]

class discrete_optimization.generic_tasks_tools.objectives.allocation_cost.MultimodeAllocationProblem

Bases: AllocationProblem[Task, UnaryResource], MultimodeProblem[Task]

class discrete_optimization.generic_tasks_tools.objectives.allocation_cost.MultimodeAllocationSolution(problem: Problem)

Bases: AllocationSolution[Task, UnaryResource], MultimodeSolution[Task]

discrete_optimization.generic_tasks_tools.objectives.cumul_cost module

class discrete_optimization.generic_tasks_tools.objectives.cumul_cost.CumulCostComputer(problem: GenericSchedulingProblem[Task, UnaryResource, Skill, NonSkillCumulativeResource, NonRenewableResource] = None, weight_objective: float = 1.0, cumul_dimensions: list[CUMUL_DIMENSIONS] = None, value_tasks: dict[CUMUL_DIMENSIONS, dict[Task, float]] = None, value_tasks_per_mode: dict[CUMUL_DIMENSIONS, dict[tuple[Task, int], float]] = None)

Bases: ObjectiveComputer[Task], Generic[Task, UnaryResource, Skill, NonSkillCumulativeResource, NonRenewableResource]

compute_objective(solution: GenericSchedulingSolution[Task, UnaryResource, Skill, NonSkillCumulativeResource, NonRenewableResource]) → float

depends_on_mode(dimension: CUMUL_DIMENSIONS, task: Task)

static get_objective_name() → Objective | str

get_value_dimension_task_mode(dimension: CUMUL_DIMENSIONS, task: Task, mode: int)

problem: GenericSchedulingProblem[Task, UnaryResource, Skill, NonSkillCumulativeResource, NonRenewableResource]

discrete_optimization.generic_tasks_tools.objectives.earliness_tardiness module

class discrete_optimization.generic_tasks_tools.objectives.earliness_tardiness.EarlinessTardinessComputer(problem: SchedulingProblem[Task], weight_objective: float = 1.0, max_start_and_weight_for_tardiness: dict[Task, tuple[int | None, int | None]] = None, max_end_and_weight_for_tardiness: dict[Task, tuple[int | None, int | None]] = None, min_start_and_weight_for_earliness: dict[Task, tuple[int | None, int | None]] = None, min_end_and_weight_for_earliness: dict[Task, tuple[int | None, int | None]] = None)

Bases: ObjectiveComputer[Task]

compute_aggregated_cost(solution: SchedulingSolution[Task]) → float

compute_earliness_cost(solution: SchedulingSolution[Task]) → float

compute_earliness_end(solution: SchedulingSolution[Task], task: Task) → float

compute_earliness_start(solution: SchedulingSolution[Task], task: Task) → float

compute_objective(solution: TasksSolution) → float

compute_tardiness_cost(solution: SchedulingSolution[Task]) → float

compute_tardiness_end(solution: SchedulingSolution[Task], task: Task) → float

compute_tardiness_start(solution: SchedulingSolution[Task], task: Task) → float

detailed_objectives(solution: SchedulingSolution[Task]) → dict[tuple[str, str], dict[Task, int]]

get_max_end_for_tardiness(task: Task) → int

get_max_start_for_tardiness(task: Task) → int | None

get_min_end_for_earliness(task: Task) → int

get_min_start_for_earliness(task: Task) → int

static get_objective_name() → Objective | str

get_tasks_having_max_end_for_tardiness() → list[Task]

get_tasks_having_max_start_for_tardiness() → list[Task]

get_tasks_having_min_end_for_earliness() → list[Task]

get_tasks_having_min_start_for_earliness() → list[Task]

get_weight_end_for_earliness(task: Task) → float

get_weight_end_for_tardiness(task: Task) → float

get_weight_start_for_earliness(task: Task) → float

get_weight_start_for_tardiness(task: Task) → float

problem: SchedulingProblem[Task]

discrete_optimization.generic_tasks_tools.objectives.makespan module

class discrete_optimization.generic_tasks_tools.objectives.makespan.MakespanObjectiveComputer(problem: TasksProblem[Task] = None, weight_objective: float = 1.0)

Bases: ObjectiveComputer[Task]

compute_objective(solution: SchedulingSolution[Task]) → int

static get_objective_name() → Objective | str

problem: SchedulingProblem[Task]

discrete_optimization.generic_tasks_tools.objectives.mode_cost module

class discrete_optimization.generic_tasks_tools.objectives.mode_cost.ModeCostComputer(problem: MultimodeProblem[Task] = None, weight_objective: float = 1.0, mode_cost: dict[Task, dict[int, int]] = None)

Bases: ObjectiveComputer[Task]

compute_objective(solution: MultimodeSolution[Task]) → float

static get_objective_name() → Objective | str

has_any_mode_cost()

mode_cost(task: Task, mode: int) → float

problem: MultimodeProblem[Task]

discrete_optimization.generic_tasks_tools.objectives.objective_computer module

class discrete_optimization.generic_tasks_tools.objectives.objective_computer.ObjectiveComputer(problem: TasksProblem[Task] = None, weight_objective: float = 1.0)

Bases: ABC, Generic[Task]

abstractmethod compute_objective(solution: TasksSolution) → float

static get_objective_name() → Objective | str

problem: TasksProblem[Task]

set_problem(problem: TasksProblem[Task])

property weight_cost: float

discrete_optimization.generic_tasks_tools.objectives.resource_levels module

class discrete_optimization.generic_tasks_tools.objectives.resource_levels.CalendarRenewableResourceLevelObjectiveComputer(problem: CalendarResourceProblem[Task, Resource], weight_objective: float = 1.0, weight_resource: dict[Resource, float] = None)

Bases: ObjectiveComputer[Task], Generic[Task, Resource]

compute_objective(solution: CalendarResourceSolution[Task, Resource]) → float

static get_objective_name() → Objective | str

get_weight_resource(resource: Resource) → float

has_any_weight()

problem: CalendarResourceProblem[Task, Resource]

class discrete_optimization.generic_tasks_tools.objectives.resource_levels.NonRenewableResourceLevelObjectiveComputer(problem: NonRenewableResourceProblem[Task, Resource], weight_objective: float = 1.0, weight_resource: dict[Resource, float] = None)

Bases: ObjectiveComputer[Task], Generic[Task, NonRenewableResource]

compute_objective(solution: NonRenewableResourceSolution[Task, NonRenewableResource]) → float

static get_objective_name() → Objective | str

get_weight_resource(resource: Resource) → float

has_any_weight()

problem: NonRenewableResourceProblem[Task, NonRenewableResource]

discrete_optimization.generic_tasks_tools.objectives.schedule_changes module

class discrete_optimization.generic_tasks_tools.objectives.schedule_changes.ScheduleChangesComputer(problem: SchedulingProblem[Task], base_scheduling_solution: SchedulingSolution[Task], weight_objective: float = 1.0, cost_any_shift: dict[Task, float] = None, cost_unit_deviation: dict[Task, float] = None)

Bases: ObjectiveComputer[Task]

base_scheduling_solution: SchedulingSolution[Task]

compute_any_shift_cost(solution: SchedulingSolution[Task]) → float

compute_objective(solution: TasksSolution) → float

compute_unit_deviation_cost(solution: SchedulingSolution[Task]) → float

cost_any_shift(task: Task) → int

Cost of any move of the task (whatever deviation) :param task: task of the scheduling problem :return: the cost of any move of the task

cost_unit_deviation(task: Task) → int

Cost of shifting one unit of time so the total cost will be : unit*abs(new_time-prev_time)

static get_objective_name() → Objective | str

has_any_shift_cost()

has_any_unit_deviation_cost()

problem: SchedulingProblem[Task]

tasks_with_any_shift_cost()

tasks_with_unit_deviation_cost()

discrete_optimization.generic_tasks_tools.objectives.scheduled_tasks module

class discrete_optimization.generic_tasks_tools.objectives.scheduled_tasks.ScheduledTasksComputer(problem: SchedulingProblem[Task], weight_objective: float = 1.0, weight_per_task: dict[Task, int] | None = None)

Bases: ObjectiveComputer[Task], Generic[Task]

compute_objective(solution: SchedulingSolution[Task]) → float

static get_objective_name() → Objective | str

problem: SchedulingProblem[Task]

discrete_optimization.generic_tasks_tools.objectives.soft_time_penalty module

class discrete_optimization.generic_tasks_tools.objectives.soft_time_penalty.SoftTimePenaltyComputer(problem: TasksProblem[Task] = None, weight_objective: float = 1.0)

Bases: ObjectiveComputer[Task], Generic[Task, UnaryResource, Skill, NonSkillCumulativeResource, NonRenewableResource]

compute_objective(solution: GenericSchedulingSolution[Task, UnaryResource, Skill, NonSkillCumulativeResource, NonRenewableResource]) → float

static get_objective_name() → Objective

penalty = 0

problem: GenericSchedulingProblem[Task, UnaryResource, Skill, NonSkillCumulativeResource, NonRenewableResource]

discrete_optimization.generic_tasks_tools.objectives.unary_resource_used module

class discrete_optimization.generic_tasks_tools.objectives.unary_resource_used.UnaryResourcesUsedComputer(problem: AllocationProblem[Task, UnaryResource] = None, weight_objective: float = 1.0, weight_per_unary_resource: dict[UnaryResource, float] = None)

Bases: ObjectiveComputer[Task], Generic[Task, UnaryResource]

compute_objective(solution: AllocationSolution[Task, UnaryResource])

static get_objective_name() → Objective | str

get_weight_per_unary_resource(ur: UnaryResource) → float

has_cost_on_unary_resource() → bool

problem: AllocationProblem[Task, UnaryResource]

discrete_optimization.generic_tasks_tools.objectives.utils module

discrete_optimization.generic_tasks_tools.objectives.utils.get_mapping()

discrete_optimization.generic_tasks_tools.objectives.utils.get_objective_computer_class(objective: Objective) → Type[ObjectiveComputer]

Module contents