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

namespace  bop
 
namespace  cap_prod_util
 
namespace  data
 
namespace  fz
 
namespace  glop
 
namespace  internal
 
namespace  or_internal
 
namespace  sat
 
namespace  scp
 
namespace  sysinfo
 
namespace  utf8
 

Classes

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

enum class BronKerboschAlgorithmStatus
strong
Enumerator
COMPLETED 
INTERRUPTED 

Definition at line 68 of file cliques.h.

◆ CliqueResponse

enum class CliqueResponse
strong
Enumerator
CONTINUE 
STOP 

Definition at line 58 of file cliques.h.

◆ DimensionSchedulingStatus

enum class DimensionSchedulingStatus
strong
Enumerator
OPTIMAL 
RELAXED_OPTIMAL_ONLY 
INFEASIBLE 

Definition at line 126 of file routing_lp_scheduling.h.

◆ GScipHintResult

enum class GScipHintResult
strong
Enumerator
kInfeasible 
kRejected 
kAccepted 

Definition at line 444 of file gscip.h.

◆ GScipVarType

enum class GScipVarType
strong
Enumerator
kContinuous 
kInteger 
kImpliedInteger 

Definition at line 103 of file gscip.h.

◆ MPCallbackEvent

enum class 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 class ProtoWriteFormat
strong
Enumerator
kProtoText 
kProtoBinary 
kJson 

Definition at line 47 of file file_util.h.

◆ ScipSeparationResult

enum class 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 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 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 AddHadOverflow ( int64  x,
int64  y,
int64  sum 
)
inline

Definition at line 52 of file saturated_arithmetic.h.

◆ AddLocalSearchNeighborhoodOperatorsFromFlags()

void AddLocalSearchNeighborhoodOperatorsFromFlags ( RoutingSearchParameters *  parameters)

Definition at line 202 of file routing_flags.cc.

◆ AddOverflows()

bool 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 AreAllBooleans ( const std::vector< IntVar * > &  vars)
inline

Definition at line 2937 of file constraint_solveri.h.

◆ AreAllBound()

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

Definition at line 2928 of file constraint_solveri.h.

◆ AreAllBoundOrNull()

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.

Definition at line 2944 of file constraint_solveri.h.

◆ AreAllBoundTo()

bool 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 AreAllGreaterOrEqual ( const std::vector< T > &  values,
const T &  value 
)

Definition at line 2858 of file constraint_solveri.h.

◆ AreAllLessOrEqual()

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

Definition at line 2868 of file constraint_solveri.h.

◆ AreAllNegative()

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

Definition at line 2883 of file constraint_solveri.h.

◆ AreAllNull()

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

Definition at line 2853 of file constraint_solveri.h.

◆ AreAllOnes()

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

Definition at line 2848 of file constraint_solveri.h.

◆ AreAllPositive()

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

Definition at line 2878 of file constraint_solveri.h.

◆ AreAllStrictlyNegative()

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

Definition at line 2893 of file constraint_solveri.h.

◆ AreAllStrictlyPositive()

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

Definition at line 2888 of file constraint_solveri.h.

◆ AreWithinAbsoluteOrRelativeTolerances()

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

Definition at line 120 of file fp_utils.h.

◆ AreWithinAbsoluteTolerance()

bool 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 BitCount32 ( uint32  n)
inline

Definition at line 53 of file bitset.h.

◆ BitCount64()

uint64 BitCount64 ( uint64  n)
inline

Definition at line 42 of file bitset.h.

◆ BitCountRange32()

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

◆ BitCountRange64()

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

◆ BitLength32()

uint32 BitLength32 ( uint32  size)
inline

Definition at line 339 of file bitset.h.

◆ BitLength64()

uint64 BitLength64 ( uint64  size)
inline

Definition at line 338 of file bitset.h.

◆ BitOffset32()

uint32 BitOffset32 ( uint32  pos)
inline

Definition at line 335 of file bitset.h.

◆ BitOffset64()

uint64 BitOffset64 ( uint64  pos)
inline

Definition at line 334 of file bitset.h.

◆ BitPos32()

uint32 BitPos32 ( uint32  pos)
inline

Definition at line 331 of file bitset.h.

◆ BitPos64()

uint32 BitPos64 ( uint64  pos)
inline

Definition at line 330 of file bitset.h.

◆ BitShift32()

uint32 BitShift32 ( uint32  v)
inline

Definition at line 343 of file bitset.h.

◆ BitShift64()

uint64 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 > BuildEulerianPath ( const Graph &  graph)

Definition at line 138 of file eulerian_path.h.

◆ BuildEulerianPathFromNode()

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

Definition at line 74 of file eulerian_path.h.

◆ BuildEulerianTour()

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

Definition at line 128 of file eulerian_path.h.

◆ BuildEulerianTourFromNode()

std::vector< NodeIndex > 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 > BuildKruskalMinimumSpanningTree ( const Graph &  graph,
const ArcComparator &  arc_comparator 
)

Definition at line 89 of file minimum_spanning_tree.h.

◆ BuildKruskalMinimumSpanningTreeFromSortedArcs()

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

Definition at line 50 of file minimum_spanning_tree.h.

◆ BuildLineGraph()

bool 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 > 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 CapAdd ( int64  x,
int64  y 
)
inline

Definition at line 124 of file saturated_arithmetic.h.

◆ CapAddGeneric()

int64 CapAddGeneric ( int64  x,
int64  y 
)
inline

Definition at line 102 of file saturated_arithmetic.h.

◆ CapOpp()

int64 CapOpp ( int64  v)
inline

Definition at line 163 of file saturated_arithmetic.h.

◆ CapProd()

int64 CapProd ( int64  x,
int64  y 
)
inline

Definition at line 231 of file saturated_arithmetic.h.

◆ CapProdGeneric()

int64 CapProdGeneric ( int64  x,
int64  y 
)
inline

Definition at line 180 of file saturated_arithmetic.h.

◆ CapSub()

int64 CapSub ( int64  x,
int64  y 
)
inline

Definition at line 154 of file saturated_arithmetic.h.

◆ CapSubGeneric()

int64 CapSubGeneric ( int64  x,
int64  y 
)
inline

Definition at line 132 of file saturated_arithmetic.h.

◆ CapWithSignOf()

int64 CapWithSignOf ( int64  x)
inline

Definition at line 97 of file saturated_arithmetic.h.

◆ CeilRatio()

int64 CeilRatio ( int64  value,
int64  positive_coeff 
)

Definition at line 87 of file sorted_interval_list.cc.

◆ ChooseMode()

BaseAssignVariables::Mode 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 ClearBit32 ( uint32 *const  bitset,
uint32  pos 
)
inline

Definition at line 365 of file bitset.h.

◆ ClearBit64()

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

Definition at line 362 of file bitset.h.

◆ CompareKnapsackItemWithEfficiencyInDecreasingEfficiencyOrder()

bool 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 > > > 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 > > > ComputeMinimumWeightMatchingWithMIP ( const GraphType &  graph,
const WeightFunctionType &  weight 
)

Definition at line 145 of file christofides.h.

◆ ComputeOneTree()

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 
)

Definition at line 331 of file one_tree_lower_bound.h.

◆ ComputeOneTreeLowerBound()

double ComputeOneTreeLowerBound ( int  number_of_nodes,
const CostFunction &  cost 
)

Definition at line 480 of file one_tree_lower_bound.h.

◆ ComputeOneTreeLowerBoundWithAlgorithm()

double 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 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 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 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]

DEFINE_INT_TYPE ( RoutingCostClassIndex  ,
int   
)

◆ DEFINE_INT_TYPE() [2/5]

DEFINE_INT_TYPE ( RoutingDimensionIndex  ,
int   
)

◆ DEFINE_INT_TYPE() [3/5]

DEFINE_INT_TYPE ( RoutingDisjunctionIndex  ,
int   
)

◆ DEFINE_INT_TYPE() [4/5]

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]

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 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 DemonProfilerBeginInitialPropagation ( DemonProfiler *const  monitor,
Constraint *const  constraint 
)

Definition at line 482 of file demon_profiler.cc.

◆ DemonProfilerEndInitialPropagation()

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

Definition at line 487 of file demon_profiler.cc.

◆ DemonProfilerExportInformation()

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 
)

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 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 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 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 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 Hash1 ( const std::vector< int64 > &  ptrs)
inline

Definition at line 268 of file constraint_solveri.h.

◆ Hash1() [2/7]

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

Definition at line 258 of file constraint_solveri.h.

◆ Hash1() [3/7]

uint64 Hash1 ( int  value)
inline

Definition at line 246 of file constraint_solveri.h.

◆ Hash1() [4/7]

uint64 Hash1 ( int64  value)
inline

Definition at line 244 of file constraint_solveri.h.

◆ Hash1() [5/7]

uint64 Hash1 ( uint32  value)
inline

Definition at line 233 of file constraint_solveri.h.

◆ Hash1() [6/7]

uint64 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 Hash1 ( void *const  ptr)
inline

Definition at line 248 of file constraint_solveri.h.

◆ Hash32NumWithSeed()

uint32 Hash32NumWithSeed ( uint32  num,
uint32  c 
)
inline

Definition at line 97 of file hash.h.

◆ Hash64NumWithSeed()

uint64 Hash64NumWithSeed ( uint64  num,
uint64  c 
)
inline

Definition at line 103 of file hash.h.

◆ HasUnaryDimension()

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

Definition at line 4724 of file routing.cc.

◆ IncrementalSort() [1/2]

void 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 IncrementalSort ( Iterator  begin,
Iterator  end,
Compare  comp = Compare{},
bool  is_stable = false 
)

Definition at line 129 of file sort.h.

◆ InputContainsNan()

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

Definition at line 645 of file hungarian.cc.

◆ InsertionSort()

void 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 InternalSaveBooleanVarValue ( Solver *const  solver,
IntVar *const  var 
)

Definition at line 947 of file constraint_solver.cc.

◆ Interpolate()

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

Definition at line 242 of file fp_utils.h.

◆ IntervalDown32()

uint32 IntervalDown32 ( uint32  s)
inline

Definition at line 316 of file bitset.h.

◆ IntervalDown64()

uint64 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 IntervalUp32 ( uint32  s)
inline

Definition at line 305 of file bitset.h.

◆ IntervalUp64()

uint64 IntervalUp64 ( uint64  s)
inline

Definition at line 300 of file bitset.h.

◆ IsArrayBoolean()

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

Definition at line 2838 of file constraint_solveri.h.

◆ IsArrayConstant()

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

Definition at line 2828 of file constraint_solveri.h.

◆ IsArrayInRange()

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

Definition at line 2918 of file constraint_solveri.h.

◆ IsBitSet32()

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

Definition at line 349 of file bitset.h.

◆ IsBitSet64()

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

Definition at line 346 of file bitset.h.

◆ IsEmptyRange32()

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

◆ IsEmptyRange64()

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

◆ IsEulerianGraph()

bool IsEulerianGraph ( const Graph &  graph)

Definition at line 40 of file eulerian_path.h.

◆ IsIncreasing()

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

Definition at line 2908 of file constraint_solveri.h.

◆ IsIncreasingContiguous()

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

Definition at line 2898 of file constraint_solveri.h.

◆ IsIntegerWithinTolerance()

bool IsIntegerWithinTolerance ( FloatType  x,
FloatType  tolerance 
)
inline

Definition at line 161 of file fp_utils.h.

◆ IsPositiveOrNegativeInfinity()

bool IsPositiveOrNegativeInfinity ( FloatType  x)
inline

Definition at line 107 of file fp_utils.h.

◆ IsSemiEulerianGraph()

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

Definition at line 55 of file eulerian_path.h.

◆ IsSmallerWithinTolerance()

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

Definition at line 153 of file fp_utils.h.

◆ JoinDebugString()

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

Definition at line 38 of file string_array.h.

◆ JoinDebugStringPtr()

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

Definition at line 45 of file string_array.h.

◆ JoinNameFieldPtr()

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

Definition at line 58 of file string_array.h.

◆ JoinNamePtr()

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

Definition at line 52 of file string_array.h.

◆ LeastSignificantBitPosition32() [1/2]

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

◆ LeastSignificantBitPosition32() [2/2]

int LeastSignificantBitPosition32 ( uint32  n)
inline

Definition at line 182 of file bitset.h.

◆ LeastSignificantBitPosition32DeBruijn()

int LeastSignificantBitPosition32DeBruijn ( uint32  n)
inline

Definition at line 144 of file bitset.h.

◆ LeastSignificantBitPosition32Default()

int LeastSignificantBitPosition32Default ( uint32  n)
inline

Definition at line 153 of file bitset.h.

◆ LeastSignificantBitPosition64() [1/2]

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

◆ LeastSignificantBitPosition64() [2/2]

int LeastSignificantBitPosition64 ( uint64  n)
inline

Definition at line 127 of file bitset.h.

◆ LeastSignificantBitPosition64DeBruijn()

int LeastSignificantBitPosition64DeBruijn ( uint64  n)
inline

Definition at line 81 of file bitset.h.

◆ LeastSignificantBitPosition64Default()

int LeastSignificantBitPosition64Default ( uint64  n)
inline

Definition at line 93 of file bitset.h.

◆ LeastSignificantBitWord32()

uint32 LeastSignificantBitWord32 ( uint32  n)
inline

Definition at line 64 of file bitset.h.

◆ LeastSignificantBitWord64()

uint64 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 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 LoadGurobiFunctions ( )

Definition at line 138 of file gurobi_environment.cc.

◆ LoadSpecificGurobiLibrary()

bool 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 * 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 * 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 * 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 * 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 * 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 * 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 * 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 > 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()

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 
)

Definition at line 675 of file hungarian.cc.

◆ MaxVarArray()

int64 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()

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 
)

Definition at line 657 of file hungarian.cc.

◆ MinVarArray()

int64 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 mix ( uint32 a,
uint32 b,
uint32 c 
)
inlinestatic

Definition at line 28 of file hash.h.

◆ mix() [2/2]

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

Definition at line 59 of file hash.h.

◆ MixTwoUInt64()

uint64 MixTwoUInt64 ( uint64  fp1,
uint64  fp2 
)
inline

Definition at line 20 of file thorough_hash.h.

◆ MostSignificantBitPosition32() [1/2]

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

◆ MostSignificantBitPosition32() [2/2]

int MostSignificantBitPosition32 ( uint32  n)
inline

Definition at line 273 of file bitset.h.

◆ MostSignificantBitPosition32Default()

int MostSignificantBitPosition32Default ( uint32  n)
inline

Definition at line 249 of file bitset.h.

◆ MostSignificantBitPosition64() [1/2]

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

◆ MostSignificantBitPosition64() [2/2]

int MostSignificantBitPosition64 ( uint64  n)
inline

Definition at line 231 of file bitset.h.

◆ MostSignificantBitPosition64Default()

int 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 > > 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 One ( )
inline

This method returns 1.

Definition at line 3147 of file constraint_solver.h.

◆ OneBit32()

uint32 OneBit32 ( int  pos)
inline

Definition at line 39 of file bitset.h.

◆ OneBit64()

uint64 OneBit64 ( int  pos)
inline

Definition at line 38 of file bitset.h.

◆ OneRange32()

uint32 OneRange32 ( uint32  s,
uint32  e 
)
inline

Definition at line 292 of file bitset.h.

◆ OneRange64()

uint64 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 & operator<< ( std::ostream &  os,
MPSolver::OptimizationProblemType  optimization_problem_type 
)
inline

Definition at line 904 of file linear_solver.h.

◆ operator<<() [2/9]

std::ostream & 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 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 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 PosIntDivDown ( int64  e,
int64  v 
)
inline

Definition at line 2998 of file constraint_solveri.h.

◆ PosIntDivUp()

int64 PosIntDivUp ( int64  e,
int64  v 
)
inline

Definition at line 2993 of file constraint_solveri.h.

◆ ProbablyRunningInsideUnitTest()

bool ProbablyRunningInsideUnitTest ( )
inline

Definition at line 19 of file testing_utils.h.

◆ ProtobufDebugString()

std::string ProtobufDebugString ( const P &  message)

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

◆ ProtobufShortDebugString()

std::string ProtobufShortDebugString ( const P &  message)

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

◆ ProtobufTextFormatMergeFromString()

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

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

◆ ProtoEnumToString()

std::string 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 > ReadAllRecordsOrDie ( absl::string_view  filename)

Definition at line 102 of file file_util.h.

◆ ReadAllRecordsOrDie() [2/2]

std::vector< Proto > 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 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 ReadOneRecordOrDie ( absl::string_view  filename)

Definition at line 114 of file file_util.h.

◆ RealDebugString()

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

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

◆ RealLoad()

void 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 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 RegisterConstraintHandler ( ScipConstraintHandler< Constraint > *  handler,
SCIP *  scip 
)

◆ RegisterConstraintHandler() [2/2]

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

Definition at line 255 of file scip_callback.h.

◆ RegisterDemon()

void 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 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 RunWorker ( void *  data)

Definition at line 19 of file threadpool.cc.

◆ SafeAddInto()

bool 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 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 SetBit32 ( uint32 *const  bitset,
uint32  pos 
)
inline

Definition at line 357 of file bitset.h.

◆ SetBit64()

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

Definition at line 354 of file bitset.h.

◆ SetFirstSolutionStrategyFromFlags()

void SetFirstSolutionStrategyFromFlags ( RoutingSearchParameters *  parameters)

Definition at line 135 of file routing_flags.cc.

◆ SetIsEqual()

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

Definition at line 6332 of file expressions.cc.

◆ SetIsGreaterOrEqual()

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

Definition at line 6339 of file expressions.cc.

◆ SetLocalSearchMetaheuristicFromFlags()

void SetLocalSearchMetaheuristicFromFlags ( RoutingSearchParameters *  parameters)

Definition at line 179 of file routing_flags.cc.

◆ SetMiscellaneousParametersFromFlags()

void SetMiscellaneousParametersFromFlags ( RoutingSearchParameters *  parameters)

Definition at line 300 of file routing_flags.cc.

◆ SetSearchLimitsFromFlags()

void 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 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 SubHadOverflow ( int64  x,
int64  y,
int64  diff 
)
inline

Definition at line 61 of file saturated_arithmetic.h.

◆ SubOverflows()

int64 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]

TEST ( LinearAssignmentTest  ,
NullMatrix   
)

Definition at line 60 of file hungarian_test.cc.

◆ TEST() [2/5]

TEST ( LinearAssignmentTest  ,
SizeOneMatrix   
)

Definition at line 90 of file hungarian_test.cc.

◆ TEST() [3/5]

TEST ( LinearAssignmentTest  ,
Small3x4Matrix   
)

Definition at line 118 of file hungarian_test.cc.

◆ TEST() [4/5]

TEST ( LinearAssignmentTest  ,
Small4x3Matrix   
)

Definition at line 131 of file hungarian_test.cc.

◆ TEST() [5/5]

TEST ( LinearAssignmentTest  ,
Small4x4Matrix   
)

Definition at line 103 of file hungarian_test.cc.

◆ TestMaximization()

void 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 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 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 TwoBitsFromPos64 ( uint64  pos)
inline

Definition at line 402 of file bitset.h.

◆ TwosComplementAddition()

int64 TwosComplementAddition ( int64  x,
int64  y 
)
inline

Definition at line 38 of file saturated_arithmetic.h.

◆ TwosComplementSubtraction()

int64 TwosComplementSubtraction ( int64  x,
int64  y 
)
inline

Definition at line 44 of file saturated_arithmetic.h.

◆ UnsafeLeastSignificantBitPosition32()

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

◆ UnsafeLeastSignificantBitPosition64()

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

◆ UnsafeMostSignificantBitPosition32()

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

◆ UnsafeMostSignificantBitPosition64()

int64 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 WriteRecordsOrDie ( absl::string_view  filename,
const std::vector< Proto > &  protos 
)

Definition at line 123 of file file_util.h.

◆ Zero()

int64 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