| ►Ncxx14 | |
| Ndetail | |
| ►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 |
| 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 |
| ►NFlatZinc | Interpreter for the FlatZinc language |
| ►NAST | Abstract syntax trees for the FlatZinc interpreter |
| CArray | Array node |
| CArrayAccess | Node representing an array access |
| CAtom | Node representing an atom |
| CBoolLit | Boolean literal node |
| CBoolVar | Boolean variable node |
| CCall | Node representing a function call |
| CFloatLit | Float literal node |
| CFloatVar | Float variable node |
| CIntLit | Integer literal node |
| CIntVar | Integer variable node |
| CNode | A node in a FlatZinc abstract syntax tree |
| CSetLit | Set literal node |
| CSetVar | Set variable node |
| CString | String node |
| CTypeError | Exception signaling type error |
| CVar | Variable node base class |
| CAlias | Alias for a variable specification |
| ►CAuxVarBrancher | Branching on the introduced variables |
| CChoice | Choice that only signals failure or success |
| CBoolVarSpec | Specification for Boolean variables |
| CBranchInformation | |
| CBranchInformationO | |
| CConExpr | Abstract representation of a constraint |
| CError | Exception class for FlatZinc errors |
| CFlatZincGetInfo | |
| CFlatZincOptions | Options for running FlatZinc models |
| CFlatZincSpace | A space that can be initialized with a FlatZinc model |
| CFlatZincSpaceInitData | |
| CFloatVarSpec | Specification for floating point variables |
| CFZPrintingComparator | |
| CFZPrintingInspector | An inspector for printing simple text output |
| CGistEngine | Traits class for search engines |
| CGistEngine< BAB< S > > | Specialization for BAB |
| CGistEngine< DFS< S > > | Specialization for DFS |
| 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 |
| 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 |
| 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  |
| CNaryMax | Bounds consistent n-ary maximum propagator |
| 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 |
| CMeritActionSize | Merit class for action over size |
| CMeritAFCSize | Merit class for AFC over size |
| CMeritCHBSize | Merit class for CHB Q-score over size |
| CMeritDegreeSize | Merit class for degree over size |
| CMeritMax | Merit class for maximum of float view |
| CMeritMin | Merit class for mimimum |
| CMeritSize | Merit class for size of float view |
| CValCommitLqGq | Value commit class for less or equal or greater or equal |
| CValSelGq | Value selection class for values smaller than median of view |
| CValSelLq | Value selection class for values smaller than median of view |
| CValSelRnd | Value selection class for random value of view |
| ►NChannel | Channel propagators |
| CChannel | Propagator for bounds consistent integer part operator |
| NLimits | Numerical limits for floating point variables |
| ►NLinear | Linear propagators |
| CEq | Propagator for bounds consistent n-ary linear equality |
| CLin | Base-class for n-ary linear propagators |
| CLq | Propagator for bounds consistent n-ary linear less or equal |
| CTerm | Class for describing linear term  |
| CTermLess | Sort linear terms by view |
| ►NRel | Simple relation propagators |
| CEq | Binary bounds consistent equality propagator |
| CLe | Less propagator |
| CLq | Less or equal propagator |
| CNaryEq | N-ary bounds consistent equality propagator |
| CNq | Binary bounds consistent disequality propagator |
| CNqFloat | Binary bounds consistent disequality propagator with float value |
| CReEq | Reified binary bounds consistent equality propagator |
| CReEqFloat | Reified bounds consistent equality with float propagator |
| CReLeFloat | Reified less with float propagator |
| CReLq | Reified less or equal propagator |
| CReLqFloat | Reified less or equal with float propagator |
| ►NTranscendental | Transcendental propagators |
| CExp | Propagator for bounds consistent exp operator |
| CPow | Propagator for bounds consistent pow operator |
| ►NTrigonometric | Trigonometric propagators |
| CACos | Propagator for bounds consistent arc cosinus operator |
| CASin | Propagator for bounds consistent arc sinus operator |
| CATan | Propagator for bounds consistent arc tangent operator |
| CCos | Propagator for bounds consistent cosinus operator |
| CSin | Propagator for bounds consistent sinus operator |
| CTan | Propagator for bounds consistent 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 |
| 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 |
| CRelax | Class for posting equalities for non-relaxed variables |
| 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 |
| NLayoutConfig | Parameters for the tree layout |
| CAboutGist | Display information about Gist |
| CBestNode | Static reference to the currently best space |
| CBoundingBox | Bounding box |
| CBranch | Representation of a branch in the search tree |
| 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 |
| CGistOutputStream | An outputstream that prints on a QTextEdit |
| 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 |
| CLayouter | Helper functions for the layout algorithm |
| 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 |
| C_I | 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 |
| CSearchItem | A stack item for depth first search |
| CShape | The shape of a subtree |
| CShapeAllocator | Allocate shapes statically |
| 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 |
| 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 |
| ►CConflictGraph | Graph containing conflict information |
| CClique | Clique information |
| CNode | Class for node in graph |
| CNodes | Iterator over node sets |
| CNodeSet | Sets of graph nodes |
| CItem | Item combining bin and size information |
| CPack | Bin-packing propagator |
| CSizeSet | Size sets |
| CSizeSetMinusOne | Size sets with one element discarded |
| CTellCache | Record tell 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 mimimum 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 mimimum 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 |
| CBoolIter | Iterates the values to be removed as defined by an array of Boolean views |
| 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 |
| CEqInt | Propagator for counting views (equal integer to number of equal views) |
| CEqView | Propagator for counting views (equal to number of equal views) |
| CGqInt | Propagator for counting views (greater or equal integer to number of equal views) |
| CGqView | Propagator for counting views (greater or equal to number of equal views) |
| CIntBase | Baseclass for count propagators (integer) |
| CLqInt | Propagator for counting views (less or equal integer to number of equal views) |
| CLqView | Propagator for counting views (less or equal to number of equal views) |
| CViewBase | Base-class for count propagators (view) |
| ►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 evnet 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 |
| CReIntSet | Reified domain dom-propagator |
| CReRange | Reified range dom-propagator |
| ►NElement | Element propagators |
| ►CInt | Element propagator for array of integers |
| CByVal | Sorting pointers to (index,value) pairs in value order |
| 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 |
| CIterIdxView | Value iterator for indices in index-view map |
| CPair | Domain consistent pair propagator |
| CPairValues | Value iterator for pair of iterators |
| 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 |
| CCTAdvisor | Advisor for updating current table |
| CLostSupports | Iterator over lost supports |
| CValidSupports | Iterator over valid supports |
| CGroupStates | GroupStates is used to index StateGroup by group |
| ►CLayeredGraph | Domain consistent layered graph (regular) propagator |
| CEdge | Edge defined by in-state and out-state |
| CIndex | Advisors for views (by position in array) |
| CIndexRange | Range approximation of which positions have changed |
| CLayer | Layer for a view in the layered graph |
| CLayerValues | Iterator for telling variable domains by scanning support |
| CState | States are described by number of incoming and outgoing edges |
| CSupport | Support information for a value |
| CNegCompact | Domain consistent negative extensional propagator |
| ►CPosCompact | Domain consistent positive extensional propagator |
| CStatus | Status management |
| CPosCompare | Tuple comparison by position |
| CReCompact | Domain consistent reified extensional propagator |
| CStateGroup | Stategroup is used to compute a partition of states |
| CStateGroupByGroup | Sort groups stated by group and then state |
| CTinyBitSet | Tiny bit-set |
| CTransByI_State | Sort transition array by input state |
| CTransByO_State | Sort transition array by output state |
| CTransBySymbol | Sort transition array by symbol (value) |
| CTransBySymbolI_State | Sort transition array by symbol and then input states |
| CTupleCompare | Tuple comparison |
| 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  in the variable-value-graph |
| CHallInfo | Container class provding information about the Hall structure of the problem variables |
| CMaxInc | Compares two indices i, j of two views   according to the ascending order of the views upper bounds |
| CMinIdx | Compares two cardinality views according to the index |
| CMinInc | Compares two indices i, j of two views 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 |
| CLDSBBrancher | Symmetry-breaking brancher with generic view and value selection |
| CLDSBChoice | Choice storing position and value, and symmetric literals to be excluded on the right branch |
| CLiteral | A Literal is a pair of variable index and value |
| CSymmetryImp | Implementation of a single symmetry |
| CSymmetryObject | Implementation of a symmetry at the modelling level |
| CValueSequenceSymmetryImp | Implementation of a value sequence symmetry |
| CValueSequenceSymmetryObject | Implementation of a value sequence symmetry at the modelling level |
| CValueSymmetryImp | Implementation of a value symmetry |
| CValueSymmetryObject | Implementation of a value symmetry at the modelling level |
| CVariableMap | Map from variable implementation to index |
| CVariableSequenceSymmetryImp | Implementation of a variable sequence symmetry |
| CVariableSequenceSymmetryObject | Implementation of a variable sequence symmetry at the modelling level |
| CVariableSymmetryImp | Implementation of a variable symmetry |
| CVariableSymmetryObject | Implementation of a variable symmetry at the modelling level |
| NLimits | Numerical limits for integer variables |
| ►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 |
| 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 |
| CBase | Base class for no-overlap propagator |
| CFixDim | Dimension combining coordinate and integer size information |
| CFlexDim | Dimension combining coordinate and integer view size information |
| CManBox | Mandatory box class |
| CManProp | No-overlap propagator for mandatory boxes |
| COptBox | Optional box class |
| COptProp | No-overlap propagator for optional boxes |
| ►NNValues | Number of values propagators |
| CBoolBase | Number of values propagator for Boolean views base class |
| CEqBool | Equal to number of values propagator for Boolean views |
| CEqInt | Equal to number of values propagator for integer views |
| CGqBool | Greater or equal to number of values propagator for Boolean views |
| CGqInt | Greater or equal to number of values propagator for integer views |
| CGraph | View-value graph for propagation of upper bound |
| CIntBase | Number of values propagator for integer views base class |
| CLqBool | Less or equal to number of values propagator for Boolean views |
| CLqInt | Less or equal to number of values propagator for integer views |
| CRangeEvent | Event for range-based overlap analysis |
| CSymBitMatrix | Symmetric diagonal bit matrix |
| ►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 |
| CEqBnd | Binary bounds consistent equality propagator |
| CEqDom | Binary domain consistent equality propagator |
| CEqVal | Binary value propagation equality propagator |
| CLe | Less propagator |
| CLexLqLe | Lexical ordering propagator |
| CLexNq | Lexical disequality propagator |
| CLq | Less or equal propagator |
| CNaryEqBnd | N-ary bounds consistent equality propagator |
| CNaryEqDom | N-ary domain 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 |
| CNq | Binary disequality propagator |
| CReEqBnd | Reified binary bounds consistent equality propagator |
| CReEqBndInt | Reified bounds consistent equality with integer propagator |
| CReEqDom | Reified binary domain consistent equality propagator |
| CReEqDomInt | Reified domain consistent equality with integer propagator |
| CReLq | Reified less or equal propagator |
| CReLqInt | Reified less or equal with integer 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 |
| CManFixPSETask | Unary (mandatory) task with fixed processing, start or end time |
| CManFixPTask | Unary (mandatory) task with fixed processing time |
| CManFlexTask | Unary (mandatory) task with flexible processing time |
| CManProp | Scheduling propagator for unary 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 | Unary optional task with fixed processing, start or end time |
| COptFixPTask | Unary optional task with fixed processing time |
| COptFlexTask | Unary optional task with flexible processing time |
| COptProp | Scheduling propagator for unary resource with optional tasks |
| ►NUnshare | Unsharing shared variables |
| CVarPtrLess | Sort order for variables |
| ►NViewValGraph | Support classes for propagators using a view-value graph |
| CBiLink | Bidirectional links for edges and anchors in nodes of view-value graph |
| CCombPtrFlag | Class for combining two pointers with a flag |
| CEdge | Edges in view-value graph |
| CGraph | View-value graph base class |
| CIterPruneVal | Iterates the values to be pruned from a view node |
| CNode | Base-class for nodes (both view and value nodes) |
| CValNode | Value nodes in view-value graph |
| CViewNode | View nodes in view-value graph |
| 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 |
| CIntVarImpBase | Base-class for Int-variable implementations |
| CIntVarImpConf | Configuration for Int-variable implementations |
| CIntView | Integer view for integer variables |
| CLDSBBadValueSelection | Exception: Value selection incompatible with LDSB |
| CLDSBUnbranchedVariable | Exception: Variable in symmetry not branched on |
| 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 |
| CRelax | Class for posting equalities for non-relaxed variables |
| 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 |
| 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::Set::ConstSetView > | VarArg type for constant 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 |
| NConfig | |
| NMemoryConfig | Parameters defining memory management policy for spaces |
| ►CFunctionBranch | Brancher for calling a function |
| CDescription | Minimal brancher description storing no information |
| ►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 | Occurence information for a view |
| ►NMiniModel | Minimalistic modeling support |
| CArgumentOutOfRange | Exception: Argument out of range |
| CArgumentSizeMismatch | Exception: Sizes of arguments does not match |
| CArithNonLinFloatExpr | Non-linear float arithmetic expressions |
| CArithNonLinIntExpr | Non-linear arithmetic expressions over integer variables |
| CExpInfo | Expression information |
| CFinalBag | For collecting final states while constructing a DFA |
| CNodeInfo | Node information computed during traversal of the expressions |
| CPosInfo | Information on positions collected during traversal |
| CPosSet | Sets of positions |
| CSetNonLinIntExpr | Integer valued set expressions |
| CStateNode | Node together with state information |
| CStatePool | State pool combines a tree of states together with yet unprocessed states |
| CSymbolsInc | Sort symbols |
| CTooFewArguments | Exception: Too few arguments available in argument array |
| CTransitionBag | For collecting transitions while constructing a DFA |
| ►NSearch | Search engines |
| NConfig | Search configuration |
| ►NMeta | Meta search engine implementations |
| NParallel | Parallel meta search engine implementations |
| NSequential | Sequential meta search engine implementations |
| ►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 controling slaves in a portfolio |
| CSlave | Runnable slave of a portfolio master |
| NParallel | Parallel search engine implementations |
| ►NSeq | |
| CBAB | Implementation of depth-first branch-and-bound search engine |
| CDead | A dead engine (failed root) |
| 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 controling 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 |
| NSequential | Sequential search engine implementations |
| CBabBuilder | A BAB engine builder |
| CBase | Base-class for 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 |
| 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 |
| CExcNGL | No-good literal for exclusion |
| CIncNGL | No-good literal for inclusion |
| CMeritActionSize | Merit class for action over size |
| CMeritAFCSize | Merit class for AFC over size |
| CMeritCHBSize | Merit class for CHB Q-score over size |
| CMeritDegreeSize | Merit class for degree over size |
| CMeritMax | Merit class for maximum of set view |
| CMeritMin | Merit class for mimimum of set views |
| CMeritSize | Merit class for size of set view |
| CValCommitExc | Value commit class for exclusion |
| CValCommitInc | Value commit class for inclusion |
| CValSelMax | Value selection class for maximum of view |
| CValSelMed | Value selection class for median of view |
| CValSelMin | Value selection class for mimimum of view |
| CValSelRnd | Value selection class for random value of view |
| ►NChannel | Channeling propagators for set variables |
| ►CChannelBool | Propagator for channelling between set variable and its characteristic function |
| CIndexAdvisor | Advisor storing a single index |
| CChannelInt | Propagator for channelling between variable-value-dual models |
| CChannelSet | Propagator for successors/predecessors channelling |
| CChannelSorted | Propagator for the sorted channel constraint |
| ►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 |
| CElementDisjoint | Propagator for element with disjointness |
| CElementIntersection | Propagator for element with intersection |
| CElementUnion | Propagator for element with union |
| CElementUnionConst | Propagator for element with union of constant sets |
| ►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 |
| CVariableMap | Map from variable implementation to index |
| NLimits | Numerical limits for set variables |
| ►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 |
| CIntersection | Propagator for ternary intersection |
| CIntersectionN | Propagator for nary intersection |
| CPartitionN | Propagator for nary partition |
| CSubOfUnion | Propagator for the subset of union |
| CSuperOfInter | Propagator for the superset of intersection |
| CUnion | Propagator for ternary union |
| CUnionN | Propagator for nary union |
| ►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 |
| CRelax | Class for posting equalities for non-relaxed variables |
| 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 |
| CDeleter | A class to delete the master (running in parallel) |
| CMaster | |
| CWorker | The actual worker using a thread to run a job |
| 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 |
| CBElementExpr | Boolean element expressions |
| 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 |
| CNode | Node for Boolean expression |
| 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 withot 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 |
| CInfo | View information |
| ►CRecorder | Propagator for recording chb information |
| CIdx | Advisor with index and change 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) |
| ►CDFAI | Data stored for a DFA |
| CHashEntry | Specification of transition range |
| CSymbols | Iterator for DFA symbols |
| CTransition | Specification of a DFA transition |
| CTransitions | Iterator for DFA transitions (sorted by symbols) |
| 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 |
| CMinInc | Sort ranges according to increasing minimum |
| 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 |
| CNode | Nodes for linear expressions |
| CLinFloatRel | Linear relations |
| ►CLinIntExpr | Linear expressions over integer variables |
| CNode | Nodes for linear expressions |
| 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 |
| C_I | 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 |
| CExp | Implementation of the actual expression tree |
| 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 |
| CEdgeInfo | Edge information |
| CEngineInfo | Information about an engine |
| 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 |
| CNode | Node for set expression |
| 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 |
| CBranchers | Class to iterate over branchers of a space |
| CIdlePropagators | Class to iterate over idle propagators of a space |
| CPropagators | Class to iterate over propagators of a space |
| CScheduledPropagators | Class to iterate over scheduled propagators 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 represeting a set of tuples |
| CData | Data stored for a Table |
| CRange | Range information |
| CRanges | Iterator over ranges |
| CValueData | Data about values in the table |
| 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 |
| CIdx | Advisor with index information |
| CSlack | Collection of slack values |
| CViewValBrancher | Generic brancher by view and value selection |
| CViewValNGL | View-value no-good literal |
| NJobShopConfig | Default configuration settings |
| ►Nstd | |
| Chash< Gecode::DFA > | Hashing for DFAs |
| Chash< Gecode::SharedArray< int > > | Hashing for tuple sets |
| Chash< Gecode::TupleSet > | Hashing for tuple sets |
| ►NTest | General test support |
| ►NArray | Tests for arrays |
| CIterator | Base class for testing iterators |
| CSharedArrayIterator | Class for testing the SharedArray iterator |
| CTestSpace | Test space |
| CVarArgsIterator | Class for testing the VarArgs iterator |
| CVarArrayIterator | Class for testing the VarArray iterator |
| CViewArrayIterator | Class for testing the ViewArray iterator |
| ►NAssign | Tests for assignments |
| CBool | Test branching with distinct propagator |
| CBoolTest | Base class for tests for branching on Boolean variables |
| CBoolTestSpace | Space for executing Boolean tests |
| CFloat | Test assignment with distinct propagator |
| CFloatTest | Base class for tests for branching on float variables |
| CFloatTestSpace | Space for executing Boolean tests |
| CInt | Test assignment with distinct propagator |
| CIntTest | Base class for tests for assigning integer variables |
| CIntTestSpace | Space for executing integer tests |
| CSet | Test assignment with disjoint union propagator |
| CSetTest | Base class for tests for branching on set variables |
| CSetTestSpace | Space for executing Boolean tests |
| ►NBranch | Tests for branchings |
| CBool | Test brancher with distinct propagator |
| CBoolTest | Base class for tests for branching on Boolean variables |
| CBoolTestSpace | Space for executing Boolean tests |
| CFloat | Test brancher with distinct propagator |
| CFloatTest | Base class for tests for branching on float variables |
| CFloatTestSpace | Space for executing Float tests |
| CInt | Test brancher with distinct propagator |
| CIntTest | Base class for tests for branching on integer variables |
| CIntTestSpace | Space for executing integer tests |
| CRunInfo | Information about one test-run |
| CSet | Test brancher |
| CSetTest | Base class for tests for branching on set variables |
| CSetTestSpace | Space for executing Set tests |
| ►NFlatZinc | Tests for FlatZinc |
| CFlatZincTest | Base class for tests for FlatZinc |
| ►NFloat | Testing domain floats |
| ►NArithmetic | Tests for arithmetic constraints |
| CAbsXX | Test for absolute value constraint with shared variables |
| CAbsXY | Test for absolute value constraint |
| CDiv | Test for division constraint |
| CDivSol | Test for division constraint when solution is ensured |
| CMaxNary | Test for n-ary maximum constraint |
| CMaxNaryShared | Test for n-ary maximum constraint with shared variables |
| CMaxXXX | Test for binary maximum constraint with shared variables |
| CMaxXXY | Test for binary maximum constraint with shared variables |
| CMaxXYX | Test for binary maximum constraint with shared variables |
| CMaxXYY | Test for binary maximum constraint with shared variables |
| CMaxXYZ | Test for binary maximum constraint |
| CMinNary | Test for n-ary minimmum constraint |
| CMinNaryShared | Test for n-ary minimmum constraint with shared variables |
| CMinXXX | Test for binary minimum constraint with shared variables |
| CMinXXY | Test for binary minimum constraint with shared variables |
| CMinXYX | Test for binary minimum constraint with shared variables |
| CMinXYY | Test for binary minimum constraint with shared variables |
| CMinXYZ | Test for binary minimum constraint |
| CMultXXX | Test for multiplication constraint with shared variables |
| CMultXXY | Test for multiplication constraint with shared variables |
| CMultXXYSol | Test for multiplication constraint with shared variables when solution is ensured |
| CMultXYX | Test for multiplication constraint with shared variables |
| CMultXYY | Test for multiplication constraint with shared variables |
| CMultXYZ | Test for multiplication constraint |
| CMultXYZSol | Test for multiplication constraint when solution is ensured |
| CNRootXX | Test for nroot constraint with shared variables |
| CNRootXY | Test for nroot constraint |
| CNRootXYSol | Test for nroot constraint where solution is ensured |
| CPowXX | Test for pow constraint with shared variables |
| CPowXY | Test for pow constraint |
| CPowXYSol | Test for pow constraint where solution is ensured |
| CSqrtXX | Test for square root constraint with shared variables |
| CSqrtXY | Test for square root constraint |
| CSqrtXYSol | Test for square root constraint where solution is ensured |
| CSqrXX | Test for squaring constraint with shared variables |
| CSqrXY | Test for squaring constraint |
| CSqrXYSol | Test for squaring constraint where solution is ensured |
| ►NBasic | Tests for basic setup |
| CBasic | Test whether testing infrastructure for float variables works |
| ►NChannel | Tests for channel constraints |
| CBool | Test channel between float and Boolean |
| CInt | Test channel between float and integer |
| ►NDom | Tests for domain constraints |
| CCreate | Help class to create and register tests |
| CNum | Test for domain constraints with float numbers |
| CVal | Test for domain constraints with a float value |
| ►NLinear | Tests for linear constraints |
| CCreate | Help class to create and register tests |
| CFloatFloat | Test linear relation over float variables |
| CFloatVar | Test linear relation over float variables |
| ►NMiniModelLin | Tests for minimal modeling constraints (linear) |
| CCreate | Help class to create and register tests |
| CLinExpr | Test linear expressions over float variables |
| CLinInstr | Type for representing a linear instruction |
| CLinRel | Test linear relations over float variables |
| ►NRel | Tests for relation constraints |
| CCreate | Help class to create and register tests |
| CFloatFloat | Test for simple relation involving float variable and float constant |
| CFloatVarXX | Test for simple relation involving shared float variables |
| CFloatVarXY | Test for simple relation involving float variables |
| ►NTranscendental | Tests for transcendental constraints |
| CExpXX | Test for exponent constraint with shared variables |
| CExpXY | Test for exponent constraint |
| CExpXYSol | Test for exponent constraint where solution is ensured |
| CLogNXX | Test for logarithm base n constraint with shared variables |
| CLogNXY | Test for logarithm base n constraint |
| CLogNXYSol | Test for logarithm base n constraint where solution is ensured |
| CLogXX | Test for logarithm constraint with shared variables |
| CLogXY | Test for logarithm constraint |
| CLogXYSol | Test for logarithm constraint where solution is ensured |
| CPowXX | Test for pow exponent n constraint with shared variables |
| CPowXY | Test for pow exponent n constraint |
| CPowXYSol | Test for pow exponent n constraint where solution is ensured |
| ►NTrigonometric | Tests for trigonometric constraints |
| CACosXX | Test for acosinus constraint with shared variables |
| CACosXY | Test for acosinus constraint |
| CACosXYSol | Test for acosinus constraint where solution is ensured |
| CASinXX | Test for asinus constraint with shared variables |
| CASinXY | Test for asinus constraint |
| CASinXYSol | Test for asinus constraint where solution is ensured |
| CATanXX | Test for atangent constraint with shared variables |
| CATanXY | Test for atangent constraint |
| CATanXYSol | Test for atangent constraint where solution is ensured |
| CCosXX | Test for cosinus constraint with shared variables |
| CCosXY | Test for cosinus constraint |
| CCosXYSol | Test for cosinus constraint where solution is ensured |
| CSinXX | Test for sinus constraint with shared variables |
| CSinXY | Test for sinus constraint |
| CSinXYSol | Test for sinus constraint where solution is ensured |
| CTanXX | Test for tangent constraint with shared variables |
| CTanXY | Test for tangent constraint |
| CTanXYSol | Test for tangent constraint where solution is ensured |
| CAssignment | Base class for assignments |
| CCpltAssignment | Generate all assignments |
| CExtAssignment | Generate all assignments except the last variable and complete it to get a solution |
| CFloatRelTypes | Iterator for float relation types |
| CRandomAssignment | Generate random selection of assignments |
| CTest | Base class for tests with float constraints |
| CTestSpace | Space for executing tests |
| ►NInt | Testing finite domain integers |
| ►NArithmetic | Tests for arithmetic constraints |
| CAbsXX | Test for absolute value constraint with shared variables |
| CAbsXY | Test for absolute value constraint |
| CArgMax | Test for argument maximum constraint |
| CArgMaxBool | Test for Boolean argument maximum constraint |
| CArgMaxBoolShared | Test for argument maximum constraint with shared variables |
| CArgMaxShared | Test for argument maximum constraint with shared variables |
| CArgMin | Test for argument minimum constraint |
| CArgMinBool | Test for argument minimum constraint |
| CArgMinBoolShared | Test for argument minimum constraint with shared variables |
| CArgMinShared | Test for argument minimum constraint with shared variables |
| CCreate | Help class to create and register tests |
| CDiv | Test for division constraint |
| CDivMod | Test for division/modulo constraint |
| CMaxNary | Test for n-ary maximum constraint |
| CMaxNaryShared | Test for n-ary maximum constraint with shared variables |
| CMaxXXX | Test for binary maximum constraint with shared variables |
| CMaxXXY | Test for binary maximum constraint with shared variables |
| CMaxXYX | Test for binary maximum constraint with shared variables |
| CMaxXYY | Test for binary maximum constraint with shared variables |
| CMaxXYZ | Test for binary maximum constraint |
| CMinNary | Test for n-ary minimmum constraint |
| CMinNaryShared | Test for n-ary minimmum constraint with shared variables |
| CMinXXX | Test for binary minimum constraint with shared variables |
| CMinXXY | Test for binary minimum constraint with shared variables |
| CMinXYX | Test for binary minimum constraint with shared variables |
| CMinXYY | Test for binary minimum constraint with shared variables |
| CMinXYZ | Test for binary minimum constraint |
| CMod | Test for modulo constraint |
| CMultXXX | Test for multiplication constraint with shared variables |
| CMultXXY | Test for multiplication constraint with shared variables |
| CMultXYX | Test for multiplication constraint with shared variables |
| CMultXYY | Test for multiplication constraint with shared variables |
| CMultXYZ | Test for multiplication constraint |
| CNrootXX | Test for nroot constraint with shared variables |
| CNrootXY | Test for nroot constraint |
| CPowXX | Test for power constraint with shared variables |
| CPowXY | Test for power constraint |
| CSqrtXX | Test for square root constraint with shared variables |
| CSqrtXY | Test for square root constraint |
| CSqrXX | Test for squaring constraint with shared variables |
| CSqrXY | Test for squaring constraint |
| ►NBasic | Tests for basic setup |
| CBasic | Test whether testing infrastructure for integer variables works |
| ►NBinPacking | Tests for bin-packing constraint |
| CBPT | Test with different bin loads and items |
| ►CCliqueMBPT | Test for testing the max-clique finding for multi bin-packing |
| CTestSpace | Simple test space class |
| CCreate | Help class to create and register tests |
| CLoadBinAssignment | Generate load and bin assignments |
| CMBPT | Test with different bin loads and items |
| ►NBool | Tests for Boolean constraints |
| CBinConstXX | Test for binary Boolean operation with shared variables and constant |
| CBinConstXY | Test for binary Boolean operation with constant |
| CBinXXX | Test for binary Boolean operation with shared variables |
| CBinXXY | Test for binary Boolean operation with shared variables |
| CBinXYX | Test for binary Boolean operation with shared variables |
| CBinXYY | Test for binary Boolean operation with shared variables |
| CBinXYZ | Test for binary Boolean operation |
| CClauseConst | Test for Clause Boolean operation with constant |
| CClauseXXY | Test for Clause Boolean operation |
| CClauseXXYYX | Test for Clause Boolean operation |
| CClauseXYZ | Test for Clause Boolean operation |
| CCreate | Help class to create and register tests |
| CITEBool | Test for if-then-else-constraint |
| CITEInt | Test for if-then-else-constraint |
| CNary | Test for Nary Boolean operation |
| CNaryConst | Test for Nary Boolean operation with constant |
| CNaryShared | Test for Nary Boolean operation |
| ►NChannel | Tests for channel constraints |
| CChannelFull | Simple test for channel (testing all variables) |
| CChannelHalf | Simple test for channel (testing single set of variables) |
| CChannelLinkMulti | Test channel between integer variable and array of Boolean variables |
| CChannelLinkSingle | Test channel between integer and Boolean variable |
| CChannelShared | Test channel with shared variables |
| ►NCircuit | Tests for circuit constraints |
| CCircuit | Simple test for circuit constraint |
| CCircuitCost | Simple test for circuit constraint with total cost |
| CCircuitFullCost | Simple test for circuit constraint with full cost information |
| CCreate | Help class to create and register tests |
| CPath | Simple test for Hamiltonian path constraint |
| CPathCost | Simple test for path constraint with total cost |
| ►NCount | Tests for count constraints |
| CCreate | Help class to create and register tests |
| CIntArrayInt | Test number of several equal integers equal to integer |
| CIntArrayVar | Test number of several equal integers equal to integer variable |
| CIntInt | Test number of equal integers equal to integer |
| CIntIntDup | Test number of equal integers equal to integer with duplicate variables |
| CIntVar | Test number of equal integers equal to integer variable |
| CIntVarShared | Test number of equal integers equal to integer variable with sharing |
| CSetInt | Test number of integers contained in an integer set equal to integer |
| CSetVar | Test number of integers contained in an integer set equal to integer variable |
| CVarInt | Test number of equal variables equal to integer |
| CVarVar | Test number of equal variables equal to integer variable |
| CVarVarSharedA | Test number of equal variables equal to integer variable with sharing |
| CVarVarSharedB | Test number of equal variables equal to integer variable with sharing |
| CVarVarSharedC | Test number of equal variables equal to integer variable with sharing |
| ►NCumulative | Tests for cumulative scheduling constraints |
| CCreate | Help class to create and register tests |
| CManFixPCumulative | Test for cumulative constraint with mandatory tasks |
| CManFlexCumulative | Test for cumulative constraint with flexible mandatory tasks |
| COptFixPCumulative | Test for cumulative constraint with optional tasks |
| COptFlexCumulative | Test for cumulative constraint with optional flexible tasks |
| ►NCumulatives | Tests for scheduling constraints |
| CAbove | Describe that event is above a certain limit |
| CAss | Script for generating assignments |
| CBelow | Describe that event is below a certain limit |
| CCumulativeAssignment | Class for generating reasonable assignments |
| CCumulatives | Test for cumulatives constraint |
| CEvent | Event to be scheduled |
| ►NDistinct | Tests for distinct constraints |
| CDistinct | Simple test for distinct constraint |
| CExcept | Simple test for distinct except constant constraint |
| COffset | Simple test for distinct constraint with offsets |
| COptional | Simple test for optional distinct constraint |
| ►CPathological | Testing pathological cases |
| CTestSpace | Test space |
| CRandom | Randomized test for distinct constraint |
| ►NDom | Tests for domain constraints |
| CDomDom | Test for domain constraint (full integer set) |
| CDomInt | Test for domain constraint (integer) |
| CDomRange | Test for domain constraint (range) |
| CDomRangeEmpty | Test for domain constraint (empty range) |
| ►NElement | Tests for element constraints |
| CCreate | Help class to create and register tests |
| CIntBoolInt | Test for element with integer array and integer and Boolean variable |
| CIntBoolVar | Test for element with integer array and integer and Boolean variable |
| CIntIntInt | Test for element with integer array and integer variables |
| CIntIntShared | Test for element with integer array and single shared integer variable |
| CIntIntVar | Test for element with integer array and integer variables |
| CMatrixBoolVarBoolVarXX | Test for matrix element with Boolean variable array and Boolean variable |
| CMatrixBoolVarBoolVarXY | Test for matrix element with Boolean variable array and Boolean variable |
| CMatrixIntBoolVarXX | Test for matrix element with integer array and Boolean variable |
| CMatrixIntBoolVarXY | Test for matrix element with integer array and Boolean variable |
| CMatrixIntIntVarXX | Test for matrix element with integer array and integer variable |
| CMatrixIntIntVarXY | Test for matrix element with integer array and integer variable |
| CMatrixIntVarIntVarXX | Test for matrix element with integer variable array and integer variable |
| CMatrixIntVarIntVarXY | Test for matrix element with integer variable array and integer variable |
| CVarBoolInt | Test for element with Boolean variable array and integer variable |
| CVarBoolVar | Test for element with Boolean variable array and integer variable |
| CVarIntInt | Test for element with variable array and integer variables |
| CVarIntShared | Test for element with variable array and shared integer variable |
| CVarIntVar | Test for element with variable array and integer variables |
| ►NExec | Tests for synchronized execution |
| CBoolWait | Simple test for wait (Boolean variables) |
| CIntWait | Simple test for wait (integer variables) |
| CWhen | Simple test for when |
| ►NExtensional | Tests for extensional (relation) constraints |
| CCreate | Help class to create and register tests |
| CRandomTupleSetTest | |
| CRegDistinct | Test with regular expression for distinct constraint |
| CRegEmptyDFA | Test for empty DFA |
| CRegEmptyREG | Test for empty regular expression |
| CRegOpt | Test for optimizations |
| CRegRoland | Test with simple regular expression from Roland Yap |
| CRegSharedA | Test with simple regular expression and shared variables (uses unsharing) |
| CRegSharedB | Test with simple regular expression and shared variables (uses unsharing) |
| CRegSharedC | Test with simple regular expression and shared variables (uses unsharing) |
| CRegSharedD | Test with simple regular expression and shared variables (uses unsharing) |
| CRegSimpleA | Test with simple regular expression |
| CRegSimpleB | Test with simple regular expression |
| CRegSimpleC | Test with simple regular expression |
| CTupleSetBase | Test with tuple set |
| CTupleSetBool | Test with bool tuple set |
| CTupleSetLarge | Test with large tuple set |
| CTupleSetTest | Test with tuple set |
| CTupleSetTestSize | Help class to create and register tests with a fixed table size |
| ►NGCC | Tests for counting constraints (global cardinality) |
| CCreate | Help class to create and register tests |
| CIntAllMax | Test for integer cardinality with max cardinality for all variables |
| CIntAllMinMax | Test for integer cardinality with min and max for all variables |
| CIntAllMinMaxDef | Test for integer cardinality with min and max for all variables |
| CIntSome | Test for integer cardinality for some variables |
| CVarAll | Test for variable cardinality for all cardinality values |
| CVarSome | Test for variable cardinality for some cardinality values |
| ►NLinear | Tests for linear constraints |
| CBoolInt | Test linear relation over Boolean variables equal to constant |
| CBoolVar | Test linear relation over Boolean variables equal to integer variable |
| CCreate | Help class to create and register tests |
| CIntInt | Test linear relation over integer variables |
| CIntVar | Test linear relation over integer variables |
| ►NMember | Tests for membership constraints |
| CBool | Test membership for Boolean variables |
| CCreate | Help class to create and register tests |
| CInt | Test membership for integer variables |
| ►NMiniModel | Tests for minimal modelling constraints (simple relations) |
| CBoolLex | Test for relation between arrays of Boolean variables |
| CCreate | Help class to create and register tests |
| CIntLex | Test for relation between arrays of integer variables |
| ►NMiniModelArithmetic | Tests for minimal modelling constraints (arithmetic) |
| CAbs | Test for absolute value constraint |
| CDiv | Test for division constraint |
| CMax | Test for binary maximum constraint |
| CMaxNary | Test for n-ary maximum constraint |
| CMin | Test for binary minimum constraint |
| CMinNary | Test for n-ary minimmum constraint |
| CMinus | Test for subtraction constraint |
| CMod | Test for division constraint |
| CMult | Test for multiplication constraint |
| CPlus | Test for addition constraint |
| CSqr | Test for sqr constraint |
| CSqrt | Test for sqrt constraint |
| ►NMiniModelBoolean | Tests for minimal modelling constraints (Boolean) |
| CBoolElement | Test for Boolean element (regression) |
| CBoolExprInt | Test Boolean expressions with integer result |
| CBoolExprVar | Test posting Boolean expressions |
| CBoolInstr | Type for representing a Boolean instruction |
| CCreate | Help class to create and register tests |
| ►NMiniModelCount | Tests for minimal modelling constraints (counting) |
| CCreate | Help class to create and register tests |
| CIntArrayInt | Test number of several equal integers equal to integer |
| CIntArrayVar | Test number of several equal integers equal to integer variable |
| CIntInt | Test number of equal integers equal to integer |
| CIntVar | Test number of equal integers equal to integer variable |
| CVarInt | Test number of equal variables equal to integer |
| CVarVar | Test number of equal variables equal to integer variable |
| ►NMiniModelLin | Tests for minimal modelling constraints (linear) |
| CCreate | Help class to create and register tests |
| CLinExprBool | Test linear expressions over Boolean variables |
| CLinExprInt | Test linear expressions over integer variables |
| CLinExprMixed | Test linear expressions over integer and Boolean variables |
| CLinInstr | Type for representing a linear instruction |
| CLinRelBool | Test linear relations over Boolean variables |
| CLinRelInt | Test linear relations over integer variables |
| CLinRelMixed | Test linear relations over integer and Boolean variables |
| ►NMiniModelSet | Tests for minimal modelling constraints (Set) |
| CCreate | Help class to create and register tests |
| CSetExprConst | Test set expressions with constant result |
| CSetExprExpr | Test set expressions with expression result |
| CSetInstr | Type for representing a set instruction |
| ►NNoOverlap | Tests for no-overlap constraint |
| CCreate | Help class to create and register tests |
| CInt2 | Test for no-overlap with integer dimensions (rectangles) |
| CIntOpt2 | Test for no-overlap with optional rectangles |
| CVar2 | Test for no-overlap with variable dimensions (rectangles) |
| CVarOpt2 | Test for no-overlap with optional rectangles |
| CVarOptShared2 | Test for no-overlap with optional rectangles and shared variables |
| ►NNValues | Tests for number of values constraints |
| CBoolInt | Test number of values of Boolean variables equal to integer |
| CBoolVar | Test number of values of Boolean variables equal to integer variable |
| CCreate | Help class to create and register tests |
| CIntInt | Test number of values of integer variables equal to integer |
| CIntVar | Test number of values of integer variables equal to integer variable |
| ►NOrder | Tests for order constraint |
| CCreate | Help class to create and register tests |
| CInt | Test order for integer variables |
| ►NPrecede | Tests for value precedence constraints |
| CMulti | Test for multiple value precedence constraint |
| CSingle | Test for single value precedence constraint |
| ►NRel | Tests for relation constraints |
| CBoolArrayInt | Test for relation between arrays of Boolean variables and integers |
| CBoolArrayVar | Test for relation between arrays of Boolean variables |
| CBoolInt | Test for simple relation involving Boolean variable and integer constant |
| CBoolSeq | Test for sequence of relations between Boolean variables |
| CBoolSharedSeq | Test for sequence of relations between shared Boolean variables |
| CBoolVarXX | Test for simple relation involving shared Boolean variables |
| CBoolVarXY | Test for simple relation involving Boolean variables |
| CCreate | Help class to create and register tests |
| CIntArrayDiff | Test for relation between differently sized arrays of integer variables |
| CIntArrayInt | Test for relation between same sized arrays of integer variables and integers |
| CIntArrayVar | Test for relation between same sized arrays of integer variables |
| CIntInt | Test for simple relation involving integer variable and integer constant |
| CIntSeq | Test for sequence of relations between integer variables |
| CIntSharedSeq | Test for sequence of relations between shared integer variables |
| CIntVarXX | Test for simple relation involving shared integer variables |
| CIntVarXY | Test for simple relation involving integer variables |
| ►NSequence | Tests for sequence constraints |
| CCreate | Help class to create and register tests |
| CSequenceBoolTest | Test for sequence with boolean variables |
| CSequenceIntTest | Test for sequence with boolean variables |
| CSequenceTest | Base test for sequence |
| ►NSorted | Tests for sorted constraints |
| CNoVar | Test sorted without permutation variables |
| CPermVar | Test sorted with permutation variables |
| CSortIntMin | Relation for sorting integers in increasing order |
| ►NUnary | Tests for unary scheduling constraints |
| CCreate | Help class to create and register tests |
| CManFixPUnary | Test for unary constraint |
| CManFlexUnary | Test for unary constraint |
| COptFixPUnary | Test for unary constraint with optional tasks |
| COptFlexUnary | Test for unary constraint with optional tasks |
| ►NUnshare | Tests for unsharing variables in arrays |
| CBool | Test for unsharing Boolean variables |
| CFailed | Test for unsharing in failed spaces |
| CInt | Test for unsharing integer variables |
| CAssignment | Base class for assignments |
| CBoolOpTypes | Iterator for Boolean operation types |
| CCpltAssignment | Generate all assignments |
| CIntPropBasicAdvanced | Iterator for basic and advanced integer propagation levels |
| CIntPropLevels | Iterator for simple integer propagation levels |
| CIntRelTypes | Iterator for integer relation types |
| CRandomAssignment | Generate random selection of assignments |
| CRandomMixAssignment | Generate random selection of assignments |
| CTest | Base class for tests with integer constraints |
| CTestSpace | Space for executing tests |
| ►NLDSB | Testing for LDSB |
| CAction1 | Test with action |
| CLDSB | Test for LDSB infrastructure |
| ►CLDSBLatin | Test for LDSB infrastructure with Latin square problem |
| CLatin | Latin square space |
| CLDSBSet | Test for LDSB infrastructure |
| CMatSym1 | Test for matrix symmetry |
| CMatSym2 | Test for matrix symmetry |
| CMatSym3 | Test for matrix symmetry |
| CMatSym4 | Test for matrix symmetry |
| COneArray | Test space |
| COneArraySet | Test space (set version) |
| CRecomputation | Test for handling of recomputation |
| CReflectSym1 | Test for reflection symmetry |
| CReflectSym2 | Test for reflection symmetry |
| CSetValSym1 | Test for set value symmetry |
| CSetValSym2 | Test for set value symmetry |
| CSetVarSeqSym1 | Test for set variable sequence symmetry |
| CSetVarSeqSym2 | Test for set variable sequence symmetry |
| CSetVarSym1 | Test for set variable symmetry |
| CSimIntValSym1 | Test for value sequence symmetry |
| CSimIntValSym2 | Test for value sequence symmetry |
| CSimIntValSym3 | Test for value sequence symmetry |
| CSimIntVarSym1 | Test for variable sequence symmetry |
| CSimIntVarSym2 | Test for variable sequence symmetry |
| CTieBreak | Test tiebreaking variable heuristic |
| CValSym1 | Test for value symmetry |
| CValSym1b | Test for value symmetry |
| CValSym1c | Test for value symmetry |
| CValSym2 | Test for value symmetry |
| CValSym2b | Test for value symmetry |
| CValSym3 | Test for value symmetry |
| CValSym4 | Test for value symmetry |
| CValSym5 | Test for value symmetry |
| CVarSym1 | Test for variable symmetry |
| CVarSym1b | Test for variable symmetry |
| CVarSym2 | Test for variable symmetry |
| CVarSym3 | Test for variable symmetry |
| CVarSym4 | Test for variable symmetry |
| CVarSym5 | Test for variable symmetry |
| CVarValSym1 | Test for variable and value symmetry |
| ►NNoGoods | Tests for search using no-goods |
| CCreate | Help class to create and register tests |
| CHamming | Example for testing set no-goods |
| CNoGoods | Base class for no-good tests |
| CQueens | Example for testing integer no-goods |
| ►NSearch | Tests for search engines |
| CBAB | Test for best solution search |
| CBranchTypes | Iterator for branching types |
| CConstrainTypes | Iterator for constrain types |
| CCreate | Help class to create and register tests |
| CDFS | Test for depth-first search |
| CFailImmediate | Space that immediately fails |
| CHasSolutions | Space that requires propagation and has solutions |
| CLDS | Test for limited discrepancy search |
| CPBS | Test for portfolio-based search |
| CRBS | Test for restart-based search |
| CSEBPBS | Test for portfolio-based search using SEBs |
| CSolveImmediate | Space that is immediately solved |
| CTest | Base class for search tests |
| CTestSpace | Space with information |
| ►NSet | Testing finite sets |
| ►NChannel | Tests for set channeling constraints |
| CChannelBool | Test for Boolean channel constraint |
| CChannelInt | Test for integer channel constraint |
| CChannelSet | Test for set channel constraint |
| CChannelSorted | Test for sorted channeling constraint |
| ►NConvex | Tests for convexity constraints |
| CConvex | Test for convexity propagator |
| CConvexHull | Test for convex hull propagator |
| CConvexHullS | Sharing test for convex hull propagator |
| ►NDistinct | Tests for distinctness constraints |
| CAtmostOne | Test for the atmostone propagator |
| ►NDom | Tests for domain constraints |
| CCardRange | Test for cardinality range |
| CDomDom | Test for equality with a domain |
| CDomInt | Test for equality with an integer |
| CDomIntRange | Test for equality with an integer range |
| CDomRange | Test for equality with a range |
| ►NElement | Tests for set element constraints |
| CElementDisjoint | Test for ElementDisjoint constraint |
| CElementInter | Test for ElementInter constraint |
| CElementInterIn | Test for ElementInter constraint |
| CElementSet | Test for ElementSet constraint |
| CElementSetConst | Test for ElementSetConst constraint |
| CElementUnion | Test for ElementUnion constraint |
| CElementUnionConst | Test for ElementUnionConst constraint |
| CMatrixIntSet | Test for matrix element with integer set array and set variable |
| ►NExec | Tests for synchronized execution |
| CWait | Simple test for wait (set variables) |
| ►NInt | Tests for combined int/set constraints |
| CCard | Test for cardinality constraint |
| CElem | Test for element constraint |
| CIntRel | Test for integer relation constraint |
| CMax | Test for maximal element constraint |
| CMin | Test for minimal element constraint |
| CNoElem | Test for negated element constraint |
| CNotMax | Test for negated maximal element constraint |
| CNotMin | Test for negated minimal element constraint |
| CRel | Test for relation constraint |
| CWeights | Test for set weight constraint |
| ►NPrecede | Tests for value precedence constraints |
| CMulti | Test for multiple value precedence constraint |
| CSingle | Test for single value precedence constraint |
| ►NRel | Tests for relation constraints |
| CITE | Test for if-then-else-constraint |
| CRelBin | Test for binary set relation constraint |
| ►NRelOp | Tests for relation/operation constraints |
| CCreate | Help class to create and register tests |
| CCreateIntN | Help class to create and register tests |
| CCreateN | Help class to create and register tests |
| CRel | Test for ternary relation constraint |
| CRelIntN | Test for n-ary partition constraint |
| CRelN | Test for n-ary partition constraint |
| ►NRelOpConst | Tests for relation/operation constraints with constants |
| CCreate | Help class to create and register tests |
| CRelISI | Test for set relation constraint with constants |
| CRelSIS | Test for set relation constraint with constants |
| CRelSSI | Test for set relation constraint with constants |
| ►NSequence | Tests for sequence constraints |
| CSeqU | Test for sequential-union constraint |
| CSequence | Test for sequence constraint |
| ►NVar | Tests for set variable conors |
| CConstruct | Test for cardinality constraint |
| CCountableSet | Iterate all subsets of a given set |
| CCountableSetRanges | Range iterator producing subsets of an IntSet |
| CCountableSetValues | Value iterator producing subsets of an IntSet |
| CSetAssignment | Generate all set assignments |
| CSetOpTypes | Iterator for Boolean operation types |
| CSetRelTypes | Iterator for set relation types |
| CSetTest | Base class for tests with set constraints |
| CSetTestSpace | Space for executing set tests |
| ►CAFC | Test for AFC infrastructure |
| CTestSpace | Test space |
| CBase | Base class for all tests to be run |
| Cind | Simple class for describing identation |
| COptions | Commandline options |
| CRegion | Test for Region memory area |
| CSortByName | Sort tests by name |
