# Class List

Here are the classes, structs, unions and interfaces with brief descriptions:AllInterval | Example: All-interval series |

Alpha | Example: Alpha puzzle |

BACP | Example: The balanced academic curriculum problem |

BACP::ValBestLoad< minimize > | Custom value selection class for a view-value branching |

BIBD | Example: Balanced incomplete block design (BIBD) |

BIBDOptions | Options for BIBD problems |

BinPacking | Example: Bin packing |

BlackHole | Example: Black hole patience |

BlackHoleBranch | Custom brancher for black hole patience |

BlackHoleBranch::Choice | Choice for black hole brancher |

CarSequencing | Example: Car sequencing |

CDBF | Custom brancher implementing CDBF |

CDBF::Choice | Choice |

Course | A course |

Crew | Example: Airline crew allocation |

Crossword | Example: Crossword puzzle |

CrowdedChess | Example: Crowded chessboard |

Curriculum | A curriculum |

Dictionary | A simple dictionary class |

DominatingQueens | Example: Dominating Queens |

Domino | Example: Solitaire domino |

Donald | Example: DONALD+GERALD=ROBERT puzzle |

EFPA | Example: Equidistant Frequency Permutation Arrays |

EFPAOptions | Options for EFPA problems |

Eq20 | Example: Solving 20 linear equations |

FileSizeOptions | Parse an additional file option |

Gecode::Actor | Base-class for both propagators and branchers |

Gecode::ActorLink | Double-linked list for actors |

Gecode::Advisor | Base-class for advisors |

Gecode::Advisors< A > | Class to iterate over advisors of a council |

Gecode::AllVarConf | Configuration for all variable implementations |

Gecode::Archive | Archive representation |

Gecode::ArchivedRandomGenerator | Random generator with archiving (to be used in branchers) |

Gecode::ArgArray< T > | Argument array for non-primitive types |

Gecode::ArgArrayBase< T > | Base-class for argument arrays |

Gecode::ArrayTraits< A > | Traits of arrays in Gecode |

Gecode::ArrayTraits< ArgArray< IntSet > > | Traits of IntSetArgs |

Gecode::ArrayTraits< BoolVarArgs > | Traits of BoolVarArgs |

Gecode::ArrayTraits< BoolVarArray > | Traits of BoolVarArray |

Gecode::ArrayTraits< IntArgs > | Traits of IntArgs |

Gecode::ArrayTraits< IntVarArgs > | Traits of IntVarArgs |

Gecode::ArrayTraits< IntVarArray > | Traits of IntVarArray |

Gecode::ArrayTraits< PrimArgArray< int > > | Traits of IntArgs |

Gecode::ArrayTraits< PrimArgArray< TaskType > > | Traits of TaskTypeArgs |

Gecode::ArrayTraits< SetVarArgs > | Traits of SetVarArgs |

Gecode::ArrayTraits< SetVarArray > | Traits of SetVarArray |

Gecode::ArrayTraits< VarArgArray< BoolVar > > | Traits of BoolVarArgs |

Gecode::ArrayTraits< VarArgArray< IntVar > > | Traits of IntVarArgs |

Gecode::ArrayTraits< VarArgArray< SetVar > > | Traits of VarArgArray<SetVar> |

Gecode::ArrayTraits< VarArray< BoolVar > > | Traits of BoolVarArray |

Gecode::ArrayTraits< VarArray< IntVar > > | Traits of IntVarArray |

Gecode::ArrayTraits< VarArray< SetVar > > | Traits of VarArray<SetVar> |

Gecode::BAB< T > | Depth-first branch-and-bound search engine |

Gecode::BaseOptions | Base class for script options |

Gecode::BElementExpr | Boolean element expressions |

Gecode::BinaryPropagator< View, pc > | Binary propagator |

Gecode::BoolExpr | Boolean expressions |

Gecode::BoolExpr::MiscExpr | Miscealloneous Boolean expressions |

Gecode::BoolExpr::NNF | Node for negation normalform (NNF) |

Gecode::BoolExpr::Node | Node for Boolean expression |

Gecode::BoolVar | Boolean integer variables |

Gecode::BoolVarArgs | Passing Boolean variables |

Gecode::BoolVarArray | Boolean variable array |

Gecode::Brancher | Base-class for branchers |

Gecode::Choice | Choice for performing commit |

Gecode::ChoiceVirtual< Choice > | Virtualized choice |

Gecode::ChoiceVirtualBase | Virtualized choice baseclass |

Gecode::CloneStatistics | Statistics for execution of clone |

Gecode::CommitStatistics | Statistics for execution of commit |

Gecode::ConstView< View > | Base-class for constant views |

Gecode::Council< A > | Council of advisors |

Gecode::Delta | Generic domain change information to be supplied to advisors |

Gecode::DerivedView< View > | Base-class for derived views |

Gecode::DFA | Deterministic finite automaton (DFA) |

Gecode::DFA::DFAI | Data stored for a DFA |

Gecode::DFA::DFAI::HashEntry | Specification of transition range |

Gecode::DFA::Symbols | Iterator for DFA symbols |

Gecode::DFA::Transition | Specification of a DFA transition |

Gecode::DFA::Transitions | Iterator for DFA transitions (sorted by symbols) |

Gecode::DFS< T > | Depth-first search engine |

Gecode::Driver::BaseOption | Base class for options |

Gecode::Driver::BoolOption | Boolean option |

Gecode::Driver::Cutoff | Stop object based on nodes, failures, and time |

Gecode::Driver::DoubleOption | Double option |

Gecode::Driver::IntOption | Integer option |

Gecode::Driver::ScriptBase< BaseSpace > | Parametric base-class for scripts |

Gecode::Driver::StringOption | String-valued option (integer value defined by strings) |

Gecode::Driver::StringOption::Value | Option value |

Gecode::Driver::StringValueOption | String-valued option |

Gecode::Driver::UnsignedIntOption | Unsigned integer option |

Gecode::DynamicCastFailed | Exception: dynamic cast failed |

Gecode::EmptyValSelChoice | Emty value selection choice |

Gecode::EmptyViewSelChoice | Emty view selection choice |

Gecode::Exception | Exception: Base-class for exceptions |

Gecode::FlatZinc::Alias | Alias for a variable specification |

Gecode::FlatZinc::AST::Array | Array node |

Gecode::FlatZinc::AST::ArrayAccess | Node representing an array access |

Gecode::FlatZinc::AST::Atom | Node representing an atom |

Gecode::FlatZinc::AST::BoolLit | Boolean literal node |

Gecode::FlatZinc::AST::BoolVar | Boolean variable node |

Gecode::FlatZinc::AST::Call | Node representing a function call |

Gecode::FlatZinc::AST::FloatLit | Float literal node |

Gecode::FlatZinc::AST::FloatVar | Float variable node |

Gecode::FlatZinc::AST::IntLit | Integer literal node |

Gecode::FlatZinc::AST::IntVar | Integer variable node |

Gecode::FlatZinc::AST::Node | A node in a FlatZinc abstract syntax tree |

Gecode::FlatZinc::AST::SetLit | Set literal node |

Gecode::FlatZinc::AST::SetVar | Set variable node |

Gecode::FlatZinc::AST::String | String node |

Gecode::FlatZinc::AST::TypeError | Exception signaling type error |

Gecode::FlatZinc::AST::Var | Variable node base class |

Gecode::FlatZinc::BoolVarSpec | Specification for Boolean variables |

Gecode::FlatZinc::ConExpr | Abstract representation of a constraint |

Gecode::FlatZinc::Error | Exception class for FlatZinc errors |

Gecode::FlatZinc::FlatZincOptions | Options for running FlatZinc models |

Gecode::FlatZinc::FlatZincSpace | A space that can be initialized with a FlatZinc model |

Gecode::FlatZinc::FloatVarSpec | Specification for floating point variables |

Gecode::FlatZinc::IntVarSpec | Specification for integer variables |

Gecode::FlatZinc::Option< Val > | Optional value |

Gecode::FlatZinc::OutputOrder | Strict weak ordering for output items |

Gecode::FlatZinc::ParserState | State of the FlatZinc parser |

Gecode::FlatZinc::Printer | Output support class for FlatZinc interpreter |

Gecode::FlatZinc::Registry | Map from constraint identifier to constraint posting functions |

Gecode::FlatZinc::SetVarSpec | Specification for set variables |

Gecode::FlatZinc::SymbolEntry | Entries in the symbol table |

Gecode::FlatZinc::SymbolTable< Val > | Symbol table mapping identifiers (strings) to values |

Gecode::FlatZinc::VarSpec | Base class for variable specifications |

Gecode::FreeList | Base-class for freelist-managed objects |

Gecode::FunctionBranch | Brancher for calling a function |

Gecode::FunctionBranch::Description | Minimal brancher description storing no information |

Gecode::Gist::AboutGist | Display information about Gist |

Gecode::Gist::BestNode | Static reference to the currently best space |

Gecode::Gist::BoundingBox | Bounding box |

Gecode::Gist::Branch | Representation of a branch in the search tree |

Gecode::Gist::Comparator | Abstract base class for comparators |

Gecode::Gist::DisposeCursor | A cursor that frees all memory |

Gecode::Gist::DrawingCursor | A cursor that draws a tree on a QWidget |

Gecode::Gist::Extent | Extent representing shape of a tree at one depth level |

Gecode::Gist::Gist | Gecode Interactive Search Tool |

Gecode::Gist::GistMainWindow | Main window for stand-alone Gist |

Gecode::Gist::GistOutputStream | An outputstream that prints on a QTextEdit |

Gecode::Gist::HideFailedCursor | A cursor that marks failed subtrees as hidden |

Gecode::Gist::Inspector | Abstract base class for inspectors |

Gecode::Gist::Layout | Layout parameters |

Gecode::Gist::LayoutCursor | A cursor that computes a tree layout for VisualNodes |

Gecode::Gist::Layouter | Helper functions for the layout algorithm |

Gecode::Gist::Logos | Class holding Gecode and Gist logo icons |

Gecode::Gist::NextSolCursor | A cursor that finds the next solution |

Gecode::Gist::Node | Base class for nodes of the search tree |

Gecode::Gist::NodeAllocatorBase< T > | Node allocator |

Gecode::Gist::NodeCursor< Node > | A cursor that can be run over a tree |

Gecode::Gist::NodeStatInspector | Display information about nodes |

Gecode::Gist::NodeVisitor< Cursor > | Base class for a visitor that runs a cursor over a tree |

Gecode::Gist::NodeWidget | Small node drawings for the status bar |

Gecode::Gist::Options | Options for Gist |

Gecode::Gist::Options::_I | Helper class storing inspectors |

Gecode::Gist::PostorderNodeVisitor< Cursor > | Run a cursor over a tree, processing nodes in post-order |

Gecode::Gist::PreferencesDialog | Preferences dialog for Gist |

Gecode::Gist::PreorderNodeVisitor< Cursor > | Run a cursor over a tree, processing nodes in pre-order |

Gecode::Gist::Print< S > | An inspector for printing simple text output |

Gecode::Gist::SearcherThread | A thread that concurrently explores the tree |

Gecode::Gist::SearchItem | A stack item for depth first search |

Gecode::Gist::Shape | The shape of a subtree |

Gecode::Gist::ShapeAllocator | Allocate shapes statically |

Gecode::Gist::SpaceNode | A node of a search tree of Gecode spaces |

Gecode::Gist::StatCursor | A cursor that collects statistics |

Gecode::Gist::Statistics | Statistics about the search tree |

Gecode::Gist::StopBrancher | Brancher that stops exploration in Gist |

Gecode::Gist::StopChoice | Choice for StopBrancher |

Gecode::Gist::TextOutput | An window for simple text output |

Gecode::Gist::TextOutputI | Window with associated ostream, used for inspecting Gist nodes |

Gecode::Gist::TreeCanvas | A canvas that displays the search tree |

Gecode::Gist::UnhideAllCursor | A cursor that marks all nodes in the tree as not hidden |

Gecode::Gist::UnstopAllCursor | A cursor that marks all nodes in the tree as not stopping |

Gecode::Gist::VarComparator< S > | A simple comparator |

Gecode::Gist::VisualNode | Node class that supports visual layout |

Gecode::GlobalPropInfo | Globally shared object for propagator information |

Gecode::Heap | Heap memory management class |

Gecode::HeapChunk | Memory chunk allocated from heap with proper alignment |

Gecode::Home | Home class for posting propagators |

Gecode::InstanceOptions | Options for scripts with additional instance parameter |

Gecode::Int::ArgumentSame | Exception: Arguments contain same variable multiply |

Gecode::Int::ArgumentSizeMismatch | Exception: Arguments are of different size |

Gecode::Int::Arithmetic::AbsBnd< View > | Bounds consistent absolute value propagator |

Gecode::Int::Arithmetic::AbsDom< View > | Domain consistent absolute value propagator |

Gecode::Int::Arithmetic::DivBnd< View > | Bounds consistent division propagator |

Gecode::Int::Arithmetic::DivMod< View > | Integer division/modulo propagator |

Gecode::Int::Arithmetic::DivPlusBnd< Val, VA, VB, VC > | Bounds consistent positive division propagator |

Gecode::Int::Arithmetic::MaxBnd< View > | Bounds consistent ternary maximum propagator |

Gecode::Int::Arithmetic::MaxDom< View > | Domain consistent ternary maximum propagator |

Gecode::Int::Arithmetic::MultBnd< View > | Bounds consistent multiplication propagator |

Gecode::Int::Arithmetic::MultDom< View > | Domain consistent multiplication propagator |

Gecode::Int::Arithmetic::MultPlusBnd< Val, VA, VB, VC > | Bounds consistent positive multiplication propagator |

Gecode::Int::Arithmetic::MultPlusDom< Val, VA, VB, VC > | Domain consistent positive multiplication propagator |

Gecode::Int::Arithmetic::MultZeroOne< View, pc > | Bounds or domain consistent propagator for |

Gecode::Int::Arithmetic::NaryMaxBnd< View > | Bounds consistent n-ary maximum propagator |

Gecode::Int::Arithmetic::NaryMaxDom< View > | Domain consistent n-ary maximum propagator |

Gecode::Int::Arithmetic::RangesMapSqr | Mapping ranges to squares |

Gecode::Int::Arithmetic::RangesMapSqrt | Mapping integer to square root |

Gecode::Int::Arithmetic::SqrBnd< View > | Bounds consistent square propagator |

Gecode::Int::Arithmetic::SqrDom< View > | Domain consistent square propagator |

Gecode::Int::Arithmetic::SqrPlusBnd< VA, VB > | Bounds consistent positive square propagator |

Gecode::Int::Arithmetic::SqrPlusDom< VA, VB > | Domain consistent positive square propagator |

Gecode::Int::Arithmetic::SqrtBnd< View > | Bounds consistent square root propagator |

Gecode::Int::Arithmetic::SqrtDom< View > | Domain consistent square root propagator |

Gecode::Int::Arithmetic::ValuesMapSqr | Mapping integer to square |

Gecode::Int::Arithmetic::ValuesMapSqrt | Mapping integer to square root |

Gecode::Int::BinPacking::Item | Item combining bin and size information |

Gecode::Int::BinPacking::Pack | Bin-packing propagator |

Gecode::Int::BinPacking::SizeSet | Size sets |

Gecode::Int::BinPacking::SizeSetMinusOne | Size sets with one element discarded |

Gecode::Int::BinPacking::TellCache | Record tell information |

Gecode::Int::Bool::BinOrTrue< BVA, BVB > | Binary Boolean disjunction propagator (true) |

Gecode::Int::Bool::BoolBinary< BVA, BVB > | Base-class for binary Boolean propagators |

Gecode::Int::Bool::BoolTernary< BVA, BVB, BVC > | Base-class for ternary Boolean propagators |

Gecode::Int::Bool::Clause< VX, VY > | Boolean clause propagator (disjunctive) |

Gecode::Int::Bool::Clause< VX, VY >::Tagged | Advisors for views (tagged whether for x or y) |

Gecode::Int::Bool::ClauseTrue< VX, VY > | Boolean clause propagator (disjunctive, true) |

Gecode::Int::Bool::Eq< BVA, BVB > | Boolean equality propagator |

Gecode::Int::Bool::Eqv< BVA, BVB, BVC > | Boolean equivalence propagator |

Gecode::Int::Bool::Le< BV > | Boolean less propagator |

Gecode::Int::Bool::Lq< BV > | Boolean less or equal propagator |

Gecode::Int::Bool::NaryEq< BV > | N-ary Boolean equality propagator |

Gecode::Int::Bool::NaryEqv | Boolean n-ary equivalence propagator |

Gecode::Int::Bool::NaryLq< VX > | Nary Boolean less or equal propagator |

Gecode::Int::Bool::NaryOr< VX, VY > | Boolean n-ary disjunction propagator |

Gecode::Int::Bool::NaryOrTrue< BV > | Boolean n-ary disjunction propagator (true) |

Gecode::Int::Bool::Or< BVA, BVB, BVC > | Boolean disjunction propagator |

Gecode::Int::Bool::OrTrueSubsumed< BV > | Binary Boolean disjunction propagator (subsumed) |

Gecode::Int::Bool::QuadOrTrue< BV > | Quarternary Boolean disjunction propagator (true) |

Gecode::Int::Bool::TerOrTrue< BV > | Ternary Boolean disjunction propagator (true) |

Gecode::Int::BoolVarImp | Boolean variable implementation |

Gecode::Int::BoolVarImpBase | Base-class for Bool-variable implementations |

Gecode::Int::BoolVarImpConf | Configuration for Bool-variable implementations |

Gecode::Int::BoolView | Boolean view for Boolean variables |

Gecode::Int::Branch::AssignValMed< View > | Class for assigning maximum value |

Gecode::Int::Branch::AssignValMin< View > | Class for assigning minimum value |

Gecode::Int::Branch::AssignValRnd< View > | Class for assigning random value |

Gecode::Int::Branch::AssignValZero< View > | Class for assigning zero |

Gecode::Int::Branch::ByMaxMax | View selection class for view with largest max |

Gecode::Int::Branch::ByMaxMin | View selection class for view with smallest max |

Gecode::Int::Branch::ByMinMax | View selection class for view with largest min |

Gecode::Int::Branch::ByMinMin | View selection class for view with smallest min |

Gecode::Int::Branch::ByRegretMaxMax | View selection class for view with largest max-regret |

Gecode::Int::Branch::ByRegretMaxMin | View selection class for view with smallest max-regret |

Gecode::Int::Branch::ByRegretMinMax | View selection class for view with largest min-regret |

Gecode::Int::Branch::ByRegretMinMin | View selection class for view with smallest min-regret |

Gecode::Int::Branch::BySizeAfcMax | View selection class for view with largest size divided by accumulated failure count |

Gecode::Int::Branch::BySizeAfcMin | View selection class for view with smallest size divided by accumulated failure count |

Gecode::Int::Branch::BySizeDegreeMax | View selection class for view with largest size divided by degree |

Gecode::Int::Branch::BySizeDegreeMin | View selection class for view with smallest size divided by degree |

Gecode::Int::Branch::BySizeMax | View selection class for view with largest size |

Gecode::Int::Branch::BySizeMin | View selection class for view with smallest size |

Gecode::Int::Branch::NoValue | For Boolean branchers not needing a value |

Gecode::Int::Branch::PosValuesChoice< ViewSel, View > | Choice storing position and values |

Gecode::Int::Branch::ValMed< View > | Class for selecting median value |

Gecode::Int::Branch::ValMin< View > | Class for selecting minimum value |

Gecode::Int::Branch::ValRangeMin< View > | Class for trying the first range of a domain first or splitting domain at mean of smallest and largest element (lower half first) |

Gecode::Int::Branch::ValRnd< _View > | Class for random value selection |

Gecode::Int::Branch::ValSplitMin< View > | Class for splitting domain at mean of smallest and largest element (lower half first) |

Gecode::Int::Branch::ValZeroOne< View > | Class for trying zero and then one |

Gecode::Int::Branch::ViewValuesBrancher< ViewSel, View > | Brancher by view and values selection |

Gecode::Int::CachedView< View > | Cached integer view |

Gecode::Int::Channel::Base< Info, Offset, pc > | Base-class for channel propagators |

Gecode::Int::Channel::BoolIter | Iterates the values to be removed as defined by an array of Boolean views |

Gecode::Int::Channel::Dom< View, Offset, shared > | Domain consistent channel propagator |

Gecode::Int::Channel::DomInfo< View, Offset > | Combine view with information for domain propagation |

Gecode::Int::Channel::LinkMulti | Link propagator for multiple Boolean views |

Gecode::Int::Channel::LinkSingle | Link propagator for a single Boolean view |

Gecode::Int::Channel::Val< View, Offset, shared > | Naive channel propagator |

Gecode::Int::Channel::ValInfo< View > | Combine view with information for value propagation |

Gecode::Int::Circuit::Base< View, Offset > | Base-class for circuit propagator |

Gecode::Int::Circuit::Dom< View, Offset > | "Domain consistent" circuit propagator |

Gecode::Int::Circuit::SsccInfo< View > | Information required for non-recursive checking for a single scc |

Gecode::Int::Circuit::TellInfo< View > | Information for performing a recorded tell |

Gecode::Int::Circuit::Val< View, Offset > | "Value-consistent" circuit propagator |

Gecode::Int::ConstIntView | Constant integer view |

Gecode::Int::Count::EqInt< VX, VY > | Propagator for counting views (equal integer to number of equal views) |

Gecode::Int::Count::EqView< VX, VY, VZ, shr, dom > | Propagator for counting views (equal to number of equal views) |

Gecode::Int::Count::GqInt< VX, VY > | Propagator for counting views (greater or equal integer to number of equal views) |

Gecode::Int::Count::GqView< VX, VY, VZ, shr, dom > | Propagator for counting views (greater or equal to number of equal views) |

Gecode::Int::Count::IntBase< VX, VY > | Baseclass for count propagators (integer) |

Gecode::Int::Count::LqInt< VX, VY > | Propagator for counting views (less or equal integer to number of equal views) |

Gecode::Int::Count::LqView< VX, VY, VZ, shr > | Propagator for counting views (less or equal to number of equal views) |

Gecode::Int::Count::ViewBase< VX, VY, VZ > | Base-class for count propagators (view) |

Gecode::Int::Cumulative::Event | Event for task |

Gecode::Int::Cumulative::ExtOmegaNode | Node for an extended omega tree |

Gecode::Int::Cumulative::ExtOmegaTree< TaskView > | Omega trees for computing ect of task sets |

Gecode::Int::Cumulative::ManFixPSETask | Cumulative (mandatory) task with fixed processing, start or end time |

Gecode::Int::Cumulative::ManFixPTask | Cumulative (mandatory) task with fixed processing time |

Gecode::Int::Cumulative::ManFlexTask | Cumulative (mandatory) task with flexible processing time |

Gecode::Int::Cumulative::ManProp< ManTask, Cap > | Scheduling propagator for cumulative resource with mandatory tasks |

Gecode::Int::Cumulative::OmegaLambdaNode | Node for an omega lambda tree |

Gecode::Int::Cumulative::OmegaLambdaTree< TaskView > | Omega-lambda trees for computing ect of task sets |

Gecode::Int::Cumulative::OmegaNode | Node for an omega tree |

Gecode::Int::Cumulative::OmegaTree< TaskView > | Omega trees for computing ect of task sets |

Gecode::Int::Cumulative::OptFixPSETask | Cumulative optional task with fixed processing, start or end time |

Gecode::Int::Cumulative::OptFixPTask | Cumulative optional task with fixed processing time |

Gecode::Int::Cumulative::OptFlexTask | Cumulative optional task with flexible processing time |

Gecode::Int::Cumulative::OptProp< OptTask, Cap > | Scheduling propagator for cumulative resource with optional tasks |

Gecode::Int::Cumulative::PrecOrder | Sort by prec array |

Gecode::Int::Cumulative::StoCap< TaskView, inc > | Sort by capacity |

Gecode::Int::Cumulative::TaskByDecCap< Task > | Sort order for tasks by decreasing capacity |

Gecode::Int::Cumulatives::Event | An event collects the information for one evnet for the sweep-line |

Gecode::Int::Cumulatives::Val< ViewM, ViewP, ViewU, View > | Propagator for the cumulatives constraint |

Gecode::Int::Distinct::Bnd< View > | Bounds consistent distinct propagator |

Gecode::Int::Distinct::Dom< View > | Domain consistent distinct propagator |

Gecode::Int::Distinct::DomCtrl< View > | Propagation controller for domain consistent distinct |

Gecode::Int::Distinct::Graph< View > | View-value graph for propagation |

Gecode::Int::Distinct::HallInfo | Information on Hall intervals |

Gecode::Int::Distinct::MaxIncIdx< View > | Sort-order by increasing maximum (by index) |

Gecode::Int::Distinct::MinInc< View > | Sort-order by increasing minimum (direct) |

Gecode::Int::Distinct::MinIncIdx< View > | Sort-order by increasing minimum (by index) |

Gecode::Int::Distinct::Rank | Rank information |

Gecode::Int::Distinct::TerDom< View > | Ternary domain consistent distinct propagator |

Gecode::Int::Distinct::Val< View > | Naive value distinct propagator |

Gecode::Int::Dom::ReIntSet< View > | Reified domain dom-propagator |

Gecode::Int::Dom::ReRange< View > | Reified range dom-propagator |

Gecode::Int::Element::IdxView< View > | Class for pair of index and view |

Gecode::Int::Element::IdxViewArray< View > | An array of IndexView pairs |

Gecode::Int::Element::Int< V0, V1, Idx, Val > | Element propagator for array of integers |

Gecode::Int::Element::Int< V0, V1, Idx, Val >::ByVal | Sorting pointers to (index,value) pairs in value order |

Gecode::Int::Element::Int< V0, V1, Idx, Val >::IdxVal | Linked index-value pairs |

Gecode::Int::Element::Int< V0, V1, Idx, Val >::IterIdxUnmark | Value iterator for indices in index-value map |

Gecode::Int::Element::Int< V0, V1, Idx, Val >::IterVal | Value iterator for values in index-value map |

Gecode::Int::Element::Int< V0, V1, Idx, Val >::IterValUnmark | Value iterator for values in index-value map |

Gecode::Int::Element::IterIdxView< View > | Value iterator for indices in index-view map |

Gecode::Int::Element::Pair | Domain consistent pair propagator |

Gecode::Int::Element::PairValues | Value iterator for pair of iterators |

Gecode::Int::Element::RelTestBnd< VA, VC > | Class for bounds-equality test |

Gecode::Int::Element::RelTestBnd< VA, ConstIntView > | Class for bounds-equality test (specialized) |

Gecode::Int::Element::RelTestDom< VA, VC > | Class for domain-equality test |

Gecode::Int::Element::RelTestDom< VA, ConstIntView > | Class for domain-equality test (specialized) |

Gecode::Int::Element::View< VA, VB, VC, pc_ac > | Base-class for element propagator for array of views |

Gecode::Int::Element::ViewBnd< VA, VB, VC > | Bounds consistent element propagator for array of views |

Gecode::Int::Element::ViewDom< VA, VB, VC > | Domain consistent element propagator for array of views |

Gecode::Int::Element::ViewToVarArg< View > | Class to get VarArg type for view |

Gecode::Int::Element::ViewToVarArg< BoolView > | VarArg type for Boolean views |

Gecode::Int::Element::ViewToVarArg< Gecode::Set::ConstSetView > | VarArg type for constant Set views |

Gecode::Int::Element::ViewToVarArg< Gecode::Set::SetView > | VarArg type for Set views |

Gecode::Int::Element::ViewToVarArg< Gecode::Set::SingletonView > | VarArg type for singleton views |

Gecode::Int::Element::ViewToVarArg< IntView > | VarArg type for integer views |

Gecode::Int::Exec::When | Conditional propagator |

Gecode::Int::Extensional::Base< View, subscribe > | Base for domain consistent extensional propagation |

Gecode::Int::Extensional::Basic< View, shared > | Domain consistent extensional propagator |

Gecode::Int::Extensional::GroupStates | GroupStates is used to index StateGroup by group |

Gecode::Int::Extensional::Incremental< View > | Domain consistent extensional propagator |

Gecode::Int::Extensional::Incremental< View >::SupportEntry | Entry for storing support |

Gecode::Int::Extensional::Incremental< View >::Work | Work stack |

Gecode::Int::Extensional::Incremental< View >::WorkEntry | Description of work to be done |

Gecode::Int::Extensional::LayeredGraph< View, Val, Degree, StateIdx > | Domain consistent layered graph (regular) propagator |

Gecode::Int::Extensional::LayeredGraph< View, Val, Degree, StateIdx >::Edge | Edge defined by in-state and out-state |

Gecode::Int::Extensional::LayeredGraph< View, Val, Degree, StateIdx >::Index | Advisors for views (by position in array) |

Gecode::Int::Extensional::LayeredGraph< View, Val, Degree, StateIdx >::IndexRange | Range approximation of which positions have changed |

Gecode::Int::Extensional::LayeredGraph< View, Val, Degree, StateIdx >::Layer | Layer for a view in the layered graph |

Gecode::Int::Extensional::LayeredGraph< View, Val, Degree, StateIdx >::LayerValues | Iterator for telling variable domains by scanning support |

Gecode::Int::Extensional::LayeredGraph< View, Val, Degree, StateIdx >::State | States are described by number of incoming and outgoing edges |

Gecode::Int::Extensional::LayeredGraph< View, Val, Degree, StateIdx >::Support | Support information for a value |

Gecode::Int::Extensional::StateGroup | Stategroup is used to compute a partition of states |

Gecode::Int::Extensional::StateGroupByGroup | Sort groups stated by group and then state |

Gecode::Int::Extensional::TransByI_State | Sort transition array by input state |

Gecode::Int::Extensional::TransByO_State | Sort transition array by output state |

Gecode::Int::Extensional::TransBySymbol | Sort transition array by symbol (value) |

Gecode::Int::Extensional::TransBySymbolI_State | Sort transition array by symbol and then input states |

Gecode::Int::Extensional::VarTraits< Var > | Traits class for variables |

Gecode::Int::Extensional::VarTraits< BoolVar > | Traits class for variables |

Gecode::Int::Extensional::VarTraits< IntVar > | Traits class for variables |

Gecode::Int::FwdToBwd< TaskView > | Task mapper: turns a task view into its dual |

Gecode::Int::GCC::Bnd< Card > | Bounds consistent global cardinality propagator |

Gecode::Int::GCC::CardConst | Constant view containing lower and upper cardinality bounds |

Gecode::Int::GCC::CardLess< Card > | Sort by increasing cardinality |

Gecode::Int::GCC::CardView | Cardinality integer view |

Gecode::Int::GCC::Dom< Card > | Domain consistent global cardinality propagator |

Gecode::Int::GCC::Edge | Class for edges in the variable-value-graph |

Gecode::Int::GCC::HallInfo | Container class provding information about the Hall structure of the problem variables |

Gecode::Int::GCC::MaxInc< View > | Compares two indices i, j of two views according to the ascending order of the views upper bounds |

Gecode::Int::GCC::MinIdx< Card > | Compares two cardinality views according to the index |

Gecode::Int::GCC::MinInc< View > | Compares two indices i, j of two views according to the ascending order of the views lower bounds |

Gecode::Int::GCC::Node | Base class for nodes in the variable-value-graph |

Gecode::Int::GCC::PartialSum< Card > | Partial sum structure for constant time computation of the maximal capacity of an interval |

Gecode::Int::GCC::Rank | Maps domain bounds to their position in hall[].bounds |

Gecode::Int::GCC::UnReachable | Class for computing unreachable values in the value GCC propagator |

Gecode::Int::GCC::Val< Card > | Value consistent global cardinality propagator |

Gecode::Int::GCC::ValNode | Value node |

Gecode::Int::GCC::VarNode | Variable node |

Gecode::Int::GCC::VarValGraph< Card > | Variable-value-graph used during propagation |

Gecode::Int::IllegalOperation | Exception: Illegal operation passed as argument |

Gecode::Int::IntDelta | Integer delta information for advisors |

Gecode::Int::IntVarImp | Integer variable implementation |

Gecode::Int::IntVarImp::RangeList | Lists of ranges (intervals) |

Gecode::Int::IntVarImpBase | Base-class for Int-variable implementations |

Gecode::Int::IntVarImpBwd | Backward iterator for ranges of integer variable implementations |

Gecode::Int::IntVarImpConf | Configuration for Int-variable implementations |

Gecode::Int::IntVarImpFwd | Range iterator for ranges of integer variable implementation |

Gecode::Int::IntView | Integer view for integer variables |

Gecode::Int::Linear::BoolNegTraits< BV > | Traits for Boolean negation view |

Gecode::Int::Linear::BoolNegTraits< BoolView > | Traits for Boolean negation view |

Gecode::Int::Linear::BoolNegTraits< NegBoolView > | Traits for Boolean negation view |

Gecode::Int::Linear::DomEq< Val, View > | Propagator for domain consistent n-ary linear equality |

Gecode::Int::Linear::EmptyScaleBoolArray | Empty array of scale Boolean views |

Gecode::Int::Linear::Eq< Val, P, N > | Propagator for bounds consistent n-ary linear equality |

Gecode::Int::Linear::EqBin< Val, A, B > | Propagator for bounds consistent binary linear equality |

Gecode::Int::Linear::EqBoolInt< VX > | Propagator for integer equal to Boolean sum (cardinality) |

Gecode::Int::Linear::EqBoolScale< SBAP, SBAN, VX > | Propagator for equality to Boolean sum with coefficients |

Gecode::Int::Linear::EqBoolView< XV, YV > | Propagator for equality to Boolean sum (cardinality) |

Gecode::Int::Linear::EqTer< Val, A, B, C > | Propagator for bounds consistent ternary linear equality |

Gecode::Int::Linear::GqBin< Val, A, B > | Propagator for bounds consistent binary linear greater or equal |

Gecode::Int::Linear::GqBoolInt< VX > | Propagator for integer less or equal to Boolean sum (cardinality) |

Gecode::Int::Linear::GqBoolView< XV, YV > | Propagator for greater or equal to Boolean sum (cardinality) |

Gecode::Int::Linear::Lin< Val, P, N, pc > | Base-class for n-ary linear propagators |

Gecode::Int::Linear::LinBin< Val, A, B, pc > | Base-class for binary linear propagators |

Gecode::Int::Linear::LinBoolInt< VX > | Baseclass for integer Boolean sum |

Gecode::Int::Linear::LinBoolScale< SBAP, SBAN, VX, pcx > | Base class for linear Boolean constraints with coefficients |

Gecode::Int::Linear::LinBoolView< XV, YV > | Base-class for Boolean linear propagators |

Gecode::Int::Linear::LinTer< Val, A, B, C, pc > | Base-class for ternary linear propagators |

Gecode::Int::Linear::Lq< Val, P, N > | Propagator for bounds consistent n-ary linear less or equal |

Gecode::Int::Linear::LqBin< Val, A, B > | Propagator for bounds consistent binary linear less or equal |

Gecode::Int::Linear::LqBoolScale< SBAP, SBAN, VX > | Propagator for inequality to Boolean sum with coefficients |

Gecode::Int::Linear::LqTer< Val, A, B, C > | Propagator for bounds consistent ternary linear less or equal |

Gecode::Int::Linear::NegSupportIter< Val > | Support-based iterator for negative view |

Gecode::Int::Linear::NoView | No view serves as filler for empty view arrays |

Gecode::Int::Linear::Nq< Val, P, N > | Propagator for bounds consistent n-ary linear disequality |

Gecode::Int::Linear::NqBin< Val, A, B > | Propagator for bounds consistent binary linear disequality |

Gecode::Int::Linear::NqBoolInt< VX > | Propagator for integer disequal to Boolean sum (cardinality) |

Gecode::Int::Linear::NqBoolScale< SBAP, SBAN, VX > | Propagator for disequality to Boolean sum with coefficients |

Gecode::Int::Linear::NqBoolView< XV, YV > | Propagator for disequality to Boolean sum (cardinality) |

Gecode::Int::Linear::NqTer< Val, A, B, C > | Propagator for bounds consistent ternary linear disquality |

Gecode::Int::Linear::PosSupportIter< Val > | Support-based iterator for positive view |

Gecode::Int::Linear::ReEq< Val, P, N, Ctrl > | Propagator for reified bounds consistent n-ary linear equality |

Gecode::Int::Linear::ReEqBin< Val, A, B, Ctrl > | Propagator for reified bounds consistent binary linear equality |

Gecode::Int::Linear::ReEqBoolInt< VX, VB > | Propagator for reified integer equal to Boolean sum (cardinality) |

Gecode::Int::Linear::ReGqBoolInt< VX, VB > | Propagator for reified integer less or equal to Boolean sum (cardinality) |

Gecode::Int::Linear::ReLin< Val, P, N, pc, Ctrl > | Base-class for reified n-ary linear propagators |

Gecode::Int::Linear::ReLinBin< Val, A, B, pc, Ctrl > | Base-class for reified binary linear propagators |

Gecode::Int::Linear::ReLinBoolInt< VX, VB > | Baseclass for reified integer Boolean sum |

Gecode::Int::Linear::ReLq< Val, P, N > | Propagator for reified bounds consistent n-ary linear less or equal |

Gecode::Int::Linear::ReLqBin< Val, A, B > | Propagator for reified bounds consistent binary linear less or equal |

Gecode::Int::Linear::ScaleBool | Coefficient and Boolean view |

Gecode::Int::Linear::ScaleBoolArray | Array of scale Boolean views |

Gecode::Int::Linear::SupportIter< Val > | Base-class for support-based iterator |

Gecode::Int::Linear::SupportSet | Set for support information |

Gecode::Int::Linear::Term< View > | Class for describing linear term |

Gecode::Int::Linear::TermLess< View > | Sort linear terms by view |

Gecode::Int::ManTaskViewIter< OptTaskView, sto, inc > | Allows to iterate over mandatory task views according to a specified order |

Gecode::Int::ManToOptTask< ManTask > | Class to define an optional from a mandatory task |

Gecode::Int::Member::Prop< View > | Membership propagator |

Gecode::Int::Member::ReProp< View > | Reified membership propagator |

Gecode::Int::MinusView | Minus integer view |

Gecode::Int::NegBoolView | Negated Boolean view |

Gecode::Int::NoOffset< View > | Converter without offsets |

Gecode::Int::NoOverlap::Base< Box > | Base class for no-overlap propagator |

Gecode::Int::NoOverlap::FixDim | Dimension combining coordinate and integer size information |

Gecode::Int::NoOverlap::FlexDim | Dimension combining coordinate and integer view size information |

Gecode::Int::NoOverlap::ManBox< Dim, n > | Mandatory box class |

Gecode::Int::NoOverlap::ManProp< Dim, d > | No-overlap propagator for mandatory boxes |

Gecode::Int::NoOverlap::OptBox< Dim, n > | Optional box class |

Gecode::Int::NoOverlap::OptProp< Dim, d > | No-overlap propagator for optional boxes |

Gecode::Int::NotYetFinalized | Exception: Tuple set not yet finalized |

Gecode::Int::NotZeroOne | Exception: Not 0/1 integer |

Gecode::Int::NValues::BoolBase< VY > | Number of values propagator for Boolean views base class |

Gecode::Int::NValues::EqBool< VY > | Equal to number of values propagator for Boolean views |

Gecode::Int::NValues::EqInt< VY > | Equal to number of values propagator for integer views |

Gecode::Int::NValues::GqBool< VY > | Greater or equal to number of values propagator for Boolean views |

Gecode::Int::NValues::GqInt< VY > | Greater or equal to number of values propagator for integer views |

Gecode::Int::NValues::Graph | View-value graph for propagation of upper bound |

Gecode::Int::NValues::IntBase< VY > | Number of values propagator for integer views base class |

Gecode::Int::NValues::LqBool< VY > | Less or equal to number of values propagator for Boolean views |

Gecode::Int::NValues::LqInt< VY > | Less or equal to number of values propagator for integer views |

Gecode::Int::NValues::RangeEvent | Event for range-based overlap analysis |

Gecode::Int::NValues::SymBitMatrix | Symmetric diagonal bit matrix |

Gecode::Int::Offset | Converter with fixed offset |

Gecode::Int::OffsetView | Offset integer view |

Gecode::Int::OutOfLimits | Exception: Value out of limits |

Gecode::Int::Precede::Single< View > | Single value precedence propagator |

Gecode::Int::Precede::Single< View >::Index | Advisors for views (by position in array) |

Gecode::Int::ReBinaryPropagator< View, pc, CtrlView > | Reified binary propagator |

Gecode::Int::Rel::EqBnd< View0, View1 > | Binary bounds consistent equality propagator |

Gecode::Int::Rel::EqDom< View0, View1 > | Binary domain consistent equality propagator |

Gecode::Int::Rel::Le< View > | Less propagator |

Gecode::Int::Rel::LexLqLe< View > | Lexical ordering propagator |

Gecode::Int::Rel::LexNq< View > | Lexical disequality propagator |

Gecode::Int::Rel::Lq< View > | Less or equal propagator |

Gecode::Int::Rel::NaryEqBnd< View > | N-ary bounds consistent equality propagator |

Gecode::Int::Rel::NaryEqDom< View > | N-ary domain consistent equality propagator |

Gecode::Int::Rel::NaryLqLe< View, o > | N-ary less and less or equal propagator |

Gecode::Int::Rel::NaryLqLe< View, o >::Index | Advisors for views (by position in array) |

Gecode::Int::Rel::NaryLqLe< View, o >::Pos | Positions in view array that have to be propagated |

Gecode::Int::Rel::NaryNq< View > | Nary disequality propagator |

Gecode::Int::Rel::Nq< View > | Binary disequality propagator |

Gecode::Int::Rel::ReEqBnd< View, CtrlView > | Reified binary bounds consistent equality propagator |

Gecode::Int::Rel::ReEqBndInt< View, CtrlView > | Reified bounds consistent equality with integer propagator |

Gecode::Int::Rel::ReEqDom< View, CtrlView > | Reified binary domain consistent equality propagator |

Gecode::Int::Rel::ReEqDomInt< View, CtrlView > | Reified domain consistent equality with integer propagator |

Gecode::Int::Rel::ReLq< View, CtrlView > | Reified less or equal propagator |

Gecode::Int::Rel::ReLqInt< View, CtrlView > | Reified less or equal with integer propagator |

Gecode::Int::ReMixBinaryPropagator< View0, pc0, View1, pc1, CtrlView > | Reified mixed binary propagator |

Gecode::Int::ReUnaryPropagator< View, pc, CtrlView > | Reified unary propagator |

Gecode::Int::ScaleView< Val, UnsVal > | Scale integer view (template) |

Gecode::Int::Sequence::Sequence< View, Val > | Sequence propagator for array of integers |

Gecode::Int::Sequence::SupportAdvisor< View > | Class for advising the propagator |

Gecode::Int::Sequence::ViewValSupport< View, Val, iss > | Class for view value support structure |

Gecode::Int::Sequence::ViewValSupportArray< View, Val, iss > | An array of ViewValSupport data structures |

Gecode::Int::Sequence::Violations | Simple bitsets for recording violations |

Gecode::Int::Sorted::OfflineMin | Offline-Min datastructure Used to compute the perfect matching between the unsorted views x and the sorted views y |

Gecode::Int::Sorted::OfflineMinItem | Item used to construct the OfflineMin sequence |

Gecode::Int::Sorted::Rank | Storage class for mininmum and maximum of a variable |

Gecode::Int::Sorted::SccComponent | Representation of a strongly connected component |

Gecode::Int::Sorted::Sorted< View, Perm > | Bounds consistent sortedness propagator |

Gecode::Int::Sorted::TupleMaxInc< View > | Index comparison for ViewArray<Tuple> |

Gecode::Int::Sorted::TupleMaxIncExt< View > | Extended Index comparison for ViewArray<Tuple> |

Gecode::Int::Sorted::TupleMinInc< View > | View comparison on ViewTuples |

Gecode::Int::Sorted::TupleMinIncExt< View > | Extended view comparison on pairs of views |

Gecode::Int::Sorted::ViewPair< View > | Pair of views |

Gecode::Int::SortMap< TaskView, STO, inc > | Sorting maps rather than tasks |

Gecode::Int::StoEct< TaskView, inc > | Sort by earliest completion times |

Gecode::Int::StoEst< TaskView, inc > | Sort by earliest start times |

Gecode::Int::StoLct< TaskView, inc > | Sort by latest completion times |

Gecode::Int::StoLst< TaskView, inc > | Sort by latest start times |

Gecode::Int::SupportValues< View, A > | Support value iterator and recorder |

Gecode::Int::TaskArray< Task > | Task array |

Gecode::Int::TaskProp< Task, pc > | Propagator for tasks |

Gecode::Int::TaskTraits< Task > | Traits class for mapping tasks to task views |

Gecode::Int::TaskTraits< Cumulative::ManFixPSETask > | Task traits for mandatory fixed tasks |

Gecode::Int::TaskTraits< Cumulative::ManFixPTask > | Task traits for mandatory fixed tasks |

Gecode::Int::TaskTraits< Cumulative::ManFlexTask > | Task traits for mandatory flexible tasks |

Gecode::Int::TaskTraits< Cumulative::OptFixPSETask > | Task traits for optional fixed tasks |

Gecode::Int::TaskTraits< Cumulative::OptFixPTask > | Task traits for optional fixed tasks |

Gecode::Int::TaskTraits< Cumulative::OptFlexTask > | Task traits for optional flexible tasks |

Gecode::Int::TaskTraits< Unary::ManFixPSETask > | Task traits for mandatory fixed tasks |

Gecode::Int::TaskTraits< Unary::ManFixPTask > | Task traits for mandatory fixed tasks |

Gecode::Int::TaskTraits< Unary::ManFlexTask > | Task traits for mandatory flexible tasks |

Gecode::Int::TaskTraits< Unary::OptFixPSETask > | Task traits for optional fixed tasks |

Gecode::Int::TaskTraits< Unary::OptFixPTask > | Task traits for optional fixed tasks |

Gecode::Int::TaskTraits< Unary::OptFlexTask > | Task traits for optional flexible tasks |

Gecode::Int::TaskTree< TaskView, Node > | Task trees for task views with node type Node |

Gecode::Int::TaskViewArray< TaskView > | Task view array |

Gecode::Int::TaskViewIter< TaskView, sto, inc > | Allows to iterate over task views according to a specified order |

Gecode::Int::TaskViewTraits< TaskView > | Traits class for mapping task views to tasks |

Gecode::Int::TaskViewTraits< Cumulative::ManFixPSETaskBwd > | Task view traits for backward task views |

Gecode::Int::TaskViewTraits< Cumulative::ManFixPSETaskFwd > | Task view traits for forward task views |

Gecode::Int::TaskViewTraits< Cumulative::ManFixPTaskBwd > | Task view traits for backward task views |

Gecode::Int::TaskViewTraits< Cumulative::ManFixPTaskFwd > | Task view traits for forward task views |

Gecode::Int::TaskViewTraits< Cumulative::ManFlexTaskBwd > | Task view traits for backward task views |

Gecode::Int::TaskViewTraits< Cumulative::ManFlexTaskFwd > | Task view traits for forward task views |

Gecode::Int::TaskViewTraits< Cumulative::OptFixPSETaskBwd > | Task view traits for backward task views |

Gecode::Int::TaskViewTraits< Cumulative::OptFixPSETaskFwd > | Task view traits for forward optional task views |

Gecode::Int::TaskViewTraits< Cumulative::OptFixPTaskBwd > | Task view traits for backward task views |

Gecode::Int::TaskViewTraits< Cumulative::OptFixPTaskFwd > | Task view traits for forward optional task views |

Gecode::Int::TaskViewTraits< Cumulative::OptFlexTaskBwd > | Task view traits for backward task views |

Gecode::Int::TaskViewTraits< Cumulative::OptFlexTaskFwd > | Task view traits for forward optional task views |

Gecode::Int::TaskViewTraits< Unary::ManFixPSETaskBwd > | Task view traits for backward task views |

Gecode::Int::TaskViewTraits< Unary::ManFixPSETaskFwd > | Task view traits for forward task views |

Gecode::Int::TaskViewTraits< Unary::ManFixPTaskBwd > | Task view traits for backward task views |

Gecode::Int::TaskViewTraits< Unary::ManFixPTaskFwd > | Task view traits for forward task views |

Gecode::Int::TaskViewTraits< Unary::ManFlexTaskBwd > | Task view traits for backward task views |

Gecode::Int::TaskViewTraits< Unary::ManFlexTaskFwd > | Task view traits for forward task views |

Gecode::Int::TaskViewTraits< Unary::OptFixPSETaskBwd > | Task view traits for backward task views |

Gecode::Int::TaskViewTraits< Unary::OptFixPSETaskFwd > | Task view traits for forward optional task views |

Gecode::Int::TaskViewTraits< Unary::OptFixPTaskBwd > | Task view traits for backward task views |

Gecode::Int::TaskViewTraits< Unary::OptFixPTaskFwd > | Task view traits for forward optional task views |

Gecode::Int::TaskViewTraits< Unary::OptFlexTaskBwd > | Task view traits for backward task views |

Gecode::Int::TaskViewTraits< Unary::OptFlexTaskFwd > | Task view traits for forward optional task views |

Gecode::Int::TooFewArguments | Exception: Too few arguments available in argument array |

Gecode::Int::Unary::ManFixPSETask | Unary (mandatory) task with fixed processing, start or end time |

Gecode::Int::Unary::ManFixPTask | Unary (mandatory) task with fixed processing time |

Gecode::Int::Unary::ManFlexTask | Unary (mandatory) task with flexible processing time |

Gecode::Int::Unary::ManProp< ManTask > | Scheduling propagator for unary resource with mandatory tasks |

Gecode::Int::Unary::OmegaLambdaNode | Node for an omega lambda tree |

Gecode::Int::Unary::OmegaLambdaTree< TaskView > | Omega-lambda trees for computing ect of task sets |

Gecode::Int::Unary::OmegaNode | Node for an omega tree |

Gecode::Int::Unary::OmegaTree< TaskView > | Omega trees for computing ect of task sets |

Gecode::Int::Unary::OptFixPSETask | Unary optional task with fixed processing, start or end time |

Gecode::Int::Unary::OptFixPTask | Unary optional task with fixed processing time |

Gecode::Int::Unary::OptFlexTask | Unary optional task with flexible processing time |

Gecode::Int::Unary::OptProp< OptTask > | Scheduling propagator for unary resource with optional tasks |

Gecode::Int::UnknownBranching | Exception: Unknown value or variable selection passed as argument |

Gecode::Int::UnknownOperation | Exception: Unknown operation passed as argument |

Gecode::Int::UnknownRelation | Exception: Unknown relation passed as argument |

Gecode::Int::Unshare::VarPtrLess< Var > | Sort order for variables |

Gecode::Int::ValOfUnassignedVar | Exception: Attempt to access value of unassigned variable |

Gecode::Int::ValSet | Class for storing values of already assigned views |

Gecode::Int::ValSet::Ranges | Iterator over ranges |

Gecode::Int::VariableEmptyDomain | Exception: Variable created with empty domain |

Gecode::Int::ViewDiffRanges< View > | Range iterator for cached integer views |

Gecode::Int::ViewRanges< View > | Range iterator for integer views |

Gecode::Int::ViewRanges< BoolView > | Range iterator for Boolean variable views |

Gecode::Int::ViewRanges< CachedView< View > > | Range iterator for offset integer views |

Gecode::Int::ViewRanges< ConstIntView > | Range iterator for constant integer views |

Gecode::Int::ViewRanges< DoubleScaleView > | Range iterator for double-precision scale integer views |

Gecode::Int::ViewRanges< GCC::CardView > | Range iterator for indexed problem variables |

Gecode::Int::ViewRanges< IntScaleView > | Range iterator for integer-precision scale integer views |

Gecode::Int::ViewRanges< IntView > | Range iterator for integer variable views |

Gecode::Int::ViewRanges< MinusView > | Range iterator for minus integer views |

Gecode::Int::ViewRanges< NegBoolView > | Range iterator for negated Boolean variable views |

Gecode::Int::ViewRanges< OffsetView > | Range iterator for offset integer views |

Gecode::Int::ViewRanges< ZeroIntView > | Range iterator for constant integer views |

Gecode::Int::ViewValGraph::BiLink | Bidirectional links for edges and anchors in nodes of view-value graph |

Gecode::Int::ViewValGraph::CombPtrFlag< T > | Class for combining two pointers with a flag |

Gecode::Int::ViewValGraph::Edge< View > | Edges in view-value graph |

Gecode::Int::ViewValGraph::Graph< View > | View-value graph base class |

Gecode::Int::ViewValGraph::IterPruneVal< View > | Iterates the values to be pruned from a view node |

Gecode::Int::ViewValGraph::Node< View > | Base-class for nodes (both view and value nodes) |

Gecode::Int::ViewValGraph::ValNode< View > | Value nodes in view-value graph |

Gecode::Int::ViewValGraph::ViewNode< View > | View nodes in view-value graph |

Gecode::Int::ViewValues< View > | Value iterator for integer views |

Gecode::Int::ZeroIntView | Zero integer view |

Gecode::IntArgs | Passing integer arguments |

Gecode::IntSet | Integer sets |

Gecode::IntSet::MinInc | Sort ranges according to increasing minimum |

Gecode::IntSetInit< I > | Integer set initialization |

Gecode::IntSetInit< IntArgs > | |

Gecode::IntSetInit< IntSet > | |

Gecode::IntSetRanges | Range iterator for integer sets |

Gecode::IntSetValues | Value iterator for integer sets |

Gecode::IntVar | Integer variables |

Gecode::IntVarArgs | Passing integer variables |

Gecode::IntVarArray | Integer variable array |

Gecode::IntVarRanges | Range iterator for integer variables |

Gecode::IntVarValues | Value iterator for integer variables |

Gecode::Iter::Ranges::AddRange< I > | Range iterator for adding a single range to a range iterator |

Gecode::Iter::Ranges::Append< I, J > | Range iterator for appending two range iterators |

Gecode::Iter::Ranges::Array | Range iterator for array of ranges |

Gecode::Iter::Ranges::Array::Range | Ranges for array |

Gecode::Iter::Ranges::Cache | Range iterator cache |

Gecode::Iter::Ranges::Compl< UMIN, UMAX, I > | Range iterator for computing the complement (described by template arguments) |

Gecode::Iter::Ranges::ComplVal< I > | Range iterator for computing the complement (described by values) |

Gecode::Iter::Ranges::Diff< I, J > | Range iterator for computing set difference |

Gecode::Iter::Ranges::Empty | Range iterator for empty range |

Gecode::Iter::Ranges::Inter< I, J > | Range iterator for computing intersection (binary) |

Gecode::Iter::Ranges::Map< I, M, strict > | Range iterator for mapping ranges |

Gecode::Iter::Ranges::Map< I, M, false > | Specialized mapping of ranges for non-strict maps |

Gecode::Iter::Ranges::Map< I, M, true > | Specialized mapping of ranges for strict maps |

Gecode::Iter::Ranges::MinMax | Base for range iterators with explicit min and max |

Gecode::Iter::Ranges::Minus | Range iterator for pointwise minus of a range iterator |

Gecode::Iter::Ranges::NaryAppend< I > | Range iterator for appending arbitrarily many iterators |

Gecode::Iter::Ranges::NaryInter | Range iterator for intersection of iterators |

Gecode::Iter::Ranges::NaryUnion | Range iterator for union of iterators |

Gecode::Iter::Ranges::Negative< I, strict > | Range iterator for negative part of a range iterator |

Gecode::Iter::Ranges::Offset< I > | Range iterator for pointwise offset (by some constant) |

Gecode::Iter::Ranges::Positive< I, strict > | Range iterator for positive part of a range iterator |

Gecode::Iter::Ranges::RangeList | Range iterator for range lists |

Gecode::Iter::Ranges::RangeListIter | Iterator over range lists |

Gecode::Iter::Ranges::RangeListIter::RangeList | Range list class |

Gecode::Iter::Ranges::RangeListIter::RLIO | Shared object for allocation |

Gecode::Iter::Ranges::ScaleDown< I > | Range iterator for pointwise division by a positive integer |

Gecode::Iter::Ranges::ScaleUp< Val, UnsVal, I > | Range iterator for pointwise product with a positive integer |

Gecode::Iter::Ranges::Singleton | Range iterator for singleton range |

Gecode::Iter::Ranges::SingletonAppend< J > | Range iterator for appending a singleton with a range iterator |

Gecode::Iter::Ranges::Size< I > | Range iterator with size counting |

Gecode::Iter::Ranges::SubRange< I > | Range iterator for subtracting a single range from a range iterator |

Gecode::Iter::Ranges::ToValues< I > | Value iterator from range iterator |

Gecode::Iter::Ranges::Union< I, J > | Range iterator for computing union (binary) |

Gecode::Iter::Values::Array | Value iterator for array of integers |

Gecode::Iter::Values::BitSet< BS > | Value iterator for values in a bitset |

Gecode::Iter::Values::Inter< I, J > | Value iterator for the intersection of two value iterators |

Gecode::Iter::Values::Map< I, M, strict > | Value iterator for mapping values of a value iterator |

Gecode::Iter::Values::Minus | Value iterator for pointwise minus of a value iterator |

Gecode::Iter::Values::Negative< I, strict > | Value iterator for selecting only negative values |

Gecode::Iter::Values::Offset< I > | Value iterator for pointwise offset (by some constant) |

Gecode::Iter::Values::Positive< I, strict > | Value iterator for selecting only positive values |

Gecode::Iter::Values::Singleton | Value iterator for single value |

Gecode::Iter::Values::ToRanges< I > | Range iterator from value iterator |

Gecode::Iter::Values::Union< I, J > | Value iterator for the union of two value iterators |

Gecode::Iter::Values::Unique< I > | Remove duplicate values from from value iterator |

Gecode::Iter::Values::ValueListIter | Iterator over value lists |

Gecode::Iter::Values::ValueListIter::ValueList | Value list class |

Gecode::Iter::Values::ValueListIter::VLIO | Shared object for allocation |

Gecode::Kernel::NaryWait< View > | Wait propagator for several views |

Gecode::Kernel::UnaryWait< View > | Wait propagator for single view |

Gecode::LinExpr | Linear expressions |

Gecode::LinRel | Linear relations |

Gecode::LocalHandle | Handles for local (space-shared) objects |

Gecode::LocalObject | Local (space-shared) object |

Gecode::Matrix< A > | Matrix-interface for arrays |

Gecode::MemoryChunk | Memory chunk with size information |

Gecode::MemoryExhausted | Exception: Memory exhausted |

Gecode::MemoryManager | Manage memory for space |

Gecode::MiniModel::ArgumentOutOfRange | Exception: Argument out of range |

Gecode::MiniModel::ArgumentSizeMismatch | Exception: Sizes of arguments does not match |

Gecode::MiniModel::ArithNonLinExpr | Non-linear arithmetic expressions |

Gecode::MiniModel::ExpInfo | Expression information |

Gecode::MiniModel::FinalBag | For collecting final states while constructing a DFA |

Gecode::MiniModel::NodeInfo | Node information computed during traversal of the expressions |

Gecode::MiniModel::OptimizeSpace< irt > | Baseclass for cost-based optimization |

Gecode::MiniModel::PosInfo | Information on positions collected during traversal |

Gecode::MiniModel::PosSet | Sets of positions |

Gecode::MiniModel::SetNonLinExpr | Integer valued set expressions |

Gecode::MiniModel::StateNode | Node together with state information |

Gecode::MiniModel::StatePool | State pool combines a tree of states together with yet unprocessed states |

Gecode::MiniModel::SymbolsInc | Sort symbols |

Gecode::MiniModel::TooFewArguments | Exception: Too few arguments available in argument array |

Gecode::MiniModel::TransitionBag | For collecting transitions while constructing a DFA |

Gecode::MixBinaryPropagator< View0, pc0, View1, pc1 > | Mixed binary propagator |

Gecode::MixNaryOnePropagator< View0, pc0, View1, pc1 > | Mixed (n+1)-ary propagator |

Gecode::MixTernaryPropagator< View0, pc0, View1, pc1, View2, pc2 > | Mixed ternary propagator |

Gecode::NaryOnePropagator< View, pc > | (n+1)-ary propagator |

Gecode::NaryPropagator< View, pc > | N-ary propagator |

Gecode::NoIdxVarImpConf | Configuration class for variable implementations without index structure |

Gecode::NonLinExpr | Base class for non-linear expressions |

Gecode::OperatingSystemError | Exception: operating system error |

Gecode::Options | Options for scripts |

Gecode::Pos | Position information |

Gecode::PosChoice< ViewSel > | Choices storing position |

Gecode::PosValChoice< ViewSel, ValSel > | Choice storing position and value |

Gecode::PrimArgArray< T > | Argument array for primtive types |

Gecode::Propagator | Base-class for propagators |

Gecode::PropCost | Propagation cost |

Gecode::PropInfo | Class for propagator information |

Gecode::RangeList | Lists of ranges (intervals) |

Gecode::REG | Regular expressions over integer values |

Gecode::REG::Exp | Implementation of the actual expression tree |

Gecode::Region | Handle to region |

Gecode::region_allocator< T > | Allocator that allocates memory from a region |

Gecode::region_allocator< T >::rebind< U > | Rebinding helper (returns the type of a similar allocator for type U) |

Gecode::region_allocator< void > | Region allocator - specialization for `void` |

Gecode::region_allocator< void >::rebind< U > | Rebinding helper (returns the type of a similar allocator for type U) |

Gecode::Restart< T > | Depth-first restart best solution search engine |

Gecode::Search::Engine | Search engine interface |

Gecode::Search::FailStop | Stop-object based on number of failures |

Gecode::Search::MemoryStop | Stop-object based on memory consumption |

Gecode::Search::NodeStop | Stop-object based on number of nodes |

Gecode::Search::Options | Search engine options |

Gecode::Search::Parallel::BAB | Parallel branch-and-bound engine |

Gecode::Search::Parallel::BAB::Worker | Parallel branch-and-bound search worker |

Gecode::Search::Parallel::DFS | Parallel depth-first search engine |

Gecode::Search::Parallel::DFS::Worker | Parallel depth-first search worker |

Gecode::Search::Parallel::Engine | Parallel depth-first search engine |

Gecode::Search::Parallel::Engine::Worker | Parallel depth-first search worker |

Gecode::Search::Parallel::Path | Depth-first path (stack of edges) supporting recomputation |

Gecode::Search::Parallel::Path::Edge | Search tree edge for recomputation |

Gecode::Search::Parallel::Restart | Depth-first restart best solution search engine implementation |

Gecode::Search::Sequential::BAB | Implementation of depth-first branch-and-bound search engine |

Gecode::Search::Sequential::DFS | Depth-first search engine implementation |

Gecode::Search::Sequential::Path | Depth-first path (stack of edges) supporting recomputation |

Gecode::Search::Sequential::Path::Edge | Search tree edge for recomputation |

Gecode::Search::Sequential::Restart | Depth-first restart best solution search engine implementation |

Gecode::Search::Statistics | Search engine statistics |

Gecode::Search::Stop | Base-class for Stop-object |

Gecode::Search::TimeStop | Stop-object based on time |

Gecode::Search::Worker | Search worker control including memory information |

Gecode::Search::WorkerToEngine< Worker > | Virtualize a worker to an engine |

Gecode::Set::ArgumentSizeMismatch | Exception: Arguments are of different size |

Gecode::Set::ArrayRanges | Range iterator for a two-dimensional array |

Gecode::Set::BndSet | Sets of integers |

Gecode::Set::BndSetRanges | Range iterator for integer sets |

Gecode::Set::Branch::AssignValMax< inc > | Class for assigning maximum value |

Gecode::Set::Branch::AssignValMed< inc > | Class for assigning median value (rounding downwards) |

Gecode::Set::Branch::AssignValMin< inc > | Class for assigning minimum value |

Gecode::Set::Branch::AssignValRnd< inc > | Class for assigning random value |

Gecode::Set::Branch::ByMaxMax | View selection class for view with largest maximal element in lub-glb |

Gecode::Set::Branch::ByMaxMin | View selection class for view with smallest maximal element in lub-glb |

Gecode::Set::Branch::ByMinMax | View selection class for view with largest minimum element in lub-glb |

Gecode::Set::Branch::ByMinMin | View selection class for view with smallest minimum element in lub-glb |

Gecode::Set::Branch::BySizeAfcMax | View selection class for view with largest cardinality of lub-glb divided by accumulated failure count |

Gecode::Set::Branch::BySizeAfcMin | View selection class for view with smallest cardinality of lub-glb divided by accumulated failure count |

Gecode::Set::Branch::BySizeDegreeMax | View selection class for view with largest cardinality of lub-glb divided by degree |

Gecode::Set::Branch::BySizeDegreeMin | View selection class for view with smallest cardinality of lub-glb divided by degree |

Gecode::Set::Branch::BySizeMax | View selection class for view with largest cardinality of lub-glb |

Gecode::Set::Branch::BySizeMin | View selection class for view with smallest cardinality of lub-glb |

Gecode::Set::Branch::ValMax< inc > | Class for selecting maximum value |

Gecode::Set::Branch::ValMed< inc > | Class for selecting median value (rounding downwards) |

Gecode::Set::Branch::ValMin< inc > | Class for selecting minimum value |

Gecode::Set::Branch::ValRnd< inc > | Class for random value selection |

Gecode::Set::CachedView< View > | Cached set view |

Gecode::Set::ComplementView< View > | Complement set view |

Gecode::Set::ConstSetView | Constant view |

Gecode::Set::Convex::Convex | Propagator for the convex constraint |

Gecode::Set::Convex::ConvexHull | Propagator for the convex hull constraint |

Gecode::Set::Distinct::AtmostOne | Propagator for the AtMostOneIntersection constraint |

Gecode::Set::Element::ElementDisjoint< SView, RView > | Propagator for element with disjointness |

Gecode::Set::Element::ElementIntersection< View, View0, View1 > | Propagator for element with intersection |

Gecode::Set::Element::ElementUnion< View, View0, View1 > | Propagator for element with union |

Gecode::Set::Element::ElementUnionConst< SView, RView > | Propagator for element with union of constant sets |

Gecode::Set::EmptyView | Constant view for the empty set |

Gecode::Set::GlbDiffRanges< View > | Range iterator for difference of greatest lower bound and cache |

Gecode::Set::GLBndSet | Growing sets of integers |

Gecode::Set::GlbRanges< T > | Range iterator for the greatest lower bound |

Gecode::Set::GlbRanges< CachedView< View > > | Range iterator for greatest lower bound of cached set views |

Gecode::Set::GlbRanges< ComplementView< ComplementView< View > > > | Range iterator for the greatest lower bound of double-complement-views |

Gecode::Set::GlbRanges< ComplementView< View > > | Range iterator for greatest lower bound of complement set views |

Gecode::Set::GlbRanges< ConstSetView > | Range iterator for greatest lower bound of constant set view |

Gecode::Set::GlbRanges< EmptyView > | Range iterator for greatest lower bound of constantly empty set view |

Gecode::Set::GlbRanges< SetVarImp * > | Range iterator for the greatest lower bound of a set variable implementation |

Gecode::Set::GlbRanges< SetView > | Range iterator for greatest lower bound of set variable views |

Gecode::Set::GlbRanges< SingletonView > | Range iterator for greatest lower bound of singleton set view |

Gecode::Set::GlbRanges< UniverseView > | Range iterator for greatest lower bound of constant universe set view |

Gecode::Set::IllegalOperation | Exception: Illegal operation passed as argument |

Gecode::Set::Int::Card< View > | Propagator for cardinality |

Gecode::Set::Int::ChannelBool< View > | Propagator for channelling between set variable and its characteristic function |

Gecode::Set::Int::ChannelBool< View >::IndexAdvisor | Advisor storing a single index |

Gecode::Set::Int::ChannelInt< View > | Propagator for channelling between variable-value-dual models |

Gecode::Set::Int::IntLess | Sort order for integers |

Gecode::Set::Int::Match< View > | Propagator for the match constraint |

Gecode::Set::Int::MaxElement< View > | Propagator for maximum element |

Gecode::Set::Int::MinElement< View > | Propagator for minimum element |

Gecode::Set::Int::NotMaxElement< View > | Propagator for not maximum element |

Gecode::Set::Int::NotMinElement< View > | Propagator for not minimum element |

Gecode::Set::Int::OverweightValues< I > | Value Iterator for values above a certain weight |

Gecode::Set::Int::ReMaxElement< View > | Reified propagator for maximum element |

Gecode::Set::Int::ReMinElement< View > | Propagator for reified minimum element |

Gecode::Set::Int::Weights< View > | Propagator for weight of a set |

Gecode::Set::LubDiffRanges< View > | Range iterator for difference of least upper bound and cache |

Gecode::Set::LUBndSet | Shrinking sets of integers |

Gecode::Set::LubRanges< T > | Range iterator for the least upper bound |

Gecode::Set::LubRanges< CachedView< View > > | Range iterator for least upper bound of cached set views |

Gecode::Set::LubRanges< ComplementView< ComplementView< View > > > | Range iterator for the least upper bound of double-complement-views |

Gecode::Set::LubRanges< ComplementView< View > > | Range iterator for least upper bound of complement set views |

Gecode::Set::LubRanges< ConstSetView > | Range iterator for least upper bound of constant set view |

Gecode::Set::LubRanges< EmptyView > | Range iterator for least upper bound of constantly empty set view |

Gecode::Set::LubRanges< SetVarImp * > | Range iterator for the least upper bound of a set variable implementation |

Gecode::Set::LubRanges< SetView > | Range iterator for least upper bound of set variable views |

Gecode::Set::LubRanges< SingletonView > | Range iterator for least upper bound of singleton set view |

Gecode::Set::LubRanges< UniverseView > | Range iterator for least upper bound of constant universe set view |

Gecode::Set::OutOfLimits | Exception: Value out of limits |

Gecode::Set::Precede::Single< View > | Single value precedence propagator |

Gecode::Set::Precede::Single< View >::Index | Advisors for views (by position in array) |

Gecode::Set::RangesCompl< I > | A complement iterator spezialized for the BndSet limits |

Gecode::Set::Rel::CharacteristicSets | Representation of the characteristic functions of two sets |

Gecode::Set::Rel::CharacteristicSets::CSIter | Value iterator for characteristic function |

Gecode::Set::Rel::Distinct< View0, View1 > | Propagator for negated equality |

Gecode::Set::Rel::DistinctDoit< View0 > | Propagator for negated equality |

Gecode::Set::Rel::Eq< View0, View1 > | Propagator for set equality |

Gecode::Set::Rel::Lq< View0, View1, strict > | Propagator for set less than or equal |

Gecode::Set::Rel::NoSubset< View0, View1 > | Propagator for the negated subset constraint |

Gecode::Set::Rel::ReEq< View0, View1 > | Reified equality propagator |

Gecode::Set::Rel::ReLq< View0, View1, strict > | Reified propagator for set less than or equal |

Gecode::Set::Rel::ReSubset< View0, View1 > | Reified subset propagator |

Gecode::Set::Rel::Subset< View0, View1 > | Propagator for the subset constraint |

Gecode::Set::RelOp::Intersection< View0, View1, View2 > | Propagator for ternary intersection |

Gecode::Set::RelOp::IntersectionN< View0, View1 > | Propagator for nary intersection |

Gecode::Set::RelOp::PartitionN< View0, View1 > | Propagator for nary partition |

Gecode::Set::RelOp::SubOfUnion< View0, View1, View2 > | Propagator for the subset of union |

Gecode::Set::RelOp::SuperOfInter< View0, View1, View2 > | Propagator for the superset of intersection |

Gecode::Set::RelOp::Union< View0, View1, View2 > | Propagator for ternary union |

Gecode::Set::RelOp::UnionN< View0, View1 > | Propagator for nary union |

Gecode::Set::Sequence::Seq | Propagator for the sequence constraint |

Gecode::Set::Sequence::SeqU | Propagator for the sequenced union constraint |

Gecode::Set::SetDelta | Finite set delta information for advisors |

Gecode::Set::SetVarImp | Finite integer set variable implementation |

Gecode::Set::SetVarImpBase | Base-class for Set-variable implementations |

Gecode::Set::SetVarImpConf | Configuration for Set-variable implementations |

Gecode::Set::SetView | Set view for set variables |

Gecode::Set::SingletonView | Singleton set view |

Gecode::Set::TooFewArguments | Exception: No arguments available in argument array |

Gecode::Set::UniverseView | Constant view for the universe |

Gecode::Set::UnknownBranching | Exception: Unknown value or variable selection passed as argument |

Gecode::Set::UnknownOperation | Exception: Unknown operation type passed as argument |

Gecode::Set::UnknownRanges< T > | Range iterator for the unknown set |

Gecode::Set::UnknownRelation | Exception: Unknown relation type passed as argument |

Gecode::Set::VariableEmptyDomain | Exception: Variable created with empty domain |

Gecode::SetCmpRel | Comparison relation (for two-sided comparisons) |

Gecode::SetExpr | Set expressions |

Gecode::SetExpr::NNF | Node for negation normalform (NNF) |

Gecode::SetExpr::Node | Node for set expression |

Gecode::SetRel | Set relations |

Gecode::SetVar | Set variables |

Gecode::SetVarArgs | Passing set variables |

Gecode::SetVarArray | Set variable array |

Gecode::SetVarGlbRanges | Iterator for the greatest lower bound ranges of a set variable |

Gecode::SetVarGlbValues | Iterator for the values in the greatest lower bound of a set variable |

Gecode::SetVarLubRanges | Iterator for the least upper bound ranges of a set variable |

Gecode::SetVarLubValues | Iterator for the values in the least upper bound of a set variable |

Gecode::SetVarUnknownRanges | Iterator for the unknown ranges of a set variable |

Gecode::SetVarUnknownValues | Iterator for the values in the unknown set of a set variable |

Gecode::SharedArray< T > | Shared array with arbitrary number of elements |

Gecode::SharedArray< T >::SAO | Implementation of object for shared arrays |

Gecode::SharedHandle | The shared handle |

Gecode::SharedHandle::Object | The shared object |

Gecode::SharedMemory | Shared object for several memory areas |

Gecode::SizeOptions | Options for scripts with additional size parameter |

Gecode::Slice< A > | A slice of a matrix |

Gecode::Space | Computation spaces |

Gecode::Space::Branchers | Class to iterate over branchers of a space |

Gecode::Space::Propagators | Class to iterate over propagators of a space |

Gecode::space_allocator< T > | Allocator that allocates memory from a space heap |

Gecode::space_allocator< T >::rebind< U > | Rebinding helper (returns the type of a similar allocator for type U) |

Gecode::space_allocator< void > | Space allocator - specialization for `void` |

Gecode::space_allocator< void >::rebind< U > | Rebinding helper (returns the type of a similar allocator for type U) |

Gecode::SpaceConstrainUndefined | Exception: no constrain member function defined |

Gecode::SpaceFailed | Exception: Operation on failed space invoked |

Gecode::SpaceIllegalAlternative | Exception: Commit with illegal alternative |

Gecode::SpaceNoBrancher | Exception: Commit when no brancher present |

Gecode::SpaceNotStable | Exception: Operation on not stable space invoked |

Gecode::StatusStatistics | Statistics for execution of status |

Gecode::Support::BitSet< A > | Simple bitsets |

Gecode::Support::BitSetBase | Basic bitset support |

Gecode::Support::BitSetData | Date item for bitsets |

Gecode::Support::BlockAllocator< T, A, blocksize > | Manage memory organized into block lists (allocator) |

Gecode::Support::BlockClient< T, A, blocksize > | Client for block allocator of type T |

Gecode::Support::DynamicArray< T, A > | Array with arbitrary number of elements |

Gecode::Support::DynamicQueue< T, A > | Queue with arbitrary number of elements |

Gecode::Support::DynamicStack< T, A > | Stack with arbitrary number of elements |

Gecode::Support::Event | An event for synchronization |

Gecode::Support::IntTypeTraits< IntType > | Traits to for information about integer types |

Gecode::Support::IntTypeTraits< signed char > | Traits for signed char |

Gecode::Support::IntTypeTraits< signed int > | Traits for signed integer |

Gecode::Support::IntTypeTraits< signed short int > | Traits for signed short int |

Gecode::Support::IntTypeTraits< unsigned char > | Traits for unsigned char |

Gecode::Support::IntTypeTraits< unsigned int > | Traits for unsigned integer |

Gecode::Support::IntTypeTraits< unsigned short int > | Traits for unsigned short int |

Gecode::Support::Less< Type > | Comparison class for sorting using < |

Gecode::Support::LinearCongruentialGenerator< m, a, q, r > | Template for linear congruential generators |

Gecode::Support::Lock | A lock as a scoped frontend for a mutex |

Gecode::Support::Mutex | A mutex for mutual exclausion among several threads |

Gecode::Support::QuickSortStack< Type > | Static stack for quicksort |

Gecode::Support::Runnable | An interface for objects that can be run by a thread |

Gecode::Support::StaticStack< T, A > | Stack with fixed number of elements |

Gecode::Support::Thread | Simple threads |

Gecode::Support::Thread::Run | A real thread |

Gecode::Support::Timer | Timer |

Gecode::TernaryPropagator< View, pc > | Ternary propagator |

Gecode::TieBreakVarBranch< VarBranch > | Combine variable selection criteria for tie-breaking |

Gecode::TieBreakVarBranchOptions | Combine variable branch options for tie-breaking |

Gecode::TooManyBranchers | Exception: too many branchers |

Gecode::TupleSet | Class represeting a set of tuples |

Gecode::TupleSet::TupleSetI | Data stored for a Table |

Gecode::UnaryPropagator< View, pc > | Unary propagator |

Gecode::ValBranchOptions | Value branch options |

Gecode::ValSelBase< _View, _Val > | Base class for value selection |

Gecode::Var | Base class for variables |

Gecode::VarArgArray< Var > | Argument array for variables |

Gecode::VarArgArray< Var >::VarLess | Sort order for variables |

Gecode::VarArray< Var > | Variable arrays |

Gecode::VarBranchOptions | Variable branch options |

Gecode::VarImp< VIC > | Base-class for variable implementations |

Gecode::VarImpBase | Base-class for variable implementations |

Gecode::VarImpDisposer< VarImp > | Variable implementation disposer |

Gecode::VarImpDisposerBase | Base class for Variable type disposer |

Gecode::VarImpVar< VarImp > | Variables as interfaces to variable implementations |

Gecode::VarImpView< Var > | Base-class for variable implementation views |

Gecode::ViewAdvisor< View > | Advisor storing a single view |

Gecode::ViewArray< View > | View arrays |

Gecode::ViewArray< Int::Linear::NoView > | View array for no view (empty) |

Gecode::ViewBrancher< ViewSel > | Generic brancher by view selection |

Gecode::ViewSelAfcMax< View > | View selection class for view with largest accumulated failure count |

Gecode::ViewSelAfcMin< View > | View selection class for view with smallest accumulated failure count |

Gecode::ViewSelBase< _View > | Base class for view selection |

Gecode::ViewSelDegreeMax< View > | View selection class for view with largest degree |

Gecode::ViewSelDegreeMin< View > | View selection class for view with smallest degree |

Gecode::ViewSelNone< View > | Select first not assigned view |

Gecode::ViewSelRnd< _View > | View selection class for random selection |

Gecode::ViewSelTieBreakDynamic< _View > | View selection class for dynamic tie breaking |

Gecode::ViewSelTieBreakDynamic< _View >::Choice | Choice for tie breakers |

Gecode::ViewSelTieBreakStatic< A, B > | View selection class for static tie breaking |

Gecode::ViewSelTieBreakStatic< A, B >::Choice | View selection choice |

Gecode::ViewSelVirtual< ViewSel > | Virtualized view selection |

Gecode::ViewSelVirtualBase< View > | Virtualized view selection base class |

Gecode::ViewValBrancher< ViewSel, ValSel > | Generic brancher by view and value selection |

Golf | Example: Golf tournament |

GolfOptions | Options for Golf example |

GolombRuler | Example: Finding optimal Golomb rulers |

Graph | Graph specification |

GraphColor | Example: Clique-based graph coloring |

GraphColorSpec | Graph specification |

Grocery | Example: Grocery puzzle |

Hamming | Example: Generating Hamming codes |

HammingOptions | Options for Hamming problems |

IndSet | Example: Independent sets in a graph |

Kakuro | Example: Kakuro |

Knights | Base-class for knight's tour example |

KnightsCircuit | Example: n-Knights tour (model using circuit) |

KnightsReified | Example: n-Knight's tour (simple model) |

LangfordNumber | Example: Langford's number problem |

LangfordNumberOptions | Options taking two additional parameters |

MagicSequence | Example: Magic sequence |

MagicSquare | Example: Magic squares |

ManFixPSETask | |

ManFixPTask | |

ManFlexTask | |

MineSweeper | Example: Minesweeper |

Money | Example: SEND+MORE=MONEY puzzle |

Nonogram | Example: Nonogram |

OpenShop | Example: open-shop scheduling |

OpenShop::PrintTask | Helper class for representing tasks when printing a solution |

OpenShop::Task | Task representation for CROSH heuristic |

OrthoLatinSquare | Example: Orthogonal latin squares |

Partition | Example: partition numbers into two groups |

Pentominoes | Example: Pentominoes |

PerfectSquare | Example: Packing squares into a rectangle |

Photo | Example: Placing people on a photo |

PhotoSpec | Specifications for the photo example |

Play | Entry in round robin schedule |

QueenArmies | Example: Peaceable co-existing armies of queens |

QueenArmies::QueenBranch | Custom brancher for Peacable queens |

Queens | Example: n-Queens puzzle |

Radiotherapy | Example: Radiotherapy |

Radiotherapy::NestedSearch | Nested search on the q variables |

RadiotherapyData | Instance data for radio therapy problem |

RRS | Round robin schedule |

Sat | Example: CNF SAT solver |

SatOptions | Options for SAT problems |

Schur | Example: Schur's lemma |

SchurOptions | Options for Schur's Lemma |

SportsLeague | Example: Sports league scheduling |

SteelMill | Example: Steel-mill slab design problem |

SteelMill::SteelMillBranch | Custom brancher for steel mill slab design |

SteelMill::SteelMillBranch::Choice | Choice |

SteelMillOptions | SteelMillOptions for examples with size option and an additional optional file name parameter |

Steiner | Example: Steiner triples |

Sudoku | Base class for Sudoku puzzles |

SudokuInt | Example: Solving Sudoku puzzles using integer constraints |

SudokuMixed | Example: Solving Sudoku puzzles using both set and integer constraints |

SudokuSet | Example: Solving Sudoku puzzles using set constraints |

Test::AFC | Test for AFC infrastructure |

Test::AFC::TestSpace | Test space |

Test::Array::Iterator | Base class for testing iterators |

Test::Array::SharedArrayIterator | Class for testing the SharedArray iterator |

Test::Array::TestSpace | Test space |

Test::Array::VarArgsIterator | Class for testing the VarArgs iterator |

Test::Array::VarArrayIterator | Class for testing the VarArray iterator |

Test::Array::ViewArrayIterator | Class for testing the ViewArray iterator |

Test::Assign::Bool | Test branching with distinct propagator |

Test::Assign::BoolTest | Base class for tests for branching on Boolean variables |

Test::Assign::BoolTestSpace | Space for executing Boolean tests |

Test::Assign::Int | Test assignment with distinct propagator |

Test::Assign::IntTest | Base class for tests for assigning integer variables |

Test::Assign::IntTestSpace | Space for executing integer tests |

Test::Assign::Set | Test assignment with disjoint union propagator |

Test::Assign::SetTest | Base class for tests for branching on set variables |

Test::Assign::SetTestSpace | Space for executing Boolean tests |

Test::Base | Base class for all tests to be run |

Test::Branch::Bool | Test brancher with distinct propagator |

Test::Branch::BoolTest | Base class for tests for branching on Boolean variables |

Test::Branch::BoolTestSpace | Space for executing Boolean tests |

Test::Branch::Int | Test brancher with distinct propagator |

Test::Branch::IntTest | Base class for tests for branching on integer variables |

Test::Branch::IntTestSpace | Space for executing integer tests |

Test::Branch::RunInfo | Information about one test-run |

Test::Branch::Set | Test brancher |

Test::Branch::SetTest | Base class for tests for branching on set variables |

Test::Branch::SetTestSpace | Space for executing Boolean tests |

Test::ind | Simple class for describing identation |

Test::Int::Arithmetic::AbsXX | Test for absolute value constraint with shared variables |

Test::Int::Arithmetic::AbsXY | Test for absolute value constraint |

Test::Int::Arithmetic::Div | Test for division constraint |

Test::Int::Arithmetic::DivMod | Test for division/modulo constraint |

Test::Int::Arithmetic::MaxNary | Test for n-ary maximum constraint |

Test::Int::Arithmetic::MaxNaryShared | Test for n-ary maximum constraint with shared variables |

Test::Int::Arithmetic::MaxXXX | Test for binary maximum constraint with shared variables |

Test::Int::Arithmetic::MaxXXY | Test for binary maximum constraint with shared variables |

Test::Int::Arithmetic::MaxXYX | Test for binary maximum constraint with shared variables |

Test::Int::Arithmetic::MaxXYY | Test for binary maximum constraint with shared variables |

Test::Int::Arithmetic::MaxXYZ | Test for binary maximum constraint |

Test::Int::Arithmetic::MinNary | Test for n-ary minimmum constraint |

Test::Int::Arithmetic::MinNaryShared | Test for n-ary minimmum constraint with shared variables |

Test::Int::Arithmetic::MinXXX | Test for binary minimum constraint with shared variables |

Test::Int::Arithmetic::MinXXY | Test for binary minimum constraint with shared variables |

Test::Int::Arithmetic::MinXYX | Test for binary minimum constraint with shared variables |

Test::Int::Arithmetic::MinXYY | Test for binary minimum constraint with shared variables |

Test::Int::Arithmetic::MinXYZ | Test for binary minimum constraint |

Test::Int::Arithmetic::Mod | Test for modulo constraint |

Test::Int::Arithmetic::MultXXX | Test for multiplication constraint with shared variables |

Test::Int::Arithmetic::MultXXY | Test for multiplication constraint with shared variables |

Test::Int::Arithmetic::MultXYX | Test for multiplication constraint with shared variables |

Test::Int::Arithmetic::MultXYY | Test for multiplication constraint with shared variables |

Test::Int::Arithmetic::MultXYZ | Test for multiplication constraint |

Test::Int::Arithmetic::SqrtXX | Test for square root constraint with shared variables |

Test::Int::Arithmetic::SqrtXY | Test for square root constraint |

Test::Int::Arithmetic::SqrXX | Test for squaring constraint with shared variables |

Test::Int::Arithmetic::SqrXY | Test for squaring constraint |

Test::Int::Assignment | Base class for assignments |

Test::Int::Basic::Basic | Test whether testing infrastructure for integer variables works |

Test::Int::BinPacking::BPT | Test with different bin loads and items |

Test::Int::BinPacking::Create | Help class to create and register tests |

Test::Int::BinPacking::LoadBinAssignment | Generate load and bin assignments |

Test::Int::Bool::BinConstXX | Test for binary Boolean operation with shared variables and constant |

Test::Int::Bool::BinConstXY | Test for binary Boolean operation with constant |

Test::Int::Bool::BinXXX | Test for binary Boolean operation with shared variables |

Test::Int::Bool::BinXXY | Test for binary Boolean operation with shared variables |

Test::Int::Bool::BinXYX | Test for binary Boolean operation with shared variables |

Test::Int::Bool::BinXYY | Test for binary Boolean operation with shared variables |

Test::Int::Bool::BinXYZ | Test for binary Boolean operation |

Test::Int::Bool::ClauseConst | Test for Clause Boolean operation with constant |

Test::Int::Bool::ClauseXXY | Test for Clause Boolean operation |

Test::Int::Bool::ClauseXXYYX | Test for Clause Boolean operation |

Test::Int::Bool::ClauseXYZ | Test for Clause Boolean operation |

Test::Int::Bool::Create | Help class to create and register tests |

Test::Int::Bool::Nary | Test for Nary Boolean operation |

Test::Int::Bool::NaryConst | Test for Nary Boolean operation with constant |

Test::Int::Bool::NaryShared | Test for Nary Boolean operation |

Test::Int::BoolOpTypes | Iterator for Boolean operation types |

Test::Int::Channel::ChannelFull | Simple test for channel (testing all variables) |

Test::Int::Channel::ChannelHalf | Simple test for channel (testing single set of variables) |

Test::Int::Channel::ChannelLinkMulti | Test channel between integer variable and array of Boolean variables |

Test::Int::Channel::ChannelLinkSingle | Test channel between integer and Boolean variable |

Test::Int::Channel::ChannelShared | Test channel with shared variables |

Test::Int::Circuit::Circuit | Simple test for circuit constraint |

Test::Int::Circuit::CircuitCost | Simple test for circuit constraint with total cost |

Test::Int::Circuit::CircuitFullCost | Simple test for circuit constraint with full cost information |

Test::Int::Circuit::Create | Help class to create and register tests |

Test::Int::Circuit::Path | Simple test for Hamiltonian path constraint |

Test::Int::Circuit::PathCost | Simple test for path constraint with total cost |

Test::Int::Count::Create | Help class to create and register tests |

Test::Int::Count::IntArrayInt | Test number of several equal integers equal to integer |

Test::Int::Count::IntArrayVar | Test number of several equal integers equal to integer variable |

Test::Int::Count::IntInt | Test number of equal integers equal to integer |

Test::Int::Count::IntIntDup | Test number of equal integers equal to integer with duplicate variables |

Test::Int::Count::IntVar | Test number of equal integers equal to integer variable |

Test::Int::Count::IntVarShared | Test number of equal integers equal to integer variable with sharing |

Test::Int::Count::SetInt | Test number of integers contained in an integer set equal to integer |

Test::Int::Count::SetVar | Test number of integers contained in an integer set equal to integer variable |

Test::Int::Count::VarInt | Test number of equal variables equal to integer |

Test::Int::Count::VarVar | Test number of equal variables equal to integer variable |

Test::Int::Count::VarVarSharedA | Test number of equal variables equal to integer variable with sharing |

Test::Int::Count::VarVarSharedB | Test number of equal variables equal to integer variable with sharing |

Test::Int::Count::VarVarSharedC | Test number of equal variables equal to integer variable with sharing |

Test::Int::CpltAssignment | Generate all assignments |

Test::Int::Cumulative::Create | Help class to create and register tests |

Test::Int::Cumulative::ManFixPCumulative | Test for cumulative constraint with mandatory tasks |

Test::Int::Cumulative::ManFlexCumulative | Test for cumulative constraint with flexible mandatory tasks |

Test::Int::Cumulative::OptFixPCumulative | Test for cumulative constraint with optional tasks |

Test::Int::Cumulative::OptFlexCumulative | Test for cumulative constraint with optional flexible tasks |

Test::Int::Cumulatives::Above | Describe that event is above a certain limit |

Test::Int::Cumulatives::Ass | Script for generating assignments |

Test::Int::Cumulatives::Below | Describe that event is below a certain limit |

Test::Int::Cumulatives::CumulativeAssignment | Class for generating reasonable assignments |

Test::Int::Cumulatives::Cumulatives | Test for cumulatives constraint |

Test::Int::Cumulatives::Event | Event to be scheduled |

Test::Int::Distinct::Distinct< useCount > | Simple test for distinct constraint |

Test::Int::Distinct::Offset | Simple test for distinct constraint with offsets |

Test::Int::Distinct::Pathological | Testing pathological cases |

Test::Int::Distinct::Pathological::TestSpace | Test space |

Test::Int::Distinct::Random | Randomized test for distinct constraint |

Test::Int::Dom::DomDom | Test for domain constraint (full integer set) |

Test::Int::Dom::DomInt | Test for domain constraint (integer) |

Test::Int::Dom::DomRange | Test for domain constraint (range) |

Test::Int::Dom::DomRangeEmpty | Test for domain constraint (empty range) |

Test::Int::Element::Create | Help class to create and register tests |

Test::Int::Element::IntBoolInt | Test for element with integer array and integer and Boolean variable |

Test::Int::Element::IntBoolVar | Test for element with integer array and integer and Boolean variable |

Test::Int::Element::IntIntInt | Test for element with integer array and integer variables |

Test::Int::Element::IntIntShared | Test for element with integer array and single shared integer variable |

Test::Int::Element::IntIntVar | Test for element with integer array and integer variables |

Test::Int::Element::MatrixBoolVarBoolVarXX | Test for matrix element with Boolean variable array and Boolean variable |

Test::Int::Element::MatrixBoolVarBoolVarXY | Test for matrix element with Boolean variable array and Boolean variable |

Test::Int::Element::MatrixIntBoolVarXX | Test for matrix element with integer array and Boolean variable |

Test::Int::Element::MatrixIntBoolVarXY | Test for matrix element with integer array and Boolean variable |

Test::Int::Element::MatrixIntIntVarXX | Test for matrix element with integer array and integer variable |

Test::Int::Element::MatrixIntIntVarXY | Test for matrix element with integer array and integer variable |

Test::Int::Element::MatrixIntVarIntVarXX | Test for matrix element with integer variable array and integer variable |

Test::Int::Element::MatrixIntVarIntVarXY | Test for matrix element with integer variable array and integer variable |

Test::Int::Element::VarBoolInt | Test for element with Boolean variable array and integer variable |

Test::Int::Element::VarBoolVar | Test for element with Boolean variable array and integer variable |

Test::Int::Element::VarIntInt | Test for element with variable array and integer variables |

Test::Int::Element::VarIntShared | Test for element with variable array and shared integer variable |

Test::Int::Element::VarIntVar | Test for element with variable array and integer variables |

Test::Int::Exec::BoolWait | Simple test for wait (Boolean variables) |

Test::Int::Exec::IntWait | Simple test for wait (integer variables) |

Test::Int::Exec::When | Simple test for when |

Test::Int::Extensional::RegDistinct | Test with regular expression for distinct constraint |

Test::Int::Extensional::RegEmptyDFA | Test for empty DFA |

Test::Int::Extensional::RegEmptyREG | Test for empty regular expression |

Test::Int::Extensional::RegOpt | Test for optimizations |

Test::Int::Extensional::RegRoland | Test with simple regular expression from Roland Yap |

Test::Int::Extensional::RegSharedA | Test with simple regular expression and shared variables (uses unsharing) |

Test::Int::Extensional::RegSharedB | Test with simple regular expression and shared variables (uses unsharing) |

Test::Int::Extensional::RegSharedC | Test with simple regular expression and shared variables (uses unsharing) |

Test::Int::Extensional::RegSharedD | Test with simple regular expression and shared variables (uses unsharing) |

Test::Int::Extensional::RegSimpleA | Test with simple regular expression |

Test::Int::Extensional::RegSimpleB | Test with simple regular expression |

Test::Int::Extensional::RegSimpleC | Test with simple regular expression |

Test::Int::Extensional::TupleSetA | Test with tuple set |

Test::Int::Extensional::TupleSetB | Test with tuple set |

Test::Int::Extensional::TupleSetBool | Test with bool tuple set |

Test::Int::GCC::Create | Help class to create and register tests |

Test::Int::GCC::IntAllMax | Test for integer cardinality with max cardinality for all variables |

Test::Int::GCC::IntAllMinMax | Test for integer cardinality with min and max for all variables |

Test::Int::GCC::IntAllMinMaxDef | Test for integer cardinality with min and max for all variables |

Test::Int::GCC::IntSome< hole > | Test for integer cardinality for some variables |

Test::Int::GCC::VarAll | Test for variable cardinality for all cardinality values |

Test::Int::GCC::VarSome | Test for variable cardinality for some cardinality values |

Test::Int::IntConLevels | Iterator for integer consistency levels |

Test::Int::IntRelTypes | Iterator for integer relation types |

Test::Int::Linear::BoolInt | Test linear relation over Boolean variables equal to constant |

Test::Int::Linear::BoolVar | Test linear relation over Boolean variables equal to integer variable |

Test::Int::Linear::Create | Help class to create and register tests |

Test::Int::Linear::IntInt | Test linear relation over integer variables |

Test::Int::Linear::IntVar | Test linear relation over integer variables |

Test::Int::Member::Bool | Test membership for Boolean variables |

Test::Int::Member::Create | Help class to create and register tests |

Test::Int::Member::Int | Test membership for integer variables |

Test::Int::MiniModel::BoolLex | Test for relation between arrays of Boolean variables |

Test::Int::MiniModel::Create | Help class to create and register tests |

Test::Int::MiniModel::IntLex | Test for relation between arrays of integer variables |

Test::Int::MiniModelArithmetic::Abs | Test for absolute value constraint |

Test::Int::MiniModelArithmetic::Div | Test for division constraint |

Test::Int::MiniModelArithmetic::Max | Test for binary maximum constraint |

Test::Int::MiniModelArithmetic::MaxNary | Test for n-ary maximum constraint |

Test::Int::MiniModelArithmetic::Min | Test for binary minimum constraint |

Test::Int::MiniModelArithmetic::MinNary | Test for n-ary minimmum constraint |

Test::Int::MiniModelArithmetic::Minus | Test for subtraction constraint |

Test::Int::MiniModelArithmetic::Mod | Test for division constraint |

Test::Int::MiniModelArithmetic::Mult | Test for multiplication constraint |

Test::Int::MiniModelArithmetic::Plus | Test for addition constraint |

Test::Int::MiniModelArithmetic::Sqr | Test for sqr constraint |

Test::Int::MiniModelArithmetic::Sqrt | Test for sqrt constraint |

Test::Int::MiniModelBoolean::BoolExprInt | Test Boolean expressions with integer result |

Test::Int::MiniModelBoolean::BoolExprVar | Test posting Boolean expressions |

Test::Int::MiniModelBoolean::BoolInstr | Type for representing a Boolean instruction |

Test::Int::MiniModelBoolean::Create | Help class to create and register tests |

Test::Int::MiniModelCount::Create | Help class to create and register tests |

Test::Int::MiniModelCount::IntArrayInt | Test number of several equal integers equal to integer |

Test::Int::MiniModelCount::IntArrayVar | Test number of several equal integers equal to integer variable |

Test::Int::MiniModelCount::IntInt | Test number of equal integers equal to integer |

Test::Int::MiniModelCount::IntVar | Test number of equal integers equal to integer variable |

Test::Int::MiniModelCount::VarInt | Test number of equal variables equal to integer |

Test::Int::MiniModelCount::VarVar | Test number of equal variables equal to integer variable |

Test::Int::MiniModelLin::Create | Help class to create and register tests |

Test::Int::MiniModelLin::LinExprBool | Test linear expressions over Boolean variables |

Test::Int::MiniModelLin::LinExprInt | Test linear expressions over integer variables |

Test::Int::MiniModelLin::LinExprMixed | Test linear expressions over integer and Boolean variables |

Test::Int::MiniModelLin::LinInstr | Type for representing a linear instruction |

Test::Int::MiniModelLin::LinRelBool | Test linear relations over Boolean variables |

Test::Int::MiniModelLin::LinRelInt | Test linear relations over integer variables |

Test::Int::MiniModelLin::LinRelMixed | Test linear relations over integer and Boolean variables |

Test::Int::MiniModelSet::Create | Help class to create and register tests |

Test::Int::MiniModelSet::SetExprConst | Test set expressions with constant result |

Test::Int::MiniModelSet::SetExprExpr | Test set expressions with expression result |

Test::Int::MiniModelSet::SetInstr | Type for representing a set instruction |

Test::Int::NoOverlap::Create | Help class to create and register tests |

Test::Int::NoOverlap::Int2 | Test for no-overlap with integer dimensions (rectangles) |

Test::Int::NoOverlap::IntOpt2 | Test for no-overlap with optional rectangles |

Test::Int::NoOverlap::Var2 | Test for no-overlap with variable dimensions (rectangles) |

Test::Int::NoOverlap::VarOpt2 | Test for no-overlap with optional rectangles |

Test::Int::NValues::BoolInt | Test number of values of Boolean variables equal to integer |

Test::Int::NValues::BoolVar | Test number of values of Boolean variables equal to integer variable |

Test::Int::NValues::Create | Help class to create and register tests |

Test::Int::NValues::IntInt | Test number of values of integer variables equal to integer |

Test::Int::NValues::IntVar | Test number of values of integer variables equal to integer variable |

Test::Int::Precede::Multi | Test for multiple value precedence constraint |

Test::Int::Precede::Single | Test for single value precedence constraint |

Test::Int::RandomAssignment | Generate random selection of assignments |

Test::Int::RandomMixAssignment | Generate random selection of assignments |

Test::Int::Rel::BoolArray | Test for relation between arrays of Boolean variables |

Test::Int::Rel::BoolInt | Test for simple relation involving Boolean variable and integer constant |

Test::Int::Rel::BoolSeq | Test for sequence of relations between Boolean variables |

Test::Int::Rel::BoolSharedSeq | Test for sequence of relations between shared Boolean variables |

Test::Int::Rel::BoolVarXX | Test for simple relation involving shared Boolean variables |

Test::Int::Rel::BoolVarXY | Test for simple relation involving Boolean variables |

Test::Int::Rel::Create | Help class to create and register tests |

Test::Int::Rel::IntArray | Test for relation between same sized arrays of integer variables |

Test::Int::Rel::IntArrayDiff | Test for relation between differently sized arrays of integer variables |

Test::Int::Rel::IntInt | Test for simple relation involving integer variable and integer constant |

Test::Int::Rel::IntSeq | Test for sequence of relations between integer variables |

Test::Int::Rel::IntSharedSeq | Test for sequence of relations between shared integer variables |

Test::Int::Rel::IntVarXX | Test for simple relation involving shared integer variables |

Test::Int::Rel::IntVarXY | Test for simple relation involving integer variables |

Test::Int::Sequence::Create | Help class to create and register tests |

Test::Int::Sequence::SequenceBoolTest | Test for sequence with boolean variables |

Test::Int::Sequence::SequenceIntTest | Test for sequence with boolean variables |

Test::Int::Sequence::SequenceTest | Base test for sequence |

Test::Int::Sorted::NoVar | Test sorted without permutation variables |

Test::Int::Sorted::PermVar | Test sorted with permutation variables |

Test::Int::Sorted::SortIntMin | Relation for sorting integers in increasing order |

Test::Int::Test | Base class for tests with integer constraints |

Test::Int::TestSpace | Space for executing tests |

Test::Int::Unary::ManFixPUnary | Test for unary constraint |

Test::Int::Unary::ManFlexUnary | Test for unary constraint |

Test::Int::Unary::OptFixPUnary | Test for unary constraint with optional tasks |

Test::Int::Unary::OptFlexUnary | Test for unary constraint with optional tasks |

Test::Int::Unshare::Bool | Test for unsharing Boolean variables |

Test::Int::Unshare::Int | Test for unsharing integer variables |

Test::Options | Commandline options |

Test::Search::Best< Model, Engine > | Test for best solution search |

Test::Search::BranchTypes | Iterator for branching types |

Test::Search::ConstrainTypes | Iterator for constrain types |

Test::Search::Create | Help class to create and register tests |

Test::Search::DFS< Model > | Test for depth-first search |

Test::Search::FailImmediate | Space that immediately fails |

Test::Search::HasSolutions | Space that requires propagation and has solutions |

Test::Search::Test | Base class for search tests |

Test::Search::TestSpace | Space with information |

Test::Set::Convex::Convex | Test for convexity propagator |

Test::Set::Convex::ConvexHull | Test for convex hull propagator |

Test::Set::Convex::ConvexHullS | Sharing test for convex hull propagator |

Test::Set::CountableSet | Iterate all subsets of a given set |

Test::Set::CountableSetRanges | Range iterator producing subsets of an IntSet |

Test::Set::CountableSetValues | Value iterator producing subsets of an IntSet |

Test::Set::Distinct::AtmostOne | Test for the atmostone propagator |

Test::Set::Dom::CardRange | Test for cardinality range |

Test::Set::Dom::DomDom | Test for equality with a domain |

Test::Set::Dom::DomInt | Test for equality with an integer |

Test::Set::Dom::DomIntRange | Test for equality with an integer range |

Test::Set::Dom::DomRange | Test for equality with a range |

Test::Set::Element::ElementDisjoint | Test for ElementDisjoint constraint |

Test::Set::Element::ElementInter | Test for ElementInter constraint |

Test::Set::Element::ElementInterIn | Test for ElementInter constraint |

Test::Set::Element::ElementSet | Test for ElementSet constraint |

Test::Set::Element::ElementSetConst | Test for ElementSetConst constraint |

Test::Set::Element::ElementUnion | Test for ElementUnion constraint |

Test::Set::Element::ElementUnionConst | Test for ElementUnionConst constraint |

Test::Set::Element::MatrixIntSet | Test for matrix element with integer set array and set variable |

Test::Set::Exec::Wait | Simple test for wait (set variables) |

Test::Set::FakeSpace | Fake space for creation of regions |

Test::Set::Int::Card | Test for cardinality constraint |

Test::Set::Int::ChannelBool | Test for Boolean channel constraint |

Test::Set::Int::ChannelInt | Test for integer channel constraint |

Test::Set::Int::Elem | Test for element constraint |

Test::Set::Int::IntRel | Test for integer relation constraint |

Test::Set::Int::Match | Test for match constraint |

Test::Set::Int::Max | Test for maximal element constraint |

Test::Set::Int::Min | Test for minimal element constraint |

Test::Set::Int::NoElem | Test for negated element constraint |

Test::Set::Int::NotMax | Test for negated maximal element constraint |

Test::Set::Int::NotMin | Test for negated minimal element constraint |

Test::Set::Int::Rel | Test for relation constraint |

Test::Set::Int::Weights | Test for set weight constraint |

Test::Set::Precede::Multi | Test for multiple value precedence constraint |

Test::Set::Precede::Single | Test for single value precedence constraint |

Test::Set::Rel::RelBin | Test for binary set relation constraint |

Test::Set::RelOp::Create | Help class to create and register tests |

Test::Set::RelOp::CreateIntN | Help class to create and register tests |

Test::Set::RelOp::CreateN | Help class to create and register tests |

Test::Set::RelOp::Rel | Test for ternary relation constraint |

Test::Set::RelOp::RelIntN | Test for n-ary partition constraint |

Test::Set::RelOp::RelN | Test for n-ary partition constraint |

Test::Set::RelOpConst::Create | Help class to create and register tests |

Test::Set::RelOpConst::RelISI | Test for set relation constraint with constants |

Test::Set::RelOpConst::RelSIS | Test for set relation constraint with constants |

Test::Set::RelOpConst::RelSSI | Test for set relation constraint with constants |

Test::Set::Sequence::SeqU | Test for sequential-union constraint |

Test::Set::Sequence::Sequence | Test for sequence constraint |

Test::Set::SetAssignment | Generate all set assignments |

Test::Set::SetOpTypes | Iterator for Boolean operation types |

Test::Set::SetRelTypes | Iterator for set relation types |

Test::Set::SetTest | Base class for tests with set constraints |

Test::Set::SetTestSpace | Space for executing set tests |

Test::Set::Var::Construct | Test for cardinality constraint |

Test::SortByName | Sort tests by name |

TileSpec | Specification of one tile |

TSP | Example: Travelling salesman problem (TSP) |

Warehouses | Example: Locating warehouses |

Warnsdorff | Custom brancher for knight's tours using Warnsdorff's rule |

Warnsdorff::Choice | Choice |

WordSquare | Example: Word-square puzzle |