Uses of Class
org.jacop.core.Store

Packages that use Store

Package	Description
org.jacop.api
org.jacop.constraints
org.jacop.constraints.binpacking
org.jacop.constraints.cumulative
org.jacop.constraints.diffn
org.jacop.constraints.geost
org.jacop.constraints.knapsack
org.jacop.constraints.netflow
org.jacop.constraints.regular
org.jacop.constraints.table
org.jacop.core
org.jacop.examples.cpviz
org.jacop.examples.fd
org.jacop.examples.fd.filters
org.jacop.examples.set
org.jacop.floats.constraints
org.jacop.floats.constraints.linear
org.jacop.floats.core
org.jacop.floats.search
org.jacop.fz
org.jacop.fz.constraints
org.jacop.satwrapper
org.jacop.search
org.jacop.search.restart
org.jacop.search.sgmpcs
org.jacop.set.constraints
org.jacop.set.core
org.jacop.util

Uses of Store in org.jacop.api

Methods in org.jacop.api with parameters of type Store

Modifier and Type	Method	Description
void	StoreAware.include(Store store)	It provide store for constraints that are not imposed but called from other constraints.

Uses of Store in org.jacop.constraints

Fields in org.jacop.constraints declared as Store

Modifier and Type	Field	Description
(package private) Store	Diff.currentStore
(package private) Store	Alldiff.store
(package private) Store	CircuitVar.store
(package private) Store	Diff2Var.store
(package private) Store	DisjointCondVar.store
(package private) Store	ExtensionalConflictVA.store
(package private) Store	ExtensionalSupportSTR.store
(package private) Store	IfThen.store
(package private) Store	IfThenElse.store
(package private) Store	Implies.store
private Store	LexOrder.store
(package private) Store	Linear.store	Deprecated.
(package private) Store	LinearInt.store
(package private) Store	Member.store
(package private) Store	Subcircuit.store
(package private) Store	SumBool.store
(package private) Store	SumInt.store
(package private) Store	ValuePrecede.store
(package private) Store	VariableTrace.store

Methods in org.jacop.constraints with parameters of type Store

Modifier and Type	Method	Description
(package private) void	Circuit.alldifferent(Store store, LinkedHashSet<IntVar> fdvs)
(package private) void	Subcircuit.alldifferent(Store store, LinkedHashSet<IntVar> fdvs)
(package private) void	AbsXeqY.boundConsistency(Store store)
protected void	LinearInt.commonInitialization(Store store, IntVar[] list, int[] weights, String rel, int sum)
void	AbsXeqY.consistency(Store store)
void	Alldiff.consistency(Store store)
void	Alldifferent.consistency(Store store)
void	Alldistinct.consistency(Store store)
void	AllEqual.consistency(Store store)
void	Among.consistency(Store store)
void	AmongVar.consistency(Store store)
void	And.consistency(Store store)
void	AndBoolSimple.consistency(Store store)
void	AndBoolVector.consistency(Store store)
void	ArgMax.consistency(Store store)
void	ArgMin.consistency(Store store)
void	Assignment.consistency(Store store)
void	AtLeast.consistency(Store store)
void	AtMost.consistency(Store store)
void	BoolClause.consistency(Store store)	computes consistency for x_0 \/ ...
void	ChannelImply.consistency(Store store)
void	ChannelReif.consistency(Store store)
void	Circuit.consistency(Store store)
void	Conditional.consistency(Store store)
abstract void	Constraint.consistency(Store store)	It is a (most probably incomplete) consistency function which removes the values from variables domains.
void	Count.consistency(Store store)
void	CountBounds.consistency(Store store)
void	CountValues.consistency(Store store)
void	CountValuesBounds.consistency(Store store)
void	CountVar.consistency(Store store)
void	Cumulative.consistency(Store store)
void	Diff.consistency(Store store)
void	Distance.consistency(Store store)
void	Element.consistency(Store store)
void	ElementInteger.consistency(Store store)
void	ElementIntegerFast.consistency(Store store)
void	ElementVariable.consistency(Store store)
void	ElementVariableFast.consistency(Store store)
void	Eq.consistency(Store store)
void	EqBool.consistency(Store store)
void	ExtensionalConflictVA.consistency(Store store)
void	ExtensionalSupportMDD.consistency(Store s)
void	ExtensionalSupportSTR.consistency(Store store)
void	ExtensionalSupportVA.consistency(Store store)
void	GCC.consistency(Store store)
void	IfThen.consistency(Store store)
void	IfThenBool.consistency(Store store)
void	IfThenElse.consistency(Store store)
void	Implies.consistency(Store store)
void	In.consistency(Store store)
void	Increasing.consistency(Store store)
void	LexOrder.consistency(Store store)
void	Linear.consistency(Store store)	Deprecated.
void	LinearInt.consistency(Store store)
void	LinearIntDom.consistency(Store store)
void	Max.consistency(Store store)
void	MaxSimple.consistency(Store store)
void	Member.consistency(Store store)
void	Min.consistency(Store store)
void	MinSimple.consistency(Store store)
void	NoGood.consistency(Store store)
void	Not.consistency(Store store)
void	Or.consistency(Store store)
void	OrBoolSimple.consistency(Store store)
void	OrBoolVector.consistency(Store store)
void	Reified.consistency(Store store)
void	SeqPrecedeChain.consistency(Store store)
void	Subcircuit.consistency(Store store)
void	Sum.consistency(Store store)
void	SumBool.consistency(Store store)
void	SumInt.consistency(Store store)
void	SumWeight.consistency(Store store)
void	SumWeightDom.consistency(Store store)	Deprecated.
void	ValuePrecede.consistency(Store store)
void	Values.consistency(Store store)
void	VariableTrace.consistency(Store store)
void	XdivYeqZ.consistency(Store store)
void	XeqC.consistency(Store store)
void	XeqY.consistency(Store store)
void	XexpYeqZ.consistency(Store store)
void	XgtC.consistency(Store store)
void	XgteqC.consistency(Store store)
void	XgteqY.consistency(Store store)
void	XgtY.consistency(Store store)
void	XltC.consistency(Store store)
void	XlteqC.consistency(Store store)
void	XlteqY.consistency(Store store)
void	XltY.consistency(Store store)
void	XmodYeqZ.consistency(Store store)
void	XmulCeqZ.consistency(Store store)
void	XmulYeqC.consistency(Store store)
void	XmulYeqZ.consistency(Store store)
void	XneqC.consistency(Store store)
void	XneqY.consistency(Store store)
void	Xor.consistency(Store store)
void	XorBool.consistency(Store store)
void	XplusCeqZ.consistency(Store store)
void	XplusClteqZ.consistency(Store store)
void	XplusYeqC.consistency(Store store)
void	XplusYeqZ.consistency(Store store)
void	XplusYgtC.consistency(Store store)
void	XplusYlteqZ.consistency(Store store)
void	AmongVar.consistencyForX(Store store)	Is called when all y are grounded and amongForSet is equivalent to simple version of Among.
void	AmongVar.consistencyForY(Store store)	It is a function which makes Y consistent if all X's are grounded.
void	AmongVar.consistencyWhen_LB0_EQ_UB0(Store store)	The number of x in lbsDom is equal to the number of X intersecting ubSDom.
private void	GCC.countBoundConsistency(Store store)
List<PrimitiveConstraint>	AndBool.decompose(Store store)
List<Constraint>	AndBoolVector.decompose(Store store)
List<Constraint>	Constraint.decompose(Store store)	It returns an array list of constraint which are used to decompose this constraint.
abstract List<T>	DecomposedConstraint.decompose(Store store)	It returns an array list of constraint which are used to decompose this constraint.
List<Constraint>	EqBool.decompose(Store store)
List<Constraint>	Increasing.decompose(Store store)
List<Constraint>	Lex.decompose(Store store)
List<PrimitiveConstraint>	OrBool.decompose(Store store)
List<Constraint>	OrBoolVector.decompose(Store store)
List<Constraint>	Sequence.decompose(Store store)
List<Constraint>	SoftAlldifferent.decompose(Store store)
List<Constraint>	SoftGCC.decompose(Store store)
List<Constraint>	Stretch.decompose(Store store)
List<Constraint>	Lex.decomposeLE(Store store)
List<Constraint>	Lex.decomposeLERegular(Store store)
List<Constraint>	Lex.decomposeLT(Store store)
List<Constraint>	Lex.decomposeLTRegular(Store store)
FloatVar	DecomposedConstraint.derivative(Store store, FloatVar f, Set<FloatVar> vars, FloatVar x)
(package private) void	AbsXeqY.domainConsistency(Store store)
private void	Cumulative.edgeFindingDown(Store store)
private void	Cumulative.edgeFindingUp(Store store)
void	Alldiff.impose(Store store)
void	Alldifferent.impose(Store store)
void	Alldistinct.impose(Store store)
void	Among.impose(Store store)
void	AmongVar.impose(Store store)
void	Assignment.impose(Store store)
void	AtLeast.impose(Store store)
void	AtMost.impose(Store store)
void	ChannelImply.impose(Store store)
void	ChannelReif.impose(Store store)
void	Circuit.impose(Store store)
void	Constraint.impose(Store store)	It imposes the constraint in a given store.
void	Constraint.impose(Store store, int queueIndex)	It imposes the constraint and adjusts the queue index.
void	Count.impose(Store store)
void	CountBounds.impose(Store store)
void	CountValues.impose(Store store)
void	CountValuesBounds.impose(Store store)
void	CountVar.impose(Store store)
void	Diff2.impose(Store store)
void	Disjoint.impose(Store store)
void	DisjointConditional.impose(Store store)
void	Element.impose(Store store)
void	ElementInteger.impose(Store store)	It imposes the constraint in a given store.
void	ElementIntegerFast.impose(Store store)
void	ElementVariable.impose(Store store)
void	ElementVariableFast.impose(Store store)	It imposes the constraint in a given store.
void	ExtensionalConflictVA.impose(Store store)
void	ExtensionalSupportMDD.impose(Store store)
void	ExtensionalSupportSTR.impose(Store store)
void	ExtensionalSupportVA.impose(Store store)
void	GCC.impose(Store store)
void	IfThen.impose(Store store)
void	IfThenElse.impose(Store store)
void	Implies.impose(Store store)
void	LexOrder.impose(Store store)
void	Linear.impose(Store store)	Deprecated.
void	LinearInt.impose(Store store)
void	Max.impose(Store store)
void	Member.impose(Store store)
void	Min.impose(Store store)
void	NoGood.impose(Store store)
void	PrimitiveConstraint.impose(Store store)
void	Reified.impose(Store store)
void	Subcircuit.impose(Store store)
void	Sum.impose(Store store)
void	SumBool.impose(Store store)
void	SumInt.impose(Store store)
void	SumWeight.impose(Store store)
void	SumWeightDom.impose(Store store)	Deprecated.
void	ValuePrecede.impose(Store store)
void	VariableTrace.impose(Store store)
void	XeqY.impose(Store store)
void	XgteqY.impose(Store store)
void	XgtY.impose(Store store)
void	XlteqY.impose(Store store)
void	XltY.impose(Store store)
void	XneqY.impose(Store store)
void	Xor.impose(Store store)
void	AndBool.imposeDecomposition(Store store)
void	AndBoolVector.imposeDecomposition(Store store)
void	Constraint.imposeDecomposition(Store store)	It imposes the decomposition of the given constraint in a given store.
abstract void	DecomposedConstraint.imposeDecomposition(Store store)	It imposes the constraint in a given store.
void	DecomposedConstraint.imposeDecomposition(Store store, int queueIndex)	It imposes the constraint and adjusts the queue index.
void	EqBool.imposeDecomposition(Store store)
void	Increasing.imposeDecomposition(Store store)
void	Lex.imposeDecomposition(Store store)
void	OrBool.imposeDecomposition(Store store)
void	OrBoolVector.imposeDecomposition(Store store)
void	Sequence.imposeDecomposition(Store store)
void	SoftAlldifferent.imposeDecomposition(Store store)
void	SoftGCC.imposeDecomposition(Store store)
void	Stretch.imposeDecomposition(Store store)
void	AndBoolVector.include(Store store)
void	AtLeast.include(Store store)
void	AtMost.include(Store store)
void	BoolClause.include(Store store)
void	Count.include(Store store)
void	CountBounds.include(Store store)
void	CountVar.include(Store store)
void	IfThen.include(Store store)
void	IfThenElse.include(Store store)
void	Implies.include(Store store)
void	Member.include(Store store)
void	OrBoolVector.include(Store store)
void	PrimitiveConstraint.include(Store store)
(package private) int	Circuit.lastNode(Store store, int current)
void	AbsXeqY.notConsistency(Store store)
void	AllEqual.notConsistency(Store store)
void	And.notConsistency(Store store)
void	AndBoolSimple.notConsistency(Store store)
void	AndBoolVector.notConsistency(Store store)
void	AtLeast.notConsistency(Store store)
void	AtMost.notConsistency(Store store)
void	BoolClause.notConsistency(Store store)	computes consistency for not (x_0 \/ ...
void	Count.notConsistency(Store store)
void	CountBounds.notConsistency(Store store)
void	CountVar.notConsistency(Store store)
void	Distance.notConsistency(Store store)
void	Eq.notConsistency(Store store)
void	EqBool.notConsistency(Store store)
void	IfThen.notConsistency(Store store)
void	IfThenBool.notConsistency(Store store)
void	IfThenElse.notConsistency(Store store)
void	Implies.notConsistency(Store store)
void	In.notConsistency(Store store)
void	LinearInt.notConsistency(Store store)
void	LinearIntDom.notConsistency(Store store)
void	Member.notConsistency(Store store)
void	Not.notConsistency(Store store)
void	Or.notConsistency(Store store)
void	OrBoolSimple.notConsistency(Store store)
void	OrBoolVector.notConsistency(Store store)
abstract void	PrimitiveConstraint.notConsistency(Store store)	It makes pruning in such a way that constraint is notConsistent.
void	Reified.notConsistency(Store store)
void	SumBool.notConsistency(Store store)
void	SumInt.notConsistency(Store store)
void	XeqC.notConsistency(Store store)
void	XeqY.notConsistency(Store store)
void	XgtC.notConsistency(Store store)
void	XgteqC.notConsistency(Store store)
void	XgteqY.notConsistency(Store store)
void	XgtY.notConsistency(Store store)
void	XltC.notConsistency(Store store)
void	XlteqC.notConsistency(Store store)
void	XlteqY.notConsistency(Store store)
void	XltY.notConsistency(Store store)
void	XmulCeqZ.notConsistency(Store store)
void	XmulYeqC.notConsistency(Store store)
void	XneqC.notConsistency(Store store)
void	XneqY.notConsistency(Store store)
void	Xor.notConsistency(Store store)
void	XorBool.notConsistency(Store store)
void	XplusCeqZ.notConsistency(Store store)
void	XplusClteqZ.notConsistency(Store store)
void	XplusYeqC.notConsistency(Store store)
void	XplusYeqZ.notConsistency(Store store)
void	XplusYgtC.notConsistency(Store store)
void	XplusYlteqZ.notConsistency(Store store)
private void	Cumulative.notFirst(Store store, Task s, List<Task> S)
private void	Cumulative.notLast(Store store, Task s, List<Task> S)
(package private) void	Circuit.oneCircuit(Store store, LinkedHashSet<IntVar> fdvs)
List<Constraint>	SoftAlldifferent.primitiveDecomposition(Store store)
List<Constraint>	SoftGCC.primitiveDecomposition(Store store)
private void	Cumulative.profileCheckInterval(Store store, IntVar Start, IntVar Duration, Interval i, IntVar Resources, int mustUseMin, int mustUseMax)
private void	Diff.profileCheckInterval(Store store, DiffnProfile Profile, int limit, IntVar Start, IntVar Duration, int iMin, int i_max, IntVar Resources)
(package private) void	DisjointConditional.profileCheckInterval(Store store, DisjointConditionalProfile Profile, int limit, IntVar Start, IntVar Duration, int _min, int _max, IntVar Resources)
private void	Cumulative.profileCheckTasks(Store store)
private void	Linear.pruneRelation(Store store, byte rel)	Deprecated.
private boolean	Alldifferent.satisfiedFullCheck(Store S)
(package private) void	Circuit.sccs(Store store)
private int	Subcircuit.sccs(Store store)
private void	Subcircuit.sccsBasedPruning(Store store)
private void	Cumulative.updateTasksRes(Store store)

Constructors in org.jacop.constraints with parameters of type Store

Modifier	Constructor	Description
(package private)	CircuitVar(Store store)
(package private)	CircuitVar(Store store, int next, int previous)
(package private)	Diff2Var(Store store)
(package private)	Diff2Var(Store store, Rectangle[] R)
(package private)	DisjointCondVar(Store S)
(package private)	DisjointCondVar(Store S, List<RectangleWithCondition> R)
(package private)	DisjointCondVar(Store S, RectangleWithCondition[] R)
	Linear(Store store, List<? extends IntVar> variables, List<Integer> weights, String rel, int sum)	Deprecated. It constructs the constraint Linear.
	Linear(Store store, IntVar[] list, int[] weights, String rel, int sum)	Deprecated. It constructs the constraint Linear.
	LinearInt(Store store, List<? extends IntVar> list, List<Integer> weights, String rel, int sum)	Deprecated. LinearInt constraint does not use Store parameter any longer.
	LinearInt(Store store, IntVar[] list, int[] weights, String rel, int sum)	Deprecated.
	LinearInt(Store store, IntVar[] list, int[] weights, String rel, IntVar sum)	Deprecated.
	LinearIntDom(Store store, List<? extends IntVar> variables, List<Integer> weights, String rel, int sum)	Deprecated. LinearIntDom constraint does not use Store parameter any longer.
	LinearIntDom(Store store, IntVar[] list, int[] weights, String rel, int sum)	Deprecated. LinearIntDom constraint does not use Store parameter any longer.
	LinearIntDom(Store store, IntVar[] list, int[] weights, String rel, IntVar sum)	Deprecated. LinearIntDom constraint does not use Store parameter any longer.
	SumBool(Store store, List<? extends IntVar> variables, String rel, IntVar sum)	Deprecated.
	SumBool(Store store, IntVar[] list, String rel, IntVar sum)	Deprecated.
	SumInt(Store store, List<? extends IntVar> variables, String rel, IntVar sum)	Deprecated. SumInt constraint does not use Store parameter any longer.
	SumInt(Store store, IntVar[] list, String rel, IntVar sum)	Deprecated. SumInt constraint does not use Store parameter any longer.

Uses of Store in org.jacop.constraints.binpacking

Methods in org.jacop.constraints.binpacking with parameters of type Store

Modifier and Type	Method	Description
void	Binpacking.consistency(Store store)
void	Binpacking.impose(Store store)

Uses of Store in org.jacop.constraints.cumulative

Methods in org.jacop.constraints.cumulative with parameters of type Store

Modifier and Type	Method	Description
private void	Cumulative.adjustBounds(Store store, ThetaLambdaTree tree, TaskView[] t, int[] prec, long cap)
void	Cumulative.consistency(Store store)
void	CumulativeBasic.consistency(Store store)
void	CumulativeOptional.consistency(Store store)
void	CumulativePrimary.consistency(Store store)
void	CumulativeUnary.consistency(Store store)
void	CumulativeUnaryOptional.consistency(Store store)
(package private) void	CumulativeUnary.detectable(Store store, TaskView[] tn, TaskView[] tr)
private void	CumulativeUnary.detectable(Store store, ThetaTree tree, TaskView[] t, TaskView[] q, TaskView[] to)
private void	CumulativeUnary.detectablePhase(Store store, TaskView[] tc)
(package private) void	Cumulative.edgeFind(Store store)
private void	Cumulative.edgeFind(Store store, TaskView[] tn)
(package private) void	CumulativeUnary.edgeFind(Store store, TaskView[] tn, TaskView[] tr)
private void	CumulativeUnary.edgeFindPhase(Store store, TaskView[] tc)
(package private) void	Cumulative.edgeFindQuad(Store store)
private void	Cumulative.edgeFindQuad(Store store, TaskView[] tn)
(package private) void	CumulativeUnary.notFirstNotLast(Store store, TaskView[] tn, TaskView[] tr)
private void	CumulativeUnary.notFirstNotLastPhase(Store store, TaskView[] tc)
private void	CumulativeUnary.notLast(Store store, ThetaTree tree, TaskView[] t, TaskView[] q, TaskView[] tc)
(package private) void	CumulativeBasic.profileProp(Store store)
(package private) void	ProfileOptional.pruneOpt(Store store, TaskView[] tn, IntVar[] opt)
private void	CumulativeBasic.sweepPruning(Store store)
(package private) void	CumulativePrimary.sweepPruning(Store store)
(package private) void	ProfileOptional.sweepPruning(Store store, TaskView[] tn, IntVar[] opt)
private void	CumulativeBasic.updateTasksRes(Store store)
(package private) void	ProfileOptional.updateTasksRes(Store store, TaskView[] ts)

Uses of Store in org.jacop.constraints.diffn

Fields in org.jacop.constraints.diffn declared as Store

Modifier and Type	Field	Description
(package private) Store	Nooverlap.store

Methods in org.jacop.constraints.diffn with parameters of type Store

Modifier and Type	Method	Description
void	Diffn.consistency(Store store)
void	Nooverlap.consistency(Store store)
List<Constraint>	Diffn.decompose(Store store)
List<Constraint>	DiffnDecomposed.decompose(Store store)
void	Nooverlap.impose(Store store)
void	Diffn.imposeDecomposition(Store store)	It imposes DiffnDecomposed in a given store.
void	DiffnDecomposed.imposeDecomposition(Store store)	It imposes DiffnDecomposed in a given store.
(package private) boolean	Rectangle.instantiatedBefore(Store store)

Uses of Store in org.jacop.constraints.geost

Fields in org.jacop.constraints.geost declared as Store

Modifier and Type	Field	Description
protected Store	Geost.store	It keeps a reference to the store.

Methods in org.jacop.constraints.geost with parameters of type Store

Modifier and Type	Method	Description
void	Geost.consistency(Store store)
boolean	GeostObject.TimeBoundConstraint.consistencyDurationGtZero(Store store)	It applies constraint enforcing that duration > 0
boolean	GeostObject.TimeBoundConstraint.consistencyStartPlusDurationEqEnd(Store store)	It evaluates part of the constraint that ensures that start + duration = end
void	Geost.impose(Store store)
protected int	Geost.pruneMax(Store store, GeostObject o, int currentShape, int d, int limit)	the sweeping routine for minimal bounds.
protected int	Geost.pruneMin(Store store, GeostObject o, int currentShape, int d, int limit)	the sweeping routine for minimal bounds.

Uses of Store in org.jacop.constraints.knapsack

Methods in org.jacop.constraints.knapsack with parameters of type Store

Modifier and Type	Method	Description
void	Knapsack.consistency(Store store)
void	Knapsack.impose(Store store)
private void	Knapsack.restrictItemQuantity(Store store, TreeNode parent, int availableCapacity)	It makes sure that no item has a possibility to use more than available capacity.

Uses of Store in org.jacop.constraints.netflow

Fields in org.jacop.constraints.netflow declared as Store

Modifier and Type	Field	Description
Store	Network.store	The store

Methods in org.jacop.constraints.netflow with parameters of type Store

Modifier and Type	Method	Description
void	NetworkFlow.consistency(Store store)
List<Constraint>	Arithmetic.decompose(Store store)
void	NetworkFlow.impose(Store store)
void	Arithmetic.imposeDecomposition(Store store)
void	Network.initialize(Store store)
List<Constraint>	Arithmetic.primitiveDecomposition(Store store)
List<Constraint>	NetworkBuilder.primitiveDecomposition(Store store)	Generally speaking, especially in case of multiple arcs between two nodes and structure constraints imposed on arcs makes it hard to decompose network flow constraint into primitive ones.
private void	NetworkBuilder.sumC(List<Constraint> list, Store store, List<IntVar> vars, IntVar result)

Constructors in org.jacop.constraints.netflow with parameters of type Store

Modifier	Constructor	Description
private	ArithmeticBuilder(Store store, int[] sum)

Uses of Store in org.jacop.constraints.regular

Methods in org.jacop.constraints.regular with parameters of type Store

Modifier and Type	Method	Description
void	Regular.consistency(Store store)
List<Constraint>	Regular.decompose(Store store)
void	Regular.impose(Store store)
void	Regular.imposeDecomposition(Store store)

Uses of Store in org.jacop.constraints.table

Fields in org.jacop.constraints.table declared as Store

Modifier and Type	Field	Description
(package private) Store	SimpleTable.store
(package private) Store	Table.store

Methods in org.jacop.constraints.table with parameters of type Store

Modifier and Type	Method	Description
void	SimpleTable.consistency(Store store)
void	Table.consistency(Store store)
void	SimpleTable.impose(Store store)
void	Table.impose(Store store)
(package private) void	ReversibleSparseBitSet.init(Store store, long[] w)

Constructors in org.jacop.constraints.table with parameters of type Store

Modifier	Constructor	Description
	ReversibleSparseBitSet(Store store, IntVar[] x, int[][] tuple)

Uses of Store in org.jacop.core

Fields in org.jacop.core declared as Store

Modifier and Type	Field	Description
(package private) Store	MutableDomain.store
(package private) Store	TimeStamp.store
Store	Var.store	Each variable is created in a store.

Methods in org.jacop.core that return Store

Modifier and Type	Method	Description
Store	Var.getStore()	This function returns store used by this variable.

Methods in org.jacop.core with parameters of type Store

Modifier and Type	Method	Description
private void	IntVar.commonInitialization(Store store, String name, IntDomain dom)

Constructors in org.jacop.core with parameters of type Store

Modifier	Constructor	Description
	BooleanVar(Store store)	This constructor creates a variable with empty domain (standard FD domain), automatically generated name, and empty attached constraint list.
	BooleanVar(Store store, int min, int max)	Boolean variable constructor.
	BooleanVar(Store store, String name)	Boolean variable constructor.
	BooleanVar(Store store, String name, int min, int max)	Boolean variable constructor.
	BooleanVar(Store store, String name, BoundDomain dom)	It creates a Boolean variable.
	BooleanVar(Store store, BoundDomain dom)	It creates a Boolean variable.
	IntVar(Store store)	This constructor creates a variable with empty domain (standard IntervalDomain domain), automatically generated name, and empty attached constraint list.
	IntVar(Store store, int min, int max)	This constructor creates a variable with a domain between min..max, automatically generated name, and empty attached constraint list.
	IntVar(Store store, String name)	This constructor creates a variable with an empty domain (standard IntervalDomain domain), the specified name, and an empty attached constraint list.
	IntVar(Store store, String name, int min, int max)	This constructor creates a variable in a given store, with the domain specified by min..max and with the given name.
	IntVar(Store store, String name, IntDomain dom)	It creates a variable in a given store, with a given name and a given domain.
	IntVar(Store store, IntDomain dom)	It creates a variable in a given store, with a given name and a given domain.
	MutableDomain(Store store)
	MutableDomain(Store store, IntDomain domain)
	TimeStamp(Store store, T input)	The constructor.

Uses of Store in org.jacop.examples.cpviz

Fields in org.jacop.examples.cpviz declared as Store

Modifier and Type	Field	Description
(package private) Store	CPvizGardner.store
(package private) Store	CPvizNetworkFlow.store
(package private) Store	CPvizNewspaper.store
(package private) Store	CPvizSendMoreMoney.store

Uses of Store in org.jacop.examples.fd

Fields in org.jacop.examples.fd declared as Store

Modifier and Type	Field	Description
(package private) Store	ConferenceTalkPlacement.store
Store	ExampleFD.store	It specifies the constraint store responsible for holding information about constraints and variables.

Methods in org.jacop.examples.fd that return Store

Modifier and Type	Method	Description
Store	ExampleFD.getStore()	It specifies the constraint store used within an example.

Uses of Store in org.jacop.examples.fd.filters

Methods in org.jacop.examples.fd.filters with parameters of type Store

Modifier and Type	Method	Description
static int	FilterBenchmark.experiment1(Store store, Filter filter, int addNum, int mulNum)	It optimizes scheduling of filter operations.
static int	FilterBenchmark.experiment1C(Store store, Filter filter, int addNum, int mulNum, int clock)	It optimizes scheduling of filter operation in fashion allowing chaining of operations within one clock cycle.
static int	FilterBenchmark.experiment1P(Store store, Filter filter, int addNum, int mulNum)	It optimizes scheduling of filter operations.
static int	FilterBenchmark.experiment1PM(Store store, Filter filter, int addNum, int mulNum)	It optimizes scheduling of filter operations in a fashion allowing pipelining of multiplication operations.
static int	FilterBenchmark.experiment2(Store store, Filter filter, int addNum, int mulNum)	It optimizes scheduling of filter operations.
static int	FilterBenchmark.experiment2C(Store store, Filter filter, int addNum, int mulNum, int clock)	It optimizes scheduling of filter operation in fashion allowing chaining of operations within one clock cycle.
static int	FilterBenchmark.experiment2P(Store store, Filter filter, int addNum, int mulNum)	It optimizes scheduling of filter operations.
static int	FilterBenchmark.experiment2PM(Store store, Filter filter, int addNum, int mulNum)	It optimizes scheduling of filter operation in fashion allowing pipelining of multiplication operations.
static List<List<IntVar>>	FilterBenchmark.makeConstraints(Store store, Filter filter, int addNum, int mulNum)	It creates constraint model for scheduling of filter operations.
static List<List<IntVar>>	FilterBenchmark.makeConstraintsChain(Store store, Filter filter, int addNum, int mulNum, int clk)	It creates constraint model for scheduling of filter operation in fashion allowing chaining of operations within one clock cycle.
static List<List<IntVar>>	FilterBenchmark.makeConstraintsPipeline(Store store, Filter filter, int addNum, int mulNum)	It creates a model for optimization of scheduling of operations of a given filter.
static List<List<IntVar>>	FilterBenchmark.makeConstraintsPipeMultiplier(Store store, Filter filter, int addNum, int mulNum)	It creates constraint model for scheduling of filter operation in fashion allowing pipelining of multiplication operations.

Uses of Store in org.jacop.examples.set

Fields in org.jacop.examples.set declared as Store

Modifier and Type	Field	Description
Store	ExampleSet.store	It specifies the constraint store responsible for holding information about constraints and variables.

Methods in org.jacop.examples.set that return Store

Modifier and Type	Method	Description
Store	ExampleSet.getStore()	It specifies the constraint store used within an example.

Uses of Store in org.jacop.floats.constraints

Fields in org.jacop.floats.constraints declared as Store

Modifier and Type	Field	Description
(package private) static Store	Derivative.store

Methods in org.jacop.floats.constraints with parameters of type Store

Modifier and Type	Method	Description
(package private) void	AbsPeqR.boundConsistency(Store store)
(package private) void	CosPeqR.boundConsistency(Store store)
(package private) void	SinPeqR.boundConsistency(Store store)
(package private) void	TanPeqR.boundConsistency(Store store)
void	AbsPeqR.consistency(Store store)
void	CeilPeqX.consistency(Store store)
void	CosPeqR.consistency(Store store)
void	ElementFloat.consistency(Store store)
void	ElementFloatVariable.consistency(Store store)
void	EquationSystem.consistency(Store store)
void	ExpPeqR.consistency(Store store)
void	FloorPeqX.consistency(Store store)
void	Max.consistency(Store store)
void	Min.consistency(Store store)
void	PeqC.consistency(Store store)
void	PeqQ.consistency(Store store)
void	PgtC.consistency(Store store)
void	PgteqC.consistency(Store store)
void	PgteqQ.consistency(Store store)
void	PgtQ.consistency(Store store)
void	PltC.consistency(Store store)
void	PlteqC.consistency(Store store)
void	PlteqQ.consistency(Store store)
void	PltQ.consistency(Store store)
void	PmulCeqR.consistency(Store store)
void	PmulQeqR.consistency(Store store)
void	PneqC.consistency(Store store)
void	PneqQ.consistency(Store store)
void	PplusCeqR.consistency(Store store)
void	PplusQeqR.consistency(Store store)
void	RoundPeqX.consistency(Store store)
void	SinPeqR.consistency(Store store)
void	SqrtPeqR.consistency(Store store)
void	TanPeqR.consistency(Store store)
void	XeqP.consistency(Store store)
List<Constraint>	CosPeqR_decomposed.decompose(Store store)
FloatVar	CosPeqR.derivative(Store store, FloatVar f, Set<FloatVar> vars, FloatVar x)
FloatVar	ExpPeqR.derivative(Store store, FloatVar f, Set<FloatVar> vars, FloatVar x)
FloatVar	LinearFloat.derivative(Store store, FloatVar f, Set<FloatVar> vars, FloatVar x)
FloatVar	PmulCeqR.derivative(Store store, FloatVar f, Set<FloatVar> vars, FloatVar x)
FloatVar	PmulQeqR.derivative(Store store, FloatVar f, Set<FloatVar> vars, FloatVar x)
FloatVar	PplusCeqR.derivative(Store store, FloatVar f, Set<FloatVar> vars, FloatVar x)
FloatVar	PplusQeqR.derivative(Store store, FloatVar f, Set<FloatVar> vars, FloatVar x)
FloatVar	SinPeqR.derivative(Store store, FloatVar f, Set<FloatVar> vars, FloatVar x)
FloatVar	SqrtPeqR.derivative(Store store, FloatVar f, Set<FloatVar> vars, FloatVar x)
static final FloatVar	Derivative.getDerivative(Store store, FloatVar f, Set<FloatVar> vars, FloatVar x)
void	ElementFloat.impose(Store store)
void	ElementFloatVariable.impose(Store store)	It imposes the constraint in a given store.
void	EquationSystem.impose(Store store)
void	CosPeqR_decomposed.imposeDecomposition(Store store)
static void	Derivative.init(Store s)
void	PeqC.notConsistency(Store store)
void	PeqQ.notConsistency(Store store)
void	PgtC.notConsistency(Store store)
void	PgteqC.notConsistency(Store store)
void	PgteqQ.notConsistency(Store store)
void	PgtQ.notConsistency(Store store)
void	PltC.notConsistency(Store store)
void	PlteqC.notConsistency(Store store)
void	PlteqQ.notConsistency(Store store)
void	PltQ.notConsistency(Store store)
void	PneqC.notConsistency(Store store)
void	PneqQ.notConsistency(Store store)
void	PplusCeqR.notConsistency(Store store)
void	PplusQeqR.notConsistency(Store store)

Constructors in org.jacop.floats.constraints with parameters of type Store

Modifier	Constructor	Description
	EquationSystem(Store store, FloatVar[] f, FloatVar[] x)	It constructs the constraint EquationSystem.
	LinearFloat(Store store, List<? extends FloatVar> variables, List<Double> weights, String rel, double sum)	Deprecated. LinearFloat constraint does not use Store parameter any longer.
	LinearFloat(Store store, FloatVar[] list, double[] weights, String rel, double sum)	Deprecated. LinearFloat constraint does not use Store parameter any longer.
	LinearFloat(Store store, FloatVar[] list, double[] weights, String rel, FloatVar sum)	Deprecated. LinearFloat constraint does not use Store parameter any longer.
	MultivariateIntervalNewton(Store store, FloatVar[] f, FloatVar[] x)
	SumFloat(Store store, FloatVar[] list, String rel, FloatVar sum)	Deprecated. SumFloat constraint does not use Store parameter any longer.

Uses of Store in org.jacop.floats.constraints.linear

Fields in org.jacop.floats.constraints.linear declared as Store

Modifier and Type	Field	Description
(package private) Store	BoundsVar.store
(package private) Store	Linear.store
(package private) Store	VariableNode.store

Methods in org.jacop.floats.constraints.linear with parameters of type Store

Modifier and Type	Method	Description
private void	Linear.commonInitialization(Store store, FloatVar[] list, double[] weights, String rel, double sum)
void	Linear.consistency(Store store)
void	Linear.impose(Store store)
void	Linear.notConsistency(Store store)

Constructors in org.jacop.floats.constraints.linear with parameters of type Store

Modifier	Constructor	Description
	BNode(Store store)
	BNode(Store store, double min, double max)
	BNode(Store store, double min, double max, double lb, double ub)
(package private)	BoundsVar(Store store)
(package private)	BoundsVar(Store store, double min, double max)
(package private)	BoundsVar(Store store, double min, double max, double lb, double ub)
	Linear(Store store, List<? extends FloatVar> variables, List<Double> weights, String rel, double sum)	It constructs the constraint Linear.
	Linear(Store store, FloatVar[] list, double[] weights, String rel, double sum)
	Linear(Store store, FloatVar[] list, double[] weights, String rel, FloatVar sum)
	RootBNode(Store store)
	RootBNode(Store store, double min, double max)
	VarNode(Store store, FloatVar v)
	VarWeightNode(Store store, FloatVar v, double w)

Uses of Store in org.jacop.floats.core

Methods in org.jacop.floats.core with parameters of type Store

Modifier and Type	Method	Description
private void	FloatVar.commonInitialization(Store store, String name, FloatDomain dom)

Constructors in org.jacop.floats.core with parameters of type Store

Modifier	Constructor	Description
	FloatVar(Store store)	This constructor creates a variable with empty domain (standard FloatIntervalDomain domain), automatically generated name, and empty attached constraint list.
	FloatVar(Store store, double min, double max)	This constructor creates a variable with a domain between min..max, automatically generated name, and empty attached constraint list.
	FloatVar(Store store, String name)	This constructor creates a variable with an empty domain (standard IntervalDomain domain), the specified name, and an empty attached constraint list.
	FloatVar(Store store, String name, double min, double max)	This constructor creates a variable in a given store, with the domain specified by min..max and with the given name.
	FloatVar(Store store, String name, FloatDomain dom)	It creates a variable in a given store, with a given name and a given domain.
	FloatVar(Store store, FloatDomain dom)	It creates a variable in a given store, with a given name and a given domain.

Uses of Store in org.jacop.floats.search

Fields in org.jacop.floats.search declared as Store

Modifier and Type	Field	Description
(package private) Store	Optimize.store

Constructors in org.jacop.floats.search with parameters of type Store

Modifier	Constructor	Description
	Optimize(Store store, DepthFirstSearch<T> search, SelectChoicePoint<T> select, FloatVar cost)
	SplitRandomSelectFloat(Store store, T[] variables, ComparatorVariable<T> varSelect)	The constructor to create a simple choice select mechanism.
	SplitRandomSelectFloat(Store store, T[] variables, ComparatorVariable<T> varSelect, ComparatorVariable<T> tieBreakerVarSelect)	It constructs a simple selection mechanism for choice points.
	SplitSelectFloat(Store store, T[] variables, ComparatorVariable<T> varSelect)	The constructor to create a simple choice select mechanism.
	SplitSelectFloat(Store store, T[] variables, ComparatorVariable<T> varSelect, ComparatorVariable<T> tieBreakerVarSelect)	It constructs a simple selection mechanism for choice points.
	WeightedDegreeFloat(Store store)

Uses of Store in org.jacop.fz

Fields in org.jacop.fz declared as Store

Modifier and Type	Field	Description
(package private) Store	Constraints.store
(package private) Store	Parser.store
(package private) Store	SearchItem.store
(package private) Store	Solve.store
(package private) Store	Tables.store

Methods in org.jacop.fz that return Store

Modifier and Type	Method	Description
Store	FlatzincLoader.getStore()
(package private) Store	Parser.getStore()

Methods in org.jacop.fz with parameters of type Store

Modifier and Type	Method	Description
void	Solve.PrecisionSetting.executedAtInitialize(Store store)
(package private) void	VariablesParameters.generateArray(SimpleNode node, Tables table, Store store)
(package private) void	VariablesParameters.generateArrayVariables(SimpleNode node, Tables table, Store store)
(package private) void	VariablesParameters.generateVariables(SimpleNode node, Tables table, Store store)
(package private) IntVar[]	VariablesParameters.getScalarFlatExpr_ArrayVar(Store store, SimpleNode node, int index)
(package private) FloatVar[]	VariablesParameters.getScalarFlatExpr_ArrayVarFloat(Store store, SimpleNode node, int index)
(package private) IntVar	VariablesParameters.getScalarFlatExpr_var(Store store, SimpleNode node, int i)
(package private) FloatVar	VariablesParameters.getScalarFlatExpr_varFloat(Store store, SimpleNode node, int i)
(package private) SetVar[]	VariablesParameters.getSetFlatExpr_ArrayVar(Store store, SimpleNode node, int index)
(package private) SetVar	VariablesParameters.getSetFlatExpr_var(Store store, SimpleNode node, int i)
(package private) void	VariablesParameters.pose(Store store, Constraint c)

Constructors in org.jacop.fz with parameters of type Store

Modifier	Constructor	Description
	Constraints(Store store, Tables dict)	It creates an object to parse the constraint part of the flatzinc file.
	SearchItem(Store store, Tables table)	It constructs search part parsing object based on dictionaries provided as well as store object within which the search will take place.
	Solve(Store store, SatTranslation sat)	It creates a parser for the solve part of the flatzinc file.
	Tables(Store s)

Uses of Store in org.jacop.fz.constraints

Fields in org.jacop.fz.constraints declared as Store

Modifier and Type	Field	Description
(package private) Store	BoolConstraints.store
(package private) Store	ComparisonConstraints.store
(package private) Store	ElementConstraints.store
(package private) Store	FloatComparisonConstraints.store
(package private) Store	FloatLinearConstraints.store
(package private) Store	FloatOperationConstraints.store
(package private) Store	GlobalConstraints.store
(package private) Store	GraphConstraints.store
(package private) Store	LinearConstraints.store
(package private) Store	OperationConstraints.store
(package private) Store	SetConstraints.store
(package private) Store	Support.store

Constructors in org.jacop.fz.constraints with parameters of type Store

Modifier	Constructor	Description
	Support(Store store, Tables d, SatTranslation sat)

Uses of Store in org.jacop.satwrapper

Fields in org.jacop.satwrapper declared as Store

Modifier and Type	Field	Description
(package private) Store	SatTranslation.store
Store	SatWrapper.store

Methods in org.jacop.satwrapper with parameters of type Store

Modifier and Type	Method	Description
void	SatWrapper.consistency(Store store)	The point where all operations are effectively done in the SAT solver, until no operation remains or a conflict occurs
final void	SatWrapper.impose(Store store)

Constructors in org.jacop.satwrapper with parameters of type Store

Modifier	Constructor	Description
	SatTranslation(Store store)

Uses of Store in org.jacop.search

Fields in org.jacop.search declared as Store

Modifier and Type	Field	Description
Store	DepthFirstSearch.store	It represents store within which a search is performed.
(package private) Store	FailConstraintsStatistics.store
(package private) Store	Shaving.store	It specifies current store, so shaving can obtained information about recent failed constraint.

Methods in org.jacop.search with parameters of type Store

Modifier and Type	Method	Description
boolean	SimpleSolutionListener.assignSolution(Store store)	It assigns the last found solution to the store.
boolean	SimpleSolutionListener.assignSolution(Store store, int number)
boolean	SolutionListener.assignSolution(Store store, int no)	It imposes the constraints, so the last found solution is enforced.
void	ExitListener.executedAtExit(Store store, int solutionsNo)	It is executed right after time out is determined.
void	NoGoodsCollector.executedAtExit(Store store, int solutionsNo)
void	TraceGenerator.executedAtExit(Store store, int solutionsNo)
void	InitializeListener.executedAtInitialize(Store store)	It is executed before the search starts labeling procedure.
void	OneSolution.executedAtInitialize(Store store)
void	TransformExtensional.executedAtInitialize(Store store)
boolean	DepthFirstSearch.labeling(Store store, SelectChoicePoint<T> select)
boolean	DepthFirstSearch.labeling(Store store, SelectChoicePoint<T> select, Var costVar)
boolean	PrioritySearch.labeling(Store store)
boolean	PrioritySearch.labeling(Store store, Var costVar)
boolean	PrioritySearch.labeling(Store store, SelectChoicePoint<T> select)
boolean	PrioritySearch.labeling(Store store, SelectChoicePoint<T> select, Var costVar)
boolean	Search.labeling(Store store, SelectChoicePoint<T> select)	It performs search using supplied choice point selection heuristic.
boolean	Search.labeling(Store store, SelectChoicePoint<T> select, Var costVar)	It performs search using supplied choice point selection heuristic, as well as costVariable as aim at finding an optimal solution.
void	DepthFirstSearch.setStore(Store store)
void	Search.setStore(Store store)	It sets the reference to the store in the context of which the search operates.
void	Shaving.setStore(Store store)	It specifies the constraint store in which context the shaving will take place.

Constructors in org.jacop.search with parameters of type Store

Modifier	Constructor	Description
	ActivityMax(Store store)
	ActivityMax(Store store, double decay)
	ActivityMaxDeg(Store store)
	ActivityMaxDeg(Store store, double decay)
	ActivityMin(Store store)
	ActivityMin(Store store, double decay)
	ActivityMinDeg(Store store)
	ActivityMinDeg(Store store, double decay)
	AFCMax(Store store)
	AFCMax(Store store, double decay)
	AFCMaxDeg(Store store)
	AFCMaxDeg(Store store, double decay)
	AFCMin(Store store)
	AFCMin(Store store, double decay)
	AFCMinDeg(Store store)
	AFCMinDeg(Store store, double decay)
	FailConstraintsStatistics(Store s)
	InputOrderSelect(Store store, T[] variables, Indomain<T> indomain)	It constructs an input order selection procedure.
	WeightedDegree(Store store)

Uses of Store in org.jacop.search.restart

Fields in org.jacop.search.restart declared as Store

Modifier and Type	Field	Description
(package private) Store	RestartSearch.store

Constructors in org.jacop.search.restart with parameters of type Store

Modifier	Constructor	Description
	RestartSearch(Store store, DepthFirstSearch<T> s, SelectChoicePoint<T> sel, Calculator calculator)
	RestartSearch(Store store, DepthFirstSearch<T> s, SelectChoicePoint<T> sel, Calculator calculator, T cost)

Uses of Store in org.jacop.search.sgmpcs

Fields in org.jacop.search.sgmpcs declared as Store

Modifier and Type	Field	Description
Store	SGMPCSearch.store
Store	SimpleImprovementSearch.store

Constructors in org.jacop.search.sgmpcs with parameters of type Store

Modifier	Constructor	Description
	SGMPCSearch(Store store, IntVar[] vars, IntVar cost)
	SGMPCSearch(Store store, IntVar[] vars, IntVar cost, ImproveSolution<IntVar> search)
	SimpleImprovementSearch(Store store, IntVar[] vars, IntVar cost)

Uses of Store in org.jacop.set.constraints

Fields in org.jacop.set.constraints declared as Store

Modifier and Type	Field	Description
(package private) Store	PartitionSet.store

Methods in org.jacop.set.constraints with parameters of type Store

Modifier and Type	Method	Description
void	AdiffBeqC.consistency(Store store)
void	AdisjointB.consistency(Store store)
void	AeqB.consistency(Store store)
void	AeqS.consistency(Store store)
void	AinB.consistency(Store store)
void	AinS.consistency(Store store)
void	AintersectBeqC.consistency(Store store)
void	AleB.consistency(Store store)
void	AltB.consistency(Store store)
void	AunionBeqC.consistency(Store store)
void	CardA.consistency(Store store)
void	CardAeqX.consistency(Store store)
void	ChannelBoolSet.consistency(Store store)
void	ChannelIntSet.consistency(Store store)
void	EinA.consistency(Store store)
void	ElementSet.consistency(Store store)
void	ElementSetVariable.consistency(Store store)
void	Lex.consistency(Store store)	Deprecated.
void	Match.consistency(Store store)
void	PartitionSet.consistency(Store store)
void	SinA.consistency(Store store)
void	SumWeightedSet.consistency(Store store)
void	XeqA.consistency(Store store)
void	XinA.consistency(Store store)
void	AleB.impose(Store store)
void	AltB.impose(Store store)
void	ElementSetVariable.impose(Store store)	It imposes the constraint in a given store.
void	Lex.impose(Store store)	Deprecated.
void	AeqB.notConsistency(Store store)
void	AeqS.notConsistency(Store store)
void	AinB.notConsistency(Store store)
void	AinS.notConsistency(Store store)
void	AleB.notConsistency(Store store)
void	AltB.notConsistency(Store store)
void	EinA.notConsistency(Store store)
void	SinA.notConsistency(Store store)
void	XeqA.notConsistency(Store store)
void	XinA.notConsistency(Store store)

Uses of Store in org.jacop.set.core

Constructors in org.jacop.set.core with parameters of type Store

Modifier	Constructor	Description
	SetVar(Store store)	This constructor creates a variable with empty domain (standard IntervalDomain domain), automatically generated name, and empty attached constraint list.
	SetVar(Store store, int min, int max)	This constructor creates a set variable with domain a set min..max automatically generated name, and empty attached constraint list.
	SetVar(Store store, String name)	This constructor creates a variable with an empty domain (standard IntervalDomain domain), the specified name, and an empty attached constraint list.
	SetVar(Store store, String name, int min, int max)	This constructor creates a variable in a given store, with the domain specified by min..max and with the given name.
	SetVar(Store store, String name, SetDomain dom)	It creates a variable in a given store, with a given name and a given domain.
	SetVar(Store store, SetDomain dom)	It creates a variable in a given store, with a given name and a given domain.

Uses of Store in org.jacop.util

Methods in org.jacop.util with parameters of type Store

Modifier and Type	Method	Description
void	IndexDomainView.removeUnSupportedValues(Store store)	It removes all values for which no support was found since the initialization of the support sweep.