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.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 and 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

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

Modifier and Type	Method and Description
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	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	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.
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)
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	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	Constraint.impose(Store store, int queueIndex) It imposes the constraint and adjusts the queue index.
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	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	DecomposedConstraint.imposeDecomposition(Store store, int queueIndex) It imposes the constraint and adjusts the queue index.
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)
void	AbsXeqY.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)
List<Constraint>	SoftAlldifferent.primitiveDecomposition(Store store)
List<Constraint>	SoftGCC.primitiveDecomposition(Store store)

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

Constructor and Description
Linear(Store store, IntVar[] list, int[] weights, String rel, int sum) Deprecated. It constructs the constraint Linear.
Linear(Store store, List<? extends IntVar> variables, List<Integer> weights, String rel, int sum) Deprecated. It constructs the constraint Linear.
LinearInt(Store store, IntVar[] list, int[] weights, String rel, int sum) Deprecated.
LinearInt(Store store, IntVar[] list, int[] weights, String rel, IntVar sum) Deprecated.
LinearInt(Store store, List<? extends IntVar> list, List<Integer> weights, String rel, int sum) Deprecated. LinearInt 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.
LinearIntDom(Store store, List<? extends IntVar> variables, List<Integer> weights, String rel, int sum) Deprecated. LinearIntDom constraint does not use Store parameter any longer.
SumBool(Store store, IntVar[] list, String rel, IntVar sum) Deprecated.
SumBool(Store store, List<? extends IntVar> variables, String rel, IntVar sum) Deprecated.
SumInt(Store store, IntVar[] list, String rel, IntVar sum) Deprecated. SumInt constraint does not use Store parameter any longer.
SumInt(Store store, List<? extends IntVar> variables, 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 and 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 and Description
void	Cumulative.consistency(Store store)
void	CumulativeBasic.consistency(Store store)
void	CumulativeUnary.consistency(Store store)

Uses of Store in org.jacop.constraints.diffn

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

Modifier and Type	Method and 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.

Uses of Store in org.jacop.constraints.geost

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

Modifier and Type	Field and 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 and 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 and Description
void	Knapsack.consistency(Store store)
void	Knapsack.impose(Store store)

Uses of Store in org.jacop.constraints.netflow

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

Modifier and Type	Field and Description
Store	Network.store The store

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

Modifier and Type	Method and 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.

Uses of Store in org.jacop.constraints.regular

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

Modifier and Type	Method and 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

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

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

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

Constructor and 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 and Description
Store	Var.store Each variable is created in a store.

Methods in org.jacop.core that return Store

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

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

Constructor and 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, org.jacop.core.BoundDomain dom) It creates a Boolean variable.
BooleanVar(Store store, int min, int max) Boolean variable constructor.
BooleanVar(Store store, String name) Boolean variable constructor.
BooleanVar(Store store, String name, org.jacop.core.BoundDomain dom) It creates a Boolean variable.
BooleanVar(Store store, String name, int min, int max) Boolean variable constructor.
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, IntDomain dom) It creates a variable in a given store, with a given name and a given domain.
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, IntDomain dom) It creates a variable in a given store, with a given name and a given domain.
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.
MutableDomain(Store store)
MutableDomain(Store store, IntDomain domain)
TimeStamp(Store store, T input) The constructor.

Uses of Store in org.jacop.examples.fd

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

Modifier and Type	Field and Description
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 and 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 and 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 and 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 and Description
Store	ExampleSet.getStore() It specifies the constraint store used within an example.

Uses of Store in org.jacop.floats.constraints

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

Modifier and Type	Method and Description
void	AbsPeqR.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	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	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 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

Constructor and Description
EquationSystem(Store store, FloatVar[] f, FloatVar[] x) It constructs the constraint EquationSystem.
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.
LinearFloat(Store store, List<? extends FloatVar> variables, List<Double> weights, String rel, double 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

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

Modifier and Type	Method and Description
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

Constructor and Description
BNode(Store store)
BNode(Store store, double min, double max)
BNode(Store store, double min, double max, double lb, double ub)
Linear(Store store, FloatVar[] list, double[] weights, String rel, double sum)
Linear(Store store, FloatVar[] list, double[] weights, String rel, FloatVar sum)
Linear(Store store, List<? extends FloatVar> variables, List<Double> weights, String rel, double sum) It constructs the constraint Linear.
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

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

Constructor and 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, FloatDomain dom) It creates a variable in a given store, with a given name and a given domain.
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.

Uses of Store in org.jacop.floats.search

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

Constructor and 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

Methods in org.jacop.fz that return Store

Modifier and Type	Method and Description
Store	FlatzincLoader.getStore()

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

Modifier and Type	Method and Description
void	Solve.PrecisionSetting.executedAtInitialize(Store store)

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

Constructor and 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

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

Constructor and 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 and Description
Store	SatWrapper.store

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

Modifier and Type	Method and 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
void	SatWrapper.impose(Store store)

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

Constructor and Description
SatTranslation(Store store)

Uses of Store in org.jacop.search

Fields in org.jacop.search declared as Store

Modifier and Type	Field and Description
Store	DepthFirstSearch.store It represents store within which a search is performed.

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

Modifier and Type	Method and 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	PrioritySearch.labeling(Store store)
boolean	DepthFirstSearch.labeling(Store store, SelectChoicePoint<T> select)
boolean	PrioritySearch.labeling(Store store, SelectChoicePoint<T> select)
boolean	Search.labeling(Store store, SelectChoicePoint<T> select) It performs search using supplied choice point selection heuristic.
boolean	DepthFirstSearch.labeling(Store store, SelectChoicePoint<T> select, Var costVar)
boolean	PrioritySearch.labeling(Store store, SelectChoicePoint<T> select, Var costVar)
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.
boolean	PrioritySearch.labeling(Store store, Var costVar)
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

Constructor and 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

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

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

Uses of Store in org.jacop.search.sgmpcs

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

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

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

Constructor and 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

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

Modifier and Type	Method and 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	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	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

Constructor and 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, SetDomain dom) It creates a variable in a given store, with a given name and a given domain.
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.

Uses of Store in org.jacop.util

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

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