|
||||||||||
PREV NEXT | FRAMES NO FRAMES |
Uses of ContradictionException in choco.cp.solver |
---|
Methods in choco.cp.solver that throw ContradictionException | |
---|---|
void |
CPSolver.propagate()
Propagation: Computes consistency on the model (the model may no longer be consistent since the last propagation because of listeners that have been posted and variables that have been reduced |
Uses of ContradictionException in choco.cp.solver.constraints.global |
---|
Methods in choco.cp.solver.constraints.global that throw ContradictionException | |
---|---|
void |
Lex.ACleq(int i)
|
void |
Lex.ACless(int i)
|
void |
IncreasingNValue.adjustMax(int idx,
int val)
|
void |
IncreasingNValue.adjustMin(int idx,
int val)
|
void |
SortingSConstraint.awake()
This method is invoked during the first propagation. |
void |
SemiLeximinSConstraint.awake()
This method is invoked during the first propagation. |
void |
Occurrence.awake()
|
void |
LeximinSConstraint.awake()
This method is invoked during the first propagation. |
void |
LexChain.awake()
|
void |
Lex.awake()
|
void |
Geost_Constraint.awake()
|
void |
BoundGccVar.awake()
|
void |
BoundGcc.awake()
|
void |
BoundAllDiff.awake()
|
void |
AtMostNValue.awake()
|
void |
AmongGAC.awake()
Propagation: Propagating the constraint for the very first time until local consistency is reached. |
void |
Geost_Constraint.awakeOnBounds(int varIndex)
|
void |
BoundAllDiff.awakeOnBounds(int idx)
|
void |
SortingSConstraint.awakeOnInf(int idx)
This method is called when the minimal value of the domain of a variable has been updated. |
void |
SemiLeximinSConstraint.awakeOnInf(int idx)
Cette m�thode r�agit si une variable a vu sa borne inf�rieure augmenter. |
void |
Occurrence.awakeOnInf(int idx)
|
void |
LeximinSConstraint.awakeOnInf(int idx)
Cette m�thode r�agit si une variable a vu sa borne inf�rieure augmenter. |
void |
Lex.awakeOnInf(int idx)
|
void |
Geost_Constraint.awakeOnInf(int idx)
|
void |
BoundGccVar.awakeOnInf(int i)
|
void |
BoundGcc.awakeOnInf(int i)
|
void |
BoundAllDiff.awakeOnInf(int i)
|
void |
AtMostNValue.awakeOnInf(int idx)
|
void |
AmongGAC.awakeOnInf(int varIdx)
Default propagation on improved lower bound: propagation on domain revision. |
void |
SortingSConstraint.awakeOnInst(int idx)
This method is called when a variable has been instanciated |
void |
SemiLeximinSConstraint.awakeOnInst(int idx)
This method is called when a variable has been instanciated |
void |
Occurrence.awakeOnInst(int idx)
|
void |
LeximinSConstraint.awakeOnInst(int idx)
This method is called when a variable has been instanciated |
void |
LexChain.awakeOnInst(int idx)
|
void |
Lex.awakeOnInst(int idx)
|
void |
Geost_Constraint.awakeOnInst(int idx)
|
void |
BoundGccVar.awakeOnInst(int i)
|
void |
BoundGcc.awakeOnInst(int i)
|
void |
BoundAllDiff.awakeOnInst(int i)
|
void |
AtMostNValue.awakeOnInst(int idx)
|
void |
AmongGAC.awakeOnInst(int idx)
Default propagation on instantiation: full constraint re-propagation. |
void |
Lex.awakeOnRem(int idx,
int x)
|
void |
Geost_Constraint.awakeOnRem(int idx,
int x)
|
void |
BoundGccVar.awakeOnRem(int idx,
int i)
Only maintain the data structure and update upperbounds of card |
void |
BoundGcc.awakeOnRem(int idx,
int val)
|
void |
AmongGAC.awakeOnRem(int varIdx,
int val)
Default propagation on one value removal: propagation on domain revision. |
void |
Occurrence.awakeOnRemovals(int idx,
DisposableIntIterator deltaDomain)
|
void |
Geost_Constraint.awakeOnRemovals(int idx,
DisposableIntIterator deltaDomain)
|
void |
BoundAllDiff.awakeOnRemovals(int idx,
DisposableIntIterator deltaDomain)
|
void |
AtMostNValue.awakeOnRemovals(int idx,
DisposableIntIterator deltaDomain)
|
void |
SortingSConstraint.awakeOnSup(int idx)
This method is called when the maximal value of the domain of a variable has been updated. |
void |
SemiLeximinSConstraint.awakeOnSup(int idx)
Cette m�thode r�agit si une variable a vu sa borne sup�rieure diminuer. |
void |
Occurrence.awakeOnSup(int idx)
|
void |
LeximinSConstraint.awakeOnSup(int idx)
Cette m�thode r�agit si une variable a vu sa borne sup�rieure diminuer. |
void |
Lex.awakeOnSup(int idx)
|
void |
Geost_Constraint.awakeOnSup(int idx)
|
void |
BoundGccVar.awakeOnSup(int i)
|
void |
BoundGcc.awakeOnSup(int i)
|
void |
BoundAllDiff.awakeOnSup(int i)
|
void |
AtMostNValue.awakeOnSup(int idx)
|
void |
AmongGAC.awakeOnSup(int varIdx)
Default propagation on improved upper bound: propagation on domain revision. |
void |
SortingSConstraint.boundConsistency()
|
void |
LexChain.boundsLex(int[] a,
IntDomainVar[] x,
int[] b,
int j)
Filtering algorithm for between(a,x,b) Ensures that x is lexicographically greater than a and less than b if strict is false otherwise x is lexicographically greater than or equal to a and less than or equal to b |
void |
Occurrence.checkNbPossible()
|
void |
Occurrence.checkNbSure()
|
int |
LexChain.computeAlpha(IntDomainVar[] x,
int[] b)
computes alpha for use in computing lexicographically largest feasible upper bound of x in computUB |
int |
LexChain.computeBeta(IntDomainVar[] x,
int[] a)
computes beta for use in computing lexicographically smallest feasible lower bound of x in computeLB |
void |
LexChain.computeLB(IntDomainVar[] x,
int[] a,
int[] lower)
Computes the lexicographically smallest feasible lower bound vector of integers of x . |
void |
LexChain.computeUB(IntDomainVar[] x,
int[] b,
int[] u)
Computes the lexicographically largest feasible upper bound vector of integers of x . |
void |
Occurrence.filter()
|
void |
LexChain.filter()
Implements the main filtering algorithm by calling boundsLex for
each vector in the chain. |
void |
Geost_Constraint.filter()
|
void |
Lex.filter(int i)
|
void |
BoundGccVar.filterBCOnInf(int i)
|
void |
BoundGccVar.filterBCOnInst(int val)
Enforce simple occurrences reasonnings on value val no need to reason on the number of possible (instead of sure) values as this will be done as part of the BC on vars |
void |
BoundGccVar.filterBCOnRem(int val)
|
void |
BoundGccVar.filterBCOnSup(int i)
|
protected void |
BoundAllDiff.filterLower()
|
protected void |
BoundGccVar.filterLowerMax()
Shrink the lower bounds for the max occurences |
void |
BoundGccVar.filterLowerMin()
|
protected void |
BoundAllDiff.filterUpper()
|
protected void |
BoundGccVar.filterUpperMax()
Shrink the upper bounds for the max occurences |
void |
BoundGccVar.filterUpperMin()
|
void |
BoundGccVar.initBackDataStruct()
|
void |
Lex.initialize()
|
void |
SortingSConstraint.propagate()
This methode propagates the constraint events. |
void |
SemiLeximinSConstraint.propagate()
This methode propagates the constraint events. |
void |
Occurrence.propagate()
|
void |
LeximinSConstraint.propagate()
This methode propagates the constraint events. |
void |
LexChain.propagate()
|
void |
Lex.propagate()
|
void |
IncreasingNValue.propagate()
|
void |
Geost_Constraint.propagate()
|
void |
Exactly.propagate()
Propagation: Propagating the constraint until local consistency is reached. |
void |
BoundGccVar.propagate()
|
void |
BoundGcc.propagate()
|
void |
BoundAllDiff.propagate()
|
void |
AtMostNValue.propagate()
|
void |
AmongGAC.propagate()
Propagation: Propagating the constraint until local consistency is reached. |
void |
BoundGccVar.propagateSumCard()
Enforce sum of the cardinalities = nbVariable |
void |
SemiLeximinSConstraint.setPointersAndFlags()
The setPointersAndFlags method sets the values
α, β, γ and δ, used by the algorithm. |
void |
LeximinSConstraint.setPointersAndFlags()
The setPointersAndFlags method sets the values
α, β, γ and δ, used by the algorithm. |
void |
Lex.updateAlpha(int i)
|
void |
Lex.updateBeta(int i)
|
void |
SemiLeximinSConstraint.updatePointersAndFlags(int idx,
boolean inf)
The setPointersAndFlags method updates the values
α, β, γ and δ, used by the algorithm,
when the domain of a variable has changed. |
void |
LeximinSConstraint.updatePointersAndFlags(int idx,
boolean inf)
The setPointersAndFlags method updates the values
α, β, γ and δ, used by the algorithm,
when the domain of a variable has changed. |
Uses of ContradictionException in choco.cp.solver.constraints.global.automata.fast_costregular |
---|
Methods in choco.cp.solver.constraints.global.automata.fast_costregular that throw ContradictionException | |
---|---|
void |
CostRegular.awake()
|
void |
CostKnapSack.awake()
|
void |
CostRegular.awakeOnInf(int idx)
|
void |
CostRegular.awakeOnRemovals(int idx,
DisposableIntIterator it2)
|
void |
CostRegular.awakeOnSup(int idx)
|
void |
CostKnapSack.initGraph()
|
void |
CostRegular.initGraph(ICostAutomaton pi)
|
void |
CostRegular.prefilter()
|
void |
CostRegular.propagate()
|
Uses of ContradictionException in choco.cp.solver.constraints.global.automata.fast_multicostregular |
---|
Methods in choco.cp.solver.constraints.global.automata.fast_multicostregular that throw ContradictionException | |
---|---|
void |
SoftMultiCostRegular.awake()
|
void |
MultiCostRegular.awake()
|
void |
SoftMultiCostRegular.awakeOnInf(int idx)
|
void |
SoftMultiCostRegular.awakeOnInst(int idx)
|
void |
SoftMultiCostRegular.awakeOnRem(int idx,
int val)
|
void |
MultiCostRegular.awakeOnRem(int idx,
int val)
|
void |
SoftMultiCostRegular.awakeOnSup(int idx)
|
void |
SoftMultiCostRegular.checkWorld()
|
protected void |
MultiCostRegular.checkWorld()
|
void |
MultiCostRegular.computeSharpBounds()
Iteratively compute upper and lower bound for the underlying RCSPP |
protected boolean |
SoftMultiCostRegular.delayedGraphUpdate()
Updates the graphs w.r.t. the caught event during event-based propagation |
protected void |
MultiCostRegular.delayedGraphUpdate()
Updates the graphs w.r.t. the caught event during event-based propagation |
protected void |
MultiCostRegular.filterDown(double realsp)
Filters w.r.t. a given lower bound. |
protected void |
MultiCostRegular.filterUp(double reallp)
Filters w.r.t. a given upper bound. |
void |
MultiCostRegular.forcePathRecomputation()
|
void |
SoftMultiCostRegular.makeTableConstraints()
|
protected boolean |
MultiCostRegular.prefilter()
Performs cost based filtering w.r.t. each cost dimension. |
void |
SoftMultiCostRegular.propagate()
|
void |
MultiCostRegular.propagate()
|
void |
MultiCostRegular.rebuildCostRegInfo()
|
protected void |
MultiCostRegular.updateLowerBound()
Performs a lagrangian relaxation to compute a new Lower bound of the underlying RCSPP problem Each built subproblem is a shortest path one can use to perform cost based filtering |
protected void |
MultiCostRegular.updateUpperBound()
Performs a lagrangian relaxation to compute a new Upper bound of the underlying RCSPP problem Each built subproblem is a longest path one can use to perform cost based filtering |
boolean |
SoftMultiCostRegular.updateViolationLB()
|
boolean |
SoftMultiCostRegular.updateViolationUB()
|
Uses of ContradictionException in choco.cp.solver.constraints.global.automata.fast_regular |
---|
Methods in choco.cp.solver.constraints.global.automata.fast_regular that throw ContradictionException | |
---|---|
void |
FastRegular.awake()
|
void |
FastRegular.awakeOnRem(int i,
int j)
|
void |
FastRegular.propagate()
|
Uses of ContradictionException in choco.cp.solver.constraints.global.geost.internalConstraints |
---|
Methods in choco.cp.solver.constraints.global.geost.internalConstraints that throw ContradictionException | |
---|---|
boolean |
DistLeqIC.updateDistance(int k)
|
boolean |
DistGeqIC.updateDistance(int k)
|
Uses of ContradictionException in choco.cp.solver.constraints.global.geost.layers |
---|
Methods in choco.cp.solver.constraints.global.geost.layers that throw ContradictionException | |
---|---|
boolean |
GeometricKernel.filterCtrs(int k,
int[] oIDs,
List<ExternalConstraint> ectrs)
This is the main filtering algorithm associated with the Geost_Constraint. |
boolean |
GeometricKernel.fixAllObjs_incr(int k,
int[] oIDs,
List<ExternalConstraint> ectrs,
List<int[]> ctrlVs,
IStateInt idxLastFreeObject)
|
boolean |
GeometricKernel.fixAllObjs(int k,
int[] oIDs,
List<ExternalConstraint> ectrs,
List<int[]> ctrlVs,
IStateInt idxLastFreeObject)
Tries to fix all the objects within one single propagation. |
void |
GeostNumeric.prune(Obj o,
int k,
List<InternalConstraint> ictrs)
|
Uses of ContradictionException in choco.cp.solver.constraints.global.lightcostregular.structure |
---|
Methods in choco.cp.solver.constraints.global.lightcostregular.structure that throw ContradictionException | |
---|---|
protected void |
LayeredGraph.decQ(int i,
int j)
|
protected void |
LayeredGraph.initialFilter()
|
void |
LayeredGraph.makeGraph()
|
int |
LayeredGraph.removeEdge(Edge e)
|
Uses of ContradictionException in choco.cp.solver.constraints.global.matching |
---|
Methods in choco.cp.solver.constraints.global.matching that throw ContradictionException | |
---|---|
void |
GlobalCardinalityVar.awake()
|
void |
GlobalCardinality.awake()
performing the initial propagation, reduce variables domain to the candidate assign values |
void |
AllDifferent.awake()
no specific initial propagation (awake does the same job as propagate) |
void |
GlobalCardinalityVar.awakeOnInf(int idx)
|
void |
GlobalCardinality.awakeOnInf(int idx)
update the reference matching before redoing the strongly connected components analysis when removing value in the domain of variable idx |
void |
GlobalCardinalityVar.awakeOnInst(int idx)
|
void |
GlobalCardinality.awakeOnInst(int idx)
update the reference matching before redoing the strongly connected components analysis when idx is instantiated |
void |
AllDifferent.awakeOnInst(int idx)
update current matching when a variable has been instantiated |
void |
GlobalCardinalityVar.awakeOnRem(int idx,
int x)
|
void |
GlobalCardinality.awakeOnRem(int idx,
int x)
Implement reaction to edge removal |
void |
GlobalCardinalityVar.awakeOnSup(int idx)
|
void |
GlobalCardinality.awakeOnSup(int idx)
update the reference matching before redoing the strongly connected components analysis when removing value in the domain of variable idx |
void |
GlobalCardinality.deleteEdgeAndPublish(int i,
int j)
implement one of the two main events: when an edge is definitely removed from the bipartite assignment graph |
void |
AllDifferent.deleteEdgeAndPublish(int i,
int j)
when an edge is definitely removed from the bipartite assignment graph. |
void |
GlobalCardinality.propagate()
|
void |
GlobalCardinality.setEdgeAndPublish(int i,
int j)
implement the other main event: when an edge is definitely set in the bipartite assignment graph |
void |
AllDifferent.setEdgeAndPublish(int i,
int j)
when an edge is definitely chosen in the bipartite assignment graph. |
Uses of ContradictionException in choco.cp.solver.constraints.global.ordered |
---|
Methods in choco.cp.solver.constraints.global.ordered that throw ContradictionException | |
---|---|
void |
OrderedGcc.awake()
|
void |
OrderedGcc.propagate()
|
Uses of ContradictionException in choco.cp.solver.constraints.global.pack |
---|
Methods in choco.cp.solver.constraints.global.pack that throw ContradictionException | |
---|---|
void |
PackSConstraint.awake()
|
void |
PackSConstraint.awakeOnBounds(int varIndex)
|
void |
PackSConstraint.awakeOnEnv(int varIdx,
int x)
|
void |
PackSConstraint.awakeOnInf(int varIdx)
|
void |
PackSConstraint.awakeOnInst(int varIdx)
|
void |
PackSConstraint.awakeOnKer(int varIdx,
int x)
|
void |
PackSConstraint.awakeOnRem(int varIdx,
int val)
|
void |
PackSConstraint.awakeOnSup(int varIdx)
|
protected void |
PackFiltering.cardAndItemsCoherence(int bin)
|
protected void |
PackFiltering.cardMaintenance(int bin)
|
protected void |
PackSConstraint.checkBounds(int item)
|
protected void |
PackSConstraint.checkDeltaDomain(int item)
|
protected void |
PackSConstraint.checkEnveloppes()
|
void |
IPackSConstraint.fail()
|
protected void |
PackFiltering.loadAndSizeCoherence(int bin)
The minimum and maximum load of each bin PackFiltering.loads is maintained according to the domains of the bin assignment variables. |
protected void |
PackFiltering.loadMaintenance(int bin)
The minimum and maximum load of each bin PackFiltering.loads is maintained according to the domains of the bin assignment variables. |
protected void |
PackFiltering.noSumBinLoads(NoSumList nosum,
int bin)
Update the load of a given bin with no sum algorithm |
protected void |
PackFiltering.noSumItemEliminationAndCommitment(NoSumList nosum,
int bin)
use no sum algorithm to pack into or remove from. |
protected void |
PackFiltering.noSumPruningRule(NoSumList nosum,
int bin)
Feasibility test on the load of a given bin using no sum algorothm. |
boolean |
PackSConstraint.pack(int item,
int bin)
|
protected void |
PackFiltering.pack(int item,
int bin)
Do not update status |
boolean |
IPackSConstraint.pack(int item,
int bin)
Pack an item into a bin |
void |
PackSConstraint.propagate()
|
void |
PackFiltering.propagate()
|
boolean |
PackSConstraint.remove(int item,
int bin)
|
protected void |
PackFiltering.remove(int item,
int bin)
Do not update status |
boolean |
IPackSConstraint.remove(int item,
int bin)
Remove a possible assignment of an item into a bin. |
protected void |
PackFiltering.singleItemEliminationAndCommitment(int bin)
Single item elimination and commitment. |
protected void |
PackFiltering.singleItemEliminationAndCommitmentAndFill(int bin)
|
boolean |
PackSConstraint.updateInfLoad(int bin,
int load)
|
protected void |
PackFiltering.updateInfLoad(int bin,
int load)
Update the minimal load of a given bin. |
boolean |
IPackSConstraint.updateInfLoad(int bin,
int load)
Update the minimal load of a given bin. |
boolean |
PackSConstraint.updateNbNonEmpty(int min,
int max)
|
boolean |
IPackSConstraint.updateNbNonEmpty(int min,
int max)
update the number of non empty bins. |
boolean |
PackSConstraint.updateSupLoad(int bin,
int load)
|
protected void |
PackFiltering.updateSupLoad(int bin,
int load)
Update the maximal load of a given bin. |
boolean |
IPackSConstraint.updateSupLoad(int bin,
int load)
Update the maximal load of a given bin. |
Uses of ContradictionException in choco.cp.solver.constraints.global.regular |
---|
Methods in choco.cp.solver.constraints.global.regular that throw ContradictionException | |
---|---|
void |
Regular.awake()
|
void |
Regular.awakeOnRem(int idx,
int x)
|
void |
Regular.cleanUp()
removes values that are not supported by any state of the automata |
void |
Regular.decrement_indeg(LightState st,
int i)
Decrement the in-degree of state st located on the i-th layer |
void |
Regular.decrement_outdeg(LightState st,
int i)
Decrement the out-degree of state st located on the i-th layer |
void |
Regular.propagate()
|
void |
Regular.propagateNullInDeg(LightState st,
int i)
|
void |
Regular.propagateNullOutDeg(LightState st,
int i)
|
void |
Regular.propagateRemoval(int i,
int j)
Incremental propagation of a value removal |
void |
Regular.prune(int i,
int val)
|
Uses of ContradictionException in choco.cp.solver.constraints.global.scheduling |
---|
Methods in choco.cp.solver.constraints.global.scheduling that throw ContradictionException | |
---|---|
boolean |
RTask.assign()
|
boolean |
BoundHRTask.assign()
|
void |
AbstractResourceSConstraint.awake()
|
void |
AbstractResourceSConstraint.awakeOnBounds(int varIndex)
|
void |
TempTaskConstraintWrapper.awakeOnHypDomMod(int varIdx)
|
void |
AbstractResourceSConstraint.awakeOnInf(int varIdx)
|
void |
UseResourcesGeq.awakeOnInst(int idx)
|
void |
UseResourcesEq.awakeOnInst(int idx)
|
void |
AbstractUseResourcesSConstraint.awakeOnInst(int idx)
|
void |
AbstractResourceSConstraint.awakeOnInst(int idx)
|
void |
AbstractResourceSConstraint.awakeOnSup(int varIdx)
|
void |
RTask.checkConsistency()
|
void |
BoundHRTask.checkConsistency()
|
protected void |
BoundHRTask.checkHConsistency()
|
boolean |
AbstractResourceSConstraint.checkTask(int varIdx)
|
void |
AbstractResourceSConstraint.enforceTaskConsistency()
|
void |
RTask.fail()
|
protected void |
AbstractUseResourcesSConstraint.filterEarliestStartingTime(int k)
|
void |
AbstractUseResourcesSConstraint.filterHypotheticalDomains()
|
protected void |
AbstractUseResourcesSConstraint.filterLatestCompletionTime()
|
protected void |
AbstractUseResourcesSConstraint.filterLatestCompletionTime(int k)
|
void |
UseResourcesGeq.propagate()
|
void |
UseResourcesEq.propagate()
|
void |
TempTaskConstraintWrapper.propagate()
|
void |
AbstractUseResourcesSConstraint.propagate()
|
boolean |
RTask.remove()
|
boolean |
RTask.setDuration(int duration)
|
boolean |
BoundHRTask.setDuration(int duration)
|
boolean |
RTask.setECT(int val)
|
boolean |
BoundHRTask.setECT(int val)
|
boolean |
RTask.setEndingTime(int endingTime)
|
boolean |
BoundHRTask.setEndingTime(int endingTime)
|
boolean |
RTask.setEndNotIn(int a,
int b)
|
boolean |
BoundHRTask.setEndNotIn(int a,
int b)
|
boolean |
RTask.setEST(int val)
|
boolean |
BoundHRTask.setEST(int val)
|
protected boolean |
EnumHRTask.setHDuration(int duration)
|
protected boolean |
BoundHRTask.setHDuration(int duration)
|
protected boolean |
EnumHRTask.setHECT(int val)
|
protected boolean |
BoundHRTask.setHECT(int val)
|
boolean |
BoundHRTask.setHEndingTime(int endingTime)
|
boolean |
BoundHRTask.setHEndNotIn(int a,
int b)
|
protected boolean |
EnumHRTask.setHEST(int val)
|
protected boolean |
BoundHRTask.setHEST(int val)
|
protected boolean |
EnumHRTask.setHLCT(int val)
|
protected boolean |
BoundHRTask.setHLCT(int val)
|
protected boolean |
EnumHRTask.setHLST(int val)
|
protected boolean |
BoundHRTask.setHLST(int val)
|
protected boolean |
BoundHRTask.setHStartingTime(int startingTime)
|
protected boolean |
BoundHRTask.setHStartNotIn(int min,
int max)
|
boolean |
RTask.setLCT(int val)
|
boolean |
BoundHRTask.setLCT(int val)
|
boolean |
RTask.setLST(int val)
|
boolean |
BoundHRTask.setLST(int val)
|
boolean |
RTask.setMaxDuration(int val)
|
boolean |
BoundHRTask.setMaxDuration(int val)
|
boolean |
RTask.setMinDuration(int val)
|
boolean |
BoundHRTask.setMinDuration(int val)
|
boolean |
RTask.setStartingTime(int startingTime)
|
boolean |
BoundHRTask.setStartingTime(int startingTime)
|
boolean |
RTask.setStartNotIn(int min,
int max)
|
boolean |
BoundHRTask.setStartNotIn(int min,
int max)
|
void |
RTask.updateCompulsoryPart()
|
boolean |
RTask.updateDuration(int duration)
|
boolean |
BoundHRTask.updateDuration(int duration)
|
boolean |
RTask.updateECT()
|
boolean |
RTask.updateECT(int val)
|
boolean |
BoundHRTask.updateECT(int val)
|
boolean |
RTask.updateEndingTime(int endingTime)
|
boolean |
BoundHRTask.updateEndingTime(int endingTime)
|
boolean |
RTask.updateEndNotIn(int a,
int b)
|
boolean |
BoundHRTask.updateEndNotIn(int a,
int b)
|
boolean |
RTask.updateEST()
|
boolean |
RTask.updateEST(int val)
|
boolean |
BoundHRTask.updateEST(int val)
|
boolean |
RTask.updateLCT()
|
boolean |
RTask.updateLCT(int val)
|
boolean |
BoundHRTask.updateLCT(int val)
|
boolean |
RTask.updateLST()
|
boolean |
RTask.updateLST(int val)
|
boolean |
BoundHRTask.updateLST(int val)
|
boolean |
RTask.updateMaxDuration(int val)
|
boolean |
BoundHRTask.updateMaxDuration(int val)
|
boolean |
RTask.updateMaxHeight(int val)
|
boolean |
RTask.updateMinDuration(int val)
|
boolean |
BoundHRTask.updateMinDuration(int val)
|
boolean |
RTask.updateMinHeight(int val)
|
boolean |
RTask.updateStartingTime(int startingTime)
|
boolean |
BoundHRTask.updateStartingTime(int startingTime)
|
boolean |
RTask.updateStartNotIn(int a,
int b)
|
boolean |
BoundHRTask.updateStartNotIn(int a,
int b)
|
Uses of ContradictionException in choco.cp.solver.constraints.global.scheduling.cumulative |
---|
Methods in choco.cp.solver.constraints.global.scheduling.cumulative that throw ContradictionException | |
---|---|
void |
Cumulative.awake()
|
boolean |
ICumulRules.calcEF_end()
Edge finding algorithm for ending dates in O(n^2 \times k) where k is the number of distinct heights. |
boolean |
CumulRules.calcEF_end()
|
boolean |
ICumulRules.calcEF_start()
Edge finding algorithm for starting dates in O(n^2 \times k) where k is the number of distinct heights. |
boolean |
CumulRules.calcEF_start()
|
protected void |
CumulSweep.checkConsAndCapa()
|
void |
Cumulative.filter()
Main loop to achieve the fix point over the sweep and edge-finding algorithms |
void |
CumulRules.oldSlowTaskIntervals()
|
void |
Cumulative.propagate()
|
protected void |
CumulSweep.prune(int low,
int up)
|
protected boolean |
CumulSweep.pruneForbidden(IRTask rtask,
int low,
int up)
|
protected boolean |
CumulSweep.pruneHeight(IRTask rtask,
int low,
int up)
|
protected boolean |
CumulSweep.pruneRequired(IRTask rtask,
int low,
int up)
|
void |
ICumulRules.slowTaskIntervals()
a basic n^2 tasks interval |
void |
CumulRules.slowTaskIntervals()
|
boolean |
ICumulSweep.sweep()
Build to cumulative profile and achieve the pruning regarding this profile. |
boolean |
CumulSweep.sweep()
|
void |
ICumulRules.taskIntervals()
fast task intervals in n*log(n) |
void |
CumulRules.taskIntervals()
|
boolean |
AbstractCumulativeSConstraint.updateMaxCapacity(int val)
|
boolean |
AbstractCumulativeSConstraint.updateMaxConsumption(int val)
|
boolean |
AbstractCumulativeSConstraint.updateMinCapacity(int val)
|
boolean |
AbstractCumulativeSConstraint.updateMinConsumption(int val)
|
boolean |
ICumulRules.vilimEndEF()
Edge finding algorithm for ending dates in O(n^2 \times k) where k is the number of distinct heights. |
boolean |
CumulRules.vilimEndEF()
|
boolean |
ICumulRules.vilimStartEF()
Edge finding algorithm for starting dates in O(n^2 \times k) where k is the number of distinct heights. |
boolean |
CumulRules.vilimStartEF()
|
Uses of ContradictionException in choco.cp.solver.constraints.global.scheduling.disjunctive |
---|
Methods in choco.cp.solver.constraints.global.scheduling.disjunctive that throw ContradictionException | |
---|---|
protected boolean |
Disjunctive.applySingleRule()
|
void |
ForbiddenIntervals.awakeOnInf(int idx)
|
void |
ForbiddenIntervals.awakeOnInst(int idx)
|
void |
AltDisjunctive.awakeOnRem(int varIdx,
int val)
|
void |
AltDisjunctive.awakeOnRemovals(int idx,
DisposableIntIterator deltaDomain)
|
void |
ForbiddenIntervals.awakeOnSup(int idx)
|
protected void |
Disjunctive.defaultFiltering()
|
boolean |
IDisjRules.detectablePrecedence()
|
boolean |
AbstractDisjRules.detectablePrecedence()
|
boolean |
IDisjRules.detectablePrecedenceEST()
|
boolean |
DisjRules.detectablePrecedenceEST()
DetectablePrecedence rule. |
boolean |
AltDisjRules.detectablePrecedenceEST()
|
boolean |
IDisjRules.detectablePrecedenceLCT()
|
boolean |
DisjRules.detectablePrecedenceLCT()
symmetric DetectablePrecedence rule. |
boolean |
AltDisjRules.detectablePrecedenceLCT()
|
boolean |
IDisjRules.edgeFinding()
|
boolean |
AbstractDisjRules.edgeFinding()
|
boolean |
IDisjRules.edgeFindingEST()
|
boolean |
DisjRules.edgeFindingEST()
EdgeFinding rule. |
boolean |
AltDisjRules.edgeFindingEST()
Edge Finding supporting optional activities reasoning by Sebastian Kuhnert |
boolean |
IDisjRules.edgeFindingLCT()
|
boolean |
DisjRules.edgeFindingLCT()
symmetric EdgeFinding rule. |
boolean |
AltDisjRules.edgeFindingLCT()
|
boolean |
IDisjRules.notFirst()
|
boolean |
DisjRules.notFirst()
|
boolean |
AltDisjRules.notFirst()
|
boolean |
IDisjRules.notFirstNotLast()
|
boolean |
AbstractDisjRules.notFirstNotLast()
|
boolean |
IDisjRules.notLast()
|
boolean |
DisjRules.notLast()
NotLast rule. |
boolean |
AltDisjRules.notLast()
|
void |
IDisjRules.overloadChecking()
|
void |
DisjRules.overloadChecking()
Overload checking rule. |
void |
AltDisjRules.overloadChecking()
|
void |
ForbiddenIntervals.propagate()
Empty method. |
void |
Disjunctive.propagate()
Propagate. |
void |
AltDisjunctive.propagate()
|
protected void |
AbstractDisjRules.setMakespanLB(IThetaTree tree)
|
protected void |
Disjunctive.singleRuleFiltering()
|
protected void |
Disjunctive.vilimFiltering()
|
Uses of ContradictionException in choco.cp.solver.constraints.global.scheduling.precedence |
---|
Methods in choco.cp.solver.constraints.global.scheduling.precedence that throw ContradictionException | |
---|---|
void |
AbstractPrecedenceSConstraint.awakeOnBounds(int idx)
|
void |
AbstractPrecedenceSConstraint.awakeOnInf(int idx)
|
void |
AbstractPrecedenceSConstraint.awakeOnInst(int idx)
|
void |
AbstractPrecedenceSConstraint.awakeOnRemovals(int idx,
DisposableIntIterator deltaDomain)
|
void |
AbstractPrecedenceSConstraint.awakeOnSup(int idx)
|
void |
PrecedenceReified.filterOnP1P2TowardsB()
|
void |
PrecedenceImplied.filterOnP1P2TowardsB()
|
void |
AbstractPrecedenceSConstraint.filterOnP1P2TowardsB()
|
void |
AbstractPrecedenceSConstraint.propagate()
|
protected void |
AbstractPrecedenceSConstraint.propagate(int idx1,
int idx2)
propagate vars[idx1] <= vars[idx2] |
protected void |
AbstractPrecedenceSConstraint.propagate(int idx1,
int k1,
int idx2)
propagate vars[idx1] + k1 <= vars[idx2] |
void |
VariablePrecedenceDisjoint.propagateP1()
|
void |
PrecedenceVSDisjoint.propagateP1()
|
void |
PrecedenceVDisjoint.propagateP1()
|
void |
PrecedenceReified.propagateP1()
|
void |
PrecedenceImplied.propagateP1()
|
void |
PrecedenceDisjoint.propagateP1()
|
abstract void |
AbstractPrecedenceSConstraint.propagateP1()
|
void |
VariablePrecedenceDisjoint.propagateP2()
|
void |
PrecedenceVSDisjoint.propagateP2()
|
void |
PrecedenceVDisjoint.propagateP2()
|
void |
PrecedenceReified.propagateP2()
|
void |
PrecedenceImplied.propagateP2()
|
void |
PrecedenceDisjoint.propagateP2()
|
abstract void |
AbstractPrecedenceSConstraint.propagateP2()
|
Uses of ContradictionException in choco.cp.solver.constraints.global.softscheduling |
---|
Methods in choco.cp.solver.constraints.global.softscheduling that throw ContradictionException | |
---|---|
protected void |
SoftCumulative.checkCosts(int low,
int up)
|
void |
SoftCumulative.filter()
|
void |
SoftCumulative.propagate()
|
void |
SoftCumulative.prune(int low,
int up)
|
void |
SoftCumulative.sweep()
|
void |
SoftCumulativeSum.taskIntervals()
|
void |
SoftCumulative.taskIntervals()
|
void |
AbstractSoftCumulative.updateCompulsoryPart()
|
protected void |
SoftCumulativeSum.updateCost(int low,
int up)
|
protected void |
SoftCumulative.updateCost(int low,
int up)
|
Uses of ContradictionException in choco.cp.solver.constraints.global.tree |
---|
Methods in choco.cp.solver.constraints.global.tree that throw ContradictionException | |
---|---|
void |
TreeSConstraint.awake()
Initial awake of the tree constraint. |
void |
TreeSConstraint.awakeOnBounds(int idx)
Event based propagation related to the update of the bounds of a variable. |
void |
TreeSConstraint.awakeOnInf(int idx)
Event based propagation related to the update of the lower bound of a variable. |
void |
TreeSConstraint.awakeOnInst(int idx)
Event based propagation related to the instanciation of a variable. |
void |
TreeSConstraint.awakeOnRem(int idx,
int i)
Event based propagation related to the removal of a value in the domain of a variable. |
void |
TreeSConstraint.awakeOnRemovals(int idx,
DisposableIntIterator deltaDomain)
Event based propagation related to the removal of a set of values in the domain of a variable. |
void |
TreeSConstraint.awakeOnSup(int idx)
Event based propagation related to the update of the upper bound of a variable. |
void |
TreeSConstraint.propagate()
The main propagation method. |
Uses of ContradictionException in choco.cp.solver.constraints.global.tree.filtering |
---|
Methods in choco.cp.solver.constraints.global.tree.filtering that throw ContradictionException | |
---|---|
boolean |
AbstractPropagator.applyConstraint()
a generic method that manage the filtering methods |
boolean |
FilteringAdvisor.applyFiltering()
the main method that allows to apply all the filtering rules of each propagator |
abstract boolean |
AbstractPropagator.feasibility()
check the consistency of the filtering rules of a given propagator |
abstract void |
AbstractPropagator.filter()
record the inconsistant values with the variables of a given propagator |
void |
RemovalsAdvisor.setMaxNProper(int val)
update the upper bound of the nproper variable with the value val |
void |
RemovalsAdvisor.setMaxNtree(int val)
update the upper bound of the ntree variable with the value val |
void |
RemovalsAdvisor.setMaxObjective(int val)
update the upper bound of the objective variable with the value val |
void |
RemovalsAdvisor.setMinNProper(int val)
update the lower bound of the nproper variable with the value val |
void |
RemovalsAdvisor.setMinNtree(int val)
update the lower bound of the ntree variable with the value val |
void |
RemovalsAdvisor.setMinObjective(int val)
update the lower bound of the objective variable with the value val |
void |
RemovalsAdvisor.startRemovals()
main method that synchronize the recorded value removals with the corresponding variables |
Uses of ContradictionException in choco.cp.solver.constraints.global.tree.filtering.costFiltering |
---|
Methods in choco.cp.solver.constraints.global.tree.filtering.costFiltering that throw ContradictionException | |
---|---|
boolean |
Cost.feasibility()
|
void |
Cost.filter()
remove each arc (i,j) of the graph such that the total cost a forest containing this arc exceed the objective variable |
Uses of ContradictionException in choco.cp.solver.constraints.global.tree.filtering.structuralFiltering |
---|
Methods in choco.cp.solver.constraints.global.tree.filtering.structuralFiltering that throw ContradictionException | |
---|---|
boolean |
Nproper.feasibility()
|
void |
Incomparability.filter()
two filtering rules are applied for the incomparability constraints: 1- remove infeasible potential roots when the number of trees is fixed to 1. |
Uses of ContradictionException in choco.cp.solver.constraints.global.tree.filtering.structuralFiltering.globalCardConstraint |
---|
Methods in choco.cp.solver.constraints.global.tree.filtering.structuralFiltering.globalCardConstraint that throw ContradictionException | |
---|---|
boolean |
GlobalCardinalityNoLoop.applyGCC(RemovalsAdvisor rem)
Achieves generalized arc consistency in one call remove arcs connecting two different strongly connected components the event generated by the flow algorithm: discovering that an edge is no longer valid, and posting this event to the constraint solver: since we are already achieving GAC consistency in one single loop. |
void |
AbstractBipartGraph.propagate(RemovalsAdvisor rem)
|
void |
AbstractBipartGraph.removeUselessEdges(RemovalsAdvisor rem)
remove arcs connecting two different strongly connected components the event generated by the flow algorithm: discovering that an edge is no longer valid, and posting this event to the constraint solver: since we are already achieving GAC consistency in one single loop, there is no need to post a constAwake |
Uses of ContradictionException in choco.cp.solver.constraints.global.tree.filtering.structuralFiltering.precedences |
---|
Methods in choco.cp.solver.constraints.global.tree.filtering.structuralFiltering.precedences that throw ContradictionException | |
---|---|
void |
Precedences.filter()
filtering rules related to the interaction between the graph to partition and the precedence constraints. |
Uses of ContradictionException in choco.cp.solver.constraints.global.tree.filtering.structuralFiltering.timeWindows |
---|
Methods in choco.cp.solver.constraints.global.tree.filtering.structuralFiltering.timeWindows that throw ContradictionException | |
---|---|
void |
DirectedPropag.applyGraphFiltering()
filtering method that removes the arcs which become infeasible because of the time windows constraints |
void |
OrderedGraphPropag.applyTWfiltering()
filtering methods that update the time windows of each node according to the precedence constraints and the minimum travel time matrix |
void |
DirectedPropag.applyTWfiltering()
filtering methods that update the time windows of each node according to the travel time matrix and the graph * @throws ContradictionException |
boolean |
TimeWindow.feasibility()
|
void |
TimeWindow.filter()
|
void |
DirectedPropag.updateByPotentialPred()
|
void |
DirectedPropag.updateByPotentialSucc()
|
Uses of ContradictionException in choco.cp.solver.constraints.global.tree.filtering.structuralFiltering.tree |
---|
Methods in choco.cp.solver.constraints.global.tree.filtering.structuralFiltering.tree that throw ContradictionException | |
---|---|
void |
Tree.filter()
Filtering method for the pure tree constraint. |
Uses of ContradictionException in choco.cp.solver.constraints.global.tree.structure.inputStructure |
---|
Constructors in choco.cp.solver.constraints.global.tree.structure.inputStructure that throw ContradictionException | |
---|---|
Node(Solver solver,
int nbNodes,
int idx,
List<BitSet[]> graphs,
List<int[][]> matrix)
constructor: build a node and its associated attributes |
|
TreeParameters(Solver solver,
int nbNodes,
IntDomainVar ntree,
IntDomainVar nproper,
IntDomainVar objective,
List<BitSet[]> graphs,
List<int[][]> matrix,
int[][] travel)
constructor: build the input data of a tree constraint. |
Uses of ContradictionException in choco.cp.solver.constraints.global.tree.structure.internalStructure |
---|
Methods in choco.cp.solver.constraints.global.tree.structure.internalStructure that throw ContradictionException | |
---|---|
void |
StructuresAdvisor.applyStructure()
the main method that allows to update the degree constraint and the cost structure according to the current state of the graph. |
Uses of ContradictionException in choco.cp.solver.constraints.integer |
---|
Methods in choco.cp.solver.constraints.integer that throw ContradictionException | |
---|---|
void |
TimesXYZ.awake()
|
void |
ModuloXYC2.awake()
|
void |
ElementVG.awake()
|
void |
ElementV.awake()
|
void |
ElementG.awake()
|
void |
Element.awake()
|
void |
DistanceXYC.awake()
Default initial propagation: full constraint re-propagation. |
void |
SignOp.awakeOnBounds(int varIndex)
|
void |
EuclideanDivisionXYZ.awakeOnBounds(int varIndex)
|
void |
ElementG.awakeOnBounds(int varIdx)
|
void |
Element2D.awakeOnBounds(int idx)
|
void |
DistanceXYZ.awakeOnBounds(int varIndex)
|
void |
TimesXYZ.awakeOnInf(int idx)
|
void |
SignOp.awakeOnInf(int idx)
|
void |
NotEqualXY_C.awakeOnInf(int idx)
|
void |
NotEqualXYC.awakeOnInf(int idx)
|
void |
NotEqualXC.awakeOnInf(int idx)
in case the bounds have changed and the domain is approximated by an interval, we need to re-propagate |
void |
ModuloXYC2.awakeOnInf(int idx)
|
void |
MinXYZ.awakeOnInf(int idx)
|
void |
MinOfAList.awakeOnInf(int idx)
Propagation when lower bound is increased. |
void |
MaxXYZ.awakeOnInf(int idx)
|
void |
MaxOfAList.awakeOnInf(int idx)
Propagation when lower bound is increased. |
void |
LessOrEqualXY_C.awakeOnInf(int idx)
Propagation when a minimal bound of a variable was modified. |
void |
InverseChannelingWithinRange.awakeOnInf(int idx)
|
void |
InverseChanneling.awakeOnInf(int idx)
|
void |
IntLinComb.awakeOnInf(int idx)
Propagation whenever the lower bound of a variable is modified. |
void |
GreaterOrEqualXY_C.awakeOnInf(int idx)
Propagation when a minimal bound of a variable was modified. |
void |
GreaterOrEqualXYC.awakeOnInf(int idx)
Propagation when a minimal bound of a variable was modified. |
void |
EuclideanDivisionXYZ.awakeOnInf(int varIdx)
Default propagation on improved lower bound: propagation on domain revision. |
void |
EqualXY_C.awakeOnInf(int idx)
|
void |
EqualXYC.awakeOnInf(int idx)
|
void |
EqualXC.awakeOnInf(int idx)
|
void |
ElementVG.awakeOnInf(int idx)
|
void |
ElementV.awakeOnInf(int idx)
|
void |
ElementG.awakeOnInf(int i)
|
void |
Element2D.awakeOnInf(int idx)
|
void |
DistanceXYZ.awakeOnInf(int idx)
|
void |
DistanceXYC.awakeOnInf(int idx)
|
void |
Absolute.awakeOnInf(int idx)
If X.inf increases, values from -X.inf to X.inf are forbidden for Y If Y.inf increases, it depends on the situation |
void |
TimesXYZ.awakeOnInst(int vIdx)
|
void |
SignOp.awakeOnInst(int idx)
|
void |
NotEqualXY_C.awakeOnInst(int idx)
|
void |
NotEqualXYC.awakeOnInst(int idx)
|
void |
NotEqualXC.awakeOnInst(int idx)
When the one and only variable of the constraint becomes instantiated Need to check that the value of the variable is not the value forbidden by the constraint |
void |
ModuloXYC2.awakeOnInst(int idx)
|
void |
MinOfAList.awakeOnInst(int idx)
Propagation when a variable is instantiated. |
void |
MaxOfAList.awakeOnInst(int idx)
Propagation when a variable is instantiated. |
void |
LessOrEqualXY_C.awakeOnInst(int idx)
Propagation when a variable is instantiated. |
void |
LessOrEqualXC.awakeOnInst(int idx)
|
void |
InverseChannelingWithinRange.awakeOnInst(int idx)
|
void |
InverseChanneling.awakeOnInst(int idx)
|
void |
IntLinComb.awakeOnInst(int idx)
Propagation whenever a variable is instantiated. |
void |
GreaterOrEqualXY_C.awakeOnInst(int idx)
Propagation when a variable is instantiated. |
void |
GreaterOrEqualXYC.awakeOnInst(int idx)
Propagation when a variable is instantiated. |
void |
GreaterOrEqualXC.awakeOnInst(int idx)
|
void |
EqualXY_C.awakeOnInst(int idx)
|
void |
EqualXYC.awakeOnInst(int idx)
|
void |
EqualXC.awakeOnInst(int idx)
|
void |
ElementVG.awakeOnInst(int idx)
|
void |
ElementV.awakeOnInst(int idx)
|
void |
ElementG.awakeOnInst(int i)
|
void |
Element2D.awakeOnInst(int idx)
|
void |
Element.awakeOnInst(int i)
|
void |
DistanceXYZ.awakeOnInst(int idx)
|
void |
DistanceXYC.awakeOnInst(int idx)
|
void |
Absolute.awakeOnInst(int idx)
When X is instantiated, Y is restricted to 2 values : X.value and -(X.value) When Y is instantiated, X is instantiated to abs(Y) |
void |
MinXYZ.awakeOnInst(int idx,
int val)
|
void |
MaxXYZ.awakeOnInst(int idx,
int val)
|
void |
NotEqualXY_C.awakeOnRem(int varIdx,
int val)
|
void |
NotEqualXYC.awakeOnRem(int varIdx,
int val)
|
void |
NotEqualXC.awakeOnRem(int idx,
int x)
When a value is removed from the domain of the one and only variable: Nothing to be propagated. |
void |
ModuloXYC2.awakeOnRem(int idx,
int valeur)
|
void |
MinXYZ.awakeOnRem(int idx,
int x)
|
void |
MaxXYZ.awakeOnRem(int idx,
int x)
|
void |
InverseChannelingWithinRange.awakeOnRem(int idx,
int x)
|
void |
InverseChanneling.awakeOnRem(int idx,
int x)
|
void |
IntLinComb.awakeOnRem(int idx,
int x)
Propagation whenever a value is removed from the variable domain. |
void |
EqualXY_C.awakeOnRem(int idx,
int x)
|
void |
EqualXYC.awakeOnRem(int idx,
int x)
|
void |
EqualXC.awakeOnRem(int idx,
int x)
|
void |
ElementVG.awakeOnRem(int idx,
int x)
|
void |
ElementV.awakeOnRem(int idx,
int x)
|
void |
ElementG.awakeOnRem(int i,
int x)
|
void |
Element.awakeOnRem(int i,
int x)
|
void |
DistanceXYC.awakeOnRem(int idx,
int x)
|
void |
Absolute.awakeOnRem(int idx,
int x)
When a value is removed from the domain of X: then this value and its opposite are removed from the domain of Y. |
void |
SignOp.awakeOnRemovals(int idx,
DisposableIntIterator deltaDomain)
|
void |
NotEqualXY_C.awakeOnRemovals(int idx,
DisposableIntIterator deltaDomain)
|
void |
NotEqualXYC.awakeOnRemovals(int idx,
DisposableIntIterator deltaDomain)
|
void |
IntLinComb.awakeOnRemovals(int idx,
DisposableIntIterator deltaDomain)
|
void |
Element2D.awakeOnRemovals(int idx,
DisposableIntIterator deltaDomain)
|
void |
DistanceXYZ.awakeOnRemovals(int idx,
DisposableIntIterator deltaDomain)
|
void |
TimesXYZ.awakeOnSup(int idx)
|
void |
SignOp.awakeOnSup(int idx)
|
void |
NotEqualXY_C.awakeOnSup(int idx)
|
void |
NotEqualXYC.awakeOnSup(int idx)
|
void |
NotEqualXC.awakeOnSup(int idx)
in case the bounds have changed and the domain is approximated by an interval, we need to re-propagate |
void |
ModuloXYC2.awakeOnSup(int idx)
|
void |
MinXYZ.awakeOnSup(int idx)
|
void |
MinOfAList.awakeOnSup(int idx)
Propagation when upper bound is decreased. |
void |
MaxXYZ.awakeOnSup(int idx)
|
void |
MaxOfAList.awakeOnSup(int idx)
Propagation when upper bound is decreased. |
void |
LessOrEqualXY_C.awakeOnSup(int idx)
Propagation when a maximal bound of a variable was modified. |
void |
InverseChannelingWithinRange.awakeOnSup(int idx)
|
void |
InverseChanneling.awakeOnSup(int idx)
|
void |
IntLinComb.awakeOnSup(int idx)
Propagation whenever the upper bound of a variable is modified. |
void |
GreaterOrEqualXY_C.awakeOnSup(int idx)
Propagation when a maximal bound of a variable was modified. |
void |
GreaterOrEqualXYC.awakeOnSup(int idx)
Propagation when a maximal bound of a variable was modified. |
void |
EuclideanDivisionXYZ.awakeOnSup(int varIdx)
Default propagation on improved upper bound: propagation on domain revision. |
void |
EqualXY_C.awakeOnSup(int idx)
|
void |
EqualXYC.awakeOnSup(int idx)
|
void |
EqualXC.awakeOnSup(int idx)
|
void |
ElementVG.awakeOnSup(int idx)
|
void |
ElementV.awakeOnSup(int idx)
|
void |
ElementG.awakeOnSup(int i)
|
void |
Element2D.awakeOnSup(int idx)
|
void |
DistanceXYZ.awakeOnSup(int idx)
|
void |
DistanceXYC.awakeOnSup(int idx)
|
void |
Absolute.awakeOnSup(int idx)
If X.sup decreases, Y is limited to (-(X.sup) .. |
protected void |
TimesXYZ.awakeOnX()
reaction when X (v0) is updated |
protected void |
TimesXYZ.awakeOnY()
|
protected void |
TimesXYZ.awakeOnZ()
|
protected void |
Absolute.detectSymetricalHoles(int inf,
int sup)
Try to detect symetrical holes (ie value such that both value and -(value) are not in the domain of Y, in which case abs(value) can be removed from the domain of X) |
protected void |
ElementVG.equalityBehaviour()
|
protected void |
ElementV.equalityBehaviour()
|
void |
SignOp.filter()
|
void |
TimesXYZ.filter(int idx)
|
void |
MinXYZ.filter(int idx)
|
void |
MaxXYZ.filter(int idx)
|
boolean |
DistanceXYZ.filterEQFromXZToY()
|
boolean |
DistanceXYZ.filterEQFromYZToX()
|
void |
DistanceXYZ.filterFixPoint()
|
void |
DistanceXYC.filterFromVarToVar(IntDomainVar var1,
IntDomainVar var2)
Initial propagation in case of EQ and enumerated domains |
boolean |
DistanceXYZ.filterFromXYtoLBZ()
|
boolean |
DistanceXYZ.filterFromXYtoUBZ()
|
void |
DistanceXYC.filterGT()
In case of a GT |
boolean |
DistanceXYZ.filterGTFromXZtoY()
|
boolean |
DistanceXYZ.filterGTFromYZtoX()
|
void |
DistanceXYC.filterGTonVar(IntDomainVar vv0,
IntDomainVar vv1)
In case of a GT, due to a modification on vv0 domain |
void |
DistanceXYC.filterLT()
In case of a LT |
boolean |
DistanceXYZ.filterLTFromXZtoY()
|
boolean |
DistanceXYZ.filterLTFromYZtoX()
|
void |
DistanceXYC.filterLTonVar(IntDomainVar vv0,
IntDomainVar vv1)
In case of a LT, due to a modification on vv0 domain |
void |
IncreasingSum.filterMax()
|
void |
IncreasingSum.filterMin()
|
void |
DistanceXYC.filterNeq()
|
void |
SignOp.filterNotSame(IntDomainVar x1,
IntDomainVar x2)
|
void |
DistanceXYC.filterOnInf(IntDomainVar vv0,
IntDomainVar vv1)
In case of a EQ, due to a modification of the lower bound of vv0 |
void |
DistanceXYC.filterOnInst(IntDomainVar v,
int val)
In case of a EQ, due to the instantion to one variable to val |
void |
DistanceXYC.filterOnSup(IntDomainVar vv0,
IntDomainVar vv1)
In case of a EQ, due to a modification of the upper bound of vv0 |
void |
SignOp.filterSame(IntDomainVar x1,
IntDomainVar x2)
|
protected void |
MinOfAList.onlyOneMaxCandidatePropagation()
If only one candidate to be the min of the list, some additionnal propagation can be performed (as in usual x == y constraint). |
protected void |
MaxOfAList.onlyOneMaxCandidatePropagation()
If only one candidate to be the max of the list, some additionnal propagation can be performed (as in usual x == y constraint). |
void |
TimesXYZ.propagate()
|
void |
SignOp.propagate()
The one and only propagation method, using foward checking |
void |
NotMemberEnum.propagate()
Propagation: Propagating the constraint until local consistency is reached. |
void |
NotMemberBound.propagate()
Propagation: Propagating the constraint until local consistency is reached. |
void |
NotEqualXY_C.propagate()
The one and only propagation method, using foward checking |
void |
NotEqualXYC.propagate()
The one and only propagation method, using foward checking |
void |
NotEqualXC.propagate()
The single propagation method. |
void |
ModuloXYC2.propagate()
The one and only propagation method, using foward checking |
void |
MinXYZ.propagate()
Propagation for the constraint awake var. |
void |
MinOfAList.propagate()
Propagation of the constraint. |
void |
MemberEnum.propagate()
Propagation: Propagating the constraint until local consistency is reached. |
void |
MemberBound.propagate()
Propagation: Propagating the constraint until local consistency is reached. |
void |
MaxXYZ.propagate()
Propagation for the constraint awake var. |
void |
MaxOfAList.propagate()
Propagation of the constraint. |
void |
LessOrEqualXY_C.propagate()
The propagation on constraint awake events. |
void |
LessOrEqualXC.propagate()
The one and only propagation method. |
void |
InverseChannelingWithinRange.propagate()
|
void |
InverseChanneling.propagate()
|
void |
IntLinComb.propagate()
Launchs the filtering algorithm. |
void |
IncreasingSum.propagate()
|
void |
GreaterOrEqualXY_C.propagate()
The propagation on constraint awake events. |
void |
GreaterOrEqualXYC.propagate()
The propagation on constraint awake events. |
void |
GreaterOrEqualXC.propagate()
The one and only propagation method. |
void |
EuclideanDivisionXYZ.propagate()
Propagation: Propagating the constraint until local consistency is reached. |
void |
EqualXY_C.propagate()
The one and only propagation method, using foward checking |
void |
EqualXYC.propagate()
The one and only propagation method, using foward checking |
void |
EqualXC.propagate()
The one and only propagation method. |
void |
ElementVG.propagate()
|
void |
ElementV.propagate()
|
void |
ElementG.propagate()
|
void |
Element2D.propagate()
|
void |
Element.propagate()
Propagation: Propagating the constraint until local consistency is reached. |
void |
DistanceXYZ.propagate()
|
void |
DistanceXYC.propagate()
|
void |
Absolute.propagate()
The initial propagation consist in enforcing X to be positive executing all standard propagation methods executing specific propagation methods |
void |
TimesXYZ.propagateZero()
propagate the fact that v2 (Z) is instantiated to 0 |
void |
ModuloXYC2.reviseV0OnInf(BitSet supports)
|
void |
ModuloXYC2.reviseV0OnInst(int inst)
|
void |
ModuloXYC2.reviseV0OnRem(BitSet supports,
int valeur)
|
void |
ModuloXYC2.reviseV0OnSup(BitSet supports)
|
void |
ModuloXYC2.reviseV1OnInf()
|
void |
ModuloXYC2.reviseV1OnInst(int inst)
|
void |
ModuloXYC2.reviseV1OnRem(int valeur)
|
void |
ModuloXYC2.reviseV1OnSup()
|
protected boolean |
TimesXYZ.shaveOnX()
Updating X and Y when Z can be 0 |
protected void |
TimesXYZ.shaveOnXandY()
|
protected boolean |
TimesXYZ.shaveOnY()
|
protected void |
TimesXYZ.shaveOnYandX()
|
protected void |
ElementVG.updateIndexFromValue()
|
protected void |
ElementV.updateIndexFromValue()
|
void |
Element2D.updateIndexFromValue()
|
protected void |
Element.updateIndexFromValue()
|
protected void |
ElementVG.updateIndexFromValue(int v)
|
protected void |
ElementG.updateIndexFromValue(int v)
|
void |
IncreasingSum.updateMax()
|
void |
IncreasingSum.updateMin()
|
protected void |
Absolute.updateMinFromHoles()
Deduce the minimum value of X from the eventual central gap in the domain of Y. |
protected void |
ElementVG.updateValueFromIndex()
|
protected void |
ElementV.updateValueFromIndex()
|
void |
Element2D.updateValueFromIndex()
|
protected void |
Element.updateValueFromIndex()
|
protected void |
ElementVG.updateValueFromIndex(int idx)
|
protected void |
ElementG.updateValueFromIndex(int i)
|
protected void |
ElementVG.updateVariable(int index,
int value)
|
protected boolean |
TimesXYZ.updateX()
Updating X and Y when Z cannot be 0 |
protected void |
TimesXYZ.updateXandY()
loop until a fix point is reach (see testProd14) |
protected boolean |
TimesXYZ.updateY()
|
protected void |
TimesXYZ.updateYandX()
|
Uses of ContradictionException in choco.cp.solver.constraints.integer.bool |
---|
Methods in choco.cp.solver.constraints.integer.bool that throw ContradictionException | |
---|---|
void |
LargeXor.awake()
Default initial propagation: full constraint re-propagation. |
void |
LargeXnor.awake()
Default initial propagation: full constraint re-propagation. |
void |
LargeXor.awakeOnBounds(int varIndex)
|
void |
LargeXnor.awakeOnBounds(int varIndex)
|
void |
LargeOr.awakeOnBounds(int varIndex)
|
void |
LargeNor.awakeOnBounds(int varIndex)
|
void |
LargeNand.awakeOnBounds(int varIndex)
|
void |
LargeAnd.awakeOnBounds(int varIndex)
|
void |
LargeXor.awakeOnInf(int varIdx)
|
void |
LargeXnor.awakeOnInf(int varIdx)
|
void |
LargeOr.awakeOnInf(int varIdx)
|
void |
LargeNor.awakeOnInf(int varIdx)
|
void |
LargeNand.awakeOnInf(int varIdx)
|
void |
LargeAnd.awakeOnInf(int varIdx)
|
void |
BoolIntLinComb.awakeOnInf(int idx)
|
void |
BinXor.awakeOnInf(int varIdx)
|
void |
BinXnor.awakeOnInf(int varIdx)
|
void |
BinOr.awakeOnInf(int varIdx)
|
void |
BinNor.awakeOnInf(int varIdx)
|
void |
BinNand.awakeOnInf(int varIdx)
|
void |
BinAnd.awakeOnInf(int varIdx)
|
void |
LargeXor.awakeOnInst(int idx)
|
void |
LargeXnor.awakeOnInst(int idx)
|
void |
LargeOr.awakeOnInst(int idx)
|
void |
LargeNor.awakeOnInst(int idx)
|
void |
LargeNand.awakeOnInst(int idx)
|
void |
LargeAnd.awakeOnInst(int idx)
|
void |
BoolTimesXYZ.awakeOnInst(int idx)
|
void |
BoolIntLinComb.awakeOnInst(int idx)
******************************************************************** |
void |
BinXor.awakeOnInst(int idx)
|
void |
BinXnor.awakeOnInst(int idx)
|
void |
BinOr.awakeOnInst(int idx)
|
void |
BinNor.awakeOnInst(int idx)
|
void |
BinNand.awakeOnInst(int idx)
|
void |
BinAnd.awakeOnInst(int idx)
|
void |
BinXor.awakeOnRem(int varIdx,
int val)
|
void |
BinXnor.awakeOnRem(int varIdx,
int val)
|
void |
BinOr.awakeOnRem(int varIdx,
int val)
|
void |
BinNor.awakeOnRem(int varIdx,
int val)
|
void |
BinNand.awakeOnRem(int varIdx,
int val)
|
void |
BinAnd.awakeOnRem(int varIdx,
int val)
|
void |
LargeXor.awakeOnRemovals(int idx,
DisposableIntIterator deltaDomain)
|
void |
LargeXnor.awakeOnRemovals(int idx,
DisposableIntIterator deltaDomain)
|
void |
LargeOr.awakeOnRemovals(int idx,
DisposableIntIterator deltaDomain)
|
void |
LargeNor.awakeOnRemovals(int idx,
DisposableIntIterator deltaDomain)
|
void |
LargeNand.awakeOnRemovals(int idx,
DisposableIntIterator deltaDomain)
|
void |
LargeAnd.awakeOnRemovals(int idx,
DisposableIntIterator deltaDomain)
|
void |
LargeXor.awakeOnSup(int varIdx)
|
void |
LargeXnor.awakeOnSup(int varIdx)
|
void |
LargeOr.awakeOnSup(int varIdx)
|
void |
LargeNor.awakeOnSup(int varIdx)
|
void |
LargeNand.awakeOnSup(int varIdx)
|
void |
LargeAnd.awakeOnSup(int varIdx)
|
void |
BoolIntLinComb.awakeOnSup(int idx)
|
void |
BinXor.awakeOnSup(int varIdx)
|
void |
BinXnor.awakeOnSup(int varIdx)
|
void |
BinOr.awakeOnSup(int varIdx)
|
void |
BinNor.awakeOnSup(int varIdx)
|
void |
BinNand.awakeOnSup(int varIdx)
|
void |
BinAnd.awakeOnSup(int varIdx)
|
boolean |
BoolIntLinComb.filterNegCoeffLb()
enforce variables that would otherwise make the upper bound unreachable |
boolean |
BoolIntLinComb.filterNegCoeffUb()
|
boolean |
BoolIntLinComb.filterPosCoeffLb()
******************************************************************** |
boolean |
BoolIntLinComb.filterPosCoeffUb()
|
void |
BoolIntLinComb.fixPointOnEQ()
|
void |
Not.propagate()
Propagation: Propagating the constraint until local consistency is reached. |
void |
LargeXor.propagate()
|
void |
LargeXnor.propagate()
|
void |
LargeOr.propagate()
|
void |
LargeNor.propagate()
|
void |
LargeNand.propagate()
|
void |
LargeAnd.propagate()
|
void |
Identity.propagate()
Propagation: Propagating the constraint until local consistency is reached. |
void |
BoolTimesXYZ.propagate()
|
void |
BoolIntLinComb.propagate()
|
void |
BinXor.propagate()
|
void |
BinXnor.propagate()
|
void |
BinOr.propagate()
|
void |
BinNor.propagate()
|
void |
BinNand.propagate()
|
void |
BinAnd.propagate()
|
void |
BoolIntLinComb.propagateEQ()
|
void |
BoolIntLinComb.propagateGEQ()
|
void |
BoolIntLinComb.propagateLEQ()
|
boolean |
BoolIntLinComb.updateForGEQ()
******************************************************************** |
boolean |
BoolIntLinComb.updateForLEQ()
|
Uses of ContradictionException in choco.cp.solver.constraints.integer.bool.sat |
---|
Methods in choco.cp.solver.constraints.integer.bool.sat that throw ContradictionException | |
---|---|
void |
ClauseStore.awake()
|
void |
ClauseStore.awakeOnInst(int idx)
|
void |
ClauseStore.filterFromScratch()
|
void |
ClauseStore.filterOnInst(int idx)
|
void |
ClauseStore.propagate()
|
boolean |
WLClause.propagate(int p,
int idxcl)
propagate the clause because one of the watched literals has changed |
boolean |
BinaryWLClause.propagate(int p,
int idxcl)
|
void |
ClauseStore.propagateUnitClause()
|
boolean |
WLClause.register(ClauseStore propagator)
register this clause in the watching lists of the propagator. |
void |
WLClause.simplePropagation(ClauseStore propagator)
propagate the clause from scratch |
boolean |
WLClause.update()
|
void |
WLClause.updateDomain()
|
void |
BinaryWLClause.updateDomain()
|
Uses of ContradictionException in choco.cp.solver.constraints.integer.bool.sum |
---|
Methods in choco.cp.solver.constraints.integer.bool.sum that throw ContradictionException | |
---|---|
void |
NeqBoolSum.awake()
|
void |
LeqBoolSum.awake()
|
void |
GeqBoolSum.awake()
|
void |
EqBoolSum.awake()
|
void |
BoolSumStructure.awakeOnEq()
|
void |
BoolSumStructure.awakeOnGeq()
|
void |
NeqBoolSum.awakeOnInst(int idx)
|
void |
LeqBoolSum.awakeOnInst(int idx)
|
void |
GeqBoolSum.awakeOnInst(int idx)
|
void |
EqBoolSum.awakeOnInst(int idx)
|
void |
AbstractBoolSum.awakeOnInst(int idx)
|
void |
BoolSumStructure.awakeOnLeq()
|
void |
BoolSumStructure.awakeOnNeq()
|
boolean |
BoolSumStructure.filterGeq()
|
boolean |
BoolSumStructure.filterLeq()
|
void |
BoolSumStructure.forceAllOne()
|
void |
BoolSumStructure.forceAllZero()
|
void |
LeqBoolSum.propagate()
|
void |
GeqBoolSum.propagate()
|
void |
EqBoolSum.propagate()
|
void |
AbstractBoolSum.propagate()
|
void |
BoolSumStructure.putAllOne()
|
void |
BoolSumStructure.putAllZero()
|
Uses of ContradictionException in choco.cp.solver.constraints.integer.channeling |
---|
Methods in choco.cp.solver.constraints.integer.channeling that throw ContradictionException | |
---|---|
void |
DomainChanneling.awake()
Propagation: Propagating the constraint for the very first time until local consistency is reached. |
void |
ReifiedLargeOr.awakeOnBounds(int varIndex)
|
void |
ReifiedLargeNor.awakeOnBounds(int varIndex)
|
void |
ReifiedLargeNand.awakeOnBounds(int varIndex)
|
void |
ReifiedLargeAnd.awakeOnBounds(int varIndex)
|
void |
ReifiedBinXor.awakeOnBounds(int varIndex)
|
void |
ReifiedBinXnor.awakeOnBounds(int varIndex)
|
void |
ReifiedBinImplication.awakeOnBounds(int varIndex)
|
void |
ReifiedLargeOr.awakeOnInf(int varIdx)
|
void |
ReifiedLargeNor.awakeOnInf(int varIdx)
|
void |
ReifiedLargeNand.awakeOnInf(int varIdx)
|
void |
ReifiedLargeAnd.awakeOnInf(int varIdx)
|
void |
ReifiedBinXor.awakeOnInf(int varIdx)
|
void |
ReifiedBinXnor.awakeOnInf(int varIdx)
|
void |
ReifiedBinImplication.awakeOnInf(int varIdx)
|
void |
DomainChanneling.awakeOnInf(int i)
Default propagation on improved lower bound: propagation on domain revision. |
void |
BooleanChanneling.awakeOnInf(int idx)
|
void |
ReifiedLargeOr.awakeOnInst(int idx)
|
void |
ReifiedLargeNor.awakeOnInst(int idx)
|
void |
ReifiedLargeNand.awakeOnInst(int idx)
|
void |
ReifiedLargeAnd.awakeOnInst(int idx)
|
void |
ReifiedBinXor.awakeOnInst(int idx)
|
void |
ReifiedBinXnor.awakeOnInst(int idx)
|
void |
ReifiedBinImplication.awakeOnInst(int idx)
|
void |
DomainChanneling.awakeOnInst(int idx)
Default propagation on instantiation: full constraint re-propagation. |
void |
DomainChanneling.awakeOnRem(int idx,
int val)
Default propagation on one value removal: propagation on domain revision. |
void |
ReifiedLargeOr.awakeOnRemovals(int idx,
DisposableIntIterator deltaDomain)
|
void |
ReifiedLargeNor.awakeOnRemovals(int idx,
DisposableIntIterator deltaDomain)
|
void |
ReifiedLargeNand.awakeOnRemovals(int idx,
DisposableIntIterator deltaDomain)
|
void |
ReifiedLargeAnd.awakeOnRemovals(int idx,
DisposableIntIterator deltaDomain)
|
void |
ReifiedBinXor.awakeOnRemovals(int idx,
DisposableIntIterator deltaDomain)
|
void |
ReifiedBinXnor.awakeOnRemovals(int idx,
DisposableIntIterator deltaDomain)
|
void |
ReifiedBinImplication.awakeOnRemovals(int idx,
DisposableIntIterator deltaDomain)
|
void |
BooleanChanneling.awakeOnRemovals(int idx,
DisposableIntIterator deltaDomain)
|
void |
ReifiedLargeOr.awakeOnSup(int varIdx)
|
void |
ReifiedLargeNor.awakeOnSup(int varIdx)
|
void |
ReifiedLargeNand.awakeOnSup(int varIdx)
|
void |
ReifiedLargeAnd.awakeOnSup(int varIdx)
|
void |
ReifiedBinXor.awakeOnSup(int varIdx)
|
void |
ReifiedBinXnor.awakeOnSup(int varIdx)
|
void |
ReifiedBinImplication.awakeOnSup(int varIdx)
|
void |
DomainChanneling.awakeOnSup(int i)
Default propagation on improved upper bound: propagation on domain revision. |
void |
BooleanChanneling.awakeOnSup(int idx)
|
void |
BooleanChanneling.filterFromBtoX()
|
void |
BooleanChanneling.filterFromXtoB()
|
void |
ReifiedLargeOr.propagate()
|
void |
ReifiedLargeNor.propagate()
|
void |
ReifiedLargeNand.propagate()
|
void |
ReifiedLargeAnd.propagate()
|
void |
ReifiedBinXor.propagate()
|
void |
ReifiedBinXnor.propagate()
|
void |
ReifiedBinImplication.propagate()
|
void |
DomainChanneling.propagate()
Propagation: Propagating the constraint until local consistency is reached. |
void |
BooleanChanneling.propagate()
|
Uses of ContradictionException in choco.cp.solver.constraints.integer.extension |
---|
Methods in choco.cp.solver.constraints.integer.extension that throw ContradictionException | |
---|---|
void |
GACstrPositiveLargeSConstraint.awake()
|
void |
GAC3rmPositiveLargeConstraint.awake()
|
void |
GAC3rmLargeConstraint.awake()
|
void |
GAC2001PositiveLargeConstraint.awake()
|
void |
GAC2001LargeSConstraint.awake()
|
void |
AC3rmBitBinSConstraint.awake()
|
void |
AC3rmBinSConstraint.awake()
|
void |
AC2001BinSConstraint.awake()
|
void |
GACstrPositiveLargeSConstraint.awakeOnBounds(int varIndex)
|
void |
GAC3rmPositiveLargeConstraint.awakeOnBounds(int varIndex)
|
void |
GAC3rmLargeConstraint.awakeOnBounds(int varIndex)
|
void |
GAC2001PositiveLargeConstraint.awakeOnBounds(int varIndex)
|
void |
GAC2001LargeSConstraint.awakeOnBounds(int varIndex)
|
void |
CspLargeSConstraint.awakeOnBounds(int varIndex)
|
void |
AC3rmBitBinSConstraint.awakeOnBounds(int varIndex)
|
void |
AC3rmBinSConstraint.awakeOnBounds(int varIndex)
|
void |
AC2001BinSConstraint.awakeOnBounds(int varIndex)
|
void |
GACstrPositiveLargeSConstraint.awakeOnInf(int idx)
|
void |
GAC3rmPositiveLargeConstraint.awakeOnInf(int idx)
|
void |
GAC3rmLargeConstraint.awakeOnInf(int idx)
|
void |
GAC2001PositiveLargeConstraint.awakeOnInf(int idx)
|
void |
GAC2001LargeSConstraint.awakeOnInf(int idx)
|
void |
AC3rmBitBinSConstraint.awakeOnInf(int idx)
|
void |
AC3rmBinSConstraint.awakeOnInf(int idx)
|
void |
AC3BinSConstraint.awakeOnInf(int idx)
Propagation when a minimal bound of a variable was modified. |
void |
AC2001BinSConstraint.awakeOnInf(int idx)
|
void |
GACstrPositiveLargeSConstraint.awakeOnInst(int idx)
|
void |
GAC3rmPositiveLargeConstraint.awakeOnInst(int idx)
|
void |
GAC3rmLargeConstraint.awakeOnInst(int idx)
|
void |
GAC2001PositiveLargeConstraint.awakeOnInst(int idx)
|
void |
GAC2001LargeSConstraint.awakeOnInst(int idx)
|
void |
FCBinSConstraint.awakeOnInst(int idx)
|
void |
CspLargeSConstraint.awakeOnInst(int idx)
|
void |
AC3rmBitBinSConstraint.awakeOnInst(int idx)
|
void |
AC3rmBinSConstraint.awakeOnInst(int idx)
|
void |
AC3BinSConstraint.awakeOnInst(int idx)
Propagation when a variable is instantiated. |
void |
AC2001BinSConstraint.awakeOnInst(int idx)
|
void |
GACstrPositiveLargeSConstraint.awakeOnRem(int idx,
int x)
|
void |
GAC3rmPositiveLargeConstraint.awakeOnRem(int idx,
int x)
|
void |
GAC3rmLargeConstraint.awakeOnRem(int idx,
int x)
|
void |
GAC2001PositiveLargeConstraint.awakeOnRem(int idx,
int x)
|
void |
GAC2001LargeSConstraint.awakeOnRem(int idx,
int x)
|
void |
AC3rmBitBinSConstraint.awakeOnRem(int idx,
int x)
|
void |
AC3rmBinSConstraint.awakeOnRem(int idx,
int x)
|
void |
AC3BinSConstraint.awakeOnRem(int idx,
int x)
|
void |
AC2001BinSConstraint.awakeOnRem(int idx,
int x)
|
void |
GACstrPositiveLargeSConstraint.awakeOnRemovals(int idx,
DisposableIntIterator deltaDomain)
|
void |
GAC3rmPositiveLargeConstraint.awakeOnRemovals(int idx,
DisposableIntIterator deltaDomain)
|
void |
GAC3rmLargeConstraint.awakeOnRemovals(int idx,
DisposableIntIterator deltaDomain)
|
void |
GAC2001PositiveLargeConstraint.awakeOnRemovals(int idx,
DisposableIntIterator deltaDomain)
|
void |
GAC2001LargeSConstraint.awakeOnRemovals(int idx,
DisposableIntIterator deltaDomain)
|
void |
CspLargeSConstraint.awakeOnRemovals(int idx,
DisposableIntIterator deltaDomain)
|
void |
AC3rmBitBinSConstraint.awakeOnRemovals(int idx,
DisposableIntIterator deltaDomain)
|
void |
AC3rmBinSConstraint.awakeOnRemovals(int idx,
DisposableIntIterator deltaDomain)
|
void |
AC2001BinSConstraint.awakeOnRemovals(int idx,
DisposableIntIterator deltaDomain)
|
void |
GACstrPositiveLargeSConstraint.awakeOnSup(int idx)
|
void |
GAC3rmPositiveLargeConstraint.awakeOnSup(int idx)
|
void |
GAC3rmLargeConstraint.awakeOnSup(int idx)
|
void |
GAC2001PositiveLargeConstraint.awakeOnSup(int idx)
|
void |
GAC2001LargeSConstraint.awakeOnSup(int idx)
|
void |
AC3rmBitBinSConstraint.awakeOnSup(int idx)
|
void |
AC3rmBinSConstraint.awakeOnSup(int idx)
|
void |
AC3BinSConstraint.awakeOnSup(int idx)
|
void |
AC2001BinSConstraint.awakeOnSup(int idx)
|
void |
GACstrPositiveLargeSConstraint.filter(int idx)
|
void |
GAC3rmPositiveLargeConstraint.filter(int idx)
|
void |
GAC2001PositiveLargeConstraint.filter(int idx)
|
void |
GAC2001LargeSConstraint.filter(int idx)
|
void |
GACstrPositiveLargeSConstraint.gacstr()
Main propagation loop. |
void |
GACstrPositiveLargeSConstraint.gacstr(int idx)
Main Incremental propagation loop. |
void |
GAC3rmLargeConstraint.initializeSupports(int indexVar)
initialize the supports of each value of indexVar |
void |
GAC3rmPositiveLargeConstraint.initSupports()
initialize the residual supports of each pair to their first allowed tuple |
void |
GACstrPositiveLargeSConstraint.propagate()
|
void |
GAC3rmPositiveLargeConstraint.propagate()
|
void |
GAC3rmLargeConstraint.propagate()
|
void |
GAC2001PositiveLargeConstraint.propagate()
|
void |
GAC2001LargeSConstraint.propagate()
|
void |
FCBinSConstraint.propagate()
|
void |
CspLargeSConstraint.propagate()
|
void |
AC3rmBitBinSConstraint.propagate()
|
void |
AC3rmBinSConstraint.propagate()
|
void |
AC3BinSConstraint.propagate()
|
void |
AC2001BinSConstraint.propagate()
|
void |
GACstrPositiveLargeSConstraint.pruningPhase()
|
void |
AC3rmBitBinSConstraint.revise(int idx)
|
void |
AC3rmBinSConstraint.revise(int idx)
|
void |
AC3rmBitBinSConstraint.reviseV0()
|
void |
AC3rmBinSConstraint.reviseV0()
|
void |
AC3BinSConstraint.reviseV0()
|
void |
AC2001BinSConstraint.reviseV0()
|
void |
AC3rmBitBinSConstraint.reviseV1()
|
void |
AC3rmBinSConstraint.reviseV1()
|
void |
AC3BinSConstraint.reviseV1()
|
void |
AC2001BinSConstraint.reviseV1()
|
void |
GAC3rmPositiveLargeConstraint.reviseVar(int indexVar)
updates the support for all values in the domain of variable and remove unsupported values for variable |
void |
GAC3rmLargeConstraint.reviseVar(int indexVar)
|
void |
GAC2001PositiveLargeConstraint.reviseVar(int indexVar)
updates the support for all values in the domain of variable and remove unsupported values for variable |
void |
GAC2001LargeSConstraint.reviseVar(int indexVar,
boolean fromScratch)
|
Uses of ContradictionException in choco.cp.solver.constraints.integer.intlincomb |
---|
Methods in choco.cp.solver.constraints.integer.intlincomb that throw ContradictionException | |
---|---|
void |
IntLinCombOp.filter(boolean startWithLB,
int minNbRules)
A strategy for chaotic iteration with two rules (LB and UB propagation). |
protected abstract boolean |
IntLinCombOp.filterOnImprovedLowerBound()
Checks a new lower bound. |
boolean |
IntLinCombNEQ.filterOnImprovedLowerBound()
Checks a new lower bound. |
boolean |
IntLinCombLEQ.filterOnImprovedLowerBound()
Checks a new lower bound. |
boolean |
IntLinCombGEQ.filterOnImprovedLowerBound()
Checks a new lower bound. |
boolean |
IntLinCombEQ.filterOnImprovedLowerBound()
Checks a new lower bound. |
protected abstract boolean |
IntLinCombOp.filterOnImprovedUpperBound()
Checks a new upper bound. |
boolean |
IntLinCombNEQ.filterOnImprovedUpperBound()
Checks a new upper bound. |
boolean |
IntLinCombLEQ.filterOnImprovedUpperBound()
Checks a new upper bound. |
boolean |
IntLinCombGEQ.filterOnImprovedUpperBound()
Checks a new upper bound. |
boolean |
IntLinCombEQ.filterOnImprovedUpperBound()
Checks a new upper bound. |
Uses of ContradictionException in choco.cp.solver.constraints.integer.soft |
---|
Methods in choco.cp.solver.constraints.integer.soft that throw ContradictionException | |
---|---|
void |
SoftIntSConstraint.awake()
|
void |
SoftIntSConstraint.awakeOnBounds(int varIndex)
|
void |
SoftIntSConstraint.awakeOnInf(int idx)
|
void |
SoftIntSConstraint.awakeOnInst(int idx)
|
void |
SoftIntSConstraint.awakeOnRem(int idx,
int x)
|
void |
SoftIntSConstraint.awakeOnRemovals(int idx,
DisposableIntIterator deltaDomain)
|
void |
SoftIntSConstraint.awakeOnSup(int idx)
|
void |
SoftIntSConstraint.filter()
|
void |
SoftIntSConstraint.filterReifiedConstraintFromBool()
|
void |
SoftIntSConstraint.filterReifiedConstraintFromCons()
|
void |
SoftIntSConstraint.propagate()
|
Uses of ContradictionException in choco.cp.solver.constraints.real |
---|
Methods in choco.cp.solver.constraints.real that throw ContradictionException | |
---|---|
void |
MixedCstElt.awake()
|
void |
MixedEqXY.awakeOnBounds(int varIdx)
|
void |
MixedCstElt.awakeOnBounds(int idx)
|
void |
MixedEqXY.awakeOnInf(int idx)
|
void |
MixedCstElt.awakeOnInf(int idx)
|
void |
MixedEqXY.awakeOnInst(int varIdx)
|
void |
MixedCstElt.awakeOnInst(int varIdx)
|
void |
MixedEqXY.awakeOnRem(int varIdx,
int val)
|
void |
MixedCstElt.awakeOnRem(int varIdx,
int val)
|
void |
MixedEqXY.awakeOnRemovals(int varIdx,
DisposableIntIterator deltaDomain)
|
void |
MixedCstElt.awakeOnRemovals(int varIdx,
DisposableIntIterator deltaDomain)
|
void |
MixedEqXY.awakeOnSup(int idx)
|
void |
MixedCstElt.awakeOnSup(int idx)
|
void |
MixedEqXY.propagate()
|
void |
MixedCstElt.propagate()
|
void |
Equation.propagate()
|
protected void |
MixedEqXY.updateIInf()
|
void |
MixedCstElt.updateIInf()
|
protected void |
MixedEqXY.updateISup()
|
void |
MixedCstElt.updateISup()
|
protected void |
MixedEqXY.updateReal()
|
void |
MixedCstElt.updateReal()
|
Uses of ContradictionException in choco.cp.solver.constraints.real.exp |
---|
Methods in choco.cp.solver.constraints.real.exp that throw ContradictionException | |
---|---|
void |
RealIntervalImpl.intersect(RealInterval interval)
Deprecated. |
void |
RealSin.project()
|
void |
RealPlus.project()
Projects domain reduction on operands according to the expression domain itself (due to constraint restrictions). |
void |
RealMult.project()
|
void |
RealMinus.project()
|
void |
RealIntegerPower.project()
|
void |
RealCos.project()
|
Uses of ContradictionException in choco.cp.solver.constraints.reified |
---|
Methods in choco.cp.solver.constraints.reified that throw ContradictionException | |
---|---|
void |
ReifiedIntSConstraint.awake()
|
void |
ReifiedIntSConstraint.awakeOnBounds(int varIndex)
|
void |
ReifiedAllSConstraint.awakeOnBounds(int varIdx)
|
void |
ReifiedAllSConstraint.awakeOnEnv(int varIdx,
int x)
Default propagation on enveloppe modification: propagation on removing a value from the enveloppe. |
void |
ReifiedAllSConstraint.awakeOnEnvRemovals(int sIdx,
DisposableIntIterator deltaDomain)
|
void |
ReifiedIntSConstraint.awakeOnInf(int idx)
|
void |
ReifiedAllSConstraint.awakeOnInf(int varIdx)
Default propagation on improved lower bound: propagation on domain revision. |
void |
ReifiedIntSConstraint.awakeOnInst(int idx)
|
void |
ReifiedAllSConstraint.awakeOnInst(int varIdx)
Default propagation on instantiation. |
void |
ReifiedAllSConstraint.awakeOnKer(int varIdx,
int x)
Default propagation on kernel modification: propagation on adding a value to the kernel. |
void |
ReifiedAllSConstraint.awakeOnkerAdditions(int sIdx,
DisposableIntIterator deltaDomain)
|
void |
ReifiedIntSConstraint.awakeOnRem(int idx,
int x)
|
void |
ReifiedAllSConstraint.awakeOnRem(int varIdx,
int val)
Default propagation on one value removal: propagation on domain revision. |
void |
ReifiedIntSConstraint.awakeOnRemovals(int idx,
DisposableIntIterator deltaDomain)
|
void |
ReifiedAllSConstraint.awakeOnRemovals(int varIdx,
DisposableIntIterator deltaDomain)
|
void |
ReifiedIntSConstraint.awakeOnSup(int idx)
|
void |
ReifiedAllSConstraint.awakeOnSup(int varIdx)
Default propagation on improved upper bound: propagation on domain revision. |
void |
ReifiedIntSConstraint.filter()
|
void |
ReifiedAllSConstraint.filter()
|
void |
ReifiedAllSConstraint.filterReifiedConstraintFromBool()
|
void |
ReifiedIntSConstraint.filterReifiedConstraintFromCons()
|
void |
ReifiedAllSConstraint.filterReifiedConstraintFromCons()
|
void |
IfThenElse.filterReifiedConstraintFromCons()
|
void |
ReifiedIntSConstraint.propagate()
|
void |
ReifiedAllSConstraint.propagate()
|
Uses of ContradictionException in choco.cp.solver.constraints.set |
---|
Methods in choco.cp.solver.constraints.set that throw ContradictionException | |
---|---|
void |
SetValuePrecede.awake()
|
void |
SetNaryUnion.awake()
|
void |
SetCard.awake()
|
void |
MemberX.awake()
|
void |
InverseSetInt.awake()
|
void |
InverseSet.awake()
|
void |
AmongSet.awake()
Propagation: Propagating the constraint for the very first time until local consistency is reached. |
void |
SetValuePrecede.awakeOnEnv(int varIdx,
int x)
|
void |
SetUnion.awakeOnEnv(int varIdx,
int x)
|
void |
SetNotEq.awakeOnEnv(int varIdx,
int x)
|
void |
SetNaryUnion.awakeOnEnv(int varIdx,
int x)
Default propagation on enveloppe modification: propagation on removing a value from the enveloppe. |
void |
SetIntersection.awakeOnEnv(int varIdx,
int x)
|
void |
SetEq.awakeOnEnv(int varIdx,
int x)
|
void |
NotMemberXY.awakeOnEnv(int varIdx,
int x)
|
void |
NotMemberX.awakeOnEnv(int varIdx,
int x)
|
void |
MemberXiY.awakeOnEnv(int varIdx,
int x)
|
void |
MemberXY.awakeOnEnv(int varIdx,
int x)
|
void |
MemberX.awakeOnEnv(int varIdx,
int x)
|
void |
IsNotIncluded.awakeOnEnv(int varIdx,
int x)
|
void |
IsIncluded.awakeOnEnv(int varIdx,
int x)
|
void |
InverseSetInt.awakeOnEnv(int i,
int j)
Filtering Rule 2 : j \not\in s[i] => x[j]! |
void |
InverseSet.awakeOnEnv(int varIdx,
int x)
|
void |
ComplementSet.awakeOnEnv(int varIdx,
int x)
|
void |
AmongSet.awakeOnEnv(int varIdx,
int x)
|
void |
SetCard.awakeOnEnvRemovals(int idx,
DisposableIntIterator deltaDomain)
|
void |
AbstractBoundOfASet.awakeOnEnvRemovals(int idx,
DisposableIntIterator deltaDomain)
|
void |
SetCard.awakeOnInf(int idx)
|
void |
NotMemberXY.awakeOnInf(int idx)
|
void |
MinOfASet.awakeOnInf(int idx)
Propagation when lower bound is increased. |
void |
MemberXY.awakeOnInf(int idx)
|
void |
MaxOfASet.awakeOnInf(int idx)
Propagation when lower bound is increased. |
void |
SetValuePrecede.awakeOnInst(int varIdx)
|
void |
SetUnion.awakeOnInst(int varIdx)
|
void |
SetNotEq.awakeOnInst(int varIdx)
|
void |
SetNaryUnion.awakeOnInst(int varIdx)
Default propagation on instantiation. |
void |
SetIntersection.awakeOnInst(int varIdx)
|
void |
SetEq.awakeOnInst(int varIdx)
|
void |
SetCard.awakeOnInst(int varIdx)
|
void |
NotMemberXY.awakeOnInst(int varIdx)
|
void |
NotMemberX.awakeOnInst(int varIdx)
|
void |
MemberXiY.awakeOnInst(int varIdx)
|
void |
MemberXY.awakeOnInst(int varIdx)
|
void |
MemberX.awakeOnInst(int varIdx)
|
void |
IsNotIncluded.awakeOnInst(int varIdx)
|
void |
IsIncluded.awakeOnInst(int varIdx)
|
void |
InverseSetInt.awakeOnInst(int x)
Filtering Rule 3 : x[j]=i => j \in s[i] and j \not\in s[i'] \forall i'! |
void |
Disjoint.awakeOnInst(int varIdx)
|
void |
AmongSet.awakeOnInst(int varIdx)
|
void |
AllDisjoint.awakeOnInst(int varIdx)
|
void |
AbstractBoundOfASet.awakeOnInst(int idx)
Propagation when a variable is instantiated. |
void |
MinOfASet.awakeOnKer()
|
void |
MaxOfASet.awakeOnKer()
|
protected abstract void |
AbstractBoundOfASet.awakeOnKer()
|
void |
SetValuePrecede.awakeOnKer(int varIdx,
int x)
|
void |
SetUnion.awakeOnKer(int varIdx,
int x)
|
void |
SetNotEq.awakeOnKer(int varIdx,
int x)
|
void |
SetNaryUnion.awakeOnKer(int varIdx,
int x)
Default propagation on kernel modification: propagation on adding a value to the kernel. |
void |
SetIntersection.awakeOnKer(int varIdx,
int x)
|
void |
SetEq.awakeOnKer(int varIdx,
int x)
|
void |
NotMemberXY.awakeOnKer(int varIdx,
int x)
|
void |
NotMemberX.awakeOnKer(int varIdx,
int x)
|
void |
MemberX.awakeOnKer(int varIdx,
int x)
|
void |
IsNotIncluded.awakeOnKer(int varIdx,
int x)
|
void |
IsIncluded.awakeOnKer(int varIdx,
int x)
|
void |
InverseSetInt.awakeOnKer(int i,
int j)
Filtering Rule 1 : j \in s[i] => x[j]=i (then propagate Rule 3) |
void |
InverseSet.awakeOnKer(int varIdx,
int x)
|
void |
Disjoint.awakeOnKer(int varIdx,
int x)
|
void |
ComplementSet.awakeOnKer(int varIdx,
int x)
|
void |
AmongSet.awakeOnKer(int varIdx,
int x)
|
void |
AllDisjoint.awakeOnKer(int varIdx,
int x)
|
void |
AbstractBoundOfASet.awakeOnKer(int varIdx,
int x)
|
void |
SetCard.awakeOnkerAdditions(int idx,
DisposableIntIterator deltaDomain)
|
void |
AbstractBoundOfASet.awakeOnkerAdditions(int idx,
DisposableIntIterator deltaDomain)
|
void |
MinOfASet.awakeOnRem()
|
void |
MaxOfASet.awakeOnRem()
|
protected abstract void |
AbstractBoundOfASet.awakeOnRem()
|
void |
NotMemberXY.awakeOnRem(int idx,
int x)
|
void |
MemberXY.awakeOnRem(int idx,
int x)
|
void |
InverseSetInt.awakeOnRem(int x,
int v)
Filtering Rule 4 : x[j]! |
void |
AmongSet.awakeOnRem(int varIdx,
int val)
Default propagation on one value removal: propagation on domain revision. |
void |
AbstractBoundOfASet.awakeOnRem(int varIdx,
int val)
|
void |
SetCard.awakeOnRemovals(int idx,
DisposableIntIterator deltaDomain)
|
void |
SetCard.awakeOnSup(int idx)
|
void |
NotMemberXY.awakeOnSup(int idx)
|
void |
MinOfASet.awakeOnSup(int idx)
Propagation when upper bound is decreased. |
void |
MemberXY.awakeOnSup(int idx)
|
void |
MaxOfASet.awakeOnSup(int idx)
Propagation when upper bound is decreased. |
void |
InverseSetInt.awakeOnVar(int x)
propagation on a var: Rules 1 & 2 (integer) or 3 & 4 (set) |
boolean |
SetNotEq.checkAreEqual()
|
void |
SetCard.filter()
|
void |
NotMemberXY.filter()
if only one value out of the kernel, then this value can be removed from the enveloppe |
void |
MinOfASet.filter()
Propagation of the constraint. |
void |
MemberXY.filter()
|
void |
MaxOfASet.filter()
Propagation of the constraint. |
void |
IsNotIncluded.filter()
|
protected abstract void |
AbstractBoundOfASet.filter()
|
void |
IsIncluded.filter(int idx)
|
void |
Disjoint.filter(int idx)
|
void |
AllDisjoint.filter(int idx)
|
void |
SetEq.filterEq()
|
void |
SetNotEq.filterForInst(SetVar instvar,
SetVar otherVar,
int idx)
|
void |
InverseSetInt.filterFromIndices()
Filtering Rule 0 : i>s.length => x[j]! |
int |
IsNotIncluded.findUniqueOutsider()
test if all values in env(v0) are in ker(v1) and returns - +Infini if it is false and there are at least two such values - -Infini if it is true - the single value that is in env(v0) and not in ker(v1) if there is a single one |
protected void |
AbstractBoundOfASet.onlyOneCandidatePropagation()
If only one candidate to be the max of the list, some additionnal propagation can be performed (as in usual x == y constraint). |
void |
SetValuePrecede.propagate()
|
void |
SetUnion.propagate()
|
void |
SetNotEq.propagate()
|
void |
SetNaryUnion.propagate()
|
void |
SetLexicographicOrdering.propagate()
|
void |
SetIntersection.propagate()
|
void |
SetEq.propagate()
|
void |
SetCard.propagate()
|
void |
NotMemberXY.propagate()
|
void |
NotMemberX.propagate()
|
void |
MemberXiY.propagate()
|
void |
MemberXY.propagate()
|
void |
MemberX.propagate()
|
void |
IsNotIncluded.propagate()
|
void |
IsIncluded.propagate()
|
void |
InverseSetInt.propagate()
|
void |
InverseSet.propagate()
|
void |
Disjoint.propagate()
|
void |
ComplementSet.propagate()
|
void |
AmongSet.propagate()
Propagation: Propagating the constraint until local consistency is reached. |
void |
AllDisjoint.propagate()
|
void |
AbstractBoundOfASet.propagate()
|
void |
SetCard.reactOnInfAndEnvEvents(int envSize)
|
void |
SetCard.reactOnSupAndKerEvents(int kerSize)
|
protected boolean |
AbstractBoundOfASet.remFromEnveloppe()
|
protected boolean |
MinOfASet.removeFromEnv(int idx)
|
protected boolean |
MaxOfASet.removeFromEnv(int idx)
|
protected abstract boolean |
AbstractBoundOfASet.removeFromEnv(int idx)
|
protected boolean |
AbstractBoundOfASet.removeGreaterFromEnv(int idx,
int maxValue)
|
protected boolean |
AbstractBoundOfASet.removeLowerFromEnv(int idx,
int minValue)
|
protected boolean |
AbstractBoundOfASet.updateBoundInf(int val)
|
protected boolean |
AbstractBoundOfASet.updateBoundSup(int val)
|
protected void |
MinOfASet.updateKernelInf()
|
protected void |
MaxOfASet.updateKernelSup()
|
Uses of ContradictionException in choco.cp.solver.constraints.strong |
---|
Methods in choco.cp.solver.constraints.strong with parameters of type ContradictionException | |
---|---|
void |
DomOverWDegRPC.contradictionOccured(ContradictionException e)
|
Methods in choco.cp.solver.constraints.strong that throw ContradictionException | |
---|---|
void |
AbstractStrongConsistency.awake()
|
void |
Adapter.propagate()
|
void |
SCVariable.removeVal(int value)
|
Uses of ContradictionException in choco.cp.solver.constraints.strong.maxrpcrm |
---|
Methods in choco.cp.solver.constraints.strong.maxrpcrm that throw ContradictionException | |
---|---|
void |
MaxRPCrm.awake()
|
void |
MaxRPCrm.propagate()
Effectue la propagation à partir de la file courante |
boolean |
MaxRPCConstraintLight.revise(int position)
Propagation d'un arc (Contrainte, Variable) |
boolean |
MaxRPCConstraintFull.revise(int position)
Propagation d'un arc (Contrainte, Variable, Valeur) |
abstract boolean |
AbstractMaxRPCConstraint.revise(int position)
|
boolean |
MaxRPCConstraintFull.revisePC(Clique clique,
int position)
|
abstract boolean |
AbstractMaxRPCConstraint.revisePC(Clique clique,
int position)
|
Uses of ContradictionException in choco.cp.solver.goals |
---|
Methods in choco.cp.solver.goals that throw ContradictionException | |
---|---|
Goal |
Sequence.execute(Solver s)
|
Goal |
GlobalFail.execute(Solver solver)
|
Uses of ContradictionException in choco.cp.solver.goals.choice |
---|
Methods in choco.cp.solver.goals.choice that throw ContradictionException | |
---|---|
Goal |
Instantiate.execute(Solver s)
|
Goal |
Generate.execute(Solver s)
|
Uses of ContradictionException in choco.cp.solver.propagation |
---|
Fields in choco.cp.solver.propagation declared as ContradictionException | |
---|---|
protected ContradictionException |
AbstractPropagationEngine.reuseException
Storing the last contradiction (reusable). |
Methods in choco.cp.solver.propagation that throw ContradictionException | |
---|---|
void |
BlockingVarEventQueue.propagateAllEvents()
Propagates some events: in fact all the events of the queue, since there are the most important events. |
void |
VariableEventQueue.propagateAllEvents()
Propagates some events: in fact all the events of the queue, since there are the most important events. |
void |
ConstraintEventQueue.propagateAllEvents()
Propagates one var in the queue. |
void |
ChocoEngine.propagateEvents()
Propagate one by one events registered |
void |
BlockingVarEventQueue.propagateOneEvent()
Propagates one single event from the queue (usefull for tracing) |
void |
VariableEventQueue.propagateOneEvent()
Propagates one single event from the queue (usefull for tracing) |
void |
ConstraintEventQueue.propagateOneEvent()
Propagates one var in the queue. |
void |
AbstractPropagationEngine.raiseContradiction(int cidx,
Var variable,
SConstraint cause)
Deprecated. |
void |
AbstractPropagationEngine.raiseContradiction(Object cause)
Raising a contradiction with a cause. |
void |
AbstractPropagationEngine.raiseContradiction(Object cause,
int move)
Raising a contradiction with a cause and a movement |
Uses of ContradictionException in choco.cp.solver.search |
---|
Methods in choco.cp.solver.search that throw ContradictionException | |
---|---|
void |
SearchLimitManager.endNode()
|
protected void |
SearchLoopWithRecomputation.goUpBranch()
|
protected void |
AbstractSearchLoopWithRestart.goUpBranch()
post the dynamic cut, backtrack and propagate. |
void |
SearchLimitManager.newNode()
|
Uses of ContradictionException in choco.cp.solver.search.integer.branching |
---|
Methods in choco.cp.solver.search.integer.branching with parameters of type ContradictionException | |
---|---|
void |
DomOverWDegBinBranching.contradictionOccured(ContradictionException e)
Deprecated. |
void |
DomOverWDegBranching.contradictionOccured(ContradictionException e)
Deprecated. |
Methods in choco.cp.solver.search.integer.branching that throw ContradictionException | |
---|---|
void |
PackDynRemovals.fail()
|
void |
DomOverWDegBinBranching.goDownBranch(IntBranchingDecision ctx)
Deprecated. |
void |
ImpactBasedBranching.goDownBranch(IntBranchingDecision ctx)
|
void |
DomOverWDegBranching.goDownBranch(IntBranchingDecision decision)
Deprecated. |
void |
AssignVar.goDownBranch(IntBranchingDecision decision)
|
void |
AssignOrForbidIntVarValPair.goDownBranch(IntBranchingDecision decision)
|
void |
AssignOrForbidIntVarVal.goDownBranch(IntBranchingDecision ctx)
|
protected void |
ImpactBasedBranching.goDownBranch(IntDomainVar var,
int val)
|
void |
PackDynRemovals.goUpBranch(IntBranchingDecision decision)
|
void |
ImpactBasedBranching.goUpBranch(IntBranchingDecision decision)
|
void |
DomOverWDegBranching.goUpBranch(IntBranchingDecision decision)
Deprecated. |
void |
AssignVar.goUpBranch(IntBranchingDecision decision)
|
void |
PackDynRemovals.removeEmptyBins(IntDomainVar bin)
|
void |
PackDynRemovals.removeEquivalentBins(IntDomainVar bin,
int bup)
|
Object |
DomOverWDegBinBranching.selectBranchingObject()
Deprecated. |
Object |
ImpactBasedBranching.selectBranchingObject()
|
Object |
DomOverWDegBranching.selectBranchingObject()
Deprecated. |
Object |
AssignVar.selectBranchingObject()
selecting the object under scrutiny (that object on which an alternative will be set) |
Object |
AssignOrForbidIntVarValPair.selectBranchingObject()
|
Object |
AssignOrForbidIntVarVal.selectBranchingObject()
selecting the object under scrutiny (that object on which an alternative will be set) |
Uses of ContradictionException in choco.cp.solver.search.integer.branching.domwdeg |
---|
Methods in choco.cp.solver.search.integer.branching.domwdeg with parameters of type ContradictionException | |
---|---|
void |
AbstractDomOverWDegBranching.contradictionOccured(ContradictionException e)
|
Methods in choco.cp.solver.search.integer.branching.domwdeg that throw ContradictionException | |
---|---|
void |
TaskOverWDegBinBranching.goDownBranch(IntBranchingDecision decision)
|
void |
DomOverWDegBranchingNew.goDownBranch(IntBranchingDecision decision)
|
void |
DomOverWDegBinBranchingNew.goDownBranch(IntBranchingDecision decision)
|
void |
DomOverWDegBranchingNew.goUpBranch(IntBranchingDecision decision)
|
void |
AbstractDomOverWDegBinBranching.goUpBranch(IntBranchingDecision decision)
nothing to do |
Object |
TaskOverWDegBinBranching.selectBranchingObject()
|
Object |
AbstractDomOverWDegBranching.selectBranchingObject()
|
Uses of ContradictionException in choco.cp.solver.search.integer.objective |
---|
Methods in choco.cp.solver.search.integer.objective that throw ContradictionException | |
---|---|
void |
MinIntObjManager.postFloorBound()
|
void |
MaxIntObjManager.postFloorBound()
|
void |
IntObjectiveManager.postIncFloorBound()
|
void |
MinIntObjManager.postTargetBound()
|
void |
MaxIntObjManager.postTargetBound()
|
Uses of ContradictionException in choco.cp.solver.search.integer.varselector |
---|
Methods in choco.cp.solver.search.integer.varselector with parameters of type ContradictionException | |
---|---|
void |
DomOverWDeg.contradictionOccured(ContradictionException e)
Deprecated. |
Uses of ContradictionException in choco.cp.solver.search.integer.varselector.ratioselector |
---|
Methods in choco.cp.solver.search.integer.varselector.ratioselector with parameters of type ContradictionException | |
---|---|
void |
RandDomOverWDegSelector.contradictionOccured(ContradictionException e)
|
void |
DomOverWDegSelector.contradictionOccured(ContradictionException e)
|
Uses of ContradictionException in choco.cp.solver.search.integer.varselector.ratioselector.ratios.task |
---|
Methods in choco.cp.solver.search.integer.varselector.ratioselector.ratios.task that throw ContradictionException | |
---|---|
IntVarValPair |
CompositePrecValSelector.selectVarValPair()
|
Uses of ContradictionException in choco.cp.solver.search.real |
---|
Methods in choco.cp.solver.search.real that throw ContradictionException | |
---|---|
void |
AssignInterval.goDownBranch(IntBranchingDecision decision)
|
void |
AssignInterval.goUpBranch(IntBranchingDecision decision)
do nothing |
Object |
AssignInterval.selectBranchingObject()
|
Uses of ContradictionException in choco.cp.solver.search.real.objective |
---|
Methods in choco.cp.solver.search.real.objective that throw ContradictionException | |
---|---|
void |
RealObjectiveManager.postFloorBound()
|
void |
RealObjectiveManager.postIncFloorBound()
|
void |
RealObjectiveManager.postTargetBound()
|
Uses of ContradictionException in choco.cp.solver.search.set |
---|
Methods in choco.cp.solver.search.set that throw ContradictionException | |
---|---|
Object |
AssignSetVar.selectBranchingObject()
|
Uses of ContradictionException in choco.cp.solver.search.task |
---|
Methods in choco.cp.solver.search.task that throw ContradictionException | |
---|---|
void |
SetTimes.goDownBranch(IntBranchingDecision decision)
select a remaining task with the heuristic and assign its earliest starting time. |
void |
SetTimes.goUpBranch(IntBranchingDecision decision)
set the task not selectable. |
Object |
SetTimes.selectBranchingObject()
Select branching object. |
Uses of ContradictionException in choco.cp.solver.search.task.profile |
---|
Methods in choco.cp.solver.search.task.profile that throw ContradictionException | |
---|---|
IntVarValPair |
ProfileSelector.selectVarValPair()
|
Uses of ContradictionException in choco.cp.solver.variables.integer |
---|
Methods in choco.cp.solver.variables.integer that throw ContradictionException | |
---|---|
protected boolean |
BooleanDomain._instantiate(int x,
SConstraint cause)
Instantiating a variable to an search value. |
protected boolean |
IntervalIntDomain._removeVal(int x,
SConstraint cause)
|
protected boolean |
BooleanDomain._removeVal(int x,
SConstraint cause)
Removing a value from the domain of a variable. |
protected boolean |
BipartiteIntDomain._removeVal(int x,
SConstraint cause)
Removing a value from the domain of a variable. |
protected boolean |
BooleanDomain._updateInf(int x,
SConstraint cause)
Improving the lower bound. |
protected boolean |
BooleanDomain._updateSup(int x,
SConstraint cause)
Improving the upper bound. |
boolean |
IntDomainVarTimePosCste.instantiate(int x,
int idx)
|
boolean |
IntDomainVarImpl.instantiate(int x,
int idx)
Deprecated. |
boolean |
IntDomainVarAddCste.instantiate(int x,
int idx)
|
boolean |
BoolVarNot.instantiate(int x,
int idx)
|
boolean |
ViewIntDomainVarImpl.instantiate(int x,
SConstraint cause,
boolean forceAwake)
Internal var: instantiation of the variable caused by its i-th constraint Returns a boolean indicating whether the call indeed added new information. |
boolean |
IntDomainVarTimePosCste.instantiate(int x,
SConstraint cause,
boolean forceAwake)
|
boolean |
IntDomainVarImpl.instantiate(int x,
SConstraint cause,
boolean forceAwake)
Internal var: instantiation of the variable caused by its i-th constraint Returns a boolean indicating whether the call indeed added new information. |
boolean |
IntDomainVarAddCste.instantiate(int x,
SConstraint cause,
boolean forceAwake)
|
boolean |
BooleanVarImpl.instantiate(int x,
SConstraint cause,
boolean forceAwake)
Internal var: instantiation of the variable caused by its i-th constraint Returns a boolean indicating whether the call indeed added new information. |
boolean |
BooleanDomain.instantiate(int x,
SConstraint cause,
boolean forceAwake)
Internal var: instantiation of the variable caused by its i-th constraint Returns a boolean indicating whether the call indeed added new information. |
boolean |
BoolVarNot.instantiate(int x,
SConstraint cause,
boolean forceAwake)
|
boolean |
AbstractIntDomain.instantiate(int x,
SConstraint cause,
boolean forceAwake)
Internal var: instantiation of the variable caused by its i-th constraint Returns a boolean indicating whether the call indeed added new information. |
boolean |
IntVarEvent.propagateEvent()
Propagates the event through calls to the propagation engine. |
boolean |
IntCsteEvent.propagateEvent()
Propagates the event through calls to the propagation engine. |
void |
IntVarEvent.propagateInfEvent(C evtCause)
Propagates the update to the lower bound |
void |
IntVarEvent.propagateInstEvent(C evtCause)
Propagates the instantiation event |
void |
IntVarEvent.propagateRemovalsEvent(C evtCause)
Propagates a set of value removals |
void |
IntVarEvent.propagateSupEvent(C evtCause)
Propagates the update to the upper bound |
boolean |
IntDomainVarTimePosCste.removeInterval(int a,
int b,
int idx)
|
boolean |
IntDomainVarImpl.removeInterval(int a,
int b,
int idx)
Deprecated. |
boolean |
IntDomainVarAddCste.removeInterval(int a,
int b,
int idx)
|
boolean |
BoolVarNot.removeInterval(int a,
int b,
int idx)
|
boolean |
ViewIntDomainVarImpl.removeInterval(int a,
int b,
SConstraint cause,
boolean forceAwake)
Internal var: remove an interval (a sequence of consecutive values) from the domain of a variable caused by its i-th constraint. |
boolean |
IntDomainVarTimePosCste.removeInterval(int a,
int b,
SConstraint cause,
boolean forceAwake)
|
boolean |
IntDomainVarImpl.removeInterval(int a,
int b,
SConstraint cause,
boolean forceAwake)
Internal var: remove an interval (a sequence of consecutive values) from the domain of a variable caused by its i-th constraint. |
boolean |
IntDomainVarAddCste.removeInterval(int a,
int b,
SConstraint cause,
boolean forceAwake)
|
boolean |
BooleanVarImpl.removeInterval(int a,
int b,
SConstraint cause,
boolean forceAwake)
Internal var: remove an interval (a sequence of consecutive values) from the domain of a variable caused by its i-th constraint. |
boolean |
BoolVarNot.removeInterval(int a,
int b,
SConstraint cause,
boolean forceAwake)
|
boolean |
BipartiteIntDomain.removeInterval(int a,
int b,
SConstraint cause,
boolean forceAwake)
|
boolean |
AbstractIntDomain.removeInterval(int a,
int b,
SConstraint cause,
boolean forceAwake)
Internal var: remove an interval (a sequence of consecutive values) from the domain of a variable caused by its i-th constraint. |
boolean |
IntDomainVarTimePosCste.removeVal(int x,
int idx)
|
boolean |
IntDomainVarImpl.removeVal(int x,
int idx)
Deprecated. |
boolean |
IntDomainVarAddCste.removeVal(int x,
int idx)
|
boolean |
BoolVarNot.removeVal(int x,
int idx)
|
boolean |
ViewIntDomainVarImpl.removeVal(int x,
SConstraint cause,
boolean forceAwake)
Internal var: update (value removal) on the domain of a variable caused by its i-th constraint. |
boolean |
IntDomainVarTimePosCste.removeVal(int x,
SConstraint cause,
boolean forceAwake)
|
boolean |
IntDomainVarImpl.removeVal(int x,
SConstraint cause,
boolean forceAwake)
Internal var: update (value removal) on the domain of a variable caused by its i-th constraint. |
boolean |
IntDomainVarAddCste.removeVal(int x,
SConstraint cause,
boolean forceAwake)
|
boolean |
BooleanVarImpl.removeVal(int x,
SConstraint cause,
boolean forceAwake)
Internal var: update (value removal) on the domain of a variable caused by its i-th constraint. |
boolean |
BooleanDomain.removeVal(int x,
SConstraint cause,
boolean forceAwake)
Internal var: update (value removal) on the domain of a variable caused by its i-th constraint. |
boolean |
BoolVarNot.removeVal(int x,
SConstraint cause,
boolean forceAwake)
|
boolean |
AbstractIntDomain.removeVal(int x,
SConstraint cause,
boolean forceAwake)
Internal var: update (value removal) on the domain of a variable caused by its i-th constraint. |
void |
IntDomainVarTimePosCste.remVal(int x)
|
void |
IntDomainVarImpl.remVal(int x)
Removes a value. |
void |
IntDomainVarAddCste.remVal(int x)
|
void |
BoolVarNot.remVal(int x)
|
void |
IntDomainVarTimePosCste.setInf(int x)
|
void |
IntDomainVarImpl.setInf(int x)
Sets the minimum value. |
void |
IntDomainVarAddCste.setInf(int x)
|
void |
BoolVarNot.setInf(int x)
|
void |
IntDomainVarTimePosCste.setMax(int x)
Deprecated. |
void |
IntDomainVarImpl.setMax(int x)
Deprecated. replaced by setSup |
void |
IntDomainVarAddCste.setMax(int x)
Deprecated. |
void |
BoolVarNot.setMax(int x)
|
void |
IntDomainVarTimePosCste.setMin(int x)
Deprecated. |
void |
IntDomainVarImpl.setMin(int x)
Deprecated. replaced by setInf |
void |
IntDomainVarAddCste.setMin(int x)
Deprecated. |
void |
BoolVarNot.setMin(int x)
|
void |
IntDomainVarTimePosCste.setSup(int x)
|
void |
IntDomainVarImpl.setSup(int x)
Sets the maximal value. |
void |
IntDomainVarAddCste.setSup(int x)
|
void |
BoolVarNot.setSup(int x)
|
void |
IntDomainVarTimePosCste.setVal(int x)
|
void |
IntDomainVarImpl.setVal(int x)
Instantiates the variable. |
void |
IntDomainVarAddCste.setVal(int x)
|
void |
BoolVarNot.setVal(int x)
|
boolean |
IntDomainVarTimePosCste.updateInf(int x,
int idx)
|
boolean |
IntDomainVarImpl.updateInf(int x,
int idx)
Deprecated. |
boolean |
IntDomainVarAddCste.updateInf(int x,
int idx)
|
boolean |
BoolVarNot.updateInf(int x,
int idx)
|
boolean |
ViewIntDomainVarImpl.updateInf(int x,
SConstraint cause,
boolean forceAwake)
Internal var: update on the variable lower bound caused by its i-th constraint. |
boolean |
IntDomainVarTimePosCste.updateInf(int x,
SConstraint cause,
boolean forceAwake)
|
boolean |
IntDomainVarImpl.updateInf(int x,
SConstraint cause,
boolean forceAwake)
Internal var: update on the variable lower bound caused by its i-th constraint. |
boolean |
IntDomainVarAddCste.updateInf(int x,
SConstraint cause,
boolean forceAwake)
|
boolean |
BooleanVarImpl.updateInf(int x,
SConstraint cause,
boolean forceAwake)
Internal var: update on the variable lower bound caused by its i-th constraint. |
boolean |
BooleanDomain.updateInf(int x,
SConstraint cause,
boolean forceAwake)
Internal var: update on the variable lower bound caused by its i-th constraint. |
boolean |
BoolVarNot.updateInf(int x,
SConstraint cause,
boolean forceAwake)
|
boolean |
AbstractIntDomain.updateInf(int x,
SConstraint cause,
boolean forceAwake)
Internal var: update on the variable lower bound caused by its i-th constraint. |
boolean |
IntDomainVarTimePosCste.updateSup(int x,
int idx)
|
boolean |
IntDomainVarImpl.updateSup(int x,
int idx)
Deprecated. |
boolean |
IntDomainVarAddCste.updateSup(int x,
int idx)
|
boolean |
BoolVarNot.updateSup(int x,
int idx)
|
boolean |
ViewIntDomainVarImpl.updateSup(int x,
SConstraint cause,
boolean forceAwake)
Internal var: update on the variable upper bound caused by its i-th constraint. |
boolean |
IntDomainVarTimePosCste.updateSup(int x,
SConstraint cause,
boolean forceAwake)
|
boolean |
IntDomainVarImpl.updateSup(int x,
SConstraint cause,
boolean forceAwake)
Internal var: update on the variable upper bound caused by its i-th constraint. |
boolean |
IntDomainVarAddCste.updateSup(int x,
SConstraint cause,
boolean forceAwake)
|
boolean |
BooleanVarImpl.updateSup(int x,
SConstraint cause,
boolean forceAwake)
Internal var: update on the variable upper bound caused by its i-th constraint. |
boolean |
BooleanDomain.updateSup(int x,
SConstraint cause,
boolean forceAwake)
Internal var: update on the variable upper bound caused by its i-th constraint. |
boolean |
BoolVarNot.updateSup(int x,
SConstraint cause,
boolean forceAwake)
|
boolean |
AbstractIntDomain.updateSup(int x,
SConstraint cause,
boolean forceAwake)
Internal var: update on the variable upper bound caused by its i-th constraint. |
void |
IntDomainVarImpl.wipeOut()
|
void |
AbstractBijectiveVar.wipeOut()
|
Uses of ContradictionException in choco.cp.solver.variables.real |
---|
Methods in choco.cp.solver.variables.real that throw ContradictionException | |
---|---|
void |
RealVarImpl.intersect(RealInterval interval)
|
void |
RealDomainImpl.intersect(RealInterval interval)
|
boolean |
RealVarEvent.propagateEvent()
|
void |
RealVarEvent.propagateInfEvent(C evtCause)
Propagates the update to the lower bound |
void |
RealVarEvent.propagateSupEvent(C evtCause)
Propagates the update to the upper bound |
Uses of ContradictionException in choco.cp.solver.variables.set |
---|
Methods in choco.cp.solver.variables.set that throw ContradictionException | |
---|---|
boolean |
SetVarImpl.addToKernel(int x,
int idx)
Deprecated. |
boolean |
SetVarImpl.addToKernel(int x,
SConstraint cause,
boolean forceAwake)
|
boolean |
SetDomainImpl.addToKernel(int x,
SConstraint cause,
boolean forceAwake)
|
boolean |
SetVarImpl.instantiate(int[] x,
int idx)
Deprecated. |
boolean |
SetVarImpl.instantiate(int[] x,
SConstraint cause,
boolean forceAwake)
|
boolean |
SetDomainImpl.instantiate(int[] x,
SConstraint cause,
boolean forceAwake)
|
void |
SetVarEvent.propagateEnveloppeEvents(C evtCause)
Propagates a set of value removals |
boolean |
SetVarEvent.propagateEvent()
Propagates the event through calls to the propagation engine. |
void |
SetVarEvent.propagateInstEvent(C evtCause)
Propagates the instantiation event |
void |
SetVarEvent.propagateKernelEvents(C evtCause)
Propagates a set of value removals |
boolean |
SetVarImpl.remFromEnveloppe(int x,
int idx)
Deprecated. |
boolean |
SetVarImpl.remFromEnveloppe(int x,
SConstraint cause,
boolean forceAwake)
|
boolean |
SetDomainImpl.remFromEnveloppe(int x,
SConstraint cause,
boolean forceAwake)
|
void |
SetVarImpl.setVal(int[] val)
|
void |
SetVarImpl.setValIn(int x)
|
void |
SetVarImpl.setValOut(int x)
|
Uses of ContradictionException in choco.kernel.solver |
---|
Methods in choco.kernel.solver that return ContradictionException | |
---|---|
static ContradictionException |
ContradictionException.build()
Builder of contradiction. |
Methods in choco.kernel.solver that throw ContradictionException | |
---|---|
void |
Solver.propagate()
Propagation: Computes consistency on the model (the model may no longer be consistent since the last propagation because of listeners that have been posted and variables that have been reduced |
Uses of ContradictionException in choco.kernel.solver.branch |
---|
Methods in choco.kernel.solver.branch that throw ContradictionException | |
---|---|
void |
IntBranching.goDownBranch(IntBranchingDecision decision)
Performs the action, so that we go down a branch from the current choice point. |
void |
BranchingWithLoggingStatements.goDownBranch(IntBranchingDecision decision)
|
void |
AbstractIntBranching.goDownBranch(IntBranchingDecision decision)
Deprecated. Performs the action, so that we go down a branch from the current choice point. |
abstract void |
AbstractIntBranching.goDownBranch(Object x,
int i)
Deprecated. Performs the action, so that we go down a branch from the current choice point. |
void |
IntBranching.goUpBranch(IntBranchingDecision decision)
Performs the action, so that we go up the current branch to the father choice point. |
void |
BranchingWithLoggingStatements.goUpBranch(IntBranchingDecision decision)
|
void |
AbstractIntBranching.goUpBranch(IntBranchingDecision decision)
Deprecated. Performs the action, so that we go up the current branch to the father choice point. |
void |
AbstractBinIntBranchingStrategy.goUpBranch(IntBranchingDecision decision)
nothing to do |
abstract void |
AbstractIntBranching.goUpBranch(Object x,
int i)
Deprecated. Performs the action, so that we go up the current branch to the father choice point. |
Object |
BranchingWithLoggingStatements.selectBranchingObject()
|
Object |
BranchingStrategy.selectBranchingObject()
selecting the object under scrutiny (that object on which an alternative will be set) |
abstract Object |
AbstractIntBranching.selectBranchingObject()
Deprecated. selecting the object under scrutiny (that object on which an alternative will be set) |
Uses of ContradictionException in choco.kernel.solver.constraints |
---|
Methods in choco.kernel.solver.constraints that throw ContradictionException | |
---|---|
void |
ConstantSConstraint.propagate()
|
Uses of ContradictionException in choco.kernel.solver.constraints.global.automata.fast_costregular.structure |
---|
Methods in choco.kernel.solver.constraints.global.automata.fast_costregular.structure that throw ContradictionException | |
---|---|
void |
StoredValuedDirectedMultiGraph.removeArc(int arcId,
gnu.trove.TIntStack toRemove)
|
Uses of ContradictionException in choco.kernel.solver.constraints.global.automata.fast_multicostregular.algo |
---|
Methods in choco.kernel.solver.constraints.global.automata.fast_multicostregular.algo that throw ContradictionException | |
---|---|
void |
SoftPathFinder.computeLongestPath(gnu.trove.TIntStack removed,
double lb,
double[] u)
|
void |
FastPathFinder.computeLongestPath(gnu.trove.TIntStack removed,
double lb,
double[] u,
boolean lagrange,
boolean max,
int resource)
|
void |
FastPathFinder.computeShortestAndLongestPath(IStateIntVector removed,
int lb,
int ub,
double[] u,
boolean lagrange,
boolean max,
int resource)
|
boolean[] |
FastPathFinder.computeShortestAndLongestPath(gnu.trove.TIntStack removed,
IntDomainVar[] z)
|
boolean[] |
SoftPathFinder.computeShortestAndLongestPath(gnu.trove.TIntStack removed,
IntDomainVar[] y,
AbstractIntSConstraint[] tables)
|
void |
SoftPathFinder.computeShortestPath(gnu.trove.TIntStack removed,
double ub,
double[] u)
|
void |
FastPathFinder.computeShortestPath(gnu.trove.TIntStack removed,
double ub,
double[] u,
boolean lagrange,
boolean max,
int resource)
|
Uses of ContradictionException in choco.kernel.solver.constraints.global.automata.fast_multicostregular.structure |
---|
Methods in choco.kernel.solver.constraints.global.automata.fast_multicostregular.structure that throw ContradictionException | |
---|---|
boolean |
StoredDirectedMultiGraph.removeArc(int arcId,
gnu.trove.TIntStack toRemove,
gnu.trove.TIntStack[] updateLeft,
gnu.trove.TIntStack[] updateRight)
|
boolean |
SoftStoredMultiValuedDirectedMultiGraph.removeArc(int arcId,
gnu.trove.TIntStack toRemove,
gnu.trove.TIntStack[] updateLeft,
gnu.trove.TIntStack[] updateRight)
|
boolean |
SoftStoredMultiValuedDirectedMultiGraph.updateLeft(gnu.trove.TIntStack updateLeft,
gnu.trove.TIntStack toRemove,
int dim,
AbstractIntSConstraint table)
|
void |
StoredDirectedMultiGraph.updateLeft(gnu.trove.TIntStack updateLeft,
gnu.trove.TIntStack toRemove,
int dim,
boolean[] modBound)
|
boolean |
SoftStoredMultiValuedDirectedMultiGraph.updateRight(gnu.trove.TIntStack updateRight,
gnu.trove.TIntStack toRemove,
int dim,
AbstractIntSConstraint table)
|
void |
StoredDirectedMultiGraph.updateRight(gnu.trove.TIntStack updateRight,
gnu.trove.TIntStack toRemove,
int dim,
boolean[] modBound)
|
Uses of ContradictionException in choco.kernel.solver.constraints.global.automata.fast_regular.structure |
---|
Methods in choco.kernel.solver.constraints.global.automata.fast_regular.structure that throw ContradictionException | |
---|---|
void |
StoredDirectedMultiGraph.removeArc(int arcId)
|
Uses of ContradictionException in choco.kernel.solver.constraints.global.matching |
---|
Methods in choco.kernel.solver.constraints.global.matching that throw ContradictionException | |
---|---|
void |
AbstractBipartiteGraph.augmentFlow()
keeps augmenting the flow until a maximal flow is reached |
abstract void |
AbstractBipartiteGraph.deleteEdgeAndPublish(int i,
int j)
two methods used for detecting that an edge should be removed from the bipartite assignment graph deleteMatch -> removes it from the graph data strutures deleteEdgeAndPublish -> same + publishes the information outside the constraint |
void |
AbstractBipartiteGraph.propagate()
Achieves generalized arc consistency in one call |
protected void |
AbstractBipartiteGraph.removeUselessEdges()
remove arcs connecting two different strongly connected components the event generated by the flow algorithm: discovering that an edge is no longer valid, and posting this event to the constraint strategy: since we are already achieving GAC consistency in one single loop, there is no need to post a constAwake |
protected void |
AbstractBipartiteFlow.removeUselessEdges()
|
Uses of ContradictionException in choco.kernel.solver.constraints.global.scheduling |
---|
Methods in choco.kernel.solver.constraints.global.scheduling that throw ContradictionException | |
---|---|
void |
AbstractTaskSConstraint.awakeOnHypDomMod(int varIdx)
|
void |
AbstractTaskSConstraint.awakeOnRem(int varIdx,
int val)
|
void |
AbstractTaskSConstraint.awakeOnRemovals(int idx,
DisposableIntIterator deltaDomain)
|
Uses of ContradictionException in choco.kernel.solver.constraints.integer |
---|
Methods in choco.kernel.solver.constraints.integer that throw ContradictionException | |
---|---|
void |
AbstractIntSConstraint.awakeOnBounds(int varIndex)
|
void |
AbstractIntSConstraint.awakeOnInf(int varIdx)
Default propagation on improved lower bound: propagation on domain revision. |
void |
AbstractIntSConstraint.awakeOnInst(int idx)
Default propagation on instantiation: full constraint re-propagation. |
void |
AbstractIntSConstraint.awakeOnRem(int varIdx,
int val)
Default propagation on one value removal: propagation on domain revision. |
void |
AbstractIntSConstraint.awakeOnRemovals(int idx,
DisposableIntIterator deltaDomain)
The default implementation of propagation when a variable has been modified consists in iterating all values that have been removed (the delta domain) and propagate them one after another, incrementally. |
void |
AbstractIntSConstraint.awakeOnSup(int varIdx)
Default propagation on improved upper bound: propagation on domain revision. |
Uses of ContradictionException in choco.kernel.solver.constraints.real |
---|
Methods in choco.kernel.solver.constraints.real that throw ContradictionException | |
---|---|
void |
AbstractRealSConstraint.awakeOnInf(int idx)
Default propagation on improved lower bound: propagation on domain revision. |
void |
AbstractRealSConstraint.awakeOnSup(int idx)
Default propagation on improved upper bound: propagation on domain revision. |
void |
RealExp.project()
Projects computed bounds to the sub expressions. |
Uses of ContradictionException in choco.kernel.solver.constraints.real.exp |
---|
Methods in choco.kernel.solver.constraints.real.exp that throw ContradictionException | |
---|---|
void |
AbstractRealCompoundTerm.intersect(RealInterval interval)
|
Uses of ContradictionException in choco.kernel.solver.constraints.set |
---|
Methods in choco.kernel.solver.constraints.set that throw ContradictionException | |
---|---|
void |
AbstractMixedSetIntSConstraint.awakeOnBounds(int varIndex)
|
void |
AbstractSetSConstraint.awakeOnEnv(int varIdx,
int x)
|
void |
AbstractMixedSetIntSConstraint.awakeOnEnv(int varIdx,
int x)
|
void |
AbstractSetSConstraint.awakeOnEnvRemovals(int idx,
DisposableIntIterator deltaDomain)
|
void |
AbstractMixedSetIntSConstraint.awakeOnEnvRemovals(int idx,
DisposableIntIterator deltaDomain)
|
void |
AbstractMixedSetIntSConstraint.awakeOnInf(int varIdx)
Default propagation on improved lower bound: propagation on domain revision. |
void |
AbstractSetSConstraint.awakeOnInst(int varIdx)
|
void |
AbstractMixedSetIntSConstraint.awakeOnInst(int varIdx)
|
void |
AbstractSetSConstraint.awakeOnKer(int varIdx,
int x)
|
void |
AbstractMixedSetIntSConstraint.awakeOnKer(int varIdx,
int x)
|
void |
AbstractSetSConstraint.awakeOnkerAdditions(int idx,
DisposableIntIterator deltaDomain)
|
void |
AbstractMixedSetIntSConstraint.awakeOnkerAdditions(int idx,
DisposableIntIterator deltaDomain)
|
void |
AbstractMixedSetIntSConstraint.awakeOnRem(int varIdx,
int val)
Default propagation on one value removal: propagation on domain revision. |
void |
AbstractMixedSetIntSConstraint.awakeOnRemovals(int idx,
DisposableIntIterator deltaDomain)
The default implementation of propagation when a variable has been modified consists in iterating all values that have been removed (the delta domain) and propagate them one after another, incrementally. |
void |
AbstractMixedSetIntSConstraint.awakeOnSup(int varIdx)
Default propagation on improved upper bound: propagation on domain revision. |
Uses of ContradictionException in choco.kernel.solver.goals |
---|
Methods in choco.kernel.solver.goals that throw ContradictionException | |
---|---|
Goal |
Goal.execute(Solver solver)
|
Uses of ContradictionException in choco.kernel.solver.goals.choice |
---|
Methods in choco.kernel.solver.goals.choice that throw ContradictionException | |
---|---|
Goal |
SetVal.execute(Solver s)
|
Goal |
RemoveVal.execute(Solver s)
|
Uses of ContradictionException in choco.kernel.solver.goals.solver |
---|
Methods in choco.kernel.solver.goals.solver that throw ContradictionException | |
---|---|
Goal |
ChoicePoint.execute(Solver solver)
|
Uses of ContradictionException in choco.kernel.solver.propagation |
---|
Methods in choco.kernel.solver.propagation that throw ContradictionException | |
---|---|
void |
Propagator.awake()
Propagation: Propagating the constraint for the very first time until local consistency is reached. |
void |
ShavingTools.destructiveLowerBound(IObjectiveManager objM)
|
void |
Propagator.fail()
raise a contradiction during propagation when the constraint can definitely not be satisfied given the current domains |
abstract void |
Propagator.propagate()
Propagation: Propagating the constraint until local consistency is reached. |
void |
PropagationEngine.propagateEvents()
Propagate one by one events registered |
void |
PropagationEngine.raiseContradiction(int cidx,
Var variable,
SConstraint cause)
Deprecated. |
void |
PropagationEngine.raiseContradiction(Object cause)
Raising a contradiction with a cause. |
void |
PropagationEngine.raiseContradiction(Object cause,
int move)
Raising a contradiction with a cause and a movement |
protected void |
ShavingTools.shaveBoundVar(IntDomainVar var)
|
protected void |
ShavingTools.shaveEnumVar(IntDomainVar var)
|
protected boolean |
ShavingTools.shaveObjective(IObjectiveManager objM)
|
protected void |
ShavingTools.shaveVars()
|
void |
ShavingTools.shaving()
|
protected void |
ShavingTools.shaving(IntDomainVar var,
int val)
|
Uses of ContradictionException in choco.kernel.solver.propagation.event |
---|
Methods in choco.kernel.solver.propagation.event that throw ContradictionException | |
---|---|
abstract boolean |
VarEvent.propagateEvent()
Propagates the event through calls to the propagation engine. |
boolean |
TaskVarEvent.propagateEvent()
Propagates the event through calls to the propagation engine. |
boolean |
PropagationEvent.propagateEvent()
Propagates the var through calls to the propagation engine. |
boolean |
ConstraintEvent.propagateEvent()
Propagates the var: awake or propagate depending on the init status. |
void |
TaskVarEvent.propagateHypDomModEvent(C evtCause)
Propagates the instantiation event |
Uses of ContradictionException in choco.kernel.solver.propagation.listener |
---|
Methods in choco.kernel.solver.propagation.listener with parameters of type ContradictionException | |
---|---|
void |
PropagationEngineListener.contradictionOccured(ContradictionException e)
|
Methods in choco.kernel.solver.propagation.listener that throw ContradictionException | |
---|---|
void |
IntPropagator.awakeOnBounds(int varIdx)
|
void |
SetPropagator.awakeOnEnv(int varIdx,
int x)
Default propagation on enveloppe modification: propagation on removing a value from the enveloppe. |
void |
SetPropagator.awakeOnEnvRemovals(int varIdx,
DisposableIntIterator deltaDomain)
BEWARE: No need to dipose the iterator, this done in the calling methode |
void |
TaskPropagator.awakeOnHypDomMod(int varIdx)
Default propagation on improved hypothetical domain: propagation on domain revision. |
void |
RealPropagator.awakeOnInf(int idx)
Default propagation on improved lower bound: propagation on domain revision. |
void |
IntPropagator.awakeOnInf(int varIdx)
Default propagation on improved lower bound: propagation on domain revision. |
void |
SetPropagator.awakeOnInst(int varIdx)
Default propagation on instantiation. |
void |
IntPropagator.awakeOnInst(int varIdx)
Default propagation on instantiation: full constraint re-propagation. |
void |
SetPropagator.awakeOnKer(int varIdx,
int x)
Default propagation on kernel modification: propagation on adding a value to the kernel. |
void |
SetPropagator.awakeOnkerAdditions(int varIdx,
DisposableIntIterator deltaDomain)
BEWARE: No need to dipose the iterator, this done in the calling methode |
void |
IntPropagator.awakeOnRem(int varIdx,
int val)
Default propagation on one value removal: propagation on domain revision. |
void |
IntPropagator.awakeOnRemovals(int varIdx,
DisposableIntIterator deltaDomain)
|
void |
RealPropagator.awakeOnSup(int idx)
Default propagation on improved upper bound: propagation on domain revision. |
void |
IntPropagator.awakeOnSup(int varIdx)
Default propagation on improved upper bound: propagation on domain revision. |
Uses of ContradictionException in choco.kernel.solver.propagation.queue |
---|
Methods in choco.kernel.solver.propagation.queue that throw ContradictionException | |
---|---|
void |
EventQueue.propagateAllEvents()
Propagate some events (one or several depending on the queue). |
void |
EventQueue.propagateOneEvent()
Propagate one single event from the queue). |
Uses of ContradictionException in choco.kernel.solver.search |
---|
Methods in choco.kernel.solver.search that throw ContradictionException | |
---|---|
protected void |
AbstractOptimize.advancedInitialPropagation()
|
protected void |
AbstractGlobalSearchStrategy.advancedInitialPropagation()
|
void |
GlobalSearchLimitManager.endNode()
notify the limit object whenever the search closes a node in the search tree |
void |
GlobalSearchLimitManager.newNode()
notify the limit object whenever a new node is created in the search tree |
void |
AbstractGlobalSearchStrategy.newTreeSearch()
called before a new search tree is explored |
void |
AbstractOptimize.postDynamicCut()
we use targetBound data structures for the optimization cuts |
void |
AbstractGlobalSearchStrategy.postDynamicCut()
called before going down into each branch of the choice point |
void |
IObjectiveManager.postFloorBound()
propagating the optimization cuts from the new floor bounds |
void |
IObjectiveManager.postIncFloorBound()
|
void |
IObjectiveManager.postTargetBound()
propagating the optimization cuts from the new target bounds |
void |
IntBranchingTrace.remIntVal()
|
void |
IntBranchingDecision.remIntVal()
apply the integer removal decision, i.e. remove the branching value from the domain of the branching int var. |
void |
IntBranchingTrace.setIntVal()
|
void |
IntBranchingDecision.setIntVal()
apply the integer assignment decision, i.e. assign the branching value to the branching int var. |
void |
IntBranchingTrace.setValInSet()
|
void |
IntBranchingDecision.setValInSet()
apply the set assignment decision, i.e. put the value into the kernel. |
void |
IntBranchingTrace.setValOutSet()
|
void |
IntBranchingDecision.setValOutSet()
apply the set removal decision, i.e. remove the value from the enveloppe. |
Uses of ContradictionException in choco.kernel.solver.search.integer |
---|
Methods in choco.kernel.solver.search.integer that throw ContradictionException | |
---|---|
IntVarValPair |
VarValPairSelector.selectVarValPair()
|
Uses of ContradictionException in choco.kernel.solver.search.measure |
---|
Methods in choco.kernel.solver.search.measure with parameters of type ContradictionException | |
---|---|
void |
FailMeasure.contradictionOccured(ContradictionException e)
|
Uses of ContradictionException in choco.kernel.solver.search.set |
---|
Methods in choco.kernel.solver.search.set that throw ContradictionException | |
---|---|
void |
AbstractSetBranchingStrategy.goDownBranch(IntBranchingDecision decision)
|
Uses of ContradictionException in choco.kernel.solver.variables.integer |
---|
Methods in choco.kernel.solver.variables.integer that throw ContradictionException | |
---|---|
boolean |
IntDomainVar.instantiate(int x,
int idx)
Deprecated. |
boolean |
IntDomainVar.instantiate(int x,
SConstraint cause,
boolean forceAwake)
Propagation events instantiating a variable (ie: removing all other values from the domain) |
boolean |
IntDomainVar.removeInterval(int a,
int b,
int idx)
Deprecated. |
boolean |
IntDomainVar.removeInterval(int a,
int b,
SConstraint cause,
boolean forceAwake)
Propagation events updating the domain of a variable (by removing an interval, ie, a sequence of consecutive values) |
boolean |
IntDomainVar.removeVal(int x,
int idx)
Deprecated. |
boolean |
IntDomainVar.removeVal(int x,
SConstraint cause,
boolean forceAwake)
Propagation events updating the domain of a variable (by removing a value) |
void |
IntDomainVar.remVal(int x)
Public user API: Propagation events removing a value from the domain of a variable. |
void |
IntDomainVar.setInf(int x)
Public user API: Propagation events updating the lower bound of a variable (ie: removing all value strictly below the new lower bound from the domain). |
void |
IntDomainVar.setMax(int x)
Deprecated. replaced by setMax |
void |
IntDomainVar.setMin(int x)
Deprecated. replaced by setInf |
void |
IntDomainVar.setSup(int x)
Public user API: Propagation events updating the upper bound of a variable (ie: removing all value strictly above the new upper bound from the domain). |
void |
IntVar.setVal(int x)
Public user API: Propagation events assigning a value to a variable (ie: removing all other values from its domain). |
boolean |
IntDomainVar.updateInf(int x,
int idx)
Deprecated. |
boolean |
IntDomainVar.updateInf(int x,
SConstraint cause,
boolean forceAwake)
Propagation events updating the lower bound of a variable (ie: removing all value strictly below the new lower bound from the domain). |
boolean |
IntDomainVar.updateSup(int x,
int idx)
Deprecated. |
boolean |
IntDomainVar.updateSup(int x,
SConstraint cause,
boolean forceAwake)
Propagation events updating the upper bound of a variable (ie: removing all value strictly above the new upper bound from the domain). |
void |
IntDomainVar.wipeOut()
Public user API: Propagation events wiping out the domain of the variable (removing all values) and throwing a contradiction |
Uses of ContradictionException in choco.kernel.solver.variables.real |
---|
Methods in choco.kernel.solver.variables.real that throw ContradictionException | |
---|---|
void |
RealIntervalConstant.intersect(RealInterval interval)
|
void |
RealInterval.intersect(RealInterval interval)
Modifies the bounds for intersecting with the specified interval. |
Uses of ContradictionException in choco.kernel.solver.variables.scheduling |
---|
Methods in choco.kernel.solver.variables.scheduling that throw ContradictionException | |
---|---|
void |
IRTask.checkConsistency()
|
void |
IRTask.fail()
|
boolean |
IRTask.setDuration(int duration)
|
boolean |
IRTask.setECT(int val)
Update the Earliest Completion Time (ECT). |
boolean |
IRTask.setEndingTime(int endingTime)
|
boolean |
IRTask.setEndNotIn(int a,
int b)
The task can not end in the interval [a,b]. |
boolean |
IRTask.setEST(int val)
Update the Earliest Starting Time (EST). |
boolean |
IRTask.setLCT(int val)
Update the Latest Completion Time (LCT). |
boolean |
IRTask.setLST(int val)
Update the Latest Starting Time (LST). |
boolean |
IRTask.setMaxDuration(int val)
|
boolean |
IRTask.setMinDuration(int val)
|
boolean |
IRTask.setStartingTime(int startingTime)
|
boolean |
IRTask.setStartNotIn(int a,
int b)
The task can not start in the interval [a,b]. |
void |
IRTask.updateCompulsoryPart()
|
void |
TaskVar.updateCompulsoryPart(SConstraint cause)
|
boolean |
IRTask.updateDuration(int duration)
|
boolean |
IRTask.updateECT()
Update using IRTask.getStoredValue() . |
boolean |
AbstractRTask.updateECT()
|
boolean |
IRTask.updateECT(int val)
Update the Earliest Completion Time (ECT). |
boolean |
IRTask.updateEndingTime(int endingTime)
|
boolean |
IRTask.updateEndNotIn(int a,
int b)
The task can not end in the interval [a,b]. |
boolean |
IRTask.updateEST()
Update using IRTask.getStoredValue() . |
boolean |
AbstractRTask.updateEST()
|
boolean |
IRTask.updateEST(int val)
Update the Earliest Starting Time (EST). |
void |
IRMakespan.updateInf(int value)
|
boolean |
IRTask.updateLCT()
Update using IRTask.getStoredValue() . |
boolean |
AbstractRTask.updateLCT()
|
boolean |
IRTask.updateLCT(int val)
Update the Latest Completion Time (LCT). |
boolean |
IRTask.updateLST()
Update using IRTask.getStoredValue() . |
boolean |
AbstractRTask.updateLST()
|
boolean |
IRTask.updateLST(int val)
Update the Latest Starting Time (LST). |
boolean |
IRTask.updateMaxDuration(int val)
|
boolean |
IRTask.updateMinDuration(int val)
|
boolean |
IRTask.updateStartingTime(int startingTime)
|
boolean |
IRTask.updateStartNotIn(int a,
int b)
The task can not start in the interval [a,b]. |
void |
IRMakespan.updateSup(int value)
|
Uses of ContradictionException in choco.kernel.solver.variables.set |
---|
Methods in choco.kernel.solver.variables.set that throw ContradictionException | |
---|---|
boolean |
SetVar.addToKernel(int x,
int idx)
Deprecated. |
boolean |
SetVar.addToKernel(int x,
SConstraint cause,
boolean forceAwake)
Propagation events updating the kernel of a variable (i.e adding a value) |
boolean |
SetDomain.addToKernel(int x,
SConstraint cause,
boolean forceAwake)
|
boolean |
SetVar.instantiate(int[] x,
int idx)
Deprecated. |
boolean |
SetVar.instantiate(int[] x,
SConstraint cause,
boolean forceAwake)
Propagation events instantiated a set var to a specific set of values |
boolean |
SetDomain.instantiate(int[] x,
SConstraint cause,
boolean forceAwake)
|
boolean |
SetVar.remFromEnveloppe(int x,
int idx)
Deprecated. |
boolean |
SetVar.remFromEnveloppe(int x,
SConstraint cause,
boolean forceAwake)
Propagation events updating the enveloppe of a variable (i.e removing a value) |
boolean |
SetDomain.remFromEnveloppe(int x,
SConstraint cause,
boolean forceAwake)
|
void |
SetVar.setVal(int[] val)
set the value of the variable to the set val. |
void |
SetVar.setValIn(int x)
Public user API: setting a value to the kernel of a set variable |
void |
SetVar.setValOut(int x)
Public user API: removing a value from the Enveloppe of a set variable. |
Uses of ContradictionException in samples.jobshop |
---|
Methods in samples.jobshop that throw ContradictionException | |
---|---|
void |
SimpleDTConstraint.awakeOnBounds(int varIdx)
|
void |
SimpleDTConstraint.awakeOnInf(int varIdx)
|
void |
SimpleDTConstraint.awakeOnInst(int idx)
|
void |
SimpleDTConstraint.awakeOnRem(int idx,
int x)
|
void |
SimpleDTConstraint.awakeOnSup(int varIdx)
|
void |
SimpleDTConstraint.propagate()
|
Uses of ContradictionException in samples.multicostregular.nsp |
---|
Methods in samples.multicostregular.nsp that throw ContradictionException | |
---|---|
void |
NSPStruct.awake()
|
void |
NSPStruct.awakeOnInst(int idx)
|
void |
NSPBranching.goDownBranch(IntBranchingDecision decision)
|
void |
NSPBranching.goUpBranch(IntBranchingDecision decision)
|
Object |
NSPBranching.selectBranchingObject()
|
Uses of ContradictionException in samples.multicostregular.planner |
---|
Methods in samples.multicostregular.planner that throw ContradictionException | |
---|---|
void |
SubSetChannelling.awake()
|
void |
SimpleChannelling.awake()
|
void |
SubSetChannelling.awakeOnInf(int idx)
|
void |
SimpleChannelling.awakeOnInf(int idx)
|
void |
SubSetChannelling.awakeOnInst(int idx)
|
void |
SimpleChannelling.awakeOnInst(int idx)
|
void |
SubSetChannelling.awakeOnRem(int idx,
int val)
|
void |
SimpleChannelling.awakeOnRem(int idx,
int val)
|
void |
SubSetChannelling.awakeOnSup(int idx)
|
void |
SimpleChannelling.awakeOnSup(int idx)
|
void |
SubSetChannelling.propagate()
|
void |
SimpleChannelling.propagate()
|
Uses of ContradictionException in samples.tutorials.lns.lns |
---|
Methods in samples.tutorials.lns.lns that throw ContradictionException | |
---|---|
void |
AbstractLNSSolver.propagate()
Deprecated. |
Uses of ContradictionException in samples.tutorials.to_sort.socialgolfer |
---|
Methods in samples.tutorials.to_sort.socialgolfer that throw ContradictionException | |
---|---|
void |
ScalarAtMost.awake()
|
void |
ScalarAtMost.awakeOnInst(int idx)
|
void |
ScalarAtMost.filter()
|
void |
ScalarAtMost.propagate()
|
void |
ScalarAtMost.propagateDiff(int i)
|
void |
ScalarAtMost.propagateEq(int i)
|
Uses of ContradictionException in samples.tutorials.to_sort.tsp |
---|
Methods in samples.tutorials.to_sort.tsp that throw ContradictionException | |
---|---|
void |
SubTourConstraint.awake()
|
void |
MinSpanningTree.awake()
|
void |
SubTourConstraint.awakeOnBounds(int u)
|
void |
MinSpanningTree.awakeOnBounds(int u)
|
void |
SubTourConstraint.awakeOnInf(int u)
|
void |
MinSpanningTree.awakeOnInf(int u)
|
void |
SubTourConstraint.awakeOnInst(int u)
|
void |
MinSpanningTree.awakeOnInst(int u)
|
void |
SubTourConstraint.awakeOnRem(int u,
int v)
|
void |
MinSpanningTree.awakeOnRem(int u,
int v)
|
void |
SubTourConstraint.awakeOnRemovals(int u,
DisposableIntIterator deltaDomain)
|
void |
MinSpanningTree.awakeOnRemovals(int u,
DisposableIntIterator deltaDomain)
|
void |
SubTourConstraint.awakeOnSup(int u)
|
void |
MinSpanningTree.awakeOnSup(int u)
|
void |
SubTourConstraint.propagate()
|
void |
MinSpanningTree.propagate()
|
|
||||||||||
PREV NEXT | FRAMES NO FRAMES |