| NGecode | Gecode toplevel namespace |
| NCPProfiler | Code that is specific to the CPProfiler |
| CConnector | |
| CMessage | Message for the CP Profiler |
| CMessageMarshalling | |
| CNode | |
| CNodeUID | Unique identifier for a node |
| COption | Optional value class |
| NDriver | Script commandline driver |
| CBaseOption | Base class for options |
| CBoolOption | Boolean option |
| CCombinedStop | Stop object based on nodes, failures, and time |
| CDoubleOption | Double option |
| CEngineToMeta | Wrapper class to add engine template argument |
| CExtractStepOption | Class to extract the step option value |
| CGistEngine | Traits class for search engines |
| CGistEngine< BAB< S > > | Specialization for BAB |
| CGistEngine< DFS< S > > | Specialization for DFS |
| CGistEngine< LDS< S > > | Specialization for LDS |
| CIgnoreStepOption | Class to ignore the step option value |
| CIntOption | Integer option |
| CIplOption | Integer propagation level option |
| CProfilerOption | Profiler option |
| CScriptBase | Parametric base-class for scripts |
| CScriptGetInfo | Class to send solution information to CPProfiler for a script |
| CStringOption | String-valued option (integer value defined by strings) |
| CValue | Option value |
| CStringValueOption | String-valued option |
| CTraceOption | Trace flag option |
| CUnsignedIntOption | Unsigned integer option |
| CUnsignedLongLongIntOption | Unsigned long long integer option |
| NFlatZinc | Interpreter for the FlatZinc language |
| NAST | Abstract syntax trees for the FlatZinc interpreter |
| CTypeError | Exception signaling type error |
| CNode | A node in a FlatZinc abstract syntax tree |
| CBoolLit | Boolean literal node |
| CIntLit | Integer literal node |
| CFloatLit | Float literal node |
| CSetLit | Set literal node |
| CVar | Variable node base class |
| CBoolVar | Boolean variable node |
| CIntVar | Integer variable node |
| CFloatVar | Float variable node |
| CSetVar | Set variable node |
| CArray | Array node |
| CCall | Node representing a function call |
| CArrayAccess | Node representing an array access |
| CAtom | Node representing an atom |
| CString | String node |
| CAlias | Alias for a variable specification |
| CBlackBoxAccess | Access to the model-local blackbox context while posting and searching |
| CBlackBoxBackend | Backend for a deterministic FlatZinc blackbox function |
| CBlackBoxCall | Inputs and pre-sized output buffers for one backend call |
| CBlackBoxContextHandle | Model-local context shared by blackbox propagators and search support |
| CBlackBoxExec | Persistent-process backend shared by equal executable configurations |
| CBlackBoxLibrary | Dynamic-library backend owned by one blackbox constraint |
| CBlackBoxProcessSession | Platform process session used by the executable blackbox backend |
| CBoolVarSpec | Specification for Boolean variables |
| CBranchInformation | |
| CComplete | |
| CConExpr | Abstract representation of a constraint |
| CError | Exception class for FlatZinc errors |
| CFlatZincOptions | Options for running FlatZinc models |
| CFlatZincSpace | A space that can be initialized with a FlatZinc model |
| COnRestartHandle | |
| COnRestartData | |
| CFloatVarSpec | Specification for floating point variables |
| CIntBoolBrancher | Brancher for integer and Boolean views |
| CIntBoolBrancherBase | Base-class for brancher for integer and Boolean views |
| CIntBoolVarBranch | Which integer or Boolean variable to select for branching |
| CIntVarSpec | Specification for integer variables |
| CLastVal | |
| CMeritMaxAction | Select by maximal Action |
| CMeritMaxActionSize | Select by maximal Action over size |
| CMeritMaxAFC | Select by maximal AFC |
| CMeritMaxAFCSize | Select by maximal AFC over size |
| CMeritMaxCHB | Select by maximal CHB |
| CMeritMaxCHBSize | Select by maximal CHB over size |
| COption | Optional value |
| COutputOrder | Strict weak ordering for output items |
| CParserState | State of the FlatZinc parser |
| CPosIntChoice | Choice storing position and value |
| CPrinter | Output support class for FlatZinc interpreter |
| CRegistry | Map from constraint identifier to constraint posting functions |
| CSetBoolLastVal | |
| CSetFloatLastVal | |
| CSetIntLastVal | |
| CSetIntSetLastVal | |
| CSetVarSpec | Specification for set variables |
| CSymbolEntry | Entries in the symbol table |
| CSymbolTable | Symbol table mapping identifiers (strings) to values |
| CVarSpec | Base class for variable specifications |
| NFloat | Floating point numbers |
| NArithmetic | Arithmetic propagators |
| CAbs | Propagator for bounds consistent absolute operator |
| CDiv | Propagator for bounds division operator |
| CMax | Propagator for bounds consistent max operator |
| CMin | Propagator for bounds consistent min operator |
| CMult | Bounds consistent multiplication propagator |
| CMultPlus | Bounds consistent positive multiplication propagator |
| CMultZeroOne | Bounds or domain consistent propagator for \(x_0\times x_1=x_0\) |
| CNaryMax | Bounds consistent n-ary maximum propagator |
| CNonZero | Propagator maintaining that a float view does not contain zero |
| CNthRoot | Propagator for bounds consistent nth root operator |
| CPow | Propagator for bounds consistent pow operator |
| CSqr | Propagator for bounds consistent square operator |
| CSqrPlus | Bounds consistent positive square propagator |
| CSqrt | Propagator for bounds consistent square root operator |
| NBool | Boolean propagators |
| CIte | If-then-else propagator |
| NBranch | Float branchers |
| CMeritMin | Merit class for minimum |
| CMeritMax | Merit class for maximum of float view |
| CMeritSize | Merit class for size of float view |
| CMeritDegreeSize | Merit class for degree over size |
| CMeritAFCSize | Merit class for AFC over size |
| CMeritActionSize | Merit class for action over size |
| CMeritCHBSize | Merit class for CHB Q-score over size |
| CValSelLq | Value selection class for values smaller than median of view |
| CValSelGq | Value selection class for values smaller than median of view |
| CValSelRnd | Value selection class for random value of view |
| CValCommitLqGq | Value commit class for less or equal or greater or equal |
| NChannel | Channel propagators |
| CChannel | Propagator for bounds consistent integer part operator |
| NLinear | Linear propagators |
| CLin | Base-class for n-ary linear propagators |
| CEq | Propagator for bounds consistent n-ary linear equality |
| CLq | Propagator for bounds consistent n-ary linear less or equal |
| CTerm | Class for describing linear term \(a\cdot x\) |
| NRel | Simple relation propagators |
| CEq | Binary bounds consistent equality propagator |
| CNaryEq | N-ary bounds consistent equality propagator |
| CReEq | Reified binary bounds consistent equality propagator |
| CReEqFloat | Reified bounds consistent equality with float propagator |
| CNq | Binary bounds consistent disequality propagator |
| CNqFloat | Binary bounds consistent disequality propagator with float value |
| CLq | Less or equal propagator |
| CLe | Less propagator |
| CReLqFloat | Reified less or equal with float propagator |
| CReLeFloat | Reified less with float propagator |
| CReLq | Reified less or equal propagator |
| NTranscendental | Transcendental propagators |
| CExp | Propagator for bounds consistent exp operator |
| CPow | Propagator for bounds consistent pow operator |
| NTrigonometric | Trigonometric propagators |
| CSin | Propagator for bounds consistent sinus operator |
| CCos | Propagator for bounds consistent cosinus operator |
| CASin | Propagator for bounds consistent arc sinus operator |
| CACos | Propagator for bounds consistent arc cosinus operator |
| CTan | Propagator for bounds consistent tangent operator |
| CATan | Propagator for bounds consistent arc tangent operator |
| CArgumentSame | Exception: Arguments contain same variable multiply |
| CArgumentSizeMismatch | Exception: Arguments are of different size |
| CFloatDelta | Float delta information for advisors |
| CFloatTraceView | Float trace view |
| CFloatVarImp | Float variable implementation |
| CFloatVarImpBase | Base-class for Float-variable implementations |
| CFloatVarImpConf | Configuration for Float-variable implementations |
| CFloatView | Float view for float variables |
| CIllegalOperation | Exception: Illegal operation passed as argument |
| CMinusView | Minus float view |
| COffsetView | OffsetView float view |
| COutOfLimits | Exception: Value out of limits |
| CRounding | Floating point rounding policy |
| CScaleView | Scale float view |
| CTooFewArguments | Exception: Too few arguments available in argument array |
| CUnknownBranching | Exception: Unknown value or variable selection passed as argument |
| CUnknownOperation | Exception: Unknown operation passed as argument |
| CUnknownRelation | Exception: Unknown relation passed as argument |
| CValOfUnassignedVar | Exception: Attempt to access value of unassigned variable |
| CValueMixedSign | Exception: Value with mixed sign |
| CVariableEmptyDomain | Exception: Variable created with empty domain |
| NGist | The Gecode Interactive Search Tool |
| CAboutGist | Display information about Gist |
| CBestNode | Static reference to the currently best space |
| CBoundingBox | Bounding box |
| CBranchLabelCursor | A cursor that labels branches |
| CComparator | Abstract base class for comparators |
| CDisposeCursor | A cursor that frees all memory |
| CDrawingCursor | A cursor that draws a tree on a QWidget |
| CExtent | Extent representing shape of a tree at one depth level |
| CGist | Gecode Interactive Search Tool |
| CGistMainWindow | Main window for stand-alone Gist |
| CHideFailedCursor | A cursor that marks failed subtrees as hidden |
| CInspector | Abstract base class for inspectors |
| CLayout | Layout parameters |
| CLayoutCursor | A cursor that computes a tree layout for VisualNodes |
| CLogos | Class holding Gecode and Gist logo icons |
| CNextSolCursor | A cursor that finds the next solution |
| CNode | Base class for nodes of the search tree |
| CNodeAllocatorBase | Node allocator |
| CNodeCursor | A cursor that can be run over a tree |
| CNodeStatInspector | Display information about nodes |
| CNodeVisitor | Base class for a visitor that runs a cursor over a tree |
| CNodeWidget | Small node drawings for the status bar |
| COptions | Options for Gist |
| CI_ | Helper class storing inspectors |
| CPostorderNodeVisitor | Run a cursor over a tree, processing nodes in post-order |
| CPreferencesDialog | Preferences dialog for Gist |
| CPreorderNodeVisitor | Run a cursor over a tree, processing nodes in pre-order |
| CPrint | An inspector for printing simple text output |
| CSearcherThread | A thread that concurrently explores the tree |
| CShape | The shape of a subtree |
| CSpaceNode | A node of a search tree of Gecode spaces |
| CStatCursor | A cursor that collects statistics |
| CStatistics | Statistics about the search tree |
| CStopBrancher | Brancher that stops exploration in Gist |
| CStopChoice | Choice for StopBrancher |
| CTextOutput | An window for simple text output |
| CTextOutputI | Window with associated ostream, used for inspecting Gist nodes |
| CTreeCanvas | A canvas that displays the search tree |
| CUnhideAllCursor | A cursor that marks all nodes in the tree as not hidden |
| CUnstopAllCursor | A cursor that marks all nodes in the tree as not stopping |
| CVarComparator | A simple comparator |
| CVisualNode | Node class that supports visual layout |
| NInt | Finite domain integers |
| NArithmetic | Numerical (arithmetic) propagators |
| CAbsBnd | Bounds consistent absolute value propagator |
| CAbsDom | Domain consistent absolute value propagator |
| CArgMax | Argument maximum propagator |
| CDivBnd | Bounds consistent division propagator |
| CDivMod | Integer division/modulo propagator |
| CDivPlusBnd | Bounds consistent positive division propagator |
| CMaxBnd | Bounds consistent ternary maximum propagator |
| CMaxDom | Domain consistent ternary maximum propagator |
| CMultBnd | Bounds consistent multiplication propagator |
| CMultDom | Domain consistent multiplication propagator |
| CMultPlusBnd | Bounds consistent positive multiplication propagator |
| CMultPlusDom | Domain consistent positive multiplication propagator |
| CMultZeroOne | Bounds or domain consistent propagator for \(x_0\times x_1=x_0\) |
| CNaryMaxBnd | Bounds consistent n-ary maximum propagator |
| CNaryMaxDom | Domain consistent n-ary maximum propagator |
| CNrootBnd | Bounds consistent n-th root propagator |
| CNrootDom | Domain consistent n-th root propagator |
| CNrootPlusBnd | Positive bounds consistent n-th root propagator |
| CNrootPlusDom | Domain consistent n-th root propagator |
| CPowBnd | Bounds consistent power propagator |
| CPowDom | Domain consistent power propagator |
| CPowOps | Operations for power and nroot propagators |
| CPowPlusBnd | Bounds consistent positive power propagator |
| CPowPlusDom | Domain consistent positive power propagator |
| CRangesMapNroot | Mapping integer to n-th root |
| CRangesMapPow | Mapping ranges to powers |
| CSqrOps | Operations for square and square-root propagators |
| CValuesMapNroot | Mapping integer (must be an n-th power) to n-th root |
| CValuesMapNrootSigned | Mapping integer (must be an n-th power) to n-th root (signed) |
| CValuesMapPow | Mapping integer to power |
| NBinPacking | Bin-packing propagators |
| CItem | Item combining bin and size information |
| CSizeSet | Size sets |
| CSizeSetMinusOne | Size sets with one element discarded |
| CLambdaRange | Range of lambda values |
| CPack | Bin-packing propagator |
| CConflictGraph | Graph containing conflict information |
| CNodeSet | Sets of graph nodes |
| CNode | Class for node in graph |
| CNodes | Iterator over node sets |
| CClique | Clique information |
| NBool | Boolean propagators |
| CBinOrTrue | Binary Boolean disjunction propagator (true) |
| CBoolBinary | Base-class for binary Boolean propagators |
| CBoolTernary | Base-class for ternary Boolean propagators |
| CClause | Boolean clause propagator (disjunctive) |
| CTagged | Advisors for views (tagged whether for x or y) |
| CClauseTrue | Boolean clause propagator (disjunctive, true) |
| CEq | Boolean equality propagator |
| CEqv | Boolean equivalence propagator |
| CIteBase | If-then-else propagator base-class |
| CIteBnd | If-then-else bounds-consistent propagator |
| CIteDom | If-then-else domain-consistent propagator |
| CLe | Boolean less propagator |
| CLq | Boolean less or equal propagator |
| CNaryEq | N-ary Boolean equality propagator |
| CNaryEqv | Boolean n-ary equivalence propagator |
| CNaryLq | Nary Boolean less or equal propagator |
| CNaryOr | Boolean n-ary disjunction propagator |
| CNaryOrTrue | Boolean n-ary disjunction propagator (true) |
| COr | Boolean disjunction propagator |
| COrTrueSubsumed | Binary Boolean disjunction propagator (subsumed) |
| CQuadOrTrue | Quarternary Boolean disjunction propagator (true) |
| CTerOrTrue | Ternary Boolean disjunction propagator (true) |
| NBranch | Integer branchers |
| CEqNGL | No-good literal for equality |
| CGqNGL | No-good literal for greater or equal |
| CLqNGL | No-good literal for less or equal |
| CMeritActionSize | Merit class for action over size |
| CMeritAFCSize | Merit class for AFC over size |
| CMeritCHBSize | Merit class for CHB over size |
| CMeritDegreeSize | Merit class for degree over size |
| CMeritMax | Merit class for maximum |
| CMeritMin | Merit class for minimum of integer views |
| CMeritRegretMax | Merit class for maximum regret |
| CMeritRegretMin | Merit class for minimum regret |
| CMeritSize | Merit class for size |
| CNqNGL | No-good literal for disequality |
| CPosValuesChoice | Choice storing position and values for integer views |
| CValCommitEq | Value commit class for equality |
| CValCommitGq | Value commit class for greater or equal |
| CValCommitGr | Value commit class for greater |
| CValCommitLq | Value commit class for less or equal |
| CValSelAvg | Value selection class for average of view |
| CValSelMax | Value selection class for maximum of view |
| CValSelMed | Value selection class for median of view |
| CValSelMin | Value selection class for minimum of view |
| CValSelRangeMax | Value selection class for maximum range of integer view |
| CValSelRangeMin | Value selection class for minimum range of integer view |
| CValSelRnd | Value selection class for random value of view |
| CViewValuesBrancher | Brancher by view and values selection |
| NChannel | Channel propagators |
| CBase | Base-class for channel propagators |
| CDom | Domain consistent channel propagator |
| CDomInfo | Combine view with information for domain propagation |
| CLinkMulti | Link propagator for multiple Boolean views |
| CLinkSingle | Link propagator for a single Boolean view |
| CVal | Naive channel propagator |
| CValInfo | Combine view with information for value propagation |
| NCircuit | Circuit propagators |
| CBase | Base-class for circuit propagator |
| CDom | "Domain consistent" circuit propagator |
| CNodeInfo | Information required for non-recursive checking for a single scc |
| CTellInfo | Information for performing a recorded tell |
| CVal | "Value-consistent" circuit propagator |
| NCount | Counting propagators |
| CIntBase | Baseclass for count propagators (integer) |
| CEqInt | Propagator for counting views (equal integer to number of equal views) |
| CGqInt | Propagator for counting views (greater or equal integer to number of equal views) |
| CLqInt | Propagator for counting views (less or equal integer to number of equal views) |
| CViewBase | Base-class for count propagators (view) |
| CEqView | Propagator for counting views (equal to number of equal views) |
| CLqView | Propagator for counting views (less or equal to number of equal views) |
| CGqView | Propagator for counting views (greater or equal to number of equal views) |
| NCumulative | Scheduling for cumulative resources |
| CExtOmegaNode | Node for an extended omega tree |
| CExtOmegaTree | Omega trees for computing ect of task sets |
| CManFixPSETask | Cumulative (mandatory) task with fixed processing, start or end time |
| CManFixPTask | Cumulative (mandatory) task with fixed processing time |
| CManFlexTask | Cumulative (mandatory) task with flexible processing time |
| CManProp | Scheduling propagator for cumulative resource with mandatory tasks |
| COmegaLambdaNode | Node for an omega lambda tree |
| COmegaLambdaTree | Omega-lambda trees for computing ect of task sets |
| COmegaNode | Node for an omega tree |
| COmegaTree | Omega trees for computing ect of task sets |
| COptFixPSETask | Cumulative optional task with fixed processing, start or end time |
| COptFixPTask | Cumulative optional task with fixed processing time |
| COptFlexTask | Cumulative optional task with flexible processing time |
| COptProp | Scheduling propagator for cumulative resource with optional tasks |
| CPrecOrder | Sort by prec array |
| CStoCap | Sort by capacity |
| CTaskByDecCap | Sort order for tasks by decreasing capacity |
| NCumulatives | Cumulatives propagators |
| CEvent | An event collects the information for one event for the sweep-line |
| CVal | Propagator for the cumulatives constraint |
| NDistinct | Distinct propagators |
| CBnd | Bounds consistent distinct propagator |
| CDom | Domain consistent distinct propagator |
| CDomCtrl | Propagation controller for domain consistent distinct |
| CEqIte | Equal-if-then-else domain-consistent propagator |
| CGraph | View-value graph for propagation |
| CHallInfo | Information on Hall intervals |
| CMaxIncIdx | Sort-order by increasing maximum (by index) |
| CMinInc | Sort-order by increasing minimum (direct) |
| CMinIncIdx | Sort-order by increasing minimum (by index) |
| CRank | Rank information |
| CTerDom | Ternary domain consistent distinct propagator |
| CVal | Naive value distinct propagator |
| NDom | Domain propagators |
| CReRange | Reified range dom-propagator |
| CReIntSet | Reified domain dom-propagator |
| NElement | Element propagators |
| CInt | Element propagator for array of integers |
| CIdxVal | Linked index-value pairs |
| CIterIdxUnmark | Value iterator for indices in index-value map |
| CIterVal | Value iterator for values in index-value map |
| CIterValUnmark | Value iterator for values in index-value map |
| CByVal | Sorting pointers to (index,value) pairs in value order |
| CIterIdxView | Value iterator for indices in index-view map |
| CPair | Domain consistent pair propagator |
| CPairWithOffsets | Domain consistent pair-with-offsets propagator |
| CRelTestBnd | Class for bounds-equality test |
| CRelTestBnd< VA, ConstIntView > | Class for bounds-equality test (specialized) |
| CRelTestDom | Class for domain-equality test |
| CRelTestDom< VA, ConstIntView > | Class for domain-equality test (specialized) |
| CView | Base-class for element propagator for array of views |
| CViewBnd | Bounds consistent element propagator for array of views |
| CViewDom | Domain consistent element propagator for array of views |
| NExec | Synchronized execution |
| CWhen | Conditional propagator |
| NExtensional | Extensional propagators |
| CBitSet | Bit-set |
| CCompact | Base class for compact table propagator |
| CValidSupports | Iterator over valid supports |
| CLostSupports | Iterator over lost supports |
| CCompactActorFactory | |
| CCompactAdvisor | Advisor shared by compact-table support representations |
| CCompactAdvisorIndex | Optional variable index stored by a compact-table advisor |
| CCompactAdvisorIndex< false > | Compact-table advisor without a variable index |
| CCompactAdvisorIndex< true > | Compact-table advisor with a variable index |
| CCompactCompressed | |
| CValidSupports | |
| CLostSupports | |
| CCompactStatus | Touched-advisor status shared by positive compact-table propagators |
| CCompactSupportPolicy | |
| CCompactSupportPolicy< CompressedSupport > | |
| CCompactSupportPolicy< const BitSetData * > | |
| CCompressedSupport | Compressed tuple-word support list |
| CLayeredGraph | Domain consistent layered graph (regular) propagator |
| CState | States are described by number of incoming and outgoing edges |
| CEdge | Edge defined by in-state and out-state |
| CSupport | Support information for a value |
| CLayer | Layer for a view in the layered graph |
| CLayerValues | Iterator for telling variable domains by scanning support |
| CIndex | Advisors for views (by position in array) |
| CIndexRange | Range approximation of which positions have changed |
| CNegCompact | Domain consistent negative extensional propagator |
| CNegCompactAlgorithm | Shared implementation of negative compact-table propagation |
| CNegCompactCompressed | |
| CPosCompact | Domain consistent positive extensional propagator |
| CPosCompactAlgorithm | Shared implementation of positive compact-table propagation |
| CPosCompactCompressed | |
| CReCompact | Domain consistent reified extensional propagator |
| CReCompactActorFactory | |
| CReCompactAlgorithm | Shared implementation of reified compact-table propagation |
| CReCompactCompressed | |
| CTinyBitSet | Tiny bit-set |
| CTupleSetAccess | Internal access to finalized tuple-set support representations |
| CVarTraits | Traits class for variables |
| CVarTraits< BoolVar > | Traits class for variables |
| CVarTraits< IntVar > | Traits class for variables |
| NGCC | Global cardinality propagators (Counting) |
| CBnd | Bounds consistent global cardinality propagator |
| CCardConst | Constant view containing lower and upper cardinality bounds |
| CCardLess | Sort by increasing cardinality |
| CCardView | Cardinality integer view |
| CDom | Domain consistent global cardinality propagator |
| CEdge | Class for edges \( e(x,v) \) in the variable-value-graph |
| CHallInfo | Container class providing information about the Hall structure of the problem variables |
| CMaxInc | Compares two indices i, j of two views \( x_i \) \( x_j\) according to the ascending order of the views upper bounds |
| CMinIdx | Compares two cardinality views \( x_i \) \( x_j\) according to the index |
| CMinInc | Compares two indices i, j of two views \( x_i \) \( x_j\) according to the ascending order of the views lower bounds |
| CNode | Base class for nodes in the variable-value-graph |
| CPartialSum | Partial sum structure for constant time computation of the maximal capacity of an interval |
| CRank | Maps domain bounds to their position in hall[].bounds |
| CUnReachable | Class for computing unreachable values in the value GCC propagator |
| CVal | Value consistent global cardinality propagator |
| CValNode | Value node |
| CVarNode | Variable node |
| CVarValGraph | Variable-value-graph used during propagation |
| NLDSB | Symmetry breaking for integer variables |
| CLiteral | A Literal is a pair of variable index and value |
| CSymmetryObject | Implementation of a symmetry at the modelling level |
| CVariableSymmetryObject | Implementation of a variable symmetry at the modelling level |
| CValueSymmetryObject | Implementation of a value symmetry at the modelling level |
| CVariableSequenceSymmetryObject | Implementation of a variable sequence symmetry at the modelling level |
| CValueSequenceSymmetryObject | Implementation of a value sequence symmetry at the modelling level |
| CSymmetryImp | Implementation of a single symmetry |
| CVariableSymmetryImp | Implementation of a variable symmetry |
| CValueSymmetryImp | Implementation of a value symmetry |
| CVariableSequenceSymmetryImp | Implementation of a variable sequence symmetry |
| CValueSequenceSymmetryImp | Implementation of a value sequence symmetry |
| CLDSBChoice | Choice storing position and value, and symmetric literals to be excluded on the right branch |
| CLDSBBrancher | Symmetry-breaking brancher with generic view and value selection |
| NLinear | Linear propagators |
| CBoolNegTraits | Traits for Boolean negation view |
| CBoolNegTraits< BoolView > | Traits for Boolean negation view |
| CBoolNegTraits< NegBoolView > | Traits for Boolean negation view |
| CDomEq | Propagator for domain consistent n-ary linear equality |
| CEmptyScaleBoolArray | Empty array of scale Boolean views |
| CEq | Propagator for bounds consistent n-ary linear equality |
| CEqBin | Propagator for bounds consistent binary linear equality |
| CEqBoolInt | Propagator for integer equal to Boolean sum (cardinality) |
| CEqBoolScale | Propagator for equality to Boolean sum with coefficients |
| CEqBoolView | Propagator for equality to Boolean sum (cardinality) |
| CEqTer | Propagator for bounds consistent ternary linear equality |
| CGqBin | Propagator for bounds consistent binary linear greater or equal |
| CGqBoolInt | Propagator for integer less or equal to Boolean sum (cardinality) |
| CGqBoolView | Propagator for greater or equal to Boolean sum (cardinality) |
| CLin | Base-class for n-ary linear propagators |
| CLinBin | Base-class for binary linear propagators |
| CLinBoolInt | Baseclass for integer Boolean sum |
| CLinBoolScale | Base class for linear Boolean constraints with coefficients |
| CLinBoolView | Base-class for Boolean linear propagators |
| CLinTer | Base-class for ternary linear propagators |
| CLq | Propagator for bounds consistent n-ary linear less or equal |
| CLqBin | Propagator for bounds consistent binary linear less or equal |
| CLqBoolScale | Propagator for inequality to Boolean sum with coefficients |
| CLqTer | Propagator for bounds consistent ternary linear less or equal |
| CNegSupportIter | Support-based iterator for negative view |
| CNoView | No view serves as filler for empty view arrays |
| CNq | Propagator for bounds consistent n-ary linear disequality |
| CNqBin | Propagator for bounds consistent binary linear disequality |
| CNqBoolInt | Propagator for integer disequal to Boolean sum (cardinality) |
| CNqBoolScale | Propagator for disequality to Boolean sum with coefficients |
| CNqBoolView | Propagator for disequality to Boolean sum (cardinality) |
| CNqTer | Propagator for bounds consistent ternary linear disquality |
| CPosSupportIter | Support-based iterator for positive view |
| CReEq | Propagator for reified bounds consistent n-ary linear equality |
| CReEqBin | Propagator for reified bounds consistent binary linear equality |
| CReEqBoolInt | Propagator for reified integer equal to Boolean sum (cardinality) |
| CReGqBoolInt | Propagator for reified integer less or equal to Boolean sum (cardinality) |
| CReLin | Base-class for reified n-ary linear propagators |
| CReLinBin | Base-class for reified binary linear propagators |
| CReLinBoolInt | Baseclass for reified integer Boolean sum |
| CReLq | Propagator for reified bounds consistent n-ary linear less or equal |
| CReLqBin | Propagator for reified bounds consistent binary linear less or equal |
| CScaleBool | Coefficient and Boolean view |
| CScaleBoolArray | Array of scale Boolean views |
| CSupportIter | Base-class for support-based iterator |
| CSupportSet | Set for support information |
| CTerm | Class for describing linear term \(a\cdot x\) |
| CTermBySizePos | Sort linear terms by coefficient size and original position |
| CTermByView | Sort linear terms by view |
| NMember | Membership propagators |
| CProp | Membership propagator |
| CReProp | Reified membership propagator |
| NNoOverlap | No-overlap propagators |
| CFixDim | Dimension combining coordinate and integer size information |
| CFlexDim | Dimension combining coordinate and integer view size information |
| CManBox | Mandatory box class |
| COptBox | Optional box class |
| CBase | Base class for no-overlap propagator |
| CManProp | No-overlap propagator for mandatory boxes |
| COptProp | No-overlap propagator for optional boxes |
| NNValues | Number of values propagators |
| CRangeEvent | Event for range-based overlap analysis |
| CSymBitMatrix | Symmetric diagonal bit matrix |
| CGraph | View-value graph for propagation of upper bound |
| CIntBase | Number of values propagator for integer views base class |
| CEqInt | Equal to number of values propagator for integer views |
| CLqInt | Less or equal to number of values propagator for integer views |
| CGqInt | Greater or equal to number of values propagator for integer views |
| CBoolBase | Number of values propagator for Boolean views base class |
| CEqBool | Equal to number of values propagator for Boolean views |
| CLqBool | Less or equal to number of values propagator for Boolean views |
| CGqBool | Greater or equal to number of values propagator for Boolean views |
| NOrder | Int for ordering two tasks |
| COrderProp | Scheduling propagator for ordering two tasks |
| NPrecede | Value precedence propagators |
| CSingle | Single value precedence propagator |
| CIndex | Advisors for views (by position in array) |
| NRel | Simple relation propagators |
| CEqDom | Binary domain consistent equality propagator |
| CEqVal | Binary value propagation equality propagator |
| CEqBnd | Binary bounds consistent equality propagator |
| CNaryEqDom | N-ary domain consistent equality propagator |
| CNaryEqBnd | N-ary bounds consistent equality propagator |
| CNaryLqLe | N-ary less and less or equal propagator |
| CIndex | Advisors for views (by position in array) |
| CPos | Positions in view array that have to be propagated |
| CNaryNq | Nary disequality propagator |
| CReEqDom | Reified binary domain consistent equality propagator |
| CReEqBnd | Reified binary bounds consistent equality propagator |
| CReEqDomInt | Reified domain consistent equality with integer propagator |
| CReEqBndInt | Reified bounds consistent equality with integer propagator |
| CNq | Binary disequality propagator |
| CLq | Less or equal propagator |
| CLe | Less propagator |
| CReLq | Reified less or equal propagator |
| CReLqInt | Reified less or equal with integer propagator |
| CLexLqLe | Lexical ordering propagator |
| CLexNq | Lexical disequality propagator |
| NSequence | Sequence propagators |
| CSequence | Sequence propagator for array of integers |
| CSupportAdvisor | Class for advising the propagator |
| CViewValSupport | Class for view value support structure |
| CViewValSupportArray | An array of ViewValSupport data structures |
| CViolations | Simple bitsets for recording violations |
| NSorted | Sorted propagators |
| COfflineMin | Offline-Min datastructure Used to compute the perfect matching between the unsorted views x and the sorted views y |
| COfflineMinItem | Item used to construct the OfflineMin sequence |
| CRank | Storage class for mininmum and maximum of a variable |
| CSccComponent | Representation of a strongly connected component |
| CSorted | Bounds consistent sortedness propagator |
| CTupleMaxInc | Index comparison for ViewArray<Tuple> |
| CTupleMaxIncExt | Extended Index comparison for ViewArray<Tuple> |
| CTupleMinInc | View comparison on ViewTuples |
| CTupleMinIncExt | Extended view comparison on pairs of views |
| CViewPair | Pair of views |
| NUnary | Int for unary resources |
| CManFixPTask | Unary (mandatory) task with fixed processing time |
| CManFixPSETask | Unary (mandatory) task with fixed processing, start or end time |
| COptFixPTask | Unary optional task with fixed processing time |
| COptFixPSETask | Unary optional task with fixed processing, start or end time |
| CManFlexTask | Unary (mandatory) task with flexible processing time |
| COptFlexTask | Unary optional task with flexible processing time |
| COmegaNode | Node for an omega tree |
| COmegaTree | Omega trees for computing ect of task sets |
| COmegaLambdaNode | Node for an omega lambda tree |
| COmegaLambdaTree | Omega-lambda trees for computing ect of task sets |
| CManProp | Scheduling propagator for unary resource with mandatory tasks |
| COptProp | Scheduling propagator for unary resource with optional tasks |
| NViewValGraph | Support classes for propagators using a view-value graph |
| CCombPtrFlag | Class for combining two pointers with a flag |
| CBiLink | Bidirectional links for edges and anchors in nodes of view-value graph |
| CEdge | Edges in view-value graph |
| CNode | Base-class for nodes (both view and value nodes) |
| CValNode | Value nodes in view-value graph |
| CViewNode | View nodes in view-value graph |
| CIterPruneVal | Iterates the values to be pruned from a view node |
| CGraph | View-value graph base class |
| CAlreadyFinalized | Exception: Tuple set already finalized |
| CArgumentSame | Exception: Arguments contain same variable multiply |
| CArgumentSizeMismatch | Exception: Arguments are of different size |
| CBoolTraceView | Duplicate of a Boolean view |
| CBoolVarImp | Boolean variable implementation |
| CBoolVarImpBase | Base-class for Bool-variable implementations |
| CBoolVarImpConf | Configuration for Bool-variable implementations |
| CBoolView | Boolean view for Boolean variables |
| CCachedView | Cached integer view |
| CConstIntView | Constant integer view |
| CEvent | Time-tabling event for task |
| CFwdToBwd | Task mapper: turns a task view into its dual |
| CIdxView | Class for pair of index and view |
| CIdxViewArray | An array of IdxView pairs |
| CIllegalOperation | Exception: Illegal operation passed as argument |
| CIntDelta | Integer delta information for advisors |
| CIntTraceView | Duplicate of an integer view |
| CIntVarImp | Integer variable implementation |
| CRangeList | Lists of ranges (intervals) |
| CIntVarImpBase | Base-class for Int-variable implementations |
| CIntVarImpBwd | Backward iterator for ranges of integer variable implementations |
| CIntVarImpConf | Configuration for Int-variable implementations |
| CIntVarImpFwd | Range iterator for ranges of integer variable implementation |
| CIntView | Integer view for integer variables |
| CLDSBBadValueSelection | Exception: Value selection incompatible with LDSB |
| CLDSBUnbranchedVariable | Exception: Variable in symmetry not branched on |
| CManTaskViewIter | Allows to iterate over mandatory task views according to a specified order |
| CManToOptTask | Class to define an optional from a mandatory task |
| CMinusView | Minus integer view |
| CNegBoolView | Negated Boolean view |
| CNoOffset | Converter without offsets |
| CNotYetFinalized | Exception: Tuple set not yet finalized |
| CNotZeroOne | Exception: Not 0/1 integer |
| COffset | Converter with fixed offset |
| COffsetView | Offset integer view |
| COutOfLimits | Exception: Value out of limits |
| CPLA | Class for defining advanced propagation level |
| CPLB | Class for defining basic propagation level |
| CPLBA | Class for defining basic and advanced propagation level |
| CReBinaryPropagator | Reified binary propagator |
| CReMixBinaryPropagator | Reified mixed binary propagator |
| CReUnaryPropagator | Reified unary propagator |
| CScaleView | Scale integer view (template) |
| CSortMap | Sorting maps rather than tasks |
| CStoEct | Sort by earliest completion times |
| CStoEst | Sort by earliest start times |
| CStoLct | Sort by latest completion times |
| CStoLst | Sort by latest start times |
| CSupportValues | Support value iterator and recorder |
| CTaskArray | Task array |
| CTaskProp | Propagator for tasks |
| CTaskTraits | Traits class for mapping tasks to task views |
| CTaskTraits< Cumulative::ManFixPSETask > | Task traits for mandatory fixed tasks |
| CTaskTraits< Cumulative::ManFixPTask > | Task traits for mandatory fixed tasks |
| CTaskTraits< Cumulative::ManFlexTask > | Task traits for mandatory flexible tasks |
| CTaskTraits< Cumulative::OptFixPSETask > | Task traits for optional fixed tasks |
| CTaskTraits< Cumulative::OptFixPTask > | Task traits for optional fixed tasks |
| CTaskTraits< Cumulative::OptFlexTask > | Task traits for optional flexible tasks |
| CTaskTraits< Unary::ManFixPSETask > | Task traits for mandatory fixed tasks |
| CTaskTraits< Unary::ManFixPTask > | Task traits for mandatory fixed tasks |
| CTaskTraits< Unary::ManFlexTask > | Task traits for mandatory flexible tasks |
| CTaskTraits< Unary::OptFixPSETask > | Task traits for optional fixed tasks |
| CTaskTraits< Unary::OptFixPTask > | Task traits for optional fixed tasks |
| CTaskTraits< Unary::OptFlexTask > | Task traits for optional flexible tasks |
| CTaskTree | Task trees for task views with node type Node |
| CTaskViewArray | Task view array |
| CTaskViewIter | Allows to iterate over task views according to a specified order |
| CTaskViewTraits | Traits class for mapping task views to tasks |
| CTaskViewTraits< Cumulative::ManFixPSETaskBwd > | Task view traits for backward task views |
| CTaskViewTraits< Cumulative::ManFixPSETaskFwd > | Task view traits for forward task views |
| CTaskViewTraits< Cumulative::ManFixPTaskBwd > | Task view traits for backward task views |
| CTaskViewTraits< Cumulative::ManFixPTaskFwd > | Task view traits for forward task views |
| CTaskViewTraits< Cumulative::ManFlexTaskBwd > | Task view traits for backward task views |
| CTaskViewTraits< Cumulative::ManFlexTaskFwd > | Task view traits for forward task views |
| CTaskViewTraits< Cumulative::OptFixPSETaskBwd > | Task view traits for backward task views |
| CTaskViewTraits< Cumulative::OptFixPSETaskFwd > | Task view traits for forward optional task views |
| CTaskViewTraits< Cumulative::OptFixPTaskBwd > | Task view traits for backward task views |
| CTaskViewTraits< Cumulative::OptFixPTaskFwd > | Task view traits for forward optional task views |
| CTaskViewTraits< Cumulative::OptFlexTaskBwd > | Task view traits for backward task views |
| CTaskViewTraits< Cumulative::OptFlexTaskFwd > | Task view traits for forward optional task views |
| CTaskViewTraits< Unary::ManFixPSETaskBwd > | Task view traits for backward task views |
| CTaskViewTraits< Unary::ManFixPSETaskFwd > | Task view traits for forward task views |
| CTaskViewTraits< Unary::ManFixPTaskBwd > | Task view traits for backward task views |
| CTaskViewTraits< Unary::ManFixPTaskFwd > | Task view traits for forward task views |
| CTaskViewTraits< Unary::ManFlexTaskBwd > | Task view traits for backward task views |
| CTaskViewTraits< Unary::ManFlexTaskFwd > | Task view traits for forward task views |
| CTaskViewTraits< Unary::OptFixPSETaskBwd > | Task view traits for backward task views |
| CTaskViewTraits< Unary::OptFixPSETaskFwd > | Task view traits for forward optional task views |
| CTaskViewTraits< Unary::OptFixPTaskBwd > | Task view traits for backward task views |
| CTaskViewTraits< Unary::OptFixPTaskFwd > | Task view traits for forward optional task views |
| CTaskViewTraits< Unary::OptFlexTaskBwd > | Task view traits for backward task views |
| CTaskViewTraits< Unary::OptFlexTaskFwd > | Task view traits for forward optional task views |
| CTooFewArguments | Exception: Too few arguments available in argument array |
| CUninitializedTupleSet | Exception: uninitialized tuple set |
| CUnknownBranching | Exception: Unknown value or variable selection passed as argument |
| CUnknownOperation | Exception: Unknown operation passed as argument |
| CUnknownReifyMode | Exception: Unknown reification mode passed as argument |
| CUnknownRelation | Exception: Unknown relation passed as argument |
| CValOfUnassignedVar | Exception: Attempt to access value of unassigned variable |
| CValSet | Class for storing values of already assigned views |
| CRanges | Iterator over ranges |
| CVariableEmptyDomain | Exception: Variable created with empty domain |
| CViewDiffRanges | Range iterator for cached integer views |
| CViewRanges | Range iterator for integer views |
| CViewRanges< BoolView > | Range iterator for Boolean variable views |
| CViewRanges< CachedView< View > > | Range iterator for offset integer views |
| CViewRanges< ConstIntView > | Range iterator for constant integer views |
| CViewRanges< GCC::CardView > | Range iterator for indexed problem variables |
| CViewRanges< IntScaleView > | Range iterator for integer-precision scale integer views |
| CViewRanges< IntView > | Range iterator for integer variable views |
| CViewRanges< LLongScaleView > | Range iterator for long long int-precision scale integer views |
| CViewRanges< MinusView > | Range iterator for minus integer views |
| CViewRanges< NegBoolView > | Range iterator for negated Boolean variable views |
| CViewRanges< OffsetView > | Range iterator for offset integer views |
| CViewRanges< ZeroIntView > | Range iterator for constant integer views |
| CViewToVarArg | Class to map VarArg type to view |
| CViewToVarArg< BoolView > | VarArg type for Boolean views |
| CViewToVarArg< Gecode::Float::FloatView > | VarArg type for Set views |
| CViewToVarArg< Gecode::Set::SetView > | VarArg type for Set views |
| CViewToVarArg< Gecode::Set::SingletonView > | VarArg type for singleton views |
| CViewToVarArg< IntView > | VarArg type for integer views |
| CViewToVarArg< MinusView > | VarArg type for minus views |
| CViewToVarArg< NegBoolView > | VarArg type for Boolean views |
| CViewValues | Value iterator for integer views |
| CZeroIntView | Zero integer view |
| NIter | Range and value iterators |
| NRanges | Range iterators |
| CAddRange | Range iterator for adding a single range to a range iterator |
| CAppend | Range iterator for appending two range iterators |
| CArray | Range iterator for array of ranges |
| CRange | Ranges for array |
| CCache | Range iterator cache |
| CCompl | Range iterator for computing the complement (described by template arguments) |
| CComplVal | Range iterator for computing the complement (described by values) |
| CDiff | Range iterator for computing set difference |
| CEmpty | Range iterator for empty range |
| CInter | Range iterator for computing intersection (binary) |
| CMap | Range iterator for mapping ranges |
| CMap< I, M, false > | Specialized mapping of ranges for non-strict maps |
| CMap< I, M, true > | Specialized mapping of ranges for strict maps |
| CMinMax | Base for range iterators with explicit min and max |
| CMinus | Range iterator for pointwise minus of a range iterator |
| CNaryAppend | Range iterator for appending arbitrarily many iterators |
| CNaryInter | Range iterator for intersection of iterators |
| CNaryUnion | Range iterator for union of iterators |
| CNegative | Range iterator for negative part of a range iterator |
| COffset | Range iterator for pointwise offset (by some constant) |
| CPositive | Range iterator for positive part of a range iterator |
| CRangeList | Range iterator for range lists |
| CRangeListIter | Iterator over range lists |
| CRangeList | Range list class |
| CRLIO | Shared object for allocation |
| CScaleDown | Range iterator for pointwise division by a positive integer |
| CScaleUp | Range iterator for pointwise product with a positive integer |
| CSingleton | Range iterator for singleton range |
| CSingletonAppend | Range iterator for appending a singleton with a range iterator |
| CSize | Range iterator with size counting |
| CSubRange | Range iterator for subtracting a single range from a range iterator |
| CToValues | Value iterator from range iterator |
| CUnion | Range iterator for computing union (binary) |
| NValues | Value iterators |
| CArray | Value iterator for array of integers |
| CBitSet | Value iterator for values in a bitset |
| CBitSetOffset | Value iterator for values in an offset bitset |
| CInter | Value iterator for the intersection of two value iterators |
| CMap | Value iterator for mapping values of a value iterator |
| CMinus | Value iterator for pointwise minus of a value iterator |
| CNegative | Value iterator for selecting only negative values |
| COffset | Value iterator for pointwise offset (by some constant) |
| CPositive | Value iterator for selecting only positive values |
| CSingleton | Value iterator for single value |
| CToRanges | Range iterator from value iterator |
| CUnion | Value iterator for the union of two value iterators |
| CUnique | Remove duplicate values from from value iterator |
| CValueListIter | Iterator over value lists |
| CValueList | Value list class |
| CVLIO | Shared object for allocation |
| NKernel | Kernel functionality |
| CGPI | Global propagator information |
| CInfo | Class for storing propagator information |
| CHeapChunk | Memory chunk allocated from heap with proper alignment |
| CMemoryChunk | Memory chunk with size information |
| CMemoryManager | Manage memory for space |
| CSharedMemory | Shared object for several memory areas |
| CSharedSpaceData | Class to store data shared among several spaces |
| CData | The shared data |
| CViewOcc | Occurrence information for a view |
| NMiniModel | Minimalistic modeling support |
| CTooFewArguments | Exception: Too few arguments available in argument array |
| CArgumentSizeMismatch | Exception: Sizes of arguments does not match |
| CArgumentOutOfRange | Exception: Argument out of range |
| NSearch | Search engines |
| NPar | |
| CBAB | Parallel branch-and-bound engine |
| CWorker | Parallel branch-and-bound search worker |
| CCollectAll | Collect all solutions |
| CCollectBest | Collect best solutions |
| CDFS | Parallel depth-first search engine |
| CWorker | Parallel depth-first search worker |
| CEngine | Parallel depth-first search engine |
| CWorker | Parallel depth-first search worker |
| CPath | Depth-first path (stack of edges) supporting recomputation |
| CEdge | Search tree edge for recomputation |
| CPBS | Parallel portfolio engine implementation |
| CPortfolioStop | Stop object used for controlling slaves in a portfolio |
| CSlave | Runnable slave of a portfolio master |
| CCompletion | Completion event for the current run |
| NSeq | |
| CBAB | Implementation of depth-first branch-and-bound search engine |
| CDFS | Depth-first search engine implementation |
| CLDS | Limited discrepancy search engine implementation |
| CPath | Depth-first path (stack of edges) supporting recomputation |
| CEdge | Search tree edge for recomputation |
| CPBS | Sequential portfolio engine implementation |
| CPortfolioStop | Stop object used for controlling slaves in a portfolio |
| CProbe | Probe engine for LDS |
| CNode | Node in the search tree for LDS |
| CRBS | Engine for restart-based search |
| CRestartStop | Stop-object for restart engine |
| CSharedStopInfo | Shared stop information |
| CSlave | Runnable slave of a portfolio master |
| CBabBuilder | A BAB engine builder |
| CBase | Base-class for search engines |
| CBuilder | A class for building search engines |
| CCutoff | Base class for cutoff generators for restart-based meta engine |
| CCutoffAppend | Cutoff generator appending two cutoff generators |
| CCutoffConstant | Cutoff generator for constant sequence |
| CCutoffGeometric | Cutoff generator for the geometric sequence |
| CCutoffLinear | Cutoff generator for linear sequence |
| CCutoffLuby | Cutoff generator for the Luby sequence |
| CCutoffMerge | Cutoff generator merging two cutoff generators |
| CCutoffRandom | Cutoff generator for the random sequence |
| CCutoffRepeat | Cutoff generator that repeats a cutoff from another cutoff generator |
| CDfsBuilder | A DFS engine builder |
| CEdgeTraceRecorder | Recorder for a search tracer with edge information |
| CEngine | Search engine implementation interface |
| CFailStop | Stop-object based on number of failures |
| CLdsBuilder | A DFS engine builder |
| CMixedBest | Exception: Mixed non-best and best solution search requested |
| CNoAssets | Exception: No assets requested for portfolio-based search |
| CNoBest | Exception: Best solution search is not supported |
| CNodeStop | Stop-object based on number of nodes |
| CNoGoodsProp | No-good propagator |
| CNoNGL | Class for a sentinel no-good literal |
| CNoTraceRecorder | Empty trace recorder |
| CID | Class for storing node identifiers |
| COptions | Search engine options |
| CPbsBuilder | A PBS engine builder |
| CRbsBuilder | A RBS engine builder |
| CRestartStop | Stop-object based on number of restarts |
| CStatistics | Search engine statistics |
| CStop | Base-class for Stop-object |
| CTimeStop | Stop-object based on time |
| CTraceRecorder | Simple recorder for a search tracer |
| CID | Class for storing identifiers |
| CUninitializedCutoff | Exception: Uninitialized cutoff for restart-based search |
| CWorker | Search worker statistics |
| CWorkerToEngine | Virtualize a worker to an engine |
| CWrapTraceRecorder | Recorder for engine events (for access control) |
| NSet | Finite integer sets |
| NBranch | Set branchings |
| CMeritMin | Merit class for minimum of set views |
| CMeritMax | Merit class for maximum of set view |
| CMeritSize | Merit class for size of set view |
| CMeritDegreeSize | Merit class for degree over size |
| CMeritAFCSize | Merit class for AFC over size |
| CMeritActionSize | Merit class for action over size |
| CMeritCHBSize | Merit class for CHB Q-score over size |
| CValSelMin | Value selection class for minimum of view |
| CValSelMax | Value selection class for maximum of view |
| CValSelMed | Value selection class for median of view |
| CValSelRnd | Value selection class for random value of view |
| CIncNGL | No-good literal for inclusion |
| CExcNGL | No-good literal for exclusion |
| CValCommitInc | Value commit class for inclusion |
| CValCommitExc | Value commit class for exclusion |
| NChannel | Channeling propagators for set variables |
| CChannelSorted | Propagator for the sorted channel constraint |
| CChannelInt | Propagator for channelling between variable-value-dual models |
| CChannelBool | Propagator for channelling between set variable and its characteristic function |
| CIndexAdvisor | Advisor storing a single index |
| CChannelSet | Propagator for successors/predecessors channelling |
| NConvex | Propagators for convexity |
| CConvex | Propagator for the convex constraint |
| CConvexHull | Propagator for the convex hull constraint |
| NDistinct | Propagators for global distinctness constraints |
| CAtmostOne | Propagator for the AtMostOneIntersection constraint |
| NElement | Set element propagators |
| CElementIntersection | Propagator for element with intersection |
| CElementUnion | Propagator for element with union |
| CElementUnionConst | Propagator for element with union of constant sets |
| CElementDisjoint | Propagator for element with disjointness |
| NInt | Propagators connecting set and int variables |
| CCard | Propagator for cardinality |
| CIntLess | Sort order for integers |
| CMaxElement | Propagator for maximum element |
| CMinElement | Propagator for minimum element |
| CNotMaxElement | Propagator for not maximum element |
| CNotMinElement | Propagator for not minimum element |
| COverweightValues | Value Iterator for values above a certain weight |
| CReMaxElement | Reified propagator for maximum element |
| CReMinElement | Propagator for reified minimum element |
| CWeights | Propagator for weight of a set |
| NLDSB | Symmetry breaking for set variables |
| CLDSBSetBrancher | Symmetry-breaking brancher with generic view and value selection |
| NPrecede | Value precedence propagators |
| CSingle | Single value precedence propagator |
| CIndex | Advisors for views (by position in array) |
| NRel | Standard set relation propagators |
| CCharacteristicSets | Representation of the characteristic functions of two sets |
| CCSIter | Value iterator for characteristic function |
| CDistinct | Propagator for negated equality |
| CDistinctDoit | Propagator for negated equality |
| CEq | Propagator for set equality |
| CLq | Propagator for set less than or equal |
| CNoSubset | Propagator for the negated subset constraint |
| CReEq | Reified equality propagator |
| CReLq | Reified propagator for set less than or equal |
| CReSubset | Reified subset propagator |
| CSubset | Propagator for the subset constraint |
| NRelOp | Standard set operation propagators |
| CSuperOfInter | Propagator for the superset of intersection |
| CSubOfUnion | Propagator for the subset of union |
| CIntersection | Propagator for ternary intersection |
| CUnion | Propagator for ternary union |
| CIntersectionN | Propagator for nary intersection |
| CUnionN | Propagator for nary union |
| CPartitionN | Propagator for nary partition |
| NSequence | Propagators for ordered sequences of sets |
| CSeq | Propagator for the sequence constraint |
| CSeqU | Propagator for the sequenced union constraint |
| CArgumentSizeMismatch | Exception: Arguments are of different size |
| CArrayRanges | Range iterator for a two-dimensional array |
| CBndSet | Sets of integers |
| CBndSetRanges | Range iterator for integer sets |
| CCachedView | Cached set view |
| CComplementView | Complement set view |
| CConstSetView | Constant view |
| CEmptyView | Constant view for the empty set |
| CGlbDiffRanges | Range iterator for difference of greatest lower bound and cache |
| CGLBndSet | Growing sets of integers |
| CGlbRanges | Range iterator for the greatest lower bound |
| CGlbRanges< CachedView< View > > | Range iterator for greatest lower bound of cached set views |
| CGlbRanges< ComplementView< ComplementView< View > > > | Range iterator for the greatest lower bound of double-complement-views |
| CGlbRanges< ComplementView< View > > | Range iterator for greatest lower bound of complement set views |
| CGlbRanges< ConstSetView > | Range iterator for greatest lower bound of constant set view |
| CGlbRanges< EmptyView > | Range iterator for greatest lower bound of constantly empty set view |
| CGlbRanges< SetVarImp * > | Range iterator for the greatest lower bound of a set variable implementation |
| CGlbRanges< SetView > | Range iterator for greatest lower bound of set variable views |
| CGlbRanges< SingletonView > | Range iterator for greatest lower bound of singleton set view |
| CGlbRanges< UniverseView > | Range iterator for greatest lower bound of constant universe set view |
| CIllegalOperation | Exception: Illegal operation passed as argument |
| CLubDiffRanges | Range iterator for difference of least upper bound and cache |
| CLUBndSet | Shrinking sets of integers |
| CLubRanges | Range iterator for the least upper bound |
| CLubRanges< CachedView< View > > | Range iterator for least upper bound of cached set views |
| CLubRanges< ComplementView< ComplementView< View > > > | Range iterator for the least upper bound of double-complement-views |
| CLubRanges< ComplementView< View > > | Range iterator for least upper bound of complement set views |
| CLubRanges< ConstSetView > | Range iterator for least upper bound of constant set view |
| CLubRanges< EmptyView > | Range iterator for least upper bound of constantly empty set view |
| CLubRanges< SetVarImp * > | Range iterator for the least upper bound of a set variable implementation |
| CLubRanges< SetView > | Range iterator for least upper bound of set variable views |
| CLubRanges< SingletonView > | Range iterator for least upper bound of singleton set view |
| CLubRanges< UniverseView > | Range iterator for least upper bound of constant universe set view |
| COutOfLimits | Exception: Value out of limits |
| CRangesCompl | A complement iterator spezialized for the BndSet limits |
| CSetDelta | Finite set delta information for advisors |
| CSetTraceView | Duplicate of a set view |
| CSetVarImp | Finite integer set variable implementation |
| CSetVarImpBase | Base-class for Set-variable implementations |
| CSetVarImpConf | Configuration for Set-variable implementations |
| CSetView | Set view for set variables |
| CSingletonView | Singleton set view |
| CTooFewArguments | Exception: No arguments available in argument array |
| CUniverseView | Constant view for the universe |
| CUnknownBranching | Exception: Unknown value or variable selection passed as argument |
| CUnknownOperation | Exception: Unknown operation type passed as argument |
| CUnknownRanges | Range iterator for the unknown set |
| CUnknownRelation | Exception: Unknown relation type passed as argument |
| CVariableEmptyDomain | Exception: Variable created with empty domain |
| NSupport | Support algorithms and datastructures |
| CAllocator | Default memory allocator |
| CBitSet | Simple bitsets |
| CBitSetBase | Basic bitset support |
| CBitSetData | Date item for bitsets |
| CBitSetOffset | Bitsets with index offset |
| CBlockAllocator | Manage memory organized into block lists (allocator) |
| CBlockClient | Client for block allocator of type T |
| CDynamicArray | Array with arbitrary number of elements |
| CDynamicQueue | Queue with arbitrary number of elements |
| CDynamicStack | Stack with arbitrary number of elements |
| CEvent | An event for synchronization |
| CIntTypeTraits | Traits to for information about integer types |
| CIntTypeTraits< signed char > | Traits for signed char |
| CIntTypeTraits< signed int > | Traits for signed integer |
| CIntTypeTraits< signed short int > | Traits for signed short int |
| CIntTypeTraits< unsigned char > | Traits for unsigned char |
| CIntTypeTraits< unsigned int > | Traits for unsigned integer |
| CIntTypeTraits< unsigned short int > | Traits for unsigned short int |
| CJob | Baseclass for jobs with return type RetType |
| CJobStop | Class to throw an exception to stop new jobs from being started |
| CLess | Comparison class for sorting using < |
| CLinearCongruentialGenerator | Template for linear congruential generators |
| CLock | A lock as a scoped frontend for a mutex |
| CMutex | A mutex for mutual exclausion among several threads |
| CQuickSortStack | Static stack for quicksort |
| CRawBitSetBase | Basic bitset support (without stored size information) |
| CRefCount | A class for thread-safe reference counting |
| CRunJobs | Parallel iterator that runs jobs with a given number of threads |
| CWorker | The actual worker using a thread to run a job |
| CMaster | |
| CDeleter | A class to delete the master (running in parallel) |
| CRunnable | An interface for objects that can be run by a thread |
| CStaticStack | Stack with fixed number of elements |
| CTerminator | An interface for objects that can be called after a thread has terminated (after running the thread's destructor) |
| CThread | Simple threads |
| CRun | A real thread |
| CTimer | Timer |
| CAction | Class for action management |
| CRecorder | Propagator for recording action information |
| CIdx | Advisor with index and change information |
| CStorage | Object for storing action values |
| CActor | Base-class for both propagators and branchers |
| CActorLink | Double-linked list for actors |
| CAdvisor | Base-class for advisors |
| CAdvisors | Class to iterate over advisors of a council |
| CAFC | Class for AFC (accumulated failure count) management |
| CAllVarConf | Configuration for all variable implementations |
| CArchive | Archive representation |
| CArgArray | Argument array for non-primitive types |
| CArgArrayBase | Base-class for argument arrays |
| CArrayTraits | Traits of arrays in Gecode |
| CArrayTraits< ArgArray< FloatVal > > | Traits of FloatValArgs |
| CArrayTraits< ArgArray< int > > | Traits of IntArgs |
| CArrayTraits< ArgArray< IntSet > > | Traits of IntSetArgs |
| CArrayTraits< ArgArray< SEB > > | Traits of SEBs |
| CArrayTraits< ArgArray< SymmetryHandle > > | Traits of Symmetries |
| CArrayTraits< ArgArray< TaskType > > | Traits of TaskTypeArgs |
| CArrayTraits< ArgArray< VarImpBase * > > | Traits of ArgArray<VarImpBase*> |
| CArrayTraits< BoolVarArgs > | Traits of BoolVarArgs |
| CArrayTraits< BoolVarArray > | Traits of BoolVarArray |
| CArrayTraits< FloatValArgs > | Traits of FloatValArgs |
| CArrayTraits< FloatVarArgs > | Traits of FloatVarArgs |
| CArrayTraits< FloatVarArray > | Traits of FloatVarArray |
| CArrayTraits< IntArgs > | Traits of IntArgs |
| CArrayTraits< IntVarArgs > | Traits of IntVarArgs |
| CArrayTraits< IntVarArray > | Traits of IntVarArray |
| CArrayTraits< LiteralArgs > | Traits of LiteralArgs |
| CArrayTraits< SEBs > | Traits of SEBs |
| CArrayTraits< SetVarArgs > | Traits of SetVarArgs |
| CArrayTraits< SetVarArray > | Traits of SetVarArray |
| CArrayTraits< VarArgArray< BoolVar > > | Traits of BoolVarArgs |
| CArrayTraits< VarArgArray< FloatVar > > | Traits of FloatVarArgs |
| CArrayTraits< VarArgArray< IntVar > > | Traits of IntVarArgs |
| CArrayTraits< VarArgArray< SetVar > > | Traits of VarArgArray<SetVar> |
| CArrayTraits< VarArray< BoolVar > > | Traits of BoolVarArray |
| CArrayTraits< VarArray< FloatVar > > | Traits of FloatVarArray |
| CArrayTraits< VarArray< IntVar > > | Traits of IntVarArray |
| CArrayTraits< VarArray< SetVar > > | Traits of VarArray<SetVar> |
| CBAB | Depth-first branch-and-bound search engine |
| CBaseOptions | Base class for script options |
| CBinaryPropagator | Binary propagator |
| CBoolAction | Recording actions for Boolean variables |
| CBoolAFC | Recording AFC information for Boolean variables |
| CBoolAssign | Which values to select for assignment |
| CBoolCHB | Recording CHB for Boolean variables |
| CBoolExpr | Boolean expressions |
| CMisc | Miscealloneous Boolean expressions |
| CBoolTraceDelta | Trace delta information for Boolean variables |
| CBoolValBranch | Which values to select for branching first |
| CBoolVar | Boolean integer variables |
| CBoolVarArgs | Passing Boolean variables |
| CBoolVarArray | Boolean variable array |
| CBoolVarBranch | Which Boolean variable to select for branching |
| CBrancher | Base-class for branchers |
| CBrancherFilter | Class storing a branch filter function |
| CBrancherGroup | Group of branchers |
| CBrancherNoFilter | Class without a branch filter function |
| CBrancherNoPrint | Class without print function |
| CBrancherPrint | Class storing a print function |
| CBranchers | Class to iterate over branchers in a group |
| CBranchTraits | Traits for branching |
| CBranchTraits< BoolVar > | Traits of BoolVar for branching |
| CBranchTraits< FloatVar > | Traits of FloatVar for branching |
| CBranchTraits< IntVar > | Traits of IntVar for branching |
| CBranchTraits< SetVar > | Traits of SetVar for branching |
| CCHB | Class for CHB management |
| CRecorder | Propagator for recording chb information |
| CIdx | Advisor with index and change information |
| CInfo | View information |
| CStorage | Object for storing chb information |
| CChoice | Choice for performing commit |
| CChooseMax | Choose views with larger merit values |
| CChooseMin | Choose views with smaller merit values |
| CCloneStatistics | Statistics for execution of clone |
| CCommitStatistics | Statistics for execution of commit |
| CCommitTraceInfo | Commit trace information |
| CConstView | Base-class for constant views |
| CCouncil | Council of advisors |
| CCPProfilerSearchTracer | Class to record search trace info for CPProfiler |
| CGetInfo | Class to send solution information to CPProfiler |
| CDelta | Generic domain change information to be supplied to advisors |
| CDerivedView | Base-class for derived views |
| CDFA | Deterministic finite automaton (DFA) |
| CTransition | Specification of a DFA transition |
| CTransitions | Iterator for DFA transitions (sorted by symbols) |
| CSymbols | Iterator for DFA symbols |
| CDFAI | Data stored for a DFA |
| CHashEntry | Specification of transition range |
| CDFS | Depth-first search engine |
| CDynamicCastFailed | Exception: dynamic cast failed |
| CException | Exception: Base-class for exceptions |
| CFloatAction | Recording actions for float variables |
| CFloatAFC | Recording AFC information for float variables |
| CFloatAssign | Which values to select for assignment |
| CFloatCHB | Recording CHB for float variables |
| CFloatMaximizeSpace | Class for maximizing float cost |
| CFloatMinimizeSpace | Class for minimizing float cost |
| CFloatNumBranch | Value description class for branching |
| CFloatTraceDelta | Trace delta information for float variables |
| CFloatVal | Float value type |
| CFloatValArgs | Passing float arguments |
| CFloatValBranch | Which values to select for branching first |
| CFloatVar | Float variables |
| CFloatVarArgs | Passing float variables |
| CFloatVarArray | Float variable array |
| CFloatVarBranch | Which variable to select for branching |
| CFreeList | Base-class for freelist-managed objects |
| CGroup | Group baseclass for controlling actors |
| CHeap | Heap memory management class |
| CHeapAllocated | Base class for heap allocated objects |
| CHome | Home class for posting propagators |
| CIllegalDecay | Exception: illegal decay factor |
| CInstanceOptions | Options for scripts with additional instance parameter |
| CIntAction | Recording actions for integer variables |
| CIntAFC | Recording AFC information for integer variables |
| CIntArgs | Passing integer arguments |
| CIntAssign | Which values to select for assignment |
| CIntCHB | Recording CHB for integer variables |
| CIntLexMaximizeSpace | Class for lexicographically maximizing integer costs |
| CIntLexMinimizeSpace | Class for lexicographically minimizing integer costs |
| CIntMaximizeSpace | Class for maximizing integer cost |
| CIntMinimizeSpace | Class for minimizing integer cost |
| CIntPropLevels | Class for specifying integer propagation levels used by minimodel |
| CIntSet | Integer sets |
| CIntSetInit | Integer set initialization |
| CIntSetInit< IntArgs > | Initialize integer set with integer arguments |
| CIntSetInit< IntSet > | Initialize integer set with integer set |
| CIntSetRanges | Range iterator for integer sets |
| CIntSetValues | Value iterator for integer sets |
| CIntTraceDelta | Trace delta information for integer variables |
| CIntValBranch | Which values to select for branching first |
| CIntVar | Integer variables |
| CIntVarArgs | Passing integer variables |
| CIntVarArray | Integer variable array |
| CIntVarBranch | Which integer variable to select for branching |
| CIntVarRanges | Range iterator for integer variables |
| CIntVarValues | Value iterator for integer variables |
| CInvalidFunction | Exception: invalid function |
| CLDS | Limited discrepancy search engine |
| CLinFloatExpr | Float expressions |
| CLinFloatRel | Linear relations |
| CLinIntExpr | Linear expressions over integer variables |
| CLinIntRel | Linear relations over integer variables |
| CLocalHandle | Handles for local (space-shared) objects |
| CLocalObject | Local (space-shared) object |
| CMatrix | Matrix-interface for arrays |
| CMemoryExhausted | Exception: Memory exhausted |
| CMeritAction | Merit class for action |
| CMeritAFC | Merit class for AFC |
| CMeritBase | Base-class for merit class |
| CMeritCHB | Merit class for CHB |
| CMeritDegree | Merit class for degree |
| CMeritFunction | Merit class for user-defined merit function |
| CMetaInfo | Information passed by meta search engines |
| CMixBinaryPropagator | Mixed binary propagator |
| CMixNaryOnePropagator | Mixed (n+1)-ary propagator |
| CMixTernaryPropagator | Mixed ternary propagator |
| CMoreThanOneTracer | Exception: action has wrong arity |
| CNaryOnePropagator | (n+1)-ary propagator |
| CNaryPropagator | N-ary propagator |
| CNaryWait | Wait propagator for several views |
| CNGL | No-good literal recorded during search |
| CNoGoods | No-goods recorded from restarts |
| CNoIdxVarImpConf | Configuration class for variable implementations without index structure |
| CNonLinFloatExpr | Base class for non-linear float expressions |
| CNonLinIntExpr | Base class for non-linear expressions over integer variables |
| COperatingSystemError | Exception: operating system error |
| COptions | Options for scripts |
| CI_ | Helper class storing Gist inspectors |
| CPBS | Meta engine using a portfolio of search engines |
| CPos | Position information |
| CPosChoice | Choices storing position |
| CPostInfo | Class to set group information when a post function is executed |
| CPostTraceInfo | Post trace information |
| CPosValChoice | Choice storing position and value |
| CPropagateTraceInfo | Propagate trace information |
| CPropagator | Base-class for propagators |
| CPropagatorGroup | Group of propagators |
| CPropagators | Class to iterate over propagators in a group |
| CPropCost | Propagation cost |
| CRangeList | Lists of ranges (intervals) |
| CRBS | Meta-engine performing restart-based search |
| CREG | Regular expressions over integer values |
| CRegion | Handle to region |
| Cregion_allocator | Allocator that allocates memory from a region |
| Crebind | Rebinding helper (returns the type of a similar allocator for type U) |
| Cregion_allocator< void > | Region allocator - specialization for void |
| Crebind | Rebinding helper (returns the type of a similar allocator for type U) |
| CReify | Reification specification |
| CRnd | Random number generator |
| CSearchTracer | Support for tracing search |
| CEngineInfo | Information about an engine |
| CEdgeInfo | Edge information |
| CNodeInfo | Node information |
| CSEBs | Passing search engine builder arguments |
| CSetAction | Recording actions for set variables |
| CSetAFC | Recording AFC information for set variables |
| CSetAssign | Which value to select for assignment |
| CSetCHB | Recording CHB for set variables |
| CSetCmpRel | Comparison relation (for two-sided comparisons) |
| CSetExpr | Set expressions |
| CSetRel | Set relations |
| CSetTraceDelta | Trace delta information for set variables |
| CGlb | Delta for the greatest lower bound |
| CLub | Delta for the least upper bound |
| CSetValBranch | Which values to select for branching first |
| CSetVar | Set variables |
| CSetVarArgs | Passing set variables |
| CSetVarArray | Set variable array |
| CSetVarBranch | Which variable to select for branching |
| CSetVarGlbRanges | Iterator for the greatest lower bound ranges of a set variable |
| CSetVarGlbValues | Iterator for the values in the greatest lower bound of a set variable |
| CSetVarLubRanges | Iterator for the least upper bound ranges of a set variable |
| CSetVarLubValues | Iterator for the values in the least upper bound of a set variable |
| CSetVarUnknownRanges | Iterator for the unknown ranges of a set variable |
| CSetVarUnknownValues | Iterator for the values in the unknown set of a set variable |
| CSharedArray | Shared array with arbitrary number of elements |
| CSAO | Implementation of object for shared arrays |
| CSharedData | Class for sharing data between spaces |
| CSDO | The object storing the actual data |
| CSharedHandle | The shared handle |
| CObject | The shared object |
| CSizeOptions | Options for scripts with additional size parameter |
| CSlice | A slice of a matrix |
| CSpace | Computation spaces |
| CPropagators | Class to iterate over propagators of a space |
| CScheduledPropagators | Class to iterate over scheduled propagators of a space |
| CIdlePropagators | Class to iterate over idle propagators of a space |
| CBranchers | Class to iterate over branchers of a space |
| Cspace_allocator | Allocator that allocates memory from a space heap |
| Crebind | Rebinding helper (returns the type of a similar allocator for type U) |
| Cspace_allocator< void > | Space allocator - specialization for void |
| Crebind | Rebinding helper (returns the type of a similar allocator for type U) |
| CSpaceFailed | Exception: Operation on failed space invoked |
| CSpaceIllegalAlternative | Exception: Commit with illegal alternative |
| CSpaceNoBrancher | Exception: Commit when no brancher present |
| CSpaceNotCloned | Exception: Copy constructor did not call base class copy constructor |
| CSpaceNotStable | Exception: Operation on not stable space invoked |
| CStatusStatistics | Statistics for execution of status |
| CStdBoolTracer | Standard Boolean variable tracer |
| CStdFloatTracer | Standard float variable tracer |
| CStdIntTracer | Standard integer variable tracer |
| CStdSearchTracer | |
| CStdSetTracer | Standard set variable tracer |
| CStdTracer | Default tracer |
| CSubscribedPropagators | Iterator over subscribed propagators |
| CSymmetries | Collection of symmetries |
| CSymmetryHandle | A reference-counted pointer to a SymmetryObject |
| CTernaryPropagator | Ternary propagator |
| CTFE | Trace filter expressions |
| CNode | Node for trace filter expression |
| CTieBreak | Combine variable selection criteria for tie-breaking |
| CTooManyBranchers | Exception: too many branchers |
| CTooManyGroups | Exception: too many groups |
| CTraceFilter | Trace filters |
| CTFO | The actual object storing the shared filters |
| CFilter | Filter information |
| CStackFrame | |
| CTracer | Tracer |
| CTracerBase | Class to provide synchronization |
| CTraceRecorder | Propagator for recording trace information |
| CTraceTraits | Traits for tracing |
| CTraceTraits< Float::FloatView > | Trace traits for float views |
| CTraceTraits< Int::BoolView > | Trace traits for Boolean views |
| CTraceTraits< Int::IntView > | Trace traits for integer views |
| CTraceTraits< Set::SetView > | Trace traits for set views |
| CTupleSet | Class representing a set of tuples |
| CCSupportWord | Compressed support data for one tuple-word block |
| CRange | Range information |
| CValueData | Data about values in the table |
| CData | Data stored for a Table |
| CRanges | Iterator over ranges |
| CUnaryPropagator | Unary propagator |
| CUnaryWait | Wait propagator for single view |
| CUninitializedAction | Exception: uninitialized action |
| CUninitializedAFC | Exception: uninitialized AFC |
| CUninitializedCHB | Exception: uninitialized CHB |
| CUninitializedRnd | Exception: uninitialized random number generator |
| CUnknownBrancher | Exception: unknown brancher |
| CUnknownPropagator | Exception: unknown propagator |
| CValBranch | Value branching information |
| CValCommit | Base class for value commit |
| CValCommitFunction | Class for user-defined value commit |
| CValSel | Base class for value selection |
| CValSelCommit | Class for value selection and commit |
| CValSelCommitBase | Base class for value selection and commit |
| CValSelFunction | User-defined value selection |
| CVar | Base class for variables |
| CVarArgArray | Argument array for variables |
| CVarArray | Variable arrays |
| CVarBranch | Variable branching information |
| CVarImp | Base-class for variable implementations |
| CVarImpBase | Base-class for variable implementations |
| CVarImpDisposer | Variable implementation disposer |
| CVarImpDisposerBase | Base class for Variable type disposer |
| CVarImpVar | Variables as interfaces to variable implementations |
| CVarImpView | Base-class for variable implementation views |
| CViewAdvisor | Advisor storing a single view |
| CViewArray | View arrays |
| CViewArray< Int::Linear::NoView > | View array for no view (empty) |
| CViewBrancher | Generic brancher by view selection |
| CViewSel | Abstract class for view selection |
| CViewSelChoose | Choose view according to merit |
| CViewSelChooseTbl | Choose view according to merit taking tie-break limit into account |
| CViewSelMax | Select view with largest merit |
| CViewSelMaxTbl | Select view with largest merit taking tie-break limit into account |
| CViewSelMin | Select view with least merit |
| CViewSelMinTbl | Select view with least merit taking tie-break limit into account |
| CViewSelNone | Select the first unassigned view |
| CViewSelRnd | Select a view randomly |
| CViewTraceInfo | View trace information |
| CViewTracer | Tracer that process view trace information |
| CViewTraceRecorder | Propagator for recording view trace information |
| CSlack | Collection of slack values |
| CIdx | Advisor with index information |
| CViewValBrancher | Generic brancher by view and value selection |
| CViewValNGL | View-value no-good literal |
| NTest | General test support |
| NAssign | Tests for assignments |
| CIntTest | Base class for tests for assigning integer variables |
| CBoolTest | Base class for tests for branching on Boolean variables |
| CSetTest | Base class for tests for branching on set variables |
| CFloatTest | Base class for tests for branching on float variables |
| NBranch | Tests for branchings |
| CIntTest | Base class for tests for branching on integer variables |
| CBoolTest | Base class for tests for branching on Boolean variables |
| CSetTest | Base class for tests for branching on set variables |
| CFloatTest | Base class for tests for branching on float variables |
| NFlatZinc | Tests for FlatZinc |
| CFlatZincTest | Base class for tests for FlatZinc |
| CFlatZincErrorTest | |
| NFloat | Testing domain floats |
| CAssignment | Base class for assignments |
| CCpltAssignment | Generate all assignments |
| CExtAssignment | Generate all assignments except the last variable and complete it to get a solution |
| CRandomAssignment | Generate random selection of assignments |
| CTestSpace | Space for executing tests |
| CTest | Base class for tests with float constraints |
| CFloatRelTypes | Iterator for float relation types |
| NInt | Testing finite domain integers |
| CAssignment | Base class for assignments |
| CCpltAssignment | Generate all assignments |
| CRandomAssignment | Generate random selection of assignments |
| CRandomMixAssignment | Generate random selection of assignments |
| CTestSpace | Space for executing tests |
| CTest | Base class for tests with integer constraints |
| CIntPropLevels | Iterator for simple integer propagation levels |
| CIntPropBasicAdvanced | Iterator for basic and advanced integer propagation levels |
| CIntRelTypes | Iterator for integer relation types |
| CBoolOpTypes | Iterator for Boolean operation types |
| NSet | Testing finite sets |
| CCountableSetValues | Value iterator producing subsets of an IntSet |
| CCountableSetRanges | Range iterator producing subsets of an IntSet |
| CCountableSet | Iterate all subsets of a given set |
| CSetAssignment | Generate all set assignments |
| CSetTestSpace | Space for executing set tests |
| CSetTest | Base class for tests with set constraints |
| CSetRelTypes | Iterator for set relation types |
| CSetOpTypes | Iterator for Boolean operation types |
| Cind | Simple class for describing indentation |
| COptions | Commandline options |
| CBase | Base class for all tests to be run |
| CAllInterval | Example: All-interval series |
| CAlpha | Example: Alpha puzzle |
| CArchimedeanSpiral | Example: Archimedean spiral |
| CBACP | Example: The balanced academic curriculum problem |
| CBIBD | Example: Balanced incomplete block design (BIBD) |
| CBIBDOptions | Options for BIBD problems |
| CBinPacking | Example: Bin packing |
| CBlackHole | Example: Black hole patience |
| CCarSequencing | Example: Car sequencing |
| CCartesianHeart | Example: Cartesian Heart |
| CCDBF | Custom brancher implementing CDBF |
| CChoice | Choice |
| CColoredMatrix | Example: Colored matrix example |
| CColoredMatrixOptions | ColoredMatrixOptions |
| CCommonOptions | Common command line options |
| CCourse | A course |
| CCrew | Example: Airline crew allocation |
| CCrossword | Example: Crossword puzzle |
| CCrowdedChess | Example: Crowded chessboard |
| CCurriculum | A curriculum |
| CDescartesFolium | Example: Folium of Descartes |
| CDictionary | A simple dictionary class |
| CDominatingQueens | Example: Dominating Queens |
| CDomino | Example: Solitaire domino |
| CDonald | Example: DONALD+GERALD=ROBERT puzzle |
| CEFPA | Example: Equidistant Frequency Permutation Arrays |
| CEFPAOptions | Options for EFPA problems |
| CEq20 | Example: Solving 20 linear equations |
| CFailTimeStop | Stop object combining time and failuresa |
| CFileSizeOptions | Parse an additional file option |
| CGoldenSpiral | Example: Golden spiral |
| CGolf | Example: Golf tournament |
| CGolfOptions | Options for Golf example |
| CGolombRuler | Example: Finding optimal Golomb rulers |
| CGraph | Graph specification |
| CGraphColor | Example: Clique-based graph coloring |
| CGraphColorSpec | Graph specification |
| CGrocery | Example: Grocery puzzle |
| CHamming | Example: Generating Hamming codes |
| CHammingOptions | Options for Hamming problems |
| CIndSet | Example: Independent sets in a graph |
| CJobShopBase | Example: Job Shop Scheduling |
| CJobShopOptions | Options for JobShop problems |
| CJobShopProbe | Model for probing |
| CJobShopSolve | Model for solving |
| CKakuro | Example: Kakuro |
| CKnights | Base-class for knight's tour example |
| CKnightsCircuit | Example: n-Knights tour (model using circuit) |
| CKnightsReified | Example: n-Knight's tour (simple model) |
| CLangfordNumber | Example: Langford's number problem |
| CLangfordNumberOptions | Options taking two additional parameters |
| CLexCostWarehouses | Model with cost defined lexicographically |
| CMagicSequence | Example: Magic sequence |
| CMagicSquare | Example: Magic squares |
| CMineSweeper | Example: Minesweeper |
| CMoney | Example: SEND+MORE=MONEY puzzle |
| CMultiBinPacking | Example: Multi-dimensional bin packing |
| CNonogram | Example: Nonogram |
| COpenShop | Example: open-shop scheduling |
| CTask | Task representation for CROSH heuristic |
| CPrintTask | Helper class for representing tasks when printing a solution |
| COrthoLatinSquare | Example: Orthogonal latin squares |
| CPartition | Example: partition numbers into two groups |
| CPentominoes | Example: Pentominoes |
| CPerfectSquare | Example: Packing squares into a rectangle |
| CPhoto | Example: Placing people on a photo |
| CPhotoSpec | Specifications for photo example |
| CPlay | Entry in round robin schedule |
| CQCP | Example: Quasigroup completion |
| CQueenArmies | Example: Peaceable co-existing armies of queens |
| CQueenBranch | Custom brancher for Peacable queens |
| CQueens | Example: n-Queens puzzle |
| CRadiotherapy | Example: Radiotherapy |
| CNestedSearch | Nested search on the q variables |
| CRadiotherapyData | Instance data for radio therapy problem |
| CRRS | Round robin schedule |
| CSat | Example: CNF SAT solver |
| CSatOptions | Options for SAT problems |
| CSchur | Example: Schur's lemma |
| CSchurOptions | Options for Schur's Lemma |
| CSortByWeight | Sort orders by weight |
| CSportsLeague | Example: Sports league scheduling |
| CSteelMill | Example: Steel-mill slab design problem |
| CSteelMillBranch | Custom brancher for steel mill slab design |
| CChoice | Choice |
| CSteelMillOptions | SteelMillOptions for examples with size option and an additional optional file name parameter |
| CSteiner | Example: Steiner triples |
| CSudoku | Base class for Sudoku puzzles |
| CSudokuInt | Example: Solving Sudoku puzzles using integer constraints |
| CSudokuMixed | Example: Solving Sudoku puzzles using both set and integer constraints |
| CSudokuSet | Example: Solving Sudoku puzzles using set constraints |
| CSumCostWarehouses | Model with cost defined as sum |
| CTileSpec | Specification of one tile |
| CTSP | Example: Travelling salesman problem (TSP) |
| CWarehouses | Example: Locating warehouses |
| CWarnsdorff | Custom brancher for knight's tours using Warnsdorff's rule |
| CChoice | Choice |
| CWordSquare | Example: Word-square puzzle |
