C++ Reference: class RoutingModel

This documentation is automatically generated.

Method
ActiveVar	Return type: IntVar* Arguments: int64 index Returns the active variable of the node corresponding to index.
ActiveVehicleVar	Return type: IntVar* Arguments: int vehicle Returns the active variable of the vehicle. It will be equal to 1 iff the route of the vehicle is not empty, 0 otherwise.
AddAtSolutionCallback	Return type: void Arguments: std::function<void()> callback Adds a callback called each time a solution is found during the search. This is a shortcut to creating a monitor to call the callback on AtSolution() and adding it with AddSearchMonitor.
AddConstantDimension	Return type: bool Arguments: int64 value, int64 capacity, bool fix_start_cumul_to_zero, const std::string& name
AddConstantDimensionWithSlack	Return type: bool Arguments: int64 value, int64 capacity, int64 slack_max, bool fix_start_cumul_to_zero, const std::string& name Creates a dimension where the transit variable is constrained to be equal to 'value'; 'capacity' is the upper bound of the cumul variables. 'name' is the name used to reference the dimension; this name is used to get cumul and transit variables from the routing model. Returns false if a dimension with the same name has already been created (and doesn't create the new dimension).
AddDimension	Return type: bool Arguments: int evaluator_index, int64 slack_max, int64 capacity, bool fix_start_cumul_to_zero, const std::string& name Creates a dimension where the transit variable is constrained to be equal to evaluator(i, next(i)); 'slack_max' is the upper bound of the slack variable and 'capacity' is the upper bound of the cumul variables. 'name' is the name used to reference the dimension; this name is used to get cumul and transit variables from the routing model. Returns false if a dimension with the same name has already been created (and doesn't create the new dimension). Takes ownership of the callback 'evaluator'.
AddDimensionDependentDimensionWithVehicleCapacity	Return type: bool Arguments: const std::vector<int>& pure_transits, const std::vector<int>& dependent_transits, const RoutingDimension* base_dimension, int64 slack_max, std::vector<int64> vehicle_capacities, bool fix_start_cumul_to_zero, const std::string& name Creates a dimension with transits depending on the cumuls of another dimension. 'pure_transits' are the per-vehicle fixed transits as above. 'dependent_transits' is a vector containing for each vehicle an index to a registered state dependent transit callback. 'base_dimension' indicates the dimension from which the cumul variable is taken. If 'base_dimension' is nullptr, then the newly created dimension is self-based.
AddDimensionDependentDimensionWithVehicleCapacity	Return type: bool Arguments: const std::vector<int>& transits, const RoutingDimension* base_dimension, int64 slack_max, std::vector<int64> vehicle_capacities, bool fix_start_cumul_to_zero, const std::string& name As above, but pure_transits are taken to be zero evaluators.
AddDimensionDependentDimensionWithVehicleCapacity	Return type: bool Arguments: int transit, const RoutingDimension* base_dimension, int64 slack_max, int64 vehicle_capacity, bool fix_start_cumul_to_zero, const std::string& name Homogeneous versions of the functions above.
AddDimensionDependentDimensionWithVehicleCapacity	Return type: bool Arguments: int pure_transit, int dependent_transit, const RoutingDimension* base_dimension, int64 slack_max, int64 vehicle_capacity, bool fix_start_cumul_to_zero, const std::string& name
AddDimensionWithVehicleCapacity	Return type: bool Arguments: int evaluator_index, int64 slack_max, std::vector<int64> vehicle_capacities, bool fix_start_cumul_to_zero, const std::string& name
AddDimensionWithVehicleTransitAndCapacity	Return type: bool Arguments: const std::vector<int>& evaluator_indices, int64 slack_max, std::vector<int64> vehicle_capacities, bool fix_start_cumul_to_zero, const std::string& name
AddDimensionWithVehicleTransits	Return type: bool Arguments: const std::vector<int>& evaluator_indices, int64 slack_max, int64 capacity, bool fix_start_cumul_to_zero, const std::string& name
AddDisjunction	Return type: DisjunctionIndex Arguments: const std::vector<int64>& indices, int64 penalty = kNoPenalty, int64 max_cardinality = 1 Adds a disjunction constraint on the indices: exactly 'max_cardinality' of the indices are active. Start and end indices of any vehicle cannot be part of a disjunction. If a penalty is given, at most 'max_cardinality' of the indices can be active, and if less are active, 'penalty' is payed per inactive index. This is equivalent to adding the constraint: p + Sum(i)active[i] == max_cardinality where p is an integer variable, and the following cost to the cost function: p * penalty. 'penalty' must be positive to make the disjunction optional; a negative penalty will force 'max_cardinality' indices of the disjunction to be performed, and therefore p == 0. Note: passing a vector with a single index will model an optional index with a penalty cost if it is not visited.
AddHardTypeIncompatibility	Return type: void Arguments: int type1, int type2 Incompatibilities: Two nodes with "hard" incompatible types cannot share the same route at all, while with a "temporal" incompatibility they can't be on the same route at the same time.
AddIntervalToAssignment	Return type: void Arguments: IntervalVar* const interval
AddLocalSearchFilter	Return type: void Arguments: LocalSearchFilter* filter Adds a custom local search filter to the list of filters used to speed up local search by pruning unfeasible variable assignments. Calling this method after the routing model has been closed (CloseModel() or Solve() has been called) has no effect. The routing model does not take ownership of the filter.
AddLocalSearchOperator	Return type: void Arguments: LocalSearchOperator* ls_operator Adds a local search operator to the set of operators used to solve the vehicle routing problem.
AddMatrixDimension	Return type: bool Arguments: /// std::vector<std::vector<int64> /*needed_for_swig> values, int64 capacity, bool fix_start_cumul_to_zero, const std::string& name Creates a dimension where the transit variable is constrained to be equal to 'values[i][next(i)]' for node i; 'capacity' is the upper bound of the cumul variables. 'name' is the name used to reference the dimension; this name is used to get cumul and transit variables from the routing model. Returns false if a dimension with the same name has already been created (and doesn't create the new dimension).
AddPickupAndDelivery	Return type: void Arguments: int64 pickup, int64 delivery Notifies that index1 and index2 form a pair of nodes which should belong to the same route. This methods helps the search find better solutions, especially in the local search phase. It should be called each time you have an equality constraint linking the vehicle variables of two node (including for instance pickup and delivery problems): Solver* const solver = routing.solver(); int64 index1 = manager.NodeToIndex(node1); int64 index2 = manager.NodeToIndex(node2); solver->AddConstraint(solver->MakeEquality( routing.VehicleVar(index1), routing.VehicleVar(index2))); routing.AddPickupAndDelivery(index1, index2); TODO(user): Remove this when model introspection detects linked nodes.
AddPickupAndDeliverySets	Return type: void Arguments: DisjunctionIndex pickup_disjunction, DisjunctionIndex delivery_disjunction Same as AddPickupAndDelivery but notifying that the performed node from the disjunction of index 'pickup_disjunction' is on the same route as the performed node from the disjunction of index 'delivery_disjunction'.
AddRequiredTypeAlternativesWhenAddingType	Return type: void Arguments: int dependent_type, absl::flat_hash_set<int> required_type_alternatives If type_D depends on type_R when adding type_D, any node_D of type_D and VisitTypePolicy TYPE_ADDED_TO_VEHICLE or TYPE_SIMULTANEOUSLY_ADDED_AND_REMOVED requires at least one type_R on its vehicle at the time node_D is visited.
AddRequiredTypeAlternativesWhenRemovingType	Return type: void Arguments: int dependent_type, absl::flat_hash_set<int> required_type_alternatives The following requirements apply when visiting dependent nodes that remove their type from the route, i.e. type_R must be on the vehicle when type_D of VisitTypePolicy ADDED_TYPE_REMOVED_FROM_VEHICLE, TYPE_ON_VEHICLE_UP_TO_VISIT or TYPE_SIMULTANEOUSLY_ADDED_AND_REMOVED is visited.
AddSameVehicleRequiredTypeAlternatives	Return type: void Arguments: int dependent_type, absl::flat_hash_set<int> required_type_alternatives Requirements: NOTE: As of 2019-04, cycles in the requirement graph are not supported, and lead to the dependent nodes being skipped if possible (otherwise the model is considered infeasible). The following functions specify that "dependent_type" requires at least one of the types in "required_type_alternatives". For same-vehicle requirements, a node of dependent type type_D requires at least one node of type type_R among the required alternatives on the same route.
AddSearchMonitor	Return type: void Arguments: SearchMonitor* const monitor Adds a search monitor to the search used to solve the routing model.
AddSoftSameVehicleConstraint	Return type: void Arguments: const std::vector<int64>& indices, int64 cost Adds a soft contraint to force a set of variable indices to be on the same vehicle. If all nodes are not on the same vehicle, each extra vehicle used adds 'cost' to the cost function.
AddTemporalTypeIncompatibility	Return type: void Arguments: int type1, int type2
AddToAssignment	Return type: void Arguments: IntVar* const var Adds an extra variable to the vehicle routing assignment.
AddVariableMaximizedByFinalizer	Return type: void Arguments: IntVar* var Adds a variable to maximize in the solution finalizer (see above for information on the solution finalizer).
AddVariableMinimizedByFinalizer	Return type: void Arguments: IntVar* var Adds a variable to minimize in the solution finalizer. The solution finalizer is called each time a solution is found during the search and allows to instantiate secondary variables (such as dimension cumul variables).
AddVariableTargetToFinalizer	Return type: void Arguments: IntVar* var, int64 target Add a variable to set the closest possible to the target value in the solution finalizer.
AddVectorDimension	Return type: bool Arguments: std::vector<int64> values, int64 capacity, bool fix_start_cumul_to_zero, const std::string& name Creates a dimension where the transit variable is constrained to be equal to 'values[i]' for node i; 'capacity' is the upper bound of the cumul variables. 'name' is the name used to reference the dimension; this name is used to get cumul and transit variables from the routing model. Returns false if a dimension with the same name has already been created (and doesn't create the new dimension).
AddWeightedVariableMinimizedByFinalizer	Return type: void Arguments: IntVar* var, int64 cost Adds a variable to minimize in the solution finalizer, with a weighted priority: the higher the more priority it has.
ApplyLocks	Return type: IntVar* Arguments: const std::vector<int64>& locks Applies a lock chain to the next search. 'locks' represents an ordered vector of nodes representing a partial route which will be fixed during the next search; it will constrain next variables such that: next[locks[i]] == locks[i+1]. Returns the next variable at the end of the locked chain; this variable is not locked. An assignment containing the locks can be obtained by calling PreAssignment().
ApplyLocksToAllVehicles	Return type: bool Arguments: const std::vector<std::vector<int64>>& locks, bool close_routes Applies lock chains to all vehicles to the next search, such that locks[p] is the lock chain for route p. Returns false if the locks do not contain valid routes; expects that the routes do not contain the depots, i.e. there are empty vectors in place of empty routes. If close_routes is set to true, adds the end nodes to the route of each vehicle and deactivates other nodes. An assignment containing the locks can be obtained by calling PreAssignment().
ArcIsMoreConstrainedThanArc	Return type: bool Arguments: int64 from, int64 to1, int64 to2 Returns whether the arc from->to1 is more constrained than from->to2, taking into account, in order: - whether the destination node isn't an end node - whether the destination node is mandatory - whether the destination node is bound to the same vehicle as the source - the "primary constrained" dimension (see SetPrimaryConstrainedDimension) It then breaks ties using, in order: - the arc cost (taking unperformed penalties into account) - the size of the vehicle vars of "to1" and "to2" (lowest size wins) - the value: the lowest value of the indices to1 and to2 wins. See the .cc for details. The more constrained arc is typically preferable when building a first solution. This method is intended to be used as a callback for the BestValueByComparisonSelector value selector. Args: from: the variable index of the source node to1: the variable index of the first candidate destination node. to2: the variable index of the second candidate destination node.
AreEmptyRouteCostsConsideredForVehicle	Return type: bool Arguments: int vehicle
AssignmentToRoutes	Return type: void Arguments: const Assignment& assignment, std::vector<std::vector<int64>>* const routes Converts the solution in the given assignment to routes for all vehicles. Expects that assignment contains a valid solution (i.e. routes for all vehicles end with an end index for that vehicle).
CheckLimit	Return type: bool Returns true if the search limit has been crossed.
CloseModel	Return type: void Closes the current routing model; after this method is called, no modification to the model can be done, but RoutesToAssignment becomes available. Note that CloseModel() is automatically called by Solve() and other methods that produce solution. This is equivalent to calling CloseModelWithParameters(DefaultRoutingSearchParameters()).
CloseModelWithParameters	Return type: void Arguments: const RoutingSearchParameters& search_parameters Same as above taking search parameters (as of 10/2015 some the parameters have to be set when closing the model).
CloseVisitTypes	Return type: void This function should be called once all node visit types have been set and prior to adding any incompatibilities/requirements. TODO(user): Reconsider the logic and potentially remove the need to "close" types.
CompactAndCheckAssignment	Return type: Assignment* Arguments: const Assignment& assignment Same as CompactAssignment() but also checks the validity of the final compact solution; if it is not valid, no attempts to repair it are made (instead, the method returns nullptr).
CompactAssignment	Return type: Assignment* Arguments: const Assignment& assignment Returns a compacted version of the given assignment, in which all vehicles with id lower or equal to some N have non-empty routes, and all vehicles with id greater than N have empty routes. Does not take ownership of the returned object. If found, the cost of the compact assignment is the same as in the original assignment and it preserves the values of 'active' variables. Returns nullptr if a compact assignment was not found. This method only works in homogenous mode, and it only swaps equivalent vehicles (vehicles with the same start and end nodes). When creating the compact assignment, the empty plan is replaced by the route assigned to the compatible vehicle with the highest id. Note that with more complex constraints on vehicle variables, this method might fail even if a compact solution exists. This method changes the vehicle and dimension variables as necessary. While compacting the solution, only basic checks on vehicle variables are performed; if one of these checks fails no attempts to repair it are made (instead, the method returns nullptr).
ComputeLowerBound	Return type: int64 Computes a lower bound to the routing problem solving a linear assignment problem. The routing model must be closed before calling this method. Note that problems with node disjunction constraints (including optional nodes) and non-homogenous costs are not supported (the method returns 0 in these cases). TODO(user): Add support for non-homogeneous costs and disjunctions.
ConsiderEmptyRouteCostsForVehicle	Return type: void Arguments: bool consider_costs, int vehicle
CostClass	Return type: explicit Arguments: int evaluator_index
CostsAreHomogeneousAcrossVehicles	Return type: bool Whether costs are homogeneous across all vehicles.
CostVar	Return type: IntVar* Returns the global cost variable which is being minimized.
DebugOutputAssignment	Return type: std::string Arguments: const Assignment& solution_assignment, const std::string& dimension_to_print Print some debugging information about an assignment, including the feasible intervals of the CumulVar for dimension "dimension_to_print" at each step of the routes. If "dimension_to_print" is omitted, all dimensions will be printed.
End	Return type: int64 Arguments: int vehicle Returns the variable index of the ending node of a vehicle route.
first_solution_evaluator	Return type: const Solver::IndexEvaluator2&
ForEachNodeInDisjunctionWithMaxCardinalityFromIndex	Return type: void Arguments: int64 index, int64 max_cardinality, F f
GetAllDimensionNames	Return type: std::vector<std::string> Outputs the names of all dimensions added to the routing engine. TODO(user): rename.
GetAmortizedLinearCostFactorOfVehicles	Return type: const std::vector<int64>&
GetAmortizedQuadraticCostFactorOfVehicles	Return type: const std::vector<int64>&
GetArcCostForClass	Return type: int64 Arguments: int64 from_index, int64 to_index, /// int64 /*CostClassIndex cost_class_index Returns the cost of the segment between two nodes for a given cost class. Input are variable indices of nodes and the cost class. Unlike GetArcCostForVehicle(), if cost_class is kNoCost, then the returned cost won't necessarily be zero: only some of the components of the cost that depend on the cost class will be omited. See the code for details.
GetArcCostForFirstSolution	Return type: int64 Arguments: int64 from_index, int64 to_index Returns the cost of the arc in the context of the first solution strategy. This is typically a simplification of the actual cost; see the .cc.
GetArcCostForVehicle	Return type: int64 Arguments: int64 from_index, int64 to_index, int64 vehicle Returns the cost of the transit arc between two nodes for a given vehicle. Input are variable indices of node. This returns 0 if vehicle < 0.
GetAutomaticFirstSolutionStrategy
GetCostClassesCount	Return type: int Returns the number of different cost classes in the model.
GetCostClassIndexOfVehicle	Return type: CostClassIndex Arguments: int64 vehicle int64 /*CostClassIndex cost_class_index) const; Get the cost class index of the given vehicle.
GetDepot	Return type: int64 Returns the variable index of the first starting or ending node of all routes. If all routes start and end at the same node (single depot), this is the node returned.
GetDimensionOrDie	Return type: const RoutingDimension& Arguments: const std::string& dimension_name Returns a dimension from its name. Dies if the dimension does not exist.
GetDimensions	Return type: const std::vector<RoutingDimension*>& Returns all dimensions of the model.
GetDimensionsWithSoftOrSpanCosts	Return type: std::vector<RoutingDimension*> Returns dimensions with soft or vehicle span costs.
GetDisjunctionIndices	Return type: const std::vector<DisjunctionIndex>& Arguments: int64 index Returns the indices of the disjunctions to which an index belongs.
GetDisjunctionIndices	Return type: const std::vector<int64>& Arguments: DisjunctionIndex index Returns the variable indices of the nodes in the disjunction of index 'index'.
GetDisjunctionMaxCardinality	Return type: int64 Arguments: DisjunctionIndex index Returns the maximum number of possible active nodes of the node disjunction of index 'index'.
GetDisjunctionPenalty	Return type: int64 Arguments: DisjunctionIndex index Returns the penalty of the node disjunction of index 'index'.
GetFixedCostOfVehicle	Return type: int64 Arguments: int vehicle Returns the route fixed cost taken into account if the route of the vehicle is not empty, aka there's at least one node on the route other than the first and last nodes.
GetGlobalDimensionCumulOptimizers
GetHardTypeIncompatibilitiesOfType	Return type: const absl::flat_hash_set<int>& Arguments: int type Returns visit types incompatible with a given type.
GetHomogeneousCost	Return type: int64 Arguments: int64 from_index, int64 to_index Returns the cost of the segment between two nodes supposing all vehicle costs are the same (returns the cost for the first vehicle otherwise).
GetLocalDimensionCumulMPOptimizers
GetLocalDimensionCumulOptimizers
GetMaximumNumberOfActiveVehicles	Return type: int Returns the maximum number of active vehicles.
GetMutableDimension	Return type: RoutingDimension* Arguments: const std::string& dimension_name Returns a dimension from its name. Returns nullptr if the dimension does not exist.
GetMutableGlobalCumulOptimizer	Return type: GlobalDimensionCumulOptimizer* Arguments: const RoutingDimension& dimension Returns the global/local dimension cumul optimizer for a given dimension, or nullptr if there is none.
GetMutableLocalCumulMPOptimizer	Return type: LocalDimensionCumulOptimizer* Arguments: const RoutingDimension& dimension
GetMutableLocalCumulOptimizer	Return type: LocalDimensionCumulOptimizer* Arguments: const RoutingDimension& dimension
GetNonZeroCostClassesCount	Return type: int Ditto, minus the 'always zero', built-in cost class.
GetNumberOfDecisionsInFirstSolution	Return type: int64 Arguments: const RoutingSearchParameters& search_parameters Returns statistics on first solution search, number of decisions sent to filters, number of decisions rejected by filters.
GetNumberOfDisjunctions	Return type: int Returns the number of node disjunctions in the model.
GetNumberOfRejectsInFirstSolution	Return type: int64 Arguments: const RoutingSearchParameters& search_parameters
GetNumberOfVisitTypes	Return type: int
GetNumOfSingletonNodes	Return type: int
GetPairIndicesOfType	Return type: const std::vector<int>& Arguments: int type
GetPickupAndDeliveryDisjunctions
GetPickupAndDeliveryPairs	Return type: const IndexPairs& Returns pickup and delivery pairs currently in the model.
GetPickupAndDeliveryPolicyOfVehicle	Return type: PickupAndDeliveryPolicy Arguments: int vehicle
GetPickupIndexPairs	Arguments: int64 node_index
GetPrimaryConstrainedDimension	Return type: const std::string& Get the primary constrained dimension, or an empty string if it is unset.
GetSameVehicleIndicesOfIndex	Return type: const std::vector<int>& Arguments: int node Returns variable indices of nodes constrained to be on the same route.
GetSingleNodesOfType	Return type: const std::vector<int>& Arguments: int type
GetTemporalTypeIncompatibilitiesOfType	Return type: const absl::flat_hash_set<int>& Arguments: int type
GetTopologicallySortedVisitTypes	Return type: const std::vector<int>&
GetVehicleClassesCount	Return type: int Returns the number of different vehicle classes in the model.
GetVehicleClassIndexOfVehicle	Return type: VehicleClassIndex Arguments: int64 vehicle
GetVehicleTypeContainer	Return type: const VehicleTypeContainer&
GetVisitType	Return type: int Arguments: int64 index
GetVisitTypePolicy	Return type: VisitTypePolicy Arguments: int64 index
HasDimension	Return type: bool Arguments: const std::string& dimension_name Returns true if a dimension exists for a given dimension name.
HasHardTypeIncompatibilities	Return type: bool Returns true iff any hard (resp. temporal) type incompatibilities have been added to the model.
HasSameVehicleTypeRequirements	Return type: bool clang-format on Returns true iff any same-route (resp. temporal) type requirements have been added to the model.
HasTemporalTypeIncompatibilities	Return type: bool
HasTemporalTypeRequirements	Return type: bool
HasTypeRegulations	Return type: bool Returns true iff the model has any incompatibilities or requirements set on node types.
HasVehicleWithCostClassIndex	Return type: bool Arguments: CostClassIndex cost_class_index Returns true iff the model contains a vehicle with the given cost_class_index.
IgnoreDisjunctionsAlreadyForcedToZero	Return type: void SPECIAL: Makes the solver ignore all the disjunctions whose active variables are all trivially zero (i.e. Max() == 0), by setting their max_cardinality to 0. This can be useful when using the BaseBinaryDisjunctionNeighborhood operators, in the context of arc-based routing.
IsEnd	Return type: bool Arguments: int64 index Returns true if 'index' represents the last node of a route.
IsMatchingModel	Return type: bool Returns true if a vehicle/node matching problem is detected.
IsStart	Return type: bool Arguments: int64 index Returns true if 'index' represents the first node of a route.
IsVehicleAllowedForIndex	Return type: bool Arguments: int vehicle, int64 index Returns true if a vehicle is allowed to visit a given node.
IsVehicleUsed	Return type: bool Arguments: const Assignment& assignment, int vehicle Returns true if the route of 'vehicle' is non empty in 'assignment'.
MakeGreedyDescentLSOperator	Return type: static std::unique_ptr<LocalSearchOperator> Arguments: std::vector<IntVar*> variables TODO(user): MakeGreedyDescentLSOperator is too general for routing.h. Perhaps move it to constraint_solver.h. MakeGreedyDescentLSOperator creates a local search operator that tries to improve the initial assignment by moving a logarithmically decreasing step away in each possible dimension.
MakeGuidedSlackFinalizer	Return type: DecisionBuilder* Arguments: const RoutingDimension* dimension, std::function<int64(int64)> initializer The next few members are in the public section only for testing purposes. TODO(user): Find a way to test and restrict the access at the same time. MakeGuidedSlackFinalizer creates a DecisionBuilder for the slacks of a dimension using a callback to choose which values to start with. The finalizer works only when all next variables in the model have been fixed. It has the following two characteristics: 1. It follows the routes defined by the nexts variables when choosing a variable to make a decision on. 2. When it comes to choose a value for the slack of node i, the decision builder first calls the callback with argument i, and supposingly the returned value is x it creates decisions slack[i] = x, slack[i] = x + 1, slack[i] = x - 1, slack[i] = x + 2, etc.
MakePathSpansAndTotalSlacks	Return type: Constraint* Arguments: const RoutingDimension* dimension, std::vector<IntVar*> spans, std::vector<IntVar*> total_slacks For every vehicle of the routing model: - if total_slacks[vehicle] is not nullptr, constrains it to be the sum of slacks on that vehicle, that is, dimension->CumulVar(end) - dimension->CumulVar(start) - sum_{node in path of vehicle} dimension->FixedTransitVar(node). - if spans[vehicle] is not nullptr, constrains it to be dimension->CumulVar(end) - dimension->CumulVar(start) This does stronger propagation than a decomposition, and takes breaks into account.
MakeSelfDependentDimensionFinalizer	Return type: DecisionBuilder* Arguments: const RoutingDimension* dimension MakeSelfDependentDimensionFinalizer is a finalizer for the slacks of a self-dependent dimension. It makes an extensive use of the caches of the state dependent transits. In detail, MakeSelfDependentDimensionFinalizer returns a composition of a local search decision builder with a greedy descent operator for the cumul of the start of each route and a guided slack finalizer. Provided there are no time windows and the maximum slacks are large enough, once the cumul of the start of route is fixed, the guided finalizer can find optimal values of the slacks for the rest of the route in time proportional to the length of the route. Therefore the composed finalizer generally works in time O(log(t)*n*m), where t is the latest possible departute time, n is the number of nodes in the network and m is the number of vehicles.
MakeStateDependentTransit	Return type: static RoutingModel::StateDependentTransit Arguments: const std::function<int64(int64)>& f, int64 domain_start, int64 domain_end Creates a cached StateDependentTransit from an std::function.
MutablePreAssignment	Return type: Assignment*
Next	Return type: int64 Arguments: const Assignment& assignment, int64 index Assignment inspection Returns the variable index of the node directly after the node corresponding to 'index' in 'assignment'.
Nexts	Return type: const std::vector<IntVar*>& Returns all next variables of the model, such that Nexts(i) is the next variable of the node corresponding to i.
NextVar	Return type: IntVar* Arguments: int64 index Returns the next variable of the node corresponding to index. Note that NextVar(index) == index is equivalent to ActiveVar(index) == 0.
nodes	Return type: int Sizes and indices Returns the number of nodes in the model.
PackCumulsOfOptimizerDimensionsFromAssignment	Return type: const Assignment* Arguments: const Assignment* original_assignment, absl::Duration duration_limit For every dimension in the model with an optimizer in local/global_dimension_optimizers_, this method tries to pack the cumul values of the dimension, such that: - The cumul costs (span costs, soft lower and upper bound costs, etc) are minimized. - The cumuls of the ends of the routes are minimized for this given minimal cumul cost. - Given these minimal end cumuls, the route start cumuls are maximized. Returns the assignment resulting from allocating these packed cumuls with the solver, and nullptr if these cumuls could not be set by the solver.
PreAssignment	Return type: const Assignment* const Returns an assignment used to fix some of the variables of the problem. In practice, this assignment locks partial routes of the problem. This can be used in the context of locking the parts of the routes which have already been driven in online routing problems.
ReadAssignment	Return type: Assignment* Arguments: const std::string& file_name Reads an assignment from a file and returns the current solution. Returns nullptr if the file cannot be opened or if the assignment is not valid.
ReadAssignmentFromRoutes	Return type: Assignment* Arguments: const std::vector<std::vector<int64>>& routes, bool ignore_inactive_indices Restores the routes as the current solution. Returns nullptr if the solution cannot be restored (routes do not contain a valid solution). Note that calling this method will run the solver to assign values to the dimension variables; this may take considerable amount of time, especially when using dimensions with slack.
RegisterPositiveTransitCallback	Return type: int Arguments: TransitCallback2 callback
RegisterPositiveUnaryTransitCallback	Return type: int Arguments: TransitCallback1 callback
RegisterStateDependentTransitCallback	Return type: int Arguments: VariableIndexEvaluator2 callback
RegisterTransitCallback	Return type: int Arguments: TransitCallback2 callback
RegisterUnaryTransitCallback	Return type: int Arguments: TransitCallback1 callback Registers 'callback' and returns its index.
RemainingTime	Return type: absl::Duration Returns the time left in the search limit.
RestoreAssignment	Return type: Assignment* Arguments: const Assignment& solution Restores an assignment as a solution in the routing model and returns the new solution. Returns nullptr if the assignment is not valid.
RoutesToAssignment	Return type: bool Arguments: const std::vector<std::vector<int64>>& routes, bool ignore_inactive_indices, bool close_routes, Assignment* const assignment Fills an assignment from a specification of the routes of the vehicles. The routes are specified as lists of variable indices that appear on the routes of the vehicles. The indices of the outer vector in 'routes' correspond to vehicles IDs, the inner vector contains the variable indices on the routes for the given vehicle. The inner vectors must not contain the start and end indices, as these are determined by the routing model. Sets the value of NextVars in the assignment, adding the variables to the assignment if necessary. The method does not touch other variables in the assignment. The method can only be called after the model is closed. With ignore_inactive_indices set to false, this method will fail (return nullptr) in case some of the route contain indices that are deactivated in the model; when set to true, these indices will be skipped. Returns true if routes were successfully loaded. However, such assignment still might not be a valid solution to the routing problem due to more complex constraints; it is advisible to call solver()->CheckSolution() afterwards.
RoutingModel	Return type: explicit Arguments: const RoutingIndexManager& index_manager Constructor taking an index manager. The version which does not take RoutingModelParameters is equivalent to passing DefaultRoutingModelParameters().
RoutingModel	Arguments: const RoutingIndexManager& index_manager, const RoutingModelParameters& parameters
~RoutingModel
SetAllowedVehiclesForIndex	Return type: void Arguments: const std::vector<int>& vehicles, int64 index Sets the vehicles which can visit a given node. If the node is in a disjunction, this will not prevent it from being unperformed. Specifying an empty vector of vehicles has no effect (all vehicles will be allowed to visit the node).
SetAmortizedCostFactorsOfAllVehicles	Return type: void Arguments: int64 linear_cost_factor, int64 quadratic_cost_factor The following methods set the linear and quadratic cost factors of vehicles (must be positive values). The default value of these parameters is zero for all vehicles. When set, the cost_ of the model will contain terms aiming at reducing the number of vehicles used in the model, by adding the following to the objective for every vehicle v: INDICATOR(v used in the model) * [linear_cost_factor_of_vehicle_[v] - quadratic_cost_factor_of_vehicle_[v]*(square of length of route v)] i.e. for every used vehicle, we add the linear factor as fixed cost, and subtract the square of the route length multiplied by the quadratic factor. This second term aims at making the routes as dense as possible. Sets the linear and quadratic cost factor of all vehicles.
SetAmortizedCostFactorsOfVehicle	Return type: void Arguments: int64 linear_cost_factor, int64 quadratic_cost_factor, int vehicle Sets the linear and quadratic cost factor of the given vehicle.
SetArcCostEvaluatorOfAllVehicles	Return type: void Arguments: int evaluator_index Sets the cost function of the model such that the cost of a segment of a route between node 'from' and 'to' is evaluator(from, to), whatever the route or vehicle performing the route.
SetArcCostEvaluatorOfVehicle	Return type: void Arguments: int evaluator_index, int vehicle Sets the cost function for a given vehicle route.
SetAssignmentFromOtherModelAssignment	Return type: void Arguments: Assignment* target_assignment, const RoutingModel* source_model, const Assignment* source_assignment Given a "source_model" and its "source_assignment", resets "target_assignment" with the IntVar variables (nexts_, and vehicle_vars_ if costs aren't homogeneous across vehicles) of "this" model, with the values set according to those in "other_assignment". The objective_element of target_assignment is set to this->cost_.
SetFirstSolutionEvaluator	Return type: void Arguments: Solver::IndexEvaluator2 evaluator Takes ownership of evaluator.
SetFixedCostOfAllVehicles	Return type: void Arguments: int64 cost Sets the fixed cost of all vehicle routes. It is equivalent to calling SetFixedCostOfVehicle on all vehicle routes.
SetFixedCostOfVehicle	Return type: void Arguments: int64 cost, int vehicle Sets the fixed cost of one vehicle route.
SetMaximumNumberOfActiveVehicles	Return type: void Arguments: int max_active_vehicles Constrains the maximum number of active vehicles, aka the number of vehicles which do not have an empty route. For instance, this can be used to limit the number of routes in the case where there are fewer drivers than vehicles and that the fleet of vehicle is heterogeneous.
SetPickupAndDeliveryPolicyOfAllVehicles	Return type: void Arguments: PickupAndDeliveryPolicy policy Sets the Pickup and delivery policy of all vehicles. It is equivalent to calling SetPickupAndDeliveryPolicyOfVehicle on all vehicles.
SetPickupAndDeliveryPolicyOfVehicle	Return type: void Arguments: PickupAndDeliveryPolicy policy, int vehicle
SetPrimaryConstrainedDimension	Return type: void Arguments: const std::string& dimension_name Set the given dimension as "primary constrained". As of August 2013, this is only used by ArcIsMoreConstrainedThanArc(). "dimension" must be the name of an existing dimension, or be empty, in which case there will not be a primary dimension after this call.
SetSweepArranger	Return type: void Arguments: SweepArranger* sweep_arranger TODO(user): Revisit if coordinates are added to the RoutingModel class.
SetTabuVarsCallback	Return type: void Arguments: GetTabuVarsCallback tabu_var_callback
SetVisitType	Return type: void Arguments: int64 index, int type, VisitTypePolicy type_policy TODO(user): Support multiple visit types per node?
Size	Return type: int64 Returns the number of next variables in the model.
Solve	Return type: const Assignment* Arguments: const Assignment* assignment = nullptr Solves the current routing model; closes the current model. This is equivalent to calling SolveWithParameters(DefaultRoutingSearchParameters()) or SolveFromAssignmentWithParameters(assignment, DefaultRoutingSearchParameters()).
SolveFromAssignmentWithParameters	Return type: const Assignment* Arguments: const Assignment* assignment, const RoutingSearchParameters& search_parameters, std::vector<const Assignment*>* solutions = nullptr
solver	Return type: Solver* Returns the underlying constraint solver. Can be used to add extra constraints and/or modify search algoithms.
SolveWithParameters	Return type: const Assignment* Arguments: const RoutingSearchParameters& search_parameters, std::vector<const Assignment*>* solutions = nullptr Solves the current routing model with the given parameters. If 'solutions' is specified, it will contain the k best solutions found during the search (from worst to best, including the one returned by this method), where k corresponds to the 'number_of_solutions_to_collect' in 'search_parameters'. Note that the Assignment returned by the method and the ones in solutions are owned by the underlying solver and should not be deleted.
Start	Return type: int64 Arguments: int vehicle Model inspection. Returns the variable index of the starting node of a vehicle route.
StateDependentTransitCallback	Return type: const VariableIndexEvaluator2& Arguments: int callback_index
status	Return type: Status Returns the current status of the routing model.
sweep_arranger	Return type: SweepArranger* Returns the sweep arranger to be used by routing heuristics.
TransitCallback	Return type: const TransitCallback2& Arguments: int callback_index
UnaryTransitCallbackOrNull	Return type: const TransitCallback1& Arguments: int callback_index
UnperformedPenalty	Return type: int64 Arguments: int64 var_index Get the "unperformed" penalty of a node. This is only well defined if the node is only part of a single Disjunction involving only itself, and that disjunction has a penalty. In all other cases, including forced active nodes, this returns 0.
UnperformedPenaltyOrValue	Return type: int64 Arguments: int64 default_value, int64 var_index Same as above except that it returns default_value instead of 0 when penalty is not well defined (default value is passed as first argument to simplify the usage of the method in a callback).
VehicleCostsConsideredVar	Return type: IntVar* Arguments: int vehicle Returns the variable specifying whether or not costs are considered for vehicle.
VehicleIndex	Return type: int Arguments: int index Returns the vehicle of the given start/end index, and -1 if the given index is not a vehicle start/end.
vehicles	Return type: int Returns the number of vehicle routes in the model.
VehicleVar	Return type: IntVar* Arguments: int64 index Returns the vehicle variable of the node corresponding to index. Note that VehicleVar(index) == -1 is equivalent to ActiveVar(index) == 0.
VehicleVars	Return type: const std::vector<IntVar*>& Returns all vehicle variables of the model, such that VehicleVars(i) is the vehicle variable of the node corresponding to i.
WriteAssignment	Return type: bool Arguments: const std::string& file_name Writes the current solution to a file containing an AssignmentProto. Returns false if the file cannot be opened or if there is no current solution.