diff --git a/packages/gecode/dev/code-generator.py b/packages/gecode/dev/code-generator.py index 02bbf9461..b840130c5 100644 --- a/packages/gecode/dev/code-generator.py +++ b/packages/gecode/dev/code-generator.py @@ -666,15 +666,18 @@ def gecode_version(): @@GECODE_VERSION""") f.close() cxx.preprocess(file_hh,output_file=file_txt) - f = open(file_txt) - version = "" - for line in f: - if line.startswith("@@"): - version = line[3:-2] - break - f.close() - os.remove(file_hh) - os.remove(file_txt) + if True: + f = open(file_txt) + version = "" + for line in f: + if line.startswith("@@"): + version = line[3:-2] + break + f.close() + os.remove(file_hh) + os.remove(file_txt) + else: + version = "4.4.0" GECODE_VERSION = version return version diff --git a/packages/gecode/dev/extractor/Doxyfile b/packages/gecode/dev/extractor/Doxyfile index c11bf9b38..2b3c64d99 100644 --- a/packages/gecode/dev/extractor/Doxyfile +++ b/packages/gecode/dev/extractor/Doxyfile @@ -610,7 +610,7 @@ WARN_LOGFILE = # directories like "/usr/src/myproject". Separate the files or directories # with spaces. -INPUT = /usr/local/include/gecode +INPUT = /usr/include/gecode # This tag can be used to specify the character encoding of the source files # that doxygen parses. Internally doxygen uses the UTF-8 encoding, which is diff --git a/packages/gecode/dev/extractor/xml/namespaceGecode.xml b/packages/gecode/dev/extractor/xml/namespaceGecode.xml new file mode 100644 index 000000000..437c19448 --- /dev/null +++ b/packages/gecode/dev/extractor/xml/namespaceGecode.xml @@ -0,0 +1,23233 @@ + + + + Gecode + Gecode::Activity + Gecode::ActivityWrongArity + Gecode::Actor + Gecode::ActorLink + Gecode::Advisor + Gecode::Advisors + Gecode::AFC + Gecode::AFCWrongArity + Gecode::AllVarConf + Gecode::Archive + Gecode::ArgArray + Gecode::ArgArrayBase + Gecode::ArrayTraits + Gecode::ArrayTraits< ArgArray< IntSet > > + Gecode::ArrayTraits< ArgArray< SymmetryHandle > > + Gecode::ArrayTraits< ArgArray< VarImpBase * > > + Gecode::ArrayTraits< BoolVarArgs > + Gecode::ArrayTraits< BoolVarArray > + Gecode::ArrayTraits< FloatValArgs > + Gecode::ArrayTraits< FloatVarArgs > + Gecode::ArrayTraits< FloatVarArray > + Gecode::ArrayTraits< IntArgs > + Gecode::ArrayTraits< IntVarArgs > + Gecode::ArrayTraits< IntVarArray > + Gecode::ArrayTraits< LiteralArgs > + Gecode::ArrayTraits< PrimArgArray< FloatVal > > + Gecode::ArrayTraits< PrimArgArray< int > > + Gecode::ArrayTraits< PrimArgArray< TaskType > > + Gecode::ArrayTraits< SetVarArgs > + Gecode::ArrayTraits< SetVarArray > + Gecode::ArrayTraits< VarArgArray< BoolVar > > + Gecode::ArrayTraits< VarArgArray< FloatVar > > + Gecode::ArrayTraits< VarArgArray< IntVar > > + Gecode::ArrayTraits< VarArgArray< SetVar > > + Gecode::ArrayTraits< VarArray< BoolVar > > + Gecode::ArrayTraits< VarArray< FloatVar > > + Gecode::ArrayTraits< VarArray< IntVar > > + Gecode::ArrayTraits< VarArray< SetVar > > + Gecode::BAB + Gecode::BaseOptions + Gecode::BinaryPropagator + Gecode::BoolExpr + Gecode::BoolVar + Gecode::BoolVarArgs + Gecode::BoolVarArray + Gecode::Brancher + Gecode::BrancherHandle + Gecode::BranchTraits + Gecode::BranchTraits< BoolVar > + Gecode::BranchTraits< FloatVar > + Gecode::BranchTraits< IntVar > + Gecode::BranchTraits< SetVar > + Gecode::Choice + Gecode::ChooseMax + Gecode::ChooseMin + Gecode::CloneStatistics + Gecode::CommitStatistics + Gecode::ConstView + Gecode::Council + Gecode::CRI + Gecode::Delta + Gecode::DerivedView + Gecode::DFA + Gecode::DFS + Gecode::DynamicCastFailed + Gecode::Exception + Gecode::FloatActivity + Gecode::FloatAFC + Gecode::FloatAssign + Gecode::FloatNumBranch + Gecode::FloatVal + Gecode::FloatValArgs + Gecode::FloatValBranch + Gecode::FloatVar + Gecode::FloatVarArgs + Gecode::FloatVarArray + Gecode::FloatVarBranch + Gecode::FreeList + Gecode::GlobalAFC + Gecode::Heap + Gecode::HeapChunk + Gecode::Home + Gecode::IllegalDecay + Gecode::InstanceOptions + Gecode::IntActivity + Gecode::IntAFC + Gecode::IntArgs + Gecode::IntAssign + Gecode::IntMaximizeSpace + Gecode::IntMinimizeSpace + Gecode::IntSet + Gecode::IntSetInit + Gecode::IntSetInit< IntArgs > + Gecode::IntSetInit< IntSet > + Gecode::IntSetRanges + Gecode::IntSetValues + Gecode::IntValBranch + Gecode::IntVar + Gecode::IntVarArgs + Gecode::IntVarArray + Gecode::IntVarBranch + Gecode::IntVarRanges + Gecode::IntVarValues + Gecode::LinIntExpr + Gecode::LinIntRel + Gecode::LocalHandle + Gecode::LocalObject + Gecode::Matrix + Gecode::MemoryChunk + Gecode::MemoryExhausted + Gecode::MemoryManager + Gecode::MeritActivity + Gecode::MeritAFC + Gecode::MeritBase + Gecode::MeritDegree + Gecode::MeritFunction + Gecode::MixBinaryPropagator + Gecode::MixNaryOnePropagator + Gecode::MixTernaryPropagator + Gecode::NaryOnePropagator + Gecode::NaryPropagator + Gecode::NGL + Gecode::NoGoods + Gecode::NoIdxVarImpConf + Gecode::NonLinIntExpr + Gecode::OperatingSystemError + Gecode::Options + Gecode::Pos + Gecode::PosChoice + Gecode::PosValChoice + Gecode::PrimArgArray + Gecode::Propagator + Gecode::PropCost + Gecode::RangeList + Gecode::RBS + Gecode::REG + Gecode::Region + Gecode::region_allocator + Gecode::region_allocator< void > + Gecode::Reify + Gecode::Rnd + Gecode::SetActivity + Gecode::SetAFC + Gecode::SetAssign + Gecode::SetValBranch + Gecode::SetVar + Gecode::SetVarArgs + Gecode::SetVarArray + Gecode::SetVarBranch + Gecode::SetVarGlbRanges + Gecode::SetVarGlbValues + Gecode::SetVarLubRanges + Gecode::SetVarLubValues + Gecode::SetVarUnknownRanges + Gecode::SetVarUnknownValues + Gecode::SharedArray + Gecode::SharedHandle + Gecode::SharedMemory + Gecode::SizeOptions + Gecode::Slice + Gecode::Space + Gecode::space_allocator + Gecode::space_allocator< void > + Gecode::SpaceFailed + Gecode::SpaceIllegalAlternative + Gecode::SpaceNoBrancher + Gecode::SpaceNotCloned + Gecode::SpaceNotStable + Gecode::StatusStatistics + Gecode::Symmetries + Gecode::SymmetryHandle + Gecode::TernaryPropagator + Gecode::TieBreak + Gecode::TooManyBranchers + Gecode::TupleSet + Gecode::UnaryPropagator + Gecode::UninitializedActivity + Gecode::UninitializedAFC + Gecode::UninitializedRnd + Gecode::ValBranch + Gecode::ValCommit + Gecode::ValCommitFunction + Gecode::ValSel + Gecode::ValSelCommit + Gecode::ValSelCommitBase + Gecode::ValSelFunction + Gecode::Var + Gecode::VarArgArray + Gecode::VarArray + Gecode::VarBranch + Gecode::VarImp + Gecode::VarImpBase + Gecode::VarImpDisposer + Gecode::VarImpDisposerBase + Gecode::VarImpVar + Gecode::VarImpView + Gecode::ViewAdvisor + Gecode::ViewArray + Gecode::ViewArray< Int::Linear::NoView > + Gecode::ViewBrancher + Gecode::ViewSel + Gecode::ViewSelChoose + Gecode::ViewSelChooseTbl + Gecode::ViewSelMax + Gecode::ViewSelMaxTbl + Gecode::ViewSelMin + Gecode::ViewSelMinTbl + Gecode::ViewSelNone + Gecode::ViewSelRnd + Gecode::ViewValBrancher + Gecode::ViewValNGL + Gecode::Driver + Gecode::FlatZinc + Gecode::Float + Gecode::Gist + Gecode::Int + Gecode::Iter + Gecode::Kernel + Gecode::MemoryConfig + Gecode::MiniModel + Gecode::Search + Gecode::Set + Gecode::Support + + + ScriptMode + + SM_SOLUTION + +Print solution and some statistics. + + + + + SM_TIME + +Measure average runtime. + + + + + SM_STAT + +Print statistics for script. + + + + + SM_GIST + +Run script in Gist. + + + + +Different modes for executing scripts. + + + + + + + + RestartMode + + RM_NONE + +No restarts. + + + + + RM_CONSTANT + +Restart with constant sequence. + + + + + RM_LINEAR + +Restart with linear sequence. + + + + + RM_LUBY + +Restart with Luby sequence. + + + + + RM_GEOMETRIC + +Restart with geometric sequence. + + + + +Different modes for restart-based search. + + + + + + + + FloatRelType + + FRT_EQ + +Equality ( $=$) + + + + + FRT_NQ + +Disequality ( $\neq$) + + + + + FRT_LQ + +Less or equal ( $\leq$) + + + + + FRT_LE + +Less ( $<$) + + + + + FRT_GQ + +Greater or equal ( $\geq$) + + + + + FRT_GR + +Greater ( $>$) + + + + +Relation types for floats. + + + + + + + + ReifyMode + + RM_EQV + +Equivalence for reification (default) + +For a constraint $c$ and a Boolean control variable $b$ defines that $b=1\Leftrightarrow c$ is propagated. + + + RM_IMP + +Implication for reification. + +For a constraint $c$ and a Boolean control variable $b$ defines that $b=1\Leftarrow c$ is propagated. + + + RM_PMI + +Inverse implication for reification. + +For a constraint $c$ and a Boolean control variable $b$ defines that $b=1\Rightarrow c$ is propagated. + + +Mode for reification. + + + + + + + + IntRelType + + IRT_EQ + +Equality ( $=$) + + + + + IRT_NQ + +Disequality ( $\neq$) + + + + + IRT_LQ + +Less or equal ( $\leq$) + + + + + IRT_LE + +Less ( $<$) + + + + + IRT_GQ + +Greater or equal ( $\geq$) + + + + + IRT_GR + +Greater ( $>$) + + + + +Relation types for integers. + + + + + + + + BoolOpType + + BOT_AND + +Conjunction. + + + + + BOT_OR + +Disjunction. + + + + + BOT_IMP + +Implication. + + + + + BOT_EQV + +Equivalence. + + + + + BOT_XOR + +Exclusive or. + + + + +Operation types for Booleans. + + + + + + + + IntConLevel + + ICL_VAL + +Value propagation or consistency (naive) + + + + + ICL_BND + +Bounds propagation or consistency. + + + + + ICL_DOM + +Domain propagation or consistency. + + + + + ICL_DEF + +The default consistency for a constraint. + + + + +Consistency levels for integer propagators. + +The descriptions are meant to be suggestions. It is not required that a propagator achieves full domain consistency or full bounds consistency. It is more like: which level of consistency comes closest.If in the description of a constraint below no consistency level is mentioned, the propagator for the constraint implements domain consistency. + + + + + + TaskType + + TT_FIXP + + + + + + + TT_FIXS + + + + + + + TT_FIXE + + + + + + +Type of task for scheduling constraints. + + + + + + + + ExtensionalPropKind + + EPK_DEF + +Make a default decision. + + + + + EPK_SPEED + +Prefer speed over memory consumption. + + + + + EPK_MEMORY + +Prefer little memory over speed. + + + + +Extensional propagation kind. + +Signals that a particular kind is used in propagation for the implementation of a extensional constraint. + + + + + + ExecStatus + + __ES_SUBSUMED + = -2 + +Internal: propagator is subsumed, do not use. + + + + + ES_FAILED + = -1 + +Execution has resulted in failure. + + + + + ES_NOFIX + = 0 + +Propagation has not computed fixpoint. + + + + + ES_OK + = 0 + +Execution is okay. + + + + + ES_FIX + = 1 + +Propagation has computed fixpoint. + + + + + ES_NOFIX_FORCE + = 2 + +Advisor forces rescheduling of propagator. + + + + + __ES_PARTIAL + = 2 + +Internal: propagator has computed partial fixpoint, do not use. + + + + + + + + + + + + + ActorProperty + + AP_DISPOSE + = (1 << 0) + +Actor must always be disposed. + +Normally, a propagator will not be disposed if its home space is deleted. However, if an actor uses external resources, this property can be used to make sure that the actor will always be disposed. + + + AP_WEAKLY + = (1 << 1) + + + +Propagator is only weakly monotonic, that is, the propagator is only monotonic on assignments. + + +Actor properties. + + + + + + + + SpaceStatus + + SS_FAILED + +Space is failed + + + + + SS_SOLVED + +Space is solved (no brancher left) + + + + + SS_BRANCH + +Space must be branched (at least one brancher left) + + + + +Space status + + + + + + + + SetRelType + + SRT_EQ + +Equality ( $=$) + + + + + SRT_NQ + +Disequality ( $\neq$) + + + + + SRT_SUB + +Subset ( $\subseteq$) + + + + + SRT_SUP + +Superset ( $\supseteq$) + + + + + SRT_DISJ + +Disjoint ( $\parallel$) + + + + + SRT_CMPL + +Complement. + + + + + SRT_LQ + +Less or equal ( $\leq$) + + + + + SRT_LE + +Less ( $<$) + + + + + SRT_GQ + +Greater or equal ( $\geq$) + + + + + SRT_GR + +Greater ( $>$) + + + + +Common relation types for sets. + +The total order on sets is defined as the lexicographic order on their characteristic functions, e.g., $x\leq y$ means that either $x$ is empty or the minimal element of the symmetric difference $x\ominus y$ is in $y$. + + + + + + SetOpType + + SOT_UNION + +Union. + + + + + SOT_DUNION + +Disjoint union. + + + + + SOT_INTER + +Intersection + + + + + SOT_MINUS + +Difference. + + + + +Common operations for sets. + + + + + + + + + + Driver::ScriptBase< Driver::IgnoreStepOption< Space > > + typedef Driver::ScriptBase<Driver::IgnoreStepOption<Space> > Gecode::Script + + Script + +Base-class for scripts. + + + + + + + + Driver::ScriptBase< Driver::IgnoreStepOption< MinimizeSpace > > + typedef Driver::ScriptBase<Driver::IgnoreStepOption<MinimizeSpace> > Gecode::MinimizeScript + + MinimizeScript + +Base-class for scripts for finding solution of lowest integer cost. + + + + + + + + Driver::ScriptBase< Driver::IgnoreStepOption< MaximizeSpace > > + typedef Driver::ScriptBase<Driver::IgnoreStepOption<MaximizeSpace> > Gecode::MaximizeScript + + MaximizeScript + +Base-class for scripts for finding solution of highest integer cost. + + + + + + + + Driver::ScriptBase< Driver::IgnoreStepOption< IntMinimizeSpace > > + typedef Driver::ScriptBase<Driver::IgnoreStepOption<IntMinimizeSpace> > Gecode::IntMinimizeScript + + IntMinimizeScript + +Base-class for scripts for finding solution of lowest integer cost. + + + + + + + + Driver::ScriptBase< Driver::IgnoreStepOption< IntMaximizeSpace > > + typedef Driver::ScriptBase<Driver::IgnoreStepOption<IntMaximizeSpace> > Gecode::IntMaximizeScript + + IntMaximizeScript + +Base-class for scripts for finding solution of highest integer cost. + + + + + + + + double + typedef double Gecode::FloatNum + + FloatNum + +Floating point number base type. + +This type defines the interval bounds used for representing floating point values. + + + + + + bool(* + typedef bool(* Gecode::FloatBranchFilter) (const Space &home, FloatVar x, int i) + )(const Space &home, FloatVar x, int i) + FloatBranchFilter + +Branch filter function type for float variables. + +The variable x is considered for selection and i refers to the variable's position in the original array passed to the brancher. + + + + + + double(* + typedef double(* Gecode::FloatBranchMerit) (const Space &home, FloatVar x, int i) + )(const Space &home, FloatVar x, int i) + FloatBranchMerit + +Branch merit function type for float variables. + +The function must return a merit value for the variable x. The value i refers to the variable's position in the original array passed to the brancher. + + + + + + FloatNumBranch(* + typedef FloatNumBranch(* Gecode::FloatBranchVal) (const Space &home, FloatVar x, int i) + )(const Space &home, FloatVar x, int i) + FloatBranchVal + +Branch value function type for float variables. + +Returns a value for the variable x that is to be used in the corresponding branch commit function. The integer i refers to the variable's position in the original array passed to the brancher. + + + + + + void(* + typedef void(* Gecode::FloatBranchCommit) (Space &home, unsigned int a, FloatVar x, int i, FloatNumBranch nl) + )(Space &home, unsigned int a, FloatVar x, int i, FloatNumBranch nl) + FloatBranchCommit + +Branch commit function type for float variables. + +The function must post a constraint on the variable x which corresponds to the alternative a. The integer i refers to the variable's position in the original array passed to the brancher. The value nl is the value description computed by the corresponding branch value function. + + + + + + void(* + typedef void(* Gecode::FloatVarValPrint) (const Space &home, const BrancherHandle &bh, unsigned int a, FloatVar x, int i, const FloatNumBranch &n, std::ostream &o) + )(const Space &home, const BrancherHandle &bh, unsigned int a, FloatVar x, int i, const FloatNumBranch &n, std::ostream &o) + FloatVarValPrint + +Function type for explaining branching alternatives for set variables. + + + + + + + + ArgArray< Int::LDSB::Literal > + typedef ArgArray<Int::LDSB::Literal> Gecode::LiteralArgs + + LiteralArgs + +An array of literals. + + + + + + + + ArgArray< IntSet > + typedef ArgArray<IntSet> Gecode::IntSetArgs + + IntSetArgs + +Passing set arguments. + + + + + + + + PrimArgArray< TaskType > + typedef PrimArgArray<TaskType> Gecode::TaskTypeArgs + + TaskTypeArgs + +Argument arrays for passing task type arguments. + + + + + + + + SharedArray< int > + typedef SharedArray<int> Gecode::IntSharedArray + + IntSharedArray + +Arrays of integers that can be shared among several element constraints. + + + + + + + + bool(* + typedef bool(* Gecode::IntBranchFilter) (const Space &home, IntVar x, int i) + )(const Space &home, IntVar x, int i) + IntBranchFilter + +Branch filter function type for integer variables. + +The variable x is considered for selection and i refers to the variable's position in the original array passed to the brancher. + + + + + + bool(* + typedef bool(* Gecode::BoolBranchFilter) (const Space &home, BoolVar x, int i) + )(const Space &home, BoolVar x, int i) + BoolBranchFilter + +Branch filter function type for Boolean variables. + +The variable x is considered for selection and i refers to the variable's position in the original array passed to the brancher. + + + + + + double(* + typedef double(* Gecode::IntBranchMerit) (const Space &home, IntVar x, int i) + )(const Space &home, IntVar x, int i) + IntBranchMerit + +Branch merit function type for integer variables. + +The function must return a merit value for the variable x. The integer i refers to the variable's position in the original array passed to the brancher. + + + + + + double(* + typedef double(* Gecode::BoolBranchMerit) (const Space &home, BoolVar x, int i) + )(const Space &home, BoolVar x, int i) + BoolBranchMerit + +Branch merit function type for Boolean variables. + +The function must return a merit value for the variable x. The integer i refers to the variable's position in the original array passed to the brancher. + + + + + + int(* + typedef int(* Gecode::IntBranchVal) (const Space &home, IntVar x, int i) + )(const Space &home, IntVar x, int i) + IntBranchVal + +Branch value function type for integer variables. + +Returns a value for the variable x that is to be used in the corresponding branch commit function. The integer i refers to the variable's position in the original array passed to the brancher. + + + + + + int(* + typedef int(* Gecode::BoolBranchVal) (const Space &home, BoolVar x, int i) + )(const Space &home, BoolVar x, int i) + BoolBranchVal + +Branch value function type for Boolean variables. + +Returns a value for the variable x that is to be used in the corresponding branch commit function. The integer i refers to the variable's position in the original array passed to the brancher. + + + + + + void(* + typedef void(* Gecode::IntBranchCommit) (Space &home, unsigned int a, IntVar x, int i, int n) + )(Space &home, unsigned int a, IntVar x, int i, int n) + IntBranchCommit + +Branch commit function type for integer variables. + +The function must post a constraint on the variable x which corresponds to the alternative a. The integer i refers to the variable's position in the original array passed to the brancher. The value n is the value computed by the corresponding branch value function. + + + + + + void(* + typedef void(* Gecode::BoolBranchCommit) (Space &home, unsigned int a, BoolVar x, int i, int n) + )(Space &home, unsigned int a, BoolVar x, int i, int n) + BoolBranchCommit + +Branch commit function type for Boolean variables. + +The function must post a constraint on the variable x which corresponds to the alternative a. The integer i refers to the variable's position in the original array passed to the brancher. The value n is the value computed by the corresponding branch value function. + + + + + + void(* + typedef void(* Gecode::IntVarValPrint) (const Space &home, const BrancherHandle &bh, unsigned int a, IntVar x, int i, const int &n, std::ostream &o) + )(const Space &home, const BrancherHandle &bh, unsigned int a, IntVar x, int i, const int &n, std::ostream &o) + IntVarValPrint + +Function type for printing branching alternatives for integer variables. + + + + + + + + void(* + typedef void(* Gecode::BoolVarValPrint) (const Space &home, const BrancherHandle &bh, unsigned int a, BoolVar x, int i, const int &n, std::ostream &o) + )(const Space &home, const BrancherHandle &bh, unsigned int a, BoolVar x, int i, const int &n, std::ostream &o) + BoolVarValPrint + +Function type for printing branching alternatives for Boolean variables. + + + + + + + + double(* + typedef double(* Gecode::BranchTbl) (const Space &home, double w, double b) + )(const Space &home, double w, double b) + BranchTbl + +Tie-break limit function. + +Here the value w is the worst and is the best merit value found. The function must return the merit value that is considered the limit for breaking ties. + + + + + + int + typedef int Gecode::ModEvent + + ModEvent + +Type for modification events. + + + + + + + + int + typedef int Gecode::PropCond + + PropCond + +Type for propagation conditions. + + + + + + + + int + typedef int Gecode::ModEventDelta + + ModEventDelta + +Modification event deltas. + +Modification event deltas are used by propagators. A propagator stores a modification event for each variable type. They can be accessed through a variable or a view from a given propagator. They can be constructed from a given modevent by a variable or view. + + + + + + IntMinimizeSpace + typedef IntMinimizeSpace Gecode::MinimizeSpace + + MinimizeSpace + +Class for minimizing integer cost. + +DeprecatedUse IntMinimizeSpace instead. + + + + + + IntMaximizeSpace + typedef IntMaximizeSpace Gecode::MaximizeSpace + + MaximizeSpace + +Class for maximizing integer cost. + +DeprecatedUse IntMaximizeSpace instead. + + + + + + bool(* + typedef bool(* Gecode::SetBranchFilter) (const Space &home, SetVar x, int i) + )(const Space &home, SetVar x, int i) + SetBranchFilter + +Branch filter function type for set variables. + +The variable x is considered for selection and i refers to the variable's position in the original array passed to the brancher. + + + + + + double(* + typedef double(* Gecode::SetBranchMerit) (const Space &home, SetVar x, int i) + )(const Space &home, SetVar x, int i) + SetBranchMerit + +Branch merit function type for set variables. + +The function must return a merit value for the variable x. The value i refers to the variable's position in the original array passed to the brancher. + + + + + + int(* + typedef int(* Gecode::SetBranchVal) (const Space &home, SetVar x, int i) + )(const Space &home, SetVar x, int i) + SetBranchVal + +Branch value function type for set variables. + +Returns a value for the variable x that is to be used in the corresponding branch commit function. The integer i refers to the variable's position in the original array passed to the brancher. + + + + + + void(* + typedef void(* Gecode::SetBranchCommit) (Space &home, unsigned int a, SetVar x, int i, int n) + )(Space &home, unsigned int a, SetVar x, int i, int n) + SetBranchCommit + +Branch commit function type for set variables. + +The function must post a constraint on the variable x which corresponds to the alternative a. The integer i refers to the variable's position in the original array passed to the brancher. The value n is the value computed by the corresponding branch value function. + + + + + + void(* + typedef void(* Gecode::SetVarValPrint) (const Space &home, const BrancherHandle &bh, unsigned int a, SetVar x, int i, const int &n, std::ostream &o) + )(const Space &home, const BrancherHandle &bh, unsigned int a, SetVar x, int i, const int &n, std::ostream &o) + SetVarValPrint + +Function type for printing branching alternatives for set variables. + + + + + + + + void(* + typedef void(* Gecode::VoidFunction) (void) + )(void) + VoidFunction + +Base type for any function pointer. + + + + + + + + + + const ModEvent + const ModEvent Gecode::ME_GEN_FAILED + + ME_GEN_FAILED + = -1 + +Generic modification event: failed variable. + + + + + + + + const ModEvent + const ModEvent Gecode::ME_GEN_NONE + + ME_GEN_NONE + = 0 + +Generic modification event: no modification. + + + + + + + + const ModEvent + const ModEvent Gecode::ME_GEN_ASSIGNED + + ME_GEN_ASSIGNED + = 1 + +Generic modification event: variable is assigned a value. + + + + + + + + const PropCond + const PropCond Gecode::PC_GEN_NONE + + PC_GEN_NONE + = -1 + +Propagation condition to be ignored (convenience) + + + + + + + + const PropCond + const PropCond Gecode::PC_GEN_ASSIGNED + + PC_GEN_ASSIGNED + = 0 + +Propagation condition for an assigned variable. + + + + + + + + GECODE_SUPPORT_EXPORT Heap + GECODE_SUPPORT_EXPORT Heap Gecode::heap + + heap + +The single global heap. + + + + + + + + + + FloatAssign + FloatAssign Gecode::FLOAT_ASSIGN_MIN + (void) + FLOAT_ASSIGN_MIN + + void + + +Select median value of the lower part. + + + + + + + + FloatAssign + FloatAssign Gecode::FLOAT_ASSIGN_MAX + (void) + FLOAT_ASSIGN_MAX + + void + + +Select median value of the upper part. + + + + + + + + FloatAssign + FloatAssign Gecode::FLOAT_ASSIGN_RND + (Rnd r) + FLOAT_ASSIGN_RND + + Rnd + r + + +Select median value of a randomly chosen part. + + + + + + + + FloatAssign + FloatAssign Gecode::FLOAT_ASSIGN + (FloatBranchVal v, FloatBranchCommit c) + FLOAT_ASSIGN + + FloatBranchVal + v + + + FloatBranchCommit + c + NULL + + + + +Select value as defined by the value function v and commit function c The default commit function posts the constraint that the float variable x must be less or equal than the value n. + + + + + + forceinline Archive & + forceinline Archive& Gecode::operator<< + (Archive &e, FloatNumBranch nl) + operator<< + + Archive & + e + + + FloatNumBranch + nl + + + + + + + + + + + forceinline Archive & + forceinline Archive& Gecode::operator>> + (Archive &e, FloatNumBranch &nl) + operator>> + + Archive & + e + + + FloatNumBranch & + nl + + + + + + + + + + + FloatValBranch + FloatValBranch Gecode::FLOAT_VAL_SPLIT_MIN + (void) + FLOAT_VAL_SPLIT_MIN + + void + + +Select values not greater than mean of smallest and largest value. + + + + + + + + FloatValBranch + FloatValBranch Gecode::FLOAT_VAL_SPLIT_MAX + (void) + FLOAT_VAL_SPLIT_MAX + + void + + +Select values greater than mean of smallest and largest value. + + + + + + + + FloatValBranch + FloatValBranch Gecode::FLOAT_VAL_SPLIT_RND + (Rnd r) + FLOAT_VAL_SPLIT_RND + + Rnd + r + + +Select values randomly which are not greater or not smaller than mean of largest and smallest value. + + + + + + + + FloatValBranch + FloatValBranch Gecode::FLOAT_VAL + (FloatBranchVal v, FloatBranchCommit c) + FLOAT_VAL + + FloatBranchVal + v + + + FloatBranchCommit + c + NULL + + + + +Select value as defined by the value function v and commit function c The default commit function posts the constraint that the float variable x must be less or equal than the value n for the first alternative and that x must be greater or equal than n otherwise. + + + + + + FloatVarBranch + FloatVarBranch Gecode::FLOAT_VAR_NONE + (void) + FLOAT_VAR_NONE + + void + + +Select first unassigned variable. + + + + + + + + FloatVarBranch + FloatVarBranch Gecode::FLOAT_VAR_MERIT_MIN + (FloatBranchMerit bm, BranchTbl tbl=NULL) + FLOAT_VAR_MERIT_MIN + + FloatBranchMerit + bm + + + BranchTbl + tbl + + +Select variable with least merit according to branch merit function bm. + + + + + + + + FloatVarBranch + FloatVarBranch Gecode::FLOAT_VAR_MERIT_MAX + (FloatBranchMerit bm, BranchTbl tbl=NULL) + FLOAT_VAR_MERIT_MAX + + FloatBranchMerit + bm + + + BranchTbl + tbl + + +Select variable with highest merit according to branch merit function bm. + + + + + + + + FloatVarBranch + FloatVarBranch Gecode::FLOAT_VAR_RND + (Rnd r) + FLOAT_VAR_RND + + Rnd + r + + +Select random variable (uniform distribution, for tie breaking) + + + + + + + + FloatVarBranch + FloatVarBranch Gecode::FLOAT_VAR_DEGREE_MIN + (BranchTbl tbl=NULL) + FLOAT_VAR_DEGREE_MIN + + BranchTbl + tbl + + +Select variable with smallest degree. + + + + + + + + FloatVarBranch + FloatVarBranch Gecode::FLOAT_VAR_DEGREE_MAX + (BranchTbl tbl=NULL) + FLOAT_VAR_DEGREE_MAX + + BranchTbl + tbl + + +Select variable with largest degree. + + + + + + + + FloatVarBranch + FloatVarBranch Gecode::FLOAT_VAR_AFC_MIN + (double d=1.0, BranchTbl tbl=NULL) + FLOAT_VAR_AFC_MIN + + double + d + + + BranchTbl + tbl + + +Select variable with smallest accumulated failure count with decay factor d. + + + + + + + + FloatVarBranch + FloatVarBranch Gecode::FLOAT_VAR_AFC_MIN + (FloatAFC a, BranchTbl tbl=NULL) + FLOAT_VAR_AFC_MIN + + FloatAFC + a + + + BranchTbl + tbl + + +Select variable with smallest accumulated failure count. + + + + + + + + FloatVarBranch + FloatVarBranch Gecode::FLOAT_VAR_AFC_MAX + (double d=1.0, BranchTbl tbl=NULL) + FLOAT_VAR_AFC_MAX + + double + d + + + BranchTbl + tbl + + +Select variable with largest accumulated failure count with decay factor d. + + + + + + + + FloatVarBranch + FloatVarBranch Gecode::FLOAT_VAR_AFC_MAX + (FloatAFC a, BranchTbl tbl=NULL) + FLOAT_VAR_AFC_MAX + + FloatAFC + a + + + BranchTbl + tbl + + +Select variable with largest accumulated failure count. + + + + + + + + FloatVarBranch + FloatVarBranch Gecode::FLOAT_VAR_ACTIVITY_MIN + (double d=1.0, BranchTbl tbl=NULL) + FLOAT_VAR_ACTIVITY_MIN + + double + d + + + BranchTbl + tbl + + +Select variable with lowest activity with decay factor d. + + + + + + + + FloatVarBranch + FloatVarBranch Gecode::FLOAT_VAR_ACTIVITY_MIN + (FloatActivity a, BranchTbl tbl=NULL) + FLOAT_VAR_ACTIVITY_MIN + + FloatActivity + a + + + BranchTbl + tbl + + +Select variable with lowest activity. + + + + + + + + FloatVarBranch + FloatVarBranch Gecode::FLOAT_VAR_ACTIVITY_MAX + (double d=1.0, BranchTbl tbl=NULL) + FLOAT_VAR_ACTIVITY_MAX + + double + d + + + BranchTbl + tbl + + +Select variable with highest activity with decay factor d. + + + + + + + + FloatVarBranch + FloatVarBranch Gecode::FLOAT_VAR_ACTIVITY_MAX + (FloatActivity a, BranchTbl tbl=NULL) + FLOAT_VAR_ACTIVITY_MAX + + FloatActivity + a + + + BranchTbl + tbl + + +Select variable with highest activity. + + + + + + + + FloatVarBranch + FloatVarBranch Gecode::FLOAT_VAR_MIN_MIN + (BranchTbl tbl=NULL) + FLOAT_VAR_MIN_MIN + + BranchTbl + tbl + + +Select variable with smallest min. + + + + + + + + FloatVarBranch + FloatVarBranch Gecode::FLOAT_VAR_MIN_MAX + (BranchTbl tbl=NULL) + FLOAT_VAR_MIN_MAX + + BranchTbl + tbl + + +Select variable with largest min. + + + + + + + + FloatVarBranch + FloatVarBranch Gecode::FLOAT_VAR_MAX_MIN + (BranchTbl tbl=NULL) + FLOAT_VAR_MAX_MIN + + BranchTbl + tbl + + +Select variable with smallest max. + + + + + + + + FloatVarBranch + FloatVarBranch Gecode::FLOAT_VAR_MAX_MAX + (BranchTbl tbl=NULL) + FLOAT_VAR_MAX_MAX + + BranchTbl + tbl + + +Select variable with largest max. + + + + + + + + FloatVarBranch + FloatVarBranch Gecode::FLOAT_VAR_SIZE_MIN + (BranchTbl tbl=NULL) + FLOAT_VAR_SIZE_MIN + + BranchTbl + tbl + + +Select variable with smallest domain size. + + + + + + + + FloatVarBranch + FloatVarBranch Gecode::FLOAT_VAR_SIZE_MAX + (BranchTbl tbl=NULL) + FLOAT_VAR_SIZE_MAX + + BranchTbl + tbl + + +Select variable with largest domain size. + + + + + + + + FloatVarBranch + FloatVarBranch Gecode::FLOAT_VAR_DEGREE_SIZE_MIN + (BranchTbl tbl=NULL) + FLOAT_VAR_DEGREE_SIZE_MIN + + BranchTbl + tbl + + +Select variable with smallest degree divided by domain size. + + + + + + + + FloatVarBranch + FloatVarBranch Gecode::FLOAT_VAR_DEGREE_SIZE_MAX + (BranchTbl tbl=NULL) + FLOAT_VAR_DEGREE_SIZE_MAX + + BranchTbl + tbl + + +Select variable with largest degree divided by domain size. + + + + + + + + FloatVarBranch + FloatVarBranch Gecode::FLOAT_VAR_AFC_SIZE_MIN + (double d=1.0, BranchTbl tbl=NULL) + FLOAT_VAR_AFC_SIZE_MIN + + double + d + + + BranchTbl + tbl + + +Select variable with smalllest accumulated failure count divided by domain size with decay factor d. + + + + + + + + FloatVarBranch + FloatVarBranch Gecode::FLOAT_VAR_AFC_SIZE_MIN + (FloatAFC a, BranchTbl tbl=NULL) + FLOAT_VAR_AFC_SIZE_MIN + + FloatAFC + a + + + BranchTbl + tbl + + +Select variable with smallest accumulated failure count divided by domain size. + + + + + + + + FloatVarBranch + FloatVarBranch Gecode::FLOAT_VAR_AFC_SIZE_MAX + (double d=1.0, BranchTbl tbl=NULL) + FLOAT_VAR_AFC_SIZE_MAX + + double + d + + + BranchTbl + tbl + + +Select variable with largest accumulated failure count divided by domain size with decay factor d. + + + + + + + + FloatVarBranch + FloatVarBranch Gecode::FLOAT_VAR_AFC_SIZE_MAX + (FloatAFC a, BranchTbl tbl=NULL) + FLOAT_VAR_AFC_SIZE_MAX + + FloatAFC + a + + + BranchTbl + tbl + + +Select variable with largest accumulated failure count divided by domain size. + + + + + + + + FloatVarBranch + FloatVarBranch Gecode::FLOAT_VAR_ACTIVITY_SIZE_MIN + (double d=1.0, BranchTbl tbl=NULL) + FLOAT_VAR_ACTIVITY_SIZE_MIN + + double + d + + + BranchTbl + tbl + + +Select variable with smallest activity divided by domain size with decay factor d. + + + + + + + + FloatVarBranch + FloatVarBranch Gecode::FLOAT_VAR_ACTIVITY_SIZE_MIN + (FloatActivity a, BranchTbl tbl=NULL) + FLOAT_VAR_ACTIVITY_SIZE_MIN + + FloatActivity + a + + + BranchTbl + tbl + + +Select variable with smallest activity divided by domain size. + + + + + + + + FloatVarBranch + FloatVarBranch Gecode::FLOAT_VAR_ACTIVITY_SIZE_MAX + (double d=1.0, BranchTbl tbl=NULL) + FLOAT_VAR_ACTIVITY_SIZE_MAX + + double + d + + + BranchTbl + tbl + + +Select variable with largest activity divided by domain size with decay factor d. + + + + + + + + FloatVarBranch + FloatVarBranch Gecode::FLOAT_VAR_ACTIVITY_SIZE_MAX + (FloatActivity a, BranchTbl tbl=NULL) + FLOAT_VAR_ACTIVITY_SIZE_MAX + + FloatActivity + a + + + BranchTbl + tbl + + +Select variable with largest activity divided by domain size. + + + + + + + + forceinline FloatNum + FloatNum Gecode::pi_half_lower + (void) + pi_half_lower + + void + + +Return lower bound of $\pi/2$. + + + + + + + + forceinline FloatNum + FloatNum Gecode::pi_half_upper + (void) + pi_half_upper + + void + + +Return upper bound of $\pi/2$. + + + + + + + + forceinline FloatNum + FloatNum Gecode::pi_lower + (void) + pi_lower + + void + + +Return lower bound of $\pi$. + + + + + + + + forceinline FloatNum + FloatNum Gecode::pi_upper + (void) + pi_upper + + void + + +Return upper bound of $\pi$. + + + + + + + + forceinline FloatNum + FloatNum Gecode::pi_twice_lower + (void) + pi_twice_lower + + void + + +Return lower bound of $2\pi$. + + + + + + + + forceinline FloatNum + FloatNum Gecode::pi_twice_upper + (void) + pi_twice_upper + + void + + +Return upper bound of $2\pi$. + + + + + + + + forceinline FloatVal + forceinline FloatVal Gecode::operator+ + (const FloatVal &x) + operator+ + + const FloatVal & + x + + + + + + + + + + + forceinline FloatVal + forceinline FloatVal Gecode::operator- + (const FloatVal &x) + operator- + + const FloatVal & + x + + + + + + + + + + + forceinline FloatVal + forceinline FloatVal Gecode::operator+ + (const FloatVal &x, const FloatVal &y) + operator+ + + const FloatVal & + x + + + const FloatVal & + y + + + + + + + + + + + forceinline FloatVal + forceinline FloatVal Gecode::operator+ + (const FloatVal &x, const FloatNum &y) + operator+ + + const FloatVal & + x + + + const FloatNum & + y + + + + + + + + + + + forceinline FloatVal + forceinline FloatVal Gecode::operator+ + (const FloatNum &x, const FloatVal &y) + operator+ + + const FloatNum & + x + + + const FloatVal & + y + + + + + + + + + + + forceinline FloatVal + forceinline FloatVal Gecode::operator- + (const FloatVal &x, const FloatVal &y) + operator- + + const FloatVal & + x + + + const FloatVal & + y + + + + + + + + + + + forceinline FloatVal + forceinline FloatVal Gecode::operator- + (const FloatVal &x, const FloatNum &y) + operator- + + const FloatVal & + x + + + const FloatNum & + y + + + + + + + + + + + forceinline FloatVal + forceinline FloatVal Gecode::operator- + (const FloatNum &x, const FloatVal &y) + operator- + + const FloatNum & + x + + + const FloatVal & + y + + + + + + + + + + + forceinline FloatVal + forceinline FloatVal Gecode::operator* + (const FloatVal &x, const FloatVal &y) + operator* + + const FloatVal & + x + + + const FloatVal & + y + + + + + + + + + + + forceinline FloatVal + forceinline FloatVal Gecode::operator* + (const FloatVal &x, const FloatNum &y) + operator* + + const FloatVal & + x + + + const FloatNum & + y + + + + + + + + + + + forceinline FloatVal + forceinline FloatVal Gecode::operator* + (const FloatNum &x, const FloatVal &y) + operator* + + const FloatNum & + x + + + const FloatVal & + y + + + + + + + + + + + forceinline FloatVal + forceinline FloatVal Gecode::operator/ + (const FloatVal &x, const FloatVal &y) + operator/ + + const FloatVal & + x + + + const FloatVal & + y + + + + + + + + + + + forceinline FloatVal + forceinline FloatVal Gecode::operator/ + (const FloatVal &x, const FloatNum &y) + operator/ + + const FloatVal & + x + + + const FloatNum & + y + + + + + + + + + + + forceinline FloatVal + forceinline FloatVal Gecode::operator/ + (const FloatNum &x, const FloatVal &y) + operator/ + + const FloatNum & + x + + + const FloatVal & + y + + + + + + + + + + + forceinline bool + forceinline bool Gecode::operator< + (const FloatVal &x, const FloatVal &y) + operator< + + const FloatVal & + x + + + const FloatVal & + y + + + + + + + + + + + forceinline bool + forceinline bool Gecode::operator< + (const FloatVal &x, const FloatNum &y) + operator< + + const FloatVal & + x + + + const FloatNum & + y + + + + + + + + + + + forceinline bool + forceinline bool Gecode::operator<= + (const FloatVal &x, const FloatVal &y) + operator<= + + const FloatVal & + x + + + const FloatVal & + y + + + + + + + + + + + forceinline bool + forceinline bool Gecode::operator<= + (const FloatVal &x, const FloatNum &y) + operator<= + + const FloatVal & + x + + + const FloatNum & + y + + + + + + + + + + + forceinline bool + forceinline bool Gecode::operator> + (const FloatVal &x, const FloatVal &y) + operator> + + const FloatVal & + x + + + const FloatVal & + y + + + + + + + + + + + forceinline bool + forceinline bool Gecode::operator> + (const FloatVal &x, const FloatNum &y) + operator> + + const FloatVal & + x + + + const FloatNum & + y + + + + + + + + + + + forceinline bool + forceinline bool Gecode::operator>= + (const FloatVal &x, const FloatVal &y) + operator>= + + const FloatVal & + x + + + const FloatVal & + y + + + + + + + + + + + forceinline bool + forceinline bool Gecode::operator>= + (const FloatVal &x, const FloatNum &y) + operator>= + + const FloatVal & + x + + + const FloatNum & + y + + + + + + + + + + + forceinline bool + forceinline bool Gecode::operator== + (const FloatVal &x, const FloatVal &y) + operator== + + const FloatVal & + x + + + const FloatVal & + y + + + + + + + + + + + forceinline bool + forceinline bool Gecode::operator== + (const FloatVal &x, const FloatNum &y) + operator== + + const FloatVal & + x + + + const FloatNum & + y + + + + + + + + + + + forceinline bool + forceinline bool Gecode::operator!= + (const FloatVal &x, const FloatVal &y) + operator!= + + const FloatVal & + x + + + const FloatVal & + y + + + + + + + + + + + forceinline bool + forceinline bool Gecode::operator!= + (const FloatVal &x, const FloatNum &y) + operator!= + + const FloatVal & + x + + + const FloatNum & + y + + + + + + + + + + + forceinline bool + forceinline bool Gecode::operator< + (const FloatNum &x, const FloatVal &y) + operator< + + const FloatNum & + x + + + const FloatVal & + y + + + + + + + + + + + forceinline bool + forceinline bool Gecode::operator<= + (const FloatNum &x, const FloatVal &y) + operator<= + + const FloatNum & + x + + + const FloatVal & + y + + + + + + + + + + + forceinline bool + forceinline bool Gecode::operator> + (const FloatNum &x, const FloatVal &y) + operator> + + const FloatNum & + x + + + const FloatVal & + y + + + + + + + + + + + forceinline bool + forceinline bool Gecode::operator>= + (const FloatNum &x, const FloatVal &y) + operator>= + + const FloatNum & + x + + + const FloatVal & + y + + + + + + + + + + + forceinline bool + forceinline bool Gecode::operator== + (const FloatNum &x, const FloatVal &y) + operator== + + const FloatNum & + x + + + const FloatVal & + y + + + + + + + + + + + forceinline bool + forceinline bool Gecode::operator!= + (const FloatNum &x, const FloatVal &y) + operator!= + + const FloatNum & + x + + + const FloatVal & + y + + + + + + + + + + + + + class Char + + + class Traits + + + std::basic_ostream< Char, Traits > & + std::basic_ostream<Char,Traits>& Gecode::operator<< + (std::basic_ostream< Char, Traits > &os, const FloatVal &x) + operator<< + + std::basic_ostream< Char, Traits > & + os + + + const FloatVal & + x + + + + + + + + + + + forceinline FloatVal + forceinline FloatVal Gecode::abs + (const FloatVal &x) + abs + + const FloatVal & + x + + + + + + + + + + + forceinline FloatVal + forceinline FloatVal Gecode::sqrt + (const FloatVal &x) + sqrt + + const FloatVal & + x + + + + + + + + + + + forceinline FloatVal + forceinline FloatVal Gecode::sqr + (const FloatVal &x) + sqr + + const FloatVal & + x + + + + + + + + + + + forceinline FloatVal + forceinline FloatVal Gecode::pow + (const FloatVal &x, int n) + pow + + const FloatVal & + x + + + int + n + + + + + + + + + + + forceinline FloatVal + forceinline FloatVal Gecode::nroot + (const FloatVal &x, int n) + nroot + + const FloatVal & + x + + + int + n + + + + + + + + + + + forceinline FloatVal + forceinline FloatVal Gecode::max + (const FloatVal &x, const FloatVal &y) + max + + const FloatVal & + x + + + const FloatVal & + y + + + + + + + + + + + forceinline FloatVal + forceinline FloatVal Gecode::max + (const FloatVal &x, const FloatNum &y) + max + + const FloatVal & + x + + + const FloatNum & + y + + + + + + + + + + + forceinline FloatVal + forceinline FloatVal Gecode::max + (const FloatNum &x, const FloatVal &y) + max + + const FloatNum & + x + + + const FloatVal & + y + + + + + + + + + + + forceinline FloatVal + forceinline FloatVal Gecode::min + (const FloatVal &x, const FloatVal &y) + min + + const FloatVal & + x + + + const FloatVal & + y + + + + + + + + + + + forceinline FloatVal + forceinline FloatVal Gecode::min + (const FloatVal &x, const FloatNum &y) + min + + const FloatVal & + x + + + const FloatNum & + y + + + + + + + + + + + forceinline FloatVal + forceinline FloatVal Gecode::min + (const FloatNum &x, const FloatVal &y) + min + + const FloatNum & + x + + + const FloatVal & + y + + + + + + + + + + + + + class Char + + + class Traits + + + std::basic_ostream< Char, Traits > & + std::basic_ostream<Char,Traits>& Gecode::operator<< + (std::basic_ostream< Char, Traits > &os, const FloatVar &x) + operator<< + + std::basic_ostream< Char, Traits > & + os + + + const FloatVar & + x + + + + + + + + + + + GECODE_FLOAT_EXPORT void + GECODE_FLOAT_EXPORT void Gecode::dom + (Home home, FloatVar x, FloatVal n) + dom + + Home + home + + + FloatVar + x + + + FloatVal + n + + +Propagates $x=n$. + + + + + + + + GECODE_FLOAT_EXPORT void + GECODE_FLOAT_EXPORT void Gecode::dom + (Home home, const FloatVarArgs &x, FloatVal n) + dom + + Home + home + + + const FloatVarArgs & + x + + + FloatVal + n + + +Propagates $ x_i=n$ for all $0\leq i<|x|$. + + + + + + + + GECODE_FLOAT_EXPORT void + GECODE_FLOAT_EXPORT void Gecode::dom + (Home home, FloatVar x, FloatNum l, FloatNum m) + dom + + Home + home + + + FloatVar + x + + + FloatNum + l + + + FloatNum + m + + +Propagates $ l\leq x\leq u$. + + + + + + + + GECODE_FLOAT_EXPORT void + GECODE_FLOAT_EXPORT void Gecode::dom + (Home home, const FloatVarArgs &x, FloatNum l, FloatNum u) + dom + + Home + home + + + const FloatVarArgs & + x + + + FloatNum + l + + + FloatNum + u + + +Propagates $ l\leq x_i\leq u$ for all $0\leq i<|x|$. + + + + + + + + GECODE_FLOAT_EXPORT void + GECODE_FLOAT_EXPORT void Gecode::dom + (Home home, FloatVar x, FloatVal n, Reify r) + dom + + Home + home + + + FloatVar + x + + + FloatVal + n + + + Reify + r + + +Post domain consistent propagator for $ (x=n) \equiv r$. + + + + + + + + GECODE_FLOAT_EXPORT void + GECODE_FLOAT_EXPORT void Gecode::dom + (Home home, FloatVar x, FloatNum l, FloatNum u, Reify r) + dom + + Home + home + + + FloatVar + x + + + FloatNum + l + + + FloatNum + u + + + Reify + r + + +Post domain consistent propagator for $ (l\leq x \leq u) \equiv r$. + + + + + + + + GECODE_FLOAT_EXPORT void + GECODE_FLOAT_EXPORT void Gecode::dom + (Home home, FloatVar x, FloatVar d) + dom + + Home + home + + + FloatVar + x + + + FloatVar + d + + +Constrain domain of x according to domain of d. + + + + + + + + GECODE_FLOAT_EXPORT void + GECODE_FLOAT_EXPORT void Gecode::dom + (Home home, const FloatVarArgs &x, const FloatVarArgs &d) + dom + + Home + home + + + const FloatVarArgs & + x + + + const FloatVarArgs & + d + + +Constrain domain of $ x_i $ according to domain of $ d_i $ for all $0\leq i<|x|$. + + + + + + + + GECODE_FLOAT_EXPORT void + GECODE_FLOAT_EXPORT void Gecode::rel + (Home home, FloatVar x0, FloatRelType frt, FloatVar x1) + rel + + Home + home + + + FloatVar + x0 + + + FloatRelType + frt + + + FloatVar + x1 + + +Post propagator for $ x_0 \sim_{frt} x_1$. + + + + + + + + GECODE_FLOAT_EXPORT void + GECODE_FLOAT_EXPORT void Gecode::rel + (Home home, FloatVar x, FloatRelType frt, FloatVal c) + rel + + Home + home + + + FloatVar + x + + + FloatRelType + frt + + + FloatVal + c + + +Propagates $ x \sim_{frt} c$. + + + + + + + + GECODE_FLOAT_EXPORT void + GECODE_FLOAT_EXPORT void Gecode::rel + (Home home, FloatVar x, FloatRelType frt, FloatVal c, Reify r) + rel + + Home + home + + + FloatVar + x + + + FloatRelType + frt + + + FloatVal + c + + + Reify + r + + +Post propagator for $(x \sim_{frt} c)\equiv r$. + + + + + + + + GECODE_FLOAT_EXPORT void + GECODE_FLOAT_EXPORT void Gecode::rel + (Home home, FloatVar x0, FloatRelType frt, FloatVar x1, Reify r) + rel + + Home + home + + + FloatVar + x0 + + + FloatRelType + frt + + + FloatVar + x1 + + + Reify + r + + +Post propagator for $(x_0 \sim_{frt} x_1)\equiv r$. + + + + + + + + GECODE_FLOAT_EXPORT void + GECODE_FLOAT_EXPORT void Gecode::rel + (Home home, const FloatVarArgs &x, FloatRelType frt, FloatVal c) + rel + + Home + home + + + const FloatVarArgs & + x + + + FloatRelType + frt + + + FloatVal + c + + +Propagates $ x_i \sim_{frt} c $ for all $0\leq i<|x|$. + + + + + + + + GECODE_FLOAT_EXPORT void + GECODE_FLOAT_EXPORT void Gecode::rel + (Home home, const FloatVarArgs &x, FloatRelType frt, FloatVar y) + rel + + Home + home + + + const FloatVarArgs & + x + + + FloatRelType + frt + + + FloatVar + y + + +Propagates $ x_i \sim_{frt} y $ for all $0\leq i<|x|$. + + + + + + + + GECODE_FLOAT_EXPORT void + GECODE_FLOAT_EXPORT void Gecode::min + (Home home, FloatVar x0, FloatVar x1, FloatVar x2) + min + + Home + home + + + FloatVar + x0 + + + FloatVar + x1 + + + FloatVar + x2 + + +Post propagator for $ \min\{x_0,x_1\}=x_2$. + + + + + + + + GECODE_FLOAT_EXPORT void + GECODE_FLOAT_EXPORT void Gecode::min + (Home home, const FloatVarArgs &x, FloatVar y) + min + + Home + home + + + const FloatVarArgs & + x + + + FloatVar + y + + +Post propagator for $ \min x=y$ If x is empty, an exception of type Float::TooFewArguments is thrown. + + + + + + + + GECODE_FLOAT_EXPORT void + GECODE_FLOAT_EXPORT void Gecode::max + (Home home, FloatVar x0, FloatVar x1, FloatVar x2) + max + + Home + home + + + FloatVar + x0 + + + FloatVar + x1 + + + FloatVar + x2 + + +Post propagator for $ \max\{x_0,x_1\}=x_2$. + + + + + + + + GECODE_FLOAT_EXPORT void + GECODE_FLOAT_EXPORT void Gecode::max + (Home home, const FloatVarArgs &x, FloatVar y) + max + + Home + home + + + const FloatVarArgs & + x + + + FloatVar + y + + +Post propagator for $ \max x=y$ If x is empty, an exception of type Float::TooFewArguments is thrown. + + + + + + + + GECODE_FLOAT_EXPORT void + GECODE_FLOAT_EXPORT void Gecode::abs + (Home home, FloatVar x0, FloatVar x1) + abs + + Home + home + + + FloatVar + x0 + + + FloatVar + x1 + + +Post propagator for $ |x_0|=x_1$. + + + + + + + + GECODE_FLOAT_EXPORT void + GECODE_FLOAT_EXPORT void Gecode::mult + (Home home, FloatVar x0, FloatVar x1, FloatVar x2) + mult + + Home + home + + + FloatVar + x0 + + + FloatVar + x1 + + + FloatVar + x2 + + +Post propagator for $x_0\cdot x_1=x_2$. + + + + + + + + GECODE_FLOAT_EXPORT void + GECODE_FLOAT_EXPORT void Gecode::sqr + (Home home, FloatVar x0, FloatVar x1) + sqr + + Home + home + + + FloatVar + x0 + + + FloatVar + x1 + + +Post propagator for $x_0\cdot x_0=x_1$. + + + + + + + + GECODE_FLOAT_EXPORT void + GECODE_FLOAT_EXPORT void Gecode::sqrt + (Home home, FloatVar x0, FloatVar x1) + sqrt + + Home + home + + + FloatVar + x0 + + + FloatVar + x1 + + +Post propagator for $\sqrt{x_0}=x_1$. + + + + + + + + GECODE_FLOAT_EXPORT void + GECODE_FLOAT_EXPORT void Gecode::pow + (Home home, FloatVar x0, int n, FloatVar x1) + pow + + Home + home + + + FloatVar + x0 + + + int + n + + + FloatVar + x1 + + +Post propagator for ${x_0}^{n}=x_1$ for $n 0$. + + + + + + + + GECODE_FLOAT_EXPORT void + GECODE_FLOAT_EXPORT void Gecode::nroot + (Home home, FloatVar x0, int n, FloatVar x1) + nroot + + Home + home + + + FloatVar + x0 + + + int + n + + + FloatVar + x1 + + +Post propagator for ${x_0}^{1/n}=x_1$ for $n 0$. + + + + + + + + GECODE_FLOAT_EXPORT void + GECODE_FLOAT_EXPORT void Gecode::div + (Home home, FloatVar x0, FloatVar x1, FloatVar x2) + div + + Home + home + + + FloatVar + x0 + + + FloatVar + x1 + + + FloatVar + x2 + + +Post propagator for $x_0\ \mathrm{div}\ x_1=x_2$. + + + + + + + + GECODE_FLOAT_EXPORT void + GECODE_FLOAT_EXPORT void Gecode::linear + (Home home, const FloatVarArgs &x, FloatRelType frt, FloatNum c) + linear + + Home + home + + + const FloatVarArgs & + x + + + FloatRelType + frt + + + FloatNum + c + + +Post propagator for $\sum_{i=0}^{|x|-1}x_i\sim_{frt} c$. + + + + + + + + GECODE_FLOAT_EXPORT void + GECODE_FLOAT_EXPORT void Gecode::linear + (Home home, const FloatVarArgs &x, FloatRelType frt, FloatVar y) + linear + + Home + home + + + const FloatVarArgs & + x + + + FloatRelType + frt + + + FloatVar + y + + +Post propagator for $\sum_{i=0}^{|x|-1}x_i\sim_{frt} y$. + + + + + + + + GECODE_FLOAT_EXPORT void + GECODE_FLOAT_EXPORT void Gecode::linear + (Home home, const FloatVarArgs &x, FloatRelType frt, FloatNum c, Reify r) + linear + + Home + home + + + const FloatVarArgs & + x + + + FloatRelType + frt + + + FloatNum + c + + + Reify + r + + +Post propagator for $\left(\sum_{i=0}^{|x|-1}x_i\sim_{frt} c\right)\equiv r$. + + + + + + + + GECODE_FLOAT_EXPORT void + GECODE_FLOAT_EXPORT void Gecode::linear + (Home home, const FloatVarArgs &x, FloatRelType frt, FloatVar y, Reify r) + linear + + Home + home + + + const FloatVarArgs & + x + + + FloatRelType + frt + + + FloatVar + y + + + Reify + r + + +Post propagator for $\left(\sum_{i=0}^{|x|-1}x_i\sim_{frt} y\right)\equiv r$. + + + + + + + + GECODE_FLOAT_EXPORT void + GECODE_FLOAT_EXPORT void Gecode::linear + (Home home, const FloatValArgs &a, const FloatVarArgs &x, FloatRelType frt, FloatNum c) + linear + + Home + home + + + const FloatValArgs & + a + + + const FloatVarArgs & + x + + + FloatRelType + frt + + + FloatNum + c + + +Post propagator for $\sum_{i=0}^{|x|-1}a_i\cdot x_i\sim_{frt} c$. + +Throws an exception of type Float::ArgumentSizeMismatch, if a and x are of different size. + + + + + + GECODE_FLOAT_EXPORT void + GECODE_FLOAT_EXPORT void Gecode::linear + (Home home, const FloatValArgs &a, const FloatVarArgs &x, FloatRelType frt, FloatVar y) + linear + + Home + home + + + const FloatValArgs & + a + + + const FloatVarArgs & + x + + + FloatRelType + frt + + + FloatVar + y + + +Post propagator for $\sum_{i=0}^{|x|-1}a_i\cdot x_i\sim_{frt} y$. + +Throws an exception of type Float::ArgumentSizeMismatch, if a and x are of different size. + + + + + + GECODE_FLOAT_EXPORT void + GECODE_FLOAT_EXPORT void Gecode::linear + (Home home, const FloatValArgs &a, const FloatVarArgs &x, FloatRelType frt, FloatNum c, Reify r) + linear + + Home + home + + + const FloatValArgs & + a + + + const FloatVarArgs & + x + + + FloatRelType + frt + + + FloatNum + c + + + Reify + r + + +Post propagator for $\left(\sum_{i=0}^{|x|-1}a_i\cdot x_i\sim_{frt} c\right)\equiv r$. + +Throws an exception of type Float::ArgumentSizeMismatch, if a and x are of different size. + + + + + + GECODE_FLOAT_EXPORT void + GECODE_FLOAT_EXPORT void Gecode::linear + (Home home, const FloatValArgs &a, const FloatVarArgs &x, FloatRelType frt, FloatVar y, Reify r) + linear + + Home + home + + + const FloatValArgs & + a + + + const FloatVarArgs & + x + + + FloatRelType + frt + + + FloatVar + y + + + Reify + r + + +Post propagator for $\left(\sum_{i=0}^{|x|-1}a_i\cdot x_i\sim_{frt} y\right)\equiv r$. + +Throws an exception of type Float::ArgumentSizeMismatch, if a and x are of different size. + + + + + + GECODE_FLOAT_EXPORT void + GECODE_FLOAT_EXPORT void Gecode::channel + (Home home, FloatVar x0, IntVar x1) + channel + + Home + home + + + FloatVar + x0 + + + IntVar + x1 + + +Post propagator for channeling a float and an integer variable $ x_0 = x_1$. + + + + + + + + GECODE_FLOAT_EXPORT void + GECODE_FLOAT_EXPORT void Gecode::channel + (Home home, IntVar x0, FloatVar x1) + channel + + Home + home + + + IntVar + x0 + + + FloatVar + x1 + + +Post propagator for channeling a float and an integer variable $ x_0 = x_1$. + + + + + + + + GECODE_FLOAT_EXPORT void + GECODE_FLOAT_EXPORT void Gecode::wait + (Home home, FloatVar x, void(*c)(Space &home)) + wait + + Home + home + + + FloatVar + x + + + void(*)(Space &home) + c + + +Execute c when x becomes assigned. + + + + + + + + GECODE_FLOAT_EXPORT void + GECODE_FLOAT_EXPORT void Gecode::wait + (Home home, const FloatVarArgs &x, void(*c)(Space &home)) + wait + + Home + home + + + const FloatVarArgs & + x + + + void(*)(Space &home) + c + + +Execute c when all variables in x become assigned. + + + + + + + + GECODE_FLOAT_EXPORT BrancherHandle + GECODE_FLOAT_EXPORT BrancherHandle Gecode::branch + (Home home, const FloatVarArgs &x, FloatVarBranch vars, FloatValBranch vals, FloatBranchFilter bf=NULL, FloatVarValPrint vvp=NULL) + branch + + Home + home + + + const FloatVarArgs & + x + + + FloatVarBranch + vars + + + FloatValBranch + vals + + + FloatBranchFilter + bf + NULL + + + FloatVarValPrint + vvp + NULL + + +Branch over x with variable selection vars and value selection vals. + + + + + + + + GECODE_FLOAT_EXPORT BrancherHandle + GECODE_FLOAT_EXPORT BrancherHandle Gecode::branch + (Home home, const FloatVarArgs &x, TieBreak< FloatVarBranch > vars, FloatValBranch vals, FloatBranchFilter bf=NULL, FloatVarValPrint vvp=NULL) + branch + + Home + home + + + const FloatVarArgs & + x + + + TieBreak< FloatVarBranch > + vars + + + FloatValBranch + vals + + + FloatBranchFilter + bf + NULL + + + FloatVarValPrint + vvp + NULL + + +Branch over x with tie-breaking variable selection vars and value selection vals. + + + + + + + + GECODE_FLOAT_EXPORT BrancherHandle + GECODE_FLOAT_EXPORT BrancherHandle Gecode::branch + (Home home, FloatVar x, FloatValBranch vals, FloatVarValPrint vvp=NULL) + branch + + Home + home + + + FloatVar + x + + + FloatValBranch + vals + + + FloatVarValPrint + vvp + NULL + + +Branch over x with value selection vals. + + + + + + + + GECODE_FLOAT_EXPORT BrancherHandle + GECODE_FLOAT_EXPORT BrancherHandle Gecode::assign + (Home home, const FloatVarArgs &x, FloatAssign vals, FloatBranchFilter fbf=NULL, FloatVarValPrint vvp=NULL) + assign + + Home + home + + + const FloatVarArgs & + x + + + FloatAssign + vals + + + FloatBranchFilter + fbf + NULL + + + FloatVarValPrint + vvp + NULL + + +Assign all x with value selection vals. + + + + + + + + GECODE_FLOAT_EXPORT BrancherHandle + GECODE_FLOAT_EXPORT BrancherHandle Gecode::assign + (Home home, FloatVar x, FloatAssign vals, FloatVarValPrint vvp=NULL) + assign + + Home + home + + + FloatVar + x + + + FloatAssign + vals + + + FloatVarValPrint + vvp + NULL + + +Assign x with value selection vals. + + + + + + + + IntAssign + IntAssign Gecode::INT_ASSIGN_MIN + (void) + INT_ASSIGN_MIN + + void + + +Select smallest value. + + + + + + + + IntAssign + IntAssign Gecode::INT_ASSIGN_MED + (void) + INT_ASSIGN_MED + + void + + +Select greatest value not greater than the median. + + + + + + + + IntAssign + IntAssign Gecode::INT_ASSIGN_MAX + (void) + INT_ASSIGN_MAX + + void + + +Select largest value. + + + + + + + + IntAssign + IntAssign Gecode::INT_ASSIGN_RND + (Rnd r) + INT_ASSIGN_RND + + Rnd + r + + +Select random value. + + + + + + + + IntAssign + IntAssign Gecode::INT_ASSIGN + (IntBranchVal v, IntBranchCommit c=NULL) + INT_ASSIGN + + IntBranchVal + v + + + IntBranchCommit + c + NULL + + +Select value as defined by the value function v and commit function c. + +Uses a commit function as default that posts the constraint that a variable x must be equal to the value n. + + + + + + IntAssign + IntAssign Gecode::INT_ASSIGN + (BoolBranchVal v, BoolBranchCommit c=NULL) + INT_ASSIGN + + BoolBranchVal + v + + + BoolBranchCommit + c + NULL + + +Select value as defined by the value function v and commit function c. + +Uses a commit function as default that posts the constraint that a variable x must be equal to the value n. + + + + + + IntValBranch + IntValBranch Gecode::INT_VAL_MIN + (void) + INT_VAL_MIN + + void + + +Select smallest value. + + + + + + + + IntValBranch + IntValBranch Gecode::INT_VAL_MED + (void) + INT_VAL_MED + + void + + +Select greatest value not greater than the median. + + + + + + + + IntValBranch + IntValBranch Gecode::INT_VAL_MAX + (void) + INT_VAL_MAX + + void + + +Select largest value. + + + + + + + + IntValBranch + IntValBranch Gecode::INT_VAL_RND + (Rnd r) + INT_VAL_RND + + Rnd + r + + +Select random value. + + + + + + + + IntValBranch + IntValBranch Gecode::INT_VAL_SPLIT_MIN + (void) + INT_VAL_SPLIT_MIN + + void + + +Select values not greater than mean of smallest and largest value. + + + + + + + + IntValBranch + IntValBranch Gecode::INT_VAL_SPLIT_MAX + (void) + INT_VAL_SPLIT_MAX + + void + + +Select values greater than mean of smallest and largest value. + + + + + + + + IntValBranch + IntValBranch Gecode::INT_VAL_RANGE_MIN + (void) + INT_VAL_RANGE_MIN + + void + + +Select the smallest range of the variable domain if it has several ranges, otherwise select values not greater than mean of smallest and largest value. + + + + + + + + IntValBranch + IntValBranch Gecode::INT_VAL_RANGE_MAX + (void) + INT_VAL_RANGE_MAX + + void + + +Select the largest range of the variable domain if it has several ranges, otherwise select values greater than mean of smallest and largest value. + + + + + + + + IntValBranch + IntValBranch Gecode::INT_VAL + (IntBranchVal v, IntBranchCommit c=NULL) + INT_VAL + + IntBranchVal + v + + + IntBranchCommit + c + + +Select value as defined by the value function v and commit function c Uses a commit function as default that posts the constraints that a variable x must be equal to a value n for the first alternative and that x must be different from n for the second alternative. + + + + + + + + IntValBranch + IntValBranch Gecode::INT_VAL + (BoolBranchVal v, BoolBranchCommit c=NULL) + INT_VAL + + BoolBranchVal + v + + + BoolBranchCommit + c + + +Select value as defined by the value function v and commit function c Uses a commit function as default that posts the constraints that a variable x must be equal to a value n for the first alternative and that x must be different from n for the second alternative. + + + + + + + + IntValBranch + IntValBranch Gecode::INT_VALUES_MIN + (void) + INT_VALUES_MIN + + void + + +Try all values starting from smallest. + + + + + + + + IntValBranch + IntValBranch Gecode::INT_VALUES_MAX + (void) + INT_VALUES_MAX + + void + + +Try all values starting from largest. + + + + + + + + IntValBranch + IntValBranch Gecode::INT_VAL_NEAR_MIN + (IntSharedArray n) + INT_VAL_NEAR_MIN + + IntSharedArray + n + + +Try value nearest to a given value for a variable, in case of ties use the smaller value. + + + + + + + + IntValBranch + IntValBranch Gecode::INT_VAL_NEAR_MAX + (IntSharedArray n) + INT_VAL_NEAR_MAX + + IntSharedArray + n + + +Try value nearest to a given value for a variable, in case of ties use the larger value. + + + + + + + + IntValBranch + IntValBranch Gecode::INT_VAL_NEAR_INC + (IntSharedArray n) + INT_VAL_NEAR_INC + + IntSharedArray + n + + +Try value larger than a given value for a variable first. + + + + + + + + IntValBranch + IntValBranch Gecode::INT_VAL_NEAR_DEC + (IntSharedArray n) + INT_VAL_NEAR_DEC + + IntSharedArray + n + + +Try value smaller than a given value for a variable first. + + + + + + + + IntVarBranch + IntVarBranch Gecode::INT_VAR_NONE + (void) + INT_VAR_NONE + + void + + +Select first unassigned variable. + + + + + + + + IntVarBranch + IntVarBranch Gecode::INT_VAR_RND + (Rnd r) + INT_VAR_RND + + Rnd + r + + +Select random variable (uniform distribution, for tie breaking) + + + + + + + + IntVarBranch + IntVarBranch Gecode::INT_VAR_MERIT_MIN + (IntBranchMerit bm, BranchTbl tbl=NULL) + INT_VAR_MERIT_MIN + + IntBranchMerit + bm + + + BranchTbl + tbl + + +Select variable with least merit according to branch merit function bm. + + + + + + + + IntVarBranch + IntVarBranch Gecode::INT_VAR_MERIT_MIN + (BoolBranchMerit bm, BranchTbl tbl=NULL) + INT_VAR_MERIT_MIN + + BoolBranchMerit + bm + + + BranchTbl + tbl + + +Select variable with least merit according to branch merit function bm. + + + + + + + + IntVarBranch + IntVarBranch Gecode::INT_VAR_MERIT_MAX + (IntBranchMerit bm, BranchTbl tbl=NULL) + INT_VAR_MERIT_MAX + + IntBranchMerit + bm + + + BranchTbl + tbl + + +Select variable with highest merit according to branch merit function bm. + + + + + + + + IntVarBranch + IntVarBranch Gecode::INT_VAR_MERIT_MAX + (BoolBranchMerit bm, BranchTbl tbl=NULL) + INT_VAR_MERIT_MAX + + BoolBranchMerit + bm + + + BranchTbl + tbl + + +Select variable with highest merit according to branch merit function bm. + + + + + + + + IntVarBranch + IntVarBranch Gecode::INT_VAR_DEGREE_MIN + (BranchTbl tbl=NULL) + INT_VAR_DEGREE_MIN + + BranchTbl + tbl + + +Select variable with smallest degree. + + + + + + + + IntVarBranch + IntVarBranch Gecode::INT_VAR_DEGREE_MAX + (BranchTbl tbl=NULL) + INT_VAR_DEGREE_MAX + + BranchTbl + tbl + + +Select variable with largest degree. + + + + + + + + IntVarBranch + IntVarBranch Gecode::INT_VAR_AFC_MIN + (double d=1.0, BranchTbl tbl=NULL) + INT_VAR_AFC_MIN + + double + d + + + BranchTbl + tbl + + +Select variable with smallest accumulated failure count with decay factor d. + + + + + + + + IntVarBranch + IntVarBranch Gecode::INT_VAR_AFC_MIN + (IntAFC a, BranchTbl tbl=NULL) + INT_VAR_AFC_MIN + + IntAFC + a + + + BranchTbl + tbl + + +Select variable with smallest accumulated failure count. + + + + + + + + IntVarBranch + IntVarBranch Gecode::INT_VAR_AFC_MAX + (double d=1.0, BranchTbl tbl=NULL) + INT_VAR_AFC_MAX + + double + d + + + BranchTbl + tbl + + +Select variable with largest accumulated failure count with decay factor d. + + + + + + + + IntVarBranch + IntVarBranch Gecode::INT_VAR_AFC_MAX + (IntAFC a, BranchTbl tbl=NULL) + INT_VAR_AFC_MAX + + IntAFC + a + + + BranchTbl + tbl + + +Select variable with largest accumulated failure count. + + + + + + + + IntVarBranch + IntVarBranch Gecode::INT_VAR_ACTIVITY_MIN + (double d=1.0, BranchTbl tbl=NULL) + INT_VAR_ACTIVITY_MIN + + double + d + + + BranchTbl + tbl + + +Select variable with lowest activity with decay factor d. + + + + + + + + IntVarBranch + IntVarBranch Gecode::INT_VAR_ACTIVITY_MIN + (IntActivity a, BranchTbl tbl=NULL) + INT_VAR_ACTIVITY_MIN + + IntActivity + a + + + BranchTbl + tbl + + +Select variable with lowest activity. + + + + + + + + IntVarBranch + IntVarBranch Gecode::INT_VAR_ACTIVITY_MAX + (double d=1.0, BranchTbl tbl=NULL) + INT_VAR_ACTIVITY_MAX + + double + d + + + BranchTbl + tbl + + +Select variable with highest activity with decay factor d. + + + + + + + + IntVarBranch + IntVarBranch Gecode::INT_VAR_ACTIVITY_MAX + (IntActivity a, BranchTbl tbl=NULL) + INT_VAR_ACTIVITY_MAX + + IntActivity + a + + + BranchTbl + tbl + + +Select variable with highest activity. + + + + + + + + IntVarBranch + IntVarBranch Gecode::INT_VAR_MIN_MIN + (BranchTbl tbl=NULL) + INT_VAR_MIN_MIN + + BranchTbl + tbl + + +Select variable with smallest min. + + + + + + + + IntVarBranch + IntVarBranch Gecode::INT_VAR_MIN_MAX + (BranchTbl tbl=NULL) + INT_VAR_MIN_MAX + + BranchTbl + tbl + + +Select variable with largest min. + + + + + + + + IntVarBranch + IntVarBranch Gecode::INT_VAR_MAX_MIN + (BranchTbl tbl=NULL) + INT_VAR_MAX_MIN + + BranchTbl + tbl + + +Select variable with smallest max. + + + + + + + + IntVarBranch + IntVarBranch Gecode::INT_VAR_MAX_MAX + (BranchTbl tbl=NULL) + INT_VAR_MAX_MAX + + BranchTbl + tbl + + +Select variable with largest max. + + + + + + + + IntVarBranch + IntVarBranch Gecode::INT_VAR_SIZE_MIN + (BranchTbl tbl=NULL) + INT_VAR_SIZE_MIN + + BranchTbl + tbl + + +Select variable with smallest domain size. + + + + + + + + IntVarBranch + IntVarBranch Gecode::INT_VAR_SIZE_MAX + (BranchTbl tbl=NULL) + INT_VAR_SIZE_MAX + + BranchTbl + tbl + + +Select variable with largest domain size. + + + + + + + + IntVarBranch + IntVarBranch Gecode::INT_VAR_DEGREE_SIZE_MIN + (BranchTbl tbl=NULL) + INT_VAR_DEGREE_SIZE_MIN + + BranchTbl + tbl + + +Select variable with smallest degree divided by domain size. + + + + + + + + IntVarBranch + IntVarBranch Gecode::INT_VAR_DEGREE_SIZE_MAX + (BranchTbl tbl=NULL) + INT_VAR_DEGREE_SIZE_MAX + + BranchTbl + tbl + + +Select variable with largest degree divided by domain size. + + + + + + + + IntVarBranch + IntVarBranch Gecode::INT_VAR_AFC_SIZE_MIN + (double d=1.0, BranchTbl tbl=NULL) + INT_VAR_AFC_SIZE_MIN + + double + d + + + BranchTbl + tbl + + +Select variable with smallest accumulated failure count divided by domain size with decay factor d. + + + + + + + + IntVarBranch + IntVarBranch Gecode::INT_VAR_AFC_SIZE_MIN + (IntAFC a, BranchTbl tbl=NULL) + INT_VAR_AFC_SIZE_MIN + + IntAFC + a + + + BranchTbl + tbl + + +Select variable with smallest accumulated failure count divided by domain size. + + + + + + + + IntVarBranch + IntVarBranch Gecode::INT_VAR_AFC_SIZE_MAX + (double d=1.0, BranchTbl tbl=NULL) + INT_VAR_AFC_SIZE_MAX + + double + d + + + BranchTbl + tbl + + +Select variable with largest accumulated failure count divided by domain size with decay factor d. + + + + + + + + IntVarBranch + IntVarBranch Gecode::INT_VAR_AFC_SIZE_MAX + (IntAFC a, BranchTbl tbl=NULL) + INT_VAR_AFC_SIZE_MAX + + IntAFC + a + + + BranchTbl + tbl + + +Select variable with largest accumulated failure count divided by domain size. + + + + + + + + IntVarBranch + IntVarBranch Gecode::INT_VAR_ACTIVITY_SIZE_MIN + (double d=1.0, BranchTbl tbl=NULL) + INT_VAR_ACTIVITY_SIZE_MIN + + double + d + + + BranchTbl + tbl + + +Select variable with smallest activity divided by domain size with decay factor d. + + + + + + + + IntVarBranch + IntVarBranch Gecode::INT_VAR_ACTIVITY_SIZE_MIN + (IntActivity a, BranchTbl tbl=NULL) + INT_VAR_ACTIVITY_SIZE_MIN + + IntActivity + a + + + BranchTbl + tbl + + +Select variable with smallest activity divided by domain size. + + + + + + + + IntVarBranch + IntVarBranch Gecode::INT_VAR_ACTIVITY_SIZE_MAX + (double d=1.0, BranchTbl tbl=NULL) + INT_VAR_ACTIVITY_SIZE_MAX + + double + d + + + BranchTbl + tbl + + +Select variable with largest activity divided by domain size with decay factor d. + + + + + + + + IntVarBranch + IntVarBranch Gecode::INT_VAR_ACTIVITY_SIZE_MAX + (IntActivity a, BranchTbl tbl=NULL) + INT_VAR_ACTIVITY_SIZE_MAX + + IntActivity + a + + + BranchTbl + tbl + + +Select variable with largest activity divided by domain size. + + + + + + + + IntVarBranch + IntVarBranch Gecode::INT_VAR_REGRET_MIN_MIN + (BranchTbl tbl=NULL) + INT_VAR_REGRET_MIN_MIN + + BranchTbl + tbl + NULL + + +Select variable with smallest min-regret. + +The min-regret of a variable is the difference between the smallest and second-smallest value still in the domain. + + + + + + IntVarBranch + IntVarBranch Gecode::INT_VAR_REGRET_MIN_MAX + (BranchTbl tbl=NULL) + INT_VAR_REGRET_MIN_MAX + + BranchTbl + tbl + NULL + + +Select variable with largest min-regret. + +The min-regret of a variable is the difference between the smallest and second-smallest value still in the domain. + + + + + + IntVarBranch + IntVarBranch Gecode::INT_VAR_REGRET_MAX_MIN + (BranchTbl tbl=NULL) + INT_VAR_REGRET_MAX_MIN + + BranchTbl + tbl + NULL + + +Select variable with smallest max-regret. + +The max-regret of a variable is the difference between the largest and second-largest value still in the domain. + + + + + + IntVarBranch + IntVarBranch Gecode::INT_VAR_REGRET_MAX_MAX + (BranchTbl tbl=NULL) + INT_VAR_REGRET_MAX_MAX + + BranchTbl + tbl + NULL + + +Select variable with largest max-regret. + +The max-regret of a variable is the difference between the largest and second-largest value still in the domain. + + + + + + + + class Char + + + class Traits + + + std::basic_ostream< Char, Traits > & + std::basic_ostream<Char,Traits>& Gecode::operator<< + (std::basic_ostream< Char, Traits > &os, const DFA &d) + operator<< + + std::basic_ostream< Char, Traits > & + os + + + const DFA & + d + + + + + + + + + + + + + class Char + + + class Traits + + + class T + + + std::basic_ostream< Char, Traits > & + std::basic_ostream<Char,Traits>& Gecode::operator<< + (std::basic_ostream< Char, Traits > &os, const TupleSet &ts) + operator<< + + std::basic_ostream< Char, Traits > & + os + + + const TupleSet & + ts + + + + + + + + + + + + + class Char + + + class Traits + + + std::basic_ostream< Char, Traits > & + std::basic_ostream<Char,Traits>& Gecode::operator<< + (std::basic_ostream< Char, Traits > &os, const IntSet &is) + operator<< + + std::basic_ostream< Char, Traits > & + os + + + const IntSet & + is + + + + + + + + + + + forceinline Reify + Reify Gecode::eqv + (BoolVar x) + eqv + + BoolVar + x + + +Use equivalence for reification. + + + + + + + + forceinline Reify + Reify Gecode::imp + (BoolVar x) + imp + + BoolVar + x + + +Use implication for reification. + + + + + + + + forceinline Reify + Reify Gecode::pmi + (BoolVar x) + pmi + + BoolVar + x + + +Use reverse implication for reification. + + + + + + + + + + class Char + + + class Traits + + + std::basic_ostream< Char, Traits > & + std::basic_ostream<Char,Traits>& Gecode::operator<< + (std::basic_ostream< Char, Traits > &os, const IntVar &x) + operator<< + + std::basic_ostream< Char, Traits > & + os + + + const IntVar & + x + + + + + + + + + + + + + class Char + + + class Traits + + + std::basic_ostream< Char, Traits > & + std::basic_ostream<Char,Traits>& Gecode::operator<< + (std::basic_ostream< Char, Traits > &os, const BoolVar &x) + operator<< + + std::basic_ostream< Char, Traits > & + os + + + const BoolVar & + x + + + + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::dom + (Home home, IntVar x, int n, IntConLevel icl=ICL_DEF) + dom + + Home + home + + + IntVar + x + + + int + n + + + IntConLevel + icl + ICL_DEF + + +Propagates $x=n$. + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::dom + (Home home, const IntVarArgs &x, int n, IntConLevel icl=ICL_DEF) + dom + + Home + home + + + const IntVarArgs & + x + + + int + n + + + IntConLevel + icl + ICL_DEF + + +Propagates $ x_i=n$ for all $0\leq i<|x|$. + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::dom + (Home home, IntVar x, int l, int m, IntConLevel icl=ICL_DEF) + dom + + Home + home + + + IntVar + x + + + int + l + + + int + m + + + IntConLevel + icl + ICL_DEF + + +Propagates $ l\leq x\leq m$. + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::dom + (Home home, const IntVarArgs &x, int l, int m, IntConLevel icl=ICL_DEF) + dom + + Home + home + + + const IntVarArgs & + x + + + int + l + + + int + m + + + IntConLevel + icl + ICL_DEF + + +Propagates $ l\leq x_i\leq m$ for all $0\leq i<|x|$. + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::dom + (Home home, IntVar x, const IntSet &s, IntConLevel icl=ICL_DEF) + dom + + Home + home + + + IntVar + x + + + const IntSet & + s + + + IntConLevel + icl + ICL_DEF + + +Propagates $ x\in s $. + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::dom + (Home home, const IntVarArgs &x, const IntSet &s, IntConLevel icl=ICL_DEF) + dom + + Home + home + + + const IntVarArgs & + x + + + const IntSet & + s + + + IntConLevel + icl + ICL_DEF + + +Propagates $ x_i\in s$ for all $0\leq i<|x|$. + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::dom + (Home home, IntVar x, int n, Reify r, IntConLevel icl=ICL_DEF) + dom + + Home + home + + + IntVar + x + + + int + n + + + Reify + r + + + IntConLevel + icl + ICL_DEF + + +Post domain consistent propagator for $ (x=n) \equiv r$. + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::dom + (Home home, IntVar x, int l, int m, Reify r, IntConLevel icl=ICL_DEF) + dom + + Home + home + + + IntVar + x + + + int + l + + + int + m + + + Reify + r + + + IntConLevel + icl + ICL_DEF + + +Post domain consistent propagator for $ (l\leq x \leq m) \equiv r$. + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::dom + (Home home, IntVar x, const IntSet &s, Reify r, IntConLevel icl=ICL_DEF) + dom + + Home + home + + + IntVar + x + + + const IntSet & + s + + + Reify + r + + + IntConLevel + icl + ICL_DEF + + +Post domain consistent propagator for $ (x \in s) \equiv r$. + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::dom + (Home home, IntVar x, IntVar d, IntConLevel icl=ICL_DEF) + dom + + Home + home + + + IntVar + x + + + IntVar + d + + + IntConLevel + icl + ICL_DEF + + +Constrain domain of x according to domain of d. + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::dom + (Home home, BoolVar x, BoolVar d, IntConLevel icl=ICL_DEF) + dom + + Home + home + + + BoolVar + x + + + BoolVar + d + + + IntConLevel + icl + ICL_DEF + + +Constrain domain of x according to domain of d. + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::dom + (Home home, const IntVarArgs &x, const IntVarArgs &d, IntConLevel icl=ICL_DEF) + dom + + Home + home + + + const IntVarArgs & + x + + + const IntVarArgs & + d + + + IntConLevel + icl + ICL_DEF + + +Constrain domain of $ x_i $ according to domain of $ d_i $ for all $0\leq i<|x|$. + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::dom + (Home home, const BoolVarArgs &x, const BoolVarArgs &d, IntConLevel icl=ICL_DEF) + dom + + Home + home + + + const BoolVarArgs & + x + + + const BoolVarArgs & + d + + + IntConLevel + icl + ICL_DEF + + +Constrain domain of $ x_i $ according to domain of $ d_i $ for all $0\leq i<|x|$. + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::rel + (Home home, IntVar x0, IntRelType irt, IntVar x1, IntConLevel icl=ICL_DEF) + rel + + Home + home + + + IntVar + x0 + + + IntRelType + irt + + + IntVar + x1 + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $ x_0 \sim_{irt} x_1$. + +Supports both bounds (icl = ICL_BND) and domain consistency (icl = ICL_DOM, default). + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::rel + (Home home, const IntVarArgs &x, IntRelType irt, IntVar y, IntConLevel icl=ICL_DEF) + rel + + Home + home + + + const IntVarArgs & + x + + + IntRelType + irt + + + IntVar + y + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $ x_i \sim_{irt} y $ for all $0\leq i<|x|$. + +Supports both bounds (icl = ICL_BND) and domain consistency (icl = ICL_DOM, default). + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::rel + (Home home, IntVar x, IntRelType irt, int c, IntConLevel icl=ICL_DEF) + rel + + Home + home + + + IntVar + x + + + IntRelType + irt + + + int + c + + + IntConLevel + icl + ICL_DEF + + +Propagates $ x \sim_{irt} c$. + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::rel + (Home home, const IntVarArgs &x, IntRelType irt, int c, IntConLevel icl=ICL_DEF) + rel + + Home + home + + + const IntVarArgs & + x + + + IntRelType + irt + + + int + c + + + IntConLevel + icl + ICL_DEF + + +Propagates $ x_i \sim_{irt} c $ for all $0\leq i<|x|$. + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::rel + (Home home, IntVar x0, IntRelType irt, IntVar x1, Reify r, IntConLevel icl=ICL_DEF) + rel + + Home + home + + + IntVar + x0 + + + IntRelType + irt + + + IntVar + x1 + + + Reify + r + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $ (x_0 \sim_{irt} x_1)\equiv r$. + +Supports both bounds (icl = ICL_BND) and domain consistency (icl = ICL_DOM, default). + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::rel + (Home home, IntVar x, IntRelType irt, int c, Reify r, IntConLevel icl=ICL_DEF) + rel + + Home + home + + + IntVar + x + + + IntRelType + irt + + + int + c + + + Reify + r + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $(x \sim_{irt} c)\equiv r$. + +Supports both bounds (icl = ICL_BND) and domain consistency (icl = ICL_DOM, default). + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::rel + (Home home, const IntVarArgs &x, IntRelType irt, IntConLevel icl=ICL_DEF) + rel + + Home + home + + + const IntVarArgs & + x + + + IntRelType + irt + + + IntConLevel + icl + ICL_DEF + + +Post propagator for relation among elements in x. + +States that the elements of x are in the following relation: +if r = IRT_LE, r = IRT_LQ, r = IRT_GR, or r = IRT_GQ, then the elements of x are ordered with respect to r. Supports domain consistency (icl = ICL_DOM, default).if r = IRT_EQ, then all elements of x must be equal. Supports both bounds (icl = ICL_BND) and domain consistency (icl = ICL_DOM, default).if r = IRT_NQ, then not all elements of x must be equal. Supports domain consistency (icl = ICL_DOM, default). + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::rel + (Home home, const IntVarArgs &x, IntRelType irt, const IntVarArgs &y, IntConLevel icl=ICL_DEF) + rel + + Home + home + + + const IntVarArgs & + x + + + IntRelType + irt + + + const IntVarArgs & + y + + + IntConLevel + icl + ICL_DEF + + +Post propagator for relation between x and y. + +Note that for the inequality relations this corresponds to the lexical order between x and y.Supports both bounds (icl = ICL_BND) and domain consistency (icl = ICL_DOM, default).Note that the constraint is also defined if x and y are of different size. That means that if x and y are of different size, then if r = IRT_EQ the constraint is false and if r = IRT_NQ the constraint is subsumed. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::rel + (Home home, BoolVar x0, IntRelType irt, BoolVar x1, IntConLevel icl=ICL_DEF) + rel + + Home + home + + + BoolVar + x0 + + + IntRelType + irt + + + BoolVar + x1 + + + IntConLevel + icl + ICL_DEF + + +Post domain consistent propagator for $ x_0 \sim_{irt} x_1$. + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::rel + (Home home, BoolVar x0, IntRelType irt, BoolVar x1, Reify r, IntConLevel icl=ICL_DEF) + rel + + Home + home + + + BoolVar + x0 + + + IntRelType + irt + + + BoolVar + x1 + + + Reify + r + + + IntConLevel + icl + ICL_DEF + + +Post domain consistent propagator for $(x_0 \sim_{irt} x_1)\equiv r$. + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::rel + (Home home, const BoolVarArgs &x, IntRelType irt, BoolVar y, IntConLevel icl=ICL_DEF) + rel + + Home + home + + + const BoolVarArgs & + x + + + IntRelType + irt + + + BoolVar + y + + + IntConLevel + icl + ICL_DEF + + +Post domain consistent propagator for $ x_i \sim_{irt} y $ for all $0\leq i<|x|$. + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::rel + (Home home, BoolVar x, IntRelType irt, int n, IntConLevel icl=ICL_DEF) + rel + + Home + home + + + BoolVar + x + + + IntRelType + irt + + + int + n + + + IntConLevel + icl + ICL_DEF + + +Propagates $ x \sim_{irt} n$. + +Throws an exception of type Int::NotZeroOne, if n is neither 0 or 1. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::rel + (Home home, BoolVar x, IntRelType irt, int n, Reify r, IntConLevel icl=ICL_DEF) + rel + + Home + home + + + BoolVar + x + + + IntRelType + irt + + + int + n + + + Reify + r + + + IntConLevel + icl + ICL_DEF + + +Post domain consistent propagator for $(x \sim_{irt} n)\equiv r$. + +Throws an exception of type Int::NotZeroOne, if n is neither 0 or 1. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::rel + (Home home, const BoolVarArgs &x, IntRelType irt, int n, IntConLevel icl=ICL_DEF) + rel + + Home + home + + + const BoolVarArgs & + x + + + IntRelType + irt + + + int + n + + + IntConLevel + icl + ICL_DEF + + +Propagates $ x_i \sim_{irt} n $ for all $0\leq i<|x|$. + +Throws an exception of type Int::NotZeroOne, if n is neither 0 or 1. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::rel + (Home home, const BoolVarArgs &x, IntRelType irt, const BoolVarArgs &y, IntConLevel icl=ICL_DEF) + rel + + Home + home + + + const BoolVarArgs & + x + + + IntRelType + irt + + + const BoolVarArgs & + y + + + IntConLevel + icl + ICL_DEF + + +Post domain consistent propagator for relation between x and y. + +Note that for the inequality relations this corresponds to the lexical order between x and y.Throws an exception of type Int::ArgumentSizeMismatch, if x and y are of different size. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::rel + (Home home, const BoolVarArgs &x, IntRelType irt, IntConLevel icl=ICL_DEF) + rel + + Home + home + + + const BoolVarArgs & + x + + + IntRelType + irt + + + IntConLevel + icl + ICL_DEF + + +Post domain consistent propagator for relation between elements in x. + +States that the elements of x are in the following relation: +if r = IRT_LE, r = IRT_LQ, r = IRT_GR, or r = IRT_GQ, then the elements of x are ordered with respect to r.if r = IRT_EQ, then all elements of x must be equal.if r = IRT_NQ, then not all elements of x must be equal. + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::rel + (Home home, BoolVar x0, BoolOpType o, BoolVar x1, BoolVar x2, IntConLevel icl=ICL_DEF) + rel + + Home + home + + + BoolVar + x0 + + + BoolOpType + o + + + BoolVar + x1 + + + BoolVar + x2 + + + IntConLevel + icl + ICL_DEF + + +Post domain consistent propagator for Boolean operation on x0 and x1. + +Posts propagator for $ x_0 \diamond_{\mathit{o}} x_1 = x_2$ + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::rel + (Home home, BoolVar x0, BoolOpType o, BoolVar x1, int n, IntConLevel icl=ICL_DEF) + rel + + Home + home + + + BoolVar + x0 + + + BoolOpType + o + + + BoolVar + x1 + + + int + n + + + IntConLevel + icl + ICL_DEF + + +Post domain consistent propagator for Boolean operation on x0 and x1. + +Posts propagator for $ x_0 \diamond_{\mathit{o}} x_1 = n$Throws an exception of type Int::NotZeroOne, if n is neither 0 or 1. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::rel + (Home home, BoolOpType o, const BoolVarArgs &x, BoolVar y, IntConLevel icl=ICL_DEF) + rel + + Home + home + + + BoolOpType + o + + + const BoolVarArgs & + x + + + BoolVar + y + + + IntConLevel + icl + ICL_DEF + + +Post domain consistent propagator for Boolean operation on x. + +Posts propagator for $ x_0 \diamond_{\mathit{o}} \cdots \diamond_{\mathit{o}} x_{|x|-1}= y$Throws an exception of type Int::TooFewArguments, if $|x|<2$ and o is BOT_IMP, BOT_EQV, or BOT_XOR. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::rel + (Home home, BoolOpType o, const BoolVarArgs &x, int n, IntConLevel icl=ICL_DEF) + rel + + Home + home + + + BoolOpType + o + + + const BoolVarArgs & + x + + + int + n + + + IntConLevel + icl + ICL_DEF + + +Post domain consistent propagator for Boolean operation on x. + +Posts propagator for $ x_0 \diamond_{\mathit{o}} \cdots \diamond_{\mathit{o}} x_{|x|-1}= n$Throws an exception of type Int::NotZeroOne, if n is neither 0 or 1.Throws an exception of type Int::TooFewArguments, if $|x|<2$ and o is BOT_IMP, BOT_EQV, or BOT_XOR. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::clause + (Home home, BoolOpType o, const BoolVarArgs &x, const BoolVarArgs &y, BoolVar z, IntConLevel icl=ICL_DEF) + clause + + Home + home + + + BoolOpType + o + + + const BoolVarArgs & + x + + + const BoolVarArgs & + y + + + BoolVar + z + + + IntConLevel + icl + ICL_DEF + + +Post domain consistent propagator for Boolean clause with positive variables x and negative variables y. + +Posts propagator for $ x_0 \diamond_{\mathit{o}} \cdots \diamond_{\mathit{o}} x_{|x|-1} \diamond_{\mathit{o}} \neg y_0 \diamond_{\mathit{o}} \cdots \diamond_{\mathit{o}} \neg y_{|y|-1}= z$Throws an exception of type Int::IllegalOperation, if o is different from BOT_AND or BOT_OR. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::clause + (Home home, BoolOpType o, const BoolVarArgs &x, const BoolVarArgs &y, int n, IntConLevel icl=ICL_DEF) + clause + + Home + home + + + BoolOpType + o + + + const BoolVarArgs & + x + + + const BoolVarArgs & + y + + + int + n + + + IntConLevel + icl + ICL_DEF + + +Post domain consistent propagator for Boolean clause with positive variables x and negative variables y. + +Posts propagator for $ x_0 \diamond_{\mathit{o}} \cdots \diamond_{\mathit{o}} x_{|x|-1} \diamond_{\mathit{o}} \neg y_0 \diamond_{\mathit{o}} \cdots \diamond_{\mathit{o}} \neg y_{|y|-1}= n$Throws an exception of type Int::NotZeroOne, if n is neither 0 or 1.Throws an exception of type Int::IllegalOperation, if o is different from BOT_AND or BOT_OR. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::ite + (Home home, BoolVar b, IntVar x, IntVar y, IntVar z, IntConLevel icl=ICL_DEF) + ite + + Home + home + + + BoolVar + b + + + IntVar + x + + + IntVar + y + + + IntVar + z + + + IntConLevel + icl + ICL_DEF + + +Post propagator for if-then-else constraint. + +Posts propagator for $ z = b ? x : y $ + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::precede + (Home home, const IntVarArgs &x, int s, int t, IntConLevel=ICL_DEF) + precede + + Home + home + + + const IntVarArgs & + x + + + int + s + + + int + t + + + IntConLevel + ICL_DEF + + +Post propagator that s precedes t in x. + +This constraint enforces that $x_0\neq t$ and $x_j=t \to \bigvee_{0\leq i<j} x_i=s$ for $0\leq j<|x|$. The propagator is domain consistent. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::precede + (Home home, const IntVarArgs &x, const IntArgs &c, IntConLevel=ICL_DEF) + precede + + Home + home + + + const IntVarArgs & + x + + + const IntArgs & + c + + + IntConLevel + ICL_DEF + + +Post propagator that successive values in c precede each other in x. + +This constraint enforces that $x_0\neq c_k$ for $0<k<|c|$ and $x_j=c_{k} \to \bigvee_{0\leq i<j} x_i=c_{k-1}$ for $0\leq j<|x|$ and $0< k<|c|$. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::member + (Home home, const IntVarArgs &x, IntVar y, IntConLevel icl=ICL_DEF) + member + + Home + home + + + const IntVarArgs & + x + + + IntVar + y + + + IntConLevel + icl + ICL_DEF + + +Post domain consistent propagator for $y\in \{x_0,\ldots,x_{|x|-1}\}$. + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::member + (Home home, const BoolVarArgs &x, BoolVar y, IntConLevel icl=ICL_DEF) + member + + Home + home + + + const BoolVarArgs & + x + + + BoolVar + y + + + IntConLevel + icl + ICL_DEF + + +Post domain consistent propagator for $y\in \{x_0,\ldots,x_{|x|-1}\}$. + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::member + (Home home, const IntVarArgs &x, IntVar y, Reify r, IntConLevel icl=ICL_DEF) + member + + Home + home + + + const IntVarArgs & + x + + + IntVar + y + + + Reify + r + + + IntConLevel + icl + ICL_DEF + + +Post domain consistent propagator for $\left(y\in \{x_0,\ldots,x_{|x|-1}\}\right)\equiv r$. + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::member + (Home home, const BoolVarArgs &x, BoolVar y, Reify r, IntConLevel icl=ICL_DEF) + member + + Home + home + + + const BoolVarArgs & + x + + + BoolVar + y + + + Reify + r + + + IntConLevel + icl + ICL_DEF + + +Post domain consistent propagator for $\left(y\in \{x_0,\ldots,x_{|x|-1}\}\right)\equiv r$. + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::element + (Home home, IntSharedArray n, IntVar x0, IntVar x1, IntConLevel icl=ICL_DEF) + element + + Home + home + + + IntSharedArray + n + + + IntVar + x0 + + + IntVar + x1 + + + IntConLevel + icl + ICL_DEF + + +Post domain consistent propagator for $ n_{x_0}=x_1$. + +Throws an exception of type Int::OutOfLimits, if the integers in n exceed the limits in Int::Limits. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::element + (Home home, IntSharedArray n, IntVar x0, BoolVar x1, IntConLevel icl=ICL_DEF) + element + + Home + home + + + IntSharedArray + n + + + IntVar + x0 + + + BoolVar + x1 + + + IntConLevel + icl + ICL_DEF + + +Post domain consistent propagator for $ n_{x_0}=x_1$. + +Throws an exception of type Int::OutOfLimits, if the integers in n exceed the limits in Int::Limits. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::element + (Home home, IntSharedArray n, IntVar x0, int x1, IntConLevel icl=ICL_DEF) + element + + Home + home + + + IntSharedArray + n + + + IntVar + x0 + + + int + x1 + + + IntConLevel + icl + ICL_DEF + + +Post domain consistent propagator for $ n_{x_0}=x_1$. + +Throws an exception of type Int::OutOfLimits, if the integers in n exceed the limits in Int::Limits. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::element + (Home home, const IntVarArgs &x, IntVar y0, IntVar y1, IntConLevel icl=ICL_DEF) + element + + Home + home + + + const IntVarArgs & + x + + + IntVar + y0 + + + IntVar + y1 + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $ x_{y_0}=y_1$. + +Supports both bounds (icl = ICL_BND) and domain consistency (icl = ICL_DOM, default). + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::element + (Home home, const IntVarArgs &x, IntVar y0, int y1, IntConLevel icl=ICL_DEF) + element + + Home + home + + + const IntVarArgs & + x + + + IntVar + y0 + + + int + y1 + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $ x_{y_0}=y_1$. + +Supports both bounds (icl = ICL_BND) and domain consistency (icl = ICL_DOM, default). + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::element + (Home home, const BoolVarArgs &x, IntVar y0, BoolVar y1, IntConLevel icl=ICL_DEF) + element + + Home + home + + + const BoolVarArgs & + x + + + IntVar + y0 + + + BoolVar + y1 + + + IntConLevel + icl + ICL_DEF + + +Post domain consistent propagator for $ x_{y_0}=y_1$. + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::element + (Home home, const BoolVarArgs &x, IntVar y0, int y1, IntConLevel icl=ICL_DEF) + element + + Home + home + + + const BoolVarArgs & + x + + + IntVar + y0 + + + int + y1 + + + IntConLevel + icl + ICL_DEF + + +Post domain consistent propagator for $ x_{y_0}=y_1$. + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::element + (Home home, IntSharedArray a, IntVar x, int w, IntVar y, int h, IntVar z, IntConLevel icl=ICL_DEF) + element + + Home + home + + + IntSharedArray + a + + + IntVar + x + + + int + w + + + IntVar + y + + + int + h + + + IntVar + z + + + IntConLevel + icl + ICL_DEF + + +Post domain consistent propagator for $ a_{x+w\cdot y}=z$. + +If a is regarded as a two-dimensional array in row-major order of width w and height h, then z is constrained to be the element in column x and row y.Throws an exception of type Int::OutOfLimits, if the integers in n exceed the limits in Int::Limits.Throws an exception of type Int::ArgumentSizeMismatch, if $ w\cdot h\neq|a|$. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::element + (Home home, IntSharedArray a, IntVar x, int w, IntVar y, int h, BoolVar z, IntConLevel icl=ICL_DEF) + element + + Home + home + + + IntSharedArray + a + + + IntVar + x + + + int + w + + + IntVar + y + + + int + h + + + BoolVar + z + + + IntConLevel + icl + ICL_DEF + + +Post domain consistent propagator for $ a_{x+w\cdot y}=z$. + +If a is regarded as a two-dimensional array in row-major order of width w and height h, then z is constrained to be the element in column x and row y.Throws an exception of type Int::OutOfLimits, if the integers in n exceed the limits in Int::Limits.Throws an exception of type Int::ArgumentSizeMismatch, if $ w\cdot h\neq|a|$. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::element + (Home home, const IntVarArgs &a, IntVar x, int w, IntVar y, int h, IntVar z, IntConLevel icl=ICL_DEF) + element + + Home + home + + + const IntVarArgs & + a + + + IntVar + x + + + int + w + + + IntVar + y + + + int + h + + + IntVar + z + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $ a_{x+w\cdot y}=z$. + +If a is regarded as a two-dimensional array in row-major order of width w and height h, then z is constrained to be the element in column x and row y.Supports both bounds (icl = ICL_BND) and domain consistency (icl = ICL_DOM, default).Throws an exception of type Int::OutOfLimits, if the integers in n exceed the limits in Int::Limits.Throws an exception of type Int::ArgumentSizeMismatch, if $ w\cdot h\neq|a|$. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::element + (Home home, const BoolVarArgs &a, IntVar x, int w, IntVar y, int h, BoolVar z, IntConLevel icl=ICL_DEF) + element + + Home + home + + + const BoolVarArgs & + a + + + IntVar + x + + + int + w + + + IntVar + y + + + int + h + + + BoolVar + z + + + IntConLevel + icl + ICL_DEF + + +Post domain consistent propagator for $ a_{x+w\cdot y}=z$. + +If a is regarded as a two-dimensional array in row-major order of width w and height h, then z is constrained to be the element in column x and row y.Throws an exception of type Int::OutOfLimits, if the integers in n exceed the limits in Int::Limits.Throws an exception of type Int::ArgumentSizeMismatch, if $ w\cdot h\neq|a|$. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::distinct + (Home home, const IntVarArgs &x, IntConLevel icl=ICL_DEF) + distinct + + Home + home + + + const IntVarArgs & + x + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $ x_i\neq x_j$ for all $0\leq i\neq j<|x|$. + +Supports value (icl = ICL_VAL, default), bounds (icl = ICL_BND), and domain consistency (icl = ICL_DOM).Throws an exception of type Int::ArgumentSame, if x contains the same unassigned variable multiply. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::distinct + (Home home, const IntArgs &n, const IntVarArgs &x, IntConLevel icl=ICL_DEF) + distinct + + Home + home + + + const IntArgs & + n + + + const IntVarArgs & + x + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $ x_i+n_i\neq x_j+n_j$ for all $0\leq i\neq j<|x|$. + + +Supports value (icl = ICL_VAL, default), bounds (icl = ICL_BND), and domain consistency (icl = ICL_DOM). +Throws an exception of type Int::OutOfLimits, if the integers in n exceed the limits in Int::Limits or if the sum of n and x exceed the limits. +Throws an exception of type Int::ArgumentSizeMismatch, if x and n are of different size. +Throws an exception of type Int::ArgumentSame, if x contains the same unassigned variable multiply. + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::channel + (Home home, const IntVarArgs &x, const IntVarArgs &y, IntConLevel icl=ICL_DEF) + channel + + Home + home + + + const IntVarArgs & + x + + + const IntVarArgs & + y + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $ x_i = j\leftrightarrow y_j=i$ for all $0\leq i<|x|$. + + +Supports domain consistency (icl = ICL_DOM) and value propagation (all other values for icl, default). +Throws an exception of type Int::ArgumentSizeMismatch, if x and y are of different size. +Throws an exception of type Int::ArgumentSame, if x or y contain the same unassigned variable multiply. Note that a variable can occur in both x and y, but not more than once in either x or y. + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::channel + (Home home, const IntVarArgs &x, int xoff, const IntVarArgs &y, int yoff, IntConLevel icl=ICL_DEF) + channel + + Home + home + + + const IntVarArgs & + x + + + int + xoff + + + const IntVarArgs & + y + + + int + yoff + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $ x_i - \mathit{xoff} = j\leftrightarrow y_j - \mathit{yoff} = i$ for all $0\leq i<|x|$. + + +Supports domain consistency (icl = ICL_DOM) and value propagation (all other values for icl, default). +Throws an exception of type Int::ArgumentSizeMismatch, if x and y are of different size. +Throws an exception of type Int::ArgumentSame, if x or y contain the same unassigned variable multiply. Note that a variable can occur in both x and y, but not more than once in either x or y. +Throws an exception of type Int::OutOfLimits, if xoff or yoff are negative. + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::channel + (Home home, BoolVar x0, IntVar x1, IntConLevel icl=ICL_DEF) + channel + + Home + home + + + BoolVar + x0 + + + IntVar + x1 + + + IntConLevel + icl + ICL_DEF + + +Post domain consistent propagator for channeling a Boolean and an integer variable $ x_0 = x_1$. + + + + + + + + forceinline void + forceinline void Gecode::channel + (Home home, IntVar x0, BoolVar x1, IntConLevel icl=ICL_DEF) + channel + + Home + home + + + IntVar + x0 + + + BoolVar + x1 + + + IntConLevel + icl + ICL_DEF + + +Post domain consistent propagator for channeling an integer and a Boolean variable $ x_0 = x_1$. + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::channel + (Home home, const BoolVarArgs &x, IntVar y, int o=0, IntConLevel icl=ICL_DEF) + channel + + Home + home + + + const BoolVarArgs & + x + + + IntVar + y + + + int + o + 0 + + + IntConLevel + icl + ICL_DEF + + +Post domain consistent propagator for channeling Boolean and integer variables $ x_i = 1\leftrightarrow y=i+o$. + +Throws an exception of type Int::ArgumentSame, if x contains the same unassigned variable multiply. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::sorted + (Home home, const IntVarArgs &x, const IntVarArgs &y, IntConLevel icl=ICL_DEF) + sorted + + Home + home + + + const IntVarArgs & + x + + + const IntVarArgs & + y + + + IntConLevel + icl + ICL_DEF + + +Post propagator that y is x sorted in increasing order. + +Might throw the following exceptions: +Int::ArgumentSizeMismatch, if x and y differ in size.Int::ArgumentSame, if x or y contain shared unassigned variables. + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::sorted + (Home home, const IntVarArgs &x, const IntVarArgs &y, const IntVarArgs &z, IntConLevel icl=ICL_DEF) + sorted + + Home + home + + + const IntVarArgs & + x + + + const IntVarArgs & + y + + + const IntVarArgs & + z + + + IntConLevel + icl + ICL_DEF + + +Post propagator that y is x sorted in increasing order. + +The values in z describe the sorting permutation, that is $\forall i\in\{0,\dots,|x|-1\}: x_i=y_{z_i} $.Might throw the following exceptions: +Int::ArgumentSizeMismatch, if x and y differ in size.Int::ArgumentSame, if x or y contain shared unassigned variables. + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::count + (Home home, const IntVarArgs &x, int n, IntRelType irt, int m, IntConLevel icl=ICL_DEF) + count + + Home + home + + + const IntVarArgs & + x + + + int + n + + + IntRelType + irt + + + int + m + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $\#\{i\in\{0,\ldots,|x|-1\}\;|\;x_i=n\}\sim_{irt} m$. + +Performs domain propagation but is not domain consistent. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::count + (Home home, const IntVarArgs &x, const IntSet &y, IntRelType irt, int m, IntConLevel icl=ICL_DEF) + count + + Home + home + + + const IntVarArgs & + x + + + const IntSet & + y + + + IntRelType + irt + + + int + m + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $\#\{i\in\{0,\ldots,|x|-1\}\;|\;x_i\in y\}\sim_{irt} m$. + +Performs domain propagation but is not domain consistent. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::count + (Home home, const IntVarArgs &x, IntVar y, IntRelType irt, int m, IntConLevel icl=ICL_DEF) + count + + Home + home + + + const IntVarArgs & + x + + + IntVar + y + + + IntRelType + irt + + + int + m + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $\#\{i\in\{0,\ldots,|x|-1\}\;|\;x_i=y\}\sim_{irt} m$. + +Performs domain propagation (icl = ICL_DOM, default) and slightly less domain propagation (all other values for icl), where y is not pruned. Note that in both cases propagation is not comain consistent. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::count + (Home home, const IntVarArgs &x, const IntArgs &y, IntRelType irt, int m, IntConLevel icl=ICL_DEF) + count + + Home + home + + + const IntVarArgs & + x + + + const IntArgs & + y + + + IntRelType + irt + + + int + m + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $\#\{i\in\{0,\ldots,|x|-1\}\;|\;x_i=y_i\}\sim_{irt} m$. + +Performs domain propagation but is not domain consistent.Throws an exception of type Int::ArgumentSizeMismatch, if x and y are of different size. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::count + (Home home, const IntVarArgs &x, int n, IntRelType irt, IntVar z, IntConLevel icl=ICL_DEF) + count + + Home + home + + + const IntVarArgs & + x + + + int + n + + + IntRelType + irt + + + IntVar + z + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $\#\{i\in\{0,\ldots,|x|-1\}\;|\;x_i=n\}\sim_{irt} z$. + +Performs domain propagation but is not domain consistent. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::count + (Home home, const IntVarArgs &x, const IntSet &y, IntRelType irt, IntVar z, IntConLevel icl=ICL_DEF) + count + + Home + home + + + const IntVarArgs & + x + + + const IntSet & + y + + + IntRelType + irt + + + IntVar + z + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $\#\{i\in\{0,\ldots,|x|-1\}\;|\;x_i\in y\}\sim_{irt} z$. + +Performs domain propagation but is not domain consistent. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::count + (Home home, const IntVarArgs &x, IntVar y, IntRelType irt, IntVar z, IntConLevel icl=ICL_DEF) + count + + Home + home + + + const IntVarArgs & + x + + + IntVar + y + + + IntRelType + irt + + + IntVar + z + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $\#\{i\in\{0,\ldots,|x|-1\}\;|\;x_i=y\}\sim_{irt} z$. + +Performs domain propagation (icl = ICL_DOM, default) and slightly less domain propagation (all other values for icl), where y is not pruned. Note that in both cases propagation is not comain consistent. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::count + (Home home, const IntVarArgs &x, const IntArgs &y, IntRelType irt, IntVar z, IntConLevel icl=ICL_DEF) + count + + Home + home + + + const IntVarArgs & + x + + + const IntArgs & + y + + + IntRelType + irt + + + IntVar + z + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $\#\{i\in\{0,\ldots,|x|-1\}\;|\;x_i=y_i\}\sim_{irt} z$. + +Performs domain propagation but is not domain consistent.Throws an exception of type Int::ArgumentSizeMismatch, if x and y are of different size. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::count + (Home home, const IntVarArgs &x, const IntVarArgs &c, IntConLevel icl=ICL_DEF) + count + + Home + home + + + const IntVarArgs & + x + + + const IntVarArgs & + c + + + IntConLevel + icl + ICL_DEF + + +Posts a global count (cardinality) constraint. + +Posts the constraint that $\#\{i\in\{0,\ldots,|x|-1\}\;|\;x_i=j\}=c_j$ and $ \bigcup_i \{x_i\} \subseteq \{0,\ldots,|c|-1\}$ (no other value occurs).Supports value (icl = ICL_VAL, default), bounds (icl = ICL_BND), and domain consistency (icl = ICL_DOM).Throws an exception of type Int::ArgumentSame, if x contains the same unassigned variable multiply. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::count + (Home home, const IntVarArgs &x, const IntSetArgs &c, IntConLevel icl=ICL_DEF) + count + + Home + home + + + const IntVarArgs & + x + + + const IntSetArgs & + c + + + IntConLevel + icl + ICL_DEF + + +Posts a global count (cardinality) constraint. + +Posts the constraint that $\#\{i\in\{0,\ldots,|x|-1\}\;|\;x_i=j\}\in c_j$ and $ \bigcup_i \{x_i\} \subseteq \{0,\ldots,|c|-1\}$ (no other value occurs).Supports value (icl = ICL_VAL, default), bounds (icl = ICL_BND), and domain consistency (icl = ICL_DOM).Throws an exception of type Int::ArgumentSame, if x contains the same unassigned variable multiply. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::count + (Home home, const IntVarArgs &x, const IntVarArgs &c, const IntArgs &v, IntConLevel icl=ICL_DEF) + count + + Home + home + + + const IntVarArgs & + x + + + const IntVarArgs & + c + + + const IntArgs & + v + + + IntConLevel + icl + ICL_DEF + + +Posts a global count (cardinality) constraint. + +Posts the constraint that $\#\{i\in\{0,\ldots,|x|-1\}\;|\;x_i=v_j\}=c_j$ and $ \bigcup_i \{x_i\} \subseteq \bigcup_j \{v_j\}$ (no other value occurs).Supports value (icl = ICL_VAL, default), bounds (icl = ICL_BND), and domain consistency (icl = ICL_DOM).Throws an exception of type Int::ArgumentSame, if x contains the same unassigned variable multiply.Throws an exception of type Int::ArgumentSizeMismatch, if c and v are of different size. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::count + (Home home, const IntVarArgs &x, const IntSetArgs &c, const IntArgs &v, IntConLevel icl=ICL_DEF) + count + + Home + home + + + const IntVarArgs & + x + + + const IntSetArgs & + c + + + const IntArgs & + v + + + IntConLevel + icl + ICL_DEF + + +Posts a global count (cardinality) constraint. + +Posts the constraint that $\#\{i\in\{0,\ldots,|x|-1\}\;|\;x_i=v_j\}\in c_j$ and $ \bigcup_i \{x_i\} \subseteq \bigcup_j \{v_j\}$ (no other value occurs).Supports value (icl = ICL_VAL, default), bounds (icl = ICL_BND), and domain consistency (icl = ICL_DOM).Throws an exception of type Int::ArgumentSame, if x contains the same unassigned variable multiply.Throws an exception of type Int::ArgumentSizeMismatch, if c and v are of different size. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::count + (Home home, const IntVarArgs &x, const IntSet &c, const IntArgs &v, IntConLevel icl=ICL_DEF) + count + + Home + home + + + const IntVarArgs & + x + + + const IntSet & + c + + + const IntArgs & + v + + + IntConLevel + icl + ICL_DEF + + +Posts a global count (cardinality) constraint. + +Posts the constraint that $\#\{i\in\{0,\ldots,|x|-1\}\;|\;x_i=v_j\}\in c$ and $ \bigcup_i \{x_i\} \subseteq \bigcup_j \{v_j\}$ (no other value occurs).Supports value (icl = ICL_VAL, default), bounds (icl = ICL_BND), and domain consistency (icl = ICL_DOM).Throws an exception of type Int::ArgumentSame, if x contains the same unassigned variable multiply.Throws an exception of type Int::ArgumentSizeMismatch, if c and v are of different size. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::nvalues + (Home home, const IntVarArgs &x, IntRelType irt, int y, IntConLevel icl=ICL_DEF) + nvalues + + Home + home + + + const IntVarArgs & + x + + + IntRelType + irt + + + int + y + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $\#\{x_0,\ldots,x_{|x|-1}\}\sim_{irt} y$. + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::nvalues + (Home home, const IntVarArgs &x, IntRelType irt, IntVar y, IntConLevel icl=ICL_DEF) + nvalues + + Home + home + + + const IntVarArgs & + x + + + IntRelType + irt + + + IntVar + y + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $\#\{x_0,\ldots,x_{|x|-1}\}\sim_{irt} y$. + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::nvalues + (Home home, const BoolVarArgs &x, IntRelType irt, int y, IntConLevel icl=ICL_DEF) + nvalues + + Home + home + + + const BoolVarArgs & + x + + + IntRelType + irt + + + int + y + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $\#\{x_0,\ldots,x_{|x|-1}\}\sim_{irt} y$. + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::nvalues + (Home home, const BoolVarArgs &x, IntRelType irt, IntVar y, IntConLevel icl=ICL_DEF) + nvalues + + Home + home + + + const BoolVarArgs & + x + + + IntRelType + irt + + + IntVar + y + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $\#\{x_0,\ldots,x_{|x|-1}\}\sim_{irt} y$. + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::sequence + (Home home, const IntVarArgs &x, const IntSet &s, int q, int l, int u, IntConLevel icl=ICL_DEF) + sequence + + Home + home + + + const IntVarArgs & + x + + + const IntSet & + s + + + int + q + + + int + l + + + int + u + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $\operatorname{sequence}(x,s,q,l,u)$. + +Posts a domain consistent propagator for the constraint $\bigwedge_{i=0}^{|x|-q} \operatorname{among}(\langle x_i,\ldots,x_{i+q-1}\rangle,s,l,u)$ where the among constraint is defined as $l\leq\#\{j\in\{i,\ldots,i+q-1\}\;|\;x_j\in s\} \leq u$.Throws the following exceptions: +Of type Int::TooFewArguments, if $|x|=0$.Of type Int::ArgumentSame, if x contains the same unassigned variable multiply.Of type Int::OutOfRange, if $q < 1 \vee q > |x|$. + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::sequence + (Home home, const BoolVarArgs &x, const IntSet &s, int q, int l, int u, IntConLevel icl=ICL_DEF) + sequence + + Home + home + + + const BoolVarArgs & + x + + + const IntSet & + s + + + int + q + + + int + l + + + int + u + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $\operatorname{sequence}(x,s,q,l,u)$. + +Posts a domain consistent propagator for the constraint $\bigwedge_{i=0}^{|x|-q} \operatorname{among}(\langle x_i,\ldots,x_{i+q-1}\rangle,s,l,u)$ where the among constraint is defined as $l\leq\#\{j\in\{i,\ldots,i+q-1\}\;|\;x_j\in s\} \leq u$.Throws the following exceptions: +Of type Int::TooFewArguments, if $|x|=0$.Of type Int::ArgumentSame, if x contains the same unassigned variable multiply.Of type Int::OutOfRange, if $q < 1 \vee q > |x|$. + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::extensional + (Home home, const IntVarArgs &x, DFA d, IntConLevel icl=ICL_DEF) + extensional + + Home + home + + + const IntVarArgs & + x + + + DFA + d + + + IntConLevel + icl + ICL_DEF + + +Post domain consistent propagator for extensional constraint described by a DFA. + +The elements of x must be a word of the language described by the DFA d.Throws an exception of type Int::ArgumentSame, if x contains the same unassigned variable multiply. If shared occurences of variables are required, unshare should be used. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::extensional + (Home home, const BoolVarArgs &x, DFA d, IntConLevel icl=ICL_DEF) + extensional + + Home + home + + + const BoolVarArgs & + x + + + DFA + d + + + IntConLevel + icl + ICL_DEF + + +Post domain consistent propagator for extensional constraint described by a DFA. + +The elements of x must be a word of the language described by the DFA d.Throws an exception of type Int::ArgumentSame, if x contains the same unassigned variable multiply. If shared occurences of variables are required, unshare should be used. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::extensional + (Home home, const IntVarArgs &x, const TupleSet &t, ExtensionalPropKind epk=EPK_DEF, IntConLevel icl=ICL_DEF) + extensional + + Home + home + + + const IntVarArgs & + x + + + const TupleSet & + t + + + ExtensionalPropKind + epk + EPK_DEF + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $x\in t$. + + +Supports implementations optimized for memory (epk = EPK_MEMORY, default) and speed (epk = EPK_SPEED). +Supports domain consistency (icl = ICL_DOM, default) only. +Throws an exception of type Int::ArgumentSizeMismatch, if x and t are of different size. +Throws an exception of type Int::NotYetFinalized, if the tuple set t has not been finalized. + +If the domains for the $x_i$ are not dense and have similar bounds, lots of memory will be wasted (memory consumption is in $ O\left(|x|\cdot\min_i(\underline{x_i})\cdot\max_i(\overline{x_i})\right)$ for the basic algorithm (epk = EPK_MEMORY) and additionally $ O\left(|x|^2\cdot\min_i(\underline{x_i})\cdot\max_i(\overline{x_i})\right)$ for the incremental algorithm (epk = EPK_SPEED). + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::extensional + (Home home, const BoolVarArgs &x, const TupleSet &t, ExtensionalPropKind epk=EPK_DEF, IntConLevel icl=ICL_DEF) + extensional + + Home + home + + + const BoolVarArgs & + x + + + const TupleSet & + t + + + ExtensionalPropKind + epk + EPK_DEF + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $x\in t$. + + +Supports implementations optimized for memory (epk = EPK_MEMORY, default) and speed (epk = EPK_SPEED). +Supports domain consistency (icl = ICL_DOM, default) only. +Throws an exception of type Int::ArgumentSizeMismatch, if x and t are of different size. +Throws an exception of type Int::NotYetFinalized, if the tuple set t has not been finalized. + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::min + (Home home, IntVar x0, IntVar x1, IntVar x2, IntConLevel icl=ICL_DEF) + min + + Home + home + + + IntVar + x0 + + + IntVar + x1 + + + IntVar + x2 + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $ \min\{x_0,x_1\}=x_2$. + +Supports both bounds consistency (icl = ICL_BND, default) and domain consistency (icl = ICL_DOM). + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::min + (Home home, const IntVarArgs &x, IntVar y, IntConLevel icl=ICL_DEF) + min + + Home + home + + + const IntVarArgs & + x + + + IntVar + y + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $ \min x=y$. + +Supports both bounds consistency (icl = ICL_BND, default) and domain consistency (icl = ICL_DOM).If x is empty, an exception of type Int::TooFewArguments is thrown. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::max + (Home home, IntVar x0, IntVar x1, IntVar x2, IntConLevel icl=ICL_DEF) + max + + Home + home + + + IntVar + x0 + + + IntVar + x1 + + + IntVar + x2 + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $ \max\{x_0,x_1\}=x_2$. + +Supports both bounds consistency (icl = ICL_BND, default) and domain consistency (icl = ICL_DOM). + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::max + (Home home, const IntVarArgs &x, IntVar y, IntConLevel icl=ICL_DEF) + max + + Home + home + + + const IntVarArgs & + x + + + IntVar + y + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $ \max x=y$. + +Supports both bounds consistency (icl = ICL_BND, default) and domain consistency (icl = ICL_DOM).If x is empty, an exception of type Int::TooFewArguments is thrown. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::argmin + (Home home, const IntVarArgs &x, IntVar y, bool tiebreak=true, IntConLevel icl=ICL_DEF) + argmin + + Home + home + + + const IntVarArgs & + x + + + IntVar + y + + + bool + tiebreak + true + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $ \operatorname{argmin} x=y$. + +In case of ties, the smallest value for y is chosen (provided tiebreak is true).If x is empty, an exception of type Int::TooFewArguments is thrown. If y occurs in x, an exception of type Int::ArgumentSame is thrown. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::argmax + (Home home, const IntVarArgs &x, IntVar y, bool tiebreak=true, IntConLevel icl=ICL_DEF) + argmax + + Home + home + + + const IntVarArgs & + x + + + IntVar + y + + + bool + tiebreak + true + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $ \operatorname{argmax} x=y$. + +In case of ties, the smallest value for y is chosen (provided tiebreak is true).If x is empty, an exception of type Int::TooFewArguments is thrown. If y occurs in x, an exception of type Int::ArgumentSame is thrown. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::abs + (Home home, IntVar x0, IntVar x1, IntConLevel icl=ICL_DEF) + abs + + Home + home + + + IntVar + x0 + + + IntVar + x1 + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $ |x_0|=x_1$. + +Supports both bounds consistency (icl = ICL_BND, default) and domain consistency (icl = ICL_DOM). + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::mult + (Home home, IntVar x0, IntVar x1, IntVar x2, IntConLevel icl=ICL_DEF) + mult + + Home + home + + + IntVar + x0 + + + IntVar + x1 + + + IntVar + x2 + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $x_0\cdot x_1=x_2$. + +Supports both bounds consistency (icl = ICL_BND, default) and domain consistency (icl = ICL_DOM). + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::divmod + (Home home, IntVar x0, IntVar x1, IntVar x2, IntVar x3, IntConLevel icl=ICL_DEF) + divmod + + Home + home + + + IntVar + x0 + + + IntVar + x1 + + + IntVar + x2 + + + IntVar + x3 + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $x_0\ \mathrm{div}\ x_1=x_2 \land x_0\ \mathrm{mod}\ x_1 = x_3$. + +Supports bounds consistency (icl = ICL_BND, default). + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::div + (Home home, IntVar x0, IntVar x1, IntVar x2, IntConLevel icl=ICL_DEF) + div + + Home + home + + + IntVar + x0 + + + IntVar + x1 + + + IntVar + x2 + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $x_0\ \mathrm{div}\ x_1=x_2$. + +Supports bounds consistency (icl = ICL_BND, default). + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::mod + (Home home, IntVar x0, IntVar x1, IntVar x2, IntConLevel icl=ICL_DEF) + mod + + Home + home + + + IntVar + x0 + + + IntVar + x1 + + + IntVar + x2 + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $x_0\ \mathrm{mod}\ x_1=x_2$. + +Supports bounds consistency (icl = ICL_BND, default). + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::sqr + (Home home, IntVar x0, IntVar x1, IntConLevel icl=ICL_DEF) + sqr + + Home + home + + + IntVar + x0 + + + IntVar + x1 + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $x_0^2=x_1$. + +Supports both bounds consistency (icl = ICL_BND, default) and domain consistency (icl = ICL_DOM). + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::sqrt + (Home home, IntVar x0, IntVar x1, IntConLevel icl=ICL_DEF) + sqrt + + Home + home + + + IntVar + x0 + + + IntVar + x1 + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $\lfloor\sqrt{x_0}\rfloor=x_1$. + +Supports both bounds consistency (icl = ICL_BND, default) and domain consistency (icl = ICL_DOM). + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::pow + (Home home, IntVar x0, int n, IntVar x1, IntConLevel icl=ICL_DEF) + pow + + Home + home + + + IntVar + x0 + + + int + n + + + IntVar + x1 + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $x_0^n=x_1$. + +Supports both bounds consistency (icl = ICL_BND, default) and domain consistency (icl = ICL_DOM).Throws an exception of type Int::OutOfLimits, if n is negative. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::nroot + (Home home, IntVar x0, int n, IntVar x1, IntConLevel icl=ICL_DEF) + nroot + + Home + home + + + IntVar + x0 + + + int + n + + + IntVar + x1 + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $\lfloor\sqrt[n]{x_0}\rfloor=x_1$. + +Supports both bounds consistency (icl = ICL_BND, default) and domain consistency (icl = ICL_DOM).Throws an exception of type Int::OutOfLimits, if n is not strictly positive. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::linear + (Home home, const IntVarArgs &x, IntRelType irt, int c, IntConLevel icl=ICL_DEF) + linear + + Home + home + + + const IntVarArgs & + x + + + IntRelType + irt + + + int + c + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $\sum_{i=0}^{|x|-1}x_i\sim_{irt} c$. + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::linear + (Home home, const IntVarArgs &x, IntRelType irt, IntVar y, IntConLevel icl=ICL_DEF) + linear + + Home + home + + + const IntVarArgs & + x + + + IntRelType + irt + + + IntVar + y + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $\sum_{i=0}^{|x|-1}x_i\sim_{irt} y$. + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::linear + (Home home, const IntVarArgs &x, IntRelType irt, int c, Reify r, IntConLevel icl=ICL_DEF) + linear + + Home + home + + + const IntVarArgs & + x + + + IntRelType + irt + + + int + c + + + Reify + r + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $\left(\sum_{i=0}^{|x|-1}x_i\sim_{irt} c\right)\equiv r$. + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::linear + (Home home, const IntVarArgs &x, IntRelType irt, IntVar y, Reify r, IntConLevel icl=ICL_DEF) + linear + + Home + home + + + const IntVarArgs & + x + + + IntRelType + irt + + + IntVar + y + + + Reify + r + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $\left(\sum_{i=0}^{|x|-1}x_i\sim_{irt} y\right)\equiv r$. + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::linear + (Home home, const IntArgs &a, const IntVarArgs &x, IntRelType irt, int c, IntConLevel icl=ICL_DEF) + linear + + Home + home + + + const IntArgs & + a + + + const IntVarArgs & + x + + + IntRelType + irt + + + int + c + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $\sum_{i=0}^{|x|-1}a_i\cdot x_i\sim_{irt} c$. + +Throws an exception of type Int::ArgumentSizeMismatch, if a and x are of different size. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::linear + (Home home, const IntArgs &a, const IntVarArgs &x, IntRelType irt, IntVar y, IntConLevel icl=ICL_DEF) + linear + + Home + home + + + const IntArgs & + a + + + const IntVarArgs & + x + + + IntRelType + irt + + + IntVar + y + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $\sum_{i=0}^{|x|-1}a_i\cdot x_i\sim_{irt} y$. + +Throws an exception of type Int::ArgumentSizeMismatch, if a and x are of different size. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::linear + (Home home, const IntArgs &a, const IntVarArgs &x, IntRelType irt, int c, Reify r, IntConLevel icl=ICL_DEF) + linear + + Home + home + + + const IntArgs & + a + + + const IntVarArgs & + x + + + IntRelType + irt + + + int + c + + + Reify + r + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $\left(\sum_{i=0}^{|x|-1}a_i\cdot x_i\sim_{irt} c\right)\equiv r$. + +Throws an exception of type Int::ArgumentSizeMismatch, if a and x are of different size. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::linear + (Home home, const IntArgs &a, const IntVarArgs &x, IntRelType irt, IntVar y, Reify r, IntConLevel icl=ICL_DEF) + linear + + Home + home + + + const IntArgs & + a + + + const IntVarArgs & + x + + + IntRelType + irt + + + IntVar + y + + + Reify + r + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $\left(\sum_{i=0}^{|x|-1}a_i\cdot x_i\sim_{irt} y\right)\equiv r$. + +Throws an exception of type Int::ArgumentSizeMismatch, if a and x are of different size. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::linear + (Home home, const BoolVarArgs &x, IntRelType irt, int c, IntConLevel icl=ICL_DEF) + linear + + Home + home + + + const BoolVarArgs & + x + + + IntRelType + irt + + + int + c + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $\sum_{i=0}^{|x|-1}x_i\sim_{irt} c$. + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::linear + (Home home, const BoolVarArgs &x, IntRelType irt, int c, Reify r, IntConLevel icl=ICL_DEF) + linear + + Home + home + + + const BoolVarArgs & + x + + + IntRelType + irt + + + int + c + + + Reify + r + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $\left(\sum_{i=0}^{|x|-1}x_i\sim_{irt} c\right)\equiv r$. + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::linear + (Home home, const BoolVarArgs &x, IntRelType irt, IntVar y, IntConLevel icl=ICL_DEF) + linear + + Home + home + + + const BoolVarArgs & + x + + + IntRelType + irt + + + IntVar + y + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $\sum_{i=0}^{|x|-1}x_i\sim_{irt} y$. + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::linear + (Home home, const BoolVarArgs &x, IntRelType irt, IntVar y, Reify r, IntConLevel icl=ICL_DEF) + linear + + Home + home + + + const BoolVarArgs & + x + + + IntRelType + irt + + + IntVar + y + + + Reify + r + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $\left(\sum_{i=0}^{|x|-1}x_i\sim_{irt} y\right)\equiv r$. + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::linear + (Home home, const IntArgs &a, const BoolVarArgs &x, IntRelType irt, int c, IntConLevel icl=ICL_DEF) + linear + + Home + home + + + const IntArgs & + a + + + const BoolVarArgs & + x + + + IntRelType + irt + + + int + c + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $\sum_{i=0}^{|x|-1}a_i\cdot x_i\sim_{irt} c$. + +Throws an exception of type Int::ArgumentSizeMismatch, if a and x are of different size. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::linear + (Home home, const IntArgs &a, const BoolVarArgs &x, IntRelType irt, int c, Reify r, IntConLevel icl=ICL_DEF) + linear + + Home + home + + + const IntArgs & + a + + + const BoolVarArgs & + x + + + IntRelType + irt + + + int + c + + + Reify + r + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $\left(\sum_{i=0}^{|x|-1}a_i\cdot x_i\sim_{irt} c\right)\equiv r$. + +Throws an exception of type Int::ArgumentSizeMismatch, if a and x are of different size. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::linear + (Home home, const IntArgs &a, const BoolVarArgs &x, IntRelType irt, IntVar y, IntConLevel icl=ICL_DEF) + linear + + Home + home + + + const IntArgs & + a + + + const BoolVarArgs & + x + + + IntRelType + irt + + + IntVar + y + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $\sum_{i=0}^{|x|-1}a_i\cdot x_i\sim_{irt} y$. + +Throws an exception of type Int::ArgumentSizeMismatch, if a and x are of different size. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::linear + (Home home, const IntArgs &a, const BoolVarArgs &x, IntRelType irt, IntVar y, Reify r, IntConLevel icl=ICL_DEF) + linear + + Home + home + + + const IntArgs & + a + + + const BoolVarArgs & + x + + + IntRelType + irt + + + IntVar + y + + + Reify + r + + + IntConLevel + icl + ICL_DEF + + +Post propagator for $\left(\sum_{i=0}^{|x|-1}a_i\cdot x_i\sim_{irt} y\right)\equiv r$. + +Throws an exception of type Int::ArgumentSizeMismatch, if a and x are of different size. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::binpacking + (Home home, const IntVarArgs &l, const IntVarArgs &b, const IntArgs &s, IntConLevel icl=ICL_DEF) + binpacking + + Home + home + + + const IntVarArgs & + l + + + const IntVarArgs & + b + + + const IntArgs & + s + + + IntConLevel + icl + ICL_DEF + + +Post propagator for bin packing. + +The variables in l are the loads for each bin, whereas the variables in b define for each item into which bin it is packed. The integer values s define the size of the items.It is propagated that for each $j$ with $0\leq j<|l|$ the constraint $l_j=\sum_{0\leq i<|b|\wedge b_i=j}s_i$ holds and that for each $i$ with $0\leq i<|b|$ the constraint $0\leq b_i<|l|$ holds.The propagation follows: Paul Shaw. A Constraint for Bin Packing. CP 2004.Throws the following exceptions: +Of type Int::ArgumentSizeMismatch if b and s are not of the same size.Of type Int::ArgumentSame if l and b share unassigned variables.Of type Int::OutOfLimits if s contains a negative number. + + + + + + + GECODE_INT_EXPORT IntSet + GECODE_INT_EXPORT IntSet Gecode::binpacking + (Home home, int d, const IntVarArgs &l, const IntVarArgs &b, const IntArgs &s, const IntArgs &c, IntConLevel icl=ICL_DEF) + binpacking + + Home + home + + + int + d + + + const IntVarArgs & + l + + + const IntVarArgs & + b + + + const IntArgs & + s + + + const IntArgs & + c + + + IntConLevel + icl + ICL_DEF + + + + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::nooverlap + (Home home, const IntVarArgs &x, const IntArgs &w, const IntVarArgs &y, const IntArgs &h, IntConLevel icl=ICL_DEF) + nooverlap + + Home + home + + + const IntVarArgs & + x + + + const IntArgs & + w + + + const IntVarArgs & + y + + + const IntArgs & + h + + + IntConLevel + icl + ICL_DEF + + +Post propagator for rectangle packing. + +Propagate that no two rectangles as described by the coordinates x, and y, widths w, and heights h overlap.Throws the following exceptions: +Of type Int::ArgumentSizeMismatch if x, w, y, or h are not of the same size.Of type Int::OutOfLimits if w or h contain a negative number. + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::nooverlap + (Home home, const IntVarArgs &x, const IntArgs &w, const IntVarArgs &y, const IntArgs &h, const BoolVarArgs &o, IntConLevel icl=ICL_DEF) + nooverlap + + Home + home + + + const IntVarArgs & + x + + + const IntArgs & + w + + + const IntVarArgs & + y + + + const IntArgs & + h + + + const BoolVarArgs & + o + + + IntConLevel + icl + ICL_DEF + + +Post propagator for rectangle packing. + +Propagate that no two rectangles as described by the coordinates x, and y, widths w, and heights h overlap. The rectangles can be optional, as described by the Boolean variables o.Throws the following exceptions: +Of type Int::ArgumentSizeMismatch if x, w, y, h, or o are not of the same size.Of type Int::OutOfLimits if w or h contain a negative number. + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::nooverlap + (Home home, const IntVarArgs &x0, const IntVarArgs &w, const IntVarArgs &x1, const IntVarArgs &y0, const IntVarArgs &h, const IntVarArgs &y1, IntConLevel icl=ICL_DEF) + nooverlap + + Home + home + + + const IntVarArgs & + x0 + + + const IntVarArgs & + w + + + const IntVarArgs & + x1 + + + const IntVarArgs & + y0 + + + const IntVarArgs & + h + + + const IntVarArgs & + y1 + + + IntConLevel + icl + ICL_DEF + + +Post propagator for rectangle packing. + +Propagate that no two rectangles as described by the start coordinates x0 and y0, widths w and heights h, and end coordinates x1 and y1 overlap.Note that the relations $x0_i+w_i=x1_i$ and $y0_i+h_i=y1_i$ are not propagated (for $0\leq i<|x0|$). That is, additional constraints must be posted to enforce that relation.Throws the following exceptions: +Of type Int::ArgumentSizeMismatch if x0, x1, w, y0, y1, or h are not of the same size. + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::nooverlap + (Home home, const IntVarArgs &x0, const IntVarArgs &w, const IntVarArgs &x1, const IntVarArgs &y0, const IntVarArgs &h, const IntVarArgs &y1, const BoolVarArgs &o, IntConLevel icl=ICL_DEF) + nooverlap + + Home + home + + + const IntVarArgs & + x0 + + + const IntVarArgs & + w + + + const IntVarArgs & + x1 + + + const IntVarArgs & + y0 + + + const IntVarArgs & + h + + + const IntVarArgs & + y1 + + + const BoolVarArgs & + o + + + IntConLevel + icl + ICL_DEF + + +Post propagator for rectangle packing. + +Propagate that no two rectangles as described by the start coordinates x0 and y0, widths w and heights h, and end coordinates x1 and y1 overlap. The rectangles can be optional, as described by the Boolean variables o.Note that the relations $x0_i+w_i=x1_i$ and $y0_i+h_i=y1_i$ are not propagated (for $0\leq i<|x0|$). That is, additional constraints must be posted to enforce that relation.Throws the following exceptions: +Of type Int::ArgumentSizeMismatch if x0, x1, w, y0, y1, or h are not of the same size. + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::cumulatives + (Home home, const IntVarArgs &m, const IntVarArgs &s, const IntVarArgs &p, const IntVarArgs &e, const IntVarArgs &u, const IntArgs &c, bool at_most, IntConLevel icl=ICL_DEF) + cumulatives + + Home + home + + + const IntVarArgs & + m + + + const IntVarArgs & + s + + + const IntVarArgs & + p + + + const IntVarArgs & + e + + + const IntVarArgs & + u + + + const IntArgs & + c + + + bool + at_most + + + IntConLevel + icl + ICL_DEF + + +Post propagators for the cumulatives constraint. + +This function creates propagators for the cumulatives constraint presented in "A new multi-resource cumulatives constraint +with negative heights", Nicolas Beldiceanu and Mats Carlsson, Principles and Practice of Constraint Programming 2002.The constraint models a set of machines and a set of tasks that should be assigned to the machines. The machines have a positive resource limit and the tasks each have a resource usage that can be either positive, negative, or zero. The constraint is enforced over each point in time for a machine where there is at least one task assigned.The propagator does not enforce $s_i+p_i=e_i$, this constraint has to be posted in addition to ensure consistency of the task bounds.The limit for a machine is either the maximum amount available at any given time (at_most = true), or else the least amount to be used (at_most = false). + +home + + +current space + + + +m + + +$ m_i $ is the machine assigned to task $ i $ + + + +s + + +$ s_i $ is the start time assigned to task $ i $ + + + +p + + +$ p_i $ is the processing time of task $ i $ + + + +e + + +$ e_i $ is the end time assigned to task $ i $ + + + +u + + +$ u_i $ is the amount of resources consumed by task $ i $ + + + +c + + +$ c_r $ is the capacity, the amount of resource available for machine $ r $ + + + +at_most + + +at_most tells if the amount of resources used for a machine should be less than the limit (at_most = true) or greater than the limit (at_most = false) + + + +icl + + +Supports value-consistency only (icl = ICL_VAL, default). + + + + +Int::ArgumentSizeMismatch + + +thrown if the sizes of the arguments representing tasks does not match. + + + +Int::OutOfLimits + + +thrown if any numerical argument is larger than Int::Limits::max or less than Int::Limits::min. + + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::cumulatives + (Home home, const IntArgs &m, const IntVarArgs &s, const IntVarArgs &p, const IntVarArgs &e, const IntVarArgs &u, const IntArgs &c, bool at_most, IntConLevel icl=ICL_DEF) + cumulatives + + Home + home + + + const IntArgs & + m + + + const IntVarArgs & + s + + + const IntVarArgs & + p + + + const IntVarArgs & + e + + + const IntVarArgs & + u + + + const IntArgs & + c + + + bool + at_most + + + IntConLevel + icl + ICL_DEF + + +Post propagators for the cumulatives constraint. + +Post propagators for the cumulatives constraint. This function creates propagators for the cumulatives constraint presented in "A new multi-resource cumulatives constraint +with negative heights", Nicolas Beldiceanu and Mats Carlsson, Principles and Practice of Constraint Programming 2002.The constraint models a set of machines and a set of tasks that should be assigned to the machines. The machines have a positive resource limit and the tasks each have a resource usage that can be either positive, negative, or zero. The constraint is enforced over each point in time for a machine where there is at least one task assigned.The propagator does not enforce $s_i+p_i=e_i$, this constraint has to be posted in addition to ensure consistency of the task bounds.The limit for a machine is either the maximum amount available at any given time (at_most = true), or else the least amount to be used (at_most = false). + +home + + +current space + + + +m + + +$ m_i $ is the machine assigned to task $ i $ + + + +s + + +$ s_i $ is the start time assigned to task $ i $ + + + +p + + +$ p_i $ is the processing time of task $ i $ + + + +e + + +$ e_i $ is the end time assigned to task $ i $ + + + +u + + +$ u_i $ is the amount of resources consumed by task $ i $ + + + +c + + +$ c_r $ is the capacity, the amount of resource available for machine $ r $ + + + +at_most + + +at_most tells if the amount of resources used for a machine should be less than the limit (at_most = true) or greater than the limit (at_most = false) + + + +icl + + +Supports value-consistency only (icl = ICL_VAL, default). + + + + +Int::ArgumentSizeMismatch + + +thrown if the sizes of the arguments representing tasks does not match. + + + +Int::OutOfLimits + + +thrown if any numerical argument is larger than Int::Limits::max or less than Int::Limits::min. + + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::cumulatives + (Home home, const IntVarArgs &m, const IntVarArgs &s, const IntArgs &p, const IntVarArgs &e, const IntVarArgs &u, const IntArgs &c, bool at_most, IntConLevel icl=ICL_DEF) + cumulatives + + Home + home + + + const IntVarArgs & + m + + + const IntVarArgs & + s + + + const IntArgs & + p + + + const IntVarArgs & + e + + + const IntVarArgs & + u + + + const IntArgs & + c + + + bool + at_most + + + IntConLevel + icl + ICL_DEF + + +Post propagators for the cumulatives constraint. + +Post propagators for the cumulatives constraint. This function creates propagators for the cumulatives constraint presented in "A new multi-resource cumulatives constraint +with negative heights", Nicolas Beldiceanu and Mats Carlsson, Principles and Practice of Constraint Programming 2002.The constraint models a set of machines and a set of tasks that should be assigned to the machines. The machines have a positive resource limit and the tasks each have a resource usage that can be either positive, negative, or zero. The constraint is enforced over each point in time for a machine where there is at least one task assigned.The propagator does not enforce $s_i+p_i=e_i$, this constraint has to be posted in addition to ensure consistency of the task bounds.The limit for a machine is either the maximum amount available at any given time (at_most = true), or else the least amount to be used (at_most = false). + +home + + +current space + + + +m + + +$ m_i $ is the machine assigned to task $ i $ + + + +s + + +$ s_i $ is the start time assigned to task $ i $ + + + +p + + +$ p_i $ is the processing time of task $ i $ + + + +e + + +$ e_i $ is the end time assigned to task $ i $ + + + +u + + +$ u_i $ is the amount of resources consumed by task $ i $ + + + +c + + +$ c_r $ is the capacity, the amount of resource available for machine $ r $ + + + +at_most + + +at_most tells if the amount of resources used for a machine should be less than the limit (at_most = true) or greater than the limit (at_most = false) + + + +icl + + +Supports value-consistency only (icl = ICL_VAL, default). + + + + +Int::ArgumentSizeMismatch + + +thrown if the sizes of the arguments representing tasks does not match. + + + +Int::OutOfLimits + + +thrown if any numerical argument is larger than Int::Limits::max or less than Int::Limits::min. + + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::cumulatives + (Home home, const IntArgs &m, const IntVarArgs &s, const IntArgs &p, const IntVarArgs &e, const IntVarArgs &u, const IntArgs &c, bool at_most, IntConLevel icl=ICL_DEF) + cumulatives + + Home + home + + + const IntArgs & + m + + + const IntVarArgs & + s + + + const IntArgs & + p + + + const IntVarArgs & + e + + + const IntVarArgs & + u + + + const IntArgs & + c + + + bool + at_most + + + IntConLevel + icl + ICL_DEF + + +Post propagators for the cumulatives constraint. + +Post propagators for the cumulatives constraint. This function creates propagators for the cumulatives constraint presented in "A new multi-resource cumulatives constraint +with negative heights", Nicolas Beldiceanu and Mats Carlsson, Principles and Practice of Constraint Programming 2002.The constraint models a set of machines and a set of tasks that should be assigned to the machines. The machines have a positive resource limit and the tasks each have a resource usage that can be either positive, negative, or zero. The constraint is enforced over each point in time for a machine where there is at least one task assigned.The propagator does not enforce $s_i+p_i=e_i$, this constraint has to be posted in addition to ensure consistency of the task bounds.The limit for a machine is either the maximum amount available at any given time (at_most = true), or else the least amount to be used (at_most = false). + +home + + +current space + + + +m + + +$ m_i $ is the machine assigned to task $ i $ + + + +s + + +$ s_i $ is the start time assigned to task $ i $ + + + +p + + +$ p_i $ is the processing time of task $ i $ + + + +e + + +$ e_i $ is the end time assigned to task $ i $ + + + +u + + +$ u_i $ is the amount of resources consumed by task $ i $ + + + +c + + +$ c_r $ is the capacity, the amount of resource available for machine $ r $ + + + +at_most + + +at_most tells if the amount of resources used for a machine should be less than the limit (at_most = true) or greater than the limit (at_most = false) + + + +icl + + +Supports value-consistency only (icl = ICL_VAL, default). + + + + +Int::ArgumentSizeMismatch + + +thrown if the sizes of the arguments representing tasks does not match. + + + +Int::OutOfLimits + + +thrown if any numerical argument is larger than Int::Limits::max or less than Int::Limits::min. + + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::cumulatives + (Home home, const IntVarArgs &m, const IntVarArgs &s, const IntVarArgs &p, const IntVarArgs &e, const IntArgs &u, const IntArgs &c, bool at_most, IntConLevel icl=ICL_DEF) + cumulatives + + Home + home + + + const IntVarArgs & + m + + + const IntVarArgs & + s + + + const IntVarArgs & + p + + + const IntVarArgs & + e + + + const IntArgs & + u + + + const IntArgs & + c + + + bool + at_most + + + IntConLevel + icl + ICL_DEF + + +Post propagators for the cumulatives constraint. + +Post propagators for the cumulatives constraint. This function creates propagators for the cumulatives constraint presented in "A new multi-resource cumulatives constraint +with negative heights", Nicolas Beldiceanu and Mats Carlsson, Principles and Practice of Constraint Programming 2002.The constraint models a set of machines and a set of tasks that should be assigned to the machines. The machines have a positive resource limit and the tasks each have a resource usage that can be either positive, negative, or zero. The constraint is enforced over each point in time for a machine where there is at least one task assigned.The propagator does not enforce $s_i+p_i=e_i$, this constraint has to be posted in addition to ensure consistency of the task bounds.The limit for a machine is either the maximum amount available at any given time (at_most = true), or else the least amount to be used (at_most = false). + +home + + +current space + + + +m + + +$ m_i $ is the machine assigned to task $ i $ + + + +s + + +$ s_i $ is the start time assigned to task $ i $ + + + +p + + +$ p_i $ is the processing time of task $ i $ + + + +e + + +$ e_i $ is the end time assigned to task $ i $ + + + +u + + +$ u_i $ is the amount of resources consumed by task $ i $ + + + +c + + +$ c_r $ is the capacity, the amount of resource available for machine $ r $ + + + +at_most + + +at_most tells if the amount of resources used for a machine should be less than the limit (at_most = true) or greater than the limit (at_most = false) + + + +icl + + +Supports value-consistency only (icl = ICL_VAL, default). + + + + +Int::ArgumentSizeMismatch + + +thrown if the sizes of the arguments representing tasks does not match. + + + +Int::OutOfLimits + + +thrown if any numerical argument is larger than Int::Limits::max or less than Int::Limits::min. + + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::cumulatives + (Home home, const IntArgs &m, const IntVarArgs &s, const IntVarArgs &p, const IntVarArgs &e, const IntArgs &u, const IntArgs &c, bool at_most, IntConLevel icl=ICL_DEF) + cumulatives + + Home + home + + + const IntArgs & + m + + + const IntVarArgs & + s + + + const IntVarArgs & + p + + + const IntVarArgs & + e + + + const IntArgs & + u + + + const IntArgs & + c + + + bool + at_most + + + IntConLevel + icl + ICL_DEF + + +Post propagators for the cumulatives constraint. + +Post propagators for the cumulatives constraint. This function creates propagators for the cumulatives constraint presented in "A new multi-resource cumulatives constraint +with negative heights", Nicolas Beldiceanu and Mats Carlsson, Principles and Practice of Constraint Programming 2002.The constraint models a set of machines and a set of tasks that should be assigned to the machines. The machines have a positive resource limit and the tasks each have a resource usage that can be either positive, negative, or zero. The constraint is enforced over each point in time for a machine where there is at least one task assigned.The propagator does not enforce $s_i+p_i=e_i$, this constraint has to be posted in addition to ensure consistency of the task bounds.The limit for a machine is either the maximum amount available at any given time (at_most = true), or else the least amount to be used (at_most = false). + +home + + +current space + + + +m + + +$ m_i $ is the machine assigned to task $ i $ + + + +s + + +$ s_i $ is the start time assigned to task $ i $ + + + +p + + +$ p_i $ is the processing time of task $ i $ + + + +e + + +$ e_i $ is the end time assigned to task $ i $ + + + +u + + +$ u_i $ is the amount of resources consumed by task $ i $ + + + +c + + +$ c_r $ is the capacity, the amount of resource available for machine $ r $ + + + +at_most + + +at_most tells if the amount of resources used for a machine should be less than the limit (at_most = true) or greater than the limit (at_most = false) + + + +icl + + +Supports value-consistency only (icl = ICL_VAL, default). + + + + +Int::ArgumentSizeMismatch + + +thrown if the sizes of the arguments representing tasks does not match. + + + +Int::OutOfLimits + + +thrown if any numerical argument is larger than Int::Limits::max or less than Int::Limits::min. + + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::cumulatives + (Home home, const IntVarArgs &m, const IntVarArgs &s, const IntArgs &p, const IntVarArgs &e, const IntArgs &u, const IntArgs &c, bool at_most, IntConLevel icl=ICL_DEF) + cumulatives + + Home + home + + + const IntVarArgs & + m + + + const IntVarArgs & + s + + + const IntArgs & + p + + + const IntVarArgs & + e + + + const IntArgs & + u + + + const IntArgs & + c + + + bool + at_most + + + IntConLevel + icl + ICL_DEF + + +Post propagators for the cumulatives constraint. + +Post propagators for the cumulatives constraint. This function creates propagators for the cumulatives constraint presented in "A new multi-resource cumulatives constraint +with negative heights", Nicolas Beldiceanu and Mats Carlsson, Principles and Practice of Constraint Programming 2002.The constraint models a set of machines and a set of tasks that should be assigned to the machines. The machines have a positive resource limit and the tasks each have a resource usage that can be either positive, negative, or zero. The constraint is enforced over each point in time for a machine where there is at least one task assigned.The propagator does not enforce $s_i+p_i=e_i$, this constraint has to be posted in addition to ensure consistency of the task bounds.The limit for a machine is either the maximum amount available at any given time (at_most = true), or else the least amount to be used (at_most = false). + +home + + +current space + + + +m + + +$ m_i $ is the machine assigned to task $ i $ + + + +s + + +$ s_i $ is the start time assigned to task $ i $ + + + +p + + +$ p_i $ is the processing time of task $ i $ + + + +e + + +$ e_i $ is the end time assigned to task $ i $ + + + +u + + +$ u_i $ is the amount of resources consumed by task $ i $ + + + +c + + +$ c_r $ is the capacity, the amount of resource available for machine $ r $ + + + +at_most + + +at_most tells if the amount of resources used for a machine should be less than the limit (at_most = true) or greater than the limit (at_most = false) + + + +icl + + +Supports value-consistency only (icl = ICL_VAL, default). + + + + +Int::ArgumentSizeMismatch + + +thrown if the sizes of the arguments representing tasks does not match. + + + +Int::OutOfLimits + + +thrown if any numerical argument is larger than Int::Limits::max or less than Int::Limits::min. + + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::cumulatives + (Home home, const IntArgs &m, const IntVarArgs &s, const IntArgs &p, const IntVarArgs &e, const IntArgs &u, const IntArgs &c, bool at_most, IntConLevel icl=ICL_DEF) + cumulatives + + Home + home + + + const IntArgs & + m + + + const IntVarArgs & + s + + + const IntArgs & + p + + + const IntVarArgs & + e + + + const IntArgs & + u + + + const IntArgs & + c + + + bool + at_most + + + IntConLevel + icl + ICL_DEF + + +Post propagators for the cumulatives constraint. + +Post propagators for the cumulatives constraint. This function creates propagators for the cumulatives constraint presented in "A new multi-resource cumulatives constraint +with negative heights", Nicolas Beldiceanu and Mats Carlsson, Principles and Practice of Constraint Programming 2002.The constraint models a set of machines and a set of tasks that should be assigned to the machines. The machines have a positive resource limit and the tasks each have a resource usage that can be either positive, negative, or zero. The constraint is enforced over each point in time for a machine where there is at least one task assigned.The propagator does not enforce $s_i+p_i=e_i$, this constraint has to be posted in addition to ensure consistency of the task bounds.The limit for a machine is either the maximum amount available at any given time (at_most = true), or else the least amount to be used (at_most = false). + +home + + +current space + + + +m + + +$ m_i $ is the machine assigned to task $ i $ + + + +s + + +$ s_i $ is the start time assigned to task $ i $ + + + +p + + +$ p_i $ is the processing time of task $ i $ + + + +e + + +$ e_i $ is the end time assigned to task $ i $ + + + +u + + +$ u_i $ is the amount of resources consumed by task $ i $ + + + +c + + +$ c_r $ is the capacity, the amount of resource available for machine $ r $ + + + +at_most + + +at_most tells if the amount of resources used for a machine should be less than the limit (at_most = true) or greater than the limit (at_most = false) + + + +icl + + +Supports value-consistency only (icl = ICL_VAL, default). + + + + +Int::ArgumentSizeMismatch + + +thrown if the sizes of the arguments representing tasks does not match. + + + +Int::OutOfLimits + + +thrown if any numerical argument is larger than Int::Limits::max or less than Int::Limits::min. + + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::unary + (Home home, const IntVarArgs &s, const IntArgs &p, IntConLevel icl=ICL_DEF) + unary + + Home + home + + + const IntVarArgs & + s + + + const IntArgs & + p + + + IntConLevel + icl + ICL_DEF + + +Post propagators for scheduling tasks on unary resources. + +Schedule tasks with start times s and processing times p on a unary resource. The propagator uses the algorithms from: Petr Vilím, Global Constraints in Scheduling, PhD thesis, Charles University, Prague, Czech Republic, 2007.The propagator performs overload checking, detectable precendence propagation, not-first-not-last propagation, and edge finding. +Throws an exception of type Int::ArgumentSizeMismatch, if s and p are of different size.Throws an exception of type Int::ArgumentSame, if s contains the same unassigned variable multiply.Throws an exception of type Int::OutOfLimits, if p contains an integer that is negative or that could generate an overflow. + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::unary + (Home home, const IntVarArgs &s, const IntArgs &p, const BoolVarArgs &m, IntConLevel icl=ICL_DEF) + unary + + Home + home + + + const IntVarArgs & + s + + + const IntArgs & + p + + + const BoolVarArgs & + m + + + IntConLevel + icl + ICL_DEF + + +Post propagators for scheduling optional tasks on unary resources. + +Schedule optional tasks with start times s, processing times p, and whether a task is mandatory m (a task is mandatory if the Boolean variable is 1) on a unary resource. The propagator uses the algorithms from: Petr Vilím, Global Constraints in Scheduling, PhD thesis, Charles University, Prague, Czech Republic, 2007.The propagator performs overload checking, detectable precendence propagation, not-first-not-last propagation, and edge finding. +Throws an exception of type Int::ArgumentSizeMismatch, if s, p, or m are of different size.Throws an exception of type Int::ArgumentSame, if s contains the same unassigned variable multiply.Throws an exception of type Int::OutOfLimits, if p contains an integer that is negative or that could generate an overflow. + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::unary + (Home home, const TaskTypeArgs &t, const IntVarArgs &flex, const IntArgs &fix, IntConLevel icl=ICL_DEF) + unary + + Home + home + + + const TaskTypeArgs & + t + + + const IntVarArgs & + flex + + + const IntArgs & + fix + + + IntConLevel + icl + ICL_DEF + + +Post propagators for scheduling tasks on unary resources. + +Schedule tasks with flexible times flex and fixed times fix on a unary resource. For each task, it depends on t how the flexible and fix times are interpreted: +If t[i] is TT_FIXP, then flex[i] is the start time and fix[i] is the processing time.If t[i] is TT_FIXS, then flex[i] is the end time and fix[i] is the start time.If t[i] is TT_FIXE, then flex[i] is the start time and fix[i] is the end time. +The propagator uses the algorithms from: Petr Vilím, Global Constraints in Scheduling, PhD thesis, Charles University, Prague, Czech Republic, 2007.The propagator performs overload checking, detectable precendence propagation, not-first-not-last propagation, and edge finding. +Throws an exception of type Int::ArgumentSizeMismatch, if s and p are of different size.Throws an exception of type Int::OutOfLimits, if p contains an integer that is negative for a task with type TT_FIXP or that could generate an overflow. + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::unary + (Home home, const TaskTypeArgs &t, const IntVarArgs &flex, const IntArgs &fix, const BoolVarArgs &m, IntConLevel icl=ICL_DEF) + unary + + Home + home + + + const TaskTypeArgs & + t + + + const IntVarArgs & + flex + + + const IntArgs & + fix + + + const BoolVarArgs & + m + + + IntConLevel + icl + ICL_DEF + + +Post propagators for scheduling optional tasks on unary resources. + +Schedule optional tasks with flexible times flex, fixed times fix, and whether a task is mandatory m (a task is mandatory if the Boolean variable is 1) on a unary resource. For each task, it depends on t how the flexible and fix times are interpreted: +If t[i] is TT_FIXP, then flex[i] is the start time and fix[i] is the processing time.If t[i] is TT_FIXS, then flex[i] is the end time and fix[i] is the start time.If t[i] is TT_FIXE, then flex[i] is the start time and fix[i] is the end time. +The propagator uses the algorithms from: Petr Vilím, Global Constraints in Scheduling, PhD thesis, Charles University, Prague, Czech Republic, 2007.The propagator performs overload checking, detectable precendence propagation, not-first-not-last propagation, and edge finding. +Throws an exception of type Int::ArgumentSizeMismatch, if s, p, or m are of different size.Throws an exception of type Int::OutOfLimits, if p contains an integer that is negative for a task with type TT_FIXP or that could generate an overflow. + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::unary + (Home home, const IntVarArgs &s, const IntVarArgs &p, const IntVarArgs &e, IntConLevel icl=ICL_DEF) + unary + + Home + home + + + const IntVarArgs & + s + + + const IntVarArgs & + p + + + const IntVarArgs & + e + + + IntConLevel + icl + ICL_DEF + + +Post propagators for scheduling tasks on unary resources. + +Schedule tasks with start times s, processing times p, and end times e on a unary resource. The propagator uses the algorithms from: Petr Vilím, Global Constraints in Scheduling, PhD thesis, Charles University, Prague, Czech Republic, 2007.The propagator does not enforce $s_i+p_i=e_i$, this constraint has to be posted in addition to ensure consistency of the task bounds.The propagator performs overload checking, detectable precendence propagation, not-first-not-last propagation, and edge finding.The processing times are constrained to be non-negative.Throws an exception of type Int::ArgumentSizeMismatch, if s and p are of different size. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::unary + (Home home, const IntVarArgs &s, const IntVarArgs &p, const IntVarArgs &e, const BoolVarArgs &m, IntConLevel icl=ICL_DEF) + unary + + Home + home + + + const IntVarArgs & + s + + + const IntVarArgs & + p + + + const IntVarArgs & + e + + + const BoolVarArgs & + m + + + IntConLevel + icl + ICL_DEF + + +Post propagators for scheduling optional tasks on unary resources. + +Schedule optional tasks with start times s, processing times p, end times e, and whether a task is mandatory m (a task is mandatory if the Boolean variable is 1) on a unary resource. The propagator uses the algorithms from: Petr Vilím, Global Constraints in Scheduling, PhD thesis, Charles University, Prague, Czech Republic, 2007.The propagator does not enforce $s_i+p_i=e_i$, this constraint has to be posted in addition to ensure consistency of the task bounds.The processing times are constrained to be non-negative.The propagator performs overload checking, detectable precendence propagation, not-first-not-last propagation, and edge finding.Throws an exception of type Int::ArgumentSizeMismatch, if s, p, or m are of different size. + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::cumulative + (Home home, int c, const TaskTypeArgs &t, const IntVarArgs &flex, const IntArgs &fix, const IntArgs &u, IntConLevel icl=ICL_DEF) + cumulative + + Home + home + + + int + c + + + const TaskTypeArgs & + t + + + const IntVarArgs & + flex + + + const IntArgs & + fix + + + const IntArgs & + u + + + IntConLevel + icl + ICL_DEF + + +Post propagators for scheduling tasks on cumulative resources. + +Schedule tasks with flexible times flex, fixed times fix, and use capacity u on a cumulative resource with capacity c. For each task, it depends on t how the flexible and fix times are interpreted: +If t[i] is TT_FIXP, then flex[i] is the start time and fix[i] is the processing time.If t[i] is TT_FIXS, then flex[i] is the end time and fix[i] is the start time.If t[i] is TT_FIXE, then flex[i] is the start time and fix[i] is the end time. +The propagator performs time-tabling, overload checking, and edge-finding. It uses algorithms taken from:Petr Vilím, Max Energy Filtering Algorithm for Discrete Cumulative Resources, in W. J. van Hoeve and J. N. Hooker, editors, CPAIOR, volume 5547 of LNCS, pages 294-308. Springer, 2009.andPetr Vilím, Edge finding filtering algorithm for discrete cumulative resources in O(kn log n). In I. P. Gent, editor, CP, volume 5732 of LNCS, pages 802-816. Springer, 2009. +Throws an exception of type Int::ArgumentSizeMismatch, if t, s p, or u are of different size.Throws an exception of type Int::OutOfLimits, if p, u, or c contain an integer that is not nonnegative, or that could generate an overflow. + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::cumulative + (Home home, IntVar c, const TaskTypeArgs &t, const IntVarArgs &flex, const IntArgs &fix, const IntArgs &u, IntConLevel icl=ICL_DEF) + cumulative + + Home + home + + + IntVar + c + + + const TaskTypeArgs & + t + + + const IntVarArgs & + flex + + + const IntArgs & + fix + + + const IntArgs & + u + + + IntConLevel + icl + ICL_DEF + + +Post propagators for scheduling tasks on cumulative resources. + +Post propagators for scheduling tasks on cumulative resources. Schedule tasks with flexible times flex, fixed times fix, and use capacity u on a cumulative resource with capacity c. For each task, it depends on t how the flexible and fix times are interpreted: +If t[i] is TT_FIXP, then flex[i] is the start time and fix[i] is the processing time.If t[i] is TT_FIXS, then flex[i] is the end time and fix[i] is the start time.If t[i] is TT_FIXE, then flex[i] is the start time and fix[i] is the end time. +The propagator performs time-tabling, overload checking, and edge-finding. It uses algorithms taken from:Petr Vilím, Max Energy Filtering Algorithm for Discrete Cumulative Resources, in W. J. van Hoeve and J. N. Hooker, editors, CPAIOR, volume 5547 of LNCS, pages 294-308. Springer, 2009.andPetr Vilím, Edge finding filtering algorithm for discrete cumulative resources in O(kn log n). In I. P. Gent, editor, CP, volume 5732 of LNCS, pages 802-816. Springer, 2009. +Throws an exception of type Int::ArgumentSizeMismatch, if t, s p, or u are of different size.Throws an exception of type Int::OutOfLimits, if p, u, or c contain an integer that is not nonnegative, or that could generate an overflow. + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::cumulative + (Home home, int c, const TaskTypeArgs &t, const IntVarArgs &flex, const IntArgs &fix, const IntArgs &u, const BoolVarArgs &m, IntConLevel icl=ICL_DEF) + cumulative + + Home + home + + + int + c + + + const TaskTypeArgs & + t + + + const IntVarArgs & + flex + + + const IntArgs & + fix + + + const IntArgs & + u + + + const BoolVarArgs & + m + + + IntConLevel + icl + ICL_DEF + + +Post propagators for scheduling optional tasks on cumulative resources. + +Schedule tasks with flexible times flex, fixed times fix, use capacity u, and whether a task is mandatory m (a task is mandatory if the Boolean variable is 1) on a cumulative resource with capacity c. For each task, it depends on t how the flexible and fix times are interpreted: +If t[i] is TT_FIXP, then flex[i] is the start time and fix[i] is the processing time.If t[i] is TT_FIXS, then flex[i] is the end time and fix[i] is the start time.If t[i] is TT_FIXE, then flex[i] is the start time and fix[i] is the end time. +The propagator performs time-tabling, overload checking, and edge-finding. It uses algorithms taken from:Petr Vilím, Max Energy Filtering Algorithm for Discrete Cumulative Resources, in W. J. van Hoeve and J. N. Hooker, editors, CPAIOR, volume 5547 of LNCS, pages 294-308. Springer, 2009.andPetr Vilím, Edge finding filtering algorithm for discrete cumulative resources in O(kn log n). In I. P. Gent, editor, CP, volume 5732 of LNCS, pages 802-816. Springer, 2009. +Throws an exception of type Int::ArgumentSizeMismatch, if t, s p, or u are of different size.Throws an exception of type Int::OutOfLimits, if p, u, or c contain an integer that is not nonnegative, or that could generate an overflow. + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::cumulative + (Home home, IntVar c, const TaskTypeArgs &t, const IntVarArgs &flex, const IntArgs &fix, const IntArgs &u, const BoolVarArgs &m, IntConLevel icl=ICL_DEF) + cumulative + + Home + home + + + IntVar + c + + + const TaskTypeArgs & + t + + + const IntVarArgs & + flex + + + const IntArgs & + fix + + + const IntArgs & + u + + + const BoolVarArgs & + m + + + IntConLevel + icl + ICL_DEF + + +Post propagators for scheduling optional tasks on cumulative resources. + +Post propagators for scheduling optional tasks on cumulative resources. Schedule tasks with flexible times flex, fixed times fix, use capacity u, and whether a task is mandatory m (a task is mandatory if the Boolean variable is 1) on a cumulative resource with capacity c. For each task, it depends on t how the flexible and fix times are interpreted: +If t[i] is TT_FIXP, then flex[i] is the start time and fix[i] is the processing time.If t[i] is TT_FIXS, then flex[i] is the end time and fix[i] is the start time.If t[i] is TT_FIXE, then flex[i] is the start time and fix[i] is the end time. +The propagator performs time-tabling, overload checking, and edge-finding. It uses algorithms taken from:Petr Vilím, Max Energy Filtering Algorithm for Discrete Cumulative Resources, in W. J. van Hoeve and J. N. Hooker, editors, CPAIOR, volume 5547 of LNCS, pages 294-308. Springer, 2009.andPetr Vilím, Edge finding filtering algorithm for discrete cumulative resources in O(kn log n). In I. P. Gent, editor, CP, volume 5732 of LNCS, pages 802-816. Springer, 2009. +Throws an exception of type Int::ArgumentSizeMismatch, if t, s p, or u are of different size.Throws an exception of type Int::OutOfLimits, if p, u, or c contain an integer that is not nonnegative, or that could generate an overflow. + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::cumulative + (Home home, int c, const IntVarArgs &s, const IntArgs &p, const IntArgs &u, IntConLevel icl=ICL_DEF) + cumulative + + Home + home + + + int + c + + + const IntVarArgs & + s + + + const IntArgs & + p + + + const IntArgs & + u + + + IntConLevel + icl + ICL_DEF + + +Post propagators for scheduling tasks on cumulative resources. + +Schedule tasks with start times s, processing times p, and use capacity u on a cumulative resource with capacity c.The propagator performs time-tabling, overload checking, and edge-finding. It uses algorithms taken from:Petr Vilím, Max Energy Filtering Algorithm for Discrete Cumulative Resources, in W. J. van Hoeve and J. N. Hooker, editors, CPAIOR, volume 5547 of LNCS, pages 294-308. Springer, 2009.andPetr Vilím, Edge finding filtering algorithm for discrete cumulative resources in O(kn log n). In I. P. Gent, editor, CP, volume 5732 of LNCS, pages 802-816. Springer, 2009. +Throws an exception of type Int::ArgumentSizeMismatch, if s p, or u are of different size.Throws an exception of type Int::OutOfLimits, if p, u, or c contain an integer that is not nonnegative, or that could generate an overflow. + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::cumulative + (Home home, IntVar c, const IntVarArgs &s, const IntArgs &p, const IntArgs &u, IntConLevel icl=ICL_DEF) + cumulative + + Home + home + + + IntVar + c + + + const IntVarArgs & + s + + + const IntArgs & + p + + + const IntArgs & + u + + + IntConLevel + icl + ICL_DEF + + +Post propagators for scheduling tasks on cumulative resources. + +Post propagators for scheduling tasks on cumulative resources. Schedule tasks with start times s, processing times p, and use capacity u on a cumulative resource with capacity c.The propagator performs time-tabling, overload checking, and edge-finding. It uses algorithms taken from:Petr Vilím, Max Energy Filtering Algorithm for Discrete Cumulative Resources, in W. J. van Hoeve and J. N. Hooker, editors, CPAIOR, volume 5547 of LNCS, pages 294-308. Springer, 2009.andPetr Vilím, Edge finding filtering algorithm for discrete cumulative resources in O(kn log n). In I. P. Gent, editor, CP, volume 5732 of LNCS, pages 802-816. Springer, 2009. +Throws an exception of type Int::ArgumentSizeMismatch, if s p, or u are of different size.Throws an exception of type Int::OutOfLimits, if p, u, or c contain an integer that is not nonnegative, or that could generate an overflow. + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::cumulative + (Home home, int c, const IntVarArgs &s, const IntArgs &p, const IntArgs &u, const BoolVarArgs &m, IntConLevel icl=ICL_DEF) + cumulative + + Home + home + + + int + c + + + const IntVarArgs & + s + + + const IntArgs & + p + + + const IntArgs & + u + + + const BoolVarArgs & + m + + + IntConLevel + icl + ICL_DEF + + +Post propagators for scheduling optional tasks on cumulative resources. + +Schedule optional tasks with start times s, processing times p, used capacity u, and whether a task is mandatory m (a task is mandatory if the Boolean variable is 1) on a cumulative resource with capacity c.The propagator performs time-tabling, overload checking, and edge-finding. It uses algorithms taken from:Petr Vilím, Max Energy Filtering Algorithm for Discrete Cumulative Resources, in W. J. van Hoeve and J. N. Hooker, editors, CPAIOR, volume 5547 of LNCS, pages 294-308. Springer, 2009.andPetr Vilím, Edge finding filtering algorithm for discrete cumulative resources in O(kn log n). In I. P. Gent, editor, CP, volume 5732 of LNCS, pages 802-816. Springer, 2009. +Throws an exception of type Int::ArgumentSizeMismatch, if s, p, u, or m are of different size.Throws an exception of type Int::OutOfLimits, if p, u, or c contain an integer that is not nonnegative, or that could generate an overflow. + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::cumulative + (Home home, IntVar c, const IntVarArgs &s, const IntArgs &p, const IntArgs &u, const BoolVarArgs &m, IntConLevel icl=ICL_DEF) + cumulative + + Home + home + + + IntVar + c + + + const IntVarArgs & + s + + + const IntArgs & + p + + + const IntArgs & + u + + + const BoolVarArgs & + m + + + IntConLevel + icl + ICL_DEF + + +Post propagators for scheduling optional tasks on cumulative resources. + +Post propagators for scheduling optional tasks on cumulative resources. Schedule optional tasks with start times s, processing times p, used capacity u, and whether a task is mandatory m (a task is mandatory if the Boolean variable is 1) on a cumulative resource with capacity c.The propagator performs time-tabling, overload checking, and edge-finding. It uses algorithms taken from:Petr Vilím, Max Energy Filtering Algorithm for Discrete Cumulative Resources, in W. J. van Hoeve and J. N. Hooker, editors, CPAIOR, volume 5547 of LNCS, pages 294-308. Springer, 2009.andPetr Vilím, Edge finding filtering algorithm for discrete cumulative resources in O(kn log n). In I. P. Gent, editor, CP, volume 5732 of LNCS, pages 802-816. Springer, 2009. +Throws an exception of type Int::ArgumentSizeMismatch, if s, p, u, or m are of different size.Throws an exception of type Int::OutOfLimits, if p, u, or c contain an integer that is not nonnegative, or that could generate an overflow. + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::cumulative + (Home home, int c, const IntVarArgs &s, const IntVarArgs &p, const IntVarArgs &e, const IntArgs &u, IntConLevel icl=ICL_DEF) + cumulative + + Home + home + + + int + c + + + const IntVarArgs & + s + + + const IntVarArgs & + p + + + const IntVarArgs & + e + + + const IntArgs & + u + + + IntConLevel + icl + ICL_DEF + + +Post propagators for scheduling tasks on cumulative resources. + +Schedule tasks with start times s, processing times p, end times e, and use capacity u on a cumulative resource with capacity c.The propagator does not enforce $s_i+p_i=e_i$, this constraint has to be posted in addition to ensure consistency of the task bounds.The propagator performs time-tabling, overload checking, and edge-finding. It uses algorithms taken from:Petr Vilím, Max Energy Filtering Algorithm for Discrete Cumulative Resources, in W. J. van Hoeve and J. N. Hooker, editors, CPAIOR, volume 5547 of LNCS, pages 294-308. Springer, 2009.andPetr Vilím, Edge finding filtering algorithm for discrete cumulative resources in O(kn log n). In I. P. Gent, editor, CP, volume 5732 of LNCS, pages 802-816. Springer, 2009. +Throws an exception of type Int::ArgumentSizeMismatch, if s p, or u are of different size.Throws an exception of type Int::OutOfLimits, if u or c contain an integer that is not nonnegative, or that could generate an overflow. + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::cumulative + (Home home, IntVar c, const IntVarArgs &s, const IntVarArgs &p, const IntVarArgs &e, const IntArgs &u, IntConLevel icl=ICL_DEF) + cumulative + + Home + home + + + IntVar + c + + + const IntVarArgs & + s + + + const IntVarArgs & + p + + + const IntVarArgs & + e + + + const IntArgs & + u + + + IntConLevel + icl + ICL_DEF + + +Post propagators for scheduling tasks on cumulative resources. + +Post propagators for scheduling tasks on cumulative resources. Schedule tasks with start times s, processing times p, end times e, and use capacity u on a cumulative resource with capacity c.The propagator does not enforce $s_i+p_i=e_i$, this constraint has to be posted in addition to ensure consistency of the task bounds.The propagator performs time-tabling, overload checking, and edge-finding. It uses algorithms taken from:Petr Vilím, Max Energy Filtering Algorithm for Discrete Cumulative Resources, in W. J. van Hoeve and J. N. Hooker, editors, CPAIOR, volume 5547 of LNCS, pages 294-308. Springer, 2009.andPetr Vilím, Edge finding filtering algorithm for discrete cumulative resources in O(kn log n). In I. P. Gent, editor, CP, volume 5732 of LNCS, pages 802-816. Springer, 2009. +Throws an exception of type Int::ArgumentSizeMismatch, if s p, or u are of different size.Throws an exception of type Int::OutOfLimits, if u or c contain an integer that is not nonnegative, or that could generate an overflow. + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::cumulative + (Home home, int c, const IntVarArgs &s, const IntVarArgs &p, const IntVarArgs &e, const IntArgs &u, const BoolVarArgs &m, IntConLevel icl=ICL_DEF) + cumulative + + Home + home + + + int + c + + + const IntVarArgs & + s + + + const IntVarArgs & + p + + + const IntVarArgs & + e + + + const IntArgs & + u + + + const BoolVarArgs & + m + + + IntConLevel + icl + ICL_DEF + + +Post propagators for scheduling optional tasks on cumulative resources. + +Schedule optional tasks with start times s, processing times p, end times e, used capacity u, and whether a task is mandatory m (a task is mandatory if the Boolean variable is 1) on a cumulative resource with capacity c.The propagator does not enforce $s_i+p_i=e_i$, this constraint has to be posted in addition to ensure consistency of the task bounds.The propagator performs time-tabling, overload checking, and edge-finding. It uses algorithms taken from:Petr Vilím, Max Energy Filtering Algorithm for Discrete Cumulative Resources, in W. J. van Hoeve and J. N. Hooker, editors, CPAIOR, volume 5547 of LNCS, pages 294-308. Springer, 2009.andPetr Vilím, Edge finding filtering algorithm for discrete cumulative resources in O(kn log n). In I. P. Gent, editor, CP, volume 5732 of LNCS, pages 802-816. Springer, 2009. +Throws an exception of type Int::ArgumentSizeMismatch, if s, p, u, or m are of different size.Throws an exception of type Int::OutOfLimits, if u or c contain an integer that is not nonnegative, or that could generate an overflow. + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::cumulative + (Home home, IntVar c, const IntVarArgs &s, const IntVarArgs &p, const IntVarArgs &e, const IntArgs &u, const BoolVarArgs &m, IntConLevel icl=ICL_DEF) + cumulative + + Home + home + + + IntVar + c + + + const IntVarArgs & + s + + + const IntVarArgs & + p + + + const IntVarArgs & + e + + + const IntArgs & + u + + + const BoolVarArgs & + m + + + IntConLevel + icl + ICL_DEF + + +Post propagators for scheduling optional tasks on cumulative resources. + +Post propagators for scheduling optional tasks on cumulative resources. Schedule optional tasks with start times s, processing times p, end times e, used capacity u, and whether a task is mandatory m (a task is mandatory if the Boolean variable is 1) on a cumulative resource with capacity c.The propagator does not enforce $s_i+p_i=e_i$, this constraint has to be posted in addition to ensure consistency of the task bounds.The propagator performs time-tabling, overload checking, and edge-finding. It uses algorithms taken from:Petr Vilím, Max Energy Filtering Algorithm for Discrete Cumulative Resources, in W. J. van Hoeve and J. N. Hooker, editors, CPAIOR, volume 5547 of LNCS, pages 294-308. Springer, 2009.andPetr Vilím, Edge finding filtering algorithm for discrete cumulative resources in O(kn log n). In I. P. Gent, editor, CP, volume 5732 of LNCS, pages 802-816. Springer, 2009. +Throws an exception of type Int::ArgumentSizeMismatch, if s, p, u, or m are of different size.Throws an exception of type Int::OutOfLimits, if u or c contain an integer that is not nonnegative, or that could generate an overflow. + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::circuit + (Home home, const IntVarArgs &x, IntConLevel icl=ICL_DEF) + circuit + + Home + home + + + const IntVarArgs & + x + + + IntConLevel + icl + ICL_DEF + + +Post propagator such that x forms a circuit. + +x forms a circuit if the graph with edges $i\to j$ where $x_i=j$ has a single cycle covering all nodes.Supports domain (icl = ICL_DOM) and value propagation (all other values for icl), where this refers to whether value or domain consistent distinct in enforced on x.Throws the following exceptions: +Int::ArgumentSame, if x contains the same unassigned variable multiply.Int::TooFewArguments, if x has no elements. + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::circuit + (Home home, int offset, const IntVarArgs &x, IntConLevel icl=ICL_DEF) + circuit + + Home + home + + + int + offset + + + const IntVarArgs & + x + + + IntConLevel + icl + ICL_DEF + + +Post propagator such that x forms a circuit. + +x forms a circuit if the graph with edges $i\to j$ where $x_{i-\text{offset}}=j$ has a single cycle covering all nodes.Supports domain (icl = ICL_DOM) and value propagation (all other values for icl), where this refers to whether value or domain consistent distinct in enforced on x.Throws the following exceptions: +Int::ArgumentSame, if x contains the same unassigned variable multiply.Int::TooFewArguments, if x has no elements.Int::OutOfLimits, if offset is negative. + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::circuit + (Home home, const IntArgs &c, const IntVarArgs &x, const IntVarArgs &y, IntVar z, IntConLevel icl=ICL_DEF) + circuit + + Home + home + + + const IntArgs & + c + + + const IntVarArgs & + x + + + const IntVarArgs & + y + + + IntVar + z + + + IntConLevel + icl + ICL_DEF + + +Post propagator such that x forms a circuit with costs y and z. + +x forms a circuit if the graph with edges $i\to j$ where $x_i=j$ has a single cycle covering all nodes. The integer array c gives the costs of all possible edges where $c_{i*|x|+j}$ is the cost of the edge $i\to j$. The variable z is the cost of the entire circuit. The variables y define the cost of the edge in x: that is, if $x_i=j$ then $y_i=c_{i*n+j}$.Supports domain (icl = ICL_DOM) and value propagation (all other values for icl), where this refers to whether value or domain consistent distinct in enforced on x for circuit.Throws the following exceptions: +Int::ArgumentSame, if x contains the same unassigned variable multiply.Int::TooFewArguments, if x has no elements.Int::ArgumentSizeMismacth, if x and y do not have the same size or if $|x|\times|x|\neq|c|$. + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::circuit + (Home home, const IntArgs &c, int offset, const IntVarArgs &x, const IntVarArgs &y, IntVar z, IntConLevel icl=ICL_DEF) + circuit + + Home + home + + + const IntArgs & + c + + + int + offset + + + const IntVarArgs & + x + + + const IntVarArgs & + y + + + IntVar + z + + + IntConLevel + icl + ICL_DEF + + +Post propagator such that x forms a circuit with costs y and z. + +x forms a circuit if the graph with edges $i\to j$ where $x_{i-\text{offset}}=j$ has a single cycle covering all nodes. The integer array c gives the costs of all possible edges where $c_{i*|x|+j}$ is the cost of the edge $i\to j$. The variable z is the cost of the entire circuit. The variables y define the cost of the edge in x: that is, if $x_i=j$ then $y_i=c_{i*n+j}$.Supports domain (icl = ICL_DOM) and value propagation (all other values for icl), where this refers to whether value or domain consistent distinct in enforced on x for circuit.Throws the following exceptions: +Int::ArgumentSame, if x contains the same unassigned variable multiply.Int::TooFewArguments, if x has no elements.Int::ArgumentSizeMismacth, if x and y do not have the same size or if $|x|\times|x|\neq|c|$.Int::OutOfLimits, if offset is negative. + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::circuit + (Home home, const IntArgs &c, const IntVarArgs &x, IntVar z, IntConLevel icl=ICL_DEF) + circuit + + Home + home + + + const IntArgs & + c + + + const IntVarArgs & + x + + + IntVar + z + + + IntConLevel + icl + ICL_DEF + + +Post propagator such that x forms a circuit with cost z. + +x forms a circuit if the graph with edges $i\to j$ where $x_i=j$ has a single cycle covering all nodes. The integer array c gives the costs of all possible edges where $c_{i*|x|+j}$ is the cost of the edge $i\to j$. The variable z is the cost of the entire circuit.Supports domain (icl = ICL_DOM) and value propagation (all other values for icl), where this refers to whether value or domain consistent distinct in enforced on x for circuit.Throws the following exceptions: +Int::ArgumentSame, if x contains the same unassigned variable multiply.Int::TooFewArguments, if x has no elements.Int::ArgumentSizeMismacth, if $|x|\times|x|\neq|c|$. + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::circuit + (Home home, const IntArgs &c, int offset, const IntVarArgs &x, IntVar z, IntConLevel icl=ICL_DEF) + circuit + + Home + home + + + const IntArgs & + c + + + int + offset + + + const IntVarArgs & + x + + + IntVar + z + + + IntConLevel + icl + ICL_DEF + + +Post propagator such that x forms a circuit with cost z. + +x forms a circuit if the graph with edges $i\to j$ where $x_{i-\text{offset}}=j$ has a single cycle covering all nodes. The integer array c gives the costs of all possible edges where $c_{i*|x|+j}$ is the cost of the edge $i\to j$. The variable z is the cost of the entire circuit.Supports domain (icl = ICL_DOM) and value propagation (all other values for icl), where this refers to whether value or domain consistent distinct in enforced on x for circuit.Throws the following exceptions: +Int::ArgumentSame, if x contains the same unassigned variable multiply.Int::TooFewArguments, if x has no elements.Int::ArgumentSizeMismacth, if $|x|\times|x|\neq|c|$.Int::OutOfLimits, if offset is negative. + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::path + (Home home, const IntVarArgs &x, IntVar s, IntVar e, IntConLevel icl=ICL_DEF) + path + + Home + home + + + const IntVarArgs & + x + + + IntVar + s + + + IntVar + e + + + IntConLevel + icl + ICL_DEF + + +Post propagator such that x forms a Hamiltonian path. + +x forms a Hamiltonian path if the graph with edges $i\to j$ where $x_i=j$ visits all nodes exactly once. The path starts at node s and the successor of the last node e is equal to $|x|$.Supports domain (icl = ICL_DOM) and value propagation (all other values for icl), where this refers to whether value or domain consistent distinct in enforced on x.Throws the following exceptions: +Int::ArgumentSame, if x contains the same unassigned variable multiply.Int::TooFewArguments, if x has no elements. + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::path + (Home home, int offset, const IntVarArgs &x, IntVar s, IntVar e, IntConLevel icl=ICL_DEF) + path + + Home + home + + + int + offset + + + const IntVarArgs & + x + + + IntVar + s + + + IntVar + e + + + IntConLevel + icl + ICL_DEF + + +Post propagator such that x forms a Hamiltonian path. + +x forms a Hamiltonian path if the graph with edges $i\to j$ where $x_{i-\text{offset}}=j$ visits all nodes exactly once. The path starts at node s and the successor of the last node e is equal to $|x|+\text{offset}$.Supports domain (icl = ICL_DOM) and value propagation (all other values for icl), where this refers to whether value or domain consistent distinct in enforced on x.Throws the following exceptions: +Int::ArgumentSame, if x contains the same unassigned variable multiply.Int::TooFewArguments, if x has no elements.Int::OutOfLimits, if offset is negative. + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::path + (Home home, const IntArgs &c, const IntVarArgs &x, IntVar s, IntVar e, const IntVarArgs &y, IntVar z, IntConLevel icl=ICL_DEF) + path + + Home + home + + + const IntArgs & + c + + + const IntVarArgs & + x + + + IntVar + s + + + IntVar + e + + + const IntVarArgs & + y + + + IntVar + z + + + IntConLevel + icl + ICL_DEF + + +Post propagator such that x forms a Hamiltonian path with costs y and z. + +x forms a Hamiltonian path if the graph with edges $i\to j$ where $x_i=j$ visits all nodes exactly once. The path starts at node s and the successor of the last node e is equal to $|x|$. The integer array c gives the costs of all possible edges where $c_{i*|x|+j}$ is the cost of the edge $i\to j$. The variable z is the cost of the entire path. The variables y define the cost of the edge in x: that is, if $x_i=j$ then $y_i=c_{i*n+j}$.Supports domain (icl = ICL_DOM) and value propagation (all other values for icl), where this refers to whether value or domain consistent distinct in enforced on x for circuit.Throws the following exceptions: +Int::ArgumentSame, if x contains the same unassigned variable multiply.Int::TooFewArguments, if x has no elements.Int::ArgumentSizeMismacth, if x and y do not have the same size or if $|x|\times|x|\neq|c|$. + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::path + (Home home, const IntArgs &c, int offset, const IntVarArgs &x, IntVar s, IntVar e, const IntVarArgs &y, IntVar z, IntConLevel icl=ICL_DEF) + path + + Home + home + + + const IntArgs & + c + + + int + offset + + + const IntVarArgs & + x + + + IntVar + s + + + IntVar + e + + + const IntVarArgs & + y + + + IntVar + z + + + IntConLevel + icl + ICL_DEF + + +Post propagator such that x forms a Hamiltonian path with costs y and z. + +x forms a Hamiltonian path if the graph with edges $i\to j$ where $x_{i-\text{offset}}=j$ visits all nodes exactly once. The path starts at node s and the successor of the last node e is equal to $|x|+\text{offset}$. The integer array c gives the costs of all possible edges where $c_{i*|x|+j}$ is the cost of the edge $i\to j$. The variable z is the cost of the entire path. The variables y define the cost of the edge in x: that is, if $x_i=j$ then $y_i=c_{i*n+j}$.Supports domain (icl = ICL_DOM) and value propagation (all other values for icl), where this refers to whether value or domain consistent distinct in enforced on x for circuit.Throws the following exceptions: +Int::ArgumentSame, if x contains the same unassigned variable multiply.Int::TooFewArguments, if x has no elements.Int::ArgumentSizeMismacth, if x and y do not have the same size or if $|x|\times|x|\neq|c|$.Int::OutOfLimits, if offset is negative. + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::path + (Home home, const IntArgs &c, const IntVarArgs &x, IntVar s, IntVar e, IntVar z, IntConLevel icl=ICL_DEF) + path + + Home + home + + + const IntArgs & + c + + + const IntVarArgs & + x + + + IntVar + s + + + IntVar + e + + + IntVar + z + + + IntConLevel + icl + ICL_DEF + + +Post propagator such that x forms a Hamiltonian path with cost z. + +x forms a Hamiltonian path if the graph with edges $i\to j$ where $x_i=j$ visits all nodes exactly once. The path starts at node s and the successor of the last node e is equal to $|x|$. The integer array c gives the costs of all possible edges where $c_{i*|x|+j}$ is the cost of the edge $i\to j$. The variable z is the cost of the entire path.Supports domain (icl = ICL_DOM) and value propagation (all other values for icl), where this refers to whether value or domain consistent distinct in enforced on x for circuit.Throws the following exceptions: +Int::ArgumentSame, if x contains the same unassigned variable multiply.Int::TooFewArguments, if x has no elements.Int::ArgumentSizeMismacth, if $|x|\times|x|\neq|c|$. + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::path + (Home home, const IntArgs &c, int offset, const IntVarArgs &x, IntVar s, IntVar e, IntVar z, IntConLevel icl=ICL_DEF) + path + + Home + home + + + const IntArgs & + c + + + int + offset + + + const IntVarArgs & + x + + + IntVar + s + + + IntVar + e + + + IntVar + z + + + IntConLevel + icl + ICL_DEF + + +Post propagator such that x forms a Hamiltonian path with cost z. + +x forms a Hamiltonian path if the graph with edges $i\to j$ where $x_{i-\text{offset}}=j$ visits all nodes exactly once. The path starts at node s and the successor of the last node e is equal to $|x|+\text{offset}$. The integer array c gives the costs of all possible edges where $c_{i*|x|+j}$ is the cost of the edge $i\to j$. The variable z is the cost of the entire circuit.Supports domain (icl = ICL_DOM) and value propagation (all other values for icl), where this refers to whether value or domain consistent distinct in enforced on x for circuit.Throws the following exceptions: +Int::ArgumentSame, if x contains the same unassigned variable multiply.Int::TooFewArguments, if x has no elements.Int::ArgumentSizeMismacth, if $|x|\times|x|\neq|c|$.Int::OutOfLimits, if offset is negative. + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::wait + (Home home, IntVar x, void(*c)(Space &home), IntConLevel icl=ICL_DEF) + wait + + Home + home + + + IntVar + x + + + void(*)(Space &home) + c + + + IntConLevel + icl + ICL_DEF + + +Execute c when x becomes assigned. + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::wait + (Home home, BoolVar x, void(*c)(Space &home), IntConLevel icl=ICL_DEF) + wait + + Home + home + + + BoolVar + x + + + void(*)(Space &home) + c + + + IntConLevel + icl + ICL_DEF + + +Execute c when x becomes assigned. + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::wait + (Home home, const IntVarArgs &x, void(*c)(Space &home), IntConLevel icl=ICL_DEF) + wait + + Home + home + + + const IntVarArgs & + x + + + void(*)(Space &home) + c + + + IntConLevel + icl + ICL_DEF + + +Execute c when all variables in x become assigned. + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::wait + (Home home, const BoolVarArgs &x, void(*c)(Space &home), IntConLevel icl=ICL_DEF) + wait + + Home + home + + + const BoolVarArgs & + x + + + void(*)(Space &home) + c + + + IntConLevel + icl + ICL_DEF + + +Execute c when all variables in x become assigned. + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::when + (Home home, BoolVar x, void(*t)(Space &home), void(*e)(Space &home)=NULL, IntConLevel icl=ICL_DEF) + when + + Home + home + + + BoolVar + x + + + void(*)(Space &home) + t + + + void(*)(Space &home) + e + NULL + + + IntConLevel + icl + ICL_DEF + + +Execute t (then) when x is assigned one, and e (else) otherwise. + + + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::unshare + (Home home, IntVarArgs &x, IntConLevel icl=ICL_DEF) + unshare + + Home + home + + + IntVarArgs & + x + + + IntConLevel + icl + ICL_DEF + + +Replace multiple variable occurences in x by fresh variables. + +Supports domain consistency (icl = ICL_DOM, default) and bounds consistency (icl = ICL_BND). + + + + + + GECODE_INT_EXPORT void + GECODE_INT_EXPORT void Gecode::unshare + (Home home, BoolVarArgs &x, IntConLevel icl=ICL_DEF) + unshare + + Home + home + + + BoolVarArgs & + x + + + IntConLevel + icl + ICL_DEF + + +Replace multiple variable occurences in x by fresh variables. + + + + + + + + GECODE_INT_EXPORT BrancherHandle + GECODE_INT_EXPORT BrancherHandle Gecode::branch + (Home home, const IntVarArgs &x, IntVarBranch vars, IntValBranch vals, IntBranchFilter bf=NULL, IntVarValPrint vvp=NULL) + branch + + Home + home + + + const IntVarArgs & + x + + + IntVarBranch + vars + + + IntValBranch + vals + + + IntBranchFilter + bf + NULL + + + IntVarValPrint + vvp + NULL + + +Branch over x with variable selection vars and value selection vals. + + + + + + + + GECODE_INT_EXPORT BrancherHandle + GECODE_INT_EXPORT BrancherHandle Gecode::branch + (Home home, const IntVarArgs &x, TieBreak< IntVarBranch > vars, IntValBranch vals, IntBranchFilter bf=NULL, IntVarValPrint vvp=NULL) + branch + + Home + home + + + const IntVarArgs & + x + + + TieBreak< IntVarBranch > + vars + + + IntValBranch + vals + + + IntBranchFilter + bf + NULL + + + IntVarValPrint + vvp + NULL + + +Branch over x with tie-breaking variable selection vars and value selection vals. + + + + + + + + GECODE_INT_EXPORT BrancherHandle + GECODE_INT_EXPORT BrancherHandle Gecode::branch + (Home home, IntVar x, IntValBranch vals, IntVarValPrint vvp=NULL) + branch + + Home + home + + + IntVar + x + + + IntValBranch + vals + + + IntVarValPrint + vvp + NULL + + +Branch over x with value selection vals. + + + + + + + + GECODE_INT_EXPORT BrancherHandle + GECODE_INT_EXPORT BrancherHandle Gecode::branch + (Home home, const BoolVarArgs &x, IntVarBranch vars, IntValBranch vals, BoolBranchFilter bf=NULL, BoolVarValPrint vvp=NULL) + branch + + Home + home + + + const BoolVarArgs & + x + + + IntVarBranch + vars + + + IntValBranch + vals + + + BoolBranchFilter + bf + NULL + + + BoolVarValPrint + vvp + NULL + + +Branch over x with variable selection vars and value selection vals. + + + + + + + + GECODE_INT_EXPORT BrancherHandle + GECODE_INT_EXPORT BrancherHandle Gecode::branch + (Home home, const BoolVarArgs &x, TieBreak< IntVarBranch > vars, IntValBranch vals, BoolBranchFilter bf=NULL, BoolVarValPrint vvp=NULL) + branch + + Home + home + + + const BoolVarArgs & + x + + + TieBreak< IntVarBranch > + vars + + + IntValBranch + vals + + + BoolBranchFilter + bf + NULL + + + BoolVarValPrint + vvp + NULL + + +Branch over x with tie-breaking variable selection vars and value selection vals. + + + + + + + + GECODE_INT_EXPORT BrancherHandle + GECODE_INT_EXPORT BrancherHandle Gecode::branch + (Home home, BoolVar x, IntValBranch vals, BoolVarValPrint vvp=NULL) + branch + + Home + home + + + BoolVar + x + + + IntValBranch + vals + + + BoolVarValPrint + vvp + NULL + + +Branch over x with value selection vals. + + + + + + + + GECODE_INT_EXPORT BrancherHandle + GECODE_INT_EXPORT BrancherHandle Gecode::assign + (Home home, const IntVarArgs &x, IntAssign vals, IntBranchFilter ibf=NULL, IntVarValPrint vvp=NULL) + assign + + Home + home + + + const IntVarArgs & + x + + + IntAssign + vals + + + IntBranchFilter + ibf + NULL + + + IntVarValPrint + vvp + NULL + + +Assign all x with value selection vals. + + + + + + + + GECODE_INT_EXPORT BrancherHandle + GECODE_INT_EXPORT BrancherHandle Gecode::assign + (Home home, IntVar x, IntAssign vals, IntVarValPrint vvp=NULL) + assign + + Home + home + + + IntVar + x + + + IntAssign + vals + + + IntVarValPrint + vvp + NULL + + +Assign x with value selection vals. + + + + + + + + GECODE_INT_EXPORT BrancherHandle + GECODE_INT_EXPORT BrancherHandle Gecode::assign + (Home home, const BoolVarArgs &x, IntAssign vals, BoolBranchFilter bbf=NULL, BoolVarValPrint vvp=NULL) + assign + + Home + home + + + const BoolVarArgs & + x + + + IntAssign + vals + + + BoolBranchFilter + bbf + NULL + + + BoolVarValPrint + vvp + NULL + + +Assign all x with value selection vals. + + + + + + + + GECODE_INT_EXPORT BrancherHandle + GECODE_INT_EXPORT BrancherHandle Gecode::assign + (Home home, BoolVar x, IntAssign vals, BoolVarValPrint vvp=NULL) + assign + + Home + home + + + BoolVar + x + + + IntAssign + vals + + + BoolVarValPrint + vvp + NULL + + +Assign x with value selection vals. + + + + + + + + GECODE_INT_EXPORT SymmetryHandle + GECODE_INT_EXPORT SymmetryHandle Gecode::VariableSymmetry + (const IntVarArgs &x) + VariableSymmetry + + const IntVarArgs & + x + + +Variables in x are interchangeable. + + + + + + + + GECODE_INT_EXPORT SymmetryHandle + GECODE_INT_EXPORT SymmetryHandle Gecode::VariableSymmetry + (const BoolVarArgs &x) + VariableSymmetry + + const BoolVarArgs & + x + + +Variables in x are interchangeable. + + + + + + + + GECODE_INT_EXPORT SymmetryHandle + GECODE_INT_EXPORT SymmetryHandle Gecode::VariableSymmetry + (const IntVarArgs &x, const IntArgs &indices) + VariableSymmetry + + const IntVarArgs & + x + + + const IntArgs & + indices + + +Specified variables in x are interchangeable. + + + + + + + + GECODE_INT_EXPORT SymmetryHandle + GECODE_INT_EXPORT SymmetryHandle Gecode::ValueSymmetry + (const IntArgs &v) + ValueSymmetry + + const IntArgs & + v + + +Values in v are interchangeable. + + + + + + + + GECODE_INT_EXPORT SymmetryHandle + GECODE_INT_EXPORT SymmetryHandle Gecode::ValueSymmetry + (const IntSet &v) + ValueSymmetry + + const IntSet & + v + + +Values in v are interchangeable. + + + + + + + + GECODE_INT_EXPORT SymmetryHandle + GECODE_INT_EXPORT SymmetryHandle Gecode::ValueSymmetry + (IntVar vars) + ValueSymmetry + + IntVar + vars + + +All values in the domain of the given variable are interchangeable. + + + + + + + + GECODE_INT_EXPORT SymmetryHandle + GECODE_INT_EXPORT SymmetryHandle Gecode::VariableSequenceSymmetry + (const IntVarArgs &x, int ss) + VariableSequenceSymmetry + + const IntVarArgs & + x + + + int + ss + + +Variable sequences in x of size ss are interchangeable. + +The size of x must be a multiple of ss. + + + + + + GECODE_INT_EXPORT SymmetryHandle + GECODE_INT_EXPORT SymmetryHandle Gecode::VariableSequenceSymmetry + (const BoolVarArgs &x, int ss) + VariableSequenceSymmetry + + const BoolVarArgs & + x + + + int + ss + + +Variable sequences in x of size ss are interchangeable. + +The size of x must be a multiple of ss. + + + + + + GECODE_INT_EXPORT SymmetryHandle + GECODE_INT_EXPORT SymmetryHandle Gecode::ValueSequenceSymmetry + (const IntArgs &v, int ss) + ValueSequenceSymmetry + + const IntArgs & + v + + + int + ss + + +Value sequences in v of size ss are interchangeable. + +The size of v must be a multiple of ss. + + + + + + GECODE_INT_EXPORT SymmetryHandle + GECODE_INT_EXPORT SymmetryHandle Gecode::values_reflect + (int lower, int upper) + values_reflect + + int + lower + + + int + upper + + +The values from lower to upper (inclusive) can be reflected. + + + + + + + + GECODE_INT_EXPORT SymmetryHandle + GECODE_INT_EXPORT SymmetryHandle Gecode::values_reflect + (IntVar x) + values_reflect + + IntVar + x + + +The values in the domain of can be reflected. + + + + + + + + GECODE_INT_EXPORT BrancherHandle + GECODE_INT_EXPORT BrancherHandle Gecode::branch + (Home home, const IntVarArgs &x, IntVarBranch vars, IntValBranch vals, const Symmetries &syms, IntBranchFilter bf=NULL, IntVarValPrint vvp=NULL) + branch + + Home + home + + + const IntVarArgs & + x + + + IntVarBranch + vars + + + IntValBranch + vals + + + const Symmetries & + syms + + + IntBranchFilter + bf + NULL + + + IntVarValPrint + vvp + NULL + + +Branch over x with variable selection vars and value selection vals with symmetry breaking. + +Throws LDSBBadValueSelection exception if vals is any of SEL_SPLIT_MIN, SEL_SPLIT_MAX, SEL_RANGE_MIN, SEL_RANGE_MAX, SEL_VALUES_MIN, and SEL_VALUES_MAX, or if vals is SEL_VAL_COMMIT with a custom commit function. + + + + + + GECODE_INT_EXPORT BrancherHandle + GECODE_INT_EXPORT BrancherHandle Gecode::branch + (Home home, const IntVarArgs &x, TieBreak< IntVarBranch > vars, IntValBranch vals, const Symmetries &syms, IntBranchFilter bf=NULL, IntVarValPrint vvp=NULL) + branch + + Home + home + + + const IntVarArgs & + x + + + TieBreak< IntVarBranch > + vars + + + IntValBranch + vals + + + const Symmetries & + syms + + + IntBranchFilter + bf + NULL + + + IntVarValPrint + vvp + NULL + + +Branch over x with tie-breaking variable selection vars and value selection vals with symmetry breaking. + +Throws LDSBBadValueSelection exception if vals is any of SEL_SPLIT_MIN, SEL_SPLIT_MAX, SEL_RANGE_MIN, SEL_RANGE_MAX, SEL_VALUES_MIN, and SEL_VALUES_MAX, or if vals is SEL_VAL_COMMIT with a custom commit function. + + + + + + GECODE_INT_EXPORT BrancherHandle + GECODE_INT_EXPORT BrancherHandle Gecode::branch + (Home home, const BoolVarArgs &x, IntVarBranch vars, IntValBranch vals, const Symmetries &syms, BoolBranchFilter bf=NULL, BoolVarValPrint vvp=NULL) + branch + + Home + home + + + const BoolVarArgs & + x + + + IntVarBranch + vars + + + IntValBranch + vals + + + const Symmetries & + syms + + + BoolBranchFilter + bf + NULL + + + BoolVarValPrint + vvp + NULL + + +Branch over x with variable selection vars and value selection vals with symmetry breaking. + +Throws LDSBBadValueSelection exception if vals is any of SEL_SPLIT_MIN, SEL_SPLIT_MAX, SEL_RANGE_MIN, SEL_RANGE_MAX, SEL_VALUES_MIN, and SEL_VALUES_MAX, or if vals is SEL_VAL_COMMIT with a custom commit function. + + + + + + GECODE_INT_EXPORT BrancherHandle + GECODE_INT_EXPORT BrancherHandle Gecode::branch + (Home home, const BoolVarArgs &x, TieBreak< IntVarBranch > vars, IntValBranch vals, const Symmetries &syms, BoolBranchFilter bf=NULL, BoolVarValPrint vvp=NULL) + branch + + Home + home + + + const BoolVarArgs & + x + + + TieBreak< IntVarBranch > + vars + + + IntValBranch + vals + + + const Symmetries & + syms + + + BoolBranchFilter + bf + NULL + + + BoolVarValPrint + vvp + NULL + + +Branch over x with tie-breaking variable selection vars and value selection vals with symmetry breaking. + +Throws LDSBBadValueSelection exception if vals is any of SEL_SPLIT_MIN, SEL_SPLIT_MAX, SEL_RANGE_MIN, SEL_RANGE_MAX, SEL_VALUES_MIN, and SEL_VALUES_MAX, or if vals is SEL_VAL_COMMIT with a custom commit function. + + + + + + + + class Char + + + class Traits + + + std::basic_ostream< Char, Traits > & + std::basic_ostream<Char,Traits>& Gecode::operator<< + (std::basic_ostream< Char, Traits > &os, const Activity &a) + operator<< + + std::basic_ostream< Char, Traits > & + os + + + const Activity & + a + + + + + + + + + + + + + class Char + + + class Traits + + + std::basic_ostream< Char, Traits > & + std::basic_ostream<Char,Traits>& Gecode::operator<< + (std::basic_ostream< Char, Traits > &os, const AFC &a) + operator<< + + std::basic_ostream< Char, Traits > & + os + + + const AFC & + a + + + + + + + + + + + + + class T1 + + + class T2 + + + bool + bool Gecode::operator== + (space_allocator< T1 > const &al1, space_allocator< T2 > const &al2) + operator== + + space_allocator< T1 > const & + al1 + + + space_allocator< T2 > const & + al2 + + throw () + +Tests two space allocators for equality. + +Two allocators are equal when each can release storage allocated from the other. + + + + + + + + class T1 + + + class T2 + + + bool + bool Gecode::operator!= + (space_allocator< T1 > const &al1, space_allocator< T2 > const &al2) + operator!= + + space_allocator< T1 > const & + al1 + + + space_allocator< T2 > const & + al2 + + throw () + +Tests two space allocators for inequality. + +Two allocators are equal when each can release storage allocated from the other. + + + + + + + + class T1 + + + class T2 + + + bool + bool Gecode::operator== + (region_allocator< T1 > const &al1, region_allocator< T2 > const &al2) + operator== + + region_allocator< T1 > const & + al1 + + + region_allocator< T2 > const & + al2 + + throw () + + + + + + + + + + + + class T1 + + + class T2 + + + bool + bool Gecode::operator!= + (region_allocator< T1 > const &al1, region_allocator< T2 > const &al2) + operator!= + + region_allocator< T1 > const & + al1 + + + region_allocator< T2 > const & + al2 + + throw () + + + + + + + + + + forceinline Archive & + forceinline Archive& Gecode::operator<< + (Archive &e, unsigned int i) + operator<< + + Archive & + e + + + unsigned int + i + + + + + + + + + + + forceinline Archive & + forceinline Archive& Gecode::operator<< + (Archive &e, int i) + operator<< + + Archive & + e + + + int + i + + + + + + + + + + + forceinline Archive & + forceinline Archive& Gecode::operator<< + (Archive &e, unsigned short i) + operator<< + + Archive & + e + + + unsigned short + i + + + + + + + + + + + forceinline Archive & + forceinline Archive& Gecode::operator<< + (Archive &e, short i) + operator<< + + Archive & + e + + + short + i + + + + + + + + + + + forceinline Archive & + forceinline Archive& Gecode::operator<< + (Archive &e, unsigned char i) + operator<< + + Archive & + e + + + unsigned char + i + + + + + + + + + + + forceinline Archive & + forceinline Archive& Gecode::operator<< + (Archive &e, char i) + operator<< + + Archive & + e + + + char + i + + + + + + + + + + + forceinline Archive & + forceinline Archive& Gecode::operator<< + (Archive &e, bool i) + operator<< + + Archive & + e + + + bool + i + + + + + + + + + + + forceinline Archive & + forceinline Archive& Gecode::operator<< + (Archive &e, float d) + operator<< + + Archive & + e + + + float + d + + + + + + + + + + + forceinline Archive & + forceinline Archive& Gecode::operator<< + (Archive &e, double d) + operator<< + + Archive & + e + + + double + d + + + + + + + + + + + forceinline Archive & + forceinline Archive& Gecode::operator>> + (Archive &e, unsigned int &i) + operator>> + + Archive & + e + + + unsigned int & + i + + + + + + + + + + + forceinline Archive & + forceinline Archive& Gecode::operator>> + (Archive &e, int &i) + operator>> + + Archive & + e + + + int & + i + + + + + + + + + + + forceinline Archive & + forceinline Archive& Gecode::operator>> + (Archive &e, unsigned short &i) + operator>> + + Archive & + e + + + unsigned short & + i + + + + + + + + + + + forceinline Archive & + forceinline Archive& Gecode::operator>> + (Archive &e, short &i) + operator>> + + Archive & + e + + + short & + i + + + + + + + + + + + forceinline Archive & + forceinline Archive& Gecode::operator>> + (Archive &e, unsigned char &i) + operator>> + + Archive & + e + + + unsigned char & + i + + + + + + + + + + + forceinline Archive & + forceinline Archive& Gecode::operator>> + (Archive &e, char &i) + operator>> + + Archive & + e + + + char & + i + + + + + + + + + + + forceinline Archive & + forceinline Archive& Gecode::operator>> + (Archive &e, bool &i) + operator>> + + Archive & + e + + + bool & + i + + + + + + + + + + + forceinline Archive & + forceinline Archive& Gecode::operator>> + (Archive &e, float &d) + operator>> + + Archive & + e + + + float & + d + + + + + + + + + + + forceinline Archive & + forceinline Archive& Gecode::operator>> + (Archive &e, double &d) + operator>> + + Archive & + e + + + double & + d + + + + + + + + + + + + + class Var + + + ArrayTraits< VarArray< Var > >::ArgsType + ArrayTraits<VarArray<Var> >::ArgsType Gecode::operator+ + (const VarArray< Var > &x, const VarArray< Var > &y) + operator+ + + const VarArray< Var > & + x + + + const VarArray< Var > & + y + + + + + + + + + + + + + class Var + + + ArrayTraits< VarArray< Var > >::ArgsType + ArrayTraits<VarArray<Var> >::ArgsType Gecode::operator+ + (const VarArray< Var > &x, const VarArgArray< Var > &y) + operator+ + + const VarArray< Var > & + x + + + const VarArgArray< Var > & + y + + + + + + + + + + + + + class Var + + + ArrayTraits< VarArray< Var > >::ArgsType + ArrayTraits<VarArray<Var> >::ArgsType Gecode::operator+ + (const VarArgArray< Var > &x, const VarArray< Var > &y) + operator+ + + const VarArgArray< Var > & + x + + + const VarArray< Var > & + y + + + + + + + + + + + + + class Var + + + ArrayTraits< VarArray< Var > >::ArgsType + ArrayTraits<VarArray<Var> >::ArgsType Gecode::operator+ + (const VarArray< Var > &x, const Var &y) + operator+ + + const VarArray< Var > & + x + + + const Var & + y + + + + + + + + + + + + + class Var + + + ArrayTraits< VarArray< Var > >::ArgsType + ArrayTraits<VarArray<Var> >::ArgsType Gecode::operator+ + (const Var &x, const VarArray< Var > &y) + operator+ + + const Var & + x + + + const VarArray< Var > & + y + + + + + + + + + + + + + class View + + + forceinline bool + forceinline bool Gecode::__before + (const View &x, const View &y) + __before + + const View & + x + + + const View & + y + + + + + + + + + + + + + class X + + + class Y + + + forceinline bool + forceinline bool Gecode::__same + (const X &x, const Y &y) + __same + + const X & + x + + + const Y & + y + + + + + + + + + + + + + class X + + + class Y + + + forceinline bool + forceinline bool Gecode::__shared + (const X &x, const Y &y) + __shared + + const X & + x + + + const Y & + y + + + + + + + + + + + + + class T + + + ArrayTraits< PrimArgArray< T > >::ArgsType + ArrayTraits<PrimArgArray<T> >::ArgsType Gecode::operator+ + (const PrimArgArray< T > &x, const PrimArgArray< T > &y) + operator+ + + const PrimArgArray< T > & + x + + + const PrimArgArray< T > & + y + + + + + + + + + + + + + class T + + + ArrayTraits< PrimArgArray< T > >::ArgsType + ArrayTraits<PrimArgArray<T> >::ArgsType Gecode::operator+ + (const PrimArgArray< T > &x, const T &y) + operator+ + + const PrimArgArray< T > & + x + + + const T & + y + + + + + + + + + + + + + class T + + + ArrayTraits< PrimArgArray< T > >::ArgsType + ArrayTraits<PrimArgArray<T> >::ArgsType Gecode::operator+ + (const T &x, const PrimArgArray< T > &y) + operator+ + + const T & + x + + + const PrimArgArray< T > & + y + + + + + + + + + + + + + class T + + + ArrayTraits< ArgArray< T > >::ArgsType + ArrayTraits<ArgArray<T> >::ArgsType Gecode::operator+ + (const ArgArray< T > &x, const ArgArray< T > &y) + operator+ + + const ArgArray< T > & + x + + + const ArgArray< T > & + y + + + + + + + + + + + + + class T + + + ArrayTraits< ArgArray< T > >::ArgsType + ArrayTraits<ArgArray<T> >::ArgsType Gecode::operator+ + (const ArgArray< T > &x, const T &y) + operator+ + + const ArgArray< T > & + x + + + const T & + y + + + + + + + + + + + + + class T + + + ArrayTraits< ArgArray< T > >::ArgsType + ArrayTraits<ArgArray<T> >::ArgsType Gecode::operator+ + (const T &x, const ArgArray< T > &y) + operator+ + + const T & + x + + + const ArgArray< T > & + y + + + + + + + + + + + + + class Var + + + ArrayTraits< VarArgArray< Var > >::ArgsType + ArrayTraits<VarArgArray<Var> >::ArgsType Gecode::operator+ + (const VarArgArray< Var > &x, const VarArgArray< Var > &y) + operator+ + + const VarArgArray< Var > & + x + + + const VarArgArray< Var > & + y + + + + + + + + + + + + + class Var + + + ArrayTraits< VarArgArray< Var > >::ArgsType + ArrayTraits<VarArgArray<Var> >::ArgsType Gecode::operator+ + (const VarArgArray< Var > &x, const Var &y) + operator+ + + const VarArgArray< Var > & + x + + + const Var & + y + + + + + + + + + + + + + class Var + + + ArrayTraits< VarArgArray< Var > >::ArgsType + ArrayTraits<VarArgArray<Var> >::ArgsType Gecode::operator+ + (const Var &x, const VarArgArray< Var > &y) + operator+ + + const Var & + x + + + const VarArgArray< Var > & + y + + + + + + + + + + + + + class Char + + + class Traits + + + class Var + + + std::basic_ostream< Char, Traits > & + std::basic_ostream<Char,Traits>& Gecode::operator<< + (std::basic_ostream< Char, Traits > &os, const VarArray< Var > &x) + operator<< + + std::basic_ostream< Char, Traits > & + os + + + const VarArray< Var > & + x + + + + + + + + + + + + + class Char + + + class Traits + + + class View + + + std::basic_ostream< Char, Traits > & + std::basic_ostream<Char,Traits>& Gecode::operator<< + (std::basic_ostream< Char, Traits > &os, const ViewArray< View > &x) + operator<< + + std::basic_ostream< Char, Traits > & + os + + + const ViewArray< View > & + x + + + + + + + + + + + + + class Char + + + class Traits + + + class T + + + std::basic_ostream< Char, Traits > & + std::basic_ostream<Char,Traits>& Gecode::operator<< + (std::basic_ostream< Char, Traits > &os, const ArgArrayBase< T > &x) + operator<< + + std::basic_ostream< Char, Traits > & + os + + + const ArgArrayBase< T > & + x + + + + + + + + + + + + + class VarBranch + + + TieBreak< VarBranch > + TieBreak<VarBranch> Gecode::tiebreak + (VarBranch a, VarBranch b) + tiebreak + + VarBranch + a + + + VarBranch + b + + +Combine variable selection criteria a and b for tie-breaking. + + + + + + + + + + class VarBranch + + + TieBreak< VarBranch > + TieBreak<VarBranch> Gecode::tiebreak + (VarBranch a, VarBranch b, VarBranch c) + tiebreak + + VarBranch + a + + + VarBranch + b + + + VarBranch + c + + +Combine variable selection criteria a, b, and c for tie-breaking. + + + + + + + + + + class VarBranch + + + TieBreak< VarBranch > + TieBreak<VarBranch> Gecode::tiebreak + (VarBranch a, VarBranch b, VarBranch c, VarBranch d) + tiebreak + + VarBranch + a + + + VarBranch + b + + + VarBranch + c + + + VarBranch + d + + +Combine variable selection criteria a, b, c, and d for tie-breaking. + + + + + + + + + + class VarBranch + + + forceinline TieBreak< VarBranch > + forceinline TieBreak<VarBranch> Gecode::tiebreak + (VarBranch a, VarBranch b) + tiebreak + + VarBranch + a + + + VarBranch + b + + +Combine variable selection criteria a and b for tie-breaking. + + + + + + + + + + class VarBranch + + + forceinline TieBreak< VarBranch > + forceinline TieBreak<VarBranch> Gecode::tiebreak + (VarBranch a, VarBranch b, VarBranch c) + tiebreak + + VarBranch + a + + + VarBranch + b + + + VarBranch + c + + +Combine variable selection criteria a, b, and c for tie-breaking. + + + + + + + + + + class VarBranch + + + forceinline TieBreak< VarBranch > + forceinline TieBreak<VarBranch> Gecode::tiebreak + (VarBranch a, VarBranch b, VarBranch c, VarBranch d) + tiebreak + + VarBranch + a + + + VarBranch + b + + + VarBranch + c + + + VarBranch + d + + +Combine variable selection criteria a, b, c, and d for tie-breaking. + + + + + + + + bool + forceinline bool Gecode::me_failed + (ModEvent me) + me_failed + + ModEvent + me + + +Check whether modification event me is failed. + + + + + + + + bool + forceinline bool Gecode::me_modified + (ModEvent me) + me_modified + + ModEvent + me + + +Check whether modification event me describes variable modification. + + + + + + + + + + class Char + + + class Traits + + + class T + + + std::basic_ostream< Char, Traits > & + std::basic_ostream<Char,Traits>& Gecode::operator<< + (std::basic_ostream< Char, Traits > &os, const SharedArray< T > &x) + operator<< + + std::basic_ostream< Char, Traits > & + os + + + const SharedArray< T > & + x + + + + + + + + + + + + + class ViewA + + + class ViewB + + + bool + bool Gecode::shared + (const ConstView< ViewA > &, const ConstView< ViewB > &) + shared + + const ConstView< ViewA > & + + + const ConstView< ViewB > & + + +Test whether views share same variable. + + + + + + + + + + class Var + + + class View + + + bool + bool Gecode::shared + (const VarImpView< Var > &, const ConstView< View > &) + shared + + const VarImpView< Var > & + + + const ConstView< View > & + + +Test whether views share same variable. + + + + + + + + + + class ViewA + + + class ViewB + + + bool + bool Gecode::shared + (const DerivedView< ViewA > &, const ConstView< ViewB > &) + shared + + const DerivedView< ViewA > & + + + const ConstView< ViewB > & + + +Test whether views share same variable. + + + + + + + + + + class View + + + class Var + + + bool + bool Gecode::shared + (const ConstView< View > &, const VarImpView< Var > &) + shared + + const ConstView< View > & + + + const VarImpView< Var > & + + +Test whether views share same variable. + + + + + + + + + + class ViewA + + + class ViewB + + + bool + bool Gecode::shared + (const ConstView< ViewA > &, const DerivedView< ViewB > &) + shared + + const ConstView< ViewA > & + + + const DerivedView< ViewB > & + + +Test whether views share same variable. + + + + + + + + + + class VarA + + + class VarB + + + bool + bool Gecode::shared + (const VarImpView< VarA > &, const VarImpView< VarB > &) + shared + + const VarImpView< VarA > & + + + const VarImpView< VarB > & + + +Test whether views share same variable. + + + + + + + + + + class Var + + + class View + + + bool + bool Gecode::shared + (const VarImpView< Var > &, const DerivedView< View > &) + shared + + const VarImpView< Var > & + + + const DerivedView< View > & + + +Test whether views share same variable. + + + + + + + + + + class View + + + class Var + + + bool + bool Gecode::shared + (const DerivedView< View > &, const VarImpView< Var > &) + shared + + const DerivedView< View > & + + + const VarImpView< Var > & + + +Test whether views share same variable. + + + + + + + + + + class ViewA + + + class ViewB + + + bool + bool Gecode::shared + (const DerivedView< ViewA > &, const DerivedView< ViewB > &) + shared + + const DerivedView< ViewA > & + + + const DerivedView< ViewB > & + + +Test whether views share same variable. + + + + + + + + + + class ViewA + + + class ViewB + + + forceinline bool + forceinline bool Gecode::same + (const ConstView< ViewA > &, const ConstView< ViewB > &) + same + + const ConstView< ViewA > & + + + const ConstView< ViewB > & + + +Test whether two views are the same. + + + + + + + + + + class Var + + + class View + + + forceinline bool + forceinline bool Gecode::same + (const VarImpView< Var > &, const ConstView< View > &) + same + + const VarImpView< Var > & + + + const ConstView< View > & + + +Test whether two views are the same. + + + + + + + + + + class ViewA + + + class ViewB + + + forceinline bool + forceinline bool Gecode::same + (const ConstView< ViewA > &, const DerivedView< ViewB > &) + same + + const ConstView< ViewA > & + + + const DerivedView< ViewB > & + + +Test whether two views are the same. + + + + + + + + + + class Var + + + class View + + + forceinline bool + forceinline bool Gecode::same + (const VarImpView< Var > &, const DerivedView< View > &) + same + + const VarImpView< Var > & + + + const DerivedView< View > & + + +Test whether two views are the same. + + + + + + + + + + class View + + + class Var + + + forceinline bool + forceinline bool Gecode::same + (const DerivedView< View > &, const VarImpView< Var > &) + same + + const DerivedView< View > & + + + const VarImpView< Var > & + + +Test whether two views are the same. + + + + + + + + + + class Var + + + forceinline bool + forceinline bool Gecode::same + (const VarImpView< Var > &x, const VarImpView< Var > &y) + same + + const VarImpView< Var > & + x + + + const VarImpView< Var > & + y + + +Test whether two views are the same. + + + + + + + + + + class ViewA + + + class ViewB + + + forceinline bool + forceinline bool Gecode::same + (const DerivedView< ViewA > &x, const DerivedView< ViewB > &y) + same + + const DerivedView< ViewA > & + x + + + const DerivedView< ViewB > & + y + + +Test whether two views are the same. + + + + + + + + + + class ViewA + + + class ViewB + + + forceinline bool + forceinline bool Gecode::before + (const ViewA &x, const ViewB &y) + before + + const ViewA & + x + + + const ViewB & + y + + + + + + + + + + + + + class ViewA + + + class ViewB + + + forceinline bool + forceinline bool Gecode::shared + (const ConstView< ViewA > &, const ConstView< ViewB > &) + shared + + const ConstView< ViewA > & + + + const ConstView< ViewB > & + + +Test whether views share same variable. + + + + + + + + + + class Var + + + class View + + + forceinline bool + forceinline bool Gecode::shared + (const VarImpView< Var > &, const ConstView< View > &) + shared + + const VarImpView< Var > & + + + const ConstView< View > & + + +Test whether views share same variable. + + + + + + + + + + class ViewA + + + class ViewB + + + forceinline bool + forceinline bool Gecode::shared + (const DerivedView< ViewA > &, const ConstView< ViewB > &) + shared + + const DerivedView< ViewA > & + + + const ConstView< ViewB > & + + +Test whether views share same variable. + + + + + + + + + + class View + + + class Var + + + forceinline bool + forceinline bool Gecode::shared + (const ConstView< View > &, const VarImpView< Var > &) + shared + + const ConstView< View > & + + + const VarImpView< Var > & + + +Test whether views share same variable. + + + + + + + + + + class ViewA + + + class ViewB + + + forceinline bool + forceinline bool Gecode::shared + (const ConstView< ViewA > &, const DerivedView< ViewB > &) + shared + + const ConstView< ViewA > & + + + const DerivedView< ViewB > & + + +Test whether views share same variable. + + + + + + + + + + class VarA + + + class VarB + + + forceinline bool + forceinline bool Gecode::shared + (const VarImpView< VarA > &x, const VarImpView< VarB > &y) + shared + + const VarImpView< VarA > & + x + + + const VarImpView< VarB > & + y + + +Test whether views share same variable. + + + + + + + + + + class Var + + + class View + + + forceinline bool + forceinline bool Gecode::shared + (const VarImpView< Var > &x, const DerivedView< View > &y) + shared + + const VarImpView< Var > & + x + + + const DerivedView< View > & + y + + +Test whether views share same variable. + + + + + + + + + + class View + + + class Var + + + forceinline bool + forceinline bool Gecode::shared + (const DerivedView< View > &x, const VarImpView< Var > &y) + shared + + const DerivedView< View > & + x + + + const VarImpView< Var > & + y + + +Test whether views share same variable. + + + + + + + + + + class ViewA + + + class ViewB + + + forceinline bool + forceinline bool Gecode::shared + (const DerivedView< ViewA > &x, const DerivedView< ViewB > &y) + shared + + const DerivedView< ViewA > & + x + + + const DerivedView< ViewB > & + y + + +Test whether views share same variable. + + + + + + + + GECODE_KERNEL_EXPORT BrancherHandle + GECODE_KERNEL_EXPORT BrancherHandle Gecode::branch + (Home home, void(*f)(Space &home)) + branch + + Home + home + + + void(*)(Space &home) + f + + +Call the function f (with the current space as argument) for branching. + + + + + + + + + + class A + + + SymmetryHandle + SymmetryHandle Gecode::rows_interchange + (const Matrix< A > &m) + rows_interchange + + const Matrix< A > & + m + + +Interchangeable rows symmetry specification. + + + + + + + + + + class A + + + SymmetryHandle + SymmetryHandle Gecode::columns_interchange + (const Matrix< A > &m) + columns_interchange + + const Matrix< A > & + m + + +Interchangeable columns symmetry specification. + + + + + + + + + + class A + + + SymmetryHandle + SymmetryHandle Gecode::rows_reflect + (const Matrix< A > &m) + rows_reflect + + const Matrix< A > & + m + + +Reflect rows symmetry specification. + + + + + + + + + + class A + + + SymmetryHandle + SymmetryHandle Gecode::columns_reflect + (const Matrix< A > &m) + columns_reflect + + const Matrix< A > & + m + + +Reflect columns symmetry specification. + + + + + + + + + + class A + + + SymmetryHandle + SymmetryHandle Gecode::diagonal_reflect + (const Matrix< A > &m) + diagonal_reflect + + const Matrix< A > & + m + + +Reflect around main diagonal symmetry specification. + + + + + + + + + + class A + + + Slice< A >::ArgsType + Slice< A >::ArgsType Gecode::operator+ + (const Slice< A > &x, const Slice< A > &y) + operator+ + + const Slice< A > & + x + + + const Slice< A > & + y + + +Concatenate x and y. + + + + + + + + + + class A + + + Slice< A >::ArgsType + Slice< A >::ArgsType Gecode::operator+ + (const Slice< A > &x, const typename ArrayTraits< A >::ArgsType &y) + operator+ + + const Slice< A > & + x + + + const typename ArrayTraits< A >::ArgsType & + y + + +Concatenate x and y. + + + + + + + + + + class A + + + Slice< A >::ArgsType + Slice< A >::ArgsType Gecode::operator+ + (const typename ArrayTraits< A >::ArgsType &x, const Slice< A > &y) + operator+ + + const typename ArrayTraits< A >::ArgsType & + x + + + const Slice< A > & + y + + +Concatenate x and y. + + + + + + + + + + class A + + + Slice< A >::ArgsType + Slice< A >::ArgsType Gecode::operator+ + (const Slice< A > &x, const typename ArrayTraits< A >::ValueType &y) + operator+ + + const Slice< A > & + x + + + const typename ArrayTraits< A >::ValueType & + y + + +Concatenate x and y. + + + + + + + + + + class A + + + Slice< A >::ArgsType + Slice< A >::ArgsType Gecode::operator+ + (const typename ArrayTraits< A >::ValueType &x, const Slice< A > &y) + operator+ + + const typename ArrayTraits< A >::ValueType & + x + + + const Slice< A > & + y + + +Concatenate x and y. + + + + + + + + + + class Char + + + class Traits + + + class A + + + std::basic_ostream< Char, Traits > & + std::basic_ostream<Char,Traits>& Gecode::operator<< + (std::basic_ostream< Char, Traits > &os, const Matrix< A > &m) + operator<< + + std::basic_ostream< Char, Traits > & + os + + + const Matrix< A > & + m + + + + + + + + + + + + + class Char + + + class Traits + + + class A + + + std::basic_ostream< Char, Traits > & + std::basic_ostream<Char,Traits>& Gecode::operator<< + (std::basic_ostream< Char, Traits > &os, const Slice< A > &s) + operator<< + + std::basic_ostream< Char, Traits > & + os + + + const Slice< A > & + s + + + + + + + + + + + forceinline void + forceinline void Gecode::element + (Home home, const Matrix< IntArgs > &m, IntVar x, IntVar y, IntVar z, IntConLevel icl) + element + + Home + home + + + const Matrix< IntArgs > & + m + + + IntVar + x + + + IntVar + y + + + IntVar + z + + + IntConLevel + icl + + + + + + + + + + + forceinline void + forceinline void Gecode::element + (Home home, const Matrix< IntArgs > &m, IntVar x, IntVar y, BoolVar z, IntConLevel icl) + element + + Home + home + + + const Matrix< IntArgs > & + m + + + IntVar + x + + + IntVar + y + + + BoolVar + z + + + IntConLevel + icl + + + + + + + + + + + forceinline void + forceinline void Gecode::element + (Home home, const Matrix< IntVarArgs > &m, IntVar x, IntVar y, IntVar z, IntConLevel icl) + element + + Home + home + + + const Matrix< IntVarArgs > & + m + + + IntVar + x + + + IntVar + y + + + IntVar + z + + + IntConLevel + icl + + + + + + + + + + + forceinline void + forceinline void Gecode::element + (Home home, const Matrix< BoolVarArgs > &m, IntVar x, IntVar y, BoolVar z, IntConLevel icl) + element + + Home + home + + + const Matrix< BoolVarArgs > & + m + + + IntVar + x + + + IntVar + y + + + BoolVar + z + + + IntConLevel + icl + + + + + + + + + + + + + class Char + + + class Traits + + + std::basic_ostream< Char, Traits > & + std::basic_ostream<Char,Traits>& Gecode::operator<< + (std::basic_ostream< Char, Traits > &os, const REG &r) + operator<< + + std::basic_ostream< Char, Traits > & + os + + + const REG & + r + + + + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::operator+ + (int, const IntVar &) + operator+ + + int + + + const IntVar & + + +Construct linear expression as sum of integer variable and integer. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::operator+ + (int, const BoolVar &) + operator+ + + int + + + const BoolVar & + + +Construct linear expression as sum of Boolean variable and integer. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::operator+ + (int, const LinIntExpr &) + operator+ + + int + + + const LinIntExpr & + + +Construct linear expression as sum of linear expression and integer. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::operator+ + (const IntVar &, int) + operator+ + + const IntVar & + + + int + + +Construct linear expression as sum of integer variable and integer. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::operator+ + (const BoolVar &, int) + operator+ + + const BoolVar & + + + int + + +Construct linear expression as sum of Boolean variable and integer. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::operator+ + (const LinIntExpr &, int) + operator+ + + const LinIntExpr & + + + int + + +Construct linear expression as sum of linear expression and integer. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::operator+ + (const IntVar &, const IntVar &) + operator+ + + const IntVar & + + + const IntVar & + + +Construct linear expression as sum of integer variables. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::operator+ + (const IntVar &, const BoolVar &) + operator+ + + const IntVar & + + + const BoolVar & + + +Construct linear expression as sum of integer and Boolean variable. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::operator+ + (const BoolVar &, const IntVar &) + operator+ + + const BoolVar & + + + const IntVar & + + +Construct linear expression as sum of Boolean and integer variable. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::operator+ + (const BoolVar &, const BoolVar &) + operator+ + + const BoolVar & + + + const BoolVar & + + +Construct linear expression as sum of Boolean variables. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::operator+ + (const IntVar &, const LinIntExpr &) + operator+ + + const IntVar & + + + const LinIntExpr & + + +Construct linear expression as sum of integer variable and linear expression. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::operator+ + (const BoolVar &, const LinIntExpr &) + operator+ + + const BoolVar & + + + const LinIntExpr & + + +Construct linear expression as sum of Boolean variable and linear expression. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::operator+ + (const LinIntExpr &, const IntVar &) + operator+ + + const LinIntExpr & + + + const IntVar & + + +Construct linear expression as sum of linear expression and integer variable. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::operator+ + (const LinIntExpr &, const BoolVar &) + operator+ + + const LinIntExpr & + + + const BoolVar & + + +Construct linear expression as sum of linear expression and Boolean variable. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::operator+ + (const LinIntExpr &, const LinIntExpr &) + operator+ + + const LinIntExpr & + + + const LinIntExpr & + + +Construct linear expression as sum of linear expressions. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::operator- + (int, const IntVar &) + operator- + + int + + + const IntVar & + + +Construct linear expression as sum of integer variable and integer. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::operator- + (int, const BoolVar &) + operator- + + int + + + const BoolVar & + + +Construct linear expression as sum of Boolean variable and integer. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::operator- + (int, const LinIntExpr &) + operator- + + int + + + const LinIntExpr & + + +Construct linear expression as sum of integer and linear expression. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::operator- + (const IntVar &, int) + operator- + + const IntVar & + + + int + + +Construct linear expression as sum of integer variable and integer. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::operator- + (const BoolVar &, int) + operator- + + const BoolVar & + + + int + + +Construct linear expression as sum of Boolean variable and integer. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::operator- + (const LinIntExpr &, int) + operator- + + const LinIntExpr & + + + int + + +Construct linear expression as sum of linear expression and integer. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::operator- + (const IntVar &, const IntVar &) + operator- + + const IntVar & + + + const IntVar & + + +Construct linear expression as sum of integer variables. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::operator- + (const IntVar &, const BoolVar &) + operator- + + const IntVar & + + + const BoolVar & + + +Construct linear expression as sum of integer and Boolean variable. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::operator- + (const BoolVar &, const IntVar &) + operator- + + const BoolVar & + + + const IntVar & + + +Construct linear expression as sum of Boolean and integer variable. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::operator- + (const BoolVar &, const BoolVar &) + operator- + + const BoolVar & + + + const BoolVar & + + +Construct linear expression as sum of Boolean variables. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::operator- + (const IntVar &, const LinIntExpr &) + operator- + + const IntVar & + + + const LinIntExpr & + + +Construct linear expression as sum of integer variable and linear expression. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::operator- + (const BoolVar &, const LinIntExpr &) + operator- + + const BoolVar & + + + const LinIntExpr & + + +Construct linear expression as sum of Boolean variable and linear expression. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::operator- + (const LinIntExpr &, const IntVar &) + operator- + + const LinIntExpr & + + + const IntVar & + + +Construct linear expression as sum of linear expression and integer variable. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::operator- + (const LinIntExpr &, const BoolVar &) + operator- + + const LinIntExpr & + + + const BoolVar & + + +Construct linear expression as sum of linear expression and Boolean variable. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::operator- + (const LinIntExpr &, const LinIntExpr &) + operator- + + const LinIntExpr & + + + const LinIntExpr & + + +Construct linear expression as sum of linear expressions. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::operator- + (const IntVar &) + operator- + + const IntVar & + + +Construct linear expression as negative of integer variable. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::operator- + (const BoolVar &) + operator- + + const BoolVar & + + +Construct linear expression as negative of Boolean variable. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::operator- + (const LinIntExpr &) + operator- + + const LinIntExpr & + + +Construct linear expression as negative of linear expression. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::operator* + (int, const IntVar &) + operator* + + int + + + const IntVar & + + +Construct linear expression as product of integer coefficient and integer variable. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::operator* + (int, const BoolVar &) + operator* + + int + + + const BoolVar & + + +Construct linear expression as product of integer coefficient and Boolean variable. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::operator* + (const IntVar &, int) + operator* + + const IntVar & + + + int + + +Construct linear expression as product of integer coefficient and integer variable. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::operator* + (const BoolVar &, int) + operator* + + const BoolVar & + + + int + + +Construct linear expression as product of integer coefficient and Boolean variable. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::operator* + (const LinIntExpr &, int) + operator* + + const LinIntExpr & + + + int + + +Construct linear expression as product of integer coefficient and linear expression. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::operator* + (int, const LinIntExpr &) + operator* + + int + + + const LinIntExpr & + + +Construct linear expression as product of integer coefficient and linear expression. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::sum + (const IntVarArgs &x) + sum + + const IntVarArgs & + x + + +Construct linear expression as sum of integer variables. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::sum + (const IntArgs &a, const IntVarArgs &x) + sum + + const IntArgs & + a + + + const IntVarArgs & + x + + +Construct linear expression as sum of integer variables with coefficients. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::sum + (const BoolVarArgs &x) + sum + + const BoolVarArgs & + x + + +Construct linear expression as sum of Boolean variables. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::sum + (const IntArgs &a, const BoolVarArgs &x) + sum + + const IntArgs & + a + + + const BoolVarArgs & + x + + +Construct linear expression as sum of Boolean variables with coefficients. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::sum + (const IntArgs &args) + sum + + const IntArgs & + args + + +Construct linear expression as sum of IntArgs. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator== + (int l, const IntVar &r) + operator== + + int + l + + + const IntVar & + r + + +Construct linear equality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator== + (int l, const BoolVar &r) + operator== + + int + l + + + const BoolVar & + r + + +Construct linear equality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator== + (int l, const LinIntExpr &r) + operator== + + int + l + + + const LinIntExpr & + r + + +Construct linear equality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator== + (const IntVar &l, int r) + operator== + + const IntVar & + l + + + int + r + + +Construct linear equality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator== + (const BoolVar &l, int r) + operator== + + const BoolVar & + l + + + int + r + + +Construct linear equality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator== + (const LinIntExpr &l, int r) + operator== + + const LinIntExpr & + l + + + int + r + + +Construct linear equality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator== + (const IntVar &l, const IntVar &r) + operator== + + const IntVar & + l + + + const IntVar & + r + + +Construct linear equality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator== + (const IntVar &l, const BoolVar &r) + operator== + + const IntVar & + l + + + const BoolVar & + r + + +Construct linear equality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator== + (const BoolVar &l, const IntVar &r) + operator== + + const BoolVar & + l + + + const IntVar & + r + + +Construct linear equality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator== + (const BoolVar &l, const BoolVar &r) + operator== + + const BoolVar & + l + + + const BoolVar & + r + + +Construct linear equality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator== + (const IntVar &l, const LinIntExpr &r) + operator== + + const IntVar & + l + + + const LinIntExpr & + r + + +Construct linear equality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator== + (const BoolVar &l, const LinIntExpr &r) + operator== + + const BoolVar & + l + + + const LinIntExpr & + r + + +Construct linear equality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator== + (const LinIntExpr &l, const IntVar &r) + operator== + + const LinIntExpr & + l + + + const IntVar & + r + + +Construct linear equality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator== + (const LinIntExpr &l, const BoolVar &r) + operator== + + const LinIntExpr & + l + + + const BoolVar & + r + + +Construct linear equality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator== + (const LinIntExpr &l, const LinIntExpr &r) + operator== + + const LinIntExpr & + l + + + const LinIntExpr & + r + + +Construct linear equality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator!= + (int l, const IntVar &r) + operator!= + + int + l + + + const IntVar & + r + + +Construct linear disequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator!= + (int l, const BoolVar &r) + operator!= + + int + l + + + const BoolVar & + r + + +Construct linear disequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator!= + (int l, const LinIntExpr &r) + operator!= + + int + l + + + const LinIntExpr & + r + + +Construct linear disequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator!= + (const IntVar &l, int r) + operator!= + + const IntVar & + l + + + int + r + + +Construct linear disequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator!= + (const BoolVar &l, int r) + operator!= + + const BoolVar & + l + + + int + r + + +Construct linear disequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator!= + (const LinIntExpr &l, int r) + operator!= + + const LinIntExpr & + l + + + int + r + + +Construct linear disequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator!= + (const IntVar &l, const IntVar &r) + operator!= + + const IntVar & + l + + + const IntVar & + r + + +Construct linear disequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator!= + (const IntVar &l, const BoolVar &r) + operator!= + + const IntVar & + l + + + const BoolVar & + r + + +Construct linear disequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator!= + (const BoolVar &l, const IntVar &r) + operator!= + + const BoolVar & + l + + + const IntVar & + r + + +Construct linear disequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator!= + (const BoolVar &l, const BoolVar &r) + operator!= + + const BoolVar & + l + + + const BoolVar & + r + + +Construct linear disequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator!= + (const IntVar &l, const LinIntExpr &r) + operator!= + + const IntVar & + l + + + const LinIntExpr & + r + + +Construct linear disequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator!= + (const BoolVar &l, const LinIntExpr &r) + operator!= + + const BoolVar & + l + + + const LinIntExpr & + r + + +Construct linear disequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator!= + (const LinIntExpr &l, const IntVar &r) + operator!= + + const LinIntExpr & + l + + + const IntVar & + r + + +Construct linear disequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator!= + (const LinIntExpr &l, const BoolVar &r) + operator!= + + const LinIntExpr & + l + + + const BoolVar & + r + + +Construct linear disequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator!= + (const LinIntExpr &l, const LinIntExpr &r) + operator!= + + const LinIntExpr & + l + + + const LinIntExpr & + r + + +Construct linear disequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator< + (int l, const IntVar &r) + operator< + + int + l + + + const IntVar & + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator< + (int l, const BoolVar &r) + operator< + + int + l + + + const BoolVar & + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator< + (int l, const LinIntExpr &r) + operator< + + int + l + + + const LinIntExpr & + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator< + (const IntVar &l, int r) + operator< + + const IntVar & + l + + + int + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator< + (const BoolVar &l, int r) + operator< + + const BoolVar & + l + + + int + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator< + (const LinIntExpr &l, int r) + operator< + + const LinIntExpr & + l + + + int + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator< + (const IntVar &l, const IntVar &r) + operator< + + const IntVar & + l + + + const IntVar & + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator< + (const IntVar &l, const BoolVar &r) + operator< + + const IntVar & + l + + + const BoolVar & + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator< + (const BoolVar &l, const IntVar &r) + operator< + + const BoolVar & + l + + + const IntVar & + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator< + (const BoolVar &l, const BoolVar &r) + operator< + + const BoolVar & + l + + + const BoolVar & + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator< + (const IntVar &l, const LinIntExpr &r) + operator< + + const IntVar & + l + + + const LinIntExpr & + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator< + (const BoolVar &l, const LinIntExpr &r) + operator< + + const BoolVar & + l + + + const LinIntExpr & + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator< + (const LinIntExpr &l, const IntVar &r) + operator< + + const LinIntExpr & + l + + + const IntVar & + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator< + (const LinIntExpr &l, const BoolVar &r) + operator< + + const LinIntExpr & + l + + + const BoolVar & + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator< + (const LinIntExpr &l, const LinIntExpr &r) + operator< + + const LinIntExpr & + l + + + const LinIntExpr & + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator<= + (int l, const IntVar &r) + operator<= + + int + l + + + const IntVar & + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator<= + (int l, const BoolVar &r) + operator<= + + int + l + + + const BoolVar & + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator<= + (int l, const LinIntExpr &r) + operator<= + + int + l + + + const LinIntExpr & + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator<= + (const IntVar &l, int r) + operator<= + + const IntVar & + l + + + int + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator<= + (const BoolVar &l, int r) + operator<= + + const BoolVar & + l + + + int + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator<= + (const LinIntExpr &l, int r) + operator<= + + const LinIntExpr & + l + + + int + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator<= + (const IntVar &l, const IntVar &r) + operator<= + + const IntVar & + l + + + const IntVar & + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator<= + (const IntVar &l, const BoolVar &r) + operator<= + + const IntVar & + l + + + const BoolVar & + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator<= + (const BoolVar &l, const IntVar &r) + operator<= + + const BoolVar & + l + + + const IntVar & + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator<= + (const BoolVar &l, const BoolVar &r) + operator<= + + const BoolVar & + l + + + const BoolVar & + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator<= + (const IntVar &l, const LinIntExpr &r) + operator<= + + const IntVar & + l + + + const LinIntExpr & + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator<= + (const BoolVar &l, const LinIntExpr &r) + operator<= + + const BoolVar & + l + + + const LinIntExpr & + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator<= + (const LinIntExpr &l, const IntVar &r) + operator<= + + const LinIntExpr & + l + + + const IntVar & + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator<= + (const LinIntExpr &l, const BoolVar &r) + operator<= + + const LinIntExpr & + l + + + const BoolVar & + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator<= + (const LinIntExpr &l, const LinIntExpr &r) + operator<= + + const LinIntExpr & + l + + + const LinIntExpr & + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator> + (int l, const IntVar &r) + operator> + + int + l + + + const IntVar & + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator> + (int l, const BoolVar &r) + operator> + + int + l + + + const BoolVar & + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator> + (int l, const LinIntExpr &r) + operator> + + int + l + + + const LinIntExpr & + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator> + (const IntVar &l, int r) + operator> + + const IntVar & + l + + + int + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator> + (const BoolVar &l, int r) + operator> + + const BoolVar & + l + + + int + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator> + (const LinIntExpr &l, int r) + operator> + + const LinIntExpr & + l + + + int + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator> + (const IntVar &l, const IntVar &r) + operator> + + const IntVar & + l + + + const IntVar & + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator> + (const IntVar &l, const BoolVar &r) + operator> + + const IntVar & + l + + + const BoolVar & + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator> + (const BoolVar &l, const IntVar &r) + operator> + + const BoolVar & + l + + + const IntVar & + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator> + (const BoolVar &l, const BoolVar &r) + operator> + + const BoolVar & + l + + + const BoolVar & + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator> + (const IntVar &l, const LinIntExpr &r) + operator> + + const IntVar & + l + + + const LinIntExpr & + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator> + (const BoolVar &l, const LinIntExpr &r) + operator> + + const BoolVar & + l + + + const LinIntExpr & + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator> + (const LinIntExpr &l, const IntVar &r) + operator> + + const LinIntExpr & + l + + + const IntVar & + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator> + (const LinIntExpr &l, const BoolVar &r) + operator> + + const LinIntExpr & + l + + + const BoolVar & + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator> + (const LinIntExpr &l, const LinIntExpr &r) + operator> + + const LinIntExpr & + l + + + const LinIntExpr & + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator>= + (int l, const IntVar &r) + operator>= + + int + l + + + const IntVar & + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator>= + (int l, const BoolVar &r) + operator>= + + int + l + + + const BoolVar & + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator>= + (int l, const LinIntExpr &r) + operator>= + + int + l + + + const LinIntExpr & + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator>= + (const IntVar &l, int r) + operator>= + + const IntVar & + l + + + int + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator>= + (const BoolVar &l, int r) + operator>= + + const BoolVar & + l + + + int + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator>= + (const LinIntExpr &l, int r) + operator>= + + const LinIntExpr & + l + + + int + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator>= + (const IntVar &l, const IntVar &r) + operator>= + + const IntVar & + l + + + const IntVar & + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator>= + (const IntVar &l, const BoolVar &r) + operator>= + + const IntVar & + l + + + const BoolVar & + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator>= + (const BoolVar &l, const IntVar &r) + operator>= + + const BoolVar & + l + + + const IntVar & + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator>= + (const BoolVar &l, const BoolVar &r) + operator>= + + const BoolVar & + l + + + const BoolVar & + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator>= + (const IntVar &l, const LinIntExpr &r) + operator>= + + const IntVar & + l + + + const LinIntExpr & + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator>= + (const BoolVar &l, const LinIntExpr &r) + operator>= + + const BoolVar & + l + + + const LinIntExpr & + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator>= + (const LinIntExpr &l, const IntVar &r) + operator>= + + const LinIntExpr & + l + + + const IntVar & + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator>= + (const LinIntExpr &l, const BoolVar &r) + operator>= + + const LinIntExpr & + l + + + const BoolVar & + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntRel + GECODE_MINIMODEL_EXPORT LinIntRel Gecode::operator>= + (const LinIntExpr &l, const LinIntExpr &r) + operator>= + + const LinIntExpr & + l + + + const LinIntExpr & + r + + +Construct linear inequality relation. + + + + + + + + GECODE_MINIMODEL_EXPORT BoolExpr + GECODE_MINIMODEL_EXPORT BoolExpr Gecode::operator! + (const BoolExpr &) + operator! + + const BoolExpr & + + +Negated Boolean expression. + + + + + + + + GECODE_MINIMODEL_EXPORT BoolExpr + GECODE_MINIMODEL_EXPORT BoolExpr Gecode::operator&& + (const BoolExpr &, const BoolExpr &) + operator&& + + const BoolExpr & + + + const BoolExpr & + + +Conjunction of Boolean expressions. + + + + + + + + GECODE_MINIMODEL_EXPORT BoolExpr + GECODE_MINIMODEL_EXPORT BoolExpr Gecode::operator|| + (const BoolExpr &, const BoolExpr &) + operator|| + + const BoolExpr & + + + const BoolExpr & + + +Disjunction of Boolean expressions. + + + + + + + + GECODE_MINIMODEL_EXPORT BoolExpr + GECODE_MINIMODEL_EXPORT BoolExpr Gecode::operator^ + (const BoolExpr &, const BoolExpr &) + operator^ + + const BoolExpr & + + + const BoolExpr & + + +Exclusive-or of Boolean expressions. + + + + + + + + GECODE_MINIMODEL_EXPORT BoolExpr + GECODE_MINIMODEL_EXPORT BoolExpr Gecode::operator!= + (const BoolExpr &, const BoolExpr &) + operator!= + + const BoolExpr & + + + const BoolExpr & + + +Non-equivalence of Boolean expressions. + + + + + + + + GECODE_MINIMODEL_EXPORT BoolExpr + GECODE_MINIMODEL_EXPORT BoolExpr Gecode::operator== + (const BoolExpr &, const BoolExpr &) + operator== + + const BoolExpr & + + + const BoolExpr & + + +Equivalence of Boolean expressions. + + + + + + + + GECODE_MINIMODEL_EXPORT BoolExpr + GECODE_MINIMODEL_EXPORT BoolExpr Gecode::operator>> + (const BoolExpr &, const BoolExpr &) + operator>> + + const BoolExpr & + + + const BoolExpr & + + +Implication of Boolean expressions. + + + + + + + + GECODE_MINIMODEL_EXPORT BoolExpr + GECODE_MINIMODEL_EXPORT BoolExpr Gecode::operator<< + (const BoolExpr &, const BoolExpr &) + operator<< + + const BoolExpr & + + + const BoolExpr & + + +Reverse implication of Boolean expressions. + + + + + + + + GECODE_MINIMODEL_EXPORT IntVar + GECODE_MINIMODEL_EXPORT IntVar Gecode::expr + (Home home, const LinIntExpr &e, IntConLevel icl=ICL_DEF) + expr + + Home + home + + + const LinIntExpr & + e + + + IntConLevel + icl + ICL_DEF + + +Post linear expression and return its value. + + + + + + + + GECODE_MINIMODEL_EXPORT BoolVar + GECODE_MINIMODEL_EXPORT BoolVar Gecode::expr + (Home home, const BoolExpr &e, IntConLevel icl=ICL_DEF) + expr + + Home + home + + + const BoolExpr & + e + + + IntConLevel + icl + ICL_DEF + + +Post Boolean expression and return its value. + + + + + + + + GECODE_MINIMODEL_EXPORT void + GECODE_MINIMODEL_EXPORT void Gecode::rel + (Home home, const BoolExpr &e, IntConLevel icl=ICL_DEF) + rel + + Home + home + + + const BoolExpr & + e + + + IntConLevel + icl + ICL_DEF + + +Post Boolean relation. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::abs + (const LinIntExpr &e) + abs + + const LinIntExpr & + e + + +Return expression for $|e|$. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::min + (const LinIntExpr &x, const LinIntExpr &y) + min + + const LinIntExpr & + x + + + const LinIntExpr & + y + + +Return expression for $\min(x,y)$. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::min + (const IntVarArgs &x) + min + + const IntVarArgs & + x + + +Return expression for $\min(x)$. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::max + (const LinIntExpr &x, const LinIntExpr &y) + max + + const LinIntExpr & + x + + + const LinIntExpr & + y + + +Return expression for $\max(x,y)$. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::max + (const IntVarArgs &x) + max + + const IntVarArgs & + x + + +Return expression for $\max(x)$. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::operator* + (const LinIntExpr &x, const LinIntExpr &y) + operator* + + const LinIntExpr & + x + + + const LinIntExpr & + y + + +Return expression for $x\cdot y$. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::operator/ + (const LinIntExpr &x, const LinIntExpr &y) + operator/ + + const LinIntExpr & + x + + + const LinIntExpr & + y + + +Return expression for $x\ \mathrm{div}\ y$. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::operator% + (const LinIntExpr &x, const LinIntExpr &y) + operator% + + const LinIntExpr & + x + + + const LinIntExpr & + y + + +Return expression for $x\ \mathrm{mod}\ y$. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::sqr + (const LinIntExpr &x) + sqr + + const LinIntExpr & + x + + +Return expression for $x^2$. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::sqrt + (const LinIntExpr &x) + sqrt + + const LinIntExpr & + x + + +Return expression for $\lfloor\sqrt{x}\rfloor$. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::pow + (const LinIntExpr &x, int n) + pow + + const LinIntExpr & + x + + + int + n + + +Return expression for $x^n$. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::nroot + (const LinIntExpr &x, int n) + nroot + + const LinIntExpr & + x + + + int + n + + +Return expression for $\lfloor\sqrt[n]{x}\rfloor$. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::element + (const IntVarArgs &x, const LinIntExpr &y) + element + + const IntVarArgs & + x + + + const LinIntExpr & + y + + +Return expression for $x[y]$. + + + + + + + + GECODE_MINIMODEL_EXPORT BoolExpr + GECODE_MINIMODEL_EXPORT BoolExpr Gecode::element + (const BoolVarArgs &x, const LinIntExpr &y) + element + + const BoolVarArgs & + x + + + const LinIntExpr & + y + + +Return expression for $x[y]$. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::element + (const IntArgs &x, const LinIntExpr &y) + element + + const IntArgs & + x + + + const LinIntExpr & + y + + +Return expression for $x[y]$. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::ite + (const BoolExpr &b, const LinIntExpr &x, const LinIntExpr &y) + ite + + const BoolExpr & + b + + + const LinIntExpr & + x + + + const LinIntExpr & + y + + +Return expression for if-then-else $b?x:y$. + + + + + + + + BoolVar + BoolVar Gecode::channel + (Home home, IntVar x, IntConLevel icl=ICL_DEF) + channel + + Home + home + + + IntVar + x + + + IntConLevel + icl + ICL_DEF + + +Return Boolean variable equal to $x$. + + + + + + + + IntVar + IntVar Gecode::channel + (Home home, BoolVar b, IntConLevel icl=ICL_DEF) + channel + + Home + home + + + BoolVar + b + + + IntConLevel + icl + ICL_DEF + + +Return integer variable equal to $b$. + + + + + + + + void + void Gecode::atmost + (Home home, const IntVarArgs &x, int n, int m, IntConLevel icl=ICL_DEF) + atmost + + Home + home + + + const IntVarArgs & + x + + + int + n + + + int + m + + + IntConLevel + icl + ICL_DEF + + +Post constraint $\#\{i\in\{0,\ldots,|x|-1\}\;|\;x_i=n\}\leq m$. + +Supports domain consistent propagation only. + + + + + + void + void Gecode::atmost + (Home home, const IntVarArgs &x, IntVar y, int m, IntConLevel icl=ICL_DEF) + atmost + + Home + home + + + const IntVarArgs & + x + + + IntVar + y + + + int + m + + + IntConLevel + icl + ICL_DEF + + +Post constraint $\#\{i\in\{0,\ldots,|x|-1\}\;|\;x_i=y\}\leq m$. + +Supports domain consistent propagation only. + + + + + + void + void Gecode::atmost + (Home home, const IntVarArgs &x, const IntArgs &y, int m, IntConLevel icl=ICL_DEF) + atmost + + Home + home + + + const IntVarArgs & + x + + + const IntArgs & + y + + + int + m + + + IntConLevel + icl + ICL_DEF + + +Post constraint $\#\{i\in\{0,\ldots,|x|-1\}\;|\;x_i=y_i\}\leq m$. + +Supports domain consistent propagation only.Throws an exception of type Int::ArgumentSizeMismatch, if x and y are of different size. + + + + + + void + void Gecode::atmost + (Home home, const IntVarArgs &x, int n, IntVar z, IntConLevel icl=ICL_DEF) + atmost + + Home + home + + + const IntVarArgs & + x + + + int + n + + + IntVar + z + + + IntConLevel + icl + ICL_DEF + + +Post constraint $\#\{i\in\{0,\ldots,|x|-1\}\;|\;x_i=n\}\leq z$. + +Supports domain consistent propagation only. + + + + + + void + void Gecode::atmost + (Home home, const IntVarArgs &x, IntVar y, IntVar z, IntConLevel icl=ICL_DEF) + atmost + + Home + home + + + const IntVarArgs & + x + + + IntVar + y + + + IntVar + z + + + IntConLevel + icl + ICL_DEF + + +Post constraint $\#\{i\in\{0,\ldots,|x|-1\}\;|\;x_i=y\}\leq z$. + +Supports domain consistent propagation only. + + + + + + void + void Gecode::atmost + (Home home, const IntVarArgs &x, const IntArgs &y, IntVar z, IntConLevel icl=ICL_DEF) + atmost + + Home + home + + + const IntVarArgs & + x + + + const IntArgs & + y + + + IntVar + z + + + IntConLevel + icl + ICL_DEF + + +Post constraint $\#\{i\in\{0,\ldots,|x|-1\}\;|\;x_i=y_i\}\leq z$. + +Supports domain consistent propagation only.Throws an exception of type Int::ArgumentSizeMismatch, if x and y are of different size. + + + + + + void + void Gecode::atleast + (Home home, const IntVarArgs &x, int n, int m, IntConLevel icl=ICL_DEF) + atleast + + Home + home + + + const IntVarArgs & + x + + + int + n + + + int + m + + + IntConLevel + icl + ICL_DEF + + +Post constraint $\#\{i\in\{0,\ldots,|x|-1\}\;|\;x_i=n\}\geq m$. + +Supports domain consistent propagation only. + + + + + + void + void Gecode::atleast + (Home home, const IntVarArgs &x, IntVar y, int m, IntConLevel icl=ICL_DEF) + atleast + + Home + home + + + const IntVarArgs & + x + + + IntVar + y + + + int + m + + + IntConLevel + icl + ICL_DEF + + +Post constraint $\#\{i\in\{0,\ldots,|x|-1\}\;|\;x_i=y\}\geq m$. + +Supports domain consistent propagation only. + + + + + + void + void Gecode::atleast + (Home home, const IntVarArgs &x, const IntArgs &y, int m, IntConLevel icl=ICL_DEF) + atleast + + Home + home + + + const IntVarArgs & + x + + + const IntArgs & + y + + + int + m + + + IntConLevel + icl + ICL_DEF + + +Post constraint $\#\{i\in\{0,\ldots,|x|-1\}\;|\;x_i=y_i\}\geq m$. + +Supports domain consistent propagation only.Throws an exception of type Int::ArgumentSizeMismatch, if x and y are of different size. + + + + + + void + void Gecode::atleast + (Home home, const IntVarArgs &x, int n, IntVar z, IntConLevel icl=ICL_DEF) + atleast + + Home + home + + + const IntVarArgs & + x + + + int + n + + + IntVar + z + + + IntConLevel + icl + ICL_DEF + + +Post constraint $\#\{i\in\{0,\ldots,|x|-1\}\;|\;x_i=n\}\geq z$. + +Supports domain consistent propagation only. + + + + + + void + void Gecode::atleast + (Home home, const IntVarArgs &x, IntVar y, IntVar z, IntConLevel icl=ICL_DEF) + atleast + + Home + home + + + const IntVarArgs & + x + + + IntVar + y + + + IntVar + z + + + IntConLevel + icl + ICL_DEF + + +Post constraint $\#\{i\in\{0,\ldots,|x|-1\}\;|\;x_i=y\}\geq z$. + +Supports domain consistent propagation only. + + + + + + void + void Gecode::atleast + (Home home, const IntVarArgs &x, const IntArgs &y, IntVar z, IntConLevel icl=ICL_DEF) + atleast + + Home + home + + + const IntVarArgs & + x + + + const IntArgs & + y + + + IntVar + z + + + IntConLevel + icl + ICL_DEF + + +Post constraint $\#\{i\in\{0,\ldots,|x|-1\}\;|\;x_i=y_i\}\geq z$. + +Supports domain consistent propagation only.Throws an exception of type Int::ArgumentSizeMismatch, if x and y are of different size. + + + + + + void + void Gecode::exactly + (Home home, const IntVarArgs &x, int n, int m, IntConLevel icl=ICL_DEF) + exactly + + Home + home + + + const IntVarArgs & + x + + + int + n + + + int + m + + + IntConLevel + icl + ICL_DEF + + +Post constraint $\#\{i\in\{0,\ldots,|x|-1\}\;|\;x_i=n\}=m$. + +Supports domain consistent propagation only. + + + + + + void + void Gecode::exactly + (Home home, const IntVarArgs &x, IntVar y, int m, IntConLevel icl=ICL_DEF) + exactly + + Home + home + + + const IntVarArgs & + x + + + IntVar + y + + + int + m + + + IntConLevel + icl + ICL_DEF + + +Post constraint $\#\{i\in\{0,\ldots,|x|-1\}\;|\;x_i=y\}=m$. + +Supports domain consistent propagation only. + + + + + + void + void Gecode::exactly + (Home home, const IntVarArgs &x, const IntArgs &y, int m, IntConLevel icl=ICL_DEF) + exactly + + Home + home + + + const IntVarArgs & + x + + + const IntArgs & + y + + + int + m + + + IntConLevel + icl + ICL_DEF + + +Post constraint $\#\{i\in\{0,\ldots,|x|-1\}\;|\;x_i=y_i\}=m$. + +Supports domain consistent propagation only.Throws an exception of type Int::ArgumentSizeMismatch, if x and y are of different size. + + + + + + void + void Gecode::exactly + (Home home, const IntVarArgs &x, int n, IntVar z, IntConLevel icl=ICL_DEF) + exactly + + Home + home + + + const IntVarArgs & + x + + + int + n + + + IntVar + z + + + IntConLevel + icl + ICL_DEF + + +Post constraint $\#\{i\in\{0,\ldots,|x|-1\}\;|\;x_i=n\}=z$. + +Supports domain consistent propagation only. + + + + + + void + void Gecode::exactly + (Home home, const IntVarArgs &x, IntVar y, IntVar z, IntConLevel icl=ICL_DEF) + exactly + + Home + home + + + const IntVarArgs & + x + + + IntVar + y + + + IntVar + z + + + IntConLevel + icl + ICL_DEF + + +Post constraint $\#\{i\in\{0,\ldots,|x|-1\}\;|\;x_i=y\}=z$. + +Supports domain consistent propagation only. + + + + + + void + void Gecode::exactly + (Home home, const IntVarArgs &x, const IntArgs &y, IntVar z, IntConLevel icl=ICL_DEF) + exactly + + Home + home + + + const IntVarArgs & + x + + + const IntArgs & + y + + + IntVar + z + + + IntConLevel + icl + ICL_DEF + + +Post constraint $\#\{i\in\{0,\ldots,|x|-1\}\;|\;x_i=y_i\}=z$. + +Supports domain consistent propagation only.Throws an exception of type Int::ArgumentSizeMismatch, if x and y are of different size. + + + + + + void + void Gecode::lex + (Home home, const IntVarArgs &x, IntRelType r, const IntVarArgs &y, IntConLevel icl=ICL_DEF) + lex + + Home + home + + + const IntVarArgs & + x + + + IntRelType + r + + + const IntVarArgs & + y + + + IntConLevel + icl + ICL_DEF + + +Post lexical order between x and y. + + + + + + + + void + void Gecode::lex + (Home home, const BoolVarArgs &x, IntRelType r, const BoolVarArgs &y, IntConLevel icl=ICL_DEF) + lex + + Home + home + + + const BoolVarArgs & + x + + + IntRelType + r + + + const BoolVarArgs & + y + + + IntConLevel + icl + ICL_DEF + + +Post lexical order between x and y. + + + + + + + + void + void Gecode::values + (Home home, const IntVarArgs &x, IntSet y, IntConLevel icl=ICL_DEF) + values + + Home + home + + + const IntVarArgs & + x + + + IntSet + y + + + IntConLevel + icl + ICL_DEF + + +Post constraint $\{x_0,\dots,x_{n-1}\}=y$. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::sum + (const Slice< IntArgs > &slice) + sum + + const Slice< IntArgs > & + slice + + +Construct linear expression as sum of IntArgs Slice elements. + + + + + + + + GECODE_MINIMODEL_EXPORT LinIntExpr + GECODE_MINIMODEL_EXPORT LinIntExpr Gecode::sum + (const Matrix< IntArgs > &matrix) + sum + + const Matrix< IntArgs > & + matrix + + +Construct linear expression as sum of IntArgs Matrix elements. + + + + + + + + + + class T + + + T * + T * Gecode::bab + (T *s, const Search::Options &o=Search::Options::def) + bab + + T * + s + + + const Search::Options & + o + Search::Options::def + + +Perform depth-first branch-and-bound search for subclass T of space s and options o. + +Additionally, s must implement a member function virtualvoidconstrain(constT&t) + Whenever exploration requires to add a constraint to the space c currently being explored, the engine executes c.constrain(t) where t is the so-far best solution. + + + + + + + + class T + + + forceinline T * + forceinline T* Gecode::dfs + (T *s, const Search::Options &o) + dfs + + T * + s + + + const Search::Options & + o + + +Invoke depth-first search engine for subclass T of space s with options o. + + + + + + + + + + template< class > class + E + E + + + class T + + + forceinline T * + forceinline T* Gecode::rbs + (T *s, const Search::Options &o) + rbs + + T * + s + + + const Search::Options & + o + + +Perform restart-based search. + +The engine uses the Cutoff sequence supplied in the options o to periodically restart the search of engine E.The class T can implement member functions virtualboolmaster(constCRI&cri) + and virtualboolslave(constCRI&cri) +Whenever exploration restarts or a solution is found, the engine executes the functions on the master and slave space. For more details, consult "Modeling and Programming +with Gecode". + + + + + + + + class T + + + T * + T* Gecode::dfs + (T *s, const Search::Options &o=Search::Options::def) + dfs + + T * + s + + + const Search::Options & + o + Search::Options::def + + +Invoke depth-first search engine for subclass T of space s with options o. + + + + + + + + + + template< class > class + E + E + + + class T + + + T * + T* Gecode::rbs + (T *s, const Search::Options &o) + rbs + + T * + s + + + const Search::Options & + o + + +Perform restart-based search. + +The engine uses the Cutoff sequence supplied in the options o to periodically restart the search of engine E.The class T can implement member functions virtualboolmaster(constCRI&cri) + and virtualboolslave(constCRI&cri) +Whenever exploration restarts or a solution is found, the engine executes the functions on the master and slave space. For more details, consult "Modeling and Programming +with Gecode". + + + + + + SetAssign + SetAssign Gecode::SET_ASSIGN_MIN_INC + (void) + SET_ASSIGN_MIN_INC + + void + + +Include smallest element. + + + + + + + + SetAssign + SetAssign Gecode::SET_ASSIGN_MIN_EXC + (void) + SET_ASSIGN_MIN_EXC + + void + + +Exclude smallest element. + + + + + + + + SetAssign + SetAssign Gecode::SET_ASSIGN_MED_INC + (void) + SET_ASSIGN_MED_INC + + void + + +Include median element (rounding downwards) + + + + + + + + SetAssign + SetAssign Gecode::SET_ASSIGN_MED_EXC + (void) + SET_ASSIGN_MED_EXC + + void + + +Exclude median element (rounding downwards) + + + + + + + + SetAssign + SetAssign Gecode::SET_ASSIGN_MAX_INC + (void) + SET_ASSIGN_MAX_INC + + void + + +Include largest element. + + + + + + + + SetAssign + SetAssign Gecode::SET_ASSIGN_MAX_EXC + (void) + SET_ASSIGN_MAX_EXC + + void + + +Exclude largest element. + + + + + + + + SetAssign + SetAssign Gecode::SET_ASSIGN_RND_INC + (Rnd r) + SET_ASSIGN_RND_INC + + Rnd + r + + +Include random element. + + + + + + + + SetAssign + SetAssign Gecode::SET_ASSIGN_RND_EXC + (Rnd r) + SET_ASSIGN_RND_EXC + + Rnd + r + + +Exclude random element. + + + + + + + + SetAssign + SetAssign Gecode::SET_ASSIGN + (SetBranchVal v, SetBranchCommit c=NULL) + SET_ASSIGN + + SetBranchVal + v + + + SetBranchCommit + c + NULL + + +Select value as defined by the value function v and commit function c. + +The default commit function posts the constraint that the value n must be included in the set variable x. + + + + + + SetValBranch + SetValBranch Gecode::SET_VAL_MIN_INC + (void) + SET_VAL_MIN_INC + + void + + +Include smallest element. + + + + + + + + SetValBranch + SetValBranch Gecode::SET_VAL_MIN_EXC + (void) + SET_VAL_MIN_EXC + + void + + +Exclude smallest element. + + + + + + + + SetValBranch + SetValBranch Gecode::SET_VAL_MED_INC + (void) + SET_VAL_MED_INC + + void + + +Include median element (rounding downwards) + + + + + + + + SetValBranch + SetValBranch Gecode::SET_VAL_MED_EXC + (void) + SET_VAL_MED_EXC + + void + + +Exclude median element (rounding downwards) + + + + + + + + SetValBranch + SetValBranch Gecode::SET_VAL_MAX_INC + (void) + SET_VAL_MAX_INC + + void + + +Include largest element. + + + + + + + + SetValBranch + SetValBranch Gecode::SET_VAL_MAX_EXC + (void) + SET_VAL_MAX_EXC + + void + + +Exclude largest element. + + + + + + + + SetValBranch + SetValBranch Gecode::SET_VAL_RND_INC + (Rnd r) + SET_VAL_RND_INC + + Rnd + r + + +Include random element. + + + + + + + + SetValBranch + SetValBranch Gecode::SET_VAL_RND_EXC + (Rnd r) + SET_VAL_RND_EXC + + Rnd + r + + +Exclude random element. + + + + + + + + SetValBranch + SetValBranch Gecode::SET_VAL + (SetBranchVal v, SetBranchCommit c=NULL) + SET_VAL + + SetBranchVal + v + + + SetBranchCommit + c + NULL + + +Select value as defined by the value function v and commit function c. + +The default commit function posts the constraint that the value n must be included in the set variable x for the first alternative, and that n must be excluded from x otherwise. + + + + + + SetVarBranch + SetVarBranch Gecode::SET_VAR_NONE + (void) + SET_VAR_NONE + + void + + +Select first unassigned variable. + + + + + + + + SetVarBranch + SetVarBranch Gecode::SET_VAR_RND + (Rnd r) + SET_VAR_RND + + Rnd + r + + +Select random variable (uniform distribution, for tie breaking) + + + + + + + + SetVarBranch + SetVarBranch Gecode::SET_VAR_MERIT_MIN + (SetBranchMerit bm, BranchTbl tbl=NULL) + SET_VAR_MERIT_MIN + + SetBranchMerit + bm + + + BranchTbl + tbl + + +Select variable with least merit according to branch merit function bm. + + + + + + + + SetVarBranch + SetVarBranch Gecode::SET_VAR_MERIT_MAX + (SetBranchMerit bm, BranchTbl tbl=NULL) + SET_VAR_MERIT_MAX + + SetBranchMerit + bm + + + BranchTbl + tbl + + +Select variable with highest merit according to branch merit function bm. + + + + + + + + SetVarBranch + SetVarBranch Gecode::SET_VAR_DEGREE_MIN + (BranchTbl tbl=NULL) + SET_VAR_DEGREE_MIN + + BranchTbl + tbl + + +Select variable with smallest degree. + + + + + + + + SetVarBranch + SetVarBranch Gecode::SET_VAR_DEGREE_MAX + (BranchTbl tbl=NULL) + SET_VAR_DEGREE_MAX + + BranchTbl + tbl + + +Select variable with largest degree. + + + + + + + + SetVarBranch + SetVarBranch Gecode::SET_VAR_AFC_MIN + (double d=1.0, BranchTbl tbl=NULL) + SET_VAR_AFC_MIN + + double + d + + + BranchTbl + tbl + + +Select variable with smallest accumulated failure count with decay factor d. + + + + + + + + SetVarBranch + SetVarBranch Gecode::SET_VAR_AFC_MIN + (SetAFC a, BranchTbl tbl=NULL) + SET_VAR_AFC_MIN + + SetAFC + a + + + BranchTbl + tbl + + +Select variable with smallest accumulated failure count. + + + + + + + + SetVarBranch + SetVarBranch Gecode::SET_VAR_AFC_MAX + (double d=1.0, BranchTbl tbl=NULL) + SET_VAR_AFC_MAX + + double + d + + + BranchTbl + tbl + + +Select variable with largest accumulated failure count with decay factor d. + + + + + + + + SetVarBranch + SetVarBranch Gecode::SET_VAR_AFC_MAX + (SetAFC a, BranchTbl tbl=NULL) + SET_VAR_AFC_MAX + + SetAFC + a + + + BranchTbl + tbl + + +Select variable with largest accumulated failure count. + + + + + + + + SetVarBranch + SetVarBranch Gecode::SET_VAR_ACTIVITY_MIN + (double d=1.0, BranchTbl tbl=NULL) + SET_VAR_ACTIVITY_MIN + + double + d + + + BranchTbl + tbl + + +Select variable with lowest activity with decay factor d. + + + + + + + + SetVarBranch + SetVarBranch Gecode::SET_VAR_ACTIVITY_MIN + (SetActivity a, BranchTbl tbl=NULL) + SET_VAR_ACTIVITY_MIN + + SetActivity + a + + + BranchTbl + tbl + + +Select variable with lowest activity. + + + + + + + + SetVarBranch + SetVarBranch Gecode::SET_VAR_ACTIVITY_MAX + (double d=1.0, BranchTbl tbl=NULL) + SET_VAR_ACTIVITY_MAX + + double + d + + + BranchTbl + tbl + + +Select variable with highest activity with decay factor d. + + + + + + + + SetVarBranch + SetVarBranch Gecode::SET_VAR_ACTIVITY_MAX + (SetActivity a, BranchTbl tbl=NULL) + SET_VAR_ACTIVITY_MAX + + SetActivity + a + + + BranchTbl + tbl + + +Select variable with highest activity. + + + + + + + + SetVarBranch + SetVarBranch Gecode::SET_VAR_MIN_MIN + (BranchTbl tbl=NULL) + SET_VAR_MIN_MIN + + BranchTbl + tbl + + +Select variable with smallest minimum unknown element. + + + + + + + + SetVarBranch + SetVarBranch Gecode::SET_VAR_MIN_MAX + (BranchTbl tbl=NULL) + SET_VAR_MIN_MAX + + BranchTbl + tbl + + +Select variable with largest minimum unknown element. + + + + + + + + SetVarBranch + SetVarBranch Gecode::SET_VAR_MAX_MIN + (BranchTbl tbl=NULL) + SET_VAR_MAX_MIN + + BranchTbl + tbl + + +Select variable with smallest maximum unknown element. + + + + + + + + SetVarBranch + SetVarBranch Gecode::SET_VAR_MAX_MAX + (BranchTbl tbl=NULL) + SET_VAR_MAX_MAX + + BranchTbl + tbl + + +Select variable with largest maximum unknown element. + + + + + + + + SetVarBranch + SetVarBranch Gecode::SET_VAR_SIZE_MIN + (BranchTbl tbl=NULL) + SET_VAR_SIZE_MIN + + BranchTbl + tbl + + +Select variable with smallest unknown set. + + + + + + + + SetVarBranch + SetVarBranch Gecode::SET_VAR_SIZE_MAX + (BranchTbl tbl=NULL) + SET_VAR_SIZE_MAX + + BranchTbl + tbl + + +Select variable with largest unknown set. + + + + + + + + SetVarBranch + SetVarBranch Gecode::SET_VAR_DEGREE_SIZE_MIN + (BranchTbl tbl=NULL) + SET_VAR_DEGREE_SIZE_MIN + + BranchTbl + tbl + + +Select variable with smallest degree divided by domain size. + + + + + + + + SetVarBranch + SetVarBranch Gecode::SET_VAR_DEGREE_SIZE_MAX + (BranchTbl tbl=NULL) + SET_VAR_DEGREE_SIZE_MAX + + BranchTbl + tbl + + +Select variable with largest degree divided by domain size. + + + + + + + + SetVarBranch + SetVarBranch Gecode::SET_VAR_AFC_SIZE_MIN + (double d=1.0, BranchTbl tbl=NULL) + SET_VAR_AFC_SIZE_MIN + + double + d + + + BranchTbl + tbl + + +Select variable with smallest accumulated failure count divided by domain size with decay factor d. + + + + + + + + SetVarBranch + SetVarBranch Gecode::SET_VAR_AFC_SIZE_MIN + (SetAFC a, BranchTbl tbl=NULL) + SET_VAR_AFC_SIZE_MIN + + SetAFC + a + + + BranchTbl + tbl + + +Select variable with smallest accumulated failure count divided by domain size. + + + + + + + + SetVarBranch + SetVarBranch Gecode::SET_VAR_AFC_SIZE_MAX + (double d=1.0, BranchTbl tbl=NULL) + SET_VAR_AFC_SIZE_MAX + + double + d + + + BranchTbl + tbl + + +Select variable with largest accumulated failure count divided by domain size with decay factor d. + + + + + + + + SetVarBranch + SetVarBranch Gecode::SET_VAR_AFC_SIZE_MAX + (SetAFC a, BranchTbl tbl=NULL) + SET_VAR_AFC_SIZE_MAX + + SetAFC + a + + + BranchTbl + tbl + + +Select variable with largest accumulated failure count divided by domain size. + + + + + + + + SetVarBranch + SetVarBranch Gecode::SET_VAR_ACTIVITY_SIZE_MIN + (double d=1.0, BranchTbl tbl=NULL) + SET_VAR_ACTIVITY_SIZE_MIN + + double + d + + + BranchTbl + tbl + + +Select variable with smallest activity divided by domain size with decay factor d. + + + + + + + + SetVarBranch + SetVarBranch Gecode::SET_VAR_ACTIVITY_SIZE_MIN + (SetActivity a, BranchTbl tbl=NULL) + SET_VAR_ACTIVITY_SIZE_MIN + + SetActivity + a + + + BranchTbl + tbl + + +Select variable with smallest activity divided by domain size. + + + + + + + + SetVarBranch + SetVarBranch Gecode::SET_VAR_ACTIVITY_SIZE_MAX + (double d=1.0, BranchTbl tbl=NULL) + SET_VAR_ACTIVITY_SIZE_MAX + + double + d + + + BranchTbl + tbl + + +Select variable with largest activity divided by domain size with decay factor d. + + + + + + + + SetVarBranch + SetVarBranch Gecode::SET_VAR_ACTIVITY_SIZE_MAX + (SetActivity a, BranchTbl tbl=NULL) + SET_VAR_ACTIVITY_SIZE_MAX + + SetActivity + a + + + BranchTbl + tbl + + +Select variable with largest activity divided by domain size. + + + + + + + + + + class View0 + + + class View1 + + + forceinline bool + forceinline bool Gecode::viewarrayshared + (const Space &home, const ViewArray< View0 > &va, const View1 &y) + viewarrayshared + + const Space & + home + + + const ViewArray< View0 > & + va + + + const View1 & + y + + + + + + + + + + + + + forceinline bool + forceinline bool Gecode::viewarrayshared< Set::SingletonView, Set::SetView > + (const Space &, const ViewArray< Set::SingletonView > &, const Set::SetView &) + viewarrayshared< Set::SingletonView, Set::SetView > + + const Space & + + + const ViewArray< Set::SingletonView > & + + + const Set::SetView & + + + + + + + + + + + + + class Char + + + class Traits + + + std::basic_ostream< Char, Traits > & + std::basic_ostream<Char,Traits>& Gecode::operator<< + (std::basic_ostream< Char, Traits > &os, const SetVar &x) + operator<< + + std::basic_ostream< Char, Traits > & + os + + + const SetVar & + x + + + + + + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::dom + (Home home, SetVar x, SetRelType r, int i) + dom + + Home + home + + + SetVar + x + + + SetRelType + r + + + int + i + + +Propagates $ x \sim_r \{i\}$. + + + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::dom + (Home home, const SetVarArgs &x, SetRelType r, int i) + dom + + Home + home + + + const SetVarArgs & + x + + + SetRelType + r + + + int + i + + +Propagates $ x_i \sim_r \{i\}$ for all $0\leq i<|x|$. + + + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::dom + (Home home, SetVar x, SetRelType r, int i, int j) + dom + + Home + home + + + SetVar + x + + + SetRelType + r + + + int + i + + + int + j + + +Propagates $ x \sim_r \{i,\dots,j\}$. + + + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::dom + (Home home, const SetVarArgs &x, SetRelType r, int i, int j) + dom + + Home + home + + + const SetVarArgs & + x + + + SetRelType + r + + + int + i + + + int + j + + +Propagates $ x \sim_r \{i,\dots,j\}$ for all $0\leq i<|x|$. + + + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::dom + (Home home, SetVar x, SetRelType r, const IntSet &s) + dom + + Home + home + + + SetVar + x + + + SetRelType + r + + + const IntSet & + s + + +Propagates $ x \sim_r s$. + + + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::dom + (Home home, const SetVarArgs &x, SetRelType r, const IntSet &s) + dom + + Home + home + + + const SetVarArgs & + x + + + SetRelType + r + + + const IntSet & + s + + +Propagates $ x \sim_r s$ for all $0\leq i<|x|$. + + + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::cardinality + (Home home, SetVar x, unsigned int i, unsigned int j) + cardinality + + Home + home + + + SetVar + x + + + unsigned int + i + + + unsigned int + j + + +Propagates $ i \leq |s| \leq j $. + + + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::cardinality + (Home home, const SetVarArgs &x, unsigned int i, unsigned int j) + cardinality + + Home + home + + + const SetVarArgs & + x + + + unsigned int + i + + + unsigned int + j + + +Propagates $ i \leq |s| \leq j $ for all $0\leq i<|x|$. + + + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::dom + (Home home, SetVar x, SetRelType rt, int i, Reify r) + dom + + Home + home + + + SetVar + x + + + SetRelType + rt + + + int + i + + + Reify + r + + +Post propagator for $ (x \sim_{rt} \{i\}) \equiv r $. + + + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::dom + (Home home, SetVar x, SetRelType rt, int i, int j, Reify r) + dom + + Home + home + + + SetVar + x + + + SetRelType + rt + + + int + i + + + int + j + + + Reify + r + + +Post propagator for $ (x \sim_{rt} \{i,\dots,j\}) \equiv r $. + + + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::dom + (Home home, SetVar x, SetRelType rt, const IntSet &s, Reify r) + dom + + Home + home + + + SetVar + x + + + SetRelType + rt + + + const IntSet & + s + + + Reify + r + + +Post propagator for $ (x \sim_{rt} s) \equiv r $. + + + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::dom + (Home home, SetVar x, SetVar d) + dom + + Home + home + + + SetVar + x + + + SetVar + d + + +Constrain domain of x according to domain of d. + + + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::dom + (Home home, const SetVarArgs &x, const SetVarArgs &d) + dom + + Home + home + + + const SetVarArgs & + x + + + const SetVarArgs & + d + + +Constrain domain of $ x_i $ according to domain of $ d_i $ for all $0\leq i<|x|$. + + + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::rel + (Home home, SetVar x, SetRelType r, SetVar y) + rel + + Home + home + + + SetVar + x + + + SetRelType + r + + + SetVar + y + + +Post propagator for $ x \sim_r y$. + + + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::rel + (Home home, SetVar x, SetRelType rt, SetVar y, Reify r) + rel + + Home + home + + + SetVar + x + + + SetRelType + rt + + + SetVar + y + + + Reify + r + + +Post propagator for $ (x \sim_{rt} y) \equiv r$. + + + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::rel + (Home home, SetVar s, SetRelType r, IntVar x) + rel + + Home + home + + + SetVar + s + + + SetRelType + r + + + IntVar + x + + +Post propagator for $ s \sim_r \{x\}$. + + + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::rel + (Home home, IntVar x, SetRelType r, SetVar s) + rel + + Home + home + + + IntVar + x + + + SetRelType + r + + + SetVar + s + + +Post propagator for $ \{x\} \sim_r s$. + + + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::rel + (Home home, SetVar s, SetRelType rt, IntVar x, Reify r) + rel + + Home + home + + + SetVar + s + + + SetRelType + rt + + + IntVar + x + + + Reify + r + + +Post propagator for $ (s \sim_{rt} \{x\}) \equiv r$. + + + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::rel + (Home home, IntVar x, SetRelType rt, SetVar s, Reify r) + rel + + Home + home + + + IntVar + x + + + SetRelType + rt + + + SetVar + s + + + Reify + r + + +Post propagator for $ (\{x\} \sim_{rt} s) \equiv r $. + + + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::rel + (Home home, SetVar s, IntRelType r, IntVar x) + rel + + Home + home + + + SetVar + s + + + IntRelType + r + + + IntVar + x + + +Post propagator for $|s|\geq 1 \land \forall i\in s:\ i \sim_r x$. + + + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::rel + (Home home, IntVar x, IntRelType r, SetVar s) + rel + + Home + home + + + IntVar + x + + + IntRelType + r + + + SetVar + s + + +Post propagator for $|s|\geq 1 \land \forall i\in s:\ x \sim_r i$. + + + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::rel + (Home home, SetVar x, SetOpType op, SetVar y, SetRelType r, SetVar z) + rel + + Home + home + + + SetVar + x + + + SetOpType + op + + + SetVar + y + + + SetRelType + r + + + SetVar + z + + +Post propagator for $ (x \diamond_{\mathit{op}} y) \sim_r z $. + + + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::rel + (Home home, SetOpType op, const SetVarArgs &x, SetVar y) + rel + + Home + home + + + SetOpType + op + + + const SetVarArgs & + x + + + SetVar + y + + +Post propagator for $ y = \diamond_{\mathit{op}} x$. + + + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::rel + (Home home, SetOpType op, const SetVarArgs &x, const IntSet &z, SetVar y) + rel + + Home + home + + + SetOpType + op + + + const SetVarArgs & + x + + + const IntSet & + z + + + SetVar + y + + +Post propagator for $ y = \diamond_{\mathit{op}} x \diamond_{\mathit{op}} z$. + + + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::rel + (Home home, SetOpType op, const IntVarArgs &x, const IntSet &z, SetVar y) + rel + + Home + home + + + SetOpType + op + + + const IntVarArgs & + x + + + const IntSet & + z + + + SetVar + y + + +Post propagator for $ y = \diamond_{\mathit{op}} x \diamond_{\mathit{op}} z$. + + + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::rel + (Home home, SetOpType op, const IntVarArgs &x, SetVar y) + rel + + Home + home + + + SetOpType + op + + + const IntVarArgs & + x + + + SetVar + y + + +Post propagator for $ y = \diamond_{\mathit{op}} x$. + + + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::rel + (Home home, const IntSet &x, SetOpType op, SetVar y, SetRelType r, SetVar z) + rel + + Home + home + + + const IntSet & + x + + + SetOpType + op + + + SetVar + y + + + SetRelType + r + + + SetVar + z + + +Post propagator for $ (x \diamond_{\mathit{op}} y) \sim_r z $. + + + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::rel + (Home home, SetVar x, SetOpType op, const IntSet &y, SetRelType r, SetVar z) + rel + + Home + home + + + SetVar + x + + + SetOpType + op + + + const IntSet & + y + + + SetRelType + r + + + SetVar + z + + +Post propagator for $ (x \diamond_{\mathit{op}} y) \sim_r z $. + + + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::rel + (Home home, SetVar x, SetOpType op, SetVar y, SetRelType r, const IntSet &z) + rel + + Home + home + + + SetVar + x + + + SetOpType + op + + + SetVar + y + + + SetRelType + r + + + const IntSet & + z + + +Post propagator for $ (x \diamond_{\mathit{op}} y) \sim_r z $. + + + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::rel + (Home home, const IntSet &x, SetOpType op, SetVar y, SetRelType r, const IntSet &z) + rel + + Home + home + + + const IntSet & + x + + + SetOpType + op + + + SetVar + y + + + SetRelType + r + + + const IntSet & + z + + +Post propagator for $ (x \diamond_{\mathit{op}} y) \sim_r z $. + + + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::rel + (Home home, SetVar x, SetOpType op, const IntSet &y, SetRelType r, const IntSet &z) + rel + + Home + home + + + SetVar + x + + + SetOpType + op + + + const IntSet & + y + + + SetRelType + r + + + const IntSet & + z + + +Post propagator for $ (x \diamond_{\mathit{op}} y) \sim_r z $. + + + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::convex + (Home home, SetVar x) + convex + + Home + home + + + SetVar + x + + +Post propagator that propagates that x is convex. + + + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::convex + (Home home, SetVar x, SetVar y) + convex + + Home + home + + + SetVar + x + + + SetVar + y + + +Post propagator that propagates that y is the convex hull of x. + + + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::sequence + (Home home, const SetVarArgs &x) + sequence + + Home + home + + + const SetVarArgs & + x + + +Post propagator for $\forall 0\leq i< |x|-1 : \max(x_i)<\min(x_{i+1})$. + + + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::sequence + (Home home, const SetVarArgs &y, SetVar x) + sequence + + Home + home + + + const SetVarArgs & + y + + + SetVar + x + + +Post propagator for $\forall 0\leq i< |x|-1 : \max(x_i)<\min(x_{i+1})$ and $ x = \bigcup_{i\in\{0,\dots,n-1\}} y_i $. + + + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::atmostOne + (Home home, const SetVarArgs &x, unsigned int c) + atmostOne + + Home + home + + + const SetVarArgs & + x + + + unsigned int + c + + +Post propagator for $\forall 0\leq i\leq |x| : |x_i|=c$ and $\forall 0\leq i<j\leq |x| : |x_i\cap x_j|\leq 1$. + + + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::min + (Home home, SetVar s, IntVar x) + min + + Home + home + + + SetVar + s + + + IntVar + x + + +Post propagator that propagates that x is the minimal element of s, and that s is not empty. + + + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::notMin + (Home home, SetVar s, IntVar x) + notMin + + Home + home + + + SetVar + s + + + IntVar + x + + +Post propagator that propagates that x is not the minimal element of s. + + + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::min + (Home home, SetVar s, IntVar x, Reify r) + min + + Home + home + + + SetVar + s + + + IntVar + x + + + Reify + r + + +Post reified propagator for b iff x is the minimal element of s. + + + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::max + (Home home, SetVar s, IntVar x) + max + + Home + home + + + SetVar + s + + + IntVar + x + + +Post propagator that propagates that x is the maximal element of s, and that s is not empty. + + + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::notMax + (Home home, SetVar s, IntVar x) + notMax + + Home + home + + + SetVar + s + + + IntVar + x + + +Post propagator that propagates that x is not the maximal element of s. + + + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::max + (Home home, SetVar s, IntVar x, Reify r) + max + + Home + home + + + SetVar + s + + + IntVar + x + + + Reify + r + + +Post reified propagator for b iff x is the maximal element of s. + + + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::cardinality + (Home home, SetVar s, IntVar x) + cardinality + + Home + home + + + SetVar + s + + + IntVar + x + + +Post propagator for $ |s|=x $. + + + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::weights + (Home home, IntSharedArray elements, IntSharedArray weights, SetVar x, IntVar y) + weights + + Home + home + + + IntSharedArray + elements + + + IntSharedArray + weights + + + SetVar + x + + + IntVar + y + + +Post propagator for $y = \mathrm{weight}(x)$. + +The weights are given as pairs of elements and their weight: $\mathrm{weight}(\mathrm{elements}_i) = \mathrm{weights}_i$The upper bound of x is constrained to contain only elements from elements. The weight of a set is the sum of the weights of its elements. + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::channel + (Home home, const IntVarArgs &x, const SetVarArgs &y) + channel + + Home + home + + + const IntVarArgs & + x + + + const SetVarArgs & + y + + +Post propagator for $x_i=j \Leftrightarrow i\in y_j$. + + + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::channelSorted + (Home home, const IntVarArgs &x, SetVar y) + channelSorted + + Home + home + + + const IntVarArgs & + x + + + SetVar + y + + +Post propagator for $\{x_0,\dots,x_{n-1}\}=y$ and $x_i<x_{i+1}$. + + + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::channel + (Home home, const BoolVarArgs &x, SetVar y) + channel + + Home + home + + + const BoolVarArgs & + x + + + SetVar + y + + +Post propagator for $x_i=1 \Leftrightarrow i\in y$. + + + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::channel + (Home home, const SetVarArgs &x, const SetVarArgs &y) + channel + + Home + home + + + const SetVarArgs & + x + + + const SetVarArgs & + y + + +Post propagator for $j\in x_i \Leftrightarrow i\in y_j$. + + + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::precede + (Home home, const SetVarArgs &x, int s, int t) + precede + + Home + home + + + const SetVarArgs & + x + + + int + s + + + int + t + + +Post propagator that s precedes t in x. + +This constraint enforces that if there exists $j$ such that $s\notin x_j\land t\in x_j$, then there exists $i<j$ such that $s\in x_i\land t\notin x_i$. + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::precede + (Home home, const SetVarArgs &x, const IntArgs &c) + precede + + Home + home + + + const SetVarArgs & + x + + + const IntArgs & + c + + +Post propagator that successive values in c precede each other in x. + + + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::element + (Home home, SetOpType op, const SetVarArgs &x, SetVar y, SetVar z, const IntSet &u=IntSet(Set::Limits::min, Set::Limits::max)) + element + + Home + home + + + SetOpType + op + + + const SetVarArgs & + x + + + SetVar + y + + + SetVar + z + + + const IntSet & + u + IntSet(Set::Limits::min, Set::Limits::max) + + +Post propagator for $ z=\diamond_{\mathit{op}}\langle x_0,\dots,x_{n-1}\rangle[y] $. + +If y is the empty set, the usual conventions for set operations apply: an empty union is empty, while an empty intersection is the universe, which can be given as the optional parameter u.The indices for y start at 0. + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::element + (Home home, SetOpType op, const IntVarArgs &x, SetVar y, SetVar z, const IntSet &u=IntSet(Set::Limits::min, Set::Limits::max)) + element + + Home + home + + + SetOpType + op + + + const IntVarArgs & + x + + + SetVar + y + + + SetVar + z + + + const IntSet & + u + IntSet(Set::Limits::min, Set::Limits::max) + + +Post propagator for $ z=\diamond_{\mathit{op}}\langle \{x_0\},\dots,\{x_{n-1}\}\rangle[y] $. + +If y is the empty set, the usual conventions for set operations apply: an empty union is empty, while an empty intersection is the universe, which can be given as the optional parameter u.The indices for y start at 0. + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::element + (Home home, SetOpType op, const IntSetArgs &x, SetVar y, SetVar z, const IntSet &u=IntSet(Set::Limits::min, Set::Limits::max)) + element + + Home + home + + + SetOpType + op + + + const IntSetArgs & + x + + + SetVar + y + + + SetVar + z + + + const IntSet & + u + IntSet(Set::Limits::min, Set::Limits::max) + + +Post propagator for $ z=\diamond_{\mathit{op}}\langle x_0,\dots,x_{n-1}\rangle[y] $. + +If y is the empty set, the usual conventions for set operations apply: an empty union is empty, while an empty intersection is the universe, which can be given as the optional parameter u.The indices for y start at 0. + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::element + (Home home, SetOpType op, const IntArgs &x, SetVar y, SetVar z, const IntSet &u=IntSet(Set::Limits::min, Set::Limits::max)) + element + + Home + home + + + SetOpType + op + + + const IntArgs & + x + + + SetVar + y + + + SetVar + z + + + const IntSet & + u + IntSet(Set::Limits::min, Set::Limits::max) + + +Post propagator for $ z=\diamond_{\mathit{op}}\langle \{x_0\},\dots,\{x_{n-1}\}\rangle[y] $. + +If y is the empty set, the usual conventions for set operations apply: an empty union is empty, while an empty intersection is the universe, which can be given as the optional parameter u.The indices for y start at 0. + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::element + (Home home, const SetVarArgs &x, IntVar y, SetVar z) + element + + Home + home + + + const SetVarArgs & + x + + + IntVar + y + + + SetVar + z + + +Post propagator for $ z=\langle x_0,\dots,x_{n-1}\rangle[y] $. + +The indices for y start at 0. + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::element + (Home home, const IntSetArgs &s, IntVar y, SetVar z) + element + + Home + home + + + const IntSetArgs & + s + + + IntVar + y + + + SetVar + z + + +Post propagator for $ z=\langle s_0,\dots,s_{n-1}\rangle[y] $. + +The indices for y start at 0. + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::element + (Home home, const IntSetArgs &a, IntVar x, int w, IntVar y, int h, SetVar z) + element + + Home + home + + + const IntSetArgs & + a + + + IntVar + x + + + int + w + + + IntVar + y + + + int + h + + + SetVar + z + + +Post propagator for $ a_{x+w\cdot y}=z$. + +Throws an exception of type Set::ArgumentSizeMismatch, if $ w\cdot h\neq|a|$. + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::element + (Home home, const SetVarArgs &a, IntVar x, int w, IntVar y, int h, SetVar z) + element + + Home + home + + + const SetVarArgs & + a + + + IntVar + x + + + int + w + + + IntVar + y + + + int + h + + + SetVar + z + + +Post propagator for $ a_{x+w\cdot y}=z$. + +Throws an exception of type Set::ArgumentSizeMismatch, if $ w\cdot h\neq|a|$. + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::wait + (Home home, SetVar x, void(*c)(Space &home)) + wait + + Home + home + + + SetVar + x + + + void(*)(Space &home) + c + + +Execute c when x becomes assigned. + + + + + + + + GECODE_SET_EXPORT void + GECODE_SET_EXPORT void Gecode::wait + (Home home, const SetVarArgs &x, void(*c)(Space &home)) + wait + + Home + home + + + const SetVarArgs & + x + + + void(*)(Space &home) + c + + +Execute c when all variables in x become assigned. + + + + + + + + GECODE_SET_EXPORT BrancherHandle + GECODE_SET_EXPORT BrancherHandle Gecode::branch + (Home home, const SetVarArgs &x, SetVarBranch vars, SetValBranch vals, SetBranchFilter bf=NULL, SetVarValPrint vvp=NULL) + branch + + Home + home + + + const SetVarArgs & + x + + + SetVarBranch + vars + + + SetValBranch + vals + + + SetBranchFilter + bf + NULL + + + SetVarValPrint + vvp + NULL + + +Branch over x with variable selection vars and value selection vals. + + + + + + + + GECODE_SET_EXPORT BrancherHandle + GECODE_SET_EXPORT BrancherHandle Gecode::branch + (Home home, const SetVarArgs &x, TieBreak< SetVarBranch > vars, SetValBranch vals, SetBranchFilter bf=NULL, SetVarValPrint vvp=NULL) + branch + + Home + home + + + const SetVarArgs & + x + + + TieBreak< SetVarBranch > + vars + + + SetValBranch + vals + + + SetBranchFilter + bf + NULL + + + SetVarValPrint + vvp + NULL + + +Branch over x with tie-breaking variable selection vars and value selection vals. + + + + + + + + GECODE_SET_EXPORT BrancherHandle + GECODE_SET_EXPORT BrancherHandle Gecode::branch + (Home home, SetVar x, SetValBranch vals, SetVarValPrint vvp=NULL) + branch + + Home + home + + + SetVar + x + + + SetValBranch + vals + + + SetVarValPrint + vvp + NULL + + +Branch over x with value selection vals. + + + + + + + + GECODE_SET_EXPORT BrancherHandle + GECODE_SET_EXPORT BrancherHandle Gecode::assign + (Home home, const SetVarArgs &x, SetAssign vals, SetBranchFilter bf=NULL, SetVarValPrint vvp=NULL) + assign + + Home + home + + + const SetVarArgs & + x + + + SetAssign + vals + + + SetBranchFilter + bf + NULL + + + SetVarValPrint + vvp + NULL + + +Assign all x with value selection vals. + + + + + + + + GECODE_SET_EXPORT BrancherHandle + GECODE_SET_EXPORT BrancherHandle Gecode::assign + (Home home, SetVar x, SetAssign vals, SetVarValPrint vvp=NULL) + assign + + Home + home + + + SetVar + x + + + SetAssign + vals + + + SetVarValPrint + vvp + NULL + + +Assign x with value selection vals. + + + + + + + + GECODE_SET_EXPORT SymmetryHandle + GECODE_SET_EXPORT SymmetryHandle Gecode::VariableSymmetry + (const SetVarArgs &x) + VariableSymmetry + + const SetVarArgs & + x + + +Variables in x are interchangeable. + + + + + + + + GECODE_SET_EXPORT SymmetryHandle + GECODE_SET_EXPORT SymmetryHandle Gecode::VariableSequenceSymmetry + (const SetVarArgs &x, int ss) + VariableSequenceSymmetry + + const SetVarArgs & + x + + + int + ss + + +Variable sequences in x of size ss are interchangeable. + +The size of x must be a multiple of ss. + + + + + + GECODE_SET_EXPORT BrancherHandle + GECODE_SET_EXPORT BrancherHandle Gecode::branch + (Home home, const SetVarArgs &x, SetVarBranch vars, SetValBranch vals, const Symmetries &syms, SetBranchFilter bf=NULL, SetVarValPrint vvp=NULL) + branch + + Home + home + + + const SetVarArgs & + x + + + SetVarBranch + vars + + + SetValBranch + vals + + + const Symmetries & + syms + + + SetBranchFilter + bf + NULL + + + SetVarValPrint + vvp + NULL + + +Branch over x with variable selection vars and value selection vals with symmetry breaking. + + + + + + + + GECODE_SET_EXPORT BrancherHandle + GECODE_SET_EXPORT BrancherHandle Gecode::branch + (Home home, const SetVarArgs &x, TieBreak< SetVarBranch > vars, SetValBranch vals, const Symmetries &syms, SetBranchFilter bf=NULL, SetVarValPrint vvp=NULL) + branch + + Home + home + + + const SetVarArgs & + x + + + TieBreak< SetVarBranch > + vars + + + SetValBranch + vals + + + const Symmetries & + syms + + + SetBranchFilter + bf + NULL + + + SetVarValPrint + vvp + NULL + + +Branch over x with tie-breaking variable selection vars and value selection vals with symmetry breaking. + + + + + + + + + + class T + + + T + T Gecode::ptr_cast + (void *p) + ptr_cast + + void * + p + + +Cast p into pointer of type T. + + + + + + + + + + class F1 + + + class F2 + + + F1 + F1 Gecode::function_cast + (F2 f) + function_cast + + F2 + f + + +Cast function pointer. + + + + + + + + + + class T + + + forceinline T + forceinline T Gecode::ptr_cast + (void *p) + ptr_cast + + void * + p + + +Cast p into pointer of type T. + + + + + + + + + + class F1 + + + class F2 + + + forceinline F1 + forceinline F1 Gecode::function_cast + (F2 f) + function_cast + + F2 + f + + +Cast function pointer. + + + + + + + + +Gecode toplevel namespace + +The Gecode namespace contains nested namespaces for the various submodules (for example Int for the definition of integer propagator classes). Functionality that is used for interfacing (search engines, variables, and so on) or belongs to the Gecode Kernel is contained directly in the Gecode namespace. + + +