Computes a lower bound of the span of the chain, taking into account only
the first nonchain task.
For more accurate results, this should be called after Precedences(),
otherwise the lower bound might be lower than feasible.
[[["Easy to understand","easyToUnderstand","thumb-up"],["Solved my problem","solvedMyProblem","thumb-up"],["Other","otherUp","thumb-up"]],[["Missing the information I need","missingTheInformationINeed","thumb-down"],["Too complicated / too many steps","tooComplicatedTooManySteps","thumb-down"],["Out of date","outOfDate","thumb-down"],["Samples / code issue","samplesCodeIssue","thumb-down"],["Other","otherDown","thumb-down"]],["Last updated 2024-08-06 UTC."],[[["\u003cp\u003eThe \u003ccode\u003eDisjunctivePropagator\u003c/code\u003e class in C++ acts as a constraint programming propagator, refining the possible values for task start, duration, and end times.\u003c/p\u003e\n"],["\u003cp\u003eIt employs various propagation methods, including edge-finding, precedences, and forbidden intervals, to reduce the search space for feasible solutions.\u003c/p\u003e\n"],["\u003cp\u003eThe propagator can handle chains of tasks with precedence constraints and considers time windows for non-chain tasks during propagation.\u003c/p\u003e\n"],["\u003cp\u003eIt offers functionalities like mirroring tasks for time symmetry and computing lower bounds for the chain span.\u003c/p\u003e\n"],["\u003cp\u003eUsers can iteratively call the \u003ccode\u003ePropagate\u003c/code\u003e method to further refine task bounds and detect infeasibility.\u003c/p\u003e\n"]]],["The `DisjunctivePropagator` class manages tasks defined by start, duration, and end times, refining their value ranges. Key actions include propagating precedence deductions (`Precedences`), computing new task bounds (`Propagate`), and finding lower bounds for chain spans (`ChainSpanMin`, `ChainSpanMinDynamic`). It also handles edge-finding (`EdgeFinding`), detectable precedences with chains (`DetectablePrecedencesWithChain`), enforces domain holes (`ForbiddenIntervals`), mirrors tasks with time symmetry (`MirrorTasks`), and propagates distance duration constraints (`DistanceDuration`). `Clear` clears internal state.\n"],null,["# DisjunctivePropagator\n\nC++ Reference: class DisjunctivePropagator\n==========================================\n\n\nNote: This documentation is automatically generated.\nThis class acts like a CP propagator: it takes a set of tasks given by their start/duration/end features, and reduces the range of possible values.\n\n| Method ||\n|----------------------------------------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|\n| [`ChainSpanMin`](https://github.com/google/or-tools/blob/v9.4/ortools/constraint_solver/routing.h#L2241) | Return type: `bool ` Arguments: `Tasks* tasks` Propagates a lower bound of the chain span, end\\[num_chain_tasks\\] - start\\[0\\], to span_min. |\n| [`ChainSpanMinDynamic`](https://github.com/google/or-tools/blob/v9.4/ortools/constraint_solver/routing.h#L2246) | Return type: `bool ` Arguments: `Tasks* tasks` Computes a lower bound of the span of the chain, taking into account only the first nonchain task. For more accurate results, this should be called after Precedences(), otherwise the lower bound might be lower than feasible. |\n| [`Clear`](https://github.com/google/or-tools/blob/v9.4/ortools/constraint_solver/routing.h#L2205) | Return type: `void ` \u003cbr /\u003e |\n| [`DetectablePrecedencesWithChain`](https://github.com/google/or-tools/blob/v9.4/ortools/constraint_solver/routing.h#L2234) | Return type: `bool ` Arguments: `Tasks* tasks` Does detectable precedences deductions on tasks in the chain precedence, taking the time windows of nonchain tasks into account. |\n| [`DistanceDuration`](https://github.com/google/or-tools/blob/v9.4/ortools/constraint_solver/routing.h#L2238) | Return type: `bool ` Arguments: `Tasks* tasks` Propagates distance_duration constraints, if any. |\n| [`EdgeFinding`](https://github.com/google/or-tools/blob/v9.4/ortools/constraint_solver/routing.h#L2231) | Return type: `bool ` Arguments: `Tasks* tasks` Does edge-finding deductions on all tasks. |\n| [`ForbiddenIntervals`](https://github.com/google/or-tools/blob/v9.4/ortools/constraint_solver/routing.h#L2236) | Return type: `bool ` Arguments: `Tasks* tasks` Tasks might have holes in their domain, this enforces such holes. |\n| [`MirrorTasks`](https://github.com/google/or-tools/blob/v9.4/ortools/constraint_solver/routing.h#L2229) | Return type: `bool ` Arguments: `Tasks* tasks` Transforms the problem with a time symmetry centered in 0. Returns true for convenience. |\n| [`Precedences`](https://github.com/google/or-tools/blob/v9.4/ortools/constraint_solver/routing.h#L2226) | Return type: `bool ` Arguments: `Tasks* tasks` Propagates the deductions from the chain of precedences, if there is one. |\n| [`Propagate`](https://github.com/google/or-tools/blob/v9.4/ortools/constraint_solver/routing.h#L2223) | Return type: `bool ` Arguments: `Tasks* tasks` Computes new bounds for all tasks, returns false if infeasible. This does not compute a fixed point, so recalling it may filter more. |"]]
