Uses of Class
choco.kernel.solver.ContradictionException

Packages that use ContradictionException
choco.cp.solver   
choco.cp.solver.constraints.global   
choco.cp.solver.constraints.global.automata.fast_costregular   
choco.cp.solver.constraints.global.automata.fast_multicostregular   
choco.cp.solver.constraints.global.automata.fast_regular   
choco.cp.solver.constraints.global.geost.internalConstraints   
choco.cp.solver.constraints.global.geost.layers   
choco.cp.solver.constraints.global.lightcostregular.structure   
choco.cp.solver.constraints.global.matching   
choco.cp.solver.constraints.global.ordered   
choco.cp.solver.constraints.global.pack   
choco.cp.solver.constraints.global.regular   
choco.cp.solver.constraints.global.scheduling   
choco.cp.solver.constraints.global.scheduling.cumulative   
choco.cp.solver.constraints.global.scheduling.disjunctive   
choco.cp.solver.constraints.global.scheduling.precedence   
choco.cp.solver.constraints.global.softscheduling   
choco.cp.solver.constraints.global.tree   
choco.cp.solver.constraints.global.tree.filtering   
choco.cp.solver.constraints.global.tree.filtering.costFiltering   
choco.cp.solver.constraints.global.tree.filtering.structuralFiltering   
choco.cp.solver.constraints.global.tree.filtering.structuralFiltering.globalCardConstraint   
choco.cp.solver.constraints.global.tree.filtering.structuralFiltering.precedences   
choco.cp.solver.constraints.global.tree.filtering.structuralFiltering.timeWindows   
choco.cp.solver.constraints.global.tree.filtering.structuralFiltering.tree   
choco.cp.solver.constraints.global.tree.structure.inputStructure   
choco.cp.solver.constraints.global.tree.structure.internalStructure   
choco.cp.solver.constraints.integer   
choco.cp.solver.constraints.integer.bool   
choco.cp.solver.constraints.integer.bool.sat   
choco.cp.solver.constraints.integer.bool.sum   
choco.cp.solver.constraints.integer.channeling   
choco.cp.solver.constraints.integer.extension   
choco.cp.solver.constraints.integer.intlincomb   
choco.cp.solver.constraints.integer.soft   
choco.cp.solver.constraints.real   
choco.cp.solver.constraints.real.exp   
choco.cp.solver.constraints.reified   
choco.cp.solver.constraints.set   
choco.cp.solver.constraints.strong   
choco.cp.solver.constraints.strong.maxrpcrm   
choco.cp.solver.goals   
choco.cp.solver.goals.choice   
choco.cp.solver.propagation   
choco.cp.solver.search   
choco.cp.solver.search.integer.branching   
choco.cp.solver.search.integer.branching.domwdeg   
choco.cp.solver.search.integer.objective   
choco.cp.solver.search.integer.varselector   
choco.cp.solver.search.integer.varselector.ratioselector   
choco.cp.solver.search.integer.varselector.ratioselector.ratios.task   
choco.cp.solver.search.real   
choco.cp.solver.search.real.objective   
choco.cp.solver.search.set   
choco.cp.solver.search.task   
choco.cp.solver.search.task.profile   
choco.cp.solver.variables.integer   
choco.cp.solver.variables.real   
choco.cp.solver.variables.set   
choco.kernel.solver   
choco.kernel.solver.branch A package devoted to control (branching schemes and heuristics) for branching in a search tree.
choco.kernel.solver.constraints   
choco.kernel.solver.constraints.global.automata.fast_costregular.structure   
choco.kernel.solver.constraints.global.automata.fast_multicostregular.algo   
choco.kernel.solver.constraints.global.automata.fast_multicostregular.structure   
choco.kernel.solver.constraints.global.automata.fast_regular.structure   
choco.kernel.solver.constraints.global.matching   
choco.kernel.solver.constraints.global.scheduling   
choco.kernel.solver.constraints.integer A package devoted to constraints over integers. 
choco.kernel.solver.constraints.real A package devoted continuous constraints. 
choco.kernel.solver.constraints.real.exp A package devoted real expression, that is composition of operators over real variables. 
choco.kernel.solver.constraints.set   
choco.kernel.solver.goals   
choco.kernel.solver.goals.choice   
choco.kernel.solver.goals.solver   
choco.kernel.solver.propagation A package of classes devoted to the event model of constraint propagation.
choco.kernel.solver.propagation.event   
choco.kernel.solver.propagation.listener   
choco.kernel.solver.propagation.queue   
choco.kernel.solver.search A package devoted to the the control of search algorithms.
choco.kernel.solver.search.integer A package devoted to choice points and search heuristics specific to integer variables.
choco.kernel.solver.search.measure   
choco.kernel.solver.search.set   
choco.kernel.solver.variables.integer A package devoted to the management of variables and domains for integers 
choco.kernel.solver.variables.real A package devoted to contiinuous domains and variables. 
choco.kernel.solver.variables.scheduling   
choco.kernel.solver.variables.set   
samples.jobshop   
samples.multicostregular.nsp   
samples.multicostregular.planner   
samples.tutorials.lns.lns   
samples.tutorials.to_sort.socialgolfer   
samples.tutorials.to_sort.tsp   
 

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()
           
 



Copyright © 2012. All Rights Reserved.