OR-Tools  8.2
operations_research Namespace Reference

The vehicle routing library lets one model and solve generic vehicle routing problems ranging from the Traveling Salesman Problem to more complex problems such as the Capacitated Vehicle Routing Problem with Time Windows. More...

Namespaces

 bop
 
 cap_prod_util
 
 data
 
 fz
 
 glop
 
 internal
 
 or_internal
 
 sat
 
 scp
 
 sysinfo
 
 utf8
 

Classes

class  DenseDoublyLinkedList
 
class  DynamicPartition
 
class  MergingPartition
 
class  DynamicPermutation
 
class  GraphSymmetryFinder
 
class  HungarianOptimizer
 
class  KnapsackBruteForceSolver
 
struct  KnapsackItemWithEfficiency
 
class  Knapsack64ItemsSolver
 
class  KnapsackDynamicProgrammingSolver
 
class  KnapsackMIPSolver
 
class  KnapsackSolver
 This library solves knapsack problems. More...
 
struct  KnapsackAssignment
 
struct  KnapsackItem
 
class  KnapsackSearchNode
 
class  KnapsackSearchPath
 
class  KnapsackState
 
class  KnapsackPropagator
 
class  KnapsackCapacityPropagator
 
class  BaseKnapsackSolver
 
class  KnapsackGenericSolver
 
struct  KnapsackAssignmentForCuts
 
struct  KnapsackItemForCuts
 
class  KnapsackSearchNodeForCuts
 
class  KnapsackSearchPathForCuts
 
class  KnapsackStateForCuts
 
class  KnapsackPropagatorForCuts
 
class  KnapsackSolverForCuts
 
class  SparsePermutation
 
class  AccurateSum
 
class  Bitmap
 
class  MathUtil
 
class  ACMRandom
 
class  MTRandom
 
class  ThreadPool
 
class  Queue
 
struct  StateInfo
 
struct  StateMarker
 
struct  Trail
 
class  Search
 
class  Trace
 
class  LocalSearchMonitorMaster
 
class  SimpleRevFIFO
 This class represent a reversible FIFO structure. More...
 
struct  DefaultPhaseParameters
 This struct holds all parameters for the default search. More...
 
class  Solver
 Solver Class. More...
 
class  BaseObject
 A BaseObject is the root of all reversibly allocated objects. More...
 
class  PropagationBaseObject
 NOLINT. More...
 
class  Decision
 A Decision represents a choice point in the search tree. More...
 
class  DecisionVisitor
 A DecisionVisitor is used to inspect a decision. More...
 
class  DecisionBuilder
 A DecisionBuilder is responsible for creating the search tree. More...
 
class  Demon
 A Demon is the base element of a propagation queue. More...
 
class  ModelVisitor
 Model visitor. More...
 
class  Constraint
 A constraint is the main modeling object. More...
 
class  CastConstraint
 Cast constraints are special channeling constraints designed to keep a variable in sync with an expression. More...
 
class  SearchMonitor
 A search monitor is a simple set of callbacks to monitor all search events. More...
 
class  Rev
 This class adds reversibility to a POD type. More...
 
class  NumericalRev
 Subclass of Rev<T> which adds numerical operations. More...
 
class  RevArray
 Reversible array of POD types. More...
 
class  NumericalRevArray
 Subclass of RevArray<T> which adds numerical operations. More...
 
class  IntExpr
 The class IntExpr is the base of all integer expressions in constraint programming. More...
 
class  IntVarIterator
 The class Iterator has two direct subclasses. More...
 
class  InitAndGetValues
 Utility class to encapsulate an IntVarIterator and use it in a range-based loop. More...
 
class  IntVar
 The class IntVar is a subset of IntExpr. More...
 
class  SolutionCollector
 This class is the root class of all solution collectors. More...
 
class  OptimizeVar
 This class encapsulates an objective. More...
 
class  SearchLimit
 Base class of all search limits. More...
 
class  RegularLimit
 Usual limit based on wall_time, number of explored branches and number of failures in the search tree. More...
 
class  ImprovementSearchLimit
 
class  IntervalVar
 Interval variables are often used in scheduling. More...
 
class  SequenceVar
 A sequence variable is a variable whose domain is a set of possible orderings of the interval variables. More...
 
class  AssignmentElement
 
class  IntVarElement
 
class  IntervalVarElement
 
class  SequenceVarElement
 The SequenceVarElement stores a partial representation of ranked interval variables in the underlying sequence variable. More...
 
class  AssignmentContainer
 
class  Assignment
 An Assignment is a variable -> domains mapping, used to report solutions to the user. More...
 
class  Pack
 
class  DisjunctiveConstraint
 
class  SolutionPool
 This class is used to manage a pool of solutions. More...
 
class  BaseIntExpr
 This is the base class for all expressions that are not variables. More...
 
class  RevImmutableMultiMap
 Reversible Immutable MultiMap class. More...
 
class  RevSwitch
 A reversible switch that can switch once from false to true. More...
 
class  SmallRevBitSet
 This class represents a small reversible bitset (size <= 64). More...
 
class  RevBitSet
 This class represents a reversible bitset. More...
 
class  RevBitMatrix
 Matrix version of the RevBitSet class. More...
 
class  CallMethod0
 Demon proxy to a method on the constraint with no arguments. More...
 
class  CallMethod1
 Demon proxy to a method on the constraint with one argument. More...
 
class  CallMethod2
 Demon proxy to a method on the constraint with two arguments. More...
 
class  CallMethod3
 Demon proxy to a method on the constraint with three arguments. More...
 
class  DelayedCallMethod0
 Low-priority demon proxy to a method on the constraint with no arguments. More...
 
class  DelayedCallMethod1
 Low-priority demon proxy to a method on the constraint with one argument. More...
 
class  DelayedCallMethod2
 Low-priority demon proxy to a method on the constraint with two arguments. More...
 
class  LocalSearchOperator
 The base class for all local search operators. More...
 
class  VarLocalSearchOperator
 Base operator class for operators manipulating variables. More...
 
class  IntVarLocalSearchHandler
 
class  IntVarLocalSearchOperator
 Specialization of LocalSearchOperator built from an array of IntVars which specifies the scope of the operator. More...
 
class  SequenceVarLocalSearchHandler
 
class  SequenceVarLocalSearchOperator
 
class  BaseLns
 This is the base class for building an Lns operator. More...
 
class  ChangeValue
 Defines operators which change the value of variables; each neighbor corresponds to one modified variable. More...
 
class  PathOperator
 Base class of the local search operators dedicated to path modifications (a path is a set of nodes linked together by arcs). More...
 
class  LocalSearchState
 
class  LocalSearchVariable
 
class  LocalSearchFilter
 Local Search Filters are used for fast neighbor pruning. More...
 
class  LocalSearchFilterManager
 Filter manager: when a move is made, filters are executed to decide whether the solution is feasible and compute parts of the new cost. More...
 
class  IntVarLocalSearchFilter
 
class  PropagationMonitor
 
class  LocalSearchMonitor
 
class  BooleanVar
 
class  SymmetryBreaker
 A symmetry breaker is an object that will visit a decision and create the 'symmetrical' decision in return. More...
 
class  SearchLog
 The base class of all search logs that periodically outputs information when the search is running. More...
 
class  ModelCache
 Implements a complete cache for model elements: expressions and constraints. More...
 
class  ArgumentHolder
 Argument Holder: useful when visiting a model. More...
 
class  ModelParser
 Model Parser. More...
 
class  ArrayWithOffset
 
class  RevGrowingArray
 This class is a reversible growing array. More...
 
class  RevIntSet
 This is a special class to represent a 'residual' set of T. More...
 
class  RevPartialSequence
 --— RevPartialSequence --— More...
 
class  UnsortedNullableRevBitset
 This class represents a reversible bitset. More...
 
class  PathState
 
class  UnaryDimensionChecker
 
class  DemonProfiler
 
class  IfThenElseCt
 
class  PiecewiseLinearExpr
 
class  TwoOpt
 
class  Relocate
 
class  Exchange
 
class  Cross
 
class  BaseInactiveNodeToPathOperator
 
class  MakeActiveOperator
 
class  RelocateAndMakeActiveOperator
 
class  MakeActiveAndRelocate
 
class  MakeInactiveOperator
 
class  RelocateAndMakeInactiveOperator
 
class  MakeChainInactiveOperator
 
class  SwapActiveOperator
 
class  ExtendedSwapActiveOperator
 
class  TSPOpt
 
class  TSPLns
 
class  NearestNeighbors
 
class  LinKernighan
 
class  PathLns
 
class  NeighborhoodLimit
 
class  LocalSearchProfiler
 
class  FindOneNeighbor
 
class  LocalSearchPhaseParameters
 
class  Dimension
 
class  RoutingModelInspector
 
struct  Link
 
struct  LinkSort
 
class  RouteConstructor
 
struct  SweepIndex
 
struct  SweepIndexSortAngle
 
struct  SweepIndexSortDistance
 
class  SweepBuilder
 
class  RoutingModel
 
class  RoutingModelVisitor
 Routing model visitor. More...
 
class  DisjunctivePropagator
 This 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. More...
 
struct  TravelBounds
 
class  GlobalVehicleBreaksConstraint
 GlobalVehicleBreaksConstraint ensures breaks constraints are enforced on all vehicles in the dimension passed to its constructor. More...
 
class  TypeRegulationsChecker
 
class  TypeIncompatibilityChecker
 Checker for type incompatibilities. More...
 
class  TypeRequirementChecker
 Checker for type requirements. More...
 
class  TypeRegulationsConstraint
 The following constraint ensures that incompatibilities and requirements between types are respected. More...
 
class  SimpleBoundCosts
 A structure meant to store soft bounds and associated violation constants. More...
 
class  RoutingDimension
 Dimensions represent quantities accumulated at nodes along the routes. More...
 
class  SweepArranger
 Class to arrange indices by by their distance and their angles from the depot. More...
 
class  VehicleTypeCurator
 Helper class that manages vehicles. More...
 
class  IntVarFilteredDecisionBuilder
 Decision builder building a solution using heuristics with local search filters to evaluate its feasibility. More...
 
class  IntVarFilteredHeuristic
 Generic filter-based heuristic applied to IntVars. More...
 
class  RoutingFilteredHeuristic
 Filter-based heuristic dedicated to routing. More...
 
class  CheapestInsertionFilteredHeuristic
 
class  GlobalCheapestInsertionFilteredHeuristic
 Filter-based decision builder which builds a solution by inserting nodes at their cheapest position on any route; potentially several routes can be built in parallel. More...
 
class  LocalCheapestInsertionFilteredHeuristic
 Filter-base decision builder which builds a solution by inserting nodes at their cheapest position. More...
 
class  CheapestAdditionFilteredHeuristic
 Filtered-base decision builder based on the addition heuristic, extending a path from its start node with the cheapest arc. More...
 
class  EvaluatorCheapestAdditionFilteredHeuristic
 A CheapestAdditionFilteredHeuristic where the notion of 'cheapest arc' comes from an arc evaluator. More...
 
class  ComparatorCheapestAdditionFilteredHeuristic
 A CheapestAdditionFilteredHeuristic where the notion of 'cheapest arc' comes from an arc comparator. More...
 
class  SavingsFilteredHeuristic
 Filter-based decision builder which builds a solution by using Clarke & Wright's Savings heuristic. More...
 
class  SequentialSavingsFilteredHeuristic
 
class  ParallelSavingsFilteredHeuristic
 
class  ChristofidesFilteredHeuristic
 Christofides addition heuristic. More...
 
class  BasePathFilter
 Generic path-based filter class. More...
 
class  CPFeasibilityFilter
 This filter accepts deltas for which the assignment satisfies the constraints of the Solver. More...
 
class  RoutingIndexManager
 Manager for any NodeIndex <-> variable index conversion. More...
 
class  CumulBoundsPropagator
 
class  RoutingLinearSolverWrapper
 
class  RoutingGlopWrapper
 
class  RoutingCPSatWrapper
 
class  DimensionCumulOptimizerCore
 
class  LocalDimensionCumulOptimizer
 
class  GlobalDimensionCumulOptimizer
 
class  MakeRelocateNeighborsOperator
 Relocate neighborhood which moves chains of neighbors. More...
 
class  MakePairActiveOperator
 Pair-based neighborhood operators, designed to move nodes by pairs (pairs are static and given). More...
 
class  MakePairInactiveOperator
 Operator which makes pairs of active nodes inactive. More...
 
class  PairRelocateOperator
 Operator which moves a pair of nodes to another position where the first node of the pair must be before the second node on the same path. More...
 
class  LightPairRelocateOperator
 
class  PairExchangeOperator
 Operator which exchanges the position of two pairs; for both pairs the first node of the pair must be before the second node on the same path. More...
 
class  PairExchangeRelocateOperator
 Operator which exchanges the paths of two pairs (path have to be different). More...
 
class  SwapIndexPairOperator
 Operator which iterates through each alternative of a set of pairs. More...
 
class  IndexPairSwapActiveOperator
 Operator which inserts inactive nodes into a path and makes a pair of active nodes inactive. More...
 
class  FilteredHeuristicLocalSearchOperator
 Class of operators using a RoutingFilteredHeuristic to insert unperformed nodes after changes have been made to the current solution. More...
 
class  FilteredHeuristicPathLNSOperator
 LNS-like operator based on a filtered first solution heuristic to rebuild the solution, after the destruction phase consisting of removing one route. More...
 
class  RelocatePathAndHeuristicInsertUnperformedOperator
 Heuristic-based local search operator which relocates an entire route to an empty vehicle of different vehicle class and then tries to insert unperformed nodes using the heuristic. More...
 
class  FilteredHeuristicExpensiveChainLNSOperator
 Similar to the heuristic path LNS above, but instead of removing one route entirely, the destruction phase consists of removing all nodes on an "expensive" chain from a route. More...
 
class  FilteredHeuristicCloseNodesLNSOperator
 Filtered heuristic LNS operator, where the destruction phase consists of removing a node and the 'num_close_nodes' nodes closest to it, along with each of their corresponding sibling pickup/deliveries that are performed. More...
 
class  RelocateExpensiveChain
 RelocateExpensiveChain. More...
 
class  PairNodeSwapActiveOperator
 Operator which inserts pairs of inactive nodes into a path and makes an active node inactive. More...
 
class  RelocateSubtrip
 Tries to move subtrips after an insertion node. More...
 
class  ExchangeSubtrip
 
class  SymmetryManager
 
class  SimpleLinearSumAssignment
 
class  AStarSP
 
class  BellmanFord
 
class  ChristofidesPathSolver
 
class  BronKerboschAlgorithm
 
class  DijkstraSP
 
class  EbertGraph
 
class  ForwardEbertGraph
 
class  ForwardStaticGraph
 
class  StarGraphBase
 
class  PermutationIndexComparisonByArcHead
 
class  EbertGraphBase
 
struct  graph_traits
 
struct  graph_traits< ForwardEbertGraph< NodeIndexType, ArcIndexType > >
 
struct  graph_traits< ForwardStaticGraph< NodeIndexType, ArcIndexType > >
 
class  TailArrayManager
 
class  ArcFunctorOrderingByTailAndHead
 
class  AnnotatedGraphBuildManager
 
struct  Graphs
 
struct  Graphs< operations_research::StarGraph >
 
class  ElementIterator
 
class  Set
 
class  SetRangeIterator
 
class  SetRangeWithCardinality
 
class  LatticeMemoryManager
 
class  HamiltonianPathSolver
 
class  PruningHamiltonianSolver
 
class  LinearSumAssignment
 
class  CostValueCycleHandler
 
class  ArcIndexOrderingByTailNode
 
class  GenericMaxFlow
 
class  SimpleMaxFlow
 
class  PriorityQueueWithRestrictedPush
 
class  MaxFlowStatusClass
 
class  MaxFlow
 
class  GenericMinCostFlow
 
class  MinCostFlowBase
 
class  SimpleMinCostFlow
 
class  MinCostFlow
 
class  VolgenantJonkerEvaluator
 
class  HeldWolfeCrowderEvaluator
 
struct  TravelingSalesmanLowerBoundParameters
 
class  MinCostPerfectMatching
 
class  BlossomGraph
 
struct  GScipResult
 
struct  GScipLinearRange
 
class  GScip
 
struct  GScipQuadraticRange
 
struct  GScipSOSData
 
struct  GScipIndicatorConstraint
 
struct  GScipLogicalConstraintData
 
struct  GScipVariableOptions
 
struct  GScipConstraintOptions
 
struct  GScipLinearExpr
 
struct  GScipIndicatorRangeConstraint
 
class  BopInterface
 
class  CBCInterface
 
class  CLPInterface
 
class  GLOPInterface
 
class  GurobiInterface
 
class  LinearExpr
 LinearExpr models a quantity that is linear in the decision variables (MPVariable) of an optimization problem, i.e. More...
 
class  LinearRange
 An expression of the form: More...
 
class  MPSolver
 This mathematical programming (MP) solver class is the main class though which users build and solve problems. More...
 
class  MPObjective
 A class to express a linear objective. More...
 
class  MPVariable
 The class for variables of a Mathematical Programming (MP) model. More...
 
class  MPConstraint
 The class for constraints of a Mathematical Programming (MP) model. More...
 
class  MPSolverParameters
 This class stores parameter settings for LP and MIP solvers. More...
 
class  MPSolverInterface
 
class  MPCallbackContext
 
class  MPCallback
 
class  MPCallbackList
 
struct  MPModelExportOptions
 Export options. More...
 
class  SatInterface
 
struct  CallbackSetup
 
struct  ScipConstraintHandlerDescription
 
class  ScipConstraintHandlerContext
 
struct  CallbackRangeConstraint
 
class  ScipConstraintHandler
 
struct  ScipCallbackConstraintOptions
 
class  SCIPInterface
 
class  ScipConstraintHandlerForMPCallback
 
class  ScipMPCallbackContext
 
class  AdaptiveParameterValue
 
class  AffineRelation
 
class  Bitset64
 
class  BitQueue64
 
class  SparseBitset
 
class  CachedLog
 
class  ScopedFloatingPointEnv
 
class  GraphExporter
 
class  IntegerPriorityQueue
 
class  LazyMutableCopy
 
class  MonoidOperationTree
 
class  PermutationCycleHandler
 
class  ArrayIndexCycleHandler
 
class  PermutationApplier
 
class  PiecewiseSegment
 
class  PiecewiseLinearFunction
 
class  RangeMinimumQuery
 
class  RangeMinimumIndexQuery
 
class  RangeIntToIntFunction
 
class  RangeMinMaxIndexFunction
 
class  ReversibleInterface
 
class  RevRepository
 
class  RevVector
 
class  RevMap
 
class  RevGrowingMultiMap
 
class  RunningAverage
 
class  RunningMax
 
class  SigintHandler
 
struct  ClosedInterval
 Represents a closed interval [start, end]. More...
 
class  Domain
 We call domain any subset of Int64 = [kint64min, kint64max]. More...
 
class  SortedDisjointIntervalList
 This class represents a sorted list of disjoint, closed intervals. More...
 
class  Stat
 
class  StatsGroup
 
class  DistributionStat
 
class  TimeDistribution
 
class  RatioDistribution
 
class  DoubleDistribution
 
class  IntegerDistribution
 
class  EnabledScopedTimeDistributionUpdater
 
class  DisabledScopedTimeDistributionUpdater
 
class  DisabledScopedInstructionCounter
 
class  TimeLimit
 A simple class to enforce both an elapsed time limit and a deterministic time limit in the same thread as a program. More...
 
class  SharedTimeLimit
 
class  NestedTimeLimit
 Provides a way to nest time limits for algorithms where a certain part of the computation is bounded not just by the overall time limit, but also by a stricter time limit specific just for this particular part. More...
 
class  IntTupleSet
 
class  VectorMap
 
class  VectorOrFunction
 
class  VectorOrFunction< ScalarType, std::vector< ScalarType > >
 
class  MatrixOrFunction
 
class  MatrixOrFunction< ScalarType, std::vector< std::vector< ScalarType > >, square >
 
class  ZVector
 

Typedefs

typedef KnapsackItemKnapsackItemPtr
 
using KnapsackItemForCutsPtr = std::unique_ptr< KnapsackItemForCuts >
 
typedef VarLocalSearchOperator< SequenceVar, std::vector< int >, SequenceVarLocalSearchHandlerSequenceVarLocalSearchOperatorTemplate
 
typedef std::function< int64(int64)> RoutingTransitCallback1
 
typedef std::function< int64(int64, int64)> RoutingTransitCallback2
 
typedef std::pair< std::vector< int64 >, std::vector< int64 > > RoutingIndexPair
 
typedef std::vector< RoutingIndexPairRoutingIndexPairs
 
typedef std::pair< int64, int64Arc
 
using NodeIndex = int32
 
typedef int32 ArcIndex
 
typedef int64 FlowQuantity
 
using CostValue = int64
 
typedef EbertGraph< NodeIndex, ArcIndexStarGraph
 
typedef ForwardEbertGraph< NodeIndex, ArcIndexForwardStarGraph
 
typedef ForwardStaticGraph< NodeIndex, ArcIndexForwardStarStaticGraph
 
typedef ZVector< NodeIndexNodeIndexArray
 
typedef ZVector< ArcIndexArcIndexArray
 
typedef ZVector< FlowQuantityQuantityArray
 
typedef ZVector< CostValueCostArray
 
typedef int PathNodeIndex
 
using GScipSolution = absl::flat_hash_map< SCIP_VAR *, double >
 
using GScipBranchingPriority = absl::flat_hash_map< SCIP_VAR *, int >
 
using random_engine_t = std::mt19937
 
typedef std::pair< int64, int64Fraction
 
template<class Iterator >
using value_type_t = typename std::iterator_traits< Iterator >::value_type
 
using ScopedTimeDistributionUpdater = DisabledScopedTimeDistributionUpdater
 
using ScopedInstructionCounter = DisabledScopedInstructionCounter
 
typedef ZVector< int8Int8ZVector
 
typedef ZVector< int16Int16ZVector
 
typedef ZVector< int32Int32ZVector
 
typedef ZVector< int64Int64ZVector
 
typedef ZVector< uint8UInt8ZVector
 
typedef ZVector< uint16UInt16ZVector
 
typedef ZVector< uint32UInt32ZVector
 
typedef ZVector< uint64UInt64ZVector
 

Enumerations

enum  VarTypes {
  UNSPECIFIED , DOMAIN_INT_VAR , BOOLEAN_VAR , CONST_VAR ,
  VAR_ADD_CST , VAR_TIMES_CST , CST_SUB_VAR , OPP_VAR ,
  TRACE_VAR
}
 This enum is used internally to do dynamic typing on subclasses of integer variables. More...
 
enum class  DimensionSchedulingStatus { OPTIMAL , RELAXED_OPTIMAL_ONLY , INFEASIBLE }
 
enum class  CliqueResponse { CONTINUE , STOP }
 
enum class  BronKerboschAlgorithmStatus { COMPLETED , INTERRUPTED }
 
enum class  GScipVarType { kContinuous , kInteger , kImpliedInteger }
 
enum class  GScipHintResult { kInfeasible , kRejected , kAccepted }
 
enum class  MPCallbackEvent {
  kUnknown , kPolling , kPresolve , kSimplex ,
  kMip , kMipSolution , kMipNode , kBarrier ,
  kMessage , kMultiObj
}
 
enum class  ScipSeparationResult { kLazyConstraintAdded , kCuttingPlaneAdded , kDidNotFind }
 
enum class  ProtoWriteFormat { kProtoText , kProtoBinary , kJson }
 

Functions

bool InputContainsNan (const std::vector< std::vector< double >> &input)
 
void MinimizeLinearAssignment (const std::vector< std::vector< double >> &cost, absl::flat_hash_map< int, int > *direct_assignment, absl::flat_hash_map< int, int > *reverse_assignment)
 
void MaximizeLinearAssignment (const std::vector< std::vector< double >> &cost, absl::flat_hash_map< int, int > *direct_assignment, absl::flat_hash_map< int, int > *reverse_assignment)
 
void MinimizeLinearAssignment (const std::vector< std::vector< double > > &cost, absl::flat_hash_map< int, int > *direct_assignment, absl::flat_hash_map< int, int > *reverse_assignment)
 
void MaximizeLinearAssignment (const std::vector< std::vector< double > > &cost, absl::flat_hash_map< int, int > *direct_assignment, absl::flat_hash_map< int, int > *reverse_assignment)
 
void GenericCheck (const int expected_assignment_size, const absl::flat_hash_map< int, int > &direct_assignment, const absl::flat_hash_map< int, int > &reverse_assignment, const int expected_agents[], const int expected_tasks[])
 
void TestMinimization (const std::vector< std::vector< double > > &cost, const int expected_assignment_size, const int expected_agents[], const int expected_tasks[])
 
void TestMaximization (const std::vector< std::vector< double > > &cost, const int expected_assignment_size, const int expected_agents[], const int expected_tasks[])
 
 TEST (LinearAssignmentTest, NullMatrix)
 
 TEST (LinearAssignmentTest, SizeOneMatrix)
 
 TEST (LinearAssignmentTest, Small4x4Matrix)
 
 TEST (LinearAssignmentTest, Small3x4Matrix)
 
 TEST (LinearAssignmentTest, Small4x3Matrix)
 
bool CompareKnapsackItemWithEfficiencyInDecreasingEfficiencyOrder (const KnapsackItemWithEfficiency &item1, const KnapsackItemWithEfficiency &item2)
 
const KnapsackSearchNodeForCutsMoveUpToDepth (const KnapsackSearchNodeForCuts *node, int depth)
 
static void mix (uint32 &a, uint32 &b, uint32 &c)
 
static void mix (uint64 &a, uint64 &b, uint64 &c)
 
uint32 Hash32NumWithSeed (uint32 num, uint32 c)
 
uint64 Hash64NumWithSeed (uint64 num, uint64 c)
 
int64 GetProcessMemoryUsage ()
 
uint64 MixTwoUInt64 (uint64 fp1, uint64 fp2)
 
uint64 ThoroughHash (const char *bytes, size_t len)
 
void RunWorker (void *data)
 
int OrToolsMajorVersion ()
 
int OrToolsMinorVersion ()
 
template<class Var , class Element , class Proto , class Container >
void RealLoad (const AssignmentProto &assignment_proto, Container *const container, int(AssignmentProto::*GetSize)() const, const Proto &(AssignmentProto::*GetElem)(int) const)
 
template<class Var , class Element , class Proto , class Container >
void RealSave (AssignmentProto *const assignment_proto, const Container &container, Proto *(AssignmentProto::*Add)())
 
template<class Container , class Element >
void RealDebugString (const Container &container, std::string *const out)
 
void SetAssignmentFromAssignment (Assignment *target_assignment, const std::vector< IntVar * > &target_vars, const Assignment *source_assignment, const std::vector< IntVar * > &source_vars)
 NOLINT. More...
 
std::ostream & operator<< (std::ostream &out, const Assignment &assignment)
 
DemonProfilerBuildDemonProfiler (Solver *const solver)
 
void DeleteDemonProfiler (DemonProfiler *const monitor)
 
void InstallDemonProfiler (DemonProfiler *const monitor)
 
LocalSearchProfilerBuildLocalSearchProfiler (Solver *solver)
 
void DeleteLocalSearchProfiler (LocalSearchProfiler *monitor)
 
void InstallLocalSearchProfiler (LocalSearchProfiler *monitor)
 
void CleanVariableOnFail (IntVar *const var)
 
void RestoreBoolValue (IntVar *const var)
 
void InternalSaveBooleanVarValue (Solver *const solver, IntVar *const var)
 
bool LocalOptimumReached (Search *const search)
 
bool AcceptDelta (Search *const search, Assignment *delta, Assignment *deltadelta)
 
void AcceptNeighbor (Search *const search)
 
void AcceptUncheckedNeighbor (Search *const search)
 
PropagationMonitorBuildTrace (Solver *const s)
 
LocalSearchMonitorBuildLocalSearchMonitorMaster (Solver *const s)
 
ModelCacheBuildModelCache (Solver *const solver)
 
PropagationMonitorBuildPrintTrace (Solver *const s)
 
std::ostream & operator<< (std::ostream &out, const Solver *const s)
 
std::ostream & operator<< (std::ostream &out, const BaseObject *const o)
 
int64 CpRandomSeed ()
 
int64 Zero ()
 NOLINT. More...
 
int64 One ()
 This method returns 1. More...
 
uint64 Hash1 (uint64 value)
 Hash functions. More...
 
uint64 Hash1 (uint32 value)
 
uint64 Hash1 (int64 value)
 
uint64 Hash1 (int value)
 
uint64 Hash1 (void *const ptr)
 
template<class T >
uint64 Hash1 (const std::vector< T * > &ptrs)
 
uint64 Hash1 (const std::vector< int64 > &ptrs)
 
template<class T >
LocalSearchOperatorMakeLocalSearchOperator (Solver *solver, const std::vector< IntVar * > &vars, const std::vector< IntVar * > &secondary_vars, std::function< int(int64)> start_empty_path_class)
 Operator Factories. More...
 
template<class T >
bool IsArrayConstant (const std::vector< T > &values, const T &value)
 
template<class T >
bool IsArrayBoolean (const std::vector< T > &values)
 
template<class T >
bool AreAllOnes (const std::vector< T > &values)
 
template<class T >
bool AreAllNull (const std::vector< T > &values)
 
template<class T >
bool AreAllGreaterOrEqual (const std::vector< T > &values, const T &value)
 
template<class T >
bool AreAllLessOrEqual (const std::vector< T > &values, const T &value)
 
template<class T >
bool AreAllPositive (const std::vector< T > &values)
 
template<class T >
bool AreAllNegative (const std::vector< T > &values)
 
template<class T >
bool AreAllStrictlyPositive (const std::vector< T > &values)
 
template<class T >
bool AreAllStrictlyNegative (const std::vector< T > &values)
 
template<class T >
bool IsIncreasingContiguous (const std::vector< T > &values)
 
template<class T >
bool IsIncreasing (const std::vector< T > &values)
 
template<class T >
bool IsArrayInRange (const std::vector< IntVar * > &vars, T range_min, T range_max)
 
bool AreAllBound (const std::vector< IntVar * > &vars)
 
bool AreAllBooleans (const std::vector< IntVar * > &vars)
 
template<class T >
bool AreAllBoundOrNull (const std::vector< IntVar * > &vars, const std::vector< T > &values)
 Returns true if all the variables are assigned to a single value, or if their corresponding value is null. More...
 
bool AreAllBoundTo (const std::vector< IntVar * > &vars, int64 value)
 Returns true if all variables are assigned to 'value'. More...
 
int64 MaxVarArray (const std::vector< IntVar * > &vars)
 
int64 MinVarArray (const std::vector< IntVar * > &vars)
 
void FillValues (const std::vector< IntVar * > &vars, std::vector< int64 > *const values)
 
int64 PosIntDivUp (int64 e, int64 v)
 
int64 PosIntDivDown (int64 e, int64 v)
 
std::vector< int64ToInt64Vector (const std::vector< int > &input)
 
LocalSearchFilterMakePathStateFilter (Solver *solver, std::unique_ptr< PathState > path_state, const std::vector< IntVar * > &nexts)
 
LocalSearchFilterMakeUnaryDimensionFilter (Solver *solver, std::unique_ptr< UnaryDimensionChecker > checker)
 
std::string DefaultPhaseStatString (DecisionBuilder *db)
 
void RegisterDemon (Solver *const solver, Demon *const demon, DemonProfiler *const monitor)
 
void DemonProfilerAddFakeRun (DemonProfiler *const monitor, Demon *const demon, int64 start_time, int64 end_time, bool is_fail)
 
void DemonProfilerExportInformation (DemonProfiler *const monitor, const Constraint *const constraint, int64 *const fails, int64 *const initial_propagation_runtime, int64 *const demon_invocations, int64 *const total_demon_runtime, int *const demon_count)
 
void DemonProfilerBeginInitialPropagation (DemonProfiler *const monitor, Constraint *const constraint)
 
void DemonProfilerEndInitialPropagation (DemonProfiler *const monitor, Constraint *const constraint)
 
void LinkVarExpr (Solver *const s, IntExpr *const expr, IntVar *const var)
 
ConstraintSetIsEqual (IntVar *const var, const std::vector< int64 > &values, const std::vector< IntVar * > &vars)
 
ConstraintSetIsGreaterOrEqual (IntVar *const var, const std::vector< int64 > &values, const std::vector< IntVar * > &vars)
 
IntExprBuildStartExpr (IntervalVar *var)
 
IntExprBuildDurationExpr (IntervalVar *var)
 
IntExprBuildEndExpr (IntervalVar *var)
 
IntExprBuildSafeStartExpr (IntervalVar *var, int64 unperformed_value)
 
IntExprBuildSafeDurationExpr (IntervalVar *var, int64 unperformed_value)
 
IntExprBuildSafeEndExpr (IntervalVar *var, int64 unperformed_value)
 
DecisionBuilderMakeSetValuesFromTargets (Solver *solver, std::vector< IntVar * > variables, std::vector< int64 > targets)
 A decision builder which tries to assign values to variables as close as possible to target values first. More...
 
bool HasUnaryDimension (const std::vector< RoutingDimension * > &dimensions)
 
void FillPathEvaluation (const std::vector< int64 > &path, const RoutingModel::TransitCallback2 &evaluator, std::vector< int64 > *values)
 
void AppendTasksFromPath (const std::vector< int64 > &path, const TravelBounds &travel_bounds, const RoutingDimension &dimension, DisjunctivePropagator::Tasks *tasks)
 
void AppendTasksFromIntervals (const std::vector< IntervalVar * > &intervals, DisjunctivePropagator::Tasks *tasks)
 
void FillTravelBoundsOfVehicle (int vehicle, const std::vector< int64 > &path, const RoutingDimension &dimension, TravelBounds *travel_bounds)
 
bool SolveModelWithSat (const RoutingModel &model, const RoutingSearchParameters &search_parameters, const Assignment *initial_solution, Assignment *solution)
 Attempts to solve the model using the cp-sat solver. More...
 
IntVarLocalSearchFilterMakeMaxActiveVehiclesFilter (const RoutingModel &routing_model)
 
IntVarLocalSearchFilterMakeNodeDisjunctionFilter (const RoutingModel &routing_model)
 
IntVarLocalSearchFilterMakeVehicleAmortizedCostFilter (const RoutingModel &routing_model)
 
IntVarLocalSearchFilterMakeTypeRegulationsFilter (const RoutingModel &routing_model)
 
void AppendDimensionCumulFilters (const std::vector< RoutingDimension * > &dimensions, const RoutingSearchParameters &parameters, bool filter_objective_cost, std::vector< LocalSearchFilterManager::FilterEvent > *filters)
 
void AppendLightWeightDimensionFilters (const PathState *path_state, const std::vector< RoutingDimension * > &dimensions, std::vector< LocalSearchFilterManager::FilterEvent > *filters)
 
IntVarLocalSearchFilterMakePathCumulFilter (const RoutingDimension &dimension, const RoutingSearchParameters &parameters, bool propagate_own_objective_value, bool filter_objective_cost, bool can_use_lp=true)
 
IntVarLocalSearchFilterMakeCumulBoundsPropagatorFilter (const RoutingDimension &dimension)
 
IntVarLocalSearchFilterMakeGlobalLPCumulFilter (GlobalDimensionCumulOptimizer *optimizer, bool filter_objective_cost)
 
IntVarLocalSearchFilterMakePickupDeliveryFilter (const RoutingModel &routing_model, const RoutingModel::IndexPairs &pairs, const std::vector< RoutingModel::PickupAndDeliveryPolicy > &vehicle_policies)
 
IntVarLocalSearchFilterMakeVehicleVarFilter (const RoutingModel &routing_model)
 
IntVarLocalSearchFilterMakeVehicleBreaksFilter (const RoutingModel &routing_model, const RoutingDimension &dimension)
 
IntVarLocalSearchFilterMakeCPFeasibilityFilter (RoutingModel *routing_model)
 
void SetFirstSolutionStrategyFromFlags (RoutingSearchParameters *parameters)
 
void SetLocalSearchMetaheuristicFromFlags (RoutingSearchParameters *parameters)
 
void AddLocalSearchNeighborhoodOperatorsFromFlags (RoutingSearchParameters *parameters)
 
void SetSearchLimitsFromFlags (RoutingSearchParameters *parameters)
 
void SetMiscellaneousParametersFromFlags (RoutingSearchParameters *parameters)
 
RoutingSearchParameters BuildSearchParametersFromFlags ()
 Builds routing search parameters from flags. More...
 
RoutingModelParameters BuildModelParametersFromFlags ()
 Builds routing search parameters from flags. More...
 
RoutingModelParameters DefaultRoutingModelParameters ()
 
RoutingSearchParameters DefaultRoutingSearchParameters ()
 
std::string FindErrorInRoutingSearchParameters (const RoutingSearchParameters &search_parameters)
 Returns an empty std::string if the routing search parameters are valid, and a non-empty, human readable error description if they're not. More...
 
 DEFINE_INT_TYPE (RoutingNodeIndex, int)
 Defining common types used in the routing library outside the main RoutingModel class has several purposes: 1) It allows some small libraries to avoid a dependency on routing. More...
 
 DEFINE_INT_TYPE (RoutingCostClassIndex, int)
 
 DEFINE_INT_TYPE (RoutingDimensionIndex, int)
 
 DEFINE_INT_TYPE (RoutingDisjunctionIndex, int)
 
 DEFINE_INT_TYPE (RoutingVehicleClassIndex, int)
 
BaseAssignVariables::Mode ChooseMode (Solver::IntValueStrategy val_str)
 
bool AStarShortestPath (int node_count, int start_node, int end_node, std::function< int64(int, int)> graph, std::function< int64(int)> heuristic, int64 disconnected_distance, std::vector< int > *nodes)
 
bool BellmanFordShortestPath (int node_count, int start_node, int end_node, std::function< int64(int, int)> graph, int64 disconnected_distance, std::vector< int > *nodes)
 
template<typename WeightFunctionType , typename GraphType >
absl::StatusOr< std::vector< std::pair< typename GraphType::NodeIndex, typename GraphType::NodeIndex > > > ComputeMinimumWeightMatching (const GraphType &graph, const WeightFunctionType &weight)
 
template<typename WeightFunctionType , typename GraphType >
absl::StatusOr< std::vector< std::pair< typename GraphType::NodeIndex, typename GraphType::NodeIndex > > > ComputeMinimumWeightMatchingWithMIP (const GraphType &graph, const WeightFunctionType &weight)
 
void FindCliques (std::function< bool(int, int)> graph, int node_count, std::function< bool(const std::vector< int > &)> callback)
 
void CoverArcsByCliques (std::function< bool(int, int)> graph, int node_count, std::function< bool(const std::vector< int > &)> callback)
 
bool DijkstraShortestPath (int node_count, int start_node, int end_node, std::function< int64(int, int)> graph, int64 disconnected_distance, std::vector< int > *nodes)
 
bool StableDijkstraShortestPath (int node_count, int start_node, int end_node, std::function< int64(int, int)> graph, int64 disconnected_distance, std::vector< int > *nodes)
 
template<typename GraphType >
bool BuildLineGraph (const GraphType &graph, GraphType *const line_graph)
 
template<typename Graph >
bool IsEulerianGraph (const Graph &graph)
 
template<typename NodeIndex , typename Graph >
bool IsSemiEulerianGraph (const Graph &graph, std::vector< NodeIndex > *odd_nodes)
 
template<typename NodeIndex , typename Graph >
std::vector< NodeIndexBuildEulerianPathFromNode (const Graph &graph, NodeIndex root)
 
template<typename NodeIndex , typename Graph >
std::vector< NodeIndexBuildEulerianTourFromNode (const Graph &graph, NodeIndex root)
 
template<typename Graph >
std::vector< typename Graph::NodeIndex > BuildEulerianTour (const Graph &graph)
 
template<typename Graph >
std::vector< typename Graph::NodeIndex > BuildEulerianPath (const Graph &graph)
 
template<typename CostType , typename CostFunction >
HamiltonianPathSolver< CostType, CostFunction > MakeHamiltonianPathSolver (int num_nodes, CostFunction cost)
 
template<typename Graph >
std::vector< typename Graph::ArcIndex > BuildKruskalMinimumSpanningTreeFromSortedArcs (const Graph &graph, const std::vector< typename Graph::ArcIndex > &sorted_arcs)
 
template<typename Graph , typename ArcComparator >
std::vector< typename Graph::ArcIndex > BuildKruskalMinimumSpanningTree (const Graph &graph, const ArcComparator &arc_comparator)
 
template<typename Graph , typename ArcValue >
std::vector< typename Graph::ArcIndex > BuildPrimMinimumSpanningTree (const Graph &graph, const ArcValue &arc_value)
 
template<typename CostFunction >
std::set< std::pair< int, int > > NearestNeighbors (int number_of_nodes, int number_of_neighbors, const CostFunction &cost)
 
template<typename CostFunction >
void AddArcsFromMinimumSpanningTree (int number_of_nodes, const CostFunction &cost, std::set< std::pair< int, int >> *arcs)
 
template<typename CostFunction , typename GraphType , typename AcceptFunction >
int GetNodeMinimizingEdgeCostToSource (const GraphType &graph, int source, const CostFunction &cost, AcceptFunction accept)
 
template<typename CostFunction , typename GraphType , typename CostType >
std::vector< int > ComputeOneTree (const GraphType &graph, const CostFunction &cost, const std::vector< double > &weights, const std::vector< int > &sorted_arcs, CostType *one_tree_cost)
 
template<typename CostFunction , typename Algorithm >
double ComputeOneTreeLowerBoundWithAlgorithm (int number_of_nodes, int nearest_neighbors, const CostFunction &cost, Algorithm *algorithm)
 
template<typename CostFunction >
double ComputeOneTreeLowerBoundWithParameters (int number_of_nodes, const CostFunction &cost, const TravelingSalesmanLowerBoundParameters &parameters)
 
template<typename CostFunction >
double ComputeOneTreeLowerBound (int number_of_nodes, const CostFunction &cost)
 
const GScipVariableOptionsDefaultGScipVariableOptions ()
 
const GScipConstraintOptionsDefaultGScipConstraintOptions ()
 
GScipLinearExpr GScipDifference (GScipLinearExpr left, const GScipLinearExpr &right)
 
GScipLinearExpr GScipNegate (GScipLinearExpr expr)
 
GScipLinearRange GScipLe (const GScipLinearExpr left, const GScipLinearExpr &right)
 
absl::Status GScipCreateAbs (GScip *gscip, SCIP_Var *x, SCIP_Var *abs_x, const std::string &name)
 
absl::Status GScipCreateMaximum (GScip *gscip, const GScipLinearExpr &resultant, const std::vector< GScipLinearExpr > &terms, const std::string &name)
 
absl::Status GScipCreateMinimum (GScip *gscip, const GScipLinearExpr &resultant, const std::vector< GScipLinearExpr > &terms, const std::string &name)
 
absl::Status GScipAddQuadraticObjectiveTerm (GScip *gscip, std::vector< SCIP_Var * > quadratic_variables1, std::vector< SCIP_Var * > quadratic_variables2, std::vector< double > quadratic_coefficients, const std::string &name)
 
absl::Status GScipCreateIndicatorRange (GScip *gscip, const GScipIndicatorRangeConstraint &indicator_range, const std::string &name, const GScipConstraintOptions &options)
 
void GScipSetTimeLimit (absl::Duration time_limit, GScipParameters *parameters)
 
absl::Duration GScipTimeLimit (const GScipParameters &parameters)
 
bool GScipTimeLimitSet (const GScipParameters &parameters)
 
void GScipSetMaxNumThreads (int num_threads, GScipParameters *parameters)
 
int GScipMaxNumThreads (const GScipParameters &parameters)
 
bool GScipMaxNumThreadsSet (const GScipParameters &parameters)
 
void GScipSetLogLevel (GScipParameters *parameters, int log_level)
 
int GScipLogLevel (const GScipParameters &parameters)
 
bool GScipLogLevelSet (const GScipParameters &parameters)
 
void GScipSetOutputEnabled (GScipParameters *parameters, bool output_enabled)
 
bool GScipOutputEnabled (const GScipParameters &parameters)
 
bool GScipOutputEnabledSet (const GScipParameters &parameters)
 
void GScipSetRandomSeed (GScipParameters *parameters, int random_seed)
 
int GScipRandomSeed (const GScipParameters &parameters)
 
bool GScipRandomSeedSet (const GScipParameters &parameters)
 
absl::Status LegacyScipSetSolverSpecificParameters (const std::string &parameters, SCIP *scip)
 
MPSolverInterfaceBuildBopInterface (MPSolver *const solver)
 
MPSolverInterfaceBuildCBCInterface (MPSolver *const solver)
 
MPSolverInterfaceBuildCLPInterface (MPSolver *const solver)
 
MPSolverInterfaceBuildGLOPInterface (MPSolver *const solver)
 
MPSolver::ResultStatus GlopToMPSolverResultStatus (glop::ProblemStatus s)
 
MPSolver::BasisStatus GlopToMPSolverVariableStatus (glop::VariableStatus s)
 
glop::VariableStatus MPSolverToGlopVariableStatus (MPSolver::BasisStatus s)
 
MPSolver::BasisStatus GlopToMPSolverConstraintStatus (glop::ConstraintStatus s)
 
glop::ConstraintStatus MPSolverToGlopConstraintStatus (MPSolver::BasisStatus s)
 
absl::Status LoadGurobiEnvironment (GRBenv **env)
 
void LoadGurobiFunctions ()
 
bool LoadSpecificGurobiLibrary (const std::string &full_library_path)
 
bool SearchForGurobiDynamicLibrary ()
 
MPSolverInterfaceBuildGurobiInterface (bool mip, MPSolver *const solver)
 
absl::Status SetSolverSpecificParameters (const std::string &parameters, GRBenv *gurobi)
 
absl::StatusOr< MPSolutionResponse > GurobiSolveProto (const MPModelRequest &request, GRBenv *gurobi_env)
 
std::ostream & operator<< (std::ostream &stream, const LinearExpr &linear_expr)
 
LinearExpr operator+ (LinearExpr lhs, const LinearExpr &rhs)
 
LinearExpr operator- (LinearExpr lhs, const LinearExpr &rhs)
 
LinearExpr operator* (LinearExpr lhs, double rhs)
 
LinearExpr operator/ (LinearExpr lhs, double rhs)
 
LinearExpr operator* (double lhs, LinearExpr rhs)
 
LinearRange operator<= (const LinearExpr &lhs, const LinearExpr &rhs)
 
LinearRange operator== (const LinearExpr &lhs, const LinearExpr &rhs)
 
LinearRange operator>= (const LinearExpr &lhs, const LinearExpr &rhs)
 
bool SolverTypeIsMip (MPModelRequest::SolverType solver_type)
 
MPSolverInterfaceBuildSatInterface (MPSolver *const solver)
 
MPSolverInterfaceBuildSCIPInterface (MPSolver *const solver)
 
const absl::string_view ToString (MPSolver::OptimizationProblemType optimization_problem_type)
 
bool AbslParseFlag (const absl::string_view text, MPSolver::OptimizationProblemType *solver_type, std::string *error)
 
bool MPSolverResponseStatusIsRpcError (MPSolverResponseStatus status)
 
bool SolverTypeIsMip (MPSolver::OptimizationProblemType solver_type)
 
std::ostream & operator<< (std::ostream &os, MPSolver::OptimizationProblemType optimization_problem_type)
 
std::ostream & operator<< (std::ostream &os, MPSolver::ResultStatus status)
 
std::string AbslUnparseFlag (MPSolver::OptimizationProblemType solver_type)
 
std::string ToString (MPCallbackEvent event)
 
absl::StatusOr< std::string > ExportModelAsLpFormat (const MPModelProto &model, const MPModelExportOptions &options=MPModelExportOptions())
 Outputs the current model (variables, constraints, objective) as a string encoded in the so-called "CPLEX LP file format" as generated by SCIP. More...
 
absl::StatusOr< std::string > ExportModelAsMpsFormat (const MPModelProto &model, const MPModelExportOptions &options=MPModelExportOptions())
 Outputs the current model (variables, constraints, objective) as a string encoded in MPS file format, using the "free" MPS format. More...
 
std::string FindErrorInMPModelProto (const MPModelProto &model, double abs_value_threshold=0.0)
 Returns an empty string iff the model is valid and not trivially infeasible. More...
 
absl::optional< LazyMutableCopy< MPModelProto > > ExtractValidMPModelOrPopulateResponseStatus (const MPModelRequest &request, MPSolutionResponse *response)
 If the model is valid and non-empty, returns it (possibly after extracting the model_delta). More...
 
bool ExtractValidMPModelInPlaceOrPopulateResponseStatus (MPModelRequest *request, MPSolutionResponse *response)
 Like ExtractValidMPModelOrPopulateResponseStatus(), but works in-place: if the MPModel needed extraction, it will be populated in the request, and it returns the success boolean. More...
 
std::string FindFeasibilityErrorInSolutionHint (const MPModelProto &model, double tolerance)
 Returns an empty string if the solution hint given in the model is a feasible solution. More...
 
std::string FindErrorInMPModelDeltaProto (const MPModelDeltaProto &delta, const MPModelProto &model)
 Like FindErrorInMPModelProto, but for a MPModelDeltaProto applied to a given baseline model (assumed valid, eg. More...
 
void MergeMPConstraintProtoExceptTerms (const MPConstraintProto &from, MPConstraintProto *to)
 
void ApplyVerifiedMPModelDelta (const MPModelDeltaProto &delta, MPModelProto *model)
 
absl::StatusOr< MPSolutionResponse > SatSolveProto (MPModelRequest request, std::atomic< bool > *interrupt_solve)
 
std::string EncodeSatParametersAsString (const sat::SatParameters &parameters)
 
MPSolverResponseStatus ApplyMipPresolveSteps (bool log_info, const glop::GlopParameters &glop_params, MPModelProto *model, std::vector< std::unique_ptr< glop::Preprocessor >> *for_postsolve)
 
bool LinearConstraintIsViolated (const ScipConstraintHandlerContext &context, const LinearRange &constraint)
 
ScipSeparationResult RunSeparation (internal::ScipCallbackRunner *runner, const ScipConstraintHandlerContext &context, absl::Span< SCIP_CONS * > constraints, bool is_integral)
 
template<typename Constraint >
void RegisterConstraintHandler (ScipConstraintHandler< Constraint > *handler, SCIP *scip)
 
template<typename ConstraintData >
void AddCallbackConstraint (SCIP *scip, ScipConstraintHandler< ConstraintData > *handler, const std::string &constraint_name, const ConstraintData *constraint_data, const ScipCallbackConstraintOptions &options)
 
template<typename ConstraintData >
void RegisterConstraintHandler (ScipConstraintHandler< ConstraintData > *handler, SCIP *scip)
 
std::string FindErrorInMPModelForScip (const MPModelProto &model, SCIP *scip)
 
absl::StatusOr< MPSolutionResponse > ScipSolveProto (const MPModelRequest &request)
 
::absl::Status PortableFileSetContents (absl::string_view file_name, absl::string_view content)
 
::absl::Status PortableFileGetContents (absl::string_view file_name, std::string *output)
 
::absl::Status PortableDeleteFile (absl::string_view file_name)
 
bool PortableTemporaryFile (const char *directory_prefix, std::string *filename_out)
 
template<class P >
std::string ProtobufDebugString (const P &message)
 
template<class P >
std::string ProtobufShortDebugString (const P &message)
 
template<typename ProtoEnumType >
std::string ProtoEnumToString (ProtoEnumType enum_value)
 
template<typename ProtoType >
bool ProtobufTextFormatMergeFromString (const std::string &proto_text_string, ProtoType *proto)
 
uint64 OneBit64 (int pos)
 
uint32 OneBit32 (int pos)
 
uint64 BitCount64 (uint64 n)
 
uint32 BitCount32 (uint32 n)
 
uint64 LeastSignificantBitWord64 (uint64 n)
 
uint32 LeastSignificantBitWord32 (uint32 n)
 
int LeastSignificantBitPosition64DeBruijn (uint64 n)
 
int LeastSignificantBitPosition64Default (uint64 n)
 
int LeastSignificantBitPosition64 (uint64 n)
 
int LeastSignificantBitPosition32DeBruijn (uint32 n)
 
int LeastSignificantBitPosition32Default (uint32 n)
 
int LeastSignificantBitPosition32 (uint32 n)
 
int MostSignificantBitPosition64Default (uint64 n)
 
int MostSignificantBitPosition64 (uint64 n)
 
int MostSignificantBitPosition32Default (uint32 n)
 
int MostSignificantBitPosition32 (uint32 n)
 
uint64 OneRange64 (uint64 s, uint64 e)
 
uint32 OneRange32 (uint32 s, uint32 e)
 
uint64 IntervalUp64 (uint64 s)
 
uint32 IntervalUp32 (uint32 s)
 
uint64 IntervalDown64 (uint64 s)
 
uint32 IntervalDown32 (uint32 s)
 
uint32 BitPos64 (uint64 pos)
 
uint32 BitPos32 (uint32 pos)
 
uint64 BitOffset64 (uint64 pos)
 
uint32 BitOffset32 (uint32 pos)
 
uint64 BitLength64 (uint64 size)
 
uint32 BitLength32 (uint32 size)
 
uint64 BitShift64 (uint64 v)
 
uint32 BitShift32 (uint32 v)
 
bool IsBitSet64 (const uint64 *const bitset, uint64 pos)
 
bool IsBitSet32 (const uint32 *const bitset, uint32 pos)
 
void SetBit64 (uint64 *const bitset, uint64 pos)
 
void SetBit32 (uint32 *const bitset, uint32 pos)
 
void ClearBit64 (uint64 *const bitset, uint64 pos)
 
void ClearBit32 (uint32 *const bitset, uint32 pos)
 
uint64 BitCountRange64 (const uint64 *const bitset, uint64 start, uint64 end)
 
uint32 BitCountRange32 (const uint32 *const bitset, uint32 start, uint32 end)
 
bool IsEmptyRange64 (const uint64 *const bitset, uint64 start, uint64 end)
 
bool IsEmptyRange32 (const uint32 *const bitset, uint32 start, uint32 end)
 
int64 LeastSignificantBitPosition64 (const uint64 *const bitset, uint64 start, uint64 end)
 
int LeastSignificantBitPosition32 (const uint32 *const bitset, uint32 start, uint32 end)
 
int64 MostSignificantBitPosition64 (const uint64 *const bitset, uint64 start, uint64 end)
 
int MostSignificantBitPosition32 (const uint32 *const bitset, uint32 start, uint32 end)
 
int64 UnsafeLeastSignificantBitPosition64 (const uint64 *const bitset, uint64 start, uint64 end)
 
int32 UnsafeLeastSignificantBitPosition32 (const uint32 *const bitset, uint32 start, uint32 end)
 
int64 UnsafeMostSignificantBitPosition64 (const uint64 *const bitset, uint64 start, uint64 end)
 
int32 UnsafeMostSignificantBitPosition32 (const uint32 *const bitset, uint32 start, uint32 end)
 
uint64 TwoBitsFromPos64 (uint64 pos)
 
absl::StatusOr< std::string > ReadFileToString (absl::string_view filename)
 
bool ReadFileToProto (absl::string_view filename, google::protobuf::Message *proto)
 
bool WriteProtoToFile (absl::string_view filename, const google::protobuf::Message &proto, ProtoWriteFormat proto_write_format, bool gzipped, bool append_extension_to_file_name)
 
template<typename Proto >
Proto ReadFileToProtoOrDie (absl::string_view filename)
 
template<typename Proto >
std::vector< Proto > ReadAllRecordsOrDie (absl::string_view filename)
 
template<typename Proto >
std::vector< Proto > ReadAllRecordsOrDie (File *file)
 
template<typename Proto >
Proto ReadOneRecordOrDie (absl::string_view filename)
 
template<typename Proto >
void WriteRecordsOrDie (absl::string_view filename, const std::vector< Proto > &protos)
 
void ComputeScalingErrors (const std::vector< double > &input, const std::vector< double > &lb, const std::vector< double > &ub, double scaling_factor, double *max_relative_coeff_error, double *max_scaled_sum_error)
 
double GetBestScalingOfDoublesToInt64 (const std::vector< double > &input, const std::vector< double > &lb, const std::vector< double > &ub, int64 max_absolute_sum)
 
void GetBestScalingOfDoublesToInt64 (const std::vector< double > &input, int64 max_absolute_sum, double *scaling_factor, double *max_relative_coeff_error)
 
int64 ComputeGcdOfRoundedDoubles (const std::vector< double > &x, double scaling_factor)
 
template<typename FloatType >
bool IsPositiveOrNegativeInfinity (FloatType x)
 
template<typename FloatType >
bool AreWithinAbsoluteOrRelativeTolerances (FloatType x, FloatType y, FloatType relative_tolerance, FloatType absolute_tolerance)
 
template<typename FloatType >
bool AreWithinAbsoluteTolerance (FloatType x, FloatType y, FloatType absolute_tolerance)
 
template<typename FloatType >
bool IsSmallerWithinTolerance (FloatType x, FloatType y, FloatType tolerance)
 
template<typename FloatType >
bool IsIntegerWithinTolerance (FloatType x, FloatType tolerance)
 
template<typename FloatType >
FloatType Interpolate (FloatType x, FloatType y, FloatType alpha)
 
std::string FullProtocolMessageAsString (const google::protobuf::Message &message, int indent_level)
 
template<class Proto >
absl::StatusOr< Proto * > SafeProtoDownCast (google::protobuf::Message *proto)
 
template<class Proto >
absl::StatusOr< const Proto * > SafeProtoConstDownCast (const google::protobuf::Message *proto)
 
RangeIntToIntFunctionMakeBareIntToIntFunction (std::function< int64(int64)> f)
 
RangeIntToIntFunctionMakeCachedIntToIntFunction (const std::function< int64(int64)> &f, int64 domain_start, int64 domain_end)
 
RangeMinMaxIndexFunctionMakeCachedRangeMinMaxIndexFunction (const std::function< int64(int64)> &f, int64 domain_start, int64 domain_end)
 
Fraction RationalApproximation (const double x, const double precision)
 
int64 TwosComplementAddition (int64 x, int64 y)
 
int64 TwosComplementSubtraction (int64 x, int64 y)
 
bool AddHadOverflow (int64 x, int64 y, int64 sum)
 
bool SubHadOverflow (int64 x, int64 y, int64 diff)
 
bool AddOverflows (int64 x, int64 y)
 
int64 SubOverflows (int64 x, int64 y)
 
template<typename IntegerType >
bool SafeAddInto (IntegerType a, IntegerType *b)
 
int64 CapWithSignOf (int64 x)
 
int64 CapAddGeneric (int64 x, int64 y)
 
int64 CapAdd (int64 x, int64 y)
 
int64 CapSubGeneric (int64 x, int64 y)
 
int64 CapSub (int64 x, int64 y)
 
int64 CapOpp (int64 v)
 
int64 CapProdGeneric (int64 x, int64 y)
 
int64 CapProd (int64 x, int64 y)
 
template<class Iterator , class Compare = std::less<value_type_t<Iterator>>>
void IncrementalSort (int max_comparisons, Iterator begin, Iterator end, Compare comp=Compare{}, bool is_stable=false)
 
template<class Iterator , class Compare = std::less<value_type_t<Iterator>>>
void InsertionSort (Iterator begin, Iterator end, Compare comp=Compare{})
 
template<class Iterator , class Compare = std::less<value_type_t<Iterator>>>
void IncrementalSort (Iterator begin, Iterator end, Compare comp=Compare{}, bool is_stable=false)
 
bool IntervalsAreSortedAndNonAdjacent (absl::Span< const ClosedInterval > intervals)
 Returns true iff we have: More...
 
int64 CeilRatio (int64 value, int64 positive_coeff)
 
int64 FloorRatio (int64 value, int64 positive_coeff)
 
std::ostream & operator<< (std::ostream &out, const ClosedInterval &interval)
 
std::ostream & operator<< (std::ostream &out, const std::vector< ClosedInterval > &intervals)
 
std::ostream & operator<< (std::ostream &out, const Domain &domain)
 
int64 SumOfKMinValueInDomain (const Domain &domain, int k)
 
int64 SumOfKMaxValueInDomain (const Domain &domain, int k)
 
std::string MemoryUsage ()
 
template<class T >
std::string JoinDebugString (const std::vector< T > &v, const std::string &separator)
 
template<class T >
std::string JoinDebugStringPtr (const std::vector< T > &v, const std::string &separator)
 
template<class T >
std::string JoinNamePtr (const std::vector< T > &v, const std::string &separator)
 
template<class T >
std::string JoinNameFieldPtr (const std::vector< T > &v, const std::string &separator)
 
bool ProbablyRunningInsideUnitTest ()
 
template<class T >
DemonMakeConstraintDemon0 (Solver *const s, T *const ct, void(T::*method)(), const std::string &name)
 
template<class P >
std::string ParameterDebugString (P param)
 
template<class P >
std::string ParameterDebugString (P *param)
 Support limited to pointers to classes which define DebugString(). More...
 
template<class T , class P >
DemonMakeConstraintDemon1 (Solver *const s, T *const ct, void(T::*method)(P), const std::string &name, P param1)
 
template<class T , class P , class Q >
DemonMakeConstraintDemon2 (Solver *const s, T *const ct, void(T::*method)(P, Q), const std::string &name, P param1, Q param2)
 
template<class T , class P , class Q , class R >
DemonMakeConstraintDemon3 (Solver *const s, T *const ct, void(T::*method)(P, Q, R), const std::string &name, P param1, Q param2, R param3)
 
template<class T >
DemonMakeDelayedConstraintDemon0 (Solver *const s, T *const ct, void(T::*method)(), const std::string &name)
 
template<class T , class P >
DemonMakeDelayedConstraintDemon1 (Solver *const s, T *const ct, void(T::*method)(P), const std::string &name, P param1)
 
template<class T , class P , class Q >
DemonMakeDelayedConstraintDemon2 (Solver *const s, T *const ct, void(T::*method)(P, Q), const std::string &name, P param1, Q param2)
 

Variables

static const int kUnassigned = -1
 
struct operations_research::LinkSort LinkComparator
 
struct operations_research::SweepIndexSortAngle SweepIndexAngleComparator
 
struct operations_research::SweepIndexSortDistance SweepIndexDistanceComparator
 
std::function< int(GRBmodel *, int, int *, double *, double, double, const char *)> GRBaddrangeconstr = nullptr
 
std::function< int(GRBmodel *model, int numnz, int *vind, double *vval, double obj, double lb, double ub, char vtype, const char *varname)> GRBaddvar = nullptr
 
std::function< int(GRBmodel *, int, int, int *, int *, double *, double *, double *, double *, char *, char **)> GRBaddvars = nullptr
 
std::function< int(GRBmodel *model, int numchgs, int *cind, int *vind, double *val)> GRBchgcoeffs = nullptr
 
std::function< void(GRBenv *)> GRBfreeenv = nullptr
 
std::function< int(GRBmodel *)> GRBfreemodel = nullptr
 
std::function< int(GRBmodel *, const char *, int, char *)> GRBgetcharattrelement
 
std::function< int(GRBmodel *, const char *, double *)> GRBgetdblattr = nullptr
 
std::function< int(GRBmodel *, const char *, int, int, double *)> GRBgetdblattrarray = nullptr
 
std::function< int(GRBmodel *, const char *, int, double *)> GRBgetdblattrelement
 
std::function< int(GRBenv *, const char *, double *)> GRBgetdblparam = nullptr
 
std::function< GRBenv *(GRBmodel *)> GRBgetenv = nullptr
 
std::function< char *(GRBenv *)> GRBgeterrormsg = nullptr
 
std::function< int(GRBmodel *, const char *, int *)> GRBgetintattr = nullptr
 
std::function< int(GRBmodel *, const char *, int, int *)> GRBgetintattrelement
 
std::function< int(GRBenv **, const char *)> GRBloadenv = nullptr
 
std::function< int(GRBenv *, GRBmodel **, const char *, int numvars, double *, double *, double *, char *, char **)> GRBnewmodel = nullptr
 
std::function< int(GRBmodel *)> GRBoptimize = nullptr
 
std::function< int(GRBenv *dest, GRBenv *src)> GRBcopyparams = nullptr
 
std::function< int(GRBenv *, const char *)> GRBreadparams = nullptr
 
std::function< int(GRBenv *)> GRBresetparams = nullptr
 
std::function< int(GRBmodel *, const char *, int, char)> GRBsetcharattrelement
 
std::function< int(GRBmodel *, const char *, double)> GRBsetdblattr = nullptr
 
std::function< int(GRBmodel *, const char *, int, double)> GRBsetdblattrelement
 
std::function< int(GRBenv *, const char *, double)> GRBsetdblparam = nullptr
 
std::function< int(GRBmodel *, const char *, int)> GRBsetintattr = nullptr
 
std::function< int(GRBenv *, const char *, int)> GRBsetintparam = nullptr
 
std::function< void(GRBmodel *)> GRBterminate = nullptr
 
std::function< int(GRBmodel *)> GRBupdatemodel = nullptr
 
std::function< void(int *, int *, int *)> GRBversion = nullptr
 
std::function< int(GRBmodel *, const char *)> GRBwrite = nullptr
 
std::function< int(void *cbdata, int where, int what, void *resultP)> GRBcbget
 
std::function< int(void *cbdata, int cutlen, const int *cutind, const double *cutval, char cutsense, double cutrhs)> GRBcbcut = nullptr
 
std::function< int(void *cbdata, int lazylen, const int *lazyind, const double *lazyval, char lazysense, double lazyrhs)> GRBcblazy = nullptr
 
std::function< int(void *cbdata, const double *solution, double *objvalP)> GRBcbsolution = nullptr
 
std::function< int(GRBmodel *model, int numnz, int *cind, double *cval, char sense, double rhs, const char *constrname)> GRBaddconstr = nullptr
 
std::function< int(GRBmodel *model, const char *name, int binvar, int binval, int nvars, const int *vars, const double *vals, char sense, double rhs)> GRBaddgenconstrIndicator = nullptr
 
std::function< int(GRBmodel *model, const char *attrname, int element, int newvalue)> GRBsetintattrelement = nullptr
 
std::function< int(GRBmodel *model, int(STDCALL *cb)(CB_ARGS), void *usrdata)> GRBsetcallbackfunc = nullptr
 
std::function< int(GRBenv *env, const char *paramname, const char *value)> GRBsetparam = nullptr
 
std::function< int(GRBmodel *model, int numsos, int nummembers, int *types, int *beg, int *ind, double *weight)> GRBaddsos = nullptr
 
std::function< int(GRBmodel *model, int numlnz, int *lind, double *lval, int numqnz, int *qrow, int *qcol, double *qval, char sense, double rhs, const char *QCname)> GRBaddqconstr = nullptr
 
std::function< int(GRBmodel *model, const char *name, int resvar, int nvars, const int *vars, double constant)> GRBaddgenconstrMax = nullptr
 
std::function< int(GRBmodel *model, const char *name, int resvar, int nvars, const int *vars, double constant)> GRBaddgenconstrMin = nullptr
 
std::function< int(GRBmodel *model, const char *name, int resvar, int argvar)> GRBaddgenconstrAbs = nullptr
 
std::function< int(GRBmodel *model, const char *name, int resvar, int nvars, const int *vars)> GRBaddgenconstrAnd = nullptr
 
std::function< int(GRBmodel *model, const char *name, int resvar, int nvars, const int *vars)> GRBaddgenconstrOr = nullptr
 
std::function< int(GRBmodel *model, int numqnz, int *qrow, int *qcol, double *qval)> GRBaddqpterms = nullptr
 
std::unique_ptr< DynamicLibrarygurobi_dynamic_library
 
std::string gurobi_library_path
 
constexpr NamedOptimizationProblemType kOptimizationProblemTypeNames []
 
constexpr double kDefaultPrimalTolerance = 1e-07
 
static const uint64 kAllBits64 = uint64_t{0xFFFFFFFFFFFFFFFF}
 
static const uint64 kAllBitsButLsb64 = uint64_t{0xFFFFFFFFFFFFFFFE}
 
static const uint32 kAllBits32 = 0xFFFFFFFFU
 

Detailed Description

The vehicle routing library lets one model and solve generic vehicle routing problems ranging from the Traveling Salesman Problem to more complex problems such as the Capacitated Vehicle Routing Problem with Time Windows.

The objective of a vehicle routing problem is to build routes covering a set of nodes minimizing the overall cost of the routes (usually proportional to the sum of the lengths of each segment of the routes) while respecting some problem-specific constraints (such as the length of a route). A route is equivalent to a path connecting nodes, starting/ending at specific starting/ending nodes.

The term "vehicle routing" is historical and the category of problems solved is not limited to the routing of vehicles: any problem involving finding routes visiting a given number of nodes optimally falls under this category of problems, such as finding the optimal sequence in a playlist. The literature around vehicle routing problems is extremely dense but one can find some basic introductions in the following links:

The vehicle routing library is a vertical layer above the constraint programming library (ortools/constraint_programming:cp). One has access to all underlying constrained variables of the vehicle routing model which can therefore be enriched by adding any constraint available in the constraint programming library.

There are two sets of variables available:

  • path variables:
    • "next(i)" variables representing the immediate successor of the node corresponding to i; use IndexToNode() to get the node corresponding to a "next" variable value; note that node indices are strongly typed integers (cf. ortools/base/int_type.h);
    • "vehicle(i)" variables representing the vehicle route to which the node corresponding to i belongs;
    • "active(i)" boolean variables, true if the node corresponding to i is visited and false if not; this can be false when nodes are either optional or part of a disjunction;
    • The following relationships hold for all i: active(i) == 0 <=> next(i) == i <=> vehicle(i) == -1, next(i) == j => vehicle(j) == vehicle(i).
  • dimension variables, used when one is accumulating quantities along routes, such as weight or volume carried, distance or time:
    • "cumul(i,d)" variables representing the quantity of dimension d when arriving at the node corresponding to i;
    • "transit(i,d)" variables representing the quantity of dimension d added after visiting the node corresponding to i.
    • The following relationship holds for all (i,d): next(i) == j => cumul(j,d) == cumul(i,d) + transit(i,d). Solving the vehicle routing problems is mainly done using approximate methods (namely local search, cf. http://en.wikipedia.org/wiki/Local_search_(optimization) ), potentially combined with exact techniques based on dynamic programming and exhaustive tree search. Advanced tips: Flags are available to tune the search used to solve routing problems. Here is a quick overview of the ones one might want to modify:
  • Limiting the search for solutions:
    • routing_solution_limit (default: kint64max): stop the search after finding 'routing_solution_limit' improving solutions;
    • routing_time_limit (default: kint64max): stop the search after 'routing_time_limit' milliseconds;
  • Customizing search:
    • routing_first_solution (default: select the first node with an unbound successor and connect it to the first available node): selects the heuristic to build a first solution which will then be improved by local search; possible values are GlobalCheapestArc (iteratively connect two nodes which produce the cheapest route segment), LocalCheapestArc (select the first node with an unbound successor and connect it to the node which produces the cheapest route segment), PathCheapestArc (starting from a route "start" node, connect it to the node which produces the cheapest route segment, then extend the route by iterating on the last node added to the route).
    • Local search neighborhoods:
      • routing_no_lns (default: false): forbids the use of Large Neighborhood Search (LNS); LNS can find good solutions but is usually very slow. Refer to the description of PATHLNS in the LocalSearchOperators enum in constraint_solver.h for more information.
      • routing_no_tsp (default: true): forbids the use of exact methods to solve "sub"-traveling salesman problems (TSPs) of the current model (such as sub-parts of a route, or one route in a multiple route problem). Uses dynamic programming to solve such TSPs with a maximum size (in number of nodes) up to cp_local_search_tsp_opt_size (flag with a default value of 13 nodes). It is not activated by default because it can slow down the search.
    • Meta-heuristics: used to guide the search out of local minima found by local search. Note that, in general, a search with metaheuristics activated never stops, therefore one must specify a search limit. Several types of metaheuristics are provided:

Code sample: Here is a simple example solving a traveling salesman problem given a cost function callback (returns the cost of a route segment):

  • Define a custom distance/cost function from an index to another; in this example just returns the sum of the indices:

    int64 MyDistance(int64 from, int64 to) { return from + to; }

  • Create a routing model for a given problem size (int number of nodes) and number of routes (here, 1):

    RoutingIndexManager manager(...number of nodes..., 1); RoutingModel routing(manager);

  • Set the cost function by registering an std::function<int64(int64, int64)> in the model and passing its index as the vehicle cost.

    const int cost = routing.RegisterTransitCallback(MyDistance); routing.SetArcCostEvaluatorOfAllVehicles(cost);

  • Find a solution using Solve(), returns a solution if any (owned by routing):

    const Assignment* solution = routing.Solve(); CHECK(solution != nullptr);

  • Inspect the solution cost and route (only one route here):

    LOG(INFO) << "Cost " << solution->ObjectiveValue(); const int route_number = 0; for (int64 node = routing.Start(route_number); !routing.IsEnd(node); node = solution->Value(routing.NextVar(node))) { LOG(INFO) << manager.IndexToNode(node); }

Keywords: Vehicle Routing, Traveling Salesman Problem, TSP, VRP, CVRPTW, PDP.

Meta namespace.

Typedef Documentation

◆ Arc

typedef std::pair<int64, int64> Arc

Definition at line 3361 of file search.cc.

◆ ArcIndex

typedef int32 ArcIndex

Definition at line 201 of file ebert_graph.h.

◆ ArcIndexArray

Definition at line 208 of file ebert_graph.h.

◆ CostArray

Definition at line 210 of file ebert_graph.h.

◆ CostValue

typedef BlossomGraph::CostValue CostValue

Definition at line 203 of file ebert_graph.h.

◆ FlowQuantity

Definition at line 202 of file ebert_graph.h.

◆ ForwardStarGraph

Definition at line 205 of file ebert_graph.h.

◆ ForwardStarStaticGraph

◆ Fraction

typedef std::pair<int64, int64> Fraction

Definition at line 26 of file rational_approximation.h.

◆ GScipBranchingPriority

using GScipBranchingPriority = absl::flat_hash_map<SCIP_VAR*, int>

Definition at line 114 of file gscip.h.

◆ GScipSolution

using GScipSolution = absl::flat_hash_map<SCIP_VAR*, double>

Definition at line 69 of file gscip.h.

◆ Int16ZVector

Definition at line 160 of file zvector.h.

◆ Int32ZVector

Definition at line 161 of file zvector.h.

◆ Int64ZVector

Definition at line 162 of file zvector.h.

◆ Int8ZVector

Definition at line 159 of file zvector.h.

◆ KnapsackItemForCutsPtr

using KnapsackItemForCutsPtr = std::unique_ptr<KnapsackItemForCuts>

Definition at line 91 of file knapsack_solver_for_cuts.h.

◆ KnapsackItemPtr

Definition at line 321 of file knapsack_solver.h.

◆ NodeIndex

typedef BlossomGraph::NodeIndex NodeIndex

Definition at line 200 of file ebert_graph.h.

◆ NodeIndexArray

Definition at line 207 of file ebert_graph.h.

◆ PathNodeIndex

typedef int PathNodeIndex

Definition at line 450 of file hamiltonian_path.h.

◆ QuantityArray

Definition at line 209 of file ebert_graph.h.

◆ random_engine_t

using random_engine_t = std::mt19937

Definition at line 23 of file random_engine.h.

◆ RoutingIndexPair

typedef std::pair<std::vector<int64>, std::vector<int64> > RoutingIndexPair

Definition at line 44 of file routing_types.h.

◆ RoutingIndexPairs

typedef std::vector<RoutingIndexPair> RoutingIndexPairs

Definition at line 45 of file routing_types.h.

◆ RoutingTransitCallback1

typedef std::function<int64(int64)> RoutingTransitCallback1

Definition at line 41 of file routing_types.h.

◆ RoutingTransitCallback2

typedef std::function<int64(int64, int64)> RoutingTransitCallback2

Definition at line 42 of file routing_types.h.

◆ ScopedInstructionCounter

◆ ScopedTimeDistributionUpdater

◆ SequenceVarLocalSearchOperatorTemplate

◆ StarGraph

Definition at line 204 of file ebert_graph.h.

◆ UInt16ZVector

Definition at line 164 of file zvector.h.

◆ UInt32ZVector

Definition at line 165 of file zvector.h.

◆ UInt64ZVector

Definition at line 166 of file zvector.h.

◆ UInt8ZVector

Definition at line 163 of file zvector.h.

◆ value_type_t

using value_type_t = typename std::iterator_traits<Iterator>::value_type

Definition at line 24 of file sort.h.

Enumeration Type Documentation

◆ BronKerboschAlgorithmStatus

Enumerator
COMPLETED 
INTERRUPTED 

Definition at line 68 of file cliques.h.

◆ CliqueResponse

enum CliqueResponse
strong
Enumerator
CONTINUE 
STOP 

Definition at line 58 of file cliques.h.

◆ DimensionSchedulingStatus

Enumerator
OPTIMAL 
RELAXED_OPTIMAL_ONLY 
INFEASIBLE 

Definition at line 126 of file routing_lp_scheduling.h.

◆ GScipHintResult

enum GScipHintResult
strong
Enumerator
kInfeasible 
kRejected 
kAccepted 

Definition at line 444 of file gscip.h.

◆ GScipVarType

enum GScipVarType
strong
Enumerator
kContinuous 
kInteger 
kImpliedInteger 

Definition at line 103 of file gscip.h.

◆ MPCallbackEvent

enum MPCallbackEvent
strong
Enumerator
kUnknown 
kPolling 
kPresolve 
kSimplex 
kMip 
kMipSolution 
kMipNode 
kBarrier 
kMessage 
kMultiObj 

Definition at line 36 of file linear_solver_callback.h.

◆ ProtoWriteFormat

enum ProtoWriteFormat
strong
Enumerator
kProtoText 
kProtoBinary 
kJson 

Definition at line 47 of file file_util.h.

◆ ScipSeparationResult

enum ScipSeparationResult
strong
Enumerator
kLazyConstraintAdded 
kCuttingPlaneAdded 
kDidNotFind 

Definition at line 88 of file scip_callback.cc.

◆ VarTypes

enum VarTypes

This enum is used internally to do dynamic typing on subclasses of integer variables.

Enumerator
UNSPECIFIED 
DOMAIN_INT_VAR 
BOOLEAN_VAR 
CONST_VAR 
VAR_ADD_CST 
VAR_TIMES_CST 
CST_SUB_VAR 
OPP_VAR 
TRACE_VAR 

Definition at line 123 of file constraint_solveri.h.

Function Documentation

◆ AbslParseFlag()

bool AbslParseFlag ( const absl::string_view  text,
MPSolver::OptimizationProblemType solver_type,
std::string *  error 
)

Definition at line 581 of file linear_solver.cc.

◆ AbslUnparseFlag()

std::string operations_research::AbslUnparseFlag ( MPSolver::OptimizationProblemType  solver_type)
inline

Definition at line 920 of file linear_solver.h.

◆ AcceptDelta()

bool AcceptDelta ( Search *const  search,
Assignment delta,
Assignment deltadelta 
)

Definition at line 1348 of file constraint_solver.cc.

◆ AcceptNeighbor()

void AcceptNeighbor ( Search *const  search)

Definition at line 1353 of file constraint_solver.cc.

◆ AcceptUncheckedNeighbor()

void AcceptUncheckedNeighbor ( Search *const  search)

Definition at line 1355 of file constraint_solver.cc.

◆ AddArcsFromMinimumSpanningTree()

void operations_research::AddArcsFromMinimumSpanningTree ( int  number_of_nodes,
const CostFunction &  cost,
std::set< std::pair< int, int >> *  arcs 
)

Definition at line 293 of file one_tree_lower_bound.h.

◆ AddCallbackConstraint()

void AddCallbackConstraint ( SCIP *  scip,
ScipConstraintHandler< ConstraintData > *  handler,
const std::string &  constraint_name,
const ConstraintData *  constraint_data,
const ScipCallbackConstraintOptions options 
)

Definition at line 265 of file scip_callback.h.

◆ AddHadOverflow()

bool operations_research::AddHadOverflow ( int64  x,
int64  y,
int64  sum 
)
inline

Definition at line 52 of file saturated_arithmetic.h.

◆ AddLocalSearchNeighborhoodOperatorsFromFlags()

void operations_research::AddLocalSearchNeighborhoodOperatorsFromFlags ( RoutingSearchParameters *  parameters)

Definition at line 202 of file routing_flags.cc.

◆ AddOverflows()

bool operations_research::AddOverflows ( int64  x,
int64  y 
)
inline

Definition at line 76 of file saturated_arithmetic.h.

◆ AppendDimensionCumulFilters()

void AppendDimensionCumulFilters ( const std::vector< RoutingDimension * > &  dimensions,
const RoutingSearchParameters &  parameters,
bool  filter_objective_cost,
std::vector< LocalSearchFilterManager::FilterEvent > *  filters 
)

Definition at line 2185 of file routing_search.cc.

◆ AppendLightWeightDimensionFilters()

void AppendLightWeightDimensionFilters ( const PathState path_state,
const std::vector< RoutingDimension * > &  dimensions,
std::vector< LocalSearchFilterManager::FilterEvent > *  filters 
)

Definition at line 2123 of file routing_search.cc.

◆ AppendTasksFromIntervals()

void AppendTasksFromIntervals ( const std::vector< IntervalVar * > &  intervals,
DisjunctivePropagator::Tasks tasks 
)

Definition at line 673 of file routing_breaks.cc.

◆ AppendTasksFromPath()

void AppendTasksFromPath ( const std::vector< int64 > &  path,
const TravelBounds travel_bounds,
const RoutingDimension dimension,
DisjunctivePropagator::Tasks tasks 
)

Definition at line 590 of file routing_breaks.cc.

◆ ApplyMipPresolveSteps()

MPSolverResponseStatus ApplyMipPresolveSteps ( bool  log_info,
const glop::GlopParameters &  glop_params,
MPModelProto *  model,
std::vector< std::unique_ptr< glop::Preprocessor >> *  for_postsolve 
)

Definition at line 27 of file sat_solver_utils.cc.

◆ ApplyVerifiedMPModelDelta()

void ApplyVerifiedMPModelDelta ( const MPModelDeltaProto &  delta,
MPModelProto *  model 
)

Definition at line 817 of file model_validator.cc.

◆ AreAllBooleans()

bool operations_research::AreAllBooleans ( const std::vector< IntVar * > &  vars)
inline

Definition at line 2937 of file constraint_solveri.h.

◆ AreAllBound()

bool operations_research::AreAllBound ( const std::vector< IntVar * > &  vars)
inline

Definition at line 2928 of file constraint_solveri.h.

◆ AreAllBoundOrNull()

bool operations_research::AreAllBoundOrNull ( const std::vector< IntVar * > &  vars,
const std::vector< T > &  values 
)

Returns true if all the variables are assigned to a single value, or if their corresponding value is null.

Definition at line 2944 of file constraint_solveri.h.

◆ AreAllBoundTo()

bool operations_research::AreAllBoundTo ( const std::vector< IntVar * > &  vars,
int64  value 
)
inline

Returns true if all variables are assigned to 'value'.

Definition at line 2955 of file constraint_solveri.h.

◆ AreAllGreaterOrEqual()

bool operations_research::AreAllGreaterOrEqual ( const std::vector< T > &  values,
const T &  value 
)

Definition at line 2858 of file constraint_solveri.h.

◆ AreAllLessOrEqual()

bool operations_research::AreAllLessOrEqual ( const std::vector< T > &  values,
const T &  value 
)

Definition at line 2868 of file constraint_solveri.h.

◆ AreAllNegative()

bool operations_research::AreAllNegative ( const std::vector< T > &  values)

Definition at line 2883 of file constraint_solveri.h.

◆ AreAllNull()

bool operations_research::AreAllNull ( const std::vector< T > &  values)

Definition at line 2853 of file constraint_solveri.h.

◆ AreAllOnes()

bool operations_research::AreAllOnes ( const std::vector< T > &  values)

Definition at line 2848 of file constraint_solveri.h.

◆ AreAllPositive()

bool operations_research::AreAllPositive ( const std::vector< T > &  values)

Definition at line 2878 of file constraint_solveri.h.

◆ AreAllStrictlyNegative()

bool operations_research::AreAllStrictlyNegative ( const std::vector< T > &  values)

Definition at line 2893 of file constraint_solveri.h.

◆ AreAllStrictlyPositive()

bool operations_research::AreAllStrictlyPositive ( const std::vector< T > &  values)

Definition at line 2888 of file constraint_solveri.h.

◆ AreWithinAbsoluteOrRelativeTolerances()

bool operations_research::AreWithinAbsoluteOrRelativeTolerances ( FloatType  x,
FloatType  y,
FloatType  relative_tolerance,
FloatType  absolute_tolerance 
)

Definition at line 120 of file fp_utils.h.

◆ AreWithinAbsoluteTolerance()

bool operations_research::AreWithinAbsoluteTolerance ( FloatType  x,
FloatType  y,
FloatType  absolute_tolerance 
)

Definition at line 141 of file fp_utils.h.

◆ AStarShortestPath()

bool AStarShortestPath ( int  node_count,
int  start_node,
int  end_node,
std::function< int64(int, int)>  graph,
std::function< int64(int)>  heuristic,
int64  disconnected_distance,
std::vector< int > *  nodes 
)

Definition at line 170 of file astar.cc.

◆ BellmanFordShortestPath()

bool BellmanFordShortestPath ( int  node_count,
int  start_node,
int  end_node,
std::function< int64(int, int)>  graph,
int64  disconnected_distance,
std::vector< int > *  nodes 
)

Definition at line 112 of file bellman_ford.cc.

◆ BitCount32()

uint32 operations_research::BitCount32 ( uint32  n)
inline

Definition at line 53 of file bitset.h.

◆ BitCount64()

uint64 operations_research::BitCount64 ( uint64  n)
inline

Definition at line 42 of file bitset.h.

◆ BitCountRange32()

uint32 operations_research::BitCountRange32 ( const uint32 *const  bitset,
uint32  start,
uint32  end 
)

◆ BitCountRange64()

uint64 operations_research::BitCountRange64 ( const uint64 *const  bitset,
uint64  start,
uint64  end 
)

◆ BitLength32()

uint32 operations_research::BitLength32 ( uint32  size)
inline

Definition at line 339 of file bitset.h.

◆ BitLength64()

uint64 operations_research::BitLength64 ( uint64  size)
inline

Definition at line 338 of file bitset.h.

◆ BitOffset32()

uint32 operations_research::BitOffset32 ( uint32  pos)
inline

Definition at line 335 of file bitset.h.

◆ BitOffset64()

uint64 operations_research::BitOffset64 ( uint64  pos)
inline

Definition at line 334 of file bitset.h.

◆ BitPos32()

uint32 operations_research::BitPos32 ( uint32  pos)
inline

Definition at line 331 of file bitset.h.

◆ BitPos64()

uint32 operations_research::BitPos64 ( uint64  pos)
inline

Definition at line 330 of file bitset.h.

◆ BitShift32()

uint32 operations_research::BitShift32 ( uint32  v)
inline

Definition at line 343 of file bitset.h.

◆ BitShift64()

uint64 operations_research::BitShift64 ( uint64  v)
inline

Definition at line 342 of file bitset.h.

◆ BuildBopInterface()

MPSolverInterface * BuildBopInterface ( MPSolver *const  solver)

Definition at line 386 of file bop_interface.cc.

◆ BuildCBCInterface()

MPSolverInterface * BuildCBCInterface ( MPSolver *const  solver)

Definition at line 533 of file cbc_interface.cc.

◆ BuildCLPInterface()

MPSolverInterface * BuildCLPInterface ( MPSolver *const  solver)

Definition at line 626 of file clp_interface.cc.

◆ BuildDemonProfiler()

DemonProfiler * BuildDemonProfiler ( Solver *const  solver)

Definition at line 440 of file demon_profiler.cc.

◆ BuildDurationExpr()

IntExpr * BuildDurationExpr ( IntervalVar var)

Definition at line 162 of file sched_expr.cc.

◆ BuildEndExpr()

IntExpr * BuildEndExpr ( IntervalVar var)

Definition at line 172 of file sched_expr.cc.

◆ BuildEulerianPath()

std::vector<typename Graph::NodeIndex> operations_research::BuildEulerianPath ( const Graph &  graph)

Definition at line 138 of file eulerian_path.h.

◆ BuildEulerianPathFromNode()

std::vector<NodeIndex> operations_research::BuildEulerianPathFromNode ( const Graph &  graph,
NodeIndex  root 
)

Definition at line 74 of file eulerian_path.h.

◆ BuildEulerianTour()

std::vector<typename Graph::NodeIndex> operations_research::BuildEulerianTour ( const Graph &  graph)

Definition at line 128 of file eulerian_path.h.

◆ BuildEulerianTourFromNode()

std::vector<NodeIndex> operations_research::BuildEulerianTourFromNode ( const Graph &  graph,
NodeIndex  root 
)

Definition at line 116 of file eulerian_path.h.

◆ BuildGLOPInterface()

MPSolverInterface * BuildGLOPInterface ( MPSolver *const  solver)

Definition at line 428 of file glop_interface.cc.

◆ BuildGurobiInterface()

MPSolverInterface * BuildGurobiInterface ( bool  mip,
MPSolver *const  solver 
)

Definition at line 1382 of file gurobi_interface.cc.

◆ BuildKruskalMinimumSpanningTree()

std::vector<typename Graph::ArcIndex> operations_research::BuildKruskalMinimumSpanningTree ( const Graph &  graph,
const ArcComparator &  arc_comparator 
)

Definition at line 89 of file minimum_spanning_tree.h.

◆ BuildKruskalMinimumSpanningTreeFromSortedArcs()

std::vector<typename Graph::ArcIndex> operations_research::BuildKruskalMinimumSpanningTreeFromSortedArcs ( const Graph &  graph,
const std::vector< typename Graph::ArcIndex > &  sorted_arcs 
)

Definition at line 50 of file minimum_spanning_tree.h.

◆ BuildLineGraph()

bool operations_research::BuildLineGraph ( const GraphType &  graph,
GraphType *const  line_graph 
)

Definition at line 2088 of file ebert_graph.h.

◆ BuildLocalSearchMonitorMaster()

LocalSearchMonitor * BuildLocalSearchMonitorMaster ( Solver *const  s)

Definition at line 3202 of file constraint_solver.cc.

◆ BuildLocalSearchProfiler()

LocalSearchProfiler * BuildLocalSearchProfiler ( Solver solver)

Definition at line 3834 of file local_search.cc.

◆ BuildModelCache()

ModelCache * BuildModelCache ( Solver *const  solver)

Definition at line 845 of file model_cache.cc.

◆ BuildModelParametersFromFlags()

RoutingModelParameters BuildModelParametersFromFlags ( )

Builds routing search parameters from flags.

Definition at line 328 of file routing_flags.cc.

◆ BuildPrimMinimumSpanningTree()

std::vector<typename Graph::ArcIndex> operations_research::BuildPrimMinimumSpanningTree ( const Graph &  graph,
const ArcValue &  arc_value 
)

Definition at line 115 of file minimum_spanning_tree.h.

◆ BuildPrintTrace()

PropagationMonitor * BuildPrintTrace ( Solver *const  s)

Definition at line 873 of file trace.cc.

◆ BuildSafeDurationExpr()

IntExpr * BuildSafeDurationExpr ( IntervalVar var,
int64  unperformed_value 
)

Definition at line 187 of file sched_expr.cc.

◆ BuildSafeEndExpr()

IntExpr * BuildSafeEndExpr ( IntervalVar var,
int64  unperformed_value 
)

Definition at line 192 of file sched_expr.cc.

◆ BuildSafeStartExpr()

IntExpr * BuildSafeStartExpr ( IntervalVar var,
int64  unperformed_value 
)

Definition at line 182 of file sched_expr.cc.

◆ BuildSatInterface()

MPSolverInterface * BuildSatInterface ( MPSolver *const  solver)

Definition at line 298 of file sat_interface.cc.

◆ BuildSCIPInterface()

MPSolverInterface * BuildSCIPInterface ( MPSolver *const  solver)

Definition at line 1151 of file scip_interface.cc.

◆ BuildSearchParametersFromFlags()

RoutingSearchParameters BuildSearchParametersFromFlags ( )

Builds routing search parameters from flags.

describe a valid set of routing search parameters.

Definition at line 315 of file routing_flags.cc.

◆ BuildStartExpr()

IntExpr * BuildStartExpr ( IntervalVar var)

Definition at line 152 of file sched_expr.cc.

◆ BuildTrace()

PropagationMonitor * BuildTrace ( Solver *const  s)

Definition at line 3127 of file constraint_solver.cc.

◆ CapAdd()

int64 operations_research::CapAdd ( int64  x,
int64  y 
)
inline

Definition at line 124 of file saturated_arithmetic.h.

◆ CapAddGeneric()

int64 operations_research::CapAddGeneric ( int64  x,
int64  y 
)
inline

Definition at line 102 of file saturated_arithmetic.h.

◆ CapOpp()

int64 operations_research::CapOpp ( int64  v)
inline

Definition at line 163 of file saturated_arithmetic.h.

◆ CapProd()

int64 operations_research::CapProd ( int64  x,
int64  y 
)
inline

Definition at line 231 of file saturated_arithmetic.h.

◆ CapProdGeneric()

int64 operations_research::CapProdGeneric ( int64  x,
int64  y 
)
inline

Definition at line 180 of file saturated_arithmetic.h.

◆ CapSub()

int64 operations_research::CapSub ( int64  x,
int64  y 
)
inline

Definition at line 154 of file saturated_arithmetic.h.

◆ CapSubGeneric()

int64 operations_research::CapSubGeneric ( int64  x,
int64  y 
)
inline

Definition at line 132 of file saturated_arithmetic.h.

◆ CapWithSignOf()

int64 operations_research::CapWithSignOf ( int64  x)
inline

Definition at line 97 of file saturated_arithmetic.h.

◆ CeilRatio()

int64 operations_research::CeilRatio ( int64  value,
int64  positive_coeff 
)

Definition at line 87 of file sorted_interval_list.cc.

◆ ChooseMode()

BaseAssignVariables::Mode operations_research::ChooseMode ( Solver::IntValueStrategy  val_str)

Definition at line 1998 of file search.cc.

◆ CleanVariableOnFail()

void CleanVariableOnFail ( IntVar *const  var)

Definition at line 6326 of file expressions.cc.

◆ ClearBit32()

void operations_research::ClearBit32 ( uint32 *const  bitset,
uint32  pos 
)
inline

Definition at line 365 of file bitset.h.

◆ ClearBit64()

void operations_research::ClearBit64 ( uint64 *const  bitset,
uint64  pos 
)
inline

Definition at line 362 of file bitset.h.

◆ CompareKnapsackItemWithEfficiencyInDecreasingEfficiencyOrder()

bool operations_research::CompareKnapsackItemWithEfficiencyInDecreasingEfficiencyOrder ( const KnapsackItemWithEfficiency item1,
const KnapsackItemWithEfficiency item2 
)

Definition at line 717 of file knapsack_solver.cc.

◆ ComputeGcdOfRoundedDoubles()

int64 ComputeGcdOfRoundedDoubles ( const std::vector< double > &  x,
double  scaling_factor 
)

Definition at line 189 of file fp_utils.cc.

◆ ComputeMinimumWeightMatching()

absl::StatusOr<std::vector< std::pair<typename GraphType::NodeIndex, typename GraphType::NodeIndex> > > operations_research::ComputeMinimumWeightMatching ( const GraphType &  graph,
const WeightFunctionType &  weight 
)

Definition at line 109 of file christofides.h.

◆ ComputeMinimumWeightMatchingWithMIP()

absl::StatusOr<std::vector< std::pair<typename GraphType::NodeIndex, typename GraphType::NodeIndex> > > operations_research::ComputeMinimumWeightMatchingWithMIP ( const GraphType &  graph,
const WeightFunctionType &  weight 
)

Definition at line 145 of file christofides.h.

◆ ComputeOneTree()

std::vector<int> operations_research::ComputeOneTree ( const GraphType &  graph,
const CostFunction &  cost,
const std::vector< double > &  weights,
const std::vector< int > &  sorted_arcs,
CostType *  one_tree_cost 
)

Definition at line 331 of file one_tree_lower_bound.h.

◆ ComputeOneTreeLowerBound()

double operations_research::ComputeOneTreeLowerBound ( int  number_of_nodes,
const CostFunction &  cost 
)

Definition at line 480 of file one_tree_lower_bound.h.

◆ ComputeOneTreeLowerBoundWithAlgorithm()

double operations_research::ComputeOneTreeLowerBoundWithAlgorithm ( int  number_of_nodes,
int  nearest_neighbors,
const CostFunction &  cost,
Algorithm *  algorithm 
)

Definition at line 378 of file one_tree_lower_bound.h.

◆ ComputeOneTreeLowerBoundWithParameters()

double operations_research::ComputeOneTreeLowerBoundWithParameters ( int  number_of_nodes,
const CostFunction &  cost,
const TravelingSalesmanLowerBoundParameters parameters 
)

Definition at line 452 of file one_tree_lower_bound.h.

◆ ComputeScalingErrors()

void ComputeScalingErrors ( const std::vector< double > &  input,
const std::vector< double > &  lb,
const std::vector< double > &  ub,
double  scaling_factor,
double *  max_relative_coeff_error,
double *  max_scaled_sum_error 
)

Definition at line 159 of file fp_utils.cc.

◆ CoverArcsByCliques()

void CoverArcsByCliques ( std::function< bool(int, int)>  graph,
int  node_count,
std::function< bool(const std::vector< int > &)>  callback 
)

Definition at line 240 of file cliques.cc.

◆ CpRandomSeed()

int64 operations_research::CpRandomSeed ( )
inline

Definition at line 168 of file constraint_solver.h.

◆ DefaultGScipConstraintOptions()

const GScipConstraintOptions & DefaultGScipConstraintOptions ( )

Definition at line 160 of file gscip.cc.

◆ DefaultGScipVariableOptions()

const GScipVariableOptions & DefaultGScipVariableOptions ( )

Definition at line 155 of file gscip.cc.

◆ DefaultPhaseStatString()

std::string operations_research::DefaultPhaseStatString ( DecisionBuilder db)

Definition at line 1105 of file default_search.cc.

◆ DefaultRoutingModelParameters()

RoutingModelParameters DefaultRoutingModelParameters ( )

Definition at line 31 of file routing_parameters.cc.

◆ DefaultRoutingSearchParameters()

RoutingSearchParameters DefaultRoutingSearchParameters ( )
Examples
tsp.cc, and vrp.cc.

Definition at line 44 of file routing_parameters.cc.

◆ DEFINE_INT_TYPE() [1/5]

operations_research::DEFINE_INT_TYPE ( RoutingCostClassIndex  ,
int   
)

◆ DEFINE_INT_TYPE() [2/5]

operations_research::DEFINE_INT_TYPE ( RoutingDimensionIndex  ,
int   
)

◆ DEFINE_INT_TYPE() [3/5]

operations_research::DEFINE_INT_TYPE ( RoutingDisjunctionIndex  ,
int   
)

◆ DEFINE_INT_TYPE() [4/5]

operations_research::DEFINE_INT_TYPE ( RoutingNodeIndex  ,
int   
)

Defining common types used in the routing library outside the main RoutingModel class has several purposes: 1) It allows some small libraries to avoid a dependency on routing.

{h,cc}, eg. routing_neighborhoods.h. 2) It allows an easier wrapping via SWIG, which can have issues with intra-class types.

Users that depend on routing.{h,cc} should just use the RoutingModel:: equivalent, eg. RoutingModel::NodeIndex.

◆ DEFINE_INT_TYPE() [5/5]

operations_research::DEFINE_INT_TYPE ( RoutingVehicleClassIndex  ,
int   
)

◆ DeleteDemonProfiler()

void DeleteDemonProfiler ( DemonProfiler *const  monitor)

Definition at line 448 of file demon_profiler.cc.

◆ DeleteLocalSearchProfiler()

void DeleteLocalSearchProfiler ( LocalSearchProfiler monitor)

Definition at line 3841 of file local_search.cc.

◆ DemonProfilerAddFakeRun()

void operations_research::DemonProfilerAddFakeRun ( DemonProfiler *const  monitor,
Demon *const  demon,
int64  start_time,
int64  end_time,
bool  is_fail 
)

Definition at line 465 of file demon_profiler.cc.

◆ DemonProfilerBeginInitialPropagation()

void operations_research::DemonProfilerBeginInitialPropagation ( DemonProfiler *const  monitor,
Constraint *const  constraint 
)

Definition at line 482 of file demon_profiler.cc.

◆ DemonProfilerEndInitialPropagation()

void operations_research::DemonProfilerEndInitialPropagation ( DemonProfiler *const  monitor,
Constraint *const  constraint 
)

Definition at line 487 of file demon_profiler.cc.

◆ DemonProfilerExportInformation()

void operations_research::DemonProfilerExportInformation ( DemonProfiler *const  monitor,
const Constraint *const  constraint,
int64 *const  fails,
int64 *const  initial_propagation_runtime,
int64 *const  demon_invocations,
int64 *const  total_demon_runtime,
int *const  demon_count 
)

Definition at line 470 of file demon_profiler.cc.

◆ DijkstraShortestPath()

bool DijkstraShortestPath ( int  node_count,
int  start_node,
int  end_node,
std::function< int64(int, int)>  graph,
int64  disconnected_distance,
std::vector< int > *  nodes 
)

Definition at line 147 of file dijkstra.cc.

◆ EncodeSatParametersAsString()

std::string EncodeSatParametersAsString ( const sat::SatParameters &  parameters)

Definition at line 223 of file sat_proto_solver.cc.

◆ ExportModelAsLpFormat()

absl::StatusOr< std::string > ExportModelAsLpFormat ( const MPModelProto &  model,
const MPModelExportOptions options = MPModelExportOptions() 
)

Outputs the current model (variables, constraints, objective) as a string encoded in the so-called "CPLEX LP file format" as generated by SCIP.

The LP file format is easily readable by a human.

Returns false if some error has occurred during execution. The validity of names is automatically checked. If a variable name or a constraint name is invalid or non-existent, a new valid name is automatically generated.

If 'obfuscated' is true, the variable and constraint names of proto_ are not used. Variable and constraint names of the form "V12345" and "C12345" are used instead.

For more information about the different LP file formats: http://lpsolve.sourceforge.net/5.5/lp-format.htm The following give a reasonable idea of the CPLEX LP file format: http://lpsolve.sourceforge.net/5.5/CPLEX-format.htm http://tinyurl.com/cplex-lp-format http://www.gurobi.com/documentation/5.1/reference-manual/node871

Definition at line 214 of file model_exporter.cc.

◆ ExportModelAsMpsFormat()

absl::StatusOr< std::string > ExportModelAsMpsFormat ( const MPModelProto &  model,
const MPModelExportOptions options = MPModelExportOptions() 
)

Outputs the current model (variables, constraints, objective) as a string encoded in MPS file format, using the "free" MPS format.

Returns false if some error has occurred during execution. Models with maximization objectives trigger an error, because MPS can encode only minimization problems.

The validity of names is automatically checked. If a variable name or a constraint name is invalid or non-existent, a new valid name is automatically generated.

Name validity and obfuscation works exactly as in ExportModelAsLpFormat().

For more information about the MPS format: http://en.wikipedia.org/wiki/MPS_(format) A close-to-original description coming from OSL: http://tinyurl.com/mps-format-by-osl A recent description from CPLEX: http://tinyurl.com/mps-format-by-cplex CPLEX extensions: http://tinyurl.com/mps-extensions-by-cplex Gurobi's description: http://www.gurobi.com/documentation/5.1/reference-manual/node869

Definition at line 231 of file model_exporter.cc.

◆ ExtractValidMPModelInPlaceOrPopulateResponseStatus()

bool ExtractValidMPModelInPlaceOrPopulateResponseStatus ( MPModelRequest *  request,
MPSolutionResponse *  response 
)

Like ExtractValidMPModelOrPopulateResponseStatus(), but works in-place: if the MPModel needed extraction, it will be populated in the request, and it returns the success boolean.

Definition at line 608 of file model_validator.cc.

◆ ExtractValidMPModelOrPopulateResponseStatus()

absl::optional< LazyMutableCopy< MPModelProto > > ExtractValidMPModelOrPopulateResponseStatus ( const MPModelRequest &  request,
MPSolutionResponse *  response 
)

If the model is valid and non-empty, returns it (possibly after extracting the model_delta).

If invalid or empty, updates response and returns null.

Definition at line 531 of file model_validator.cc.

◆ FillPathEvaluation()

void FillPathEvaluation ( const std::vector< int64 > &  path,
const RoutingModel::TransitCallback2 evaluator,
std::vector< int64 > *  values 
)

Definition at line 6215 of file routing.cc.

◆ FillTravelBoundsOfVehicle()

void FillTravelBoundsOfVehicle ( int  vehicle,
const std::vector< int64 > &  path,
const RoutingDimension dimension,
TravelBounds travel_bounds 
)

Definition at line 645 of file routing_breaks.cc.

◆ FillValues()

void operations_research::FillValues ( const std::vector< IntVar * > &  vars,
std::vector< int64 > *const  values 
)
inline

Definition at line 2984 of file constraint_solveri.h.

◆ FindCliques()

void FindCliques ( std::function< bool(int, int)>  graph,
int  node_count,
std::function< bool(const std::vector< int > &)>  callback 
)

Definition at line 226 of file cliques.cc.

◆ FindErrorInMPModelDeltaProto()

std::string FindErrorInMPModelDeltaProto ( const MPModelDeltaProto &  delta,
const MPModelProto &  model 
)

Like FindErrorInMPModelProto, but for a MPModelDeltaProto applied to a given baseline model (assumed valid, eg.

FindErrorInMPModelProto(model)=""). Works in O(|model_delta|) + O(num_vars in model), but the latter term has a very small constant factor.

Definition at line 682 of file model_validator.cc.

◆ FindErrorInMPModelForScip()

std::string FindErrorInMPModelForScip ( const MPModelProto &  model,
SCIP *  scip 
)

Definition at line 533 of file scip_proto_solver.cc.

◆ FindErrorInMPModelProto()

std::string FindErrorInMPModelProto ( const MPModelProto &  model,
double  abs_value_threshold = 0.0 
)

Returns an empty string iff the model is valid and not trivially infeasible.

Otherwise, returns a description of the first error or trivial infeasibility encountered.

abs_value_threshold is the (exclusive) limit for the abs value of constraint coefficients, objective coefficients, etc. If unspecified, or 0, it defaults to FLAGS_model_validator_infinity.

NOTE(user): the code of this method (and the client code too!) is considerably simplified by this string-based, simple API. If clients require it, we could add a formal error status enum.

Definition at line 416 of file model_validator.cc.

◆ FindErrorInRoutingSearchParameters()

std::string FindErrorInRoutingSearchParameters ( const RoutingSearchParameters &  search_parameters)

Returns an empty std::string if the routing search parameters are valid, and a non-empty, human readable error description if they're not.

Definition at line 137 of file routing_parameters.cc.

◆ FindFeasibilityErrorInSolutionHint()

std::string FindFeasibilityErrorInSolutionHint ( const MPModelProto &  model,
double  tolerance 
)

Returns an empty string if the solution hint given in the model is a feasible solution.

Otherwise, returns a description of the first reason for infeasibility.

This function can be useful for debugging/checking that the given solution hint is feasible when it is expected to be the case. The feasibility is checked up to the given tolerance using the ::operations_research::IsLowerWithinTolerance() function.

Definition at line 621 of file model_validator.cc.

◆ FloorRatio()

int64 operations_research::FloorRatio ( int64  value,
int64  positive_coeff 
)

Definition at line 94 of file sorted_interval_list.cc.

◆ FullProtocolMessageAsString()

std::string FullProtocolMessageAsString ( const google::protobuf::Message &  message,
int  indent_level 
)

Definition at line 58 of file proto_tools.cc.

◆ GenericCheck()

void operations_research::GenericCheck ( const int  expected_assignment_size,
const absl::flat_hash_map< int, int > &  direct_assignment,
const absl::flat_hash_map< int, int > &  reverse_assignment,
const int  expected_agents[],
const int  expected_tasks[] 
)

Definition at line 17 of file hungarian_test.cc.

◆ GetBestScalingOfDoublesToInt64() [1/2]

double GetBestScalingOfDoublesToInt64 ( const std::vector< double > &  input,
const std::vector< double > &  lb,
const std::vector< double > &  ub,
int64  max_absolute_sum 
)

Definition at line 168 of file fp_utils.cc.

◆ GetBestScalingOfDoublesToInt64() [2/2]

void GetBestScalingOfDoublesToInt64 ( const std::vector< double > &  input,
int64  max_absolute_sum,
double *  scaling_factor,
double *  max_relative_coeff_error 
)

Definition at line 178 of file fp_utils.cc.

◆ GetNodeMinimizingEdgeCostToSource()

int operations_research::GetNodeMinimizingEdgeCostToSource ( const GraphType &  graph,
int  source,
const CostFunction &  cost,
AcceptFunction  accept 
)

Definition at line 310 of file one_tree_lower_bound.h.

◆ GetProcessMemoryUsage()

int64 GetProcessMemoryUsage ( )

Definition at line 85 of file sysinfo.cc.

◆ GlopToMPSolverConstraintStatus()

MPSolver::BasisStatus GlopToMPSolverConstraintStatus ( glop::ConstraintStatus  s)

Definition at line 91 of file glop_utils.cc.

◆ GlopToMPSolverResultStatus()

MPSolver::ResultStatus GlopToMPSolverResultStatus ( glop::ProblemStatus  s)

Definition at line 18 of file glop_utils.cc.

◆ GlopToMPSolverVariableStatus()

MPSolver::BasisStatus GlopToMPSolverVariableStatus ( glop::VariableStatus  s)

Definition at line 57 of file glop_utils.cc.

◆ GScipAddQuadraticObjectiveTerm()

absl::Status GScipAddQuadraticObjectiveTerm ( GScip gscip,
std::vector< SCIP_Var * >  quadratic_variables1,
std::vector< SCIP_Var * >  quadratic_variables2,
std::vector< double >  quadratic_coefficients,
const std::string &  name 
)

Definition at line 143 of file gscip_ext.cc.

◆ GScipCreateAbs()

absl::Status GScipCreateAbs ( GScip gscip,
SCIP_Var *  x,
SCIP_Var *  abs_x,
const std::string &  name 
)

Definition at line 69 of file gscip_ext.cc.

◆ GScipCreateIndicatorRange()

absl::Status GScipCreateIndicatorRange ( GScip gscip,
const GScipIndicatorRangeConstraint indicator_range,
const std::string &  name,
const GScipConstraintOptions options 
)

Definition at line 173 of file gscip_ext.cc.

◆ GScipCreateMaximum()

absl::Status GScipCreateMaximum ( GScip gscip,
const GScipLinearExpr resultant,
const std::vector< GScipLinearExpr > &  terms,
const std::string &  name 
)

Definition at line 76 of file gscip_ext.cc.

◆ GScipCreateMinimum()

absl::Status GScipCreateMinimum ( GScip gscip,
const GScipLinearExpr resultant,
const std::vector< GScipLinearExpr > &  terms,
const std::string &  name 
)

Definition at line 132 of file gscip_ext.cc.

◆ GScipDifference()

GScipLinearExpr GScipDifference ( GScipLinearExpr  left,
const GScipLinearExpr right 
)

Definition at line 37 of file gscip_ext.cc.

◆ GScipLe()

GScipLinearRange GScipLe ( const GScipLinearExpr  left,
const GScipLinearExpr right 
)

Definition at line 56 of file gscip_ext.cc.

◆ GScipLogLevel()

int GScipLogLevel ( const GScipParameters &  parameters)

Definition at line 82 of file gscip_parameters.cc.

◆ GScipLogLevelSet()

bool GScipLogLevelSet ( const GScipParameters &  parameters)

Definition at line 87 of file gscip_parameters.cc.

◆ GScipMaxNumThreads()

int GScipMaxNumThreads ( const GScipParameters &  parameters)

Definition at line 64 of file gscip_parameters.cc.

◆ GScipMaxNumThreadsSet()

bool GScipMaxNumThreadsSet ( const GScipParameters &  parameters)

Definition at line 71 of file gscip_parameters.cc.

◆ GScipNegate()

GScipLinearExpr GScipNegate ( GScipLinearExpr  expr)

Definition at line 46 of file gscip_ext.cc.

◆ GScipOutputEnabled()

bool GScipOutputEnabled ( const GScipParameters &  parameters)

Definition at line 98 of file gscip_parameters.cc.

◆ GScipOutputEnabledSet()

bool GScipOutputEnabledSet ( const GScipParameters &  parameters)

Definition at line 103 of file gscip_parameters.cc.

◆ GScipRandomSeed()

int GScipRandomSeed ( const GScipParameters &  parameters)

Definition at line 113 of file gscip_parameters.cc.

◆ GScipRandomSeedSet()

bool GScipRandomSeedSet ( const GScipParameters &  parameters)

Definition at line 120 of file gscip_parameters.cc.

◆ GScipSetLogLevel()

void GScipSetLogLevel ( GScipParameters *  parameters,
int  log_level 
)

Definition at line 75 of file gscip_parameters.cc.

◆ GScipSetMaxNumThreads()

void GScipSetMaxNumThreads ( int  num_threads,
GScipParameters *  parameters 
)

Definition at line 58 of file gscip_parameters.cc.

◆ GScipSetOutputEnabled()

void GScipSetOutputEnabled ( GScipParameters *  parameters,
bool  output_enabled 
)

Definition at line 91 of file gscip_parameters.cc.

◆ GScipSetRandomSeed()

void GScipSetRandomSeed ( GScipParameters *  parameters,
int  random_seed 
)

Definition at line 107 of file gscip_parameters.cc.

◆ GScipSetTimeLimit()

void GScipSetTimeLimit ( absl::Duration  time_limit,
GScipParameters *  parameters 
)

Definition at line 30 of file gscip_parameters.cc.

◆ GScipTimeLimit()

absl::Duration GScipTimeLimit ( const GScipParameters &  parameters)

Definition at line 39 of file gscip_parameters.cc.

◆ GScipTimeLimitSet()

bool GScipTimeLimitSet ( const GScipParameters &  parameters)

Definition at line 54 of file gscip_parameters.cc.

◆ GurobiSolveProto()

absl::StatusOr< MPSolutionResponse > GurobiSolveProto ( const MPModelRequest &  request,
GRBenv gurobi_env 
)

Definition at line 262 of file gurobi_proto_solver.cc.

◆ Hash1() [1/7]

uint64 operations_research::Hash1 ( const std::vector< int64 > &  ptrs)
inline

Definition at line 268 of file constraint_solveri.h.

◆ Hash1() [2/7]

uint64 operations_research::Hash1 ( const std::vector< T * > &  ptrs)

Definition at line 258 of file constraint_solveri.h.

◆ Hash1() [3/7]

uint64 operations_research::Hash1 ( int  value)
inline

Definition at line 246 of file constraint_solveri.h.

◆ Hash1() [4/7]

uint64 operations_research::Hash1 ( int64  value)
inline

Definition at line 244 of file constraint_solveri.h.

◆ Hash1() [5/7]

uint64 operations_research::Hash1 ( uint32  value)
inline

Definition at line 233 of file constraint_solveri.h.

◆ Hash1() [6/7]

uint64 operations_research::Hash1 ( uint64  value)
inline

Hash functions.

value = (value << 21) - value - 1;

value * 265

value * 21

Definition at line 222 of file constraint_solveri.h.

◆ Hash1() [7/7]

uint64 operations_research::Hash1 ( void *const  ptr)
inline

Definition at line 248 of file constraint_solveri.h.

◆ Hash32NumWithSeed()

uint32 operations_research::Hash32NumWithSeed ( uint32  num,
uint32  c 
)
inline

Definition at line 97 of file hash.h.

◆ Hash64NumWithSeed()

uint64 operations_research::Hash64NumWithSeed ( uint64  num,
uint64  c 
)
inline

Definition at line 103 of file hash.h.

◆ HasUnaryDimension()

bool operations_research::HasUnaryDimension ( const std::vector< RoutingDimension * > &  dimensions)

Definition at line 4724 of file routing.cc.

◆ IncrementalSort() [1/2]

void operations_research::IncrementalSort ( int  max_comparisons,
Iterator  begin,
Iterator  end,
Compare  comp = Compare{},
bool  is_stable = false 
)

Definition at line 46 of file sort.h.

◆ IncrementalSort() [2/2]

void operations_research::IncrementalSort ( Iterator  begin,
Iterator  end,
Compare  comp = Compare{},
bool  is_stable = false 
)

Definition at line 129 of file sort.h.

◆ InputContainsNan()

bool operations_research::InputContainsNan ( const std::vector< std::vector< double >> &  input)

Definition at line 645 of file hungarian.cc.

◆ InsertionSort()

void operations_research::InsertionSort ( Iterator  begin,
Iterator  end,
Compare  comp = Compare{} 
)

Definition at line 95 of file sort.h.

◆ InstallDemonProfiler()

void InstallDemonProfiler ( DemonProfiler *const  monitor)

Definition at line 438 of file demon_profiler.cc.

◆ InstallLocalSearchProfiler()

void InstallLocalSearchProfiler ( LocalSearchProfiler monitor)

Definition at line 3830 of file local_search.cc.

◆ InternalSaveBooleanVarValue()

void operations_research::InternalSaveBooleanVarValue ( Solver *const  solver,
IntVar *const  var 
)

Definition at line 947 of file constraint_solver.cc.

◆ Interpolate()

FloatType operations_research::Interpolate ( FloatType  x,
FloatType  y,
FloatType  alpha 
)
inline

Definition at line 242 of file fp_utils.h.

◆ IntervalDown32()

uint32 operations_research::IntervalDown32 ( uint32  s)
inline

Definition at line 316 of file bitset.h.

◆ IntervalDown64()

uint64 operations_research::IntervalDown64 ( uint64  s)
inline

Definition at line 311 of file bitset.h.

◆ IntervalsAreSortedAndNonAdjacent()

bool IntervalsAreSortedAndNonAdjacent ( absl::Span< const ClosedInterval intervals)

Returns true iff we have:

  • The intervals appear in increasing order.
  • for all i: intervals[i].start <= intervals[i].end (should always be true, by construction, but bad intervals can in practice escape detection in opt mode).
  • for all i but the last: intervals[i].end + 1 < intervals[i+1].start

Definition at line 37 of file sorted_interval_list.cc.

◆ IntervalUp32()

uint32 operations_research::IntervalUp32 ( uint32  s)
inline

Definition at line 305 of file bitset.h.

◆ IntervalUp64()

uint64 operations_research::IntervalUp64 ( uint64  s)
inline

Definition at line 300 of file bitset.h.

◆ IsArrayBoolean()

bool operations_research::IsArrayBoolean ( const std::vector< T > &  values)

Definition at line 2838 of file constraint_solveri.h.

◆ IsArrayConstant()

bool operations_research::IsArrayConstant ( const std::vector< T > &  values,
const T &  value 
)

Definition at line 2828 of file constraint_solveri.h.

◆ IsArrayInRange()

bool operations_research::IsArrayInRange ( const std::vector< IntVar * > &  vars,
range_min,
range_max 
)

Definition at line 2918 of file constraint_solveri.h.

◆ IsBitSet32()

bool operations_research::IsBitSet32 ( const uint32 *const  bitset,
uint32  pos 
)
inline

Definition at line 349 of file bitset.h.

◆ IsBitSet64()

bool operations_research::IsBitSet64 ( const uint64 *const  bitset,
uint64  pos 
)
inline

Definition at line 346 of file bitset.h.

◆ IsEmptyRange32()

bool operations_research::IsEmptyRange32 ( const uint32 *const  bitset,
uint32  start,
uint32  end 
)

◆ IsEmptyRange64()

bool operations_research::IsEmptyRange64 ( const uint64 *const  bitset,
uint64  start,
uint64  end 
)

◆ IsEulerianGraph()

bool operations_research::IsEulerianGraph ( const Graph &  graph)

Definition at line 40 of file eulerian_path.h.

◆ IsIncreasing()

bool operations_research::IsIncreasing ( const std::vector< T > &  values)

Definition at line 2908 of file constraint_solveri.h.

◆ IsIncreasingContiguous()

bool operations_research::IsIncreasingContiguous ( const std::vector< T > &  values)

Definition at line 2898 of file constraint_solveri.h.

◆ IsIntegerWithinTolerance()

bool operations_research::IsIntegerWithinTolerance ( FloatType  x,
FloatType  tolerance 
)
inline

Definition at line 161 of file fp_utils.h.

◆ IsPositiveOrNegativeInfinity()

bool operations_research::IsPositiveOrNegativeInfinity ( FloatType  x)
inline

Definition at line 107 of file fp_utils.h.

◆ IsSemiEulerianGraph()

bool operations_research::IsSemiEulerianGraph ( const Graph &  graph,
std::vector< NodeIndex > *  odd_nodes 
)

Definition at line 55 of file eulerian_path.h.

◆ IsSmallerWithinTolerance()

bool operations_research::IsSmallerWithinTolerance ( FloatType  x,
FloatType  y,
FloatType  tolerance 
)

Definition at line 153 of file fp_utils.h.

◆ JoinDebugString()

std::string operations_research::JoinDebugString ( const std::vector< T > &  v,
const std::string &  separator 
)

Definition at line 38 of file string_array.h.

◆ JoinDebugStringPtr()

std::string operations_research::JoinDebugStringPtr ( const std::vector< T > &  v,
const std::string &  separator 
)

Definition at line 45 of file string_array.h.

◆ JoinNameFieldPtr()

std::string operations_research::JoinNameFieldPtr ( const std::vector< T > &  v,
const std::string &  separator 
)

Definition at line 58 of file string_array.h.

◆ JoinNamePtr()

std::string operations_research::JoinNamePtr ( const std::vector< T > &  v,
const std::string &  separator 
)

Definition at line 52 of file string_array.h.

◆ LeastSignificantBitPosition32() [1/2]

int operations_research::LeastSignificantBitPosition32 ( const uint32 *const  bitset,
uint32  start,
uint32  end 
)

◆ LeastSignificantBitPosition32() [2/2]

int operations_research::LeastSignificantBitPosition32 ( uint32  n)
inline

Definition at line 182 of file bitset.h.

◆ LeastSignificantBitPosition32DeBruijn()

int operations_research::LeastSignificantBitPosition32DeBruijn ( uint32  n)
inline

Definition at line 144 of file bitset.h.

◆ LeastSignificantBitPosition32Default()

int operations_research::LeastSignificantBitPosition32Default ( uint32  n)
inline

Definition at line 153 of file bitset.h.

◆ LeastSignificantBitPosition64() [1/2]

int64 operations_research::LeastSignificantBitPosition64 ( const uint64 *const  bitset,
uint64  start,
uint64  end 
)

◆ LeastSignificantBitPosition64() [2/2]

int operations_research::LeastSignificantBitPosition64 ( uint64  n)
inline

Definition at line 127 of file bitset.h.

◆ LeastSignificantBitPosition64DeBruijn()

int operations_research::LeastSignificantBitPosition64DeBruijn ( uint64  n)
inline

Definition at line 81 of file bitset.h.

◆ LeastSignificantBitPosition64Default()

int operations_research::LeastSignificantBitPosition64Default ( uint64  n)
inline

Definition at line 93 of file bitset.h.

◆ LeastSignificantBitWord32()

uint32 operations_research::LeastSignificantBitWord32 ( uint32  n)
inline

Definition at line 64 of file bitset.h.

◆ LeastSignificantBitWord64()

uint64 operations_research::LeastSignificantBitWord64 ( uint64  n)
inline

Definition at line 63 of file bitset.h.

◆ LegacyScipSetSolverSpecificParameters()

absl::Status LegacyScipSetSolverSpecificParameters ( const std::string &  parameters,
SCIP *  scip 
)

Definition at line 32 of file legacy_scip_params.cc.

◆ LinearConstraintIsViolated()

bool operations_research::LinearConstraintIsViolated ( const ScipConstraintHandlerContext context,
const LinearRange constraint 
)

Definition at line 94 of file scip_callback.cc.

◆ LinkVarExpr()

void LinkVarExpr ( Solver *const  s,
IntExpr *const  expr,
IntVar *const  var 
)

Definition at line 7396 of file expressions.cc.

◆ LoadGurobiEnvironment()

absl::Status LoadGurobiEnvironment ( GRBenv **  env)

Definition at line 26 of file gurobi_environment.cc.

◆ LoadGurobiFunctions()

void operations_research::LoadGurobiFunctions ( )

Definition at line 138 of file gurobi_environment.cc.

◆ LoadSpecificGurobiLibrary()

bool operations_research::LoadSpecificGurobiLibrary ( const std::string &  full_library_path)

Definition at line 204 of file gurobi_environment.cc.

◆ LocalOptimumReached()

bool LocalOptimumReached ( Search *const  search)

Definition at line 1344 of file constraint_solver.cc.

◆ MakeBareIntToIntFunction()

RangeIntToIntFunction * MakeBareIntToIntFunction ( std::function< int64(int64)>  f)

Definition at line 212 of file range_query_function.cc.

◆ MakeCachedIntToIntFunction()

RangeIntToIntFunction * MakeCachedIntToIntFunction ( const std::function< int64(int64)> &  f,
int64  domain_start,
int64  domain_end 
)

Definition at line 216 of file range_query_function.cc.

◆ MakeCachedRangeMinMaxIndexFunction()

RangeMinMaxIndexFunction * MakeCachedRangeMinMaxIndexFunction ( const std::function< int64(int64)> &  f,
int64  domain_start,
int64  domain_end 
)

Definition at line 222 of file range_query_function.cc.

◆ MakeConstraintDemon0()

Demon* operations_research::MakeConstraintDemon0 ( Solver *const  s,
T *const  ct,
void(T::*)()  method,
const std::string &  name 
)

Definition at line 525 of file constraint_solveri.h.

◆ MakeConstraintDemon1()

Demon* operations_research::MakeConstraintDemon1 ( Solver *const  s,
T *const  ct,
void(T::*)(P)  method,
const std::string &  name,
param1 
)

Definition at line 566 of file constraint_solveri.h.

◆ MakeConstraintDemon2()

Demon* operations_research::MakeConstraintDemon2 ( Solver *const  s,
T *const  ct,
void(T::*)(P, Q)  method,
const std::string &  name,
param1,
param2 
)

Definition at line 605 of file constraint_solveri.h.

◆ MakeConstraintDemon3()

Demon* operations_research::MakeConstraintDemon3 ( Solver *const  s,
T *const  ct,
void(T::*)(P, Q, R)  method,
const std::string &  name,
param1,
param2,
param3 
)

Definition at line 648 of file constraint_solveri.h.

◆ MakeCPFeasibilityFilter()

IntVarLocalSearchFilter * MakeCPFeasibilityFilter ( RoutingModel routing_model)

Definition at line 2747 of file routing_search.cc.

◆ MakeCumulBoundsPropagatorFilter()

IntVarLocalSearchFilter * MakeCumulBoundsPropagatorFilter ( const RoutingDimension dimension)

Definition at line 2578 of file routing_search.cc.

◆ MakeDelayedConstraintDemon0()

Demon* operations_research::MakeDelayedConstraintDemon0 ( Solver *const  s,
T *const  ct,
void(T::*)()  method,
const std::string &  name 
)

Definition at line 688 of file constraint_solveri.h.

◆ MakeDelayedConstraintDemon1()

Demon* operations_research::MakeDelayedConstraintDemon1 ( Solver *const  s,
T *const  ct,
void(T::*)(P)  method,
const std::string &  name,
param1 
)

Definition at line 724 of file constraint_solveri.h.

◆ MakeDelayedConstraintDemon2()

Demon* operations_research::MakeDelayedConstraintDemon2 ( Solver *const  s,
T *const  ct,
void(T::*)(P, Q)  method,
const std::string &  name,
param1,
param2 
)

Definition at line 768 of file constraint_solveri.h.

◆ MakeGlobalLPCumulFilter()

IntVarLocalSearchFilter * MakeGlobalLPCumulFilter ( GlobalDimensionCumulOptimizer optimizer,
bool  filter_objective_cost 
)

Definition at line 2682 of file routing_search.cc.

◆ MakeHamiltonianPathSolver()

HamiltonianPathSolver<CostType, CostFunction> operations_research::MakeHamiltonianPathSolver ( int  num_nodes,
CostFunction  cost 
)

Definition at line 599 of file hamiltonian_path.h.

◆ MakeLocalSearchOperator()

LocalSearchOperator * MakeLocalSearchOperator ( Solver solver,
const std::vector< IntVar * > &  vars,
const std::vector< IntVar * > &  secondary_vars,
std::function< int(int64)>  start_empty_path_class 
)

Operator Factories.

Definition at line 2277 of file local_search.cc.

◆ MakeMaxActiveVehiclesFilter()

IntVarLocalSearchFilter * MakeMaxActiveVehiclesFilter ( const RoutingModel routing_model)

Definition at line 111 of file routing_search.cc.

◆ MakeNodeDisjunctionFilter()

IntVarLocalSearchFilter * MakeNodeDisjunctionFilter ( const RoutingModel routing_model)

Definition at line 284 of file routing_search.cc.

◆ MakePathCumulFilter()

IntVarLocalSearchFilter * MakePathCumulFilter ( const RoutingDimension dimension,
const RoutingSearchParameters &  parameters,
bool  propagate_own_objective_value,
bool  filter_objective_cost,
bool  can_use_lp = true 
)

Definition at line 2071 of file routing_search.cc.

◆ MakePathStateFilter()

LocalSearchFilter * MakePathStateFilter ( Solver solver,
std::unique_ptr< PathState path_state,
const std::vector< IntVar * > &  nexts 
)

Definition at line 2953 of file local_search.cc.

◆ MakePickupDeliveryFilter()

IntVarLocalSearchFilter * MakePickupDeliveryFilter ( const RoutingModel routing_model,
const RoutingModel::IndexPairs pairs,
const std::vector< RoutingModel::PickupAndDeliveryPolicy > &  vehicle_policies 
)

Definition at line 2447 of file routing_search.cc.

◆ MakeSetValuesFromTargets()

DecisionBuilder * MakeSetValuesFromTargets ( Solver solver,
std::vector< IntVar * >  variables,
std::vector< int64 targets 
)

A decision builder which tries to assign values to variables as close as possible to target values first.

Definition at line 143 of file routing.cc.

◆ MakeTypeRegulationsFilter()

IntVarLocalSearchFilter * MakeTypeRegulationsFilter ( const RoutingModel routing_model)

Definition at line 818 of file routing_search.cc.

◆ MakeUnaryDimensionFilter()

LocalSearchFilter * MakeUnaryDimensionFilter ( Solver solver,
std::unique_ptr< UnaryDimensionChecker checker 
)

Definition at line 3196 of file local_search.cc.

◆ MakeVehicleAmortizedCostFilter()

IntVarLocalSearchFilter * MakeVehicleAmortizedCostFilter ( const RoutingModel routing_model)

Definition at line 669 of file routing_search.cc.

◆ MakeVehicleBreaksFilter()

IntVarLocalSearchFilter * MakeVehicleBreaksFilter ( const RoutingModel routing_model,
const RoutingDimension dimension 
)

Definition at line 1060 of file routing_breaks.cc.

◆ MakeVehicleVarFilter()

IntVarLocalSearchFilter * MakeVehicleVarFilter ( const RoutingModel routing_model)

Definition at line 2520 of file routing_search.cc.

◆ MaximizeLinearAssignment() [1/2]

void operations_research::MaximizeLinearAssignment ( const std::vector< std::vector< double > > &  cost,
absl::flat_hash_map< int, int > *  direct_assignment,
absl::flat_hash_map< int, int > *  reverse_assignment 
)

◆ MaximizeLinearAssignment() [2/2]

void operations_research::MaximizeLinearAssignment ( const std::vector< std::vector< double >> &  cost,
absl::flat_hash_map< int, int > *  direct_assignment,
absl::flat_hash_map< int, int > *  reverse_assignment 
)

Definition at line 675 of file hungarian.cc.

◆ MaxVarArray()

int64 operations_research::MaxVarArray ( const std::vector< IntVar * > &  vars)
inline

The std::max<int64> is needed for compilation on MSVC.

Definition at line 2964 of file constraint_solveri.h.

◆ MemoryUsage()

std::string MemoryUsage ( )

Definition at line 25 of file stats.cc.

◆ MergeMPConstraintProtoExceptTerms()

void MergeMPConstraintProtoExceptTerms ( const MPConstraintProto &  from,
MPConstraintProto *  to 
)

Definition at line 774 of file model_validator.cc.

◆ MinimizeLinearAssignment() [1/2]

void operations_research::MinimizeLinearAssignment ( const std::vector< std::vector< double > > &  cost,
absl::flat_hash_map< int, int > *  direct_assignment,
absl::flat_hash_map< int, int > *  reverse_assignment 
)

◆ MinimizeLinearAssignment() [2/2]

void operations_research::MinimizeLinearAssignment ( const std::vector< std::vector< double >> &  cost,
absl::flat_hash_map< int, int > *  direct_assignment,
absl::flat_hash_map< int, int > *  reverse_assignment 
)

Definition at line 657 of file hungarian.cc.

◆ MinVarArray()

int64 operations_research::MinVarArray ( const std::vector< IntVar * > &  vars)
inline

The std::min<int64> is needed for compilation on MSVC.

Definition at line 2974 of file constraint_solveri.h.

◆ mix() [1/2]

static void operations_research::mix ( uint32 a,
uint32 b,
uint32 c 
)
inlinestatic

Definition at line 28 of file hash.h.

◆ mix() [2/2]

static void operations_research::mix ( uint64 a,
uint64 b,
uint64 c 
)
inlinestatic

Definition at line 59 of file hash.h.

◆ MixTwoUInt64()

uint64 operations_research::MixTwoUInt64 ( uint64  fp1,
uint64  fp2 
)
inline

Definition at line 20 of file thorough_hash.h.

◆ MostSignificantBitPosition32() [1/2]

int operations_research::MostSignificantBitPosition32 ( const uint32 *const  bitset,
uint32  start,
uint32  end 
)

◆ MostSignificantBitPosition32() [2/2]

int operations_research::MostSignificantBitPosition32 ( uint32  n)
inline

Definition at line 273 of file bitset.h.

◆ MostSignificantBitPosition32Default()

int operations_research::MostSignificantBitPosition32Default ( uint32  n)
inline

Definition at line 249 of file bitset.h.

◆ MostSignificantBitPosition64() [1/2]

int64 operations_research::MostSignificantBitPosition64 ( const uint64 *const  bitset,
uint64  start,
uint64  end 
)

◆ MostSignificantBitPosition64() [2/2]

int operations_research::MostSignificantBitPosition64 ( uint64  n)
inline

Definition at line 231 of file bitset.h.

◆ MostSignificantBitPosition64Default()

int operations_research::MostSignificantBitPosition64Default ( uint64  n)
inline

Definition at line 203 of file bitset.h.

◆ MoveUpToDepth()

const KnapsackSearchNodeForCuts * MoveUpToDepth ( const KnapsackSearchNodeForCuts node,
int  depth 
)

Definition at line 94 of file knapsack_solver_for_cuts.cc.

◆ MPSolverResponseStatusIsRpcError()

bool MPSolverResponseStatusIsRpcError ( MPSolverResponseStatus  status)

Definition at line 1590 of file linear_solver.cc.

◆ MPSolverToGlopConstraintStatus()

glop::ConstraintStatus MPSolverToGlopConstraintStatus ( MPSolver::BasisStatus  s)

Definition at line 108 of file glop_utils.cc.

◆ MPSolverToGlopVariableStatus()

glop::VariableStatus MPSolverToGlopVariableStatus ( MPSolver::BasisStatus  s)

Definition at line 74 of file glop_utils.cc.

◆ NearestNeighbors()

std::set<std::pair<int, int> > operations_research::NearestNeighbors ( int  number_of_nodes,
int  number_of_neighbors,
const CostFunction &  cost 
)

Definition at line 262 of file one_tree_lower_bound.h.

◆ One()

int64 operations_research::One ( )
inline

This method returns 1.

Definition at line 3147 of file constraint_solver.h.

◆ OneBit32()

uint32 operations_research::OneBit32 ( int  pos)
inline

Definition at line 39 of file bitset.h.

◆ OneBit64()

uint64 operations_research::OneBit64 ( int  pos)
inline

Definition at line 38 of file bitset.h.

◆ OneRange32()

uint32 operations_research::OneRange32 ( uint32  s,
uint32  e 
)
inline

Definition at line 292 of file bitset.h.

◆ OneRange64()

uint64 operations_research::OneRange64 ( uint64  s,
uint64  e 
)
inline

Definition at line 285 of file bitset.h.

◆ operator*() [1/2]

LinearExpr operator* ( double  lhs,
LinearExpr  rhs 
)

Definition at line 162 of file linear_expr.cc.

◆ operator*() [2/2]

LinearExpr operator* ( LinearExpr  lhs,
double  rhs 
)

Definition at line 154 of file linear_expr.cc.

◆ operator+()

LinearExpr operator+ ( LinearExpr  lhs,
const LinearExpr rhs 
)

Definition at line 146 of file linear_expr.cc.

◆ operator-()

LinearExpr operator- ( LinearExpr  lhs,
const LinearExpr rhs 
)

Definition at line 150 of file linear_expr.cc.

◆ operator/()

LinearExpr operator/ ( LinearExpr  lhs,
double  rhs 
)

Definition at line 158 of file linear_expr.cc.

◆ operator<<() [1/9]

std::ostream& operations_research::operator<< ( std::ostream &  os,
MPSolver::OptimizationProblemType  optimization_problem_type 
)
inline

Definition at line 904 of file linear_solver.h.

◆ operator<<() [2/9]

std::ostream& operations_research::operator<< ( std::ostream &  os,
MPSolver::ResultStatus  status 
)
inline

Definition at line 910 of file linear_solver.h.

◆ operator<<() [3/9]

std::ostream & operator<< ( std::ostream &  out,
const Assignment assignment 
)

Definition at line 1089 of file constraint_solver/assignment.cc.

◆ operator<<() [4/9]

std::ostream & operator<< ( std::ostream &  out,
const BaseObject *const  o 
)

Definition at line 2498 of file constraint_solver.cc.

◆ operator<<() [5/9]

std::ostream & operator<< ( std::ostream &  out,
const ClosedInterval interval 
)

Definition at line 101 of file sorted_interval_list.cc.

◆ operator<<() [6/9]

std::ostream & operator<< ( std::ostream &  out,
const Domain domain 
)

Definition at line 110 of file sorted_interval_list.cc.

◆ operator<<() [7/9]

std::ostream & operator<< ( std::ostream &  out,
const Solver *const  s 
)

Definition at line 2493 of file constraint_solver.cc.

◆ operator<<() [8/9]

std::ostream & operator<< ( std::ostream &  out,
const std::vector< ClosedInterval > &  intervals 
)

Definition at line 105 of file sorted_interval_list.cc.

◆ operator<<() [9/9]

std::ostream & operator<< ( std::ostream &  stream,
const LinearExpr linear_expr 
)

Definition at line 141 of file linear_expr.cc.

◆ operator<=()

LinearRange operator<= ( const LinearExpr lhs,
const LinearExpr rhs 
)

Definition at line 177 of file linear_expr.cc.

◆ operator==()

LinearRange operator== ( const LinearExpr lhs,
const LinearExpr rhs 
)

Definition at line 180 of file linear_expr.cc.

◆ operator>=()

LinearRange operator>= ( const LinearExpr lhs,
const LinearExpr rhs 
)

Definition at line 183 of file linear_expr.cc.

◆ OrToolsMajorVersion()

int OrToolsMajorVersion ( )

Definition at line 18 of file version.cc.

◆ OrToolsMinorVersion()

int OrToolsMinorVersion ( )

Definition at line 19 of file version.cc.

◆ ParameterDebugString() [1/2]

std::string operations_research::ParameterDebugString ( P *  param)

Support limited to pointers to classes which define DebugString().

Definition at line 537 of file constraint_solveri.h.

◆ ParameterDebugString() [2/2]

std::string operations_research::ParameterDebugString ( param)

Definition at line 531 of file constraint_solveri.h.

◆ PortableDeleteFile()

absl::Status PortableDeleteFile ( absl::string_view  file_name)

Definition at line 55 of file file_nonport.cc.

◆ PortableFileGetContents()

absl::Status PortableFileGetContents ( absl::string_view  file_name,
std::string *  output 
)

Definition at line 32 of file file_nonport.cc.

◆ PortableFileSetContents()

absl::Status PortableFileSetContents ( absl::string_view  file_name,
absl::string_view  content 
)

Definition at line 27 of file file_nonport.cc.

◆ PortableTemporaryFile()

bool PortableTemporaryFile ( const char *  directory_prefix,
std::string *  filename_out 
)

Definition at line 37 of file file_nonport.cc.

◆ PosIntDivDown()

int64 operations_research::PosIntDivDown ( int64  e,
int64  v 
)
inline

Definition at line 2998 of file constraint_solveri.h.

◆ PosIntDivUp()

int64 operations_research::PosIntDivUp ( int64  e,
int64  v 
)
inline

Definition at line 2993 of file constraint_solveri.h.

◆ ProbablyRunningInsideUnitTest()

bool operations_research::ProbablyRunningInsideUnitTest ( )
inline

Definition at line 19 of file testing_utils.h.

◆ ProtobufDebugString()

std::string operations_research::ProtobufDebugString ( const P &  message)

Definition at line 53 of file port/proto_utils.h.

◆ ProtobufShortDebugString()

std::string operations_research::ProtobufShortDebugString ( const P &  message)

Definition at line 58 of file port/proto_utils.h.

◆ ProtobufTextFormatMergeFromString()

bool operations_research::ProtobufTextFormatMergeFromString ( const std::string &  proto_text_string,
ProtoType *  proto 
)

Definition at line 75 of file port/proto_utils.h.

◆ ProtoEnumToString()

std::string operations_research::ProtoEnumToString ( ProtoEnumType  enum_value)

Definition at line 63 of file port/proto_utils.h.

◆ RationalApproximation()

Fraction RationalApproximation ( const double  x,
const double  precision 
)

Definition at line 26 of file rational_approximation.cc.

◆ ReadAllRecordsOrDie() [1/2]

std::vector<Proto> operations_research::ReadAllRecordsOrDie ( absl::string_view  filename)

Definition at line 102 of file file_util.h.

◆ ReadAllRecordsOrDie() [2/2]

std::vector<Proto> operations_research::ReadAllRecordsOrDie ( File file)

Definition at line 106 of file file_util.h.

◆ ReadFileToProto()

bool ReadFileToProto ( absl::string_view  filename,
google::protobuf::Message *  proto 
)

Definition at line 43 of file file_util.cc.

◆ ReadFileToProtoOrDie()

Proto operations_research::ReadFileToProtoOrDie ( absl::string_view  filename)

Definition at line 41 of file file_util.h.

◆ ReadFileToString()

absl::StatusOr< std::string > ReadFileToString ( absl::string_view  filename)

Definition at line 32 of file file_util.cc.

◆ ReadOneRecordOrDie()

Proto operations_research::ReadOneRecordOrDie ( absl::string_view  filename)

Definition at line 114 of file file_util.h.

◆ RealDebugString()

void operations_research::RealDebugString ( const Container &  container,
std::string *const  out 
)

Definition at line 614 of file constraint_solver/assignment.cc.

◆ RealLoad()

void operations_research::RealLoad ( const AssignmentProto &  assignment_proto,
Container *const  container,
int(AssignmentProto::*)() const  GetSize,
const Proto &(AssignmentProto::*)(int) const  GetElem 
)

Definition at line 503 of file constraint_solver/assignment.cc.

◆ RealSave()

void operations_research::RealSave ( AssignmentProto *const  assignment_proto,
const Container &  container,
Proto *(AssignmentProto::*)()  Add 
)

Definition at line 575 of file constraint_solver/assignment.cc.

◆ RegisterConstraintHandler() [1/2]

void operations_research::RegisterConstraintHandler ( ScipConstraintHandler< Constraint > *  handler,
SCIP *  scip 
)

◆ RegisterConstraintHandler() [2/2]

void operations_research::RegisterConstraintHandler ( ScipConstraintHandler< ConstraintData > *  handler,
SCIP *  scip 
)

Definition at line 255 of file scip_callback.h.

◆ RegisterDemon()

void operations_research::RegisterDemon ( Solver *const  solver,
Demon *const  demon,
DemonProfiler *const  monitor 
)

Definition at line 460 of file demon_profiler.cc.

◆ RestoreBoolValue()

void RestoreBoolValue ( IntVar *const  var)

Definition at line 6347 of file expressions.cc.

◆ RunSeparation()

ScipSeparationResult operations_research::RunSeparation ( internal::ScipCallbackRunner runner,
const ScipConstraintHandlerContext context,
absl::Span< SCIP_CONS * >  constraints,
bool  is_integral 
)

Definition at line 111 of file scip_callback.cc.

◆ RunWorker()

void operations_research::RunWorker ( void *  data)

Definition at line 19 of file threadpool.cc.

◆ SafeAddInto()

bool operations_research::SafeAddInto ( IntegerType  a,
IntegerType *  b 
)

Definition at line 87 of file saturated_arithmetic.h.

◆ SafeProtoConstDownCast()

absl::StatusOr< const Proto * > SafeProtoConstDownCast ( const google::protobuf::Message *  proto)

Definition at line 60 of file proto_tools.h.

◆ SafeProtoDownCast()

absl::StatusOr< Proto * > SafeProtoDownCast ( google::protobuf::Message *  proto)

Definition at line 47 of file proto_tools.h.

◆ SatSolveProto()

absl::StatusOr< MPSolutionResponse > SatSolveProto ( MPModelRequest  request,
std::atomic< bool > *  interrupt_solve 
)

Definition at line 66 of file sat_proto_solver.cc.

◆ ScipSolveProto()

absl::StatusOr< MPSolutionResponse > ScipSolveProto ( const MPModelRequest &  request)

Definition at line 657 of file scip_proto_solver.cc.

◆ SearchForGurobiDynamicLibrary()

bool operations_research::SearchForGurobiDynamicLibrary ( )

Definition at line 215 of file gurobi_environment.cc.

◆ SetAssignmentFromAssignment()

void SetAssignmentFromAssignment ( Assignment target_assignment,
const std::vector< IntVar * > &  target_vars,
const Assignment source_assignment,
const std::vector< IntVar * > &  source_vars 
)

NOLINT.

Given a "source_assignment", clears the "target_assignment" and adds all IntVars in "target_vars", with the values of the variables set according to the corresponding values of "source_vars" in "source_assignment". source_vars and target_vars must have the same number of elements. The source and target assignments can belong to different Solvers.

Definition at line 1016 of file constraint_solver/assignment.cc.

◆ SetBit32()

void operations_research::SetBit32 ( uint32 *const  bitset,
uint32  pos 
)
inline

Definition at line 357 of file bitset.h.

◆ SetBit64()

void operations_research::SetBit64 ( uint64 *const  bitset,
uint64  pos 
)
inline

Definition at line 354 of file bitset.h.

◆ SetFirstSolutionStrategyFromFlags()

void operations_research::SetFirstSolutionStrategyFromFlags ( RoutingSearchParameters *  parameters)

Definition at line 135 of file routing_flags.cc.

◆ SetIsEqual()

Constraint* operations_research::SetIsEqual ( IntVar *const  var,
const std::vector< int64 > &  values,
const std::vector< IntVar * > &  vars 
)

Definition at line 6332 of file expressions.cc.

◆ SetIsGreaterOrEqual()

Constraint* operations_research::SetIsGreaterOrEqual ( IntVar *const  var,
const std::vector< int64 > &  values,
const std::vector< IntVar * > &  vars 
)

Definition at line 6339 of file expressions.cc.

◆ SetLocalSearchMetaheuristicFromFlags()

void operations_research::SetLocalSearchMetaheuristicFromFlags ( RoutingSearchParameters *  parameters)

Definition at line 179 of file routing_flags.cc.

◆ SetMiscellaneousParametersFromFlags()

void operations_research::SetMiscellaneousParametersFromFlags ( RoutingSearchParameters *  parameters)

Definition at line 300 of file routing_flags.cc.

◆ SetSearchLimitsFromFlags()

void operations_research::SetSearchLimitsFromFlags ( RoutingSearchParameters *  parameters)

Definition at line 278 of file routing_flags.cc.

◆ SetSolverSpecificParameters()

absl::Status SetSolverSpecificParameters ( const std::string &  parameters,
GRBenv gurobi 
)

Definition at line 222 of file gurobi_proto_solver.cc.

◆ SolveModelWithSat()

bool SolveModelWithSat ( const RoutingModel model,
const RoutingSearchParameters &  search_parameters,
const Assignment initial_solution,
Assignment solution 
)

Attempts to solve the model using the cp-sat solver.

As of 5/2019, will solve the TSP corresponding to the model if it has a single vehicle. Therefore the resulting solution might not actually be feasible. Will return false if a solution could not be found.

Definition at line 505 of file routing_sat.cc.

◆ SolverTypeIsMip() [1/2]

bool SolverTypeIsMip ( MPModelRequest::SolverType  solver_type)

Definition at line 65 of file linear_solver.cc.

◆ SolverTypeIsMip() [2/2]

bool operations_research::SolverTypeIsMip ( MPSolver::OptimizationProblemType  solver_type)
inline

Definition at line 897 of file linear_solver.h.

◆ StableDijkstraShortestPath()

bool StableDijkstraShortestPath ( int  node_count,
int  start_node,
int  end_node,
std::function< int64(int, int)>  graph,
int64  disconnected_distance,
std::vector< int > *  nodes 
)

Definition at line 156 of file dijkstra.cc.

◆ SubHadOverflow()

bool operations_research::SubHadOverflow ( int64  x,
int64  y,
int64  diff 
)
inline

Definition at line 61 of file saturated_arithmetic.h.

◆ SubOverflows()

int64 operations_research::SubOverflows ( int64  x,
int64  y 
)
inline

Definition at line 80 of file saturated_arithmetic.h.

◆ SumOfKMaxValueInDomain()

int64 SumOfKMaxValueInDomain ( const Domain domain,
int  k 
)

Definition at line 559 of file sorted_interval_list.cc.

◆ SumOfKMinValueInDomain()

int64 SumOfKMinValueInDomain ( const Domain domain,
int  k 
)

Definition at line 545 of file sorted_interval_list.cc.

◆ TEST() [1/5]

operations_research::TEST ( LinearAssignmentTest  ,
NullMatrix   
)

Definition at line 60 of file hungarian_test.cc.

◆ TEST() [2/5]

operations_research::TEST ( LinearAssignmentTest  ,
SizeOneMatrix   
)

Definition at line 90 of file hungarian_test.cc.

◆ TEST() [3/5]

operations_research::TEST ( LinearAssignmentTest  ,
Small3x4Matrix   
)

Definition at line 118 of file hungarian_test.cc.

◆ TEST() [4/5]

operations_research::TEST ( LinearAssignmentTest  ,
Small4x3Matrix   
)

Definition at line 131 of file hungarian_test.cc.

◆ TEST() [5/5]

operations_research::TEST ( LinearAssignmentTest  ,
Small4x4Matrix   
)

Definition at line 103 of file hungarian_test.cc.

◆ TestMaximization()

void operations_research::TestMaximization ( const std::vector< std::vector< double > > &  cost,
const int  expected_assignment_size,
const int  expected_agents[],
const int  expected_tasks[] 
)

Definition at line 47 of file hungarian_test.cc.

◆ TestMinimization()

void operations_research::TestMinimization ( const std::vector< std::vector< double > > &  cost,
const int  expected_assignment_size,
const int  expected_agents[],
const int  expected_tasks[] 
)

Definition at line 36 of file hungarian_test.cc.

◆ ThoroughHash()

uint64 operations_research::ThoroughHash ( const char *  bytes,
size_t  len 
)
inline

Definition at line 33 of file thorough_hash.h.

◆ ToInt64Vector()

std::vector< int64 > ToInt64Vector ( const std::vector< int > &  input)

Definition at line 822 of file utilities.cc.

◆ ToString() [1/2]

std::string ToString ( MPCallbackEvent  event)

Definition at line 20 of file linear_solver_callback.cc.

◆ ToString() [2/2]

const absl::string_view ToString ( MPSolver::OptimizationProblemType  optimization_problem_type)

Definition at line 569 of file linear_solver.cc.

◆ TwoBitsFromPos64()

uint64 operations_research::TwoBitsFromPos64 ( uint64  pos)
inline

Definition at line 402 of file bitset.h.

◆ TwosComplementAddition()

int64 operations_research::TwosComplementAddition ( int64  x,
int64  y 
)
inline

Definition at line 38 of file saturated_arithmetic.h.

◆ TwosComplementSubtraction()

int64 operations_research::TwosComplementSubtraction ( int64  x,
int64  y 
)
inline

Definition at line 44 of file saturated_arithmetic.h.

◆ UnsafeLeastSignificantBitPosition32()

int32 operations_research::UnsafeLeastSignificantBitPosition32 ( const uint32 *const  bitset,
uint32  start,
uint32  end 
)

◆ UnsafeLeastSignificantBitPosition64()

int64 operations_research::UnsafeLeastSignificantBitPosition64 ( const uint64 *const  bitset,
uint64  start,
uint64  end 
)

◆ UnsafeMostSignificantBitPosition32()

int32 operations_research::UnsafeMostSignificantBitPosition32 ( const uint32 *const  bitset,
uint32  start,
uint32  end 
)

◆ UnsafeMostSignificantBitPosition64()

int64 operations_research::UnsafeMostSignificantBitPosition64 ( const uint64 *const  bitset,
uint64  start,
uint64  end 
)

◆ WriteProtoToFile()

bool WriteProtoToFile ( absl::string_view  filename,
const google::protobuf::Message &  proto,
ProtoWriteFormat  proto_write_format,
bool  gzipped,
bool  append_extension_to_file_name 
)

Definition at line 102 of file file_util.cc.

◆ WriteRecordsOrDie()

void operations_research::WriteRecordsOrDie ( absl::string_view  filename,
const std::vector< Proto > &  protos 
)

Definition at line 123 of file file_util.h.

◆ Zero()

int64 operations_research::Zero ( )
inline

NOLINT.

This method returns 0. It is useful when 0 can be cast either as a pointer or as an integer value and thus lead to an ambiguous function call.

Definition at line 3144 of file constraint_solver.h.

Variable Documentation

◆ GRBaddconstr

std::function< int(GRBmodel *model, int numnz, int *cind, double *cval, char sense, double rhs, const char *constrname)> GRBaddconstr = nullptr

Definition at line 98 of file gurobi_environment.cc.

◆ GRBaddgenconstrAbs

std::function< int(GRBmodel *model, const char *name, int resvar, int argvar)> GRBaddgenconstrAbs = nullptr

Definition at line 124 of file gurobi_environment.cc.

◆ GRBaddgenconstrAnd

std::function< int(GRBmodel *model, const char *name, int resvar, int nvars, const int *vars)> GRBaddgenconstrAnd = nullptr

Definition at line 127 of file gurobi_environment.cc.

◆ GRBaddgenconstrIndicator

std::function< int(GRBmodel *model, const char *name, int binvar, int binval, int nvars, const int *vars, const double *vals, char sense, double rhs)> GRBaddgenconstrIndicator = nullptr

Definition at line 102 of file gurobi_environment.cc.

◆ GRBaddgenconstrMax

std::function< int(GRBmodel *model, const char *name, int resvar, int nvars, const int *vars, double constant)> GRBaddgenconstrMax = nullptr

Definition at line 119 of file gurobi_environment.cc.

◆ GRBaddgenconstrMin

std::function< int(GRBmodel *model, const char *name, int resvar, int nvars, const int *vars, double constant)> GRBaddgenconstrMin = nullptr

Definition at line 122 of file gurobi_environment.cc.

◆ GRBaddgenconstrOr

std::function< int(GRBmodel *model, const char *name, int resvar, int nvars, const int *vars)> GRBaddgenconstrOr = nullptr

Definition at line 130 of file gurobi_environment.cc.

◆ GRBaddqconstr

std::function< int(GRBmodel *model, int numlnz, int *lind, double *lval, int numqnz, int *qrow, int *qcol, double *qval, char sense, double rhs, const char *QCname)> GRBaddqconstr = nullptr

Definition at line 116 of file gurobi_environment.cc.

◆ GRBaddqpterms

std::function< int(GRBmodel *model, int numqnz, int *qrow, int *qcol, double *qval)> GRBaddqpterms = nullptr

Definition at line 133 of file gurobi_environment.cc.

◆ GRBaddrangeconstr

std::function< int(GRBmodel *, int, int *, double *, double, double, const char *)> GRBaddrangeconstr = nullptr

Definition at line 40 of file gurobi_environment.cc.

◆ GRBaddsos

std::function< int(GRBmodel *model, int numsos, int nummembers, int *types, int *beg, int *ind, double *weight)> GRBaddsos = nullptr

Definition at line 112 of file gurobi_environment.cc.

◆ GRBaddvar

std::function< int(GRBmodel *model, int numnz, int *vind, double *vval, double obj, double lb, double ub, char vtype, const char *varname)> GRBaddvar = nullptr

Definition at line 44 of file gurobi_environment.cc.

◆ GRBaddvars

std::function< int(GRBmodel *, int, int, int *, int *, double *, double *, double *, double *, char *, char **)> GRBaddvars = nullptr

Definition at line 47 of file gurobi_environment.cc.

◆ GRBcbcut

std::function< int(void *cbdata, int cutlen, const int *cutind, const double *cutval, char cutsense, double cutrhs)> GRBcbcut = nullptr

Definition at line 90 of file gurobi_environment.cc.

◆ GRBcbget

std::function< int(void *cbdata, int where, int what, void *resultP)> GRBcbget
Initial value:
=
nullptr

Definition at line 86 of file gurobi_environment.cc.

◆ GRBcblazy

std::function< int(void *cbdata, int lazylen, const int *lazyind, const double *lazyval, char lazysense, double lazyrhs)> GRBcblazy = nullptr

Definition at line 93 of file gurobi_environment.cc.

◆ GRBcbsolution

std::function< int(void *cbdata, const double *solution, double *objvalP)> GRBcbsolution = nullptr

Definition at line 95 of file gurobi_environment.cc.

◆ GRBchgcoeffs

std::function< int(GRBmodel *model, int numchgs, int *cind, int *vind, double *val)> GRBchgcoeffs = nullptr

Definition at line 50 of file gurobi_environment.cc.

◆ GRBcopyparams

std::function< int(GRBenv *dest, GRBenv *src)> GRBcopyparams = nullptr

Definition at line 71 of file gurobi_environment.cc.

◆ GRBfreeenv

std::function< void(GRBenv *)> GRBfreeenv = nullptr

Definition at line 51 of file gurobi_environment.cc.

◆ GRBfreemodel

std::function< int(GRBmodel *)> GRBfreemodel = nullptr

Definition at line 52 of file gurobi_environment.cc.

◆ GRBgetcharattrelement

std::function< int(GRBmodel *, const char *, int, char *)> GRBgetcharattrelement
Initial value:
=
nullptr

Definition at line 53 of file gurobi_environment.cc.

◆ GRBgetdblattr

std::function< int(GRBmodel *, const char *, double *)> GRBgetdblattr = nullptr

Definition at line 55 of file gurobi_environment.cc.

◆ GRBgetdblattrarray

std::function< int(GRBmodel *, const char *, int, int, double *)> GRBgetdblattrarray = nullptr

Definition at line 57 of file gurobi_environment.cc.

◆ GRBgetdblattrelement

std::function< int(GRBmodel *, const char *, int, double *)> GRBgetdblattrelement
Initial value:
=
nullptr

Definition at line 58 of file gurobi_environment.cc.

◆ GRBgetdblparam

std::function< int(GRBenv *, const char *, double *)> GRBgetdblparam = nullptr

Definition at line 60 of file gurobi_environment.cc.

◆ GRBgetenv

std::function< GRBenv *(GRBmodel *)> GRBgetenv = nullptr

Definition at line 61 of file gurobi_environment.cc.

◆ GRBgeterrormsg

std::function< char *(GRBenv *)> GRBgeterrormsg = nullptr

Definition at line 62 of file gurobi_environment.cc.

◆ GRBgetintattr

std::function< int(GRBmodel *, const char *, int *)> GRBgetintattr = nullptr

Definition at line 63 of file gurobi_environment.cc.

◆ GRBgetintattrelement

std::function< int(GRBmodel *, const char *, int, int *)> GRBgetintattrelement
Initial value:
=
nullptr

Definition at line 64 of file gurobi_environment.cc.

◆ GRBloadenv

std::function< int(GRBenv **, const char *)> GRBloadenv = nullptr

Definition at line 66 of file gurobi_environment.cc.

◆ GRBnewmodel

std::function< int(GRBenv *, GRBmodel **, const char *, int numvars, double *, double *, double *, char *, char **)> GRBnewmodel = nullptr

Definition at line 69 of file gurobi_environment.cc.

◆ GRBoptimize

std::function< int(GRBmodel *)> GRBoptimize = nullptr

Definition at line 70 of file gurobi_environment.cc.

◆ GRBreadparams

std::function< int(GRBenv *, const char *)> GRBreadparams = nullptr

Definition at line 72 of file gurobi_environment.cc.

◆ GRBresetparams

std::function< int(GRBenv *)> GRBresetparams = nullptr

Definition at line 73 of file gurobi_environment.cc.

◆ GRBsetcallbackfunc

std::function< int(GRBmodel *model, int(STDCALL *cb)(CB_ARGS), void *usrdata)> GRBsetcallbackfunc = nullptr

Definition at line 107 of file gurobi_environment.cc.

◆ GRBsetcharattrelement

std::function< int(GRBmodel *, const char *, int, char)> GRBsetcharattrelement
Initial value:
=
nullptr

Definition at line 74 of file gurobi_environment.cc.

◆ GRBsetdblattr

std::function< int(GRBmodel *, const char *, double)> GRBsetdblattr = nullptr

Definition at line 76 of file gurobi_environment.cc.

◆ GRBsetdblattrelement

std::function< int(GRBmodel *, const char *, int, double)> GRBsetdblattrelement
Initial value:
=
nullptr

Definition at line 77 of file gurobi_environment.cc.

◆ GRBsetdblparam

std::function< int(GRBenv *, const char *, double)> GRBsetdblparam = nullptr

Definition at line 79 of file gurobi_environment.cc.

◆ GRBsetintattr

std::function< int(GRBmodel *, const char *, int)> GRBsetintattr = nullptr

Definition at line 80 of file gurobi_environment.cc.

◆ GRBsetintattrelement

std::function< int(GRBmodel *model, const char *attrname, int element, int newvalue)> GRBsetintattrelement = nullptr

Definition at line 105 of file gurobi_environment.cc.

◆ GRBsetintparam

std::function< int(GRBenv *, const char *, int)> GRBsetintparam = nullptr

Definition at line 81 of file gurobi_environment.cc.

◆ GRBsetparam

std::function< int(GRBenv *env, const char *paramname, const char *value)> GRBsetparam = nullptr

Definition at line 109 of file gurobi_environment.cc.

◆ GRBterminate

std::function< void(GRBmodel *)> GRBterminate = nullptr

Definition at line 82 of file gurobi_environment.cc.

◆ GRBupdatemodel

std::function< int(GRBmodel *)> GRBupdatemodel = nullptr

Definition at line 83 of file gurobi_environment.cc.

◆ GRBversion

std::function< void(int *, int *, int *)> GRBversion = nullptr

Definition at line 84 of file gurobi_environment.cc.

◆ GRBwrite

std::function< int(GRBmodel *, const char *)> GRBwrite = nullptr

Definition at line 85 of file gurobi_environment.cc.

◆ gurobi_dynamic_library

std::unique_ptr<DynamicLibrary> gurobi_dynamic_library

Definition at line 135 of file gurobi_environment.cc.

◆ gurobi_library_path

std::string gurobi_library_path

Definition at line 136 of file gurobi_environment.cc.

◆ kAllBits32

const uint32 kAllBits32 = 0xFFFFFFFFU
static

Definition at line 35 of file bitset.h.

◆ kAllBits64

const uint64 kAllBits64 = uint64_t{0xFFFFFFFFFFFFFFFF}
static

Definition at line 33 of file bitset.h.

◆ kAllBitsButLsb64

const uint64 kAllBitsButLsb64 = uint64_t{0xFFFFFFFFFFFFFFFE}
static

Definition at line 34 of file bitset.h.

◆ kDefaultPrimalTolerance

constexpr double kDefaultPrimalTolerance = 1e-07
constexpr

Definition at line 165 of file linear_solver.h.

◆ kOptimizationProblemTypeNames

constexpr NamedOptimizationProblemType kOptimizationProblemTypeNames[]
constexpr
Initial value:
= {
{MPSolver::GLOP_LINEAR_PROGRAMMING, "glop"},
{MPSolver::CLP_LINEAR_PROGRAMMING, "clp"},
{MPSolver::GUROBI_LINEAR_PROGRAMMING, "gurobi_lp"},
{MPSolver::GLPK_LINEAR_PROGRAMMING, "glpk_lp"},
{MPSolver::CPLEX_LINEAR_PROGRAMMING, "cplex_lp"},
{MPSolver::XPRESS_LINEAR_PROGRAMMING, "xpress_lp"},
{MPSolver::SCIP_MIXED_INTEGER_PROGRAMMING, "scip"},
{MPSolver::CBC_MIXED_INTEGER_PROGRAMMING, "cbc"},
{MPSolver::SAT_INTEGER_PROGRAMMING, "sat"},
{MPSolver::BOP_INTEGER_PROGRAMMING, "bop"},
{MPSolver::GUROBI_MIXED_INTEGER_PROGRAMMING, "gurobi"},
{MPSolver::GLPK_MIXED_INTEGER_PROGRAMMING, "glpk"},
{MPSolver::KNAPSACK_MIXED_INTEGER_PROGRAMMING, "knapsack"},
{MPSolver::CPLEX_MIXED_INTEGER_PROGRAMMING, "cplex"},
{MPSolver::XPRESS_MIXED_INTEGER_PROGRAMMING, "xpress"},
}

Definition at line 513 of file linear_solver.cc.

◆ kUnassigned

const int kUnassigned = -1
static

Definition at line 638 of file routing.cc.

◆ LinkComparator

struct operations_research::LinkSort LinkComparator

◆ SweepIndexAngleComparator

struct operations_research::SweepIndexSortAngle SweepIndexAngleComparator

◆ SweepIndexDistanceComparator

struct operations_research::SweepIndexSortDistance SweepIndexDistanceComparator