RoutingDimension (com.google.ortools:ortools-java 9.10.4067 API)

java.lang.Object
- com.google.ortools.constraintsolver.RoutingDimension

```
public class RoutingDimension
extends java.lang.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 Summary

Fields
Modifier and Type Field and Description

protected boolean swigCMemOwn

Fields
Modifier and Type	Field and Description
`protected boolean`	`swigCMemOwn`

Constructor Summary

Constructors
Constructor and Description

RoutingDimension(long cPtr, boolean cMemoryOwn)

Constructors
Constructor and Description
`RoutingDimension(long cPtr, boolean cMemoryOwn)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addNodePrecedence(long first_node, long second_node, long offset)`
`RoutingDimension`	`base_dimension()` Returns the parent in the dependency tree if any or nullptr otherwise.
`IntVar[]`	`cumuls()` Like CumulVar(), TransitVar(), SlackVar() but return the whole variable vectors instead (indexed by int64_t var index).
`IntVar`	`cumulVar(long index)` Get the cumul, transit and slack variables for the given node (given as int64_t var index).
`void`	`delete()`
`protected void`	`finalize()`
`IntVar[]`	`fixed_transits()`
`IntVar`	`fixedTransitVar(long index)`
`IntervalVar[]`	`getBreakIntervalsOfVehicle(int vehicle)` Returns the break intervals set by SetBreakIntervalsOfVehicle().
`static long`	`getCPtr(RoutingDimension obj)`
`long`	`getCumulVarSoftLowerBound(long index)` Returns the soft lower bound of a cumul variable for a given variable index.
`long`	`getCumulVarSoftLowerBoundCoefficient(long index)` Returns the cost coefficient of the soft lower bound of a cumul variable for a given variable index.
`long`	`getCumulVarSoftUpperBound(long index)` Returns the soft upper bound of a cumul variable for a given variable index.
`long`	`getCumulVarSoftUpperBoundCoefficient(long index)` Returns the cost coefficient of the soft upper bound of a cumul variable for a given variable index.
`long`	`GetGlobalOptimizerOffset()`
`long`	`getGlobalSpanCostCoefficient()`
`long`	`getLocalOptimizerOffsetForVehicle(int vehicle)`
`int`	`GetPostTravelEvaluatorOfVehicle(int vehicle)`
`int`	`GetPreTravelEvaluatorOfVehicle(int vehicle)`
`BoundCost`	`getQuadraticCostSoftSpanUpperBoundForVehicle(int vehicle)`
`long`	`GetSlackCostCoefficientForVehicle(int vehicle)`
`BoundCost`	`getSoftSpanUpperBoundForVehicle(int vehicle)`
`long`	`getSpanCostCoefficientForVehicle(int vehicle)`
`long`	`getSpanUpperBoundForVehicle(int vehicle)`
`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'.
`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()).
`boolean`	`HasBreakConstraints()` Returns true if any break interval or break distance was defined.
`boolean`	`hasCumulVarSoftLowerBound(long index)` Returns true if a soft lower bound has been set for a given variable index.
`boolean`	`hasCumulVarSoftUpperBound(long index)` Returns true if a soft upper bound has been set for a given variable index.
`boolean`	`hasPickupToDeliveryLimits()`
`boolean`	`hasQuadraticCostSoftSpanUpperBounds()`
`boolean`	`hasSoftSpanUpperBounds()`
`void`	`InitializeBreaks()` Sets up vehicle_break_intervals_, vehicle_break_distance_duration_, pre_travel_evaluators and post_travel_evaluators.
`RoutingModel`	`model()` Returns the model on which the dimension was created.
`java.lang.String`	`name()` Returns the name of the dimension.
`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.
`void`	`setBreakIntervalsOfVehicle(IntervalVar[] breaks, int vehicle, int pre_travel_evaluator, int post_travel_evaluator)` Sets the breaks for a given vehicle.
`void`	`setBreakIntervalsOfVehicle(IntervalVar[] breaks, int vehicle, long[] node_visit_transits)` Deprecated, sets pre_travel(i, j) = node_visit_transit[i].
`void`	`setBreakIntervalsOfVehicle(IntervalVar[] breaks, int vehicle, long[] node_visit_transits, java.util.function.LongBinaryOperator delays)` Deprecated, sets pre_travel(i, j) = node_visit_transit[i] and post_travel(i, j) = delays(i, j).
`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.
`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.
`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)).
`void`	`setPickupToDeliveryLimitFunctionForPair(IntIntToLongFunction limit_function, int pair_index)`
`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.
`void`	`SetSlackCostCoefficientForAllVehicles(long coefficient)`
`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.
`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).
`void`	`setSpanCostCoefficientForAllVehicles(long coefficient)`
`void`	`setSpanCostCoefficientForVehicle(long coefficient, int vehicle)` Sets a cost proportional to the dimension span on a given vehicle, or on all vehicles at once.
`void`	`setSpanUpperBoundForVehicle(long upper_bound, int vehicle)` Sets an upper bound on the dimension span on a given vehicle.
`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.
`IntVar[]`	`slacks()`
`IntVar`	`slackVar(long index)`
`static long`	`swigRelease(RoutingDimension obj)`
`IntVar[]`	`transits()`
`IntVar`	`transitVar(long index)`

Methods inherited from class java.lang.Object
clone, equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - swigCMemOwn
```
protected transient boolean swigCMemOwn
```
- Constructor Detail
  - RoutingDimension
```
public RoutingDimension(long cPtr,
                        boolean cMemoryOwn)
```
- Method Detail
  - getCPtr
```
public static long getCPtr(RoutingDimension obj)
```
  - swigRelease
```
public static long swigRelease(RoutingDimension obj)
```
  - finalize
```
protected void finalize()
```
    Overrides:
    
    finalize in class java.lang.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)
```
  - 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,
                                       java.util.function.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 java.lang.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)
```

Class RoutingDimension

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

swigCMemOwn

Constructor Detail

RoutingDimension

Method Detail

getCPtr

swigRelease

finalize

delete

model

getTransitValue

getTransitValueFromClass

cumulVar

transitVar

fixedTransitVar

slackVar

cumuls

fixed_transits

transits

slacks

setSpanUpperBoundForVehicle

setSpanCostCoefficientForVehicle

setSpanCostCoefficientForAllVehicles

SetSlackCostCoefficientForVehicle

SetSlackCostCoefficientForAllVehicles

setGlobalSpanCostCoefficient

setCumulVarSoftUpperBound

hasCumulVarSoftUpperBound

getCumulVarSoftUpperBound

getCumulVarSoftUpperBoundCoefficient

setCumulVarSoftLowerBound

hasCumulVarSoftLowerBound

getCumulVarSoftLowerBound

getCumulVarSoftLowerBoundCoefficient

setBreakIntervalsOfVehicle

setBreakIntervalsOfVehicle

setBreakDistanceDurationOfVehicle

InitializeBreaks

HasBreakConstraints

setBreakIntervalsOfVehicle

getBreakIntervalsOfVehicle

GetPreTravelEvaluatorOfVehicle

GetPostTravelEvaluatorOfVehicle

base_dimension

shortestTransitionSlack

name

setPickupToDeliveryLimitFunctionForPair

hasPickupToDeliveryLimits

addNodePrecedence

getSpanUpperBoundForVehicle

getSpanCostCoefficientForVehicle

GetSlackCostCoefficientForVehicle

getGlobalSpanCostCoefficient

GetGlobalOptimizerOffset

getLocalOptimizerOffsetForVehicle

setSoftSpanUpperBoundForVehicle

hasSoftSpanUpperBounds

getSoftSpanUpperBoundForVehicle

setQuadraticCostSoftSpanUpperBoundForVehicle

hasQuadraticCostSoftSpanUpperBounds

getQuadraticCostSoftSpanUpperBoundForVehicle