Class RoutingDimension

java.lang.Object
com.google.ortools.constraintsolver.RoutingDimension
public class RoutingDimension extends Object
Dimensions represent quantities accumulated at nodes along the routes. They
represent quantities such as weights or volumes carried along the route, or
distance or times.

Quantities at a node are represented by "cumul" variables and the increase
or decrease of quantities between nodes are represented by "transit"
variables. These variables are linked as follows:

if j == next(i),
cumuls(j) = cumuls(i) + transits(i) + slacks(i) +
state_dependent_transits(i)

where slack is a positive slack variable (can represent waiting times for
a time dimension), and state_dependent_transits is a non-purely functional
version of transits_. Favour transits over state_dependent_transits when
possible, because purely functional callbacks allow more optimisations and
make the model faster and easier to solve.
for a given vehicle, it is passed as an external vector, it would be better
to have this information here.

  • Field Details

    • swigCMemOwn

      protected transient boolean swigCMemOwn

  • Constructor Details

    • RoutingDimension

      public RoutingDimension(long cPtr, boolean cMemoryOwn)

  • Method Details

    • getCPtr

      public static long getCPtr(RoutingDimension obj)

    • swigRelease

      public static long swigRelease(RoutingDimension obj)

    • finalize

      protected void finalize()
      Overrides:
      finalize in class Object

    • delete

      public void delete()

    • model

      public RoutingModel model()
      Returns the model on which the dimension was created.

    • getTransitValue

      public long getTransitValue(long from_index, long to_index, long vehicle)
      Returns the transition value for a given pair of nodes (as var index);
      this value is the one taken by the corresponding transit variable when
      the 'next' variable for 'from_index' is bound to 'to_index'.

    • getTransitValueFromClass

      public long getTransitValueFromClass(long from_index, long to_index, long vehicle_class)
      Same as above but taking a vehicle class of the dimension instead of a
      vehicle (the class of a vehicle can be obtained with vehicle_to_class()).

    • cumulVar

      public IntVar cumulVar(long index)
      Get the cumul, transit and slack variables for the given node (given as
      int64_t var index).

    • transitVar

      public IntVar transitVar(long index)

    • fixedTransitVar

      public IntVar fixedTransitVar(long index)

    • slackVar

      public IntVar slackVar(long index)

    • SetCumulVarRange

      public void SetCumulVarRange(long index, long min, long max)
      Some functions to allow users to use the interface without knowing about
      the underlying CP model.
      Restricts the range of the cumul variable associated to index.

    • GetCumulVarMin

      public long GetCumulVarMin(long index)
      Gets the current minimum of the cumul variable associated to index.

    • GetCumulVarMax

      public long GetCumulVarMax(long index)
      Gets the current maximum of the cumul variable associated to index.

    • cumuls

      public IntVar[] cumuls()
      Like CumulVar(), TransitVar(), SlackVar() but return the whole variable
      vectors instead (indexed by int64_t var index).

    • fixed_transits

      public IntVar[] fixed_transits()

    • transits

      public IntVar[] transits()

    • slacks

      public IntVar[] slacks()

    • setSpanUpperBoundForVehicle

      public void setSpanUpperBoundForVehicle(long upper_bound, int vehicle)
      Sets an upper bound on the dimension span on a given vehicle. This is the
      preferred way to limit the "length" of the route of a vehicle according to
      a dimension.

    • setSpanCostCoefficientForVehicle

      public void setSpanCostCoefficientForVehicle(long coefficient, int vehicle)
      Sets a cost proportional to the dimension span on a given vehicle,
      or on all vehicles at once. "coefficient" must be nonnegative.
      This is handy to model costs proportional to idle time when the dimension
      represents time.
      The cost for a vehicle is
      span_cost = coefficient * (dimension end value - dimension start value).

    • setSpanCostCoefficientForAllVehicles

      public void setSpanCostCoefficientForAllVehicles(long coefficient)

    • SetSlackCostCoefficientForVehicle

      public void SetSlackCostCoefficientForVehicle(long coefficient, int vehicle)
      Sets a cost proportional to the dimension total slack on a given vehicle,
      or on all vehicles at once. "coefficient" must be nonnegative.
      This is handy to model costs only proportional to idle time when the
      dimension represents time.
      The cost for a vehicle is
      slack_cost = coefficient *
      (dimension end value - dimension start value - total_transit).

    • SetSlackCostCoefficientForAllVehicles

      public void SetSlackCostCoefficientForAllVehicles(long coefficient)

    • setGlobalSpanCostCoefficient

      public void setGlobalSpanCostCoefficient(long coefficient)
      Sets a cost proportional to the *global* dimension span, that is the
      difference between the largest value of route end cumul variables and
      the smallest value of route start cumul variables.
      In other words:
      global_span_cost =
      coefficient * (Max(dimension end value) - Min(dimension start value)).

    • setCumulVarSoftUpperBound

      public void setCumulVarSoftUpperBound(long index, long upper_bound, long coefficient)
      Sets a soft upper bound to the cumul variable of a given variable index.
      If the value of the cumul variable is greater than the bound, a cost
      proportional to the difference between this value and the bound is added
      to the cost function of the model:
      cumulVar <= upper_bound -> cost = 0
      cumulVar > upper_bound -> cost = coefficient * (cumulVar - upper_bound)
      This is also handy to model tardiness costs when the dimension represents
      time.

    • hasCumulVarSoftUpperBound

      public boolean hasCumulVarSoftUpperBound(long index)
      Returns true if a soft upper bound has been set for a given variable
      index.

    • getCumulVarSoftUpperBound

      public long getCumulVarSoftUpperBound(long index)
      Returns the soft upper bound of a cumul variable for a given variable
      index. The "hard" upper bound of the variable is returned if no soft upper
      bound has been set.

    • getCumulVarSoftUpperBoundCoefficient

      public long getCumulVarSoftUpperBoundCoefficient(long index)
      Returns the cost coefficient of the soft upper bound of a cumul variable
      for a given variable index. If no soft upper bound has been set, 0 is
      returned.

    • setCumulVarSoftLowerBound

      public void setCumulVarSoftLowerBound(long index, long lower_bound, long coefficient)
      Sets a soft lower bound to the cumul variable of a given variable index.
      If the value of the cumul variable is less than the bound, a cost
      proportional to the difference between this value and the bound is added
      to the cost function of the model:
      cumulVar > lower_bound -> cost = 0
      cumulVar <= lower_bound -> cost = coefficient * (lower_bound -
      cumulVar).
      This is also handy to model earliness costs when the dimension represents
      time.

    • hasCumulVarSoftLowerBound

      public boolean hasCumulVarSoftLowerBound(long index)
      Returns true if a soft lower bound has been set for a given variable
      index.

    • getCumulVarSoftLowerBound

      public long getCumulVarSoftLowerBound(long index)
      Returns the soft lower bound of a cumul variable for a given variable
      index. The "hard" lower bound of the variable is returned if no soft lower
      bound has been set.

    • getCumulVarSoftLowerBoundCoefficient

      public long getCumulVarSoftLowerBoundCoefficient(long index)
      Returns the cost coefficient of the soft lower bound of a cumul variable
      for a given variable index. If no soft lower bound has been set, 0 is
      returned.

    • setBreakIntervalsOfVehicle

      public void setBreakIntervalsOfVehicle(IntervalVar[] breaks, int vehicle, int pre_travel_evaluator, int post_travel_evaluator)
      Sets the breaks for a given vehicle. Breaks are represented by
      IntervalVars. They may interrupt transits between nodes and increase
      the value of corresponding slack variables.
      A break may take place before the start of a vehicle, after the end of
      a vehicle, or during a travel i -> j.

      In that case, the interval [break.Start(), break.End()) must be a subset
      of [CumulVar(i) + pre_travel(i, j), CumulVar(j) - post_travel(i, j)). In
      other words, a break may not overlap any node n's visit, given by
      [CumulVar(n) - post_travel(_, n), CumulVar(n) + pre_travel(n, _)).
      This formula considers post_travel(_, start) and pre_travel(end, _) to be
      0; pre_travel will never be called on any (_, start) and post_travel will
      never we called on any (end, _). If pre_travel_evaluator or
      post_travel_evaluator is -1, it will be taken as a function that always
      returns 0.

    • setBreakIntervalsOfVehicle

      public void setBreakIntervalsOfVehicle(IntervalVar[] breaks, int vehicle, long[] node_visit_transits)
      Deprecated, sets pre_travel(i, j) = node_visit_transit[i].

    • setBreakDistanceDurationOfVehicle

      public void setBreakDistanceDurationOfVehicle(long distance, long duration, int vehicle)
      With breaks supposed to be consecutive, this forces the distance between
      breaks of size at least minimum_break_duration to be at most distance.
      This supposes that the time until route start and after route end are
      infinite breaks.

    • InitializeBreaks

      public void InitializeBreaks()
      Sets up vehicle_break_intervals_, vehicle_break_distance_duration_,
      pre_travel_evaluators and post_travel_evaluators.

    • HasBreakConstraints

      public boolean HasBreakConstraints()
      Returns true if any break interval or break distance was defined.

    • setBreakIntervalsOfVehicle

      public void setBreakIntervalsOfVehicle(IntervalVar[] breaks, int vehicle, long[] node_visit_transits, LongBinaryOperator delays)
      Deprecated, sets pre_travel(i, j) = node_visit_transit[i]
      and post_travel(i, j) = delays(i, j).

    • getBreakIntervalsOfVehicle

      public IntervalVar[] getBreakIntervalsOfVehicle(int vehicle)
      Returns the break intervals set by SetBreakIntervalsOfVehicle().

    • GetPreTravelEvaluatorOfVehicle

      public int GetPreTravelEvaluatorOfVehicle(int vehicle)

    • GetPostTravelEvaluatorOfVehicle

      public int GetPostTravelEvaluatorOfVehicle(int vehicle)

    • base_dimension

      public RoutingDimension base_dimension()
      Returns the parent in the dependency tree if any or nullptr otherwise.

    • shortestTransitionSlack

      public long shortestTransitionSlack(long node)
      It makes sense to use the function only for self-dependent dimension.
      For such dimensions the value of the slack of a node determines the
      transition cost of the next transit. Provided that
      1. cumul[node] is fixed,
      2. next[node] and next[next[node]] (if exists) are fixed,
      the value of slack[node] for which cumul[next[node]] + transit[next[node]]
      is minimized can be found in O(1) using this function.

    • name

      public String name()
      Returns the name of the dimension.

    • setPickupToDeliveryLimitFunctionForPair

      public void setPickupToDeliveryLimitFunctionForPair(IntIntToLongFunction limit_function, int pair_index)

    • hasPickupToDeliveryLimits

      public boolean hasPickupToDeliveryLimits()

    • addNodePrecedence

      public void addNodePrecedence(long first_node, long second_node, long offset)

    • getSpanUpperBoundForVehicle

      public long getSpanUpperBoundForVehicle(int vehicle)

    • getSpanCostCoefficientForVehicle

      public long getSpanCostCoefficientForVehicle(int vehicle)

    • GetSlackCostCoefficientForVehicle

      public long GetSlackCostCoefficientForVehicle(int vehicle)

    • getGlobalSpanCostCoefficient

      public long getGlobalSpanCostCoefficient()

    • GetGlobalOptimizerOffset

      public long GetGlobalOptimizerOffset()

    • getLocalOptimizerOffsetForVehicle

      public long getLocalOptimizerOffsetForVehicle(int vehicle)

    • setSoftSpanUpperBoundForVehicle

      public void setSoftSpanUpperBoundForVehicle(BoundCost bound_cost, int vehicle)
      If the span of vehicle on this dimension is larger than bound,
      the cost will be increased by cost * (span - bound).

    • hasSoftSpanUpperBounds

      public boolean hasSoftSpanUpperBounds()

    • getSoftSpanUpperBoundForVehicle

      public BoundCost getSoftSpanUpperBoundForVehicle(int vehicle)

    • setQuadraticCostSoftSpanUpperBoundForVehicle

      public void setQuadraticCostSoftSpanUpperBoundForVehicle(BoundCost bound_cost, int vehicle)
      If the span of vehicle on this dimension is larger than bound,
      the cost will be increased by cost * (span - bound)^2.

    • hasQuadraticCostSoftSpanUpperBounds

      public boolean hasQuadraticCostSoftSpanUpperBounds()

    • getQuadraticCostSoftSpanUpperBoundForVehicle

      public BoundCost getQuadraticCostSoftSpanUpperBoundForVehicle(int vehicle)