►CA | |
CSTLCountingAllocator< void, A > | |
CAccessStorage | |
CAccurateSum< FpNumber > | |
CAccurateSum< Fractional > | |
►CACMRandom | |
CMTRandom | |
CAdaptiveParameterValue | |
CAdaptiveParameterValue | |
CAdjustablePriorityQueue< T, Comp > | |
CAdjustablePriorityQueue< BvaPqElement > | |
CAdjustablePriorityQueue< Element > | |
CAdjustablePriorityQueue< operations_research::BlossomGraph::Edge, std::greater< operations_research::BlossomGraph::Edge > > | |
CAdjustablePriorityQueue< PQElement > | |
CAffineExpression | |
CAffineRelation | |
►Callocator< T > | STL class |
CSTLCountingAllocator< T, Alloc > | |
CAnnotation | |
CArcFunctorOrderingByTailAndHead< GraphType > | |
CArcIndexOrderingByTailNode< GraphType > | |
►CArcIterator | |
CUndirectedAdjacencyListsOfDirectedGraph< Graph >::AdjacencyListIterator | |
CStarGraphBase< NodeIndexType, ArcIndexType, DerivedGraph >::ArcIterator | |
CArgument | |
CArgumentHolder | Argument Holder: useful when visiting a model |
CAssignmentAndConstraintFeasibilityMaintainer | |
CAssignmentContainer< V, E > | |
CAssignmentContainer< IntervalVar, IntervalVarElement > | |
CAssignmentContainer< IntVar, IntVarElement > | |
CAssignmentContainer< SequenceVar, SequenceVarElement > | |
►CAssignmentElement | |
CIntVarElement | |
CIntervalVarElement | |
CSequenceVarElement | The SequenceVarElement stores a partial representation of ranked interval variables in the underlying sequence variable |
CAssignmentInfo | |
CAssignmentType | |
CAStarSP | |
CBacktrackableIntegerSet< IntType > | |
CBacktrackableIntegerSet< ConstraintIndex > | |
►CBaseDeleter | |
CTemplatedElementDeleter< STLContainer > | |
CTemplatedValueDeleter< STLContainer > | |
CBaseGraph< NodeIndexType, ArcIndexType, HasReverseArcs > | |
►CBaseGraph< int, int, true > | |
CReverseArcListGraph< int, int > | |
►CBaseGraph< int32, int32, false > | |
CCompleteBipartiteGraph< NodeIndexType, ArcIndexType > | |
CCompleteGraph< NodeIndexType, ArcIndexType > | |
CListGraph< NodeIndexType, ArcIndexType > | |
CStaticGraph< NodeIndexType, ArcIndexType > | |
►CBaseGraph< int32, int32, true > | |
CReverseArcListGraph< NodeIndexType, ArcIndexType > | |
CReverseArcMixedGraph< NodeIndexType, ArcIndexType > | |
CReverseArcStaticGraph< NodeIndexType, ArcIndexType > | |
►CBaseKnapsackSolver | |
CKnapsack64ItemsSolver | |
CKnapsackBruteForceSolver | |
CKnapsackDynamicProgrammingSolver | |
CKnapsackGenericSolver | |
CKnapsackMIPSolver | |
►CBaseObject | A BaseObject is the root of all reversibly allocated objects |
CArrayWithOffset< T > | |
CDecision | A Decision represents a choice point in the search tree |
►CDecisionBuilder | A DecisionBuilder is responsible for creating the search tree |
CFindOneNeighbor | |
CIntVarFilteredDecisionBuilder | Decision builder building a solution using heuristics with local search filters to evaluate its feasibility |
CSweepBuilder | |
►CDecisionVisitor | A DecisionVisitor is used to inspect a decision |
CSymmetryBreaker | A symmetry breaker is an object that will visit a decision and create the 'symmetrical' decision in return |
►CDemon | A Demon is the base element of a propagation queue |
CCallMethod0< T > | Demon proxy to a method on the constraint with no arguments |
CCallMethod1< T, P > | Demon proxy to a method on the constraint with one argument |
CCallMethod2< T, P, Q > | Demon proxy to a method on the constraint with two arguments |
CCallMethod3< T, P, Q, R > | Demon proxy to a method on the constraint with three arguments |
CDelayedCallMethod0< T > | Low-priority demon proxy to a method on the constraint with no arguments |
CDelayedCallMethod1< T, P > | Low-priority demon proxy to a method on the constraint with one argument |
CDelayedCallMethod2< T, P, Q > | Low-priority demon proxy to a method on the constraint with two arguments |
CDimension | |
CIntVarIterator | The class Iterator has two direct subclasses |
►CLocalSearchFilter | Local Search Filters are used for fast neighbor pruning |
►CIntVarLocalSearchFilter | |
CBasePathFilter | Generic path-based filter class |
CCPFeasibilityFilter | This filter accepts deltas for which the assignment satisfies the constraints of the Solver |
CLocalSearchFilterManager | Filter manager: when a move is made, filters are executed to decide whether the solution is feasible and compute parts of the new cost |
►CLocalSearchOperator | The base class for all local search operators |
►CVarLocalSearchOperator< IntVar, int64, IntVarLocalSearchHandler > | |
►CIntVarLocalSearchOperator | Specialization of LocalSearchOperator built from an array of IntVars which specifies the scope of the operator |
CBaseLns | This is the base class for building an Lns operator |
CChangeValue | Defines operators which change the value of variables; each neighbor corresponds to one modified variable |
►CFilteredHeuristicLocalSearchOperator | Class of operators using a RoutingFilteredHeuristic to insert unperformed nodes after changes have been made to the current solution |
CFilteredHeuristicCloseNodesLNSOperator | 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 |
CFilteredHeuristicExpensiveChainLNSOperator | 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 |
CFilteredHeuristicPathLNSOperator | LNS-like operator based on a filtered first solution heuristic to rebuild the solution, after the destruction phase consisting of removing one route |
CRelocatePathAndHeuristicInsertUnperformedOperator | 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 |
►CPathOperator | Base class of the local search operators dedicated to path modifications (a path is a set of nodes linked together by arcs) |
►CBaseInactiveNodeToPathOperator | |
CExtendedSwapActiveOperator | |
CMakeActiveAndRelocate | |
CMakeActiveOperator | |
CRelocateAndMakeActiveOperator | |
CSwapActiveOperator | |
CCross | |
CExchange | |
CExchangeSubtrip | |
CIndexPairSwapActiveOperator | Operator which inserts inactive nodes into a path and makes a pair of active nodes inactive |
CLightPairRelocateOperator | |
CLinKernighan | |
CMakeChainInactiveOperator | |
CMakeInactiveOperator | |
CMakePairActiveOperator | Pair-based neighborhood operators, designed to move nodes by pairs (pairs are static and given) |
CMakePairInactiveOperator | Operator which makes pairs of active nodes inactive |
CMakeRelocateNeighborsOperator | Relocate neighborhood which moves chains of neighbors |
CPairExchangeOperator | 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 |
CPairExchangeRelocateOperator | Operator which exchanges the paths of two pairs (path have to be different) |
CPairNodeSwapActiveOperator< swap_first > | Operator which inserts pairs of inactive nodes into a path and makes an active node inactive |
CPairRelocateOperator | 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 |
CPathLns | |
CRelocate | |
CRelocateAndMakeInactiveOperator | |
CRelocateExpensiveChain | RelocateExpensiveChain |
CRelocateSubtrip | Tries to move subtrips after an insertion node |
CTSPLns | |
CTSPOpt | |
CTwoOpt | |
CSwapIndexPairOperator | Operator which iterates through each alternative of a set of pairs |
CNeighborhoodLimit | |
►CVarLocalSearchOperator< V, Val, Handler > | Base operator class for operators manipulating variables |
CSequenceVarLocalSearchOperator | |
CLocalSearchPhaseParameters | |
►CModelVisitor | Model visitor |
CModelParser | Model Parser |
CRoutingModelInspector | |
►CPropagationBaseObject | NOLINT |
CAssignment | An Assignment is a variable -> domains mapping, used to report solutions to the user |
►CConstraint | A constraint is the main modeling object |
►CCastConstraint | Cast constraints are special channeling constraints designed to keep a variable in sync with an expression |
CIfThenElseCt | |
CDisjunctiveConstraint | |
CGlobalVehicleBreaksConstraint | GlobalVehicleBreaksConstraint ensures breaks constraints are enforced on all vehicles in the dimension passed to its constructor |
CPack | |
CTypeRegulationsConstraint | The following constraint ensures that incompatibilities and requirements between types are respected |
►CIntExpr | The class IntExpr is the base of all integer expressions in constraint programming |
►CBaseIntExpr | This is the base class for all expressions that are not variables |
CPiecewiseLinearExpr | |
►CIntVar | The class IntVar is a subset of IntExpr |
CBooleanVar | |
CIntervalVar | Interval variables are often used in scheduling |
CSequenceVar | A sequence variable is a variable whose domain is a set of possible orderings of the interval variables |
CRoutingModelVisitor | Routing model visitor |
►CSearchMonitor | A search monitor is a simple set of callbacks to monitor all search events |
►CLocalSearchMonitor | |
CLocalSearchMonitorMaster | |
CLocalSearchProfiler | |
COptimizeVar | This class encapsulates an objective |
►CPropagationMonitor | |
CDemonProfiler | |
CTrace | |
►CSearchLimit | Base class of all search limits |
CImprovementSearchLimit | |
CRegularLimit | Usual limit based on wall_time, number of explored branches and number of failures in the search tree |
CSearchLog | The base class of all search logs that periodically outputs information when the search is running |
CSolutionCollector | This class is the root class of all solution collectors |
CSymmetryManager | |
CSolutionPool | This class is used to manage a pool of solutions |
CBasisFactorization | |
CBasisState | |
CBeginEndReverseIteratorWrapper< Container > | |
CBeginEndWrapper< Iterator > | |
►CBeginEndWrapper< IntegerRangeIterator< IntegerType > > | |
CIntegerRange< IntegerType > | |
CBellmanFord | |
CImpliedBoundsProcessor::BestImpliedBoundInfo | |
CBinaryClause | |
CBinaryClauseManager | |
CLinearSumAssignment< GraphType >::BipartiteLeftNodeIterator | |
►CBitGenRef | |
CModelRandomGenerator | |
CBitmap | |
CBitQueue64 | |
CBitset64< IndexType > | |
CBitset64< ColIndex > | |
CBitset64< int64 > | |
CBitset64< LiteralIndex > | |
CBitset64< RowIndex > | |
CBlockedClauseSimplifier | |
CBlossomGraph | |
CBooleanOrIntegerLiteral | |
CBooleanOrIntegerVariable | |
CBoolVar | A Boolean variable |
CBopConstraintTerm | |
►CBopOptimizerBase | |
CBopAdaptiveLNSOptimizer | |
CBopCompleteLNSOptimizer | |
CBopRandomFirstSolutionGenerator | |
CGuidedSatFirstSolutionGenerator | |
CLinearRelaxation | |
CLocalSearchOptimizer | |
CPortfolioOptimizer | |
CSatCoreBasedOptimizer | |
CBopSolution | |
CBopSolver | |
CSimpleBoundCosts::BoundCost | |
CBoundedVariableElimination | |
CSolutionOutputSpecs::Bounds | |
CBronKerboschAlgorithm< NodeIndex > | |
CCachedLog | |
CCallbackRangeConstraint | |
CCallbackSetup | |
CCanonicalBooleanLinearProblem | |
CPathState::Chain | |
CPathState::ChainRange | |
CCheckOpMessageBuilder | |
CCheckOpString | |
CChristofidesPathSolver< CostType, ArcIndex, NodeIndex, CostFunction > | |
CClauseInfo | |
CCleanup< Callback > | |
CClosedInterval | Represents a closed interval [start, end] |
CDoubletonEqualityRowPreprocessor::RestoreInfo::ColChoiceAndStatus | |
CColumnDeletionHelper | |
CColumnPriorityQueue | |
CColumnView | |
CZeroHalfCutHelper::CombinationOfRows | |
►CCompactSparseMatrix | |
CTriangularMatrix | |
CCompactSparseMatrixView | |
CCompileAssert< bool > | |
CConnectedComponentsFinder< T, CompareOrHashT > | |
CConnectedComponentsTypeHelper< T, CompareOrHashT > | |
CConnectedComponentsTypeHelper< T, std::less< T > > | |
CConstraint | |
►CConstraint | A constraint |
CAutomatonConstraint | Specialized automaton constraint |
CCircuitConstraint | Specialized circuit constraint |
CCumulativeConstraint | Specialized cumulative constraint |
CMultipleCircuitConstraint | Specialized circuit constraint |
CNoOverlap2DConstraint | Specialized no_overlap2D constraint |
CReservoirConstraint | Specialized reservoir constraint |
CTableConstraint | Specialized assignment constraint |
CLinearConstraintManager::ConstraintInfo | |
COneFlipConstraintRepairer::ConstraintTerm | |
CCoreBasedOptimizer | |
CRoutingModel::CostClass | |
CCoverCutHelper | |
CCpModelBuilder | Wrapper class around the cp_model proto |
CCpModelMapping | |
CCpModelPresolver | |
CCrashReason | |
CCumulBoundsPropagator | |
CCutGenerator | |
CCycleTimerBase | |
CDataWrapper< Data > | |
CDataWrapper< LinearProgram > | |
CDataWrapper< MPModelProto > | |
CSatSolver::Decision | |
CDefaultPhaseParameters | This struct holds all parameters for the default search |
CDenseConnectedComponentsFinder | |
CDenseDoublyLinkedList | |
CDenseIntTopologicalSorterTpl< stable_sort > | |
CDenseIntTopologicalSorterTpl< false > | |
CDijkstraSP< S > | |
CRoutingModel::CostClass::DimensionCost | SUBTLE: The vehicle's fixed cost is skipped on purpose here, because we can afford to do so: |
CDimensionCumulOptimizerCore | |
CDisabledScopedInstructionCounter | |
CDisabledScopedTimeDistributionUpdater | |
CDisjunctivePropagator | 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 |
CDomain | We call domain any subset of Int64 = [kint64min, kint64max] |
CDomain | |
CDomainDeductions | |
CDratChecker | |
CDratProofHandler | |
CDratWriter | |
CDualBoundStrengthening | |
CDualEdgeNorms | |
CDummyClassToDefineOperator | |
CDynamicLibrary | |
CDynamicPartition | |
CDynamicPermutation | |
CBlossomGraph::Edge | |
CElementDeleter | |
CElementIterator< Set > | |
CEnabledScopedTimeDistributionUpdater | |
CEncodingNode | |
CEnteringVariable | |
CTaskSet::Entry | |
►CEntryType | |
CVectorIterator< EntryType > | |
CEnumLogger< E > | |
CEquiv< LessFunc > | |
CEtaFactorization | |
CEtaMatrix | |
CExponentialMovingAverage | |
►Cfalse_type | |
CUnordered< typename, typename, typename > | |
CUnordered< T, absl::void_t< typename T::hasher >, absl::void_t< typename T::reverse_iterator > > | |
CFeasibilityPump | |
CFile | |
CFileLineIterator | |
CFileLines | |
CLocalSearchFilterManager::FilterEvent | |
►Cflat_hash_map | |
CLinearProgrammingDispatcher | |
CFlatzincSatParameters | |
CFullEncodingFixedPointComputer | |
CGlobalCheapestInsertionFilteredHeuristic::GlobalCheapestInsertionParameters | |
CGlobalDimensionCumulOptimizer | |
CGoogleInitializer | |
Cgraph_traits< GraphType > | |
Cgraph_traits< ForwardEbertGraph< NodeIndexType, ArcIndexType > > | |
Cgraph_traits< ForwardStaticGraph< NodeIndexType, ArcIndexType > > | |
CGraphBuilderFromArcs< GraphType, is_dynamic > | |
►CGraphBuilderFromArcs< GraphType, graph_traits< GraphType >::is_dynamic > | |
CAnnotatedGraphBuildManager< GraphType > | |
CGraphBuilderFromArcs< GraphType, true > | |
CGraphExporter | |
CGraphs< Graph > | |
CGraphs< operations_research::StarGraph > | |
CGraphSymmetryFinder | |
CGScip | |
CGScipConstraintOptions | |
CGScipIndicatorConstraint | |
CGScipIndicatorRangeConstraint | |
CGScipLinearExpr | |
CGScipLinearRange | |
CGScipLogicalConstraintData | |
CGScipQuadraticRange | |
CGScipResult | |
CGScipSOSData | |
CGScipVariableOptions | |
CHamiltonianPathSolver< CostType, CostFunction > | |
CHamiltonianPathSolver< int64, std::vector< std::vector< int64 > > > | |
Chash< std::array< T, N > > | |
Chash< std::pair< First, Second > > | |
►CIntType< IntTypeName, _ValueType >::Hasher | |
Chash< gtl::IntType< IntTypeName, ValueType > > | |
CHeldWolfeCrowderEvaluator< CostType, CostFunction > | |
CHungarianOptimizer | |
CImpliedBoundEntry | |
CImpliedBounds | |
CImpliedBoundsProcessor | |
CEbertGraph< NodeIndexType, ArcIndexType >::IncomingArcIterator | |
CIncrementalAverage | |
CIndexReferences | |
CInitAndGetValues | Utility class to encapsulate an IntVarIterator and use it in a range-based loop |
CInitialBasis | |
CInprocessing | |
CSolver::IntegerCastInfo | Holds semantic information stating that the 'expression' has been cast into 'variable' using the Var() method, and that 'maintainer' is responsible for maintaining the equality between 'variable' and 'expression' |
CIntegerEncoder | |
CIntegerLiteral | |
CPrecedencesPropagator::IntegerPrecedences | |
CIntegerPriorityQueue< Element, Compare > | |
CIntegerPriorityQueue< VariableWithPriority > | |
CIntegerPriorityQueue< WeightedVarQueueElement > | |
CIntegerRangeIterator< IntegerType > | |
CIntegerRoundingCutHelper | |
CIntegerVariable | |
CIntegralSolver | |
CUnaryDimensionChecker::Interval | |
CSortedDisjointIntervalList::IntervalComparator | |
CIntervalsRepository | |
CIntervalVar | Represents a Interval variable |
CIntTupleSet | |
CIntType< IntTypeName, _ValueType > | |
CIntVar | An integer variable |
►CIntVarFilteredHeuristic | Generic filter-based heuristic applied to IntVars |
►CRoutingFilteredHeuristic | Filter-based heuristic dedicated to routing |
►CCheapestAdditionFilteredHeuristic | Filtered-base decision builder based on the addition heuristic, extending a path from its start node with the cheapest arc |
CComparatorCheapestAdditionFilteredHeuristic | A CheapestAdditionFilteredHeuristic where the notion of 'cheapest arc' comes from an arc comparator |
CEvaluatorCheapestAdditionFilteredHeuristic | A CheapestAdditionFilteredHeuristic where the notion of 'cheapest arc' comes from an arc evaluator |
►CCheapestInsertionFilteredHeuristic | |
CGlobalCheapestInsertionFilteredHeuristic | 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 |
CLocalCheapestInsertionFilteredHeuristic | Filter-base decision builder which builds a solution by inserting nodes at their cheapest position |
CChristofidesFilteredHeuristic | Christofides addition heuristic |
►CSavingsFilteredHeuristic | Filter-based decision builder which builds a solution by using Clarke & Wright's Savings heuristic |
CParallelSavingsFilteredHeuristic | |
CSequentialSavingsFilteredHeuristic | |
CIntVarLocalSearchHandler | |
►Cios_base | STL class |
►Cbasic_ios< Char > | STL class |
►Cbasic_ostream< Char > | STL class |
►Costream | STL class |
►CLogMessage::LogStream | |
►CNullStream | |
CNullStreamFatal | |
CDynamicPartition::IterablePart | |
CBitset64< IndexType >::Iterator | |
CInitAndGetValues::Iterator | |
CPathState::Chain::Iterator | |
CPathState::ChainRange::Iterator | |
CPathState::NodeRange::Iterator | |
CSimpleRevFIFO< T >::Iterator | This iterator is not stable with respect to deletion |
CSparsePermutation::Iterator | |
CMutableVectorIteration< T >::Iterator | |
CJNIUtil | |
CJsspParser | |
CKnapsackAssignment | |
CKnapsackAssignmentForCuts | |
CKnapsackItem | |
CKnapsackItem | |
CKnapsackItemForCuts | |
CKnapsackItemWithEfficiency | |
►CKnapsackPropagator | |
CKnapsackCapacityPropagator | |
CKnapsackPropagatorForCuts | |
CKnapsackSearchNode | |
CKnapsackSearchNodeForCuts | |
CKnapsackSearchPath | |
CKnapsackSearchPathForCuts | |
CKnapsackSolver | This library solves knapsack problems |
CKnapsackSolverForCuts | |
CKnapsackState | |
CKnapsackStateForCuts | |
CLatticeMemoryManager< Set, CostType > | |
CLatticeMemoryManager< operations_research::Set, CostType > | |
CLatticeMemoryManager< operations_research::Set, int64 > | |
CLazyMutableCopy< T > | |
CLearnedInfo | |
CLevelZeroCallbackHelper | |
CLexerInfo | |
CLinearConstraint | |
CLinearConstraintBuilder | |
CLinearConstraintManager | |
CLinearExpr | LinearExpr models a quantity that is linear in the decision variables (MPVariable) of an optimization problem, i.e |
CLinearExpr | A dedicated container for linear expressions |
CLinearExpression | |
CLinearProgram | |
CLinearRange | An expression of the form: |
CLinearRelaxation | |
CLinearSumAssignment< GraphType > | |
CLink | |
CLinkSort | |
CLiteral | |
CLiteralWithCoeff | |
CLocalDimensionCumulOptimizer | |
CLocalSearchAssignmentIterator | |
CLocalSearchState | |
CLocalSearchVariable | |
►CLogBase | |
►CLogLegacyBase | |
CLogLegacy | |
CLogLegacyUpTo100 | |
►CLogMultilineBase | |
CLogMultiline | |
►CLogMultilineUpToN | |
CLogMultilineUpTo100 | |
►CLogShortBase | |
CLogShort | |
►CLogShortUpToN | |
CLogShortUpTo100 | |
CLogDestination | |
CLogger | |
►CLogMessage | |
CErrnoLogMessage | |
CLogMessageFatal | |
CLogMessage::LogMessageData | |
CLogMessageVoidify | |
CLogSink | |
CLowerPriorityThan< T, Comparator > | |
CLPDecomposer | |
CLpScalingHelper | |
CLPSolveInfo | |
CLPSolver | |
CLPVariable | |
CLPVariables | |
CLubyAdaptiveParameterValue | |
CLuFactorization | |
CMarkowitz | |
CMathUtil | |
CMatrixEntry | |
CMatrixNonZeroPattern | |
CMatrixOrFunction< ScalarType, Evaluator, square > | |
CMatrixOrFunction< CostType, CostFunction, true > | |
CMatrixOrFunction< int64, std::vector< std::vector< int64 > >, true > | |
CMatrixOrFunction< ScalarType, std::vector< std::vector< ScalarType > >, square > | |
CMatrixView | |
►CMaxFlowStatusClass | |
►CGenericMaxFlow< StarGraph > | |
CMaxFlow | |
CGenericMaxFlow< Graph > | |
CMergingPartition | |
►CMinCostFlowBase | |
►CGenericMinCostFlow< StarGraph > | |
CMinCostFlow | |
CGenericMinCostFlow< Graph, ArcFlowType, ArcScaledCostType > | |
CSimpleMinCostFlow | |
CMinCostPerfectMatching | |
CModel | |
CModel | Class that owns everything related to a particular optimization model |
CModelCache | Implements a complete cache for model elements: expressions and constraints |
CModelStatistics | |
CMonoidOperationTree< T > | |
►CMPCallback | |
CMPCallbackList | |
►CMPCallbackContext | |
CScipMPCallbackContext | |
CMPConstraint | The class for constraints of a Mathematical Programming (MP) model |
CMPModelExportOptions | Export options |
CMPObjective | A class to express a linear objective |
CMPSolver | This mathematical programming (MP) solver class is the main class though which users build and solve problems |
►CMPSolverInterface | |
CBopInterface | |
CCBCInterface | |
CCLPInterface | |
CGLOPInterface | |
CGurobiInterface | |
CSCIPInterface | |
CSatInterface | |
CMPSolverParameters | This class stores parameter settings for LP and MIP solvers |
CMPSReader | |
CMPSReaderImpl | |
CMPVariable | The class for variables of a Mathematical Programming (MP) model |
CMutableUpperBoundedLinearConstraint | |
CMutableVectorIteration< T > | |
CNearestNeighbors | |
CNeighborhood | |
►CNeighborhoodGenerator | |
CConstraintBasedNeighborhood | |
CObjectiveBasedNeighborhood | |
CRelationGraphBasedNeighborhood | |
►CNeighborhoodGenerator | |
CConsecutiveConstraintsRelaxationNeighborhoodGenerator | |
CConstraintGraphNeighborhoodGenerator | |
CRelaxationInducedNeighborhoodGenerator | |
CSchedulingNeighborhoodGenerator | |
CSchedulingTimeWindowNeighborhoodGenerator | |
CSimpleConstraintNeighborhoodGenerator | |
CSimpleNeighborhoodGenerator | |
CVariableGraphNeighborhoodGenerator | |
CWeightedRandomRelaxationNeighborhoodGenerator | |
CNestedTimeLimit | 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 |
CBlossomGraph::Node | |
CGlobalCheapestInsertionFilteredHeuristic::NodeEntry | |
CStarGraphBase< NodeIndexType, ArcIndexType, DerivedGraph >::NodeIterator | |
CRoutingDimension::NodePrecedence | |
CPathState::NodeRange | |
CNonOrderedSetHasher< IntType > | |
CNonOrderedSetHasher< ConstraintIndexWithDirection > | |
CObjectiveDefinition | |
COneFlipConstraintRepairer | |
►CReverseArcListGraph< NodeIndexType, ArcIndexType >::OppositeIncomingArcIterator | |
CReverseArcListGraph< NodeIndexType, ArcIndexType >::IncomingArcIterator | |
►CReverseArcMixedGraph< NodeIndexType, ArcIndexType >::OppositeIncomingArcIterator | |
CReverseArcMixedGraph< NodeIndexType, ArcIndexType >::IncomingArcIterator | |
►CReverseArcStaticGraph< NodeIndexType, ArcIndexType >::OppositeIncomingArcIterator | |
CReverseArcStaticGraph< NodeIndexType, ArcIndexType >::IncomingArcIterator | |
COptimizerSelector | |
CCircuitPropagator::Options | |
CStarGraphBase< NodeIndexType, ArcIndexType, DerivedGraph >::OutgoingArcIterator | |
CCompleteBipartiteGraph< NodeIndexType, ArcIndexType >::OutgoingArcIterator | |
CListGraph< NodeIndexType, ArcIndexType >::OutgoingArcIterator | |
CReverseArcListGraph< NodeIndexType, ArcIndexType >::OutgoingArcIterator | |
CReverseArcMixedGraph< NodeIndexType, ArcIndexType >::OutgoingArcIterator | |
CReverseArcStaticGraph< NodeIndexType, ArcIndexType >::OutgoingArcIterator | |
CStaticGraph< NodeIndexType, ArcIndexType >::OutgoingArcIterator | |
CListGraph< NodeIndexType, ArcIndexType >::OutgoingHeadIterator | |
CReverseArcListGraph< NodeIndexType, ArcIndexType >::OutgoingHeadIterator | |
CEbertGraph< NodeIndexType, ArcIndexType >::OutgoingOrOppositeIncomingArcIterator | |
CReverseArcListGraph< NodeIndexType, ArcIndexType >::OutgoingOrOppositeIncomingArcIterator | |
CReverseArcMixedGraph< NodeIndexType, ArcIndexType >::OutgoingOrOppositeIncomingArcIterator | |
CReverseArcStaticGraph< NodeIndexType, ArcIndexType >::OutgoingOrOppositeIncomingArcIterator | |
CGlobalCheapestInsertionFilteredHeuristic::PairEntry | |
CParserContext | |
CPathState | |
CPbConstraintsEnqueueHelper | |
CPercentile | |
CPermutation< IndexType > | |
CPermutation< ColIndex > | |
CPermutation< RowIndex > | |
CPermutationApplier< IndexType > | |
►CPermutationCycleHandler< IndexType > | |
CArrayIndexCycleHandler< DataType, IndexType > | |
►CPermutationCycleHandler< ArcIndexType > | |
►CArrayIndexCycleHandler< NodeIndexType, ArcIndexType > | |
CForwardStaticGraph< NodeIndexType, ArcIndexType >::CycleHandlerForAnnotatedArcs | |
CCostValueCycleHandler< ArcIndexType > | |
CEbertGraphBase< NodeIndexType, ArcIndexType, DerivedGraph >::CycleHandlerForAnnotatedArcs | |
CPermutationIndexComparisonByArcHead< NodeIndexType, ArcIndexType > | |
CPiecewiseLinearFunction | |
CPiecewiseSegment | |
CPostsolveClauses | |
►CPreprocessor | |
CAddSlackVariablesPreprocessor | |
CDoubletonEqualityRowPreprocessor | |
CDoubletonFreeColumnPreprocessor | |
CDualizerPreprocessor | |
CEmptyColumnPreprocessor | |
CEmptyConstraintPreprocessor | |
CFixedVariablePreprocessor | |
CForcingAndImpliedFreeConstraintPreprocessor | |
CFreeConstraintPreprocessor | |
CImpliedFreePreprocessor | |
CMainLpPreprocessor | |
CProportionalColumnPreprocessor | |
CProportionalRowPreprocessor | |
CRemoveNearZeroEntriesPreprocessor | |
CScalingPreprocessor | |
CShiftVariableBoundsPreprocessor | |
CSingletonColumnSignPreprocessor | |
CSingletonPreprocessor | |
CToMinimizationPreprocessor | |
CUnconstrainedVariablePreprocessor | |
CPresolveContext | |
CPresolver | |
CPrimalEdgeNorms | |
CPriorityQueueWithRestrictedPush< Element, IntegerPriority > | |
CPriorityQueueWithRestrictedPush< NodeIndex, NodeHeight > | |
CProber | |
CProbingOptions | |
CProblemSolution | |
CProblemState | |
CPropagationGraph | |
►CPropagatorInterface | |
CAllDifferentBoundsPropagator | |
CAllDifferentConstraint | |
CBooleanXorPropagator | |
CCircuitCoveringPropagator | |
CCircuitPropagator | |
CCombinedDisjunctive< time_direction > | |
CCumulativeEnergyConstraint | |
CDisjunctiveDetectablePrecedences | |
CDisjunctiveEdgeFinding | |
CDisjunctiveNotLast | |
CDisjunctiveOverloadChecker | |
CDisjunctivePrecedences | |
CDisjunctiveWithTwoItems | |
CDivisionPropagator | |
CFixedDivisionPropagator | |
CGreaterThanAtLeastOneOfPropagator | |
CIntegerSumLE | |
CLevelZeroEquality | |
CLinMinPropagator | |
CLinearProgrammingConstraint | |
CMinPropagator | |
CNonOverlappingRectanglesDisjunctivePropagator | |
CNonOverlappingRectanglesEnergyPropagator | |
CPositiveProductPropagator | |
CPrecedencesPropagator | |
CReservoirTimeTabling | |
►CSchedulingConstraintHelper | |
CAllIntervalsHelper | |
CSelectedMinPropagator | |
CSquarePropagator | |
CTimeTableEdgeFinding | |
CTimeTablingPerTask | |
CPruningHamiltonianSolver< CostType, CostFunction > | |
CPseudoCosts | |
CQueue | |
CRandomAccessSparseColumn | |
CRangeIntToIntFunction | |
CRangeLogger< IteratorT, PolicyT > | |
CRangeMinimumIndexQuery< T, Compare > | |
CRangeMinimumQuery< T, Compare > | |
CRangeMinimumQuery< int, IndexComparator > | |
CRangeMinMaxIndexFunction | |
CRankOneUpdateElementaryMatrix | |
CRankOneUpdateFactorization | |
CRcpspParser | |
CPbConstraintsEnqueueHelper::ReasonInfo | |
CSTLCountingAllocator< T, Alloc >::rebind< U > | |
CSTLCountingAllocator< void, A >::rebind< U > | |
CRecordReader | |
CRecordWriter | |
CReducedCosts | |
CAffineRelation::Relation | |
CRestartPolicy | |
►CRev< T > | This class adds reversibility to a POD type |
CNumericalRev< int > | |
CNumericalRev< T > | Subclass of Rev<T> which adds numerical operations |
CRev< uint64 > | |
►CRevArray< T > | Reversible array of POD types |
CNumericalRevArray< T > | Subclass of RevArray<T> which adds numerical operations |
CRevArray< uint64 > | |
►CRevBitSet | This class represents a reversible bitset |
CRevBitMatrix | Matrix version of the RevBitSet class |
CReverseView< Container > | |
►CReversibleInterface | |
CRevMap< absl::flat_hash_map< IntegerVariable, int > > | |
►CRevRepository< IntegerValue > | |
CRevIntegerValueRepository | |
►CRevRepository< int > | |
CRevIntRepository | |
CRevVector< IdType, int > | |
CRevGrowingMultiMap< Key, Value > | |
CRevMap< Map > | |
CRevRepository< T > | |
CRevVector< IndexType, T > | |
CCircuitCoveringPropagator | |
CCircuitPropagator | |
CLinearProgrammingConstraint | |
CSchedulingConstraintHelper | |
CRevGrowingArray< T, C > | This class is a reversible growing array |
CRevImmutableMultiMap< K, V > | Reversible Immutable MultiMap class |
CRevIntSet< T > | This is a special class to represent a 'residual' set of T |
CRevIntSet< int > | |
CRevisedSimplex | |
CRevisedSimplexDictionary | |
CRevPartialSequence | --— RevPartialSequence --— |
CRevSwitch | A reversible switch that can switch once from false to true |
CRINSNeighborhood | |
CRoundingOptions | |
CRouteConstructor | |
CRoutingDimension | Dimensions represent quantities accumulated at nodes along the routes |
CRoutingIndexManager | Manager for any NodeIndex <-> variable index conversion |
►CRoutingLinearSolverWrapper | |
CRoutingCPSatWrapper | |
CRoutingGlopWrapper | |
CRoutingModel | |
CRowDeletionHelper | |
CRunningAverage | |
CRunningMax< Number > | |
CRunningMax< int64 > | |
CSatClause | |
CSatDecisionPolicy | |
CSatPostsolver | |
CSatPresolveOptions | |
CSatPresolver | |
►CSatPropagator | |
CBinaryImplicationGraph | |
CGenericLiteralWatcher | |
CIntegerTrail | |
CLiteralWatchers | |
CPbConstraints | |
CPrecedencesPropagator | |
CSymmetryPropagator | |
CSatSolver | |
CSatWrapper | |
CSavedLiteral | |
CSavedVariable | |
CSavingsFilteredHeuristic::SavingsContainer< Saving > | |
CSavingsFilteredHeuristic::SavingsParameters | |
CScatteredIntegerVector | |
CScatteredVector< Index, Iterator > | |
►CScatteredVector< ColIndex, ScatteredRowIterator > | |
CScatteredRow | |
►CScatteredVector< RowIndex, ScatteredColumnIterator > | |
CScatteredColumn | |
CScatteredVectorEntry< IndexType > | |
►CScatteredVectorEntry< ColIndex > | |
CScatteredRowEntry | |
►CScatteredVectorEntry< RowIndex > | |
CScatteredColumnEntry | |
CSccCounterOutput< NodeIndex > | |
CSccGraph | |
CSCIP_ConsData | |
CSCIP_ConshdlrData | |
CScipCallbackConstraintOptions | |
►CScipCallbackRunner | |
CScipCallbackRunnerImpl< ConstraintData > | |
CScipConstraintHandler< Constraint > | |
CScipConstraintHandler< ConstraintData > | |
►CScipConstraintHandler< EmptyStruct > | |
CScipConstraintHandlerForMPCallback | |
CScipConstraintHandlerContext | |
CScipConstraintHandlerDescription | |
CScopedFloatingPointEnv | |
CScopedWallTime | |
CScpData | |
CScpParser | |
CSearch | |
CSearchHeuristics | |
CSolver::SearchLogParameters | Creates a search monitor from logging parameters |
CConnectedComponentsTypeHelper< T, CompareOrHashT >::SelectContainer< U, E > | |
CConnectedComponentsTypeHelper< T, CompareOrHashT >::SelectContainer< U, absl::enable_if_t< std::is_integral< decltype(std::declval< const U & >()(std::declval< const T & >()))>::value > > | |
CSequenceVarLocalSearchHandler | |
CSet< Integer > | |
CSetRangeIterator< SetRange > | |
CSetRangeWithCardinality< Set > | |
CSharedBoundsManager | |
CSharedIncompleteSolutionManager | |
CSharedResponseManager | |
CSharedSolutionRepository< ValueType > | |
►CSharedSolutionRepository< double > | |
CSharedLPSolutionRepository | |
►CSharedSolutionRepository< int64 > | |
CSharedRelaxationSolutionRepository | |
CSharedTimeLimit | |
CSigintHandler | |
CSimpleBoundCosts | A structure meant to store soft bounds and associated violation constants |
CSimpleLinearSumAssignment | |
CSimpleMaxFlow | |
CSimpleRevFIFO< T > | This class represent a reversible FIFO structure |
CSimpleRevFIFO< bool > | |
CSimpleRevFIFO< operations_research::Decision * > | |
CSimpleRevFIFO< operations_research::Demon * > | |
CSimpleRevFIFO< operations_research::IntVar * > | |
CSingletonUndo | |
CImpliedBoundsProcessor::SlackInfo | |
CSmallRevBitSet | This class represents a small reversible bitset (size <= 64) |
CSharedSolutionRepository< ValueType >::Solution | |
CSolutionCollector::SolutionData | |
CSolutionObservers | |
CSolutionOutputSpecs | |
CNeighborhoodGenerator::SolveData | |
CSolver | Solver Class |
CSortedDisjointIntervalList | This class represents a sorted list of disjoint, closed intervals |
CSparseBitset< IntegerType > | |
CSparseBitset< BooleanVariable > | |
CSparseBitset< ConstraintIndex > | |
CSparseBitset< Index > | |
CSparseBitset< int64 > | |
CSparseBitset< IntegerVariable > | |
CSparseBitset< LiteralIndex > | |
CSparseBitset< SatDecisionLevel > | |
CSparseMatrix | |
CSparseMatrixScaler | |
CSparseMatrixWithReusableColumnMemory | |
CSparsePermutation | |
CSparseVector< IndexType, IteratorType > | |
►CSparseVector< ColIndex, SparseRowIterator > | |
CSparseRow | |
►CSparseVector< RowIndex, SparseColumnIterator > | |
CSparseColumn | |
CSparseVectorEntry< IndexType > | |
►CSparseVectorEntry< ColIndex > | |
CSparseRowEntry | |
►CSparseVectorEntry< RowIndex > | |
CSparseColumnEntry | |
CStampingSimplifier | |
►CStarGraphBase< NodeIndexType, ArcIndexType, DerivedGraph > | |
CEbertGraphBase< NodeIndexType, ArcIndexType, DerivedGraph > | |
►CStarGraphBase< NodeIndexType, ArcIndexType, EbertGraph< NodeIndexType, ArcIndexType > > | |
►CEbertGraphBase< NodeIndexType, ArcIndexType, EbertGraph< NodeIndexType, ArcIndexType > > | |
CEbertGraph< NodeIndexType, ArcIndexType > | |
►CStarGraphBase< NodeIndexType, ArcIndexType, ForwardEbertGraph< NodeIndexType, ArcIndexType > > | |
►CEbertGraphBase< NodeIndexType, ArcIndexType, ForwardEbertGraph< NodeIndexType, ArcIndexType > > | |
CForwardEbertGraph< NodeIndexType, ArcIndexType > | |
►CStarGraphBase< NodeIndexType, ArcIndexType, ForwardStaticGraph< NodeIndexType, ArcIndexType > > | |
CForwardStaticGraph< NodeIndexType, ArcIndexType > | |
CCheapestInsertionFilteredHeuristic::StartEndValue | |
►CStat | |
►CDistributionStat | |
CDoubleDistribution | |
CIntegerDistribution | |
CRatioDistribution | |
CTimeDistribution | |
CRoutingModel::StateDependentTransit | What follows is relevant for models with time/state dependent transits |
CStateInfo | |
CStateMarker | |
CStatsGroup | |
CStatus | |
CStatusBuilder | |
CSTLElementDeleter< STLContainer > | |
CSTLValueDeleter< STLContainer > | |
CStorage< Callback > | |
CStrategy | |
►Cstreambuf | |
CLogStreamBuf | |
CStronglyConnectedComponentsFinder< NodeIndex, Graph, SccOutput > | |
►CStrongVector< IntType, T, Alloc > | |
CStrictITIVector< EntryIndex, Fractional > | |
CStrictITIVector< EntryIndex, RowIndex > | |
CStrictITIVector< Index, Fractional > | |
CStrictITIVector< ColIndex, int32 > | |
CStrictITIVector< ColIndex, bool > | |
CStrictITIVector< ColIndex, ColIndex > | |
CStrictITIVector< RowIndex, ConstraintStatus > | |
CStrictITIVector< ColIndex, VariableType > | |
CStrictITIVector< RowIndex, ColIndex > | |
CStrictITIVector< ColIndex, std::string > | |
CStrictITIVector< ColIndex, VariableStatus > | |
CStrictITIVector< RowIndex, RowIndex > | |
CStrictITIVector< RowIndex, int32 > | |
CStrictITIVector< RowIndex, Fractional > | |
CStrictITIVector< ColIndex, operations_research::glop::SparseColumn const * > | |
CStrictITIVector< RowIndex, std::string > | |
CStrictITIVector< ColIndex, EntryIndex > | |
CStrictITIVector< ColIndex, operations_research::glop::SparseColumn > | |
CStrictITIVector< Index, bool > | |
CStrictITIVector< ColIndex, Fractional > | |
CStrictITIVector< IntType, T > | |
CStrongVector< ArcIndex, ArcInfo > | |
CStrongVector< ArcIndex, int > | |
CStrongVector< BooleanVariable, absl::Span< const operations_research::sat::Literal > > | |
CStrongVector< BooleanVariable, bool > | |
CStrongVector< BooleanVariable, BooleanVariable > | |
CStrongVector< BooleanVariable, ClauseIndex > | |
CStrongVector< BooleanVariable, Coefficient > | |
CStrongVector< BooleanVariable, double > | |
CStrongVector< BooleanVariable, int > | |
CStrongVector< BooleanVariable, int64 > | |
CStrongVector< BooleanVariable, operations_research::sat::AssignmentInfo > | |
CStrongVector< BooleanVariable, PQElement > | |
CStrongVector< CandidateIndex, NodeIndex > | |
CStrongVector< ClauseIndex, Clause > | |
CStrongVector< ClauseIndex, operations_research::sat::SatClause * > | |
CStrongVector< ColIndex, int > | |
CStrongVector< ConstraintIndex, absl::StrongVector< TermIndex, operations_research::bop::OneFlipConstraintRepairer::ConstraintTerm > > | |
CStrongVector< ConstraintIndex, bool > | |
CStrongVector< ConstraintIndex, Coefficient > | |
CStrongVector< ConstraintIndex, int64_t > | |
CStrongVector< ConstraintIndex, operations_research::sat::LinearConstraintManager::ConstraintInfo > | |
CStrongVector< ConstraintIndex, TermIndex > | |
CStrongVector< CostClassIndex, operations_research::RoutingModel::CostClass > | |
CStrongVector< DimensionIndex, int > | |
CStrongVector< DimensionIndex, int64 > | |
CStrongVector< DimensionIndex, operations_research::RoutingDimension * > | |
CStrongVector< DisjunctionIndex, Disjunction > | |
CStrongVector< EdgeIndex, operations_research::BlossomGraph::Edge > | |
CStrongVector< glop::ColIndex, bool > | |
CStrongVector< glop::ColIndex, IntegerValue > | |
CStrongVector< glop::RowIndex, IntegerValue > | |
CStrongVector< glop::RowIndex, LinearConstraintInternal > | |
CStrongVector< Index, std::vector< int > > | |
CStrongVector< IndexType, IndexType > | |
CStrongVector< IndexType, T > | |
CStrongVector< IntegerVariable, absl::InlinedVector< ArcIndex, 6 > > | |
CStrongVector< IntegerVariable, absl::InlinedVector< OptionalArcIndex, 6 > > | |
CStrongVector< IntegerVariable, bool > | |
►CStrongVector< IntegerVariable, Domain > | |
CIntegerDomains | |
►CStrongVector< IntegerVariable, double > | |
CLinearProgrammingConstraintLpSolution | |
CStrongVector< IntegerVariable, int > | |
CStrongVector< IntegerVariable, int64 > | |
►CStrongVector< IntegerVariable, IntegerValue > | |
CDebugSolution | |
CStrongVector< IntegerVariable, IntegerVariableSpan > | |
CStrongVector< IntegerVariable, LiteralIndex > | |
CStrongVector< IntegerVariable, operations_research::sat::IncrementalAverage > | |
CStrongVector< IntegerVariable, std::map< IntegerValue, operations_research::sat::Literal > > | |
CStrongVector< IntegerVariable, std::vector< operations_research::sat::ImpliedBoundEntry > > | |
CStrongVector< IntegerVariable, std::vector< WatchData > > | |
CStrongVector< IntegerVariable, uint64 > | |
CStrongVector< IntegerVariable, VarInfo > | |
CStrongVector< IntervalVariable, LiteralIndex > | |
CStrongVector< IntervalVariable, operations_research::sat::AffineExpression > | |
CStrongVector< IntType, uint64_t > | |
CStrongVector< LiteralIndex, absl::InlinedVector< ArcIndex, 6 > > | |
CStrongVector< LiteralIndex, absl::InlinedVector< int32, 6 > > | |
CStrongVector< LiteralIndex, absl::InlinedVector< operations_research::sat::Literal, 6 > > | |
CStrongVector< LiteralIndex, bool > | |
CStrongVector< LiteralIndex, InlinedIntegerLiteralVector > | |
CStrongVector< LiteralIndex, int > | |
CStrongVector< LiteralIndex, IntegerVariable > | |
CStrongVector< LiteralIndex, LiteralIndex > | |
CStrongVector< LiteralIndex, operations_research::sat::Literal > | |
CStrongVector< LiteralIndex, std::vector< ClauseIndex > > | |
CStrongVector< LiteralIndex, std::vector< ConstraintIndexWithCoeff > > | |
CStrongVector< LiteralIndex, std::vector< ImageInfo > > | |
CStrongVector< LiteralIndex, std::vector< operations_research::sat::LiteralWatchers::Watcher > > | |
CStrongVector< LiteralIndex, std::vector< WatchData > > | |
CStrongVector< NodeIndex, int64 > | |
CStrongVector< NodeIndex, NodeIndex > | |
CStrongVector< NodeIndex, operations_research::BlossomGraph::Node > | |
CStrongVector< NodeIndex, std::vector< EdgeIndex > > | |
CStrongVector< OptimizerIndex, int > | |
CStrongVector< OptimizerIndex, operations_research::bop::BopOptimizerBase * > | |
CStrongVector< OptionalArcIndex, ArcInfo > | |
CStrongVector< PositiveOnlyIndex, bool > | |
CStrongVector< PositiveOnlyIndex, std::vector< operations_research::sat::IntegerEncoder::ValueLiteralPair > > | |
CStrongVector< RowIndex, absl::InlinedVector< ColIndex, 6 > > | |
►CStrongVector< RowIndex, bool > | |
CStrictITIVector< RowIndex, bool > | |
CStrongVector< RowIndex, operations_research::glop::SumWithOneMissing > | |
CStrongVector< SparseIndex, BopConstraintTerm > | |
CStrongVector< VariableIndex, absl::StrongVector< EntryIndex, ConstraintEntry > > | |
CStrongVector< VariableIndex, bool > | |
CStrongVector< VariableIndex, std::vector< ConstraintIndex > > | |
CStrongVector< VehicleClassIndex, operations_research::RoutingModel::VehicleClass > | |
►CSubSolver | |
CNeighborhoodGeneratorHelper | |
CSynchronizationPoint | |
CSumWithOneMissing< supported_infinity_is_positive > | |
CSVector< T > | |
CSVector< int > | |
CSVector< int32 > | |
CSweepArranger | Class to arrange indices by by their distance and their angles from the depot |
CSweepIndex | |
CSweepIndexSortAngle | |
CSweepIndexSortDistance | |
►CT | |
Csmall_map< T > | |
Csmall_ordered_set< T > | |
CTailArrayBuilder< GraphType, has_reverse_arcs > | |
CTailArrayBuilder< GraphType, false > | |
CTailArrayManager< GraphType > | |
CTailArrayReleaser< GraphType, has_reverse_arcs > | |
CTailArrayReleaser< GraphType, false > | |
CDisjunctivePropagator::Tasks | A structure to hold tasks described by their features |
CTaskSet | |
CTaskTime | |
CThetaLambdaTree< IntegerType > | |
CThetaLambdaTree< int64 > | |
CThetaLambdaTree< IntegerValue > | |
CThreadPool | |
CTimeLimit | A simple class to enforce both an elapsed time limit and a deterministic time limit in the same thread as a program |
CTopN< Element > | |
CTopN< CutCandidate > | |
CTopNCuts | |
CTopologicalSorter< T, stable_sort, Hash, KeyEqual > | |
►CTopologicalSorter< T, false, typename absl::flat_hash_map< T, int >::hasher, typename absl::flat_hash_map< T, int, typename absl::flat_hash_map< T, int >::hasher >::key_equal > | |
CTopologicalSorter< T, stable_sort, Hash, KeyEqual > | |
CTrail | |
CTrail | |
CTransparentLess | |
CTravelBounds | |
CTravelingSalesmanLowerBoundParameters | |
►Ctrue_type | |
CUnordered< T, absl::void_t< typename T::hasher > > | |
CTypeRegulationsChecker::TypePolicyOccurrence | |
►CTypeRegulationsChecker | |
CTypeIncompatibilityChecker | Checker for type incompatibilities |
CTypeRequirementChecker | Checker for type requirements |
CUnaryDimensionChecker | |
CUndirectedAdjacencyListsOfDirectedGraph< Graph > | |
CUnsortedNullableRevBitset | This class represents a reversible bitset |
CUpdateRow | |
CUpperBoundedLinearConstraint | |
CValueDeleter | |
CIntegerEncoder::ValueLiteralPair | |
CVarDomination | |
CPseudoCosts::VariableBoundChange | |
CVariableRefOrValue | |
CVariableRefOrValueArray | |
CVariablesAssignment | |
CVariablesInfo | |
CVariableValues | |
CVariableWithSameReasonIdentifier | |
CVarValue | |
►Cvector< T > | STL class |
CLinearProgrammingConstraintCollection | |
CVectorMap< T > | |
CVectorOrFunction< ScalarType, Evaluator > | |
CVectorOrFunction< ScalarType, std::vector< ScalarType > > | |
CRoutingModel::VehicleClass | |
CRoutingModel::VehicleTypeContainer::VehicleClassEntry | |
CRoutingModel::VehicleTypeContainer | Struct used to sort and store vehicles by their type |
CVehicleTypeCurator | Helper class that manages vehicles |
CVModuleInfo | |
CVolgenantJonkerEvaluator< CostType > | |
►CWallTimer | |
CCycleTimer | |
CLiteralWatchers::Watcher | |
Cyy_buffer_state | |
Cyy_trans_info | |
Cyyalloc | |
Cyyguts_t | |
Cyypcontext_t | |
CZeroHalfCutHelper | |
CZVector< T > | |
CZVector< ArcIndex > | |
CZVector< ArcIndexType > | |
CZVector< CostValue > | |
CZVector< FlowQuantity > | |
CZVector< NodeHeight > | |
CZVector< NodeIndex > | |
CZVector< NodeIndexType > | |